Index by: file name |
procedure name |
procedure call |
annotation
gscope_clonage.tcl
(annotations | original source)
#rR gscope_clonage.tcl
proc CorrigeCmyc {} {
FaireLire "Cette procedure ne devrait plus etre necessaire. C'etait pour corriger les cMyc"
foreach FO [lsort [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
set P [file tail $FO]
regsub ".tfa" $P "" P
set TFA [ContenuDuFichier $FO]
if { ! [regexp "cMyc" $TFA]} { continue }
if { ! [regexp "seeFull" $TFA]} { continue }
set Entete [EnteteDuTexteTFA $TFA]
Espionne
Espionne "**************************************************************************************************"
Espionne
Espionne $Entete
set Fulls [StringApres "seeFull " dans $Entete]
set LesFull [split $Fulls "+"]
foreach F $LesFull {
regsub $P $FO $F FF
set TFAF [ContenuDuFichier $FF]
set EF [EnteteDuTexteTFA $TFAF]
set SF [StringApres "signal " dans $EF]
set SB [StringApres "RebuildedBrockenOli of " dans $EF]
set Bon "BamHI_$SB"
regsub $SF $EF $Bon BonEF
Espionne "$EF"
Espionne "$BonEF"
regsub $EF $TFAF $BonEF NewTFAF
Espionne "$TFAF\n$NewTFAF"
# Sauve $NewTFAF dans $FF
}
}
}
proc CorrigeRebuilded {} {
FaireLire "Cette procedure ne devrait plus etre necessaire. C'etait pour corriger les without signal du STREP"
foreach FO [lsort [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
set P [file tail $FO]
regsub ".tfa" $P "" P
set TFA [ContenuDuFichier $FO]
if { ! [regexp "RebuildedBrockenOli" $TFA]} { continue }
if { ! [regexp "without signal" $TFA]} { continue }
set Entete [EnteteDuTexteTFA $TFA]
set B [StringApres "seeBrocken " dans $Entete]
regsub $P $FO $B FB
set EB [EnteteDuFichierTFA $FB]
set NewEntete ">[FormatageEntete $EB "PourOligoNonBrocOli" $P] seeBrocken $B"
Espionne
Espionne "$Entete"
Espionne "$NewEntete"
regsub $Entete $TFA $NewEntete NewTFA
Espionne "$TFA\n$NewTFA"
# Sauve $NewTFA dans $FO
}
}
proc CorrigeAfterMe {} {
FaireLire "Cette procedure ne devrait plus etre necessaire. C'etait au temps ou il y avait AfterMe dans les BrocOli"
foreach FO [lsort -decreasing [glob "[RepertoireDuGenome]/oligos/P*.tfa"]] {
set P [file tail $FO]
regsub ".tfa" $P "" P
set TFA [ContenuDuFichier $FO]
if { ! [regexp "AfterMe" $TFA]} { set PreviousTFA $TFA ; set PreviousP $P ; continue }
if { ! [regexp $P $PreviousTFA]} { FaireLire $P }
Espionne "$P $PreviousP"
Espionne $TFA
regsub "AfterMe" $TFA $PreviousP NewTFA
Espionne $NewTFA
Sauve $NewTFA dans $FO
}
}
proc OliVsPofOl {} {
foreach P [PofOl LaListeDesPs] {
lappend LaSortie "$P"
}
}
proc StartOfOligos {} {
foreach P [Oli "LaListeMerci"] {
if {[Oli $P Sens]=="3'"} { continue }
set Seq [string toupper [Oli $P SeqSubject]]
set Codon [string range $Seq 0 2]
if {$Codon==""} { continue }
if { ! [info exists Cumul($Codon)]} { set Cumul($Codon) 0 }
incr Cumul($Codon)
lappend LesCodons $Codon
}
foreach Codon [lsort -unique $LesCodons] {
lappend LaSortie "$Codon $Cumul($Codon)"
}
return $LaSortie
}
proc InformeSeqCheck {Selection Page} {
Wup "First we take from Selectio then from Page"
set Tout "$Selection\n$Page"
set PGS ""
set FichierBlast "BlastfileNotFound"
set CodeSeqFile "CodeSequenceFileNotFound"
set P "NoOligoFound"
foreach Ligne [split $Tout "\n"] {
if {$FichierBlast=="BlastfileNotFound" && [regexp ".blast$" $Ligne]} {
set FichierBlast $Ligne
set CodeSeqFile [file tail $FichierBlast]
regsub {\.blast$} $CodeSeqFile "" CodeSeqFile
}
if {[regexp "^ PGS " $Ligne] && $PGS==""} {
scan $Ligne "%s %s" Bidon PGS
}
if {[regexp "^ Oli " $Ligne] && $P=="NoOligoFound"} {
scan $Ligne "%s %s" Bidon P
}
if {$FichierBlast!="BlastfileNotFound" \
&& $CodeSeqFile!="CodeSequenceFileNotFound" \
&& $P!="NoOligoFound"} {
break
}
}
global TextePourInformeVerificationSequencage
if {[info exists TextePourInformeVerificationSequencage]} {
set Bornes $TextePourInformeVerificationSequencage
} else {
set Bornes ""
}
set SeqCheck "SeqCheck: $CodeSeqFile $P $Bornes"
if {$PGS==""} { return "" }
if { ! [OuiOuNon "Ok to inform '$PGS' with \n$SeqCheck"]} { return "" }
return [Informe $PGS $SeqCheck]
}
proc NatureDeLaSequenceAuVuDu Titre {
if {[EstUnPAB $Titre]} { return "PGS" }
if {[regexp {^P[0-9]+$} $Titre]} { return "Oli" }
if {[regexp {^Rec1_} $Titre]} { return "Rec1" }
if {[regexp {^Rec2_} $Titre]} { return "Rec2" }
if {[regexp {^N[0-9]+_[^_]+_p} $Titre]} { return "Rec2" }
if {[regexp {^N[0-9]+_pDONR} $Titre]} { return "Rec1" }
if {[regexp {^N[0-9]+_p} $Titre]} { return "Rec1" }
if {[regexp {^pDONR} $Titre]} { return "pDONR" }
if {[regexp {^pDEST} $Titre]} { return "pDEST" }
if {[regexp {^ProduitPCR} $Titre]} { return "PPCR" }
if {[regexp {^PPCR} $Titre]} { return "PPCR" }
if {[regexp {^N[0-9]+$} $Titre]} { return "VPPCR" }
if {[NomDuAlias $Titre]!=""} { return "Alias" }
return ""
}
proc VerificationSequencageApprofondiePourTous {} {
foreach FichierBlast [glob "[RepertoireDuGenome]/retoursequencage/blast/*.blast"] {
Espionne $FichierBlast
if {[regexp "FASTA" [ContenuDuFichier $FichierBlast]]} { continue }
set Retour [VerificationSequencageApprofondie "" $FichierBlast "Show" "AvecRetour"]
if {$Retour==""} { continue }
foreach Ligne [split $Retour "\n"] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
Espionne $Ligne
}
}
}
proc VerificationSequencageApprofondie {FichierSequence FichierBlast {Action ""} {Maniere ""}} {
if {$Action==""} { set Action "Show" }
global ScoreDansProfil
set ScoreDansProfilMemo 0
if {[info exists ScoreDansProfil]} { set ScoreDansProfilMemo $ScoreDansProfil }
set ScoreDansProfil 1
set lPartieSegAli {}
set n [DecortiqueBlast $FichierBlast "SansSeuilExpect" "SansLimiteDeNombreDuTout" Query \
lBanqueId lAccess lDE lScore lPN lPartieSegAli]
set ScoreDansProfil $ScoreDansProfilMemo
set Compte 0
set NFoisQuoiMax 10
foreach BanqueId $lBanqueId ScoreLu $lScore PN $lPN {
set Quoi [NatureDeLaSequenceAuVuDu $BanqueId]
if { ! [info exists NFois($Quoi)]} { set NFois($Quoi) 0 }
if {[incr NFois($Quoi)] > $NFoisQuoiMax} { continue }
if {$Quoi==""} {
lappend LesHits(Autres) $BanqueId
lappend Expect(Autres) $PN
lappend Score(Autres) $ScoreLu
continue
}
if { ! [info exists Expect($Quoi)]} { set Expect($Quoi) $PN }
#rR if { $PN > [set Expect($Quoi)] } { continue }
if { ! [info exists Score($Quoi)]} { set Score($Quoi) $ScoreLu }
if { $ScoreLu < [set Score($Quoi)] } { continue }
if {$Quoi=="Alias"} {
set PGS [NomDuAlias $BanqueId]
foreach PG [split $PGS " "] {
if {[EstUnPAB $PG]} { lappend LesHits(PGS) $PG}
}
}
lappend LesHits($Quoi) $BanqueId
}
set LaPage {}
lappend LaPage $FichierSequence
lappend LaPage $FichierBlast
set LesIllumines {}
foreach Quoi [list "PGS" "Alias" "Oli" "VPPCR" "PPCR" "Rec1" "pDONR" "pDEST" "Autres"] {
if { ! [info exists LesHits($Quoi)] } { continue }
lappend LaPage "\n"
if {[info exists Score($Quoi)] && [info exists Expect($Quoi)]} {
lappend LaPage "$Quoi [set Score($Quoi)] [set Expect($Quoi)]"
}
set Prems 1
foreach Hi [set LesHits($Quoi)] {
set Ligne " $Quoi $Hi"
if {$Prems && ($Quoi=="PGS" || $Quoi=="Oli" || $Quoi=="VPPCR")} { lappend LesIllumines $Ligne }
if {$Quoi=="Oli"} { append Ligne " [Oli $Hi Description]" }
if {$Quoi=="VPPCR"} { append Ligne " [VirtualPPCREnStock $Hi Resume]" }
set Prems 0
lappend LaPage $Ligne
}
}
set Page [join $LaPage "\n"]
if {$Action=="RetourneTexte"} { return $Page }
set MaManiere $Maniere
if {[regexp "AvecRetour" $Maniere]} { append MaManiere "AvecRetourMaisSansWait" }
set w [AfficheVariable $Page "AvecOli$MaManiere" "Hits_of_$FichierBlast"]
if { ! [regexp "AvecRetour" $Maniere]} { return $w }
if {$LesIllumines!={}} {
foreach Illu $LesIllumines {
Illumine $Illu $w
}
Illumine [lindex $LesIllumines 0] $w
}
set Clavier "$w.buttons"
TouchePour $Clavier "See the Blast" "AfficheUneSortieBlast $FichierBlast" "" "lightblue"
TouchePour $Clavier "Disp SegAli" "AfficheZoneContigue $FichierBlast \[selection get\]" "" "lightblue"
TouchePour $Clavier "InformSeqCheck" "InformeSeqCheck \[selection get\] \[set PagePropre($w)\]" "" "lightblue"
global VariableDeRetour
tkwait variable VariableDeRetour($w)
set v $VariableDeRetour($w)
unset VariableDeRetour($w)
catch {destroy $w}
return $v
}
proc GrandFrereDuMutant Nom {
return [LesMutantsDe $Nom "SonGrandFrere"]
}
proc LesMutantsDe {PGS {Quoi ""}} {
global LesMutantsDe
Wup "Quoi can be Sites or Names"
if {$Quoi==""} { set Quoi "Sites" }
if {[info exists LesMutantsDe($PGS,$Quoi)]} { return [set LesMutantsDe($PGS,$Quoi)] }
if {[info exists LesMutantsDe("EstCharge")]} { return {} }
set LesMutantsDe("EstCharge") 1
set LesGrandsFreres {}
foreach Nom [ListeDesPABs] {
set Texte [ExtraitInfo $Nom "Muted"]
if {$Texte==""} { continue }
if { ! [regexp "mutation of" $Texte]} { continue }
set GrandFrere [StringApres "mutation of" dans $Texte]
lappend LesMutantsDe($GrandFrere,Names) $Nom
set LesMutantsDe($Nom,SonGrandFrere) $GrandFrere
regsub { *mutation +of +[^ ]+ +[^ ]+ } $Texte "" TexteCodes
set LesCodes [split $TexteCodes]
set LesCoOrdonnes {}
foreach Code $LesCodes {
if { ! [regexp -nocase {[a-z]} $Code]} { continue }
regsub {[0-9]+} [string toupper $Code] " & " Coco
scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
set LongAncienP [string length $AncienP]
lappend LesCoOrdonnes "$AncienP $PosAncienP $NouveauP"
lappend LesMutantsDe($GrandFrere,Sites) $PosAncienP
lappend LesGrandsFreres $GrandFrere
}
}
set LesGrandsFreres [lsort -u $LesGrandsFreres]
set LesMutantsDe(LaListeDes,GrandsFreres) $LesGrandsFreres
foreach GrandFrere $LesGrandsFreres {
set LesMutantsDe($GrandFrere,Sites) [lsort -integer -unique [set LesMutantsDe($GrandFrere,Sites)]]
}
return [LesMutantsDe $PGS $Quoi]
}
proc LesBornesParSeqCheck PGS {
set LesSeqCheck [split [ExtraitInfo $PGS "SeqCheck"] "/"]
set LesPossibles {}
set LesIllumines {}
foreach Ligne $LesSeqCheck {
set Ligne [string trim $Ligne]
if { ! [regexp { *(P[0-9]+) } $Ligne Match Oli]} {
lappend LesPossibles $Ligne
continue
}
set Sens [Oli $Oli "Sens"]
if {$Sens=="3'"} {
regsub "$Oli " $Ligne "$Oli " Ligne
}
lappend LesPossibles $Ligne
lappend LesIllumines $Ligne
}
set LesBons [MorceauxChoisis $LesPossibles $LesIllumines \
"Please select lines in the left window and press '--->'\n\
Reorder with 'Up' and 'Down' if necessary."]
set MinD 9999
set MaxF -9999
foreach Ligne $LesBons {
set D ""
set F ""
while {1} {
scan $Ligne "%s %s %s" NomSequenceur Oli Bornes
set Sens [Oli $Oli "Sens"]
if { ! [regexp {[0-9]+\-[0-9]+} $Bornes]} {
if {[OuiOuNon "$Ligne\is not as SeqName Pxxxx 123-987\n Do I skipp ?"]} { set D "Skip" ; break }
if {[OuiOuNon "Do You want to correct it ?"]} {
set Ligne [Entre $Ligne]
continue
}
if {[OuiOuNon "Do I cancel ?"]} { return "" }
continue
}
regsub {\-} $Bornes " " Bornes
scan $Bornes "%d %d" D F
break
}
if {$D=="Skip"} { continue }
if {$Sens=="5'"} {
set MinD [Mini $F $MinD]
}
if {$Sens=="3'"} {
set MaxF [Maxi $D $MaxF]
}
}
set Propose "$PGS $MinD $MaxF"
while 1 {
if {[OuiOuNon "Do I create sequencing oligos for\n$Propose ?\n\n(I'll extend it on each side)"]} {
return $Propose
}
if {[OuiOuNon "Do You want to correct it ?"]} {
set Propose [Entre $Propose]
continue
}
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
}
proc NomDuFichierDesOligosPourSequencage FicOli {
set FicOliOriginal $FicOli
set Prem 1
while {$Prem || $FicOli==""} {
set Prem 0
FaireLire "Please choose a file to store the oligos I'll create."
set Rep [file dirname $FicOli]
set Queue [file tail $FicOli]
if { ! [regexp ".tfa$" $Queue]} {
regsub {\.[^.]+$} $Queue "" Queue
append Queue ".tfa"
}
set FicOli "$Rep/oliseq_$Queue"
set FicOli [FichierPourSaveAs $FicOli]
if {$FicOli==""} {
if {[OuiOuNon "Do I skip creation of oligos ?"]} {return ""}
set FicOli $FicOliOriginal
set Prem 1
}
}
while {[file exists $FicOli]} {
if {[OuiOuNon "$FicOli\nalready exists. Do I append to it ?"]} { return $FicOli }
if {[OuiOuNon "$FicOli\nalready exists. Do I replace it ?"]} {
file delete -force $FicOli
return $FicOli
}
if {[OuiOuNon "$FicOli\nalready exists. Do I skip creation of oligos ?"]} {
return ""
}
if {[OuiOuNon "$FicOli\nalready exist. Do You want to change it ?"]} {
return [NomDuFichierDesOligosPourSequencing $FicOli]
}
}
return $FicOli
}
proc CreateSeqOli {Nom Debut Fin {Sens ""} {FicOli ""}} {
if {$Sens==""} { set Sens "FR" }
set LesTFAs {}
set Alias [Alias $Nom]
set Seq [QueLaSequenceDuFichierTFA [GscopeFile $Nom "nuctfa"]]
set SeqOliF [string range "n$Seq" $Debut $Fin]
set SeqOliR [NucToReverseAndComplementNuc $SeqOliF]
set NomDeLOligo "$Alias-${Debut}to${Fin}"
if {[regexp -nocase "F" $Sens]} {
set EnteteOliSeq "SeqOli_$NomDeLOligo sequencing oligo for $Nom $Alias $Debut to $Fin"
set TFA [SequenceFormatTFA $SeqOliF $EnteteOliSeq "brut"]
lappend LesTFAs $TFA
}
if {[regexp -nocase "R" $Sens]} {
set EnteteOliSeqRac "SeqOliRaC_$NomDeLOligo reverse sequencing oligo for $Nom $Alias $Debut to $Fin"
set TFA [SequenceFormatTFA $SeqOliR $EnteteOliSeqRac "brut"]
lappend LesTFAs $TFA
}
return [join $LesTFAs "\n"]
}
proc CreateOligosForSequencing {FichierOuTexteOliSeq {FicOli ""} {ReverseAussi ""} {SansPremier ""} } {
set LongueurOliSeq 21
set LongOptimale 800
set EcartAutorise 50
while {! [OuiOuNon "Are following parameters ok ?\
\n OligoLength $LongueurOliSeq\
\n Offset between oligos $LongOptimale\
\n Tolerance $EcartAutorise"]} {
set LongueurOliSeq [Entre 21]
set LongOptimale [Entre 800]
set EcartAutorise [Entre 50]
}
if {$ReverseAussi==""} {
set ReverseAussi [Entre "SansReverse"]
}
if {$ReverseAussi=="SansReverse" || $ReverseAussi==0 } { set ReverseAussi 0 } else { set ReverseAussi 1 }
if {$SansPremier==""} {
if {[OuiOuNon "Do you want that I REMOVE the Nter and Cter oligos ?"]} {
set SansPremier "SansPremier"
} else {
set SansPremier "AvecPremier"
}
}
if {$SansPremier=="SansPremier" || $SansPremier==1 } { set SansPremier 1 } else { set SansPremier 0 }
if {$FichierOuTexteOliSeq==""} { return "" }
if {[regexp "\n" $FichierOuTexteOliSeq]} {
if {$FicOli==""} {
set FicOli [NomDuFichierDesOligosPourSequencage "./sequencingoligos.tfa"]
if {$FicOli==""} { return "" }
}
set Texte $FichierOuTexteOliSeq
set LesOligos {}
foreach Ligne [split $Texte "\n"] {
CreateOligosForSequencing $Ligne $FicOli $ReverseAussi
}
return $FicOli
}
if { ! [EstUnPAB $FichierOuTexteOliSeq] && ! [regexp " " $FichierOuTexteOliSeq]} {
set Fichier $FichierOuTexteOliSeq
if {[file exists $Fichier]} {
set FicOli [NomDuFichierDesOligosPourSequencage $Fichier]
if {$FicOli==""} { return "" }
return [CreateOligosForSequencing [ContenuDuFichier $Fichier] $FicOli $ReverseAussi]
}
FaireLire "$FichierOuTexteOliSeq\ndoesn't exist. I'll cancel CreateOligosForSequencing"
return [list "No sequencing oligo for ($FichierOuTexteOliSeq) which doesn't exist"]
}
if {$FicOli==""} { set FicOli [NomDuFichierDesOligosPourSequencage ""] }
if {$FicOli==""} { return "" }
set Ligne $FichierOuTexteOliSeq
Espionne $Ligne
if {[regexp "SeqOli" $Ligne]} {
scan $Ligne "%s %s %s %s %s" Nom bidon Debut Fin Sens
set TFAs [CreateSeqOli $Nom $Debut $Fin $Sens]
AppendAuFichier $FicOli $TFAs
return $FicOli
}
Espionne "perdu"
set D ""
set F ""
scan $Ligne "%s %s %s" PAB D F
set Alias [Alias $PAB]
if {$Alias==""} { set Alias $PAB }
set Marge 45
if {$D=="SeqCheck"} {
set BornesSeqCheck [LesBornesParSeqCheck $PAB]
if {$BornesSeqCheck==""} { return "" }
scan $BornesSeqCheck "%s %d %d" PAB DNuc FNuc
set DNuc [expr $DNuc -$LongueurOliSeq -$Marge]
set FNuc [expr $FNuc + $Marge]
set D [expr ($DNuc-1)/3+1]
set F [expr $FNuc/3]
set SansPremier 0
}
set FichierNuc "[RepertoireDuGenome]/nuctfa/$PAB"
if { ! [file exists $FichierNuc]} {
FaireLire "$FichierNuc\ndoesn't exist. I'll cancel CreateOligosForSequencing for it."
return [list "No sequencing oligo for ($FichierNuc) which doesn't exist"]
}
set LesSitesDeMutation [LesMutantsDe $PAB]
set LesSitesDeMutationN {}
foreach Site $LesSitesDeMutation {
lappend LesSitesDeMutationN [expr ($Site-1)*3 + 1]
}
set ToutSeq [QueLaSequenceDuFichierTFA $FichierNuc]
set DToutSeqP 1
set FToutSeqP [expr [string length $ToutSeq]/3]
if {$D==""} { set D $DToutSeqP }
if {$F==""} { set F $FToutSeqP }
Wup "D et F indiquent les bornes en PROTEINE"
set DN [expr ($D-1)*3 + 1]
set FN [expr ($F-3)*3 + 1]
set FinVoulue $FN
set LongTotale [expr $FN-$DN+1]
set LongVoulue ""
while {$LongVoulue==""} {
if {[expr $LongTotale<($LongOptimale+$EcartAutorise)]} {
set LongVoulue $LongTotale
set NombrePossible 1
break
} else {
set NombrePossible1 [expr $LongTotale/$LongOptimale]
set NombrePossible2 [expr $NombrePossible1+1]
set LongPossible1 [expr $LongTotale/$NombrePossible1 + 1]
set LongPossible2 [expr $LongTotale/$NombrePossible2 + 1]
if {[expr abs($LongOptimale-$LongPossible1)<$EcartAutorise]} {
set NombrePossible $NombrePossible1
set LongVoulue $LongPossible1
break
}
if {[expr abs($LongOptimale-$LongPossible2)<$EcartAutorise]} {
set NombrePossible $NombrePossible2
set LongVoulue $LongPossible2
break
}
set LongVoulue [ChoixParmi [list \
"$LongPossible1 for $NombrePossible1 oligos" \
"$LongPossible2 for $NombrePossible2 oligos"]]
if {$LongVoulue==""} { continue }
scan $LongVoulue "%d" LongVoulue
if {$LongVoulue==$LongPossible1} {
set NombrePossible $NombrePossible1
} else {
set NombrePossible $NombrePossible2
}
}
}
set DOli $DN
if {$SansPremier} { incr DOli $LongVoulue }
while { $DOli < $FinVoulue} {
set DOli3 [expr (($DOli-1)/3)*3 + 1]
set FOli3 [expr $DOli3+$LongueurOliSeq-1]
while 1 {
set ToucheUneMutation 0
foreach Site $LesSitesDeMutationN {
if {$DOli3<=$Site && $Site<=$FOli3} {
set FOli3 [expr $Site-9]
set DOli3 [expr $FOli3-$LongueurOliSeq+1]
set ToucheUneMutation 1
break
}
}
if { ! $ToucheUneMutation } { break }
}
set SeqOliN [string range "n$ToutSeq" $DOli3 $FOli3]
set SeqOliP [SeqNucToSeqPro $SeqOliN]
set DOliP [expr ($DOli3-1)/3 + 1]
set NomDeLOligo "$Alias-${DOli3}to${FOli3}"
set EnteteOliSeq "SeqOli_$NomDeLOligo sequencing oligo for $PAB $Alias $DOli3 to $FOli3"
set TFA [SequenceFormatTFA $SeqOliN $EnteteOliSeq "brut"]
Espionne $TFA
AppendAuFichier $FicOli $TFA
if {$ReverseAussi} {
set SeqRaC [NucToReverseAndComplementNuc $SeqOliN]
set EnteteRaC "SeqOliRaC_$NomDeLOligo sequencing oligoRaC for $PAB $Alias $DOli3 to $FOli3"
set TFARaC [SequenceFormatTFA $SeqRaC $EnteteRaC "nucbrut"]
AppendAuFichier $FicOli $TFARaC
}
incr DOli $LongVoulue
}
while {[OuiOuNon "Do you want to verify or remove some sequencing oligos"]} {
set Nouveau [AfficheFichier $FicOli "AvecRetour"]
set N [regexp -all {>} $Nouveau]
if {[OuiOuNon "Do I save these $N oligos in $FicOli?"]} {
Sauve $Nouveau dans $FicOli
break
}
}
return $FicOli
}
proc TypeDeVecteurGatewayPourTous {} {
foreach Vecteur [LesVecteurs] {
Espionne "[TypeDeVecteurGateway $Vecteur] $Vecteur"
}
}
proc TypeDeVecteurGateway Vecteur {
if {$Vecteur==""} { return 0 }
if {[regexp "/" $Vecteur]} {
set Fichier $Vecteur
} else {
set Fichier [FindVector $Vecteur]
if {[FileAbsent $Fichier]} { return 0 }
}
set Seq [QueLaSequenceDuFichierTFA $Fichier]
if {[regexp -nocase [SEQAttL1] $Seq] && [regexp -nocase [SEQAttL2] $Seq]} { return 1 }
if {[regexp -nocase [SEQAttR1] $Seq] && [regexp -nocase [SEQAttR2] $Seq]} { return 2 }
return 0
}
proc LesVecteurs {{VecType ""} {GetThem ""}} {
if {$VecType==""} { set VecType "pDONR_pDEST" }
if {$GetThem==""} { set GetThem "GetFilenames" }
set GetFilenames [string equal -nocase $GetThem "GetFilenames"]
set GetNames [string equal -nocase $GetThem "GetNames"]
set LesPossible {}
if {[regexp "pDONR" $VecType]} { LConcat LesPossibles [LesFichiersDeType "pDONR" "" "GetAll"] }
if {[regexp "pDEST" $VecType]} { LConcat LesPossibles [LesFichiersDeType "pDEST" "" "GetAll"] }
if {$GetNames} {
set LesNames {}
foreach F $LesPossibles {
set Name [file tail $F]
regsub {\.tfa} $Name "" Name
lappend LesNames $Name
}
return $LesNames
}
if {$GetFilenames} { return $LesPossibles }
}
proc InventaireDesVecteurs {{VecType ""}} {
set LesPossibles [LesVecteurs $VecType "GetFilenames"]
return [AfficheVariable [join $LesPossibles "\n"] "AvecShow" "${VecType}_Vectors"]
}
proc OlIgbmc {P {Val ""}} {
global OlIgbmc
set FichierOlIgbmc "[RepertoireDuGenome]/fiches/oligbmc"
if {$P=="Save"} {
if {[info exists OlIgbmc("EstCharge")]} { unset OlIgbmc("EstCharge") }
if {[info exists OlIgbmc(ListeDesPs)]} { unset OlIgbmc(ListeDesPs) }
if {[info exists OlIgbmc(ListeDesIGBMCs)]} { unset OlIgbmc(ListeDesIGBMCs) }
SauveLesLignes [array get OlIgbmc] dans $FichierOlIgbmc
catch {unset OlIgbmc}
OlIgbmc "Load"
return $FichierOlIgbmc
}
if {$Val!=""} { set OlIgbmc($P) $Val ; lappend OlIgbmc(ListeDesPs) $P ; return $Val }
if {[info exists OlIgbmc($P)]} { return [set OlIgbmc($P)] }
if {[info exists OlIgbmc("EstCharge")]} { return [set OlIgbmc("EstCharge")] }
if { ! [file exists $FichierOlIgbmc]} { set OlIgbmc("EstCharge") "NoValueAvailable" }
array set OlIgbmc [LesLignesDuFichier $FichierOlIgbmc]
foreach {P IGBMC} [array get OlIgbmc] {
lappend OlIgbmc(ListeDesPs) $P
lappend OlIgbmc(ListeDesIGBMCs) $IGBMC
}
set OlIgbmc("EstCharge") ""
return [OlIgbmc $P]
}
proc LesPpcrDesPs {} {
foreach P [P5ofPPCR "LaListeDesPs"] {
Espionne "$P"
}
exit
}
proc TousLesSegmentsConsecutifs {Liste {JoinCar "\n"}} {
set LL [llength $Liste]
set LesSegments {}
foreach N [NombresEntre 1 $LL] {
foreach D [NombresEntre 0 [expr $LL-$N]] {
set F [expr $D+$N-1]
set W [lrange $Liste $D $F]
lappend LesSegments [join $W $JoinCar]
}
}
return $LesSegments
}
proc AfficheFournisseur Selection {
if {[regexp "\n" $Selection]} {
foreach Ligne $Selection {
AfficheFournisseur $Ligne
}
return ""
}
if { ! [regexp {P[0-9]+} $Selection P]} { return "" }
set Fournis [Fournisseur $P]
if {$Fournis==""} {
return [AfficheVariable "Sorry. No order file was found for $P" "" "OrderFileOf_$P"]
}
scan $Fournis "%s %s" Lieu Fichier
set Page "$Fichier\n$Lieu"
if {[file exists $Fichier]} { append Page "\n[ContenuDuFichier $Fichier]" }
set Fen [AfficheVariable $Page "AvecOli" "OrderFileOf_$P"]
Illumine $P $Fen
return $Fen
}
proc Fournisseur {P {Val ""}} {
global Fournisseur
if {$Val!=""} {
if { ! [info exists Fournisseur($P)]} {
set Fournisseur($P) $Val
lappend Fournisseur(LaListeDesPs) $P
} else {
append Fournisseur($P) $Val
}
return [set Fournisseur(LaListeDesPs)]
}
if {[info exists Fournisseur($P)]} { return [set Fournisseur($P)] }
if {[info exists Fournisseur("EstCharge")]} { return "" }
set Fournisseur("EstCharge") 1
array set Fournisseur [LesLignesDuFichier "[RepertoireDuGenome]/fiches/fournisseur"]
foreach PLu [array names Fournisseur] {
scan [set Fournisseur($PLu)] "%s" Fournis
lappend Fournisseur($Fournis) $PLu
lappend Fournisseur(LaListeDesPs) $PLu
}
return [Fournisseur $P]
}
proc ShowBlastOfOligo Selection {
if {[regexp "\n" $Selection]} {
foreach Ligne $Selection {
ShowBlastOfOligo $Ligne
}
return ""
}
if { ! [regexp {P[0-9]+} $Selection P]} { return "" }
set FB "[RepertoireDuGenome]/blastnoligo/$P"
if {[file exists $FB]} {AfficheFichier $FB "AvecSegAlignement"}
set FB "[RepertoireDuGenome]/blastnAllProGS/$P"
if {[file exists $FB]} {AfficheFichier $FB "AvecSegAlignement"}
}
proc ChercheLesOligosDoubles {} {
foreach P [Oli "LaListeMerci"] {
set Seq [string toupper [Oli $P Seq]]
if {[info exists DejaVu($Seq)]} {
lappend DejaVu($Seq) "$P [Oli $P Description]"
Espionne "\n[join [set DejaVu($Seq)] "\n"]"
} else {
lappend DejaVu($Seq) "$P [Oli $P Description]"
}
}
exit
}
proc MemeAlias {AliasDuSujet AliasDuPGS} {
if {$AliasDuSujet==""} { return 1 }
set LesBonsCouples [list \
"XPDhs p80hs" \
"NURR1 hNURR1" \
"ITK SH1-ITK" \
"LXRb hLXRb" \
"hCOUP-TFIIH hCOUP-TFII" \
"hsTFIIEA TF2EAHS" \
"SSL1 YLR005WSSL1" \
"TFB1 YDR311WTFB1" \
"RARa HRARA"]
if {[lsearch -exact $LesBonsCouples "$AliasDuSujet $AliasDuPGS"]} { return 1 }
return [string equal -nocase $AliasDuSujet $AliasDuPGS]
}
proc EstUnPABMute PAB {
return [regexp {^mutation of } [ExtraitInfo $PAB "Muted"]]
}
proc NomDuFichierDesOligosPourMutation FicOli {
set FicOliOriginal $FicOli
set Prem 1
while {$Prem || $FicOli==""} {
set Prem 0
FaireLire "Please choose a file to store the oligos I'll create."
set Rep [file dirname $FicOli]
set Queue [file tail $FicOli]
if { ! [regexp ".tfa$" $Queue]} {
regsub {\.[^.]+$} $Queue "" Queue
append Queue ".tfa"
}
set FicOli "$Rep/olimut_$Queue"
set FicOli [FichierPourSaveAs $FicOli]
if {$FicOli==""} {
if {[OuiOuNon "Do I skip creation of oligos ?"]} {return ""}
set FicOli $FicOliOriginal
set Prem 1
}
}
while {[file exists $FicOli]} {
if {[OuiOuNon "$FicOli\nalready exists. Do I append to it ?"]} { return $FicOli }
if {[OuiOuNon "$FicOli\nalready exists. Do I replace it ?"]} {
file delete -force $FicOli
return $FicOli
}
if {[OuiOuNon "$FicOli\nalready exists. Do I skip creation of oligos ?"]} {
return ""
}
if {[OuiOuNon "$FicOli\nalready exist. Do You want to change it ?"]} {
return [NomDuFichierDesOligosPourMutation $FicOli]
}
}
return $FicOli
}
proc CreateOligosForMutation {FichierOuTexteOliMut {FicOli ""} {ReverseAussi ""}} {
JeMeSignale
if {$ReverseAussi==""} { set ReverseAussi "ReverseAussi" }
if {$ReverseAussi=="SansReverse" || $ReverseAussi==0 } { set ReverseAussi 0 } else { set ReverseAussi 1 }
global DefaultLengthes
set SuperDefaultLengthes "5 5 15 15 (AA before, AA after, bases before, bases after)"
if {[OuiOuNonMemo "Do you want to change the default length of 5' and 3' extensions of the mutation oligos ?" ]} {
if { ! [info exists DefaultLengthes]} { set DefaultLengthes [Entre $SuperDefaultLengthes] }
} else {
set DefaultLengthes $SuperDefaultLengthes
}
ScanLaListe $DefaultLengthes NbAAsAvant NbAAsApres NbBasesAvant NbBasesApres
if {$FichierOuTexteOliMut==""} { return "" }
if {[regexp "\n" $FichierOuTexteOliMut]} {
if {$FicOli==""} {
set FicOli [NomDuFichierDesOligosPourMutation "./mutationoligos.tfa"]
if {$FicOli==""} { return "" }
}
set Texte $FichierOuTexteOliMut
set LesOligos {}
foreach Ligne [split $Texte "\n"] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
CreateOligosForMutation $Ligne $FicOli $ReverseAussi
}
return $FicOli
}
if { ! [regexp " " $FichierOuTexteOliMut]} {
set Fichier $FichierOuTexteOliMut
if {[file exists $Fichier]} {
set FicOli [NomDuFichierDesOligosPourMutation $Fichier]
if {$FicOli==""} { return "" }
return [CreateOligosForMutation [ContenuDuFichier $Fichier] $FicOli $ReverseAussi]
}
FaireLire "$FichierOuTexteOliMut\ndoesn't exist. I'll cancel CreateOligosForMutation"
return [list "No mutation oligo for ($FichierOuTexteOliMut) which doesn't exist"]
}
if {$FicOli==""} { set FicOli [NomDuFichierDesOligosPourMutation ""] }
if {$FicOli==""} { return "" }
set Ligne $FichierOuTexteOliMut
scan $Ligne "%s %s" PAB PABMute
set FicNucTFA "[RepertoireDuGenome]/nuctfa/$PABMute"
if { ! [file exists $FicNucTFA]} {
FaireLire "$FicNucTFA\ndoesn't exists. I'll skip CreateOligosForMutation $Ligne"
return [list "No mutation oligo for ($FichierOuTexteOliMut) $FicNucTFA doesn't exist"]
}
set ToutSeqNuc [QueLaSequenceDuFichierTFA $FicNucTFA]
set MaxP [expr [string length $ToutSeqNuc]/3]
set LesCodes [lrange [split [string trim $Ligne] " "] 2 end]
set Extension [lindex $LesCodes end]
if { ! [regexp -nocase {^[a-z]} $Extension]} {
set LesCodes [lrange $LesCodes 0 end-1]
} else {
set Extension ""
}
Espionne "\n\n$LesCodes extension $Extension"
set LesCoOrdonnes {}
foreach Code $LesCodes {
if { ! [regexp -nocase {[a-z]} $Code]} { continue }
# regsub {[0-9]+} [string toupper $Code] " & " Coco
regsub {[0-9]+} $Code " & " Coco
scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
set LongAncienP [string length $AncienP]
lappend LesCoOrdonnes "$AncienP $PosAncienP $NouveauP"
}
set LesCoOrdonnes [lsort -increasing -integer -index 1 $LesCoOrdonnes]
set Decalage 0
set LesVraiesPositionsDebut {}
set LesVraiesPositionsApres {}
foreach Co $LesCoOrdonnes {
scan $Co "%s %d %s" AncienP PosAncienP NouveauP
set Code "$AncienP$PosAncienP$NouveauP"
set MutationDeNucleotides [regexp {[a-z]} $Code]
if {$MutationDeNucleotides} {
if { ! [OuiOuNon "I see lowercase letters in $Code!\nOk to mutate nucleotides ?"]} {
FaireLire "I'll skip $Code"
continue
}
}
set PosAncienP [expr $PosAncienP+$Decalage]
regsub -all -nocase "X" $AncienP "" VraiAncienP
regsub -all -nocase "X" $NouveauP "" VraiNouveauP
set Decalage [expr [string length $VraiNouveauP]-[string length $VraiAncienP]]
set VraiePositionDebut $PosAncienP
set VraiePositionApres [expr $PosAncienP+[string length $VraiNouveauP]]
lappend LesVraiesPositionsDebut $VraiePositionDebut
lappend LesVraiesPositionsApres $VraiePositionApres
if {$MutationDeNucleotides} {
set DebN [Maxi 1 [expr $VraiePositionDebut - $NbBasesAvant]]
set FinN [Mini [expr $VraiePositionApres + $NbBasesApres] [expr $MaxP*3]]
} else {
set DebP [Maxi 1 [expr $VraiePositionDebut - $NbAAsAvant]]
set FinP [Mini [expr $VraiePositionApres -1 + $NbAAsApres] $MaxP]
set DebN [expr ($DebP-1)*3 + 1]
set FinN [expr ($FinP-1)*3 + 2 + 1]
}
set SeqNuc [string range $ToutSeqNuc [expr $DebN - 1] [expr $FinN - 1]]
set AvecSubRegion [OuiOuNonMemo "Do you want to take a subregion of these mutation oligos ?" 0]
if {$AvecSubRegion} {
set SeqNucOriginal $SeqNuc
set DebNOriginal $DebN
set FinNOriginal $FinN
while 1 {
FaireLire "For $PABMute $Code\nPlease insert 2 spaces to indicate where to cut (0 to keep full seq)"
set SeqNucCutted [Entre $SeqNucOriginal]
set i1 [string first " " $SeqNucCutted]
set i2 [string last " " $SeqNucCutted]
if {$i1==-1 || $i2==-1} {
if {[OuiOuNon "Do we cancel cutting for this oligo ?"]} {break}
FaireLire "Please insert 2 or 0 spaces"
continue
}
set NouveauDebutN [expr $DebN + $i1]
set NouveauFinN [expr $FinN - ([string length $SeqNucCutted]-$i2-1)]
if {[expr ($NouveauFinN - $NouveauDebutN)<10]} {
FaireLire "You cut to much ... We redo cutting."
continue
}
set DebN $NouveauDebutN
set FinN $NouveauFinN
set SeqNuc [string range $ToutSeqNuc [expr $DebN - 1] [expr $FinN - 1]]
set AvecSubRegion 1
break
}
}
set SeqPro [SeqNucToSeqPro $SeqNuc]
regsub -all "." $SeqPro "& " SeqPro3
Espionne "$SeqNuc\n$SeqPro3"
set Entete ""
set Alias [Alias $PABMute]
if {$Alias==""} { set Alias $PABMute }
set AliasCode "$Alias"
if { ! [regexp "$Code$" $AliasCode]} { append AliasCode "-$Code" }
if {$AvecSubRegion} { set AliasCode [Entre $AliasCode] }
set Entete "MutOli_$AliasCode mutation oligo for $PABMute $Alias $Code $DebN $FinN"
set TFA [SequenceFormatTFA $SeqNuc $Entete "nucbrut"]
AppendAuFichier $FicOli $TFA
if {$ReverseAussi} {
if {$AvecSubRegion} {
while 1 {
FaireLire "For the REVERSE sequence\n$PABMute $Code\n Please insert 2 spaces to indicate where to cut"
set SeqNucCutted [Entre $SeqNucOriginal]
set i1 [string first " " $SeqNucCutted]
set i2 [string last " " $SeqNucCutted]
if {$i1==-1 || $i2==-1} {
if {[OuiOuNon "Do we cancel cutting for this oligo ?"]} {break}
FaireLire "Please insert 2 or 0 spaces"
continue
}
set NouveauDebutN [expr $DebNOriginal + $i1]
set NouveauFinN [expr $FinNOriginal - ([string length $SeqNucCutted]-$i2-1)]
if {[expr ($NouveauFinN - $NouveauDebutN)<10]} {
FaireLire "You cut to much ... We redo cutting."
continue
}
set DebN $NouveauDebutN
set FinN $NouveauFinN
set SeqNuc [string range $ToutSeqNuc [expr $DebN - 1] [expr $FinN - 1]]
set SeqPro [SeqNucToSeqPro $SeqNuc]
regsub -all "." $SeqPro "& " SeqPro3
Espionne "$SeqNuc\n$SeqPro3"
break
}
}
if {$AvecSubRegion} { set AliasCode [Entre $AliasCode] }
set SeqRaC [NucToReverseAndComplementNuc $SeqNuc]
set EnteteRaC "MutOliRac_$AliasCode mutation oligoRac for $PABMute $Alias $Code $DebN $FinN"
set TFARaC [SequenceFormatTFA $SeqRaC $EnteteRaC "nucbrut"]
AppendAuFichier $FicOli $TFARaC
}
}
return $FicOli
}
proc AffichePof {{Quoi ""}} {
if {$Quoi==""} { set Quoi "PofOl_PofPPCR_PofMut_PofSeq" }
set Retour {}
if {[regexp "AllPs" $Quoi]} {
set LesPofOl [PofOl "LesPofOl"]
set LesPofMut [PofMut "LesPofMut"]
set LesPofSeq [PofSeq "LesPofSeq"]
set LesPs [lsort [concat $LesPofOl $LesPofMut $LesPofSeq]]
foreach TextP $LesPs {
scan $TextP "%s" P
set DejaVu($P) 1
}
foreach P [Oli "LaListeMerci"] {
if {[info exists DejaVu($P)]} { continue }
lappend LesPs [Oli $P "AllOnOneLine"]
}
set FO [AfficheListe $LesPs "AvecOliAvecFiOl" "PofOl_PofMut_PofSeq"]
lappend Retour $FO
}
if {[regexp "PofOl" $Quoi]} {
set FO [AfficheListe [PofOl "LesPofOl"] "AvecOliAvecFiOl" "PofOligos"]
lappend Retour $FO
}
if {[regexp "PofMut" $Quoi]} {
set FO [AfficheListe [PofMut "LesPofMut"] "AvecOliAvecFiOl" "PofMutation"]
lappend Retour $FO
}
if {[regexp "PofSeq" $Quoi]} {
set FO [AfficheListe [PofSeq "LesPofSeq"] "AvecOliAvecFiOl" "PofSequencing"]
lappend Retour $FO
}
if {[regexp "PofPPCR" $Quoi]} {
set FP [AfficheListe [PofPPCR "5_3"] "AvecOliAvecFiPPCR" "PofPPCR"]
lappend Retour $FP
}
return $Retour
}
proc InventaireDesMatrices {} {
return [AfficheFichier "[RepertoireDuGenome]/fiches/matrices_of_oligos" "AvecOli"]
}
proc DontCreateAllOligos {} {
global DontCreateAllOligos
set DontCreateAllOligos [OuiOuNonMemo "Do I ask each time to remove some oligos ?" 0]
}
proc ShowVirtualPPCR {Selection {Action ""}} {
global ActionShowVirtualPPCR
if { ! [info exists ActionShowVirtualPPCR]} { set ActionShowVirtualPPCR "All" }
if {$Action==""} { set Action $ActionShowVirtualPPCR }
if {[regexp "\n" $Selection]} {
foreach Sel [split $Selection "\n"] {
ShowVirtualPPCR $Sel $Action
}
return
}
if {[regexp {>(N[0-9]+) } $Selection Match N]} {
return [ShowVirtualPPCR $N $Action]
}
if {$Action=="Choose"} {
set Action [ChoixParmi [VirtualPPCREnStock "LesQuois"]]
}
if {$Action==""} { return "" }
set ActionShowVirtualPPCR $Action
set N ""
foreach NPossible [split $Selection " "] {
if {[regexp {^N[0-9]+$} $NPossible]} { set N $NPossible ; break}
}
if {$N==""} { return "" }
if {$Action=="All"} {
set LesInfos {}
foreach A [VirtualPPCREnStock "LesQuois"] {
lappend LesInfos "\n$A :\n[VirtualPPCREnStock $N $A]"
}
set Info [join $LesInfos "\n"]
} else {
set Info "[VirtualPPCREnStock $N $Action]"
}
set Texte $Info
set Fen [AfficheVariable $Texte "AvecFormateAvecBlasteAvecVirtualPPCRAvecOli" $N]
return $Fen
}
proc AfficheVirtualPPCR {} {
set Page [join [VirtualPPCREnStock LesResumes] "\n"]
set LesQuois [VirtualPPCREnStock LesQuois]
return [AfficheVariable $Page "AvecVirtualPPCR" AllVirtualPPCRs]
}
proc SequenceSansOligosDuVirtualPPCR N {
set Seq [VirtualPPCREnStock $N "Seq"]
set P5 [VirtualPPCREnStock $N "P5"]
set P3 [VirtualPPCREnStock $N "P3"]
set S5 [Oli $P5 "SeqSignals"]
set S3 [NucToReverseAndComplementNuc [Oli $P3 "SeqSignals"]]
if { ! [regexp -nocase $S5 $Seq]} { FaireLire "Error I can't find $P5 in virtualPPCR $N" }
if { ! [regexp -nocase $S3 $Seq]} { FaireLire "Error I can't find $P3 in virtualPPCR $N" }
set SeqSujet $Seq
regsub -nocase "^$S5" $SeqSujet "" SeqSujet
regsub -nocase "$S3$" $SeqSujet "" SeqSujet
return $SeqSujet
}
proc VirtualPPCREnStock {N {Quoi ""}} {
global VirtualPPCREnStock
if {$Quoi==""} { set Quoi "Resume" }
if {$Quoi=="LesRec1"} { return [Rec1 $N LesRec1] }
if {$Quoi=="LesFichiersRec1"} { return [Rec1 $N LesFichiers] }
set RepDesVirtualPPCR "[RepertoireDuGenome]/ppcr_virtuels"
if { ! [info exists VirtualPPCREnStock("EstCharge")]} {
set VirtualPPCREnStock("EstCharge") 1
set LesResumes {}
set LesQuois {}
set VirtualPPCREnStock(LaListeDesNs) {}
foreach Fichier [glob -nocomplain "$RepDesVirtualPPCR/N*"] {
set Queue [file tail $Fichier]
if {[regexp {~$|\.20[0-9]{4,}$} $Queue]} { continue }
set Entete [EnteteDuFichierTFA $Fichier]
scan $Entete "%s %s %s %s %s %s %s %s %s" Nlu ppcr for PGS Sujet with oligos P5 P3
if { ! [regexp "^>" $Nlu]} { continue }
regsub ">" $Nlu "" Nlu
lappend VirtualPPCREnStock(LaListeDesNs) $Nlu
set FullName [StringSuivant "FN: " dans $Entete]
#??? lappend VirtualPPCREnStock(N,$FullName) $Nlu
set VirtualPPCREnStock($Nlu,FullName) $FullName
set VirtualPPCREnStock($Nlu,PGS) $PGS
set VirtualPPCREnStock($Nlu,Sujet) $Sujet
set VirtualPPCREnStock($Nlu,P5) $P5
set VirtualPPCREnStock($Nlu,P3) $P3
set VirtualPPCREnStock($Nlu,File) $Fichier
set Resume "$Nlu $PGS [format "%-13s" [Alias $PGS]] $P5 $P3 $FullName"
set VirtualPPCREnStock($Nlu,Resume) $Resume
lappend LesResumes $Resume
}
set LesQuois {}
lappend LesQuois "Resume" "FullName" "PGS" "P5" "P3" "Seq" "SeqSubject" "TFA" "File"
lappend LesQuois "LesRec1" "LesFichierRec1"
set VirtualPPCREnStock(LesQuois) $LesQuois
set VirtualPPCREnStock(LesResumes) $LesResumes
}
if {$N=="LaListeDesNs"} { return [set VirtualPPCREnStock(LaListeDesNs)] }
if {$N=="LesQuois"} { return [set VirtualPPCREnStock(LesQuois)] }
if {$N=="LesResumes"} { return [set VirtualPPCREnStock(LesResumes)] }
if {$Quoi==""} { set Quoi "TFA" }
if { ! [info exists VirtualPPCREnStock($N,FullName)]} { return "" }
if {$Quoi=="TFA"} { return [ContenuDuFichier "$RepDesVirtualPPCR/$N"] }
if {$Quoi=="Seq"} { return [QueLaSequenceDuFichierTFA "$RepDesVirtualPPCR/$N"] }
if {$Quoi=="SeqSubject"} { return [SequenceSansOligosDuVirtualPPCR $N] }
if {[info exists VirtualPPCREnStock($N,$Quoi)]} { return [set VirtualPPCREnStock($N,$Quoi)] }
}
proc TestNewVirtualPPCR {} {
set PPCR "GFP-1-239 +++ AttB1 XhoI +++ XhoI AttB2"
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFaire
Espionne [NewVirtualPPCR $PPCR "PGS311" "GFP-1-239"]
Espionne [NewVirtualPPCR $PPCR "PGS311" "GFP-1-239"]
exit
}
proc NewVirtualPPCR {PPCR {PGS ""} {Sujet ""}} {
global NewVirtualPPCR
JeMeSignale
if {0} {
set Alias [Alias $PGS]
regsub -all {\-} $Alias "\\\-" XAlias
if { ! [regexp $XAlias $Sujet]} {
FaireLire "l'alias de $PGS $Alias n'est pas dans le sujet $Sujet"
}
}
set RepDesVirtualPPCR "[RepertoireDuGenome]/ppcr_virtuels"
if {$PPCR=="Load"} {
set nMax 1000
foreach Nlu [VirtualPPCREnStock "LaListeDesNs"] {
set FullName [VirtualPPCREnStock $Nlu "FullName"]
lappend NewVirtualPPCR($FullName) $Nlu
regsub -all {[^0-9]} $Nlu "" Numero
set n [Base10 $Numero]
set nMax [Maxi $nMax $n]
}
set NewVirtualPPCR(LastNumber) $nMax
set NewVirtualPPCR("EstCharge") 1
return
}
if { ! [info exists NewVirtualPPCR("EstCharge")]} { NewVirtualPPCR "Load" }
set P5 [P5ofPPCR $PPCR]
set P3 [P3ofPPCR $PPCR]
Espionne $PGS
set A5 [BaClon Trio $PGS $Sujet $P5]
set A3 [BaClon Trio $PGS $Sujet $P3]
set N5 [expr ($A5-1)*3+1]
set N3 [expr ($A3-1)*3+3]
set AskForDummy 0
set Dummy 0
Espionne "I got P5=$P5 P3=$P3 A5=$A5 A3=$A3 N5=$N5 N3=$N3"
if {$P5=="" || $P3=="" || $A5=="" || $A3=="" || $N3<$N5 } {
if {$AskForDummy && [OuiOuNon "There is a problem with NewVirtualPPCR $PPCR $PGS $Sujet \n \
I got P5=$P5 P3=$P3 A5=$A5 A3=$A3 N5=$N5 N3=$N3 \n \
Do I create a dummy PPCR (if NO I'll cancel)?" 0]} {
set Dummy 1
} else {
return ""
}
}
set FiNuc "[RepertoireDuGenome]/nuctfa/$PGS"
set SeqPGS [ZoneADNDuFichierTFA $N5 $N3 $FiNuc]
set SeqAv [Oli $P5 SeqSignals]
set SeqAp [NucToReverseAndComplementNuc [Oli $P3 SeqSignals]]
set SeqPPCR "$SeqAv$SeqPGS$SeqAp"
regsub -all -nocase {[^a-z]} $SeqPPCR "" SeqPPCR
if { ! [info exists NewVirtualPPCR(LastNumber)]} { set NewVirtualPPCR(LastNumber) 1000 }
set n [set NewVirtualPPCR(LastNumber)]
incr n
set Nppcr [format "%s%4.4d" "N" $n]
set FullName "$PGS $Sujet ppcr: $PPCR"
Espionne "FullName $FullName"
if {! $Dummy && [info exists NewVirtualPPCR($FullName)]} {
Espionne "Old VirtualPPCR $PPCR $PGS $Sujet I got P5=$P5 P3=$P3 A5=$A5 A3=$A3 N5=$N5 N3=$N3"
foreach OldN [set NewVirtualPPCR($FullName)] {
set FichierOldN "$RepDesVirtualPPCR/$OldN"
Espionne $FichierOldN
if {[file exists $FichierOldN]} {
set SeqOldN [QueLaSequenceDuTFA $FichierOldN]
if {[string equal -nocase $SeqPPCR $SeqOldN]} {
return "$OldN same already existed"
}
VoisinADN ">TheOldPPCR_$OldN\n$SeqOldN\n>TheNewPPCR_$Nppcr\n$SeqPPCR"
AfficheVariable "During creation of $Nppcr I detect that following equivalent \n\
Ppcr [set NewVirtualPPCR($FullName)] from $FullName\nalready exist\n\
Please compare Old with New in the other window\
Then I'll ask you what to do." "AvecRetour"
set GardeVieux 1
if {[OuiOuNon "Do I delete the old $OldN replacing it with $Nppcr ?"]} {
if {[OuiOuNon "Ok to delete the file \n$FichierOldN\n\
Don't worry if I 'll speak again about $OldN in this process,\n \
I can't forget so easely this old boy $OldN ..." ]} {
file delete $FichierOldN
set GardeVieux 0
}
}
if {$GardeVieux && [OuiOuNon "Do I cancel creation of $Nppcr ?"]} { return "$OldN different but I keep it" }
}
}
}
set Entete "$Nppcr Ppcr for $PGS $Sujet with oligos $P5 $P3 FN: $FullName"
if {$Dummy} {
regsub "Ppcr" $Entete "DUMMY Ppcr" Entete
set SeqPPCR "ATGTGA"
}
set TFA [SequenceFormatTFA $SeqPPCR $Entete "nucbrut"]
Espionne "NewVirtualPPCR $PPCR $PGS $Sujet I got P5=$P5 P3=$P3 A5=$A5 A3=$A3 N5=$N5 N3=$N3"
if { ! [file exists $RepDesVirtualPPCR]} { file mkdir $RepDesVirtualPPCR }
Sauve $TFA dans "$RepDesVirtualPPCR/$Nppcr"
set NewVirtualPPCR(LastNumber) $n
lappend NewVirtualPPCR($FullName) $Nppcr
return $Nppcr
}
proc OligoEnStock Seq {
global OligoEnStock
if {$Seq=="Reload"} {
if {[info exists OligoEnStock]} { unset OligoEnStock }
set Seq "LaListeMerci"
}
set Seq [string toupper $Seq]
if {[info exists OligoEnStock($Seq)]} { return [set OligoEnStock($Seq)] }
if {[info exists OligoEnStock(LALISTEMERCI)]} { return {} }
set OligoEnStock(LALISTEMERCI) [Oli LaListeMerci]
foreach P [set OligoEnStock(LALISTEMERCI)] {
set SeqOli [string toupper [Oli $P]]
lappend OligoEnStock($SeqOli) $P
}
return [OligoEnStock $Seq]
}
proc MutateSequencesListedIn {FichierOuListeOuLigne} {
if { ! [regexp " " $FichierOuListeOuLigne]} {
set LesLignes [LesLignesDuFichier $FichierOuListeOuLigne]
} else {
if {[regexp " " [lindex $FichierOuListeOuLigne 0]]} {
set LesLignes $FichierOuListeOuLigne
} else {
set LesLignes [list $FichierOuListeOuLigne]
}
}
set LesMutes {}
foreach Ligne $LesLignes {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
scan $Ligne "%s %s" PAB PABMute
set LesCodes [lrange [LesMotsDeLaLigne $Ligne] 2 end]
set Extension [lindex $LesCodes end]
if { ! [regexp -nocase {^[a-z]} $Extension]} {
set LesCodes [lrange $LesCodes 0 end-1]
} else {
set Extension ""
}
Wup "We replace * the coding of STOP by O which is not used as aa code"
set LesCodesSansEtoile {}
foreach Code $LesCodes {
if {[regexp {\*} $Code]} {
regsub -all {\*} $Code "O" Code
}
lappend LesCodesSansEtoile $Code
}
set LesCodes $LesCodesSansEtoile
Espionne "$LesCodes extension=>$Extension<"
set CodeDeMutation [join $LesCodes " "]
lappend LesMutes [MutateSequence $PAB $CodeDeMutation $Extension $PABMute]
}
return [join $LesMutes "\n"]
}
proc MutateSequence {{PAB ""} {CodeDeMutation ""} {Extension ""} {PABMute ""}} {
while {$PAB==""} {
FaireLire "Please enter the [PreFixe] to mutate."
set PAB [Entre "[PreFixe]"]
if {[EstUnPAB $PAB]} { break }
if {$PAB=="" && [OuiOuNon "Do I cancel MutateSequence ?"]} { return "" }
}
if {$CodeDeMutation==""} {
FaireLire "Please enter the codes for mutation\n\
\nF602E\nF602AP S455T R665W\nF602X\nF602*\nFPA602RW\nX55FRAP\n..."
set CodeDeMutation [Entre "F602E"]
}
if {$PABMute==""} {
regsub -nocase -all {[A-Z]} $PAB "" Numero
set Numero [Base10 $Numero]
set NumeroMute [expr $Numero+1000]
set PABMute [format "%s%3.3d" [PreFixe] $NumeroMute]
while { ! [OuiOuNon "Do I use $PABMute as mutant name"]} {
set PABMute [Entre $PABMute]
}
}
set FichierNucTfaMute "[RepertoireDuGenome]/nuctfa/$PABMute"
set FichierProtTfaMute "[RepertoireDuGenome]/prottfa/$PABMute"
set OldPABMute ""
while {[file exists $FichierNucTfaMute]} {
FaireLire "A mutant of $PAB already exists ($PABMute)\n\
Please enter an other number. \n\
(or the same to overwrite; or an empty string to skip)"
set OldPABMute $PABMute
set PABMute [Entre $PABMute]
if {$PABMute=="" && [OuiOuNon "Do I skip creation of $PABMute ?"]} { return "" }
if {$PABMute==$OldPABMute && [OuiOuNon "Do I replace the existing $PABMute"]} { break }
set FichierNucTfaMute "[RepertoireDuGenome]/nuctfa/$PABMute"
set FichierProtTfaMute "[RepertoireDuGenome]/prottfa/$PABMute"
}
set Alias [Alias $PAB]
if {[regexp "^=" $Extension]} {
set AliasMute $Extension
} else {
if {$Extension==""} {
set Extension $CodeDeMutation
regsub " " $Extension "-" Extension
set Extension "-$Extension"
}
if {$Extension=="-DontModifyAlias"} {
set AliasMute $Alias
} else {
set AliasMute "$Alias$Extension"
}
}
set FichierNucTfa "[RepertoireDuGenome]/nuctfa/$PAB"
set Seq [QueLaSequenceDuFichierTFA $FichierNucTfa]
set SeqMute [Mute $CodeDeMutation $Seq]
set Entete [EnteteDuFichierTFA $FichierNucTfa]
set Access [EnteteDuFichierTFA $FichierNucTfa "access"]
regsub $Access $Entete "$AliasMute muted $CodeDeMutation of" EnteteMute
set TFA [SequenceFormatTFA $SeqMute $EnteteMute "nucbrut"]
Sauve $TFA dans $FichierNucTfaMute
set FichierProtTfa "[RepertoireDuGenome]/prottfa/$PAB"
set SeqProt [SeqNucToSeqPro $SeqMute]
set TFAProt [SequenceFormatTFA $SeqProt $EnteteMute "protbrut"]
Sauve $TFAProt dans $FichierProtTfaMute
if {$Extension=="-DontModifyAlias"} {
InformeSansDemander $PABMute "=CopyOf_$PAB"
InformeSansDemander $PABMute "=Corrected: correction of $PAB $Alias $CodeDeMutation"
} else {
InformeSansDemander $PABMute "=Alias: $AliasMute"
InformeSansDemander $PABMute "=Muted: mutation of $PAB $Alias $CodeDeMutation"
}
set D [Box $PAB debut]
set F [Box $PAB fin]
set O [Box $PAB orient]
if {[Box $PABMute Nom]!=""} {
set LignePAB "[Box $PAB nom] [Box $PAB debut] [Box $PAB fin] [Box $PAB orient]"
set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
set LesLignes [LesLignesDuFichier $FichierBornes]
set i [lsearch -exact $LesLignes $LignePAB]
set LesNouvellesLignes [lreplace $LesLignes $i $i]
SauveLesLignes $LesNouvellesLignes dans $FichierBornes
}
Box $PABMute debut $D
Box $PABMute fin $F
Box $PABMute orient $O
AppendAuFichier "[RepertoireDuGenome]/fiches/bornesdespabs" "$PABMute $D $F $O"
ListeDesPABs $PABMute
Box $PABMute nom $PABMute
Box $PABMute debut $D
Box $PABMute fin $F
Box $PABMute orient $O
LesPABsDansLOrdre "ReplaceListReplaceFile"
return "$PAB $PABMute $CodeDeMutation"
}
proc Mute {Code Seq} {
Wup "Code can be a list of codes separated with space"
JeMeSignale
if {[regexp " " $Code]} {
set LesCoOrdonnes {}
foreach Co [split $Code " "] {
if { ! [regexp -nocase {[a-z]} $Co]} { continue }
regsub {[0-9]+} $Co " & " Coco
scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
set LongAncienP [string length $AncienP]
lappend LesCoOrdonnes "$AncienP $PosAncienP $NouveauP"
}
set LesCoOrdonnes [lsort -decreasing -integer -index 1 $LesCoOrdonnes]
set NouveauSeq $Seq
foreach Co $LesCoOrdonnes {
regsub -all " " $Co "" Co
set NouveauSeq [Mute $Co $NouveauSeq]
}
return $NouveauSeq
}
regsub {[0-9]+} $Code " & " Coco
scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
set LongAncienP [string length $AncienP]
set LongAncienN [expr $LongAncienP*3]
regsub "X" $NouveauP "" NouveauP
regsub "x" $NouveauP "" NouveauP
set LongNouveauP [string length $NouveauP]
#rR Attention, here we mutate NUCLEOTIDES
if {[regexp {^[a-z]+$} "$AncienP$NouveauP"] && \
[OuiOuNonMemo "I see that you use lowercase letters.\nPosition in Nuc count\n\
Ok to mutate nucleotides ?"]} {
set DebAncienN [expr $PosAncienP-1]
set FinAncienN [expr $DebAncienN + $LongAncienP - 1]
set NouveauSeq [string replace $Seq $DebAncienN $FinAncienN $NouveauP]
return $NouveauSeq
}
#rR Attention, here we mutate NUCLEOTIDES
#rR Attention, here we mutate NUCLEOTIDES
if {[regexp {^[a-z]+$} "$NouveauP"] && [regexp {^[A-Z]+$} "$AncienP"] && \
[OuiOuNonMemo "For $Code , I see that you use lowercase letters in $NouveauP\n\
and uppercase in $AncienP\nSo position is in AA count\nOk to mutate the aa to nucleotides ?"]} {
set DebAncienN [expr ($PosAncienP-1)*3]
set FinAncienN [expr $DebAncienN + $LongAncienP*3 - 1]
set NouveauSeq [string replace $Seq $DebAncienN $FinAncienN $NouveauP]
return $NouveauSeq
}
#rR Attention, here we mutate NUCLEOTIDES
set DebAncienN [expr ($PosAncienP-1)*3]
set FinAncienN [expr $DebAncienN+$LongAncienN-1]
set AncienN [string range [string toupper $Seq] $DebAncienN $FinAncienN]
set LesNouveauxCodons {}
foreach {A B C} [split $AncienN ""] P [split $AncienP ""] N [split $NouveauP ""] {
if {$N==""} { break }
set Codon "$A$B$C"
if {$Codon!=""} {
Espionne ">$Codon< >$P< >$N< $PosAncienP"
set AA [AAduCodon $Codon]
if {$P!="" && $AA!=$P} {
FaireLire "$P from $Code \n\
doesn't correspond to translation of $Codon from the nucleic seq.\n\
I ignore it. But, please, verify your sequences."
}
}
set NouveauCodon [PlusProcheCodon $Codon [LesCodesGenetiques $N]]
lappend LesNouveauxCodons $NouveauCodon
}
set NouveauxCodons [join $LesNouveauxCodons ""]
set NouveauSeq [string replace $Seq $DebAncienN $FinAncienN $NouveauxCodons]
return $NouveauSeq
}
proc ChoixDUneListeDeSitesDeCoupure {} {
FaireLire "Please select as much sites as you want.\nStop with 'StopAsking'"
set LeChoix {}
while 1 {
set SC [ChoixDUnSiteDeCoupure]
if {$SC=="SansCoupure"} {
if {[OuiOuNon "Do we stop now ?"]} { break }
continue
}
scan $SC "%s %s %d" Coupure CoupN LongCoupN
set SC "$CoupN $LongCoupN"
if {[info exists DejaVu($SC)]} { continue }
set DejaVu($SC) 1
lappend LeChoix "$SC"
}
return $LeChoix
}
proc CoupureParEnzyme {{Qui ""} {Quoi ""}} {
global CoupureParEnzyme
if {[info exists CoupureParEnzyme($Qui,$Quoi)]} { return $CoupureParEnzyme($Qui,$Quoi) }
if {[info exists CoupureParEnzyme("EstCharge")]} { return "" }
foreach Coup [LesCoupuresPossibles] {
set Type "N"
scan $Coup "%s %s %s" Enzyme Pos Type
set CoupureParEnzyme($Enzyme,position) $Pos
set CoupureParEnzyme($Enzyme,type) $Type
set Seq [Signal $Enzyme SEQ]
set CoupureParEnzyme($Enzyme,sequence) $Seq
lappend CoupureParEnzyme(ListeDes,Enzymes) $Enzyme
}
set CoupureParEnzyme("EstCharge") 1
return [CoupureParEnzyme $Qui $Quoi]
}
proc EstUneProtease P {
foreach PP [list "Thrombin" "TEV2" "TEVS" "Protease3C"] {
if {$P==$PP} { return 1 }
}
return 0
}
proc LesCoupuresPossibles {} {
set LesCoupuresPossibles [list "Thrombin 12 P" "TEV2 18 P" "TEVS 18 P" "Protease3C 18 P" \
"NdeI 3 N" "BamHI 3 N" "SpeI 3 N"]
return $LesCoupuresPossibles
}
proc ChoixDUnSiteDeCoupure {{ChoixPourCoupure ""}} {
if {$ChoixPourCoupure==""} { set ChoixPourCoupure "Ask" }
if {$ChoixPourCoupure=="SansCoupure"} { return "SansCoupure" }
while {$ChoixPourCoupure=="Ask" || [regexp -nocase {^[a-z\-0-9]+ +[0-9]+$} $ChoixPourCoupure]} {
if {$ChoixPourCoupure=="Ask"} {
set LesCoups [LesCoupuresPossibles]
lappend LesCoups "OtherSignal" "NucleicSequence" "NoCuttingSite" "StopAsking"
set Choix [ChoixParmi $LesCoups]
} else {
set Choix $ChoixPourCoupure
}
if {$Choix=="NoCuttingSite"} { return "SansCoupure" }
if {$Choix==""} {
if { ! [OuiOuNon "NoCuttingSite ?"]} { continue }
set ChoixPourCoupure "SetToSansCoupure"
return "SansCoupure"
} elseif {$Choix=="StopAsking"} {
return "SansCoupure"
} elseif {$Choix=="OtherSignal"} {
FaireLire "Please give SignalName and Position"
set Choix [Entre "Thrombin 12 P"]
set Sign ""
set Pos ""
scan $Choix "%s %d" Sign Pos
if { ! [EstUnSignal $Sign] || ! [regexp {^[0-9]+$} $Pos]} {
FaireLire "$Sign is not a signal name or Position is bad."
continue
}
set CoupN [Signal $Sign]
set LongCoupN $Pos
set Coupure $Sign
set ChoixPourCoupure "SetToSignalName"
} elseif {$Choix=="NucleicSequence"} {
FaireLire "Please give a nucleic sequence and Position"
set Choix [Entre "CATATG 3 N"]
set NucSeq ""
set Pos ""
scan $Choix "%s %d" NucSeq Pos
if { ! [regexp -nocase {^[a-z]+$} $NucSeq] || ! [regexp {^[0-9]+$} $Pos ]} {
FaireLire "Something is wrong ... we'll try again"
continue
}
set CoupN $NucSeq
set LongCoupN $Pos
set Coupure $NucSeq
set ChoixPourCoupure "SetToNucleicSequence"
} elseif {[regexp -nocase {^NucSeq_[ATGCN]+ [0-9]+$} $Choix]} {
regsub {^NucSeq_} $Choix "" SeqPos
scan $SeqPos "%s %d" NucSeq Pos
set CoupN $NucSeq
set LongCoupN $Pos
set Coupure $NucSeq
set ChoixPourCoupure "SetToNucleicSequence"
} else {
scan $Choix "%s %d" Sign Pos
set CoupN [Signal $Sign]
set LongCoupN $Pos
set Coupure $Sign
set ChoixPourCoupure "SetToSignal"
}
set CoupP [SeqNucToSeqPro $CoupN]
set LongCoupP [expr $LongCoupN/3]
set CoupN [string toupper $CoupN]
set CoupP [string toupper $CoupP]
}
return "$Coupure $CoupN $LongCoupN $CoupP $LongCoupP"
}
proc CoupureDesADNCirculairesPourTous {} {
set RepDestin "[RepertoireDuGenome]/coupure"
set LesFichiersCrees {}
foreach R2 [Rec2 LaListeDes Rec2] {
set FichierTFA [Rec2 $R2 Fichier]
if {[FileAbsent $FichierTFA]} { continue }
set Coupe [QuelleCoupure $R2]
if {$Coupe==""} { continue }
set Type "N"
scan $Coupe "%s %s %s" Enzyme Pos Type
if {$Type!="P"} { continue }
set Seq [Signal $Enzyme SEQ]
set LesFic [CoupureDesADNCirculaires [list $FichierTFA] [list "$Seq $Pos"] $RepDestin $Enzyme]
LConcat LesFichiersCrees $LesFic
}
return $LesFichiersCrees
}
proc CoupureDesADNCirculaires {{LesFichiersTFA ""} {LesSeqPos ""} {RepDestin ""} {Enzyme ""}} {
if {$LesSeqPos=={}} {
set LesSeqPos [ChoixDUneListeDeSitesDeCoupure]
}
if {$LesFichiersTFA=={}} {
set LesFichiersTFA [LesFichiersDeType "Rec2"]
}
if {$RepDestin==""} {
FaireLire "Please browse for the directory where to store the files"
set RepDestin [ChoixDuRepertoire [RepertoireDuGenome]]
}
set Rep $RepDestin
set LesFichiersCrees {}
foreach Fichier $LesFichiersTFA {
set Queue [file tail $Fichier]
regsub {.tfa$|.nucfa$} $Queue "" Queue
set Access [EnteteDuFichierTFA $Fichier "access"]
regsub -nocase {^(rec1_|rec2_|fusion_)} $Access "" Access
set ADN [QueLaSequenceDuFichierTFA $Fichier]
set ZonesEtSites [CoupureDUnADNCirculaire $ADN $LesSeqPos]
set Zones [lindex $ZonesEtSites 0]
set Sites [lindex $ZonesEtSites 1]
foreach Zone $Zones Site $Sites {
set BeauSite [join $Site "-"]
if {$Enzyme!=""} { set BeauSite $Enzyme }
set BeauAccess "cut_${Access}_$BeauSite"
set FichierCree "$Rep/cut_${Queue}_$BeauSite.nuctfa"
set nBases [string length $Zone]
set TFA [SequenceFormatTFA $Zone "$BeauAccess $nBases bases" "nucbrut"]
Espionne [Sauve $TFA dans $FichierCree]
lappend LesFichiersCrees $FichierCree
set CDS ""
foreach {A B C} [split $Zone ""] {
set Codon "$A$B$C"
if {[CodonStopPossible $Codon]} { break }
append CDS $Codon
}
set nAA [string length $CDS]
set SeqPro [SeqNucToSeqPro $CDS]
set ProtTFA [SequenceFormatTFA $SeqPro "$BeauAccess $nAA AA" "protbrut"]
set FichierCreeProt $FichierCree
regsub ".nuctfa$" $FichierCreeProt ".prottfa" FichierCreeProt
Espionne [Sauve $ProtTFA dans $FichierCreeProt]
lappend LesFichiersCrees $FichierCreeProt
}
}
return $LesFichiersCrees
}
proc CoupureDUnADNCirculaire {ADN LesSeqPos} {
set LongADN [string length $ADN]
Espionne $LongADN
set Double [string toupper "$ADN$ADN$ADN"]
foreach SeqPos $LesSeqPos {
scan $SeqPos "%s %d" Seq Pos
set Seq [string toupper $Seq]
set iMin -1
Espionne $Seq
while 1 {
set i [string first $Seq $Double $iMin]
if {$i<0} { break }
set iMin [expr $i+1]
set Site [expr $i+$Pos]
lappend LesSites $Site
set SeqDuSite($Site) $Seq
incr Site $LongADN
lappend LesSites $Site
set SeqDuSite($Site) $Seq
}
}
set LesSites [lsort -unique -integer $LesSites]
set LesZones {}
set LesSitesDeCoupure {}
foreach SiteA [lrange $LesSites 0 end-1] SiteB [lrange $LesSites 1 end] {
Espionne "$SiteA $SiteB"
if {[info exists DejaVu($SiteA)]} { break }
set DejaVu([expr $SiteA+$LongADN]) 1
set FinSiteB [expr $SiteB-1]
set Zone [string range $Double $SiteA $FinSiteB]
lappend LesZones $Zone
if {$FinSiteB>$LongADN} { set FinSiteB [expr $FinSiteB-$LongADN] }
lappend LesSitesDeCoupure "$SiteA $FinSiteB [set SeqDuSite($SiteA)] [set SeqDuSite($SiteB)]"
}
return [list $LesZones $LesSitesDeCoupure]
}
proc LesSujetsDansLeBonOrdre LesSujets {
set LesBeauxSujets {}
foreach Sujet $LesSujets {
set LesMots [split $Sujet "-"]
set F [lindex $LesMots end]
set D [lindex $LesMots end-1]
set BeauSujet $Sujet
if {[regexp {^[0-9]+$} $D] && [regexp {^[0-9]+$} $F]} {
set Reste [join [lrange $LesMots 0 end-2] "-"]
set BeauSujet [format "%s\-%5.5d\-%5.5d" $Reste $D $F]
}
lappend LesBeauxSujets $BeauSujet
set MonSujet($BeauSujet) $Sujet
}
set LesBeauxTries [lsort $LesBeauxSujets]
set LesTries {}
foreach BeauSujet $LesBeauxTries {
lappend LesTries [set MonSujet($BeauSujet)]
}
return $LesTries
}
proc CreeToutesLesNotesPourClonage {{Liste ""}} {
if {$Liste==""} { set Liste [ListeDesPABs] }
set RepNotes "[RepertoireDuGenome]/notes"
if { ! [file exists RepNotes]} { file mkdir $RepNotes }
foreach Nom $Liste {
set FichierNotes "$RepNotes/$Nom"
set LesSujets [split [BaClon LesSujets $Nom] " "]
set LesSujets [LesSujetsDansLeBonOrdre $LesSujets]
set LesOligos [split [BaClon LesOligos $Nom] " "]
Espionne $LesSujets
set TexteTitre "Note for $Nom [Alias $Nom] [CodeMutation $Nom All] [DefinitionRapide $Nom]"
set LesLignesSujets {}
set OldLigne ""
foreach Sujet $LesSujets {
set Ligne [format "%-15s" $Sujet]
set LesPDuTrio {}
foreach P $LesOligos {
if {[BaClonExists Trio $Nom $Sujet $P]} { lappend LesPDuTrio $P }
}
set LesPDuTrio [ListeSansDoublon $LesPDuTrio]
if {[llength $LesPDuTrio]==0} {
append Ligne " NoOligoFound"
} elseif {[llength $LesPDuTrio]!=2} {
append Ligne " OligosFound [join $LesPDuTrio " "]"
} else {
set A [lindex $LesPDuTrio 0]
set B [lindex $LesPDuTrio 1]
set pA [BaClon Trio $Nom $Sujet $A]
set pB [BaClon Trio $Nom $Sujet $B]
if {$pA>$pB} { set W $A ; set A $B ; set B $W ; set W $pA ; set pA $pB ; set pB $W }
Espionne "$Nom $Sujet $A $pA $B $pB"
set dA [expr $pA - [string length [Oli $A SeqSignals]]/3 -1]
set fA [expr $pA + [string length [Oli $A SeqSubject]]/3 -1]
set dB [expr $pB - [string length [Oli $B SeqSignals]]/3 -1]
set fB [expr $pB + [string length [Oli $B SeqSubject]]/3 -1]
lappend LesPPCRsADessiner($Nom) "$Sujet [expr ($pA-1)*3+1] [expr $pB*3] \
$A [expr ($dA-1)*3+1] [expr $fA*3] \
$B [expr ($dB-1)*3+1] [expr $fB*3]"
set BlancDevant [string repeat "." [Maxi [expr $pA/10] 2]]
set BlancDedans [string repeat "-" [Maxi [expr ($pB-$pA)/10] 2]]
set TxtP " $BlancDevant $A $BlancDedans $B"
append Ligne $TxtP
}
if {$Ligne!=$OldLigne} {
lappend LesLignesSujets $Ligne
}
set OldLigne $Ligne
}
if {$LesLignesSujets=={}} {
set TexteSujets "No subject found"
} else {
set TexteSujets [join $LesLignesSujets "\n"]
}
if {$LesOligos=={}} {
set TexteOligos "No oligos found"
} else {
set TexteOligos {}
foreach P $LesOligos {
lappend TexteOligos [Oli $P "Description"]
}
set TexteOligos [join $TexteOligos "\n"]
}
catch {unset DejaVu}
foreach P $LesOligos { set DejaVu($P) 1 }
set OtherOligos {}
foreach P [LesOligosDuPGS $Nom] {
if {[info exists DejaVu($P)]} { continue }
lappend OtherOligos [Oli $P "Description"]
}
if {$OtherOligos==""} {
set TexteOtherOligos ""
} else {
set TexteOtherOligos "Additional Oligos :\n[join $OtherOligos "\n"]"
}
set LeTextePPCR {}
foreach N [LesVirtualPPCRsDuPGS $Nom] {
lappend LeTextePPCR [VirtualPPCREnStock $N "Resume"]
}
if {$LeTextePPCR=={}} {
set TextePPCR "No PPCR found"
} else {
set TextePPCR [join $LeTextePPCR "\n"]
}
set LeTexteRec1 {}
foreach R1 [Rec1 $Nom LesRec1] {
lappend LeTexteRec1 [Rec1 $R1 "Description"]
}
if {$LeTexteRec1=={}} {
set TexteRec1 "No Rec1 found"
} else {
set TexteRec1 [join $LeTexteRec1 "\n"]
}
set LeTexteRec2 {}
foreach R2 [Rec2 $Nom LesRec2] {
lappend LeTexteRec2 [Rec2 $R2 "Description"]
}
if {$LeTexteRec2=={}} {
set TexteRec2 "No Rec2 found"
} else {
set TexteRec2 [join $LeTexteRec2 "\n"]
}
set Texte "$TexteTitre\n\n$TexteSujets\n\n$TexteOligos\n$TexteOtherOligos\
\n\n$TextePPCR\n\n$TexteRec1\n\n$TexteRec2"
Espionne [Sauve $Texte dans $FichierNotes ]
}
if {[info exists LesPPCRsADessiner]} {
SauveLesLignes [array get LesPPCRsADessiner] dans "[RepertoireDuGenome]/fiches/lesppcrsadessiner"
}
}
proc MailAuxDestinataires {FichierTXTCommandeOligos {LesDestinataires {}} {Sujet ""}} {
if {$LesDestinataires=={}} {
set LesDestinataires {}
lappend LesDestinataires "Peggy.Mathon@igbmc.u-strasbg.fr"
lappend LesDestinataires "Marie.Herledan@igbmc.u-strasbg.fr"
lappend LesDestinataires "Marie-France.Tinland@igbmc.u-strasbg.fr"
lappend LesDestinataires "Didier.Busso@igbmc.u-strasbg.fr"
lappend LesDestinataires "Sylvia.Eiler@igbmc.u-strasbg.fr"
lappend LesDestinataires "Arnaud.Poterszman@igbmc.u-strasbg.fr"
lappend LesDestinataires "Raymond.Ripp@igbmc.u-strasbg.fr"
lappend LesDestinataires "europrim@invitrogen.com"
set LesDestinataires [ChoixDesPresents $LesDestinataires]
}
if {$Sujet==""} { set Sujet [Entre "[file tail $FichierTXTCommandeOligos]"] }
if {$LesDestinataires=={}} { return {} }
foreach Destinataire $LesDestinataires {
Espionne [MailFichier $FichierTXTCommandeOligos $Destinataire $Sujet]
}
return $LesDestinataires
}
proc LigneAccessPourLOligo P {
set LesSujets [Oli $P Subjects]
set Sens [Oli $P Sens]
set Signals [Oli $P Signals]
set Seq [Oli $P Seq]
set SeqSujet [Oli $P SeqSubject]
set Type [Oli $P Type]
set TypeUtilisation $Type
if {$Type=="SynOli"} { set TypeUtilisation "PCR" }
set Fournis [Fournisseur $P]
set OlIgbmc [OlIgbmc $P]
set Tm [TMDeLaSequence $SeqSujet]
set LesPoMa [PositionSurMatrices $P]
if {0 && [llength $LesPoMa]>1 && $Type!="MutOli"} {
FaireLire "I found more than 1 matrix for $P. Please select one of them."
set PoMa [ChoixParmi $LesPoMa]
} else {
set PoMa [lindex $LesPoMa 0]
}
set AA -1
set NA -1
set Orient "F"
set PAB ""
scan $PoMa "%s %d %d %s %s" P AA NA Orient PAB
if {$AA<0} {
set Matrice ""
} else {
set Matrice [Alias $PAB]
}
set Sens ""
if {$Orient=="F"} {
set Sens "sens"
set Tm5p "tm5p_$Tm"
set LesSST {}
foreach Suj $LesSujets {
set SST "${Signals}_$Suj $Tm5p"
lappend LesSST $SST
}
set signal [join $LesSST "+"]
}
if {$Orient=="R"} {
set Sens "antisens"
set Tm3p "tm3p_$Tm"
set LesSST {}
foreach Suj $LesSujets {
set SST "${Suj}_${Signals} $Tm3p"
lappend LesSST $SST
}
set signal [join $LesSST "+"]
}
set code_IGBMC $OlIgbmc
regsub "OLIGO\:" $code_IGBMC "" code_IGBMC
set sequence $Seq
set brin $Sens
set proteine $Matrice
if {$Type=="MutOli"} {
set mutation [Oli $P CodeMutation]
} else {
set mutation ""
}
set utilisation $TypeUtilisation
set longueur [string length $Seq]
set signal $signal
if {$Fournis!=""} {
set demandeur $Fournis
} else {
set demandeur ""
}
set date_commande ""
set date_reception ""
set codon_de_l_oligo1 ""
set boite ""
set LaLigne {}
lappend LaLigne $P
lappend LaLigne $code_IGBMC
lappend LaLigne $sequence
lappend LaLigne $brin
lappend LaLigne $proteine
lappend LaLigne $mutation
lappend LaLigne $utilisation
lappend LaLigne $longueur
lappend LaLigne $signal
lappend LaLigne $demandeur
lappend LaLigne $date_commande
lappend LaLigne $date_reception
lappend LaLigne $codon_de_l_oligo1
lappend LaLigne $boite
set Ligne [join $LaLigne "\"\t\""]
set Ligne "\"$Ligne\""
return $Ligne
}
proc NumeroSuivant {DernierP {Format ""} {IncrValue 1}} {
Wup "P0123 or TOTO1234 or To_Salut1234 . If no 4 digit use Format"
if {$Format==""} { set Format "%s%4.4d" }
regsub -all {[0-9]} $DernierP "" Lettre
regsub -all {[^0-9]} $DernierP "" Numero
set Numero [Base10 $Numero]
incr Numero $IncrValue
set ProchainP [format $Format $Lettre $Numero]
return $ProchainP
}
proc StockeCetOligo {Entete Sequence {ForceProchainP ""} {FichierOli ""}} {
global DernierPStocke
if {$Entete=="Reset"} {
if {[info exists DernierPStocke]} { unset DernierPStocke }
return ""
}
if {$ForceProchainP==""} { set ForceProchainP "AutoNumbering" }
if {$ForceProchainP=="AutoNumbering"} {
if { ! [info exists DernierPStocke]} {
set LesExistants [lsort [Oli "LaListeMerci"]]
set DernierPStocke [lindex $LesExistants end]
set OriProchainP [NumeroSuivant $DernierPStocke]
set ProchainP $OriProchainP
while { ! [OuiOuNon "Do I start oligos numbering with $ProchainP ?"]} {
set ProchainP [Entre $OriProchainP]
if {[regexp -nocase "Test" $ProchainP]} {
set ProchainP "T7701"
set DernierPStocke $ProchainP
}
}
} else {
set ProchainP [NumeroSuivant $DernierPStocke]
}
} else {
set ProchainP $ForceProchainP
}
set DernierPStocke $ProchainP
if {[regexp "^T7" $ProchainP]} { return $ProchainP }
regsub "Pxxxx" $Entete $ProchainP Entete
set TFA [SequenceFormatTFA $Sequence $Entete "nucbrut"]
if {$FichierOli==""} { set FichierOli "[RepertoireDuGenome]/oligos/$ProchainP.tfa" }
return [Sauve $TFA dans $FichierOli]
}
proc FormatageEntete {Entete {PourQui ""} {P ""}} {
JeMeSignale
set BelleEntete $Entete
if {[regexp "sequencing oligo" $Entete]} {
set LesSeqOli {}
foreach E [split $Entete "+"] {
scan $E "%s" SeqOli
if {$LesSeqOli!={}} { regsub {SeqOli(Rac|)_} $SeqOli " " SeqOli }
lappend LesSeqOli $SeqOli
}
if {$P!=""} { set BelleEntete "$P " } else { set BelleEntete "" }
append BelleEntete [join $LesSeqOli " "]
return $BelleEntete
}
if {[regexp "mutation oligo" $Entete]} {
set LesMutOli {}
foreach E [split $Entete "+"] {
scan $E "%s" MutOli
if {$LesMutOli!={}} { regsub {MutOli(Rac|)_} $MutOli " " MutOli }
lappend LesMutOli $MutOli
}
if {$P!=""} { set BelleEntete "$P " } else { set BelleEntete "" }
append BelleEntete [join $LesMutOli " "]
return $BelleEntete
}
if {$PourQui==""} { set PourQui "PourCommande" }
set TM ""
if {[regexp { tm[53]p_[0-9]+} $Entete Match]} { set TM [string trim $Match] }
set LesLis [DecomposeLaLigne $Entete]
Espionne $LesLis
set LesSujets [lindex $LesLis 0]
set LesAvs [lindex $LesLis 1]
set LesAps [lindex $LesLis 2]
set Sujet [join $LesSujets " "]
set SigAv [join $LesAvs "_"]
set SigAp [join $LesAps "_"]
if {[regexp "PourOligo" $PourQui]} {
if {$SigAv!=""} {
if {[regexp "BrocOli" $Entete] && [regexp "PourOligoNonBrocOli" $PourQui]} {
set SigAvNB [StringApres " replaces " dans $Entete]
Espionne $SigAvNB
if {$SigAvNB==""} {
FaireLire "Ca merde avec le BrocOli $Entete"
} else {
set SigAv $SigAvNB
}
}
set BelleEntete "$P 5' oligo with signal $SigAv for $Sujet"
}
if {$SigAp!=""} {
if {[regexp "BrocOli" $Entete] && [regexp "PourOligoNonBrocOli" $PourQui]} {
set SigApNB [StringApres " replaces " dans $Entete]
if {$SigApNB==""} {
FaireLire "Ca merde avec le BrocOli $Entete"
} else {
set SigAp $SigApNB
}
}
set BelleEntete "$P 3' oligo with signal $SigAp for $Sujet"
}
if {$SigAv=="" && $SigAp==""} {
set BelleEntete "$P oligo without signal for $Sujet"
}
if {[regexp "BrocOli" $Entete]} {
if {[regexp "PourOligoNonBrocOli" $PourQui]} {
set CuttedSignal [StringApres "BrocOli with" dans $Entete]
set FullSignal [StringApres " replaces " dans $Entete]
set TexteBrocOli "RebuildedBrockenOli of $CuttedSignal"
} else {
set TexteBrocOli "BrocOli [StringSuivant "BrocOli " dans $Entete] seeFull AfterMe"
}
append BelleEntete " $TexteBrocOli"
}
}
if {$PourQui=="PourCommande"} {
set PremierSujet [lindex $LesSujets 0]
set Racine "trululuturlu"
if {[regexp {^[^\-]+\-} $PremierSujet Match]} { set Racine $Match }
set LesAutresSujets {}
foreach AutreSujet [lrange $LesSujets 1 end] {
regsub $Racine $AutreSujet "" AutreSujet
lappend LesAutresSujets $AutreSujet
}
set AutresSujets "[join $LesAutresSujets " "]"
if {$P!=""} { set BelleEntete "$P " } else { set BelleEntete "" }
set TexteBrocOli ""
if {[regexp "BrocOli" $Entete]} {
set TexteBrocOli " BrocOli [StringSuivant "BrocOli " dans $Entete]"
}
if {$SigAv!=""} {
append BelleEntete "${SigAv}_$PremierSujet $AutresSujets $TexteBrocOli $TM"
}
if {$SigAp!=""} {
append BelleEntete "${PremierSujet}_$SigAp $AutresSujets $TexteBrocOli $TM"
}
if {$SigAv=="" && $SigAp==""} {
append BelleEntete "$PremierSujet $AutresSujets $TexteBrocOli $TM"
}
}
return $BelleEntete
}
proc PofPPCR {{Quoi ""}} {
if {$Quoi==""} { set Quoi "5_3" }
set LesPofPPCR {}
foreach PPCR [lsort -unique [concat [P5ofPPCR "LaListeDesPPCRs"] [P3ofPPCR "LaListeDesPPCRs"]]] {
set P5 " "
set LesP5s [P5ofPPCR $PPCR]
if {$LesP5s!={}} { set P5 [join $LesP5s " "] }
set P3 " "
set LesP3s [P3ofPPCR $PPCR]
if {$LesP3s!={}} { set P3 [join $LesP3s " "] }
if {[regexp "5" $Quoi]} { lappend LesPofPPCR "$P5 $PPCR" }
if {[regexp "3" $Quoi]} { lappend LesPofPPCR "$P3 $PPCR" }
lappend LesPofPPCR ""
}
return $LesPofPPCR
}
proc P5ofPPCR {{PPCR ""} {Val ""}} {
global P5ofPPCR
set FichierP5ofPPCR "[RepertoireDuGenome]/fiches/P5ofPPCR"
if {$PPCR=="Save"} {
unset P5ofPPCR(LaListeDesPPCRs)
unset P5ofPPCR(LaListeDesPs)
unset P5ofPPCR("EstCharge")
SauveLesLignes [array get P5ofPPCR] dans $FichierP5ofPPCR
unset P5ofPPCR
P5ofPPCR Load
return $FichierP5ofPPCR
}
if {$PPCR==""} {
return [list \
"P5ofPPCR \"Sujet === SignauxAvant === SignauxApres\"" \
"P5ofPPCR LaListeDesPPCRs" \
"P5ofPPCR LaListeDesPs"]
}
if {$Val!=""} {
if {[OuiOuNonMemo "Do I load already existing PofPPCR"]} {
P5ofPPCR Load
P3ofPPCR Load
}
set P5ofPPCR("EstCharge") ""
if {[info exists P5ofPPCR($PPCR)] && [set P5ofPPCR($PPCR)]!=$Val} {
#rR FaireLire "P5ofPPCR $PPCR\n already exists it was [set P5ofPPCR($PPCR)] and now $Val"
}
set P5ofPPCR($PPCR) $Val
lappend P5ofPPCR(LaListeDesPPCRs) $PPCR
lappend P5ofPPCR(LaListeDesPs) $Val
set P5ofPPCR(LaListeDesPs) [lsort -unique [set P5ofPPCR(LaListeDesPs)]]
return $Val
}
if {[info exists P5ofPPCR($PPCR)]} { return [set P5ofPPCR($PPCR)] }
if {[info exists P5ofPPCR("EstCharge")]} { return [set P5ofPPCR("EstCharge")] }
Wup "From here we load existing"
if {[info exists P5ofPPCR]} { unset P5ofPPCR }
if { ! [file exists $FichierP5ofPPCR] } { return "NoValueAvalaible" }
array set P5ofPPCR [LesLignesDuFichier $FichierP5ofPPCR]
set LesP {}
set LesPP {}
foreach {PP P} [array get P5ofPPCR] {
lappend LesP $P
lappend LesPP $PP
}
set P5ofPPCR("EstCharge") ""
set P5ofPPCR(LaListeDesPs) [lsort -unique $LesP]
set P5ofPPCR(LaListeDesPPCRs) [lsort -unique $LesPP]
return [P5ofPPCR $PPCR]
}
proc P3ofPPCR {{PPCR ""} {Val ""}} {
global P3ofPPCR
set FichierP3ofPPCR "[RepertoireDuGenome]/fiches/P3ofPPCR"
if {$PPCR=="Save"} {
unset P3ofPPCR(LaListeDesPPCRs)
unset P3ofPPCR(LaListeDesPs)
unset P3ofPPCR("EstCharge")
SauveLesLignes [array get P3ofPPCR] dans $FichierP3ofPPCR
unset P3ofPPCR
P3ofPPCR Load
return $FichierP3ofPPCR
}
if {$PPCR==""} {
return [list \
"P3ofPPCR \"Sujet === SignauxAvant === SignauxApres\"" \
"P3ofPPCR LaListeDesPPCRs" \
"P3ofPPCR LaListeDesPs"]
}
if {$Val!=""} {
if {[OuiOuNonMemo "Do I load already existing PofPPCR"]} {
P5ofPPCR Load
P3ofPPCR Load
}
set P3ofPPCR("EstCharge") ""
if {[info exists P3ofPPCR($PPCR)] && [set P3ofPPCR($PPCR)]!=$Val} {
#rR FaireLire "P3ofPPCR $PPCR\n already exists it was [set P3ofPPCR($PPCR)] and now $Val"
}
set P3ofPPCR($PPCR) $Val
lappend P3ofPPCR(LaListeDesPPCRs) $PPCR
lappend P3ofPPCR(LaListeDesPs) $Val
set P3ofPPCR(LaListeDesPs) [lsort -unique [set P3ofPPCR(LaListeDesPs)]]
return $Val
}
if {[info exists P3ofPPCR($PPCR)]} { return [set P3ofPPCR($PPCR)] }
if {[info exists P3ofPPCR("EstCharge")]} { return [set P3ofPPCR("EstCharge")] }
Wup "From here we load existing"
if {[info exists P3ofPPCR]} { unset P3ofPPCR }
if { ! [file exists $FichierP3ofPPCR] } { return "NoValueAvalaible" }
array set P3ofPPCR [LesLignesDuFichier $FichierP3ofPPCR]
set LesP {}
set LesPP {}
foreach {PP P} [array get P3ofPPCR] {
lappend LesP $P
lappend LesPP $PP
}
set P3ofPPCR("EstCharge") ""
set P3ofPPCR(LaListeDesPs) [lsort -unique $LesP]
set P3ofPPCR(LaListeDesPPCRs) [lsort -unique $LesPP]
return [P3ofPPCR $PPCR]
}
proc OldP3ofPPCR {{PPCR ""} {Val ""}} {
global P3ofPPCR
if {$PPCR==""} {
return [list \
"P3ofPPCR \"Sujet === SignauxAvant === SignauxApres\"" \
"P3ofPPCR LaListeDesPPCRs" \
"P3ofPPCR LaListeDesPs"]
}
if {$Val!=""} {
if {[OuiOuNonMemo "Do I load existing PofPPCR"]} {
P5ofPPCR Load
P3ofPPCR Load
}
set P5ofPPCR("EstCharge") ""
set P3ofPPCR("EstCharge") ""
if {[info exists P3ofPPCR($PPCR)] && [set P3ofPPCR($PPCR)]!=$Val} {
FaireLire "P3ofPPCR $PPCR\n already exists it was [set P3ofPPCR($PPCR)] and now $Val"
}
set P3ofPPCR($PPCR) $Val
return $Val
}
if {$Val!=""} {
if {[OuiOuNonMemo "Do I load existing P3ofPPCR"]} { P3ofPPCR Load }
set P3ofPPCR("EstCharge") ""
lappend P3ofPPCR($PPCR) $Val
return $Val
}
if {[info exists P3ofPPCR($PPCR)]} { return [set P3ofPPCR($PPCR)] }
if {[info exists P3ofPPCR("EstCharge")]} { return [set P3ofPPCR("EstCharge")] }
if {[info exists P3ofPPCR]} { unset P3ofPPCR }
set FichierP3ofPPCR "[RepertoireDuGenome]/fiches/P3ofPPCR"
if { ! [file exists $FichierP3ofPPCR] } { return "NoValueAvalaible" }
array set P3ofPPCR [LesLignesDuFichier $FichierP3ofPPCR]
set LesPPCRs [lsort [array names P3ofPPCR]]
set P3ofPPCR("EstCharge") ""
set P3ofPPCR(LaListeDesPPCRs) $LesPPCRs
set LesP {}
foreach PP $LesPPCRs {
if {[regexp "EstCharge" $PP]} { continue }
lappend LesP [set P3ofPPCR($PP)]
}
set P3ofPPCR(LaListeDesPs) [lsort -unique $LesP]
return [P3ofPPCR $PPCR]
}
proc PofSeq {{Oli ""}} {
global PofSeq
if {$Oli==""} {
return [list \
"PofSeq GR" \
"PofSeq PGS002" \
"PofSeq LaListeDesOligos" \
"PofSeq LaListeDesPs" \
"PofSeq LesPofSeq"]
}
if {[info exists PofSeq($Oli)]} { return [set PofSeq($Oli)] }
if {[info exists PofSeq("EstCharge")] && $Oli!="LesPofSeq"} { return [set PofSeq("EstCharge")] }
if {[info exists PofSeq("EstCharge")] && $Oli=="LesPofSeq"} {
set LeTexte {}
foreach O [array names PofSeq] {
if {[regexp "EstCharge|LaListe" $O]} { continue }
set LesPs [set PofSeq($O)]
lappend LeTexte "[join $LesPs " "] $O"
}
set LeTexte [lsort $LeTexte]
return $LeTexte
}
if {[info exists PofSeq]} { unset PofSeq }
set FichierPofSeq "[RepertoireDuGenome]/fiches/PofSeq"
if { ! [file exists $FichierPofSeq] } {
if { ! [OuiOuNon "Do I create fiches/PofSeq with ./oligos/* ?"]} {
set PofSeq("EstCharge") ""
return "NoValueAvalaible"
}
foreach P [Oli "LaListeMerci"] {
if {[Oli $P Type]!="SeqOli"} { continue }
lappend PofSeq(LaListeDesPs) $P
set Sens [Oli $P "Sens"]
if {$Sens=="5'"} { set FouR "F" } else { set FouR "R" }
set LesSujets [Oli $P "Subjects"]
foreach Sujet $LesSujets {
lappend PofSeq($Sujet-$FouR) $P
lappend PofSeq(LaListeDesOligos-$FouR) $P
if {$Sens=="5'"} {
lappend PofSeq($Sujet) $P
lappend PofSeq(LaListeDesOligos) $P
}
}
}
SauveLesLignes [array get PofSeq] dans $FichierPofSeq
return [PofSeq $Oli]
}
array set PofSeq [LesLignesDuFichier $FichierPofSeq]
set PofSeq("EstCharge") ""
return [PofSeq $Oli]
set LesOlis [lsort [array names PofSeq]]
set PofSeq(LaListeDesOligos) $LesOlis
set LesP {}
foreach O $LesOlis {
lappend LesP [set PofSeq($O)]
}
set PofSeq(LaListeDesPs) [lsort -unique $LesP]
return [PofSeq $Oli]
}
proc PofMut {{Oli ""}} {
global PofMut
if {$Oli==""} {
return [list \
"PofMut GR-M1" \
"PofMut GR-M1-H602R" \
"PofMut PGS002 H602R" \
"PofMut LaListeDesOligos" \
"PofMut LaListeDesPs" \
"PofMut LesPofMut"]
}
if {[info exists PofMut($Oli)]} { return [set PofMut($Oli)] }
if {[info exists PofMut("EstCharge")] && $Oli!="LesPofMut"} { return [set PofMut("EstCharge")] }
if {[info exists PofMut("EstCharge")] && $Oli=="LesPofMut"} {
set LeTexte {}
foreach O [array names PofMut] {
if {[regexp "EstCharge|LaListe" $O]} { continue }
set LesPs [set PofMut($O)]
set P [lindex $LesPs 0]
set LesAutresPs [lrange $LesPs 1 end]
set RefIGBMC [format "%-14s" [OlIgbmc $P]]
set Texte "$P $RefIGBMC [format "%-25s" $O]"
if {$LesAutresPs!={}} { append Texte " with [join $LesAutresPs " "]" }
lappend LeTexte $Texte
}
set LeTexte [lsort $LeTexte]
return $LeTexte
}
if {[info exists PofMut]} { unset PofMut }
set FichierPofMut "[RepertoireDuGenome]/fiches/PofMut"
if { ! [file exists $FichierPofMut] } {
if { ! [OuiOuNon "Do I create fiches/PofMut with ./oligos/* ?"]} {
set PofMut("EstCharge") ""
return "NoValueAvalaible"
}
foreach P [Oli "LaListeMerci"] {
if {[Oli $P Type]!="MutOli"} { continue }
lappend PofMut(LaListeDesPs) $P
set Sens [Oli $P "Sens"]
if {$Sens=="5'"} { set FouR "F" } else { set FouR "R" }
set Code [Oli $P "CodeMutation"]
set LesSujets [Oli $P "Subjects"]
foreach Sujet $LesSujets {
lappend PofMut($Sujet-$FouR) $P
lappend PofMut(LaListeDesOligos-$FouR) $P
set PofMut($Sujet-$Code-$FouR) $P
if {$Sens=="5'"} {
lappend PofMut($Sujet) $P
set PofMut($Sujet-$Code) $P
lappend PofMut(LaListeDesOligos) $P
}
}
}
SauveLesLignes [array get PofMut] dans $FichierPofMut
return [PofMut $Oli]
}
array set PofMut [LesLignesDuFichier $FichierPofMut]
set PofMut("EstCharge") ""
return [PofMut $Oli]
set LesOlis [lsort [array names PofMut]]
set PofMut(LaListeDesOligos) $LesOlis
set LesP {}
foreach O $LesOlis {
lappend LesP [set PofMut($O)]
}
set PofMut(LaListeDesPs) [lsort -unique $LesP]
return [PofMut $Oli]
}
proc PofOl {{Oli ""}} {
global PofOl
if {$Oli==""} {
return [list \
"PofOl \"Sujet === SignalAvant === \"" \
"PofOl \"Sujet === === SignalAPres\"" \
"PofOl P1234" \
"PofOl LaListeDesOligos" \
"PofOl LaListeDesPs" \
"PofOl LesPofOl"]
}
if {[regexp "===$" $Oli]} { append Oli " " }
if {[info exists PofOl($Oli)]} { return [set PofOl($Oli)] }
if {[info exists PofOl("EstCharge")] && $Oli!="LesPofOl"} { return [set PofOl("EstCharge")] }
if {[info exists PofOl("EstCharge")] && $Oli=="LesPofOl"} {
set LeTexte {}
foreach O [PofOl "LaListeDesOligos"] {
if {[regexp "EstCharge|LaListe" $O]} { continue }
set LesPs [set PofOl($O)]
set WarningBrocOli ""
foreach P $LesPs {
if {[Oli $P "IsRebuildedBrockenOli"]} {
set Brocken [Oli $P "Brocken"]
append WarningBrocOli " $P rebuilded BrocOli from $Brocken"
}
}
set Premier [lindex $LesPs 0]
set RefIGBMC [format "%-14s" [OlIgbmc $Premier]]
set Four [string range "[Fournisseur $Premier] " 0 4]
lappend LeTexte "[join $LesPs " "] $Four $RefIGBMC [format "%-50s" $O] $WarningBrocOli"
}
set LeTexte [lsort $LeTexte]
return $LeTexte
}
if {[info exists PofOl]} { unset PofOl }
set FichierPofOl "[RepertoireDuGenome]/fiches/PofOl"
if { ! [file exists $FichierPofOl] } { return "NoValueAvalaible" }
array set PofOl [LesLignesDuFichier $FichierPofOl]
set LesOlis {}
set LesPs {}
foreach N [lsort [array names PofOl]] {
if {[EstUnP $N]} { lappend LesPs $N }
if {[regexp "===" $N]} { lappend LesOlis $N }
}
foreach O $LesOlis {
set SesP [split $PofOl($O) " "]
foreach P $SesP {
if { ! [EstUnP $P]} { continue }
lappend LesP $P
lappend PofOl($P) $O
}
}
set LesPs [lsort -unique $LesP]
set PofOl(LaListeDesPs) $LesP
set PofOl(LaListeDesOligos) $LesOlis
set PofOl("EstCharge") ""
return [PofOl $Oli]
}
proc CreeBBC {{NomDeLaBanque ""} {Specif ""}} {
return [CreeLaBanqueBlastClonage $NomDeLaBanque $Specif]
}
proc CreeLaBanqueBlastClonage {{NomDeLaBanque ""} {Specif ""}} {
if {$NomDeLaBanque==""} { set NomDeLaBanque "All[file tail [RepertoireDuGenome]]" }
set LesTermesSpecifs {}
if {$Specif!=""} {
set LesTermesSpecifs [LesVirtualPPCRsDuPGS $Specif]
lappend LesTermesSpecifs $Specif
}
if {[regexp "/" $NomDeLaBanque]} {
set RepDeLaBanque [file dirname $NomDeLaBanque]
set NomDeLaBanque [file tail $NomDeLaBanque]
} else {
set RepDeLaBanque "[RepertoireDuGenome]/banques"
set NomDeLaBanque [file tail $NomDeLaBanque]
}
set Banque "$RepDeLaBanque/$NomDeLaBanque"
while {[file exists $Banque]} {
if {[OuiOuNon "$Banque already exists. Do I cancel CreeLaBanqueBlastClonage ?"]} { return $Banque }
if {[OuiOuNon "$Banque already exists. Do I replace it ?"]} { break }
}
# set LesGlobs [list "nuctfa/*" "rec1/*" "rec2/*" "ppcr/*" "ppcr_virtuels/*" "oligos/*.tfa" "vecteurs/pDONR/*.tfa" "vecteurs/pDEST/*.tfa"]
set LesGlobs [list "nuctfa/*" "ppcr_virtuels/*" "oligos/*.tfa"]
foreach Glob $LesGlobs {
if {[regexp "^/" $Glob]} {
set FiGlob $Glob
} else {
set FiGlob "[RepertoireDuGenome]/$Glob"
}
foreach FiTFA [glob -nocomplain $FiGlob] {
set Queue [file tail $FiTFA]
if {$Specif!=""} {
set Ok 0
foreach Terme $LesTermesSpecifs {
if {[regexp {^P[0-9]+.tfa$} $Queue] || [regexp $Terme $Queue]} {set Ok 1 ; break}
}
if { ! $Ok } { continue }
}
Espionne "I keep $Queue"
if {[regexp {~$|\.20[0-9]{4,}$} $Queue]} { continue }
if { ! [regexp "^>" [PremiereLigneDuFichier $FiTFA]]} { continue }
Espionne $FiTFA
lappend LeTFA [ContenuDuFichier $FiTFA]
}
}
SauveLesLignes $LeTFA dans $Banque
exec formatdb -i $Banque -p F
return $Banque
}
proc CreeLaBanqueBlastDesVecteurs {{Banque ""} {RepDestination ""} {RepVecteurs ""}} {
if {$Banque==""} { set Banque "AllVectors" }
if {$RepVecteurs==""} { set RepVecteurs "[RepertoireDuGenome]/vecteurs/p*" }
if {$RepDestination==""} { set RepDestination "[RepertoireDuGenome]/banques" }
set FicBanque "$RepDestination/$Banque"
while {[file exists $FicBanque]} {
if {[OuiOuNon "$FicBanque already exists. Do I replace it ?"]} { break }
if {[OuiOuNon "$FicBanque already exists. Do I cancel CreeLaBanqueBlastDesVecteurs ?"]} { return "" }
}
foreach FicTFA [glob -nocomplain "$RepVecteurs/*.tfa"] {
lappend LesTFAs [ContenuDuFichier $FicTFA]
}
SauveLesLignes $LesTFAs dans $FicBanque
NousAllonsAuBoulot $RepDestination
if {[catch {exec formatdb -i $Banque -p F} Message]} {
FaireLire "Error from formatdb :\n$Message"
OnRevientDuBoulot
return ""
}
OnRevientDuBoulot
return $FicBanque
}
proc TriFragments {Page {Maniere ""} {Action ""}} {
if {$Action==""} { set Action "Affiche" }
if {$Maniere==""} { set Maniere "Ask" }
if {$Maniere=="Ask"} {
set Maniere [ChoixParmi [list \
"FillLimitsWith_000" \
"FullLeftRightOnSameLine" \
"1_3_0" \
"0_3_1" \
"0_" \
"1_" \
"2_" \
"3_" \
"Other"]]
}
if {$Maniere=="Other"} { set Maniere [Entre "0_1_2_3_"] }
set LesLignes [split $Page "\n"]
if {$Maniere=="FillLimitsWith_000"} {
foreach Ligne $LesLignes {
if {[regexp -- {^[^_]+_([^ \-_]+\-[0-9]+\-[0-9]+)_} $Ligne Match Sujet]} {
set LesMots [split $Sujet "-"]
ScanLaListe $LesMots N D F
set BeauSujet [format "%s-%4.4d-%4.4d" $N $D $F]
regsub -- "\-" $Sujet "\\\-" SujetRX
regsub $SujetRX $Ligne $BeauSujet Ligne
set DiffLong [expr [string length $BeauSujet]-[string length $Sujet]]
set iB [string first " " $Ligne]
regsub [string repeat " " $DiffLong] $Ligne "" Ligne
}
lappend LesLignesTriees $Ligne
}
} elseif {[regexp {^[0-9]+_[0-9]*} $Maniere]} {
set Maniere [string trim $Maniere "_"]
set LOrdre [split $Maniere "_"]
set LesLignesTriees [LesLignesTrieesSurUneClefEntete $LesLignes $LOrdre]
} elseif {$Maniere=="FullLeftRightOnSameLine"} {
foreach Ligne $LesLignes {
set Entete ""
scan $Ligne "%s %d %d %f %f" Entete Residues Charged Molecularweight Isoelectricpoint
if {$Entete==""} { continue }
regsub "_" $Entete " " ZoNom
scan $ZoNom "%s %s" Zone Nom
if { ! [info exists DejaVu($Nom)]} { lappend LesNoms $Nom }
set DejaVu($Nom) 1
foreach Var [list Entete Residues Charged Molecularweight Isoelectricpoint] {
set P($Nom,$Zone,$Var) [set $Var]
}
}
foreach Nom $LesNoms {
set ZoNom [string range "All_$Nom" 0 36]
set ChargedF [set P($Nom,Full,Charged)]
set ChargedL [set P($Nom,Left,Charged)]
set ChargedR [set P($Nom,Righ,Charged)]
set MolecularweightF [set P($Nom,Full,Molecularweight)]
set MolecularweightL [set P($Nom,Left,Molecularweight)]
set MolecularweightR [set P($Nom,Righ,Molecularweight)]
set IsoelectricpointF [set P($Nom,Full,Isoelectricpoint)]
set IsoelectricpointL [set P($Nom,Left,Isoelectricpoint)]
set IsoelectricpointR [set P($Nom,Righ,Isoelectricpoint)]
lappend LesLignesTriees [format "%-40.40s %3d %3d %3d %10.2f %10.2f %10.2f %5.2f %5.2f %5.2f" \
$ZoNom \
$ChargedF $ChargedL $ChargedR \
$MolecularweightF $MolecularweightL $MolecularweightR \
$IsoelectricpointF $IsoelectricpointL $IsoelectricpointR ]
}
} else {
return $Page
}
set BellePage [join $LesLignesTriees "\n"]
if {$Action=="Retour"} { return $BellePage }
return [AfficheVariable $BellePage "AvecTriFragments"]
}
proc AliasPourClonage Nom {
global AliasPourClonage
if {[info exists AliasPourClonage($Nom)]} { return [set AliasPourClonage($Nom)] }
set Alias ""
if {$Alias==""} { set Alias [Alias $Nom] }
if {$Alias==""} { set Alias [Narcisse $Nom] }
if {$Alias==""} { set Alias $Nom }
set AliasPourClonage($Nom) $Alias
return $Alias
}
proc CreeLesFichiersExtension5PrimeDeRec2 Rec2 {
set Rec2 [file tail $Rec2]
regsub ".tfa$" $Rec2 "" Rec2
set Titre "Fus_$Rec2"
set Fusion "Fus_$Rec2"
set FiFuN "[RepertoireDuGenome]/fusion/$Fusion.nuctfa"
set FiFuP "[RepertoireDuGenome]/fusion/$Fusion.prottfa"
set Keep 1
if {$Keep && [FileExists $FiFuP]} { return "$FiFuN $FiFuP" }
set NucFusion [NucExtension5PrimeDeRec2 $Rec2]
if {$NucFusion==""} {
FaireLire "NucExtension5PrimeDeRec2 $Rec2\nis empty."
return ""
}
set NucTFA [SequenceFormatTFA $NucFusion "$Titre" "nucbrut"]
Espionne [Sauve $NucTFA dans $FiFuN]
set ProtFusion [SeqNucToSeqPro $NucFusion]
set ProtTFA [SequenceFormatTFA $ProtFusion "$Titre" "protbrut"]
Espionne [Sauve $ProtTFA dans $FiFuP]
return "$FiFuN $FiFuP"
}
proc LesLignesTrieesSurUneClefEntete {LesLignes LesIndices} {
if {$LesIndices=={}} { return $LesLignes }
set Indice [lindex $LesIndices 0]
set Car "_"
set LesLignesTriees {}
set LesClefs {}
foreach Ligne $LesLignes {
set Entete ""
scan $Ligne "%s" Entete
if {$Entete==""} { continue }
set LesMots [split $Entete $Car]
set Clef [lindex $LesMots $Indice]
lappend LesLignesPour($Clef) $Ligne
lappend LesClefs $Clef
}
foreach Clef [lsort -unique $LesClefs] {
set LesLignes [set LesLignesPour($Clef)]
foreach Ligne $LesLignes {
lappend LesLignesTriees $Ligne
}
}
return [LesLignesTrieesSurUneClefEntete $LesLignesTriees [lrange $LesIndices 1 end]]
}
proc PeptideSortPourLesFusionsPourCertains {} {
FaireLire "Please select some fusions.\nI'll proceed step by step (Nxxxx)\n\
But First choose ONE cutting site."
set ChoixCoupure [ChoixDUnSiteDeCoupure]
if {$ChoixCoupure==""} { return {} }
set LesFiFu [glob -nocomplain "[RepertoireDuGenome]/fusion/*.nuctfa"]
set LesFiFu [lsort [ChoixDesPresents $LesFiFu]]
if {$LesFiFu=={}} { return {} }
set LaCharrette {}
set OldN "Trululu"
lappend LesFiFu "ThatsAllFolks"
set LesReports {}
foreach FiFu $LesFiFu {
if { ! [regexp {/Fus_N[0-9]+_} $FiFu N]} {
if {$FiFu != "ThatsAllFolks"} {
FaireLire "the file name \n$FiFu\n is not as I expected. I'll skip"
continue
}
set N "ThatsAllFolks"
}
if {$OldN=="Trululu" || $N==$OldN} {
lappend LaCharrette $FiFu
set OldN $N
continue
}
if {$N!=$OldN} {
set R [AffichePeptideSortPourLesFusions $LaCharrette $ChoixCoupure "SansAffichage"]
set LaCharrette {}
lappend LesReports $R
Espionne $R
}
set OldN $N
}
return $LesReports
}
proc AffichePeptideSortPourLesFusions {{LesFiFu ""} {ChoixPourCoupure ""} {AvecAffichage ""}} {
if {$AvecAffichage=="SansAffichage"} { set AvecAffichage 0 } else { set AvecAffichage 1 }
if {$LesFiFu==""} {
set LesFiFu [glob -nocomplain "[RepertoireDuGenome]/fusion/*.nuctfa"]
set LesFiFu [ChoixDesPresents $LesFiFu]
}
if {$LesFiFu=="AllFusion"} {
set LesFiFu [glob -nocomplain "[RepertoireDuGenome]/fusion/*.nuctfa"]
}
if {$LesFiFu==""} { return "" }
if {[llength [split $ChoixPourCoupure " "]]==5} {
set ChoixCoupure $ChoixPourCoupure
} else {
set ChoixCoupure [ChoixDUnSiteDeCoupure $ChoixPourCoupure]
}
set LongCoupP ""
scan $ChoixCoupure "%s %s %d %s %d" Coupure CoupN LongCoupN CoupP LongCoupP
# if {$LongCoupP==""} { return {} }
foreach FiFu $LesFiFu {
set Nom [file tail $FiFu]
regsub ".nuctfa" $Nom "" Nom
regsub ".prottfa" $FiFu ".nuctfa" FiFuN
lappend LesNoms $Nom
set SeqN [QueLaSequenceDuTFA $FiFuN]
set SeqP [SeqNucToSeqPro $SeqN]
set Zone(Seq) "Full"
set LesVariablesSeq [list "Seq"]
if {$Coupure!="SansCoupure"} {
set iDebutCoupure [string first $CoupN [string toupper $SeqN]]
set lastDebutCoupure [string last $CoupN [string toupper $SeqN]]
if {$iDebutCoupure!=$lastDebutCoupure} {
FaireLire "At least two sites for $Coupure are possible. \nI'll take the first one : $iDebutCoupure"
}
if {$iDebutCoupure>=0} {
set GaucheSeqN [string range $SeqN 0 [expr $iDebutCoupure+$LongCoupN-1]]
set DroiteSeqN [string range $SeqN [expr $iDebutCoupure+$LongCoupN] end]
}
set GaucheSeqP [SeqNucToSeqPro $GaucheSeqN]
set DroiteSeqP [SeqNucToSeqPro $DroiteSeqN]
lappend LesVariablesSeq "GaucheSeq" "DroiteSeq"
set Zone(GaucheSeq) "Left"
set Zone(DroiteSeq) "Righ"
}
foreach VariableSeq $LesVariablesSeq {
set CR [CodonsRares [set [set VariableSeq]N] "AvecBlanc"]
set PepSort [PeptideSort [set [set VariableSeq]P]]
if {[info exists TPep]} { unset TPep }
DecortiquePeptideSort $PepSort "" TPep
set Residues [set TPep(Residues)]
set Molecularweight [set TPep(Molecularweight)]
set Charged [set TPep(Charged)]
set Isoelectricpoint [set TPep(Isoelectricpoint)]
set SeqCompressee ""
append SeqCompressee [string range [set [set VariableSeq]P] 0 5]
append SeqCompressee "..."
append SeqCompressee [string range [set [set VariableSeq]P] end-5 end]
set ZoNom [string range "[set Zone($VariableSeq)]_$Nom" 0 36]
lappend LesFragments [format "%-40.40s %4d %3d %10.2f %5.2f %s %s" \
$ZoNom \
$Residues $Charged \
$Molecularweight $Isoelectricpoint \
$SeqCompressee \
$CR ]
}
}
set LesFragments [LesLignesTrieesSurUneClefEntete $LesFragments [list 0 3 1]]
if {$AvecAffichage} {
FaireLire "I'll show you the report. Please don't forget to save it."
AfficheVariable [join $LesFragments "\n"] "AvecTriFragments" PeptideSortSurFusion
} else {
set LesNR1 {}
foreach Nom $LesNoms {
regsub {_[^_]+$} $Nom "" NR1
lappend LesNR1 $NR1
}
set NomFusRep [join [lsort -unique $LesNR1] "-"]
set FichierReport "[RepertoireDuGenome]/fusionreport/${NomFusRep}_[Date].txt"
return [SauveLesLignes $LesFragments dans $FichierReport]
}
return $LesFragments
}
proc PpcrEnStock {FiPpcr {Quoi ""}} {
if { ! [regexp "/" $FiPpcr]} { set FiPpcr "[RepertoireDuGenome]/ppcr/$FiPpcr" }
if { ! [file exists $FiPpcr]} { regsub ".tfa$" $FiPpcr "" FiPpcr }
if { ! [file exists $FiPpcr]} { append FiPpcr ".tfa"}
if { ! [file exists $FiPpcr]} { return "" }
if {$Quoi==""} { set Quoi "TFA" }
if {$Quoi=="TFA"} { return [ContenuDuFichier $FiPpcr] }
set Entete [EnteteDuFichierTFA $FiPpcr "access"]
if {$Quoi=="Header"} { return $Entete }
regsub -nocase "^ProduitPcr_" $Entete "" Entete
set LSAvAp [DecomposeLaLigne $Entete]
Espionne $LSAvAp
set Sujet [lindex $LSAvAp 0]
set LesAv [lindex $LSAvAp 1]
set LesAp [lindex $LSAvAp 2]
if {$Quoi=="Sujet"} { return $Sujet }
if {$Quoi=="Signals5"} { return $LesAv }
if {$Quoi=="Signals3"} { return $LesAp }
set Seq [QueLaSequenceDuFichierTFA $FiPpcr]
set SeqAv {}
foreach Sign $LesAv {
lappend SeqAv [string totitle [Signal $Sign]]
}
set SeqAv [join $SeqAv ""]
if {$Quoi=="SeqSignals5"} { return $SeqAv }
set SeqAp {}
foreach Sign $LesAp {
lappend SeqAp [string totitle [Signal $Sign]]
}
set SeqAp [join $SeqAp ""]
if {$Quoi=="SeqSignals3"} { return $SeqAp }
set SeqSujet $Seq
regsub -nocase "^$SeqAv" $SeqSujet "" SeqSujet
regsub -nocase "$SeqAp$" $SeqSujet "" SeqSujet
if {$Quoi=="SeqSubject"} { return $SeqSujet }
}
proc TestNucExtension5PrimeDeRec2 FiRec2 {
set TFA [SequenceFormatTFA [NucExtension5PrimeDeRec2 $FiRec2] "fusion" "nucbrut"]
Espionne [Sauve $TFA dans "testfusion.tfa"]
}
proc NucExtension5PrimeDeRec2 {Rec2} {
set Rec2 [file tail $Rec2]
regsub ".tfa$" $Rec2 "" Rec2
if {$Rec2!=[EnteteDuFichierTFA [Rec2 $Rec2 Fichier] "access"]} {
FaireLire "$Rec2 is not in my rec2 database !"
return ""
}
set NucTotal [Rec2 $Rec2 "Sequence"]
set Rec1 [Rec2 $Rec2 "R1"]
if {$Rec1!=""} {
set N [Rec1 $Rec1 "N"]
set NucSujet [VirtualPPCREnStock $N SeqSubject]
} else {
set Entete [EnteteDuFichierTFA $FiRec2]
scan $Entete "%s" Entete
set LesMots [split $Entete "_"]
Espionne $LesMots
foreach Mot $LesMots {
if {[EstUnSignal $Mot]} { continue }
if {$Mot=="Rec2"} { continue }
set Sujet $Mot
break
}
set NucSujet [PPCREnStock $Sujet "SeqSubject"]
}
if {$NucSujet==""} { return "" }
set NucExtension5Prime [NucExtension5Prime $NucTotal $NucSujet]
return $NucExtension5Prime
}
proc CoOlPourTous {{Action ""}} {
if {$Action==""} {
set Action [ChoixParmi [list "Show" "RecalculateAndShow" \
"RecalculateAndReturnPofOl" "ReturnPofOl"\
"RecalculateAndReturnPofPPCR" "ReturnPofPPCR"\
"RecalculateAndReturnCoOl" "ReturnCoOl"]]
}
if { [regexp "Recalculate" $Action] } {
set FichierLesPsRejetes "[Fiches]/LesPsRejetes"
if {[OuiOuNon "Do I run MiseAJourDesPDesExistings ?"]} {
MiseAJourDesPDesExist|ings
}
if {[OuiOuNon "Do I run PositionSurMatricePourTous ?"]} {
PositionSurMatricesPourTous
}
InventaireDesFichiersClonage
set LesPs {}
while {$LesPs=={}} {
if {[OuiOuNon "Do you want to enter a list of Oligos"]} {
set LesPs [Entre "P2639 P2643"]
continue
}
if {1 || [OuiOuNon "Do I use Oli to list existing oligos (instead of CloDo) ?"]} {
set LesPs [Oli LaListeMerci]
} else {
set LesPs [CloDo ListAllPlease oligos]
}
}
set CreePofPPCR [OuiOuNon "Do I recalculate all PofPPCR ?"]
if {$CreePofPPCR} {
set CreeVirtualPPCR 0
FaireLire "Please notate that you have to rerun CoOlPourTous to create the VirtualPPCRs"
} else {
set CreeVirtualPPCR [OuiOuNon "Do I create VirtualPPCRs ?"]
}
foreach P $LesPs {
Espionne $P
set TypeOli [Oli $P Type]
if {$TypeOli!="SynOli"} { continue }
set PSujets [Oli $P Subjects]
set PSignals [Oli $P Signals]
regsub -all "_" $PSignals " " PSigs
set PSens [Oli $P Sens]
if {$PSens=="5'"} {
set POliSignals " === $PSigs === "
} else {
set POliSignals " === === $PSigs"
}
foreach Ma [MatOl $P Matrice] \
AA [MatOl $P AA] \
NA [MatOl $P NA] \
Or [MatOl $P Orient] \
Su [MatOl $P Subjects] {
Espionne "$P $AA $NA $Or $Su =$Ma="
if {0 && [Oli $P "IsRebuildedBrockenOli"]} {
set Brocken [Oli $P "Brocken"]
set Ma [MatOl $Brocken Subjects]
}
set PGS [file tail $Ma]
set CoOl "[string repeat x 50]\n$P"
if {$TypeOli=="MutOli"} {
set Code [Oli $P "CodeMutation"]
append CoOl "\n $Or oligo to mutate $Code in $PGS [Alias $PGS] at $AA $NA and for $Su"
lappend LeTexte "$CoOl"
continue
}
if {[Oli $P "IsBrocOli"]} {
set Full [Oli $P "Full"]
append CoOl "\n $Or BrocOli for Full $Full for $PGS [Alias $PGS]"
lappend LeTexte "$CoOl"
continue
}
if {$PGS==""} { continue }
BaClonAppend LesOligos $PGS $P
set LesSujets [split $Su " "]
append CoOl [format " %5d %5d %s %s %s %s" $AA $NA $Or $PGS [Alias $PGS] $Su]
if {$Or=="F"} { set Sens "5'" } else { set Sens "3'" }
set AliasDuPGS [Alias $PGS]
foreach Sujet $LesSujets {
regsub {\-[0-9]+\-[0-9]+$} $Sujet "" AliasDuSujet
if { ! [MemeAlias $AliasDuSujet $AliasDuPGS]} {
AppendAuFichier $FichierLesPsRejetes "$P $PGS $AliasDuPGS $AliasDuSujet $Sujet"
continue
}
set LesSigPourPPCRPossibles {}
BaClonAppend LesSujets $PGS $Sujet
BaClonSet LesSujets $PGS [lsort -unique [BaClon LesSujets $PGS]]
BaClonAppend LesOligosDuCouple $PGS $Sujet $P
BaClonSet Trio $PGS $Sujet $P $AA
append CoOl "\n\n $Sujet"
set LesOlis [ItsOligos $Sujet]
if {$LesOlis==""} {
Espionne "KO car $Sujet$POliSignals\nnot in \n$LesOlis"
append CoOl "\n ooooo no oligo found"
} else {
set OK 0
foreach Oli $LesOlis {
Espionne "Oli $Oli"
if { ! [string equal "$Sujet$POliSignals" $Oli]} { continue }
append CoOl "\n $Oli"
set OK 1
regsub "=== ===" $POliSignals "===" SigPourPPCR
if { ! [regexp {=== *$} $SigPourPPCR]} { append SigPourPPCR " ===" }
lappend LesSigPourPPCRPossibles $SigPourPPCR
lappend PofOl($Oli) $P
append CoOl "\n PofOl : [join [set PofOl($Oli)] " "]"
}
if { ! $OK } {
Espionne "KO car $Sujet$POliSignals\nnot in \n$LesOlis"
append CoOl "\n ooooo no corresponding signal found"
}
}
set LesPPCR [ItsPPCR $Sujet]
if {$LesPPCR==""} {
append CoOl "\n ppppp no ppcr found"
} else {
set OK 0
foreach PPCR $LesPPCR {
regsub -all {\+} $PPCR "=" xPPCR
if { ! [regexp {=== *$} $xPPCR]} { append xPPCR " ===" }
foreach SigPourPPCR $LesSigPourPPCRPossibles {
if { ! [regexp $SigPourPPCR $xPPCR]} { continue }
append CoOl "\n $PPCR"
set OK 1
if {$CreePofPPCR} {
if {$Sens=="5'"} {
P5ofPPCR $PPCR $P
} else {
P3ofPPCR $PPCR $P
}
}
}
if {[P5ofPPCR $PPCR]!={} && [P5ofPPCR $PPCR]!="NoValueAvailable"} {
append CoOl "\n P5ofPPCR : [join [P5ofPPCR $PPCR] " "]"
}
if {[P3ofPPCR $PPCR]!={} && [P3ofPPCR $PPCR]!="NoValueAvailable"} {
append CoOl "\n P3ofPPCR : [join [P3ofPPCR $PPCR] " "]"
}
if { [P5ofPPCR $PPCR]!={} && [P5ofPPCR $PPCR]!="NoValueAvailable" && \
[P3ofPPCR $PPCR]!={} && [P3ofPPCR $PPCR]!="NoValueAvailable"} {
if {$CreeVirtualPPCR} {
NewVirtualPPCR $PPCR $PGS $Sujet
}
}
}
if { ! $OK } { append CoOl "\n ppppp no corresponding oligo found" }
}
}
lappend LeTexte $CoOl
}
}
set LesPofOl {}
foreach Oli [lsort [array names PofOl]] {
set LesPs [lsort -unique [set PofOl($Oli)]]
set PofOl($Oli) $LesPs
lappend LesPofOl "[join $LesPs " "] $Oli"
}
set LesPofOl [lsort $LesPofOl]
if {[OuiOuNon "Do I save PofOl ?"]} {
SauveLesLignes [array get PofOl] dans "[RepertoireDuGenome]/fiches/PofOl"
}
set LesPofPPCR {}
foreach PPCR [lsort -unique [concat [P5ofPPCR LaListeDesPPCRs] [P3ofPPCR LaListeDesPPCRs]]] {
if {[P5ofPPCR $PPCR]!=""} {
set LesP5s [lsort -unique [P5ofPPCR $PPCR]]
P5ofPPCR $PPCR $LesP5s
set P5 [join $LesP5s " "]
} else {
set P5 " "
}
if {[P3ofPPCR $PPCR]!=""} {
set LesP3s [lsort -unique [P3ofPPCR $PPCR]]
P3ofPPCR $PPCR $LesP3s
set P3 [join $LesP3s " "]
} else {
set P3 " "
}
lappend LesPofPPCR "$P5 $PPCR"
lappend LesPofPPCR "$P3 $PPCR"
lappend LesPofPPCR ""
}
if {$CreePofPPCR} {
P5ofPPCR Save
P3ofPPCR Save
}
if {[OuiOuNon "Do I save BaClon ?"]} { BaClon Save }
if { ! $CreeVirtualPPCR} {
FaireLire "Don't forget to rerun CoOlPourTous to create the VirtualPPCRs"
}
}
if {[regexp "Show" $Action]} {
if { ! [info exists LesPofOl]} {
set LesPofOl [PofOl "LesPofOl"]
}
set FO [AfficheVariable [join $LesPofOl "\n"] "AvecOliAvecFiOl" "PofOligos"]
if { ! [info exists LesPofPPCR]} {
set LesPofPPCR [PofPPCR]
}
set FP [AfficheVariable [join $LesPofPPCR "\n"] "AvecOliAvecFiPPCR" "PofPPCR"]
if { ! [info exists LeTexte]} {
set LeTexte {}
foreach PGS [ListeDesPABs] {
if {[BaClon LesSujets $PGS]==""} {
lappend LeTexte "$PGS no subjects nor oligos"
continue
}
set LesSujets [BaClon LesSujets $PGS]
lappend LeTexte "$PGS [Alias $PGS] concerns [llength $LesSujets] subjects"
foreach Sujet $LesSujets {
lappend LeTexte " $Sujet"
foreach P [BaClon LesOligosDuCouple $PGS $Sujet] {
set AA [BaClon Trio $PGS $Sujet $P]
lappend LeTexte " $P [format "%4d" $AA] [Oli $P Description]"
}
}
}
}
set FC [AfficheVariable [join $LeTexte "\n"] \
"AvecOliAvecShowItsOligosAvecFiOlAvecShowItsPPCRAvecFiPPCRAvecShowItsPPCR" \
CoOlPourTous]
return [list $FO $FP $FC]
}
return
}
proc CreeLeTFADesEnzymesDeRestriction Fichier {
regsub ".txt$" $Fichier ".tfa" FicEnz
set FicEnz [FichierPourSaveAs $FicEnz]
if {$FicEnz==""} { return "" }
foreach Ligne [LesLignesDuFichier $Fichier] {
set Enz ""
set Seq ""
scan $Ligne "%s %s" Enz Seq
if {$Enz=="" || $Seq==""} { continue }
lappend LesEnz ">$Enz .."
lappend LesEnz "$Seq"
lappend LesEnz ""
}
return [SauveLesLignes $LesEnz dans $FicEnz]
}
proc BlastNDeLOligoPourTous {{Banque ""}} {
set SaveOlIgbmc 0
set LesPs [Oli "LaListeMerci"]
foreach P $LesPs {
set Seq [Oli $P "Seq"]
set FB [BlastNDeLOligo $P $Banque]
Espionne "$P $FB"
set Fournis [Fournisseur $P]
set MaxEssais 3
foreach Ligne [LesLignesDuFichier $FB] {
if {[regexp "^>" $Ligne] || [regexp "no hits found" $Ligne]} { break }
if {[regexp {^OLIGO\:} $Ligne]} {
if { ! [incr MaxEssais -1]} { break }
scan $Ligne "%s" BanqueId
set LEmbl [LaSequenceDesBanques $BanqueId $BanqueId AccessOK "OnVeutEMBL"]
set NomDansOLIGO [StringApres ":" dans $BanqueId]
set TFA [SequenceFormatTFA [join $LEmbl "\n"] $BanqueId "embl"]
set SeqCible [QueLaSequenceDuTexteTFA $TFA]
set NouvelleInfo "IGBMC detected_through_a_blastn_in_OLIGO $FB"
if {[string equal -nocase $Seq $SeqCible]} {
if {$Fournis=="" || $Fournis=="IGBMC"} {
set NouveauFournis $NouvelleInfo
} elseif { ! [regexp $NouvelleInfo $Fournis]} {
set NouveauFournis "$Fournis $NouvelleInfo"
}
Fournisseur $P $NouveauFournis
set SaveOlIgbmc 1
OlIgbmc $P $BanqueId
break
}
continue
}
}
}
if {$SaveOlIgbmc} { OlIgbmc Save }
return
}
proc BlastNDeLOligo {P {Banque ""}} {
if {$Banque==""} {
set NomBanque "All[file tail [RepertoireDuGenome]]"
set Banque "[RepertoireDuGenome]/banques/$NomBanque"
} else {
set NomBanque [file tail $Banque]
}
set FicQuery [FiSeqOl $P]
if { ! [file exists $FicQuery]} { return "" }
set RepBlast "[RepertoireDuGenome]/blastn$NomBanque"
if { ! [file exists $RepBlast]} { File mkdir $RepBlast }
set Keep [OuiOuNonMemo "Do I keep existing files in $RepBlast"]
set FichierBlast "$RepBlast/$P"
if {$Keep && [file exists $FichierBlast]} { return $FichierBlast }
if {[catch {exec blastall -p blastn -d $Banque -i $FicQuery -F F -o "$FichierBlast.encours"} Message] } {
Warne "Error during blastall for $P . I got message :\n$Message"
}
if { ! [file exists "$FichierBlast.encours"]} { return "" }
File rename -force "$FichierBlast.encours" "$FichierBlast"
return $FichierBlast
}
proc DepartSequencage {{LesFichiersRec1 ""} {Quoi ""}} {
if {$LesFichiersRec1==""} {
FaireLire "Please select the rec1 files You want to send to the Sequencing Service"
set LesFichiersRec1 [LesFichiersDeType "Rec1"]
}
set RepDepartSequencage "[RepertoireDuGenome]/departsequencage"
if { ! [file exists $RepDepartSequencage]} { File mkdir $RepDepartSequencage }
set FichierNDSFic "$RepDepartSequencage/nds_fichier"
if {$LesFichiersRec1=="GetAll" && $Quoi=="Lines"} {
if {[file exists $FichierNDSFic]} {
return [LesLignesDuFichier $FichierNDSFic]
} else {
return {}
}
}
set DernierNDS "NDS10000"
if {[file exists $FichierNDSFic]} {
foreach Ligne [LesLignesDuFichier $FichierNDSFic] {
scan $Ligne "%s %s" NDS Fichier
set FichierDepartSequencage($NDS) $Fichier
lappend NumeroDepartSequencage($Fichier) $NDS
set DernierNDS $NDS
}
}
if {$LesFichiersRec1=="GetAll" && $Quoi=="Files"} {
return [lsort [array names NumeroDepartSequencage]]
}
if {$LesFichiersRec1=="GetAll" && $Quoi=="NDS"} {
return [lsort [array names FichierDepartSequencage]]
}
if {$LesFichiersRec1=="GetLast" && $Quoi=="NDS"} {
return [lindex [lsort [array names FichierDepartSequencage]] end]
}
if {$LesFichiersRec1=="GetNdsOf"} {
if {[info exists NumeroDepartSequencage($Quoi)]} {
return [set NumeroDepartSequencage($Quoi)]
} else {
return ""
}
}
if {$LesFichiersRec1=="GetFilesOf" || $LesFichiersRec1=="GetFileOf"} {
if {[info exists FichierDepartSequencage($Quoi)]} {
return [set FichierDepartSequencage($Quoi)]
} else {
return ""
}
}
regsub "NDS" $DernierNDS "" NumDernier
set LesNouveaux {}
foreach Fichier $LesFichiersRec1 {
set DernierNDS [format "NDS%5.5d" [incr NumDernier]]
lappend LesNouveaux "$DernierNDS $Fichier"
}
while 1 {
set Texte "\n\n Please Validate /All or //No \n\n"
append Texte [join $LesNouveaux "\n"]
append Texte "\n\n Please Validate /All or //No"
set OK [AfficheVariable $Texte "AvecRetour" "New_Departure_to_Sequencing_Service"]
if {$OK!=""} { break }
if {[OuiOuNon "Do I cancel Departure to Sequencing Service ?"]} { return {} }
}
foreach Ligne $LesNouveaux {
scan $Ligne "%s %s" NDS Fichier
set FichierDepartSequencage($NDS) $Fichier
lappend NumeroDepartSequencage($Fichier) $NDS
}
set LesToutLeMonde {}
foreach NDS [lsort [array names FichierDepartSequencage]] {
lappend LesToutLeMonde "$NDS [set FichierDepartSequencage($NDS)]"
}
SauveLesLignes $LesToutLeMonde dans $FichierNDSFic
return $LesNouveaux
}
proc GenereFragments {{Comment ""} {Fichier ""} {PAB ""} {FichierTFAs ""}} {
while {$Comment==""} {
if {[OuiOuNon "Do You want to used an already created fragment file ?"]} {
set Fichier [ButineArborescence "All" $Fichier]
if {$Fichier!=""} {
set Comment "FromExisting"
break
}
}
if {[OuiOuNon "Do You have a file with predefined fragments ?\n\
... containing lines as follow : \nPGS048 2 234\nPGS048 56 234\nPGS050 1 565"]} {
set Comment "Predefinis"
break
}
if {[OuiOuNon "Do You have a file with limits for one sequence ?\n\
... containing lines as follow : \n1\n24\n55\n777"]} {
set Comment "AvecLimites"
break
}
if {[OuiOuNon "Do You want to give the limits ?"]} {
set Fichier "AskForLimits"
set Comment "AvecLimites"
break
}
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
set LeTFAs {}
set LesFicN {}
set LesFicP {}
if {$Comment=="Predefinis"} {
while {$Fichier==""} {
FaireLire "Please browse for the file containing the fragment limits (PGS Start End(must be +1) Alias)."
set Fichier [ButineArborescence "All" "."]
if {$Fichier=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
}
FaireLire "Please choose the directory to store the all isolate files (nuctfa and prottfa)"
set Rep [tk_chooseDirectory -mustexist 1 -initialdir "."]
set LesNomDuAlias {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase {[a-z0-9]} $Ligne]} { continue }
set Frag ""
set Alias ""
set AliasBis ""
scan $Ligne "%s %s %s %s %s" PAB Debut Fin Alias AliasBis
Espionne "PAB $PAB Debut $Debut Fin $Fin Alias $Alias AliasBis $AliasBis"
if { ! [regexp {^b?[0-9]+$} $Debut]} {
set Frag $Debut
set Debut $Fin
set Fin $Alias
set Alias $AliasBis
}
if {$Alias==""} { set Alias [AliasPourClonage $PAB] }
if {$Fin=="end"} {
set FicN "[RepertoireDuGenome]/nuctfa/$PAB"
set SeqN [QueLaSequenceDuFichierTFA $FicN]
set L [string length $SeqN]
set CodonEnd [string range $SeqN end-2 end]
if {[CodonStopPossible $CodonEnd]} {
set Fin [expr $L-3]
} else {
set Fin $L
}
set Fin [expr $Fin/3]
}
regexp {^([^_])+} $Alias NomDuAlias
if { ! [info exists DejaVu($NomDuAlias)]} { lappend LesNomDuAlias $NomDuAlias }
set DejaVu($NomDuAlias) 1
Espionne "$PAB $Frag $Debut $Fin $Alias"
set LesSequencesNP [IsoleUnDomaine $PAB $Debut $Fin "RetournerSeqNucAndSeqPro"]
ScanLaListe $LesSequencesNP SeqN SeqP
set FicN "$Rep/$Alias-$Debut-$Fin.nuctfa"
set FicP "$Rep/$Alias-$Debut-$Fin.prottfa"
set EnteteN "$Alias-$Debut-$Fin [string length $SeqN] bases"
set EnteteP "$Alias-$Debut-$Fin [string length $SeqP] AAs"
set TfaN [SequenceFormatTFA $SeqN $EnteteN "nucbrut"]
lappend LeTFAs $TfaN
lappend LesFicN [Sauve $TfaN dans $FicN]
if { ! [regexp "b" $Debut] && ! [regexp "b" $Fin] } {
set TfaP [SequenceFormatTFA $SeqP $EnteteP "protbrut"]
lappend LesFicP [Sauve $TfaP dans $FicP]
}
}
} elseif {$Comment=="AvecLimites" || $Comment=="FromExisting"} {
set LesFragments {}
if {$Comment=="FromExisting"} {
set LesFragments [LesLignesDuFichier $Fichier]
}
if {$LesFragments=={} } {
if {$Fichier=="" && [OuiOuNon "can You browse for a file with limits ?"]} {
set Fichier [ButineArborescence "All" "./"]
}
if {$Fichier=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
while {$PAB==""} {
FaireLire "Please enter a [PreFixe] number"
set PAB [Entre [PreFixe]]
set FichierTfa "[RepertoireDuGenome]/nuctfa/$PAB"
if {[file exists $FichierTfa]} { break }
if {[OuiOuNon "$FichierTfa\doesn't exists.\nDo I cancel ?"]} { return "" }
set PAB ""
}
if {$Fichier=="AskForLimits"} {
set Bornes ""
while {$Bornes==""} {
set SeqN [QueLaSequenceDuFichierTFA $FichierTfa]
set Start [string range $SeqN 0 2]
set Stop [string range $SeqN end-2 end]
set AvantStop [string range $SeqN end-2 end]
set Commentaire "($Start ... $Stop [AAduCodon $Start] [AAduCodon $Stop]) Please give the end position + 1"
set D 1
set F [string length $SeqN]
set Dp [expr ($D-1)/3+1]
set Fp [expr ($F-3)/3+1]
set Bornes [Entre "$Dp $Fp $Commentaire"]
if {$Bornes=="" && [OuiOuNon "Do I cancel ?"]} { return "" }
}
regsub { *\(.*$} $Bornes "" Bornes
Espionne $Bornes
while {[regexp " " $Bornes]} { regsub -all " " $Bornes " " Bornes }
set LesBornesDesFragments [split [string trim $Bornes] " "]
} else {
set LesBornesDesFragments [LesLignesDuFichier $Fichier]
}
set LesFragments {}
while {$LesFragments=={}} {
set LesFragments [CombineLesFragments $PAB $LesBornesDesFragments]
if {$LesFragments=={} && [OuiOuNon "Do I cancel GenereFragments ? "]} { return "" }
}
if {[OuiOuNon "Do I save these fragments in a file ?"]} {
set FicFrags [FichierPourSaveAs "./[Alias $PAB].frag"]
if {$FicFrags==""} { return "" }
SauveLesLignes $LesFragments dans $FicFrags
}
}
FaireLire "Please choose the directory to store the isolate files (nuctfa and prottfa)"
set Rep [tk_chooseDirectory -mustexist 1 -initialdir "."]
set LesNomDuAlias {}
foreach Fragment $LesFragments {
scan $Fragment "%s %s %s %s" PAB Frag Debut Fin
Espionne "$PAB $Frag $Debut $Fin"
set Alias [AliasPourClonage $PAB]
set NomDuAlias ""
regexp {^([^_])+} $Alias NomDuAlias
if { ! [info exists DejaVu($NomDuAlias)]} { lappend LesNomDuAlias $NomDuAlias }
set DejaVu($NomDuAlias) 1
set LesSequencesNP [IsoleUnDomaine $PAB $Debut $Fin "RetournerSeqNucAndSeqPro"]
ScanLaListe $LesSequencesNP SeqN SeqP
Espionne "SeqN $PAB $Frag $Debut $Fin $SeqN"
Espionne "SeqP $PAB $Frag $Debut $Fin $SeqP"
set FicN "$Rep/$Alias-$Debut-$Fin.nuctfa"
set FicP "$Rep/$Alias-$Debut-$Fin.prottfa"
set EnteteN "$Alias-$Debut-$Fin [string length $SeqN] bases"
set EnteteP "$Alias-$Debut-$Fin [string length $SeqP] AAs"
set TfaN [SequenceFormatTFA $SeqN $EnteteN "nucbrut"]
lappend LeTFAs $TfaN
lappend LesFicN [Sauve $TfaN dans $FicN]
if { ! [regexp "b" $Debut] && ! [regexp "b" $Fin] } {
set TfaP [SequenceFormatTFA $SeqP $EnteteP "protbrut"]
lappend LesFicP [Sauve $TfaP dans $FicP]
}
}
}
set NomConstruction [join $LesNomDuAlias "-"]
while {$FichierTFAs==""} {
FaireLire "Please give a name for the TFAs construction file"
set FichierTFAs [FichierPourSaveAs "./$NomConstruction.tfa"]
if {$FichierTFAs=="" && [OuiOuNon "Do I cancel GenereFragments ?"]} { return "" }
}
SauveLesLignes $LeTFAs dans $FichierTFAs
return $FichierTFAs
}
proc AfficheLesFragmentsDeMutation Nom {
set LesFragments [CombineLesFragments $Nom "MutationFragments"]
Espionne $LesFragments
while {[OuiOuNon "Do we continue to combine these fragments ?"]} {
set LesFragments [CombineLesFragments $Nom $LesFragments]
}
return $LesFragments
}
proc CombineLesFragments {Nom {LesBornesDesFragments ""}} {
JeMeSignale
set FichierNucTFA "[RepertoireDuGenome]/nuctfa/$Nom"
set ToutNuc [QueLaSequenceDuFichierTFA $FichierNucTFA]
set LesFragments {}
set FragmentsDeMutation 0
if {$LesBornesDesFragments==""} {
if { ! [OuiOuNon "Do You want to see the mutation fragments ?"]} { return "" }
}
if {$LesBornesDesFragments=="MutationFragments"} {
set FragmentsDeMutation 1
set Entete [EnteteDuFichierTFA $FichierNucTFA]
if { ! [regexp { muted (.+) of } $Entete Match Codes]} {
FaireLire "Sorry I can't find 'muted code1 code2 code3 of' in $Entete"
return ""
}
set LesCoOrdonnes [list 1]
foreach Code [split $Codes " "] {
if { ! [regexp -nocase {[a-z]} $Code]} { continue }
regsub {[0-9]+} [string toupper $Code] " & " Coco
scan $Coco "%s %d %s" AncienP PosAncienP NouveauP
set LongAncienP [string length $AncienP]
lappend LesCoOrdonnes $PosAncienP
}
lappend LesCoOrdonnes [expr [string length $ToutNuc]/3]
set LesCoOrdonnes [lsort -increasing -integer $LesCoOrdonnes]
set LesBornesDesFragments $LesCoOrdonnes
}
set Frag "A"
set LesBornesDesFragmentsOK {}
foreach X $LesBornesDesFragments {
if {[regexp -nocase "end" $X]} { set X [expr ([string length $ToutNuc]+4)/3] }
if { ! [regexp {[0-9]+} $X Bon]} { continue }
lappend LesBornesDesFragmentsOK $Bon
}
set LesBornesDesFragments $LesBornesDesFragmentsOK
foreach DP [lrange $LesBornesDesFragments 0 end-1] FP [lrange $LesBornesDesFragments 1 end] {
incr FP -1
set LesSequencesNP [IsoleUnDomaine $Nom $DP $FP "RetournerSeqNucAndSeqPro"]
ScanLaListe $LesSequencesNP SeqN SeqP
set PepSort [PeptideSort $SeqP]
if {[info exists TPep]} { unset TPep }
DecortiquePeptideSort $PepSort "" TPep
Espionne [array get TPep]
set Residues [set TPep(Residues)]
set nBases [expr $Residues*3]
set Molecularweight [set TPep(Molecularweight)]
set Charged [set TPep(Charged)]
set Isoelectricpoint [set TPep(Isoelectricpoint)]
set SeqCompressee ""
append SeqCompressee [string range $SeqP 0 5]
append SeqCompressee "..."
append SeqCompressee [string range $SeqP end-5 end]
lappend LesFragments [format "%s %6s %5d %5d %4d %4d %3d %10.2f %5.2f %s" \
$Nom \
$Frag \
$DP $FP \
$Residues $nBases $Charged \
$Molecularweight $Isoelectricpoint \
$SeqCompressee]
set Frag [NextALPHA $Frag]
}
if {[llength $LesFragments]==1} {
set Choix [AfficheVariable [join $LesFragments "\n"] "AvecRetour" PleaseSelectContigousLines]
if {$Choix=="" && [OuiOuNon "Do I cancel CombineLesFragments ?"]} { return "" }
return $LesFragments
}
set Choix ""
FaireLire "You can now create several contigous fragments"
set TousLesFragments {}
if {$FragmentsDeMutation} {
set LesFragmentsDeMutation [TousLesSegmentsConsecutifs $LesFragments]
}
set Ever 1
while $Ever {
if {$FragmentsDeMutation} {
if {$LesFragmentsDeMutation=={}} {
set OK [AfficheVariable [join $TousLesFragments "\n"] "AvecRetour" PleaseValidate]
break
} else {
set Choix [lindex $LesFragmentsDeMutation 0]
set LesFragmentsDeMutation [lrange $LesFragmentsDeMutation 1 end]
}
} else {
set Choix [AfficheVariable [join $LesFragments "\n"] "AvecRetour" PleaseSelectContigousLines]
if {$Choix=="" && \
[OuiOuNon "Did You choose enough fragments\n or maybe You want to reset selection"]} {
set Tout [join $TousLesFragments "\n"]
set Selection [AfficheVariable $Tout "AvecRetour" PleaseValidate]
if {$Selection==""} {
if {[OuiOuNon "Do You want to cancel CombineFragments ?"]} { return "" }
if {[OuiOuNon "Do You really want to empty all selection You did ?"]} {
set TousLesFragments {}
}
continue
}
if {$Selection==$Tout} { break }
if {[OuiOuNon "Do You really want to keep only following selection\n$Selection"]} {
set TousLesFragments [split $Selection "\n"]
break
}
continue
}
}
Espionne $Choix
set LeChoix [split $Choix "\n"]
set DP ""
set NomDuFragment ""
foreach Fragment $LeChoix {
scan $Fragment "%s %s %d %d" NomLu FragLu DPlu FPlu
if {$DP==""} { set DP $DPlu }
set FP $FPlu
append NomDuFragment $FragLu
}
set LesSequencesNP [IsoleUnDomaine $Nom $DP $FP "RetournerSeqNucAndSeqPro"]
ScanLaListe $LesSequencesNP SeqN SeqP
set PepSort [PeptideSort $SeqP]
if {[info exists TPep]} { unset TPep }
DecortiquePeptideSort $PepSort "" TPep
set Residues [set TPep(Residues)]
set nBases [expr $Residues*3]
set Molecularweight [set TPep(Molecularweight)]
set Charged [set TPep(Charged)]
set Isoelectricpoint [set TPep(Isoelectricpoint)]
set SeqCompressee ""
append SeqCompressee [string range $SeqP 0 5]
append SeqCompressee "..."
append SeqCompressee [string range $SeqP end-5 end]
lappend TousLesFragments [format "%s %6s %5d %5d %4d %4d %3d %10.2f %5.2f %s" \
$Nom \
$NomDuFragment \
$DP $FP \
$Residues $nBases $Charged \
$Molecularweight $Isoelectricpoint \
$SeqCompressee]
# AfficheVariable [join $TousLesFragments "\n"] "" TheFragmentsYouSelect]
set Choix ""
}
return $TousLesFragments
}
proc NommageAuto {Access {Systeme ""} {Rep "./"}} {
if {$Systeme=="" } { return [TmpFile] }
if {$Systeme=="Ask_for_each"} { return [FichierPourSaveAs "$Rep/Access"] }
if {$Systeme=="Use_access" } { return "$Rep/$Access" }
if {$Systeme=="Use_access_but_remove_signals"} {
set LesVilains [Signal "LaListeDesAccess"]
lappend LesVilains "ProduitPCR"
set Nouveau "_${Access}_"
foreach Vilain $LesVilains {
regsub -all "_${Vilain}_" $Nouveau "_" Nouveau
}
regsub -all "_" $Nouveau "" Nouveau
while {$Nouveau==""} {
FaireLire "I removed all signals from $Access and got an empty text. how do I call the file ?"
set Nouveau [Entre $Access]
}
return "$Rep/$Nouveau"
}
return "$Rep/$Access"
}
proc LesFichiersUnAUnDuTFAs {Fichier {Rep ""} {Systeme ""}} {
if {$Rep==""} { set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[RepertoireDuGenome]/.."] }
if {$Systeme=="" && [OuiOuNon "Do You want to use one of my specific naming system ?"]} {
set Systeme [ChoixParmi [list "TmpFile" "Use_access" "Use_access_but_remove_signals" "Ask_for_each"]]
}
foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $Fichier $Access]
set FicTFA [NommageAuto $Access $Systeme $Rep]
set FicTFACree [Sauve $TFA dans $FicTFA]
lappend LesFicTFACrees $FicTFACree
}
return $LesFicTFACrees
}
proc OrdaliDeLaSelection {Page Selection {NomDuFichierOrigine ""}} {
set Reste [AfficheRognure $Page $Selection "Retour" $NomDuFichierOrigine "In"]
OrdaliDuTexteMSF $Reste $NomDuFichierOrigine -viewer
return $Reste
}
proc IsoleEtAfficheUnDomaineNucleique {{NomOuTexte ""} {DP ""} {FP ""}} {
set SeqNuc [IsoleUnDomaine $NomOuTexte $DP $FP "RetournerSeqNuc"]
return [AfficheVariable $SeqNuc "AvecFormate"]
}
proc IsoleUnDomaine {{NomOuTexte ""} {DP ""} {FP ""} {QuoiRetourner ""}} {
JeMeSignale
Wup "QuoiRetourner can be RetournerSeqNuc RetournerSeqPro RetournerSeqNucAndSeqPro"
Wup "QuoiRetourner can be RetournerSeqNucIfOK ..."
Wup "otherwize QuoiRetourner is the list of the 2 filenames"
if {[EstUnPAB $NomOuTexte]} {
set Nom $NomOuTexte
set FicPro "[RepertoireDuGenome]/prottfa/$Nom"
set FicNuc "[RepertoireDuGenome]/nuctfa/$Nom"
set SeqPro [QueLaSequenceDuFichierTFA $FicPro]
set SeqNuc [QueLaSequenceDuFichierTFA $FicNuc]
set Alias [AliasPourClonage $Nom]
} elseif {[regexp "\n" $NomOuTexte] && [regexp {^>} $NomOuTexte]} {
set FicNuc ""
set FicPro ""
set TFA $NomOuTexte
set SeqNuc [QueLaSequenceDuTexteTFA $TFA]
set LongNuc [string length $SeqNuc]
set SeqPro [SeqNucToSeqPro $SeqNuc]
set Entete [EnteteDuTexteTFA $TFA]
scan $Entete "%s" Access
regsub ">" $Access "" Access
set Nom $Access
set Alias $Access
}
set LongProt [string length $SeqPro]
while {$FP==""} {
FaireLire "Please enter start and stop position for the protein\n \(or 'bases nnn nnn' if nuc)"
if {$DP==""} { set DP 1 }
set FPpropose $LongProt
set DN [expr ($DP-1)*3+1]
set FN [expr ($FPpropose-1)*3+3]
set SS [Entre "$DP $LongProt bases $DN $FN"]
if {$SS==""} {
if {[OuiOuNon "Do I cancel ?"]} { return "" } else { continue }
}
if {[regexp -nocase {^ *b} $SS]} {
catch {unset SeqPro}
scan $SS "%s %d %d" bidon DNlu FNlu
if {$DNlu<$FNlu} {
if {($QuoiRetourner!="RetournerSeqNuc" && $QuoiRetourner!="RetournerSeqNucIfOK") \
&& [expr ($FNlu-$DNlu+1)%3]!=0} {
FaireLire "$DNlu $FNlu doesn't correspond to a n*3 bases sequence. Please enter again."
continue
}
set SeqN [string range $SeqNuc [expr $DNlu-1] [expr $FNlu-1]]
set DPlu [expr ($DNlu-3)/3+1]
set FPlu [expr ($FNlu-1)/3+1]
} else {
if {($QuoiRetourner!="RetournerSeqNuc" && $QuoiRetourner!="RetournerSeqNucIfOK") \
&& [expr ($DNlu-$FNlu+1)%3]} {
FaireLire "$DNlu $FNlu doesn't correspond to a n*3 bases sequence. Please enter again."
continue
}
set SeqN [string range $SeqNuc [expr $FNlu-1] [expr $DNlu-1]]
set SeqN [NucToReverseAndComplementNuc $SeqN]
set LongSeqN [string length $SeqNuc]
set DNlu [expr $LongSeqN-$DNlu+1]
set FNlu [expr $LongSeqN-$FNlu+1]
set DPlu [expr ($DNlu-3)/3+1]
set FPlu [expr ($FNlu-1)/3+1]
}
} else {
set DPlu 99999
set FPlu -9999
scan $SS "%d %d" DPlu FPlu
if {$FPlu<$DPlu && [OuiOuNon "Do I reverse and complement the sequence $FPlu $DPlu ?"]} {
catch {unset SeqPro}
set BonneFin [strign length $SeqNuc]
while {[expr $BonneeFin%3]} { incr BonneFin -1 }
set SeqNuc [string range $SeqNuc 0 [expr $BonneFin-1]]
set SeqNuc [NucToReverseAndComplementNuc $SeqNuc]
set SeqPro [SeqNucToSeqPro $SeqNuc]
set NowLongPro [string length $SeqPro]
set DPlu [expr $NowLongProt-$DPlu+1]
set FPlu [expr $NowLongProt-$FPlu+1]
Espionne "$DNlu $FNlu $DPlu $FPlu"
}
}
if {[regexp "RetournerSeqNuc" $QuoiRetourner] && \
1<=$DNlu && $DNlu<$FNlu && $FNlu<=$LongNuc} { set DN $DNlu ; set FN $FNlu ; break }
if {1<=$DPlu && $DPlu<$FPlu && $FPlu<=$LongProt} { set DP $DPlu ; set FP $FPlu ; break }
FaireLire "Please choose correct limits between 1 and $LongProt"
}
if {[info exists SeqN]} {
set SeqP [SeqNucToSeqPro $SeqN]
} else {
set NucOnly 1
if {[regexp "b" $DP]} {
regsub "b" $DP "" DN
set NucOnly 1
} else {
set DN [expr ($DP-1)*3+1]
}
if {[regexp "b" $FP]} {
regsub "b" $FP "" FN
set NucOnly 1
} else {
set FN [expr ($FP-1)*3+3]
}
set SeqN [string range $SeqNuc [expr $DN-1] [expr $FN-1]]
if { $NucOnly } {
set SeqP ""
set FicP ""
} else {
if {[info exists SeqPro]} {
set SeqP [string range $SeqPro [expr $DP-1] [expr $FP-1]]
set SeqPVerif [SeqNucToSeqPro $SeqN]
if { ! [string equal -nocase $SeqP $SeqPVerif]} {
if {[OuiOuNon "$DN $FN\n$SeqP\n$SeqPVerif\n\
Your protein sequence is not the exact translation of the nucleic.\n\
Do I cancel ?"]} { return "" }
}
} else {
set SeqP [SeqNucToSeqPro $SeqN]
}
}
}
if {$QuoiRetourner=="RetournerSeqNuc"} { return $SeqN }
if {$QuoiRetourner=="RetournerSeqPro"} { return $SeqP }
if {$QuoiRetourner=="RetournerSeqNucAndSeqPro"} { return [list $SeqN $SeqP] }
regsub -all {.} $SeqP "& " SeqP3
set Retour [AfficheVariable "$SeqP3\n$SeqN" "AvecRetour" ""]
if {$Retour==""} { return "" }
if {$QuoiRetourner=="RetournerSeqNucIfOK"} { return $SeqN }
if {$QuoiRetourner=="RetournerSeqProIfOK"} { return $SeqP }
if {$QuoiRetourner=="RetournerSeqnucAndSeqProIfOK"} { return "$SeqN $SeqP" }
while { ! [OuiOuNon "Do I save the prot and nuc in .tfa files ?"]} {
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
set FicN "$Alias-$DP-$FP.nuctfa"
set FicN [FichierPourSaveAs $FicN]
if { ! $NucOnly } {
set FicP "$Alias-$DP-$FP.prottfa"
set FicP [FichierPourSaveAs $FicP]
set TfaP [SequenceFormatTFA $SeqP "$Alias-$DP-$FP extracted from prot $Nom" "protbrut"]
if {$TfaP==""} { return "" }
Sauve $TfaP dans $FicP
}
set TfaN [SequenceFormatTFA $SeqN "$Alias-$DP-$FP extracted from nuc $Nom bases $DN to $FN" "protbrut"]
if {$TfaN==""} { return "" }
Sauve $TfaN dans $FicN
return [list $FicP $FicN]
}
proc SequenceDesSignaux {Signaux {Sens ""}} {
Wup "Signaux can be a list or a text with '_' separating the signals"
if {[regexp "_" $Signaux]} {
set LesSignaux [split $Signaux "_"]
} else {
set LesSignaux $Signaux
}
set LesSeq {}
foreach Signal $LesSignaux {
lappend LesSeq [Signal $Signal]
}
set Seq [join $LesSeq " "]
if {$Sens=="3'"} { set Seq [NucToReverseAndComplementNuc $Seq] }
return $Seq
}
proc LesSujetsAvecOligos {} {
set LesSujetsAvecOligos {}
foreach P [Oli "LaListeMerci"] {
foreach Sujet [Oli $P Subjects] {
lappend LesSujetsAvecOligos [format "%-20s %s" $Sujet $P]
}
}
return $LesSujetsAvecOligos
}
proc ShowOli {Selection {Action ""}} {
global ActionOli
if { ! [info exists ActionOli]} { set ActionOli "All" }
if {$Action==""} { set Action $ActionOli }
if {[regexp "\n" $Selection]} {
foreach Sel [split $Selection "\n"] {
ShowOli $Sel $Action
}
return
}
if {[regexp { (P[0-9]+) \-+ (P[0-9]+)} $Selection Match P1 P2]} {
set fP1 [ShowOli $P1 $Action]
set fP2 [ShowOli $P2 $Action]
return "$fP1 $fP2"
}
if {[regexp { >(P[0-9]+) } $Selection Match P]} {
return [ShowOli $P $Action]
}
if {$Action=="Choose"} {
set Action [ChoixParmi [lrange [Oli] 2 end]]
}
if {$Action==""} { return "" }
set ActionOli $Action
set P ""
foreach PPossible [split $Selection " "] {
if {[regexp {^P[0-9]+$} $PPossible]} { set P $PPossible ; break}
}
if {$P==""} { return "" }
if {$Action=="All"} {
set LesInfos {}
if {[PourWscope]} {
lappend LesInfos "<<<KeepChevrons<h3>Oligo <a href='[WscopeScience]&AfficheFournisseur&$P'>$P</a></h3>KeepChevrons>>>"
}
foreach A [lrange [Oli] 2 end-1] {
lappend LesInfos "\n$A :\n[Oli $P $A]"
if {$A=="Type"} {
set Fournis [Fournisseur $P]
regsub " " $Fournis "\n " Fournis
lappend LesInfos "\nFournisseur: $Fournis"
lappend LesInfos " [OlIgbmc $P]"
}
}
set Info [join $LesInfos "\n"]
} else {
set Info "[Oli $P $Action]"
}
set Texte $Info
set Fen [AfficheVariable $Texte "AvecFormateAvecBlasteAvecOli" $P]
return $Fen
}
proc Oli {{P ""} {Quoi "Seq"}} {
Wup "Reads the file in oligos/P.tfa using FiSeqOl"
Wup "Quoi can be Seq TFA Sens Signals Subjects SeqSignals SeqSubject TfaSubject"
if {$P==""} { return "Oli Pxxxx Type Description TFA Seq Sens Signals Subjects SeqSignals SeqSubject TfaSubject All" }
if {$P=="LaListeMerci"} { return [FiSeqOl "LaListeMerci"] }
set Fichier [FiSeqOl $P]
if { ! [file exists $Fichier]} { return "" }
set Entete [EnteteDuFichierTFA $Fichier "all"]
if {$Entete==""} { return "" }
if {[regexp {\(} $Entete]} { regsub { *\(.*} $Entete "" Entete }
regsub ">" $Entete "" Entete
set Seq [QueLaSequenceDuFichierTFA $Fichier]
if {$Quoi=="Seq"} { return $Seq }
if {$Quoi=="TFA"||$Quoi=="All"} { return [ContenuDuFichier $Fichier] }
if {$Quoi=="Description"} { return $Entete }
if {$Quoi=="AllOnOneLine"} { return "$Entete $Seq" }
if {[regexp "ignoreoli|oligoignore" $Entete]} {
if {$Quoi=="Type"} { return "IgnoreOli" }
if {$Quoi=="SeqSubject" || $Quoi=="SeqSignals"} { return [QueLaSequenceDuFichierTFA $Fichier] }
if {$Quoi=="TfaSubject" || $Quoi=="TfaSignals"} { return [ContenuDuFichier $Fichier] }
if {$Quoi=="Sens"} { return "5'" }
if {[regexp "^Is" $Quoi]} { return 0 }
return ""
}
if {[regexp "SeqOli_|SeqOliRac_" $Entete Match]} {
if {$Quoi=="Type"} { return "SeqOli" }
if {$Quoi=="SeqSubject" || $Quoi=="SeqSignals"} { return [QueLaSequenceDuFichierTFA $Fichier] }
if {$Quoi=="TfaSubject" || $Quoi=="TfaSignals"} { return [ContenuDuFichier $Fichier] }
if {$Match=="SeqOli_"} { set Sens "5'" } else { set Sens "3'" }
if {$Quoi=="Sens"} { return $Sens }
set Reste [StringSuivant $Match dans $Entete]
set LesMots [LesMotsDeLaLigne $Reste]
set LesSujets {}
foreach Mot $LesMots {
set LesChamps [split $Mot "-"]
set Code [lindex $LesChamps end]
set Sujet [join [lrange $LesChamps 0 end-1] "-"]
lappend LesSujets $Sujet
lappend LesCodes $Code
}
set PremierCode [lindex $LesCodes 0]
if {$Quoi=="Subjects"} { return $LesSujets }
if {$Quoi=="CodeSequence" || $Quoi=="Signals"} { return $PremierCode }
if {[regexp "^Is" $Quoi]} { return 0 }
FaireLire "Please verify the call to \n[JeMeSignale Get]"
return ""
}
if {[regexp "MutOli_|MutOliRac_" $Entete Match]} {
if {$Quoi=="Type"} { return "MutOli" }
if {$Quoi=="SeqSubject" || $Quoi=="SeqSignals"} { return [QueLaSequenceDuFichierTFA $Fichier] }
if {$Quoi=="TfaSubject" || $Quoi=="TfaSignals"} { return [ContenuDuFichier $Fichier] }
if {$Match=="MutOli_"} { set Sens "5'" } else { set Sens "3'" }
if {$Quoi=="Sens"} { return $Sens }
set Reste [StringSuivant $Match dans $Entete]
set LesMots [LesMotsDeLaLigne $Reste]
set LesSujets {}
set BonCode "x1x"
foreach Mot $LesMots {
set LesChamps [split $Mot "-"]
set Code [lindex $LesChamps end]
if {$BonCode!="x1x" && $BonCode!=$Code} {
FaireLire "I found two different mutation codes in $P"
}
set BonCode $Code
set Sujet [join [lrange $LesChamps 0 end-1] "-"]
lappend LesSujets $Sujet
}
if {$Quoi=="Subjects"} { return $LesSujets }
if {$Quoi=="CodeMutation" || $Quoi=="Signals"} { return $BonCode }
FaireLire "Please verify the call to \n[JeMeSignale Get]"
return ""
}
if {$Quoi=="Type"} { return "SynOli" }
set Signaux ""
scan $Entete "%s %s %s %s %s %s" Access Sens oligo with signal Signaux
if {$Quoi=="IsBrocOli"} { return [regexp "BrocOli " $$Entete] }
if {$Quoi=="IsRebuildedBrockenOli"} { return [regexp "RebuildedBrockenOli " $Entete] }
if {$Quoi=="ItsGenericOligo"} { return [StringApres "BrocOli with " dans $Entete] }
if {$Quoi=="SignalsFull"} { return [StringApres "replaces" dans $Entete] }
if {$Quoi=="Full"} { return [StringApres "seeFull" dans $Entete] }
if {$Quoi=="Brocken"} { return [StringApres "seeBrocken" dans $Entete] }
if {$Quoi=="Sens"} { return $Sens }
if {$Quoi=="Signals"} { return $Signaux }
if {$Quoi=="Subjects"} {
if {[regexp -nocase "RebuildedBrockenOli" $Entete]} {
set Full [StringApres "seeBrocken" dans $Entete]
return [Oli $Full "Subjects"]
}
set LesSujets {}
foreach S [lrange [split $Entete " "] 7 end] {
if {[string equal -nocase $S "BrocOli"]} { break }
if {[string equal -nocase $S "RebuildedBrockenOli"]} { break }
lappend LesSujets $S
}
return $LesSujets
}
if { $Quoi=="SeqSignals" || $Quoi=="SeqSubject" || $Quoi=="TfaSubject"} {
set SeqSignaux [SequenceDesSignaux $Signaux $Sens]
Espionne "$Signaux $Sens $SeqSignaux"
set Seq [QueLaSequenceDuFichierTFA $Fichier]
regsub -all " " $SeqSignaux "" SeqSignauxSansBlancs
regsub -all " " $Seq "" SeqSansBlancs
if { ! [regexp -nocase "^$SeqSignauxSansBlancs" $Seq]} {
FaireLire "For Oligo $P : wrong signals \n$SeqSignauxSansBlancs\nin\n$SeqSansBlancs"
}
if {$Quoi=="SeqSignals"} { return $SeqSignauxSansBlancs }
if {$Quoi=="SeqSubject" || $Quoi=="TfaSubject"} {
regsub -nocase "^$SeqSignauxSansBlancs" $SeqSansBlancs "" SeqSubject
if {$Quoi=="TfaSubject"} {
regsub ">" $Entete ">Subj_" EntetePourSubject
regsub " with " $EntetePourSubject " without " EntetePourSubject
set TfaSubject [SequenceFormatTFA $SeqSubject $EntetePourSubject "nucbrut"]
return $TfaSubject
}
return $SeqSubject
}
}
FaireLire "Please verify the call to \n[JeMeSignale Get]"
return ""
}
proc LaSequenceDuTFAsMultiEntete {FichierTFAs Access} {
global LesSequencesDuTFAs
Wup "Same as LaSequenceDuTFAs execept that it accepts several access on a header line"
Wup "Loads the sequence corresponding to Access from a multiple tfa file (can be a blast database)"
Wup "Not sure that it works well if wrong '>b:id access'"
if {[info exists LesSequencesDuTFAs($FichierTFAs,$Access)]} {
return [set LesSequencesDuTFAs($FichierTFAs,$Access)]
}
if {[info exists LesSequencesDuTFAs($FichierTFAs)]} {
return ""
}
foreach Ligne [LesLignesDuFichier $FichierTFAs] {
if { ! [regexp -nocase {[a-z0-9_>]} $Ligne]} { continue }
if {[regexp "^>" $Ligne]} {
regsub "^>" $Ligne "" Ligne
set LesAcessLus {}
foreach Champ [split $Ligne "+"] {
set AccessLu ""
scan $Champ "%s" AccessLu
lappend LesAccessLus $AccessLu
set LesSequencesDuTFAs($FichierTFAs,$AccessLu) ">$AccessLu"
lappend LesSequencesDuTFAs($FichierTFAs,LaListeDesAccess) $AccessLu
}
continue
}
foreach AccessLu $LesAccessLus {
append LesSequencesDuTFAs($FichierTFAs,$AccessLu) "\n$Ligne"
}
}
set LesSequencesDuTFAs($FichierTFAs) "SontChargees"
return [LaSequenceDuTFAsMultiEntete $FichierTFAs $Access]
}
proc WarneReading Texte {
global WarneReading
global RepertoireDuGenome
set Fichier "$RepertoireDuGenome/fiches/warne_reading"
if { ! [info exists WarneReading]} {
if {[file exists $Fichier]} {
if {0 && [OuiOuNon "Do I warne reading problems in warne_reading file ?"]} {
set WarneReading 1
File delete -force $Fichier
} else {
set WarneReading 0
}
} else {
set WarneReading 1
}
}
if { ! $WarneReading} { return "" }
return [AppendAuFichier $Fichier $Texte]
}
proc Signal {{S ""} {TFAouSEQ ""}} {
global RepertoireDuGenome
global MemoSignaux
if {$S==""} { set S "ListOf" ; set TFAouSEQ "TFA" }
if {[PourWscope] && $S=="ListOf"} { set S "All" ; set TFAouSEQ "HTML" }
if {$TFAouSEQ==""} { set TFAouSEQ "SEQ" }
set TFAouSEQ [string toupper $TFAouSEQ]
if {[info exists MemoSignaux($S,$TFAouSEQ)]} { return [set MemoSignaux($S,$TFAouSEQ)] }
if {[info exists MemoSignaux("EstCharge")]} { return "" }
set MemoSignaux("EstCharge") 1
set FichierTFAs [LeFichierDesSignaux]
set LesAccess [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess"]
set MemoSignaux(LaListeDesAccess,SEQ) $LesAccess
foreach Signal [lsort $LesAccess] {
set TFA [LaSequenceDuTFAs $FichierTFAs $Signal]
set MemoSignaux($Signal,TFA) $TFA
set MemoSignaux($Signal,SEQ) [QueLaSequence $TFA]
if {[regexp "_" $Signal]} {
regsub "_" $Signal "" Signal
set MemoSignaux($Signal,TFA) $TFA
set MemoSignaux($Signal,SEQ) [QueLaSequence $TFA]
}
lappend MemoSignaux(ListOf,SIGNALS) $Signal
lappend MemoSignaux(ListOf,TFA) $TFA
}
set MemoSignaux(All,TFA) [join $MemoSignaux(ListOf,TFA) "\n"]
set MemoSignaux(All,HTML) "<pre>\n$MemoSignaux(All,TFA)\n</pre>"
return [Signal $S $TFAouSEQ]
}
proc MemeOligo {A B {Ap ""}} {
if {[string equal -nocase $A $B]} { return 1 }
if {$Ap=="Ap"} { set Ap 1 } else { set Ap 0 }
if {$Ap && [regexp -nocase "gggtC" $B]} {
set BonB "agaaagct$B"
set m [Mini [string length $A] [string length $BonB]]
incr m -1
if {[string equal -nocase [string range $A 0 $m] [string range $BonB 0 $m]]} {
Espionne "Ai recupere par agaaagct \n$A\n$B"
return 1
}
}
if {$Ap && [regexp -nocase "gaaagct" $B]} {
set BonB "a$B"
set m [Mini [string length $A] [string length $BonB]]
incr m -1
if {[string equal -nocase [string range $A 0 $m] [string range $BonB 0 $m]]} {
Espionne "Ai recupere par a \n$A\n$B"
return 1
}
}
set lA [string length $A]
set lB [string length $B]
set L [expr [Mini $lA $lB] - 1 ]
if {[expr abs($lA-$lB) > $L ]} { return 0 }
set pA [string range $A 0 $L]
set pB [string range $B 0 $L]
if {[string equal -nocase $pA $pB]} {
Espionne "Ai recupere le debordement pour \n$A\n$B"
return 1
}
return 0
}
proc FichierPpcrSansAttBAdapter Fichier {
set Entete [EnteteDuFichierTFA $Fichier "all"]
if { ! [regexp {AttB[12]_?Adapter} $Entete]} { return $Fichier }
set Seq [QueLaSequenceDuFichierTFA $Fichier]
if { ! [regexp -nocase [SEQAttB1Adapter] $Seq] && ! [regexp -nocase [SEQAttB2Adapter] $Seq]} {
return $Fichier
}
if { ! [regexp [SEQAttB1] $Seq]} {
regsub -nocase [SEQAttB1Adapter] $Seq [SEQAttB1] Seq
}
if { ! [regexp [SEQAttB2] $Seq]} {
regsub -nocase [SEQAttB2Adapter] $Seq [SEQAttB2] Seq
}
regsub -nocase {AttB1_?Adapter} $Entete "AttB1" Entete
regsub -nocase {AttB2_?Adapter} $Entete "AttB2" Entete
return [Sauve [SequenceFormatTFA $Seq $Entete "nucbrut"] dans "[TmpFile].tfa"]
}
proc UnOligoDePlusPour {P TFA} {
set FiSeqOl [FiSeqOl $P]
set Rep [file dirname $FiSeqOl]
if { ! [file exists $Rep]} { file mkdir $Rep }
if { ! [file exists $FiSeqOl]} {
return [Sauve $TFA dans $FiSeqOl]
}
set LL [LesLignesDuFichier $FiSeqOl]
set OldEntete [lindex $LL 0]
set OldSeq [join [lrange $LL 1 end] ""]
set OldPSig [join [lrange [split $OldEntete " "] 0 6] " "]
set AA [split $TFA "\n"]
set NewEntete [lindex $AA 0]
set NewSeq [join [lrange $AA 1 end] ""]
set NewPSig [join [lrange [split $NewEntete " "] 0 6] " "]
if { ! [string equal -nocase $OldSeq $NewSeq]} {
FaireLire "Different oligo sequences for $P\n$OldSeq\n$NewSeq\n I'll keep the first one."
}
if { ! [string equal -nocase $OldPSig $NewPSig]} {
FaireLire "Different oligo signal header for $P\n$OldPSig\n$NewPSig\n I'll keep the first one."
}
set NouvelleEntete "$OldEntete [lindex [split $NewEntete " "] end]"
set NewLL [lreplace $LL 0 0 $NouvelleEntete]
return [SauveLesLignes $NewLL dans $FiSeqOl]
}
proc TfaTmpFromGCG FiOl {
set LesLignes [LesLignesDuFichier $FiOl]
set Entete [lindex $LesLignes 1]
set TFA [SequenceFormatTFA_l [lrange $LesLignes 2 end] $Entete "gcg"]
return [Sauve $TFA dans "[TmpFile].tfa"]
}
proc FiSeqOl P {
if {$P=="LaListeMerci"} {
foreach F [glob -nocomplain "[RepertoireDuGenome]/oligos/P*.tfa"] {
set NomP [file tail $F]
regsub ".tfa$" $NomP "" NomP
lappend LesPs $NomP
}
return $LesPs
}
return "[RepertoireDuGenome]/oligos/$P.tfa"
}
proc LesSujetsDeLOligo_NOT_YET_USED {P {Action ""} {Valeur ""}} {
if {$Action==""} { set Action "get" }
set FiSujOl [FiSujOl $P]
if {$Action=="get"} {
if {$Valeur=="filename"} { return $FiSujOl }
if {[file exists $FiSujOl]} {
return [LesLignesDuFichier $FiSujOl]
} else {
return {}
}
}
if {$Action=="set"} {
return [SauveLesLignes $Valeur dans $FiSujOl]
}
if {$Action=="append"} {
set LesSujets [LesSujetsDeLOligo $P]
if {[lsearch $LesSujets -exact $Valeur]<0} { lappend LesSujets $Valeur }
SauveLesLignes $Valeur dans $FiSujOl
return $LesSujets
}
}
proc InventaireDeLaDatabaseClonage {} {
set Choix [ChoixParmi [list \
"Show_OligosTogether" \
"Show_Oligos" \
"Show_VirtualPPCR" \
"Show_AllRec1" \
"Show_AllRec2" \
"Show_VEDidier" \
"Show_Localisation" \
"" \
"Show_Matrices" \
"Show_pDONR_pDEST" \
"Show_pDONR" \
"Show_pDEST" \
"Show_Signals" \
"Show_BrocOli" \
"Show_GluOli" \
"Show_pEntr" \
"Show_CoOl" \
"Show_Spine" \
"" \
"Show_RestEnzymes" \
"Show_RestEnzymesHits" \
"Show_RareCodon" \
"" \
"Browse_Oligos" \
"Browse_PPCR" \
]]
switch $Choix {
"Show_OligosTogether" {AffichePof "AllPs"}
"Show_Oligos" {AffichePof}
"Show_VirtualPPCR" {AfficheVirtualPPCR}
"Show_AllRec1" {AfficheLesRec1}
"Show_AllRec2" {AfficheLesRec2}
"Show_VEDidier" {ShowVEDidier}
"Show_Localisation" {LocalisationDesVirtualPPCRs}
"Show_Matrices" {InventaireDesMatrices}
"Show_pDONR_pDEST" {InventaireDesVecteurs "pDONR_pDEST"}
"Show_pDONR" {InventaireDesVecteurs "pDONR"}
"Show_pDEST" {InventaireDesVecteurs "pDEST"}
"Show_Signals" {InventaireDesSignaux "Show"}
"Show_BrocOli" {InventaireDesBrocOli "Show"}
"Show_GluOli" {InventaireDesGluOli "Show"}
"Show_pEntr" {InventaireDesPEntr "Show"}
"Show_Signals" {RestrictionEnzymes}
"Show_CoOl" {CoOlPourTous}
"Show_Spine" {SpineSummary "Show"}
"Show_RareCodon" {AfficheSlidingCodonRarePour}
"Show_RestEnzymes" {ShowRestrictionEnzyme}
"Show_RestEnzymesHits" {RestrictionEnzymesStatistics "ShowHits"}
"Browse_Oligos" {InventaireDesOligos}
"Browse_PPCR" {InventaireDesPPCR}
default {}
}
return $Choix
}
proc Canonise Construction {
scan $Construction "%s" Construction
set MemoCons $Construction
regsub -all "hCOUP_TFII" $Construction "hCOUP-TFII" Construction
regsub -all "SH1_ITK" $Construction "SH1-ITK" Construction
regsub -all "TOPO_NcoI" $Construction "TOPONcoI" Construction
regsub -all "AttB1_Adapter" $Construction "AttB1Adapter" Construction
regsub -all "AttB2_Adapter" $Construction "AttB2Adapter" Construction
if {[regexp -nocase {(EC|Y|H)(TAF|BDF|ASF|NFY[ABC])[0-9]*_[MNWDCHF0-9]+_[MNWDCHF0-9]+} $Construction Match]} {
regsub -all "_" $Match "-" BonMatch
regsub $Match $Construction $BonMatch Construction
}
if {[regexp -nocase {[a-z0-9]+_[0-9]+[_\-][0-9]+} $Construction Match]} {
regsub -all "_" $Match "-" BonMatch
regsub $Match $Construction $BonMatch Construction
}
regsub "^>" $Construction "" Construction
return [list $Construction]
}
proc InventaireDesOligos {{Source ""}} {
if {$Source==""} { set Source "Oli" }
set LesPSuj {}
switch $Source {
"Oli" {
foreach P [Oli "LaListeMerci"] {
set DesP [Oli $P "Description"]
regsub "^>" $DesP "" DesP
lappend LesPSuj $DesP
}
}
}
AfficheVariable [join $LesPSuj "\n"] "AvecOli" "InventaireDesOligos"
return
}
proc ClonInventoryExists args {
global ClonCollection
if {$args=={}} { return [info exists ClonCollection(EstCharge)]}
set Quoi [join $args ","]
return [info exists ClonCollection($Quoi)]
}
proc ClonInventoryAppend args {
global ClonCollection
set Quoi [join [lrange $args 0 end-1] ","]
set Valeur [lindex $args end]
return [lappend ClonCollection($Quoi) $Valeur]
}
proc ClonInventorySet args {
global ClonCollection
set Quoi [join [lrange $args 0 end-1] ","]
set Valeur [lindex $args end]
return [set ClonCollection($Quoi) $Valeur]
}
proc ClonInventoryUnset args {
global ClonCollection
set Quoi [join $args ","]
catch {unset ClonCollection($Quoi)}
}
proc ClonInventory args {
global ClonCollection
set Quoi [join $args ","]
if {[info exists ClonCollection($Quoi)]} { return [set ClonCollection($Quoi)] }
if {[info exists ClonCollection(EstCharge)]} { return "" }
#rR set ClonCollection(LesOligos) [InventaireDesFichiersClonage "PAY" "RetournerOligos"]
#rR set ClonCollection(LesPPCR) [InventaireDesFichiersClonage "PAY" "RetournerPPCR"]
set ClonCollection(LesOligos) [InventaireDesFichiersClonage "ProGS" "RetournerOligos"]
set ClonCollection(LesPPCR) [InventaireDesFichiersClonage "ProGS" "RetournerPPCR"]
set ClonCollection(EstCharge) 1
if {[info exists ClonCollection($Quoi)]} { return [set ClonCollection($Quoi)] }
return ""
}
proc TestClonage {} {
set LesOli [ClonInventory LesOligos]
set LesOli [ClonInventory LesOligos]
Espionne [OligosFiles [ChoixParmi [ItsOligos [ChoixParmi $LesOli]]]]
}
proc OligosFiles Selection {
return [ShowOligosFiles $Selection "GetThem"]
}
proc ShowOligosFiles {Selection {GetThem ""}} {
if {[regexp "\n" $Selection]} {
foreach TexCoAvAp [split $Selection "\n"] {
ShowOligosFiles $TexCoAvAp
}
return
}
set TexCoAvAp [string trim $Selection]
if {[regexp "===$" $TexCoAvAp]} { append TexCoAvAp " " }
set LesFichiers [ClonInventory $TexCoAvAp]
if {$GetThem=="GetThem"} { return $LesFichiers }
return [AfficheVariable [join $LesFichiers "\n"] "AvecDecFiOl" "OligosFilesOf$TexCoAvAp"]
}
proc ItsPPCR {Selection {NA ""}} {
return [ShowItsPPCR $Selection $NA "GetThem"]
}
proc ShowItsPPCR {Selection {NA ""} {GetThem ""}} {
if {[regexp "\n" $Selection]} {
foreach Sujet [split $Selection "\n"] {
ShowItsPPCR $Sujet $NA
}
return
}
set Sujet ""
scan $Selection "%s" Sujet
if {$Sujet==""} { return "" }
set LesCoAvAp {}
foreach FiCoAvAp [ClonInventory $Sujet PPCR$NA] {
set Fichier [lindex $FiCoAvAp 0]
set CoAvAp [lindex $FiCoAvAp 1]
set TexCoAvAp [join $CoAvAp " +++ "]
lappend LesCoAvAp $TexCoAvAp
ClonInventoryAppend $TexCoAvAp $Fichier
}
set LesCoAvAp [lsort -unique $LesCoAvAp]
if {$GetThem=="GetThem"} { return $LesCoAvAp }
set Fen [AfficheVariable [join $LesCoAvAp "\n"] "AvecFiPPCR" $Sujet]
return $Fen
}
proc ItsOligos {Selection {NA ""}} {
return [ShowItsOligos $Selection $NA "GetThem"]
}
proc ShowItsOligos {Selection {NA ""} {GetThem ""}} {
if {[regexp "\n" $Selection]} {
foreach Sujet [split $Selection "\n"] {
ShowItsOligos $Sujet $NA
}
return
}
set Sujet ""
scan $Selection "%s" Sujet
if {$Sujet==""} { return "" }
set LesCoAvAp {}
foreach FiCoAvAp [ClonInventory $Sujet Oligos$NA] {
set Fichier [lindex $FiCoAvAp 0]
set CoAvAp [lindex $FiCoAvAp 1]
set TexCoAvAp [join $CoAvAp " === "]
lappend LesCoAvAp $TexCoAvAp
ClonInventoryAppend $TexCoAvAp $Fichier
}
set LesCoAvAp [lsort -unique $LesCoAvAp]
if {$GetThem=="GetThem"} { return $LesCoAvAp }
set Fen [AfficheVariable [join $LesCoAvAp "\n"] "AvecFiOl" $Sujet]
return $Fen
}
proc InventaireDesFichiersClonage {{Rep ""} {OnVeut "AfficherTout"}} {
#rR depuis 2007/07/27 if {$Rep==""} { set Rep "PAY" }
if {$Rep==""} { set Rep "ProGS" }
if { ! [ClonInventoryExists Listes]} { ClonInventorySet Listes [Debroussaille $Rep] }
set Listes [ClonInventory Listes]
set LesFichiersOligos [lindex $Listes 0]
set LesFichiersOligos_NA [lindex $Listes 1]
set LesFichiersPPCR [lindex $Listes 2]
set LesFichiersPPCR_NA [lindex $Listes 3]
set LesDecomposOligos [lindex $Listes 4]
set LesDecomposOligos_NA [lindex $Listes 5]
set LesDecomposPPCR [lindex $Listes 6]
set LesDecomposPPCR_NA [lindex $Listes 7]
set LesFichiersSignaux [lindex $Listes 8]
set LesCommandesDOligos [lindex $Listes 9]
set TousLesAvantsGroupes {}
set TousLesApresGroupes {}
ClonInventorySet Oligos Sujets {}
foreach Fichier $LesFichiersOligos Decompo $LesDecomposOligos {
foreach Sujet [lindex $Decompo 0] LesAv [lindex $Decompo 1] LesAp [lindex $Decompo 2] {
lappend TousLesAvantsGroupes [join $LesAv "_"]
lappend TousLesApresGroupes [join $LesAp "_"]
ClonInventoryAppend $Sujet Oligos [list $Fichier [list $Sujet $LesAv $LesAp]]
ClonInventoryAppend Oligos Sujets $Sujet
set CoAvAp [list $Sujet [join $LesAv " "] [join $LesAp " "]]
set TexCoAvAp [join $CoAvAp " === "]
ClonInventoryAppend $TexCoAvAp $Fichier
}
}
ClonInventorySet Oligos Sujets [lsort -unique [ClonInventory Oligos Sujets]]
if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherOligos"} {
set Fen [AfficheVariable [join [ClonInventory Oligos Sujets] "\n"] "AvecShowItsOligos" "ConstructionsWithOligos"]
if {$OnVeut=="AfficherOligos"} { return $Fen }
}
if {$OnVeut=="RetournerOligos"} {
return [ClonInventory Oligos Sujets]
}
ClonInventorySet Oligos_NA Sujets {}
foreach Fichier $LesFichiersOligos_NA Decompo $LesDecomposOligos_NA {
set Sujet [lindex $Decompo 0]
set LesAv [lindex $Decompo 1]
lappend TousLesAvantsGroupes [join $LesAv "_"]
set LesAp [lindex $Decompo 2]
lappend TousLesApresGroupes [join $LesAp "_"]
ClonInventoryAppend $Sujet Oligos_NA [list $Fichier $Decompo]
ClonInventoryAppend Oligos_NA Sujets $Sujet
set CoAvAp [list $Sujet [join $LesAv " "] [join $LesAp " "]]
set TexCoAvAp [join $CoAvAp " === "]
ClonInventoryAppend $TexCoAvAp $Fichier
}
ClonInventorySet Oligos_NA Sujets [lsort -unique [ClonInventory Oligos_NA Sujets]]
if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherOligos_NA"} {
set Fen [AfficheVariable [join [ClonInventory Oligos_NA Sujets] "\n"] "AvecShowItsOligos_NA" "ConstructionsWithOligos_NA"]
if {$OnVeut=="AfficherOligos_NA"} { return $Fen }
}
if {$OnVeut=="RetournerOligos_NA"} {
return [ClonInventory Oligos_NA Sujets]
}
ClonInventorySet PPCR_NA Sujets {}
foreach Fichier $LesFichiersPPCR_NA Decompo $LesDecomposPPCR_NA {
set Sujet [lindex $Decompo 0]
set LesAv [lindex $Decompo 1]
set LesAp [lindex $Decompo 2]
ClonInventoryAppend $Sujet PPCR_NA [list $Fichier $Decompo]
ClonInventoryAppend PPCR_NA Sujets $Sujet
set CoAvAp [list $Sujet $LesAv $LesAp]
set TexCoAvAp [join $CoAvAp " +++ "]
ClonInventoryAppend $TexCoAvAp $Fichier
}
ClonInventorySet PPCR_NA Sujets [lsort -unique [ClonInventory PPCR_NA Sujets]]
if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherPPCR_NA"} {
set Fen [AfficheVariable [join [ClonInventory PPCR_NA Sujets] "\n"] "AvecShowItsPPCR_NA" "ConstructionsWithPPCR_NA"]
if {$OnVeut=="AfficherPPCR_NA"} { return $Fen }
}
if {$OnVeut=="RetournerPPCR_NA"} {
return [ClonInventory PPCR_NA Sujets]
}
ClonInventorySet PPCR Sujets {}
foreach Fichier $LesFichiersPPCR Decompo $LesDecomposPPCR {
set LesSu [lindex $Decompo 0]
set LesAv [lindex $Decompo 1]
set LesAp [lindex $Decompo 2]
foreach Sujet $LesSu Avs $LesAv Aps $LesAp {
ClonInventoryAppend $Sujet PPCR [list $Fichier [list $Sujet $Avs $Aps]]
ClonInventoryAppend PPCR Sujets $Sujet
set CoAvAp [list $Sujet $Avs $Aps]
set TexCoAvAp [join $CoAvAp " +++ "]
ClonInventoryAppend $TexCoAvAp $Fichier
}
}
ClonInventorySet PPCR Sujets [lsort -unique [ClonInventory PPCR Sujets]]
if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherPPCR_NA"} {
set Fen [AfficheVariable [join [ClonInventory PPCR Sujets] "\n"] "AvecShowItsPPCR" "ConstructionsWithPPCR"]
if {$OnVeut=="AfficherPPCR"} { return $Fen }
}
if {$OnVeut=="RetournerPPCR"} {
return [ClonInventory PPCR Sujets]
}
if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherSignaux"} {
set Fen [AfficheVariable [join $LesFichiersSignaux "\n"] "AvecFetch" Signaux]
if {$LesFichiersSignaux!={}} {
BoutonneLaFenetre $Fen "Signals inventory" "InventaireDesSignaux \[selection get\]"
}
}
if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherLesAvantsGroupes"} {
set TousLesAvantsGroupes [lsort -unique $TousLesAvantsGroupes]
set Fen [AfficheVariable [join $TousLesAvantsGroupes "\n"] "SansFetch" AvantsGroupes]
if {$TousLesAvantsGroupes!={}} {
BoutonneLaFenetre $Fen "Groups of 5' Signals inventory" "InventaireDesSignauxGroupes \[selection get\]"
}
}
if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherLesApresGroupes"} {
set TousLesApresGroupes [lsort -unique $TousLesApresGroupes]
set Fen [AfficheVariable [join $TousLesApresGroupes "\n"] "SansFetch" ApresGroupes]
if {$TousLesApresGroupes!={}} {
BoutonneLaFenetre $Fen "Groups of 3' Signals inventory" "InventaireDesSignauxGroupes \[selection get\]"
}
}
if {$OnVeut=="AfficherTout" || $OnVeut=="AfficherLesCommandesDOligos"} {
set Fen [AfficheVariable [join $LesCommandesDOligos "\n"] "AvecOli" CommandesDOligos]
}
}
proc InventaireDesSignaux {{Selection ""}} {
global RepertoireDuGenome
set Action ""
if {$Selection=="Show"} { set Action "Show" ; set Selection "" }
if {$Selection==""} { set Selection "[RepertoireDuGenome]/signaux/signaux.tfa" }
set LeShow {}
foreach Fichier [split $Selection "\n"] {
if {[info exists SeqSign]} { unset SeqSign ; unset SeqPPCR }
set LesSignaux [LesSignauxDuFichier $Fichier SeqSign SeqPPCR]
foreach Signal $LesSignaux {
set Actuel [set SeqPPCR($Signal)]
set SIGNAL [string toupper $Signal]
lappend LesFichiersDuSignal($Signal) $Fichier
if {[info exists Sequence($SIGNAL)]} {
set Autre [set Sequence($SIGNAL)]
set Actuel [set SeqPPCR($Signal)]
if {$Autre!=$Actuel} {
FaireLire "$Autre\n$Actuel\n\ndon't correspond for signal $Signal in\n\
[join [set LesFichiersDuSignal($Signal)] \n]]"
}
}
set Sequence($SIGNAL) $Actuel
set Ligne "[format "%-20s" $Signal] $Actuel"
lappend LeShow $Ligne
}
if {$Action=="Show"} { return [AfficheVariable [join $LeShow "\n"] "" Signals_Inventory ] }
while {[OuiOuNon "I would like to save these signals in a file. Can I do it ?"]} {
set BonFichierDeSignaux "$RepertoireDuGenome/signaux/bons_signaux.tfa"
set BonFichierDeSignaux [FichierPourSaveAs $BonFichierDeSignaux]
if {$BonFichierDeSignaux==""} { continue }
foreach Signal $LesSignaux {
set SignalAGarder($Signal) 1
}
set LeMeilleurOrdrePourLesSignaux [MorceauxChoisis [LeBonOrdrePourLesSignaux] \
"Please transfer all signals to the right and reorder them if necessary"]
foreach Signal $LeMeilleurOrdrePourLesSignaux {
if { ! [info exists SignalAGarder($Signal)]} { continue }
lappend LesSeqs [SequenceFormatTFA [set SeqPPCR($Signal)] "$Signal"]
set DejaVu($Signal) 1
}
foreach Signal [array names SignalAGarder] {
if {[info exists DejaVu($Signal)]} { continue }
lappend LesSeqs [SequenceFormatTFA [set SeqPPCR($Signal)] "$Signal"]
set DejaVu($Signal) 1
}
return [Sauve [join $LesSeqs "\n\n"] dans $BonFichierDeSignaux]
}
return [lsort -unique $LesSignaux]
}
}
proc DecomposeLesLignesDuFichier Fichier {
set LesSujets {}
set LesAvants {}
set LesApres {}
set EstNA 0
foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $Fichier] $Fichier NF] {
if {[regexp "!!NA_SEQUENCE" $Ligne]} { set EstNA 1 ; continue }
if {$EstNA} { regsub "" $Ligne ">" Ligne }
if { ! [regexp ">" $Ligne]} { if {$EstNA} { break } else {continue } }
set DecTi [DecomposeLaLigne $Ligne "" $Fichier]
set LesAv [lindex $DecTi 1]
set LesAp [lindex $DecTi 2]
foreach Sujet [lindex $DecTi 0] {
lappend LesSujets $Sujet
lappend LesAvants $LesAv
lappend LesApres $LesAp
}
if {$EstNA} { break }
}
return [list $LesSujets $LesAvants $LesApres]
}
proc DecomposeLesLignesDuFichierOligos Fichier {
return [DecomposeLesLignesDuFichier $Fichier]
set LesSujets {}
set LesAvants {}
set LesApres {}
set LaSortie {}
foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $Fichier] $Fichier NF] {
if { ! [regexp ">" $Ligne]} { continue }
set DecTi [DecomposeLaLigne $Ligne "" $Fichier]
if {[lindex $DecTi 0]=={}} { return [list {} {} {}] }
set LesSuj [lindex $DecTi 0]
set LesAva [lindex $DecTi 1]
set LesApr [lindex $DecTi 2]
if {$LesAva=={} && $LesApr=={}} {
FaireLire "Decomposition of oligos \n$Fichier\nsomething is wrong at line \n$Ligne"
}
foreach Suj $LesSuj {
lappend LesSujets $Suj
lappend LesAvants $LesAva
lappend LesApres $LesApr
}
}
return [list $LesSujets $LesAvants $LesApres]
}
proc DecomposeLaLigne {Ligne {AvecOuSansErreur ""} {Fichier ""}} {
if {[regexp "SeqOli|MutOli" $Ligne]} { return [list {} {} {}] }
while {[regexp -nocase "BrocOli" $Ligne]} {
regsub -nocase { BrocOli.*} $Ligne "" Ligne
set Sujets [StringSuivant " for " dans $Ligne]
if {$Sujets==""} { break }
set LesSujets [split $Sujets " "]
if {[regexp "5' oligo" $Ligne]} {
set LesAvants [split [StringApres " with signal " dans $Ligne]] ; set LesApres {}
} else {
set LesAvants {} ; set LesApres [split [StringApres " with signal " dans $Ligne]]
}
return [list $LesSujets $LesAvants $LesApres]
}
if {[regexp -nocase "RebuildedBrockenOli " $Ligne]} { regsub -nocase {RebuildedBrockenOli .*} $Ligne "" Ligne }
Wup "returns a list of 3 lists LesSujets LesAvants LesApres"
Wup "If Ligne is like S1 Av1_Av2_Av3 Ap1_Ap2 + S2 Av1_Av2_Av3 Ap1_Ap2 + S2 Av1_Av2_Av3 Ap1_Ap2"
Wup "it returns (S1 S2 S3) (Av1 Av2 Av3) (Ap1 Ap2)"
Wup "(Av1 Av2 Av3) and (Ap1 Ap2) are common to S1 S2 and S3"
if {$AvecOuSansErreur=="AvecErreur"} {
set AvecErreur 1
} else {
set AvecErreur 0
}
set Titre [string trim $Ligne]
if {[regexp {\+} $Titre]} {
set LesSujets {}
set OldAvants "bidon"
set OldApres "bidon"
foreach Ti [split $Titre "+"] {
scan $Ti "%s" Ti
set DecTi [DecomposeLaLigne $Ti $AvecOuSansErreur $Fichier]
lappend LesSujets [lindex $DecTi 0]
set LesAvants [lindex $DecTi 1]
set LesApres [lindex $DecTi 2]
set Avants [join $LesAvants "_"]
set Apres [join $LesApres "_"]
if {$OldAvants!="bidon" && $OldAvants!=$Avants} { FaireLire "Av signals incoherent in $Ligne" }
if {$OldApres !="bidon" && $OldApres !=$Apres } { FaireLire "Ap signals incoherent in $Ligne" }
}
Wup "Une liste de sujets et les listes LesAvants et LesApres qui doivent etre identiques pour chaque sujet"
return [list $LesSujets $LesAvants $LesApres]
}
set Titre [lindex [Canonise $Titre] 0]
set LesMots [split $Titre "_"]
if {[regexp -nocase "Produit" [lindex $LesMots 0]]} {
set LesMots [lrange $LesMots 1 end]
}
set LesAvants {}
set LesApres {}
set Avant 1
foreach Mot $LesMots {
if {[EstUnSignal $Mot]} {
if {$Avant} {
lappend LesAvants $Mot
} else {
lappend LesApres $Mot
}
} else {
if {$Avant} {
set Avant 0
set Sujet $Mot
} else {
if {$AvecErreur || [OuiOuNonMemo "I found more than 2 subjects.\nDo I stop all verifications ?"]} {
return [list {} {} {}]
}
if { ! $AvecErreur } {
FaireLire "$Ligne\n $Sujet and $Mot are 2 detected subjects\n\
May be one of them should be declared as signal.\n\
In that case : Please exit, create the signal and restart the program."
}
if {$AvecErreur || [regexp -nocase { [a-z0-9]+ } $Ligne] || \
[regexp {^[0-9]+$} $Mot] || \
[OuiOuNon "$Ligne\n $Sujet and $Mot are 2 detected subjects\nDo I skip $Ligne ?"]} {
return [list {} {} {}]
} else {
append Sujet "-$Mot"
}
}
}
}
if {$Avant} {
if { ! $AvecErreur} {
FaireLire "$Ligne\nno subject detected ...\n in $Fichier"
Espionne "$Ligne\nno subject detected ...\n in $Fichier"
}
return [list {} $LesAvants $LesApres]
}
return [list $Sujet $LesAvants $LesApres]
}
proc EstUnP P {
return [regexp {^P[0-9]+$} $P]
}
proc EstUnSignal Mot {
global LesSignauxConnus
global RepertoireDuGenome
if { ! [info exists LesSignauxConnus]} {
set LesSignauxConnus [LesSignauxDuFichier "$RepertoireDuGenome/signaux/signaux.tfa" Si Se]
lappend LesSignauxConnus "TOPONcoI"
lappend LesSignauxConnus "AttB1Adapter"
lappend LesSignauxConnus "AttB2Adapter"
}
if {[lsearch -exact $LesSignauxConnus $Mot]<0} {
return 0
} else {
return 1
}
}
proc Debroussaille {{LesRepRestants ""}} {
if {$LesRepRestants=="PAY"} {
set LesRepRestants [list \
"/genomics/link/ProGS/signaux" \
"/genomics/link/ProGS/atelier" \
"/home/halter/oligos" \
"/home/arnaud/Seqdir" \
"/home/renouf/Donnees" \
]
}
if {$LesRepRestants=="ProGS"} {
set LesRepRestants [list \
"/genomics/link/ProGS/signaux" \
"/genomics/link/ProGS/atelier" \
]
}
set LesRapportsPPCR {}
set LesRapportsPPCR_NA {}
set LesRapportsOligos {}
set LesRapportsOligos_NA {}
set LesFichiersPPCR {}
set LesFichiersPPCR_NA {}
set LesFichiersOligos {}
set LesFichiersOligos_NA {}
set LesDecomposPPCR {}
set LesDecomposPPCR_NA {}
set LesDecomposOligos {}
set LesDecomposOligos_NA {}
set LesRapportsSequence {}
set LesFichiersSignaux {}
set LesCommandesDOligos {}
if {$LesRepRestants==""} { set LesRepRestants [list "."] }
while {1} {
if {[llength $LesRepRestants]==0} { break }
set RepCourant [lindex $LesRepRestants 0]
set LesRepRestants [lreplace $LesRepRestants 0 0]
foreach D [glob -nocomplain -type d "$RepCourant/*"] {
if {[regexp -nocase "Poubelle" $D]} { continue }
lappend LesRepRestants $D
}
foreach F [glob -nocomplain -type f "$RepCourant/*"] {
set YaD1 0
set Queue [file tail $F]
if { ! [regexp -nocase {\.(seq|nuctfa|tfa|pep|na|txt|list)$} $Queue]} { continue }
if { ! ([regexp {^(olimut_|oliseq_|oligos_|ppcr_)} $Queue] \
|| [regexp "obsolete" $Queue] \
|| [regexp "commande" $Queue] \
|| [regexp "existing" $Queue] \
|| [regexp "^signaux" $Queue] )} { continue }
if {[regexp {commande.*\.txt$} $F]} {
set Fournis "Invitrogen"
lappend LesCommandesDOligos "\n$F"
set FournisseurDejaCite 0
foreach Ligne [LesLignesDuFichier $F] {
if {[regexp -nocase {SYNTHESE.+IGBMC} $Ligne]} { set Fournis "IGBMC"}
if {[regexp "^D1" $Ligne]} {
set YaD1 1
if { ! $FournisseurDejaCite} {
set FournisseurDejaCite 1
lappend LesCommandesDOligos " $Fournis"
}
set Description [StringSuivant "D1: " dans $Ligne]
if {[regexp {^P[0-9]+} $Description P]} {
set Fournisseur($P) "$Fournis $F"
}
lappend LesCommandesDOligos "$Description"
}
if {! $YaD1 && $Fournis=="IGBMC" && \
[regexp {^ *([0-9]+) +P[0-9]+ +} $Ligne Match Numero]} {
if { ! $FournisseurDejaCite} {
set FournisseurDejaCite 1
lappend LesCommandesDOligos " $Fournis"
}
set Description [StringSuivant "$Numero " dans $Ligne]
set Description [string trim $Description]
if {[regexp {^P[0-9]+} $Description P]} {
set Fournisseur($P) "$Fournis $F"
}
lappend LesCommandesDOligos "$Description"
}
}
}
if {[regexp {existing.*\.list$} $F]} {
lappend LesCommandesDOligos "\n$F"
foreach Ligne [LesLignesDuFichier $F] {
if { ! [regexp {^([^ ]+) please use (P[0-9]+)} $Ligne Match SS P]} { continue }
lappend LesCommandesDOligos "$P $SS"
}
}
set NASeq 0
set NbLignes 0
if {[catch {set LesLignes [LesLignesDuFichier $F]} Message]} {
WarneReading "Problem reading $F. I got following error message :\n$Message\nI skipp this file.\n"
continue
}
set LesLignes [CorrectionPourThrombin $LesLignes $F NouveauNomPourF]
foreach Ligne $LesLignes {
set Decompo ""
if { ! [regexp -nocase {[0-9a-z]} $Ligne]} { continue }
incr NbLignes
if {$NbLignes>2 \
|| [regexp "!!AA_SEQUENCE" $Ligne] \
|| [regexp "ID " $Ligne] | [regexp ">>" $Ligne] \
|| [regexp -nocase "Reformat of" $Ligne] \
|| [regexp {[\:\|]} $Ligne]} {
lappend LesRapportsSequence $F
break
}
if {$NASeq} {
if {[regexp "^ProduitPCR" $Ligne]} {
scan $Ligne "%s" Titre
set Decompo [DecomposeLaLigne $Titre "" $F]
if {[lindex $Decompo 0]!={}} {
lappend LesRapportsPPCR_NA "$F $Decompo"
lappend LesFichiersPPCR_NA $F
lappend LesDecomposPPCR_NA $Decompo
break
}
} elseif {[regexp -nocase {_[a-z]+} $Ligne]} {
scan $Ligne "%s" Titre
set Decompo [DecomposeLaLigne $Titre "" $F]
if {[lindex $Decompo 0]!={}} {
lappend LesRapportsOligos_NA "$F $Decompo"
lappend LesFichiersOligos_NA $F
lappend LesDecomposOligos_NA $Decompo
break
}
}
lappend LesRapportsSequence "$F $Decompo"
break
}
if {[regexp "!!NA_SEQUENCE" $Ligne]} {
set NASeq 1
continue
}
if {[regexp "^>ProduitPCR" $Ligne]} {
set Decompo [DecomposeLesLignesDuFichier $F]
if {[lindex $Decompo 0]!={}} {
lappend LesRapportsPPCR "$F $Decompo"
lappend LesFichiersPPCR $F
lappend LesDecomposPPCR $Decompo
break
}
lappend LesRapportsSequence "$F $Decompo"
break
}
regsub -all {[0-9]+} $Ligne "" SansChiffre
regsub -all -- "-" $SansChiffre "" SansChiffre
while {[regexp "__" $SansChiffre] } {regsub -all "__" $SansChiffre "_" SansChiffre}
if {[regexp -nocase {>[^_]+_[a-z]+} $SansChiffre]} {
set Decompo [DecomposeLesLignesDuFichierOligos $F]
Espionne $Decompo
if {[lindex $Decompo 0]!={}} {
lappend LesRapportsOligos "$F $Decompo"
lappend LesFichiersOligos $F
lappend LesDecomposOligos $Decompo
continue
}
lappend LesRapportsSequence $F
continue
}
if {[regexp -nocase {>([a-z0-9]+)} $Ligne Match Signal] && [EstUnSignal $Signal]} {
lappend LesFichiersSignaux $F
break
}
}
}
}
if {0} {
AfficheVariable [join $LesRapportsOligos "\n"] "AvecFetch" Oligos
AfficheVariable [join $LesRapportsOligos_NA "\n"] "AvecFetch" Oligos_NA
AfficheVariable [join $LesRapportsPPCR "\n"] "AvecFetch" ProduitPCR
AfficheVariable [join $LesRapportsPPCR_NA "\n"] "AvecFetch" ProduitPCR_NA
AfficheVariable [join $LesRapportsSequence "\n"] "AvecFetch" Sequences
set Fen [AfficheVariable [join $LesFichiersSignaux "\n"] "AvecFetch" Signaux]
if {$LesFichiersSignaux!={}} {
BoutonneLaFenetre $Fen "Signals inventory" "InventaireDesSignaux \[selection get\]"
}
}
if {[info exists Fournisseur] && [OuiOuNon "Do I save Fournisseur of Oligos"]} {
SauveLesLignes [array get Fournisseur] dans "[RepertoireDuGenome]/fiches/fournisseur"
}
return [list \
$LesFichiersOligos \
$LesFichiersOligos_NA \
$LesFichiersPPCR \
$LesFichiersPPCR_NA \
$LesDecomposOligos \
$LesDecomposOligos_NA \
$LesDecomposPPCR \
$LesDecomposPPCR_NA \
$LesFichiersSignaux \
$LesCommandesDOligos \
]
}
proc LesFichiersDeType {{Type ""} {Rep ""} {GetAll ""}} {
if {$GetAll=="GetAll"} { set GetAll 1 } else { set GetAll 0 }
# set TypeBeton(Oligo) 1
set TypeBeton(Signaux) 1
set TypeBeton(pDONR) 1
set TypeBeton(pDEST) 1
set SpecifDesTypes(All) ""
set SpecifDesTypes(Fusion) ""
set SpecifDesTypes(Rec2) ""
set SpecifDesTypes(Rec1) ""
set SpecifDesTypes(Ppcr) ""
set SpecifDesTypes(Oligo) ".tfa"
set SpecifDesTypes(Header) "header*"
set SpecifDesTypes(Signaux) "signaux"
set SpecifDesTypes(Matrice) ""
set SpecifDesTypes(Construction) "*.tfa"
set SpecifDesTypes(pDONR) "p*.tfa"
set SpecifDesTypes(pDEST) "p*.tfa"
set RepertoireDesTypes(All) "./"
set RepertoireDesTypes(Fusion) "[RepertoireDuGenome]/fusion"
set RepertoireDesTypes(Rec2) "[RepertoireDuGenome]/rec2"
set RepertoireDesTypes(Rec1) "[RepertoireDuGenome]/rec1"
set RepertoireDesTypes(Ppcr) "[RepertoireDuGenome]/ppcr_virtuels"
set RepertoireDesTypes(Oligo) "[RepertoireDuGenome]/oligos"
set RepertoireDesTypes(Header) "[GscopeEtc]"
set RepertoireDesTypes(Signaux) "[RepertoireDuGenome]/signaux"
set RepertoireDesTypes(Matrice) "[RepertoireDuGenome]/matrices"
set RepertoireDesTypes(Construction) "[RepertoireDuGenome]/constructions"
set RepertoireDesTypes(pDONR) "[RepertoireDuGenome]/vecteurs/pDONR"
set RepertoireDesTypes(pDEST) "[RepertoireDuGenome]/vecteurs/pDEST"
if {[info exists SpecifDesTypes($Type)]} {
set Specif [set SpecifDesTypes($Type)]
} else {
set Specif $Type
}
if {$Rep==""} {
if {[info exists RepertoireDesTypes($Type)]} {
set Rep [set RepertoireDesTypes($Type)]
} else {
set Rep $Type
}
}
set LesPossibles {}
if { ! [info exists TypeBeton($Type)] && $SpecifDesTypes($Type)!=""} {
set Ici [pwd]
set LesLocaux [glob -nocomplain -type {f l} "$Ici/*$Specif*"]
set LesLocaux2 [glob -nocomplain -type {f l} "$Ici/*/*$Specif*"]
LConcat LesPossibles $LesLocaux
LConcat LesPossibles $LesLocaux2
}
set LesCommuns [glob -nocomplain -type {f l} "$Rep/*$Specif*"]
set LesCommuns2 [glob -nocomplain -type {f l} "$Rep/*/*$Specif*"]
LConcat LesPossibles $LesCommuns
LConcat LesPossibles $LesCommuns2
set LesPossiblesTmp [lsort -unique $LesPossibles]
set LesPossibles {}
foreach Possi $LesPossiblesTmp {
if {[regexp "~$" $Possi]} { continue }
lappend LesPossibles $Possi
}
if {$GetAll} { return $LesPossibles }
set LesBons {}
while {1} {
set TexteType $Type
if {$Type=="All"} { set TexteType "file" }
set LesBons [MorceauxChoisisAndMore $LesPossibles $LesBons \
"Please select a $TexteType in the left window and press '--->'\n\
Reorder with 'Up' and 'Down' if necessary.\n\
Press 'More' if you want to add your own file."]
if {$LesBons=={} && [OuiOuNon "Do You want an empty list ?"]} { return {} }
if {$LesBons=={} && [OuiOuNon "Do You want to select your own files ?"] \
|| [lindex $LesBons end]=="MorePlease"} {
set Perso [ButineArborescence "All" "."]
if {$Perso!=""} { lappend LesPossibles $Perso }
continue
} elseif {[lindex $LesBons end]=="Selection"} {
FaireLire "Enter a regular expression to select some of these files"
set ExpReg [Entre "YOURTEXT"]
set LesNouveauxPossibles {}
foreach Possi $LesPossibles {
if { ! [regexp $ExpReg $Possi]} { continue }
lappend LesNouveauxPossibles $Possi
}
set LesPossibles $LesNouveauxPossibles
continue
} else {
break
}
}
set LesBonsBons {}
foreach Bon $LesBons {
set Mot ""
scan $Bon "%s" Mot
if {$Mot==""} { continue }
lappend LesBonsBons $Mot
}
return $LesBonsBons
}
proc GenereOligos {{Construction ""} {SavSapFavFap ""}} {
Wup "Construction is the name of a TFAs file"
Wup "SavSapFavFap a list of LesAvants LesApres FichierDesAvants FichierDesApres"
while {$SavSapFavFap==""} {
set SavSapFavFap [ChoisisFichierSignauxEtSignaux]
if {$SavSapFavFap=={} && [OuiOuNon "Do You want an empty list of signals ?"]} { break }
if {$SavSapFavFap=={} && [OuiOuNon "Do I cancel GenereOligos ?"]} { return {} }
}
if {$Construction==""} {
FaireLire "Please choose only ONE construction file"
set Construction [lindex [LesFichiersDeType "Construction"] 0]
if {$Construction=="" && [OuiOuNon "Do I cancel GenereOligos ?"]} { return {} }
}
set Sortie [OligosEtProduitsPCR $Construction $SavSapFavFap]
return $Sortie
}
proc GestionDesClones {} {
set LesEtapes [MorceauxChoisis [list \
10_MutateSequence \
11_CreateOligosForMutation \
13_CreateOligosForSequencing \
15_GenereFragments \
16_GenereOligos \
22_CommandeOligos \
23_StockeOligos \
31_RecombinaisonPremiere \
32_DepartSequencage \
33_VerificationSequencage \
41_RecombinaisonSeconde \
42_Extension5Prime \
51_AfficheFusionEtCoupure \
52_CoupureDesADNCirculaires \
55_OligAuto \
60_WebOrder \
70_AnalyseDesSequences] \
"" "Please select one or more steps to perform."]
set SortieMutateSequence ""
set SortieCreateOligosForMutation ""
set SortieGenereFragments ""
set SortieGenereOligos ""
set FichierOligos ""
set FichierProduitsPCR ""
set FichierStockeOligos ""
set SortieCommandeOligos ""
set SortieStockeOligos ""
set SortieRecombinaisonPremiere ""
set SortieRecombinaisonSeconde ""
set SortieExtension5Prime ""
set SortieDepartSequencage ""
set SortieVerificationSequencage ""
set SortieCoupureDesADNCirculaires ""
set OldEtape ""
foreach Etape [lsort $LesEtapes] {
regsub {[0-9A-Z]+_} $Etape "" Etape
if {$Etape=="StockeOligos" && $OldEtape=="CommandeOligos"} { continue }
if {$Etape=="GenereFragments" && $OldEtape=="CreateOligosForMutation"} { continue }
if {$Etape=="GenereOligos" && $OldEtape=="CreateOligosForMutation"} { continue }
if {$Etape=="GenereFragments" && $OldEtape=="CreateOligosForSequencing"} { continue }
if {$Etape=="GenereOligos" && $OldEtape=="CreateOligosForSequencing"} { continue }
set OldEtape $Etape
switch -regexp $Etape {
"MutateSequence" {
while 1 {
set FichierDesMutations ""
if {[OuiOuNon "Can You browse for a file with lines containing\n\
PGS018 PGS518 S379R -M1 ( creates PGS518 alias hRAR-M1 )\n\
PGS018 PGS618 S379R E245A -M2 ( creates PGS618 alias hRAR-M2 )\n\
PGS025 PGS525 S379R E245A =MutedRARg ( creates PGS525 alias MutedRARg )"]} {
set FichierDesMutations [ButineArborescence "All"]
if {$FichierDesMutations==""} { continue }
break
} else {
if {[OuiOuNon "Do You want to enter [PreFixe] and mutation code ?"]} { break }
if {[OuiOuNon "Do we cancel MutateSequence ?"]} { continue }
if {[OuiOuNon "Do we cancel the whole process ?"]} { return "" }
}
}
if {$FichierDesMutations==""} {
set SortieMutateSequence [MutateSequence]
} else {
set SortieMutateSequence [MutateSequencesListedIn $FichierDesMutations]
}
while {[OuiOuNon "Do I save the description file of these mutations ?"]} {
regsub {\.codemut.*$} $FichierDesMutations "" FichierDesMutationsFaites
set FichierDesMutationsFaites "$FichierDesMutationsFaites.mutedone"
set FichierDesMutationsFaites [FichierPourSaveAs $FichierDesMutationsFaites]
if {$FichierDesMutationsFaites==""} { continue }
Sauve $SortieMutateSequence dans $FichierDesMutationsFaites
break
}
}
"CreateOligosForMutation" {
set FichierOuTexteOliMut ""
if {$SortieMutateSequence!=""} {
set FichierOuTexteOliMut $SortieMutateSequence
} else {
if {[OuiOuNon "can You browse for a file with lines containing\n\
PGS018 PGS518 S379R\n\
PGS018 PGS618 S379R E245A\n\
PGS025 PGS525 Q334T I289W P345LL"]} {
set FichierOuTexteOliMut [ButineArborescence All]
}
}
set SortieCreateOligosForMutation [CreateOligosForMutation $FichierOuTexteOliMut]
set FichierOligos $SortieCreateOligosForMutation
}
"CreateOligosForSequencing" {
set FichierOuTexteOliSeq ""
while 1 {
if {[OuiOuNon "Do You have a file with [PreFixe]s or fragments to sequence ?"]} {
set FichierOuTexteOliSeq [ButineArborescence All]
} elseif {[OuiOuNon "Do You want to enter it ?"]} {
FaireLire "Remember that you can add lines with (AA count)\n\
PGS160 SeqCheck\n\
PGS161 120 989"
set CancelOFOFS 0
while { $FichierOuTexteOliSeq==""} {
set FichierOuTexteOliSeq [string trim [EntreTexte] "\n"]
Espionne $FichierOuTexteOliSeq
if {$FichierOuTexteOliSeq==""} {
if {[OuiOuNon "May be You forgot to Validate\nTry again ?"]} {
continue
}
if {[OuiOuNon "Do You want to cancel CreationOfOligosForSequencing ?"]} {
set CancelOFOFS 1
break
}
}
}
if {$CancelOFOFS} { break }
}
if {$FichierOuTexteOliSeq!=""} { break }
if {[OuiOuNon "Do You want to cancel CreationOfOligosForSequencing ?"]} { break }
}
if {$FichierOuTexteOliSeq==""} {
set SortieCreateOligosForSequencing ""
} else {
set SortieCreateOligosForSequencing [CreateOligosForSequencing $FichierOuTexteOliSeq]
}
set FichierOligos $SortieCreateOligosForSequencing
}
"GenereFragments" {
set SortieGenereFragments [GenereFragments]
}
"GenereOligos" {
set SortieGenereOligos [GenereOligos $SortieGenereFragments]
set FichierOligos [lindex $SortieGenereOligos 0]
set FichierProduitsPCR [lindex $SortieGenereOligos 1]
}
"CommandeOligos|StockeOligos" {
if {$FichierOligos==""} {
set LesFichiersOligos [LesFichiersDeType "Oligo"]
} else {
set LesFichiersOligos [list $FichierOligos]
}
set StockeOnly ""
if {[regexp "StockeOligos" $Etape]} {
set StockeOnly "StockeOnly"
}
set SortieCommandeOligos [CommandeOligos $LesFichiersOligos $StockeOnly]
}
"RecombinaisonPremiere" {
set RepPPCR "[RepertoireDuGenome]/ppcr"
if {$FichierProduitsPCR==""} {
set LesFichiersUnProduitPCR {}
foreach FichierProduitsPCR [LesFichiersDeType "Ppcr"] {
if {[regexp "ppcr_virtuels" $FichierProduitsPCR]} {
set LesNouveauxFichiersUnProduitPCR [list $FichierProduitsPCR]
} else {
if {[OuiOuNonMemo "Do I keep the filenames for single TFA file instead of Use_access"]} {
if {[string first ">" [ContenuDuFichier $FichierProduitsPCR] 2]>-1} {
FaireLire "Attention there are more than 1 sequence in $FichierProduitsPCR\n\
I'll split it, using the access as filename"
set LesNouveauxFichiersUnProduitPCR [LesFichiersUnAUnDuTFAs $FichierProduitsPCR \
$RepPPCR "Use_access_but_remove_signals"]
} else {
set LesNouveauxFichiersUnProduitPCR $FichierProduitsPCR
}
} else {
set LesNouveauxFichiersUnProduitPCR [LesFichiersUnAUnDuTFAs $FichierProduitsPCR \
$RepPPCR "Use_access_but_remove_signals"]
}
}
LConcat LesFichiersUnProduitPCR $LesNouveauxFichiersUnProduitPCR
}
} else {
set LesFichiersUnProduitPCR [LesFichiersUnAUnDuTFAs $FichierProduitsPCR \
$RepPPCR "Use_access_but_remove_signals"]
}
set FichierVecteur [LesFichiersDeType "pDONR"]
set NomVec [file tail $FichierVecteur]
regsub ".tfa$" $NomVec "" NomVec
set LesFichiersRecombinaisonPremiere {}
foreach FichierUnPPCR $LesFichiersUnProduitPCR {
set Queue [file tail $FichierUnPPCR]
regsub "\.tfa$" $Queue "" Queue
set FichierRecombinaison "[RepertoireDuGenome]/rec1/${Queue}_$NomVec"
lappend LesFichiersRecombinaisonPremiere [Recombinaison \
$FichierUnPPCR $FichierVecteur $FichierRecombinaison "" "Premiere"]
}
set SortieRecombinaisonPremiere $LesFichiersRecombinaisonPremiere
Rec1 ReLoad
}
"DepartSequencage" {
if {$SortieRecombinaisonPremiere!=""} {
set Source $SortieRecombinaisonPremiere
} else {
set Source ""
}
set SortieDepartSequencage [DepartSequencage $Source]
}
"VerificationSequencage" {
set Source [ChoixParmi [list "GATC" "GetMacSeq" "AskForSequence"]]
set BanqueSpecif ""
while {[OuiOuNon "Do I use a [PreFixe] specific \
blast database for all sequences You'll choose" 0]} {
while 1 {
set SpecifPGS [Entre [PreFixe]]
if {[EstUnPAB $SpecifPGS]} { break }
set SpecifPGS [NomDuAlias $SpecifPGS]
if {[EstUnPAB $SpecifPGS]} { break }
}
if {$SpecifPGS==""} { continue }
set BanqueSpecif "Specif_$SpecifPGS"
set BanqueSpecif [CreeLaBanqueBlastClonage $BanqueSpecif $SpecifPGS]
break
}
set SortieVerificationSequencage [VerificationSequencage $Source $BanqueSpecif]
}
"RecombinaisonSeconde" {
if {$SortieRecombinaisonPremiere!=""} {
set LesFichiersRecombinaisonPremiere $SortieRecombinaisonPremiere
} else {
set LesFichiersRecombinaisonPremiere [LesFichiersDeType "Rec1"]
}
set LesFichierVecteur [LesFichiersDeType "pDEST"]
set LesFichiersRecombinaisonSeconde {}
foreach FichierRec1 $LesFichiersRecombinaisonPremiere {
foreach FichierVecteur $LesFichierVecteur {
set NomVecteur [file tail $FichierVecteur]
regsub ".tfa$" $NomVecteur "" NomVecteur
regsub "/rec1/" $FichierRec1 "/rec2/" FichierRec2
regsub ".tfa$" $FichierRec2 "" FichierRec2
append FichierRec2 "_$NomVecteur"
lappend LesFichiersRecombinaisonSeconde [Recombinaison \
$FichierRec1 $FichierVecteur $FichierRec2 "" "Seconde"]
}
}
set SortieRecombinaisonSeconde $LesFichiersRecombinaisonSeconde
Rec2 ReLoad
}
"Extension5Prime" {
if {$SortieRecombinaisonSeconde!=""} {
set LesFichiersRecombinaisonSeconde $SortieRecombinaisonSeconde
} else {
set LesFichiersRecombinaisonSeconde [LesFichiersDeType "Rec2"]
}
set LesFiFuN {}
foreach FichierRec2 $LesFichiersRecombinaisonSeconde {
set FiFuNP [CreeLesFichiersExtension5PrimeDeRec2 $FichierRec2]
if {$FiFuNP!=""} {
scan $FiFuNP "%s" FiFuN
lappend LesFiFuN $FiFuN
}
}
set SortieExtension5Prime $LesFiFuN
}
"AfficheFusionEtCoupure" {
if {$SortieExtension5Prime!=""} {
set LesFiFuN $SortieExtension5Prime
} else {
set LesFiFuN [LesFichiersDeType "Fusion"]
}
if {$LesFiFuN!=""} {
set LesPep [AffichePeptideSortPourLesFusions $LesFiFuN "Ask"]
}
}
"CoupureDesADNCirculaires" {
set SortieCoupureDesADNCirculaires [CoupureDesADNCirculaires]
}
"OligAuto" {
set SortieOligAuto [OligAuto]
}
"WebOrder" {
set SortieWebOrder [WebOrder]
}
}
}
}
proc VerificationSequencage {{LesFichiersDeSequences ""} {FichierOuBanqueCible ""} {FastaOuBlast ""}} {
JeMeSignale
Wup "LesFichiersDeSequences can be a list of TFA files, a TFAs file or GetMacSeq or AskForsequence"
set LesFichiersCibles {}
if {$FichierOuBanqueCible==""} { set FichierOuBanqueCible "All" }
if {$FichierOuBanqueCible=="All"} { set CibleEstAll 1 } else { set CibleEstAll 0 }
if {$FichierOuBanqueCible=="Rec1OfQuery"} { set CibleEstRec1 1 } else { set CibleEstRec1 0 }
if {[regexp "/Specif_" $FichierOuBanqueCible]} { set CibleEstNom 1 } else { set CibleEstNom 0 }
if {$FastaOuBlast==""} {
if {$CibleEstAll || $CibleEstNom} {
set FastaOuBlast "Blast"
} else {
set FastaOuBlast "Fasta"
}
}
if {$LesFichiersDeSequences=="AskForSequence"} {
set LesFichiersDeSequences [LesFichiersDeType "All"]
}
if {$LesFichiersDeSequences=="GATC"} {
set LesFichiersDeSequences [GetFromGATC]
}
if {$LesFichiersDeSequences=="GetMacSeq" || [regexp "^User_" $LesFichiersDeSequences]} {
if {[regexp "^User_" $LesFichiersDeSequences]} {
set User [StringSuivant "User_" dans $LesFichiersDeSequences]
} else {
set User ""
}
set LesFichiersDeSequences [GetMacSeq $User]
}
if {[llength $LesFichiersDeSequences]==0} { return {} }
if {[llength $LesFichiersDeSequences] >1} {
set LesBons {}
set LesDout {}
set UniqueBC [lindex $FichierOuBanqueCible 0]
foreach FS $LesFichiersDeSequences BC $FichierOuBanqueCible {
if {$BC==""} { set BC $UniqueBC }
set LeRetour [VerificationSequencage $FS $BC $FastaOuBlast]
foreach Bon [lindex $LeRetour 0] Dou [lindex $LeRetour 1] {
lappend LesBons $Bon
lappend LesDout $Dou
}
}
return [list $LesBons $LesDout]
}
if {[llength $LesFichiersDeSequences]==1 && [file exists $LesFichiersDeSequences]} {
set LesFicTFA {}
set LesCiblesAll {}
set LesCiblesNom {}
set LesCiblesRec1 {}
foreach Access [LaSequenceDuTFAs $LesFichiersDeSequences "LaListeDesAccess"] {
Espionne $Access
set BelAccess $Access
# regsub -nocase {_A[12]$} $Access "" BelAccess
# set BelAccess "${BelAccess}_Sequenced"
set TFA [LaSequenceDuTFAs $LesFichiersDeSequences $Access]
if {[regexp -nocase {_A[12](_|$)} $Access Match]} {
if {0 && [regexp -nocase "A2" $Match]} {
# set BelAccess "${BelAccess}RaC"
set BelAccess $Access
set RacSeq [NucToReverseAndComplementNuc [QueLaSequenceDuTexteTFA $TFA]]
set TFA [SequenceFormatTFA $RacSeq "$Access RaC by Gscope" "nucbrut"]
}
}
set Rep "[RepertoireDuGenome]/retoursequencage"
set FicTFA [Sauve $TFA dans "$Rep/$BelAccess.tfa"]
if {$CibleEstAll} {
lappend LesCiblesAll "[RepertoireDuGenome]/banques/AllProGS"
}
if {$CibleEstNom} {
lappend LesCiblesNom $FichierOuBanqueCible
}
if {$CibleEstRec1} {
set Queue [file tail $FicTFA]
regsub ".tfa$" $Queue "" Queue
regsub -nocase {_A[12](_.*|$)} $Queue "" Queue
set LesCibles [LesFichiersQuiCommencentPar "${Queue}_" "[RepertoireDuGenome]/rec1/" ".tfa"]
Espionne "$Queue $LesCibles"
while {[llength $LesCibles]==0} {
if { ! [OuiOuNon "I cannot find the rec1 for $Queue. Can You help me ?" 0]} { break }
set UneCible [ButineArborescence "All" "[RepertoireDuGenome]/rec1/"]
if {$UneCible!=""} { set LesCibles [list $UneCible] ; break }
}
if {[llength $LesCibles]==0} { continue }
if {[llength $LesCibles]>1} {
FaireLire "Please help me to choose te rec1 file"
}
set Cible [ChoixParmi $LesCibles]
lappend LesCiblesRec1 $Cible
}
lappend LesFicTFA $FicTFA
}
if {$LesFicTFA !={}} { set LesFichiersDeSequences $LesFicTFA }
if {$LesCiblesAll !={}} { set LesFichiersCibles $LesCiblesAll }
if {$LesCiblesNom !={}} { set LesFichiersCibles $LesCiblesNom }
if {$LesCiblesRec1!={}} { set LesFichiersCibles $LesCiblesRec1 }
} else {
if {[OuiOuNon "You submited a list of TFA files. Does it concern the same Rec1 sequence ?"]} {
}
}
set LesBonsFicQuery {}
set LesDouteuxFicQuery {}
foreach FicQuery $LesFichiersDeSequences FicCible $LesFichiersCibles {
Espionne "FicQuery $FicCible"
set NomQuery [file tail $FicQuery]
set SeqQuery [QueLaSequenceDuFichierTFA $FicQuery]
Wup "if FichierOuBanqueCible is the same for all then LesFichiersCibles is empty"
if {$FicCible==""} { set FicCible $FichierOuBanqueCible }
set FichierTFACible $FicCible
set SeqCible [QueLaSequenceDuFichierTFA $FichierTFACible]
if {[regexp -nocase -indices $SeqQuery $SeqCible]} {
lappend LesBonsFicQuery $FicQuery
continue
}
regsub {\.[^\.]*$} $FicCible "" NomCible
set Banque "$NomCible"
if { $FastaOuBlast=="Blast" && (! [file exists $FichierTFACible] || ! [file exists "$Banque.nhr"])} {
set Banque [CreeBanqueBlastDuFichier $FicCible $NomCible]
}
set FichierTFACible $Banque
set FichierBlast "[RepertoireDuGenome]/retoursequencage/blast/$NomQuery"
regsub ".tfa$" $FichierBlast "" FichierBlast
append FichierBlast ".blast"
if {$FastaOuBlast=="Blast"} {
if {[catch { exec blastall -p blastn -d $Banque -i $FicQuery -F F -v 2000 -b 2000 -o $FichierBlast } Message]} {
FaireLire "I got an error from exec blastall with message\n$Message"
continue
}
} else {
regsub ".blast$" $FichierBlast ".fasta" FichierFasta
Espionne "Je vais faire FastaN $FicQuery $Banque $FichierBlast"
BlastNAvecFastaN $FicQuery $Banque.tfa $FichierBlast $FichierFasta
}
set OnTeste 1
set OnRange 0
if {$OnTeste} {
set Val [VerificationSequencageApprofondie $FicQuery $FichierBlast "Show" "AvecRetour"]
if {$Val==""} { set Val 0 } else { set Val 1 }
if {$Val} {
lappend LesBonsFicQuery $FicQuery
} else {
lappend LesDouteuxFicQuery $FicQuery
}
}
if {$OnRange} {
DecortiqueBlast $FichierBlast "SansSeuilExpect" "SansLimiteDeNombre" \
Query lBanqueId lAccess lDE lProfil lPN]
}
}
return [list $LesBonsFicQuery $LesDouteuxFicQuery]
}
proc GetFromGATC {{SourceDir ""} {LocalDir ""}} {
if {$LocalDir==""} {
FaireLire "Please browse for the local directory to store the .tfa files"
set LocalDir [tk_chooseDirectory -mustexist 1 -initialdir "./"]
if {$LocalDir==""} { return "" }
}
if {$SourceDir==""} {
FaireLire "Please browse for the directory containing the .seq sequences"
set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[pwd]"]
if {$Rep==""} { return "" }
set SourceDir $Rep
}
set LesDispos [lsort [glob -nocomplain -type f "$SourceDir/*.seq"]]
set LesChoix [MorceauxChoisis $LesDispos]
set LesFichiersTFA {}
set LesSeq {}
foreach Choix $LesChoix {
set Queue [file tail $Choix]
regsub ".seq$" $Queue "" NomDeBapteme
set Destin "$LocalDir/$NomDeBapteme.tfa"
if {[file exists $Destin]} {
if { ! [OuiOuNon "$Destin already exists.\n Do I overwrite ?"]} { continue }
}
set Seq [ContenuDuFichier $Choix]
if {[regexp "edited with PhredPhrap" $Seq]} {
set ID [StringApres "ID: " dans $Seq]
if {$ID==$NomDeBapteme} {
regsub ">" $Seq ">$ID " Seq
} else {
FaireLire "$Choix contains no ID with $ID\n$Seq"
}
set FichierTFA [Sauve $Seq dans $Destin]
} else {
FaireLire "I didn't find 'edited with PhredPhrap' in $Choix\nI'll continue expecting fastaformat, gcgformat or raw sequence"
if {[regexp {^>} $Seq]} {
set TFA $Seq
} elseif {[regexp {\.\. *\n} $Seq]} {
set TFA [SequenceFormatTFA $Seq $NomDeBapteme "gcgmaybe"]
} else {
regsub -all {[ \n\t0-9]} $Seq "" Seq
if {[regexp -nocase {[^ATGCN]} $Seq]} {
FaireLire "The sequence file $Choix contains illegal characters\n$Seq"
}
set TFA [SequenceFormatTFA $Seq $NomDeBapteme "nucbrut"]
}
set FichierTFA [Sauve $TFA dans $Destin]
}
lappend LesFichiersTFA $FichierTFA
}
return $LesFichiersTFA
}
proc GetMacSeq {{SourceDir ""} {LocalDir ""} {User ""}} {
set RepDe(huet) "titus:/us1/user/SEQUENCEUR/HUET_Tiphaine"
set RepDe(eiler) "titus:/us1/user/SEQUENCEUR/EILER_Sylvia"
set RepDe(dock) "titus:/us1/user/SEQUENCEUR/Dock-Bregeon"
set RepDe(wassim) "titus:/us1/user/SEQUENCEUR/ABDULRAHMAN_Wassim"
set RepDe(fmichel) "titus:/us1/user/SEQUENCEUR/MICHEL_Fabrice"
set RepDe(djbusso) "titus:/us1/user/SEQUENCEUR/BUSSO_Didier"
set RepDe(arnaud) "titus:/us1/user/SEQUENCEUR/POTERSZMAN_Arnaud"
set RepDe(flatter) "titus:/us1/user/SEQUENCEUR/FLATTER_Eric"
set RepDe(desseric) "titus:/us1/user/SEQUENCEUR/DESSERICH_Vincent"
set RepDe(brelivet) "titus:/us1/user/SEQUENCEUR/BRELIVET_Yann"
set RepDe(bey) "titus:/us1/user/SEQUENCEUR/BEY_Gilbert"
set RepDe(iwema) "titus:/us1/user/SEQUENCEUR/IWEMA_Thomas"
set RepDe(billas) "titus:/us1/user/SEQUENCEUR/BILLAS_Isabelle"
set RepDe(flatter) "titus:/us1/user/SEQUENCEUR/FLATTER_Eric"
set RepDe(ruff) "titus:/us1/user/SEQUENCEUR/RUFF_Marc"
set RepDe(eddy) "titus:/us1/user/SEQUENCEUR/TROESCH_Edouard"
set RepDe(troffer) "titus:/us1/user/SEQUENCEUR/TROFFER-Nathalie"
set RepDe(uhring) "titus:/us1/user/SEQUENCEUR/UHRING_Muriel"
set RepDe(ripp) "titus:[HomeRipp]/SEQUENCAGE"
foreach U [lsort [array names RepDe]] {
lappend LesRepDe [set RepDe($U)]
}
lappend LesRepDe "Other"
if {$LocalDir==""} {
FaireLire "Please browse for the local directory to store the tfa files"
set LocalDir [tk_chooseDirectory -mustexist 1 -initialdir "./"]
if {$LocalDir==""} { return "" }
}
if {[regexp "titus\:" $SourceDir] || \
($SourceDir=="" && \
[OuiOuNon "Do I connect to titus to search for sequences ?"])} {
global env
if {$User==""} { set User [set env(USER)] }
while { ! [OuiOuNon "Do I use User $User to connect to Titus ?"]} {
set User [Entre $User]
if {$User=="" && [OuiOuNon "Do I cancel GetMacSeq ?"]} { return "" }
}
set SourceDir "titus:/us1/user/SEQUENCEUR/[string totitle $User]"
if {[info exists RepDe($User)]} { set SourceDir [set RepDe($User)] }
while { ! [OuiOuNon "Do I search in \n$SourceDir directory ?"]} {
set SourceDir [ChoixParmi $LesRepDe]
if {$SourceDir!="Other" && $SourceDir!=""} { break }
set SourceDir [Entre $SourceDir]
if {$SourceDir=="" && [OuiOuNon "Do I cancel GetMacSeq ?" ]} { return "" }
}
regsub "^titus\:" $SourceDir "" UserDir
set Dispos [exec rsh titus -l $User ls $UserDir/*.seq]
if {$Dispos==""} { return "" }
} elseif { $SourceDir!="" || [OuiOuNon "Do I browse for raw DNA files ?"]} {
set Rep [tk_chooseDirectory -mustexist 1 -initialdir "[pwd]"]
if {$Rep==""} { return "" }
set Dispos [join [lsort [glob -nocomplain -type f "$Rep/*.seq"]] "\n"]
}
set LesChoix [MorceauxChoisis [split $Dispos "\n"]]
set LesFichiersTFA {}
set LesSeq {}
foreach Choix $LesChoix {
set Queue [file tail $Choix]
regsub ".seq$" $Queue "" NomDeBapteme
set Destin "$LocalDir/$NomDeBapteme.tfa"
if {[file exists $Destin]} {
if { ! [OuiOuNon "$Destin already exists.\n Do I overwrite ?"]} { continue }
}
set ChromaSurTitus ""
if {[regexp "^titus\:" $SourceDir]} {
set FichierSurTitus "$SourceDir/$Queue"
Espionne $FichierSurTitus
regsub ".seq$" $FichierSurTitus ".ab1" ChromaSurTitus
set FiSeq [TmpFile].seq
exec rcp $FichierSurTitus $FiSeq
if { ! [file exists $FiSeq]} {
FaireLire "Problem executing\nrcp $FichierSurTitus [TmpFile].seq"
continue
}
set Seq [ContenuDuFichier $FiSeq]
File delete -force $FiSeq
} else {
set Seq [ContenuDuFichier $Choix]
}
if {[regexp {\.\. *\n} $Seq]} {
set TFA [SequenceFormatTFA $Seq $NomDeBapteme "gcgmaybe"]
} else {
regsub -all {[ \n\t0-9]} $Seq "" Seq
if {[regexp -nocase {[^ATGCN]} $Seq]} {
FaireLire "The sequence file $Choix contains illegal characters\n$Seq"
}
set TFA [SequenceFormatTFA $Seq $NomDeBapteme "nucbrut"]
}
set FichierTFA [Sauve $TFA dans $Destin]
if {$ChromaSurTitus!=""} {
regsub ".tfa$" $FichierTFA "" ChromaIci
append ChromaIci ".ab1"
if {[catch { exec rcp $ChromaSurTitus $ChromaIci } Message]} {
FaireLire "I tried \nexec rcp $ChromaSurTitus $ChromaIci\and got the message\n$Message"
}
}
lappend LesFichiersTFA $FichierTFA
}
return $LesFichiersTFA
}
proc TestRecombinaisonEtFusion {} {
set LespD [list \
"[RepertoireDuGenome]/vecteurs/pet15b-FLAG-gcassette-frameA.tfa" \
"[RepertoireDuGenome]/vecteurs/pETG60A.tfa" \
"[RepertoireDuGenome]/vecteurs/pETG28c2.tfa" \
"[RepertoireDuGenome]/vecteurs/pDEST10.tfa" ]
set LespD [ChoixDesPresents $LespD]
set LesR1 [ChoixDesPresents [glob -nocomplain "[RepertoireDuGenome]/rec1/*.tfa"]]
set LesFiFuN {}
foreach R1 $LesR1 {
set QR1 [file tail $R1]
regsub ".tfa$" $QR1 "" QR1
foreach pD $LespD {
Espionne "[file tail $R1] [file tail $pD]"
set QpD [file tail $pD]
regsub ".tfa$" $QpD "" QpD
set D "[RepertoireDuGenome]/rec2/${QR1}_$QpD.tfa"
if { ! [file exists $D]} {
Espionne [Recombinaison $R1 $pD $D "" "Seconde"]
}
if { ! [file exists $D]} { Warne "$D\nwas not created. I'll skipp." ; continue }
set FiFuNP [CreeLesFichiersExtension5PrimeDeRec2 $D]
if {$FiFuNP==""} { continue }
scan $FiFuNP "%s" $FiFuN
lappend LesFiFuN $FiFuN
}
}
return $LesFiFuN
}
proc Recombinaison {FichierSiteB FichierSiteP FichierSiteL {FichierSiteR ""} {PremSec ""}} {
JeMeSignale
set Premiere 0 ; set Seconde 0
if {$PremSec=="Premiere"} { set Premiere 1 }
if {$PremSec=="Seconde"} { set Seconde 1 }
Wup "FichierSiteB must be tfa file."
Wup "FichierSiteP can be with extension .txt or .tfa ..."
Wup " NomSiteP, BanqueDuSiteP, FichierTFASiteP are equivalent (to FichierSiteP without extension)"
if { ! [file exists $FichierSiteB] } {
FaireLire "$FichierSiteB\n doesn't exist.\nI cancel Recombinaison."
return ""
}
if { ! [file exists $FichierSiteP]} {
FaireLire "$FichierSiteP\n doesn't exist.\nI cancel Recombinaison."
return ""
}
if {[regexp ">" [string range [ContenuDuFichier $FichierSiteB] 1 end]]} {
FaireLire "$FichierSiteB\ncontains more then one sequence. I cancel Recombinaison."
return ""
}
set OriFichierSiteB $FichierSiteB
set FichierSiteB [FichierPpcrSansAttBAdapter $FichierSiteB]
set OriFichierSiteP $FichierSiteP
regsub {\.[^\.]*$} $FichierSiteP "" NomSiteP
set BanqueDuSiteP "$NomSiteP"
set FichierTFASiteP $OriFichierSiteP
if {[regexp ">" [string range [ContenuDuFichier $FichierTFASiteP] 1 end]]} {
FaireLire "$FichierSiteP\ncontains more then one sequence. I cancel Recombinaison."
return ""
}
set UseLambdaIntegrase 0
if {$Premiere} {
set SeqPPCR [QueLaSequenceDuFichierTFA $FichierSiteB]
if {[regexp -nocase [SEQAttB1] $SeqPPCR] && [regexp -nocase [SEQAttB2] $SeqPPCR]} {
if {[OuiOuNonMemo "Do I use the 'Phage Lambda integrase' to do recombination ?"]} {
set UseLambdaIntegrase 1
}
}
}
if {$Seconde} {
set SeqPPCR [QueLaSequenceDuFichierTFA $FichierSiteB]
Espionne "[SEQAttL1] $SeqPPCR"
if {[regexp -nocase [SEQAttL1] $SeqPPCR] && [regexp -nocase [SEQAttL2] $SeqPPCR]} {
if {[OuiOuNonMemo "Do I use the 'Phage Lambda integrase' to do recombination ?"]} {
set UseLambdaIntegrase 1
}
}
}
Espionne "UseLambdaIntegrase is $UseLambdaIntegrase"
if {$UseLambdaIntegrase} {
set SeqSiteP [QueLaSequenceDuFichierTFA $FichierTFASiteP]
if {$Premiere} { set Att1 [SEQAttB1] ; set Att2 [SEQAttB2] }
if {$Seconde } { set Att1 [SEQAttL1] ; set Att2 [SEQAttL2] }
set LesBornes [LesBornesParLambdaIntegrase $SeqPPCR $SeqSiteP $Att1 $Att2]
if {$LesBornes==""} {
set UseLambdaIntegrase 0
} else {
ScanLaListe $LesBornes BN BC PN PC
}
}
if { ! $UseLambdaIntegrase } {
if {[OuiOuNonMemo "Do I skip all recombination WITHOUT LambdaIntegrase ?"]} { return "" }
if { ! [file exists $FichierTFASiteP] || ! [file exists "$BanqueDuSiteP.nhr"]} {
set BanqueDuSiteP [CreeBanqueBlastDuFichier $FichierSiteP $NomSiteP]
}
set FichierTFASiteP $BanqueDuSiteP
set FichierBlast "[TmpFile].blastn"
exec blastall -p blastn -d $BanqueDuSiteP -i $FichierSiteB -F F -o $FichierBlast
if {[OuiOuNonMemo "Do You want to see the blast file ?" 0]} {
AfficheFichier $FichierBlast "AvecEtudeBlastAvecSegAlignement"
}
global SansOffsetEtOrganisme ; set SansOffsetEtOrganisme 1
set LesHomologues [ChaqueSegmentDuBlastN $FichierBlast 0.98989 "" "AvecLaSeq"]
set LesBornesTrouvees {}
foreach Homologie $LesHomologues {
ScanLaListe [split $Homologie "\t"] ChroContigTroncon nCops nCopsDansCetteSequence Orga \
PourcentageIdentiteCacheDansScore Expect \
DebutQuery FinQuery DebutSbjct FinSbjct Sequence
if {[expr ($FinSbjct-$DebutSbjct)<=0]} {
Warne "Reverse sequence in the blast. I'll skipp it"
continue
}
lappend LesBornesTrouvees "$DebutQuery $FinQuery $DebutSbjct $FinSbjct $Sequence"
}
set LesBornesTrouvees [lsort -integer -index 0 $LesBornesTrouvees]
if {[llength $LesBornesTrouvees]<2} {
FaireLire "I found less than 2 hits for \n[PremiereLigneDuFichier $FichierSiteB]\nI cancel"
return ""
}
if {[llength $LesBornesTrouvees]>2} {
Warne "I found more than 2 hits. I'll eliminate those larger than 40."
set LesBornesGardees {}
foreach Bo $LesBornesTrouvees {
scan $Bo "%d %d %d %d %s" DQ FQ DS FS Sq
if {[expr ($FQ-$DQ) > 40]} { continue }
lappend LesBornesGardees $Bo
}
if {[llength $LesBornesGardees]!=2} {
FaireLire "I found more than 2 hits. Please select two of them."
AfficheFichier $FichierBlast "AvecEtudeBlastAvecSegAlignement"
set LesBons [MorceauxChoisis $LesBornesTrouvees]
} else {
set LesBons $LesBornesGardees
}
} else {
set LesBons $LesBornesTrouvees
}
if {[llength $LesBons]!=2} {
FaireLire "I found less than 2 hits for \n[PremiereLigneDuFichier $FichierSiteB]\nI cancel"
return ""
}
foreach Essai {1 2} {
scan [lindex $LesBons 0] "%d %d %d %d" dBN fBN dPN fPN
scan [lindex $LesBons 1] "%d %d %d %d" dBC fBC dPC fPC
if {($dBN < $dBC && $dPN < $dPC)} { break }
Warne "There is a problem with the order of the recombination site. I'll change order."
set LesMeilleurs {}
lappend LesMeilleurs [lindex $LesBons 1]
lappend LesMeilleurs [lindex $LesBons 0]
set LesBons $LesMeilleurs
}
if {[expr ! ($dBN < $dBC && $dPN < $dPC)]} {
Warne "I'll cancel creation of rec for \n $FichierSiteB"
return ""
}
set MiN [expr ($fBN-$dBN)/2]
set BN [expr $dBN+$MiN]
set PN [expr $dPN+$MiN]
set MiC [expr ($fBC-$dBC)/2]
set BC [expr $dBC+$MiC]
set PC [expr $dPC+$MiC]
}
set SeqB [QueLaSequenceDuFichierTFA $FichierSiteB]
set SeqP [QueLaSequenceDuFichierTFA $FichierTFASiteP]
set SeqL ""
append SeqL [string range $SeqP 0 [expr $PN-1]]
append SeqL [string range $SeqB $BN $BC]
append SeqL [string range $SeqP [expr $PC+1] end]
set SeqR ""
append SeqR [string range $SeqB 0 [expr $BN-1]]
append SeqR [string range $SeqP $PN $PC]
append SeqR [string range $SeqB [expr $BC+1] end]
set NomB [file tail $OriFichierSiteB]
regsub ".tfa$" $NomB "" NomB
set NomP [file tail $OriFichierSiteP]
regsub ".tfa$" $NomP "" NomP
set BonTitre ""
while {$BonTitre==""} {
set EnteteB [EnteteDuFichierTFA $FichierSiteB]
set EnteteL ""
if {$Seconde && [file exists $FichierSiteL]} {
set EnteteL [EnteteDuFichierTFA $FichierSiteL]
}
set Vecteur [EnteteDuFichierTFA $FichierSiteP "access"]
if {[regexp " Rec2 in " $EnteteB]} {
if {[OuiOuNon "$EnteteB is a Rec2 file.\n\Do I cancel recombinaison ?"]} {
return ""
}
}
if {$Premiere && [regexp " Rec1 in " $EnteteB]} {
if {[OuiOuNon "$EnteteB is a Rec1 file and You want to do a rec1.\n\ Do I cancel recombinaison ?"]} {
return ""
}
}
if {[regexp " Rec1 in " $EnteteB]} {
regsub ">" $EnteteB "" TitreDuRec1
set BonTitre "Rec2 in $Vecteur of $TitreDuRec1"
break
}
if {[regexp " Ppcr for " $EnteteB]} {
regsub ">" $EnteteB "" TitreDuPpcr
set BonTitre "Rec1 in $Vecteur of $TitreDuPpcr"
break
}
if {[OuiOuNonMemo "You use uses old notation of Ppcr. Do I cancel recombinaison ?"]} { return "" }
# set EnteteL "RecombinaisonL [file tail $OriFichierSiteB] in [file tail $FichierSiteP]"
# set EnteteL "Rec1_${NomB}__$NomP"
set EnteteB [EnteteDuFichierTFA $FichierSiteB "access"]
set Titre ""
if {[regexp "^ProduitPCR_" $EnteteB]} {
regsub -nocase "ProduitPCR_" $EnteteB "" EnteteB
set Titre "Rec1_"
}
if {[regexp "^PPCR_" $EnteteB]} {
regsub -nocase "PPCR_" $EnteteB "" EnteteB
set Titre "Rec1_"
}
if {[regexp "^Rec1_" $EnteteB]} {
regsub -nocase "Rec1_" $EnteteB "" EnteteB
set Titre "Rec2_"
}
set EnteteP [EnteteDuFichierTFA $FichierSiteP "access"]
set pDONR $EnteteP
set EnteteL "${Titre}${EnteteB}_$EnteteP"
set BonTitre ""
set AllEnteteB [EnteteDuFichierTFA $FichierSiteB "all"]
set SonTitre [StringSuivant "Rec1 in " dans $AllEnteteB]
if {$SonTitre==""} {
set SonTitre [StringSuivant "Rec1 with " dans $AllEnteteB]
}
if {$SonTitre!=""} {
set BonTitre "Rec2 with $SonTitre"
} else {
set SonNom ""
scan $AllEnteteB "%s" SonNom
regsub ">" $SonNom "" SonNom
set SonTitre [StringSuivant "Ppcr for " dans $AllEnteteB]
set BonTitre "Rec1 in $pDONR of $SonNom ppcr $SonTitre"
}
}
if {$Premiere} {
if {$EnteteL==""} {
scan $EnteteB "%s" AccessDuEnteteB
set EnteteP [EnteteDuFichierTFA $FichierSiteP "access"]
scan $EnteteP "%s" AccessDuEnteteP
set EnteteL "${AccessDuEnteteB}_$AccessDuEnteteP"
}
}
if {$Seconde} {
if {$EnteteL==""} {
scan $EnteteB "%s" AccessDuEnteteB
set EnteteP [EnteteDuFichierTFA $FichierSiteP "access"]
scan $EnteteP "%s" AccessDuEnteteP
set EnteteL "${AccessDuEnteteB}_$AccessDuEnteteP"
}
}
set TfaL [SequenceFormatTFA $SeqL "$EnteteL $BonTitre" "nucbrut"]
set FSL [Sauve $TfaL dans $FichierSiteL]
if {$FichierSiteR!=""} {
if {[regexp "Rec1" $EnteteL]} {
regsub "" $EnteteL "Rec1R_" EnteteR
}
if {[regexp "Rec2" $EnteteL]} {
regsub "" $EnteteL "Rec1R_" EnteteR
}
set TfaR [SequenceFormatTFA $SeqR $EnteteR "nucbrut"]
set FSR [Sauve $TfaR dans $FichierSiteR]
}
if {[OuiOuNonMemo "Do You want to see the tfa files ?" 0]} {
if {$OriFichierSiteB!=$FichierSiteB} {
AfficheFichier $OriFichierSiteB "AvecFormateAvecBlaste"
}
AfficheFichier $FichierSiteB "AvecFormateAvecBlaste"
AfficheFichier $FichierSiteP "AvecFormateAvecBlaste"
AfficheFichier $FichierTFASiteP "AvecFormateAvecBlaste"
AfficheFichier $FichierSiteL "AvecFormateAvecBlaste"
AfficheFichier $FichierSiteR "AvecFormateAvecBlaste"
}
return $FSL
}
proc CreeAdnDesProduitsPCR Fichier {
set Adn [string repeat "n" 99]
set Numero 0
foreach Access [LaSequenceDuTFAs $Fichier "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $Fichier $Access]
set Entete [lindex [split $TFA "\n"] 0]
scan $Entete "%s %s %s %s" TexteNom TexteLong TexteDebut TexteFin
set DebutProteine [StringApres "debut_" dans $TexteDebut]
set FinProteine [StringApres "fin_" dans $TexteFin]
incr Numero
set D [FormatDesNumerosPourCollection]
set BeauNumero [format "%$D" $Numero]
set Debut [expr [string length $Adn] + $DebutProteine]
set Fin [expr [string length $Adn] + $FinProteine]
set Orient "F"
set Seq [QueLaSequenceDuTexteTFA $TFA]
set lSeq [string length $Seq]
set L [expr (($lSeq + 99)/3)*3 + 1]
set NN [expr $L-$lSeq]
append Adn $Seq
append Adn [string repeat "n" $NN]
set Nom "[PreFixe]$BeauNumero"
lappend LesBornes "$Nom $Debut $Fin $Orient"
}
set AdnTFA [SequenceFormatTFA $Adn "adn create by Gscope" "nucbrut"]
Sauve $AdnTFA dans "adn_des_produits_pcr.tfa"
SauveLesLignes $LesBornes dans "bornes_des_produits_pcr.txt"
return
}
proc CommandeOligos {LesFichiersOligos {NomPresumeDuFichierCommande ""}} {
Wup "LesFichiersOligos can be a list. "
OligoEnStock "Reload"
StockeCetOligo "Reset" ""
if {$NomPresumeDuFichierCommande=="StockeOnly"} { set StockeOnly 1 } else { set StockeOnly 0 }
if {$NomPresumeDuFichierCommande=="" \
|| $NomPresumeDuFichierCommande=="StockeOnly" \
|| [regexp -nocase "^usethisname_" $NomPresumeDuFichierCommande] } {
if {[regexp -nocase "^usethisname_" $NomPresumeDuFichierCommande]} {
regsub "^usethisname_" $NomPresumeDuFichierCommande "" NomPresumeDuFichierCommande
regsub {\.txt} $NomPresumeDuFichierCommande "" NomPresumeDuFichierCommande
} else {
set NomPresumeDuFichierCommande [lindex $LesFichiersOligos 0]
}
regsub {\.(nuc|prot|)tfa$} $NomPresumeDuFichierCommande "" NomPresumeDuFichierCommande
append NomPresumeDuFichierCommande "_commande[Date Nice_H].txt"
}
set LesTFAs {}
set D4 "50N"
set D7 "DSL"
foreach FichierOligos $LesFichiersOligos {
foreach Access [LaSequenceDuTFAs $FichierOligos "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $FichierOligos $Access]
set Seq [QueLaSequenceDuTexteTFA $TFA]
if {[info exists SeqDuAccess($Access)]} {
FaireLire "DejaVu $Access !"
continue
}
#rR Attention BrocOli
set TfaBrocOli [BrocOli $TFA]
if {[WithBrocOli] && $TfaBrocOli!=""} {
set AccBroc [EnteteDuTexteTFA $TfaBrocOli "access"]
Espionne "AccBroc $AccBroc"
lappend TFADuAccessNonBrocOli($AccBroc) $TFA
lappend SeqDuAccessNonBrocOli($AccBroc) $Seq
set TFA $TfaBrocOli
set Seq [QueLaSequenceDuTexteTFA $TFA]
}
#rR Attention BrocOli
set TFADuAccess($Access) $TFA
set SeqDuAccess($Access) $Seq
lappend LesAccessDeSeq($Seq) $Access
lappend LesAccess $Access
}
}
set LeTFADeLaCommande {}
set LaCommande {}
set EnteteDeLaCommande ""
set Fournisseur "Inconnu"
FaireLire "Please select the Scale in Micro Mol to order at Sigma (default is 0.05)"
set SigmaScaleMicroMol [ChoixParmi [list 0.05 0.025 0.05 0.2, 1. 10. 15. "OtherValue"]]
if {$SigmaScaleMicroMol=="OtherValue"} { set SigmaScaleMicroMol [Enter 0.05] }
FaireLire "Please select the Purification to order at Sigma (default is RP1)"
set SigmaPurification [ChoixParmi [list "RP1" "DST" "PAGE" "HPLC" "OtherValue"]]
if {$SigmaPurification=="OtherValue"} { set SigmaPurification [Enter "RP1"] }
set SigmaComment ""
set ListeSigma {}
if { ! $StockeOnly} {
set EnteteDeLaCommande {}
lappend EnteteDeLaCommande " SYNTHESE D'OLIGONUCLEOTIDES - IGBMC"
lappend EnteteDeLaCommande ""
lappend EnteteDeLaCommande " Date de commande : [Date Nice]"
lappend EnteteDeLaCommande ""
lappend EnteteDeLaCommande " Equipe : "
lappend EnteteDeLaCommande " Nom du demandeur : "
lappend EnteteDeLaCommande " Telephone : "
lappend EnteteDeLaCommande ""
lappend EnteteDeLaCommande ""
lappend EnteteDeLaCommande " Sequence 5' -> 3'"
lappend EnteteDeLaCommande ""
set EnteteDeLaCommande [join $EnteteDeLaCommande "\n"]
set Fournisseur "IGBMC"
set NumeroPrimer 1
# if { 0 && ! [OuiOuNon "Do I start Primer numbering with 1 ?"]} {
# set NumeroPrimer [Entre 1]
# }
}
set nPrimer 0
set TotalBases 0
set TotalBasesSansAttB 0
set nAttB1 0
set nAttB2 0
set CompteAttB ""
set LesFichiersOligosStockes {}
set LesNonCreesCarEnStock {}
foreach Access $LesAccess {
set Seq [set SeqDuAccess($Access)]
if {[info exists DejaVu($Seq)]} { continue }
set DejaVu($Seq) 1
if {[set OliEnSto [OligoEnStock $Seq]]!=""} {
set LesAutres [join [set LesAccessDeSeq($Seq)] "\n"]
if {[OuiOuNon "I found an existing oligo $OliEnSto\nfor $LesAutres\n\nDo You use it ?"]} {
foreach A $LesAutres {
set WarningBrocOli ""
if {[Oli $OliEnSto "IsBrocOli"]} {
set GenericOligo [Oli $OliEnSto "ItsGenericOligo"]
set WarningBrocOli " BrocOli with $GenericOligo"
}
lappend LesNonCreesCarEnStock "$A please use $OliEnSto$WarningBrocOli"
}
continue
}
}
set LesEntetes {}
set AppendTexteBrocOli {}
set LesB {}
set LesS {}
foreach Autre [set LesAccessDeSeq($Seq)] {
set TFA [set TFADuAccess($Autre)]
set Entete [EnteteDuTexteTFA $TFA]
Espionne "$Autre pour seq =$Seq="
if {[regexp { BrocOli.+$} $Entete TexteBrocOli]} {
if {$AppendTexteBrocOli!="" && $AppendTexteBrocOli!=$TexteBrocOli} {
FaireLire "Different BrocOli for the same sequence\
\n$Seq\n$AppendTexteBrocOli\n$TexteBrocOli"
}
scan $$TexteBrocOli "%s %s %s %s %s %s" A b w B r S
lappend LesB $B ; set LesB [ListeSansDoublon $LesB]
lappend LesS $S ; set LesS [ListeSansDoublon $LesS]
regsub "$TexteBrocOli" $Entete "" Entete
set AppendTexteBrocOli " BrocOli with [join $LesB "+"] replaces [join $LesS "+"]"
}
regsub -all ">" $Entete "" Entete
lappend LesEntetes $Entete
}
set LesEntetes [ListeSansDoublon $LesEntetes]
set Entete [join $LesEntetes "+"]
if {$AppendTexteBrocOli!=""} { append Entete $AppendTexteBrocOli }
incr nPrimer
incr TotalBases [string length $Seq]
incr TotalBasesSansAttB [string length $Seq]
set PStocke ""
set EntetePourFiStockOl [FormatageEntete $Entete PourOligo "Pxxxx"]
set FichierOligoStocke [StockeCetOligo $EntetePourFiStockOl $Seq "AutoNumbering"]
lappend LesFichiersOligosStockes $FichierOligoStocke
set PStocke [file tail $FichierOligoStocke]
regsub ".tfa$" $PStocke "" PStocke
if {[WithBrocOli]} {
set EnteteBroc [EnteteDuFichierTFA $FichierOligoStocke]
scan $EnteteBroc "%s %s %s %s %s %s %s %s" P X o w s S f A
if {$X=="5'"} { set AccBroc "${S}_$A" } else { set AccBroc "${A}_$S" }
if {[info exists TFADuAccessNonBrocOli($AccBroc)]} {
foreach TFANB $TFADuAccessNonBrocOli($AccBroc) SeqNB $SeqDuAccessNonBrocOli($AccBroc) B $LesB S $LesS {
regsub "BrocOli with .*" $EnteteBroc "BrocOli with $B replaces $S" OneEnteteBroc
Espionne "TFANB de $AccBroc $TFANB"
set EntetePourFiStockOlNB [FormatageEntete $OneEnteteBroc "PourOligoNonBrocOli" "Pxxxx"]
append EntetePourFiStockOlNB " seeBrocken $PStocke"
set FichierOligoStockeNB [StockeCetOligo $EntetePourFiStockOlNB $SeqNB "AutoNumbering"]
lappend LesFichiersOligosStockes $FichierOligoStockeNB
set PStockeNB [file tail $FichierOligoStockeNB]
regsub ".tfa$" $PStockeNB "" PStockeNB
set Monbroc [ContenuDuFichier $FichierOligoStocke]
if {[regexp "seeFull AfterMe" $Monbroc]} {
regsub "seeFull AfterMe" $Monbroc "seeFull $PStockeNB" MonBonBroc
Sauve $MonBonBroc dans $FichierOligoStocke
} else {
if {[regexp {seeFull ([P0-9\+]+)} $Monbroc Match]} {
regsub -all {\+} $Match "\\+" MatchX
regsub $MatchX $Monbroc "$Match+$PStockeNB" MonBonBroc
Sauve $MonBonBroc dans $FichierOligoStocke
}
}
}
}
}
if {$StockeOnly} { continue }
set TFA [SequenceFormatTFA $Seq ">$Entete" "brut"]
lappend LeTFADeLaCommande $TFA
set PduTFA($TFA) $PStocke
set EnteteCourte [FormatageEntete $Entete PourCommande $PStocke]
scan $EnteteCourte "%s %s" P SigSuj
set LS [list $P:$SigSuj $Seq $SigmaScaleMicroMol $SigmaPurification $SigmaComment]
lappend ListeSigma [join $LS ","]
if {$Fournisseur=="Invitrogen" || $Fournisseur=="IGBMC"} {
if {$Fournisseur=="IGBMC"} {
lappend LaCommande [string repeat "-" 66]
lappend LaCommande "$NumeroPrimer $EnteteCourte"
lappend LaCommande ""
set LesTriplets {}
set nTriplets 0
set LesBases [split $Seq ""]
set LesSuivantes [lrange [concat $LesBases [list X X X X X]] 3 end]
set FiveP " 5'"
foreach {a b c} $LesBases {d e f} $LesSuivantes {
lappend LesTriplets "$a$b$c"
set ThatsAllFolks [string equal "$d$e$f" "XXX"]
if {[incr nTriplets]==15 || $ThatsAllFolks} {
set nTriplets 0
set LigneDeTriplets [string toupper [join $LesTriplets " "]]
if {$ThatsAllFolks} {
lappend LaCommande " $FiveP $LigneDeTriplets 3'"
break
} else {
lappend LaCommande " $FiveP $LigneDeTriplets"
}
set LesTriplets {}
set FiveP " "
}
}
lappend LaCommande ""
} else {
lappend LaCommande "*"
lappend LaCommande "D1: $EnteteCourte"
lappend LaCommande "D2: $NumeroPrimer"
set SeqACommander [string toupper $Seq]
set LigneD5 ""
if {[CaCommenceParAttB $SeqACommander] && [NePasMettreAttB]} {
set LongOriginale [string length $SeqACommander]
set SeqACommander [RetireAttB $SeqACommander]
set LongCommandee [string length $SeqACommander]
set LongEconomie [expr $LongOriginale-$LongCommandee]
set TotalBasesSansAttB [expr $TotalBasesSansAttB-$LongEconomie]
if {$LongEconomie>0 && [regexp "AttB1" $Entete]} { set LigneD5 "D5: GWF" ; incr nAttB1 }
if {$LongEconomie>0 && [regexp "AttB2" $Entete]} { set LigneD5 "D5: GWR" ; incr nAttB2 }
set CompteAttB "= $TotalBasesSansAttB without AttB + $nAttB1 AttB1 + $nAttB2 AttB2"
}
lappend LaCommande "D3: $SeqACommander"
lappend LaCommande "D4: $D4"
if {$LigneD5!=""} { lappend LaCommande $LigneD5 }
lappend LaCommande "D7: $D7"
}
} else {
lappend LaCommande "\n>$Entete"
lappend LaCommande $Seq
}
incr NumeroPrimer
continue
}
if {$StockeOnly} { return $LesFichiersOligosStockes }
if {$Fournisseur=="IGBMC"} {
lappend LaCommande ""
lappend LaCommande "------------------------ FIN DE COMMANDE -------------------------"
} else {
lappend LaCommande " + "
}
lappend LaCommande "Total bases $TotalBases $CompteAttB for $nPrimer primers"
lappend LaCommande "End of text automatically created by Gscope (33)388653305"
set LEnteteDeLaCommande [list $EnteteDeLaCommande "HZ: $nPrimer" ""]
set LaCommande [concat $LEnteteDeLaCommande $LaCommande]
set Commande ""
while {$Commande==""} {
set Commande [join $LaCommande "\n"]
set Commande [EntreTexte $Commande]
if {$Commande==""} {
if {[OuiOuNon "Do You want to cancel CommandeOligos ?"]} {
if {[OuiOuNon "Sorry, but I already created the files\n\
[join $LesFichiersOligosStockes "\n"]\n\nCan I delete them ?"]} {
foreach FOS $LesFichiersOligosStockes {
if {[file exists $FOS]} { file delete $FOS }
}
}
return ""
} else {
continue
}
}
}
set WebOrder [OuiOuNon "Do I order these oligos through the [UrlCommandeOligo] Webserver ?"]
while {1} {
FaireLire "Please, tell me name for the TEXT file for oligos_commande (and oligos_weborder)"
set FichierTXTCommandeOligos $NomPresumeDuFichierCommande
set FichierTXTCommandeOligos [FichierPourSaveAs $FichierTXTCommandeOligos]
if {$FichierTXTCommandeOligos==""} {
if {[OuiOuNon "Ok to continue WITHOUT saving the text of the oligos_commande ?"]} { break } else { continue }
}
regsub "_commande" $FichierTXTCommandeOligos "_weborder" FichierTXTWebOrderOligos
regsub "_commande" $FichierTXTCommandeOligos "_sigma" FichierTXTSigmaOligos
regsub ".txt" $FichierTXTSigmaOligos "" FichierTXTSigmaOligos
append FichierTXTSigmaOligos ".csv"
append Commande "\n $FichierTXTCommandeOligos"
append Commande "\n $FichierTXTWebOrderOligos"
append Commande "\n $FichierTXTSigmaOligos"
set TFADeLaCommande [join $LeTFADeLaCommande "\n"]
set FichierTXTCommandeOligos [Sauve $Commande dans $FichierTXTCommandeOligos]
set FichierTXTWebOrderOligos [Sauve $TFADeLaCommande dans $FichierTXTWebOrderOligos]
set FichierTXTSigmaOligos [SauveLesLignes $ListeSigma dans $FichierTXTSigmaOligos]
break
}
if {$LesNonCreesCarEnStock!={}} {
FaireLire "Some oligos where not created because they exist in oligobase\n\
Please browse for a file name to store the list"
regsub "_commande" $FichierTXTCommandeOligos "_existing" FichierDesNonCreesCarEnStock
regsub ".txt$" $FichierDesNonCreesCarEnStock "" FichierDesNonCreesCarEnStock
append FichierDesNonCreesCarEnStock ".list"
set FichierDesNonCreesCarEnStock [FichierPourSaveAs $FichierDesNonCreesCarEnStock]
if {$FichierDesNonCreesCarEnStock!=""} {
SauveLesLignes $LesNonCreesCarEnStock dans $FichierDesNonCreesCarEnStock
}
}
if {$FichierTXTCommandeOligos!=""} {
while {$WebOrder} {
foreach Access [LaSequenceDuTFAs $FichierTXTWebOrderOligos "LaListeDesAccess"] {
set TFA [LaSequenceDuTFAs $FichierTXTWebOrderOligos $Access]
set Nom $Access
set Not [EnteteDuTexteTFA $TFA]
set Seq [QueLaSequenceDuTexteTFA $TFA]
if {[info exists PduTFA($TFA)]} { set Nom $PduTFA($TFA) }
lappend LesNom $Nom
lappend LesNot $Not
lappend LesSeq $Seq
}
set Retour [WebOrder $LesSeq $LesNom $LesNot]
if {$Retour!=""} { break }
if {[OuiOuNon "Do I really cancel WebOrder ?"]} { break }
}
if {[OuiOuNon "Do I print the order ?" 0]} {
ImprimeLeFichier $FichierTXTCommandeOligos "renoir -l "
}
if {[OuiOuNon "Do I mail the order ?" 0]} {
MailAuxDestinataires $FichierTXTCommandeOligos "" "Commande oligos"
}
}
return $FichierTXTCommandeOligos
}
proc NePasMettreAttB {} {
global NePasMettreAttB
if { ! [info exists NePasMettreAttB]} {
set NePasMettreAttB [expr ! [OuiOuNon "Do I include the AttB signals ?\n
Don't forget to add a CC signal at 5' end if you order at Invitrogen."]]
}
return $NePasMettreAttB
}
proc OligosEtProduitsPCR {FichierSeq SavSapFavFap args} {
set LesOptions $args
set LesAvants [lindex $SavSapFavFap 0]
set LesApres [lindex $SavSapFavFap 1]
set FichierDesSignauxAvant [lindex $SavSapFavFap 2]
set FichierDesSignauxApres [lindex $SavSapFavFap 3]
LesSignauxDuFichier $FichierDesSignauxAvant SequenceDuSignal SequenceDuSignalPourPPCR
LesSignauxDuFichier $FichierDesSignauxApres SequenceDuSignal SequenceDuSignalPourPPCR
set Retourne "LesNomsDesFichiers"
if {[OuiOuNon "Do you want (as usual) a MeltingTemp of 62 ( and 60 if it end with G or C) ?"]} {
set AvecMeltingTemp 1
set Melting "62 60"
} else {
set AvecMeltingTemp [OuiOuNon "Do you want to define a MeltingTemp a new couple of temperatures?"]
if {$AvecMeltingTemp} {
FaireLire "Please give a couple of temperatures"
set Melting [Entre "62 60 (second value if it ends with G or C)"]
set tGC ""
scan $Melting "%f %f" tAT tGC
set Melting "$tAT $tGC"
} else {
FaireLire "Please enter the length of the priming sequence"
set LongAvant [Entre 20]
set LongApres [Entre 20]
}
}
foreach A $LesOptions {
if {[regexp "^Retourne" $A]} {
regsub "^Retourne" $A Retourne
continue
}
if {[regexp {^L[0-9]+$} $A]} {
regsub "L" $A "" A
set LongAvant $A
set LongApres $A
set AvecMeltingTemp 0
continue
}
if {[regexp {^T[0-9\.](_([0-9]+))?$} $A]} {
regsub -all {[^0-9\.]} $A " " A
regsub -all { +} $A " " A
set Melting [string trim $A]
set AvecMeltingTemp 1
continue
}
}
foreach Ligne [CorrectionPourThrombin [LesLignesDuFichier $FichierSeq] $FichierSeq NF] {
if {[regexp " *>" $Ligne]} {
regsub -all ">" $Ligne " " Ligne
scan $Ligne "%s" NomSeq
lappend LesNomSeq $NomSeq
set Entetes($NomSeq) $Ligne
set Sequences($NomSeq) ""
continue
}
regsub -nocase -all {[^a-z]} $Ligne "" Seq
append Sequences($NomSeq) $Seq
}
set LesTFAsSans {}
foreach NomSeq $LesNomSeq {
set ProduitPCR ""
set LesAvantsEtMoi $NomSeq
set TM5P ""
if {$LesAvants!={} || $LesAvants=={} && $LesApres=={}} {
if {$LesAvants=={}} {
set LesAvantsEtMoi No5pSignal
} else {
set LesAvantsEtMoi $LesAvants
}
lappend LesAvantsEtMoi $NomSeq
set Nom [join $LesAvantsEtMoi "_"]
set SeqAvant ""
foreach Signal $LesAvants {
set SeqSignal [string totitle [set SequenceDuSignal($Signal)]]
append SeqAvant $SeqSignal
set SeqSignalPourPPCR [string totitle [set SequenceDuSignalPourPPCR($Signal)]]
append ProduitPCR $SeqSignalPourPPCR
}
if {$AvecMeltingTemp} {
set SeqAdd [EntammePourMeltingTemp [set Sequences($NomSeq)] $Melting]
} else {
set SeqAdd [string range [set Sequences($NomSeq)] 0 [expr $LongAvant-1]]
}
set TM5P [TMDeLaSequence $SeqAdd]
append SeqAvant $SeqAdd
set TFA [SequenceFormatTFA $SeqAvant "$Nom tm5p_$TM5P" "brut"]
if {[DontCreateAllOligos] && ! [OuiOuNon "$TFA\n\n OK to create it ?"]} {
} else {
lappend LesTFAs $TFA
}
}
set LeNomDuProduitPCR $LesAvantsEtMoi
set DebutProteine [expr [string length $ProduitPCR] +1]
append ProduitPCR [set Sequences($NomSeq)]
set FinProteine [expr [string length $ProduitPCR]]
set TM3P ""
if {$LesApres!={} || $LesAvants=={} && $LesApres=={}} {
set LeNomDuProduitPCR [concat $LeNomDuProduitPCR $LesApres]
if {$LesApres=={}} {
set LesMoiEtApres [concat [list $NomSeq] "No3pSignal"]
} else {
set LesMoiEtApres [concat [list $NomSeq] $LesApres]
}
set Nom [join $LesMoiEtApres "_"]
set SeqTotaleRaC [NucToReverseAndComplementNuc [set Sequences($NomSeq)]]
if {$AvecMeltingTemp} {
set SeqRaC [EntammePourMeltingTemp $SeqTotaleRaC $Melting]
} else {
set SeqRaC [string range $SeqTotaleRaC 0 [expr $LongApres-1]]
}
set TM3P [TMDeLaSequence $SeqRaC]
set Signaux ""
foreach Signal $LesApres {
set SeqSignal [string totitle [set SequenceDuSignal($Signal)]]
append Signaux $SeqSignal
set SeqSignalPourPPCR [string totitle [set SequenceDuSignalPourPPCR($Signal)]]
append ProduitPCR $SeqSignalPourPPCR
}
set SignauxRaC [NucToReverseAndComplementNuc $Signaux]
set RaC "$SignauxRaC$SeqRaC"
set TFA [SequenceFormatTFA $RaC "$Nom tm3p_$TM3P" "brut"]
if {[DontCreateAllOligos] && ! [OuiOuNon "$TFA\n\n OK to create it ?"]} {
} else {
lappend LesTFAs $TFA
}
}
set SeqProduitPCR [join $ProduitPCR ""]
set L [string length $SeqProduitPCR]
set CodonsRares [CodonsRares [set Sequences($NomSeq)]]
set NomDuProduitPCR [join $LeNomDuProduitPCR "_"]
set ProduitPCRTFA [SequenceFormatTFA $SeqProduitPCR \
"ProduitPCR_$NomDuProduitPCR bases_$L debut_$DebutProteine fin_$FinProteine tm5p_$TM5P tm3p_$TM3P $CodonsRares" "brut"]
lappend LesProduitsPCRTFA $ProduitPCRTFA
Espionne $ProduitPCRTFA
}
EspionneL $LesTFAs
while 1 {
FaireLire "Please, help me to choose the file name for oligos"
set Queue [file tail $FichierSeq]
if {[regexp "^cons_" $Queue]} { regsub "cons_" $Queue "" Queue }
set FichierOligos "./oligos_$Queue"
set FichierOligos [FichierPourSaveAs $FichierOligos]
if {$FichierOligos==""} {
if {[OuiOuNon "Do You really want to skipp saving of oligo ?"]} { break }
continue
}
set FichierOligos [SauveLesLignes $LesTFAs dans $FichierOligos]
break
}
while 1 {
set D [file dirname $FichierOligos]
set Q [file tail $FichierOligos]
regsub "^oligos_" $Q "" Q
set Q "ppcr_$Q"
set FichierProduitsPCR "$D/$Q"
if {[file exists $FichierProduitsPCR]} {
FaireLire "Please, help me to choose the file name for produits_pcr"
set FichierProduitsPCR [FichierPourSaveAs $FichierProduitsPCR]
}
if {$FichierProduitsPCR==""} {
if { [OuiOuNon "Do You really want to skipp saving of PPCR ?"]} { break }
continue
}
set FichierProduitsPCR [SauveLesLignes $LesProduitsPCRTFA dans $FichierProduitsPCR]
break
}
if {$Retourne=="LesNomsDesFichiers"} { return [list $FichierOligos $FichierProduitsPCR] }
if {$Retourne=="LesTFAsDesOligos"} { return $LesTFAs }
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.