#rR gscope_bigbang.tcl

proc NotreOS {{Valeur ""}} {
    global NotreOS
    if {$Valeur!=""} { set NotreOS $Valeur }
    if {[info exists NotreOS]} { return $NotreOS }
    return ""
}

proc NotreOC {{Valeur ""}} {
    global NotreOC
    if {$Valeur!=""} { set NotreOC $Valeur }
    if {[info exists NotreOC]} { return $NotreOC }
    set NOS [NotreOS]
    if {$NOS==""} { return "" }
    if {$NOS=="Inconnu inconnu"} { return "" }
    return [OCduOS $NOS]
}

proc NotreOX {{Valeur ""}} {
    global NotreOX
    if {$Valeur!=""} { set NotreOX $Valeur }
    if {[info exists NotreOX]} { return $NotreOX }
    set NOS [NotreOS]
    if {$NOS==""} { return "" }
    if {$NOS=="Inconnu inconnu"} { return "" }
    regsub -all " " $NOS "_" NOS
    set NotreOX [Tax $NOS TaxId]
    return $NotreOX
}

proc NotreTaxId {} {
    return [NotreOS]
}

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 OuSuisJe {} {
    set Ici [info script]
    Espionne $Ici
    return [Realpath $Ici]
}

proc RepriseDeOldBsuX {} {
    global RepertoireDuGenome

    foreach Bornes [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdespabs"] \
	    OldBor [LesLignesDuFichier "/genomics/link/OldBsuX/fiches/bornesdespabs"] {
	if {$Bornes==$OldBor} {
	    scan $Bornes "%s" Nom
	    foreach Rep {apns blastp descriptifs msf aliinout tfasdescopains} {
		set S "/genomics/link/OldBsuX/$Rep"
		set D "$RepertoireDuGenome/$Rep"
		Espionne " Copie de $Rep/$Nom"
		if { ! [file exists "$S/$Nom"] || [file exists "$D/$Nom"]} { continue } 
		File copy "$S/$Nom" "$D/$Nom"
	    }
	}
    }
    exit
}

proc NomDeFamille Nom {
    global NomDeFamille

    set NomDeFamilleDansAlias 1

    if {[info exists NomDeFamille($Nom)]} {return [set NomDeFamille($Nom)]}
    if {[info exists NomDeFamille("EstCharge")]} {return "UnknownFamily"}
    
    set NomDeFamille(LaListeMerci) {}
    foreach PAB [ListeDesPABs] {
	set Fam "UnknownFamily"
	if {$NomDeFamilleDansAlias} {
	    set Alias [Alias $PAB]
	    regsub {_.*$} $Alias "" Fam
	}
	set NomDeFamille($PAB) $Fam
	if { ! [info exists DejaVu($Fam)]} { 
	    lappend NomDeFamille(LaListeMerci) $Fam
	    set DejaVu($Fam) $PAB
	}
    }
    set NomDeFamille("EstCharge") 1
    return [NomDeFamille $Nom]
}

