#rR gscope_projet.tcl
#rR Où l'on crée des projets gscope automatiquement ...

#rR La creation d'un projet doit être faite en 2 temps
#rR D'abord par un autre Gscope existant pour créer le repertoire et y mettre le fasta
#rR Puis on peut faire par QuestionDeScience  

proc CreateHitFiles {} {
    foreach a b {
    }
}

proc MissBlastP {} {
    #rR A ne pas confondre avec MissBlast où on fouille dans les resultats des blast de OI2017
    #rR Ici on veut simplement savoir pourquoi certains blast n'ont pas été créés.

    set LesNomsSeq {}
    foreach Nom [ListeDesPABs] {
	set FichierBlast [GscopeFile $Nom "blastp"]
	if {[FileExists $FichierBlast]} { continue }
	set FichierTfa   [GscopeFile $Nom "prottfa"]
	set Seq [QueLaSequenceDuFichierTFA $FichierTfa]
	Espionne "$Nom $Seq"
	lappend LesNomSeq "$Nom $Seq"
    }
    return $LesNomSeq
}

proc RelanceGrilladin {} {
    #rR On ne fournit au Grilladin que ceux qui manquent ... dans le nouveau répertoire ProttfaCourant

    NousAllonsAuBoulot [RepertoireDuGenome]
    set ProttfaCourant "prottfa_[Date]"
    file mkdir $ProttfaCourant
    foreach Nom [ListeDesPABs] {
	if {[FileExists [GscopeFile $Nom blastp]]} { continue }
	file copy [GscopeFile $Nom prottfa] [GscopeFile $Nom $ProttfaCourant]
    }
    set Reponse [CompleteBlastGscopeProject "" "" $ProttfaCourant]
    OnRevientDuBoulot
    return $Reponse
}

proc CreeBlastDatabaseForUniprot {{Rep ""}} {
    #rR ceci sert surtout de pense-bête ...
    if {$Rep==""} { set Rep "./" }
    NousAllonsAuBoulot $Rep

    foreach B [list sprot trembl] {
	lappend LesCommandes "curl 'ftp://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/complete/uniprot_${B}.fasta.gz' -o uniprot_${B}.fasta.gz"
	lappend LesCommandes "gunzip uniprot_${B}.fasta.gz"
	lappend LesCommandes "mv uniprot_${B}.fasta ${B}SansOX"
	lappend LesCommandes "gscope yes FastaForBlast NewFastaFile - ${B}SansOX ${B}"
	lappend LesCommandes "ls "
	lappend LesCommandes "gscope yes CompleteCreateBlastDatabaseWithFasta $B $B"
    }
    set LesCommandesToDo [split [AfficheListe $LesCommandes "AvecRetour"] "\n"]
    EspionneL $LesCommandesToDo
    foreach Commande $LesCommandesToDo {
	Espionne $Commande
	if {[regexp "^gscope yes" $Commande]} {
	    regsub "gscope yes " $Commande "" Commande
	    eval $Commande
	} else {
	    eval exec $Commande
	}
	Espionne "$Commande done"
    }
    OnRevientDuBoulot
    return "coucou"
}

