func main() {
dbPath := util.Arg(0)
fragLibDir := util.Arg(1)
pdbFiles := flag.Args()[2:]
util.Assert(createBowDb(dbPath, fragLibDir, pdbFiles))
db := util.OpenBowDB(dbPath)
_, err := db.ReadAll()
util.Assert(err, "Could not read BOW database entries")
bowOpts := bowdb.SearchDefault
bowOpts.Limit = 200
mattOpts := matt.DefaultConfig
mattOpts.Verbose = false
chains := createChains(pdbFiles)
mattArgs := createMattArgs(chains)
tabw := tabwriter.NewWriter(os.Stdout, 0, 4, 4, ' ', 0)
header := []byte(
"BOW entry\t" +
"BOW chain\t" +
"BOW dist\t" +
"Matt entry\t" +
"Matt chain\t" +
"Matt dist\n")
for i, chain := range chains {
marg := mattArgs[i]
bowOrdered := getBowOrdering(db, bowOpts, bow.BowerFromChain(chain))
mattOrdered := getMattOrdering(mattOpts, marg, mattArgs)
fmt.Printf("Ordering for %s (chain %c)\n",
chain.Entry.IdCode, chain.Ident)
compared := comparison([2]ordering{bowOrdered, mattOrdered})
tabw.Write(header)
tabw.Write([]byte(compared.String()))
tabw.Flush()
fmt.Println("\n")
}
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)
}
}
// BowerOpen reads the contents of `fpath` and attempts to interpret it as a
// value (or values) that implement the `bow.Bower` interface. The list of
// `bow.Bower` values returned is guaranteed to be homogenous: they will
// either be all `bow.SequenceBower` values or `bow.StructureBower` values.
//
// The actual return value of the function is a receive-only channel of BowerErr
// values. Each BowerErr value either has the `Bower` member set or has the
// `err` field set to an error that prevented the file from being opened.
// Errors in this case are reserved for files that appear to be capable of
// producing a BOW, but were unable to be read.
//
// If the fpath given cannot be detected as a bower file, then a closed empty
// channel will be returned. A warning is also emitted to stderr.
//
// `lib` is a fragment library that is used to help interpret what kind of
// value must be in `r`. For example, if `lib` is a sequence fragment library,
// then `BowerOpen` is guaranteed to return a `Bower` value that implements the
// `bow.SequenceBower` interface.
//
// As of now, `BowerOpen` can read these types of files:
//
// File extension Format Interpretation
// *.{ent.gz,pdb,ent} PDB whatever `lib` is
// *.{fasta,fas,fasta.gz,fas.gz} FASTA sequence
// everything else error invalid
//
// Note that special syntax for PDB file names is supported. Namely, chain
// identifiers can be appended to the end of the file name, and only that chain
// will be included in the `bow.Bower` value. Otherwise, all chains in the PDB
// entry will be returned as individual `bow.Bower` values.
//
// The format is simple and easily demonstrated by examples:
//
// 1ctf.end.gz Chains A and B
// 1ctf.ent.gz:A Only chain A
// 1ctf.ent.gz:B Only chain B
// 1ctf.ent.gz:A,B Chains A and B
//
// A secondary format is also accepted. The following are equivalent to their
// corresponding examples above:
//
// 1ctf
// 1ctfA
// 1ctfB
// 1ctf:A,B
//
// Finally, `fpath` may be the name of a PDB identifier and its file path will
// be inferred from the value of the `PDB_PATH` environment variable.
// Alternatively, `fpath` may be the name of a SCOP domain, and its
// corresponding PDB file will be inferred from the value of the
// `SCOP_PDB_PATH` environment variable.
func BowerOpen(fpath string, lib fragbag.Library, models bool) <-chan BowerErr {
if lib == nil {
Fatalf("Files can only be converted to Fragbag frequency vectors " +
"if a fragment library is specified.")
}
bowers := make(chan BowerErr, 100)
switch {
case IsPDB(fpath):
go func() {
defer close(bowers)
entry, chains, err := PDBOpen(fpath)
if err != nil {
err = fmt.Errorf("Error reading '%s': %s", fpath, err)
bowers <- BowerErr{Err: err}
return
}
if fragbag.IsStructure(lib) {
for i := range chains {
if !chains[i].IsProtein() {
continue
}
if !models {
b := bow.BowerFromChain(chains[i])
bowers <- BowerErr{Bower: b}
} else {
for _, m := range chains[i].Models {
b := bow.BowerFromModel(m)
bowers <- BowerErr{Bower: b}
}
}
}
} else {
for i := range chains {
if !chains[i].IsProtein() {
continue
}
s := chains[i].AsSequence()
if s.Len() == 0 {
s = aminoFromStructure(chains[i])
if s.Len() == 0 {
Warnf("Chain '%s:%c' has no amino sequence.",
entry.IdCode, chains[i].Ident)
continue
}
}
bowers <- BowerErr{Bower: bow.BowerFromSequence(s)}
}
}
}()
return bowers
case IsFasta(fpath) && !fragbag.IsStructure(lib):
go func() {
defer close(bowers)
r, fp, err := fastaOpen(fpath)
if err != nil {
err = fmt.Errorf("Error reading file: %s", err)
bowers <- BowerErr{Err: err}
return
}
defer fp.Close()
fr := fasta.NewReader(r)
for {
s, err := fr.Read()
if err != nil {
if err == io.EOF {
break
}
err = fmt.Errorf("Error reading file: %s", err)
bowers <- BowerErr{Err: err}
return
}
bowers <- BowerErr{Bower: bow.BowerFromSequence(s)}
}
}()
return bowers
}
Warnf("I don't know how to produce a Fragbag frequency vector "+
"from the file '%s'.", fpath)
close(bowers)
return bowers
}