proc NiveauParFamille {} {
    global RepertoireDuGenome
    set Niveau 1
    set OldFamille ""
    set Debut 1
    set Longueur 899
    set Orient "F"
    foreach Nom [ListeDesPABs] {
	set Famille [NomDeFamille $Nom]
	if {$Famille!=$OldFamille} {
	    set Niveau [expr -$Niveau]
	    incr Debut $Niveau
	}
	incr Debut 999
	set Fin [expr $Debut+$Longueur]
	lappend LesBornes "$Nom $Debut $Fin $Orient"
	Espionne "$Nom $Alias $Famille $Debut $Niveau"
	set OldFamille $Famille
    }
   Espionne [SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs.niveauparfamille"]
   exit
}

proc ChangeGenome {{Genome ""}} {
    global RepertoireDuGenome
    global RepertoireRacineDuGenome
    global LesBoutonsDeVitrine
    global LesBoutonsDeVitrineCaches
    global LesBoutonsNonOpen
    global VariableADetruire

    if {$Genome!=""} {
	set GenomeOrigine $Genome
	if { ! [file exists $Genome]} {
	    set Genome "$RepertoireDuGenome/../[file tail $Genome]"
	}
	if { ! [file exists $Genome]} {
	    if { [OuiOuNon "$GenomeOrigine\n and \n$Genome\n don't exist.\n Do I cancel ?"]} {
		return "Cancel"
	    }
	}
    }
    while { ! [file exists $Genome]} {
	if { ! [OuiOuNon "Do You want to display another genome or collection." 0]} { return "Cancel" }
	set Genome [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."]
	if {$Genome==""} {
	    if {[OuiOuNon "Do I cancel ?"]} { return "Cancel" }
	    continue
	}
	break
    }
    set genome $Genome

    set monNiveau [info level]

    if {[info exists LesBoutonsDeVitrineCaches]} {
	foreach b $LesBoutonsDeVitrineCaches {
	    catch {destroy $b}
	}
    }
    if {[info exists LesBoutonsDeVitrine]} {
	foreach b $LesBoutonsDeVitrine {
	    catch {destroy $b}
	}
    }
    if {[info exists LesBoutonsNonOpen]} {
	foreach b $LesBoutonsNonOpen {
	    catch {destroy $b}
	}
    }
    set lesVariables [uplevel {info vars}]
    foreach variable $lesVariables {
	Espionne "variable testee $variable"
	if {[EstUneVariableGlobaleGenerale $variable]} { continue }
	Espionne "Variable detruite .................. $variable"
	set VariableADetruire $variable
	uplevel $monNiveau {unset $VariableADetruire}
    }
    set RepertoireDuGenome $Genome
    set env(REPERTOIREDUGENOME) $RepertoireDuGenome

    uplevel $monNiveau ChargeConfig
    uplevel $monNiveau Gscope

}

proc ReadLink {Lien {Rep ""}} {
    if {[file type $Lien]=="link" && ! [regexp "^/" [file readlink $Lien]]} {
	set Lien "$Rep/[file readlink $Lien]"
    }
    if {[file type $Lien]=="link"} {
	set Lien [file readlink $Lien]
    }
    return $Lien
} 

proc LocaliseTBlastNDataBase {{NomDeLaBanque ""}} {
    return [LocaliseBlastNDataBase $NomDeLaBanque "T"]
}
 
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 LocalisePsiBlastPDataBase {{Banque ""}} {
    return [LocaliseBlastPDataBase $Banque]
}

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 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"

    #rR 20200526 j'ai fait les choses correctemetn pour pouvoir lire le lien
    if {[file type $BlastPDataBase]=="link"} {
	set BlastPDataBase [ReadLink $BlastPDataBase $RepDesBanques]
    }
    #rR 20200526 et tester .phr
    while { ! [file exists $BlastPDataBase] && ! [file exists "$BlastPDataBase.phr"]} {
	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 FinPasTouche Nom {
    PasTouche $Nom "fin"
}

proc TestPasTouche {} {
    return [PasTouche Bidon12345]
}

proc PasTouche {Nom {Action ""}} {
    global RepertoireDuGenome

    Wup "Returns 1 if Nom in use, else uses it and returns 0"
    Wup " if Action is fin then release Nom and returns 0"
    Wup " if Action is test then tests only but doesn't use"
    Wup " if Nom is ListAll, it returns the text of all files"

    set RepPasTouche "[RepertoireDuGenome]/pastouche"

    set Action [string tolower $Action]

    #rR Pour voir s'il n'y en a pas qui trainent (à ne pas confondre avec test)
    if {$Nom=="Check"} {
	while {[set Etat [PasTouche "ListAll"]]!=""} {
	    if {[OuiOuNon "Attention, following processes are running\n$Etat\nDo I exit ?" 0]} { exit }
	    if {[OuiOuNon "Do I ignore it ?"]} { return 1 }
	}
	return 0
    }

    if {[regexp -nocase "ListAll" $Nom]} {
	set LesEnCours [GlobRecursif "*" $RepPasTouche]
	if {$LesEnCours=={}} { return {} }
	set Etat {}
	foreach FPT $LesEnCours {
	    if {[FileAbsent $FPT]} { continue }
	    regsub {^.+/pastouche/} $FPT "" FileName 
	    set FileName [string trimleft $FileName "./"]
	    if {[file type $FPT]=="directory"} {
		if { [regexp -nocase "Dir" $Nom]} { lappend LesFichiers $FileName }
		continue
	    }
	    if {[FileAbsent $FPT]} { continue }
	    if {[catch {lappend Etat [ContenuDuFichier $FPT]}]} { continue }
	    lappend LesFichiers  $FileName
	}
	if {[regexp -nocase "Files" $Nom ]} { return $LesFichiers }
	return [join $Etat "\n"]
    }

    if {$Action=="" && [file exists "$RepPasTouche/stopall"]} {
	Warne "I exit because I found $RepPasTouche/stopall"
	exit
    }

    if {$Action=="" && ([file exists "$RepPasTouche/stop[pid]"] || [file exists "$RepPasTouche/stop$Nom"])} {
	Warne "I exit because I found $RepPasTouche/stop[pid] or $RepPasTouche/stop$Nom"
	exit
    }

    set FichierPasTouche "$RepPasTouche/$Nom"
    if {$Action=="fin"} {
	if {[file exists $FichierPasTouche]} {
	    catch { file delete -force $FichierPasTouche }
	}
	return 0
    }
    if {[file exists $FichierPasTouche]} { return 1 }
    if {$Action!="test"} {
	if { ! [file exists [set Rep [file dirname $FichierPasTouche]]]} { file mkdir $Rep }
	Sauve "Ne me touche pas ..." dans $FichierPasTouche 
	set Message "$Nom en cours sur [Hostname] , pid [pid] depuis [Date Nice] = [info level -1]"
	regsub {[\n]} $Message " " Message
	set Message [string range $Message 0 131]
	Sauve $Message dans $FichierPasTouche
    }
    return 0
}

proc StopAllGscope {{Action ""}} {
    set Action [string totitle $Action]
    set RepPasTouche "[RepertoireDuGenome]/pastouche"
    set FichierStopAll "$RepPasTouche/stopall"
    if {$Action=="Test"  } { return [file exists $FichierStopAll] }
    if {$Action=="Delete"} { file delete -force  $FichierStopAll ; return "" }
    if {$Action!="Force" } {
	if { ! [OuiOuNon "Ok to stop all running gscope on \n[RepertoireDuGenome]\n through pastouche/stopall" 0]} {
	    return "No"
	}
    }
    Sauve "StopAll demande sur [info hostname] , pid [pid] depuis [Date Nice] = [info level -1]" dans $FichierStopAll
    file attribute $FichierStopAll -permissions 0777
    return $FichierStopAll
}

proc PrefixeDuProjet Projet {
    return [PrefixeDuGenome $Projet]
}

proc PrefixeDuGenome Genome {

    set GenOri $Genome

    if { ! [regexp "/" $Genome]} {
	set Genome "[GscopeDatabaseDir $Genome]"
    }

    set FichierMiniConfig "$Genome/beton/miniconfig"
    Espionne $FichierMiniConfig
    if { ! [file exists $FichierMiniConfig]} {
	FaireLire "I can't find $FichierMiniConfig\n to determine the PreFixe of $GenOri"
	return "AAAA"
    }

    foreach Ligne [LesLignesDuFichier $FichierMiniConfig] {
	if {[regexp "PrefixeDesORFs" $Ligne]} {
	    regsub  "PrefixeDesORFs " $Ligne "" Prefixe
	    return $Prefixe
	}
    }
    FaireLire "I can't find 'PreFixe' in $FichierMiniConfig\n to determine the PreFixe of $GenOri"
    return "AAAA"
}

proc FormatDesNumerosPourCollectionDuProjet {{Projet ""}} {
    return [FormatDesNumerosPourCollectionDuGenome $Projet]
}

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 OrganismeDuGenome Genome {
    global RepertoireDuGenome

    set GenOri $Genome

    if { ! [file exists $Genome]} {
	set Genome "$RepertoireDuGenome/../$Genome"
    }

    set FichierMiniConfig "$Genome/beton/miniconfig"
    if { ! [file exists $FichierMiniConfig]} {
	FaireLire "I can't find $FichierMiniConfig\n to determine the organism of $GenOri"
	return "Unknow unknow"
    }

    foreach Ligne [LesLignesDuFichier $FichierMiniConfig] {
	if {[regexp "NotreOS" $Ligne]} {
	    regsub "NotreOS " $Ligne "" Organisme
	    regsub {\.} $Organisme "" Organisme
	    return $Organisme
	}
    }
    FaireLire "I can't find 'NotreOS' in $FichierMiniConfig\n to determine the organism of $GenOri"
    return "Unknow unknow"
}

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 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 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 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 NarcisseDuFichier {Fichier {FichierSortie ""}} {
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s" Access
	set Nar [Narcisse $Access]
	if {$Nar==""} { set Nar [Narcisse $Access New] }
	lappend Sortie $Nar
    }
    if {$FichierSortie==""} { set FichierSortie $Fichier.narcisse }
    return [SauveLesLignes $Sortie dans $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 MonImageDansLaBanque Nom {
    set BanqueId_Access [Narcisse $Nom]
    set Access ""
    scan $BanqueId_Access "%s %s" BanqueId Access
    if {$BanqueId==""} { return "" }
    if {$Access==""} { set Access $BanqueId }
    return [join [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutEMBL"] "\n"]
}

proc Narcisse {Nom {OldNewAll ""}} {
    global RepertoireDuGenome
    global ListeDesPABs
    global Narcisse

    set Nom [string toupper $Nom]
    set NotreOS [NotreOS]

    if {[regexp -nocase "All" $OldNewAll]} {
	set OldNew ""
	set AllNarcisse 1
    } else {
	set OldNew $OldNewAll
	set AllNarcisse 0
    }

    Wup "First check for OldNew Access" 
    if {$OldNew!=""} {

	if { [regexp -nocase "Old" $OldNew] } { set OldNew "Old" }
	if { [regexp -nocase "New" $OldNew] } { set OldNew "New" }
	if { [regexp -nocase "PAB" $OldNew] } { set OldNew "PAB" }

	if {[info exists Narcisse($Nom,$OldNew)]} {
	    return [set Narcisse($Nom,$OldNew)]
	}
	if {[info exists Narcisse("EstCharge",$OldNew)]} { return "" }

	set FichierNarcisseATrois "$RepertoireDuGenome/fiches/narcisse-a-trois"
	if { ! [file exists $FichierNarcisseATrois]} {
	    set Narcisse("EstCharge",Old) "EstCharge"
	    set Narcisse("EstCharge",New) "EstCharge"
	    set Narcisse("EstCharge",PAB) "EstCharge"
	    return [Narcisse $Nom]
	} else {
	    foreach Ligne [LesLignesDuFichier $FichierNarcisseATrois] {
		scan $Ligne "%s %s %s" Moi Old New
		set Narcisse($Moi,New) $New
		set Narcisse($Moi,Old) $Old
		set Narcisse($Old,New) $New
		set Narcisse($New,Old) $Old
		set Narcisse($Old,Old) $Moi
		set Narcisse($New,New) $Moi
		set Narcisse($Old,PAB) $Moi
		set Narcisse($Moi,PAB) $Moi
		set Narcisse($New)     $Moi
		set Narcisse($Old)     $Moi
		set Narcisse([string toupper $Moi],New) $New
		set Narcisse([string toupper $Moi],Old) $Old
		set Narcisse([string toupper $Old],New) $New
		set Narcisse([string toupper $New],Old) $Old
		set Narcisse([string toupper $New])     $Moi
		set Narcisse([string toupper $Old])     $Moi
	    }
	    set Narcisse("EstCharge",New) "EstCharge" 
	    set Narcisse("EstCharge",Old) "EstCharge" 
	    set Narcisse("EstCharge",PAB) "EstCharge" 
	    return [Narcisse $Nom $OldNew]
	}
    }


    if {$AllNarcisse} {
	Wup "Look in Narcisse all"
	if {[info exists Narcisse($Nom,All)]} {
	    return [set Narcisse($Nom,All)]
	}
	if {[info exists Narcisse("EstCharge",All)]} {
	    if { [info exists Narcisse($Nom,New)]} { return [set Narcisse($Nom,New)] }
	    if { ! [info exists Narcisse("EstCharge",New)]} { return [Narcisse $Nom New] }
	    return [Narcisse $Nom]
	}
	
	Wup "Read the file narcisse all"
	set FichierNarcisse "$RepertoireDuGenome/../narcisse"
	if {[file exists $FichierNarcisse]} {
	    foreach Ligne [LesLignesDuFichier $FichierNarcisse] {
		set Access ""
		scan $Ligne "%s %s %s" NomLu BanqueId Access
		if {$Access==""} { set Access $BanqueId }
		set Narcisse($NomLu,All)  "$Access"
		set Narcisse($Access,All) "$NomLu"
		set Narcisse([string toupper $NomLu],All)  "$Access"
		set Narcisse([string toupper $Access],All) "$NomLu"
	    }
	    set Narcisse("EstCharge",All) "EstCharge"
	    return [Narcisse $Nom All]
	}
	return [Narcisse $Nom]
    }

    Wup "Look in Narcisse"
    if {[info exists Narcisse($Nom)]} {
	return [set Narcisse($Nom)]
    }
    if {[info exists Narcisse("EstCharge")]} {
	if { ! [info exists Narcisse("EstCharge",New)]} { return [Narcisse $Nom New] }
	return ""
    }

    Wup "Read the file narcisse"
    set FichierNarcisse "$RepertoireDuGenome/fiches/narcisse"
    if {[file exists $FichierNarcisse]} {
	foreach Ligne [LesLignesDuFichier $FichierNarcisse] {
	    set Access ""
	    scan $Ligne "%s %s %s" NomLu BanqueId Access
	    if { ! [regexp {\:} $BanqueId]} { set Access $BanqueId }
	    if {$Access==""} { set Access $BanqueId }
	    set Narcisse($NomLu)  "$Access"
	    set Narcisse($Access) "$NomLu"
	    set Narcisse([string toupper $NomLu])  "$Access"
	    set Narcisse([string toupper $Access]) "$NomLu"
	}
	set Narcisse("EstCharge") "EstCharge"
	if {[info exists Narcisse($Nom)]} {
	    return [set Narcisse($Nom)]
	} else {
	    if {$Nom!="APPEND"} { return "" } 
	}
    }

    Wup "Create the file narcisse"

    if {[OuiOuNon "Do I use DaedalusHits to create Narcisse ?"]} {
	foreach PAB [ListeDesPABs] {
	    Espionne "PAB $PAB"
	    if {[info exists Narcisse($PAB)]} { continue }
	    set FichierDaedalus "$RepertoireDuGenome/daedalushits/$PAB"
	    if { ! [file exists $FichierDaedalus]} { continue }
	    set TaxId [OrganismeDuPAB $PAB TaxId]
	    if {$TaxId=="Inconnu inconnu"} { set TaxId "" }
	    Espionne "I'm looking for $TaxId in $FichierDaedalus"
	    catch {unset MeilleurPNTrouve}
	    set BonneLigne ""
	    foreach Ligne [LesLignesDuFichier $FichierDaedalus] {
		set AC [ValeurDeLaBalise AC Ligne "NePasRogner"]
		set PN [ValeurDeLaBalise PN Ligne "NePasRogner"]
		set OX [ValeurDeLaBalise OX Ligne "NePasRogner"]
		Espionne "$PAB $TaxId $AC $OX $PN" 
		if {$PN > 1.e-3} { break }
		if {[EstUnAccessPDB $AC]} { continue }
		if {[EstUnPAB $AC]} { continue }
		if {$TaxId=="" && \
			[OuiOuNon "Unfortunately the organism of $PAB is unknown\n\
			Do I use the best blastp hit for Narcisse ?"]} {
		    set BonneLigne $Ligne ; break
		}
		set TexteOX "=[join $OX "="]="
		if {[regexp "=$TaxId=" $TexteOX]} { set BonneLigne $Ligne ; break }
	    }
	    if {$BonneLigne==""} {
		#	    FaireLire "I can't find an homolog for $PAB in apns/$PAB. I skipp it"
		continue
	    }
	    AppendAuFichier $FichierNarcisse "$PAB $AC"
	}
    } elseif {[OuiOuNon "Do I use apns to create Narcisse ?"]} {
	foreach PAB [ListeDesPABs] {
	    if {[info exists Narcisse($PAB)]} { continue }
	    set FichierAPNs "$RepertoireDuGenome/apns/$PAB"
	    if { ! [file exists $FichierAPNs]} { continue }
	    catch {unset MeilleurPNTrouve}
	    set BonneLigne ""
	    foreach Ligne [LesLignesDuFichier $FichierAPNs] {
		Espionne $Ligne
		scan $Ligne "%s %s %f" BanqueId Access PN
		if {$PN > 1.e-3} { break }
		if {[EstUnAccessPDB $BanqueId]} { continue }
		if {[EstUnPAB $Access]} { continue }
		if {$NotreOS=="Inconnu inconnu" && \
			[OuiOuNonMemo "Unfortunately NotreOS is 'Inconnu inconnu'\n\
			Do I use the best blastp hit for Narcisse ?"]} {
		    set BonneLigne $Ligne ; break
		}
		set Orga [OrgaDuAccess $Access Complet]
		if {[regexp $NotreOS $Orga]} { set BonneLigne $Ligne ; break }
	    }
	    if {$BonneLigne==""} {
		#	    FaireLire "I can't find an homolog for $PAB in apns/$PAB. I skipp it"
		continue
	    }
	    scan $BonneLigne "%s %s %f" BanqueId Access PN
	    AppendAuFichier $FichierNarcisse "$PAB $BanqueId $Access"
	}
    }
    if { ! [file exists $FichierNarcisse]} { Sauve "Narcisse empty" dans $FichierNarcisse }
    if {$Nom=="APPEND"} { return "" }
    return [Narcisse $Nom]
}

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 RenommePABenABY SousRepertoire {
    global RepertoireDuGenome

    foreach Fichier [lsort [glob "$RepertoireDuGenome/../casimir/$SousRepertoire/PAB*"]] {
	set NomPAB [file tail $Fichier]
	regsub "PAB" $NomPAB "ABY" NomABY
	set Nouveau {}
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    while {[regexp {PAB[0-9][0-9][0-9][0-9]} $Ligne PAB]} {
		regsub "PAB" $PAB "ABY" ABY
		regsub {PAB[0-9][0-9][0-9][0-9]} $Ligne $ABY Ligne
	    }
	    lappend Nouveau $Ligne
	}
	 Espionne [SauveLesLignes $Nouveau dans "$RepertoireDuGenome/$SousRepertoire/$NomABY"]
    }
}

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 BallastUnBlastP {Fichier {RepertoireDestination ""}} {
    global RepertoireDeTravail

    if {$RepertoireDestination==""} { set RepertoireDestination $RepertoireDeTravail }

    set Query [QueryDuFichierBlast $Fichier]

    set Destination [Ballast $Fichier $RepertoireDestination $Query]

    return [ContenuDuFichier $Destination]
}

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 RepriseDeVieuxPABs {{FichierBornesACreer ""}} {
    global RepertoireDuGenome

    if {$FichierBornesACreer==""} { set FichierBornesACreer "[Fiches]/bornesdespabs" }

    while { ! [OuiOuNon "\
	    I need a file with all 'ORFnumber begin   end     orientation'\n \
	    .                 like 'PAB2205   1017846 1018601 R'\n\
            or 'ORFnumber' (without begin end)\n\
            OK ?"]} {
	if {[OuiOuNon "Stop ?"]} { exit }
	if {[OuiOuNon "Abort reading old ORFs ?"]} { return 0 }
    }
    set ControleSurADN [OuiOuNon "Do You wish that I use DNA to verify * in each ORF"]

    set Fichier [ButineArborescence All]
    if {$Fichier==""} {
	if {[OuiOuNon "Stop ?"]} { exit } else { return 0 }
    }
    set OwnBorne [OuiOuNonMemo "Do I create my own begin end for each orf" 0]

    set L 999
    set D 100
    set F [expr $D + $L]
    set I 99
    foreach Ligne [LesLignesDuFichier $Fichier] {
	catch {unset Nom}
	catch {unset Debut}
	catch {unset Fin}
	catch {unset Orient}
	if {$OwnBorne} {
	    scan $Ligne "%s" Nom
	    set Debut $D
	    set Fin   $F
	    set Orient "F"
	    set D [expr $F + $I]
	    set F [expr $D + $L]
	    set nLus 3
	} else {
	    set nLus [scan $Ligne "%s %d %d %s" Nom Debut Fin Orient]
	}
	if {$nLus<3} {
	    if {[OuiOuNon "$Ligne \n I skip it ?"]} {
		continue
	    } else {
		if {[OuiOuNon "Stop and exit?"]} { exit }
		if {[OuiOuNon "Stop scanning ?"]} { break }
		if {[OuiOuNon "Skip this line ?"]} { continue }
		return 0
	    }
	}
	if {$Debut < $Fin} {
	    set OrientCalcule "F"
	    set DebutCalcule $Debut
	    set FinCalcule $Fin
	} else {
	    set OrientCalcule "R"
	    set DebutCalcule $Fin
	    set FinCalcule $Debut
	}
	if {$nLus==3} {
	    set Debut  $DebutCalcule
	    set Fin    $FinCalcule
	    set Orient $OrientCalcule
	} else {
	    if {$Debut!=$DebutCalcule || $Fin!=$FinCalcule} { 
		FaireLire "$Ligne\nWhen Orientation is used I want that Begin < End ..."
		if {[OuiOuNon "Stop and exit ?"]} { exit }
		if {[OuiOuNon "Stop scanning ?"]} { break }
		if {[OuiOuNon "Skip this line ?"]} { continue }
	    }
	}
	regsub -all {[^0-9]} $Nom "" sNumero
	scan $sNumero "%d" Numero
	set BeauNom [format "%s%4.4d" [PreFixe] $Numero]
	if {$ControleSurADN} {
	    set SeqNuc [BoutADN $Debut $Fin $Orient]
	    set SeqPro [SeqNucToSeqPro $SeqNuc]
	    if {[regexp -nocase {\*} $SeqPro]} {
		if {[regexp {[^\*]+\*$} $SeqPro]} {
		    if {$Orient=="F"} {
			incr Fin -3
		    } else {
			incr Debut 3
		    }
		} else {
		    FaireLire "$Ligne\nContains *'s or other wrong characters in DNA"
		    if {[OuiOuNon "Stop and exit ?"]} { exit }
		    if {[OuiOuNon "Stop scanning ?"]} { break }
		    if {[OuiOuNon "Skip this line ?"]} { continue }
		}
	    }
	}
	lappend LesBornes "$BeauNom $Debut $Fin $Orient"
    } 
    set FichierCree [SauveLesLignes $LesBornes dans $FichierBornesACreer]
    ChargeLesPABs
    return 1
}

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 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 TBlastNPourTous {{Banque ""} {Liste ""}} {
    global RepertoireDuGenome

    if {$Banque==""} {
	#rR 2016/01/24 j'ai introduit LocaliseTBlastNDatabase ... 
	set Banque "tblastndatabase"
	set NomDeLaBanque [LocaliseTBlastNDataBase]
    } else {
	set NomDeLaBanque ""
	if {$Banque == "human"}           { set NomDeLaBanque "/catalog/blast/human" }
	if {$Banque == "completegenomes"} { set NomDeLaBanque "$RepertoireDuGenome/banques/completegenomes" }
	if {$Banque == "myself"}          { set NomDeLaBanque "$RepertoireDuGenome/banques/MSoverlap"}
	if {[regexp "/" $Banque]}         { set NomDeLaBanque $Banque }
	
	
	#rR je ne suis pas sûr que ce qui suit est réellement pris en compte car j'ai rajouté LocaliseTBlastNDataBase dans la commande !!!
	while { ! [file exists "$NomDeLaBanque"] \
		    && ! [file exists "$NomDeLaBanque.nal"] \
		    && ! [file exists "$NomDeLaBanque.nhr"] } {
	    if {$NomDeLaBanque!="" && [OuiOuNon "Do You want to create the tblastn database $NomDeLaBanque"]} {
		if {$Banque == "genomes"} {
		    CreationDuNalDesGenomesComplets "PleaseAsk" "PleaseAsk" "PleaseAsk"
		} 	    
		continue
	    } else {
		if {[OuiOuNon "Can You tell me where to find the blast database $Banque ?"]} {
		    set NomDeLaBanque [Entre "/genomics/link"]
		    continue 
		} 
		if {[OuiOuNon "Do I cancel ?"]} { return }
		if {[OuiOuNon "Do I exit ?"]}   { exit }
	    }
	}
    }

    set Repertoire "$RepertoireDuGenome/tblastn_[file tail $NomDeLaBanque]"
    Espionne $Repertoire
    #rR 2016/02/11 j'ai introduit la possiblilité d'utiliser BlastParameters is dans le rep tblastn
    set p "tblastn"
    set v 100
    set b $v
    set K 0
    set e 10.0
    set F "T"
    set d $NomDeLaBanque
    set LesObliges " p i o d v b K e F "
    set MoreOptions ""
    foreach {Key Value} [BlastParameters $Repertoire] {
	Espionne "$Key $Value"
	regsub -- {^\-+} $Key "" Key
	if {[regexp " $Key " $LesObliges]} {
	    set $Key $Value
	} else {
	    append MoreOptions " -$Key $Value"
	}
    }
    set CommandeTBlastN "blastall \
	    -p $p \
	    -i \$FichierTFA \
	    -o \$FichierBlast.encours \
	    -d $d \
	    -v $v \
	    -b $b \
	    -K $K \
	    -e $e \
	    -F $F"
    Wup "To find the pseudo-gene use ungapped   -g F"
    if {0 && [regexp -nocase "human" $NomDeLaBanque]} { append CommandeTBlastN " -g F" }

    if {[OuiOuNon "Do You want to edit the tBlastN command ?" 0]} {
	set CommandeTBlastN [Entre $CommandeTBlastN]
	if {$CommandeTBlastN==""} { return "" }
    }


    if { ! [file exists "$Repertoire"]} {
	file mkdir $Repertoire
    }

    set TestExistence 1
    set GardeTout 0
    if {$Liste==""} { set Liste [ListeDeBoites] }
    foreach Nom $Liste {

	if {[regexp "GLIMMER|TRNA|ARN" $Nom]} { continue }

	if {[Fantome $Nom]} { continue }

	if {[PasTouche $Nom]} { continue }

	set FichierTFA   "$RepertoireDuGenome/prottfa/$Nom"
	set FichierBlast "$Repertoire/$Nom"

	if { ! [file exists $FichierTFA]} { 
	    FinPasTouche $Nom
	    continue
	}
	if {$GardeTout && [file exists $FichierBlast] } {
	    FinPasTouche $Nom
	    continue 
	}
	if { $TestExistence && [file exists $FichierBlast] } {
	    if {[OuiOuNon "Some tblastn file already exist.\nDo I replace all of them ?" 0]} {
		set TestExistence 0
	    } else {
		if {[OuiOuNon "Do I keep them ?"]} { set GardeTout 1 }
		if {$GardeTout || [OuiOuNon "$FichierBlast exists.\nDo I keep it ?"]} {
		    FinPasTouche $Nom
		    continue
		}
	    }
	}

	if {[catch {eval exec $CommandeTBlastN} Message]} {
	    Warne "Error in CommandeTBlastN\n$Message"
	}
	if {[file exists "$FichierBlast.encours"]} {
	    file rename -force "$FichierBlast.encours" $FichierBlast
	}
	Espionne $FichierBlast
	FinPasTouche $Nom
    }
}

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
	}
    }
Espionne $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
	#rR 2017/07/10 j'ai introduit la possiblilité d'utiliser BlastParameters is dans le rep tblastn
	set p "blastn"
	set v 100
	set b $v
	set K 0
	set e 10.0
	set F "T"
	set d $NomDeLaBanque
	set LesObliges " p i o d v b K e F "
	set MoreOptions ""
	foreach {Key Value} [BlastParameters $Repertoire] {
	    Espionne "$Key $Value"
	    regsub -- {^\-+} $Key "" Key
	    if {[regexp " $Key " $LesObliges]} {
		set $Key $Value
	    } else {
		append MoreOptions " -$Key $Value"
	    }
	}
	if {$d==""} {
	    set BlastNDataBase [LocaliseBlastNDataBase $NomDeLaBanque]
	    if {$BlastNDataBase==""} { return "" }
	    set NomDeLaBanque $BlastNDataBase
	}
	set CommandeBlast "blastall \
	    -p $p \
	    -i \$FichierTFA \
	    -o \$FichierBlast.encours \
	    -d $d \
	    -v $v \
	    -b $b \
	    -K $K \
	    -e $e \
	    -F $F"
	

	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]} { 
	    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 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 TBlastXPourTous {{NomATraiter ""} {Banque ""}} {
    global RepertoireDuGenome

    if {$Banque==""} {
	set TBlastXDataBase "/catalog/blast/genembl"
    } else {
	if {[regexp "/" $Banque]} {
	    set TBlastXDataBase $Banque
	} else {
	    set TBlastXDataBase "/catalog/blast/$Banque"
	}
    }	

    set RepFileMask "$RepertoireDuGenome/nucmask"

    set Queue [file tail $TBlastXDataBase]
    regsub {\.[^\.]+$} $Queue "" Queue
    set Repertoire "$RepertoireDuGenome/tblastx$Queue"
    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 tblastx \
	    -i \$FichierTFA \
	    -o \$FichierBlast.encours \
	    -d $TBlastXDataBase \
            -v 50 \
	    -b 50 "


    
    if {[OuiOuNonMemo "Do You want to edit the Blast command ?" 0]} {
	set CommandeBlast [Entre $CommandeBlast]
	if {$CommandeBlast==""} { return "" }
    }
    
    
    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 TBlastX 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 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 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 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 etre remplacé pas 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 PsiBlastPPourTous {{NomATraiter ""} {PsiBlastPDataBase ""}} {
    global RepertoireDuGenome
    global CommandePsiBlastPPourTous
    global GardeToutPsiBlastPPourTous
    global TestExistenceBlastPPourTous

    JeMeSignale
    
    set AvecPasTouche 1
    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]/psiblastp"
    if { ! [file exists "$Repertoire"]} {
	File mkdir $Repertoire
    }

    if {[info exists CommandePsiBlastPPourTous]} {
	set CommandePsiBlast $CommandePsiBlastPPourTous
	if {[info exists GardeToutPsiBlastPPourTous]} {
	    set GardeTout $GardeToutPsiBlastPPourTous
	} else {
	    setGardeTout 0
	}
	if {[info exists TestExistencePsiBlastPPourTous]} {
	    set TestExistence $TestExistencePsiBlastPPourTous
	} else {
	    set TestExistence 1
	}
    } else {
	set GardeTout 0
	set TestExistence 1
	if {$PsiBlastPDataBase==""} {
	    set PsiBlastPDataBase [LocalisePsiBlastPDataBase]
	}
	if {$PsiBlastPDataBase==""} { return "" }
	set j 2
	set v 500
	set b $v
	set K 0
	set e 10
	set F "T"
	set d $PsiBlastPDataBase
	set LesObliges " i o d j 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"
	    }
	}
	set CommandePsiBlast "blastpgp \
		-i \$FichierTFA \
		-o \$FichierPsiBlast.encours \
		-d $d \
		-j $j \
		-v $v \
		-b $b \
		-K $K \
		-e $e \
		-F $F \
                $MoreOptions"
	if {[OuiOuNon "Do You want to edit the PsiBlast command ?" 0]} {
	    set CommandePsiBlast [Entre $CommandePsiBlast]
	    if {$CommandePsiBlast==""} { 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 CommandePsiBlastPPourTous $CommandePsiBlast
	set GardeToutPsiBlastPPourTous $GardeTout
	set TestExistencePsiBlastPPourTous $TestExistence
    }

    foreach Nom $Liste {
	if {$AvecPasTouche && [PasTouche $Nom]} { continue }
	set FichierTFA   "$RepertoireDuGenome/prottfa/$Nom"
	set FichierPsiBlast "$Repertoire/$Nom"

	if { ! [file exists $FichierTFA]} { 
	    Warne "$FichierTFA does'nt exist."
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue
	}
	if {$GardeTout && [file exists $FichierPsiBlast] } {
	    Espionne "$Nom already done"
	    if {$AvecPasTouche} { FinPasTouche $Nom }
	    continue 
	}
	if { $TestExistence && [file exists $FichierPsiBlast] } {
	    if {[OuiOuNon "$FichierPsiBlast already exists\nDo I keep it ?"]} {
		if {$AvecPasTouche} { FinPasTouche $Nom }
		continue
	    }
	}

	catch {eval exec $CommandePsiBlast}
	if {[file exists "$FichierPsiBlast.encours"]} {
	     file rename -force "$FichierPsiBlast.encours" $FichierPsiBlast
	}

	if {$AvecPasTouche} { FinPasTouche $Nom }
	Espionne $FichierPsiBlast
	
    }

}

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 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 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 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 ChargeConfig {{Force ""}} {
    global ConfigChargee
    global SansCafeDesSciences

    if {$Force=="" && [info exists ConfigChargee]} { return }

    CommandesExecPossibles
    RepertoireDuGenome
    CurrentGenome
    if { ! [info exists SansCafeDesSciences] || ! $SansCafeDesSciences } {
	NommeLesFichiersForum
    }
    RepertoireDeTravail
    ChargeMiniConfig $Force
    LesOrganismesTresProches
    LesGenomesComplets
#    Glossaire "bidon" "Court"
#    LesGenomesCompletsPourGlossaire
}

proc ChargeMiniConfig {{Force ""}} {
    #rR Force rajouté 2016/01/07 ...... c'était débile avant, sans cela !!!
    global RepertoireDuGenome
    global CurrentGenome
    global FichierMiniConfig
    global FichierMiniConfigSansGenome
    global VersionDeGscopeAuBigBang
    global FichierSequenceADN
    global PrefixeDesORFs
    global FormatOrfNumbering
    global LongueurMiniDesORFs
    global NotreOS
    global NotreOC
    global NotreOX
    global NotreOrga
    global GenomeOuCollection
    global MaquilleNon
    global ConfigChargee
    
    if {$Force!=""} {
	set FichierMiniConfig "[RepertoireDuGenome]/beton/miniconfig"
    }

    if { ! [info exists FichierMiniConfig] || ! [file exists $FichierMiniConfig]} {
	set FichierMiniConfig $FichierMiniConfigSansGenome 
    }
    
    set MaquilleOui 0
    set MaquilleNon 1
    set GenomeOuCollection "Genome"
    foreach Ligne [LesLignesDuFichier $FichierMiniConfig] {
	if {[regexp "^#" $Ligne]} { continue }
	if {[regexp "VersionDeGscopeAuBigBang" $Ligne]} {
	    scan $Ligne "%s %s" Toto VersionDeGscopeAuBigBang
	}
	if {[regexp "FichierSequenceADN" $Ligne]} {
	    scan $Ligne "%s %s" Toto FichierSequenceADN
	}
	if {[regexp "PrefixeDesORFs" $Ligne]} {
	    scan $Ligne "%s %s" Toto PrefixeDesORFs
	}
	if {[regexp "FormatOrfNumbering" $Ligne]} {
	    # Attention il etait jusqu'au 29/06/2009 dans fiches/format_orf_numbering."
	    #  pour les nouveaux projets il sera pris ici en premier.
	    #  mais le fichier est cree quand meme car on l'appelle FormatDesNumerosPourCollection
	    #  dans CreeMiniConfig.
	    scan $Ligne "%s %s" Toto FormatOrfNumbering
	}
	if {[regexp "LongueurMiniDesORFs" $Ligne]} {
	    scan $Ligne "%s %d" Toto LongueurMiniDesORFs
	}
	if {[regexp "NotreOS" $Ligne]} {
	    regsub {\.} [string range $Ligne 8 end] "" NotreOS
	    set NotreOrga [Glossaire $NotreOS Court]
	}
	if {[regexp "NotreOC" $Ligne]} {
	    set NotreOC [string range $Ligne 8 end]
	}
	if {[regexp "NotreOX" $Ligne]} {
	    set NotreOX [string range $Ligne 8 end]
	}
	if {[regexp "GenomeOuCollection" $Ligne]} {
	    set GenomeOuCollection [string trim [string range $Ligne 19 end]]
	}
	if {[regexp "MaquilleOui" $Ligne]} {
	    scan $Ligne "%s %s" Bidon MaquilleOui
	    set MaquilleNon [expr ! $MaquilleOui]
	}
    }
    if { ! [PourWscope] } { DialogPort }
    set ConfigChargee 1
}

proc CreeLaBaseOuLaCollection {} {
    global FichierMiniConfig
    global GenomeOuCollection

    if {[file exists "$FichierMiniConfig"]} { ChargeMiniConfig }

    if { [OnTraiteUnGenome] } {
	CreeLaBase
    } else {
	CreeLaCollection
    }
}

proc CreeFichierMiniConfig {{MiniConfigOrPrefixe ""} {OrfNumbering ""} {CollectionType ""} {OS ""} {OC ""} {OX ""} {RepGen ""}} {
JeMeSignale
    #rR Attention j'ai rajouté RepGen pour pouvoir le faire pour un autre RepGen
    global RepertoireDuGenome
    global CurrentGenome
    global FichierMiniConfig
    global VersionDeGscopeAuBigBang
    global FichierSequenceADN
    global PrefixeDesORFs
    global LongueurMiniDesORFs
    global GenomeOuCollection
    global NarcisseDuAlias

    if {[regexp {%?([0-9]+)(\.[0-9]+d)?$} $OrfNumbering Match ON]} { set $OrfNumbering $ON } 
    
    set Prefixe $MiniConfigOrPrefixe
    if {[regexp "," $MiniConfigOrPrefixe]} {
	set OS ""
	set OC "" 
	set OX ""
	set RepGen ""
	lassign [split $MiniConfigOrPrefixe ","] Prefixe OrfNumbering CollectionType OS OC OX RepGen
    }
    if {$RepGen==""} {
	set RepGen [RepertoireDuGenome]
	set YaDuNeuf [expr  ![string equal $Prefixe ""]]
    } else {
	set YaDuNeuf 0
    }
    set FichierMiniConfigACreer "$RepGen/beton/miniconfig"
    file mkdir "$RepGen/beton"

    if {[regexp {^[0-9]+$} $OS]} { set OX $OS; set OS "" } 
                               set OS [Tax $OS Name]
    if {$OX!="" && $OS=="" } { set OS [Tax $OX Name] }
    if {$OX==""}             { set OX [Tax $OS TaxId] }
    if {$OC==""}             { set OC [TaxClass $OX Name] } 

    regsub -all "_" $OS " " OS
    regsub -all "_" $OC " " OC


    if {[info exists FichierMiniConfigACreer] && [file exists $FichierMiniConfigACreer]} {
	if { ! $YaDuNeuf} { return $FichierMiniConfigACreer }
	if {1 || [OuiOuNon "Do we overwrite $FichierMiniConfigACreer"]} {
	    Garde $FichierMiniConfigACreer "AndDelete"
	}
    }

    set Interactif [expr !$YaDuNeuf]

    set VersionDeGscopeAuBigBang "VersionDeGscopeAuBigBang [VersionDeGscope]"	
    set TFA [lindex [glob -nocomplain "$RepGen/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 ?" 0]} {
	    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 { set GenomeOuCollection $Clef }
    }
    
    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 $FichierMiniConfigACreer
    return $FichierMiniConfigACreer
}

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]
    Espionne $FichierMiniConfig
    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

Espionne coucou
    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 or 
		\nhttp://uniprot.org/uniprot/P12345.txt \
		\nhttp://uniprot.org/uniprot/P12345.txt Alias\
		\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 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 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 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
	    }
	}
    }
}