func main() {
if len(util.FlagCpuProf) > 0 {
f := util.CreateFile(util.FlagCpuProf)
pprof.StartCPUProfile(f)
defer f.Close()
defer pprof.StopCPUProfile()
}
if len(flagGobIt) > 0 {
astralDir := util.Arg(0)
dists := readAlignmentDists(astralDir)
enc := gob.NewEncoder(util.CreateFile(flagGobIt))
util.Assert(enc.Encode(dists), "Could not GOB encode distances")
return
}
var dists *intern.Table
if util.IsDir(util.Arg(0)) {
dists = readAlignmentDists(util.Arg(0))
} else {
dec := gob.NewDecoder(util.OpenFile(util.Arg(0)))
util.Assert(dec.Decode(&dists), "Could not GOB decode distances")
}
treeFile := util.Arg(1)
outPath := util.Arg(2)
treeReader := newick.NewReader(util.OpenFile(treeFile))
tree, err := treeReader.ReadTree()
util.Assert(err, "Could not read newick tree")
csvw := csv.NewWriter(util.CreateFile(outPath))
clusters := treeClusters(flagThreshold, dists, tree)
util.Assert(csvw.WriteAll(clusters))
}
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() {
fasInp := util.Arg(0)
fmapOut := util.Arg(1)
fmap := util.GetFmap(fasInp)
util.FmapWrite(util.CreateFile(fmapOut), fmap)
}
func mkStructure(c *command) {
c.assertNArg(2)
brkFile := c.flags.Arg(0)
saveto := c.flags.Arg(1)
util.AssertOverwritable(saveto, flagOverwrite)
brkContents, err := ioutil.ReadAll(util.OpenFile(c.flags.Arg(0)))
util.Assert(err)
pdbFragments := bytes.Split(brkContents, []byte("TER"))
fragments := make([][]structure.Coords, 0)
for i, pdbFrag := range pdbFragments {
pdbFrag = bytes.TrimSpace(pdbFrag)
if len(pdbFrag) == 0 {
continue
}
fragments = append(fragments, coords(i, pdbFrag))
}
libName := stripExt(path.Base(brkFile))
lib, err := fragbag.NewStructureAtoms(libName, fragments)
util.Assert(err)
fragbag.Save(util.CreateFile(saveto), lib)
}
func main() {
db := util.OpenBowDB(util.Arg(0))
out := util.CreateFile(util.Arg(1))
printf := func(format string, v ...interface{}) {
fmt.Fprintf(out, format, v...)
}
// Set our search options.
bowOpts := bowdb.SearchDefault
bowOpts.Limit = -1
printf("QueryID\tResultID\tCosine\tEuclid\n")
entries, err := db.ReadAll()
util.Assert(err, "Could not read BOW database entries")
for _, entry := range entries {
results := db.Search(bowOpts, entry)
for _, result := range results {
printf("%s\t%s\t%0.4f\t%0.4f\n",
entry.Id, result.Bowed.Id, result.Cosine, result.Euclid)
}
printf("\n")
}
util.Assert(out.Close())
util.Assert(db.Close())
}
func main() {
saveto := util.CreateFile(util.Arg(0))
defer saveto.Close()
w := func(format string, v ...interface{}) {
_, err := fmt.Fprintf(saveto, format, v...)
util.Assert(err)
}
var fmats []*bufio.Reader
for _, fmat := range util.Args()[1:] {
fmats = append(fmats, bufio.NewReader(util.OpenFile(fmat)))
}
LOOP:
for {
var columns int
scores := make([][]float64, len(fmats)) // matrix -> fields -> sas score
for i, fmat := range fmats {
line, err := fmat.ReadBytes('\n')
if len(line) == 0 && err == io.EOF {
break LOOP
} else if err != io.EOF {
util.Assert(err)
}
fields := bytes.Fields(line)
columns = len(fields)
scores[i] = make([]float64, columns)
for j, sas := range fields {
scores[i][j], err = strconv.ParseFloat(string(sas), 64)
util.Assert(err)
}
}
before := ""
for j := 0; j < columns; j++ {
best := scores[0][j]
for i := 1; i < len(scores); i++ {
if scores[i][j] < best {
best = scores[i][j]
}
}
if best == 0 {
w("%s0", before)
} else {
w("%s%f", before, best)
}
before = " "
}
w("\n")
}
}
func main() {
in, out := util.Arg(0), util.Arg(1)
r, w := ioFromFile(in, flagInFmt).r, ioFromFile(out, flagOutFmt).w
inf := util.OpenFile(in)
defer inf.Close()
msa, err := r(inf)
util.Assert(err, "Error parsing '%s'", in)
outf := util.CreateFile(out)
defer outf.Close()
util.Assert(w(outf, msa), "Error writing '%s'", out)
}
func main() {
flag.BoolVar(&flagAllFragments, "all-fragments", flagAllFragments,
"When set, all fragments will be shown, even if the best fragment\n"+
"of each residue set is the same.")
util.FlagParse(
"fraglib align.{fasta,ali,a2m,a3m} out-csv",
"Writes a CSV file to out-csv containing the best matching fragment\n"+
"for each pairwise contiguous set of residues between the\n"+
"first two proteins in the alignment.")
util.AssertNArg(3)
flib := util.SequenceLibrary(util.Arg(0))
aligned := util.MSA(util.Arg(1))
outcsv := util.CreateFile(util.Arg(2))
csvWriter := csv.NewWriter(outcsv)
csvWriter.Comma = '\t'
defer csvWriter.Flush()
pf := func(record ...string) {
util.Assert(csvWriter.Write(record), "Problem writing to '%s'", outcsv)
}
pf("start1", "end1", "start2", "end2", "frag1", "frag2", "rat1", "rat2")
iter := newContiguous(
flib.FragmentSize(), aligned.GetFasta(0), aligned.GetFasta(1))
for iter.next() {
best1 := flib.BestSequenceFragment(iter.res1)
best2 := flib.BestSequenceFragment(iter.res2)
if !flagAllFragments && best1 == best2 {
continue
}
if best1 == -1 || best2 == -1 {
continue
}
p1 := flib.AlignmentProb(best1, iter.res1)
p2 := flib.AlignmentProb(best2, iter.res2)
if p1.Distance(p2) > 0.14 {
continue
}
pf(
fmt.Sprintf("%d", iter.s1()),
fmt.Sprintf("%d", iter.e1()),
fmt.Sprintf("%d", iter.s2()),
fmt.Sprintf("%d", iter.e2()),
fmt.Sprintf("%d", best1),
fmt.Sprintf("%d", best2),
fmt.Sprintf("%f", p1),
fmt.Sprintf("%f", p2),
)
}
}
func main() {
var cmd string
var help bool
if len(os.Args) < 2 {
usage()
} else if strings.TrimLeft(os.Args[1], "-") == "help" {
if len(os.Args) < 3 {
usage()
} else {
cmd = os.Args[2]
help = true
}
} else {
cmd = os.Args[1]
}
for _, c := range commands {
if c.name == cmd {
c.setCommonFlags()
if c.addFlags != nil {
c.addFlags(c)
}
if help {
c.showHelp()
} else {
c.flags.Usage = c.showUsage
c.flags.Parse(os.Args[2:])
if flagCpu < 1 {
flagCpu = 1
}
runtime.GOMAXPROCS(flagCpu)
if len(flagCpuProfile) > 0 {
f := util.CreateFile(flagCpuProfile)
pprof.StartCPUProfile(f)
defer f.Close()
defer pprof.StopCPUProfile()
}
c.run(c)
return
}
}
}
log.Printf("Unknown command '%s'. Run 'flib help' for a list of "+
"available commands.", cmd)
os.Exit(1)
}
func main() {
inFasta := util.Arg(0)
outHHM := util.Arg(1)
hhblits := hhsuite.HHBlitsDefault
hhmake := hhsuite.HHMakePseudo
hhblits.Verbose = !flagQuiet
hhmake.Verbose = !flagQuiet
HHM, err := hhsuite.BuildHHM(
hhblits, hhmake, util.FlagSeqDB, inFasta)
util.Assert(err, "Error building HHM")
util.Assert(hmm.WriteHHM(util.CreateFile(outHHM), HHM),
"Error writing HHM '%s'", outHHM)
}
func main() {
flag.BoolVar(&flagAllFragments, "all-fragments", flagAllFragments,
"When set, all fragments will be shown, even if the best fragment\n"+
"of each ATOM set is the same.")
util.FlagParse(
"fraglib align.{fasta,ali,a2m,a3m} pdb-file out-csv",
"Writes a CSV file to out-csv containing the best matching fragment\n"+
"for each pairwise contiguous set of alpha-carbon atoms of the\n"+
"first two proteins in the alignment and PDB file.")
util.AssertNArg(4)
flib := util.StructureLibrary(util.Arg(0))
aligned := util.MSA(util.Arg(1))
pentry := util.PDBRead(util.Arg(2))
outcsv := util.CreateFile(util.Arg(3))
csvWriter := csv.NewWriter(outcsv)
csvWriter.Comma = '\t'
defer csvWriter.Flush()
pf := func(record ...string) {
util.Assert(csvWriter.Write(record), "Problem writing to '%s'", outcsv)
}
pf("start1", "end1", "start2", "end2", "frag1", "frag2", "frag_rmsd")
iter := newContiguous(
flib.FragmentSize(),
aligned.GetFasta(0), aligned.GetFasta(1),
pentry.Chains[0], pentry.Chains[1])
for iter.next() {
best1 := flib.BestStructureFragment(iter.atoms1)
best2 := flib.BestStructureFragment(iter.atoms2)
if !flagAllFragments && best1 == best2 {
continue
}
bestRmsd := structure.RMSD(flib.Atoms(best1), flib.Atoms(best2))
pf(
fmt.Sprintf("%d", iter.s1()),
fmt.Sprintf("%d", iter.e1()),
fmt.Sprintf("%d", iter.s2()),
fmt.Sprintf("%d", iter.e2()),
fmt.Sprintf("%d", best1),
fmt.Sprintf("%d", best2),
fmt.Sprintf("%f", bestRmsd),
)
}
}
func main() {
a3mPath := util.Arg(0)
fa3m := util.OpenFile(a3mPath)
freader := fasta.NewReader(fa3m)
freader.TrustSequences = true
seqs, err := freader.ReadAll()
util.Assert(err, "Could not read fasta format '%s'", a3mPath)
util.Assert(fa3m.Close())
w := util.CreateFile(a3mPath)
fwriter := fasta.NewWriter(w)
fwriter.Columns = 0
for _, seq := range seqs {
if len(seq.Residues) > 0 {
util.Assert(fwriter.Write(seq))
}
}
util.Assert(fwriter.Flush())
util.Assert(w.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 main() {
rfasta := util.OpenFasta(util.Arg(0))
dir := util.Arg(1)
util.Assert(os.MkdirAll(dir, 0777))
fr := fasta.NewReader(rfasta)
for {
s, err := fr.Read()
if err != nil {
if err == io.EOF {
break
}
util.Assert(err)
}
s.Name = strings.Fields(s.Name)[0]
fw := util.CreateFile(path.Join(dir, s.Name+".fasta"))
w := fasta.NewWriter(fw)
util.Assert(w.Write(s))
util.Assert(w.Flush())
util.Assert(fw.Close())
}
}
func mkSeqHMM(c *command) {
c.assertLeastNArg(3)
structLib := util.StructureLibrary(c.flags.Arg(0))
outPath := c.flags.Arg(1)
entries := c.flags.Args()[2:]
util.AssertOverwritable(outPath, flagOverwrite)
saveto := util.CreateFile(outPath)
// Stores intermediate files produced by hhmake.
tempDir, err := ioutil.TempDir("", "mk-seqlib-hmm")
util.Assert(err, "Could not create temporary directory.")
defer os.RemoveAll(tempDir)
// Initialize a MSA for each structural fragment.
var msas []seq.MSA
var msaChans []chan seq.Sequence
for i := 0; i < structLib.Size(); i++ {
msa := seq.NewMSA()
msa.SetLen(structLib.FragmentSize())
msas = append(msas, msa)
msaChans = append(msaChans, make(chan seq.Sequence))
}
// Now spin up a goroutine for each fragment that is responsible for
// adding a sequence slice to itself.
for i := 0; i < structLib.Size(); i++ {
addToMSA(msaChans[i], &msas[i])
}
// Create a channel that sends the PDB entries given.
entryChan := make(chan string)
go func() {
for _, fp := range entries {
entryChan <- fp
}
close(entryChan)
}()
progress := util.NewProgress(len(entries))
for i := 0; i < flagCpu; i++ {
wgPDBChains.Add(1)
go func() {
for entryPath := range entryChan {
_, chains, err := util.PDBOpen(entryPath)
progress.JobDone(err)
if err != nil {
continue
}
for _, chain := range chains {
structureToSequence(structLib, chain, nil, msaChans)
}
}
wgPDBChains.Done()
}()
}
wgPDBChains.Wait()
progress.Close()
// We've finishing reading all the PDB inputs. Now close the channels
// and let the sequence fragments finish.
for i := 0; i < structLib.Size(); i++ {
close(msaChans[i])
}
wgSeqFragments.Wait()
util.Verbosef("Building profile HMMs from MSAs...")
// Finally, add the sequence fragments to a new sequence fragment
// library and save.
hmms := make([]*seq.HMM, structLib.Size())
hhmake := func(i int) struct{} {
fname := path.Join(tempDir, fmt.Sprintf("%d.fasta", i))
f := util.CreateFile(fname)
util.Assert(msa.WriteFasta(f, msas[i]))
hhm, err := hhsuite.HHMakePseudo.Run(fname)
util.Assert(err)
hmms[i] = hhm.HMM
return struct{}{} // my unifier sucks, i guess
}
fun.ParMap(hhmake, fun.Range(0, structLib.Size()))
lib, err := fragbag.NewSequenceHMM(structLib.Name(), hmms)
util.Assert(err)
util.Assert(fragbag.Save(saveto, lib))
}
func main() {
if len(util.FlagCpuProf) > 0 {
f := util.CreateFile(util.FlagCpuProf)
pprof.StartCPUProfile(f)
defer f.Close()
defer pprof.StopCPUProfile()
}
vectors := readVectors(util.Arg(1))
groups := readCathGroups(util.Args()[2:])
out := util.CreateFile(util.Arg(0))
defer out.Close()
pf := func(format string, v ...interface{}) {
// fmt.Printf(format, v...)
fmt.Fprintf(out, format, v...)
}
type labeledPval struct {
Name1, Name2 string
Pval float32
}
b := stdb(vectors, groups)
pairs := combinations(len(groups))
dopairs, pvals := make(chan pair), make(chan labeledPval)
wg := new(sync.WaitGroup)
for i := 0; i < util.FlagCpu; i++ {
wg.Add(1)
go func() {
for p := range dopairs {
g1, g2 := groups[p.i], groups[p.j]
b1, b2 := b[p.i], b[p.j]
bm1, bm2 := bmean(b1, b2)
bw := delta(bm1, bm2)
randws := make([]float32, 1000)
for i := range randws {
randws[i] = delta(shuffle_mean_rows(b1, b2))
}
bigger := 0
for _, rw := range randws {
if rw >= bw {
bigger++
}
}
pval := float32(bigger) / float32(len(randws))
pvals <- labeledPval{g1.Name, g2.Name, pval}
}
wg.Done()
}()
}
done := make(chan struct{})
go func() {
sig, cutoff := 0, 0.05/float32(len(pairs))
for pval := range pvals {
if pval.Pval < cutoff {
sig++
}
pf("%s\t%s\t%f\n", pval.Name1, pval.Name2, pval.Pval)
}
pf("significant\t%d/%d\t(cutoff: %f)\n", sig, len(pairs), cutoff)
done <- struct{}{}
}()
for _, p := range pairs {
dopairs <- p
}
close(dopairs)
wg.Wait()
close(pvals)
<-done
}
func main() {
if len(util.FlagCpuProf) > 0 {
f := util.CreateFile(util.FlagCpuProf)
pprof.StartCPUProfile(f)
defer f.Close()
defer pprof.StopCPUProfile()
}
// Read all CATH domains, the best-of-all matrix, and the matrix for
// each aligner.
domains := readDomains(util.Arg(0))
boa := readMatrix(domains, util.Arg(1))
aligners := make([]aligner, 0)
flibs := make([]flib, 0)
for i := 2; i < util.NArg(); i += 2 {
fpath := util.Arg(i)
if path.Ext(fpath) == ".bowdb" {
db := util.OpenBowDB(fpath)
records, err := db.ReadAll()
util.Assert(err)
bowed := make([]bow.Bowed, domains.in.Len())
for _, b := range records {
if !domains.in.Exists(b.Id) {
util.Fatalf("Found ID in bowdb that isn't in the list "+
"of CATH domains provided: %s", b.Id)
}
bowed[domains.in.Atom(b.Id)] = b
}
flibs = append(flibs, flib{db, bowed, util.Arg(i + 1)})
} else {
aligners = append(aligners, aligner{
readMatrix(domains, fpath),
util.Arg(i + 1),
})
}
}
// Now remove CATH domains that don't have a corresponding structure file.
// We don't do this initially since the matrix files are indexed with
// respect to all CATH domains (includings ones without structure).
// This is an artifact of the fact that the matrices were generated with
// a very old version of CATH.
domains.removeOldDomains()
if a := matrixAuc(domains, boa, boa, flagThreshold); a != 1.0 {
util.Fatalf("Something is wrong. The AUC of the best-of-all matrix "+
"with respect to itself is %f, but it should be 1.0.", a)
}
if len(aligners) > 0 {
fmt.Println("Computing AUC for aligners...")
writeAuc := func(aligner aligner) struct{} {
w := util.CreateFile(aligner.outpath)
a := matrixAuc(domains, boa, aligner.matrix, flagThreshold)
fmt.Fprintf(w, "%f\n", a)
return struct{}{}
}
fun.ParMap(writeAuc, aligners)
}
if len(flibs) > 0 {
fmt.Println("Computing AUC for bowdbs...")
writeAuc := func(flib flib) struct{} {
w := util.CreateFile(flib.outpath)
a := flibAuc(domains, boa, flib, flagThreshold)
fmt.Fprintf(w, "%f\n", a)
return struct{}{}
}
fun.ParMap(writeAuc, flibs)
}
}
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)
}
}
}
func mkSeqProfile(c *command) {
c.assertLeastNArg(3)
structLib := util.StructureLibrary(c.flags.Arg(0))
outPath := c.flags.Arg(1)
entries := c.flags.Args()[2:]
util.AssertOverwritable(outPath, flagOverwrite)
saveto := util.CreateFile(outPath)
// Initialize a frequency and null profile for each structural fragment.
var freqProfiles []*seq.FrequencyProfile
var fpChans []chan seq.Sequence
for i := 0; i < structLib.Size(); i++ {
fp := seq.NewFrequencyProfile(structLib.FragmentSize())
freqProfiles = append(freqProfiles, fp)
fpChans = append(fpChans, make(chan seq.Sequence))
}
// Now spin up a goroutine for each fragment that is responsible for
// adding a sequence slice to itself.
nullChan, nullProfile := addToNull()
for i := 0; i < structLib.Size(); i++ {
addToProfile(fpChans[i], freqProfiles[i])
}
// Create a channel that sends the PDB entries given.
entryChan := make(chan string)
go func() {
for _, fp := range entries {
entryChan <- fp
}
close(entryChan)
}()
progress := util.NewProgress(len(entries))
for i := 0; i < flagCpu; i++ {
wgPDBChains.Add(1)
go func() {
for entryPath := range entryChan {
_, chains, err := util.PDBOpen(entryPath)
progress.JobDone(err)
if err != nil {
continue
}
for _, chain := range chains {
structureToSequence(structLib, chain, nullChan, fpChans)
}
}
wgPDBChains.Done()
}()
}
wgPDBChains.Wait()
progress.Close()
// We've finishing reading all the PDB inputs. Now close the channels
// and let the sequence fragments finish.
close(nullChan)
for i := 0; i < structLib.Size(); i++ {
close(fpChans[i])
}
wgSeqFragments.Wait()
// Finally, add the sequence fragments to a new sequence fragment
// library and save.
profs := make([]*seq.Profile, structLib.Size())
for i := 0; i < structLib.Size(); i++ {
profs[i] = freqProfiles[i].Profile(nullProfile)
}
lib, err := fragbag.NewSequenceProfile(structLib.Name(), profs)
util.Assert(err)
util.Assert(fragbag.Save(saveto, lib))
}
func main() {
lib := util.StructureLibrary(util.Arg(0))
fmap := util.FmapRead(util.Arg(1))
util.BowWrite(util.CreateFile(util.Arg(2)), fmap.StructureBow(lib))
}
func main() {
outDir := util.Arg(0)
fasInps := util.Args()[1:]
util.Assert(os.MkdirAll(outDir, 0777))
fastaChan := make(chan string)
wg := new(sync.WaitGroup)
for i := 0; i < max(1, runtime.GOMAXPROCS(0)); i++ {
go func() {
wg.Add(1)
for fasta := range fastaChan {
util.Verbosef("Computing map for '%s'...", fasta)
fmap := util.GetFmap(fasta)
outF := path.Join(outDir, fmt.Sprintf("%s.fmap", fmap.Name))
util.FmapWrite(util.CreateFile(outF), fmap)
}
wg.Done()
}()
}
for _, fasta := range fasInps {
fastaChan <- fasta
}
close(fastaChan)
wg.Wait()
}