func main() { buf := new(bytes.Buffer) if flag.NArg() < 2 { flag.Usage() } // If the quiet flag isn't set, enable verbose output. if !flagQuiet { cablastp.Verbose = true } inputFastaQuery, err := getInputFasta() if err != nil { fatalf("Could not read input fasta query: %s\n", err) } db, err := cablastp.NewReadDB(flag.Arg(0)) if err != nil { fatalf("Could not open '%s' database: %s\n", flag.Arg(0), err) } cablastp.Vprintln("\nBlasting query on coarse database...") if err := blastCoarse(db, inputFastaQuery, buf); err != nil { fatalf("Error blasting coarse database: %s\n", err) } cablastp.Vprintln("Decompressing blast hits...") expandedSequences, err := expandBlastHits(db, buf) if err != nil { fatalf("%s\n", err) } // Write the contents of the expanded sequences to a fasta file. // It is then passed as the "-subject" parameter to blastp. var tmpFine string if tmpFine, err = writeFasta(expandedSequences); err != nil { fatalf("Could not create FASTA input from coarse hits: %s\n", err) } // Finally, run the query against the fine fasta database and pass on the // stdout and stderr... cablastp.Vprintln("Blasting query on fine database...") if _, err := inputFastaQuery.Seek(0, os.SEEK_SET); err != nil { fatalf("Could not seek to start of query fasta input: %s\n", err) } if err := blastFine(db, tmpFine, inputFastaQuery); err != nil { fatalf("Error blasting fine database: %s\n", err) } // Delete the temporary fine database. if !flagNoCleanup { if err := os.Remove(tmpFine); err != nil { fatalf("Could not delete fine fasta database: %s\n", err) } } cleanup(db) }
func main() { if flag.NArg() < 2 { flag.Usage() } // If the quiet flag isn't set, enable verbose output. if !flagQuiet { cablastp.Verbose = true } // Open the fasta file specified for writing. outFasta, err := os.Create(flag.Arg(1)) if err != nil { fatalf("Could not write to '%s': %s\n", flag.Arg(1), err) } fastaWriter := fasta.NewWriter(outFasta) fastaWriter.Asterisk = true // Create a new database for writing. If we're appending, we load // the coarse database into memory, and setup the database for writing. db, err := cablastp.NewReadDB(flag.Arg(0)) if err != nil { fatalf("Could not open '%s' database: %s\n", flag.Arg(0), err) } cablastp.Vprintln("") // Start the CPU profile after all of the data has been read. if len(flagCpuProfile) > 0 { f, err := os.Create(flagCpuProfile) if err != nil { fatalf("%s\n", err) } pprof.StartCPUProfile(f) } numSeqs := db.ComDB.NumSequences() for orgSeqId := 0; orgSeqId < numSeqs; orgSeqId++ { oseq, err := db.ComDB.ReadSeq(db.CoarseDB, orgSeqId) if err != nil { fatalf("Error reading seq id '%d': %s\n", orgSeqId, err) } if err := fastaWriter.Write(oseq.FastaSeq()); err != nil { cablastp.Vprintf("Error writing seq '%s': %s\n", oseq.Name, err) } } cleanup(db) if err = fastaWriter.Flush(); err != nil { fatalf("%s\n", err) } if err = outFasta.Close(); err != nil { fatalf("%s\n", err) } }
func main() { if flag.NArg() < 2 { flag.Usage() } // If both 'append' and 'overwrite' flags are set, quit because the // combination doesn't make sense. if flagAppend && flagOverwrite { fatalf("Both the 'append' and 'overwrite' flags are set. It does " + "not make sense to set both of these flags.") } // If the quiet flag isn't set, enable verbose output. if !flagQuiet { cablastp.Verbose = true } // If the overwrite flag is set, remove whatever directory that may // already be there. if flagOverwrite { if err := os.RemoveAll(flag.Arg(0)); err != nil { fatalf("Could not remove existing database '%s': %s.", flag.Arg(0), err) } } // Create a new database for writing. If we're appending, we load // the coarse database into memory, and setup the database for writing. db, err := cablastp.NewWriteDB(flagAppend, dbConf, flag.Arg(0)) if err != nil { fatalf("%s\n", err) } cablastp.Vprintln("") pool := startCompressWorkers(db) orgSeqId := db.ComDB.NumSequences() mainQuit := make(chan struct{}, 0) // If the process is killed, try to clean up elegantly. // The idea is to preserve the integrity of the database. attachSignalHandler(db, mainQuit, &pool) // Start the CPU profile after all of the data has been read. if len(flagCpuProfile) > 0 { f, err := os.Create(flagCpuProfile) if err != nil { fatalf("%s\n", err) } pprof.StartCPUProfile(f) } for _, arg := range flag.Args()[1:] { seqChan, err := cablastp.ReadOriginalSeqs(arg, ignoredResidues) if err != nil { log.Fatal(err) } if orgSeqId == 0 { timer = time.Now() } for readSeq := range seqChan { // Do a non-blocking receive to see if main needs to quit. select { case <-mainQuit: <-mainQuit // wait for cleanup to finish before exiting main. return default: } if readSeq.Err != nil { log.Fatal(err) } dbConf.BlastDBSize += uint64(readSeq.Seq.Len()) orgSeqId = pool.compress(orgSeqId, readSeq.Seq) verboseOutput(db, orgSeqId) if flagMaxSeedsGB > 0 && orgSeqId%10000 == 0 { db.CoarseDB.Seeds.MaybeWipe(flagMaxSeedsGB) runtime.GC() } } } cablastp.Vprintln("\n") cablastp.Vprintf("Wrote %s.\n", cablastp.FileCompressed) cablastp.Vprintf("Wrote %s.\n", cablastp.FileIndex) cleanup(db, &pool) }
func main() { buf := new(bytes.Buffer) if flag.NArg() < 2 { flag.Usage() } if len(flagRPSPath) == 0 { fmt.Fprintln(os.Stderr, "The '--rpspath' flag must be set.") flag.Usage() } // If the quiet flag isn't set, enable verbose output. if !flagQuiet { cablastp.Verbose = true } inputFastaQuery, err := getInputFasta() if err != nil { fatalf("Could not read input fasta query: %s\n", err) } db, err := cablastp.NewReadDB(flag.Arg(0)) if err != nil { fatalf("Could not open '%s' database: %s\n", flag.Arg(0), err) } cablastp.Vprintln("\nBlasting query on coarse database...") if err := blastCoarse(db, inputFastaQuery, buf); err != nil { fatalf("Error blasting coarse database: %s\n", err) } cablastp.Vprintln("Decompressing blast hits...") expandedSequences, err := expandBlastHits(db, buf) if err != nil { fatalf("%s\n", err) } // Write the contents of the expanded sequences to a fasta file. // It is then passed as the "-subject" parameter to blastp. buf.Reset() if err := writeFasta(expandedSequences, buf); err != nil { fatalf("Could not create FASTA input from coarse hits: %s\n", err) } // Create the fine blast db in a temporary directory cablastp.Vprintln("Building fine BLAST database...") tmpDir, err := makeFineBlastDB(db, buf) if err != nil { fatalf("Could not create fine database to search on: %s\n", err) } // Finally, run the query against the fine fasta database and pass on // stdout and stderr... cablastp.Vprintln("Blasting query on fine database...") if _, err := inputFastaQuery.Seek(0, os.SEEK_SET); err != nil { fatalf("Could not seek to start of query fasta input: %s\n", err) } if err := blastFine(db, tmpDir, inputFastaQuery); err != nil { fatalf("Error blasting fine database: %s\n", err) } // Delete the temporary fine database. if !flagNoCleanup { if err := os.RemoveAll(tmpDir); err != nil { fatalf("Could not delete fine BLAST database: %s\n", err) } } cleanup(db) }