#rR gscope_orthoinspector.tcl
#rR C'est ici qu'on gère les 10 000 000 de blast que nécessite OrthoInspector V3 

proc OiMiseEnPlace {{Domaine ""}} {
    FaireLire "Attention cette procédure n'est qu'un pense bête ... "
    FaireLire "Il vaut mieux la lancer en ligne de commande car il fat pouvoir faire setgscoperr CeQuIlFaut"
    FaireLire "Mais il est facile de la modifer pour q'elle marche sous setgscoperr Zero ;-) "
    exit

    if {$Domaine==""} { set Domaine "Qfo" }            ; #rR en exemple pour ce qui suit

    #rR si Domaine est Qfo et le repertoire du genome sera /genomics/link/OIQ (ceci doit trainer dans OiDomain ...)

    # setgscoperr OIQ           ( il faudrait faire cette partie explicitement en étant en setgscoperr Zero)
    #   Il cree le répertoire /gstock/OIQ et le lien dans /genomics/link)
    #   Puis il faut y recopier le beton/miniconfig de OIA et le corriger (en y mettant OIQ et OnTraiteLike QfoProteome)
    #     et y recopier le fiches/format_orf_numbering de OIA et le corriger
    # Yannis a mis les protéomes en /genomics/link/OrthoInspector/$Domaine
    # Attention de faire les proteomes avec OiCodeForDomain après avoir déposé BlackList.txt dans /genomics/link/OrthoInspector/$Domaine

    # setgscoperr Zero
    # gscope puts OiCodeForDomain $Domaine ListOf OX   ; #rR va créer les proteomes dans Notabene en tenant compte de la BlackList.txt
    # gscope puts OiCreateOrganismXml $Domaine         ; #rR va créer le fichier Xlm pour la base OrthoInpector

    # ??? RefaireLesProteomesNonUniprotStandard        ; #rR peut-être pas nécessaire pour Qfo
    # gscope puts CreeBlastDatabaseWithOiCode $Domaine ; #rR on y crée la banque blast en utilisant OiCodeForDomain et la BlackList.txt de NotaBene
    # Faire aussi le lien /blast/orthoinspector/$Domain /genomics/link/OIQ/blastpdatabase
    # setgscoperr OIQ                                  ; #rR à partie de là il connait OiDomain car dans beton/minicofig
    # gscope puts OiSplit                              ; #rR on decoupe par organisme ... sauf pour les Eukaryota (1100 paquet de 10 000)
                                                         #rR   on aurait d'ailleurs mieux fait de découper par les 722 orgas Euka aussi 
    # gscope puts WIW ListOf OX                        ; #rR pour voir Who Is Where


    #rR Et pour les blast en Grillade ;)
    gscope Blastong                                    ; #rR par défaut max 4
    gscope Blastong +2                                 ; #rR pour en rajouter 2 quelque soit le nombre qui tournent déjà
    gscope Blastonh                                    ; #rR h pour HPC ou Hotdog
    gscope Blastonl +2 "" OIQ27, OIQ33                 ; #rR on rajoute explicitement ces deux là


    #rR Quand les blast sont faits c'est à dire qu'ils sont tous dasn les poeles
    AuCongelo
    PiqueAssiette
    MissBlast
    
    TaxonomyDuBlastPourTous     ; #rR peut être fait par le web ... Gstore

    CreeTaxoblaWithMyMissBlast  ; #rR On y met la ligne du propre prottfa pour qu'il se voit lui-même

}

proc LengthReport {{Qui ""} {Quoi ""}} {
    global LengthReport

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

    set LengthReportDir "/genomics/link/LengthReport"

    foreach Domain [list Archaea Bacteria Eukaryota Virus Qfo] {
	NousAllonsAuBoulot $LengthReportDir/$Domain
	set LesPng [lsort [glob -nocomplain "*.png"]]
	foreach Png $LesPng {
	    set Filename $LengthReportDir/$Domain/$Png
	    if { ! [regexp {_([0-9]+).png$} $Png Match OX]} { continue }
	    lappend LengthReport(ListOf,OX) $OX
	    lappend LengthReport($Domain,ListOfOX) $OX
	    lappend LengthReport(ListOf,Filename) $Filename
	    set LengthReport($OX,Filename)        $Filename
	    set LengthReport($OX,Filename)        $Filename
	    if { ! [regexp {^([^_]+)_} $Png Match OiCode]} {
		Espionne "Ca merde pour $Png"
		continue
	    }
	    regsub {^([^_]+)_} $Png "" Reste
	    regsub  {_([0-9]+).png$} $Reste "" OS
	    set LengthReport($OX,OiCode) $OiCode
	    set LengthReport($OX,OS) $OS
	    set LengthReport($OS,OX) $OX
	}
	OnRevientDuBoulot
    }
    return [LengthReport $Qui $Quoi]
}

proc TaxMemo {{Qui ""} {Quoi ""}} {
    if {[info exists TaxMemo($Qui,$Quoi)]}  { return $TaxMemo($Qui,$Quoi) }
    set R [Tax $Qui $Quoi]
    set TaxMemo($Qui,$Quoi) $R
    return $R
}