proc BlastomicsDb {{Qui ""} {Quoi ""}} {
    #rR on interroge ici toutes les bases Sqlite de BlastomicsDbDir
    #rR et on met tout en mémoire
    #rR Chaque projet peut avoir plusieurs Paraphylums associés EHomsa_CMC et EHomsa_TTLL
    #rR Chaque Paraphylum evidemment pluisieurs projets
    global BlastomicsDb

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

    set LesDb [lsort [glob -nocomplain [BlastomicsDbDir]/*.db]]
    foreach Db $LesDb {
	if {[catch {set NbOrga [SqlExecForDatabase $Db "select count(*) from organism" "GetFirstValue"]} ]} { continue }
	set Queue [file tail $Db]
	if { ! [regexp {^([^_]+)_([^\.]+)\.db$} $Queue Match Science Paraphylum]} { FaireLire "$Db non valide" } 
	regsub {\.db$} $Queue "" DbName

	lappend BlastomicsDb(ListOf,Db)     $Db
	lappend BlastomicsDb(ListOf,DbName) $DbName
	set BlastomicsDb($DbName,Db) $Db

	lappend BlastomicsDb(ListOf,Science)    $Science 
	lappend BlastomicsDb(ListOf,Paraphylum) $Paraphylum 
	lappend BlastomicsDb($Science,ListOfDb)     $Db 
	lappend BlastomicsDb($Science,ListOfDbName) $DbName 
	lappend BlastomicsDb($Science,ListOfParaphylum) $Paraphylum 
	lappend BlastomicsDb($Paraphylum,ListOfScience) $Science 

	set BlastomicsDb($DbName,ListOfClade) [SqlExecForDatabase $Db "select nom from clade" "GetList"]
	foreach Clade $BlastomicsDb($DbName,ListOfClade) {
	    set SqlOX "select taxid from organism, clade, ln_clade_organism where \
                                      clade.nom         = '$Clade'                       and \
                                      clade.pk_clade    = ln_clade_organism.pk_clade     and \
                          ln_clade_organism.pk_organism =          organism.pk_organism"
	    #Espionne $SqlOX
	    set BlastomicsDb($DbName-$Clade,ListOfOX) [SqlExecForDatabase $Db $SqlOX "GetList"]
	    #Espionne $BlastomicsDb($Queue-$Clade,ListOfOX)
	    regsub taxid $SqlOX specie SqlOS
	    set BlastomicsDb($DbName-$Clade,ListOfOS) [SqlExecForDatabase $Db $SqlOS "GetList"]
	} 
	
	set BlastomicsDb($Db,NbOrga) $NbOrga
	foreach DirTaxobla [TaxoblaProjects $Science ListOfDirTaxobla] {
	    set NbO [TaxoblaProjects $Science-$DirTaxobla NbOrga]
	}
    }

    set BlastomicsDb(ListOf,Science)    [lsort -unique $BlastomicsDb(ListOf,Science)]
    set BlastomicsDb(ListOf,Paraphylum) [lsort -unique $BlastomicsDb(ListOf,Paraphylum)]
    foreach Science $BlastomicsDb(ListOf,Science) {
	set BlastomicsDb($Science,ListOfParaphylum) [lsort -unique $BlastomicsDb($Science,ListOfParaphylum)]
    }
    foreach Paraphylum $BlastomicsDb(ListOf,Paraphylum) {
	set BlastomicsDb($Paraphylum,ListOfScience) [lsort -unique $BlastomicsDb($Paraphylum,ListOfScience)]
    }


    return [BlastomicsDb $Qui $Quoi]
}

proc BlastomicsProjects {{Qui ""} {Quoi ""}} {
    foreach Science [TaxoblaProjects ListOf Science] {
	foreach DirTaxobla [TaxoblaProjects $Science ListOfDirTaxobla] {
	    set 
	}
    }
}

proc TaxoblaProjects {{Qui ""} {Quoi ""}} {
    #rR C'est dément ... ça marche je crois ... (2018/01/09)
    #rR On fait ici la liste des projets taxobla : .. il existe un répertoire taxobla .. Plus ou moins rempli
    #rR On mémorise tout ça dans FicMemo mia son peut le refaire par TaxoblaProjects ReDo
    #rR Je vous laisse apprécier :)
    global TaxoblaProjects

    if {[regexp {^(ReDo|ReLoad)_} $Qui]} {
	if {[info exists TaxoblaProjects]} { unset TaxoblaProjects }
    }

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

    set FicMemo "/genomics/link/CilioCarta/fiches/BlastomesProjects.txt"
    if {[regexp {^ReDo_} $Qui] && [file exists $FicMemo]} { file delete $FicMemo }
    regsub {^(ReDo|ReLoad)_} $Qui "" Qui
    if {[file exists $FicMemo]} { array set TaxoblaProjects [ContenuDuFichier $FicMemo] ; return [TaxoblaProjects $Qui $Quoi] }

    set TaxoblaProjects(ListOf,Science) {}
    set TaxoblaProjects(ListOf,Go)      {}
    set TaxoblaProjects(ListOf,Taxobla) {}
    
    set LesRepTaxobla    [lsort [glob -nocomplain "/genomics/link/*/taxobla"]]
    set LesMyGOsFromGene [lsort [glob -nocomplain "/genomics/link/*/fiches/MyGOsFromGene.txt"]]
    set LesMyGenesFromGo [lsort [glob -nocomplain "/genomics/link/*/fiches/MyGenesFromGo.txt"]]

    set LesSciences {}
    foreach RepTaxobla $LesRepTaxobla {
	set Science [file tail [file dirname $RepTaxobla]]
	lappend LesSciences $Science
    }
    foreach MyGOsFromGene $LesMyGOsFromGene {
	set Science [file tail [file dirname [file dirname $MyGOsFromGene]]]
	lappend LesSciences $Science
    }
    foreach MyGenesFromGo $LesMyGenesFromGo {
	set Science [file tail [file dirname [file dirname $MyGenesFromGo]]]
	lappend LesSciences $Science
    }
    set LesSciences [lsort -unique $LesSciences]
    set TaxoblaProjects(ListOf,Science) $LesSciences 

    set TaxoblaProjects(ListOf,Info) {}
    set FormatHeader "%-12s %-10s %-8s %9s %9s %9s %9s %9s  %-30s %-30s %-12s %12s %12s %11s %6s %-12s %s"
    set FormatData   "%-12s %-10s %-8s %9d %9d %9d %9d %9d  %-30s %-30s %-12s %12d %12d %11d %6d %-12s %s"
    lappend TaxoblaProjects(ListOf,Info) [format $FormatHeader Science Prefixe Status prottfa blastp taxobla GoWithGn GnWithGO DirTaxobla DirBlastp Blast NbSeq NbLetters NbSeqTotal NbOrga Winner BlastDatabase]
    foreach Science $TaxoblaProjects(ListOf,Science) {
	set RG "/genomics/link/$Science"
	set Miniconfig [ContenuDuFichier $RG/beton/miniconfig]
	set Prefixe [StringApres "PrefixeDesORFs " dans $Miniconfig]
	set NbProttfa 0
	set RepProttfa "$RG/prottfa"
	if {[file exists $RepProttfa]} { set NbProttfa [llength [glob -nocomplain "$RepProttfa/$Prefixe*"]] }
	set NbGo 0
	set FicMyGenesFromGo "$RG/fiches/MyGenesFromGo.txt"
	if {[file exists $FicMyGenesFromGo]} { set NbGo [regexp -all {\,Noms} [ContenuDuFichier $FicMyGenesFromGo]] }
	set NbGn 0
	set FicMyGOsFromGene "$RG/fiches/MyGOsFromGene.txt" 
	if {[file exists $FicMyGOsFromGene]} { set NbGn [regexp -all {\,GOs}  [ContenuDuFichier $FicMyGOsFromGene]] }


	set TaxoblaProjects($Science,Prefixe) $Prefixe
	set TaxoblaProjects($Science,NbGo) $NbGo
	set TaxoblaProjects($Science,NbGn) $NbGn

	foreach RepTaxobla [glob -types d -nocomplain "$RG/taxobla*"] {
	    if {[file type $RepTaxobla]=="link"} { continue }
	    
	    NousAllonsAuBoulot $RepTaxobla
	    set PlusLong [exec sh -c "wc -l $Prefixe* | sort -k 1 -n -r | head -2"]
	    OnRevientDuBoulot
	    
	    set NbSeqTotal -1
	    set NbOrga -1
	    set Gagnant ""
	    lassign [LesMotsDuTexte $PlusLong] NbSeqTotal total NbOrga Gagnant
	    regsub taxobla $RepTaxobla blastp RepBlastp
	    set Premier ""
	    set Database ""
	    set EncoreUne 0
	    set NbSeq -1
	    set NbLet -1
	    if {[FileAbsent $RepBlastp]} {
		set RepBlastp ""
	    } else {
		set Premier [lindex [lsort [glob -nocomplain "$RepBlastp/$Prefixe*"]] 0]
		set OnAttend 1
		foreach Ligne [LesPremieresLignesDuFichier $Premier 50] {
		    if {$EncoreUne} {
			regsub -all "," $Ligne "" Ligne
			lassign [LesMotsDuTexte $Ligne] NbSeq Bidon NbLet
			break
		    }
		    if {$OnAttend && ! [regexp {^Database: } $Ligne]} { continue }
		    set OnAttend 0
		    set Database [StringApres "Database:" dans $Ligne]
		    set EncoreUne 1
		}
		set Premier [file tail $Premier]
	    }
	    set NbTaxobla 0
	    if {[file exists $RepTaxobla]} { set NbTaxobla [llength [glob -nocomplain "$RepTaxobla/$Prefixe*"]] }
	    set NbBlastp 0
	    set RepBlastp "bidon"
	    regsub taxobla $RepTaxobla blastp RepBlastp
	    if {[file exists $RepBlastp]} { set NbBlastp [llength [glob -nocomplain "$RepBlastp/$Prefixe*"]] }
	    set TaxoblaProjects($Science,NbTaxobla) $NbTaxobla
	    set TaxoblaProjects($Science,NbBlastp)  $NbBlastp
	    set Missing ""
	    if {$NbTaxobla<$NbBlastp} { set Missing "[expr $NbBlastp-$NbTaxobla] are missing :'(" }
	    set Status 0
	    if {$NbProttfa < 1         } { incr Status 10000 } 
	    if {$NbBlastp  < $NbProttfa} { incr Status  1000 } 
	    if {$NbTaxobla < $NbBlastp } { incr Status   100 }
	    if {$NbGo      < 1         } { incr Status    10 }
	    if {$NbGn      < 1         } { incr Status     1 }
	    set Status [format "%5.5d" $Status]
	    regsub -all "0"     $Status "." Status
	    regsub -all {[1-9]} $Status "X" Status
	    set DirTaxobla [file tail $RepTaxobla]
	    set DirBlastp  [file tail $RepBlastp]
	    lappend TaxoblaProjects(ListOf,Info) [format $FormatData $Science $Prefixe $Status $NbProttfa $NbBlastp $NbTaxobla $NbGo $NbGn $DirTaxobla $DirBlastp $Premier $NbSeq $NbLet $NbSeqTotal $NbOrga $Gagnant $Database]

	    lappend TaxoblaProjects($Science,ListOfRepTaxobla) $RepTaxobla
	    lappend TaxoblaProjects($Science,ListOfDirTaxobla) $DirTaxobla
	    lappend TaxoblaProjects($Science,ListOfRepBlastp)  $RepBlastp
	    lappend TaxoblaProjects($Science,ListOfDirBlastp)  $DirBlastp
	    lappend TaxoblaProjects($Science,ListOfNbOrga)     $NbOrga
	    set TaxoblaProjects($Science-$DirTaxobla,Status)     $Status
	    set TaxoblaProjects($Science-$DirTaxobla,NbProttfa)  $NbProttfa
	    set TaxoblaProjects($Science-$DirTaxobla,NbBlastp)   $NbBlastp
	    set TaxoblaProjects($Science-$DirTaxobla,NbTaxobla)  $NbTaxobla
	    set TaxoblaProjects($Science-$DirTaxobla,NbSeq)      $NbSeq
	    set TaxoblaProjects($Science-$DirTaxobla,NbLet)      $NbLet
	    set TaxoblaProjects($Science-$DirTaxobla,NbSeqTotal) $NbSeqTotal
	    set TaxoblaProjects($Science-$DirTaxobla,NbOrga)      $NbOrga
	}
	if {0 && [incr X 1]>5} { break }
    }

    set TaxoblaProjects(TextOf,Info) [join $TaxoblaProjects(ListOf,Info) "\n"]
    set TaxoblaProjects(,) $TaxoblaProjects(TextOf,Info)

    Sauve [array get TaxoblaProjects] dans $FicMemo
    file attribute $FicMemo -permissions 0777
    return [TaxoblaProjects $Qui $Quoi] 
}

proc GrilladesEnCours {{Qui ""} {Quoi ""}} {
    global GEC

    #rR Attention c'est pas très clair : OI utilise surtout les liens et ici on se sert des fichiers dans fiches. A CLARIFIER !!!"

    if {[info exists GEC($Qui,$Quoi)]} {
	if {[PourWscope]} { return [join $GEC($Qui,$Quoi) "\n"] }
	return $GEC($Qui,$Quoi)
    }
    if {[info exists GEC("EstCharge")]} { return "" }
    set GEC("EstCharge") 1

    set GEC(ListOf,Science)   {}
    set GEC(ListOf,PP)        {}
    set GEC(ListOf,PassePlat) {}
    
    #rR les passeplats sont tries ... du coup c'est le dernier qui est pris en compte pour une science
    set LesFichesPassePlats [lsort [glob -nocomplain "/genomics/link/*/fiches/PassePlat_*"]]
    set LesScience {}
    foreach FichePassePlat $LesFichesPassePlats {
Espionne $FichePassePlat
	set Science [file tail [file dirname [file dirname $FichePassePlat]]]
	set PassePlat [ContenuDuFichier $FichePassePlat]
	set GEC($Science,PassePlat) $PassePlat
	set PP [file tail $PassePlat]
	set GEC($PP,Science) $Science
	lappend GEC(ListOf,Science)   $Science
	lappend GEC(ListOf,PP)        $PP
	lappend GEC(ListOf,PassePlat) $PassePlat
    }
    set GEC(ListOf,Info) {}
    foreach Science $GEC(ListOf,Science) {
	set LienPP "/genomics/link/$Science/fiches/passeplat"
	set PassePlat $GEC($Science,PassePlat)
	set NbGrillades [llength [glob -nocomplain "$PassePlat/blastp/*"]]
	set GEC($Science,NbGrillades) $NbGrillades
	if { ! [file exists $LienPP]} {
	    if {[OuiOuNon "$LienPP does not exist. Do I create it ?" 0] } {
		file link -symbolic $LienPP "$PassePlat/blastp"
	    }
	}
	lappend GEC(ListOf,Info) [format "%-10s %6d on %s" $Science $NbGrillades $PassePlat]
    }
    set GEC(,) [join $GEC(ListOf,Info) "\n"]
    return [GrilladesEnCours $Qui $Quoi] 
}

proc RetourGrilladin {} {
    set LesFichesPassePlats [lsort [glob "[RepertoireDuGenome]/fiches/PassePlat*"]]
    set PassePlat [ContenuDuFichier [lindex $LesFichesPassePlats end]]
    set RepBlastPP "$PassePlat/blastp"
    set LesNouveaux {}
    file mkdir "[RepertoireDuGenome]/blastp"
    foreach F [lsort [glob "$RepBlastPP/[PreFixe]*"]] {
	set Queue [file tail $F]
	set B "[RepertoireDuGenome]/blastp/$Queue"
	if {[file exists $B]} { continue }
	lappend LesNouveaux $Queue
	file copy $F $B
    }
    return $LesNouveaux
}

proc CreateGscopeProjectWithFasta {{FastaFile ""} {ProjName ""}} {
    set RepGen     "/gstock/$ProjName"
    set RepGenLink "/genomics/link/$ProjName"
    if {[file exists $RepGen] || [file exists $RepGenLink]} {
	if { ! [OuiOuNon "$RepGen or $RepGenLink already exists. Do I continue anyway ?" 1]} { return "" }
    }
    if {[FileAbsent $RepGen]}     { file mkdir $RepGen }
    if {[FileAbsent $RepGenLink]} { file link -symbolic $RepGenLink $RepGen}
    
    set DeDir "$RepGenLink/DeWeb"
    file mkdir $DeDir
    set FastaName [file tail $FastaFile]
    set Destin $DeDir/$FastaName
    if {[FileAbsent $Destin]} { file copy $FastaFile $Destin }
    
    return $Destin
}

proc ValidBlastDatabaseForHotdog {BlastDatabase} {
    return [ValidBlastDatabaseForGrilladin $BlastDatabase]
}

proc ValidBlastDatabaseForGrilladin {BlastDatabase} {
    return 1
    return [string equal $BlastDatabase "Proteome201501"]
}

proc CompleteGscopeProjectWithFasta {{FastaFile ""} {ProjName ""} {Prefixe ""} {NbDigit ""} {OS ""} {OX ""} {OC ""} {BlastDatabase ""}} {
    #rR est lancé en QDS
    if {$NbDigit=="."} { set NbDigit "" }
    if {$OS=="."} { set OS "" }
    if {$OX=="."} { set OX "" }
    if {$OC=="."} { set OC "" }
    
    if {$OX!="" && $OS==""} { set OS [Tax $OX Name] }
    if {$OS!="" && $OX==""} { set OX [Tax $OS TaxId] }
    if {$OX!="" && $OC==""} { set OC [TaxClass $OX Name] }
    if {$OS!="" && $OC==""} { set OC [TaxClass $OS Name] }
    regsub "^root; cellular organisms; " $OC "" OC 
    
    if {[PasTouche "CompleteGscopeProjectWithFasta"]} { return "Sorry. CompleteGscopeProjectWithFasta is still running" } 
    if {$NbDigit==""} { set NbDigit 5 }
    CreeFichierMiniConfig $Prefixe $NbDigit Prot $OX
    CreeLaCollection TFA $FastaFile "" KeepEntete "No" "No"
#    AllForGo
    LogWscope "BlastDatabase=$BlastDatabase"
    set PassePlat ""
    if {[ValidBlastDatabaseForGrilladin $BlastDatabase]} {
	set ProjNameWithDate "${ProjName}_[Date]"
	set DBSizeTxt [BlastDatabaseSize $BlastDatabase]
	scan $DBSizeTxt "%d" DBSize
	set NSeqPerJob 200
	set PassePlat [Grillade::creerPoeleBlast ProjectName $ProjNameWithDate InputDir "[RepertoireDuGenome]/prottfa" DB $BlastDatabase DBsize $DBSize NSeqPerJob $NSeqPerJob]
	AppendAuFichier [Fiches PassePlat_$ProjNameWithDate] $PassePlat
    } else {
	LogWscope "$BlastDatabase invalid"
    }
    FinPasTouche "CompleteGscopeProjectWithFasta"
    set Message "OK. Most of the job is done for CompleteGscopeProjectWithFasta."
    if {$PassePlat!=""} { append $Message "Blast files will be available at $PassePlat" }
    return $Message
}

proc CompleteCreateBlastDatabaseWithFasta {{FastaFile ""} {BlastDatabaseName ""}} {

    if {$BlastDatabaseName==""} { set BlastDatabaseName [file tail $FastaFile] } ;#rR 2016/11/07

LogWscope "CompleteCreateBlastDatabaseWithFasta $FastaFile $BlastDatabaseName"

    set Logfile $BlastDatabaseName.formatdb.log
    exec formatdb -i $FastaFile -p T -n $BlastDatabaseName -l $Logfile -o T
    if {[FileAbsent $Logfile]} {
	set Message "Error. Something went wrong with CompleteCreateBlastDatabaseWithFasta. I didn't got the log file"
    } elseif {[FileAbsent $BlastDatabaseName.phr] && [FileAbsent $BlastDatabaseName.pal]} {
	set Message "Error. Something went wrong with CompleteCreateBlastDatabaseWithFasta. I didn't got the result. Log file contents [ContenuDuFichier $Logfile]"
    } else {
	set Message "OK. The BlastDatabase should be available at $BlastDatabaseName."
    }
    LogWscope $Message
    return $Message
}

proc CompleteTaxoblaGscopeProject {{FromOi ""}} {
    #rR est normalement lancé en QDS
    if {$FromOi=="FromOi"} {
	LogWscope "CompleteTaxoblaGscopeProject $FromOi"
	set LesFicTax [TaxoblaFromOi]
	return "[llength $LesFicTax] taxobla files were created"
    }
    TaxonomyDuBlastPourTous
    return "OK, TaxonomyDuBlastPourTous done"
}

proc CompleteRetourGrilladinGscopeProject {} {
    #rR est lancé en QDS
    RetourGrilladin
    return "OK, RetourGrilladin done"
}

proc CompleteBlastGscopeProject {{ProjName ""} {BlastDatabase ""} {ProttfaCourant ""}} {
    #rR est lancé en QDS ?????????????,

    if {$ProttfaCourant==""} { set ProttfaCourant "prottfa" }

    if {$BlastDatabase==""} { set BlastDatabase [LocaliseBlastPDataBase] }

    if {$ProjName==""} { set ProjName [file tail [RepertoireDuGenome]] }

    if {[PasTouche "CompleteBlastGscopeProject"]} { return "Sorry. CompleteBlastGscopeProject is still running" } 
    set PassePlat ""
    if {[ValidBlastDatabaseForGrilladin $BlastDatabase]} {
	set ProjNameWithDate "${ProjName}_[Date]"
	set DBSizeTxt [BlastDatabaseSize $BlastDatabase]
	scan $DBSizeTxt "%d" DBSize 
	Espionne      "Grillade::creerPoeleBlast  ProjectName $ProjNameWithDate  Input [RepertoireDuGenome]/$ProttfaCourant  DB $BlastDatabase  DBsize $DBSize"
	set PassePlat [Grillade::creerPoeleBlast  ProjectName $ProjNameWithDate  Input [RepertoireDuGenome]/$ProttfaCourant  DB $BlastDatabase  DBsize $DBSize]
	if {[regexp -nocase "^Error" $PassePlat]} {
	    set Message "Error. Something is wrong with Grilladin. I got the error message $PassePlat"
	}
	#rR Tcl ne veut pas pointer si la cible n'existe pas :file link -symbolic "[RepertoireDuGenome]/passeplat" "$PassePlat/blastp"
	exec ln -sf "$PassePlat/blastp" "[RepertoireDuGenome]/passeplat"
	AppendAuFichier [Fiches PassePlat_$ProjNameWithDate] $PassePlat
	set Message "Warning. I launched Grilladin for $ProjName. Blast files will be available at $PassePlat" 
	return $Message
    } else {
	set Message "Error. Sorry the blast database '$BlastDatabase' is not a valid blast database for Grilladin"
    }
    LogWscope $Message
    FinPasTouche "CompleteBlastGscopeProject"
    return $Message
}

proc CreateGscopeProjectWithOi {Source OiName {SpOnly ""}} {
    if {$SpOnly ==""} { set SpOnly  0 }
    set FichierFasta [CreateGscopeProjectFromOiName $Source $OiName $SpOnly]
    return $FichierFasta
}

proc CompleteGscopeProjectWithOi {Source OiCode FichierFasta {NbDigit ""}} {
    #rR est lancé en QDS
    if {[PasTouche "CompleteGscopeProjectWithOi"]} { return "Sorry. CompleteGscopeProjectWithOi is still running" } 
    if {$NbDigit==""} { set NbDigit 5 }
    if {$Source=="OiOld"} {
	set OX [OiName $OiCode OX]
    } else {
	#rR Source est OiArchaea ou OiEukaryota
	set Domain [string range $Source 2 end]
	set OX [OiCodeForDomain $Domain $OiCode OX]
    }
    CreeFichierMiniConfig $OiCode $NbDigit Prot $OX
    CreeLaCollection TFA $FichierFasta "" KeepEntete "No" "No"
    AllForGo
    NIAG
    FinPasTouche "CompleteGscopeProjectWithOi"
    return "OK. All is done for CompleteGscopeProjectWithOi"
}

proc SpOnlyFromFasta {Fasta NewFasta} {
    set LeNew {}
    set LeTFA {}
    foreach Ligne [LesLignesDuFichier $Fasta] {
	if { ! [regexp ">" $Ligne]} { lappend LeTFA $Ligne ; continue }
	if {[regexp "BANK=sp" $LeTFA]} {
	    lappend LeNew [join $LeTFA "\n"]
	}
	set LeTFA {}
	lappend LeTFA $Ligne
    }
    return [SauveLesLignes $LeNew dans $NewFasta]
}

proc BestGN Nom {
    if {[set ValiGN  [ExtraitInfo $Nom "ValiGN:"]] !=""} { return $ValiGN } 
    if {[set GN      [ExtraitInfo $Nom "GN:"]]     !=""} { return $GN } 
    if {[set DraftGN [ExtraitInfo $Nom "DraftGN:"]]!=""} { return $DraftGN }
    return ""
}

proc BestDE Nom {
    if {[set ValiDE  [ExtraitInfo $Nom "ValiDE:"]] !=""} { return $ValiDE } 
    if {[set DE      [ExtraitInfo $Nom "DE:"]]     !=""} { return $DE } 
    if {[set DraftDE [ExtraitInfo $Nom "DraftDE:"]]!=""} { return $DraftDE }
    return ""
}

proc InformeFromOiPourTous {} {
    if { ! [OuiOuNon "Merci de vérifier cette proc, elle est peut-être obsolète. Il faut peut etre mettre ValiGN ou GN DraftGN. \nJe le fais quand même ?"]} { return "" }
    foreach Nom [ListeDesPABs] {
	set FicTfa [GscopeFile $Nom prottfa]
	set Header [PremiereLigneDuFichier $FicTfa]
	set Gn [StringApres "GN=" dans $Header]
	if {[regexp "DRAFT_" $Gn]} { InformeSansDemander $Nom "=DraftGN: $Gn" ; set Gn "" }
	if {$Gn=="Fragment"}       { set Gn "" }
	regsub "GN=.+" $Header "" Debut 
	set LesMots [LesMotsDuTexte $Debut]
	set Id [lindex $LesMots 1]
	set Ac [lindex $LesMots 2]
	set De [join [lrange $LesMots 5 end] " "]
	if {[regexp {\|} $Id]} {
	    lassign [split $Id "|"] B A I
	    set Id $I
	    set Ac $A
	    set Ba $B
	    set De [join [lrange $LesMots 2 end] " "]
	}
	if {$Id!=""} { InformeSansDemander $Nom "=ID: $Id" }
 	if {$Ac!=""} { InformeSansDemander $Nom "=AC: $Ac" }
	if {$Gn!=""} { InformeSansDemander $Nom "=GN: $Gn" ; InformeSansDemander $Nom "=Alias: $Gn"}
 	if {$De!=""} { InformeSansDemander $Nom "=DE: $De" }
    }
    return ""
}

proc CreateGscopeProjectFromOiName {{Source ""} {OiName ""} {SpOnly ""}} {
JeMeSignale
    #rR Attention ici OiName peut aussi être OiCode ............ mais je laisse OiName en nom de variable
    if {$Source=="OiOld"} { set UseOiCode 0 } else { set UseOiCode 1 }
    if {$SpOnly==""} {
	set SpOnly [OuiOuNon "Do I use only Swissprot (I'll test BANK=sp in the protein headers)" 0]
    }
    while {$OiName==""} {
	if {$UseOiCode} {
	    set Info [ChoixParmi [OiCode ListOf Info]]
	} else {
	    set Info [ChoixParmi [OiName ListOf Info]]
	}
	if {$Info==""} {
	    if {[OuiOuNon "Do I skip CreateGscopeProjectFromOiName"]} { return "" }
	    continue
	}
	scan $Info "%s" OiName
    }
    set RepGen     "/gstock/$OiName"
    set RepGenLink "/genomics/link/$OiName"
    if {[file exists $RepGen] || [file exists $RepGenLink]} {
	if { ! [OuiOuNon "$RepGen or $RepGenLink already exists. Do I continue anyway ?" 1]} { return "" }
    }
    if {[FileAbsent $RepGen]}     { file mkdir $RepGen }
    if {[FileAbsent $RepGenLink]} { file link -symbolic $RepGenLink $RepGen}

    set DeOiDir $RepGenLink/DeOi
    file mkdir $DeOiDir
    if {$UseOiCode} {	
	set FastaFile [OiCode $OiName FullFilePath]
	set FastaName [OiCode $OiName OI]
	set OX        [OiCode $OiName OX]
    } else {
	set FastaFile [OiName $OiName Fasta]
	set FastaName [OiName $OiName Orga]
	set OX        [OiName $OiName OX]
    }
    set Destin $DeOiDir/$FastaName

Espionne "file copy $FastaFile $Destin"

    if {[FileAbsent $Destin]} { file copy $FastaFile $Destin }
    if {$SpOnly} {
	set AllBanks "${Destin}_AllBanks"
	file rename $Destin "$AllBanks"
	SpOnlyFromFasta $AllBanks $Destin
    }


    set OS [Tax $OX Name]
    set OC [TaxClass $OX Name]
    regsub "^root; cellular organisms; " $OC "" OC 

    return $Destin
}

proc CreateBlastDatabasesForDir {{Dir ""} {Titre ""} {OutFilename ""}} {
    #rR Je ne sais pas où on s'en sert ... à creuser (2016/07/25)

    #rR On crée les banques blast à deux niveaux .. faudrait le faire récursif ...
    #rR on crée les banques pour chaque fasta
    #rR  puis un .nal pour cette banque
    #rR Puis un .nal du nom du répertoire qui contient tous ces .nhr
    #rR Et tout en haut le .nal qui contient les .nal des sous-répertoires
    if {$Titre      ==""} { set Titre "GenomesFor[file tail [RepertoireDuGenome]]" }
    if {$OutFilename==""} { set $OutFilename $Titre }
    if {$Dir==""} { set Dir "[RepertoireDuGenome]/Genomes" }
    NousAllonsAuBoulot $Dir
    set LesFastaFile [glob -nocomplain */*{.fsa,.fna}*]
    set LesNal {}
    foreach FastaPath $LesFastaFile {
	set SubDir [file dirname $FastaPath]
	set FastaFile [file tail $FastaPath]
	NousAllonsAuBoulot $SubDir
	regsub {(\.fsa|\.fna)} $FastaFile "" Name
	Espionne $FastaFile
	Espionne $Name
	if { ! [file exists $Name.nhr]} {
	    exec formatdb -p F -o T -i $FastaFile -n $Name -l $Name.log
	}
	if { ! [file exists $SubDir.nal]} {
	    set LesNhr [lsort -dictionary [glob "*.nhr"]]
	    set LesSousBanques {}
	    foreach Nhr $LesNhr {
		regsub {\.nhr$} $Nhr "" Banque
		lappend LesSousBanques $Banque
	    }
	    set DbList [join $LesSousBanques " "]
	    set LeNal {}
	    lappend LeNal "#"
	    lappend LeNal "# Alias file created by Gscope CreateBlastDatabasesForDir [Date Nice]"
	    lappend LeNal "#"
	    lappend LeNal "TITLE $SubDir"
	    lappend LeNal "#"
	    lappend LeNal "DBLIST $DbList"
	    lappend LeNal "#"
	    SauveLesLignes $LeNal dans $SubDir.nal
	}
	lappend LesNal $SubDir/$SubDir.nal
	OnRevientDuBoulot
    }
    set LesSousBanques {}
    foreach Nal $LesNal {
	regsub {\.nal$} $Nal "" Banque
	lappend LesSousBanques $Banque
    }
    set DbList [join $LesSousBanques " "]
    lappend LeNal "#"
    lappend LeNal "# Alias file created by Gscope CreateBlastDatabasesForDir [Date Nice]"
    lappend LeNal "#"
    lappend LeNal "TITLE $Titre"
    lappend LeNal "#"
    lappend LeNal "DBLIST $DbList"
    lappend LeNal "#"
    SauveLesLignes $LeNal dans $Titre.nal
    OnRevientDuBoulot
    return $Dir/$Titre.nal
}

proc BlastTestDir {} {
    set BlastTestDir "/blast/BlastTest"
    return $BlastTestDir
}

proc BlastDatabaseSizeNice {B {DoBlastIfNecessary ""} {DefaultSize ""}} {
    return [BlastDatabaseSize $B $DoBlastIfNecessary $DefaultSize "Nice"]
}

proc BlastDatabaseSize {B {DoBlastIfNecessary ""} {DefaultSize ""} {Nice ""}} {
    #rR Rend le nombre de séquences et le nombre de lettres si on le trouve N L sinon N
    #rR Initialement écrit par Mickael Joly
    #rR S'il existe un blast déjà fait sur cette base on va y chercher la taille
    #rR Sinon on va voir dans formatdb.log
    #rR Si c'est un .pal on cumule les tailles des sousbases

    set Info [exec /biolo/blast/bin/blastdbcmd -info -db $B]
    if { [regexp {([0-9\,]+) sequences; ([0-9\,]+) total residues} $Info Match NbSeq NbRes]} {
	regsub -all {\,} $NbSeq "" NbSeq
	regsub -all {\,} $NbRes "" NbRes
	return "$NbRes letters $NbSeq sequences"
    }

    set BlastTestDir "/blast/BlastTest"
    if {$DefaultSize==""} { set DefaultSize 3608421 }

    if { ! [regexp "^/" $B]} { set B "/blast/$B" }
    set queue [file tail $B]
    set FichierBlast "[BlastTestDir]/$queue.test.blast"
    if {[file exists $FichierBlast]}  {
	if {[regexp {([0-9\,]+) sequences} [ContenuDuFichier $FichierBlast] Match NAV]} {
	    regsub -all "\," $NAV "" N
	    if {[regexp {([0-9\,]+) total letters} [ContenuDuFichier $FichierBlast] Match LAV]} {
		regsub -all "\," $LAV "" L
		return "$L letters $N sequences"
	    }
	    return $N
	}
    } else {
	if {[string equal -nocase "DoBlastIfNecessary" $DoBlastIfNecessary] || [OuiOuNon "$FichierBlast does not exist ... Do I create it ... It will take some time" 0]} {
	    set FichierQuery "[BlastTestDir]/queryBidon.tfa"
	    set creationBlast [BlastForTest $FichierQuery $FichierBlast $B]
	    set Size [BlastDatabaseSize $B $DefaultSize]
	    return $Size
	}
    }
    set FicFormat "$B.formatdb.log"
    set total 0
    if {[file exists $FicFormat]} {
	foreach Ligne [LesLignesDuFichier $FicFormat] {
	    if {![regexp {Formatted ([0-9]+) sequences} $Ligne Match N]} {continue}
	    incr total $N
	}
	return $total
    }

    foreach Ext {pal nal} {
	set FicPal "$B.$Ext"
	Espionne $FicPal
	set total 0
	if {[FileAbsent $FicPal]} { continue }
	set Dir [file dirname $FicPal]
	foreach Ligne [LesLignesDuFichier $FicPal] {
	    if {![regexp {^DBLIST } $Ligne]} {continue}
	    regsub -all {[ \t]+} $Ligne " " Ligne
	    set LesMots [split $Ligne " "]
	    foreach SousBase [lrange $LesMots 1 end] {
		if {! [regexp "^/" $SousBase]} { set SousBase "$Dir/$SousBase" }
		Espionne $SousBase
		set N [BlastDatabaseSize $SousBase "No" 0]
		scan $N "%d" N
		incr total $N
		Espionne $N
	    }
	}
	return $total
    }
    return $DefaultSize
}

proc BlastDatabaseSizePourTous {} {
    set LesBanques [split [BlastDatabaseInventory ListOf ProBestFirst]]
    set LesNouveaux {}
    foreach Banque $LesBanques {
	set Queue [file tail $Banque]
	set FichierBlast "[BlastTestDir]/$Queue.test.blast"
	set FichierQuery "[BlastTestDir]/queryBidon.tfa"
	Espionne "$Queue $Banque $FichierBlast"
	if {[FileAbsent $FichierBlast]} {
	    BlastForTest $FichierQuery $FichierBlast $Banque "GetFilename" "Wait"
	}
	set Size [BlastDatabaseSize $Banque]
	Espionne $Size
	lappend LesSize "$Size $FichierBlast"
    }
    return $LesSize
}

proc BlastForTest {FichierEntree {FichierSortie ""} {Banque ""} {GetWhat ""} {Wait ""}} {
    #rR on s'en sert surtout pour créer les blast qui permettent d'en extraire la taille par BlastDatabaseSize
    if {$GetWhat==""} { set GetWhat "GetFilename" }
    if {[string equal -nocase $GetWhat "GetPid"]} { set Wait "Wait" }
    set Wait [string equal -nocase $Wait "Wait"]

    if {[PourWscope]} {
	if {[regexp "\.\." $FichierSortie]} {
	    return "Sorry. You are not allowed to create $FichierSortie]"
	}
	if { ! [regexp [BlastTestDir] $FichierSortie] && ! [regexp "magasin" $FichierSortie]} { 
	    return "Sorry. You are not allowed to create $FichierSortie]"
	}
    }

    if { [file exists $FichierSortie] && [string equal -nocase $Action "Lire"]  } {return [ContenuDuFichier $FichierSortie]}
    set commande "tcsh -c \"/biolo/ncbi/bin/blastall -i $FichierEntree -a 8 -d $Banque -p blastp -F T -o $FichierSortie.tmp -K 0 -v 33 -b 33 -e 1.0e-33 ; mv $FichierSortie.tmp $FichierSortie;\""
    if {$Wait} {
	eval exec $commande
	if {[string equal -nocase $GetWhat "Lire"]  } { return [ContenuDuFichier $fichierSortie] }
	return $FichierSortie
    }
    set Pid [eval exec $commande &]
    return "blast was launched with command\n$commande\npid=$Pid Result will be available in $FichierSortie"
}

proc BlastDatabaseInventory {{Qui ""} {Quoi ""} {RepBan ""}} {
    global BDI

    if {$Qui=="ResetAll"} {
	if {[info exists BDI]} { unset BDI }
	return ""
    }

    if {$Qui==""} { set Qui "Usage" ; set Quoi "" }

    if {$Quoi=="Size"} { return [BlastDatabaseSizeNice $Qui] }

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

    if {$RepBan==""} { set RepBan "/blast" }

    set BDI(Dir,) $RepBan

    set LesNal {}

    set LesProBest [list \
		     protall \
		     uniprot \
		     protein \
		     swissprot \
		     trembl \
		     pdb \
		     varsplic \
		     refseq-prot \
		     uniref90 \
		    ]
    set LesNucBest [list \
		     genembl \
		     genbank \
		     refseq-nuc \
		     est \
		     HUMAN \
		     MOUSE \
		    ]
    
    set ToutesLesBanques [lsort [glob -nocomplain "$RepBan/*"]] 
    foreach Fichier $ToutesLesBanques {
	set Banque [file tail $Fichier]
	set B $Banque
	if { ! [regexp {(\.pal|\.phr|\.nhr|\.nal)$} $Banque] } { continue }
	if {[regexp {\.pal$} $Banque]} {
	    regsub {\.pal$} $Banque "" B
	    set EstPal($B) $B
	}
	if {[regexp {\.nal$} $Banque]} {
	    regsub {\.nal$} $Banque "" B
	    set EstNal($B) $B
	}
    }
    foreach Fichier $ToutesLesBanques {
#	if {[file type $Fichier]=="link"} { continue }
	set Banque [file tail $Fichier]
	set B $Banque
	if { ! [regexp {(\.pal|\.phr|\.nhr|\.nal)$} $Banque] } { continue }
	lappend BDI(ListOf,All) $Banque
	if {[regexp {\.pal$} $Banque]} {
	    regsub {\.pal$} $Banque "" B
	    set ContentOf($B) [ContenuDuFichier $Fichier]
	    foreach Ligne [LesLignesDuFichier $Fichier] {
		if {[regexp "^TITLE" $Ligne]} { set Title($B) [StringSuivant "TITLE " dans $Ligne] }
		if {[regexp "^DBLIST" $Ligne]} {
		    set Filles [StringSuivant "DBLIST " dans $Ligne]
		    regsub -all " +" $Filles " " Filles
		    set LesFilles [split [string trim $Filles] " "]
		    set LesFillesDe($B) {}
		    foreach Fille $LesFilles {
			if { ! [regexp "^/" $Fille] && [FileAbsent "$RepBan/$Fille.pal"] && [FileAbsent "$RepBan/$Fille.phr"]} {
			    continue 
			    FaireLire "$RepBan/$Fille.phr ou .pal introuvable"
			}
			lappend LesMeresDe($Fille) $B
			lappend LesFillesDe($B)    $Fille 
		    }
		}
	    }
	    if { ! [info exists Title($B)]} { set Title($B) "" }
	    if {$LesFillesDe($B)=={}} { continue }
	    lappend LesPal $B
	    set BDI($B,TITLE)  $Title($B)
	    set BDI($B,DBLIST) $LesFillesDe($B)
	    set BDI($B,CONTENT) $ContentOf($B)
	}
	if {[regexp {\.nal$} $Banque]} {
	    regsub {\.nal$} $Banque "" B
	    set ContentOf($B) [ContenuDuFichier $Fichier]
	    foreach Ligne [LesLignesDuFichier $Fichier] {
		if {[regexp "^TITLE" $Ligne]} { set Title($B) [StringSuivant "TITLE " dans $Ligne] }
		if {[regexp "^DBLIST" $Ligne]} {
		    set Filles [StringSuivant "DBLIST " dans $Ligne]
		    regsub -all " +" $Filles " " Filles
		    set LesFilles [split [string trim $Filles] " "]
		    set LesFillesDe($B) {}
		    foreach Fille $LesFilles {
			if {[FileAbsent "$RepBan/$Fille.nal"] && [FileAbsent "$RepBan/$Fille.nhr"]} {
			    continue
			    FaireLire "$RepBan/$Fille.nhr ou .nal introuvable"
			}
			lappend LesMeresDe($Fille) $B
			lappend LesFillesDe($B)    $Fille 
		    }
		}
	    }
	    if { ! [info exists Title($B)]} { set Title($B) "" }
	    if {$LesFillesDe($B)=={}} { continue }
	    lappend LesNal $B
	    set BDI($B,TITLE) $Title($B)
	    set BDI($B,DBLIST) $LesFillesDe($B)
	    set BDI($B,CONTENT) $ContentOf($B)
	}
	if {[info exists DejaVu($B)]} { FaireLire "$B\n$Fichier\n$DejaVu($B)" }
	set DejaVu($B) $Fichier	
    }
    set LesPhr {}
    set LesNhr {}
    foreach Fichier $ToutesLesBanques {
	set Banque [file tail $Fichier]
	set B $Banque
	if { ! [regexp {(\.phr|\.nhr)$} $Banque] } { continue }
	if {[regexp {\.phr$} $Banque]} {
	    regsub {\.phr$} $Banque "" B
	    if {[regexp         {(unigene)[0-9]+$} $B] } { continue }
	    if {[regexp {(part|\.)[0-9]+$} $B] && [info exists LesMeresDe($B)]} { continue }
	    lappend LesPhr $B
	    lappend LesProWithTitle "[format %-33s $B] :"
	}
	if {[regexp {\.nhr$} $Banque]} {
	    regsub {\.nhr$} $Banque "" B
	    if {[regexp         {(unigene)[0-9]+$} $B] } { continue }
	    if {[regexp {(part|\.|unigene)[0-9]+$} $B] && [info exists LesMeresDe($B)]} { continue }
	    lappend LesNhr $B
	}
    }
    foreach {K V} [array get LesMeresDe] {
	set BDI($K,PartOf) $V
    }
    set LesPro [lsort [concat $LesPal $LesPhr]]
    set LesNuc [lsort [concat $LesNal $LesNhr]]
    set LesProBestExistant {}
    foreach B $LesProBest {
	if {[lsearch $LesPro $B]<0} { continue }
	lappend LesProBestExistant $B
    }
    set LesNucBestExistant {}
    foreach B $LesNucBest {
	if {[lsearch $LesNuc $B]<0} { continue }
	lappend LesNucBestExistant $B
    }
    set LesProBestFirst [ListeSansDoublon [concat $LesProBestExistant $LesPro]]
    set LesNucBestFirst [ListeSansDoublon [concat $LesNucBestExistant $LesNuc]]

    foreach X [list "Pro" "Nuc" "ProBestFirst" "NucBestFirst"] {
	set Les${X}WithTitle {}
	foreach B [set Les${X}] {
	    set T ""
	    if {[info exists Title($B)]} { set T $Title($B) }
	    lappend Les${X}WithTitle "[format %-33s $B] : $T"
	}
    }

    set BDI(ListOf,ProWithTitle) [join $LesProWithTitle "\n"]
    set BDI(ListOf,Pro)          [join $LesPro "\n"]
    set BDI(ListOf,Pal)          [join $LesPal "\n"]
    set BDI(ListOf,Phr)          [join $LesPhr "\n"]
    set BDI(ListOf,NucWithTitle) [join $LesNucWithTitle "\n"]
    set BDI(ListOf,Nuc)          [join $LesNuc "\n"]
    set BDI(ListOf,Nal)          [join $LesNal "\n"]
    set BDI(ListOf,Nhr)          [join $LesNhr "\n"]

    set BDI(ListOf,ProBestFirst)          [join $LesProBestFirst "\n"] 
    set BDI(ListOf,NucBestFirst)          [join $LesNucBestFirst "\n"] 
    set BDI(ListOf,ProBestFirstWithTitle) [join $LesProBestFirstWithTitle "\n"] 
    set BDI(ListOf,NucBestFirstWithTitle) [join $LesNucBestFirstWithTitle "\n"]

    set BDI(ListOf,ProNucBestFirstWithTitle) "$BDI(ListOf,ProBestFirstWithTitle)\n$BDI(ListOf,NucBestFirstWithTitle)"

    foreach B $LesPal {
	set BDI($B,Type) "Pal"
    }
    foreach B $LesPhr {
	set BDI($B,Type) "Phr"
    }
    foreach B $LesNal {
	set BDI($B,Type) "Nal"
    }
    foreach B $LesNhr {
	set BDI($B,Type) "Nhr"
    }
    set LesUs [array names BDI]
    set LesUsages {}
    foreach Us $LesUs {
	if {[regexp "EstCharge" $Us]} { continue }
	lassign [split $Us ","] A B
	if {[info exists BDI($A,PartOf)] || [info exists BDI($A,Type)]} { set A "BlastDatabank" }
	lappend LesUsages "BlastDatabaseInventory $A $B"
    }
    lappend LesUsages "BlastDatabaseInventory ResetAll"
    lappend LesUsages "BlastDatabaseInventory Usage"
    set LesUsages [lsort -unique $LesUsages] 
    set BDI(Usage,) [join $LesUsages "\n"]
    
    return [BlastDatabaseInventory $Qui $Quoi]
}