func main() {
var f io.Reader
var err error
f = util.OpenFile(flag.Arg(0))
if strings.HasSuffix(flag.Arg(0), ".gz") {
f, err = gzip.NewReader(f)
util.Assert(err)
}
cifEntry, err := pdbx.Read(f)
util.Assert(err, "Could not read PDBx/mmCIF file")
fasEntries := make([]seq.Sequence, 0, 5)
for _, ent := range cifEntry.Entities {
for _, chain := range ent.Chains {
if !isChainUsable(chain) || len(ent.Seq) == 0 {
continue
}
fasEntry := seq.Sequence{
Name: chainHeader(chain),
Residues: ent.Seq,
}
fasEntries = append(fasEntries, fasEntry)
}
}
if len(fasEntries) == 0 {
util.Fatalf("Could not find any chains with amino acids.")
}
var fasOut io.Writer
if flag.NArg() == 1 {
fasOut = os.Stdout
} else {
if len(flagSplit) > 0 {
util.Fatalf("The '--split' option is incompatible with a single " +
"output file.")
}
fasOut = util.CreateFile(util.Arg(1))
}
if len(flagSplit) == 0 {
util.Assert(fasta.NewWriter(fasOut).WriteAll(fasEntries),
"Could not write FASTA file '%s'", fasOut)
} else {
for _, entry := range fasEntries {
fp := path.Join(flagSplit, fmt.Sprintf("%s.fasta", entry.Name))
out := util.CreateFile(fp)
w := fasta.NewWriter(out)
util.Assert(w.Write(entry), "Could not write to '%s'", fp)
util.Assert(w.Flush(), "Could not write to '%s'", fp)
}
}
}
func mkPaired(c *command) {
c.assertNArg(2)
in := util.Library(c.flags.Arg(0))
outPath := c.flags.Arg(1)
util.AssertOverwritable(outPath, flagOverwrite)
if _, ok := in.(fragbag.WeightedLibrary); ok {
util.Fatalf("%s is a weighted library (not allowed)", in.Name())
}
name := fmt.Sprintf("paired-%s", in.Name())
if fragbag.IsStructure(in) {
var pairs [][]structure.Coords
lib := in.(fragbag.StructureLibrary)
nfrags := lib.Size()
for i := 0; i < nfrags; i++ {
for j := 0; j < nfrags; j++ {
if i == j {
continue
}
f1, f2 := lib.Atoms(i), lib.Atoms(j)
pairs = append(pairs, append(f1, f2...))
}
}
pairLib, err := fragbag.NewStructureAtoms(name, pairs)
util.Assert(err)
fragbag.Save(util.CreateFile(outPath), pairLib)
} else if strings.Contains(in.Tag(), "hmm") {
var pairs []*seq.HMM
lib := in.(fragbag.SequenceLibrary)
nfrags := lib.Size()
for i := 0; i < nfrags; i++ {
for j := 0; j < nfrags; j++ {
if i == j {
continue
}
f1, f2 := lib.Fragment(i).(*seq.HMM), lib.Fragment(j).(*seq.HMM)
pairs = append(pairs, seq.HMMCat(f1, f2))
}
}
pairLib, err := fragbag.NewSequenceHMM(name, pairs)
util.Assert(err)
fragbag.Save(util.CreateFile(outPath), pairLib)
} else if strings.Contains(in.Tag(), "profile") {
util.Fatalf("Sequence profiles not implemented.")
} else {
util.Fatalf("Unrecognized fragment library: %s", in.Tag())
}
}
func main() {
entry := util.PDBRead(flag.Arg(0))
if len(flagChain) > 0 {
if len(flagChain) != 1 {
util.Fatalf("Chain identifiers must be a single character.")
}
chain := entry.Chain(flagChain[0])
if chain == nil {
util.Fatalf("Could not find chain '%c' in PDB entry '%s'.",
chain.Ident, entry.Path)
}
showMapping(chain, chain.SequenceAtoms())
} else {
for _, chain := range entry.Chains {
showMapping(chain, chain.SequenceAtoms())
}
}
}
func main() {
lib = util.StructureLibrary(util.Arg(0))
pdbEntry := util.PDBRead(util.Arg(1))
if util.NArg() == 2 {
for _, chain := range pdbEntry.Chains {
atoms := chain.CaAtoms()
bestFragsForRegion(chain, atoms, 0, len(atoms))
}
} else {
chainId := util.Arg(2)
chain := pdbEntry.Chain(chainId[0])
if chain == nil || !chain.IsProtein() {
util.Fatalf("Could not find protein chain with id '%c'.", chainId)
}
atoms := chain.CaAtoms()
if util.NArg() == 3 {
bestFragsForRegion(chain, atoms, 0, len(atoms))
} else {
if util.NArg() != 5 {
log.Println("Both a start and end must be provided.")
util.Usage()
}
s, e := util.Arg(3), util.Arg(4)
sn, en := util.ParseInt(s)-1, util.ParseInt(e)
if en-sn < lib.FragmentSize() {
util.Fatalf("The range [%s, %s] specifies %d alpha-carbon "+
"atoms while at least %d alpha-carbon atoms are required "+
"for the given fragment library.",
s, e, en-sn, lib.FragmentSize())
}
bestFragsForRegion(chain, atoms, sn, en)
}
}
}
func search(c *command) {
c.assertLeastNArg(2)
// Some search options don't translate directly to command line parameters
// specified by the flag package.
if flagSearchDesc {
flagSearchOpts.Order = bowdb.OrderDesc
}
switch flagSearchSort {
case "cosine":
flagSearchOpts.SortBy = bowdb.SortByCosine
case "euclid":
flagSearchOpts.SortBy = bowdb.SortByEuclid
default:
util.Fatalf("Unknown sort field '%s'.", flagSearchSort)
}
db := util.OpenBowDB(c.flags.Arg(0))
bowPaths := c.flags.Args()[1:]
_, err := db.ReadAll()
util.Assert(err, "Could not read BOW database entries")
// always hide the progress bar here.
bows := util.ProcessBowers(bowPaths, db.Lib, false, flagCpu, true)
out, outDone := outputter()
// launch goroutines to search queries in parallel
wgSearch := new(sync.WaitGroup)
for i := 0; i < flagCpu; i++ {
wgSearch.Add(1)
go func() {
defer wgSearch.Done()
for b := range bows {
sr := db.Search(flagSearchOpts, b)
out <- searchResult{b, sr}
}
}()
}
wgSearch.Wait()
close(out)
<-outDone
util.Assert(db.Close())
}
func main() {
libPath := util.Arg(0)
chain := util.Arg(1)
pdbEntryPath := util.Arg(2)
bowOut := util.Arg(3)
lib := util.StructureLibrary(libPath)
entry := util.PDBRead(pdbEntryPath)
thechain := entry.Chain(chain[0])
if thechain == nil || !thechain.IsProtein() {
util.Fatalf("Could not find chain with identifier '%c'.", chain[0])
}
bow := bow.BowerFromChain(thechain).StructureBow(lib)
if bowOut == "--" {
fmt.Println(bow)
} else {
util.BowWrite(util.CreateFile(bowOut), bow)
}
}
func recordToDist(record []string) pair {
namePieces := strings.SplitN(record[0], ".ent_", 2)
if len(namePieces) != 2 {
util.Fatalf("Invalid alignment pair: '%s'.", record[0])
}
p1, p2 := namePieces[0], namePieces[1]
p2 = p2[0 : len(p2)-5]
rf := func(i int) float64 { return readFloat(record[i]) }
corelen, rmsd := rf(1), rf(2)
l1, l2 := rf(7), rf(8)
coreval := (2.0 * corelen) / (l1 + l2)
dist := -6.04979701*(rmsd-coreval*corelen*0.155+1.6018) + 1000
dist = 1.0 / dist
dist *= 100.0
if p1 < p2 {
return pair{[2]string{p1, p2}, dist}
}
return pair{[2]string{p2, p1}, dist}
}
func outputter() (chan searchResult, chan struct{}) {
out := make(chan searchResult)
done := make(chan struct{})
go func() {
if flagSearchOutFmt == "csv" {
fmt.Printf("QueryID\tHitID\tCosine\tEuclid\n")
}
first := true
for sr := range out {
switch flagSearchOutFmt {
case "plain":
outputPlain(sr, first)
case "csv":
outputCsv(sr, first)
default:
util.Fatalf("Invalid output format '%s'.", flagSearchOutFmt)
}
first = false
}
done <- struct{}{}
}()
return out, done
}
func main() {
pdbEntry := util.PDBRead(flag.Arg(0))
fasEntries := make([]seq.Sequence, 0, 5)
if !flagSeparateChains {
var fasEntry seq.Sequence
if len(pdbEntry.Chains) == 1 {
fasEntry.Name = chainHeader(pdbEntry.OneChain())
} else {
fasEntry.Name = fmt.Sprintf("%s", strings.ToLower(pdbEntry.IdCode))
}
seq := make([]seq.Residue, 0, 100)
for _, chain := range pdbEntry.Chains {
if isChainUsable(chain) {
seq = append(seq, chain.Sequence...)
}
}
fasEntry.Residues = seq
if len(fasEntry.Residues) == 0 {
util.Fatalf("Could not find any amino acids.")
}
fasEntries = append(fasEntries, fasEntry)
} else {
for _, chain := range pdbEntry.Chains {
if !isChainUsable(chain) {
continue
}
fasEntry := seq.Sequence{
Name: chainHeader(chain),
Residues: chain.Sequence,
}
fasEntries = append(fasEntries, fasEntry)
}
}
if len(fasEntries) == 0 {
util.Fatalf("Could not find any chains with amino acids.")
}
var fasOut io.Writer
if flag.NArg() == 1 {
fasOut = os.Stdout
} else {
if len(flagSplit) > 0 {
util.Fatalf("The '--split' option is incompatible with a single " +
"output file.")
}
fasOut = util.CreateFile(util.Arg(1))
}
if len(flagSplit) == 0 {
util.Assert(fasta.NewWriter(fasOut).WriteAll(fasEntries),
"Could not write FASTA file '%s'", fasOut)
} else {
for _, entry := range fasEntries {
fp := path.Join(flagSplit, fmt.Sprintf("%s.fasta", entry.Name))
out := util.CreateFile(fp)
w := fasta.NewWriter(out)
util.Assert(w.Write(entry), "Could not write to '%s'", fp)
util.Assert(w.Flush(), "Could not write to '%s'", fp)
}
}
}
