" $Ligne "" Ligne
regsub -all "" $Ligne "@" Ligne
ScanLaListe [split $Ligne "@"] X0 P D X1 X2 X3 C H A
regsub -all {<[^>]+>} $P "" PAB
if { ! [regexp "^PAB" $PAB]} { continue }
regsub -all {<[^>]+>} $C "" Commentaire
regsub "PAB" $PAB [PreFixe] Nom
Espionne $Nom
set LeTexte "Nom:$PAB"
lappend LeTexte "AuteurDate: $A $H"
lappend LeTexte "DeCo: $D"
lappend LeTexte "DeOO: [ExtraitInfo $Nom DE_Narcisse]"
set i 0
while {$Commentaire!=""} {
set Bout [string range $Commentaire 0 80]
set iBlanc [string last " " $Bout]
Espionne "$iBlanc $Commentaire"
if {$iBlanc==-1} { set iBlanc 80 }
set BonBout [string range $Commentaire 0 $iBlanc]
set Commentaire [string range $Commentaire [incr iBlanc] end]
lappend LeTexte "Comment_[incr i]: $BonBout"
}
SauveLesLignes $LeTexte dans "$RepertoireDuGenome/cohen/$Nom"
}
}
proc TFAsDeLaListe {Liste {Rep ""} {FichierACreer ""}} {
set LaSelection {}
if {$FichierACreer=="" && ($Rep=="GetText" || $Rep=="GetList")} {
set Rep $FichierACreer
set Rep ""
}
if {$Rep==""} {
set LaSelection $Liste
} else {
foreach El $Liste {
lappend LaSelection "$El $Rep"
}
}
set Selection [join $LaSelection "\n"]
return [CreeUnTFAs $Selection $FichierACreer]
}
proc CreeUnTFAs {Selection {FichierACreer ""}} {
global RepertoireDuGenome
Wup "Creates the TFAs file containing the sequences of the selected accesses"
if {$Selection == "" } { return }
if {[regexp "\n" $Selection]} {
set LaSelection [split $Selection "\n"]
} else {
set LaSelection $Selection
}
set SauveTFAs 1
set LesTFAS {}
foreach Ligne $LaSelection {
scan $Ligne "%s" Fichier
if {[regexp "/" $Fichier] && [file exists $Fichier]} {
set TFAouTFAs [ContenuDuFichier $Fichier]
set Format [FormatDeLaSequence $TFAouTFAs]
if {$Format=="tfa" || $Format=="tfas"} {
lappend LesTFAs $TFAouTFAs
}
continue
}
set Access ""
scan $Ligne "%s %s" BanqueId Access
if {[EstUnPAB $BanqueId]} {
set Nom $BanqueId
set Rep $Access
if {$Rep==""} { set Rep "nuctfa" }
set FicTFA [GscopeFile $Nom $Rep]
if {[FileExists $FicTFA]} {
set TFA [ContenuDuFichier $FicTFA]
lappend LesTFAs $TFA
}
continue
}
set TFA [SequenceFormatTFA_l [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutNucEMBL"] "" "embl"]
lappend LesTFAs $TFA
}
if {$LesTFAs == {} } { return "" }
if {$FichierACreer=="GetText"} { return [join $LesTFAs "\n"] }
if {$FichierACreer=="GetList"} { return $LesTFAs }
set TFAs [join $LesTFAs "\n"]
if {$FichierACreer=="ShowIt"} {
return [AfficheVariable $TFAs "AvecFormate"]
}
if {$FichierACreer!=""} {
return [Sauve $TFAs dans $FichierACreer]
}
return $TFAs
}
proc CreeUnTFAsDesListesBidAccess {lBanqueId lAccess {FichierACreer ""}} {
global RepertoireDuGenome
Wup "Creates the TFAs file containing the sequences listed in lBanqueId lAccess"
set SauveTFAs 1
set LesTFAs {}
foreach BanqueId $lBanqueId Access $lAccess {
Espionne "Je cherche $BanqueId $Access"
set TFA [SequenceFormatTFA_l [LaSequenceDesBanques $BanqueId $Access AccessOK "OnVeutNucEMBL"] "" "embl"]
lappend LesTFAs $TFA
}
if {$LesTFAs == {} } { return "" }
set TFAs [join $LesTFAs "\n"]
if {$FichierACreer=="ShowIt"} {
return [AfficheVariable $TFAs "AvecFormate"]
}
if {$FichierACreer!=""} {
return [Sauve $TFAs dans $FichierACreer]
}
return $TFAs
}
proc QuiToucheCeChromosome {Chromo} {
set Fichier "~/$Chromo.liste"
return [SauveLesLignes [QuiTouche $Chromo] dans $Fichier]
}
proc QuiTouche {Chro {Contig ""}} {
set LesBons {}
foreach Nom [ListeDesPABs] {
set ML [MeilleureLocalisationSurChroContig $Nom]
scan $ML "%s %s" Ch Co
if {$Ch!=$Chro} { continue }
if {$Contig!="" && $Co!=$Contig} { continue }
lappend LesBons $Nom
}
return $LesBons
}
proc OrthographeCanonique Texte {
global OrthographeCanonique
global OrthographeCanoniqueInverse
set TEXTE [string trim [string toupper $Texte]]
regsub -all " " $TEXTE "_" TEXTE
if {[info exists OrthographeCanonique($TEXTE)]} { return [set OrthographeCanonique($TEXTE)] }
if { ! [info exists OrthographeCanonique]} {
set OrthographeCanonique(XENOPUS.) "Xenopus laevis"
set OrthographeCanonique(METHANOTHERMOBACTER_THERMAUTOTROPHICUS) "Methanobacterium thermoautotrophicum"
set OrthographeCanonique(M.THERMAUTOTROPHICUS) "Methanobacterium thermoautotrophicum"
# set OrthographeCanonique(DANIO_RERIO) "Brachydanio rerio"
# set OrthographeCanonique(DANI.RERIO) "Brachydanio rerio"
# set OrthographeCanonique(D.RERIO) "Brachydanio rerio"
if {[lsearch -exact [LesGenomesComplets] "Buchnera aphidicola"]<0} {
set OrthographeCanonique(BUCHNERA_SP) "Buchnera aphidicola"
set OrthographeCanonique(BUCHNERA_SP.) "Buchnera aphidicola"
set OrthographeCanonique(BUCH.SP) "Buchnera aphidicola"
set OrthographeCanonique(B.SP) "Buchnera aphidicola"
}
set OrthographeCanonique(UREAPLASMA_PARVUM) "Ureaplasma urealyticum"
set OrthographeCanonique(UREA.PARVU) "Ureaplasma urealyticum"
set OrthographeCanonique(U.PARVUM) "Ureaplasma urealyticum"
set OrthographeCanonique(RHIZOBIUM_MELILOTI) "Sinorhizobium meliloti"
set OrthographeCanonique(RHIZ.MELIL) "Sinorhizobium meliloti"
set OrthographeCanonique(R.MELILOTI) "Sinorhizobium meliloti"
set OrthographeCanonique(RHIZOBIUM_LOTI) "Mesorhizobium loti"
set OrthographeCanonique(RHIZ.LOTI) "Mesorhizobium loti"
set OrthographeCanonique(R.LOTI) "Mesorhizobium loti"
set OrthographeCanonique(SULFOLOBUS_TOKADAII) "Sulfolobus tokodaii"
set OrthographeCanonique(S.TOKADAII) "Sulfolobus tokodaii"
set OrthographeCanonique(SULF.TOKAD) "Sulfolobus tokodaii"
set OrthographeCanonique(SALMONELLA_TYPHI) "Salmonella enterica"
set OrthographeCanonique(S.TYPHI) "Salmonella enterica"
set OrthographeCanonique(THERMOPLASMA_VOLCANICUM) "Thermoplasma volcanium"
set OrthographeCanonique(T.VOLCANICUM) "Thermoplasma volcanium"
# set OrthographeCanonique(THERMUS_THERMOPHILUS) "Thermus aquaticus"
# set OrthographeCanonique(THER.THERM) "Thermus aquaticus"
# set OrthographeCanonique(T.THERMOPHILUS) "Thermus aquaticus"
foreach {BAD Good} [array get OrthographeCanonique] {
if { ! [regexp "_" $BAD]} { continue }
regsub "_" $BAD " " BAD
set Bad "[string index $BAD 0][string tolower [string range $BAD 1 end]]"
lappend OrthographeCanoniqueInverse($Good) $Bad
}
}
if {[info exists OrthographeCanonique($TEXTE)]} { return [set OrthographeCanonique($TEXTE)] }
return $Texte
}
proc LesGenomesCompletsBizarres {{Quoi ""}} {
if {$Quoi==""} {
set Quoi [ChoixParmi [list "Bizarres" "Nouveaux" "Inconnus"]]
if {$Quoi==""} { return {} }
}
set LesBizarres {}
set LesNouveaux {}
set LesInconnus {}
foreach O [LesGenomesComplets] {
set G [Glossaire $O Complet]
if {$G==$O} { continue }
set T [Tax $O "Name"]
if {$T==$O} {
lappend LesBizarres "New organism : $O"
lappend LesNouveaux $O
}
if {$T=="" || [regexp -nocase "Error" $T] } {
lappend LesBizarres "Wrong organism : $O"
lappend LesInconnus $O
}
}
if {$Quoi=="Bizarres"} { return $LesBizarres }
if {$Quoi=="Nouveaux"} { return $LesNouveaux }
if {$Quoi=="Inconnus"} { return $LesInconnus }
return $LesBizarres
}
proc SampledOrganism {Genre {Espece ""}} {
global SampledOrganism
global RepertoireDuGenome
if {$Espece==""} {
set O $Genre
} else {
set O "$Genre $Espece"
}
set Orga [Glossaire $O Complet]
if {$Orga==""} { set Orga $O }
if {[info exists SampledOrganism($Orga)]} { return [set SampledOrganism($Orga)] }
if {[info exists SampledOrganism ]} { return [set SampledOrganism("NotFound")] }
set Fichier "$RepertoireDuGenome/fiches/sampled_organism"
if {[file exists $Fichier]} {
set SampledOrganism(LaListeMerci) {}
foreach Ligne [LesLignesDuFichier $Fichier] {
set OrgaLu [string trim $Ligne]
lappend SampledOrganism(LaListeMerci) $OrgaLu
set SampledOrganism($OrgaLu) 1
}
set SampledOrganism("NotFound") 0
return [SampledOrganism $O]
}
set LaFamille {}
while {[OuiOuNon "Do You want to define 'Sampled Organisms' ?"]} {
if {[OuiOuNon "Do You want to copy or link an other 'SampledOrganism' file ?"]} {
set Autre [ButineArborescence "All" "$RepertoireDuGenome/.."]
if {$Autre==""} { continue }
if {[OuiOuNon "Do I link \n$Autre\n to \n$Fichier\n ?"]} {
exec ln -s $Autre $Fichier
} elseif {[OuiOuNon "Do I copy it ?"]} {
File copy $Autre $Fichier
}
return [SampledOrganism $O]
}
set LaFamille [ChoixDesPresents [FamiliarOrganism LaListeMerci]]
set Other ""
while {[OuiOuNon "Do You want to add other organisms to the sampled organisms list ?" 0]} {
set Other [Entre $Other]
set BonOther [Glossaire $Other Complet]
if {$BonOther==""} {
FaireLire "I don't know the organism $Other"
} else {
lappend LaFamille $BonOther
}
}
if {[OuiOuNon "[join $LaFamille "\n"]\n\nOK ?"]} { break }
}
if {$LaFamille=={}} {
if { ! [OuiOuNon "Do You want to save 'Sampled Organisms' as an empty list ?"]} {
set SampledOrganism("NotFound") 0
set SampledOrganism(LaListeMerci) {}
return [SampledOrganism $O]
}
}
SauveLesLignes $LaFamille dans $Fichier
return [SampledOrganism $O]
}
proc FamiliarTaxId {TaxId {Quoi ""}} {
global FamiliarTaxId
if {$Quoi==""} { set Quoi "Test" }
if {[info exists FamiliarTaxId($TaxId,$Quoi)]} { return [set FamiliarTaxId($TaxId,$Quoi)] }
if {[info exists FamiliarTaxId("TaxIdEstCharge")]} { return 0 }
set FamiliarTaxId("TaxIdEstCharge") 1
set FichierFOWTI "[RepertoireDuGenome]/fiches/familiar_organism_with_taxid"
while { ! [file exists $FichierFOWTI]} {
if { ! [OuiOuNon "Can I create the file\n$FichierFOWTI\nusing familiar_organism ?"]} {return 0}
TaxIdOfFamiliarOrganisms
}
foreach Ligne [LesLignesDuFichier $FichierFOWTI] {
scan $Ligne "%s %s %d" G E OX
set FamiliarTaxId($OX,All) $Ligne
set FamiliarTaxId($OX,Test) 1
lappend FamiliarTaxId(LaListeMerci,Test) $Ligne
}
return [FamiliarTaxId $TaxId $Quoi]
}
proc FamiliarOrganism {Genre {Espece ""}} {
global FamiliarOrganism
global RepertoireDuGenome
if {$Espece==""} {
set O $Genre
} else {
set O "$Genre $Espece"
}
if {[info exists FamiliarOrganism($O)]} { return [set FamiliarOrganism($O)] }
set Orga [Glossaire $O Complet]
if {$Orga==""} { set Orga $O }
if {[info exists FamiliarOrganism($Orga)]} { return [set FamiliarOrganism($Orga)] }
if {[info exists FamiliarOrganism ]} { return [set FamiliarOrganism("NotFound")] }
set Fichier "$RepertoireDuGenome/fiches/familiar_organism"
if {[file exists $Fichier]} {
Wup "We do it first for the most common used"
foreach G [LesGenomesComplets] {
set C [Glossaire $G Court]
set FamiliarOrganism($G) 0
set FamiliarOrganism($C) 0
}
set FamiliarOrganism(LaListeMerci) {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
if {[regexp {^ *\#} $Ligne]} { continue }
set OrgaLu [string trim $Ligne]
if {[Glossaire $OrgaLu Court]==""} {
if {[regexp -nocase {^ERROR} [set Bon [Tax $OrgaLu "Name"]]]} {
FaireLire "For familiar organism\nI don't know the organism \n$OrgaLu\n I'll skip it"
continue
}
set OrgaLu $Bon
}
lappend FamiliarOrganism(LaListeMerci) $OrgaLu
set FamiliarOrganism($OrgaLu) 1
set FamiliarOrganism([Glossaire $OrgaLu Court]) 1
}
set FamiliarOrganism("NotFound") 0
return [FamiliarOrganism $O]
}
set LaFamille {}
while {[OuiOuNon "Do You want to define 'Familiar Organisms' ?"]} {
if {[OuiOuNon "Do You want to copy or link an other 'FamiliarOrganism' file ?"]} {
set Autre [ButineArborescence "All" "$RepertoireDuGenome/.."]
if {$Autre==""} { continue }
if {[OuiOuNon "Do I link \n$Autre\n to \n$Fichier\n ?"]} {
exec ln -s $Autre $Fichier
} elseif {[OuiOuNon "Do I copy it ?"]} {
File copy $Autre $Fichier
}
return [FamiliarOrganism $O]
}
set LaFamille [ChoixDesPresents [LesGenomesComplets]]
set Other ""
while {[OuiOuNon "Do You want to add other organisms to the familiar organisms list ?" 0]} {
set Other [Entre $Other]
set BonOther [Glossaire $Other Complet]
if {$BonOther==""} {
FaireLire "I don't know the organism $Other"
} else {
lappend LaFamille $BonOther
}
}
if {[OuiOuNon "[join $LaFamille "\n"]\n\nOK ?"]} { break }
}
if {$LaFamille=={}} {
if { ! [OuiOuNon "Do You want to save 'Familiar Organisms' as an empty list ?"]} {
set FamiliarOrganism("NotFound") 0
set FamiliarOrganism(LaListeMerci) {}
return [FamiliarOrganism $O]
}
}
SauveLesLignes $LaFamille dans $Fichier
return [FamiliarOrganism $O]
}
proc TooCloseOrganism {Genre {Espece ""}} {
global TooCloseOrganism
global RepertoireDuGenome
if {$Espece==""} {
set O $Genre
} else {
set O "$Genre $Espece"
}
if {[info exists TooCloseOrganism($O)]} { return [set TooCloseOrganism($O)] }
set Orga [Glossaire $O Complet]
if {$Orga==""} { set Orga $O }
if {[info exists TooCloseOrganism($Orga)]} { return [set TooCloseOrganism($Orga)] }
if {[info exists TooCloseOrganism ]} { return [set TooCloseOrganism("NotFound")] }
set Fichier "$RepertoireDuGenome/fiches/tooclose_organism"
if {[file exists $Fichier]} {
Wup "We do it first for the most common used"
foreach G [LesGenomesComplets] {
set C [Glossaire $G Court]
set TooCloseOrganism($G) 0
set TooCloseOrganism($C) 0
}
set TooCloseOrganism(LaListeMerci) {}
foreach Ligne [LesLignesDuFichier $Fichier] {
set OrgaLu [string trim $Ligne]
lappend TooCloseOrganism(LaListeMerci) $OrgaLu
set TooCloseOrganism($OrgaLu) 1
set TooCloseOrganism([Glossaire $OrgaLu "Court"]) 1
Espionne [Glossaire $OrgaLu "Court"]
}
set TooCloseOrganism("NotFound") 0
return [TooCloseOrganism $O]
}
set LaFamille {}
while {[OuiOuNon "Do You want to define 'Too close organisms' ?"]} {
if {[OuiOuNon "Do You want to copy or link an other 'TooCloseOrganism' file ?"]} {
set Autre [ButineArborescence "All" "$RepertoireDuGenome/.."]
if {$Autre==""} { continue }
if {[OuiOuNon "Do I link \n$Autre\n to \n$Fichier\n ?"]} {
exec ln -s $Autre $Fichier
} elseif {[OuiOuNon "Do I copy it ?"]} {
File copy $Autre $Fichier
}
return [TooCloseOrganism $O]
}
set LaFamille [ChoixDesPresents [LesGenomesComplets]]
set Other ""
while {[OuiOuNon "Do You want to add other organisms to the too close organisms list ?" 0]} {
set Other [Entre $Other]
set BonOther [Glossaire $Other Complet]
if {$BonOther==""} {
FaireLire "I don't know the organism $Other"
} else {
lappend LaFamille $BonOther
}
}
if {[OuiOuNon "[join $LaFamille "\n"]\n\nOK ?"]} { break }
}
if {$LaFamille=={}} {
if { ! [OuiOuNon "Do You want to save 'Too Close Organisms' as an empty list ?"]} {
set TooCloseOrganism("NotFound") 0
set TooCloseOrganism(LaListeMerci) {}
return [TooCloseOrganism $O]
}
}
SauveLesLignes $LaFamille dans $Fichier
return [TooCloseOrganism $O]
}
proc CreeLesCDNAsDeRegine {{Fichier ""} {Repertoire ""}} {
global RepertoireDuGenome
if {$Fichier==""} {
FaireLire "Please browse for a file with 'clone length seq'"
set Fichier [ButineArborescence All "$RepertoireDuGenome"]
if {$Fichier==""} { return "" }
}
return $Fichier
if {$Repertoire==""} {
set Repertoire "$RepertoireDuGenome/cdna"
}
if { ! [file exists $Repertoire]} { File mkdir $Repertoire }
foreach Ligne [LesLignesDuFichier $Fichier] {
set Clone ""
set Long -1
set Seq ""
ScanLaListe [split $Ligne "\t"] Clone Long Seq
regsub -all -nocase {[^a-z0-9_]} $Clone "" Clone
if {$Seq=="NA" || [regexp "non ana" $Seq]} { set Seq "" }
Espionne "$Clone [string range $Seq 0 20] $Long [string length $Seq]"
if {[string length $Seq]==0} { continue }
set NomFichier "R$Clone.tfa"
set Entete "R $Clone"
set TFA [SequenceFormatTFA $Seq $Entete "nucbrut"]
Sauve $TFA dans "$Repertoire/$NomFichier"
}
exit
}
proc WithOverlapAffymetrix Nom {
return [llength [LesAffymetrixEnOverlap $Nom]]
}
proc LesAffymetrixDuOwner Owner {
foreach Nom [ListeDesPABs] {
if {[OwnerOfCDNA $Nom]!=$Owner} { continue }
Espionne "$Nom [LesAffymetrixEnOverlap $Nom]"
}
exit
}
proc CreeLesFichiersTFAsDesMeilleursCopainsDuBlastPourTous {RepBlast GrosFichierTFAs {Expect "1e-25"} {RepTFAs ""}} {
global RepertoireDuGenome
if { $RepTFAs=="" } { set RepTFAs "copains[file tail $RepBlast]" }
if { ! [regexp "/" $RepTFAs]} { set RepTFAs "$RepertoireDuGenome/$RepTFAs" }
if { ! [file exists $RepTFAs]} { File mkdir $RepTFAs }
foreach Nom [ListeDesPABs] {
Espionne "Je vais traiter $Nom"
set FichierTFAsACreer "$RepTFAs/$Nom"
if {[file exists $FichierTFAsACreer]} { continue }
set Texte [TexteTFAsDesMeilleursCopainsDuBlast $Nom $RepBlast $GrosFichierTFAs $Expect]
if {$Texte==""} { continue }
Espionne [Sauve $Texte dans "$FichierTFAsACreer"]
}
}
proc TexteTFAsDesMeilleursCopainsDuBlast {Nom RepBlast GrosFichierTFAs {Expect 0.001}} {
global RepertoireDuGenome
if { ! [regexp "/" $RepBlast]} { set RepBlast "$RepertoireDuGenome/$RepBlast" }
set FichierBlast "$RepBlast/$Nom"
if {$FichierBlast==""} { return "" }
set n [DecortiqueBlast $FichierBlast $Expect "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN]
if {$n==0} {
set n [DecortiqueBlast $FichierBlast 0.001 5 Query lBanqueId lAccess lDE lProfil lPN]
if {$n==0} { return "" }
}
Espionne $lBanqueId
set Texte [ExtraitLesSequencesDuTFAs $GrosFichierTFAs $lBanqueId]
return $Texte
}
proc ExtraitLesSequencesDuTFAs {FichierTFAs LesAccess} {
if {$LesAccess=={}} { return "" }
set E [open $FichierTFAs "r"]
set LesACCESS "turlututu"
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
set Beau($ACCESS) $Access
lappend LesACCESS $ACCESS
}
lappend LesACCESS "turlututu"
set ACCESSES [join $LesACCESS "="]
while {[gets $E Ligne]>=0} {
if { ! [regexp "^>" $Ligne]} {
if { [info exists Courant]} { lappend Sequences($Courant) $Ligne }
continue
}
if {[info exists Courant]} { unset Courant }
regsub ">" $Ligne "" LigneSansChevron
scan $LigneSansChevron "%s" AccessLu
set ACCESSLU [string toupper $AccessLu]
if { ! [regexp "=$ACCESSLU=" $ACCESSES]} { continue }
set Courant [set Beau($ACCESSLU)]
lappend Sequences($Courant) $Ligne
}
set Sortie {}
foreach Access $LesAccess {
set ACCESS [string toupper $Access]
if {[info exists DejaVu($ACCESS)]} { continue }
set DejaVu($ACCESS) 1
if { ! [info exists Sequences($Access)]} { continue }
lappend Sortie [join [set Sequences($Access)] "\n"]
}
return [join $Sortie "\n"]
}
proc XtoN FichierTFA {
set E [open "$FichierTFA" "r"]
set S [open "$FichierTFA.new" "w"]
while {[gets $E Ligne]>=0} {
if { ! [regexp ">" $Ligne]} {
regsub -all -nocase "X" $Ligne "N" Ligne
}
puts $S $Ligne
}
exit
}
proc CreeBornesDesPABsAvecTFAs {{FichierTFAs ""} {KeepEntete ""} {CreateNarcisse ""} {ForceAccessFirst ""}} {
global RepertoireDuGenome
if {[OnTraiteDesNucleotides]} {
if { ! [file exists "$RepertoireDuGenome/nuctfa"]} { file mkdir "$RepertoireDuGenome/nuctfa" }
if { ! [file exists "$RepertoireDuGenome/nucembl"]} { file mkdir "$RepertoireDuGenome/nucembl" }
}
if {[OnTraiteDesProteines]} {
if { ! [file exists "$RepertoireDuGenome/prottfa"]} { file mkdir "$RepertoireDuGenome/prottfa" }
if { ! [file exists "$RepertoireDuGenome/protembl"]} { file mkdir "$RepertoireDuGenome/protembl" }
}
if {$FichierTFAs==""} {
if { ! [OuiOuNon "Could You browse a TFAs file with all sequences ? \n\
(I expect \n\
'>Access ...'\n\
or \n\
'>sp|Access|something definition (GN) ...')"]} {
return {}
}
set FichierTFAs [ButineArborescence "All" $RepertoireDuGenome]
if {$FichierTFAs==""} { return {} }
}
if {$KeepEntete==""} {
set KeepEntete [OuiOuNon "Do I keep the information following each '>'"]
} else {
set KeepEntete [string equal -nocase $KeepEntete "KeepEntete"]
}
if {$CreateNarcisse==""} {
set CreateNarcisse [OuiOuNon "Can I use the Access from each sequence to create Narcisse ?"]
} else {
set CreateNarcisse [string equal -nocase $CreateNarcisse "CreateNarcisse"]
}
if {$ForceAccessFirst==""} {
set ForceAccessFirst [OuiOuNon "Do I Force Access to be in position 1" 0]
} else {
set ForceAccessFirst [string equal -nocase $ForceAccessFirst "ForceAccessFirst"]
}
if {$ForceAccessFirst} { set ForceAccessFirst "ForceAccessFirst" } else { set ForceAccessFirst "" }
set AddNewSequences 0
set FichierBornes "[RepertoireDuGenome]/fiches/bornesdespabs"
if {[file exists $FichierBornes]} {
if { ! [OuiOuNon "You want to add new sequences. Did You add them at the end of \n $FichierTFAs\n OK ?" 0]} {
return {}
}
set AddNewSequences 1
set LesExistants [lsort [ListeDesPABs]]
}
set Debut 101
set Fin 101
set Long 1000
set n 0
set LeBonChamp -1
foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess" "" "" $ForceAccessFirst] {
incr n
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set Fin [expr $Debut+$Long]
set Orient "F"
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
# SauveLesLignes $LesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs"
set Debut [expr $Fin + 33]
set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
set FichierNucTFA "$RepertoireDuGenome/nuctfa/$Nom"
set FichierProtEMBL "$RepertoireDuGenome/protembl/$Nom"
set FichierProtTFA "$RepertoireDuGenome/prottfa/$Nom"
if {[OnTraiteDesProteines] && [file exists $FichierProtEMBL] && [file exists $FichierProtTFA] || \
[file exists $FichierNucEMBL] && [file exists $FichierNucTFA]} {
if {[OuiOuNonMemo "Do I keep the already existing sequences." 0]} {
Espionne "I skip $Nom"
continue
}
}
#Espionne "I'll create $Nom"
if {$AddNewSequences && [lsearch -exact $LesExistants $Nom]>=0} {
# set Debut [expr $Fin + 33]
continue
}
set BonAccess ""
set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
set NewWay [OuiOuNonMemo "I'll create sequences from a TFA file \n\
Are the header lines as follow\n\
>Access Definition\n\
>Access Homo sapiens Definition\n\
>sp|Access|Id Definition\n\
>sp|Access|Id Homo sapiens Definition\n\
"]
if {$NewWay} {
if {[OnTraiteDesProteines]} {
set FormatVer "tfa"
set SeqVer $TFA
set ProtEMBL [SequenceFormatEMBL $SeqVer $Nom "tfa"]
if {$FormatVer=="tfa"} {
set ProtTFA $SeqVer
regsub "^>" $ProtTFA ">$Nom " ProtTFA
} else {
set ProtEMBL [SequenceFormatEMBL $SeqVer $FormatVer]
set ProtTFA [SequenceFormatTFA $ProtEMBL "" "embl"]
}
Sauve $ProtEMBL dans $FichierProtEMBL
Sauve $ProtTFA dans $FichierProtTFA
if {[OuiOuNonMemo "Can I use the Access as Alias for each?"]} {
InformeSansDemander $Nom "Alias: $Access"
}
} else {
set FormatVer "tfa"
set SeqVer $TFA
set NucEMBL [SequenceFormatEMBL $SeqVer $Nom "tfa"]
if {$FormatVer=="tfa"} {
set NucTFA $SeqVer
regsub "^>" $NucTFA ">$Nom " NucTFA
} else {
set NucEMBL [SequenceFormatEMBL $SeqVer $FormatVer]
set NucTFA [SequenceFormatTFA $NucEMBL "" "embl"]
}
Sauve $NucEMBL dans $FichierNucEMBL
Sauve $NucTFA dans $FichierNucTFA
if {[OuiOuNonMemo "Can I use the Access as Alias for each?"]} {
InformeSansDemander $Nom "Alias: $Access"
}
}
}
if { ! $NewWay} {
set Seq [QueLaSequenceDuTexteTFA $TFA]
set Ent [EnteteDuTexteTFA $TFA]
regsub {>+} $Ent "" Ent
scan $Ent "%s" Access
if {[regexp {\|} $Access]} {
if {$LeBonChamp < 0} {
set LesChamps [split $Access "|"]
FaireLire "Please help me to choose the correct access in $Access"
set LeBonChamp [ChoixParmiJoli [NombresEntre 0 [expr [llength $LesChamps]-1]] {} $LesChamps]
if {$LeBonChamp==""} { set LeBonChamp 999 }
}
set BonAccess [lindex $LesChamps $LeBonChamp]
} else {
set BonAccess $Access
}
set Descr [string trim [StringSuivant " " dans $Ent]]
if {$Descr==""} { set Descr $Ent }
if {[regexp -nocase {\([a-z0-9_]+\)} $Ent GN]} {
set GN [string range $GN 1 end-1]
} else {
set GN ""
}
set LongSeq [string length $Seq]
set Seq [SequenceFormatBrut $Seq]
if {$BonAccess!=""} {
AppendAuFichier "$RepertoireDuGenome/fiches/narcisse" "$Nom $BonAccess"
}
if {([OnTraiteDesNucleotides] || [OnTraiteDesCDS]) && \
(! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA])} {
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $Nom created by Gscope from a tfas file "
lappend LesLignesEMBL "AC $Nom;"
if {$GN!=""} {
lappend LesLignesEMBL "GN $GN"
InformeSansDemander $Nom "ValiGN: $GN"
}
set Sep ":"
foreach Wrap [WrapLeTexte $Descr 50] {
lappend LesLignesEMBL "CC Original description$Sep $Wrap"
set Sep "+"
}
lappend LesLignesEMBL "SQ SEQUENCE $LongSeq bases;"
lappend LesLignesEMBL $Seq
if {$KeepEntete} {
set Entete "$Nom $Ent"
} else {
set Entete "$Nom $Descr"
}
scan $Entete "%s %s" A B
if {$A==$B} { regsub "$A +" $Entete "" Entete }
set NucEMBL [join $LesLignesEMBL "\n"]
Sauve $NucEMBL dans $FichierNucEMBL
set NucTFA [SequenceFormatTFA $NucEMBL $Entete "embl"]
Sauve $NucTFA dans $FichierNucTFA
}
if {[OnTraiteDesProteines] && \
(! [file exists $FichierProtEMBL] || ! [file exists $FichierProtTFA])} {
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $Nom created by Gscope from a tfas file "
lappend LesLignesEMBL "AC $Nom;"
if {$GN!=""} {
lappend LesLignesEMBL "GN $GN"
InformeSansDemander $Nom "ValiGN: $GN"
}
set Sep ":"
foreach Wrap [WrapLeTexte $Descr 50] {
lappend LesLignesEMBL "CC Original description$Sep $Wrap"
set Sep "+"
}
if {[OnTraiteDesCDS]} {
if { ! [file exists $FichierNucTFA]} { continue }
set Seq [SeqNucToSeqPro [QueLaSequenceDuFichierTFA $FichierNucTFA]]
set LongSeq [string length $Seq]
}
lappend LesLignesEMBL "SQ SEQUENCE $LongSeq AA;"
lappend LesLignesEMBL $Seq
if {$KeepEntete} {
set Entete "$Nom $Ent"
} else {
set Entete "$Nom $Descr"
}
set ProtEMBL [join $LesLignesEMBL "\n"]
set ProtTFA [SequenceFormatTFA $ProtEMBL "$Entete" "embl"]
Sauve $ProtTFA dans $FichierProtTFA
Sauve $ProtEMBL dans "$RepertoireDuGenome/protembl/$Nom"
}
}
}
SauveLesLignes $LesBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs"
}
proc VoirADNduContig {ChroContig Selection} {
set SansAffichage ""
set CarNature(Prom) "P"
set CarNature(Init) "I"
set CarNature(Intr) "X"
set CarNature(Sngl) "S"
set CarNature(Term) "T"
set CarNature(PlyA) "A"
set CarNature(InGN) "."
set CarNature(OuGN) " "
set LesBornes {}
foreach Ligne [split $Selection "\n"] {
if { ! [regexp {^ *[0-9]+\.[0-9]+ } $Ligne]} { continue }
scan $Ligne "%s %s %s %d %d" Num Nature Sens D F
if {$Sens=="-"} {
set W $D
set D $F
set F $W
}
lappend LesBornes "$D $F $Sens"
set C " "
if {[info exists CarNature($Nature)]} { set C [set CarNature($Nature)] }
set CarNature($D) $C
set Orientation($D) $Sens
}
if {$LesBornes=={}} { return "" }
set Seq "n[QueLaSequenceDuTFA [ContigEnStock $ChroContig "FileNamePlease"]]"
Espionne "$ChroContig $Seq"
if {$Seq==""} { return "" }
set BornesDebut [lindex $LesBornes 0]
scan $BornesDebut "%s" Debut
set BornesFin [lindex $LesBornes end]
scan $BornesFin "%s %s" Bidon Fin
set LongN [expr $Fin-$Debut+1]
set DebutEtendu [expr $Debut-99]
set FinEtendu [expr $Fin +99]
while { $DebutEtendu < 1 } { incr DebutEtendu 3}
while { $FinEtendu >= [string length $Seq] } { incr FinEtendu -3}
set adn [string range $Seq $DebutEtendu $FinEtendu]
set tdn [NucToComplementNuc $adn]
set Orient "F"
set NaturePlus ""
set NatureMinus ""
set pep(0) ""
set pep(1) ""
set pep(2) ""
set pep(3) ""
set pep(4) ""
set pep(5) ""
set Precision 25
set Loc $DebutEtendu
set Regle [string repeat " " [expr $Precision - $Loc%$Precision]]
set iBornes 0
set Bornes [lindex $LesBornes $iBornes]
scan $Bornes "%d %d %s" D F Sens
for {set i 0} { $i < [string length $adn] } {incr i } {
append pep([expr $i%3]) "[AAduCodon [string range $adn $i [expr $i+2]]] "
append pep([expr $i%3+3]) "[AAduCodon [ReverseString [string range $tdn $i [expr $i+2]]]] "
set Car " "
if {$D <= $Loc && $Loc <= $F} {
set Car [set CarNature($D)]
set Sens [set Orientation($D)]
if {$Car==" "} { set Car [set CarNature(InGN)] }
}
if {$Sens=="+"} {
append NaturePlus $Car
append NatureMinus " "
} else {
append NaturePlus " "
append NatureMinus $Car
}
if {$Loc==$F} {
incr iBornes
set Bornes [lindex $LesBornes $iBornes]
scan $Bornes "%d %d %s" D F Sens
}
if {[expr $Loc-($Loc/$Precision)*$Precision]==0} {
set Gradu [string range "$Loc[string repeat " " $Precision]" 0 [expr $Precision - 1]]
append Regle $Gradu
}
incr Loc
}
set FrameP0 " $pep(2)"
set FrameP1 " $pep(1)"
set FrameP2 "$pep(0)"
set FrameM0 " $pep(3)"
set FrameM1 " $pep(4)"
set FrameM2 " $pep(5)"
set Texte "$FrameP0\n$FrameP1\n$FrameP2\n\
$NaturePlus\n$adn\n$Regle\n$tdn\n$NatureMinus\n\
$FrameM0\n$FrameM1\n$FrameM2"
set i -1
foreach Ligne [split $Texte "\n"] {
set LaLigne([incr i]) $Ligne
lappend LesIemes $i
}
set Largeur 1000
set D 0
set F [expr $D+$Largeur-1]
set LeHachis {}
while {$D<$FinEtendu} {
foreach i $LesIemes {
lappend LeHachis [string range [set LaLigne($i)] $D $F]
}
lappend LeHachis "\n"
incr D $Largeur
incr F $Largeur
}
set Texte [join $LeHachis "\n"]
if {$SansAffichage!=""} { return $Texte }
return [AfficheVariable $Texte "GrandeLargeur" $ChroContig]
}
proc ReAlignePourTous {} {
global RepertoireDuGenome
global MyDbClustal
while { ! [info exists MyDbClustal]} {
set MyDbClustal "integral"
if { ! [OuiOuNon "Do You want to use $MyDbClustal"]} {
set MyDbClustal [Entre $MyDbClustal]
}
if {$MyDbClustal==""} { unset MyDbClustal }
}
set RepSortie ""
while {$RepSortie==""} {
set RepSortie "$RepertoireDuGenome/msf2"
if { ! [OuiOuNon "Do You want to store the new alignments in\n$RepSortie"]} {
set RepSortie [Entre "$RepertoireDuGenome/"]
}
}
if { ! [file exists $RepSortie]} { File mkdir $RepSortie }
set Keep 1
if {[llength [glob -nocomplain "$RepSortie/*"]]>0} {
set Keep [OuiOuNon "Do I keep existing files in \n$RepSortie ?"]
}
foreach Nom [ListeDesPABs] {
if {[PasTouche $Nom]} { continue }
set FichierMSF "$RepSortie/$Nom"
if {$Keep && [file exists $FichierMSF]} { continue }
set Status [ReAligne $Nom $FichierMSF]
Espionne "$Nom $Status"
FinPasTouche $Nom
}
}
proc ReAligne {Nom {FichierMSF ""}} {
global RepertoireDuGenome
global MyDbClustal
if {$FichierMSF=="" || $FichierMSF=="RetourneTexteMSF"} {
set FichierMSF [TmpFile].msf
set RetourneTexte 1
} else {
set RetourneTexte 0
}
while { ! [info exists MyDbClustal]} {
set MyDbClustal "integral"
if { ! [OuiOuNon "Do You want to use $MyDbClustal"]} {
set MyDbClustal [Entre $MyDbClustal]
}
if {$MyDbClustal==""} { unset MyDbClustal }
}
set MSFOrigine "$RepertoireDuGenome/msf/$Nom"
if { ! [file exists $MSFOrigine]} { return "" }
set n [DecortiqueUnMSF $MSFOrigine LesNomsDesSeqs Seqs]
if {$n<2} { return "" }
set LesTFAs {}
foreach NomSeq $LesNomsDesSeqs {
set Seq [set Seqs($NomSeq)]
regsub -all -nocase {[^a-z]} $Seq "" Seq
set TFA [SequenceFormatTFA $Seq $NomSeq "protbrut"]
lappend LesTFAs $TFA
}
set TFAs [join $LesTFAs "\n"]
set Status [DbClustal $Nom $FichierMSF $TFAs "AvecTexteTFAs"]
if {$RetourneTexte} {
if {[file exists $FichierMSF]} {
return [ContenuDuFichier $FichierMSF]
} else {
return ""
}
} else {
return $Status
}
}
proc Maigrir {{Quoi "blastp"} {Combien ""} {NomVoulu ""} {NewRep ""}} {
if {$Combien==""} { set Combien 13 }
set Rep "[RepertoireDuGenome]/$Quoi"
if {$NewRep==""} { set NewRep $Quoi }
if { ! [regexp "/" $NewRep]} { set NewRep "[RepertoireDuGenome]/$NewRep" }
if { ! [OuiOuNon "I will reduce the blast segment alignments to $Combien\n\
from $Rep \nto $NewRep\n OK ?" 0]} { return 0 }
if {$NomVoulu==""} {
set Liste [ListeDesPABs]
} else {
set Liste [list $NomVoulu]
}
foreach Nom $Liste {
set FichierAvant "$Rep/$Nom"
if { ! [file exists $FichierAvant]} { continue }
set FichierApres "$NewRep/$Nom"
if {[file exists $FichierApres]} { continue }
set ListeDesLignes [LesLignesDuFichier $FichierAvant]
set LongAvant [llength $ListeDesLignes]
scan [join [lrange $ListeDesLignes 0 3] " "] "%s" PremierMot
set PremierMot [string toupper $PremierMot]
# set PourBlastP [string equal -nocase $PremierMot "BLASTP"]
# set PourBallast [string equal -nocase $PremierMot "Ballast"]
# set PourTBlastX [string equal -nocase $PremierMot "TBLASTX"]
# set PourBlastN [string equal -nocase $PremierMot "BLASTN"]
# set PourTBlastN [string equal -nocase $PremierMot "TBLASTN"]
set PourBlastP [expr ! [string compare $PremierMot "BLASTP"]]
set PourBlastX [expr ! [string compare $PremierMot "BLASTX"]]
set PourTBlastX [expr ! [string compare $PremierMot "TBLASTX"]]
set PourBlastN [expr ! [string compare $PremierMot "BLASTN"]]
set PourTBlastN [expr ! [string compare $PremierMot "TBLASTN"]]
set PourBallast [expr ! [string compare $PremierMot "BALLAST"]]
if { ! [expr $PourBlastP+$PourBlastX+$PourBallast+$PourTBlastX+$PourBlastN+$PourTBlastN] == 1} {
Warne "$Fichier is not a blast file. I skipp it."
continue
}
set Encore $Combien
set LeNouveau {}
set LongApres 0
foreach Ligne $ListeDesLignes {
if {[regexp "^>" $Ligne]} {
if { ! [incr Encore -1]} { break }
}
incr LongApres
lappend LeNouveau $Ligne
}
SauveLesLignes $LeNouveau dans $FichierApres
Espionne "$Nom a maigri de $LongAvant a $LongApres"
}
return 1
}
proc AfficheGenscanDuContig Selection {
Wup "Shows Genscan output for all contig of selection"
if {$Selection==""} { return "" }
set F ""
foreach Ligne [split $Selection "\n"] {
scan $Ligne "%s" ChroContig
set FichierGSC [GenScanEnStock $ChroContig "FileNamePlease"]
if {$FichierGSC==""} { continue }
set F [AfficheFichier $FichierGSC "AvecRien"]
set B [BoutonneLaFenetre $F "See DNA of sel.\nBlastP sel. prot" ""]
$B configure -background "green"
bind $B <1> "VoirADNduContig $ChroContig \[selection get\]"
bind $B "Blaste P \[selection get\]"
}
return $F
}
proc AffymetrixAssocie {} {
global AffymetrixAssocie
global RepertoireDuGenome
if {[info exists AffymetrixAssocie]} {
if {$AffymetrixAssocie=="NoAssociatedAffymetrix"} { return "" }
return $AffymetrixAssocie
}
set FichierAA "$RepertoireDuGenome/fiches/affymetrixassocie"
if {[file exists $FichierAA]} {
scan [ContenuDuFichier $FichierAA] "%s" AffymetrixAssocie
if {$AffymetrixAssocie=="NoAssociatedAffymetrix"} { return "" }
return $AffymetrixAssocie
}
set D ""
while {$D==""} {
if { ! [OuiOuNon "Do You want to correlate with an associated Affymetrix Gscope ?" 0]} {
set D "NoAssociatedAffymetrix"
break
}
FaireLire "I need to know the associated Affymetrix directory.\nPlease browse for it."
set D [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/.."]
if {$D==""} {
set D [Entre "NoAssociatedAffymetrix"]
}
}
set AffymetrixAssocie [file tail $D]
Sauve $AffymetrixAssocie dans $FichierAA
if {$AffymetrixAssocie=="NoAssociatedAffymetrix"} { return "" }
return $AffymetrixAssocie
}
proc JumeauRepresentatif Nom {
global JumeauRepresentatif
if {[info exists JumeauRepresentatif($Nom)]} { return [set JumeauRepresentatif($Nom)] }
if {[info exists JumeauRepresentatif("EstCharge")]} { return "" }
set FichierDesJumeaux "[RepertoireDuGenome]/fiches/jumeaux"
if { ! [file exists $FichierDesJumeaux]} {
set LesFichiersJumeaux [glob -nocomplain "[RepertoireDuGenome]/fiches/jumeaux*"]
if {[llength $LesFichiersJumeaux]>0} {
set LesPossibles $LesFichiersJumeaux
lappend LesPossibles "Run a new Jumeaux"
set FichierDesJumeaux [ChoixParmi $LesPossibles]
if {$FichierDesJumeaux=="Run a new Jumeaux"} { set FichierDesJumeaux "" }
}
}
if { $FichierDesJumeaux=={} || ! [file exists $FichierDesJumeaux]} {
if {[OuiOuNon "Do You want to run Jumeaux ?"]} {
set FichierDesJumeaux [Jumeaux "Ask"]
}
}
foreach Ligne [LesLignesDuFichier $FichierDesJumeaux] {
set LesJumeaux [split $Ligne " "]
set JR [lindex $LesJumeaux 0]
lappend JumeauRepresentatif(LaListeMerci) $JR
foreach J [lrange $LesJumeaux 0 end] {
set JumeauRepresentatif($J) $JR
}
}
set JumeauRepresentatif("EstCharge") 1
return [JumeauRepresentatif $Nom]
}
proc CleanSpace {} {
global RepertoireDuGenome
foreach F [glob "$RepertoireDuGenome/cdna/*"] {
regsub -all "'" $F "_" D
regsub -all " " $D "" D
regsub "/cdna/" $D "/newcdna/" D
file copy $F $D
}
}
proc CreeBornesDesPABsLoc {} {
global RepertoireDuGenome
set FichTrD "$RepertoireDuGenome/fiches/localisationchrocontig.trid.best"
set InterChros 1200
set InterContigs 900
set InterIlots 300
set MaxiInterIlots 30
foreach Loc [LesLignesDuFichier $FichTrD] {
scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
set ChroContig "$Chro$Contig"
if { ! [info exists DejaVu($ChroContig)]} lappend LesChroContig $ChroContig
lappend LesLocsDu($ChroContig) $Loc
if { ! [info exists AlphaDu($ChroContig)]} {
set OmegaDu($ChroContig) $Fin
} else {
set AlphaDu($ChroContig) [Mini $Debut [set AlphaDu($ChroContig)]]
set OmegaDu($ChroContig) [Maxi $Fin [set OmegaDu($ChroContig)]]
}
}
set Depart 0
set OldOmega 0
foreach ChroContig $LesChroContig {
set LesLocs {}
set LesDebuts {}
set LesFins {}
foreach Loc [set LesLocsDu($ChroContig)] {
scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
lappend LesDebuts $DebutCd
lappend LesFins $FinCd
lappend LesLocs $Loc
}
set Alpha [set AlphaDu($ChroContig)]
set Omega [set OmegaDu($ChroContig)]
Espionne [expr $Omega - $Alpha]
foreach Loc $LesLocs {
scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
set D [expr $Depart+($Debut-$Alpha)]
set F [expr $D+$Fin-$Debut]
if {$Sens=="+"} { set O "F" } else { set O "R" }
Espionne "$Nom $D $F $O"
lappend LesBornes "$Nom $D $F $O"
}
set OldOmega $Omega
set RajoutArrondi [expr (($Inter+$Omega-$Alpha+3)/3)*3]
Espionne "$Depart $OldOmega $Alpha $Omega $RajoutArrondi"
incr Depart $RajoutArrondi
set LesLocs {}
set LesDebuts {}
set LesFins {}
}
SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs_loc"
}
proc OldCreeBornesDesPABsLoc {} {
global RepertoireDuGenome
set FichTrD "$RepertoireDuGenome/fiches/localisationchrocontig.trid.best"
set FichTrF "$RepertoireDuGenome/fiches/localisationchrocontig.trif.best"
set LesCd [LesLignesDuFichier $FichTrD]
set LesAf [LesLignesDuFichier $FichTrF]
set InterChros 1200
set InterContigs 900
set InterIlots 300
set MaxiInterIlots 30
set OldChro "ChroBidon"
set OldContig "ContigBidon"
set Depart 0
set OldOmega 0
set LesLocs {}
set LesDebuts {}
set LesFins {}
foreach Cd $LesCd Af $LesAf {
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
lappend LesLocs $Cd
lappend LesDebuts $DebutCd
lappend LesFins $FinCd
if {$NomCd!=$NomAf} {
if {[info exists OnAttend($NomCd,D)]} { unset OnAttend($NomCd,D) } else { set OnAttend($NomCd,F) 1 }
if {[info exists OnAttend($NomAf,F)]} { unset OnAttend($NomAf,F) } else { set OnAttend($NomAf,D) 1 }
}
if {[info exists OnAttend]} {Espionne [array names OnAttend]}
if {[info exists OnAttend] && [array names OnAttend]!={}} { continue }
set Alpha [MiniDeLaListe $LesDebuts]
set Omega [MaxiDeLaListe $LesFins]
Espionne [expr $Omega - $Alpha]
set Inter 0
if {[expr ($Alpha-$OldOmega) > $MaxiInterIlots] } { set Inter $InterIlots }
if {$OldContig!=$ContigCd} { set Inter $InterContigs }
if {$OldChro!=$ChroCd} { set Inter $InterChros }
foreach Loc $LesLocs {
scan $Loc "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
set D [expr $Depart+$Inter+($Debut-$Alpha)]
set F [expr $D+$Fin-$Debut]
if {$Sens=="+"} { set O "F" } else { set O "R" }
Espionne "$Nom $D $F $O"
lappend LesBornes "$Nom $D $F $O"
}
set OldOmega $Omega
set RajoutArrondi [expr (($Inter+$Omega-$Alpha+3)/3)*3]
Espionne "$Depart $OldOmega $Alpha $Omega $RajoutArrondi"
incr Depart $RajoutArrondi
set LesLocs {}
set LesDebuts {}
set LesFins {}
}
SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs_loc"
}
proc MeilleureLocalisationSurChroContig Nom {
set LesLocs [LesLocalisationsSurChroContig $Nom]
if {$LesLocs=={}} { return "Chro0 Contig00 -1 -1 -" }
set Meilleure [lindex $LesLocs 0]
if {$Meilleure=="No value"} { return "Chro0 Contig00 0 0 +" }
return $Meilleure
}
proc LesCDNAsEnOverlap {Nom {BestOnly ""}} {
global LesCDNAsEnOverlap
global RepertoireDuGenome
Wup "Attention si on commence en BestOnly il le reste durant tout le run et vice versa"
set BestOnly [regexp -nocase "BestOnly" $BestOnly]
if {$BestOnly} { set Best ".best" } else { set Best "" }
if {[info exists LesCDNAsEnOverlap($Nom)]} {
return [set LesCDNAsEnOverlap($Nom)]
}
if {[info exists LesCDNAsEnOverlap("EstCharge")]} {
return [set LesCDNAsEnOverlap("EstCharge")]
}
set FichierOverlap "$RepertoireDuGenome/fiches/overlap_cdnas$Best"
if {[file exists $FichierOverlap]} {
foreach Ligne [LesLignesDuFichier $FichierOverlap] {
scan $Ligne "%s" NomLu
set LesCDNAsEnOverlap($NomLu) [lrange [split $Ligne " "] 1 end]
}
set LesCDNAsEnOverlap("EstCharge") {}
return [LesCDNAsEnOverlap $Nom]
}
if { ! [OuiOuNon "Do I create $FichierOverlap ?"]} {
set LesCDNAsEnOverlap("EstCharge") [list "NoValues"]
return [set LesCDNAsEnOverlap("EstCharge")]
}
set LesAf [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trif$Best"]
set LesCd [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trid$Best"]
set iAf -1
set iCd 0
set PrecedentiCd $iCd
foreach Af $LesAf {
incr iAf
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
Espionne "[string repeat " " 40] $Af"
set iCd $PrecedentiCd
while {1} {
set Cd [lindex $LesCd $iCd]
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
Espionne "\n $Af\n$Cd"
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { break }
if {"$ChroAf $ContigAf" > "$ChroCd $ContigCd"} {
Espionne "[string repeat " " 40] $ChroAf $ContigAf > $ChroCd $ContigCd"
incr iCd
continue
}
if {$FinCd<$DebutAf} {
Espionne "[string repeat " " 40] $FinCd<$DebutAf"
incr iCd
continue
}
Espionne "je me lance dans\n $Af\n$Cd"
break
}
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { continue }
for {set PrecedentiCd $iCd} {$iCd < [llength $LesCd]} { incr iCd } {
set Cd [lindex $LesCd $iCd]
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
if {[CetOrdre $Af $Cd]} { break }
if {$FinCd < $DebutAf} { continue }
if {$NomCd==$NomAf} { continue }
Espionne " $Af\n$Cd overlap"
lappend LesCDNAs($NomCd) $NomAf
}
}
foreach Nom [array names LesCDNAs] {
set LesAffys [lsort -unique [set LesCDNAs($Nom)]]
AppendAuFichier $FichierOverlap "$Nom [join $LesAffys " "]"
}
return [LesCDNAsEnOverlap $Nom]
}
proc Cousins args {
global RepertoireDuGenome
set FichierDesCousins "cousins"
File delete -force $FichierDesCousins
set RepertoireRacine [file dirname $RepertoireDuGenome]
foreach Gdb $args {
set Rep "$RepertoireRacine/$Gdb"
foreach Fichier [glob -nocomplain "$Rep/nuctfa/*"] {
set Nom "$Gdb/nuctfa/[file tail $Fichier]"
if { ! [file exists $Fichier]} { continue }
set Seq [QueLaSequenceDuTFA $Fichier]
lappend LesSeqNom "$Seq $Nom"
}
}
set LesSeqNom [lsort $LesSeqNom]
lappend LesSeqNom "bidon bidon"
set OldSeq "zzzzzz"
set LaSortie {}
foreach SeqNom $LesSeqNom {
scan $SeqNom "%s %s" Seq Nom
if {$OldSeq==$Seq} {
if { ! [info exists LesMemes]} { set LesMemes $OldNom }
lappend LesMemes $Nom
} else {
if {[info exists LesMemes]} {
Espionne [join $LesMemes " "]
lappend LaSortie [join $LesMemes " "]
unset LesMemes
}
}
Espionne "[string range $Seq 0 80] [string length $Seq]"
set OldSeq $Seq
set OldNom $Nom
}
if {$LaSortie=={}} {
Sauve "No cusins were found" dans $FichierDesCousins
} else {
SauveLesLignes $LaSortie dans $FichierDesCousins
}
return $FichierDesCousins
}
proc Jumeaux {{Source ""} {Rep ""}} {
while {$Source=="" || $Source =="Ask"} {
set Source [ChoixParmi [list "NoTwinsAtAll" "SeqNuc" "LocChroContig" "Overlap"]]
if {$Source!=""} { break }
}
set FichierDesJumeaux "[RepertoireDuGenome]/fiches/jumeaux_$Source"
while {[file exists $FichierDesJumeaux]} {
if {[OuiOuNon "$FichierDesJumeaux already exists.\n\ Do I replace it ?"]} {
File delete -force $FichierDesJumeaux
break
}
if {[OuiOuNon "$FichierDesJumeaux already exists.\n\ Do I keep it ?"]} {
return $FichierDesJumeaux
}
}
set LesSeqNom {}
if {$Source=="Overlap"} {
return [ClustersDeClonesAuxLocsChevauchantes]
}
if {$Source=="SeqNuc"} {
if {$Rep==""} { set Rep "[RepertoireDuGenome]/nuctfa" }
foreach Nom [ListeDesPABs] {
set Fichier "$Rep/$Nom"
if { ! [file exists $Fichier]} { continue }
set Seq [string toupper [QueLaSequenceDuTFA $Fichier]]
lappend LesSeqNom "$Seq $Nom"
}
}
if {$Source=="LocChroContig"} {
foreach Nom [ListeDesPABs] {
set LesLocCC [LesLocalisationsSurChroContig $Nom]
if {$LesLocCC=={}} { continue }
set LocCC [lindex $LesLocCC 0]
regsub { [+\-]} $LocCC "" LocCC
regsub -all { } $LocCC "_" LocCC
lappend LesSeqNom "$LocCC $Nom"
}
}
set LesSeqNom [lsort $LesSeqNom]
lappend LesSeqNom "bidon bidon"
set OldSeq "zzzzzz"
set LaSortie {}
foreach SeqNom $LesSeqNom {
scan $SeqNom "%s %s" Seq Nom
if {$OldSeq==$Seq} {
if { ! [info exists LesMemes]} { set LesMemes $OldNom }
lappend LesMemes $Nom
} else {
if {[info exists LesMemes]} {
lappend LaSortie [join $LesMemes " "]
unset LesMemes
}
}
set OldSeq $Seq
set OldNom $Nom
}
if {$LaSortie=={}} {
Sauve "No twins were found" dans $FichierDesJumeaux
} else {
SauveLesLignes $LaSortie dans $FichierDesJumeaux
}
return $FichierDesJumeaux
}
proc CodeCloneDuAffymetrix Affy {
set AssoAffy [AffymetrixAssocie]
if {$AssoAffy=="NoAssociatedAffymetrix"} { return "NoAssociatedAffymetrix" }
set CC [QuestionDeScience $AssoAffy "ret CodeClone $Affy"]
return $CC
}
proc VoirLaMeilleureLocalisationDuCDNA Nom {
Wup "Shows the first localisation of Nom"
Gs "Canvas"
set Loc [MeilleureLocalisationSurChroContig $Nom]
if {[regexp "Chro0 Contig00" $Loc]} { return "" }
scan $Loc "%s %s" Chro Contig
return [VoirLesLocalisations $Chro $Contig]
}
proc VoirLesLocalisationsDuCDNA {Nom {Selection ""}} {
Wup "Shows all localisations of Nom if Selection is empty, otherwise only these from Selection"
set K ""
if {$Selection==""} {
set Selection [join [ChaqueSegmentDuBlastN $Nom 0.001 {}] "\n"]
}
foreach Ligne [split $Selection "\n"] {
scan $Ligne "%s" ChroContig
ScanLaListe [split $ChroContig ":"] Chro Contig
regsub {_[0-9]+} $Contig "" Contig
set K [VoirLesLocalisations $Chro $Contig]
}
return $K
}
proc VoirLesLocalisations {Chro Contig} {
Gs "Canvas"
JeMeSignale
set Minimum 999999999
set Maximum -999999999
set ChroContig "${Chro}_$Contig"
set Maximum [ContigEnStock "$ChroContig" "SizePlease"]
if {$Maximum==""} { return "" }
set LesBornes [LesBornesDeChroContig $Chro $Contig]
foreach Ligne $LesBornes {
scan $Ligne "%s %d %d %s" Nom D F O
set Minimum [Mini $Minimum $D]
set Maximum [Maxi $Maximum $F]
}
set LesLocGenscan [LesProteinesPreditesDuGenscan $ChroContig "Loc"]
foreach Loc $LesLocGenscan {
scan $Loc "%d %d %s %s" D F O P
set Maximum [Maxi $Maximum $F]
lappend LesLocs $Loc
}
set SX 800
set SY 800
set MX [expr $Maximum + 50]
set LargeurMini 20
set MY $SY
set BY 100
set K [UnCanva $MX $MY $SX $SY]
regsub ".canvas$" $K "" w
set Y 0
set OldFPAB -999
set OldFAFF -999
foreach Ligne $LesBornes {
scan $Ligne "%s %d %d %s" Nom D F O
if {[info exists DejaVu($Nom)]} { continue }
set DejaVu($Nom) 1
if {$O=="F"} { set C "blue" } else { set C "red" }
if {[EstUnPAB $Nom]} {
set DeltaY -30
if {[expr $OldFPAB < $D]} {
set Y [expr $MY/2 - $BY]
} else {
incr Y $DeltaY
}
set OldFPAB $F
} else {
set DeltaY 30
if {[expr $OldFAFF < $D]} {
set Y [expr $MY/2 + $BY]
} else {
incr Y $DeltaY
}
set OldFAFF $F
}
set Dm $D
set Fm $F
if {0 && [expr ($F-$D)*1.*$SX/$Maximum < $LargeurMini]} {
set Dm [expr ($D+$F)/2-$LargeurMini*$Maximum/(2.*$SX)]
set Fm [expr ($D+$F)/2+$LargeurMini*$Maximum/(2.*$SX)]
}
if {[EstUnPAB $Nom]} {
set NdS [NomDeScene $Nom]
} else {
set NdS $Nom
}
set IdR [$K create rectangle $Dm [expr $Y-10] $Fm [expr $Y+10] -fill "white"]
set IdT [$K create text [expr ($D+$F)/2] $Y -text $NdS -anchor c -fill $C -tags [list "CDNA" $Nom "$D $F $O"]]
if {[EstUnPAB $Nom]} {
$K itemconfigure $IdR -tags [list "Box" $Nom "FetchMe" "CDNA" "$D $F $O"]
$K itemconfigure $IdT -tags [list "Box" $Nom "FetchMe" "CDNA" "$D $F $O"]
}
}
$K bind "CDNA" "Devoile $K %x %y"
$K bind "CDNA" "Devoile $K %x %y Efface"
$K bind "FetchMe" <1> "FetcheBox $K %x %y"
$K bind "FetchMe" <3> "FetcheBox $K %x %y"
$K bind "FetchMe" <2> "SearchOnBoard \[NomDuCourant $K\]"
$K create rectangle 0 [expr $MY/2-1] $Maximum [expr $MY/2+1] -fill "black"
$K create text [expr ($Maximum)/2] [expr $MY/2+30] \
-text "$Chro $Contig $Maximum bases" \
-tags [list "ChroContig"] \
-anchor c -fill "black"
$K bind "ChroContig" <1> "AfficheContigComplet ${Chro}_$Contig"
$K bind "ChroContig" <3> "AfficheContigComplet ${Chro}_$Contig"
set Ecart 5
foreach Loc $LesLocGenscan {
scan $Loc "%d %d %s %s" D F O P
if {$O=="+"} { set Couleur "blue"} else { set Couleur "red" }
set Ecart [expr -$Ecart]
set Haut [expr $MY/2-$Ecart-10]
set Bas [expr $MY/2-$Ecart+10]
$K create rectangle $D $Haut $F $Bas \
-fill $Couleur -outline $Couleur \
-tag [list "Box" "Predite" "$D $F $O $ChroContig $P"]
}
$K bind "Predite" "Devoile $K %x %y"
$K bind "Predite" "Devoile $K %x %y Efface"
$K bind "Predite" <3> "Devoile $K %x %y GenScan"
wm title $w "Localisation on $Chro $Contig"
Gonfle $w all [expr (1.*$SX)/$MX] 1.0
if { 0 && [PourWscope] } {
return [winfo toplevel $K]
}
return $K
}
proc LesBornesDeChroContig {Chro Contig} {
global RepertoireDuGenome
set AA [AffymetrixAssocie]
if {$AA==""} {
set LesAd {}
set LesAf {}
} else {
set LesAd [LesLignesDuFichier "$RepertoireDuGenome/../$AA/fiches/localisationchrocontig.trid.best"]
set LesAf [LesLignesDuFichier "$RepertoireDuGenome/../$AA/fiches/localisationchrocontig.trif.best"]
}
set LesCd [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trid.best"]
set LesCf [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trif.best"]
lappend $LesAf "Fin HZ"
lappend $LesCd "Fin HZ"
set iAd 0
set iAf 0
set iCd 0
set iCf 0
set LesBornes {}
foreach LesAouC [list $LesAf $LesCd] {
set iAf 0
set longAf [llength $LesAouC]
while {$iAf<$longAf} {
set Af [lindex $LesAouC $iAf]
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
if {$SensAf=="+"} { set SensAf "F" } else { set SensAf "R" }
if {"$Chro $Contig" > "$ChroAf $ContigAf"} { incr iAf ; continue }
if {"$Chro $Contig" < "$ChroAf $ContigAf"} { break }
if { ! [regexp $Contig $ContigAf]} { incr iAf ; continue }
lappend LesBornes "$NomAf $DebutAf $FinAf $SensAf"
incr iAf
}
}
return $LesBornes
}
proc CetOrdre {Af Cd} {
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { return 1 }
if {"$ChroAf $ContigAf" > "$ChroCd $ContigCd"} { return 0 }
return [expr $FinAf < $DebutCd]
}
proc LesCodeCloneDesAffymetrixEnOverlap Nom {
set LesAffys [LesAffymetrixEnOverlap $Nom]
set LesCC {}
foreach Affy $LesAffys {
set CC [CodeCloneDuAffymetrix $Affy]
if {$CC==""} { continue }
lappend LesCC $CC
}
return $LesCC
}
proc LesAffymetrixEnOverlap Nom {
global LesAffymetrixEnOverlap
global RepertoireDuGenome
set AA [AffymetrixAssocie]
if {$AA==""} { return {} }
if {[info exists LesAffymetrixEnOverlap($Nom)]} {
return [set LesAffymetrixEnOverlap($Nom)]
}
if {[info exists LesAffymetrixEnOverlap("EstCharge")]} {
return [set LesAffymetrixEnOverlap("EstCharge")]
}
set FichierOverlap "$RepertoireDuGenome/fiches/overlap_affymetrix"
if {[file exists $FichierOverlap]} {
foreach Ligne [LesLignesDuFichier $FichierOverlap] {
scan $Ligne "%s" NomLu
set LesAffymetrixEnOverlap($NomLu) [lrange [split $Ligne " "] 1 end]
}
set LesAffymetrixEnOverlap("EstCharge") {}
return [LesAffymetrixEnOverlap $Nom]
}
if { ! [OuiOuNon "Do I create $FichierOverlap ?"]} {
set LesAffymetrixEnOverlap("EstCharge") [list "NoValues"]
return [set LesAffymetrixEnOverlap("EstCharge")]
}
set LesAf [LesLignesDuFichier "$RepertoireDuGenome/../$AA/fiches/localisationchrocontig.trif"]
set LesCd [LesLignesDuFichier "$RepertoireDuGenome/fiches/localisationchrocontig.trid"]
set iAf -1
set iCd 0
set PrecedentiCd $iCd
set MaxiCd [llength $LesCd]
foreach Af $LesAf {
incr iAf
scan $Af "%s %s %s %d %d %s" NomAf ChroAf ContigAf DebutAf FinAf SensAf
Espionne "[string repeat " " 40] $Af"
set iCd $PrecedentiCd
while {$iCd<$MaxiCd} {
set Cd [lindex $LesCd $iCd]
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
# Espionne "\n $Af\n$Cd"
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { break }
if {"$ChroAf $ContigAf" > "$ChroCd $ContigCd"} {
# Espionne "[string repeat " " 40] $ChroAf $ContigAf > $ChroCd $ContigCd"
incr iCd
continue
}
if {$FinCd<$DebutAf} {
# Espionne "[string repeat " " 40] $FinCd<$DebutAf"
incr iCd
continue
}
# Espionne "je me lance dans\n $Af\n$Cd"
break
}
if {"$ChroAf $ContigAf" < "$ChroCd $ContigCd"} { continue }
for {set PrecedentiCd $iCd} {$iCd < [llength $LesCd]} { incr iCd } {
set Cd [lindex $LesCd $iCd]
scan $Cd "%s %s %s %d %d %s" NomCd ChroCd ContigCd DebutCd FinCd SensCd
if {[CetOrdre $Af $Cd]} { break }
if {$FinCd < $DebutAf} { continue }
# Espionne " $Af\n$Cd overlap"
lappend LesAffymetrix($NomCd) $NomAf
}
}
foreach NomCd [array names LesAffymetrix] {
set LesAffys [lsort -unique [set LesAffymetrix($NomCd)]]
AppendAuFichier $FichierOverlap "$NomCd [join $LesAffys " "]"
}
return [LesAffymetrixEnOverlap $Nom]
}
proc TriLesLocalisations {{BestOnly ""}} {
global RepertoireDuGenome
set BestOnly [regexp -nocase "BestOnly" $BestOnly]
if {$BestOnly} { set Best ".best" } else { set Best "" }
set FichLoc "$RepertoireDuGenome/fiches/localisationchrocontig"
set FichTrD "$RepertoireDuGenome/fiches/localisationchrocontig.trid$Best"
set FichTrF "$RepertoireDuGenome/fiches/localisationchrocontig.trif$Best"
if { ! [file exists $FichLoc]} { return [list {} {}] }
while {[file exists $FichTrD]} {
if {[OuiOuNon "$FichTrD already exists. Do I use it ?"]} {
return [list [LesLignesDuFichier $FichTrD] [LesLignesDuFichier $FichTrF]]
}
if {[OuiOuNon "$FichTrD already exists. Do I overwrite it ?"]} {
File delete -force $FichTrD
File delete -force $FichTrF
} else {
if {[OuiOuNon "Do I stop ?"]} { exit }
}
}
foreach Ligne [LesLignesDuFichier $FichLoc] {
scan $Ligne "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
if {$BestOnly && [info exists Dejavu($Nom)]} { continue }
set Dejavu($Nom) 1
set CC "$Chro $Contig"
lappend LesLocsDesCC($CC) $Ligne
if { ! [info exists DejaVu($CC)]} { lappend LesCC $CC }
set DejaVu($CC) 1
}
set LesCCT [lsort $LesCC]
foreach CC $LesCCT {
set LesDebuts {}
set LesFins {}
if {[info exists DejaDebut]} { unset DejaDebut ; unset LesLocsDesDebuts}
if {[info exists DejaFin]} { unset DejaFin ; unset LesLocsDesFins}
foreach Ligne [set LesLocsDesCC($CC)] {
scan $Ligne "%s %s %s %d %d %s" Nom Chro Contig Debut Fin Sens
lappend LesLocsDesDebuts($Debut) $Ligne
if { ! [info exists DejaDebut($Debut)]} { lappend LesDebuts $Debut }
set DejaDebut($Debut) 1
lappend LesLocsDesFins($Fin) $Ligne
if { ! [info exists DejaFin($Fin)]} { lappend LesFins $Fin }
set DejaFin($Fin) 1
}
set LesDebuts [lsort -integer $LesDebuts]
set LesFins [lsort -integer $LesFins]
foreach Debut $LesDebuts {
AppendAuFichier $FichTrD [join [set LesLocsDesDebuts($Debut)] "\n"]
}
foreach Fin $LesFins {
AppendAuFichier $FichTrF [join [set LesLocsDesFins($Fin)] "\n"]
}
}
return [list [LesLignesDuFichier $FichTrD] [LesLignesDuFichier $FichTrF]]
}
proc LesMeilleursCopainsDuBlast {Nom {Rep "blastngenembl"}} {
global LesMeilleursCopainsDuBlast
global RepertoireDuGenome
if {[info exists LesMeilleursCopainsDuBlast($Nom,$Rep)]} {
return [set LesMeilleursCopainsDuBlast($Nom,$Rep)]
}
if {[info exists LesMeilleursCopainsDuBlast("EstCharge",$Rep)]} {
return [set LesMeilleursCopainsDuBlast("EstCharge",$Rep)]
}
set Fichier "$RepertoireDuGenome/fiches/cops_$Rep"
if { ! [file exists $Fichier]} {
set LesMeilleursCopainsDuBlast("EstCharge",$Rep) [list "File not yet available"]
return [set LesMeilleursCopainsDuBlast("EstCharge",$Rep)]
}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
scan $Ligne "%s" NomLu
regsub "$NomLu " $Ligne "" Cop
lappend LesMeilleursCopainsDuBlast($NomLu,$Rep) $Cop
}
set LesMeilleursCopainsDuBlast("EstCharge",$Rep) [list "No value"]
return [LesMeilleursCopainsDuBlast $Nom $Rep]
}
proc MeilleursCopainsDuBlastPourTous {{Rep "blastngenembl"} {CutPN ""} {MaxListe ""}} {
global RepertoireDuGenome
Wup "Creates the file and returns its name. Returns an empty string if nothing found"
set Fichier "$RepertoireDuGenome/fiches/cops_$Rep"
if {[file exists $Fichier]} {
if {[OuiOuNon "Do I keep existing results found in $Fichier ?"]} {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s" Nom
lappend LesOldCops($Nom) $Ligne
}
if {[info exists Nom]} { unset LesOldCops($Nom) }
}
File rename -force $Fichier $Fichier.copie
File delete -force $Fichier
}
foreach Nom [ListeDesPABs] {
Espionne "Je vais chercher les cops dans $Rep de $Nom"
if {[info exists LesOldCops($Nom)]} {
AppendAuFichier $Fichier [join $LesOldCops($Nom) "\n"]
continue
}
set LesCops [MeilleursCopainsDuBlast $Nom $Rep]
if {$LesCops=={}} { continue }
AppendAuFichier $Fichier [join $LesCops "\n"]
}
if {[file exists $Fichier]} {
return $Fichier
} else {
return ""
}
}
proc MeilleursCopainsDuBlast {Nom {Rep "blastngenembl"} {CutPN ""} {MaxListe ""}} {
global RepertoireDuGenome
if {$CutPN==""} { set CutPN 0.001 }
if {$MaxListe==""} { set MaxListe 5 }
if {[EstUnPAB $Nom]} {
set FichierBlast "$RepertoireDuGenome/$Rep/$Nom"
} else {
set FichierBlast $Nom
}
if { ! [file exists $FichierBlast]} { return {} }
set LesR {}
DecortiqueBlast $FichierBlast $CutPN $MaxListe Query lBanqueId lAccess lDE lProfil lPN
foreach BanqueId $lBanqueId Access $lAccess DE $lDE Profil $lProfil PN $lPN {
if {[regexp -nocase "sapiens" $DE]} {
set OS "Homo sapiens"
} else {
set OS "Inconnu inconnu"
}
set R "$Nom $BanqueId $Access $PN $OS $DE"
set LeEMBL [LaSequenceDesBanques $BanqueId $Access a "OnVeutEMBL"]
if {$LeEMBL!={}} {
set OS "Inconnu inconnu"
set LaDef {}
foreach Ligne $LeEMBL {
if {[regexp "^OS " $Ligne]} {
set Genre "Inconnu"
set Espece "inconnu"
scan $Ligne "%s %s %s" Bidon Genre Espece
if {[regexp -nocase "Mitochondrion Homo" "$Genre $Espece"]} {
set OS "Homo sapiens"
} else {
set OS "$Genre $Espece"
}
regsub {\.$} $OS "" OS
continue
}
if {[regexp "^DE " $Ligne]} {
regsub "^DE " $Ligne "" Ligne
set Ligne [string trim $Ligne]
lappend LaDef $Ligne
}
}
if {$LaDef!={}} { set DE [join $LaDef " "] }
set R "$Nom $BanqueId $Access $PN $OS $DE"
}
lappend LesR $R
}
if {$LesR=={}} { set LesR [list "$Nom No hits found"] }
return $LesR
}
proc MeilleurPdbDuBlast {Nom {Rep ""} {CutPN ""} {MaxListe ""}} {
if {$Rep==""} { set Rep "blastp" }
if {$CutPN==""} { set CutPN 0.001 }
if {$MaxListe==""} { set MaxListe 999 }
if {[EstUnPAB $Nom]} {
set FichierBlast "[RepertoireDuGenome]/$Rep/$Nom"
} else {
set FichierBlast $Nom
}
if { ! [file exists $FichierBlast]} { return "" }
set LesR {}
DecortiqueBlast $FichierBlast $CutPN $MaxListe Query lBanqueId
foreach BId $lBanqueId {
if {[EstUnAccessPDB $BId]} { return $BId }
}
return ""
}
proc MeilleurPdbDuMsf {Nom {Rep ""} {Query ""}} {
Wup "Query peut etre Nom ou un access ou 'QueryInFirstPlace'"
if {$Query==""} { set Query [file tail $Nom] }
if {$Rep==""} { set Rep "msf" }
if {[EstUnPAB $Nom]} {
set FichierMsf "[RepertoireDuGenome]/$Rep/$Nom"
} else {
set FichierMsf $Nom
}
if { [FileAbsent $FichierMsf]} { return "" }
set LeR [IdentiteEtSimilariteDansMSF $FichierMsf $Query]
set LeR [lsort -decreasing -command CompareLeDeuxiemeChamp $LeR]
foreach R $LeR {
scan $R "%s %f %f" Hit PI PS
if {[EstUnAccessPDB $Hit]} { return $Hit }
}
return ""
}
proc ConsacreVersusPredite Nom {
global RepertoireDuGenome
global ConsacreVersusPredite
if {[info exists ConsacreVersusPredite($Nom)]} { return [set ConsacreVersusPredite($Nom)] }
if {[info exists ConsacreVersusPredite("EstCharge")]} { return [set ConsacreVersusPredite("EstCharge")] }
set Fichier "$RepertoireDuGenome/fiches/consacre_versus_predite"
if {[file exists $Fichier]} {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s" NomLu
regsub "$NomLu *" $Ligne "" Valeur
if {$Valeur==""} { set Valeur "OK" }
set ConsacreVersusPredite($NomLu) $Valeur
}
set ConsacreVersusPredite("EstCharge") "No value"
return [ConsacreVersusPredite $Nom]
}
set ConsacreVersusPredite("EstCharge") "No values available"
return [set ConsacreVersusPredite("EstCharge")]
}
proc TBlastNDuConsacreDeLaPreditePourTous {{Banque "est"}} {
global RepertoireDuGenome
set NomDeLaBanque "/catalog/blast/$Banque"
set FichierLog "$RepertoireDuGenome/fiches/consacre_versus_predite"
set Rep "$RepertoireDuGenome/tblastn$Banque"
if { ! [file exists $Rep]} { File mkdir $Rep }
set Keep 1
if {[llength [glob -nocomplain $Rep/*]]>0} {
if { ! [OuiOuNon "Some TBlastN against $Banque have already be made.\nDo I keep them ?"]} {
set Keep 0
} else {
if {[file exists $FichierLog]} {
File copy -force $FichierLog "${FichierLog}.copie"
foreach Ligne [LesLignesDuFichier $FichierLog] {
scan $Ligne "%s" NomLu
set TexteLog($NomLu) $Ligne
}
}
}
File delete -force $FichierLog
}
foreach Nom [ListeDesPABs] {
Espionne "Je vais lancer TBlastN $NomDeLaBanque pour $Nom"
set FichierBlast "$Rep/$Nom"
if {$Keep && [file exists $FichierBlast]} {
if {[info exists TexteLog($Nom)]} {
AppendAuFichier $FichierLog [set TexteLog($Nom)]
}
continue
}
set FichierPredite "$RepertoireDuGenome/genscanpredictions/$Nom"
if { ! [file exists $FichierPredite]} {
AppendAuFichier $FichierLog "$Nom no GenScan prediction available"
continue
}
set TfaP [ContenuDuFichier $FichierPredite]
set SeqP [QueLaSequenceDuTexteTFA $TfaP]
set LongP [string length $SeqP]
if {$LongP < 10} {
AppendAuFichier $FichierLog "$Nom less than 10 aa in GenScan prediction"
continue
}
set Consacre [lindex [MeilleursCopains $Nom] 0]
if {[regexp "^No " $Consacre]} { continue }
scan $Consacre "%s %s" BID Access
set LesLignesEMBL [LaSequenceDesBanques $BID $Access AccessOK "OnVeutEMBL"]
if {$LesLignesEMBL=={}} {
AppendAuFichier $FichierLog "$Nom $BID $Access not found"
continue
}
set TfaC [SequenceFormatTFA_l $LesLignesEMBL $AccessOK "embl"]
set SeqC [QueLaSequenceDuTexteTFA $TfaC]
set LongC [string length $SeqC]
if {$LongC < 10} {
AppendAuFichier $FichierLog "$Nom less than 10 aa in best blastp hit"
continue
}
set CsP [expr (1.0*$LongC)/$LongP]
if { 0.7 < $CsP && $CsP < 1.3 } {
set FichierTFA [Sauve $TfaC dans "[TmpFile].tfa"]
AppendAuFichier $FichierLog "$Nom"
} elseif { $LongC < $LongP } {
set FichierTFA [Sauve $TfaC dans "[TmpFile].tfa"]
AppendAuFichier $FichierLog "$Nom may be missing exons in predicted protein"
} else {
set FichierTFA $FichierPredite
AppendAuFichier $FichierLog "$Nom may be surnumerous exons or merged proteins in predicted protein"
}
set CommandeTBlastN "blastall \
-p tblastn \
-i $FichierTFA \
-o ${FichierBlast}.encours \
-d $NomDeLaBanque \
-v 125 \
-K 0 \
-b 125 \
-e 10.0 \
-F T "
eval exec $CommandeTBlastN
if {[file exists ${FichierBlast}.encours]} {
file rename -force ${FichierBlast}.encours $FichierBlast
}
}
}
proc CreeTousLesRapportsPourAccess {{Start ""} {Keep ""}} {
global RepertoireDuGenome
set RepRapports "$RepertoireDuGenome/rapportsaccess"
if { ! [file exists $RepRapports]} { File mkdir $RepRapports }
if {$Keep==""} { set Keep 0 } else { set Keep 1 }
foreach Nom [ListeDesPABs] {
Espionne $Nom
if {$Start!="" && $Nom!=$Start} { continue }
set Start ""
if {$Keep && [file exists "$RepRapports/$Nom"]} { continue }
set Rapport {}
#Generalites
lappend Rapport "GscopeCode: $Nom"
set codeCl [CodeClone $Nom]
set User [OwnerOfCDNA $Nom]
lappend Rapport "CodeClone: $codeCl"
lappend Rapport "User: $User"
set JR [JumeauRepresentatif $Nom]
if {$JR!=$Nom && $JR!=""} {
set CC [CodeClone $JR]
lappend Rapport "JR: $CC $JR"
}
#RepeatMasker
set TypeMask [QuelMask $Nom]
Espionne $TypeMask
set PourcentMask [ExtraitInfo $Nom "RMPourcent"]
lappend Rapport "MaskType: $TypeMask"
lappend Rapport "MaskedProportion: $PourcentMask"
set TypeRepeat [ExtraitInfo $Nom "RM"]
if { $TypeRepeat!="" } {
lappend Rapport "RepeatType: $TypeRepeat"
}
#BlastN contre le genome humain
set PolyLoc [PolyLocalise $Nom]
Espionne $PolyLoc
lappend Rapport "LocType: $PolyLoc"
if { $PolyLoc!="NoBlastFile" && $PolyLoc!="NoLocalization"} {
set LesLocs [LesLocalisationsSurChroContig $Nom]
set MeilleureLoc [lindex $LesLocs 0]
scan $MeilleureLoc "%s %s %d %d %s" Chro Contig Debut Fin Orient
regsub "HS" $Chro "" Chro
lappend Rapport "Chromosome: $Chro"
lappend Rapport "Contig: $Contig"
lappend Rapport "Begin: $Debut"
lappend Rapport "End: $Fin"
lappend Rapport "Orientation: $Orient"
}
#GenScan
set GS [ExtraitInfo $Nom "GS"]
if {$GS == "overlap found with a predicted protein"} { lappend Rapport "InAPredictedGene: 1" }
if {$GS == "no overlap found with a predicted protein"} { lappend Rapport "InAPredictedGene: 0" }
set GS3 [ExtraitInfo $Nom "GS3"]
if {$GS3 == "in 3' region"} { lappend Rapport "InPredicted3Region: 1" }
if {$GS3 == "not in 3' region"} { lappend Rapport "InPredicted3Region: 0" }
set GSE [ExtraitInfo $Nom "GSE"]
if {$GSE == "in an exon"} { lappend Rapport "InAPredictedExon: 1" }
if {$GSE == "not in an exon"} { lappend Rapport "InAPredictedExon: 0" }
#BlastP
set LesCopains [MeilleursCopains $Nom]
if {$LesCopains != {} } {
set MeilleurCopain [lindex $LesCopains 0]
if {$MeilleurCopain=="No hits found" || \
$MeilleurCopain=="No human protein with expect less than 1.e-3 in the BlastP results" || \
$MeilleurCopain=="No blastp file available" } {
lappend Rapport "BlastPDef: $MeilleurCopain"
} else {
set Access ""
set PlusieursFonctions 0
scan $MeilleurCopain "%s %s" BID Access
regsub "$BID $Access" $MeilleurCopain "" PremDef
set PremDef [string trim $PremDef]
lappend Rapport "BlastPAccess: $BID"
lappend Rapport "BlastPDef: $PremDef"
if {[expr [llength $LesCopains] > 1]} {
foreach Cop [lrange $LesCopains 1 end] {
scan $Cop "%s %s" BID Access
set Definition [join [lrange [split $Cop " "] 2 end] " "]
if {$Definition!=$PremDef} {set PlusieursFonctions 1 ; break}
}
}
lappend Rapport "BlastPMore: $PlusieursFonctions"
}
set CvP [ConsacreVersusPredite $Nom]
if {$CvP!="No values"} {
lappend Rapport "Prediction_vs_BlastPHit: $CvP"
}
}
#BlastX
set LesCopains [LesMeilleursCopainsDuBlast $Nom "blastx"]
if {$LesCopains != {} } {
set MeilleurCopain [lindex $LesCopains 0]
if {[regexp -nocase "^no hit" $MeilleurCopain]} { set MeilleurCopain "No hits found" }
if {$MeilleurCopain=="No hits found" || \
$MeilleurCopain=="No human protein with expect less than 1.e-3 in the BlastX results" || \
$MeilleurCopain=="No blastx file available" } {
lappend Rapport "BlastXDef: $MeilleurCopain"
} else {
set Access ""
set PlusieursFonctions 0
scan $MeilleurCopain "%s %s" BID Access
regsub "$BID $Access" $MeilleurCopain "" PremDef
set PremDef [string trim $PremDef]
lappend Rapport "BlastXAccess: $BID"
lappend Rapport "BlastXDef: $PremDef"
if {[expr [llength $LesCopains] > 1]} {
foreach Cop [lrange $LesCopains 1 end] {
scan $Cop "%s %s" BID Access
set Definition [join [lrange [split $Cop " "] 2 end] " "]
if {$Definition!=$PremDef} {set PlusieursFonctions 1 ; break}
}
}
lappend Rapport "BlastXMore: $PlusieursFonctions"
}
}
#BlastN contre genembl et est, et TBlastN contre est
foreach {Banque Titre} {blastngenembl Genembl blastnest Est tblastnest TbnEst} {
set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque]
if {$LesCops=={}} {
lappend Rapport "${Titre}Def: values not yet available"
} elseif {[lindex $LesCops 0]=="File not yet available"} {
lappend Rapport "${Titre}Def: values not yet available"
} elseif {[lindex $LesCops 0]=="No value"} {
lappend Rapport "${Titre}Def: no value available"
} elseif {[lindex $LesCops 0]=="No hit"} {
lappend Rapport "${Titre}Def: no hit"
} else {
set PremiereFois 1
set Autre 0
foreach Cop $LesCops {
set Genre "Inconnu"
set Espece "inconnu"
scan $Cop "%s %s %s %s %s" BID Access Expect Genre Espece
set OS "$Genre $Espece"
set DE [join [lrange [split $Cop " "] 5 end] " "]
if { ! [regexp -nocase "Homo sapiens" $OS]} { continue }
if {$PremiereFois} {
lappend Rapport "${Titre}Def: $DE"
lappend Rapport "${Titre}Access: $BID"
set PremDE $DE
set PremiereFois 0
continue
}
if {$DE!=$PremDE} { incr Autre }
}
lappend Rapport "${Titre}More: [expr $Autre > 0]"
}
}
#Affymetrix overlaps
set LesCC [LesCodeCloneDesAffymetrixEnOverlap $Nom]
if {$LesCC!={}} {
set TexteAffy "Affymetrix: [join $LesCC " "]"
} else {
if {[AffymetrixAssocie]=="NoAssociatedAffymetrix"} {
set TexteAffy "Affymetrix: not tested"
} else {
set TexteAffy "Affymetrix: not detected"
}
}
lappend Rapport $TexteAffy
SauveLesLignes $Rapport dans "$RepRapports/$Nom"
}
return ""
}
proc CreeToutesLesNotesPourCDNA {{Start ""} {Keep ""}} {
global RepertoireDuGenome
set RepNotes "$RepertoireDuGenome/notes"
if { ! [file exists $RepNotes]} { File mkdir $RepNotes }
if {$Keep==""} { set Keep 0 } else { set Keep 1 }
foreach Nom [ListeDesPABs] {
Espionne $Nom
if {$Start!="" && $Nom!=$Start} { continue }
set Start ""
if {$Keep && [file exists "$RepNotes/$Nom"]} { continue }
set Note {}
#Identites
lappend Note "Name" "$Nom"
lappend Note "" ""
lappend Note "cDNA length" [string length [QueLaSequenceDuFichierTFA "$RepertoireDuGenome/nuctfa/$Nom"]]
lappend Note "" ""
set Clone [CodeClone $Nom]
set Owner [OwnerOfCDNA $Nom]
lappend Note "Code in the Access database" $Clone
lappend Note "Owner in the Access database" $Owner
if {[OnTraiteDesAffymetrix]} {
set Access [AffymetrixAccess $Nom]
set DE [ExtraitInfo $Nom "GBtagsDefinition"]
lappend Note "GBtags accession number" $Access
lappend Note "GBtags definition" $DE
}
set JR [JumeauRepresentatif $Nom]
if {$JR!=$Nom && $JR!=""} {
set CC [CodeClone $JR]
lappend Note "Same sequence as" "$JR $CC"
}
#RepeatMasker
set TypeMask [QuelMask $Nom]
Espionne $TypeMask
set PourcentMask [ExtraitInfo $Nom "RMPourcent"]
lappend Note "RepeatMasker results" "$TypeMask ( $PourcentMask % )"
set TypeRepeat [ExtraitInfo $Nom "RM"]
if { $TypeRepeat!="" } {
lappend Note "" "$Nom contains $TypeRepeat sequence(s)"
}
#BlastN contre le genome humain
set PolyLoc [PolyLocalise $Nom]
Espionne $PolyLoc
lappend Note "BlastN human results" $PolyLoc
if { $PolyLoc!="NoBlastFile" && $PolyLoc!="NoLocalization"} {
set LesLocs [LesLocalisationsSurChroContig $Nom]
foreach Loc $LesLocs {
scan $Loc "%s %s %d %d %s" Chr Cont Gauche Droite Orient
lappend Note "" "chromosome $Chr contig $Cont from $Gauche to $Droite ( $Orient )"
}
}
#GenScan
set GS [ExtraitInfo $Nom "GS"]
if {$GS != "" } {lappend Note "GenScan results" $GS}
set GS3 [ExtraitInfo $Nom "GS3"]
if {$GS3 != "" } {lappend Note "" "$Nom is $GS3"}
set GSE [ExtraitInfo $Nom "GSE"]
if {$GSE != "" } {lappend Note "" "$Nom is $GSE"}
#BlastP
set LesCopains [MeilleursCopains $Nom]
EspionneL $LesCopains
lappend Note "BlastP results" [lindex $LesCopains 0]
foreach Copain [lrange $LesCopains 1 end] {
lappend Note "" $Copain
}
set CvP [ConsacreVersusPredite $Nom]
if {$CvP!="No values"} {
lappend Note "Prediction_vs_BlastPHit" $CvP
}
#BlastX
set LesCopains [LesMeilleursCopainsDuBlast $Nom "blastx"]
EspionneL $LesCopains
lappend Note "BlastX results" [lindex $LesCopains 0]
foreach Copain [lrange $LesCopains 1 end] {
lappend Note "" $Copain
}
#BlastN contre genembl et est, et TBlastN contre est
foreach {Banque Titre} {tblastnest "TblastN Est" blastngenembl "BlastN Genembl" blastnest "BlastN Est"} {
set LesCops [LesMeilleursCopainsDuBlast $Nom $Banque]
if {$LesCops=={}} {
lappend Note "$Titre results" "values not yet available"
} elseif {[lindex $LesCops 0]=="File not yet available"} {
lappend Note "$Titre results" "values not yet available"
} elseif {[lindex $LesCops 0]=="No value"} {
lappend Note "$Titre results" "no value available"
} elseif {[lindex $LesCops 0]=="No hit"} {
lappend Note "$Titre results" "no hit"
} else {
set PremiereFois 1
foreach Cop $LesCops {
set Genre "Inconnu"
set Espece "inconnu"
scan $Cop "%s %s %s %s %s" BID Access Expect Genre Espece
set OS "$Genre $Espece"
set DE [join [lrange [split $Cop " "] 5 end] " "]
if { ! [regexp -nocase "Homo sapiens" $OS]} { continue }
if {$PremiereFois} {
lappend Note "$Titre results" "$BID $Access $Expect $DE"
set PremiereFois 0
continue
} else {
lappend Note "" "$BID $Access $Expect $DE"
}
}
}
}
#Affymetrix overlaps
set LesAffys [LesAffymetrixEnOverlap $Nom]
if {$LesAffys!={}} {
set TexteAffy "[join $LesAffys " "]"
} else {
if {[AffymetrixAssocie]=="NoAssociatedAffymetrix"} {
set TexteAffy "not tested"
} else {
set TexteAffy "not detected"
}
}
lappend Note "Affymetrix" $TexteAffy
#Traitement pour tous
set LesLignes {}
foreach {T V} $Note {
if {$T=="Name"} {
lappend LesLignes $Nom
continue
}
if {$T!="" || $V!=""} {
set L [expr 30 - [string length $T]]
if {$T!=""} { set C "." ; set S ":" } else { set C " " ; set S " " }
set P [string repeat $C $L]
lappend LesLignes [format "%s %s %s %s" $T $P $S $V]
} else {
lappend LesLignes ""
}
}
SauveLesLignes $LesLignes dans "$RepNotes/$Nom"
}
return ""
}
proc DecortiqueBlastPCDNA {BanqueID Hit Quoi {Fichier ""} {MaxAccess -1} {MaxHitsParAccess -1} } {
global DecortiqueBlastPCDNA
if {$Fichier==""} {
if {[info exists DecortiqueBlastPCDNA($BanqueID,$Hit,$Quoi)]} {
return [set DecortiqueBlastPCDNA($BanqueID,$Hit,$Quoi)]
}
return {}
} else {
if {[info exists DecortiqueBlastPCDNA]} { unset DecortiqueBlastPCDNA }
}
set LesLignes [LesLignesDuFichier $Fichier]
if {[lsearch -regexp [lrange $LesLignes 0 30] "No hits found"] != -1} { return 0 }
set IndexSPSA [lsearch -regexp $LesLignes "Sequences producing significant alignments"]
if { $IndexSPSA == -1 } { return 0 }
set PartieRestante [lrange $LesLignes [incr IndexSPSA 2] end]
set IndexPremierChevron [lsearch -regexp $PartieRestante {^>}]
if { $IndexPremierChevron == -1 } { return 0 }
set PartieScores [lrange $PartieRestante 0 [expr $IndexPremierChevron-1]]
set PartieSegAli [lrange $PartieRestante $IndexPremierChevron end]
set EncoreUnAccess $MaxAccess
foreach Ligne $PartieSegAli {
if { $Ligne == "" } { continue }
if { [regexp "^>" $Ligne] } {
if { ! [incr EncoreUnAccess -1]} { break }
set EncoreUnHit $MaxHitsParAccess
set NumHit 0
set CurrentAccess ""
scan $Ligne "%s %s" CurrentBID CurrentAccess
regsub ">" $CurrentBID "" CurrentBID
regsub "^>$CurrentBID" $Ligne "" Ligne
set LesMots [split $Ligne " "]
if {[EstUnAccessPDB $CurrentBID]} {
set DefProt [join [lrange $LesMots 1 end] " "]
} else {
set DefProt [join [lrange $LesMots 2 end] " "]
}
# lappend LesBIDs $CurrentBID
set Def($CurrentBID) $DefProt
set Acc($CurrentBID) $CurrentAccess
continue
}
if { [regexp "Length" $Ligne] } {
regsub "^ *Length = " $Ligne "" Ligne
scan $Ligne "%d" Long
set LongProt($CurrentBID) $Long
continue
}
if { [regexp "Expect" $Ligne] } {
incr NumHit
set E [PNApres "Expect =" dans $Ligne]
set Expect($CurrentBID,$NumHit) $E
continue
}
if { [regexp "Identities" $Ligne] } {
regsub -all "," $Ligne "" Ligne
regsub -all {\(*\)} $Ligne "" Ligne
set nId [IntegerApres "Identities =" dans $Ligne]
set nTot [IntegerApres "/" dans $Ligne]
set nGaps [IntegerApres "Gaps =" dans $Ligne]
if {$nGaps==""} { set nGaps 0 }
set Identites($CurrentBID,$NumHit) $nId
set Gaps($CurrentBID,$NumHit) $nGaps
set LongHit($CurrentBID,$NumHit) $nTot
if { ! [info exists DejaVu($CurrentBID)]} {
lappend LesBIDs $CurrentBID
set DejaVu($CurrentBID) 1
}
if { ! [incr EncoreUnHit -1]} { break }
lappend LesHits($CurrentBID) $NumHit
}
}
set DecortiqueBlastPCDNA(All,All,Numbers) $LesBIDs
foreach B $LesBIDs {
set DecortiqueBlastPCDNA($B,All,DefProt) [set Def($B)]
set DecortiqueBlastPCDNA($B,All,Access) [set Acc($B)]
set DecortiqueBlastPCDNA($B,All,LongProt) [set LongProt($B)]
set DecortiqueBlastPCDNA($B,All,Numbers) [set LesHits($B)]
foreach H [set LesHits($B)] {
set DecortiqueBlastPCDNA($B,$H,Identites) [set Identites($B,$H)]
set DecortiqueBlastPCDNA($B,$H,Gaps) [set Gaps($B,$H)]
set DecortiqueBlastPCDNA($B,$H,Expect) [set Expect($B,$H)]
set DecortiqueBlastPCDNA($B,$H,LongHit) [set LongHit($B,$H)]
}
}
return [DecortiqueBlastPCDNA $BanqueID $Hit $Quoi]
}
proc MeilleursCopains {Nom {Organisme "Homo sapiens"}} {
global RepertoireDuGenome
Wup "Return BID Access Definition of the best blastp hits ('best' means high score and %)"
if {[EstUnPAB $Nom]} {
set FichierBlast "[RepertoireDuGenome]/blastp/$Nom"
} else {
set FichierBlast $Nom
}
if { ! [file exists $FichierBlast]} { return [list "No blastp file available"] }
Espionne $FichierBlast
if {[DecortiqueBlastPCDNA All All Numbers $FichierBlastP 20 7]==0} {return [list "No hits found"]}
Wup "20 7 means that we take from the 20 first access there first 7 hits only"
set Trouve 0
set LesDefinitions {}
set LesScores {}
#pour chaque proteine on cherche le hit de meilleur score
foreach BID [DecortiqueBlastPCDNA All All Numbers] {
if {[EstUnAccessPDB $BID]} {continue}
set Access [DecortiqueBlastPCDNA $BID All Access]
set ScoreBestHit 0
foreach Hit [DecortiqueBlastPCDNA $BID All Numbers] {
set E [DecortiqueBlastPCDNA $BID $Hit Expect]
if {[expr $E>1.e-3] && $E!=0.0} {continue}
set nGaps [DecortiqueBlastPCDNA $BID $Hit Gaps]
set nId [DecortiqueBlastPCDNA $BID $Hit Identites]
set Score($BID,$Hit) [expr $nId + $nGaps]
if {[expr [set Score($BID,$Hit)] > $ScoreBestHit] && [expr $nGaps<$nId] } {
set ScoreBestHit [set Score($BID,$Hit)]
set NumBestHit $Hit
}
}
if {$ScoreBestHit!=0 } {
lappend LesScores "$BID $Access $NumBestHit $ScoreBestHit"
}
}
#on regroupe les proteines de meme score
set LesSc {}
foreach Ligne $LesScores {
set Sc [lindex $Ligne end]
lappend LesSc $Sc
lappend LesProt($Sc) $Ligne
}
set LesScTries [lsort -integer -decreasing $LesSc]
foreach Sc $LesScTries {
#on parcourt les groupes jusqu'a en trouver un contenant une proteine humaine
foreach Prot [set LesProt($Sc)] {
set BanqueID [lindex $Prot 0]
set Access [lindex $Prot 1]
set LeEMBL [LaSequenceDesBanques $BanqueID $Access a "OnVeutNucEMBL"]
if {$LeEMBL!={}} {
set OS "Inconnu inconnu"
set LaDef {}
foreach Ligne $LeEMBL {
if {[regexp "^OS " $Ligne]} {
set Genre "Inconnu"
set Espece "inconnu"
scan $Ligne "%s %s %s" Bidon Genre Espece
set OS "$Genre $Espece"
regsub {\.$} $OS "" OS
continue
}
# on prend une def plus complete que celle de DecortiqueBlastPCDNA
if {[regexp "^DE " $Ligne]} {
regsub "^DE " $Ligne "" Ligne
set Ligne [string trim $Ligne]
lappend LaDef $Ligne
}
}
if {$LaDef!={}} { set DE [join $LaDef " "] }
set Humaine [regexp -nocase $Organisme $OS]
} else {
continue
}
if {$Humaine} {
set Trouve 1
lappend LesDefinitions "$BanqueID $Access $DE"
}
}
if {$Trouve} {break}
}
if {[llength $LesDefinitions] == 0} {
lappend LesDefinitions "No human protein with expect less than 1.e-3 in the BlastP results"
}
Espionne ""
return $LesDefinitions
}
proc DecortiqueSortieRepeatMasker {RepeatVoulu Quoi {Texte ""}} {
global DecortiqueSortieRepeatMasker
Wup "RepeatVoulu can be All or a number"
Wup "Quoi can be Numbers, nBases, Pourcent, Nature, Occurrences"
set LesRepeats {}
if { $Texte=="" } {
if {[info exists DecortiqueSortieRepeatMasker($RepeatVoulu,$Quoi)]} { return [set DecortiqueSortieRepeatMasker($RepeatVoulu,$Quoi)] }
return {}
} else {
if {[info exists DecortiqueSortieRepeatMasker]} { unset DecortiqueSortieRepeatMasker }
}
set OnAttendBasesMasked 1
set Repeat 0
foreach Ligne [split $Texte "\n"] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
if {$OnAttendBasesMasked} {
if { ! [regexp "bases masked" $Ligne]} { continue }
set OnAttendBasesMasked 0
regsub "bases masked:" $Ligne "" Ligne
regsub "bp" $Ligne "" Ligne
regsub {\(} $Ligne "" Ligne
regsub {\)} $Ligne "" Ligne
scan $Ligne "%d %f" nBasesMasquees PourcentMasque
set DecortiqueSortieRepeatMasker(All,nBases) $nBasesMasquees
set DecortiqueSortieRepeatMasker(All,Pourcent) $PourcentMasque
continue
}
if {[regexp "SINEs|LINEs|LTR elements|DNA elements|Total interspersed repeats" $Ligne]} { continue }
if {[regexp {\%} $Ligne]} {
if {[regexp "Small RNA" $Ligne] || [regexp "Simple repeats" $Ligne] || [regexp "Low complexity" $Ligne] } {
scan $Ligne "%s %s %d" TypeRepeat1 TypeRepeat2 nOccurrences
set TypeRepeat "$TypeRepeat1 $TypeRepeat2"
} else {
scan $Ligne "%s %d" TypeRepeat nOccurrences
}
if { $nOccurrences != 0 } {
regsub {\:} $TypeRepeat "" TypeRepeat
incr Repeat
set Nature($Repeat) $TypeRepeat
set Occurrences($Repeat) $nOccurrences
lappend LesRepeats "$Repeat"
}
continue
}
}
set DecortiqueSortieRepeatMasker(All,Numbers) $LesRepeats
foreach R $LesRepeats {
set DecortiqueSortieRepeatMasker($R,Nature) [set Nature($R)]
set DecortiqueSortieRepeatMasker($R,Occurrences) [set Occurrences($R)]
}
return [DecortiqueSortieRepeatMasker $RepeatVoulu $Quoi]
}
proc BlastPDeLaPreditePourTous {{NomATraiter ""}} {
global RepertoireDuGenome
global CommandeBlastPPourTous
global GardeToutBlastPPourTous
global TestExistenceBlastPPourTous
JeMeSignale
if {$NomATraiter == ""} {
set Liste [ListeDesPABs]
} else {
set Liste [list $NomATraiter]
}
set Repertoire "$RepertoireDuGenome/blastp"
if { ! [file exists "$Repertoire"]} {
File mkdir $Repertoire
}
if {[info exists CommandeBlastPPourTous]} {
set CommandeBlast $CommandeBlastPPourTous
if {[info exists GardeToutBlastPPourTous]} {
set GardeTout $GardeToutBlastPPourTous
} else {
setGardeTout 0
}
if {[info exists TestExistenceBlastPPourTous]} {
set TestExistence $TestExistenceBlastPPourTous
} else {
set TestExistence 1
}
} else {
set GardeTout 0
set TestExistence 1
set BlastPDataBase [LocaliseBlastPDataBase]
if {$BlastPDataBase==""} { return "" }
set CommandeBlast "blastall \
-p blastp \
-i \$FichierTFA \
-o \$FichierBlast \
-d $BlastPDataBase \
-v 500 \
-K 0 \
-b 300 \
-e 30.0 \
-F F"
#attention sur les consignes d'olivier j'ai enleve le filtre !!
if {[OuiOuNon "Do You want to edit the Blast command ?" 0]} {
set CommandeBlast [Entre $CommandeBlast]
if {$CommandeBlast==""} { return "" }
}
while {[llength [glob -nocomplain "$Repertoire/*"]]> 0} {
if {[OuiOuNon "Some files exist in $Repertoire\nDo I keep all of them ?"]} {
set TestExistence 1
set GardeTout 1
break
} elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I replace all of them ?"]} {
set TestExistence 0
set GardeTout 0
break
} elseif {[OuiOuNon "Some files exist in $Repertoire\nDo I ask for each ?"]} {
set TestExistence 1
set GardeTout 0
break
}
}
set CommandeBlastPPourTous $CommandeBlast
set GardeToutBlastPPourTous $GardeTout
set TestExistenceBlastPPourTous $TestExistence
}
foreach Boite $Liste {
set Nom [Box $Boite nom]
set FichierTFA "$RepertoireDuGenome/genscanpredictions/$Nom"
set FichierBlast "$Repertoire/$Nom"
Espionne "Je m'occupe de $Nom"
if { ! [file exists $FichierTFA]} {
Espionne "$FichierTFA does not exist"
InformeSansDemander $Nom "=BlastP: $FichierTFA does not exist."
continue
}
if {$GardeTout && [file exists $FichierBlast] } {
continue
}
if { $TestExistence && [file exists $FichierBlast] } {
if {[OuiOuNon "$FichierBlast already exists\nDo I keep it ?"]} {
continue
}
}
Espionne "Je vais lancer BlastP sur $Nom"
InformeSansDemander $Nom "=BlastP: prediction genscan trouvee"
eval exec $CommandeBlast
}
}
proc LesLocalisationsSurChroContig NomVoulu {
global LesLocalisationsSurChroContig
global RepertoireDuGenome
JeMeSignale
if {[info exists LesLocalisationsSurChroContig($NomVoulu)]} {
return [set LesLocalisationsSurChroContig($NomVoulu)]
}
if {[info exists LesLocalisationsSurChroContig("EstCharge")]} {
return [set LesLocalisationsSurChroContig("EstCharge")]
}
set Fichier "$RepertoireDuGenome/fiches/localisationchrocontig"
if {[file exists $Fichier]} {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s" Nom
regsub "$Nom " $Ligne "" Ligne
lappend LesLocalisationsSurChroContig($Nom) $Ligne
}
set LesLocalisationsSurChroContig("EstCharge") [list "No value"]
return [LesLocalisationsSurChroContig $NomVoulu]
}
if {$NomVoulu=="Create"} {
set Liste [ListeDesPABs]
set CreeFichier 1
} else {
set Liste [list $NomVoulu]
set CreeFichier 0
}
foreach Nom $Liste {
set LesHomologues [ChaqueSegmentDuBlastN $Nom]
set LesChroContig($Nom) {}
set OldChroContig ""
foreach Homologue $LesHomologues {
scan $Homologue "%s %s %s %s %s %f %d %d %d %d" ChroContigTroncon n1 n2 Orga PrctId E DQ FQ Deb Fin
if {[expr $E > 1.e-3] } { continue }
regsub {\:} $ChroContigTroncon " " ChroContigTroncon
regsub {_} $ChroContigTroncon " " ChroContigTroncon
set Troncon 0
scan $ChroContigTroncon "%s %s %s" Chro Contig Troncon
set Troncon [Base10 $Troncon]
regsub {^0} $Chro "" Chro
if {![info exists DejaVu($Nom,$Chro,$Contig)]} {
set DejaVu($Nom,$Chro,$Contig) 1
if {$Deb<$Fin} {
set MeilleureGauche($Nom,$Chro,$Contig) $Deb
set MeilleureDroite($Nom,$Chro,$Contig) $Fin
} else {
set MeilleureGauche($Nom,$Chro,$Contig) $Fin
set MeilleureDroite($Nom,$Chro,$Contig) $Deb
}
lappend LesNomChroContigDansLOrdre($Nom) "$Nom,$Chro,$Contig"
}
lappend LesHomologuesDe($Nom,$Chro,$Contig) $Homologue
}
if {[info exists DejaVu]} { unset DejaVu }
if { ! [info exists LesNomChroContigDansLOrdre($Nom)]} { continue }
foreach NCC [set LesNomChroContigDansLOrdre($Nom)] {
foreach Homologue [set LesHomologuesDe($NCC)] {
scan $Homologue "%s %s %s %s %s %f %d %d %d %d" ChroContigTroncon n1 n2 Orga PrctId E DQ FQ Deb Fin
regsub {\:} $ChroContigTroncon " " ChroContigTroncon
regsub {_} $ChroContigTroncon " " ChroContigTroncon
set Troncon 0
scan $ChroContigTroncon "%s %s %s" Chro Contig Troncon
set Troncon [Base10 $Troncon]
regsub {^0} $Chro "" Chro
if {![info exists DejaVu($Nom,$Chro,$Contig)]} {
lappend LesChroContig($Nom) "$Chro $Contig"
set DejaVu($Nom,$Chro,$Contig) 1
}
lappend LesPositions($Nom,$Chro,$Contig) $Deb $Fin
if {[expr $Deb < $Fin]} {
set Sens($Nom,$Chro,$Contig) "+"
} else {
set Sens($Nom,$Chro,$Contig) "-"
}
}
set LesLocas {}
foreach Loc [set LesChroContig($Nom)] {
scan $Loc "%s %s" Chro Contig
set LesPosTriees [lsort -integer [set LesPositions($Nom,$Chro,$Contig)]]
set MG [set MeilleureGauche($Nom,$Chro,$Contig)]
set iMG [lsearch $LesPosTriees $MG]
while 1 {
if {$iMG<=0} { break }
set NewMG [lindex $LesPosTriees [incr iMG -1]]
if {[expr $NewMG + 100000 < $MG]} { break }
set MG $NewMG
}
set MD [set MeilleureDroite($Nom,$Chro,$Contig)]
set iMD [lsearch $LesPosTriees $MD]
set L [expr [llength $LesPosTriees] -1]
while 1 {
if {$iMD>=$L} { break }
set NewMD [lindex $LesPosTriees [incr iMD 1]]
if {[expr $MD + 100000 < $NewMD]} { break }
set MD $NewMD
}
set Gauche $MG
set Droite $MD
set Orient [set Sens($Nom,$Chro,$Contig)]
Espionne "LesLocalisation sur $Nom $Chro $Contig $Gauche $Droite $Orient"
lappend LesLocas "$Chro $Contig $Gauche $Droite $Orient"
}
}
if {$CreeFichier} {
set LesLocalisationsSurChroContig($Nom) $LesLocas
foreach Lo $LesLocas {
AppendAuFichier $Fichier "$Nom $Lo"
}
} else {
return $LesLocas
}
set LesLocalisationsSurChroContig("EstCharge") [list "No value"]
}
if {$CreeFichier} { return $Fichier }
return [LesLocalisationsSurChroContig $NomVoulu]
}
proc CreeBornesDesCDNAs {{Qui ""} {Adjonction ""}} {
global RepertoireDuGenome
set FichierBornesDesPABs "[RepertoireDuGenome]/fiches/bornesdespabs"
if {[file exists $FichierBornesDesPABs]} { Garde $FichierBornesDesPABs }
set DebutBornes 101
set FinBornes $DebutBornes
set NumDuDernier 0
if {$Adjonction=="EnFin"} {
set Adjonction 1
set AdjonctionEnFin 1
set LesBornesDesPABs [LesLignesDuFichier $FichierBornesDesPABs]
} else {
set Adjonction 0
set AdjonctionEnFin 0
set LesBornesDesPABs {}
}
if {$AdjonctionEnFin} {
set DernierPos [DernierPAB "EnPosition"]
set F [Box $DernierPos fin]
set DebutBornes [expr $F + 1000]
set FinBornes $DebutBornes
set DernierNum [DernierPAB "EnNumero"]
regsub "^[PreFixe]" $DernierNum "" NumDuDernier
set NumDuDernier [Base10 $NumDuDernier]
set NouveauNum [expr $NumDuDernier + 1]
set NouveauNom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $NouveauNum]
if { ! [OuiOuNon "Ok to add the new elements \n\
at $DebutBornes after $DernierPos \n\
Numbering starts with $NouveauNom"]} { return "" }
if { ! [OuiOuNon "I'll replace $FichierBornesDesPABs and exit.\nOK ?"]} { return "" }
}
set OS [Entre "Homo sapiens"]
set OC [OCduOS $OS]
if { ! [file exists "$RepertoireDuGenome/nuctfa"]} { File mkdir "$RepertoireDuGenome/nuctfa" }
if { ! [file exists "$RepertoireDuGenome/nucembl"]} { File mkdir "$RepertoireDuGenome/nucembl" }
set PrenomNom(cDNA_with_owner_clone) "cDNAs with owner and clone"
set PrenomNom(Affymetrix) "Affymetrix"
set PrenomNom(In_TFA) "Nucleic sequences in one TFA file"
set PrenomNom(In_TFA_WithCC) "Nucleic sequences in one TFA file with CC and Owner"
set PrenomNom(In_TFA_FromEstChip) "Nucleic sequences in one TFA file with xxx_yyy and definition"
set PrenomNom(DNA_with_Access_Alias) "file with a 'access (alias (def))' list"
if {$Qui==""} {
set LesQui [array names PrenomNom]
foreach Q $LesQui {
lappend LesPNoms [set PrenomNom($Q)]
}
set Qui [ChoixParmiJoli $LesQui {} $LesPNoms]
if {$Qui==""} { exit }
}
if {$Qui=="DNA_with_Access_Alias"} {
if { ! [OuiOuNon "Could You browse for a file with 'access (alias (def))' ?"]} {
return [CreeBornesDesCDNAs]
}
set FichierAccessAlias [ButineArborescence "All" $RepertoireDuGenome]
if {$FichierAccessAlias==""} { return [CreeBornesDesCDNAs] }
set Debut $DebutBornes
set Fin $Debut
set Long 1000
set n $NumDuDernier
foreach Ligne [LesLignesDuFichier $FichierAccessAlias] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
set Alias [format "%s%[FormatDesNumerosPourCollection]" "ALIAS_" $n]
scan $Ligne "%s %s" Access Alias
regsub "$Alias +$Access +" $Ligne "" Descr
set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
set Debut [expr $Debut + $Offset]
set Fin [expr $Debut + $Long -1]
set Orient "F"
incr n
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
set FichierNucTFA "$RepertoireDuGenome/nuctfa/$Nom"
if {! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA]} {
set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNucEMBL"]
if {$LesLignesEMBL==""} {
AppendAuFichier "$RepertoireDuGenome/not_founded_accesses" $Access
continue
}
set DE ""
set LesNouvellesLignes {}
foreach Ligne $LesLignesEMBL {
if {[regexp "^ID " $Ligne]} {
scan $Ligne "%s %s" Bidon ID
set Ligne "ID $Nom created by Gscope from ID $ID"
}
if {[regexp "^AC " $Ligne]} {
scan $Ligne "%s %s" Bidon AC
set Ligne "AC $Nom;"
}
if {[regexp "^DE " $Ligne]} {
regsub {DE *} $Ligne "" DE
}
if {[regexp "^SQ " $Ligne]} {
lappend LesNouvellesLignes "CC Original description: $Descr"
}
lappend LesNouvellesLignes $Ligne
}
set Entete "$Nom $Access $Alias : $Descr"
Espionne $Entete
set NucEMBL [join $LesNouvellesLignes "\n"]
set NucTFA [SequenceFormatTFA $NucEMBL "$Entete" "embl"]
Sauve $NucTFA dans $FichierNucTFA
Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
}
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
}
}
set FromEstChip 0
set WithCC 0
set IExpect "(I expect '>access definition ...')"
if {$Qui=="In_TFA_WithCC"} {
set WithCC 1
set Qui "In_TFA"
set IExpect "(I expect '>CodeClone Owner')"
}
if {$Qui=="In_TFA_FromEstChip"} {
set FromEstChip 1
set Qui "In_TFA"
set IExpect "(I expect '>xxx_yyy definition')"
}
if {$Qui=="In_TFA"} {
if { ! [OuiOuNon "Could You browse a TFA file with all sequences ? \n $IExpect"]} {
return [CreeBornesDesCDNAs]
}
set FichierTFAs [ButineArborescence "All" $RepertoireDuGenome]
if {$FichierTFAs==""} { return [CreeBornesDesCDNAs] }
set Debut $DebutBornes
set Fin $Debut
set Long 1000
set n $NumDuDernier
foreach Access [LaSequenceDuTFAs $FichierTFAs "LaListeDesAccess"] {
set LesLignesEMBL {}
set TFA [LaSequenceDuTFAs $FichierTFAs $Access]
set Descr [EnteteDuTexteTFA $TFA]
set Seq [QueLaSequenceDuTexteTFA $TFA]
regsub ">" $Descr "" Descr
if {$FromEstChip} { scan $Descr "%s" CC ; regsub "$CC " $Descr "" Descr }
if {$WithCC} { scan $Descr "%s %s" CC Owner }
regsub -all -nocase {[^a-z]} $Seq "" Seq
set LongSeq [string length $Seq]
set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
set Debut [expr $Debut + $Offset]
set Fin [expr $Debut + $Long -1]
set Orient "F"
incr n
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
set FichierNucTFA "$RepertoireDuGenome/nuctfa/$Nom"
if {! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA]} {
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $Nom created by Gscope from a tfas file "
lappend LesLignesEMBL "AC $Nom;"
if {$WithCC} {
lappend LesLignesEMBL "CC CodeClone $CC Owner $Owner"
set Entete "$Nom $CC $Owner"
} elseif {$FromEstChip} {
lappend LesLignesEMBL "CC CodeClone $CC"
lappend LesLignesEMBL "CC Description $Descr"
set Entete "$Nom $CC $Descr"
} else {
set Sep ":"
foreach Wrap [WrapLeTexte $Descr 50] {
lappend LesLignesEMBL "CC Original description$Sep $Wrap"
set Sep "+"
}
set Entete "$Nom : $Descr"
}
set SeqEMBL [QueSequenceFormatEMBL $Seq "AvecSQ"]
lappend LesLignesEMBL $SeqEMBL
set NucEMBL [join $LesLignesEMBL "\n"]
set NucTFA [SequenceFormatTFA $NucEMBL "$Entete" "embl"]
Sauve $NucTFA dans $FichierNucTFA
Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
}
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
}
}
if {$Qui=="Affymetrix"} {
if { ! [OuiOuNon "Could You browse a file with Affymetrix Clone Accession numbers ? \n\
(I expect 'Clone Access Definition ...')"]} {
return [CreeBornesDesCDNAs]
}
set FichierAffy [ButineArborescence "All" $RepertoireDuGenome]
if {$FichierAffy==""} { return [CreeBornesDesCDNAs] }
set Debut $DebutBornes
set Fin $Debut
set Long 500
set n $NumDuDernier
foreach CcAcDescr [LesLignesDuFichier $FichierAffy] {
if { ! [regexp -nocase {[a-z]} $CcAcDescr]} { continue }
scan $CcAcDescr "%s %s" Alias Access
regsub "$Alias +$Access +" $CcAcDescr "" Descr
set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
set Debut [expr $Debut + $Offset]
set Fin [expr $Debut + $Long -1]
set Orient "F"
incr n
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set FichierNucEMBL "$RepertoireDuGenome/nucembl/$Nom"
set FichierNucTFA "$RepertoireDuGenome/nuctfa/$Nom"
if {! [file exists $FichierNucEMBL] || ! [file exists $FichierNucTFA]} {
set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutNucEMBL"]
if {$LesLignesEMBL==""} {
AppendAuFichier "$RepertoireDuGenome/not_founded_accesses" $Access
continue
}
set DE ""
set LesNouvellesLignes {}
foreach Ligne $LesLignesEMBL {
if {[regexp "^ID " $Ligne]} {
scan $Ligne "%s %s" Bidon ID
set Ligne "ID $Nom created by Gscope from ID $ID"
}
if {[regexp "^AC " $Ligne]} {
scan $Ligne "%s %s" Bidon AC
set Ligne "AC $Nom;"
}
if {[regexp "^DE " $Ligne]} {
regsub {DE *} $Ligne "" DE
}
if {[regexp "^SQ " $Ligne]} {
lappend LesNouvellesLignes "CC Affy's description: $Descr"
}
lappend LesNouvellesLignes $Ligne
}
set Entete "$Nom $Access $Alias : $Descr"
Espionne $Entete
set NucEMBL [join $LesNouvellesLignes "\n"]
set NucTFA [SequenceFormatTFA $NucEMBL "$Entete" "embl"]
Sauve $NucTFA dans $FichierNucTFA
Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
}
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
}
}
if {$Qui=="cDNA_with_owner_clone"} {
foreach Fichier [glob "$RepertoireDuGenome/cdna/*"] {
set LeTFA [LesLignesDuFichier $Fichier]
set Entete [lindex $LeTFA 0]
set LaSeq [lrange $LeTFA 1 end]
scan $Entete "%s %s" ChevronUser Clone
regsub "$ChevronUser $Clone" $Entete "" Remarque
set Remarque [string trim $Remarque]
regsub ">" $ChevronUser "" User
set CDNAcode "$User$Clone"
set Seq [join $LaSeq ""]
set NomFiCDNA [file tail $Fichier]
set JR [JumeauRepresentatif $NomFiCDNA]
if {$JR!=$NomFiCDNA && $JR!=""} { append Remarque "SameSeqAs:$JR" }
set NomDuFichierCDNA($CDNAcode) $NomFiCDNA
set Clones($CDNAcode) $Clone
set Seqs($CDNAcode) $Seq
set Remarques($CDNAcode) $Remarque
set Users($CDNAcode) $User
lappend LesCDNAs $CDNAcode
}
set LesCDNAs [lsort $LesCDNAs]
set Debut $DebutBornes
set Fin $Debut
set n $NumDuDernier
foreach CDNA $LesCDNAs {
incr n
set Seq [set Seqs($CDNA)]
set Clone [set Clones($CDNA)]
set Rem [set Remarques($CDNA)]
set User [set Users($CDNA)]
set NomFiCDNA [set NomDuFichierCDNA($CDNA)]
set Long [string length $Seq]
set Offset [expr (($Fin - $Debut + 15)/3*3) + 1]
set Debut [expr $Debut + $Offset]
set Fin [expr $Debut + $Long -1]
set Orient "F"
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] $n]
set PABduFiCDNA($NomFiCDNA) $Nom
lappend LesBornesDesPABs "$Nom $Debut $Fin $Orient"
if {[regexp "SameSeqAs:" $Rem]} {
set JR [StringApres "SameSeqAs:" dans $Rem]
append Rem " [set PABduFiCDNA($JR)]"
}
set NucTFA [SequenceFormatTFA $Seq "$Nom $Clone $User $Rem" "nucbrut"]
set NucEMBL ""
append NucEMBL "ID $Nom PRELIMINARY; DNA; $Long bases."
append NucEMBL "\nAC $Nom"
append NucEMBL "\nOS $OS."
append NucEMBL "\nOC $OC"
append NucEMBL "\nCC -!- cDNA sequence by [set PrenomNom($Qui)]"
append NucEMBL "\nCC User $User Clone $Clone"
if {$Rem!=""} { append NucEMBL "\nCC $Rem" }
append NucEMBL "\n[QueSequenceFormatEMBL $Seq AvecSQ]"
Sauve $NucTFA dans "$RepertoireDuGenome/nuctfa/$Nom"
Sauve $NucEMBL dans "$RepertoireDuGenome/nucembl/$Nom"
if {$Adjonction} { InformeIdentitesDuCDNA $Nom }
SauveLesLignes $LesBornesDesPABs dans $FichierBornesDesPABs
}
}
if {$Adjonction} { exit }
InformeIdentitesDuCDNAPourTous
return $LesBornesDesPABs
}
proc ShowHTMLBox {K Action} {
global ShowHTMLBox
JeMeSignale
set Id [$K find withtag current]
if {$Action=="Enter"} {
if {[info exists ShowHTMLBox($K,Image)]} { $K raise [set ShowHTMLBox($K,Image)] }
set LesTags [$K gettags $Id]
set Alias [lindex $LesTags 0]
set Nom [NomDuAlias $Alias]
if {$Nom!=""} {
return [FetcheBox $K $Nom $Nom]
} else {
return [RepereBox $Alias]
}
}
if {$Action=="Press"} {
$K lower $Id
set ShowHTMLBox($K,Image) $Id
return
}
if {$Action=="Release"} {
if {[info exists ShowHTMLBox($K,Image)]} { $K raise [set ShowHTMLBox($K,Image)] }
}
}
proc MapCliquable {{Action "Create"} {Repertoire ""}} {
global RepertoireDuGenome
global LesOrdresPourGIF
Gs "Canvas"
if {$Repertoire==""} { set Repertoire "$RepertoireDuGenome/maps" }
set LesFichierSize [glob -nocomplain "$Repertoire/*.size"]
if {$Action=="Existe"} { return [llength $LesFichierSize] }
set Titre [PreFixe]
if {$Action=="PourGif"} {
set PourGif 1
set Image NeRienFaire
set Canvas NeRienFaire
set Bind NeRienFaire
set Pack NeRienFaire
set Fram NeRienFaire
set Button NeRienFaire
set Scrollbar NeRienFaire
set Grid NeRienFaire
set FonctionRejetteLaBoite "RejetteLaBoite"
set LesOrdresPourGif {}
set w "PourGif"
set K "OrdrePourGif"
} else {
set PourGif 0
set Image image
set Canvas canvas
set Bind bind
set Pack pack
set Fram frame
set Button button
set Scrollbar scrollbar
set Grid grid
set FonctionRejetteLaBoite "NeRejettePasLaBoite"
set w [NomDe board]
catch {destroy $w}
toplevel $w
wm title $w "$Titre"
wm iconname $w "$Titre"
set K $w.canvas
}
if {[llength $LesFichierSize]>1} {
set FichierSize [ChoixParmi $LesFichierSize]
if {$FichierSize==""} { return {} }
} else {
set FichierSize [lindex $LesFichierSize 0]
}
regsub ".size$" $FichierSize ".gif" FichierImage
regsub ".size$" $FichierSize ".html" FichierHTML
scan [PremiereLigneDuFichier $FichierSize] "%d %d" Largeur Hauteur
if {$PourGif} {
} else {
set K [UnCanva $Largeur $Hauteur]
}
$Image create photo FondDeMap -file $FichierImage
foreach Aire [LesAiresCliquablesDuHTML $FichierHTML] {
scan $Aire "%s %d %d %d %d %s" AliasLu xMin yMin xMax yMax Ref
if {$PourGif} {
set LesTags [list ]
} else {
set LesTags [list $AliasLu "ClickMe"]
}
$K create rectangle $xMin $yMin $xMax $yMax -fill red -tags $LesTags
}
$K bind "ClickMe" "ShowHTMLBox $K Enter"
$K bind "ClickMe" "ShowHTMLBox $K Leave"
$K create image 0 0 -image FondDeMap -anchor "nw" -tags [list Image]
$K bind "Image" <1> "ShowHTMLBox $K Press"
if {$PourGif} {
return $LesOrdresPourGIF
} else {
return $K
}
}
proc LesAiresCliquablesDuHTML {{FichierHTML ""}} {
global RepertoireDuGenome
if {$FichierHTML==""} {
set FichierHTML [ButineArborescence "All"]
if {$FichierHTML==""} { return {} }
}
set Texte [ContenuDuFichier $FichierHTML]
set Map [ValeurDeLaBalise "map" Texte]
while {$Map!=""} {
set Area [ValeurDeLaBalise "area" Map]
if {$Area==""} { break }
set Reference [StringApres "href=" dans $Area]
regsub -all {\"} $Reference "" Reference
set Nom [file tail $Reference]
regsub -nocase {(.htm|.html)$} $Nom "" Nom
set Shape [StringApres "shape=" dans $Area]
set TexteCoords [StringSuivant "coords=" dans $Area]
regsub -all {[\"\,]} $TexteCoords " " TexteCoords
if {[regexp "circle" $Shape]} {
scan $TexteCoords "%d %d %d" xC yC rC
set xMin [expr $xC-$rC]
set xMax [expr $xC+$rC]
set yMin [expr $yC-$rC]
set yMax [expr $yC+$rC]
} else {
scan $TexteCoords "%d %d %d %d" xMin yMin xMax yMax
}
lappend LesAires "$Nom $xMin $yMin $xMax $yMax $Reference"
}
return $LesAires
}
proc CreeAccessAliasDefinitionPourPeroxNew {} {
global RepertoireDuGenome
foreach {a b c} [LesLignesDuFichier "$RepertoireDuGenome/DeAurora/perox20010503ok.txt"] {
set Alias ""
set Access ""
scan $a "%s" Alias
set DE [string trim $b]
scan $c "%s" Access
if {$Alias=="" || $DE=="" || $Access==""} { break }
lappend Sortie "$Access $Alias $DE"
set LSDB [LaSequenceDesBanques $Access $Access a "OnVeutEMBL"]
if {$LSDB=={}} {
FaireLire "$a $b $c\nI couldn't get the sequence $Access"
}
}
Espionne [SauveLesLignes $Sortie dans "$RepertoireDuGenome/PeroxAccesAliasDef.fof"]
exit
}
proc NarcisseDuAliasPourTous {} {
global RepertoireDuGenome
global NarcisseDuAlias
ChargeNarcisseDuAlias
set FichierNarcisse "$RepertoireDuGenome/fiches/narcisse"
if {[info exists NarcisseDuAlias] && ! [file exists $FichierNarcisse]} {
if {[OuiOuNon "Can I use NarcisseDuAlias to create Narcisse ?"]} {
set LesNarcisses {}
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
if {[info exists NarcisseDuAlias($Alias)]} {
set NdA [set NarcisseDuAlias($Alias)]
set Narcisse($Nom) $NdA
lappend LesNarcisses "$Nom $NdA"
}
}
if {$LesNarcisses!={}} {
SauveLesLignes $LesNarcisses dans $FichierNarcisse
}
}
}
}
proc InformeValiGNParAlias {} {
foreach Nom [ListeDesPABs] {
set ValiGN [ExtraitInfo $Nom "ValiGN"]
if {$ValiGN!=""} { continue }
set Alias [Alias $Nom]
if {$Alias==""} { continue }
InformeSansDemander $Nom "=ValiGN: $Alias"
}
}
proc InformeParChangementEnteteDuChamp {Ancien Nouveau} {
foreach Nom [ListeDesPABs] {
set Valeur [ExtraitInfo $Nom $Ancien]
if {$Valeur==""} { continue }
Espionne "$Nom $Nouveau: $Valeur"
InformeParSuppressionDuChamp $Nom $Ancien
InformeSansDemander $Nom "$Nouveau: $Valeur"
}
}
proc VerifieLesPDBs {} {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/lespdbs"] {
regsub ">" $Ligne "" Ligne
ScanLaListe [split $Ligne ":"] Nom aPDB
set SeqBanque [LaSequenceDuTFAs "/blast/pdb" $aPDB]
set SeqPerox [LaSequenceDuTFAs "$RepertoireDuGenome/tfasdescopains/$Nom" $aPDB]
set SeqBanque [join [lrange [split $SeqBanque "\n"] 1 end] ""]
set SeqPerox [join [lrange [split $SeqPerox "\n"] 1 end] ""]
if {$SeqBanque==$SeqPerox} {
continue
}
Espionne "$Nom $aPDB"
Espionne "$SeqBanque\n$SeqPerox"
FaireLire "$Nom $aPDB"
lappend LesMauvais $Nom
}
SauveLesLignes $LesMauvais dans "$RepertoireDuGenome/lesmauvais"
exit
}
proc BlastPPourCollection Nom {
Wup "Attention we call the BlastPPourTous for only one !!"
BlastPPourTous $Nom
}
proc MSFPourCollection Nom {
Wup "Attention we call the DbClustalPourTous for only one !!"
DbClustalPourTous $Nom
}
proc CreeProteomeAvecUneListeAccessAliasDefinition {Fichier {AADorBAAD ""}} {
global RepertoireDuGenome
global NarcisseDuAlias
set Geno [file tail $RepertoireDuGenome]
set FichierFOF "$RepertoireDuGenome/$Geno.fof"
set RepProteome "$RepertoireDuGenome/proteome"
if { ! [file exists $RepProteome]} {
File mkdir $RepProteome
}
if {[glob -nocomplain "$RepProteome/*"]=={}} {
set LaTotale 1
} else {
set LaTotale [OuiOuNon "Do I replace all known files ? "]
}
set TesteTout 0
set AppendSeul 0
while {[file exists $FichierFOF]} {
set LaTotale 0
if {[OuiOuNon "$FichierFOF already exists. \nDo I keep it, doing nothing ?" 0]} { return $FichierFOF }
if {[OuiOuNon "$FichierFOF already exists. \nDo I replace all existing files ?" 0]} {
set LaTotale 1
break
}
if {[OuiOuNon "$FichierFOF already exists. \nDo I test for changes ?"]} {
set TesteTout 1
break
}
}
if {$TesteTout} {
foreach Ligne [LesLignesDuFichier $FichierFOF] {
scan $Ligne "%s %s" Alias Ver
set VerDuAlias($Alias) $Ver
}
}
if {$AADorBAAD==""} {
if { [OuiOuNonMemo "Does this file contain BanqueId AND Access (Alias (Definition)) ?" 0] } {
set AADorBAAD "BAAD"
} else {
set AADorBAAD "AAD"
}
}
set BanqueIdAndAccess [string compare -nocase $AADorBAAD "BAAD"]
set n 0
foreach Ligne [LesLignesDuFichier $Fichier] {
incr n
if { ! [regexp -nocase {[a-z]+} $Ligne]} { continue }
if {[regexp -nocase {^[ \t]*\#} $Ligne]} { continue }
regsub -all "\t" $Ligne " " Ligne
set BanqueId ""
set Access ""
set Alias "ALIAS_$n"
set DE ""
if {$BanqueIdAndAccess} {
scan $Ligne "%s %s %s" BanqueId Access Alias
regsub "\:" $BanqueId "\\:" BanqueIdSansPP
regsub " *$BanqueIdSansPP +$Access +$Alias +" $Ligne "" DE
} else {
scan $Ligne "%s %s" Access Alias
regsub " *$Access +$Alias +" $Ligne "" DE
}
if {$Access==""} { set Access $BanqueId }
Espionne "$BanqueId $Access $Alias $DE"
if {$TesteTout && [info exists VerDuAlias($Alias)]} {
set Ver [set VerDuAlias($Alias)]
if {[regexp "/" $Access]} {
set RepAccess $Access
} else {
set RepAccess "$RepProteome/$Access"
}
while {$RepAccess!=$Ver} {
FaireLire " Reading the line \n \
$Ligne \n \
I see that \n\
$Alias $RepAccess \n \
doesn't correspond to the old \n\
$Alias $Ver"
if {[OuiOuNon "Do I ignore this, and use $Access ?"]} { break }
if {[OuiOuNon "Do I use the old access $Ver ?"]} { set Access [file tail $Ver] }
if {[OuiOuNon "Do I cancel creation of $FichierFOF ?"]} { return "" }
}
}
set FichierEMBL "$RepProteome/[file tail $Access]"
regsub {\.tfa$} $FichierEMBL "" FichierEMBL
set AccessOK $Access
if { $LaTotale || ! [file exists $FichierEMBL]} {
if {[regexp {^https?:} $Access]} {
set LesLignesEMBL [LesLignesDuFichier $Access]
} else {
set AccessOK "NotYetAvailable"
set LesLignesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"]
}
while {$LesLignesEMBL=={}} {
if {[file exists $FichierEMBL]} {
set LesLignesEMBL [LesLignesDuFichier $FichierEMBL]
break
}
if {[OuiOuNon "I didn't found the sequence $Access. Do I do it later ?"]} {
set DoItLater 1
break
}
if {[OuiOuNon "I didn't found the sequence $Access. Do I skipp ?"]} {
set DoItLater 0
break
}
if {[OuiOuNon "I didn't found the sequence $Access. Do I cancel ?"]} { return "" }
if {[OuiOuNon "I didn't found the sequence $Access. Do I stop ?"]} { exit }
}
if {$LesLignesEMBL!={}} {
SauveLesLignes $LesLignesEMBL dans $FichierEMBL
} else {
if {$DoItLater} {
set $FichierEMBL "xx"
} else {
continue
}
}
}
lappend LesFOFs "$Alias $FichierEMBL"
set NarcisseDuAlias($Alias) $AccessOK
}
return [SauveLesLignes $LesFOFs dans $FichierFOF]
}
proc QuelsCopainsDisponibles {} {
global RepertoireDuGenome
set LesRepertoiresCopains [glob -nocomplain $RepertoireDuGenome/co*]
foreach Copain $LesRepertoiresCopains {
lappend LesCopainsDisponibles [file tail $Copain]
}
return $LesCopainsDisponibles
}
proc MaquillePourTous {{LaListeMerci ""}} {
global RepertoireDuGenome
global Maquille
global MaquilleNon
if {[info exists MaquilleNon] && $MaquilleNon} { return {} }
set Maquillage "$RepertoireDuGenome/fiches/maquillage"
if {[file exists $Maquillage]} {
foreach Ligne [LesLignesDuFichier $Maquillage] {
scan $Ligne "%s %s" O N
set Maquille($O) $N
set Maquille($N) $O
}
}
if { ! [info exist Maquille]} {
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
set OldMSF "$RepertoireDuGenome/DeBayroch/Familles/$Alias/$Alias.msf"
set NewMSF "$RepertoireDuGenome/msf/$Nom"
set OnAttend 1
if { ! [file exists $OldMSF]} { continue }
foreach OldLigne [LesLignesDuFichier $OldMSF] NewLigne [LesLignesDuFichier $NewMSF] {
if { ! [regexp "Name:" $OldLigne]} {
if {$OnAttend} { continue } else { break }
}
set OnAttend 0
scan $OldLigne "%s %s" Name OldNom
scan $NewLigne "%s %s" Name NewNom
if {[info exists Maquille($OldNom)]} {
FaireLire "$Nom $Alias $OldNom $NewNom"
}
set Maquille($OldNom) $NewNom
lappend LeMaquillage "$OldNom $NewNom"
set Maquille($NewNom) $OldNom
}
}
SauveLesLignes $LeMaquillage dans $Maquillage
}
if {$LaListeMerci!=""} { return [LesLignesDuFichier $Maquillage] }
return
}
proc Maquille Nom {
global Maquille
global MaquilleNon
if {[info exists MaquilleNon] && $MaquilleNon} { return $Nom }
if { ! [info exists Maquille]} { MaquillePourTous }
if { ! [info exists Maquille($Nom)]} { return $Nom }
return [set Maquille($Nom)]
}
proc Family Nom {
return [ExtraitInfo $Nom "Family"]
}
proc ComplementInfoPourTous {} {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/Fam.txt"] {
scan $Ligne "%s %s" Alias Autre
set Alias [string toupper $Alias]
set MaLigne($Alias) $Ligne
if { ! [regexp {\(} $Autre]} { set Autre "" }
Espionne "$Alias $Autre."
regsub -all {[\(\)]} $Autre "" MonAutre($Alias)
set Reste [string range $Ligne 26 35]
set BAE ""
if {[regexp "P" $Reste]} { append BAE "B" } else { append BAE "b" }
if {[regexp "A" $Reste]} { append BAE "A" } else { append BAE "a" }
if {[regexp "E" $Reste]} { append BAE "E" } else { append BAE "e" }
set MonBAE($Alias) $BAE
}
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
set Autre [set MonAutre($Alias)]
if {$Autre!=""} { set Autre "/$Autre" }
InformeSansDemander $Nom "ValiGN: $Alias$Autre\nFamily: [set MaLigne($Alias)]\nBAE: [set MonBAE($Alias)]"
}
}
proc AliasPourTous {} {
global RepertoireDuGenome
FaireLire "Please browse for the file .fof containing 'Alias ... ... ...'"
set FOF [ButineArborescence "All" "$RepertoireDuGenome"]
set Numero 0
foreach Ligne [LesLignesDuFichier $FOF] {
if { ! [regexp -nocase {[A-Z0-9_]} $Ligne]} { continue }
catch {unset Nom}
catch {unset Ver}
catch {unset OrigineBlastP}
catch {unset OrigineBallast}
catch {unset OrigineMSF}
set NbLus [scan $Ligne "%s %s %s %s %s %s" Alias OrigineVer OrigineBlastP OrigineBallast OrigineMSF SecondMSF]
if {$NbLus < 2} {
if {[OuiOuNon "$Ligne\n missing values. Do I stop ?"]} { exit }
continue
}
set Nom [format "%s%[FormatDesNumerosPourCollection]" [PreFixe] [incr Numero]]
InformeSansDemander $Nom "=Alias: $Alias"
}
}
proc LaListeNomAlias {} {
set LaListe {}
foreach Nom [ListeDesPABs] {
set Alias [Alias $Nom]
if {$Alias==""} { set Alias "unknown" }
lappend LaListe "$Nom $Alias"
}
return [join $LaListe "\n"]
}
proc LesAliasExistants {} {
return [NomDuAlias "LesAlias"]
}
proc NomDuAlias Alias {
global NomDuAlias
set ALIAS [string toupper $Alias]
if {[info exists NomDuAlias($Alias)]} { return [set NomDuAlias($Alias)] }
if {[info exists NomDuAlias($ALIAS)]} { return [set NomDuAlias($ALIAS)] }
if {[info exists NomDuAlias("EstCharge")]} { return "" }
set NomDuAlias("EstCharge") 1
set LesAlias {}
foreach Nom [ListeDesPABs] {
set AliasLu [Alias $Nom]
set ALIASLU [string toupper $AliasLu]
if {$AliasLu==""} { continue }
lappend LesAlias $AliasLu
lappend NomDuAlias($AliasLu) $Nom
if {$ALIASLU!=$AliasLu} { lappend NomDuAlias($ALIASLU) $Nom }
}
set NomDuAlias(LESALIAS) [lsort -unique $LesAlias]
return [NomDuAlias $Alias]
}
proc Alias Nom {
return [ExtraitInfo $Nom "Alias"]
}
proc FormatDesNumerosPourCollection {{OrfNumbering ""}} {
global RepertoireDuGenome
global FormatDesNumerosPourCollection
if {$OrfNumbering!="" && [info exists FormatDesNumerosPourCollection]} { unset FormatDesNumerosPourCollection }
if {[info exists FormatDesNumerosPourCollection]} { return $FormatDesNumerosPourCollection }
set Fichier "$RepertoireDuGenome/fiches/format_orf_numbering"
if {[file exists $Fichier]} {
scan [ContenuDuFichier $Fichier] "%s" FormatDesNumerosPourCollection
return $FormatDesNumerosPourCollection
}
set FormatDesNumerosPourCollection ""
while {$FormatDesNumerosPourCollection==""} {
if {$OrfNumbering==""} {
FaireLire "Howmany digits do we use for ORF numbering ? \n(1 from 1 to 9, 2 from 01 to 99, 3 from 001 to 999, etc.)"
set N [Entre 3]
} else {
set N $OrfNumbering
}
if {[regexp {^[1-9]+$} $N]} { break }
if {$OrfNumbering!=""} { FaireLire "Illegal OrfNumbering $OrfNumbering. I'll ask you for a correct value." }
set OrfNumbering ""
}
set FormatDesNumerosPourCollection "$N.${N}d"
Sauve $FormatDesNumerosPourCollection dans $Fichier
return $FormatDesNumerosPourCollection
}
proc AfficheLesSortiesDuBallast {FichierBlastP {Quoi "rsf"}} {
regsub {/co[a-z]+/} $FichierBlastP "/coballast/" FichiersBallast
regsub -nocase {\.[a-z_]*$} $FichiersBallast "" FichiersBallast
set Fichier "$FichiersBallast.$Quoi"
Espionne $Fichier
if { ! [file exists $Fichier]} { return "" }
return [AfficheFichier $Fichier "Avec$Quoi"]
}
proc InformeLesCopainsDeThetase {{Liste {}}} {
global RepertoireDuGenome
global InformeSansDemander
set InformeSansDemander 1
if {$Liste=={}} { set Liste [ListeDesPABs] }
foreach Nom $Liste {
foreach FichierCopain [glob -nocomplain "$RepertoireDuGenome/copains/$Nom/*"] {
set Access [file tail $FichierCopain]
set LesEMBL [LaSequenceDesBanques $Access $Access AccessOK "OnVeutEMBL"]
if {$LesEMBL=={}} {
InformeLeCopain "$Nom/$Access" "=AltAccess: not found"
continue
}
set SeqCopain [LaSequenceDesLignesEMBL [LesLignesDuFichier $FichierCopain]]
set SeqBanque [LaSequenceDesLignesEMBL $LesEMBL]
if {[string equal -nocase $SeqCopain $SeqBanque] || \
[string equal -nocase [string range $SeqCopain 1 end] $SeqBanque]} {
InformeLeCopain "$Nom/$Access" "=AltAccess: $AccessOK"
} else {
InformeLeCopain "$Nom/$Access" "=AltAccess: $AccessOK but with no identical sequence"
}
}
}
}
proc InformeLeCopainSansDemander {NomAccess {Append ""}} {
global InformeSansDemander
if {[info exists InformeSansDemander]} { set Memo $InformeSansDemander }
set InformeSansDemander 1
set Retour [InformeLeCopain $NomAccess $Append]
if {[info exists Memo]} { set InformeSansDemander $Memo }
return $Retour
}
proc InformeLeCopain {NomAccess {Append ""}} {
global RepertoireDuGenome
global FenetreInfoOuverte
global InformeSansDemander
set Access [file tail $NomAccess]
set Nom [file tail [file dirname $NomAccess]]
set FichierInfo "$RepertoireDuGenome/coinfos/$Nom/$Access"
if {[info exists FenetreInfoOuverte($Nom,$Access)]} {
raise [set FenetreInfoOuverte($Nom,$Access)]
if {$Append == ""} { return "[ContenuDuFichier $FichierInfo]" }
if {[OuiOuNon "$Append\n doit etre rajoute a la page info $Nom/$Access\n \
La page info est deja ouverte.\n \
Dois-je abandonner ?"]} { return -1 }
if {[OuiOuNon "Dois-je le faire maintenant ?"]} {
[set FenetreInfoOuverte($Nom,$Access)].text insert end "$Append\n"
return -2
}
FaireLire "Vous ferez, plus tard, le couper-coller pour moi. Merci."
return -3
}
set FenetreInfoOuverte($Nom,$Access) "$Nom,$Access"
if {! [file exists $FichierInfo]} {
set Information "Nom: $Nom $Access"
if {[file exists "$RepertoireDuGenome/beton/infocopainmodele"]} {
append Information "\n[ContenuDuFichier $RepertoireDuGenome/beton/infocopainmodele]"
}
Sauve $Information dans $FichierInfo
}
if { [info exists InformeSansDemander] && $InformeSansDemander } {
set BonTexte "[ContenuDuFichier $FichierInfo]\n$Append"
} else {
set BonTexte [EntreTexte "[ContenuDuFichier $FichierInfo]\n$Append"]
}
if { $BonTexte != "" } {
set TexteOk [Censure "$BonTexte"]
Sauve $TexteOk dans $FichierInfo
}
unset FenetreInfoOuverte($Nom,$Access)
return $BonTexte
}
proc VerifieLesNarcissesDesMutants {} {
foreach Nom [ListeDesPABs] {
if { ! [EstUnPABMute $Nom]} { continue }
set GF [GrandFrereDuMutant $Nom]
if {$GF==""} { FaireLire "$Nom has no GrandFrere" ; continue }
if {[Narcisse $GF]==[Narcisse $Nom]} { continue }
FaireLire "$Nom [Narcisse $Nom] is not [Narcisse $GF] of $GF"
}
}
proc NarcisseDansLOrdreDesPABs {} {
set FichierNarcisse "[RepertoireDuGenome]/fiches/narcisse"
foreach Ligne [LesLignesDuFichier $FichierNarcisse] {
if { ! [regexp -nocase {[a-z]} $Ligne]} { continue }
scan $Ligne "%s" NomLu
if {[info exists SaLigne($NomLu)]} {
FaireLire "I already saw $NomLu\n\
$SaLigne($NomLu)\n\and now\n$Ligne\n\nI'll cancel"
return ""
}
set SaLigne($NomLu) $Ligne
}
set LeNouveau {}
foreach Nom [ListeDesPABs] {
if {[info exists SaLigne($Nom)]} { lappend LeNouveau $SaLigne($Nom) }
}
EspionneL $LeNouveau
if { ! [OuiOuNon "Do I save in $FichierNarcisse ?"]} { return "" }
return [SauveLesLignes $LeNouveau dans $FichierNarcisse]
}
proc LesPABsDansLOrdre {{Replace ""}} {
global RepertoireDuGenome
global ListeDesPABs
global ListeDeBoites
set ReplaceList [regexp -nocase "ReplaceList" $Replace]
set ReplaceFile [regexp -nocase "ReplaceFile" $Replace]
foreach Boite [ListeDesPABs] {
set Nom [Box $Boite nom]
set Debut [Box $Boite debut]
lappend AQuiEstCeDebut($Debut) $Nom
set AQuiEstCeDebut($Debut) [lsort -unique [set AQuiEstCeDebut($Debut)]]
lappend LesDebuts $Debut
}
set LesDebutsTries [lsort -unique -integer $LesDebuts]
set NouvelleListeDesPABs {}
foreach Debut $LesDebutsTries {
foreach Nom [set AQuiEstCeDebut($Debut)] {
set Ligne "$Nom [Box $Nom debut] [Box $Nom fin] [Box $Nom orient]"
lappend NouveauBornesDesPABs $Ligne
lappend NouvelleListeDesPABs $Nom
}
}
if {$ReplaceFile} {
SauveLesLignes $NouveauBornesDesPABs dans "$RepertoireDuGenome/fiches/bornesdespabs"
}
if {$ReplaceList} {
set ListeDesPABs $NouvelleListeDesPABs
set NouvelleListeDeBoites $NouvelleListeDesPABs
foreach Boite [ListeDeBoites] {
if {[info exists DejaVu($Boite)]} { continue }
set DejaVu($Boite) 1
lappend NouvelleListeDeBoites $Boite
}
set ListeDeBoites $NouvelleListeDeBoites
}
return $NouvelleListeDesPABs
}
proc ImprimeLesOrgaEtSesPlaces {} {
global RepertoireDuGenome
NousAllonsAuBoulot
foreach Fichier [glob "$RepertoireDuGenome/fiches/orgaetsesplaces.*"] {
set Texte "\n$Fichier\n\n[ContenuDuFichier $Fichier]"
set FichierTmp "tmp.[file tail $Fichier]"
Sauve $Texte dans $FichierTmp
eval exec renoir -l $FichierTmp
}
OnRevientDuBoulot
exit
}
proc RepriseDesVieuxInfos {Source PrefixeSource} {
global RepertoireDuGenome
global ListeDeBoites
set RepertoireSource $Source
if { ! [file exists $RepertoireSource]} {
set RepertoireRacine [file dirname $RepertoireDuGenome]
set RepertoireSource "$RepertoireRacine/$Source"
}
if { ! [file exists $RepertoireSource]} {
FaireLire "I cannot find $Source"
exit
}
set RepertoireDestin "$RepertoireDuGenome/infos"
if { ! [file exists $RepertoireDestin]} {
File mkdir $RepertoireDestin
}
set Garde 0
if {[llength [glob -nocomplain "$RepertoireDestin/*"]] > 0} {
set Garde [OuiOuNon "Do I keep the existing info files ?"]
}
if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
foreach Boite $ListeDeBoites {
set Nom [Box $Boite nom]
regsub [PreFixe] $Nom $PrefixeSource NomSource
set InfoSource "$RepertoireSource/infos/$NomSource"
set InfoDestin "$RepertoireDuGenome/infos/$Nom"
if {! [file exists $InfoSource]} { continue }
if {$Nom==$NomSource} {
if { $Garde && [file exists $InfoDestin]} { continue }
File copy $InfoSource $InfoDestin
continue
}
set Texte [ContenuDuFichier $InfoSource]
while {[regexp "$PrefixeSource\[0-9\]+" $Texte Match]} {
regsub $PrefixeSource $Match [PreFixe] Nouveau
regsub -all $Match $Texte $Nouveau Texte
}
Espionne [Sauve $Texte dans $InfoDestin]
}
}
proc LesClassesDuGlossaire {} {
global RepertoireDuGenome
foreach Complet [Glossaire "Coucou" "EntierComplet"] {
set Classe [OCduOS $Complet]
if {$Classe=="" || $Classe=="ClassUnknown"} {
scan $Complet "%s" Genre
if {[regexp -nocase "^Virus " $Complet]} {
set Classe "Virus."
} elseif {[info exists Classes($Genre)]} {
set Classe [set Classes($Genre)]
} else {
Espionne "$Complet:$Classe"
lappend LesUnknowns $Complet
continue
}
}
scan $Complet "%s" Genre
set Classes($Genre) $Classe
lappend CompletClasse "$Complet:$Classe"
}
Espionne [SauveLesLignes $LesUnknowns dans "$RepertoireDuGenome/fiches/completssansclasse"]
Espionne [SauveLesLignes $CompletClasse dans "$RepertoireDuGenome/fiches/organisme_classe"]
}
proc DeleteBallast {} {
global RepertoireDuGenome
foreach Fichier [glob "$RepertoireDuGenome/ballast/*"] {
File delete $Fichier
}
exit
}
proc OrdaliDuTexteMSF {MSF {FichierOrigine ""} {OptionsOrdali ""}} {
set FichierMSF [Sauve $MSF dans "[TmpFile "" "" "_"].msf"]
return [Ordali $FichierMSF $FichierOrigine "EnExec" $OptionsOrdali]
}
proc Ordali {{NomOuFichier ""} {FichierOrigine ""} {EnExec ""} {OptionsOrdali ""} {ForceXml ""}} {
global RepertoireDuGenome
global OrdaliDejaCharge
if {[string equal -nocase $FichierOrigine "ForceXml"]} {
set ForceXml "ForceXml"
set FichierOrigine $NomOuFichier
}
set ForceXml [string equal -nocase $ForceXml "ForceXml"]
if {$EnExec==""} {
global OrdaliEnExec
if {[info exists OrdaliEnExec]} {
set EnExec $OrdaliEnExec
} else {
set EnExec 1
}
}
if {[regexp "EnExec" $EnExec]} { set EnExec 1 }
if {[regexp "EnProc" $EnExec]} { set EnExec 0 }
set Nom [file tail $NomOuFichier]
if {0 && [regexp -nocase "xml" $NomOuFichier]} { set ForceXml 1 }
if {$ForceXml} {
if { ! [regexp "/" $NomOuFichier] && [EstUnPAB $Nom]} {
set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
if { ! [file exists $FichierXml]} {
append FichierXml ".xml"
}
} else {
set FichierXml $NomOuFichier
}
if {[file exists $FichierXml]} {
set Commande "tcsh -c \"setordalilm ; ordali -xml $FichierXml $OptionsOrdali\""
Espionne "Je vais faire exec $Commande &"
set Retour [eval exec $Commande &]
return $Retour
}
FaireLire "I can't find the XML file associated to $NomOuFichier. Sorry."
return ""
}
if {[EstUnPAB $NomOuFichier]} {
set FichierXml "[RepertoireDuGenome]/macsimXml/$Nom"
if { ! [file exists $FichierXml]} {
append FichierXml ".xml"
}
if {[file exists $FichierXml]} {
set Commande "tcsh -c \"setordalilm; ordali -xml $FichierXml $OptionsOrdali\""
Espionne "Je vais faire exec $Commande &"
set Retour [eval exec $Commande &]
return $Retour
}
}
Espionne "on passe icic"
if {$OptionsOrdali==""} { set OptionsOrdali "-Group secator -Run" }
if {0 && ($FichierOrigine!="" || [regexp {msf[^/]*/} $FichierOrigine])} {
set FichierMSF $FichierOrigine
} else {
set FichierMSF $NomOuFichier
if { $Nom!="" && ![EstUnPAB $Nom] && [file exists $NomOuFichier]} {
set FichierMSF $NomOuFichier
}
if { $Nom!="" && [EstUnPAB $Nom] && [file exists "$RepertoireDuGenome/msf/$Nom"]} {
set FichierMSF "$RepertoireDuGenome/msf/$Nom"
}
}
if {$EnExec} {
if {[file exists $FichierMSF]} {
set FicPourOrdali $FichierMSF
#set RepPourOrdali [file dirname $FichierMSF]
#set FicPourOrdali [file tail $FichierMSF]
#NousAllonsAuBoulot $RepPourOrdali
#set Commande "tcsh -c \"setordalilm; ordali -MSF $FicPourOrdali $OptionsOrdali\""
#Espionne "execution de $Commande"
#set Retour [eval exec $Commande &]
#OnRevientDuBoulot
set Commande "tcsh -c \"setordalilm; ordali $FicPourOrdali $OptionsOrdali\""
Espionne "execution de $Commande"
set Retour [eval exec $Commande &]
return $Retour
} else {
set Commande "tcsh -c \"setordalilm; ordali\""
Espionne "Je vais executer $Commande"
return [eval exec $Commande &]
}
}
Espionne "Execution en proc"
set Fenetre [NomDe ordali]
if { ! [info exists OrdaliDejaCharge]} {
set OrdaliDejaCharge 1
LesDefauts
}
# if {$FichierMSF!=""} { InterpreteLaLigneDeCommande "-MSF $FichierMSF -NoCheckSeq $OptionSecator $OptionRun" }
if {$FichierMSF!=""} { InterpreteLaLigneDeCommande "-MSF $FichierMSF $OptionsOrdali" }
set FenetreOrdali [InitialiseFenetreOrdali slave $Fenetre]
return $FenetreOrdali
}
proc QuelleFonte F {
puts [font measure {Courier 8} X]
}
proc LireHori {Fichier {FichierSuivant ""}} {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp "^PH" $Ligne]} { continue }
set LesMots [split $Ligne ","]
scan $LesMots "%s %s %d %d" NomLu PM Debut Fin
if {$PM=="+"} { set Orient "F" }
if {$PM=="-"} { set Orient "R" }
regsub -all -nocase {[a-z]} $NomLu "" Numero
scan $Numero "%d" N
set Nom [PreFixe][format "%4.4d" $N]
lappend LesBornes "$Nom $Debut $Fin $Orient"
}
if {$FichierSuivant!=""} {
set N [Maxi $Numero 3000]
foreach Ligne [LesLignesDuFichier $FichierSuivant] {
if { ! [regexp "^PH" $Ligne]} { continue }
set LesMots [split $Ligne ","]
scan $LesMots "%s %s %d %d" NomLu PM Debut Fin
if {$PM=="+"} { set Orient "F" }
if {$PM=="-"} { set Orient "R" }
set Nom [PreFixe][format "%4.4d" [incr N]]
lappend LesBornes "$Nom $Debut $Fin $Orient"
}
}
Espionne [SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs.nouveaux"]
}
proc TestRetourne {} {
set L {a b c d e f g}
puts [join $L " "]
puts [join [RetourneLaListe $L] " "]
}
proc Inventaire {{GetWhat ""}} {
if {$GetWhat==""} { set GetWhat "Show" }
set Total [format "%5d" [llength [ListeDesPABs]]]
set Sortie [list "$Total [PreFixe] are available\n"]
foreach Toire [lsort [glob -type d "[RepertoireDuGenome]/*"]] {
set Queue [file tail $Toire]
set BeauQ [format "%16s" $Queue]
set Rep $Toire
set BeauToire [format "%-15s" $Toire]
if { ! [file exists $Rep] } {
lappend Sortie "$BeauToire doesn't exists."
continue
}
set LesPABs [lsort [glob -nocomplain "$Rep/[PreFixe]*"]]
set LesTous [lsort [glob -nocomplain "$Rep/*"]]
set N [llength $LesPABs]
set A [expr [llength $LesTous] - [llength $LesPABs]]
set BeauN [format "%5d" $N]
set BeauA [format "%5d" $A]
if {[info exists SesPABs]} { unset SesPABs }
set LesExt {}
foreach PAB $LesPABs {
if {[regexp "[PreFixe]\[0-9\]+(\[^0-9\]*)" $PAB Match Ext]} {
lappend LesExt $Ext
lappend SesPABs($Ext) $PAB
}
}
set LesExt [lsort -unique $LesExt]
if {[llength $LesExt]>1} {
foreach Ext $LesExt {
set LesPs $SesPABs($Ext)
set N [llength $LesPs]
set A [expr [llength $LesTous] - [llength $LesPs]]
set BeauN [format "%5d" $N]
set BeauA [format "%5d" $A]
lappend Sortie "$BeauN $BeauQ [PreFixe]1234[format %-12s $Ext] files and $BeauA other files in $BeauToire"
}
} else {
set Ext ""
lappend Sortie "$BeauN $BeauQ [PreFixe]1234[format %-12s $Ext] files and $BeauA other files in $BeauToire"
}
}
set LesFiches [lsort [glob -nocomplain "[RepertoireDuGenome]/fiches/*"]]
set LesPastouche [lsort [glob -nocomplain "[RepertoireDuGenome]/pastouche/*"]]
set Sortie [concat $Sortie [list "\n\n"] $LesFiches]
set Sortie [concat $Sortie [list "\n\n"] $LesPastouche]
if {[OnTraite OI]} { lappend Sortie "\n\n" [BlastLocalInventaire] }
set LeContenuPasTouche {}
foreach P [lsort [GlobRecursif "" "[RepertoireDuGenome]/pastouche"]] {
if {[info exists DejaVu($P)]} { FaireLire "$P deja vu en \n$DejaVu($P)" }
set DejaVu($P) $P
if {[file type $P]=="directory"} { continue }
lappend LeContenuPasTouche [ContenuDuFichier $P]
}
set ContenuPasTouche [join $LeContenuPasTouche "\n"]
lappend Sortie "\nContenu des pastouche"
lappend Sortie $ContenuPasTouche
set Sortie [join $Sortie "\n"]
#rR ............................................... on peut faire Affiche meme avec Wscope mais faut faire postpone des boutons
if {[PourWscope]} { return "$Sortie " }
if {$GetWhat=="GetText"} { return $Sortie }
set F [Affiche $Sortie "AvecShow" "Inventory at [Date Nice]"]
set B [BoutonneLaFenetre $F "NewInventory\nNew Check"]
$B configure -background "yellow"
bind $B <1> Inventaire
bind $B CheckInventaire
return $F
}
proc Nommenclature {Nom {OrganismeComplet ""}} {
global RepertoireDuGenome
global Nommenclature
JeMeSignale
if {[info exists Nommenclature($Nom)]} {
Espionne "trouve [set Nommenclature($Nom)] [set Nommenclature($Nom,Complet)]"
if {$OrganismeComplet!=""} {
return "[set Nommenclature($Nom,Complet)]"
} else {
return "[set Nommenclature($Nom)]"
}
}
set FichierNommenclature "$RepertoireDuGenome/fiches/nommenclature"
if { ! [file exists $FichierNommenclature]} { return "" }
if { ! [info exists Nommenclature("EstCharge")]} {
foreach Ligne [LesLignesDuFichier $FichierNommenclature] {
scan $Ligne "%s %s %s %s" NomLu Alias Genre Espece
set GenEspe ""
append GenEspe "[string toupper [string range $Genre 0 0]]"
append GenEspe "[string tolower [string range $Genre 1 2]]"
append GenEspe "[string toupper [string range $Espece 0 0]]"
append GenEspe "[string tolower [string range $Espece 1 3]]"
set Nommenclature($NomLu) "${Alias}_$GenEspe"
set Nommenclature($NomLu,Complet) "$Genre $Espece"
}
set Nommenclature("EstCharge") "EtBienCharge"
return [Nommenclature $Nom $OrganismeComplet]
}
return ""
}
proc ChoisisTonBlast {FichierTFA FichierBlast {Programme ""} {Banque ""} {Ask ""}} {
global RepertoireDuGenome
global GscopeDir
if {$Ask=="DontAsk"} { set Ask 0 } else { set Ask 1 }
if {$Programme==""} {
set Programme [ChoixParmi {blastp blastx blastn tblastn tblastx Other}]
if {$Programme == "Other"} { set Programme [Entre] }
if {$Programme == ""} { return "" }
}
set AvecBanques "nucpro"
if {[regexp {^blastp$|^blastx$} $Programme]} {
regsub "nuc" $AvecBanques "" AvecBanques
}
if {[regexp {^tblastn$|^tblastx$|^blastn$} $Programme]} {
regsub "pro" $AvecBanques "" AvecBanques
}
if {$Banque==""} {
lappend LesRepertoiresDesBanques "$RepertoireDuGenome/banques"
lappend LesRepertoiresDesBanques "$RepertoireDuGenome/banquesblast"
lappend LesRepertoiresDesBanques "/catalog/blast"
set LesBanques {}
foreach RepBan $LesRepertoiresDesBanques {
if {[regexp "nuc" $AvecBanques]} {
set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.nsq"]]
set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.nal"]]
}
if {[regexp "pro" $AvecBanques]} {
set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.psq"]]
set LesBanques [concat $LesBanques [glob -nocomplain "$RepBan/*.pal"]]
}
}
set LesBonnesBanques {}
foreach Banque [lsort $LesBanques] {
regsub {\.nsq$|\.psq$|\.nal$|\.pal$} $Banque "" Banque
if {[info exists DejaVu($Banque)]} { continue }
set DejaVu($Banque) 1
lappend LesBonnesBanques $Banque
}
lappend LesBonnesBanques "Other"
set Banque [ChoixParmi $LesBonnesBanques]
if {$Banque == "Other"} {
set Banque [ButineArborescence "All" [RepertoireDuGenome]]
regsub {\.[np]..$} $Banque "" Banque
}
if {$Banque == ""} { return "" }
}
set CommandeBlast "$GscopeDir/gscope_batchcom.tcl eval exec blastall \
-p $Programme \
-i $FichierTFA \
-o $FichierBlast \
-d $Banque \
-v 500 \
-K 0 \
-b 500 \
-e 10.0 \
-F T "
if {$Ask} {
set CommandeBlast [Entre $CommandeBlast]
}
return $CommandeBlast
}
proc PartieNomsDesSequencesDuBlast {Fichier {AvecQuery ""}} {
DecortiqueBlast $Fichier \
"SansSeuilExpect" "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN
set LesSeqs {}
if {$AvecQuery != ""} {
lappend LesSeqs $Query
}
foreach BanqueId $lBanqueId Access $lAccess DE $lDE {
lappend LesSeqs "$BanqueId $Access $DE"
}
set PartieNoms [join $LesSeqs "\n"]
return $PartieNoms
}
proc CreeUneBanqueBlast {{Selection ""} {RepBanquesBanque ""}} {
global RepertoireDuGenome
Wup "Selection can be 'AllProttfa' or 'AllNuctfa"
Wup "Creates a blast database with the sequences whose file names are in the text Selection"
Wup "If Banque doesn't contain a '/' I take RepertoireDuGenome/banques"
if {$Selection == "" } {
set LesPossibles [list "AllProttfa" "AllNuctfa" "DNA"]
global FichierSequenceADN
if {[info exists FichierSequenceADN] && [FileExists $FichierSequenceADN]} { lappend LesPossibles $FichierSequenceADN }
set Selection [ChoixParmi $LesPossibles]
if {$RepBanquesBanque == ""} { set RepBanquesBanque $Selection }
}
if {$Selection == "" } { return "" }
set SauveTFAs 1
set RepBanques "$RepertoireDuGenome/banques"
if {$RepBanquesBanque == "" } {
FaireLire "Please give me the name of the Blast Database."
set RepBanquesBanque [Entre "$RepBanques/$Selection"]
set Banque [file tail $RepBanquesBanque]
if {$Banque == ""} { return "" }
}
if { ! [regexp "/" $RepBanquesBanque]} { set RepBanquesBanque "$RepBanques/$RepBanquesBanque" }
set RepBanques [file dirname $RepBanquesBanque]
file mkdir $RepBanques
set Banque [file tail $RepBanquesBanque]
if {$Selection=="AllProttfa"} {
set RepTFA "prottfa"
}
if {$Selection=="AllNuctfa"} {
set RepTFA "nuctfa"
}
if {$Selection=="AllProttfa" || $Selection=="AllNuctfa"} {
set UseNomAliasDE [OuiOuNonMemo "Do I create new header with '>Nom Alias DE' ?\n if not I'll take the original fasta file"]
foreach Nom [ListeDesPABs] {
if {[Fantome $Nom]} { continue }
set FichierTFA "$RepertoireDuGenome/$RepTFA/$Nom"
if { ! [file exists $FichierTFA]} { continue }
set TFA [ContenuDuFichier $FichierTFA]
if {$UseNomAliasDE} {
set Seq [QueLaSequenceDuTexteTFA $TFA]
if {[string length $Seq]<1} { continue }
set Alias [Alias $Nom]
set DE [DefinitionRapide $Nom]
regsub "^>" $TFA ">$Nom $Alias $DE" TFA
}
lappend LesTFAs $TFA
}
set TFAs [join $LesTFAs "\n"]
} else {
set LaSelection [split $Selection "\n"]
if {$Selection==$RepBanquesBanque} {
set TFAs [ContenuDuFichier $Selection]
set SauveTFAs 0
} else {
set SauveTFAs 1
foreach Ligne $LaSelection {
scan $Ligne "%s" Fichier
if {[regexp "/" $Fichier] && [file exists $Fichier]} {
set TFAouTFAs [ContenuDuFichier $Fichier]
set Format [FormatDeLaSequence $TFAouTFAs]
if {$Format=="tfa" || $Format=="tfas"} {
lappend LesTFAs $TFAouTFAs
continue
}
}
set Access ""
scan $Ligne "%s %s" BanqueId Access
set TFA [SequenceFormatTFA_l [LaSequenceDesBanques $BanqueId $Access AccessOK]]
lappend LesTFAs $TFA
}
if {$LesTFAs == {} } { return "" }
set TFAs [join $LesTFAs "\n"]
}
}
set FormatProt "F"
foreach Ligne [split [string range $TFAs 0 2000] "\n"] {
if {[regexp "^>" $Ligne]} { continue }
if {[regexp -nocase {[DEFHIKLMPQSVWY]} $Ligne]} {
# Espionne $Ligne
set FormatProt "T"
break
}
}
if { ! [file exists $RepBanques]} { File mkdir $RepBanques }
if {$SauveTFAs} {
if {[file exists "$RepBanques/$Banque"]} {
if { ! [OuiOuNon "$RepBanques/$Banque\n exists. Overwrite ? "]} { return "" }
}
Sauve $TFAs dans "$RepBanques/$Banque"
}
NousAllonsAuBoulot $RepBanques
exec /biolo/ncbi/bin/formatdb -i $Banque -p $FormatProt
OnRevientDuBoulot
return "$RepBanques/$Banque"
}
proc CreeLesBanquesBlastDesTFAsPourTous {{RepTFAs ""} {RepBanques ""} {FormatProt ""}} {
if {$RepBanques==""} { set RepBanques "banquesdescopains" }
if {$RepTFAs==""} { set RepTFAs "tfasdescopains" }
file mkdir $RepBanques
set LesBanques {}
foreach Nom [ListeDesPABs] {
set FicTFAs [GscopeFile $Nom $RepTFAs]
if {[FileAbsent $FicTFAs]} { continue }
lappend LesBanques [CreeUneBanqueBlastDuTFAs $FicTFAs $RepBanques $FormatProt]
}
return $LesBanques
}
proc CreeUneBanqueBlastDuTFAs {FicTFAs {RepBanques ""} {FormatProt ""}} {
if {$FormatProt==""} { set FormatProt "T" }
if {$RepBanques==""} { set RepBanques "[RepertoireDuGenome]/banques" }
set Banque [file tail $FicTFAs]
regsub -nocase {\.tfa} $Banque "" Banque
file copy -force $FicTFAs "$RepBanques/$Banque"
NousAllonsAuBoulot $RepBanques
exec formatdb -i $Banque -p $FormatProt
OnRevientDuBoulot
return "$RepBanques/$Banque"
}
proc CreeUneBanqueBlastDuPAB {Nom {AvecQuery ""} {Rep ""}} {
if {$Rep==""} { set Rep "blastp" }
global RepertoireDuGenome
set PartieNom [PartieNomsDesSequencesDuBlast "$RepertoireDuGenome/$Rep/$Nom" $AvecQuery]
CreeUneBanqueBlast $PartieNom $Nom
return $PartieNom
}
proc CreeUneBanqueBlastDuBlast {Fichier {NomDeLaBanque ""} {AvecQuery ""}} {
global RepertoireDuGenome
if {$NomDeLaBanque==""} { set NomDeLaBanque [file tail $Fichier] }
set PartieNom [PartieNomsDesSequencesDuBlast $Fichier $AvecQuery]
CreeUneBanqueBlast $PartieNom $NomDeLaBanque
return $PartieNom
}
proc CreeLesCopains Nom {
global RepertoireDuGenome
set Destination "$RepertoireDuGenome/copains/$Nom"
if { ! [file isdirectory $Destination]} { File mkdir $Destination }
set LesCopains {}
if {[file exists "$RepertoireDuGenome/apns/$Nom"]} {
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/apns/$Nom"] {
scan $Ligne "%s %s" BanqueId Access
lappend LesCopains $Access
}
} else {
set FichierBlast "$RepertoireDuGenome/blastp/$Nom"
if { ! [file exists $FichierBlast]} { return {} }
set PartieNoms [PartieNomsDesSequencesDuBlast $FichierBlast]
set LesHits [split $PartieNoms "\n"]
if {$LesHits == "" } { return {} }
foreach Ligne $LesHits {
set Access [AccessDUneLigneBlast $Ligne]
lappend LesCopains $Access
}
}
if {$LesCopains == {} } { return {} }
foreach Copain $LesCopains {
if {[file exists "$Destination/$Copain"]} { continue }
if {[file exists "$Destination/[string toupper $Copain]"]} { continue }
if {[file exists "$Destination/[string tolower $Copain]"]} { continue }
Espionne [Sauve [Fetche $Copain] dans "$Destination/$Copain"]
}
}
proc CreeLesCoBlastn Nom {
global RepertoireDuGenome
set FichierBlast "$RepertoireDuGenome/blastp/$Nom"
if { ! [file exists $FichierBlast]} { return {} }
if { ! [file exists "$RepertoireDuGenome/banques/$Nom"]} {
set PartieNoms [CreeUneBanqueBlastDuPAB $Nom]
} else {
set PartieNoms [PartieNomsDesSequencesDuBlast $FichierBlast]
}
set LesQuerys [split $PartieNoms "\n"]
if {$LesQuerys == "" } { return {} }
set CommandeBlast "eval exec blastall \
-p blastn \
-i \$FichierTFA \
-o \$FichierBlast \
-d \$RepertoireDuGenome/banques/$Nom \
-v 500 \
-K 0 \
-b 500 \
-e 10.0 \
-F T "
set CommandeBlast [Entre $CommandeBlast]
if {$CommandeBlast==""} { return "" }
set Repertoire "$RepertoireDuGenome/coblastn/$Nom"
if { ! [file isdirectory "$Repertoire"]} {
File mkdir $Repertoire
}
set TestExistence 1
set GardeTout 0
foreach Ligne $LesQuerys {
set Query [AccessDUneLigneBlast $Ligne]
set FichierTFA [Sauve [SequenceFormatTFA [SequenceDesBanques $Query]] dans "tmp_coblastn.tfa"]
set FichierBlast "$Repertoire/$Query"
if { ! [file exists $FichierTFA]} {
Warne "$FichierTFA n'existe pas."
continue
}
if {$GardeTout && [file exists $FichierBlast] } {
continue
}
if { $TestExistence && [file exists $FichierBlast] } {
if {[OuiOuNon "Some blast files allready exists.\nDo I keep them ?"]} {
set TestExistence 0
} else {
if {[OuiOuNon "Do I keep all ?"]} { set GardeTout 1 }
if {$GardeTout || [OuiOuNon "$FichierBlast still exists.\nDo I keep it ?"]} { continue }
}
}
eval $CommandeBlast
Espionne $FichierBlast
}
}
proc CreeLesCoClustalw Nom {
global RepertoireDuGenome
global Commandes
set Repertoire "$RepertoireDuGenome/coclustalw/$Nom"
if { ! [file isdirectory "$Repertoire"]} {
File mkdir $Repertoire
}
foreach FichierCoBlastn [glob "$RepertoireDuGenome/coblastn/$Nom/*"] {
set Copain [file tail $FichierCoBlastn]
set Destination "$Repertoire/$Copain"
if {[file exists $Destination]} { continue }
set LesCopains {}
DecortiqueBlast $FichierCoBlastn 1.0e-80 25 Query lBanqueId lAccess lDE lProfil lPN
Espionne [join $lAccess "\n"]
if {[llength $lAccess] < 2} { continue }
set LesTFAsConcatenes {}
foreach Access $lAccess {
set FichierCopain "$RepertoireDuGenome/copains/$Nom/$Access"
if { ! [file exists $FichierCopain]} {
Warne "$Access n'est pas copain de $Copain"
continue
}
set TFA [SequenceFormatTFA [ContenuDuFichier $FichierCopain] $Access]
lappend LesTFAsConcatenes $TFA
}
if {[llength $LesTFAsConcatenes] < 2} { continue }
set Tmp "tmp.[pid][NomDe ""]"
set In "$Tmp.inp"
Sauve [join $LesTFAsConcatenes "\n"] dans $In
set Out $Tmp.out
set Log $Tmp.log
Warne "Clustalw sur $Nom $Access lance en interactif ... un peu de patience. Merci."
eval exec "[set Commandes(dbclustal)] $In $Out $Log"
Warne " ... j'ai fini."
# File delete -force $In
# File delete -force $Out
# File delete -force $Log
set MSF "$Out.msf"
Espionne "$MSF en $Destination"
if { ! [file exists $MSF]} { Warne "ai perdu $MSF" ; continue }
File copy $MSF $Destination
}
}
proc AfficheAssocie {Source CoRepertoire {Maniere ""}} {
global RepertoireDuGenome
regsub -nocase {\.[a-z_]*$} $Source "" Source
set Nom [file tail $Source]
set CheminSource [file dirname $Source]
set CheminCheminSource [file dirname $CheminSource]
set RepSource [file tail $CheminCheminSource]
regsub "$RepSource" $Source "$CoRepertoire" Nouveau
Wup "If Nouveau not found we try CoRepertoire/Nom"
foreach Nouveau [list $Nouveau "$RepertoireDuGenome/$CoRepertoire/$Nom"] {
if { ! [file exists $Nouveau]} { continue }
if {$Maniere=="" && [regexp "bla" $CoRepertoire]} {
set Maniere "AvecAligneursAvecSegAlignement"
}
return [AfficheFichier $Nouveau $Maniere]
}
FaireLire "Sorry, no file associated to\n$Source $CoRepertoire"
return ""
}
proc SansAmbiguite LesNouveaux {
foreach Nouveau $LesNouveaux {
set Numero 1
while {[info exists DejaVu($Nouveau)]} {
incr Numero
if {$Numero<10} {
regsub -nocase {[a-z0-9]$} $Nouveau $Numero Nouveau
} else {
regsub -nocase {[a-z0-9][a-z0-9]$} $Nouveau $Numero Nouveau
}
}
set DejaVu($Nouveau) 1
lappend LesNouveauxNouveaux $Nouveau
}
return $LesNouveauxNouveaux
}
proc MaquilleLeMSF {FichierMSF LesAnciens LesNouveaux {MaxAccess ""} {Force ""} {NouveauFichier ""}} {
global MaquilleNon
#rR attention si maquillon il faut mettre Force
#rR on remplace les anciens par les nouveaux
#rR on garde ceux qui ne sont pas dans la liste
#rR on ne tient pas compte des majuscules minuscule pour les anciens
#rR LesAnciens peut etre ReplaceNumberOnly. Dans ce cas LesNouveaux contient le caractere a mettre devant
set Force [string equal -nocase $Force "Force"]
if {$MaxAccess==""} { set MaxAccess 15 }
if { ! $Force && [info exists MaquilleNon] && $MaquilleNon} { return [LesLignesDuFichier $FichierMSF] }
set ReplaceNumberOnly 0
if {[string equal -nocase "ReplaceNumberOnly" $LesAnciens]} {
set ReplaceNumberOnly 1
set StartForNumber $LesNouveaux
}
foreach Ancien $LesAnciens Nouveau $LesNouveaux {
set ANCIEN [string toupper $Ancien]
set NouveauNom($ANCIEN) $Nouveau
}
set FormatName " Name: %-${MaxAccess}s %s"
set FormatAlig "%-[expr $MaxAccess+2]s %s"
set YaEuName 0
foreach Ligne [LesLignesDuFichier $FichierMSF] {
if {[regexp "Name: " $Ligne]} {
set YaEuName 1
scan $Ligne "%s %s" Name Ancien
set Nouveau $Ancien
if {$ReplaceNumberOnly} {
if {[regexp {^[0-9]+$} $Ancien]} { set Nouveau "$StartForNumber$Ancien" }
} else {
set ANCIEN [string toupper $Ancien]
if {[info exists NouveauNom($ANCIEN)]} { set Nouveau $NouveauNom($ANCIEN)}
}
set iLen [string first "Len:" $Ligne]
set NouvelleLigne [format $FormatName $Nouveau [string range $Ligne $iLen end]]
lappend LeNouveauMSF $NouvelleLigne
continue
}
if { ! $YaEuName || ! [regexp -nocase {[\.0-9a-z_]} $Ligne]} {
lappend LeNouveauMSF $Ligne
continue
}
scan $Ligne "%s" Ancien
regsub $Ancien $Ligne "" LigneAmputee
set LigneAmputee [string trimleft $LigneAmputee]
set Nouveau $Ancien
if {$ReplaceNumberOnly && [regexp -nocase {[a-z\.\-\~]} $Ligne]} {
if {[regexp {^[0-9]+$} $Ancien]} { set Nouveau "$StartForNumber$Ancien" }
} else {
set ANCIEN [string toupper $Ancien]
if {[info exists NouveauNom($ANCIEN)]} { set Nouveau $NouveauNom($ANCIEN)}
}
set NouvelleLigne [format $FormatAlig $Nouveau $LigneAmputee]
lappend LeNouveauMSF $NouvelleLigne
continue
}
if {$NouveauFichier!=""} { return [SauveLesLignes $LeNouveauMSF dans $NouveauFichier] }
return $LeNouveauMSF
}
proc StockeLesSequencesEtMaquilleLeMSF {FichierMSF Alias Nom} {
global RepertoireDuGenome
global MaquilleNon
JeMeSignale
set N [DecortiqueUnMSF $FichierMSF LesNoms Sequences]
set LeMSF [LesLignesDuFichier $FichierMSF]
File mkdir "$RepertoireDuGenome/copains/$Nom"
set MaquillageNecessaire 0
foreach NomDeSequence $LesNoms {
if {[regexp "tfiih" "$RepertoireDuGenome"] && \
[set NouveauNom [Nommenclature $NomDeSequence]] != "" } {
Espionne $NouveauNom
set OS [Nommenclature $NomDeSequence "OrganismeComplet"]
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $NouveauNom; cree par rR d'apres Nommenclature et MSF $FichierMSF"
lappend LesLignesEMBL "AC $NouveauNom"
lappend LesLignesEMBL "DE $NouveauNom"
lappend LesLignesEMBL "OS $OS"
lappend LesLignesEMBL "OC [OCduOS $OS]"
lappend LesLignesEMBL [QueSequenceFormatEMBL [set Sequences($NomDeSequence)] "AvecSQ"]
} elseif {[regexp -nocase {^[a-z]+_[a-z]+$} $NomDeSequence]} {
set G [string index $NomDeSequence 0]
set Esp [string range [StringSuivant "_" dans $NomDeSequence] 0 2]
set GEsp [string tolower "${G}$Esp"]
set OS [Glossaire $GEsp "Complet"]
set LesLignesEMBL {}
set NouveauNom $NomDeSequence
Espionne "$NouveauNom $OS"
lappend LesLignesEMBL "ID $NouveauNom; cree par rR car Genr_Espe et MSF $FichierMSF"
lappend LesLignesEMBL "AC $NouveauNom"
lappend LesLignesEMBL "DE $NouveauNom"
lappend LesLignesEMBL "OS $OS"
lappend LesLignesEMBL "OC [OCduOS $OS]"
lappend LesLignesEMBL [QueSequenceFormatEMBL [set Sequences($NomDeSequence)] "AvecSQ"]
} else {
set LesLignesEMBL [LaSequenceDesBanques $NomDeSequence $NomDeSequence AccessOK "OnVeutEMBL"]
if {$LesLignesEMBL == {}} {
if { ! [info exists Ask]} {
set Ask [OuiOuNonMemo "Do You want to help me for each definition, orga, etc. ?"]
}
if {$Ask && ! [OuiOuNon "$NomDeSequence cannot be found in databases. I'll create the EMBL file.\n\
Do You want to give a name ?"]} {
set NouveauNom [Entre "$NomDeSequence"]
} else {
set NouveauNom $NomDeSequence
}
set LesLignesEMBL {}
lappend LesLignesEMBL "ID $NouveauNom; cree par rR d'apres MSF $FichierMSF."
lappend LesLignesEMBL "AC $NouveauNom"
if {$Ask} {
lappend LesLignesEMBL "DE [Entre definition]"
set Organisme [Entre "Genus species"]
lappend LesLignesEMBL "OS $Organisme"
lappend LesLignesEMBL "OC [OCduOS $Organisme]"
}
lappend LesLignesEMBL [QueSequenceFormatEMBL [set Sequences($NomDeSequence)] "AvecSQ"]
} else {
DecortiqueLesLignesEMBL $LesLignesEMBL ID AC DE GN OS OC OX
if { ! [info exists MaquilleNon] || ! $MaquilleNon} {
set Organisme [OrganismeCanonique $OS]
if {$Organisme==""} {
if {[set Organisme [Nommenclature $NomDeSequence "OrganismeComplet"]] == "" } {
set Organisme "Unknown unknown"
}
}
scan $Organisme "%s %s" Genre Espece
set GenEspe ""
append GenEspe "[string toupper [string range $Genre 0 0]]"
append GenEspe "[string tolower [string range $Genre 1 2]]"
append GenEspe "[string toupper [string range $Espece 0 0]]"
append GenEspe "[string tolower [string range $Espece 1 3]]"
set NouveauNom "${Alias}_$GenEspe"
} else {
set NouveauNom $NomDeSequence
}
}
}
lappend LesSequencesEMBL $LesLignesEMBL
if {$NomDeSequence!=$NouveauNom} { set MaquillageNecessaire 1 }
lappend LesAnciens $NomDeSequence
lappend LesNouveaux $NouveauNom
continue
}
set LesNouveaux [SansAmbiguite $LesNouveaux]
foreach Nouveau $LesNouveaux LesLignesEMBL $LesSequencesEMBL {
SauveLesLignes $LesLignesEMBL dans "$RepertoireDuGenome/copains/$Nom/$Nouveau"
}
if {$MaquillageNecessaire} {
set LeNouveauMSF [MaquilleLeMSF $FichierMSF $LesAnciens $LesNouveaux]
} else {
set LeNouveauMSF [LesLignesDuFichier $FichierMSF]
}
return $LeNouveauMSF
}
proc ChargeNarcisseDuAlias {{Fichier ""}} {
global RepertoireDuGenome
global NarcisseDuAlias
if {$Fichier==""} {
set Fichier [ButineArborescence "All" "$RepertoireDuGenome"]
}
if {$Fichier==""} { return 0 }
set n 0
foreach Ligne [LesLignesDuFichier $Fichier] {
incr n
if { ! [regexp -nocase {[a-z]+} $Ligne]} { continue }
if {[regexp -nocase {^[ \t]*\#} $Ligne]} { continue }
regsub -all "\t" $Ligne " " Ligne
set Access ""
set Alias "ALIAS_$n"
set DE ""
if {[OuiOuNonMemo "Does this file contain BanqueId AND Access (Alias (Definition)) ?"]} {
scan $Ligne "%s %s %s" BanqueId Access Alias
regsub "\:" $BanqueId "\\:" BanqueIdSansPP
regsub " *$BanqueIdSansPP +$Access +$Alias +" $Ligne "" DE
} else {
scan $Ligne "%s %s" Access Alias
regsub " *$Access +$Alias +" $Ligne "" DE
}
if {$Access==""} { set Access $BanqueId }
set NarcisseDuAlias($Alias) $Access
}
return $n
}
proc CreeBornesDesPABsPourUneCollection {FOF {RefaireCeNomUniquement ""}} {
global RepertoireDuGenome
global ListeDeBoites
global ListeDesPABs
global InformeSansDemander
JeMeSignale
Wup "On peut refaire un nom s'il existe deja. Supprimer les copains et autres."
if { ! [info exists NarcisseDuAlias]} {
if {[OuiOuNon "I need help to create Narcisse.\nOnce again, could You browse for a file with 'Access Alias' ?" 0]} {
ChargeNarcisseDuAlias
}
}
set OnEnRajoute 0
set Conserve 0
if { [file exists "$RepertoireDuGenome/fiches/bornesdespabs"]} {
if {[OuiOuNon "$RepertoireDuGenome/fiches/bornesdespabs still exists.\n Do I stop ?"]} {
exit
}
if { ! [OuiOuNon "Do You want to keep the existing files ?"]} {
File rename -force "$RepertoireDuGenome/fiches/bornesdespabs"\
"$RepertoireDuGenome/fiches/bornesdespabs.old"
} else {
if { ! [OuiOuNon "The new elements have to be at the end of the $FOF ...\nOK ?"]} {
exit
}
set OnEnRajoute 1
set Conserve 1
if { ! [info exists ListeDesPABs]} { ListeDesPABs }
}
}
if { ! [file exists "$RepertoireDuGenome/msf"]} {
File mkdir "$RepertoireDuGenome/msf"
}
if { ! [file exists "$RepertoireDuGenome/ballast"]} {
File mkdir "$RepertoireDuGenome/ballast"
}
if { ! [file exists "$RepertoireDuGenome/blastp"]} {
File mkdir "$RepertoireDuGenome/blastp"
}
if { ! [file exists "$RepertoireDuGenome/copains"]} {
File mkdir "$RepertoireDuGenome/copains"
}
if { ! [file exists "$RepertoireDuGenome/ver"]} {
File mkdir "$RepertoireDuGenome/ver"
}
set ORF [PreFixe]
set Numero 0
if { ! [OuiOuNon "Do I start $ORF numbering with [expr $Numero+1]"]} {
set Numero [Entre 1]
incr Numero -1
}
set Debut 0
set Fin [expr $Debut + 900 - 1]
set Saut 1000
set Orient "F"
set LesPABsExistants {}
if {[info exists ListeDesPABs]} {
foreach PAB $ListeDesPABs {
if {[EstUnPABMute $PAB]} {
lappend LesMutants($Papa) $PAB
continue
}
lappend LesPABsExistants $PAB
set Papa $PAB
}
}
set LesBornes {}
set LesLignes [LesLignesDuFichier $FOF]
foreach Ligne [LesLignesDuFichier $FOF] {
if { ! [regexp -nocase {[A-Z0-9_]} $Ligne]} { continue }
set Alias ""
catch {unset Nom}
catch {unset Ver}
catch {unset OrigineBlastP}
catch {unset OrigineBallast}
catch {unset OrigineMSF}
set NbLus [scan $Ligne "%s %s %s %s %s %s" Alias OrigineVer OrigineBlastP OrigineBallast OrigineMSF SecondMSF]
if {$NbLus < 2} {
set OrigineVer $Alias
set Alias ""
if {[OuiOuNonMemo "I got some lines with only one word. Do I use the access I'll find as alias. For all ??"]} {
set TexteVer [ContenuDuFichier $OrigineVer]
while 1 {
if { ! [regexp {^>([^ ]+)} $TexteVer Match AliasLu]} { set Alias $AliasLu; break }
if { ! [regexp {\nAC ([^;]+)} $TexteVer Match AliasLu]} { set Alias $AliasLu; break }
}
}
if {$Alias==""} {
if {[OuiOuNon "$Ligne\n missing values. Do I stop ?"]} { exit }
continue
}
}
set Nom [format "%s%[FormatDesNumerosPourCollection]" $ORF [incr Numero]]
# if {[regexp "^bidonPour" $Alias]} { continue }
if {[EstUnPAB $Alias] && $Alias==$Nom } { continue }
if {[EstUnPAB $Alias] && $Alias!=$Nom } {
FaireLire "$Alias should be $Nom"
continue
}
if { [FileExists "[RepertoireDuGenome]/fiches/bornesdespabs"] && [Alias $Nom]!=$Alias} {
if {(! [info exists InformeSansDemander] || ! $InformeSansDemander) \
&& [OuiOuNon "Do I stop asking for Informe ? "]} {
set InformeSansDemander 1
}
Informe $Nom "=Alias: $Alias"
}
if {$RefaireCeNomUniquement=="$Nom"} {
set Refaire 1
} else {
set Refaire 0
if {$LesPABsExistants != {} } {
set PAB [lindex $LesPABsExistants 0]
set LesPABsExistants [lrange $LesPABsExistants 1 end]
set GN [NomDeGene $Nom]
while {$PAB!=$Nom || ($GN!=$PAB && $GN!=$Alias)} {
if {[OuiOuNon "$Ligne\n$PAB vs $Nom\n$GN vs $Alias\n don't correspond ... Do I stop ?"]} { exit }
if {[OuiOuNon "Do I ignore that Alias $Alias is not GeneName $GN"]} { break }
set MemoInformeSansDemander $InformeSansDemander
set InformeSansDemander 0
Informe $Nom
set InformeSansDemander $MemoInformeSansDemander
}
set Debut [Box $Nom debut]
set Fin [Box $Nom fin]
set Orient [Box $Nom orient]
lappend LesBornes "$PAB $Debut $Fin $Orient"
if {[info exists LesMutants($PAB)]} {
foreach PABMut [set LesMutants($PAB)] {
set Debut [Box $PABMut debut]
set Fin [Box $PABMut fin]
set Orient [Box $PABMut orient]
lappend LesBornes "$PABMut $Debut $Fin $Orient"
}
}
continue
}
}
if { [info exists SecondMSF] && [file exists $SecondMSF] } {
set MSF "$RepertoireDuGenome/msf2/$Nom"
if { ! [file exists "$MSF"] || ! $Conserve || $Refaire} {
File copy $SecondMSF $MSF
}
}
if { [info exists OrigineMSF] && [file exists $OrigineMSF] } {
set MSF "$RepertoireDuGenome/msf/$Nom"
if { ! [file exists "$MSF"] || ! $Conserve || $Refaire} {
set LeBeauMSF [StockeLesSequencesEtMaquilleLeMSF $OrigineMSF $Alias $Nom]
SauveLesLignes $LeBeauMSF dans $MSF
}
}
if { [info exists OrigineBallast] && [file exists $OrigineBallast] } {
set Ballast "$RepertoireDuGenome/ballast/$Nom"
if { ! [file exists "$Ballast"] || ! $Conserve || $Refaire} {
File copy $OrigineBallast $Ballast
}
}
if { [info exists OrigineBlastP] && [file exists $OrigineBlastP] } {
set BlastP "$RepertoireDuGenome/blastp/$Nom"
if { ! [file exists "$BlastP"] || ! $Conserve || $Refaire} {
File copy $OrigineBlastP $BlastP
}
}
if { [info exists OrigineVer] && [file exists $OrigineVer] } {
set Ver "$RepertoireDuGenome/ver/$Nom"
if { ! [file exists "$Ver"] || ! $Conserve || $Refaire} {
File copy -force $OrigineVer $Ver
}
}
incr Debut $Saut
incr Fin $Saut
Box $Nom nom $Nom
Box $Nom debut $Debut
Box $Nom fin $Fin
Box $Nom orient $Orient
Box $Nom frame [NomDeLaFrame [expr $Debut%3] $Orient]
Box $Nom long [expr $Fin-$Debut+1]
lappend ListeDesPABs $Nom
lappend ListeDeBoites $Nom
lappend LesBornes "$Nom $Debut $Fin F"
if {[regexp "thetase" "$RepertoireDuGenome"]} {
set AA3 [AADuNomDuFichier [file tail $OrigineMSF] "SansAlias"]
Informe $Nom "=ValiGN: ${AA3}rs"
}
if {[regexp "/NR$" "$RepertoireDuGenome"]} {
Informe $Nom "=ValiGN: $Alias"
}
if {[regexp "nag" "$RepertoireDuGenome"]} {
Informe $Nom "=ValiGN: $Alias"
}
if {[regexp "tfiih" "$RepertoireDuGenome"]} {
Informe $Nom "=ValiGN: $Alias"
}
# if {$RefaireCeNomUniquement==$Nom} { exit }
Espionne fin
}
SauveLesLignes $LesBornes dans "$RepertoireDuGenome/fiches/bornesdespabs"
}
|