Index by: file name |
procedure name |
procedure call |
annotation
gscope_liste.tcl
(annotations | original source)
#rR gscope_liste.tcl
proc LesFantomes {} {
foreach Nom [ListeDesPABs] {
if { ! [Fantome $Nom]} { continue }
Espionne "$Nom [ExtraitInfo $Nom Fantome]"
lappend LesFantomes $Nom
}
return $LesFantomes
}
proc PlaceDuPAB Nom {
set i -1
foreach PAB [ListeDesPABs] {
incr i
if {$PAB==$Nom} { return $i }
}
return -1
}
proc MiseAJourBornesDesPABs {NouvelleBorne {ReCharge ""}} {
if {$ReCharge==""} { set ReCharge "ReCharge" }
if {$ReCharge=="ReCharge" } { set ReCharge 1 } else { set ReCharge 0 }
set FichierBornesDesPABs "[RepertoireDuGenome]/fiches/bornesdespabs"
scan $NouvelleBorne "%s %d %d %s" Nom Debut Fin Orient
set BelleBorne "$Nom $Debut $Fin $Orient"
set LesBornes {}
foreach Ligne [LesLignesDuFichier $FichierBornesDesPABs] {
if { ! [regexp -nocase {[A-Z_]+[0-9]+ +[0-9]+ +[0-9]+ [FR] *} $Ligne]} {
if {[regexp -nocase {[A-Z0-9]} $Ligne]} {
FaireLire "I'll skip the illegal line \n$Ligne"
}
continue
}
scan $Ligne "%s %d %d %s" N D F O
lappend LesBornes "$N $D $F $O"
}
if {[set i [PlaceDuPAB $Nom]]<0} {
lappend LesBornes "$Nom $Debut $Fin $Orient"
} else {
set LesBornes [lreplace $LesBornes $i $i $BelleBorne]
}
SauveLesLignes $LesBornes dans $FichierBornesDesPABs
if { ! $ReCharge } { return "" }
global ListeDesPABs ; unset ListeDesPABs
global ListeDeBoites ; unset ListeDeBoites
return [ListeDesPABs]
}
proc PresentationDesPABs {} {
set LaPresentation {}
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
set Defin [DefinitionRapide $Nom]
set Ligne [format "%s %-15s %s" $Nom $Alias $Defin]
lappend LaPresentation $Ligne
}
return $LaPresentation
}
proc LesBanquesDeLaFerme Ferme {
set OnAttendPP 1
set LesBanques {}
foreach Ligne [LesLignesDuFichier $Ferme] {
if {$OnAttendPP} {
if {[regexp {\.\.} $Ligne]} { set OnAttendPP 0 }
continue
}
scan $Ligne "%s" B
lappend LesBanques $B
}
return $LesBanques
}
proc BlastHitCount {Nom {Rep ""} {CutPN ""} {MaxListe ""}} {
Wup "If Nom contains / then Rep is CutPN and CutPN is Maxlist"
Wup "If Rep doesn't contain / I add RepertoireDuGenome"
Wup "The default for Rep is blastp"
if {[regexp "/" $Nom]} {
set MaxListe $CutPN
set CutPN $Rep
set Rep [file dirname $Nom]
set Nom [file tail $Nom]
} else {
if {[regexp -nocase {^[0-9\-\.e]+$} $Rep] || $Rep=="SansSeuilExpect" } {
set MaxLists $CutPN
set CutPN $Rep
set Rep ""
}
if {$Rep==""} { set Rep "blastp" }
if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
}
set Fichier "$Rep/$Nom"
if { ! [file exists $Fichier]} { return -1 }
return [DecortiqueBlast $Fichier $CutPN $MaxListe "BlastHitCount"]
}
proc ToutSurLesEntetesDeFrag {FichierFrag {Rep ""}} {
if {$Rep==""} { set Rep "SameDir" }
if {$Rep=="SameDir"} { set Rep "[file dirname $FichierFrag]" }
set LesBanques {}
foreach Ligne [LesLignesDuFichier $FichierFrag] {
regsub {\:} $Ligne " " Ligne
scan $Ligne "%s" Banque
set LesMots [split $Ligne " "]
set Genre [lindex $LesMots 9]
set Espece [lindex $LesMots 10]
if {[info exists DejaVu($Banque)]} { continue }
set DejaVu($Banque) 1
lappend LesBanques $Banque
lappend LesOrganismes "$Genre $Espece"
}
set LesBonnesBanques {}
foreach SN $LesBanques O $LesOrganismes {
set FN [FNduSNgcg $SN]
set LN [LNduSNgcg $SN]
if {$FN==""} { FaireLire "$SN inconnu" ; continue }
ScanLaListe [split $FN ":"] Dir Fic
if {$LN!=$Fic} { FaireLire "FN $FN <> LN $LN" }
if {[catch {set VraieDir [exec name $Dir]} Message]} {
FaireLire "Problem with 'exec name $Dir'\ I got message \n$Message"
continue
}
set BonRef ""
foreach FiRef [glob -nocomplain "$VraieDir/*.ref"] {
set Queue [file tail $FiRef]
if {[string equal -nocase $Queue "$Fic.ref"]} { set BonRef $FiRef ; break }
}
if {$BonRef==""} { Warne "$VraieDir/$Fic.ref doen't exist" }
set TaxId [TaxIdDuFichierRef $BonRef]
set TaxIdDuO [Tax $O]
Espionne "$O<$TaxIdDuO>"
if {$TaxId==""} {
if {$TaxIdDuO==""} { FaireLire "I didn't found a TaxId for\n$BonRef" }
set TaxId $TaxIdDuO
}
set N 7
set TaxIdAuBonNiveau $TaxId
while { [incr N -1] } {
Espionne "$N $TaxIdAuBonNiveau $TaxIdDuO"
if {$TaxIdAuBonNiveau==$TaxIdDuO} { break }
set TaxIdAuBonNiveau [Tax $TaxIdAuBonNiveau Parent]
}
if {0 && $TaxIdAuBonNiveau!=$TaxIdDuO} { FaireLire "$TaxIdDuO is not a parent of $TaxId for \n$BonRef" }
lappend LesBonnesBanques "$SN $BonRef $TaxId"
set TaxIdDuGenomeComplet($SN) $TaxId
set RefDuGenomeComplet($SN) $BonRef
}
if {[OuiOuNon "Do I save TaxIdDuGenomeComplet ?"]} {
set FichierTaxIdDuGenomeComplet "/genomics/link/Common/fiches/taxid_des_genomes_complets"
SauveLesLignes [array get TaxIdDuGenomeComplet] dans $FichierTaxIdDuGenomeComplet
}
if {[OuiOuNon "Do I save RefDuGenomeComplet ?"]} {
set FichierRefDuGenomeComplet "/genomics/link/Common/fiches/ref_des_genomes_complets"
SauveLesLignes [array get RefDuGenomeComplet] dans $FichierRefDuGenomeComplet
}
return $LesBonnesBanques
}
proc A_Voir_LesBanquesDesEntetesDeFrag {FichierFrag {Rep ""}} {
if {$Rep==""} { set Rep "SameDir" }
if {$Rep=="SameDir"} { set Rep "[file dirname $FichierFrag]" }
set LesBanques {}
foreach Ligne [LesLignesDuFichier $FichierFrag] {
regsub {\:} $Ligne " " Ligne
scan $Ligne "%s" Banque
lappend LesBanques $Banque
}
set LesBonnesBanques {}
foreach Banque $LesBanques {
set Banque [file tail $Banque]
set BonneBanque "$Rep/$Banque"
set Nhr "$BonneBanque.nhr"
if { ! [file exists $Nhr]} { FaireLire "$Nhr n'existe pas" }
if {[catch {set Name [exec name $Banque]} Message]} {
FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
continue
}
if {[regexp "^@GenDBConfigFiles" $Name]} {
regsub "^@" $Name "" Name
set NameDir [lindex [split $Name ":"] 0]
set Ferme [lindex [split $Name ":"] 1]
if {[catch {set Dir [exec name $NameDir]} Message]} {
FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
continue
}
set Farm "$Dir/$Ferme"
if { ! [file exists $Farm]} { FaireLire "$Farm doesn't exists" ; continue }
foreach B [LesBanquesDeLaFerme $Farm] {
Espionne "B $B"
if {[catch {set NameDeB [exec name $B]} Message]} {
FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
continue
}
set NameDirDeB [lindex [split $NameDeB ":"] 0]
if {[catch {set DirDeB [exec name $NameDirDeB]} Message]} {
FaireLire "Problem with 'exec name $NameDirDeB'\ I got message \n$Message"
continue
}
lappend LesBonnesBanques "$BonneBanque $DirDeB $NameDeB"
}
} else {
set NameDir [lindex [split $Name ":"] 0]
if {[catch {set Dir [exec name $NameDir]} Message]} {
FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
continue
}
lappend LesBonnesBanques "$BonneBanque $Dir $Name"
}
}
return $LesBonnesBanques
}
proc Nouveau_LesBanquesDuNal {Fichier {Rep ""}} {
if {$Rep==""} { set Rep "SameDir" }
if {$Rep=="SameDir"} { set Rep "[file dirname $Fichier]" }
set LesBanques {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp "^DBLIST " $Ligne]} { continue }
while {[regsub -all " " $Ligne " " Ligne]} {}
set Ligne [string trim $Ligne]
set LesBanques [lrange [split $Ligne " "] 1 end]
}
set LesBonnesBanques {}
foreach Banque $LesBanques {
set Banque [file tail $Banque]
set BonneBanque "$Rep/$Banque"
set Nhr "$BonneBanque.nhr"
if { ! [file exists $Nhr]} { FaireLire "$Nhr n'existe pas" }
if {[catch {set Name [exec name $Banque]} Message]} {
FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
continue
}
if {[regexp "^@GenDBConfigFiles" $Name]} {
regsub "^@" $Name "" Name
set NameDir [lindex [split $Name ":"] 0]
set Ferme [lindex [split $Name ":"] 1]
if {[catch {set Dir [exec name $NameDir]} Message]} {
FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
continue
}
set Farm "$Dir/$Ferme"
if { ! [file exists $Farm]} { FaireLire "$Farm doesn't exists" ; continue }
foreach B [LesBanquesDeLaFerme $Farm] {
if {[catch {set NameDeB [exec name $B]} Message]} {
FaireLire "Problem with 'exec name $Banque'\ I got message \n$Message"
continue
}
set NameDirDeB [lindex [split $NameDeB ":"] 0]
if {[catch {set DirDeB [exec name $NameDirDeB]} Message]} {
FaireLire "Problem with 'exec name $NameDirDeB'\ I got message \n$Message"
continue
}
lappend LesBonnesBanques "$BonneBanque $DirDeB $NameDeB"
}
} else {
set NameDir [lindex [split $Name ":"] 0]
if {[catch {set Dir [exec name $NameDir]} Message]} {
FaireLire "Problem with 'exec name $NameDir'\ I got message \n$Message"
continue
}
lappend LesBonnesBanques "$BonneBanque $Dir $Name"
}
}
return $LesBonnesBanques
}
proc LesBanquesDuNal {Fichier {Rep ""}} {
if {$Rep==""} { set Rep "SameDir" }
if {$Rep=="SameDir"} { set Rep "[file dirname $Fichier]/" }
set LesBanques {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp "^DBLIST " $Ligne]} { continue }
while {[regsub -all " " $Ligne " " Ligne]} {}
set LesBanques [lrange [split $Ligne " "] 1 end]
}
set LesBonnesBanques {}
foreach Banque $LesBanques {
set Banque [file tail $Banque]
lappend LesBonnesBanques "$Rep$Banque"
}
return $LesBonnesBanques
}
proc VerifieLesGenomesCompletsIGBMC {{Fichier ""}} {
if {$Fichier==""} { set Fichier "/genome/GCGdbs" }
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
if { ! [regexp {^[ \t]} $Ligne]} { continue }
if {[regexp "All the " $Ligne]} { continue }
regsub -all {\.} $Ligne " " Ligne
scan $Ligne "%s %s" Genre Espece
if {$Espece=="sp"} { set Espece "sp." }
set Organisme [Glossaire "$Genre $Espece" Complet]
if {[info exists DejaVu($Organisme)]} { continue }
set DejaVu($Organisme) 1
if {$Organisme!="$Genre $Espece"} {
if {$Organisme==""} {
set Trouve "nothing"
} else {
set Trouve "'$Organisme'"
}
set Bon ""
if {[OuiOuNon "I found $Trouve for\n$Ligne\n Do I keep '$Genre $Espece' ?"]} {
set Bon "$Genre $Espece"
}
if {$Bon=="" && $Organisme!="" && [OuiOuNon " Do I keep '$Organisme' ?"]} {
set Bon "$Genre $Espece"
}
if {$Bon==""} { continue }
}
lappend LesOrganismes $Organisme
}
set LesBons [ChoixDesPresents $LesOrganismes]
return $LesBons
}
proc RetireLesAccessDuMSF {FichierAvant LesAccess {FichierApres ""} {InOut "Out"}} {
if {$InOut=="In"} { set In 1 } else { set In 0 }
set LeNouveau {}
foreach Ligne [LesLignesDuFichier $FichierAvant] {
if {[regexp "^PileUp" $Ligne] || \
! [regexp -nocase {[a-z0-9]} $Ligne] } { lappend LeNouveau $Ligne ; continue }
set Tope 0
scan $Ligne "%s %s" Access AccessBis
if {[regexp -nocase "Name:" $Ligne]} {
set Access $AccessBis
}
foreach AccessARetirer $LesAccess {
if {[string equal -nocase $AccessARetirer $Access]} { set Tope 1 ; break }
}
if { $Tope && ! $In } { continue }
if { ! $Tope && $In } { continue }
lappend LeNouveau $Ligne
}
if {$FichierApres=="" | $FichierApres=="GetLines"} { return $LeNouveau }
return [SauveLesLignes $LeNouveau dans $FichierApres]
}
proc ListEqual {A B} {
if {[llength $A]!=[llength $B]} { return 0 }
foreach a $A b $B {
if {[set L [llength $a]]!=[llength $b]} { return 0 }
if {$L>1} {
if { ! [ListEqual $a $b]} { return 0 }
} else {
if {$a != $b} { return 0 }
}
}
return 1
}
proc SetOptions Liste {
set LesValeurs [lrange $Liste 1 end]
lappend LesValeurs 1
foreach Option $Liste Valeur $LesValeurs {
if { ! [regexp {^\-} $Option]} { continue }
regsub {^\-} $Option "" Option
if {[regexp {^[0-9]} $Option]} { continue }
lappend LesOptions $Option
if {[regexp {^\-[^0-9]} $Valeur]} { set Valeur 1 }
uplevel set $Option \"$Valeur\"
}
return $LesOptions
}
proc TestSetOptions {A B C D args} {
set LesOptions [SetOptions $args]
foreach Option $LesOptions {
Espionne "$Option [set $Option]"
}
exit
}
proc DupliqueLaBaseGscope {{RepDestin ""}} {
global RepertoireDuGenome
while {1} {
if {$RepDestin==""} { set RepDestin "${RepertoireDuGenome}COPY" }
if { ! [regexp "/" $RepDestin]} {
set RepDestin "[file dirname $RepertoireDuGenome]/$RepDestin"
}
if { ! [OuiOuNon "Ok to duplicate \n\
$RepertoireDuGenome\n to \
$RepDestin\n \
?"]} {
set RepDestin [Entre $RepDestin]
}
if {$RepDestin!=""} { break }
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
while {! [file exists $RepDestin]} {
if {[OuiOuNon "Please create the directory of the new gscope database \n\
$RepDestin\
OK ?"]} { continue }
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
foreach Rep {"beton" "nuctfa" "nucembl" "prottfa" "protembl" "infos" "trnadir" "codonw"} {
set Source "$RepertoireDuGenome/$Rep"
set Destin "$RepDestin/$Rep"
if { ! [file exists $Source]} { continue }
Espionne "$Source to $Destin"
if { ! [info exists $Destin]} { File mkdir $Destin }
foreach Fichier [glob -nocomplain "$Source/*"] {
set Nom [file tail $Fichier]
File copy $Fichier "$Destin/$Nom"
}
}
set Source "$RepertoireDuGenome/fiches"
set Destin "$RepDestin/fiches"
if { ! [file exists $Destin]} { File mkdir $Destin }
if {[file exists $Source]} {
foreach F { \
bornesdesarns \
bornesdesglimmers \
bornesdespabs \
bornesdestrnas \
codonstartpossible \
codonstoppossible \
coglimmer \
compositionenatgc \
createurdespabs \
lesorganismestresproches \
narcisse \
sd_bons \
sd_loin \
sd_mets \
sd_sans \
similarite \
spectregc \
spectregcxy \
startcodon_summary } {
if { ! [file exists $Source/$F]} { continue }
Espionne "$Source/$F to $Destin/$F"
File copy "$Source/$F" "$Destin/$F"
}
}
return
}
proc SplitLeGrosGenbank {{Fichier ""} {Petit ""}} {
global RepertoireDuGenome
if {$Fichier==""} {
set Fichier [ButineArborescence "All" "$RepertoireDuGenome"]
}
if {$Fichier==""} { return {} }
set n 1
foreach Ligne [LesLignesDuFichier $Fichier] {
lappend T($n) $Ligne
if {[regexp "^//" $Ligne]} { incr n }
}
incr n -1
if {$n==1} {
FaireLire "I found only one section in $Fichier"
}
set Format "%5.5d"
if { 1<$n && $n< 10} { set Format "%1.1d" }
if { 9<$n && $n< 100} { set Format "%2.2d" }
if { 99<$n && $n< 1000} { set Format "%3.3d" }
if {999<$n && $n<10000} { set Format "%4.4d" }
if {$Petit==""} {
set Petit [file tail $Fichier]
set Rep [file dirname $Fichier]
regsub ".gbk$" $Petit "" Petit
regsub -nocase {_[a-z]*$} $Petit "" Petit
append Petit "_"
while {1} {
set PetitMin [format "%s$Format%s" $Petit 1 ".gbk"]
set PetitMax [format "%s$Format%s" $Petit $n ".gbk"]
if {[OuiOuNon "I will create the files\n$PetitMin to $PetitMax\nin $Rep"]} { break }
set Petit [Entre $Petit]
}
}
foreach i [NombresEntre 1 $n] {
set PetitNom [format "%s$Format%s" $Petit $i ".gbk"]
set PetitFichier [SauveLesLignes [set T($i)] dans "$Rep/$PetitNom"]
lappend LesPetits $PetitFichier
}
return $LesPetits
}
proc MMm {} {
global Coucou T _1T
set Coucou "bonjour\nsalut"
set T(1) "Je suis sur \n deux lignes"
set _1T(a) "1ta"
foreach Variable [info globals] {
global $Variable
if {[regexp "Glossaire" $Variable]} { continue }
if { ! [info exists $Variable]} { continue }
if {[array exists $Variable]} {
lappend LesGlobal [PaqArray [set Variable]]
} else {
lappend LesGlobal [PaqListe $Variable [set $Variable]]
}
}
set Coucou perdu
unset _1T
EspionneL $LesGlobal
Espionne "Fin de LesGlobal"
set LesV [AffecteLesVariablesDeLaListe $LesGlobal]
foreach V $LesV {
if {[array exists $V]} {
Espionne "$V [array get $V]"
} else {
Espionne "$V [set $V]"
}
}
Espionne $Coucou
Espionne $T(1)
Espionne $_1T(a)
exit
}
proc Aujourdhui {} {
scan [Today] "%s %s %s %s" S J M A
set Aujourdhui "[Traduction $S francais] $J [Traduction $M francais] $A"
return $Aujourdhui
}
proc Today {} {
return [clock format [clock seconds] -format "%A %d %B %Y"]
}
proc IllumineSuivantLesGroupes {LesAGs Fenetre} {
set OldG Bidon
set Lumiere 0
foreach Ligne $LesAGs {
scan $Ligne "%s %s" A G
if {$OldG!=$G} { set Lumiere [expr ! $Lumiere] }
set OldG $G
if {$Lumiere} { Illumine $A $Fenetre }
}
}
proc MontreSecator MSF {
set FiMSF [Sauve $MSF dans [TmpFile "secator"]]
set LesAGs [GroupeSecator $FiMSF "" "ToutLeMondeAvecGroupe" "ToCalculate"]
set Fenetre [AfficheVariable [join $LesAGs "\n"] ""]
IllumineSuivantLesGroupes $LesAGs $Fenetre
MemoSelection $Fenetre Memorize
return $LesAGs
}
proc AfficheReordonneMSF {MSF {LesAccess ""} {FichierOrigine ""}} {
if {$LesAccess=="" || $LesAccess=="Ask"} {
set LesAccess [ChoixParmi {"Disphy" "Secator" "Dpc" "Oumy" "ShowSecator"}]
if {$LesAccess==""} { return "" }
}
if {$LesAccess=="ShowSecator"} {
MontreSecator $MSF
}
set Nom [file tail $FichierOrigine]
set Fenetre [AfficheVariable [ReordonneMSF $MSF $LesAccess $Nom] "AvecEtudeMSFGrandeLargeur" "$FichierOrigine"]
if {$LesAccess=="Disphy"} { return $Fenetre }
set LesAGs [MontreSecator $MSF]
IllumineSuivantLesGroupes $LesAGs $Fenetre
MemoSelection $Fenetre Memorize
return $Fenetre
}
proc DiffBlaAli Nom {
global RepertoireDuGenome
global DiffBlaAli
if {[info exists DiffBlaAli($Nom)]} { return [set DiffBlaAli($Nom)] }
if {[info exists DiffBlaAli]} { return "" }
set DiffBlaAli("EstCharge") 1
set FichierDiffBlaAli "$RepertoireDuGenome/fiches/diffblaali"
if { ! [file exists $FichierDiffBlaAli]} { return "" }
foreach DBA [LesLignesDuFichier $FichierDiffBlaAli] {
scan $DBA "%s %s" NomLu Rapport
if {[regexp "No(More|Bla|Ali)" $Rapport]} {
set DiffBlaAli($NomLu) $Rapport
continue
}
scan $DBA "%s %s %s %s %s %s %s %s" NomLu BestBla BestAli DisBla DisAli Ecart Rapport Fragments
set DiffBlaAli($NomLu) "$Rapport $BestBla $BestAli"
}
if {[info exists DiffBlaAli($Nom)]} { return [set DiffBlaAli($Nom)] }
return ""
}
proc RapportDuDifferentiel {DisBla DisAli {Test "AvecDis"}} {
if {$Test=="AvecDis"} {
set MaxDis [Maxi [Maxi $DisAli $DisBla] 1]
set EcartDis [Maxi 0 [expr ($DisBla-$DisAli) - 1]]
set EcartDisProp [expr (100*$EcartDis)/100]
set SeuilEcartDisProp 5
if {$EcartDisProp > $SeuilEcartDisProp} {
set Rapport "Different"
} else {
set Rapport "Close"
}
set Ecart $EcartDisProp
return "$Rapport $Ecart"
}
if {$Test=="AvecPI"} {
set SeuilEcartPI 90
set EcartPI [expr 100-($DisBla-$DisAli)]
if {$EcartPI < $SeuilEcartPI} {
set Rapport "Different"
} else {
set Rapport "Close"
}
set Ecart $EcartPI
return "$Rapport $Ecart"
}
}
proc ReconsidereLesDifferentiels {} {
global RepertoireDuGenome
set LesXDifferent {}
set LesYDifferent {}
set LesXClose {}
set LesYClose {}
foreach DiffBlaAli [LesLignesDuFichier "$RepertoireDuGenome/fiches/diffblaali"] {
scan $DiffBlaAli "%s %s" Nom Rapport
if {[regexp "No(More|Bla|Ali)" $Rapport]} {
lappend Sortie $DiffBlaAli
continue
}
scan $DiffBlaAli "%s %s %s %s %s %s %s %s" Nom BestBla BestAli DisBla DisAli Ecart Rapport Fragments
if { ! [regexp "Problem" $Rapport] && ! [regexp "Same" $Rapport]} {
scan [RapportDuDifferentiel $DisBla $DisAli] "%s %d" Rapport Ecart
}
set Beau [format "%s %-9s %-9s %3d %3d %3d %-10s %s" \
$Nom $BestBla $BestAli $DisBla $DisAli $Ecart $Rapport $Fragments]
lappend LesX $DisBla
lappend LesY $DisAli
if {$Rapport=="Different"} {
lappend LesXDifferent $DisBla
lappend LesYDifferent $DisAli
}
if {$Rapport=="Close"} {
lappend LesXClose $DisBla
lappend LesYClose $DisAli
}
lappend Sortie $Beau
}
SauveLesLignes $Sortie dans "$RepertoireDuGenome/fiches/diffblaali"
set K [Graphe $LesX $LesY "" "green"]
Graphe $LesXClose $LesYClose $K "blue"
Graphe $LesXDifferent $LesYDifferent $K "red"
MainLeveeSurUnCanva $K
}
proc ShowDifferentielBlastAlignement Selection {
global RepertoireDuGenome
Gs "Frame"
foreach DiffBlaAli [split $Selection "\n"] {
scan $DiffBlaAli "%s %s" Nom Rapport
if {[regexp NoMore $Rapport]} {
FaireLire "$Rapport for $Nom"
continue
}
scan $DiffBlaAli "%s %s %s %s %s %s %s" Nom BestBla BestAli DisBla DisAli Ecart Rapport
if {[regexp "Problem|Same" $Rapport]} {
FaireLire "$DiffBlaAli"
continue
}
set ToShow "$Nom\n$BestBla\n$BestAli"
set FichierMSF "$RepertoireDuGenome/msf/$Nom"
set MSF [ContenuDuFichier $FichierMSF]
regsub -nocase "Name: $BestBla oo " $MSF "Name: $BestBla $DisBla" MSF
regsub -nocase "Name: $BestAli oo " $MSF "Name: $BestAli $DisAli" MSF
set Fen [AfficheRognure $MSF $ToShow "" $FichierMSF "In"]
Illumine $BestAli $Fen
Illumine [string toupper $BestAli] $Fen
continue
}
}
proc MSFSelection {FichierOuTexteMSF LesAccess {InOut "In"}} {
if {[EstUnPAB $FichierOuTexteMSF]} { set FichierOuTexteMSF [GscopeFile $FichierOuTexteMSF "msf"] }
set TexteMSF $FichierOuTexteMSF
if { ! [regexp "\n" $FichierOuTexteMSF] && [file exists $FichierOuTexteMSF]} {
set TexteMSF [ContenuDuFichier $FichierOuTexteMSF]
}
if {$InOut=="In"} { set In 1 } else { set In 0 }
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
set InterestingAccess($ACCESS) 1
}
set LesNouveaux {}
foreach Ligne [split $TexteMSF "\n"] {
if {[regexp "^PileUp" $Ligne] || \
[regexp {^ANCHORS [0-9]+} $Ligne] || \
[regexp {^ +MSF\:} $Ligne] || \
! [regexp -nocase {[a-z0-9]} $Ligne] } { lappend LesNouveaux $Ligne ; continue }
set Tope 0
if {[regexp -nocase {Name: [a-z0-9_\:\-]} $Ligne]} {
scan $Ligne "%s %s" Name Access
} else {
scan $Ligne "%s" Access
}
set ACCESS [string toupper $Access]
set Tope [info exists InterestingAccess($ACCESS)]
if { $Tope && ! $In } { continue }
if { ! $Tope && $In } { continue }
lappend LesNouveaux $Ligne
}
return [join $LesNouveaux "\n"]
}
proc AfficheRognure {Page Selection Maniere NomDuFichierOrigine {InOut "In"}} {
if {$InOut=="Alone"} {
if {$Maniere=="Retour"} { return $Selection }
return [AfficheVariable $Selection $Maniere $NomDuFichierOrigine]
}
set LesAccess {}
foreach Ligne [split $Selection "\n"] {
regsub "Name:" $Ligne "" Ligne
set Access ""
scan $Ligne "%s" Access
if {$Access==""} { continue }
lappend LesAccess $Access
}
set NouvellePage [MSFSelection $Page $LesAccess $InOut]
if {$Maniere=="Retour"} { return $NouvellePage }
return [AfficheVariable $NouvellePage $Maniere "$NomDuFichierOrigine"]
}
proc FromDisphyOf {A B} {
FromDisphy $A
return [FromDisphy $B]
}
proc FromDisphy NomOuFichier {
global RepertoireDuGenome
global FromDisphy
Wup "returns the list of all accesses and stores the distances in memory"
set M [string toupper $NomOuFichier]
if {[info exists FromDisphy($M)]} { return [set FromDisphy($M)] }
if {[info exists FromDisphy]} { unset FromDisphy }
set Nom [file tail $NomOuFichier]
set FichierDisphy $NomOuFichier
if { ! [file exists $FichierDisphy]} {
set FichierDisphy "$RepertoireDuGenome/disphy/$Nom"
}
if { ! [file exists $FichierDisphy]} { return {} }
set LesAccess {}
foreach Ligne [LesLignesDuFichier $FichierDisphy] {
set Access ""
scan $Ligne "%s %s %s" Orga Dis Access
if {$Access==""} { continue }
set ACCESS [string toupper $Access]
set FromDisphy($ACCESS) $Dis
lappend LesAccess $Access
}
set FromDisphy($NomOuFichier) $LesAccess
return $LesAccess
}
proc LesAccessDuAPN NomOuFichier {
global RepertoireDuGenome
set Nom [file tail $NomOuFichier]
set FichierAPN $NomOuFichier
if { ! [file exists $FichierAPN]} {
set FichierAPN "$RepertoireDuGenome/apns/$Nom"
}
if { ! [file exists $FichierAPN]} { return {} }
set LesAccess {}
foreach Ligne [LesLignesDuFichier $FichierAPN] {
set Access ""
scan $Ligne "%s %s %s" BanqueId Access PN
if {$Access==""} { continue }
lappend LesAccess $Access
}
return $LesAccess
}
proc DifferentielBlastAlignementPourTous {} {
global RepertoireDuGenome
set FichierDiffBlaAli "$RepertoireDuGenome/fiches/diffblaali"
while {[file exists $FichierDiffBlaAli]} {
if {[OuiOuNon "The file differential blastp alignment already exists. \n Do I replace it ?"]} {
File delete $FichierDiffBlaAli
continue
}
if {[OuiOuNon "Do I append to it ?"]} {
foreach Ligne [LesLignesDuFichier $FichierDiffBlaAli] {
scan $Ligne "%s" Nom
set BlaAli($Nom) $Ligne
}
break
}
}
foreach Nom [ListeDesPABs] {
if {[info exists BlaAli($Nom)]} { continue }
set Differentiel [DifferentielBlastAlignement $Nom]
AppendAuFichier $FichierDiffBlaAli "$Differentiel"
if { [regexp " Same " $Differentiel]} { continue }
Espionne "$Differentiel"
}
return $FichierDiffBlaAli
}
proc DifferentielBlastAlignement Nom {
global RepertoireDuGenome
global NotreOS
global NotreOrga
set AvecShow 0
set FichierAli "$RepertoireDuGenome/disphy/$Nom"
if { ! [file exists $FichierAli]} { return "$Nom NoAli" }
set FichierBla "$RepertoireDuGenome/apns/$Nom"
if { ! [file exists $FichierBla]} { set FichierBla "$RepertoireDuGenome/blastp/$Nom" }
if { ! [file exists $FichierAli]} { return "$Nom NoBla" }
set DescriAli [AfficheLesDescriptifs $FichierAli "MemeOrdre" "LaListe"]
set LesBonsAli {}
foreach Ligne $DescriAli {
if {[regexp [ExpressionReguliereDesPABs] [lindex [split $Ligne " "] 0]]} { continue }
if {[regexp -nocase "OS:$NotreOS" $Ligne]} { continue }
lappend LesBonsAli $Ligne
}
if {$LesBonsAli=={}} { return "$Nom NoMoreAli" }
set DescriBla [AfficheLesDescriptifs $FichierBla "MemeOrdre" "LaListe"]
set LesBonsBla {}
foreach Ligne $DescriBla {
if {[regexp [ExpressionReguliereDesPABs] [lindex [split $Ligne " "] 0]]} { continue }
if {[regexp -nocase "OS:$NotreOS" $Ligne]} { continue }
lappend LesBonsBla $Ligne
}
if {$LesBonsBla=={}} { return "$Nom NoMoreBla" }
set Rapport "NotYetValued"
scan [lindex $LesBonsBla 0] "%s" BestBla
scan [lindex $LesBonsAli 0] "%s" BestAli
if {[string equal -nocase $BestBla $BestAli]} {
set Rapport "Same"
set Ecart 000
set DisBla 000
set DisAli 000
}
if {$Rapport!="Same"} {
FromDisphy $Nom
set DisBla [FromDisphy $BestBla]
set DisAli [FromDisphy $BestAli]
if { ! [regexp {^[0-9]+$} $DisBla] || ! [regexp {^[0-9]+$} $DisAli]} {
set DisBla 0
set DisAli 0
set Ecart 0
set Rapport "Problem"
} else {
scan [RapportDuDifferentiel $DisBla $DisAli] "%s %d" Rapport Ecart
}
}
set Fragments ".."
if {$Rapport!="Same"} {
set DEBla [ChampDuDescriptif [LeDescriptif $BestBla $Nom] DE]
set DEAli [ChampDuDescriptif [LeDescriptif $BestAli $Nom] DE]
set FraBla [regexp -nocase "FRAGMENT" $DEBla]
set FraAli [regexp -nocase "FRAGMENT" $DEAli]
if {$FraBla} { set FraBla "F" } else { set FraBla "-" }
if {$FraAli} { set FraAli "F" } else { set FraAli "-" }
set Fragments "$FraBla$FraAli"
}
set Beau [format "%s %-9s %-9s %3d %3d %3d %-10s %s" \
$Nom $BestBla $BestAli $DisBla $DisAli $Ecart $Rapport $Fragments]
return $Beau
}
proc ReorganiseLesDescriptifs Nom {
global RepertoireDuGenome
set FichierDescriptif "$RepertoireDuGenome/descriptifs/$Nom"
set FichierBlastP "$RepertoireDuGenome/blastp/$Nom"
foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
regsub "Viridiplantae; Embryophyta;" $Ligne "Viridiplantae; Streptophyta; Embryophyta;" Ligne
ScanLaListe [split $Ligne "="] Access Reste
if {[info exists D($Access)] && [set D($Access)]!=$Ligne} {
set Stock [set D($Access)]
if {[regexp "Genre espece" $Stock] && ! [regexp "Genre espece" $Ligne]} {
set D($Access) $Ligne
continue
}
if { ! [regexp "Genre espece" $Stock] && [regexp "Genre espece" $Ligne]} { continue }
if { ! [regexp "Escherichia coli. OX:" $Stock] && [regexp "Escherichia coli. OX:" $Ligne]} { continue }
if { [regexp "Escherichia coli. OX:" $Stock] && ! [regexp "Escherichia coli. OX:" $Ligne]} {
set D($Access) $Ligne
continue
}
set i 0
while {1} {
if {[string index $Stock $i]!=[string index $Ligne $i]} { break }
incr i
}
set d [expr $i-40]
set f [expr $i+100]
set Fen [AfficheVariable "[string range $Stock $d $f]\n[string range $Ligne $d $f]" "AvecRien"]
set Garde [expr ! [OuiOuNon "Je prend le second ?"]]
after idle destroy $Fen
if {$Garde} { continue }
}
set D($Access) $Ligne
}
exit
}
proc CreeStartCodonSummary {{Ask ""}} {
global RepertoireDuGenome
set FichierSummary "$RepertoireDuGenome/fiches/startcodon_summary"
if {$Ask=="FileName" && [file exists $FichierSummary]} { return $FichierSummary }
if {$Ask=="" || $Ask=="Replace"} { set Ask 0 } else { set Ask 1}
if {[file exists $FichierSummary]} {
if { ! $Ask || [OuiOuNon "$FichierSummary\n already exists. Do I keep it ?" 0]} {
File delete $FichierSummary
} else {
return $FichierSummary
}
}
set Sortie {}
foreach Nom [ListeDesPABs] {
set Poch [ExtraitInfo $Nom "met"]
set MetRR [ExtraitInfo $Nom "MetRR"]
set CS [CodonStart $Nom]
if {$CS==""} { continue }
set TailleDuGroupe 999
set NombreDeSequences 999
if {[regexp "GroupSize" $CS]} {
scan $CS "%s %d %d" Bidon TailleDuGroupe NombreDeSequences
regsub {GroupSize [0-9]+ [0-9]+ } $CS "" CS
}
set LesDejaVus {}
set OldOv [OverlapAtStart $Nom]
FromDisphy $Nom
Espionne "$Nom $CS"
if { ! [regexp -nocase {^[A-Z]+ [0-9]+ } $CS]} { continue }
if {[regexp -nocase " / " $CS]} {
FaireLire "I found an error in CodonStart. Please correct it"
set CS [Entre $CS]
}
foreach {AA P Accesses} [split $CS " "] {
set NewOv [expr $OldOv - ($P-1)*3]
if {$NewOv<0} { set NewOv "+[expr -$NewOv]" }
set LesAccess [split $Accesses "/"]
set nAcc [llength $LesAccess]
set CumulDisAli 0
set nCumul 0
set Distances ""
foreach Access $LesAccess {
set DisAli [FromDisphy $Access]
append Distances "/$DisAli"
if {$DisAli==""} { continue }
incr nCumul
incr CumulDisAli $DisAli
}
if {$nCumul==0} {
set MoyDisAli 999
} else {
set MoyDisAli [expr $CumulDisAli/$nCumul]
}
Espionne "$Accesses\n$Distances $MoyDisAli"
set GGTtoATG [ShineDalgarnoSiNouveauMet $Nom $P]
set iGGT [string length $GGTtoATG]
if {$MetRR==""} {
set RemarquePochOuMetRR $Poch
} else {
scan $MetRR "%s %d" MVL BonMet
if {$BonMet==$P} {
set RemarquePochOuMetRR "Better $MetRR"
} else {
set RemarquePochOuMetRR ""
}
}
lappend LesDejaVus [format "$Nom %3d %s %4d %3d %4s %3d/%3d %3d %3d = %-20s %s" \
$iGGT $AA $P $OldOv $NewOv \
$nAcc $TailleDuGroupe $NombreDeSequences $MoyDisAli \
$RemarquePochOuMetRR $GGTtoATG]
}
if {$LesDejaVus=={}} { continue }
lappend Sortie "\n[join $LesDejaVus "\n"]"
}
return [SauveLesLignes $Sortie dans $FichierSummary]
}
proc StartCodonSummary {Nom {Quoi "Summary"}} {
global StartCodonSummary
if {[info exists StartCodonSummary($Nom,$Quoi)]} {
return [set StartCodonSummary($Nom,$Quoi)]
}
if {[info exists StartCodonSummary("EstCharge",Summary)]} {
if {[info exists StartCodonSummary("EstCharge",Quoi)]} {
return [set StartCodonSummary("EstCharge",$Quoi)]
} else {
return "NoSummaryExists"
}
}
set FichierSummary [CreeStartCodonSummary "FileName"]
if {$FichierSummary==""} {
set StartCodonSummary("EstCharge",Summary) "NoSummaryAvalaible"
return [StartCodonSummary $Nom $Quoi]
}
foreach Ligne [LesLignesDuFichier $FichierSummary] {
if { ! [regexp -nocase {[A-Z]} $Ligne]} { continue }
if {[regexp {[0-9]\+} $Ligne]} { regsub {\+} $Ligne " +" Ligne }
scan $Ligne "%s" NomLu
regsub "$NomLu *" $Ligne "" Summary
lappend StartCodonSummary($NomLu,Summary) $Summary
scan $Summary "%d %s %d" iGGT AA P
set StartCodonSummary($NomLu,$P) $Summary
}
set StartCodonSummary("EstCharge",Summary) "NoSummaryExists"
return [StartCodonSummary $Nom $Quoi]
}
proc ShineDalgarnoSiNouveauMet {Nom {P 0}} {
global MotifShineDalgarno
incr P -1
if { ! [info exists MotifShineDalgarno]} {
set Motif [CreeLesFichiersDesShineDalgarnoDesPABs "LeMotifMerci"]
}
set Motif $MotifShineDalgarno
Wup "returns 1 if ShineDalgarno before alternative Met at position P"
set MinSD -18
set MaxSD -3
set Debut [Box $Nom debut]
set Fin [Box $Nom fin]
set Orient [Box $Nom orient]
if {$Orient=="F"} {
set D [expr $Debut + $P*3 + $MinSD]
set F [expr $Debut + $P*3 + $MaxSD]
set dATG $D
set fATG [expr $Debut + $P*3 + 2]
} else {
set D [expr $Fin - $P*3 - $MinSD]
set F [expr $Fin - $P*3 - $MaxSD]
set dATG [expr $Fin - $P*3 - 2]
set fATG $F
}
set PlageSD [BoutADN $D $F $Orient]
if { ! [regexp -indices -nocase $Motif $PlageSD Indices]} { return "" }
set i [lindex $Indices 0]
set PlageAvantATG [BoutADN $dATG $fATG $Orient]
set GGTtoATG [string range $PlageAvantATG $i end]
set GGT [string range $GGTtoATG 0 2]
set ggt [string tolower $GGT]
set ATG [string range $GGTtoATG end-2 end]
set atg [string tolower $ATG]
regsub "^$GGT" $GGTtoATG "$ggt" GGTtoATG
regsub "$ATG$" $GGTtoATG "$atg" GGTtoATG
set iGGT [expr -($MinSD+$i)]
return $GGTtoATG
}
proc LesMetsTropLoin {{Quoi "faux"}} {
foreach Nom [ListeDesPABs] {
set Valeur [CodonStart $Nom]
if {$Valeur==""} { continue }
foreach {M P As} [split $Valeur " "] {
set Poch [ExtraitInfo $Nom "met"]
if {[regexp "faux" $Poch]} {
lappend Lesfaux "$P faux $Nom"
}
if {[regexp "ok" $Poch]} {
if {[info exists DejaVu($Nom)]} { continue }
lappend Lesok "$P ok $Nom"
}
if {[regexp "plau" $Poch]} {
if {[info exists DejaVu($Nom)]} { continue }
lappend Lesplau "$P plau $Nom"
}
set DejaVu($Nom) 1
}
}
return [join [set Les$Quoi] "\n"]
}
proc EstUnFichierBlastP Fichier {
set PremierMot [join [LesPremieresLignesDuFichier $Fichier 3] ""]
Espionne $PremierMot
return [regexp -nocase {^[ \t\n]*BLASTP} $PremierMot]
}
proc TestOrgaDuDescriptif {Nom1 Nom2} {
global RepertoireDuGenome
foreach Nom [list $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2 $Nom1 $Nom2] {
Espionne $Nom
set FichierDescriptif "$RepertoireDuGenome/descriptifs/$Nom"
set LesAccess {}
foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
ScanLaListe [split $Ligne "="] Access
lappend LesAccess $Access
Espionne $Access
}
set O [LesOrgasDesAccess $LesAccess Court $Nom]
}
exit
}
proc OrgaDuDescriptif {Access Nom} {
global RepertoireDuGenome
global OrgaDuDescriptif
if {[info exists OrgaDuDescriptif($Access)]} { return [set OrgaDuDescriptif($Access)] }
if {[info exists OrgaDuDescriptif($Nom,"EstCharge")]} { return "" }
if {[info exists OrgaDuDescriptif]} { unset OrgaDuDescriptif }
set OrgaDuDescriptif($Nom,"EstCharge") 1
set FichierDescriptif "$RepertoireDuGenome/descriptifs/$Nom"
if { ! [file exists $FichierDescriptif]} { return "coucou" }
foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
ScanLaListe [split $Ligne "="] AC Reste
ScanLaListe [split $Ligne " "] Bidon OSGenre Espece
regsub "OS\:" $OSGenre "" Genre
set Organisme "$Genre $Espece"
set OrgaDuDescriptif($AC) $Organisme
}
if {[info exists OrgaDuDescriptif($Access)]} {
return [set OrgaDuDescriptif($Access)]
} else {
return ""
}
}
proc Hydrophobicity {Nom {Quoi "nHelices"}} {
global RepertoireDuGenome
global Hydrophobicity
Wup "Quoi can be nHelices Hydro or OwnHydro"
if {[info exists Hydrophobicity($Nom,$Quoi)]} { return [set Hydrophobicity($Nom,$Quoi)] }
if {[info exists Hydrophobicity]} { return -999 }
set FichierHydrophobicity "$RepertoireDuGenome/fiches/hydrophobicity"
if {[file exists $FichierHydrophobicity]} {
foreach Ligne [LesLignesDuFichier $FichierHydrophobicity] {
scan $Ligne "%s %d %f %f" NomLu nHelices Hydro OwnHydro
set Hydrophobicity($NomLu,nHelices) $nHelices
set Hydrophobicity($NomLu,OwnHydro) $OwnHydro
set Hydrophobicity($NomLu,Hydro) $Hydro
}
set Hydrophobicity(EstChargee) 1
return [Hydrophobicity $Nom $Quoi]
}
if { ! [OuiOuNon "Do I calculate all hydrophobicities ?"]} {
set Hydrophobicity(EstChargee) 1
return [Hydrophobicity $Nom $Quoi]
}
foreach PAB [ListeDesPABs] {
set Texte [Hydrophobicities $PAB]
if {$Texte==""} {
set Hydro -2
set SonHydro -2
set nHelices -2
} else {
foreach Ligne [split [Hydrophobicities $PAB] "\n"] {
if {[regexp "\[ \t\]$PAB\[ \t\]+" $Ligne]} {
scan $Ligne "%s %f %f %d %d" Bidon SonHydro P Long nHelices
}
if {[regexp "^GES " $Ligne]} { scan $Ligne "%s %f" Bidon Hydro }
}
}
set Hydrophobicity($PAB,OwnHydro) $SonHydro
set Hydrophobicity($PAB,Hydro) $Hydro
set Hydrophobicity($PAB,nHelices) $nHelices
lappend LesHydros "$PAB $nHelices $Hydro $SonHydro"
}
SauveLesLignes $LesHydros dans $FichierHydrophobicity
return [Hydrophobicity $Nom $Quoi]
}
proc Hydrophobicities {Fichier {DuParalogue ""}} {
global RepertoireDuGenome
if {$DuParalogue==""} {
set Rep "$RepertoireDuGenome/msf"
} else {
set Rep "$RepertoireDuGenome/msfparalogues"
}
set Nom [file tail $Fichier]
if { ! [file exists $Fichier]} { set Fichier "$Rep/$Nom" }
if { ! [file exists $Fichier]} { return {} }
if {[catch {set Texte [eval exec "gesscale $Fichier -v"]} Message]} {
return ""
}
return $Texte
}
proc AfficheLesDescriptifs {Source {Ordre "MemeOrdre"} {QuoiRetourner ""} {LesAccessOrdonnes ""} {LesClefs ""} {NomOrigine ""}} {
#rR Source can be Texte, a file or descriptif/Nom msf/Nom rsf/Nom blast/Nom etc.
#rR il y a une petite confusion a regler pour LesAccessOrdonnees
#rR attention je croyais que ca marcherait si on donne une source qui n'est pas du même projet !!!
#rR ca ne marche pas si on prend MemeOrdre qu'un fichier Macsim par exemple car LeDescriptif est trop spécfique au projet Gscope :'( A VOIR
Wup "Attention: blast doesn't rearrange the order of the file"
if {[regexp "\n" $Source]} {
set TmpMSF "[TmpFile].msf"
Sauve $Source dans $TmpMSF
set NomOuFichier $TmpMSF
} else {
set NomOuFichier $Source
while {[FileAbsent $NomOuFichier]} {
set Possible "[RepertoireDuGenome]/$NomOuFichier"
if {[FileExists $Possible]} { set NomOuFichier $Possible; break }
if {[EstUnPAB $NomOuFichier]} {
#rR on priviligie le MSF
set Possible "[RepertoireDuGenome]/msf/$NomOuFichier"
if {[FileExists $Possible]} { set NomOuFichier $Possible; break }
}
if {[regexp "rsf" $NomOuFichier]} {
set Queue [file tail $NomOuFichier]
set Possible "[RepertoireDuGenome]/macsimRsf/$Queue"
if {[FileExists $Possible]} { set NomOuFichier $Possible; break }
}
FaireLire "I can not find $NomOuFichier"
return ""
}
}
if {$NomOrigine==""} { set NomOrigine $NomOuFichier }
set Nom [file tail $NomOrigine]
set RepDesc "[RepertoireDuGenome]/descriptifs"
set PossibleRepDesc "[file dirname [file dirname $Source]]/descriptifs"
if {[file exists $PossibleRepDesc/$Nom]} { set RepDesc $PossibleRepDesc }
if { 0 && [regexp "/" $NomOuFichier] && [file exists $NomOuFichier]} {
#rR a mis 0 ... 20150521 ..................................................... ca merde ... si le projet n'est pas le RepertoireDuGenome
set FichierDescriptif $NomOuFichier
} else {
set FichierDescriptif "$RepDesc/$Nom"
}
set FichierModele "NeDoitPasExister"
if {[FileAbsent $FichierDescriptif]} { return "" }
if {$Ordre=="Natif"} { set LesDes [LesLignesDuFichier $FichierDescriptif] ; set NomOuFichier $FichierDescriptif }
if {$Ordre=="MemeOrdre" && [regexp -nocase "msf|clustal" $NomOuFichier]} {
DecortiqueUnMSF $NomOuFichier LesAccessOrdonnes
}
if {$Ordre=="MemeOrdre" && [regexp -nocase "rsf" $NomOuFichier]} {
DecortiqueUnRSF $NomOuFichier LesAccessOrdonnes
}
if {$Ordre=="MemeOrdre" && [regexp -nocase "blast" $NomOuFichier]} {
DecortiqueBlast $NomOuFichier 0.001 "SansLimiteDeNombre" Query lBA LesAccessOrdonnes lDE lProfil lPN
}
if {$Ordre=="MemeOrdre" && [regexp -nocase "aliinout" $NomOuFichier]} {
set LesAccessOrdonnes [LesAccessDuAliInOut $NomOuFichier]
}
if {$Ordre=="MemeOrdre" && [regexp -nocase "disphy" $NomOuFichier]} {
set LesAccessOrdonnes [FromDisphy $NomOuFichier]
}
if {$Ordre=="MemeOrdre" && [regexp -nocase "apns" $NomOuFichier]} {
set LesAccessOrdonnes [LesAccessDuAPN $NomOuFichier]
}
if {[info exists LesAccessOrdonnes] && $LesAccessOrdonnes!=""} {
if { ! [info exists lBA]} { set lBA $LesAccessOrdonnes }
foreach Access $LesAccessOrdonnes BA $lBA {
set Des [LeDescriptif $Access $Nom]
if {[regexp "no description" $Des]} {
regsub {^PDB_} $BA "PDB:" BA
set Des [LeDescriptif $BA $Nom]
}
if {[regexp "no description" $Des]} {
regsub {^[^\:]+:} $BA "" BA
set Des [LeDescriptif $BA $Nom]
}
lappend LesDes $Des
}
} else {
set LesDes [LesLignesDuFichier $FichierDescriptif]
}
foreach Descriptif $LesDes {
set BeauDes [MiseEnPageDuDescriptif $Descriptif $LesClefs]
lappend LesBeauxDes $BeauDes
}
if {[info exists TmpMSF] && [file exists $TmpMSF]} { file delete -force $TmpMSF }
if { $QuoiRetourner == "PourGif" } {
return [join $LesBeauxDes "\n"]
} elseif { $QuoiRetourner == "LaListe" } {
return $LesBeauxDes
} else {
return [AfficheVariable [join $LesBeauxDes "\n"] "GrandeLargeurAvecAligneurs" $NomOrigine]
}
}
proc AfficheLesDescriptifsDuMSF NomOuFichier {
global LesDescriptifs
set Nom [file tail $NomOuFichier]
if {[regexp "/" $NomOuFichier] && [file exists $NomOuFichier]} {
set Fichier $NomOuFichier
} else {
set Fichier "[RepertoireDuGenome]/msf/$Nom"
}
if { ! [file exists $Fichier]} { return "" }
set MSFdesCopains [expr [OnTraiteUneCollection] && [YaPABdans $Nom]]
set LesAccess {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp "//" $Ligne]} { break }
if { ! [regexp "Name\:" $Ligne]} { continue }
scan $Ligne "%s %s" Name Access
if {[info exists LesDescriptifs($Access)]} { continue }
lappend LesAccess $Access
}
if {$LesAccess!={} && ! $MSFdesCopains} {
PrepareLesSequencesDesBanques $LesAccess $LesAccess
}
set AuMoinsUneDescription 0
foreach Access $LesAccess {
if {[info exists LesDescriptifs($Access)]} {
set Descriptif [set LesDescriptifs($Access)]
} else {
if {0 && $MSFdesCopains} {
set LesLignesEMBL [split [CoCherche "embl" $Nom $Access] "\n"]
} else {
set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"]
}
if {$LesLignesEMBL=={} } {
lappend Liste "$Access (no description)"
continue
}
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
set Descriptif "$Access OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX: $OX"
set LesDescriptifs($Access) $Descriptif
}
lappend Liste [MiseEnPageDuDescriptif $Descriptif]
set AuMoinsUneDescription 1
}
if { ! $AuMoinsUneDescription || ! [info exists Liste]} { return "" }
return [AfficheVariable [join $Liste "\n"] "AvecAligneurs" $Fichier]
}
proc LeDescriptifDuPAB Nom {
set OS [NotreOS]
set OC [NotreOC]
set OX [NotreOX]
set DE [Definition $Nom]
set GN [NomDeGene $Nom]
set ID $Nom
set AC $Nom
set Descriptif "$Nom OS:$OS GN:$GN DE:$DE ID:$ID AC:$AC OC:$OC OX:$OX"
return $Descriptif
}
proc LeDescriptif {Access {Nom ""} {Texte ""}} {
global LesDescriptifs
global NomDesDescriptifsEnMemoire
Wup "if Texte isn't empty it returns the old value and sets the new one"
if {$Texte!=""} {
if {[info exists LesDescriptifs($Access)]} {
set Old [set LesDescriptifs($Access)]
set LesDescriptifs($Access) $Texte
set LesDescriptifs([string toupper $Access]) $Texte
return $Old
}
}
if {[info exists LesDescriptifs($Access)]} { return [set LesDescriptifs($Access)] }
set FichierDescriptif "[RepertoireDuGenome]/descriptifs/$Nom"
if {$Nom!="" && [file exists $FichierDescriptif]} {
if {[info exists NomDesDescriptifsEnMemoire] && $NomDesDescriptifsEnMemoire==$Nom} {
return "$Access (no description available in descriptifs/$Nom)"
}
set LesDescriptifs(${Nom}_isloaded) $Nom
if {[info exists LesDescriptifs]} { unset LesDescriptifs }
set LeDescDuPAB [LeDescriptifDuPAB $Nom]
set LesDescriptifs($Nom) $LeDescDuPAB
foreach Ligne [LesLignesDuFichier $FichierDescriptif] {
set iEgal [string first "=" $Ligne]
set AccessLu [string range $Ligne 0 [expr $iEgal -1]]
set Descript [string range $Ligne [expr $iEgal +1] end]
set LesDescriptifs($AccessLu) $Descript
set LesDescriptifs([string toupper $AccessLu]) $Descript
set Id [StringApres "ID:" dans $Ligne]
set ID [string toupper $Id]
regsub $AccessLu $Descript $Id Descript
if { ! [info exists LesDescriptifs($Id)] } { set LesDescriptifs($Id) $Descript }
if { ! [info exists LesDescriptifs($ID)] } { set LesDescriptifs($ID) $Descript }
}
set NomDesDescriptifsEnMemoire $Nom
if {$Texte!=""} {
#rR attention le descriptif du Id n'est pas mis à jour !!!!!!!!!!!
if {[info exists LesDescriptifs($Access)]} {
set Old [set LesDescriptifs($Access)]
set LesDescriptifs($Access) $Texte
set LesDescriptifs([string toupper $Access]) $Texte
return $Old
}
}
if {[info exists LesDescriptifs($Access)]} { return [set LesDescriptifs($Access)] }
if {$Nom==$Access} { return [LeDescriptifDuPAB $Nom] }
return "$Access (no description)"
}
}
proc StockeLeDescriptif {Access Texte {PourQui ""}} {
global LesDescriptifs
if { ! [regexp "^file_" $PourQui] && [YaPABdans $PourQui]} {
set RepDesc "[RepertoireDuGenome]/descriptifs"
if { ! [file exists $RepDesc]} { File mkdir $RepDesc }
set Nom $PourQui
Wup "It does not yet exist or has an other value"
if {[LeDescriptif $Access $Nom $Texte]!=$Texte} {
return [AppendAuFichier "$RepDesc/$Nom" "$Access=$Texte"]
}
return "$RepDesc/$Nom"
}
if {$PourQui==""} {
puts stdout "$Access=$Texte"
return
}
if {[regexp "file_" $PourQui]} {
regsub "file_" $PourQui "" Fichier
return [AppendAuFichier $Fichier "$Access=$Texte"]
}
if {[regexp "itself_?" $PourQui]} {
set Descriptif "$Access=$Texte"
return [MiseEnPageDuDescriptif $Descriptif]
}
return
}
proc MiseEnPageDuDescriptif {Descriptif {LesClefs ""}} {
set Texte $Descriptif
set ID ""
scan $Texte "%s" ID
if {[regexp {^[^ ]+=} $Texte]} {
set iEgal [string first "=" $Texte]
set Texte [string range $Texte [incr iEgal] end]
}
set OX [ChampDuDescriptif $Descriptif OX]
if {[regexp " " $OX]} { regsub {OS\:} $Texte "OS: $OX " Texte }
set LesClefsDefaut { OS GN DE ID AC OC OX}
set IncrementsDefaut {30 15 150 15 15 120 10}
set NouvelleManiere 0
if {$LesClefs=={}} {
set LesClefs $LesClefsDefaut
set Increments $IncrementsDefaut
} else {
set NouvelleManiere 1
set Increments {}
foreach C $LesClefs {
set i [lsearch $LesClefsDefaut $C]
lappend Increments [lindex $IncrementsDefaut $i]
}
}
if {$NouvelleManiere} {
set Texte [format "%-15s" $ID]
foreach Clef $LesClefs Increment $Increments {
set Valeur [ChampDuDescriptif $Descriptif $Clef]
append Texte "\t$Clef:[format %-${Increment}s $Valeur]"
}
return $Texte
}
set BonnePosition 0
foreach Clef $LesClefs Increment $Increments {
incr BonnePosition $Increment
set Position [string first "$Clef\:" $Texte]
if {$Position < 0} { return $Texte }
if {$Position < $BonnePosition} {
set Debut [string range $Texte 0 [expr $Position-1]]
set Suite [string range $Texte [expr $Position] end]
set Blanc [string repeat " " [expr $BonnePosition-$Position-1]]
set Texte "$Debut$Blanc$Suite"
}
}
return $Texte
}
proc ChampDuDescriptif {Descriptif Clef} {
if {$Descriptif==""} { return "" }
set iClef [string first "$Clef:" $Descriptif]
if {$iClef<0} { return "" }
set iSuivant [string first ":" [string range $Descriptif [incr iClef 3] end]]
if {$iSuivant<0} {
set iSuivant end
} else {
incr iSuivant [expr $iClef-3]
}
return [string trim [string range $Descriptif $iClef $iSuivant]]
}
proc GardeQueLesMinusculesDesDescriptifs {} {
Wup "Avant les descriptifs etaient essentiellement en majuscule"
Wup " S'il y a conflit ... je ne garde que le minuscule."
set OldAccess ""
set OldLigne ""
foreach Ligne [LesLignesDuFichier "lesdescriptifs"] {
set iEgal [string first "=" $Ligne]
set Access [string range $Ligne 0 [incr iEgal -1]]
set Descriptif [string range $Ligne [incr iEgal 2] end]
if {$OldAccess==$Access} {
set OldLigne ""
}
if {$OldLigne!=""} {
lappend BonnesLignes $OldLigne
}
set OldAccess ""
set OldLigne $Ligne
set OldAccess $Access
set OldDescriptif $Descriptif
}
if {$Ligne!=""} {
lappend BonnesLignes $Ligne
}
SauveLesLignes $BonnesLignes dans "lesdescriptifs.nouveau"
}
proc DecrisLaLigne {W x y {Efface ""}} {
regsub ".list" $W ".message" M
catch {destroy $M}
if {$Efface!=""} {
return ""
}
set Ligne [$W get @$x,$y]
set Access ""
set AccessBis ""
scan $Ligne "%s %s" Access AccessBis
set Descr [LeDescriptif $Access]
if {$Descr=="" || [regexp "no description" $Descr]} {
set Descr [LeDescriptif $AccessBis]
}
if {$Descr=="" || [regexp "no description" $Descr]} { return "" }
set OX [ChampDuDescriptif $Descr OX]
if {[regexp " " $OX]} {
foreach TaxId [split $OX " "] {
set OS [Tax $TaxId]
append Descr "($TaxId=$OS )"
}
}
regsub -all {[A-Z][A-Z]:} $Descr "\n& " Texte
message $M -borderwidth 3 -font {Courier 10} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
place $M -x 10 -y $y -anchor w
}
proc MDScoreAvecSelectionDuFichier {FichierMSF LesAccess {InOut "In"}} {
return [MDScoreAvecSelection [ContenuDuFichier $FichierMSF] $LesAccess $InOut]
}
proc MDScoreAvecSelection {TexteMSF LesAccess {InOut "In"}} {
if {[llength $LesAccess]<2} { return -9999.0 }
set MSFSelection [MSFSelection $TexteMSF $LesAccess $InOut]
if {$MSFSelection==""} { return -9999.0 }
return [MDScore $MSFSelection "IsText"]
}
proc NormdEnStock {Nom {Rep ""}} {
regsub "blastp" $Rep "" Rep
#rR on suppose que tous les Normd on deja ete calcules pour chaque type d'alignement correspondant à Rep
#rR march surtou pour CilioCode, attention a adapter pour les autres
global NormdEnStock
if {[info exists NormdEnStock($Nom,$Rep)]} { return $NormdEnStock($Nom,$Rep) }
if {[info exists NormdEnStock("EstCharge")]} { return -8888.8 }
set NormdEnStock("EstCharge") 1
foreach FichierNormd [glob -nocomplain "[Fiches]/md_scores*"] {
set Q [file tail $FichierNormd]
regsub {md_scores\.?} $Q "" R
foreach Ligne [LesLignesDuFichier $FichierNormd] {
scan $Ligne "%s %s" N V
set NormdEnStock($N,$R) $V
}
}
return [NormdEnStock $Nom $Rep]
}
proc NormdPourTous {{Force ""}} {
return [Normd "LaListeMerci" $Force]
}
proc Normd {MSFouNom {Force ""}} {
return [MDScore $MSFouNom $Force]
}
proc MDScore {MSFouNom {Force ""}} {
global MDScore
global RepertoireDuGenome
Wup "Force can be CalculeMoi or IsText if MSFouNom is the text of the MSF itself"
if {$Force=="IsText"} {
set MSF $MSFouNom
set FichierMSF [TmpFile]
Sauve $MSF dans $FichierMSF
set Nom ""
set Force "CalculeMoi"
} else {
set Nom $MSFouNom
if {$Nom=="LaListeMerci" && [info exists MDScore("LaListeMerci")]} {
return [set MDScore("LaListeMerci")]
}
set FichierMSF $Nom
set Nom [file tail $FichierMSF]
}
set CalculeMoi [string equal -nocase "CalculeMoi" $Force]
if { ! $CalculeMoi && $Nom!="" && [info exists MDScore($Nom)]} { return [set MDScore($Nom)] }
if { ! [file exists $FichierMSF]} {
set FichierMSF "$RepertoireDuGenome/msf/$Nom"
}
if { $Nom!="LaListeMerci" && ($CalculeMoi || ! [YaPABouTROUouTRNAouARNenDebutDe $Nom])} {
set CommandeMDScore "normd $FichierMSF"
set MD ""
if { ! [catch {set MD [eval exec $CommandeMDScore]} Message]} {
if { ! [regexp {[0-9]} $MD]} {
Warne "MDScore ne rend pas de nombre mais $Message"
return -9999.4
}
set Score ""
scan $MD "%s %f" NomDuFich Score
if {[regexp {^[0-9\-\+\.eE]+$} $Score]} {
set MD $Score
} elseif {[regexp {^[0-9\-\+\.eE]+$} $NomDuFich]} {
set MD $NomDuFich
} else {
set MD $MD
}
return $MD
} else {
Warne "MDScore se plante par $Message"
return -9999.0
}
}
set FichierMDs "$RepertoireDuGenome/fiches/md_scores"
if {[file exists $FichierMDs] && [ContenuDuFichier $FichierMDs]!=""} {
foreach Ligne [LesLignesDuFichier $FichierMDs] {
set MD ""
scan $Ligne "%s %s %s" NomLu MDouFichier MD
if {$MD==""} { set MD $MDouFichier }
if {$MD==""} { set MD -9999.5 }
set MDScore($NomLu) $MD
lappend MDScore(LaListeMerci) "$NomLu $MD"
}
if {[info exists MDScore($Nom)]} {
return [set MDScore($Nom)]
} else {
if {$Force=="CalculeMoiSiManquant"} {
set MD [MDScore $Nom "CalculeMoi"]
lappend MDScore(LaListeMerci) "$Nom $MD"
set LesNomMD [lsort [set MDScore(LaListeMerci)]]
SauveLesLignes $LesNomMD dans $FichierMDs
return $MD
}
return -9999.8
}
}
if { ! [OuiOuNonMemo "Do I calculate now all MDscores (NorMD) ... ?"]} { return -9999.3 }
foreach NomLu [ListeDesPABs] {
if {[info exists MDScore($NomLu)]} { continue }
set FichierMSF "$RepertoireDuGenome/msf/$NomLu"
if { ! [file exists $FichierMSF] } {
set MD -9999.7
} elseif { [regexp -nocase "NoSequencesToAlign" [ContenuDuFichier $FichierMSF]] } {
set MD -9999.7
} else {
set MD [MDScore $FichierMSF "CalculeMoi"]
}
set MDScore($NomLu) $MD
Espionne "$NomLu $MD"
AppendAuFichier $FichierMDs "$NomLu $MD"
}
if {[info exists MDScore($Nom)]} {
return [set MDScore($Nom)]
} else {
return -9999.6
}
}
proc FichierMiniConfig {} {
global RepertoireDuGenome
return "$RepertoireDuGenome/beton/miniconfig"
}
proc FichierBlastPDuPAB Nom {
global RepertoireDuGenome
return "$RepertoireDuGenome/blastp/$Nom"
}
proc LesDefinitionsRevisitees {} {
foreach Nom [ListeDesPABs] {
set NotreDE [string trim [Definition $Nom] "."]
set NarciDE [string trim [ExtraitInfo $Nom "DE_Narcisse"] "."]
if {[string toupper $NotreDE]==[string toupper $NarciDE]} { continue }
if {[regexp "Hypothetical protein" $NotreDE] \
&& [regexp {HYPOTHETICAL [0-9\.]* KDA PROTEIN} $NarciDE] } { continue }
Espionne $Nom
Espionne "$NotreDE\n$NarciDE"
lappend LesNouveaux $Nom
}
return $LesNouveaux
}
proc LaManierePourAffiche TypeDeFichier {
set PourNotes 0
set PourNuc 0
set PourProt 0
set PourBlast 0
set PourMSF 0
set Rep [file tail [file dirname $TypeDeFichier]]
if {[regexp -nocase {^notes} $Rep]} {
set PourNotes 1
}
if {[regexp -nocase {^(copain|tfa)} $Rep]} {
set PourNuc 1
}
if {[regexp -nocase {nuctfa|nucembl} $Rep]} {
set PourNuc 1
}
if {[regexp -nocase {prottfa|protembl} $Rep]} {
set PourProt 1
}
if {[regexp -nocase {(TBlast|Blast|Ballast)} $Rep]} {
set PourBlast 1
}
if {[regexp -nocase {(MSF|Clustal|DbClustal)} $Rep]} {
set PourMSF 1
}
set LesAvecs {}
if {$PourNuc} { lappend LesAvecs "AvecBlaste" "AvecFormate"}
if {$PourProt} { lappend LesAvecs "AvecBlaste" "AvecFormate"}
if {$PourBlast} { lappend LesAvecs "AvecAligneurs" "AvecSegAlignements" }
if {$PourMSF} { lappend LesAvecs "AvecEtudeMSF" "GrandeLargeur"}
if {[OnTraiteDesClones]} {
if {$PourNotes} {
lappend LesAvecs "AvecOli"
lappend LesAvecs "AvecShowItsOligos"
}
}
set LesAvecs [lsort -unique $LesAvecs]
return [join $LesAvecs ""]
}
proc PourcentageDeStops {} {
global RepertoireDuGenome
Wup "Ecrit pour Philippe Dumas, pour trouver les codons stop en frame shift dans chaque prot"
set CumulFavorable(1) 0
set CumulFavorable(2) 0
set CumulPossible(1) 0
set CumulPossible(2) 0
set nSansRien 0
set MaxVoulus -1
foreach Nom [ListeDesPABs] {
if { ! [incr MaxVoulus -1]} { break }
set Debut [Box $Nom debut]
set Fin [Box $Nom fin]
set Orient [Box $Nom orient]
set Seq [BoutADN $Debut $Fin $Orient]
set Long [string length $Seq]
foreach Decalage {1 2} {
set nStops 0
set nCodons 0
set nSansRien 0
for {set i $Decalage} {$i < [expr $Long-3]} {incr i 3} {
incr nCodons
incr CumulPossible($Decalage)
set Codon [string range $Seq $i [expr $i+2]]
if {[CodonStopPossible $Codon]} {
incr CumulFavorable($Decalage)
incr nStops
if {$nSansRien>0} {
lappend LesSansRien($Decalage) $nSansRien
}
set nSansRien 0
} else {
incr nSansRien
}
}
set Pourcent($Decalage) [expr 100.*$nStops/$nCodons]
}
# Espionne "$Nom [format "%4.1f" $Pourcent(1)] [format "%4.1f" $Pourcent(2)]"
}
Histogramme [set LesSansRien(1)] "Graphe"
Histogramme [set LesSansRien(2)] "Graphe"
Espionne "$CumulFavorable(1) / $CumulPossible(1) $CumulFavorable(2) / $CumulPossible(2)"
Espionne "[format "%4.1f" [expr 100.*$CumulFavorable(1)/$CumulPossible(1)]] [format "%4.1f" [expr 100.*$CumulFavorable(2)/$CumulPossible(2)]]"
return
}
proc VraisParaloguesDe Nom {
global VraisParaloguesDe
global RepertoireDuGenome
set SeuilParalogue 20
if {[info exists VraisParaloguesDe($Nom)]} { return [set VraisParaloguesDe($Nom)] }
if {[info exists VraisParaloguesDe]} { return {} }
set FichierVraisParalogues "$RepertoireDuGenome/fiches/paralogues"
if {[file exists $FichierVraisParalogues]} {
foreach Ligne [LesLignesDuFichier $FichierVraisParalogues] {
set LesParas [split $Ligne " "]
set NomLu [lindex $LesParas 0]
lappend LesNoms $NomLu
set VraisParaloguesDe($NomLu) [lrange $LesParas 1 end]
}
set VraisParaloguesDe(LaListeMerci) $LesNoms
if {[info exists VraisParaloguesDe($Nom)]} { return [set VraisParaloguesDe($Nom)] }
return {}
}
set PICPar "$RepertoireDuGenome/fiches/piclustalw.paralogues"
if { ! [file exists $PICPar]} {
FaireLire "Please create the paralogues with AlignonsLesParalogues"
set VraisParaloguesDe(LaListeMerci) {}
return {}
}
foreach Ligne [LesLignesDuFichier $PICPar] {
set Liste [split $Ligne " "]
set NomLu [lindex $Liste 0]
set LesParas {}
foreach {Para PIC} [lrange $Liste 1 end] {
if {$Para==$NomLu} { continue }
if { $PIC < $SeuilParalogue } { break }
lappend LesParas $Para
}
if {$LesParas=={}} { continue }
lappend LesLignes "$NomLu [join $LesParas " "]"
}
SauveLesLignes $LesLignes dans $FichierVraisParalogues
return [VraisParaloguesDe $Nom]
}
proc tnal {} {
CreationDuNalDesGenomesComplets "pfur" "dmel|worm" "Pfuriosus"
}
proc OrganismeDeLaBanqueBlastN {{Qui ""} {Quoi ""}} {
global OrganismeDeLaBanqueBlast
if {$Qui=="" && $Quoi==""} { set Qui "ListOf" ; set Quoi "Files" }
if { ! [regexp -nocase "Banks|Bank|Organisms|Organism|Files" $Quoi]} {
if {$Quoi==""} {
if {[regexp " " $Qui]} { set Quoi "Bank" } else { set Quoi "Organism" }
} else {
set Qui "$Qui $Quoi"
set Quoi "Bank"
}
}
if {[info exists OrganismeDeLaBanqueBlast($Qui,$Quoi)]} { return $OrganismeDeLaBanqueBlast($Qui,$Quoi) }
if {[info exists OrganismeDeLaBanqueBlast("EstCharge")]} { return "" }
set OrganismeDeLaBanqueBlast("EstCharge") 1
foreach FichierNal [lsort [glob -nocomplain "/catalog/blast/*.nal"]] {
set Queue [file tail $FichierNal]
regsub {\.nal$} $Queue "" Banque
set Organisme ""
foreach Ligne [LesLignesDuFichier $FichierNal] {
if { ! [regexp -nocase {^ *TITLE +Genome complet *\- *} $Ligne]} { continue }
regsub -nocase {^ *TITLE +Genome complet *\- *} $Ligne "" Organisme
break
}
if {$Organisme==""} { continue }
if {[regexp "_" $Banque]} {
regsub "_" $Banque " " BO
if {$BO!=$Organisme} { FaireLire "$Organisme\n$Ligne\n$FichierNal" }
}
if {[info exists OrganismeDeLaBanqueBlast($Banque,Organism)]} {
FaireLire "Doublon $Organisme $Banque\n$Ligne\n$FichierNal"
}
set OrganismeDeLaBanqueBlast($Banque,Organism) $Organisme
if { ! [info exists OrganismeDeLaBanqueBlast($Organisme,Bank)]} {
set OrganismeDeLaBanqueBlast($Organisme,Bank) $Banque
} else {
if {[regexp "_" $Banque]} { set OrganismeDeLaBanqueBlast($Organisme,Bank) $Banque }
}
lappend OrganismeDeLaBanqueBlast(ListOf,Files) $FichierNal
lappend OrganismeDeLaBanqueBlast(ListOf,Organisms) $Organisme
lappend OrganismeDeLaBanqueBlast(ListOf,Banks) $Banque
}
return [OrganismeDeLaBanqueBlastN $Qui $Quoi]
}
proc CreationDuNalDesGenomesComplets {{Indesirables ""} {SuppOfficielles ""} {SuppGscope ""}} {
global RepertoireDuGenome
set RepertoireOfficiel "/catalog/blast"
set LienLocal "blast"
if { ! [file exists "$RepertoireDuGenome/banques"]} { File mkdir "$RepertoireDuGenome/banques" }
while { ! [file exists "$RepertoireDuGenome/banques/blast"]} {
if {[OuiOuNon "I need a link $RepertoireOfficiel -> $RepertoireDuGenome/banques/$LienLocal\n \
Can I do it ? "]} {
eval exec "ln -s $RepertoireOfficiel $RepertoireDuGenome/banques/$LienLocal"
} else {
if {[OuiOuNon "Do I skipp this now (You can fix it later) ?"]} { break }
if {[OuiOuNon "Do I cancel the Nal-blastn-database creation ?"]} { return }
if {[OuiOuNon "Do I exit Gscope ?"]} { exit }
}
}
set FichierNal "$RepertoireDuGenome/banques/completegenomes.nal"
if {[OuiOuNon "Do you want to use the new version (2007/12/20) ?"]} {
set LeNal {}
foreach Genome [LesGenomesComplets] {
regsub " " $Genome "_" G
set RG "/catalog/blast/$G"
if {[file exists "$RG.nal"]} {
lappend LeNal $RG
continue
}
set RG [Entre $RG]
if {$RG ==""} { continue }
lappend LeNal $RG
}
set LeTexte {}
lappend LeTexte "# Alias file created by Gscope"
lappend LeTexte "#"
lappend LeTexte "TITLE \"Complete Genomes created by Gscope [Date Nice]\""
lappend LeTexte "#"
lappend LeTexte "DBLIST [join $LeNal " "]"
SauveLesLignes $LeTexte dans $FichierNal
return $FichierNal
}
set NalOfficiel "$RepertoireOfficiel/genomes.nal"
foreach IS {"Indesirables" "SuppOfficielles" "SuppGscope"} \
Action {"remove" "add" "add (from Gscope)"} \
Defaut {"llact" \
"/catalog/blast/dmel|/catalog/blast/worm|/catalog/blast/spombe|/catalog/blast/ecuniculi|/catalog/blast/yeast|/catalog/blast/athaliana" \
"Mkan"} {
if {[set $IS] != "PleaseAsk"} { continue }
if {[OuiOuNon "Do You want to $Action some genomes in $NalOfficiel ? "]} {
FaireLire "Please give their names (BUT NOT human NOR mouse) (see in $NalOfficiel)"
set $IS [Entre $Defaut]
regsub -all {\|} [set $IS] " " $IS
while {[regexp " " [set $IS]]} { regsub -all " " [set $IS] " " $IS }
regsub -all " " [set $IS] "|" $IS
} else {
set $IS ""
}
Espionne "$IS [set $IS]"
}
set LesIndesirables [split $Indesirables "|"]
set LesSuppOfficielles [split $SuppOfficielles "|"]
set LesSuppGscope [split $SuppGscope "|"]
Espionne $LesIndesirables
Espionne $LesSuppOfficielles
set LesBanquesOfficielles {}
foreach Ligne [LesLignesDuFichier $NalOfficiel] {
if { ! [regexp -nocase "^DBLIST" $Ligne]} { continue }
set LesBanquesOfficielles [concat $LesBanquesOfficielles [lrange [split $Ligne " "] 1 end]]
}
foreach Banque $LesBanquesOfficielles {
if { ! [regexp -nocase {[a-z]} $Banque]} { continue }
if { [lsearch -exact $LesIndesirables $Banque] > -1 } { continue }
lappend LesBonnesBanquesOfficielles "$LienLocal/$Banque"
lappend LesVraiesBanques $RepertoireOfficiel/$Banque
}
foreach BanqOff $LesSuppOfficielles {
if { ! [file exists "$BanqOff.nhr"] && ! [file exists "/catalog/blast/$BanqOff.nhr"]} {
if {[OuiOuNon "$BanqOff.nhr doesn't exist ... Do I skip it ?"]} { continue }
}
set Banque [file tail $BanqOff]
lappend LesBonnesBanquesOfficielles "$LienLocal/$Banque"
lappend LesVraiesBanques $BanqOff
}
set LesBonnesBanquesANous {}
foreach RepGenome $LesSuppGscope {
if { ! [regexp "/" $RepGenome]} {
set Prefixe [PrefixeDuGenome $RepGenome]
set Banque "../../$RepGenome/banques/${Prefixe}overlap"
}
set BonneBanque 1
set VraieBanque "$RepertoireDuGenome/banques/$Banque"
while { ! [file exists "$VraieBanque.nhr"] } {
if {[OuiOuNon "$VraieBanque\n doesn't exist.\n \
(Maybe you can create it later with\n \
setgscope $RepGenome\n \
gscope CreeLaBanqueBlastN\n \
It's easy.)\n \
Do I keep it now as it is ?"]} { break }
if {[OuiOuNon "the tfa file of $VraieBanque\n doesn't exist. Do I skipp it ?"]} {
set BonneBanque 0
break
}
if {[OuiOuNon "$VraieBanque\n doesn't exist. Do You know how to call it ?"]} {
set Banque [Entre $Banque]
set VraieBanque "$RepertoireDuGenome/banques/$Banque"
}
}
if {$BonneBanque} {
lappend LesBonnesBanquesANous $Banque
lappend LesVraiesBanques $VraieBanque
}
}
set SuppHuman ""
set LesHuman {}
if {[OuiOuNon "Do You want to add the complete human genome ?"]} {
set SuppHuman "human.nal"
set LesHuman [LesBanquesDuNal "/catalog/blast/human.nal" "$LienLocal/"]
foreach HB $LesHuman {
lappend LesVraiesBanques $HB
}
}
set SuppMouse ""
set LesMouse {}
if {[OuiOuNon "Do You want to add the complete mouse genome ?"]} {
set SuppMouse "mouse.nal"
set LesMouse [LesBanquesDuNal "/catalog/blast/mouse.nal" "$LienLocal/"]
foreach MB $LesMouse {
lappend LesVraiesBanques $MB
}
}
set Liste [join [concat $LesBonnesBanquesANous $LesBonnesBanquesOfficielles $LesHuman $LesMouse] " "]
set Sortie {}
lappend Sortie "#"
lappend Sortie "# Alias file for blast database created by Gscope [Date]"
lappend Sortie "#"
lappend Sortie "TITLE \"Complete Microbial Genomes without $Indesirables with $SuppOfficielles $SuppGscope $SuppHuman $SuppMouse\""
lappend Sortie "#"
lappend Sortie "DBLIST $Liste"
lappend Sortie "#"
set FichierNal [SauveLesLignes $Sortie dans "$RepertoireDuGenome/banques/completegenomes.nal"]
set Hop 0
set FichierHeaders "$RepertoireDuGenome/banques/completegenomes.header"
set FichierCorrection "$RepertoireDuGenome/banques/completegenomes.correction"
if {[file exists $FichierHeaders] && [OuiOuNon "Do I replace $FichierHeaders ?"]} {
File delete -force $FichierHeaders
}
set nORGinconnu 0
foreach VraieBanque $LesVraiesBanques {
Espionne "VraieBanque $VraieBanque"
set Banque [file tail $VraieBanque]
set SesHeaders [LesHeadersDeLaBanqueBlast $VraieBanque]
set H [lindex $SesHeaders 0]
Espionne "H $H"
set ORG [file tail $VraieBanque]
if { ! [regexp -nocase {^[a-z0-9_]+\:[a-z0-9_]+} $H]} {
set ORG "$ORG:"
foreach H $SesHeaders {
scan $H "%s" A
AppendAuFichier $FichierCorrection "$A $ORG$A"
lappend SesNouveauxHeaders "$ORG$H"
Espionne "I use ${ORG}$A instead of $A (see $FichierCorrection) "
}
set SesHeaders $SesNouveauxHeaders
}
AppendAuFichier $FichierHeaders [join $SesHeaders "\n"]
}
return $FichierNal
}
proc ttok {Fonction Fichier} {
global TokCourant
global ChaineTok
set Texte [ContenuDuFichier $Fichier]
Tok $Texte
Espionne [$Fonction]
if {$ChaineTok!=""} { Espionne "${TokCourant}$ChaineTok" }
exit
}
proc TroisBoots {{Texte ""}} {
global TokCourant
if {$Texte!=""} { Tok $Texte }
if { ! [regexp {^\(} $TokCourant]} { return "TroisBootsNonValideCarSansOuvrante" }
Tok
set Gauche [Arboot]
if {[regexp "NonValide" $Gauche]} { return "TroisBootsNonValideCar$Gauche" }
if { ! [regexp {\,} $TokCourant]} { return "TroisBootsNonValideCarSansVirgule" }
Tok
set Milieu [Arboot]
if {[regexp "NonValide" $Milieu]} { return "TroisBootsNonValideCar$Milieu" }
if { ! [regexp {\,} $TokCourant]} { return "TroisBootsNonValideCarSansVirgule" }
Tok
set Droite [Arboot]
if {[regexp "NonValide" $Droite]} { return "TroisBootsNonValideCar$Droite" }
if { ! [regexp {\)} $TokCourant]} { return "TroisBootsNonValideCarSansFermante" }
Tok
if { ! [regexp {\;} $TokCourant]} { return "TroisBootsNonValideCarSansPointVirgule" }
return [list $Gauche $Milieu $Droite]
}
proc Arboot {} {
global TokCourant
if { ! [regexp {^\(} $TokCourant]} {
set FeuilleDist [FeuilleDist]
if {[regexp "NonValide" $FeuilleDist]} { return "ArbootNonValideCar$FeuilleDist" }
return $FeuilleDist
}
Tok
set Gauche [Arboot]
if {[regexp "NonValide" $Gauche]} { return "ArbootNonValideCar$Gauche" }
if { ! [regexp {\,} $TokCourant]} { return "ArbootNonValideCarSansVirgule" }
Tok
set Droite [Arboot]
if {[regexp "NonValide" $Droite]} { return "ArbootNonValideCar$Droite" }
if { ! [regexp {\)} $TokCourant]} { return "ArbootNonValideCarSansFermante" }
Tok
set ValeurDist [ValeurDist]
if {[regexp "NonValide" $ValeurDist]} { return "ArbootNonValideCar$ValeurDist" }
if {[regexp {^\[} $TokCourant]} {
set ValeurBoot [ValeurBoot]
if {[regexp "NonValide" $ValeurBoot]} { return "ArbootNonValideCar$ValeurBoot" }
} else {
set ValeurBoot 0
}
return [list $Gauche $Droite $ValeurDist $ValeurBoot]
}
proc FeuilleDist {} {
global TokCourant
set LabelFeuille [AlphaNum]
if {[regexp "NonValide" $LabelFeuille]} { return "FeuilleDistNonValideCar$LabelFeuille" }
set ValeurDist [ValeurDist]
if {[regexp "NonValide" $ValeurDist]} { return "FeuilleDistNonValideCar$ValeurDist" }
return [list $LabelFeuille $ValeurDist]
}
proc Flottant {} {
global TokCourant
set Courant ""
if {[regexp {^\.} $TokCourant]} {
set Courant "0."
Tok
} else {
set AvantPoint [Entier]
if {[regexp "NonValide" $AvantPoint]} { return "FlottantNonValideCar$AvantPoint" }
set Courant "$AvantPoint."
if { ! [regexp {^\.} $TokCourant]} {
return "FlottantNonValideCarSansPointDecimal"
}
Tok
}
if { ! [regexp {^[0-9]} $TokCourant]} { return "${Courant}0" }
set ApresPoint [Entier]
return "${Courant}$ApresPoint"
}
proc AlphaNum {} {
global TokCourant
set Courant ""
if {[regexp -nocase {[a-z_]} $TokCourant]} {
set Courant $TokCourant
}
if {$Courant==""} { return "AlphaNumNonValideCarNonAlphaEnDebut" }
while {[regexp -nocase {[a-z_0-9]} [Tok]]} {
append Courant $TokCourant
}
return $Courant
}
proc Entier {} {
global TokCourant
set Courant ""
if {[regexp {[0-9]} $TokCourant]} {
set Courant $TokCourant
}
if {$Courant==""} {
return "EntierNonValideCarNonNumeriqueEnDebut"
}
while {[regexp {[0-9]} [Tok]]} {
append Courant $TokCourant
}
return $Courant
}
proc ValeurFeuille {} {
global TokCourant
global ValueurFeuille
if {regexp -nocase {[a-z_]} $TokCourant} {
set ValeurFeuille $TokCourant
Tok
set AlphaNum [AlphaNum]
if { ! [regexp "NonValide" $AlphaNum]} {
append ValeurFeuille $AlphaNum
}
return $ValeurFeuille
}
return "ValeurFeuilleNonValideCarNonAlphaEnDebut"
}
proc ValeurDist {} {
global TokCourant
if {$TokCourant==":"} {
Tok
set Flottant [Flottant]
if {[regexp "NonValide" $Flottant]} { return "ValeurDistNonValideCar$Flottant" }
return $Flottant
}
return "ValeurDistNonValideCarNonDoublePoints"
}
proc ValeurBoot {} {
global TokCourant
if {$TokCourant=="\["} {
Tok
set Entier [Entier]
if {[regexp "NonValide" $Entier]} { return "ValeurBootNonValideCar$Entier" }
if {$TokCourant=="\]"} {
Tok
return $Entier
}
return "ValeurBootNonValideCarNonCrochetFermant"
}
return "ValeurBootNonValideCarNonCrochetOuvrant"
}
proc Tok {{TexteInitial ""}} {
global ChaineTok
global TokCourant
if {$TexteInitial!=""} { set ChaineTok $TexteInitial }
if { $ChaineTok=="" } { set TokCourant "" ; return "" }
set Tok [string index $ChaineTok 0]
set ChaineTok [string range $ChaineTok 1 end]
if {[regexp {[ \n\t]} $Tok]} { return [Tok] }
set TokCourant $Tok
return $Tok
}
proc PhyloBreak {{Nom "LaListeMerci"}} {
global RepertoireDuGenome
global PhyloBreak PhyloBreakEstCharge
if {[info exists PhyloBreak($Nom)]} { return [set PhyloBreak($Nom)] }
if { ! [info exists PhyloBreakEstCharge]} {
set FichierPhyloBreak "$RepertoireDuGenome/fiches/phylobreak"
if { ! [file exists $FichierPhyloBreak]} { return "NotAvailable" }
foreach Ligne [LesLignesDuFichier $FichierPhyloBreak] {
scan $Ligne "%s" NomLu
set PhyloBreak($NomLu) 1
}
set PhyloBreakEstCharge "EstCharge"
}
if {$Nom=="LaListeMerci"} { return [array names PhyloBreak] }
if {[info exists PhyloBreak($Nom)]} {
return [set PhyloBreak($Nom)]
} else {
return 0
}
}
proc TestLesDescriptifs {} {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/lesdescriptifs"] {
ScanLaListe [split $Ligne "="] AC Reste
# Espionne "[ChampDuDescriptif [LeDescriptif $AC] OS] \
# [ChampDuDescriptif [LeDescriptif $AC] OX]"
# continue
ScanLaListe [split $Ligne " "] Bidon OSGenre Espece
regsub "OS\:" $OSGenre "" Genre
set Organisme "$Genre $Espece"
Espionne [time {Getz $AC}]
Espionne [time {set OS [QuestionDeScience QuidSeq "QuidOSOfAC $AC"]}]
regsub {^[ \n]|[ \n]$} $OS "" OS
if {$OS==$Organisme} {
Espionne "$Organisme $AC"
} else {
Espionne "$Organisme $AC >$OS< +++++++++++++++++"
}
}
}
proc PourcentageDeGenomesCompletsOrthologuesDansTBlastN Nom {
global PourcentageDeGenomesCompletsOrthologuesDansTBlastN
if {[info exists PourcentageDeGenomesCompletsOrthologuesDansTBlastN($Nom)]} {
return [set PourcentageDeGenomesCompletsOrthologuesDansTBlastN($Nom)]
}
if {[info exists PourcentageDeGenomesCompletsOrthologuesDansTBlastN("EstCharge")]} {
return -1
}
foreach NomLu [ListeDesPABs] {
set Tous [string trim [ORGAorgaDesTBlastNs $NomLu]]
regsub -all { {2,}} $Tous " " Tous
set nTous [Maxi 1 [llength [split $Tous " "]]]
regsub -all {[A-Z]} $Tous "" Absents
set Absents [string trim $Absents]
regsub -all { {2,}} $Absents " " Absents
set nAbsents [llength [split $Absents " "]]
set PourcentageDeGenomesCompletsOrthologuesDansTBlastN($NomLu) [expr round(($nTous-$nAbsents)*100/$nTous)]
}
set PourcentageDeGenomesCompletsOrthologuesDansTBlastN(Count) $nTous
set PourcentageDeGenomesCompletsOrthologuesDansTBlastN("EstCharge") 1
return [PourcentageDeGenomesCompletsOrthologuesDansTBlastN $Nom]
}
proc PourcentageDeGenomesCompletsOrthologuesDansDbClustal Nom {
global PourcentageDeGenomesCompletsOrthologuesDansDbClustal
if {[info exists PourcentageDeGenomesCompletsOrthologuesDansDbClustal($Nom)]} {
return [set PourcentageDeGenomesCompletsOrthologuesDansDbClustal($Nom)]
}
if {[info exists PourcentageDeGenomesCompletsOrthologuesDansDbClustal("EstCharge")]} {
return -1
}
foreach NomLu [ListeDesPABs] {
set Tous [string trim [ORGAorgaDesMSFs $NomLu]]
regsub -all { {2,}} $Tous " " Tous
set nTous [Maxi 1 [llength [split $Tous " "]]]
regsub -all {[A-Z]} $Tous "" Absents
set Absents [string trim $Absents]
regsub -all { {2,}} $Absents " " Absents
set nAbsents [llength [split $Absents " "]]
set PourcentageDeGenomesCompletsOrthologuesDansDbClustal($NomLu) [expr round(($nTous-$nAbsents)*100/$nTous)]
}
set PourcentageDeGenomesCompletsOrthologuesDansDbClustal(Count) $nTous
set PourcentageDeGenomesCompletsOrthologuesDansDbClustal("EstCharge") -1
return [PourcentageDeGenomesCompletsOrthologuesDansDbClustal $Nom]
}
proc OldPourcentageDeGenomesCompletsOrthologuesDansDbClustal Nom {
global PourcentageDeGenomesCompletsOrthologuesDansDbClustal
if {[info exists PourcentageDeGenomesCompletsOrthologuesDansDbClustal($Nom)]} {
return [set PourcentageDeGenomesCompletsOrthologuesDansDbClustal($Nom)]
}
if {[info exists PourcentageDeGenomesCompletsOrthologuesDansDbClustal("EstCharge")]} {
return -1
}
foreach NomLu [ListeDesPABs] {
set PH [PhylumsOrthologues $NomLu]
scan $PH "%s %d %d %d %d %d %d" BAE nB mB nA mA nE mE
set Favorable [expr $nB+$nA+$nE]
set Possible [expr $mB+$mA+$mE]
set PourcentageDeGenomesCompletsOrthologuesDansDbClustal($NomLu) [expr round(($nB+$nA+$nE)*100/($mB+$mA+$mE))]
}
set PourcentageDeGenomesCompletsOrthologuesDansDbClustal(Count) $Possible
set PourcentageDeGenomesCompletsOrthologuesDansDbClustal("EstCharge") -1
return [PourcentageDeGenomesCompletsOrthologuesDansDbClustal $Nom]
}
proc PhylumsOrthologues {{Nom "LaListeMerci"}} {
global RepertoireDuGenome
global PhylumsOrthologues
set FichierPhylumsOrthologues "$RepertoireDuGenome/fiches/phylumsorthologues"
if {[info exists PhylumsOrthologues($Nom)]} { return [set PhylumsOrthologues($Nom)] }
if {[info exists PhylumsOrthologues("EstCharge")]} {
if {[info exists PhylumsOrthologues($Nom)]} { return [set PhylumsOrthologues($Nom)] }
if {$Nom=="LaListeMerci"} { return [LesLignesDuFichier $FichierPhylumsOrthologues] }
return ""
}
if {[OnTraiteUneCollection] && [ExtraitInfo [lindex [ListeDesPABs] 0] "BAE"]!=""} {
foreach NomLu [ListeDesPABs] {
set BAE [ExtraitInfo $NomLu "BAE"]
set PhylumsOrthologues($NomLu) $BAE
lappend PhylumsOrthologues(LaListeMerci) $BAE
}
set PhylumsOrthologues("EstCharge") 1
if {[info exists PhylumsOrthologues($Nom)]} { return [set PhylumsOrthologues($Nom)] }
if {$Nom=="LaListeMerci"} { return [set PhylumsOrthologues(LaListeMerci)] }
return ""
}
Wup "Now we will load FichierPhylumsOrthologues"
if {[file exists $FichierPhylumsOrthologues]} {
foreach Ligne [LesLignesDuFichier $FichierPhylumsOrthologues] {
scan $Ligne "%s" NomLu
regsub "^$NomLu " $Ligne "" Ligne
set Ligne [string trim $Ligne]
set PhylumsOrthologues($NomLu) $Ligne
}
set PhylumsOrthologues("EstCharge") 1
return [PhylumsOrthologues $Nom]
}
Wup "Now We will create FichierPhylumsOrthologues"
set FichierOoMSF "$RepertoireDuGenome/fiches/oomsf"
if { ! [file exists $FichierOoMSF]} { return "" }
foreach OS [LesGenomesDansLeBonOrdre] OC [LesGenomesDansLeBonOrdre OC] {
set BAE($OS) [string index $OC 0]
}
foreach Ligne [LesLignesDuFichier $FichierOoMSF] {
set Ligne [string trim $Ligne]
scan $Ligne "%s" Nom
Wup "C means Class unknown"
foreach P {B A E C} S {0.5 0.5 0.5 0.5} {
set PhylumTouche($P) 0
set PhylumTotal($P) 0
set SeuilPhylumTouche($P) $S
}
foreach Oo [lrange [split $Ligne " "] 1 end] {
set Orga [string tolower $Oo]
set Complet [Glossaire $Orga Complet]
set P ""
if {[info exists BAE($Complet)]} {
set P [set BAE($Complet)]
}
if {$P==""} { set P "C" }
incr PhylumTotal($P)
if {[regexp {[A-Z]} $Oo]} { incr PhylumTouche($P) }
set T [Maxi [set PhylumTotal($P)] 1]
set PourcentagePhylumTouche($P) [expr 1.0*[set PhylumTouche($P)]/$T]
}
set TexteBAE ""
set Resume {}
foreach P {B A E} {
if {[set PourcentagePhylumTouche($P)] >= [set SeuilPhylumTouche($P)]} {
append TexteBAE [string toupper $P]
} else {
append TexteBAE [string tolower $P]
}
lappend Resume "[set PhylumTouche($P)] [set PhylumTotal($P)]"
}
set SonBAE "$Nom $TexteBAE [join $Resume " "]"
Espionne $SonBAE
lappend LesBAEs $SonBAE
}
SauveLesLignes $LesBAEs dans $FichierPhylumsOrthologues
return [PhylumsOrthologues $Nom]
}
proc AlignonsLesParalogues {} {
global RepertoireDuGenome
global NotreOS
global NotreOrga
set FichierParalogues "$RepertoireDuGenome/fiches/paralogues.blastp"
if { ! [file exists $FichierParalogues]} { LesParaloguesDuBlastP }
Alignons Paralogues
}
proc LesParaloguesDuBlastPPourMs {{Source ""} {SeuilExpect ""}} {
if {$SeuilExpect==""} { set SeuilExpect 0.001 }
set MaxListe 999
set FichierParalogues "[RepertoireDuGenome]/fiches/paraloguesMs"
if {[FileExists $FichierParalogues]} {
foreach Ligne [LesLignesDuFichier $FichierParalogues] {
scan $Ligne "%s" Nom
set DejaVu($Nom) 1
}
}
if {$Source==""} { set Source "blastp" }
if {$Source=="blastp"} {
foreach Nom [ListeDesPABs] {
Espionne "je cherche les paralogues pour $Nom"
if {[info exists DejaVu($Nom)]} { continue }
set FichierBlast [GscopeFile $Nom "blastp"]
if {[FileAbsent $FichierBlast]} {continue}
set n [DecortiqueBlast $FichierBlast $SeuilExpect $MaxListe Query \
lBanqueId lAccess lDE lProfil lPN]
if {$n==0} { continue }
set MesParalogues {}
foreach BanqueId $lBanqueId Access $lAccess {
if {[regexp -nocase {\:} $BanqueId]} {
set NomLu [StringApres ":" dans $BanqueId]
if {$NomLu==$Nom} { continue }
if {[EstUnPAB $NomLu]} {
lappend MesParalogues $NomLu
continue
}
}
}
if {$MesParalogues=={}} { continue }
set BonneLigne "$Nom [join $MesParalogues " "]"
Espionne $BonneLigne
AppendAuFichier $FichierParalogues $BonneLigne
}
}
return $FichierParalogues
}
proc LesParaloguesDuBlastP {} {
global RepertoireDuGenome
global NotreOS
global NotreOrga
set FichierParalogues "$RepertoireDuGenome/fiches/paralogues.blastp"
set LesNomParalogues {}
set LesNomAPNs {}
foreach Nom [ListeDesPABs] {
set SesParalogues {}
set SesAPNs {}
set FichierAPNs "$RepertoireDuGenome/apns/$Nom"
if {[file exists $FichierAPNs]} {
foreach Ligne [LesLignesDuFichier $FichierAPNs] {
scan $Ligne "%s %s %f" BanqueId Access PN
if { $PN > 0.001 } { break }
set Para [Narcisse $Access]
if {$Para==$Nom} { continue }
if { ! [regexp "[ExpressionReguliereDesPABs]" $Para]} { continue }
lappend SesParalogues $Para
lappend SesAPNs "$BanqueId $Access $PN"
}
}
lappend LesNomParalogues "$Nom [join $SesParalogues " "]"
foreach APN $SesAPNs {
lappend LesNomAPNs "$Nom $APN"
}
}
Espionne [SauveLesLignes $LesNomParalogues dans "$FichierParalogues"]
Espionne [SauveLesLignes $LesNomAPNs dans "$FichierParalogues.apn"]
return $FichierParalogues
}
proc AfficheLesOrthologuesFamiliersDuBlastP Nom {
set LesOF [LesOrthologuesFamiliersDuBlastP $Nom]
return [AfficheVariable [join $LesOF "\n"] "AvecRien" $Nom]
}
proc LesOrthologuesFamiliersDuBlastP {{Nom "CreateIt"} {Quoi "All"}} {
global RepertoireDuGenome
global NotreOS
global NotreOrga
set FichierOrthologuesFamiliers "$RepertoireDuGenome/fiches/orthologues.familiar"
if {$Nom!="CreateIt"} {
if { ! [file exists $FichierOrthologuesFamiliers]} { return "" }
set DejaPasse 0
set LesOrthos {}
foreach Ligne [LesLignesDuFichier $FichierOrthologuesFamiliers] {
scan $Ligne "%s" NomLu
if {$NomLu!=$Nom && ! $DejaPasse } { continue }
if {$NomLu!=$Nom && $DejaPasse } { break }
scan $Ligne "%s %s %s %s %s %s" NomLu BanqueId Access Expect Genre Espece
switch -regexp $Quoi {
"All" { set Texte "$BanqueId $Access $Expect $Genre $Espece" }
"BanqueId" { set Texte "$BanqueId" }
"Access" { set Texte "$Access" }
"Expect" { set Texte "$Expect" }
"Orga" { set Texte "$Genre $Espece" }
default { set Texte "$BanqueId $Access $Expect $Genre $Espece" }
}
set DejaPasse 1
lappend LesOrthos $Texte
}
return $LesOrthos
}
while {[file exists $FichierOrthologuesFamiliers]} {
if {[OuiOuNon "$FichierOrthologuesFamiliers already exists\n \
Do I cancel LesOrthologuesFamiliersDuBlastP ?"]} {
return $FichierOrthologuesFamiliers
}
if {[OuiOuNon "$FichierOrthologuesFamiliers already exists\n \
Do I replace it ?"]} {
File delete -force $FichierOrthologuesFamiliers
break
}
if {[OuiOuNon "$FichierOrthologuesFamiliers already exists\n \
Do I append to it ?"]} {
set LesAnciennes {}
foreach Ligne [LesLignesDuFichier $FichierOrthologuesFamiliers] {
scan $Ligne "%s" NomLu
set DejaVu($NomLu) 1
}
break
}
}
set LesNomOrthologues {}
set LesNomAPNs {}
foreach NomLu [ListeDesPABs] {
if {[info exists DejaVu($NomLu)]} { continue }
set SesAPNs {}
set FichierAPNs "$RepertoireDuGenome/apns/$NomLu"
if {[file exists $FichierAPNs]} {
foreach Ligne [LesLignesDuFichier $FichierAPNs] {
set Genre ""
set Espece ""
set Organisme ""
scan $Ligne "%s %s %f %s %s" BanqueId Access PN Genre Espece
if { $PN > 0.001 } { break }
if {$Espece!=""} { set Organisme "$Genre $Espece" }
if {$Organisme==""} {
continue
set Organisme [OrgaDuAccess $Access Complet $BanqueId]
}
if {$Organisme==""} { continue }
if { ! [FamiliarOrganism $Organisme] && $Organisme!=$NotreOS} { continue }
lappend SesAPNs "$NomLu $Ligne"
}
}
foreach APN $SesAPNs {
AppendAuFichier $FichierOrthologuesFamiliers [join $SesAPNs "\n"]
}
}
return $FichierOrthologuesFamiliers
}
proc LesParaloguesDuMSF {} {
global RepertoireDuGenome
global NotreOS
global NotreOrga
set FichierParalogues "$RepertoireDuGenome/fiches/paralogues.msf"
set FichierDistanceMSF "$RepertoireDuGenome/fiches/distancesphylo.$NotreOrga"
while { ! [file exists $FichierDistanceMSF]} {
if { ! [OuiOuNon "$FichierDistanceMSF\n doesn't exist. Do I calculate it ? "]} {
return ""
}
set FichierDistanceMSF [CreeDistancesPhyloAvecLesMSFs $NotreOrga ".$NotreOrga"]
}
foreach Ligne [LesLignesDuFichier $FichierDistanceMSF] {
scan $Ligne "%s" Nom
set SesParalogues {}
set SesDistances {}
set Premier 1
foreach {Orga Dist Access} [lrange [split $Ligne " "] 1 end] {
if {$Orga!=$NotreOrga} { continue }
if {$Premier} { set Premier 0 }
set Para [Narcisse $Access]
if {$Para==$Nom} { continue }
lappend SesParalogues $Para
lappend SesDistances $Dist
}
lappend LesNomParalogues "$Nom [join $SesParalogues " "]"
lappend LesNomDistances "$Nom [join $SesDistances " "]"
}
Espionne [SauveLesLignes $LesNomParalogues dans "$FichierParalogues"]
Espionne [SauveLesLignes $LesNomDistances dans "$FichierParalogues.dist"]
}
proc FromRef {Ref Champ} {
if { ! [regexp -nocase {[a-z_0-9]} $Ref]} { return "" }
set Liste {}
foreach Ligne [split $Ref "\n"] {
if {[regexp "^$Champ" $Ligne]} {
regsub "$Champ " $Ligne "" Texte
lappend Liste [string trim $Texte]
}
}
return [join $Liste " "]
}
proc InformeClassePourTous {} {
foreach Nom [ListeDesPABs] {
set TaxOS [OrganismeDuPAB $Nom]
if {$TaxOS==""} { continue }
scan $TaxOS "%d" TaxId
set Classe [TaxClass $TaxId "" "" Name]
Espionne "$Nom Taxonomy: $Classe"
InformeSansDemander $Nom "Taxonomy: $Classe"
}
}
proc InformePourTous {{Clef ""} {Commande ""}} {
foreach Nom [ListeDesPABs] {
set Valeur ""
if {$Commande!=""} { set Valeur [eval $Commande $Nom] }
#rR if {$Valeur==""} { continue }
Espionne "$Nom $Clef: $Valeur"
if {$Clef!=""} {
InformeSansDemander $Nom "$Clef: $Valeur"
} else {
InformeSansDemander $Nom ""
}
}
}
proc LesChampsInteressantsDeNarcisse {} {
return {ID AC DE GN}
}
proc InformeParNarcissePourTous {} {
foreach Nom [ListeDesPABs] {
InformeParNarcisse $Nom
}
}
proc InformeParNarcisse Nom {
set Nar [Narcisse $Nom]
if {$Nar==""} { Espionne "$Nom ++++" ;return "" }
set Ref [RefOfAC $Nar]
if {$Ref==""} { Espionne "$Nom ----" ;return "" }
Espionne "$Nom $Nar"
foreach Champ [LesChampsInteressantsDeNarcisse] {
set Texte "${Champ}_Narcisse: [FromRef $Ref $Champ]"
lappend LesTextes $Texte
}
set Textes [join $LesTextes "\n"]
return [InformeSansDemander $Nom $Textes]
}
proc InformeParClonagePourTous {{GenomeOrigine ""} {Champ ""}} {
foreach Nom [ListeDesPABs] {
if {[InformeParClonage $Nom $GenomeOrigine $Champ]=="Cancel"} { return "Cancel" }
}
}
proc InformeParClonage {Nom {GenomeOrigine ""} {Champ ""}} {
global RepertoireDuGenome
global GenomeACloner PrefixeDuGenomeACloner
if {$GenomeOrigine!=""} {
set GenomeACloner $GenomeOrigine
if { ! [file exists $GenomeACloner]} {
set GenomeACloner "$RepertoireDuGenome/../[file tail $GenomeACloner]"
set PrefixeDuGenomeACloner [PrefixeDuGenome $GenomeACloner]
}
if { ! [file exists $GenomeACloner]} {
if { [OuiOuNon "$GenomeOrigine\n and \n$GenomeACloner\n don't exist.\n Do I cancel ?"]} {
return "Cancel"
}
unset GenomeACloner
}
}
while { ! [info exists GenomeACloner]} {
FaireLire "Please select the genome from which the info have to be taken."
set GenomeACloner [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."]
if {$GenomeACloner==""} {
if {[OuiOuNon "Do I cancel ?"]} { return "Cancel" }
continue
}
set PrefixeDuGenomeACloner [PrefixeDuGenome $GenomeACloner]
break
}
if {[file tail $GenomeACloner]==[file tail $RepertoireDuGenome]} {
FaireLire "You want to clone myself ... I cancel."
return "Cancel"
}
regsub "^[PreFixe]" $Nom $PrefixeDuGenomeACloner PAB
set FichierInfo "$GenomeACloner/infos/$PAB"
if { ! [file exists $FichierInfo]} { return "" }
set OnAttendLeBon 1
set LesTextes {}
foreach Ligne [LesLignesDuFichier $FichierInfo] {
if {$OnAttendLeBon && $Ligne=="Nom: $PAB"} {
set OnAttendLeBon 0
continue
}
if {$OnAttendLeBon} {
if {[OuiOuNon "$PAB is wrong, Do You want to see the info file ?"]} {
AfficheFichier $FichierInfo "SansFetch"
}
if {[OuiOuNon "$PAB is wrong, Do I cancel ?"]} { return "Cancel"}
if {[OuiOuNon "$PAB is wrong, Do I skipp it ?"]} { return ""}
if { ! [OuiOuNon "$PAB is wrong, Do I accept it ?"]} { exit }
set OnAttendLeBon 0
}
if {$PrefixeDuGenomeACloner!=[PreFixe]} {
while {[regexp "$PrefixeDuGenomeACloner\[0-9\]+" $Ligne Match]} {
regsub $PrefixeDuGenomeACloner $Match [PreFixe] NouveauMatch
regsub -all $Match $Ligne $NouveauMatch Ligne
}
}
if {$Champ!="" && ! [regexp "^$Champ: " $Ligne]} { continue }
lappend LesTextes $Ligne
}
if {$LesTextes=={}} { return "" }
set Textes [join $LesTextes "\n"]
Espionne "Clonage de $PAB vers $Nom $Textes"
return [InformeSansDemander $Nom $Textes]
}
proc RefOfAC AC {
return [QuestionDeScience QuidSeq "QuidRefOfAC $AC"]
}
proc CouleursDuRougeAuBleu n {
if {$n==1} { return { red } }
if {$n==2} { return { red blue } }
if {$n==3} { return { red green blue } }
if {$n==4} { return { red orange green blue } }
if {$n==5} { return { red orange green lightblue blue } }
if {$n==6} { return { red orange yellow green lightblue blue } }
if {$n==7} { return {brown red orange yellow green lightblue blue } }
if {$n==8} { return {brown red orange yellow green lightblue blue purple} }
if {$n<=0} { return {} }
return [concat [CouleursDuRougeAuBleu [incr n -1]] [list black]]
}
proc CouleursDuBleuAuRouge n {
return [RetourneLaListe [CouleursDuRougeAuBleu $n]]
}
proc LesSeuilsMDScore {{QueVeutOn "SeuilMerci"}} {
global LesSeuilsMDScore LesSeuilsMDScoreSign LesSeuilsMDScoreCoul
if { ! [info exists LesSeuilsMDScore]} {
set LesSeuilsMDScore { -999.0 0.0 0.5 0.7 0.9 }
set LesSeuilsMDScoreSign {"No value" "Problem" "Twilight zone" "Good" "Sure"}
set LesSeuilsMDScoreCoul {"grey" "red" "orange" "yellow" "green"}
}
if {$QueVeutOn=="SeuilMerci"} { return $LesSeuilsMDScore }
if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsMDScoreSign }
if {$QueVeutOn=="CouleurMerci"} { return $LesSeuilsMDScoreCoul }
}
proc TSOH {} {
set OHLaListe [CompteDesOrganismesAyantMemeOperon "LaListeMerci"]
Espionne [lsort -integer $OHLaListe]
Espionne [MoyenneEcartMinMaxCumulLong $OHLaListe]
}
proc LesSeuilsOperonsHomologues {{QueVeutOn ""}} {
global LesSeuilsOperonsHomologues LesSeuilsOperonsHomologuesSign
if { ! [info exists LesSeuilsOperonsHomologues]} {
# set OHLaListe [CompteDesOrganismesAyantMemeOperon "LaListeMerci"]
# scan [MoyenneEcartMinMaxCumulLong $OHLaListe] "%f %f %d %d" Mo Ec Mi Ma
lappend LesSeuilsOH [format "%4.1f" 0.1]
lappend LesSeuilsOH [format "%4.1f" 1.1]
lappend LesSeuilsOH [format "%4.1f" 2.1]
lappend LesSeuilsOH [format "%4.1f" 10.1]
lappend LesSeuilsOH [format "%4.1f" 20.1]
lappend LesSeuilsOHSign "ClusterMaintenance 0 == n"
lappend LesSeuilsOHSign "ClusterMaintenance 1 == n"
lappend LesSeuilsOHSign "ClusterMaintenance 2 <= n < 10"
lappend LesSeuilsOHSign "ClusterMaintenance 10 < n <= 20"
lappend LesSeuilsOHSign "ClusterMaintenance 20 < n"
}
if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsOHSign }
return $LesSeuilsOH
}
proc LesSeuilsGC {{QueVeutOn ""}} {
global LesSeuilsGC LesSeuilsGCSign
if { ! [info exists LesSeuilsGC]} {
set GCLaListe [CompositionEn GC "LaListeMerci"]
scan [MoyenneEcartMinMaxCumulLong $GCLaListe] "%f %f %d %d" Mo Ec Mi Ma
lappend LesSeuilsGC [format "%4.1f" [expr $Mo-2*$Ec]]
lappend LesSeuilsGC [format "%4.1f" [expr $Mo-1*$Ec]]
lappend LesSeuilsGC [format "%4.1f" [expr $Mo+1*$Ec]]
lappend LesSeuilsGC [format "%4.1f" [expr $Mo+2*$Ec]]
set i -1
lappend LesSeuilsGCSign "GC skew verylow ( %GC < [lindex $LesSeuilsGC [incr i]])"
lappend LesSeuilsGCSign "GC skew low ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])"
lappend LesSeuilsGCSign "GC skew normal ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])"
lappend LesSeuilsGCSign "GC skew high ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])"
lappend LesSeuilsGCSign "GC skew veryhigh ([lindex $LesSeuilsGC $i] <= %GC < [lindex $LesSeuilsGC [incr i]])"
}
if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsGCSign }
return $LesSeuilsGC
}
proc LesSeuilsAC {{QueVeutOn ""}} {
global LesSeuilsAC LesSeuilsACCoul LesSeuilsACSign
if { ! [info exists LesSeuilsAC]} {
set ACLaListe [AnchorsCount "LaListeMerci"]
scan [MoyenneEcartMinMaxCumulLong $ACLaListe] "%f %f %d %d" Mo Ec Mi Ma
lappend LesSeuilsAC [format "%4.1f" [Maxi 1.0 [expr $Mo-2*$Ec]]]
lappend LesSeuilsAC [format "%4.1f" [Maxi 2.0 [expr $Mo-1*$Ec]]]
lappend LesSeuilsAC [format "%4.1f" [expr $Mo+1*$Ec]]
lappend LesSeuilsAC [format "%4.1f" [expr $Mo+2*$Ec]]
lappend LesSeuilsACCoul "red"
lappend LesSeuilsACCoul "orange"
lappend LesSeuilsACCoul "yellow"
lappend LesSeuilsACCoul "green"
set i -1
lappend LesSeuilsACSign "AC verylow ( %AC < [lindex $LesSeuilsAC [incr i]])"
lappend LesSeuilsACSign "AC low ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])"
lappend LesSeuilsACSign "AC normal ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])"
lappend LesSeuilsACSign "AC high ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])"
lappend LesSeuilsACSign "AC veryhigh ([lindex $LesSeuilsAC $i] <= %AC < [lindex $LesSeuilsAC [incr i]])"
}
if {$QueVeutOn=="CouleurMerci"} { return $LesSeuilsACCoul }
if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsACSign }
return $LesSeuilsAC
}
proc LesSeuilsCAI {{QueVeutOn ""}} {
global LesSeuilsCAI LesSeuilsCAISign
if { ! [info exists LesSeuilsCAI]} {
set CAILaListe [CAI "LaListeMerci"]
scan [MoyenneEcartMinMaxCumulLong $CAILaListe] "%f %f %d %d" Mo Ec Mi Ma
lappend LesSeuilsCAI [format "%4.1f" [expr $Mo-2*$Ec]]
lappend LesSeuilsCAI [format "%4.1f" [expr $Mo-1*$Ec]]
lappend LesSeuilsCAI [format "%4.1f" [expr $Mo+1*$Ec]]
lappend LesSeuilsCAI [format "%4.1f" [expr $Mo+2*$Ec]]
set i -1
lappend LesSeuilsCAISign "CAI verylow ( CAI < [lindex $LesSeuilsCAI [incr i]])"
lappend LesSeuilsCAISign "CAI low ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])"
lappend LesSeuilsCAISign "CAI normal ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])"
lappend LesSeuilsCAISign "CAI high ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])"
lappend LesSeuilsCAISign "CAI veryhigh ([lindex $LesSeuilsCAI $i] <= CAI < [lindex $LesSeuilsCAI [incr i]])"
}
if {$QueVeutOn=="SignificationMerci"} { return $LesSeuilsCAISign }
return $LesSeuilsCAI
}
proc QuelInterval {Valeur LesBornes LesIntervals} {
foreach Borne $LesBornes Interval $LesIntervals {
if {$Valeur < $Borne} { return $Interval }
}
return [lindex $LesIntervals end]
}
proc GCLevel Nom {
set GC [CompositionEn GC $Nom]
return [QuelInterval $GC [LesSeuilsGC] [LesSeuilsGC "SignificationMerci"]]
}
proc GCContent Nom {
return [CompositionEn GC $Nom]
}
proc TasTamis {{Tam ""} {Fichier ""}} {
global TasTamis
Wup "Create a file Fichier (or returns a list) with 'Nom Value' foreach Nom verifying Tam"
if {[info exists TasTamis]} { unset TasTamis }
CreeLeTasTamis $Tam
set Liste {}
foreach Nom [array names TasTamis] {
lappend Liste "$Nom [set TasTamis($Nom)]"
}
if {$Fichier==""} {
return $Liste
} else {
return [SauveLesLignes $Liste dans $Fichier]
}
}
proc SauveLeTamis {{Tam ""} {Fichier ""}} {
if {$Tam==""} {
set Tam [ChoisisUnTamis "ChampNom" "AvecNewTamis"]
}
if {$Fichier==""} {
set Fichier [FichierPourSaveAs]
}
if {$Fichier==""} { return "" }
return [SauveLesLignes [Tamis $Tam] dans $Fichier]
}
proc CreeLeTasTamis {{Tam ""}} {
global TasTamis
Wup "Creates the array TasTamis(Nom) for a Tamis Tam which can be choosen"
if {$Tam==""} {
set Tam [ChoisisUnTamis "ChampNom" "AvecNewTamis"]
}
if {[info exists TasTamis]} { unset TasTamis }
foreach Nom [Tamis $Tam] {
set TasTamis($Nom) 1
}
set TasTamis(FromTamis) $Tam
return $Tam
}
proc ScanCOV {COV aCritere aOperateur aValeur} {
upvar $aCritere Critere
upvar $aOperateur Operateur
upvar $aValeur Valeur
scan $COV "%s %s" Critere Operateur
regsub "$Critere +$Operateur +" $COV "" Valeur
}
proc NoCo {Action {No ""} {Co ""}} {
global RepertoireDuGenome
global NoCo
global NoCoEstCharge
Wup "NoCo 'NomCommande' manages the Criteria file and array NoCo"
if { ! [info exists FichierNoCo]} { set FichierNoCo "$RepertoireDuGenome/fiches/nomcommande-criteres" }
if {$Action=="Recharger"} {
if {[info exists NoCoEstCharge]} {unset NoCoEstCharge}
}
if { ! [info exists NoCoEstCharge]} {
while { ! [file exists $FichierNoCo]} {
if {[OuiOuNon "Do I create a Criteria file ?"]} {
set LesNoCos {}
lappend LesNoCos "NewCriteria X X X"
lappend LesNoCos "UnPAB Echo == ?"
lappend LesNoCos "AAStartM AAStart == M"
lappend LesNoCos "AAStartV AAStart == V"
lappend LesNoCos "AAStartL AAStart == L"
SauveLesLignes $LesNoCos dans $FichierNoCo
} else {
set NoCoEstCharge 1
break
}
}
if { ! [info exists NoCoEstCharge]} {
foreach Ligne [LesLignesDuFichier $FichierNoCo] {
scan $Ligne "%s" NoLu
regsub "$NoLu +" $Ligne "" CoLu
set NoCo($NoLu) $CoLu
}
}
set NoCoEstCharge 1
}
switch $Action {
"LaListeMerci" { return [lsort [array names NoCo]] }
"ReCharger" { return [lsort [array names NoCo]] }
"ReSauver" {
set LesNoCos {}
foreach No [lsort [array names NoCo]] {
lappend LesNoCos "$No [set NoCo($No)]"
}
SauveLesLignes $LesNoCos dans $FichierNoCo
return [NoCo "ReCharger"]
}
"MieuxNommer" {
if {[info exists NoCo($No)] && [set NoCo($No)]==$Co} { return $No }
FaireLire "Please give a name for the criteria\n$Co"
set NoLu [Entre]
while {[info exists NoCo($NoLu)] && [set NoCo($NoLu)]!=$Co} {
if {[OuiOuNon " The Old criteria\n\
$NoLu [set NoCo($NoLu)]\n will be replaced by\n$NoLu $Co\n Do You accept ?"]} {
break
}
set NoLu [Entre]
}
Espionne "$NoLu $Co"
set NoCo($NoLu) $Co
NoCo "ReSauver"
return $NoLu
}
"Remplacer|Creer" {
set NoCo($No) $Co
return [NoCo "ReSauver"]
}
"Supprimer" {
if {[info exists NoCo($No)]} {unset NoCo($No)}
return [NoCo "ReSauver"]
}
"Titre" {
if {[info exists NoCo($No)]} {
return $No
} else {
return ""
}
}
"Commande" {
if {[info exists NoCo($No)]} {
return [set NoCo($No)]
} else {
return ""
}
}
"Tout" {
if {[info exists NoCo($No)]} {
return "$No [set NoCo($No)]"
} else {
return ""
}
}
default { FaireLire "Illegal Action $Action" ; return "" }
}
}
proc ChoixDansLaListeFait Texte {
global ChoixDansLaListe
Wup "Tests the selection for NormalSelection, Cancel or NewCommand"
if {$Texte==""} { return }
if {$Texte=="PasDeChoixDansLaListe"} { set ChoixDansLaListe "" ; return }
if {$Texte=="NouveauChoixDansLaListe"} {
set ChoixDansLaListe [Entre]
return
}
set ChoixDansLaListe $Texte
return
}
proc ChoixDansLaListe {Liste {SansRetour ""}} {
global ChoixDansLaListe
Wup "Displays a list and ask for a selection"
if {$SansRetour=="SansRetour"} {
set Titre "For display only ..."
} else {
set Titre "Select a line and Accept"
}
set Fenetre [ShowText [join $Liste "\n"] "SansFetchAvecRien" $Titre]
if {$SansRetour=="SansRetour"} { return }
set Bouton [BoutonneLaFenetre $Fenetre "Accept/Cancel/New" ""]
$Bouton configure -background "green"
bind $Bouton <1> "ChoixDansLaListeFait \[selection get\] "
bind $Bouton <2> "ChoixDansLaListeFait PasDeChoixDansLaListe"
bind $Bouton <3> "ChoixDansLaListeFait NouveauChoixDansLaListe"
set Bouton [BoutonneLaFenetre $Fenetre "Show Criteria" ""]
$Bouton configure -background "yellow"
bind $Bouton <1> "ChoisisUneGrille SansRetour"
tkwait variable ChoixDansLaListe
set LigneChoisie $ChoixDansLaListe
unset ChoixDansLaListe
destroy $Fenetre
return $LigneChoisie
}
proc NommeEtStockeLeTamis Commande {
Wup "Gives a name to the Tamis"
if {[LeTamis NeConnaitPasEncore $Commande]} {
while {[OuiOuNon "$Commande\nwill be a new Tamis ?"]} {
FaireLire "Please give a name"
set NewTamis [Entre "Tamis_"]
if {$NewTamis==""} { continue }
LeTamis $NewTamis $Commande
break
}
}
}
proc ChoisisUneGrille {{ChampChoisi ""}} {
Wup "Displays the known Criterias and asks for a selection"
set LesGrillesExistantes [NoCo "LaListeMerci"]
if { $LesGrillesExistantes=={} } { return "" }
foreach Grille $LesGrillesExistantes {
set COV [NoCo "Commande" $Grille]
lappend LesBellesGrilles [format "%-20s %s" $Grille $COV]
}
if {$ChampChoisi=="SansRetour"} {
set ChampsNomEtCommande [ChoixDansLaListe $LesBellesGrilles "SansRetour"]
return
} else {
set ChampsNomEtCommande [ChoixDansLaListe $LesBellesGrilles]
}
if {$ChampsNomEtCommande==""} { return "" }
scan $ChampsNomEtCommande "%s" Grille
return $Grille
}
proc ChoisisUnTamis {{ChampChoisi ""} {AvecNewTamis ""}} {
Wup "Displays the known Tamis and asks for a selection"
set LesTamisExistants [LeTamis "LaListeMerci"]
if { $LesTamisExistants=="TamisInconnu" } {
LeTamis AllPABs "ListeDesPABs"
LeTamis AllTRNAs "ListeDesTRNAs"
LeTamis AllARNs "ListeDesARNs"
set LesTamisExistants [LeTamis "LaListeMerci"]
}
set LesBeauxTamis {}
if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisWhere X Where X] }
if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisAnd X And X] }
if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisOr X Or X] }
if {$AvecNewTamis!=""} { lappend LesBeauxTamis [format "%-20s %s %s %s" NewTamisButNot X ButNot X] }
foreach Tam $LesTamisExistants {
lappend LesBeauxTamis [format "%-20s %s" $Tam [LeTamis $Tam]]
}
set ChampsNomEtCommande [ChoixDansLaListe $LesBeauxTamis]
if {$ChampsNomEtCommande==""} { return "" }
scan $ChampsNomEtCommande "%s" Tam
if {$ChampChoisi=="ChampNom"} { return $Tam }
if {$ChampChoisi=="ChampCommande"} { return [LeTamis $Tam] }
return "$Tam [LeTamis $Tam]"
}
proc LeTamis {Tam {Commande ""}} {
global RepertoireDuGenome
global LeTamis
global LeTamisDeLaCommande
Wup "Manages the file and array containing the Tamis"
set FichierDesTamis "$RepertoireDuGenome/fiches/nomcommande-tamis"
if {$Tam=="RelireEtReecrireLeFichierDesTamis"} {
if {[info exists LeTamis]} {unset LeTamis}
set ReecrireLeFichierDesTamis 1
} else {
set ReecrireLeFichierDesTamis 0
}
if {$Tam=="NeConnaitPasEncore" || $Tam=="LeNomDuTamisAssocieA"} {
if { ! [info exists LeTamis(EstCharge)]} { LeTamis Turlututu }
if {[info exists LeTamisDeLaCommande($Commande)]} {
return 0
} else {
if {$Tam=="NeConnaitPasEncore"} { return 1 }
if {$Tam=="LeNomDuTamisAssocieA"} { return [set LeTamisDeLaCommande($Commande)] }
}
}
if {$Commande!=""} {
set CommandeExistante [LeTamis $Tam]
if {$CommandeExistante=="TamisInconnu"} {
AppendAuFichier $FichierDesTamis "$Tam $Commande"
if {[info exists LeTamis]} { unset LeTamis }
return [LeTamis $Tam]
}
if {$CommandeExistante==$Commande} { return $Commande }
if {[OuiOuNon " The new\n$Tam $Commande\n wants to replace the old\n$Tam $CommandeExistante\n Do you want to replace it ?"]} {
AppendAuFichier $FichierDesTamis "$Tam $Commande"
if {[info exists LeTamis]} { unset LeTamis }
LeTamis "RelireEtReecrireLeFichierDesTamis"
return [LeTamis $Tam]
}
return ""
}
if {[info exists LeTamis($Tam)]} { return [set LeTamis($Tam)]}
if {[info exists LeTamis(EstCharge)]} { return "TamisInconnu"}
if {[file exists $FichierDesTamis]} {
set LesLignesTamis [LesLignesDuFichier $FichierDesTamis]
} else {
set LesLignesTamis {}
}
if {[info exists LeTamis]} { unset LeTamis }
foreach Ligne $LesLignesTamis {
scan $Ligne "%s" TamisLu
regsub "$TamisLu " $Ligne "" CommandeLue
set LeTamis($TamisLu) $CommandeLue
set LeTamisDeLaCommande($CommandeLue) $TamisLu
}
set LesLignesTamis {}
set LaListe {}
foreach TamExistant [lsort [array names LeTamis]] {
lappend LeTamis(LaListeMerci) $TamExistant
lappend LesLignesTamis "$TamExistant [set LeTamis($TamExistant)]"
}
if {$ReecrireLeFichierDesTamis} { SauveLesLignes $LesLignesTamis dans $FichierDesTamis }
set LeTamis(EstCharge) "TamisCharge"
if {[info exists LeTamis($Tam)]} { return [set LeTamis($Tam)]}
if {[info exists LeTamis(EstCharge)]} { return "TamisInconnu"}
}
proc AlwaysTrue Nom {
return 1
}
proc Echo Nom {
return $Nom
}
#a b c .
#d e . .
#g h i k
#a d g
#b e h
#c . i
#. . k
proc TestListTranspose {} {
set LL {{a b c} {d e} {g h i k}}
EspionneL $LL
EspionneL [ListTranspose $LL]
return [ListTranspose $LL]
}
proc ListTranspose LL {
#rR LL peut avoir des lignes de longueurs différentes
#rR On est obligé de passer par un tableau à 2 dimensions
set MaxICol -1
set iLig 0
foreach Ligne $LL {
set iCol 0
set LesCol {}
foreach e $Ligne {
lappend LesCol $iCol
lappend T($iLig,$iCol) $e
incr iCol
}
set MaxICol [expr max($MaxICol,[llength $LesCol]-1)]
incr iLig
}
set MaxILig [expr $iLig-1]
set N {}
set Vide "NA"
foreach iCol [NombresEntre 0 $MaxICol] {
set Colonne {}
foreach iLig [NombresEntre 0 $MaxILig] {
if {[info exists T($iLig,$iCol)]} {
lappend Colonne $T($iLig,$iCol)
} else {
lappend Colonne $Vide
}
}
# Espionne $Colonne
lappend N $Colonne
}
return $N
}
proc ListsUnion {LesA LesB} {
set LesAB [ListeSansDoublon [concat $LesA $LesB]]
return $LesAB
}
proc ListsIntersection {LesA LesB {NoCase ""}} {
#rR si NoCase on garde quand meme les A avec leur casse
set NoCase [string equal -nocase $NoCase "NoCase"]
foreach B $LesB {
if {$NoCase} { set B [string tolower $B] }
set Existe($B) 1
}
set InterAB {}
foreach A $LesA {
set a $A
if {$NoCase} { set a [string tolower $A] }
if {[info exists Existe($a)]} {
lappend InterAB $A
}
}
return $InterAB
}
proc ListsComplement {LesA LesB} {
Wup "A butnot B"
foreach B $LesB {
set Existe($B) 1
}
set ComplementAB {}
foreach A $LesA {
if {! [info exists Existe($A)]} {
lappend ComplementAB $A
}
}
return $ComplementAB
}
proc SelectionneCeCritere Texte {
global CritereSelectionne
Wup "Give a value to the waiting variable CritereSelectionne"
if {$Texte=="CritereNonVoulu"} {
set Critere ""
} else {
scan $Texte "%s" Critere
}
set CritereSelectionne $Critere
}
proc ChoisisLeCritere {} {
global CritereSelectionne
Wup "Asks for a Criteria (the name of a Proc)"
set Fenetre [AfficheLesProcs "ArgsContain:^Nom"]
set Bouton [BoutonneLaFenetre $Fenetre "Select\nCancel" "SelectionneCeCritere \[selection get\]"]
$Bouton configure -background "orange"
bind $Bouton <Shift-1> "SelectionneCeCritere CritereNonVoulu"
tkwait variable CritereSelectionne
set Critere $CritereSelectionne
unset CritereSelectionne
catch { destroy $Fenetre }
return $Critere
}
proc TesteTamis {} {
set Commande [ChoisisUnTamis "ChampCommande"]
if {$Commande==""} { exit }
Espionne [eval $Commande]
exit
}
proc Tamis {{TamisOuListe ListeDesPABs} {Action ForAll} \
{TamisOuListe2OuGrilleOuCritere X} {Operateur ""} {Valeur ""}} {
if {[regexp "^NewTamis" $TamisOuListe]} {
regsub "NewTamis" $TamisOuListe "" Action
set TamisOuListe "X"
set TamisOuListe2OuGrilleOuCritere "X"
}
if {$TamisOuListe=="X"} {
set NomTamisEntrant [ChoisisUnTamis "ChampNom"]
if {$NomTamisEntrant==""} { return {} }
set ComTamisEntrant [LeTamis $NomTamisEntrant]
} elseif {[LeTamis $TamisOuListe]!="TamisInconnu"} {
set NomTamisEntrant $TamisOuListe
set ComTamisEntrant [LeTamis $NomTamisEntrant]
} else {
set NomTamisEntrant $TamisOuListe
set ComTamisEntrant $TamisOuListe
}
if {[regexp -nocase "ForAll" $Action]} {
if {$ComTamisEntrant=="TamisInconnu"} { return {} }
return [eval $ComTamisEntrant]
}
if {[regexp -nocase "And|Or|ButNot" $Action]} {
set TamisOuListe2 $TamisOuListe2OuGrilleOuCritere
if {$TamisOuListe2=="X"} {
set NomTamisEntrant2 [ChoisisUnTamis "ChampNom"]
if {$NomTamisEntrant2==""} { return {} }
set ComTamisEntrant2 [LeTamis $NomTamisEntrant2]
} elseif {[LeTamis $TamisOuListe2]!="TamisInconnu"} {
set NomTamisEntrant2 $TamisOuListe2
set ComTamisEntrant2 [LeTamis $NomTamisEntrant2]
} else {
set NomTamisEntrant2 $TamisOuListe2
set ComTamisEntrant2 $TamisOuListe2
}
set Commande "Tamis $NomTamisEntrant $Action $NomTamisEntrant2"
NommeEtStockeLeTamis $Commande
if {$ComTamisEntrant=="TamisInconnu"} {
set ListeDeNoms1 {}
} else {
set ListeDeNoms1 [eval $ComTamisEntrant]
}
if {$ComTamisEntrant2=="TamisInconnu"} {
set ListeDeNoms2 {}
} else {
set ListeDeNoms2 [eval $ComTamisEntrant2]
}
switch [string toupper $Action] {
"AND" { return [ListsIntersection $ListeDeNoms1 $ListeDeNoms2] }
"OR" { return [ListsUnion $ListeDeNoms1 $ListeDeNoms2] }
"BUTNOT" { return [ListsComplement $ListeDeNoms1 $ListeDeNoms2] }
}
FaireLire "Y a un probleme dans Tamis"
return {}
}
if {[regexp -nocase "Where" $Action]} {
set NoMayBe "NoMayBe"
set GrilleOuCritere $TamisOuListe2OuGrilleOuCritere
if {$Operateur==""} {
set Grille $GrilleOuCritere
if {$Grille=="X"} {
set Grille [ChoisisUneGrille]
}
set NoMayBe $Grille
set COV [NoCo "Commande" $Grille]
ScanCOV $COV Critere Operateur Valeur
} else {
set Critere $GrilleOuCritere
}
if {$Critere=="X"} {
set Critere [ChoisisLeCritere]
if {$Critere==""} {
set Critere "AlwaysTrue"
set Operateur "=="
set Valeur "1"
}
}
if {$Operateur=="X"} {
set Operateur [ChoixDansLaListe {"<" "<=" "==" ">=" ">" "!=" "Contains" "NotContains"} ]
}
if {$Valeur=="X"} {
set Valeur [Entre]
}
if {$Valeur=="?"} {
set QuestionnerToujours 1
set Valeur [Entre]
} else {
set QuestionnerToujours 0
}
if {$QuestionnerToujours} {
set COV "$Critere $Operateur ?"
} else {
set COV "$Critere $Operateur $Valeur"
}
set Grille [NoCo "MieuxNommer" $NoMayBe $COV]
set Commande "Tamis $NomTamisEntrant $Action $Grille"
NommeEtStockeLeTamis $Commande
set LesBons {}
set CasFavorables {}
switch $Operateur {
"<" { set CasFavorable {"-1"} }
"<=" { set CasFavorable {"-1" "0"} }
"==" { set CasFavorable {"0"} }
">=" { set CasFavorable {"0" "1"} }
">" { set CasFavorable {"1"} }
"!=" { set CasFavorable {"-1" "1"} }
default { set CasFavorable "1" }
}
regsub {\?$} $Valeur "" Valeur
if {$ComTamisEntrant=="TamisInconnu"} { return {} }
set ListeDeNoms [eval $ComTamisEntrant]
set AutresArgs ""
set SesArgs [info args $Critere]
set nArgs [llength $SesArgs]
if {$nArgs>1} {
FaireLire "$Critere \{$SesArgs\} need [incr nArgs -1] additionnal arguments. Please give me them."
set AutresArgs [Entre]
}
foreach Nom $ListeDeNoms {
if {$AutresArgs==""} {
set ValeurCalculee [eval $Critere $Nom]
} else {
set ValeurCalculee [eval $Critere $Nom $AutresArgs]
}
if {$Operateur=="Contains"} {
set T [regexp -nocase "$Valeur" "$ValeurCalculee"]
} elseif {$Operateur=="NotContains"} {
set T [expr ! [regexp -nocase "$Valeur" "$ValeurCalculee"]]
} else {
if { ! [catch {if {[expr $ValeurCalculee $Operateur $Valeur]} { lappend LesBons $Nom }}]} { continue }
set T [string compare $ValeurCalculee $Valeur]
}
foreach Cas $CasFavorable {
if {$T==$Cas} {
lappend LesBons $Nom
break
}
}
}
return $LesBons
}
if {[regexp -nocase "Keep" $Action]} {
set NoMayBe "NoMayBe"
set Critere $TamisOuListe2OuGrilleOuCritere
if {$Critere=="X"} {
set Critere [ChoisisLeCritere]
if {$Critere==""} {
set Critere "AlwaysTrue"
}
}
set COV [NoCo "Commande" $Critere]
if {$COV!=""} {
set NoNomme $Critere
set Critere $COV
} else {
# on pourrait y rajouter des args supplementaires pris dans operateur et valeur
set COV $Critere
set NoNomme [NoCo "MieuxNommer" $NoMayBe $COV]
}
set Commande "Tamis $NomTamisEntrant $Action $NoNomme"
NommeEtStockeLeTamis $Commande
set LesBons {}
if {$ComTamisEntrant=="TamisInconnu"} { return {} }
set ListeDeNoms [eval $ComTamisEntrant]
set AutresArgs ""
set SesArgs [info args $Critere]
set nArgs [llength $SesArgs]
if {$nArgs>1} {
FaireLire "$Critere \{$SesArgs\} need [incr nArgs -1] additionnal arguments. Please give me them."
set AutresArgs [Entre]
}
foreach Nom $ListeDeNoms {
if {$AutresArgs==""} {
set ValeurCalculee [eval $Critere $Nom]
} else {
set ValeurCalculee [eval $Critere $Nom $AutresArgs]
}
lappend LesBons "$Nom $ValeurCalculee"
}
return $LesBons
}
FaireLire "Action $Action unknown in Tamis"
return {}
}
proc AffecteListeDesPABs Liste {
global MemoAffecteListeDesPABs
global ListeDesPABs
if {$Liste=="Reset"} {
if { ! [info exists MemoAffecteListeDesPABs]} {
return [ListeDesPABs]
}
set ListeDesPABs $MemoAffecteListeDesPABs
unset MemoAffecteListeDesPABs
return $ListeDesPABs
}
if { ! [info exists MemoAffecteListeDesPABs]} {
set MemoAffecteListeDesPABs [ListeDesPABs]
}
set ListeDesPABs $Liste
return $ListeDesPABs
}
proc ListeDesJumeauxRepresentatifs {} {
return [JumeauRepresentatif "LaListeMerci"]
}
proc RechargeListeDesPABs {} {
global ListeDesPABs
if {[info exists ListeDesPABs]} { unset ListeDesPABs }
return [ListeDesPABs]
}
proc ListeDesPABs {{NouveauPAB ""}} {
global ListeDesPABs
if { ! [info exists ListeDesPABs]} {
ChargeLesPABs
}
if {$NouveauPAB!="" && [lsearch -exact $ListeDesPABs $NouveauPAB]<0} {
lappend ListeDesPABs $NouveauPAB
}
return $ListeDesPABs
}
proc ListeDesGLIMMERs {} {
global ListeDesGLIMMERs
if { ! [info exists ListeDesGLIMMERs]} { ChargeLesGLIMMERs }
return $ListeDesGLIMMERs
}
proc ListeDesTRNAs {} {
global ListeDesTRNAs
if { ! [info exists ListeDesTRNAs]} { ChargeLesTRNAs }
return $ListeDesTRNAs
}
proc ListeDesARNs {} {
global ListeDesARNs
if { ! [info exists ListeDesARNs]} { ChargeLesARNs }
return $ListeDesARNs
}
proc ListeDeBoites {} {
global ListeDeBoites
if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
return $ListeDeBoites
}
proc ListeDesTROUs {} {
global ListeDesTROUs
if { ! [info exists ListeDesTROUs]} { ChargeLesTROUs }
return $ListeDesTROUs
}
proc ChargeListeDeBoites {} {
global RepertoireDuGenome
global ADN TDN RAC
global ContenusDesBox
global ListeDeBoites
global ListeDesTRNAs
global ListeDesARNs
global ListeDesTROUs
global ListeDesGLIMMERs
global ListeDesFusions
set ListeDeBoites {}
if { ! [info exists ListeDesPABs]} { ChargeLesPABs }
if { ! [info exists ListeDesFusions]} { ListeDesFusions }
if { ! [info exists ListeDesTRNAs]} { ChargeLesTRNAs }
if { ! [info exists ListeDesARNs]} { ChargeLesARNs }
if { ! [info exists ListeDesTROUs]} { ChargeLesTROUs }
if { ! [info exists ListeDesGLIMMERs]} { ChargeLesGLIMMERs }
return $ListeDeBoites
}
proc ChargeLesPABs {} {
global ListeDesPABs
global ListeDeBoites
# if {[OnTraite "REFUNI" "NonStrict"]} { set ListeDesPABs {} ; set ListeDesBoites {} ; return {} }
set FichierBornesDesPABs "[RepertoireDuGenome]/fiches/bornesdespabs"
while { ! [file exists $FichierBornesDesPABs]} { CreeLaBaseOuLaCollection }
set LesBornes [LesLignesDuFichier $FichierBornesDesPABs]
set ListeDeBoites {}
set ListeDesPABs {}
foreach Ligne $LesBornes {
if { ! [YaPABdans $Ligne] } {
continue
}
ExtraireDe $Ligne Nom Debut Fin Orient
if {[regexp {\-([0-9]+)$} $Debut Match D] && [regexp {\-([0-9]+)$} $Fin Match F]} {
#rR on traite le cas Chr01-12345 Chr01-12389
set Long [expr $F-$D+1]
set Frame [NomDeLaFrame [expr $D%3] $Orient]
} else {
set Long [expr $Fin-$Debut+1]
set Frame [NomDeLaFrame [expr $Debut%3] $Orient]
}
set Boite $Nom
Box $Boite nom $Nom
Box $Boite orient $Orient
Box $Boite frame $Frame
Box $Boite debut $Debut
Box $Boite fin $Fin
Box $Boite long $Long
lappend ListeDeBoites $Boite
lappend ListeDesPABs $Nom
}
return $ListeDesPABs
}
proc ChargeLesTRNAs {} {
global RepertoireDuGenome
global ListeDeBoites
global ListeDesTRNAs
set ListeDesTRNAs {}
if {[OnTraiteUneCollection]} { return {} }
set FichierBornesDesTRNAs "$RepertoireDuGenome/fiches/bornesdestrnas"
if {[file exists $FichierBornesDesTRNAs]} {
set LesBornes [LesLignesDuFichier "$FichierBornesDesTRNAs"]
set LireDansBornes 1
} else {
set FichierTRNAscan [lindex [glob -nocomplain "$RepertoireDuGenome/trnadir/tRNAscan*"] 0]
if {$FichierTRNAscan != "" && \
[OuiOuNon "Je peux prendre $FichierTRNAscan pour les tRNAs ?"]} {
} else {
if { 1 || ! [OuiOuNon "Y a t-il un fichier tRNAscan quelque part ?"]} {
return {}
} else {
set FichierTRNAscan [ButineArborescence All]
if {$FichierTRNAscan == ""} { return {} }
}
}
set LesBornes [LesLignesDuFichier "$FichierTRNAscan"]
set LireDansBornes 0
}
set DejaVus {}
set NombreDeLignesASauter 3
foreach Ligne $LesBornes {
if {$LireDansBornes} {
ExtraireDe $Ligne Nom Debut Fin Orient
} else {
if { $NombreDeLignesASauter > 0 } { incr NombreDeLignesASauter -1 ; continue }
scan $Ligne "%s %d %d %d %s %s %d %d %f" Bidon n Debut Fin Type AntiCodon IntronBegin IntronEnd CoveScore
set Nom "TRNA$Type$AntiCodon"
if { ! [regexp {[A-Z][a-z][a-z]} $Type] || \
! [regexp {[ATGC][ATGC][ATGC]} $AntiCodon]} {
FaireLire "$Nom n'est pas conforme ... faudra me dire comment je l'appelle."
set Nom [Entre "TRNAXxxNNN"]
}
set Orient "F"
if { [expr $Fin < $Debut] } {
set Temp $Debut
set Debut $Fin
set Fin $Temp
set Orient "R"
}
}
while {[lsearch $DejaVus $Nom] >= 0} {
if {[info exists Nieme($Nom)]} {
incr Nieme($Nom)
} else {
set Nieme($Nom) 2
}
set Nom "$Nom-[set Nieme($Nom)]"
}
lappend DejaVus $Nom
if {[regexp {\-([0-9]+)$} $Debut Match D] && [regexp {\-([0-9]+)$} $Fin Match F]} {
#rR on traite le cas Chr01-12345 Chr01-12389
set Long [expr $F-$D+1]
} else {
set Long [expr $Fin-$Debut+1]
}
set Frame [NomDeLaFrame TRNA $Orient]
set Boite $Nom
Box $Boite nom $Nom
Box $Boite orient $Orient
Box $Boite frame $Frame
Box $Boite debut $Debut
Box $Boite fin $Fin
Box $Boite long $Long
lappend ListeDeBoites $Boite
lappend ListeDesTRNAs $Nom
}
if { ! $LireDansBornes && [OuiOuNon "Je sauve les tRNAs dans $FichierBornesDesTRNAs"]} {
set Liste {}
foreach TRNA $ListeDesTRNAs {
set Nom [Box $TRNA nom]
set Orient [Box $TRNA orient]
set Debut [Box $TRNA debut]
set Fin [Box $TRNA fin]
lappend Liste "$Nom $Debut $Fin $Orient"
}
SauveLesLignes $Liste dans $FichierBornesDesTRNAs
}
}
proc ChargeLesARNs {} {
global RepertoireDuGenome
global ListeDeBoites
global ListeDesARNs
set ListeDesARNs {}
if {[file exists "$RepertoireDuGenome/fiches/bornesdesarns"]} {
set LesBornes [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdesarns"]
set LireDansBornes 1
} else {
if { ! [OnTraiteUnGenome]} { return {}}
if { ! [file isdirectory "$RepertoireDuGenome/arndir"] && \
[glob -nocomplain "$RepertoireDuGenome/fiches/*arn*"]=={}} { return {}}
if { ! [OuiOuNon "Y a t-il un fichier ARN quelque part ?" 0]} { return {} }
set FichierARN [ButineArborescence All]
if {$FichierARN == ""} { return {} }
set LesBornes [LesLignesDuFichier "$FichierARN"]
set LireDansBornes 0
}
foreach Ligne $LesBornes {
if {$LireDansBornes} {
ExtraireDe $Ligne Nom Debut Fin Orient
} else {
if { ! [regexp {\:} $Ligne]} { continue }
scan $Ligne "%s %s %d %s %d" Nom dp Debut Moins Fin
set Nom "ARN$Nom"
set Orient "F"
if { [expr $Fin < $Debut] } {
set Temp $Debut
set Debut $Fin
set Fin $Temp
set Orient "R"
}
}
if {[regexp {\-([0-9]+)$} $Debut Match D] && [regexp {\-([0-9]+)$} $Fin Match F]} {
#rR on traite le cas Chr01-12345 Chr01-12389
set Long [expr $F-$D+1]
} else {
set Long [expr $Fin-$Debut+1]
}
set Frame [NomDeLaFrame ARN $Orient]
set Boite $Nom
Box $Boite nom $Nom
Box $Boite orient $Orient
Box $Boite frame $Frame
Box $Boite debut $Debut
Box $Boite fin $Fin
Box $Boite long $Long
lappend ListeDeBoites $Boite
lappend ListeDesARNs $Nom
}
}
proc ChargeLesTROUs {} {
global RepertoireDuGenome
global ListeDesTROUs
global ListeDeBoites
global SansLesTrous
set SansLesTrous 0
if {[info exists SansLesTrous] && $SansLesTrous } {
set ListeDesTROUs {}
return $ListeDesTROUs
}
set ListeDesTROUs {}
if { ! [file exists "$RepertoireDuGenome/fiches/bornesdestrous"]} { return $ListeDesTROUs }
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdestrous"] {
ExtraireDe $Ligne Nom Debut Fin Orient
# if {[NombreDeCopainsDansBlast $Nom] < 1} { continue }
set Frame [string range $Nom [string length "TROUxxxx"] end]
if {[regexp {[ABCN]} $Frame]} {
set Orient "F"
} else {
set Orient "R"
}
set Long [expr $Fin-$Debut+1]
set Boite $Nom
Box $Boite nom $Nom
Box $Boite orient $Orient
Box $Boite frame $Frame
Box $Boite debut $Debut
Box $Boite fin $Fin
Box $Boite long $Long
lappend ListeDeBoites $Boite
lappend ListeDesTROUs $Nom
}
return $ListeDesTROUs
}
proc ChargeLesGLIMMERs {} {
global ListeDeBoites
global ListeDesGLIMMERs
set ListeDesGLIMMERs {}
set FichierBornesDesGlimmers "[RepertoireDuGenome]/fiches/bornesdesglimmers"
if { ! [file exists $FichierBornesDesGlimmers]} { return $ListeDesGLIMMERs }
set LesBornes [LesLignesDuFichier $FichierBornesDesGlimmers]
foreach Ligne $LesBornes {
if { ! [regexp "GLIMMER" $Ligne] } { continue }
ExtraireDe $Ligne Nom Debut Fin Orient
set Long [expr $Fin-$Debut+1]
set Frame [NomDeLaFrame [expr $Debut%3] $Orient]
set Boite $Nom
Box $Boite nom $Nom
Box $Boite orient $Orient
Box $Boite frame $Frame
Box $Boite debut $Debut
Box $Boite fin $Fin
Box $Boite long $Long
lappend ListeDeBoites $Boite
lappend ListeDesGLIMMERs $Nom
}
return $ListeDesGLIMMERs
}
proc ChargeLesInterGenes {} {
global RepertoireDuGenome
global ListeDesInterGenes
if { ! [file exists "$RepertoireDuGenome/fiches/bornesdesintergenes"]} {
RecreeLeFichierBornesDesInterGenes
}
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdesintergenes"] {
ExtraireDe $Ligne Nom Debut Fin Orient
set Long [expr $Fin-$Debut+1]
set Orient "F"
set Frame "I"
set Boite $Nom
Box $Boite nom $Nom
Box $Boite orient $Orient
Box $Boite frame $Frame
Box $Boite debut $Debut
Box $Boite fin $Fin
Box $Boite long $Long
lappend ListeDesInterGenes $Boite
}
return $ListeDesInterGenes
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.