proc RangeTaxobla {Id LeTaxobla} {
    set Nom [PABsDuIdOuAc $Id]
    if {$Nom==""} { return "" }
    
    set FicTaxobla [GscopeFile $Nom taxobla]
    if {[file exists $FicTaxobla]} { return "" }

    if {[PasTouche "RangeTaxobla_$Nom"]} { return "" }

    file mkdir [GscopeFile "" taxobla]

    set LesIdSub {}
    set LesInfos {}
    foreach Ligne $LeTaxobla {
	lassign [split $Ligne "\t"] TaxId Query Subject PId AL MM GOpen Qstart Qend Sstart Send PN Score
	if {[regexp {\|} $Subject]} {
	    lassign [split $Subject "|"] Bank AcSub IdSub
	} else {
	    set Bank "xx"
	    set AcSub $Subject
	    set IdSub $Subject
	}
	lappend LesIdSub $IdSub
	lappend LesInfos $IdSub $AcSub $Bank $TaxId $PN $Score
    }
    set Ids [join $LesIdSub ","]
    set GQ [QuestionDeScience GeneQuid "ret UniprotData $Ids QY,+GN-,+DE-"]
    set LesQGD [split [string trim $GQ "\n"] "\n"]

    set Message "$Nom $Id [llength $LeTaxobla] [llength $LesIdSub] [llength $LesQGD]"
    Espionne $Message
    LogWscope $Message

    foreach {Q G D} $LesQGD {
	regsub "GN   "     $G "" G
	regsub "DE   "     $D "" D
	regsub {;.*$}      $G "" G
	regsub { *\{.*$}   $G "" G
	regsub {^[^=]+=}   $G "" G
	regsub {;.*$}      $D "" D
	regsub {^[^=]+=}   $D "" D
	regsub { *\{.*$}   $D "" D
	regsub -all {[\[\]]} $D "" D
	set GnDe($Q) $G
	set DeDe($Q) $D
    }
    set LeNew {}
    foreach {IdSub AcSub Bank TaxId PN Score} $LesInfos {
	set Organisme [TaxMemo $TaxId Name]
	set Orga $Organisme
	if {[string length $Orga]>36} { set Orga "[string range $Orga 0 36]..." }
	set GN $GnDe($IdSub)
	set DE $DeDe($IdSub)
	set Info "$IdSub $AcSub $DE GN=$GN OS=$Organisme TAXID=$TaxId BANK=$Bank"
	lappend LeNew [format "%7s\t%6s\t%8s\t%-40s\t%s" $PN $Score $TaxId $Orga $Info]  ;#rR rajout de score 2015/06/08
    }
    set Fichier [SauveLesLignes $LeNew dans [GscopeFile $Nom taxobla]]
    if {0 && [regexp {1$} $Fichier]} { Espionne $Fichier }

    FinPasTouche "RangeTaxobla_$Nom"
    return $Fichier
}

proc TaxoblaDuCongelo LesOP {
    if {[regexp {[ ,\n\t]} $LesOP]} {
	regsub -all {[ ,\n\t]+} $LesOP "," LesOP
	set LesOP [split [string trim $LesOP ","] ","]
    }
    set PreviousId ""
    set LeTaxobla {}
    set Ieme 0
    set Keme 0
    set LesFicTax {}
    foreach OP $LesOP {
	if {[file exists "[RepertoireDuGenome]/$OP"]} {
	    set g [open "[RepertoireDuGenome]/$OP" "r"]
	    Espionne "j'utilise le dezipé"
	} else {
	    set Gz [DernierGz $OP]
	    set g [open $Gz "r"]
	    zlib push gunzip $g
	}
	while {[gets $g Ligne]>=0} {
	    if {[incr Keme]%10000==1} { Espionne $Keme }
	    if {[string index $Ligne 0]=="#"} { continue }
	    scan $Ligne "%s %s" BAI Subject
	    set Id [lindex [split $BAI "|"] end]
	    if {$PreviousId!="" && $Id!=$PreviousId} {
		if {[info exists DejaVu]} { unset DejaVu }
		if {[incr Ieme]%100==1} { LogWscope $Ieme }
		if {     $Ieme % 10==1} { Espionne $Ieme }
		set FicTax [RangeTaxobla $PreviousId $LeTaxobla]
		if {$FicTax!=""} { lappend LesFicTax $FicTax }
		set LeTaxobla {}
	    }
	    set PreviousId $Id
	    set IdSubject [lindex [split $Subject "|"] end]
	    #set OX [QuestionDeScience OI "ret WiwOxFrom $IdSubject"]
	    set OX [WiwOxFrom $IdSubject]
	    if {[info exists DejaVu($OX)]} { continue }
	    set DejaVu($OX) $IdSubject
	    lappend LeTaxobla "$OX\t$Ligne"
	}	    
	close $g
    }
    if {$LeTaxobla!={}} { RangeTaxobla $PreviousId $LeTaxobla }
    return $LesFicTax
}

proc ScienceOiDeMonDomaine {} {
    set Science "OI"
    set Projet [file tail [RepertoireDuGenome]]
    if {$Projet=="OI"} { return "OI" }
    if {$Projet=="OIA"} { return "OIA" }
    if {$Projet=="OIB"} { return "OIB" }
    if {$Projet=="OIE"} { return "OI" }
    if {$Projet=="OIV"} { return "OIV" }
    if { ! [regexp {^([A-Z])[A-Z][a-z]+} $Projet Match Initial]} { return $Science }
    set  Initial [string index $Projet 0]
    if {$Initial=="A"} { set Science "OIA" }
    if {$Initial=="B"} { set Science "OIB" }
    if {$Initial=="E"} { set Science "OI"  }
    if {$Initial=="V"} { set Science "OIV" }
    return $Science
} 

proc TaxoblaFromOi {} {
    set OX [NotreOX]
    set Science [ScienceOiDeMonDomaine]
    Espionne "QuestionDeScience $Science ret WIW $OX ListOfOP"
    set LesOP [QuestionDeScience $Science "ret WIW $OX ListOfOP"]
    Espionne $LesOP
    LogWscope $LesOP
    return [TaxoblaDuCongelo $LesOP]
}

proc LesBlastsDuCongelo {} {
    set OiCode [PreFixe]
    set Domain [OiDomainFromOiCode $OiCode]
    set OX     [NotreOX]
    set Science [ScienceOiDeMonDomaine]
    set LesOP  [QuestionDeScience $Science "ret WIW $OX ListOfOP"]
    return $LesOP
}

proc BlastFromOi Nom {
    #rR marche pas ........ je fais autrement voir TaxoblaDuCongelo
    #rR attention Nom represent ici un PAB du projet courant pour lequel on veut chercher le blast dans le congelo corespondant 
    set LesOP [LesBlastsDuCongelo]
    set LesGz [MissBlast $LesOP "GetAllGz"]
    foreach Gz $LesGz {
	
    }
}

proc DernierGz Nom {
    set Congelo [DernierCongelo $Nom]
    set Assiette "$Congelo/assiette"
    if {[FileAbsent $Assiette]} {
	set Message "No assiette $Assiette"
	Espionne $Message
	return ""
    }
    set Gz "$Assiette/output_formated.gz"
    if {[FileAbsent $Gz]} {
	set Gz "$Assiette/output.gz"
    }
    if {[FileAbsent $Gz]} {
	Espionne "No $Gz"
	return ""
    }
    return $Gz
}

proc DernierePoele {Nom {GetWhat ""}} {
    set LesPoeles [lsort [glob -nocomplain "/tempor/grid/poeles/$Nom*"]]
    if {$LesPoeles=={}} { return "" }
    if {[string equal -nocase "GetAll" $GetWhat]} { return $LesPoeles }
    return [lindex $LesPoeles end]
}

proc DernierCongelo {Nom {GetWhat ""}} {
    set LesCongelos [lsort [glob -nocomplain "/tempor/grid/congelo/$Nom*"]]
    if {$LesCongelos=={}} { return "" }
    if {[string equal -nocase "GetAll" $GetWhat]} { return $LesCongelos }
    return [lindex $LesCongelos end]
}

proc NettoieCongelo {} {
    set LesAvariesAFaire {}
    foreach Nom [ListeDesPABs] {
	set LesC [DernierCongelo $Nom GetAll]
	if {[llength $LesC]<=1} { continue }
	EspionneL $LesC
	LConcat LesAvariesAFaire [lrange $LesC 0 end-1]
    }
    Espionne ".............................. LesAvaries a virer dans la poubelle"
    EspionneL $LesAvariesAFaire
    if { ! [OuiOuNon "Je vire ces avaries ?"]} { return "" }
    set LesFaits {}
    foreach A $LesAvariesAFaire {
	#exec mv $A /tempor/grid/poubelle/
    }
    return $LesFaits
}

proc AuCongelo {{Action ""}} {
    set LesAvaries {}
    set LesAvariesAFaire {}
    set LesAFaire {}
    foreach Nom [ListeDesPABs] {
	set P [DernierePoele $Nom]
	set C [DernierCongelo $Nom]
	if {$P==""} { continue }
	Espionne "$Nom = $P = $C ="
	if {$C==""} {
	    Espionne "$P"
	    lappend LesAFaire $P
	}
	if {$C!="" && ([set TC [file mtime $C]] < [set TP [file mtime $P]])} {
	    lappend LesAFaire $P
	    lappend LesAvaries "$Nom [Date Nice $TC] [Date Nice $TP]"
	    lappend LesAvariesAFaire $C
	}
    }
    Espionne ".............................. LesAvaries"
    EspionneL $LesAvaries
    Espionne ".............................. LesAFaire"
    EspionneL $LesAFaire
    if { ! [OuiOuNon "Je congele effectivement ?"]} { return "" }
    set LesFaits {}
    foreach A $LesAvariesAFaire {
	exec mv $A /tempor/grid/poubelle/
    }
    foreach P $LesAFaire {
	exec mv $P /tempor/grid/congelo/
	lappend LesFaits "/tempor/grid/congelo/[file tail $P]"
    }
    return $LesFaits
}

proc MyMissBlast {} {
    set Science [ScienceOiDeMonDomaine]
    set LesOI [QuestionDeScience $Science "ret WIW [NotreOX] ListOfOP"]
    set RepMB "[GscopeDatabaseDir $Science]/missblast/"
    set MMB {}
    foreach OI $LesOI {
	set FichierMissBlast "$RepMB/$OI"
	if {[FileAbsent $FichierMissBlast]} { continue }
	foreach Ligne [LesLignesDuFichier $FichierMissBlast] {
	    scan $Ligne "%s %s" Id Seq
	    set Nom [NIAG $Id N]
	    if {$Nom==""} { continue }
	    lappend MMB "$Nom $Ligne"
	}
    }
    return $MMB
}

proc MissBlast {{LesNomsVoulus ""} {GetWhat ""}} {
    #rR J'ai greffé l'extraction des Gz pour LesNomsVoulus si GetWhat = GetAllGz
    #rR On essaie de detecter les séquences trop petites pour se trouver elles-même

    if { ! [OnTraite OI]} { }


    set LesSize {}
    set LeRetour {}

    if {[regexp "\," $LesNomsVoulus]} { set LesNomsVoulus [split $LesNomsVoulus ","] }

    if {$LesNomsVoulus==""} { set LesNomsVoulus [ListeDesPABs] }
    NousAllonsAuBoulot "/tempor/grid/congelo"
    set LesGz {}
    foreach Nom $LesNomsVoulus {
	if {$GetWhat=="" && [PasTouche "MissBlast_$Nom"]} { continue }
	set Congelo [DernierCongelo $Nom]
	set Assiette "$Congelo/assiette"
	if {[FileAbsent $Assiette]} {
	    set Message "No assiette $Assiette"
	    Espionne $Message
	    lappend LesManquants $Message
	    continue
	}
	set Gz "$Assiette/output_formated.gz"
	if {[FileAbsent $Gz]} {
	    set Gz "$Assiette/output.gz"
	}
	if {[FileAbsent $Gz]} {
	    set Message "I didn't find $Gz"
	    Espionne $Message
	    lappend LesManquants $Message
	    FinPasTouche "MissBlast_$Nom"
	    continue
	}

	if {$GetWhat=="GetAllGz"} { lappend LesGz $Gz ; continue }

	set FichierMissBlast "[RepertoireDuGenome]/missblast/$Nom"
	if {[file exists $FichierMissBlast] && [file mtime $Gz]<[file mtime $FichierMissBlast]} {
	    Espionne "$FichierMissBlast existe deja et est plus récent que le Gz"
	    FinPasTouche "MissBlast_$Nom"
	    continue
	}
	set N [file size $Gz]
	lappend LesSize "$N $Nom"
	set Queries [split [exec zcat $Gz | cut -f 1 | grep -v "#" | sort -u] "\n"]
	Espionne "[llength $Queries] Queries lues dans $Gz"
	set LesIdDuBlast {}
	foreach Q $Queries {
	    set Id [lindex [split $Q "|"] end]
	    lappend LesIdDuBlast $Id
	}
	set LesIdDuBlast [lsort $LesIdDuBlast]
	set NbIdDuBlast [llength $LesIdDuBlast]
	set NbQueries $NbIdDuBlast
	
	set FichierOi "[RepertoireDuGenome]/oip/$Nom"
	set F [open $FichierOi "r"]

	set LesIdDuOi {}
	unset -nocomplain SeqDe
	set I 0
	set K 0
	while {[gets $F Ligne]>=0} {
	    if {[regexp "^>" $Ligne]} {
		scan [string range $Ligne 1 end] "%s" BAI
		set IdDuOi [lindex [split $BAI "|"] end]
		lappend LesIdDuOi $IdDuOi
		set SeqDe($IdDuOi) ""
		if {$I%1000==0} { Espionne "$I $Ligne" }
		incr I
		continue
	    }
	    if {$IdDuOi=="GBI00002920_3311"} { Espionne $Ligne }
	    append SeqDe($IdDuOi) $Ligne
	}
	close $F
	Espionne [llength $LesIdDuOi]
	set LesIdDuOi [lsort -unique $LesIdDuOi]
	set NbIdDuOi [llength $LesIdDuOi]
	
	Espionne "$Nom $NbIdDuBlast $NbIdDuOi"
	Espionne [lrange $LesIdDuBlast 0 10]
	Espionne [lrange $LesIdDuOi    0 10]
	set LesPerdus [ListsComplement $LesIdDuOi $LesIdDuBlast]
	Espionne $LesPerdus
	set LesAccessSeq {}
	foreach Perdu $LesPerdus {
	    lappend LesAccessSeq "$Perdu $SeqDe($Perdu)"
	}
	SauveLesLignes $LesAccessSeq dans "[RepertoireDuGenome]/missblast/$Nom"
	AppendAuFichier "[RepertoireDuGenome]/fiches/NbQueriesDansOiEtBlast.txt" "$Nom $NbIdDuOi $NbQueries"
	
	lappend LesNbQueries "$NbQueries $Nom"
	if {$N<100} {
	    set Message "$Nom n'a que $N octets"
	    Espionne $Message
	    lappend LesManquants $Message
	} else {
	    Espionne "$Nom $Gz $N"
	}
	FinPasTouche "MissBlast_$Nom"
    }
    if {$GetWhat=="GetAllGz"} { return $LesGz }
    return $LeRetour
}

proc PiqueAssiette {{Plateau ""} {TaillePaquet ""} {GetWhat ""}} {
    #rR Permet de regrouper sur un plateau les assiettes du congelo par paquet
    #rR Si on met TaillePaquet 1 chaque OIB1234 est dans OIB1234-OIB1234
    #rR Si on met TaillePaquet 0 tous les OIBxxxx sont dans OIB0001-OI3863

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

    if {$Plateau!="" && ! [regexp "/" $Plateau]} { set Plateau "/tempor/grid/plateau/$Plateau" }
    if {$Plateau==""} {	set Plateau "/tempor/grid/plateau/OI[OiDomain]" }
    if {$GetWhat=="GetPlateau"} { return $Plateau }
    file mkdir $Plateau
    NousAllonsAuBoulot $Plateau
    set LesManquants {}
    set MaPlage ""
    set I 0
    foreach Nom [ListeDesPABs] {
	if {$TaillePaquet==0} {
	    set Plage 1
	} else {
	    set Plage [expr {$I/$TaillePaquet}]
	}
	set PlageDe($Nom) $Plage
	lappend LesNomsDeLaPlage($Plage) $Nom
	incr I
    }
    set LesSize {}
    set LesNbQueries {}
    foreach Nom [ListeDesPABs] {
	set Plage $PlageDe($Nom)
	set Deb [lindex $LesNomsDeLaPlage($Plage) 0]
	set Fin [lindex $LesNomsDeLaPlage($Plage) end]
	set DebFin "$Deb-$Fin"
	set MonPlateau ${Plateau}/$DebFin
	file mkdir $MonPlateau
	NousAllonsAuBoulot $MonPlateau
	set LesCongelo [lsort [glob -nocomplain "/tempor/grid/congelo/$Nom*"]]
	if {$LesCongelo=={}} { continue }
	set Congelo [lindex $LesCongelo end]
	set Assiette "$Congelo/assiette"
	if {[FileAbsent $Assiette]} {
	    set Message "No assiette $Assiette"
	    Espionne $Message
	    lappend LesManquants $Message
	    OnRevientDuBoulot
	    continue
	}
	set Gz "$Assiette/output_formated.gz"
	if {[FileAbsent $Gz]} {
	    set Gz "$Assiette/output.gz"
	}
	if {[FileAbsent $Gz]} {
	    set Message "I didn't find $Gz"
	    Espionne $Message
	    lappend LesManquants $Message
	    OnRevientDuBoulot
	    continue
	}
	if {$GetWhat=="Test"} {
	    set FichierDeglingue "[RepertoireDuGenome]/deglingues/$Nom"
	    if {[file exists $FichierDeglingue]} {
		Espionne "$FichierDeglingue existe deja" 
		continue
	    }
	    set N [file size $Nom]
	    lappend LesSize "$N $Nom"
	    set Queries [split [exec zcat $Gz | cut -f 1 | sort -u] "\n"]
	    Espionne "[llength $Queries] Queries lues dans $Gz"
	    set LesIdDuBlast {}
	    foreach Q $Queries {
		set Id [lindex [split $Q "|"] end]
		lappend LesIdDuBlast $Id
	    }
	    set LesIdDuBlast [lsort $LesIdDuBlast]
	    set NbIdDuBlast [llength $LesIdDuBlast]
	    set NbQueries $NbIdDuBlast
	    
	    set FichierOi "[RepertoireDuGenome]/oip/$Nom"
	    set LesBAI [split [exec grep " " $FichierOi] "\n"] 
	    Espionne "[llength $LesBAI] sequences lues dans $FichierOi"
	    set LesIdDuOi {}
	    foreach BAI $LesBAI {
		scan $BAI "%s" BAI
		set IdDuOi [lindex [split $BAI "|"] end]
		lappend LesIdDuOi $IdDuOi
	    }
	    set LesIdDuOi [lsort -unique $LesIdDuOi]
	    set NbIdDuOi [llength $LesIdDuOi]

	    Espionne "$Nom $NbIdDuBlast $NbIdDuOi"
	    Espionne [lrange $LesIdDuBlast 0 10]
	    Espionne [lrange $LesIdDuOi    0 10]
	    set LesPerdus [ListsComplement $LesIdDuOi $LesIdDuBlast]
	    Espionne $LesPerdus
	    set LesAccessSeq [QueLaSequenceDesBanquesDeLaListe $LesPerdus]
	    SauveLesLignes $LesAccessSeq dans "[RepertoireDuGenome]/deglingues/$Nom"
	    AppendAuFichier "[RepertoireDuGenome]/fiches/NbQueriesDansOiEtBlast.txt" "$Nom $NbIdDuOi $NbQueries"
	    
	    lappend LesNbQueries "$NbQueries $Nom"
	    if {$N<100} {
		set Message "$Nom n'a que $N octets"
		Espionne $Message
		lappend LesManquants $Message
	    } else {
		Espionne "$Nom $Gz $N"
	    }
	} else {
	    set DoIt 0
	    if {[FileAbsent $Nom]} {
		Espionne "$Nom n'existe pas encore je le crée"
		set DoIt 1
	    }
	    if {[file exists $Nom] && [file type $Nom]=="link" && [file readlink $Nom]!=$Gz} {
		Espionne "Redéfinition du lien $Gz pour $Nom"
		set DoIt 1
	    }
	    Espionne "exec ln -sf $Gz $Nom"
	    if {$DoIt} { exec ln -sf $Gz $Nom }
	} 
	OnRevientDuBoulot
    }
    set LesSize [lsort -decreasing -index 0 -integer $LesSize]
    EspionneL $LesSize
    set LesNbQueries [lsort -decreasing -index 0 -integer $LesNbQueries]
    EspionneL $LesNbQueries
    set LeRetour {}
    if {$LesManquants!={}} { LConcat LeRetour $LesManquants } 
    return $LeRetour
}


proc PlateauOkOld {{Plateau ""}} {
    set Plateau [PiqueAssiette $Plateau "GetPlateau"]
    set Ok "Tout est bon"
    set Min 9999999999999
    set Max -1
    set NbPresents 0
    foreach Nom [ListeDesPABs] {
	set Gz $Plateau/$Nom
	if {[FileAbsent $Gz]} {
	    set Ok "Il en manque :'("
	    FaireLire "$Gz n'existe pas !!!!"
	    Espionne "$Nom !!!!!!!!!!!!!!!!!!!!!!!! n'existe pas"
	    continue
	}
	incr NbPresents
	set N [file size $Gz]
	Espionne "$Nom $N"
	set Min [Mini $Min $N]
	set Max [Maxi $Max $N]
    }
    Espionne "Il y a $NbPresents Gz dont la taille varie de $Min à $Max"
    return $Ok
}

proc PiqueAssietteOld {{Plateau ""} {GetWhat ""}} {
    if {$Plateau!="" && ! [regexp "/" $Plateau]} { set Plateau "/tempor/grid/plateau/$Plateau" }
    if {$Plateau==""} { set Plateau "/tempor/grid/plateau/OIEukaryota" }
    if {$GetWhat=="GetPlateau"} { return $Plateau }
    file mkdir $Plateau
    NousAllonsAuBoulot $Plateau
    set LesManquants {}
    foreach Nom [ListeDesPABs] {
	set LesCongelo [lsort [glob -nocomplain "/tempor/grid/congelo/$Nom*"]]
	if {$LesCongelo=={}} { continue }
	set Congelo [lindex $LesCongelo end]
	set Assiette "$Congelo/assiette"
	if {[FileAbsent $Assiette]} {
	    set Message "No assiette $Assiette"
	    Espionne $Message
	    lappend LesManquants $Message
	    continue
	}
	set Gz "$Assiette/output_formated.gz"
	if {[FileAbsent $Gz]} {
	    set Gz "$Assiette/output.gz"
	}
	if {[FileAbsent $Gz]} {
	    set Message "I didn't find $Gz"
	    Espionne $Message
	    lappend LesManquants $Message
	    continue
	}
	Espionne $Gz
	exec ln -sf $Gz $Nom 
    }
    OnRevientDuBoulot
    set LeRetour {}
    if {$LesManquants!={}} { LConcat LeRetour $LesManquants } 
    return $LeRetour
}

proc TempsExecutionDesBlast {{GetWhat ""} {Qui ""} {Mi ""} {Ma ""}} {
    #rR Je prends la date de création du fasta et du blast dans oif/OI1234/fasta et oif/OI1234/blast
    if {$Mi==""} { set Mi -1 }
    if {$Ma==""} { set Ma 9999999 }
    if {$Qui==""} { set Qui [lsort [glob -nocomplain "[RepertoireDuGenome]/oif/OI*"]] }
    set N 0
    set Total 0
    set LesTemps {}
    set Min 999999
    set Max -1
    set NbNom 0
    foreach Nom $Qui {
	set Nom [file tail $Nom]
	incr NbNom
	Espionne $Nom
	NousAllonsAuBoulot "[RepertoireDuGenome]/oif/$Nom"
	foreach B [lsort [glob -nocomplain "blast/*"]] {
	    set S [file size $B]
	    if {$S==0} { continue }
	    set Q [file tail $B]
	    set F "fasta/$Q"
	    set Deb [file mtime $F]
	    set Fin [file mtime $B]
	    set Duree [expr $Fin-$Deb]
	    if {$Duree<$Mi} { continue }
	    if {$Ma<$Duree} { continue }
	    incr N
	    incr Total $Duree
	    lappend LesTemps $Duree
	    set Min [Mini $Min $Duree] 
	    set Max [Maxi $Max $Duree] 
	}
	OnRevientDuBoulot
    }
    set M [expr $Total/$N]
    set JoursTotalLbgi [expr $Total/(60*60*24)]
    set JoursTotal [expr 10000000*$JoursTotalLbgi/$N]
    set AnsTotal [expr $JoursTotal/365]
    set Message "Sur $N blast faits Min $Min  Moyenne $M   Max $Max    Temps total $JoursTotalLbgi jours au lbgi ... et en extraolant $JoursTotal jours pour les 10 000 000 soit $AnsTotal ans !"
    Espionne $Message
    set LesTemps [lsort -integer $LesTemps]
    
    if {[regexp -nocase "Histo" $GetWhat]} {
	lassign [Histogramme $LesTemps "GetLists"] LesN LesY
	Graphe $LesN $LesY "" "" 1200 1200
    }
    if {[regexp -nocase "Graphe" $GetWhat]} {
	Graphe $LesTemps "" "" "" 1200 1200
    }
    return $Message
}

proc WIWB {{Qui ""} {Quoi ""}} {
    #rR Who Is Where in the Blast
    global WIWB

    if {$Quoi==""} { 
	if {[EstUnPAB $Qui]} {
	    set Quoi "Queries"
	} else {
	    set Quoi "Nom"
	}
    }

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

    set Fichier "[RepertoireDuGenome]/fiches/WhereIsCodeOrga.txt"
    foreach Ligne [LesLignesDuFichier $Fichier] {
	scan $Ligne "%s" Nom
	lappend WIWB(ListOf,Nom) $Nom
	set LesQuery [lrange [split $Ligne " "] 1 end]
	set WIWB($Nom,Queries) $LesQuery
	foreach Query $LesQuery {
	    lappend WIWB($Query,Nom) $Nom
	    lappend WIWB(ListOf,Queries) $Query
	}
    }
    set WIWB(ListOf,Queries) [lsort -unique $WIWB(ListOf,Queries)]
    return [WIWB $Qui $Quoi]
}

proc OiOrgsFromBlast Fichier {
    foreach Nom [ListeDesPABs] {
	if {[WIWB $Nom Queries]!=""} { continue }
	set LesPoeles [lsort [glob -nocomplain "/tempor/grid/poeles/$Nom*"]]
	if {$LesPoeles=={}} { continue }
	set Poele [lindex $LesPoeles end]
	set Assiette "$Poele/assiette"
	if {[FileAbsent $Assiette]} {
	    Espionne "No assiette $Assiette"
	    conitinue
	}
	set Gz "$Assiette/output_formated.gz"
	if {[FileAbsent $Gz]} {
	    set Gz "$Assiette/output.gz"
	}
	if {[FileAbsent $Gz]} {
	    Espionne "I didn't find $Gz"
	    continue
	}
	Espionne $Gz
	set LesQuery [exec zcat $Gz | grep -v "#" | cut -f 1 | cut -d _ -f 2-3 | cut -d _ -f 2 | uniq ]
	Espionne $LesQuery
	set LesQuery [ListeSansDoublon $LesQuery]
	AppendAuFichier "[RepertoireDuGenome]/fiches/WhereIsCodeOrga.txt" "$Nom [join $LesQuery { }]" 
    }
}

proc LesLignesDuGz Fichier {
    set f [open $Fichier]
    zlib push gunzip $f
    set LesLignes {}
    while {[gets $f Ligne]>=0} {
	lappend LesLignes $Ligne
    }
    close $f
    return $LesLignes
}

proc OiCompressBlastonl {} {
    NousAllonsAuBoulot "[RepertoireDuGenome]/oif"
    set LesCopies {}
    foreach Nom [lsort [glob -nocomplain "[PreFixe]*"]] {
	NousAllonsAuBoulot "$Nom/blast"
	set LesBlast [exec ls -t]
	if {[set N [llength $LesBlast]]<10000} {
	    if { ! [OuiOuNon "Il n'y a que $N blast pour $Nom. Je copie quand même ?" 0] } {
		OnRevientDuBoulot
		continue
	    }
	}
	set Dernier [lindex $LesBlast end]
	set Date [Date "" [file mtime $Dernier]]
	set Assiette "/tempor/grid/poeles/${Nom}_${Date}/assiette"
	if {[file exists "$Assiette/output.gz"]} {
	    if { ! [OuiOuNon "$Assiette already exists. Do I overwrite ?" 0]} {
		OnRevientDuBoulot
		continue
	    }
	}
	file mkdir $Assiette
	Espionne "$Nom $Assiette"
	exec sh -c "cat * | pigz -9 -p 18 > $Assiette/output.gz"
	lappend LesCopies $Assiette
	OnRevientDuBoulot
    }
    OnRevientDuBoulot
    return $LesCopies
}


proc ClearPassePlatDansFiches {} {
    NousAllonsAuBoulot "[RepertoireDuGenome]/fiches"
    set LesClear {}
    set Previous ""
    foreach PP [lsort -decreasing [glob -nocomplain PassePlat*]] {
	if { ! [regexp {^PassePlat_([^_]+)_([0-9]+)$} $PP Match Nom Date]} {
	    set Previous ""
	    continue
	}
	if {$Nom==$Previous} {
	    lappend LesClear $PP
	}
	set Previous $Nom
    }
    set LesClearAFaire [AfficheListe $LesClear "AvecRetour" "Do I clear these"]
    foreach PP $LesClearAFaire {
	file delete $PP
    }
    OnRevientDuBoulot
    return $LesClearAFaire
}

proc ClearPassePlat {} {
    NousAllonsAuBoulot [RepertoireDuGenome]
    set LesClear {}
    set Previous ""
    foreach PP [lsort -decreasing [glob -nocomplain PassePlat*]] {
	if { ! [regexp {^PassePlat_([^_]+)_([0-9]+)$} $PP Match Nom Date]} {
	    set Previous ""
	    continue
	}
	if {$Nom==$Previous} {
	    lappend LesClear $PP
	}
	set Previous $Nom
    }
    set LesClearAFaire [AfficheListe $LesClear "AvecRetour" "Do I clear these"]
    foreach PP $LesClearAFaire {
	file delete $PP
    }
    OnRevientDuBoulot
    return $LesClearAFaire
}

proc BlastLocalInventaire {} {
    NousAllonsAuBoulot [RepertoireDuGenome]
    set TotN 0
    set TotF 0
    set TotB 0
    foreach Poeloc [lsort [glob -nocomplain -type d "oif/*"]] {
	set Nom [file tail $Poeloc]
	set LesF [glob -nocomplain "$Poeloc/fasta/*"]
	set LesB [glob -nocomplain "$Poeloc/blast/*"]
	set NbF [llength $LesF]
	set NbB [llength $LesB]
	incr TotN 1
	incr TotF $NbF
	incr TotB $NbB
	set Compte [format "%5s %-8s %5d fasta  %5d blast already done" " " $Nom $NbF $NbB] 
	lappend LeMessage $Compte
    }
    lappend LeMessage ""
    lappend LeMessage [format "%5d %-8s %5d fasta  %5d blast already done" $TotN "OIs" $TotF $TotB] 

    OnRevientDuBoulot
    set Message [join $LeMessage "\n"]
    return $Message
}


proc BlastLocalPourOiEnProcessSepare {Nom {Nb ""}} {
    #rR On exécute dans un process gscope séparé pour reprendre la main tout de suite
	if {$Nb==""} { set Nb 1 }
	set Host [Hostname]
	set LesCourants {}
	foreach i [NombresEntre 1 $Nb] {
		set Cle [pid][NomDe ""]
		set Courant ${Nom}_${Host}_${Cle}
		Espionne "tcsh -c \"setgscoperr OI -q ; gscope -notk puts BlastLocalPourOi $Nom >& [RepertoireDuGenome]/oif/log/$Courant.log\" &"
		exec tcsh -c "setgscoperr OI -q ; gscope -notk puts BlastLocalPourOi $Nom >& [RepertoireDuGenome]/oif/log/$Courant.log" &
		lappend LesCourants $Courant
	}
	return $LesCourants
}

proc BlastLocalPourOi {{Nom ""}} {
    #rR On 
    set Oif         "[RepertoireDuGenome]/oif"                ; file mkdir $Oif
    set OifNom      "$Oif/$Nom"                               ; file mkdir $OifNom
    set OifNomFasta "$OifNom/fasta"                           ; file mkdir $OifNomFasta
    set OifNomBlast "$OifNom/blast"                           ; file mkdir $OifNomBlast

    set Fastas [GscopeFile $Nom "oip"]
    Espionne $Fastas
    if {[FileAbsent $Fastas]} { return "Error. No fasta file available for $Nom\n$Fastas" }
    foreach Access [LaSequenceDuTFAs $Fastas "LaListeDesAccess"] {
	set Id $Access
	if {[regexp "\|" $Access]} { lassign [split $Access "|"] B A Id }

	set FicFasta "$OifNomFasta/$Id"
	set FicBlast "$OifNomBlast/$Id"
	if {[file exists $FicBlast]} { continue }
	if {[PasTouche "Blastonl$Nom/$Id"]} { continue }
	set TFA [LaSequenceDuTFAs $Fastas $Access]
	Sauve $TFA dans $FicFasta
	exec /biolo/blast/bin/blastp -word_size 3 -evalue 1.0e-5 -max_target_seqs 5000 -comp_based_stats 2 -query $FicFasta -out $FicBlast -db /blast/OrthoInspector/OiEukaryota -outfmt "7 qseqid sseqid pident length mismatch gapopen qstart qend sstart send evalue bitscore" -num_threads 1
	FinPasTouche "Blastonl$Nom/$Id"
    }
    return $OifNomBlast
}

proc HotdogPourOi {{ProjName ""} {FastaFile ""} {BlastDatabase ""} {OptionsBlast ""}} {

    if {$ProjName==""}      { set ProjName "BlastonhOi" }
    if {$FastaFile==""}     { set FastaFile [GscopeFile $ProjName "oip"] }
    if {$BlastDatabase==""} { set BlastDatabase [LocaliseBlastPDataBase] }
    #f {$OptionsBlast==""}  { set OptionsBlast "-W 3 -e 1.0e-5 -v 5000 -b 5000 -K 0 -F F -C 2" }
    if {$OptionsBlast==""}  { set OptionsBlast "-word_size 3 -evalue 1.0e-5 -max_target_seqs 5000 -comp_based_stats 2" }

    set PassePlat ""
    if {[ValidBlastDatabaseForHotdog $BlastDatabase]} {
	set ProjNameWithDate "${ProjName}_[Date]"
	set DBSizeTxt [BlastDatabaseSize $BlastDatabase]
	scan $DBSizeTxt "%d" DBSize
	if {1} {
	    Espionne      "Grillade::creerPoeleBlastOiHpc ProjectName $ProjNameWithDate  Input $FastaFile  DB $BlastDatabase  DBsize $DBSize BlastOpts $OptionsBlast"
	    set PassePlat [Grillade::creerPoeleBlastOiHpc ProjectName $ProjNameWithDate  Input $FastaFile  DB $BlastDatabase  DBsize $DBSize BlastOpts $OptionsBlast]
	} else {
	    Espionne ""
	    set PassePlat "/tempor/grid/poeles/$ProjName"
	}
	if {[regexp -nocase "^Error" $PassePlat]} {
	    set Message "Error. Something is wrong with Hotdog. I got the error message $PassePlat"
	}
	#rR Tcl ne veut pas pointer si la cible n'existe pas.ON est obligé de faire un exec :("
	exec ln -sf "$PassePlat" "[RepertoireDuGenome]/PassePlat_$ProjNameWithDate"
	AppendAuFichier [Fiches PassePlat_$ProjNameWithDate] $PassePlat
	set Message "Warning. I launched Hotdog for $ProjName. Blast files will be available at $PassePlat" 
	return $Message
    } else {
	set Message "Error. Sorry the blast database '$BlastDatabase' is not a valid blast database for Grilladin"
    }
    return $Message
}

proc GrilladinPourOi {{ProjName ""} {FastaFile ""} {BlastDatabase ""} {OptionsBlast ""} {BlastallOrBlastplus ""}} {

    if {$BlastDatabase=="-"} { set BlastDatabase "" }
    if {$OptionsBlast =="-"} { set OptionsBlast "" }

    if {$BlastallOrBlastplus==""} { set BlastallOrBlastplus "Blastplus" }

    if {$ProjName==""}      { set ProjName "BlastongOi" }
    if {$FastaFile==""}     { set FastaFile [GscopeFile $ProjName "oip"] }
    if {$BlastDatabase==""} { set BlastDatabase [LocaliseBlastPDataBase] }
    if {$BlastallOrBlastplus=="Blastall"} {
	if {$OptionsBlast==""}  { set OptionsBlast "-W 3 -e 1.0e-5 -v 5000 -b 5000 -K 0 -F F -C 2" }
    } else {
	if {$OptionsBlast==""}  { set OptionsBlast "-word_size 3 -evalue 1.0e-5 -max_target_seqs 5000 -comp_based_stats 2" }
    }
    set PassePlat ""
    if {[ValidBlastDatabaseForGrilladin $BlastDatabase]} {
	set ProjNameWithDate "${ProjName}_[Date]"
	set DBSizeTxt [BlastDatabaseSize $BlastDatabase]
	if {$BlastallOrBlastplus=="Blastall"} {
	    scan $DBSizeTxt "%d %s %d %s" NbLetters letters DbSize sequences
	} else {
	    scan $DBSizeTxt "%d" DBSize
	} 
	Espionne      "Grillade::creerPoeleBlastOi ProjectName $ProjNameWithDate  Input $FastaFile  DB $BlastDatabase  DBsize $DBSize BlastOpts $OptionsBlast"
	set PassePlat [Grillade::creerPoeleBlastOi ProjectName $ProjNameWithDate  Input $FastaFile  DB $BlastDatabase  DBsize $DBSize BlastOpts $OptionsBlast]
	Espionne $PassePlat
	if {[regexp -nocase "^Error" $PassePlat]} {
	    set Message "Error. Something is wrong with Grilladin. I got the error message $PassePlat"
	}
	#rR Ici on fait DEUX choses : on crée un lien et on crée un fichier dans fiches ........................... c'est le lien qui est bon !
	#rR Tcl ne veut pas pointer si la cible n'existe pas :file link -symbolic "[RepertoireDuGenome]/passeplat" "$PassePlat/blastp"
	exec ln -sf "$PassePlat" "[RepertoireDuGenome]/PassePlat_$ProjNameWithDate"
	AppendAuFichier [Fiches PassePlat_$ProjNameWithDate] $PassePlat
	set Message "Warning. I launched Grilladin for $ProjName. Blast files will be available at $PassePlat" 
	return $Message
    } else {
	set Message "Error. Sorry the blast database '$BlastDatabase' is not a valid blast database for Grilladin"
    }
    return $Message
}

proc DoneBlastong {Nom} {
    return [DoneBlaston $Nom "g"]
}

proc DoneBlastonh {Nom} {
    return [DoneBlaston $Nom "h"]
}

proc DoneBlastonl {Nom} {
    return [DoneBlaston $Nom "l"]
}

proc DoneBlaston {Nom Ou} {
    PasTouche "DoneBlaston$Ou$Nom"
    set FiPat "[RepertoireDuGenome]/pastouche/Blaston$Ou$Nom"
    if {[file exists $FiPat]} {
	if {[catch {file delete $FiPat} Message]} { return "Error. $Message" }
    }
    return "$Nom state is now DoneBlaston$Ou"
}

proc ListBlastong {} {
}

proc Blastong {{MaxBlastong ""} {TestOnly ""} {LesNoms ""}} {
    #rR Blast On Grid (for OrthoInspector)  ;)

    if {$LesNoms==""} { set LesNoms [ListeDesPABs] }
    if {[regexp "," $LesNoms]} {
	regsub -all {[ \,\n\t]} $LesNoms "," LesNoms
	set LesNoms [split $LesNoms ","]
    }
    set DoMore 0
    if {[regexp {^\+([0-9]+)$} $MaxBlastong Match N]} {
	set MaxBlastong ""
	set DoMore $N  
    }
    if {$MaxBlastong==""} { set MaxBlastong 4 }
    
    
    
    set TestOnly [string equal -nocase $TestOnly "TestOnly"]
    if {[regexp -nocase "TestOnly" $MaxBlastong]} { return [Blastong "" "TestOnly"] }
    
    set MessageAlreadyRunning ""
    set LeMessageBlastong {}
    foreach Nom $LesNoms {
	if {[PasTouche "DoneBlastong$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonh$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonh$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastong$Nom" "test"]} {
	    set LesRetours [glob -nocomplain "[RepertoireDuGenome]/PassePlat_${Nom}_*/assiette/*"]
	    if { $LesRetours!={}} {
		set Status [DoneBlastong $Nom]
		lappend LeMessageBlastong $Status
	    }
	    continue
	}
	#rR Attention là on cherche le Done$Nom et on compte les Blastong
	set NbBlastong 0
	set Done 0
	foreach PasTouche [PasTouche "ListAllFiles"] {
	    if {$PasTouche=="DoneBlastong$Nom"} {
		set Done 1
		break
	    }
	    if {[regexp "^Blastong" $PasTouche]} {
		incr NbBlastong
	    }
	}
	if {$Done} { continue }	

	if {$DoMore<1 && $NbBlastong>=$MaxBlastong} { set MessageAlreadyRunning "$NbBlastong are already running" ; continue }
	incr DoMore -1

	if {$TestOnly} {
	    if {[PasTouche "Blastong$Nom" "test"]} { continue }
	} else {
	    if {[PasTouche "Blastong$Nom"]} { continue }
	}
	    
	#rR Arrivé ici on lance une grillade !!!!!!!!!!!!!!!!!!!!! (sauf test)

	if {$TestOnly} {
	    incr MaxBlastong -1
	    set Grillade "I did not lauch $Nom because it is only a test"
	} else {
	    set Grillade [GrilladinPourOi $Nom ]
	}
	lappend LeMessageBlastong $Grillade
    }
    if {$MessageAlreadyRunning==""} { lappend LeMessageBlastong "It seems all is done or is running" }
    if {$LeMessageBlastong=={}} {
	set LeMessageBlastong [list "Nothing to do. $MessageAlreadyRunning"]
    }
    set MessageBlastong [join $LeMessageBlastong "\n"]
    return $MessageBlastong
}

proc Blastonh {{MaxBlastonh ""} {TestOnly ""} {LesNoms ""}} {
    #rR Blast On HPC (for OrthoInspector)  ;)

    if {$LesNoms==""} { set LesNoms [ListeDesPABs] }
    if {[regexp "," $LesNoms]} {
	regsub -all {[ \,\n\t]} $LesNoms "," LesNoms
	set LesNoms [split $LesNoms ","]
    }
    set DoMore 0
    if {[regexp {^\+([0-9]+)$} $MaxBlastonh Match N]} {
	set MaxBlastonh ""
	set DoMore $N  
    }
    if {$MaxBlastonh==""} { set MaxBlastonh 4 }

    set TestOnly [string equal -nocase $TestOnly "TestOnly"]
    if {[regexp -nocase "TestOnly" $MaxBlastonh]} { return [Blastonh "" "TestOnly" $LesNoms] }

    set MessageAlreadyRunning ""
    set LeMessageBlastonh {}
    foreach Nom $LesNoms {
	if {[PasTouche "DoneBlastong$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonh$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastong$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonh$Nom" "test"]} {
	    set LesRetours [glob -nocomplain "[RepertoireDuGenome]/PassePlat_${Nom}_*/assiette/*"]
	    if { $LesRetours!={}} {
		set Status [DoneBlastonh $Nom]
		lappend LeMessageBlastonh $Status
	    }
	    continue
	}

	#rR Attention là on cherche le Done$Nom et on compte les Blastonh
	set NbBlastonh 0
	set Done 0
	foreach PasTouche [PasTouche "ListAllFiles"] {
	    if {$PasTouche=="DoneBlastong$Nom" || $PasTouche=="DoneBlastonh$Nom" || $PasTouche=="DoneBlastonl$Nom"} {
		set Done 1
		break
	    }
	    if {[regexp "^Blastonh" $PasTouche]} {
		incr NbBlastonh
	    }
	}
	if {$Done} { continue }	

	if {$DoMore<1 && $NbBlastonh>=$MaxBlastonh} { set MessageAlreadyRunning "$NbBlastonh are already running" ; continue }
	incr DoMore -1

	if {$TestOnly} {
	    Espionne "Test $Nom"
	    if {[PasTouche "Blastonh$Nom" "test"]} { continue }
	} else {
	    Espionne "try $Nom"
	    if {[PasTouche "Blastonh$Nom"]} { continue }
	}
	    
	#rR Arrivé ici on lance un hotdog sur HPC  !!!!!!!!!!!!!!!!!!!!! (sauf test)

	if {$TestOnly} {
	    incr MaxBlastonh -1
	    set Hotdog "I did not lauch $Nom because it is only a test"
	} else {
	    set Hotdog [HotdogPourOi $Nom ]
	}
	lappend LeMessageBlastonh $Hotdog
    }
    if {$MessageAlreadyRunning==""} { lappend LeMessageBlastonh "It seems all is done or is running" }
    if {$LeMessageBlastonh=={}} {
	set LeMessageBlastonh [list "Nothing to do. $MessageAlreadyRunning"]
    }
    set MessageBlastonh [join $LeMessageBlastonh "\n"]
    return $MessageBlastonh
}

proc Blastonl {{MaxBlastonl ""} {TestOnly ""} {LesNoms ""}} {
    #rR Blast en Local (for OrthoInspector)  ;)
    #rR Si on en lance c'est en process séparé
    #rR Attention on lance sur la machine courante !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    NousAllonsAuBoulot "[RepertoireDuGenome]/oif"

    if {$LesNoms==""} { set LesNoms [ListeDesPABs] }
    if {[regexp "," $LesNoms]} {
	regsub -all {[ \,\n\t]} $LesNoms "," LesNoms
	set LesNoms [split $LesNoms ","]
    }
    set DoMore 0
    if {[regexp {^\+([0-9]+)$} $MaxBlastonl Match N]} {
	set MaxBlastonl ""
	set DoMore $N  
    }
    if {$MaxBlastonl==""} { set MaxBlastonl 4 }
    if {[regexp {[0-9]+$} $TestOnly]} {
		set Nb $TestOnly
		set TestOnly ""
	}   
    
    set TestOnly [string equal -nocase $TestOnly "TestOnly"]
    if {[regexp -nocase "TestOnly" $MaxBlastonl]} { return [Blastonl "" "TestOnly"] }

    set NbBlastonl 0
    foreach PasTouche [PasTouche "ListAllFilesAndDirectories"] {
	if {[regexp {^Blastonl(OI[0-9]+)} $PasTouche Match Nom]} {
	    set YaPasTouche($Nom) 1
	    incr NbBlastonl
	}
    }
    Espionne $NbBlastonl
    set MessageAlreadyRunning ""
    set LeMessageBlastonl {}
    foreach Nom $LesNoms {
	if {[PasTouche "DoneBlastonl$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonh$Nom" "test"]} { continue }
	if {[PasTouche "DoneBlastonl$Nom" "test"]} { continue }
	if {[PasTouche     "Blastong$Nom" "test"]} { continue }
	if {[PasTouche     "Blastonh$Nom" "test"]} { continue }

	if {[info exist YaPasTouche($Nom)]} {
	    set AtLeastOneAbsent 0
	    set NbBlast [llength [glob -nocomplain "$Nom/blast/*"]]
	    if {$NbBlast>=10000 && [glob -nocomplain "[RepertoireDuGenome]/pastouche/Blastonl$Nom/*"]=={}} {
		Espionne "Je vais faire DoneBlastonl $Nom"
		set Status [DoneBlastonl $Nom]
		lappend LeMessageBlastonl $Status
		incr NbBlastonl -1
	    }
	}
	#rR Attention là on cherche le Done$Nom et on compte les Blastonl
	set Done 0
	foreach PasTouche [PasTouche "ListAllFiles"] {
	    if {$PasTouche=="DoneBlastonl$Nom"} {
		set Done 1
		break
	    }
	}
	if {$Done} { continue }	

	if {$DoMore<1 && $NbBlastonl>=$MaxBlastonl} { set MessageAlreadyRunning "$NbBlastonl are already running" ; continue }
	incr DoMore -1

	#rR Arrivé ici on lance un local !!!!!!!!!!!!!!!!!!!!! (sauf test)
	if {$TestOnly} {
	    incr MaxBlastonl -1
	    set Lolo "I did not lauch $Nom because it is only a test"
	} else {
	    set Lolo [BlastLocalPourOiEnProcessSepare $Nom $Nb]
	    set Lolo "I launched $Nom log in  oif/log/$Lolo"
	    set MessageAlreadyRunning "Bidon" ;#rR ne sera pas affiché
	}
	lappend LeMessageBlastonl "For $Nom $Lolo"
    }
    if {$MessageAlreadyRunning==""} { lappend LeMessageBlastonl "It seems all is done or is running" }
    if {$LeMessageBlastonl=={}} {
	set LeMessageBlastonl [list "Nothing to do. $MessageAlreadyRunning"]
    }
    set MessageBlastonl [join $LeMessageBlastonl "\n"]

    OnRevientDuBoulot
    return $MessageBlastonl
}

proc OrdonnanceBlastong {} {
    # On teste si tout est fini et das ce cas on supprime le todo de l'ordonnanceur par deleteall)
    # Sinon
    #  On dépose un qds OI Blastong 

    # bref je sais plus comment on fait  :(
}


proc OiSplitSize {{Domaine ""}} {
    if {$Domaine==""} { set Domaine [OiDomain] }
    if {$Domaine=="Eukaryota"} { return 10000 }
    return "SplitOrganisms"
}

proc OiSourceProteomes {{Domaine ""}} {
    if {$Domaine==""} { set Domaine [OiDomain] }
    return "/blast/OrthoInspector/Oi$Domaine"
}

proc OiSplit {{Domaine ""}} {
    if {$Domaine==""} { set Domaine [OiDomain] }
    set SplitSize [OiSplitSize $Domaine]
    set SplitOrganisms [string equal -nocase "SplitOrganisms" $SplitSize]
    set RepOip "[RepertoireDuGenome]/oip"
    file mkdir $RepOip
    set F [open [OiSourceProteomes $Domaine] "r"]
    set N 0
    set LaTranche {}
    set P 0
    set NbSeqLues 0
    set MaxSeqPourTest -21000 
    set PreviousOX ""

    set FNum "[FormatDesNumerosPourCollection]"

    while {[gets $F Ligne]>=0} {
	if {[string trim $Ligne]==""} { continue }
	if {[string index $Ligne 0]!=">"} { lappend LaTranche $Ligne; continue }
	set OX [IntegerApres "OX=" dans $Ligne]
	incr NbSeqLues
	if {$NbSeqLues%1000==0} {
	    Espionne "$NbSeqLues $P $Ligne"
	    
	}
	if {$MaxSeqPourTest>0 && $NbSeqLues>$MaxSeqPourTest} { break }
	incr N
	if {$N>1 && ($SplitOrganisms && $PreviousOX!=$OX) || ( ! $SplitOrganisms && ($N-1)%$SplitSize==0)} {
	    Espionne $N
	    #Doit etre comme ci-dessous
	    incr P
	    set Nom [format "%s%$FNum" [PreFixe] $P]
	    lappend LesNoms $Nom
	    SauveLesLignes $LaTranche dans $RepOip/$Nom
	    Espionne "creation de $RepOip/$Nom"
	    set LaTranche {}
	}
	set PreviousOX $OX
	lappend LaTranche $Ligne
    }
    if {$LaTranche!={}} {
	#Doit etre comme ci-dessus
	incr P
	set Nom [format "%s%$FNum" [PreFixe] $P]
	lappend LesNoms $Nom
	SauveLesLignes $LaTranche dans $RepOip/$Nom
	Espionne "creation de $RepOip/$Nom"
	set LaTranche {}
    }
    CreeBornesDesPABsTroisGradins 1 $P "" "" "" $FNum
    return $LesNoms
}

proc BAIOX {Ligne {AcceptIdOnly ""}} {
    set AcceptIdOnly [string equal -nocase "AcceptIdOnly" $AcceptIdOnly]
    scan $Ligne "%s" BAI
    set B ""; set Ac "" ; set Id ""; set OX "" 
    lassign [split $BAI "|"] B Ac Id
    set OX [IntegerApres "OX=" dans $Ligne]

    
    if {$B eq "" || $Ac eq "" || $Id eq "" || $OX eq ""} {
	if {$AcceptIdOnly} {
	    set Ac "Access$BAI"
	    set Id $BAI
	} else {
	    FaireLire "$Ligne\nsomething is wrong"
	}
    }
    return [list $B $Ac $Id $OX]
}

proc TestCodeOrga {} {
    foreach OX [WIW ListOf OX] {
    }
	
}

proc WiwOxFrom Qui {
    global WiwOxFrom

    set Science [ScienceOiDeMonDomaine]
    #if { ! [OnTraite $Science]} { return [QuestionDeScience $Science "ret WiwOxFrom $Qui"] }

    if {[info exists WiwOxFrom($Qui)]} { return $WiwOxFrom($Qui) }
    if {[info exists WiwOxFrom("EstCharge")]} {
	set CodeOrga [lindex [split $Qui "|"] end]
	return [WIW CodeOrga_$CodeOrga OX]
    }

    set Science [ScienceOiDeMonDomaine]
    #set Fichier "[RepertoireDuGenome]/fiches/wiwoxfrom.txt"
    set Fichier "/genomics/link/$Science/fiches/wiwoxfrom.txt"

    if {[file exists $Fichier]} {
	array set WiwOxFrom [ContenuDuFichier $Fichier]
    } else {
	set WiwOxFrom("EstCharge") 1
	foreach CodeOrga [WIW ListOf CodeOrgaWithMultipleOX] {
	    Espionne $CodeOrga
	    foreach OX [WIW CodeOrga_$CodeOrga OX] {
		Espionne $OX
		foreach Id [WIW $OX ListOfID] {
		    if {$Id=="A0A0E9NSC1_9ASCO"} { Espionne $OX }
		    set WiwOxFrom($Id) $OX
		}
	    }
	}
	Sauve [array get WiwOxFrom] dans $Fichier
    }
    return [WiwOxFrom $Qui]
}

proc WIW {{Qui ""} {Quoi ""}} {
    #rR Attention pour que ça marche pour les Eukaryota Archaea et autre il faut être dans le bon Gscope
    #rR oi pour Eukaryota; OIA pour Archaea etc.
    global WIW

    #rR WIW Who is Where
    # Attention il y a quelques P12345_BIDULE qui correspondent à plusieurs organismes 

    if {[info exists WIW($Qui,$Quoi)]} { return $WIW($Qui,$Quoi) }
    if {[info exists WIW("EstCharge")]} {
	if {[regexp {_([^_]+)$} $Qui Match CodeOrga]} {
	    if {[info exists WIW(CodeOrga_$CodeOrga,$Quoi)]} {
		return $WIW(CodeOrga_$CodeOrga,$Quoi)
	    } else {
		if {[info exists WIW(CodeOrga_$CodeOrga,OX)]} {
		    set LeResultat {}
		    foreach OX $WIW(CodeOrga_$CodeOrga,OX) {
			if {[info exists WIW($OX,$Quoi)]} { lappend LeResultat $WIW($OX,$Quoi) }
		    }
		    return $LeResultat
		}
	    }
		
	}
	if {[info exists WIW($Qui,ListOfOX)]} {
	    set LeR {}
	    foreach OX $WIW($Qui,ListOfOX) {
		if {[info exists WIW($OX,$Quoi)]} { LConcat LeR $WIW($OX,$Quoi) }
	    }
	    return $LeR
	}
	if {[info exists WIW(CodeOrga_$Qui,OX)]} { return [WIW CodeOrga_$Qui $Quoi] }
	return ""
    }
    set WIW("EstCharge") 1

    set Science [ScienceOiDeMonDomaine]

#    set FicWIW "[RepertoireDuGenome]/fiches/wiw.txt"
    set FicWIW "/genomics/link/$Science/fiches/wiw.txt"

    set WIW(Filename,) $FicWIW

    if {[file exists $FicWIW]} {
	array set WIW [ContenuDuFichier $FicWIW]
	return [WIW $Qui $Quoi]
    }

    set RepOip "/genomics/link/$Science/oip"
    NousAllonsAuBoulot $RepOip

    set NiveauSeq 0
    foreach Nom [ListeDesPABs] {
	lappend WIW(ListOf,OP) $Nom
	foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "oip"]] {
	    if {[string index $Ligne 0]!=">"} { lappend LaTranche $Ligne; continue }
	    lassign [BAIOX $Ligne "AcceptIdOnly"] B Ac Id OX
	    if {[info exists WIW($Ac,OX)] && $OX!=5763} {
		FaireLire "Double in $Nom\n$Ac\n$WIW($Ac,OX)\n$OX"
	    } 
	    set WIW($Ac,OX) $OX
	    if {[info exists WIW($Id,OX)] && $OX!=5763} {
		FaireLire "Double in $Nom\n$Id\n$WIW($Id,OX)\n$OX"
	    }
	    lappend WIW($OX,ListOfOP)  $Nom
	    lappend WIW($Nom,ListOfOX) $OX
	    lappend WIW($Nom,ListOfID) $Id
	    lappend WIW(ListOf,OX)     $OX
	    lappend WIW($OX,ListOfAC)  $Ac
	    lappend WIW($OX,ListOfID)  $Id
	    set CodeOrga [lindex [split $Id "_"] end]
	    if {[info exists WIW(CodeOrga_$CodeOrga,OX)]} {
		if {[lsearch $WIW(CodeOrga_$CodeOrga,OX) $OX]<0} {
		    lappend WIW(CodeOrga_$CodeOrga,OX) $OX
		    lappend WIW(ListOf,CodeOrgaWithMultipleOX) $CodeOrga
		}
	    } else {
		lappend WIW(ListOf,CodeOrga) $CodeOrga
		    set WIW(CodeOrga_$CodeOrga,OX) $OX
	    }
	    if {[info exists WIW($OX,CodeOrga)] && [lsearch $WIW($OX,CodeOrga) $CodeOrga]<0} {
		lappend WIW($OX,CodeOrga) $CodeOrga
		lappend WIW(ListOf,OXWithMultipleCodeOrga) $OX
	    } else {
		set WIW($OX,CodeOrga) $CodeOrga
	    }
	    
	    if {$NiveauSeq} {
		set WIW($Ac,OX) $OX
		set WIW($Id,OX) $OX
		set WIW($Ac,AC) $Ac
		set WIW($Id,AC) $Ac
		set WIW($Ac,ID) $Ac
		set WIW($Id,IC) $Id
		lappend WIW($Nom,ItsAC) $Ac
		lappend WIW($Nom,ItsID) $Id
		lappend WIW(ListOf,AC) $Ac
		lappend WIW(ListOf,ID) $Id
	    }
	}
	set WIW($Nom,ListOfID) [lsort $WIW($Nom,ListOfID)]
    }
    if {[info exists WIW(ListOf,CodeOrgaWithMultipleOX)]} {
	set WIW(ListOf,CodeOrgaWithMultipleOX) [lsort -unique $WIW(ListOf,CodeOrgaWithMultipleOX)]
    }
    set WIW(ListOf,OX) [lsort -integer -unique $WIW(ListOf,OX)]
    foreach OX $WIW(ListOf,OX) {
	set WIW($OX,ListOfOP) [lsort -unique $WIW($OX,ListOfOP)]
    }
    foreach OP $WIW(ListOf,OP) {
	set WIW($OP,ListOfOX) [lsort -integer -unique $WIW($OP,ListOfOX)]
    }
    Sauve [array get WIW] dans $FicWIW 

    OnRevientDuBoulot

    return [WIW $Qui $Quoi]
}

proc CreeBornesDesPABsTroisGradins {Premier Dernier {Prefixe ""} {Long ""} {Start ""} {FNum ""} {RepGen ""}} {

    if {$Prefixe==""} { set Prefixe [PreFixe] }
    if {$Long==""}    { set Long    601 }
    if {$Start==""}   { set Start   99 }
    set Ecart [expr 3*($Long/10)/3 + 1]
    set OldFin $Start

    if {$FNum==""} { set FNum [FormatDesNumerosPourCollectionDuProjet] }
    set FNum [string trimleft $FNum "%"]

    foreach N [NombresEntre $Premier $Dernier] {
	set Nom [format "%s%$FNum" $Prefixe $N]
	set Debut [expr $OldFin + $Ecart]
	set Fin   [expr $Debut+$Long-1]
	lappend LesNouvellesBornes "$Nom $Debut $Fin F"

	set OldFin $Fin
    }
    if {$RepGen==""} { set RepGen [RepertoireDuGenome] }
    set FichierBornes "$RepGen/fiches/bornesdespabs"
    Garde $FichierBornes
    return [SauveLesLignes $LesNouvellesBornes dans $FichierBornes]
 
}