Index by: file name |
procedure name |
procedure call |
annotation
gscope_orthoinspector.tcl
(annotations | original source)
#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]
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.