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() {
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 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 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))
}