Index by: file name |
procedure name |
procedure call |
annotation
gscope_clotools.tcl
(annotations | original source)
#rR gscope_clotools.tcl
proc CreateCommandeSigmaFromIgbmc {{LesFichiersCommande {}} {GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "GetList" }
if {$LesFichiersCommande=={}} {
set LesFichiersCommande [MorceauxChoisis [lsort [glob -nocomplain "*_commande*.txt"]]]
}
set SigmaScaleMicroMol [Entre "Scale in Micro Mol to order at Sigma: 0.05"]
regsub -all {[^0-9\.]} $SigmaScaleMicroMol "" SigmaScaleMicroMol
set SigmaPurification [Entre "Purification for Sigma: RPI"]
regsub {[^\:]*\:} $SigmaPurification "" SigmaPurification
set SigmaPurification [string trim $SigmaPurification]
set SigmaComment ""
set ListeSigma {}
foreach FichierCommande $LesFichiersCommande {
set OnAttend 1
foreach Ligne [LesLignesDuFichier $FichierCommande] {
if {[regexp "FIN DE COMMANDE" $Ligne]} { break }
if {$OnAttend} {
if { [regexp -- {\-\-\-\-\-} $Ligne]} { set OnAttend 0 }
continue
}
if { [regexp -- {\-\-\-\-\-} $Ligne]} { continue }
if { [string trim $Ligne]==""} { continue }
if {[regexp { *[0-9]+ +P[0-9]+ *} $Ligne]} {
scan $Ligne "%d %s %s" n P SS
set Seq($P) ""
set SigSuj($P) $SS
lappend LesP $P
continue
}
regsub {[53]'} $Ligne "" S
regsub -all " " $S "" S
append Seq($P) $S
}
}
foreach P $LesP {
lappend ListeSigma "$P $SigSuj($P)\t$Seq($P)\t$SigmaScaleMicroMol\t$SigmaPurification\t$SigmaComment"
}
if {$GetWhat=="GetList"} { return $ListeSigma }
if {$GetWhat=="GetText"} { return [join $ListeSigma "\n"] }
return [SauveLesLignes $ListeSigma dans $GetWhat]
}
proc ChoisisWindowSizePourSlidingCodonRare {{WindowSize ""}} {
while { ! [regexp {^\-?[0-9]+} $WindowSize]} {
set WindowSize [ChoixParmi [list 1 10 20 30 40 50 "WholeSequence" "Other"]]
if {$WindowSize=="Other"} { set WindowSize [Entre 12] }
if {$WindowSize=="WholeSequence"} { set WindowSize -1 }
}
return $WindowSize
}
proc AfficheSlidingCodonRarePour {{Liste ""}} {
if {$Liste==""} {
set Liste [MorceauxChoisis [PresentationDesPABs]]
}
if {$Liste=={}} { return "" }
set WindowSize [ChoisisWindowSizePourSlidingCodonRare]
foreach Ligne $Liste {
scan $Ligne "%s" Nom
set FichierTFA "[RepertoireDuGenome]/nuctfa/$Nom"
if { ! [file exists $FichierTFA]} { continue }
set SCR [SlidingCodonRare $FichierTFA $WindowSize]
lappend LesSCRs $Ligne
lappend LesSCRs [join $SCR "\n"]
lappend LesSCRs ""
}
return [AfficheVariable [join $LesSCRs "\n"] "AvecRienGrandeLargeur" "SlidingCodonRare"]
}
proc AfficheSlidingCodonRare {Page {WindowSize ""}} {
set SCR [SlidingCodonRare $Page]
return [AfficheVariable [join $SCR "\n"] "AvecRienGrandeLargeur" "SlidingCodonRare"]
}
proc SlidingCodonRare {FichierOuTexteTFAOuSeq {WindowSize ""}} {
set LesRares [CodonsRares "LaListeMerci"]
if {[regexp "^>" $FichierOuTexteTFAOuSeq]} {
set Seq [QueLaSequenceDuTexteTFA $FichierOuTexteTFAOuSeq]
} else {
if { ! [regexp {[^ATGCN \n\t]} $FichierOuTexteTFAOuSeq]} {
regsub -all {[^ATGCN]} $FichierOuTexteTFAOuSeq "" Seq
} else {
if {[file exists $FichierOuTexteTFAOuSeq]} {
set Seq [QueLaSequenceDuFichierTFA $FichierOuTexteTFAOuSeq]
} else {
FaireLire "Following line(s) is not a filename, TFA text or a nucleic sequence\n\
$FichierOuTexteTFAOuSeq"
return ""
}
}
}
set Seq [string toupper $Seq]
set WindowSize [ChoisisWindowSizePourSlidingCodonRare $WindowSize]
if {$WindowSize<0} { set WindowSize [expr [string length $Seq]/3] }
set Decale [string range "[string repeat "NNN" $WindowSize]$Seq" 0 [string length $Seq]]
set LesBases [split $Seq ""]
set LesDecales [split $Decale ""]
set i 0
foreach {A B C} $LesBases {D E F} $LesDecales {
set Codon "$A$B$C"
set Decal "$D$E$F"
lappend LesCodons $Codon
if { ! [info exists Pic($Codon)]} { set Pic($Codon) 0 }
if { ! [info exists Cumul($Codon)]} { set Cumul($Codon) 0 }
if { ! [info exists Cumul($Decal)]} { set Cumul($Decal) 0 }
incr Cumul($Codon)
incr Cumul($Decal) -1
if {[set Cumul($Codon)] == [set Pic($Codon)]} { lappend PosDuPic($Codon) [expr $i/3+1] }
if {[set Cumul($Codon)] > [set Pic($Codon)]} {
set Pic($Codon) [set Cumul($Codon)]
set SeqDuPic($Codon) [string range $Seq [expr $i+3-$WindowSize*3] [expr $i+2]]
set PosDuPic($Codon) [list [expr $i/3+1]]
}
incr i 3
}
set LesCodons [lsort -unique $LesCodons]
set Sortie {}
foreach Rare $LesRares {
if { ! [info exists Pic($Rare)]} { continue }
set SdP [set SeqDuPic($Rare)]
set BelleSdP ""
foreach {A B C} [split $SdP ""] {
set Codon "$A$B$C"
if {$Codon!=$Rare} { set Codon [string tolower $Codon] }
append BelleSdP "$Codon "
}
lappend Sortie "$Rare [set Pic($Rare)] $BelleSdP [join [set PosDuPic($Rare)] " "]"
}
Espionne $Sortie
return $Sortie
}
proc BaClonExists args {
global BaClon
if {$args=={}} { return [info exists BaClon(EstCharge)]}
set Quoi [join $args ","]
return [info exists BaClon($Quoi)]
}
proc BaClonAppend args {
global BaClon
set Quoi [join [lrange $args 0 end-1] ","]
set Valeur [lindex $args end]
if {[info exists BaClon($Quoi)] && [lsearch -exact [set BaClon($Quoi)] $Valeur]>-1} {
return [set BaClon($Quoi)]
}
return [lappend BaClon($Quoi) $Valeur]
}
proc BaClonSet args {
global BaClon
set Quoi [join [lrange $args 0 end-1] ","]
set Valeur [lindex $args end]
return [set BaClon($Quoi) $Valeur]
}
proc BaClonUnset args {
global BaClon
set Quoi [join $args ","]
catch {unset BaClon($Quoi)}
}
proc BaClon args {
global BaClon
if {$args=={}} {
return [list \
"BaClon LesSujets PGS" \
"BaClon LesOligos PGS" \
"BaClon LesOligosDuCouple PGS Sujet" \
"BaClon Trio PGS Sujet P"]
}
if {$args=="Save"} {
set FichierBaClon "[RepertoireDuGenome]/fiches/baclon"
SauveLesLignes [array get BaClon] dans $FichierBaClon
return $FichierBaClon
}
set Quoi [join $args ","]
if {[info exists BaClon($Quoi)]} { return [set BaClon($Quoi)] }
if {[info exists BaClon(EstCharge)]} { return "" }
set FichierBaClon "[RepertoireDuGenome]/fiches/baclon"
if {[file exists $FichierBaClon]} {
array set BaClon [LesLignesDuFichier $FichierBaClon]
}
set BaClon(EstCharge) 1
if {[info exists BaClon($Quoi)]} { return [set BaClon($Quoi)] }
return ""
}
proc TMDeLaSequence {Seq} {
regsub -all " " $Seq "" Seq
set Seq [string toupper $Seq]
set Texte [ContenuDuFichier "[LbgiUrl]/MeltingTemperatureBioPhp.php?primer=$Seq&NearestNeighbor=1&cp=500&cs=50&cmg=1"]
set Temp [FloatApres "<tmvalue>" dans $Texte]
if {$Temp>55} { Espionne "$Temp $Seq" }
return $Temp
#suite obsolete
set nAT [regexp -all -nocase {[AT]} $Seq]
set nGC [regexp -all -nocase {[GC]} $Seq]
set nATGC [expr $nAT+$nGC]
if {$nATGC < 14 } {
set Temp [expr $nAT*2 + $nGC*4]
} else {
set Temp [expr 64.9 + 41*($nGC - 16.4)/$nATGC]
}
return $Temp
#suite obsolete
if {0} {
set TM(A) 2
set TM(T) 2
set TM(G) 4
set TM(C) 4
set Seq [string toupper $Seq]
set Cumul 0
foreach Base [split $Seq ""] {
if {[info exists TM($Base)]} { incr Cumul [set TM($Base)] }
}
return $Cumul
}
}
proc EntammePourMeltingTemp {Seq TmVoulu {TmSiFinGC ""}} {
# TmVoulu peut contenir les deux
if {[regexp {([0-9\.]+) +([0-9\.]+)} $TmVoulu Match TmATGC TmGC]} {
set TmVoulu $TmATGC
set TmSiFinGC $TmGC
}
if {$TmSiFinGC==""} { set TmSiFinGC $TmVoulu }
set Seq [string toupper $Seq]
set Entamme ""
foreach Base [split $Seq ""] {
append Entamme $Base
if { ! [regexp {[ATGC]} $Base]} { continue }
set TM [TMDeLaSequence $Entamme]
if {$TM >= $TmVoulu} { break }
if {$TM >= $TmSiFinGC && ($Base=="G" || $Base=="C")} { break }
}
return $Entamme
}
proc CreeLesOligosManquants {} {
FaireLire "ne pas relancer"; exit
cd "[RepertoireDuGenome]/oligos"
set iP 2798
foreach P [list P2644.tfa P2645.tfa P2652.tfa P2654.tfa P2655.tfa P2657.tfa P2658.tfa P2660.tfa] {
regsub ".tfa" $P "" BP
set TFA [ContenuDuFichier $P]
set Entete [EnteteDuTexteTFA $TFA]
set Seq [QueLaSequenceDuTexteTFA $TFA]
set SB [StringApres " signal " dans $Entete]
set ST [StringApres " replaces " dans $Entete]
set Sujet [StringApres " for " dans $Entete]
regsub "_$SB" $ST "" SA
Espionne "$ST $SA"
set SSA [Signal $SA "SEQ"]
set FullSeq "$SSA$Seq"
set FullP "P$iP"
incr iP
regsub "AfterMeButItDoesNotExist" $Entete $FullP NewEntete
set NewTFA [SequenceFormatTFA $Seq $NewEntete "nucbrut"]
set FullE "$FullP 5' oligo with signal $ST for $Sujet RebuildedBrockenOli of $SA seeBrocken $BP"
set FullTFA [SequenceFormatTFA $FullSeq $FullE "nucbrut"]
Sauve $NewTFA dans $P
Sauve $FullTFA dans "$FullP.tfa"
}
}
proc OperonClonage {Nom {Qui ""} {Quoi ""}} {
if { ! [EstUnPAB $Nom]} { set Nom [NomDuAlias $Nom] }
if { ! [EstUnPAB $Nom]} { return "" }
set Operon [ExtraitInfo $Nom "Operon:"]
if {$Operon==""} { return ""}
if {$Qui ==""} { set Qui "GetOperon" }
if {$Quoi==""} { set Quoi "GetSequence" }
if {$Qui =="GetOperon"} { return [split $Operon " "]}
foreach {G D F} [split $Operon " "] {
if {$Qui==$G} {
if {$Quoi=="GetStartEnd"} { return "$D $F" }
if {$Quoi=="GetStart"} { return $D }
if {$Quoi=="GetEnd"} { return $F }
if {$Quoi=="GetSequence"} {
set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
return [string range "n$Seq" $D $F]
}
}
}
return ""
}
proc OperonNancyInforme {} {
FaireLire "Ne plus relancer. Merci"; exit;
foreach Nom [ListeDesPABs] {
set FicNucTfa [GscopeFile $Nom "nuctfa"]
if {[FileAbsent $FicNucTfa]} { continue }
set Entete [EnteteDuFichierTFA $FicNucTfa]
if { ! [regexp "operon coding for" $Entete]} { continue }
set SeqNucOp "n[QueLaSequenceDuFichierTFA $FicNucTfa]"
set Reste [StringSuivant "operon coding for" dans $Entete]
set LesGDF {}
set LesSeqPro {}
while {[regexp {operonprot ([^ ]+) +base +([0-9]+) +to +([0-9]+)} $Reste Match Gene Deb Fin]} {
regsub {operonprot ([^ ]+) +base +([0-9]+) +to +([0-9]+)} $Reste "" Reste
lappend LesGDF $Gene $Deb $Fin
set SeqNuc [string range $SeqNucOp $Deb $Fin]
set SeqDep [QueLaSequenceDuFichierTFA "[OperonNancy Directory]/$Gene.tfa"]
if { ! [string equal $SeqNuc $SeqDep]} {
Espionne "$SeqNucOp\n$SeqNuc\n$SeqDep"
FaireLire "$Nom $Gene something is wrong\
\n[string range $SeqNuc 0 44]\n[string range $SeqDep 0 44]"
}
set SeqPro [SeqNucToSeqPro $SeqNuc]
lappend LesSeqPro $SeqPro
}
set AllSeqPro [join $LesSeqPro "XXXXXXXXXX"]
set AllTfaPro [SequenceFormatTFA $AllSeqPro $Entete "protbrut"]
Espionne $AllTfaPro
Sauve $AllTfaPro dans [GscopeFile $Nom "prottfa"]
set Info "Operon: [join $LesGDF " "]"
InformeSansDemander $Nom $Info
Espionne $Info
}
}
proc OperonNancyCreateSequences {} {
FaireLire "Ne plus relancer. Merci"; exit;
cd [OperonNancy "Directory"]
foreach OS [OperonNancy ListOf OS] {
set GE [OperonNancy $OS ge]
set Nuc2 [OperonNancy $GE nuc]
set FE "mhpFE$GE"
set F [OperonNancy $GE F]
set E [OperonNancy $GE E]
set NucF [OperonNancy $F nuc]
set NucE [OperonNancy $E nuc]
set dF 1
set fF [expr [string length $NucF] ]
set dE [expr [string length $Nuc2]-[string length $NucE] + 1]
set fE [expr [string length $Nuc2] ]
set Entete2 "$FE $OS mhp operon coding for operonprot $F base $dF to $fF and operonprot $E base $dE to $fE"
set EnteteF "$F $OS mhp protein F"
set EnteteE "$E $OS mhp protein E"
set Tfa2 [SequenceFormatTFA $Nuc2 $Entete2 "nucbrut"]
set TfaF [SequenceFormatTFA $NucF $EnteteF "nucbrut"]
set TfaE [SequenceFormatTFA $NucE $EnteteE "nucbrut"]
lappend LesFichiers [Sauve $Tfa2 dans $FE.tfa]
lappend LesFichiers [Sauve $TfaF dans $F.tfa]
lappend LesFichiers [Sauve $TfaE dans $E.tfa]
}
return $LesFichiers
}
proc OperonNancy {{Qui ""} {Quoi ""}} {
FaireLire "Ne plus relancer. Merci"; exit;
#rR OperonNancy lit le seqs.txt et fournit les mhpEF mhpF mhpE
global OperonNancy
if {$Qui==""} { set Qui "ListOf"; set Quoi "keys"; }
if {[info exists OperonNancy($Qui,$Quoi)]} { return $OperonNancy($Qui,$Quoi) }
if {[info exists OperonNancy("EstCharge")]} { return "" }
set OperonNancy("EstCharge") 1
set NancyDir "[RepertoireDuGenome]/atelier/OperonNancy"
set FiSeqs "$NancyDir/seqs.txt"
set OperonNancy(Directory,) $NancyDir
foreach Ligne [LesLignesDuFichier $FiSeqs] {
set Ligne [string trim $Ligne]
if {$Ligne==""} { continue }
if {[regexp {^ *mhp} $Ligne]} {
if {[regexp {([0-9]+) *AA} $Ligne Match na]} {
incr na
scan $Ligne "%s" P
if { ! [regexp {mhp(F|E)([a-z]+)} $P Match FE GE]} { FaireLire "Gloups on \n$Ligne" ; exit }
if {$ge!=$GE} { FaireLire "$ge $GE on \n$Ligne" ; exit }
set $FE "mhp$FE$GE"
set Long($FE) $na
if {$FE=="F"} {
set F [set $FE]
lappend OperonNancy(ListOf,F) $F
set OperonNancy($GE,F) $F
set nb $na*3
set db 0
set fb [expr $nb-1]
set OperonNancy($F,nuc) [string range $OperonNancy($GE,nuc) $db $fb]
set Courant $F
}
if {$FE=="E"} {
set E [set $FE]
lappend OperonNancy(ListOf,E) $E
set OperonNancy($GE,E) $E
set nb $na*3
set db [expr $nb-1]
set OperonNancy($E,nuc) [string range $OperonNancy($GE,nuc) end-$db end]
set Courant $E
}
continue
}
if { ! [regexp {mhpFE ([a-zA-z0-9 ]+)} $Ligne Match OS]} { FarireLire "Oups \n$Ligne"; exit }
scan $OS "%s %s" g e
set ge "[string tolower [string index $g 0]][string tolower [string index $e 0]]"
if {[info exists DejaVu($ge) ]} {
set ge "[string tolower [string index $g 0]][string tolower [string range $e 0 1]]"
}
set DejaVu($ge) $Ligne
lappend OperonNancy(ListOf,OS) $OS
lappend OperonNancy(ListOf,GE) $ge
set OperonNancy($OS,ge) $ge
set OperonNancy($ge,os) $OS
set Courant "TwoNuc"
continue
}
if {$Courant=="TwoNuc"} { regsub -all "X" $Ligne "N" SeqNuc ; set OperonNancy($ge,nuc) $SeqNuc; }
if {$Courant!="TwoNuc"} {
set OperonNancy($Courant,pro) $Ligne
set ProFromNuc [SeqNucToSeqPro $OperonNancy($Courant,nuc)]
if { ! [string equal -nocase $OperonNancy($Courant,pro) $ProFromNuc]} {
FaireLire "$OperonNancy($Courant,pro)\n$ProFromNuc"
}
}
}
set OperonNancy(ListOf,keys) [lsort [array names OperonNancy]]
lappend OperonNancy(ListOf,keys) "ListOf,keys"
return [OperonNancy $Qui $Quoi]
}
proc MiseAJourOligosExisting {} {
foreach Fichier [glob "[RepertoireDuGenome]/atelier/*/*existing*.list"] {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s %s %s %s" ASA please use P
lassign [DecomposeLaLigne $ASA] LesSujets
set FicOli "[RepertoireDuGenome]/oligos/$P.tfa"
if {[FileAbsent $FicOli]} { continue }
set Tfa [ContenuDuFichier $FicOli]
set Description [PremiereLigneDuFichier $FicOli]
if {$Description==""} { continue }
if {[regexp "oligoignore" $Description]} { continue }
set NewTfa $Tfa
set YaFull [regexp {seeFull (P[0-9]+)} $Description Match F]
while {$YaFull} {
set FicOliF "[RepertoireDuGenome]/oligos/$F.tfa"
if {[FileAbsent $FicOliF]} { set YaFull 0 ; break }
set TfaF [ContenuDuFichier $FicOliF]
set DesF [PremiereLigneDuFichier $FicOli]
if {[regexp "oligoignore" $DesF]} { set YaFull ; break }
set NewTfaF $TfaF
break
}
foreach Sujet $LesSujets {
if {[string first " $Sujet " "$Description "]>0} { continue }
Espionne
Espionne $Ligne
regsub "for " $NewTfa "for $Sujet " NewTfa
Espionne "$Tfa\n$NewTfa"
if {$YaFull && [string first " $Sujet " "$DesF "]<0} {
regsub "for " $NewTfaF "for $Sujet " NewTfaF
Espionne "$TfaF\n$NewTfaF"
}
}
# if { $Tfa !=$NewTfa } {Sauve $NewTfa dans $FicOli}
# if {$YaFull && $TfaF!=$NewTfaF} {Sauve $NewTfaF dans $FicOliF}
}
}
}
proc RepareLesRebuilded {} {
foreach FP [glob "[RepertoireDuGenome]/oligos20081202/P*.tfa"] {
set TFA [ContenuDuFichier $FP]
if { ! [regexp -nocase "Rebuilded" $TFA]} { continue }
if { [regexp -nocase "without signal" $TFA]} { continue }
Espionne $TFA
scan $TFA "%s %s %s %s %s %s %s %s %s" P O w s f B r o S
regsub ">" $P "" P
set LesSubjects [Oli $B "Subjects"]
set Subjects [join $LesSubjects " "]
set Signals [Oli $B "Signals"]
set SignalsFull [Oli $B "SignalsFull"]
set Sens [Oli $B "Sens"]
Espionne "$P $B $S $Subjects $Signals $SignalsFull"
regsub "oligo without signal for $B" $TFA "$Sens oligo with signal $SignalsFull for $Subjects" NewTFA
regsub "oligos20081202" $FP "oligos" NewFP
# Sauve $NewTFA dans $NewFP
}
}
proc VerifieLesMutantsPourClonage {} {
set LesMalPlaces {}
foreach Ligne [LesLignesDuFichier [Fiches "bornesdespabs"]] {
Espionne $Ligne
scan $Ligne "%s %s %s" Nom D F
if {[info exists DejaVu($D,$F)]} {
set GrandFrere [GrandFrereDuMutant $Nom]
while {[EstUnPABMute $GrandFrere]} { set GrandFrere [GrandFrereDuMutant $GrandFrere] }
if {$DejaVu($D,$F)==$GrandFrere} { continue }
# FaireLire "$Nom $D $F $DejaVu($D,$F)"
lappend LesMalPlaces "$Nom $D $F $DejaVu($D,$F)"
}
set DejaVu($D,$F) $Nom
}
AfficheListe $LesMalPlaces
}
proc SignalReverse Signal {
return [NucToReverseAndComplementNuc [Signal $Signal]]
}
proc ShowCloning Nom {
foreach Ligne [LesLignesDuFichier [GscopeFile $Nom "notes"]] {
if { ! [regexp -nocase {[a-z]} $Ligne]} {
lappend LaPage $Ligne
continue
}
set Ref ""
scan $Ligne "%s" Cible
if {0} {
} elseif {[regexp {^P[0-9]{4,}$} $Cible]} {
set Ref "[WscopeScience]\\&ShowOli\\&$Cible"
} elseif {[regexp {^N[0-9]{4,}$} $Cible]} {
set Ref "[WscopeScience]\\&ShowVirtualPPCR\\&$Cible"
} elseif {[regexp {^N[0-9]{4,}_[0-9a-zA-Z]+$} $Cible]} {
set Ref "[WscopeScience]\\&FileMoi\\&rec1\\&$Cible"
} elseif {[regexp {^N[0-9]{4,}_[0-9a-zA-Z]+_[0-9a-zA-Z]+$} $Cible]} {
set Ref "[WscopeScience]\\&FileMoi\\&rec2\\&$Cible"
}
if {$Ref==""} {
lappend LaPage $Ligne
continue
}
regsub $Cible $Ligne "<a href='$Ref' target='_blank'>$Cible</a>" Ligne
lappend LaPage $Ligne
}
Html_ZeroToBody
Html_BackTo
Html_Append "<pre>[join $LaPage \n]</pre>"
return [Html_Get]
}
proc TestHdac {} {
set LesEnzymes [list BamHI BglII EcoRI NcoI NdeI NruI]
foreach Fichier [lsort -dictionary [glob "[RepertoireDuGenome]/atelier/hdac/hdac*.tfa"]] {
set ProtTfa [NucToProtTFA [ContenuDuFichier $Fichier]]
set L [string length [QueLaSequenceDuTexteTFA $ProtTfa]]
regsub ".tfa$" $Fichier .prottfa FichierProt
Sauve $ProtTfa dans $FichierProt
set Hits [CheckRestrictionEnzymes $Fichier $LesEnzymes "" "GetHits"]
lappend LaSortie $Hits
lappend LaSortie "[expr 3*$L] bases $L AA"
lappend LaSortie " "
}
set Sortie [join $LaSortie "\n"]
return [AfficheVariable $Sortie]
}
proc IUPAC B {
if {[string length $B] > 1} {
set Tout ""
foreach C [split $B ""] {
append Tout [IUPAC $C]
}
return $Tout
}
set B [string toupper $B]
if {$B=="A"} { return "A" }
if {$B=="G"} { return "G" }
if {$B=="C"} { return "C" }
if {$B=="T"} { return "T" }
if {$B=="U"} { return "T" }
if {$B=="M"} { return "\[AC\]" }
if {$B=="R"} { return "\[AG\]" }
if {$B=="W"} { return "\[AT\]" }
if {$B=="S"} { return "\[CG\]" }
if {$B=="Y"} { return "\[CT\]" }
if {$B=="K"} { return "\[GT\]" }
if {$B=="V"} { return "\[ACG\]" }
if {$B=="H"} { return "\[ACT\]" }
if {$B=="D"} { return "\[AGT\]" }
if {$B=="B"} { return "\[CGT\]" }
if {$B=="N"} { return "\[ACGT\]" }
return $B
}
proc RestrictionEnzymesStatistics {{Quoi ""}} {
set FichierStat "[Fiches]/EnzymesStatistics.txt"
set FichierHits "[Fiches]/EnzymesHits.txt"
if {$Quoi==""} { set Quoi "ShowHits" }
if {$Quoi=="Update"} {
file delete -force $FichierStat
file delete -force $FichierHits
regsub "Update" $Quoi "" Quoi
}
if {[FileExists $FichierStat] || [FileExists $FichierHits]} {
if {[regexp "Statistics" $Quoi]} { set Texte [ContenuDuFichier $FichierStat] }
if {[regexp "Hits" $Quoi]} { set Texte [ContenuDuFichier $FichierHits] }
if {[regexp "Show" $Quoi]} { return [AfficheVariable $Texte "" "RestrictionEnzymesStatistics"] }
return $Texte
}
foreach E [RestrictionEnzyme ListOf Enzymes] {
set SE [string toupper [RestrictionEnzyme $E "Sequence"]]
set SEX [IUPAC $SE]
set LesHits {}
set NbHits 0
foreach Nom [ListeDesPABs] {
if {[EstUnPABMute $Nom]} { continue }
set FichierTFA [GscopeFile $Nom "nuctfa"]
if {[FileAbsent $FichierTFA]} { continue }
set Seq [string toupper [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]]
if { ! [set N [regexp -all $SEX $Seq]]} { continue }
lappend LesHits [Alias $Nom]
incr NbHits $N
}
set EnzHitsCount "[format "%-8s %-20s %3d %4d" $E $SE [llength $LesHits] $NbHits]"
Espionne "$EnzHitsCount"
AppendAuFichier "$FichierStat" "$EnzHitsCount"
AppendAuFichier "$FichierHits" "$EnzHitsCount $LesHits"
}
return [RestrictionEnzymesStatistics $Quoi]
}
proc CheckRestrictionEnzymes {NomOuAlias {ListOfEnzymes ""} {Texte ""} {Quoi ""}} {
if {[regexp "^Get" $Texte]} { set Quoi $Texte ; set Texte "" }
regsub "^for_" $NomOuAlias "" NomOuAlias
if {$ListOfEnzymes=="" || $ListOfEnzymes=="All"} { set ListOfEnzymes [RestrictionEnzyme ListOf Enzymes] }
if {$ListOfEnzymes=="Signals"} {
set ListOfEnzymes {}
foreach Signal [Signal ListOf Signals] {
set EstUnSignal($Signal) 1
}
foreach E [RestrictionEnzyme ListOf Enzymes] {
if {[info exists EstUnSignal($E)]} { lappend ListOfEnzymes $E }
}
}
set Nom ""
set Alias ""
set DE ""
while {$Nom==""} {
if {$NomOuAlias=="FromFile"} { set Nom "FromFile" ; set NomOuAlias $Texte }
if {[regexp "/" $NomOuAlias]} { set Nom "FromFile" ; break }
if {$NomOuAlias=="FromSequence"} { set Nom $NomOuAlias ; break }
if {[EstUnPAB $NomOuAlias]} { set Nom $NomOuAlias ; break }
if {[NomDuAlias $NomOuAlias]!=""} { set Nom $NomOuAlias ; break }
if {$Texte==""} { set Texte $NomOuAlias }
set NomOuAlias "FromSequence"
}
if {[EstUnPAB $Nom]} {
set Alias [Alias $Nom]
set DE [DefinitionRapide $Nom]
set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
}
if {$Nom=="FromSequence"} {
if {[regexp ">" $Texte]} {
set Seq [QueLaSequenceDuTexteTFA $Texte]
} else {
set Seq $Texte
}
}
if {$Nom=="FromFile"} {
set Seq [QueLaSequenceDuFichierTFA $NomOuAlias]
set Nom $NomOuAlias
}
set Seq [string toupper $Seq]
set LesHits [list "CheckRestrictionEnzymes for $Nom $Alias $DE"]
foreach E $ListOfEnzymes {
set SE [string toupper [RestrictionEnzyme $E "Sequence"]]
set SEX [IUPAC $SE]
set LesDFs [regexp -all -indices -inline $SEX $Seq]
if {$LesDFs=={}} {
lappend LesHits "[format %-8s $E] [format %-20s $SE] NotFound"
} else {
set LesIs {}
foreach DF $LesDFs {
scan $DF "%d" I
lappend LesIs "[expr $I+1] [expr ($I+3)/3]"
}
lappend LesHits "[format %-8s $E] [format %-20s $SE] [join $LesIs " / "]"
}
}
set Hits [join $LesHits "\n"]
if {$Quoi=="GetHtml"} { return [Html_DuTexteTelQuel $Hits] }
if {$Quoi=="GetHits"} { return $Hits }
return [AfficheVariable $Hits "" "Restriction Enzymes Hits for $Nom"]
}
proc ShowRestrictionEnzyme {} {
foreach E [RestrictionEnzyme ListOf Enzymes] {
set Ligne [format "%-8s %-20s %s" $E [RestrictionEnzyme $E "Sequence"] [RestrictionEnzyme $E "SequenceCut"]]
lappend LesLignes $Ligne
}
set Texte [join $LesLignes "\n"]
return [AfficheVariable $Texte "AvecEnzyme" "RestrictionEnzymes"]
}
proc RestrictionEnzyme {{Qui ""} {Quoi ""}} {
global RestrictionEnzyme
if {$Qui==""} { set Qui "ListOf" }
if {$Quoi==""} {
set Quoi "Sequence"
if {$Qui=="ListOf"} { set Quoi "Enzymes" }
}
if {[info exists RestrictionEnzyme($Qui,$Quoi)]} { return $RestrictionEnzyme($Qui,$Quoi) }
if {[info exists RestrictionEnzyme("EstCharge")]} { return "" }
set RestrictionEnzyme("EstCharge") 1
set FichierEnzyme "[GscopeEtc]/enzyme.dat"
set RestrictionEnzyme(File,Name) $FichierEnzyme
set RestrictionEnzyme(File,Content) [ContenuDuFichier $FichierEnzyme]
set OnAttendPointPoint 1
foreach Ligne [LesLignesDuFichier $FichierEnzyme] {
if {$OnAttendPointPoint} {
if {[regexp {\.\.\s*$} $Ligne]} { set OnAttendPointPoint 0 }
continue
}
if {[regexp {^\;} $Ligne]} { continue }
regsub {>.*} $Ligne "" Ligne
set Ligne [string trim $Ligne]
set Enz ""
set SeqCut ""
set Autres ""
scan $Ligne "%s %d %s %d %s %s" Enz P SeqCut M Exclam Autres
if {$Enz=="" || $SeqCut==""} { continue }
set LesEnzymesCourants [split $Autres ","]
lappend LesEnzymesCourants $Enz
regsub -all {['_]} $SeqCut "" Seq
foreach Enzyme $LesEnzymesCourants {
set RestrictionEnzyme($Enzyme,SequenceCut) $SeqCut
set RestrictionEnzyme($Enzyme,Sequence) $Seq
lappend RestrictionEnzyme(ListOf,Enzymes) $Enz
lappend RestrictionEnzyme(ListOf,Sequence) $Seq
lappend RestrictionEnzyme(ListOf,SequenceCut) $SeqCut
}
set RestrictionEnzyme(ListOf,Sequence) [lsort -unique -dictionary $RestrictionEnzyme(ListOf,Sequence)]
set RestrictionEnzyme(ListOf,SequenceCut) [lsort -unique -dictionary $RestrictionEnzyme(ListOf,SequenceCut)]
set RestrictionEnzyme(ListOf,Enzymes) [lsort -unique -dictionary $RestrictionEnzyme(ListOf,Enzymes)]
}
return [RestrictionEnzyme $Qui $Quoi]
}
proc CompositionDesSequences {{Rep ""} {Action ""} {Ordre ""} {Sens ""}} {
if {$Rep==""} { set Rep [ChoixDuRepertoire [RepertoireDuGenome]] }
if {$Sens==""} { set Sens "increasing" }
if {$Ordre==""} { set Ordre 0 }
if {$Action==""} { set Action "Show" }
if { ! [regexp "/" $Rep]} { set Rep "[RepertoireDuGenome]/$Rep" }
foreach Fichier [lsort [glob -nocomplain $Rep/*]] {
set Nom [file tail $Fichier]
set Seq [QueLaSequenceDuFichierTFA $Fichier]
set Seq [string toupper $Seq]
set Entete [EnteteDuFichierTFA $Fichier]
set L [regexp -all "." $Seq]
set Ligne "$Nom length [format "%4d" $L] :"
foreach C [lsort -unique [split $Seq ""]] {
set N [regexp -all -nocase -- "$C" $Seq]
append Ligne " [format "%4d" $N] $C"
}
append Ligne " $Entete"
lappend LeTexte $Ligne
set ListeDesMots [LesMotsDeLaLigne $Ligne]
lappend LesListesDesMots $ListeDesMots
set TexteDesMots([join $ListeDesMots "_"]) $Ligne
}
set LeBonTexte {}
foreach LdM [lsort -$Sens -index $Ordre $LesListesDesMots] {
lappend LeBonTexte $TexteDesMots([join $LdM "_"])
}
if {$Action=="GetList"} { return $LeBonTexte }
if {$Action=="GetText"} { return [join $LeBonTexte "\n"]}
set F [AfficheVariable [join $LeBonTexte "\n"] "" "CompositionDesSequences_$Rep"]
set B [BoutonneLaFenetre $F "Composition" ""]
$B configure -text "Composition ReOrder lines/ New" -background "cyan"
bind $B <1> "CompositionDesSequences $Rep Show \[Entre $Ordre\] \[ChoixParmi {increasing decreasing}\]"
bind $B <2> "CompositionDesSequences"
return $F
}
proc MatOl {{Qui ""} {Quoi ""}} {
global MatOl
if {$Qui==""} {
return [list \
"MatOl P Matrice" \
"MatOl P AA" \
"MatOl P NA" \
"MatOl P Orient" \
"MatOl P Subjects" \
"MatOl LaListeDes Oligos" \
"MatOl LaListeDes Matrices" \
"MatOl LaListeDes Fichiers"]
}
if {$Quoi==""} { set Quoi "Matrice" }
if {[info exists MatOl($Qui,$Quoi)] } { return [set MatOl($Qui,$Quoi)] }
if {[info exists MatOl("EstCharge")]} { return "" }
set MatOl("EstCharge") 1
set FiMatOfOl "[RepertoireDuGenome]/fiches/matrices_of_oligos"
if { ! [file exists $FiMatOfOl]} {
if { ! [OuiOuNon "$FiMatOfOl\n does not exist. Do I create it ?" 0]} { return "" }
PositionSurMatricesPourTous
}
set LeVieux [LesLignesDuFichier $FiMatOfOl]
set LeNouveau {}
foreach Ligne $LeVieux {
if { ! [regexp -nocase {[a-z]} $Ligne]} { lappend LeNouveau $Ligne ;continue }
set BonneLigne $Ligne
set Mat ""
scan $Ligne "%s %d %d %s %s" P NA AA Orient Mat
if {[regexp {=|~$} $Mat]} { set Mat "" }
if {[regexp {=|~$} $Mat]} { set Mat "" }
lappend MatOl(LaListeDes,Oligos) $P
set Subjects [Oli $P "Subjects"]
set Subjects [join [lsort -unique [split $Subjects " "]] " "]
set MatSubjects [string trim [StringSuivant "=> " dans $Ligne]]
if {$MatSubjects!=$Subjects} {
if {$Subjects!="" && [OuiOuNon "for $P\nMat gives $MatSubjects\nOli gives $Subjects\nDo you choose Oli ?"]} {
set MatSubjects $Subjects
regsub {=> .*} $Ligne "=> $Subjects" BonneLigne
}
}
lappend MatOl($P,Subjects) $MatSubjects
lappend MatOl($P,NA) $NA
lappend MatOl($P,AA) $AA
lappend MatOl($P,Orient) $Orient
lappend LeNouveau $BonneLigne
if {$NA<=0} { continue }
if {[regexp "/" $Mat]} {
set FiMat $Mat
} else {
set FiMat "[RepertoireDuGenome]/nuctfa/$Mat"
}
lappend MatOl(LaListeDes,Matrices) $Mat
lappend MatOl(LaListeDes,Fichiers) $FiMat
if {[file exists $FiMat]} {
lappend MatOl($P,Matrice) $FiMat
if {$Orient=="F"} {
lappend MatOl($P,Sequence) [ZoneADNDuFichierTFA $NA end $FiMat]
} else {
lappend MatOl($P,Sequence) [ZoneADNDuFichierTFA 1 $NA $FiMat]
}
} else {
lappend MatOl($P,Matrice) "FileLoosed"
lappend MatOl($P,Sequence) "FileLoosed"
}
}
if {$LeNouveau!=$LeVieux && [OuiOuNon "I made some corrections in\n$FiMatOfOl\nDo I save them ?"]} {
SauveLesLignes $LeNouveau dans $FiMatOfOl
}
set MatOl(LaListeDes,Matrices) [lsort -unique [set MatOl(LaListeDes,Matrices)]]
set MatOl(LaListeDes,Fichiers) [lsort -unique [set MatOl(LaListeDes,Fichiers)]]
return [MatOl $Qui $Quoi]
}
proc SupprimeDoublonsDansMatricesOfOligos {} {
set FiMatDefaut "[RepertoireDuGenome]/fiches/matrices_of_oligos"
Garde $FiMatDefaut
set LesBons {}
foreach Ligne [LesLignesDuFichier $FiMatDefaut] {
set Sujets [StringSuivant "=> " dans $Ligne]
set Sujets [join [lsort -unique [split $Sujets " "]] " "]
regsub {=> .*} $Ligne "" Debut
lappend LesBons "$Debut => $Sujets"
}
SauveLesLignes $LesBons dans $FiMatDefaut
return $FiMatDefaut
}
proc PositionSurMatricesPourTous {{AppendOrShow ""} {FiMat ""}} {
if {$AppendOrShow==""} { set AppendOrShow "Append" }
set Append [regexp "Append" $AppendOrShow]
set Show [regexp "Show" $AppendOrShow]
set FiMatDefaut "[RepertoireDuGenome]/fiches/matrices_of_oligos"
if {$FiMat==""} { set FiMat $FiMatDefaut }
if {$FiMat=="ShowOnly"} { set Show 1 }
set ToutesLesPositions {}
if {[FileExists $FiMat]} {
foreach Ligne [LesLignesDuFichier $FiMat] {
scan $Ligne "%s %d" P AA
if {$AA<0} { continue }
set DejaVu($P) 1
lappend ToutesLesPositions $Ligne
}
}
if {1 || [OuiOuNon "Do I use Oli to list existing oligos (instead of CloDo) ?"]} {
set LesPs [Oli "LaListeMerci"]
} else {
set LesPs [CloDo "ListAllPlease" oligos]
}
if {$Append} {
foreach P $LesPs {
Espionne "PositionSurMatrice pour $P"
if { ! [regexp {^P[0-9]+$} $P]} { continue }
if {[info exists DejaVu($P)]} { continue }
set LesPositions [PositionSurMatrices $P]
foreach Pos $LesPositions {
lappend ToutesLesPositions $Pos
AppendAuFichier $FiMat $Pos
}
}
}
set ToutesLesPositions [lsort -unique $ToutesLesPositions]
if {$Append} { SauveLesLignes $ToutesLesPositions dans $FiMat }
if {$Show} {
set Fen [AfficheVariable [join $ToutesLesPositions "\n"] "AvecOli" Matrices]
return $Fen
}
return $FiMat
}
proc PositionSurMatrices {P {Ou ""}} {
if {$Ou==""} { set Ou "nuctfa" }
if {[regexp "/" $Ou]} {
set LesMatrices [glob -nocomplain "$Ou/*"]
} else {
set LesMatrices [glob -nocomplain "[RepertoireDuGenome]/$Ou/*"]
}
if {[Oli $P TFA]==""} {
Espionne "$P merde"
set Orient "!"
set Posi [format "%4d %4d" -2 -2]
# set Sign [CloDo signal $P]
set Sign ""
if {$Sign==""} { set Sign "no signal available" }
set Resume "$Posi $Orient [format "%-15s" " "] => $Sign"
return [list "$P $Resume"]
}
set SeqD [Oli $P "SeqSubject"]
set Sens [Oli $P "Sens"]
set Orient "?"
if {$Sens=="5'"} { set Orient "F" }
if {$Sens=="3'"} { set Orient "R" }
set LesPositions {}
set Posi [format "%4d %4d" -1 -1]
foreach Fichier $LesMatrices {
set Queue [file tail $Fichier]
if {[regexp {~$|\.20[0-9]{4,}$} $Queue]} { continue }
if {[string length $SeqD] < 10} { break }
if { ! [EstUnFichierTFA $Fichier]} { continue }
if {[regexp -- "\-mRNA" $Fichier]} { continue }
regsub "matrices_a_tester/" $Fichier "matrices" FichierOK
if {$Fichier!=$FichierOK && [file exists $FichierOK]} { continue }
if {$Sens=="5'"} { set FoR "F" } else { set FoR "RaC" }
set NAetAA [PositionDuPatternDansFichierTFA $SeqD $Fichier $FoR]
scan $NAetAA "%d %d" NA AA
if {$NA<=0} { continue }
set Posi [format "%4d %4d" $NA $AA]
set Sujets [Oli $P "Subjects"]
set Matrice [file tail $Fichier]
regsub ".tfa$" $Matrice "" Matrice
set PGS [file tail $Matrice]
set Alias [Alias $PGS]
while 1 {
Espionne "$Alias $PGS $Sujets"
if { $Alias!="" && ! [regexp "^$Alias" $Sujets] } { break }
if { ! [EstUnPABMute $PGS]} { break }
Espionne "Oli $P $Sujets \n Y a t il un grand frere pour $Alias"
set GrandFrere [GrandFrereDuMutant $PGS]
if {$GrandFrere==""} { break }
set AliasGrandFrere [Alias $GrandFrere]
if {$AliasGrandFrere==""} { break }
Espionne "Oui $GrandFrere"
set LesNouveauxSujets {}
foreach Sujet [split $Sujets " "] {
if { ! [regexp -indices {\-[0-9]+\-[0-9]+$} $Sujet Indices]} { continue }
scan $Indices "%d" D
set Bornes [string range $Sujet $D end]
set CorpsDuSujet [string range $Sujet 0 [incr D -1]]
if { ! [string equal $AliasGrandFrere $CorpsDuSujet]} { continue }
set NouveauSujet "$Alias$Bornes"
lappend LesNouveauxSujets $NouveauSujet
Espionne "NouveauSujet $NouveauSujet"
}
if {$LesNouveauxSujets!=""} {
set Sujets "[join $LesNouveauxSujets " "] $Sujets"
}
break
}
set Sujets [join [lsort -unique [split $Sujets " "]] " "]
set Resume "$Posi $Orient [format "%-15s" $Matrice] => $Sujets"
lappend LesPositions "$P $Resume"
}
if {$LesPositions=={}} {
set Resume "$Posi $Orient [format "%-15s" " "] => [Oli $P Subjects]"
set LesPositions [list "$P $Resume"]
}
return $LesPositions
}
proc PositionDuPatternDansFichierTFA {Pattern Fichier {RaC ""} {NAouAA ""} {Circulaire ""} {GetAll ""}} {
set LastAlso [regexp -nocase "LastAlso" $Circulaire]
set Circulaire [regexp -nocase "Circ" $Circulaire]
if {[regexp -nocase "GetAll" $RaC]} {
set GetAll $RaC
set Rac ""
}
if {$RaC=="RaC"} { set RaC 1 } else { set RaC 0 }
if {$NAouAA==""} { set NAouAA "NA_AA" }
set Seq [string toupper [QueLaSequenceDuFichierTFA $Fichier]]
set lSeq [string length $Seq]
set OnTesteUneProteine [regexp {[^ATGCN\-\. ]} $Seq]
if {$Circulaire} { set Seq "$Seq$Seq" }
regsub -all -nocase {[^A-Z]} $Pattern "" Pattern
if {$RaC} { set Pattern [NucToReverseAndComplementNuc $Pattern] }
set PATTERN [string toupper $Pattern]
set lPat [string length $PATTERN]
if {[regexp -nocase "GetAll" $GetAll]} {
set LesPositions {}
set i 0
while { [set NA [string first $PATTERN "x$Seq" $i]]>=0 } {
lappend LesPositions $NA
set i $NA
incr i
}
return $LesPositions
}
set lastNA [string last $PATTERN "x$Seq"]
set NA [string first $PATTERN "x$Seq"]
if {$RaC && $NA>0} { incr NA [expr $lPat-1] }
if {$OnTesteUneProteine && $NA>0} {
set NA [expr ($NA-1)*3 + 1]
set lastNA [expr ($lastNA-1)*3 + 1]
}
if {$NAouAA == "NA"} {
return $NA
}
if {$NA>0} {
set AA [expr ($NA-1)/3+1]
} else {
set AA -1
}
if {$NAouAA == "AA"} { return $AA }
if {$LastAlso} { return "$NA $AA $lastNA" }
return "$NA $AA"
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.