Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Removed unused 'correct-long' subprogram

  • Loading branch information...
commit aed475425587a0076d59bc37e94357f44709bbb2 1 parent 618088f
Jared Simpson authored
248 src/Algorithm/LRCorrectionAlgorithm.cpp
View
@@ -1,248 +0,0 @@
-//-----------------------------------------------
-// Copyright 2011 Wellcome Trust Sanger Institute
-// Written by Jared Simpson (js18@sanger.ac.uk)
-// Released under the GPL
-//-----------------------------------------------
-//
-// LRCorrectionAlgorithmAlgorithm - Collection of algorithms for
-// correcting long reads with a set of short reads
-//
-#include "LRCorrectionAlgorithm.h"
-#include "StringThreader.h"
-#include "HaplotypeBuilder.h"
-
-namespace LRCorrectionAlgorithm
-{
-
-std::string correct(const std::string& query,
- const BWT* pTargetBWT,
- const BWT* pRevTargetBWT,
- const SampledSuffixArray* pTargetSSA,
- const LRAlignment::LRParams& params)
-{
- (void)pTargetSSA;
- (void)params;
- //return correctAlignment(query, pTargetBWT, pTargetSSA, params);
- //return correctGraphThread(query, pTargetBWT, pRevTargetBWT, pTargetSSA, params);
- return correctDeBruijnPath(query, pTargetBWT, pRevTargetBWT);
-}
-
-// Correct the read using an alignment-based approach
-std::string correctAlignment(const std::string& query,
- const BWT* pTargetBWT,
- const SampledSuffixArray* pTargetSSA,
- const LRAlignment::LRParams& params)
-{
- LRAlignment::LRHitVector hits;
- LRAlignment::bwaswAlignment(query, pTargetBWT, pTargetSSA, params, hits);
- MultiAlignment ma = LRAlignment::convertHitsToMultiAlignment(query, pTargetBWT, pTargetSSA, params, hits);
- std::string consensus = ma.generateConsensus();
- ma.print();
- if(consensus.size() > query.size() * 0.8f)
- return consensus;
- else
- return "";
-}
-
-
-// Correct the read using an alignment-based approach
-std::string correctAlignmentPartial(const std::string& query,
- const BWT* pTargetBWT,
- const SampledSuffixArray* pTargetSSA,
- const LRAlignment::LRParams& params)
-{
-
- size_t ss_length = 150;
- size_t stride = 50;
- LRAlignment::LRHitVector allHits;
-
- for(size_t i = 0; i < query.size() - ss_length; i += stride)
- {
- if(query.size() < ss_length)
- break;
- std::string sub = query.substr(i, ss_length);
-
- LRAlignment::LRHitVector hits;
- LRAlignment::bwaswAlignment(sub, pTargetBWT, pTargetSSA, params, hits);
-
- for(size_t j = 0; j < hits.size(); ++j)
- {
- LRAlignment::LRHit shiftHit = hits[j];
- shiftHit.q_start += i;
- shiftHit.q_end += i;
- allHits.push_back(shiftHit);
- }
- }
-
- MultiAlignment ma = LRAlignment::convertHitsToMultiAlignment(query, pTargetBWT, pTargetSSA, params, allHits);
- ma.print();
- std::string consensus = ma.generateConsensus();
- if(consensus.size() > query.size() * 0.9f)
- return consensus;
- else
- return "";
-}
-
-// Attempt to correct the sequence via threading through a graph
-std::string correctGraphThread(const std::string& query,
- const BWT* pTargetBWT,
- const BWT* /*pRevTargetBWT*/,
- const SampledSuffixArray* pTargetSSA,
- const LRAlignment::LRParams& params)
-{
- // Calculate hits using bwa-sw alignment over the first portion
- // of the long read. The hits will be used to seed the threading
- // process.
- size_t extension_kmer = 51;
- size_t ss_length = 150;
- std::string sub = query.substr(0, ss_length);
- LRAlignment::LRHitVector hits;
- LRAlignment::bwaswAlignment(sub, pTargetBWT, pTargetSSA, params, hits);
-
- // No hits found
- if(hits.empty())
- return "";
-
- int bestScore = std::numeric_limits<int>::min();
- std::string bestString = "";
-
- for(size_t i = 0; i < hits.size(); ++i)
- {
- LRAlignment::LRHit seedHit = hits[i];
- std::string seed = BWTAlgorithms::extractSubstring(pTargetBWT, seedHit.targetID, seedHit.t_start, seedHit.length);
- if(seed.size() < extension_kmer)
- continue;
-
- // Perform the threading for this query seed
- std::string querySeed = query.substr(seedHit.q_start);
- StringThreader threader(seed, &querySeed, seedHit.q_end, extension_kmer, pTargetBWT);
-
- StringThreaderResultVector results;
- threader.run(results);
-
- // Process the results and save the best-scoring thread
- for(size_t j = 0; j < results.size(); ++j)
- {
- StringThreaderResult& r = results[j];
- int score = StdAlnTools::globalAlignment(querySeed.substr(0, r.query_align_length), r.thread);
-
- if(score > bestScore)
- {
- bestScore = score;
- bestString = r.thread;
- }
- }
- }
- return bestString;
-}
-
-// Correct the read using a de Bruijn graph threading approach
-std::string correctDeBruijnPath(const std::string& query,
- const BWT* pTargetBWT,
- const BWT* pRevTargetBWT,
- bool verbose)
-{
- size_t kmer = 41;
- size_t kmerThreshold = 5;
-
- if(verbose)
- std::cout << "Processing query: " << query << "\n";
-
- // Compute the set of anchor sequences. These are kmers with frequency
- // above the given threshold. For non-adjacent anchors, we construct haplotypes
- // from the graph and use these sequences to correct the read.
- AnchorVector anchors;
-
- // Create a table of kmer frequences over the query sequence
- for(size_t i = 0; i < query.size() - kmer + 1; ++i)
- {
- std::string ks = query.substr(i, kmer);
- size_t count = BWTAlgorithms::countSequenceOccurrences(ks, pTargetBWT);
-
- AnchorSequence anchor = { ks, static_cast<int>(i), static_cast<int>(count) };
- if(verbose)
- std::cout << anchor << "\n";
- if(count >= kmerThreshold)
- anchors.push_back(anchor);
- }
-
- // Build haplotypes between non-adjacent anchors
-
- // If there is zero or one anchor, do nothing
- if(anchors.size() <= 1)
- return "";
-
- AnchorSequence& previousAnchor = anchors.front();
- std::string correctedSequence = previousAnchor.sequence;
-
- for(size_t i = 1; i < anchors.size(); ++i)
- {
- AnchorSequence& currAnchor = anchors[i];
-
- // Check if the anchors are non-adjacent
- if(currAnchor.position != previousAnchor.position + 1)
- {
- // Build haplotypes between anchors
- if(verbose)
- {
- std::cout << "Anchor1: " << previousAnchor << "\n";
- std::cout << "Anchor2: " << currAnchor << "\n";
- }
-
- // Skip degenerate anchors, leave the read uncorrected
- if(previousAnchor.sequence == currAnchor.sequence)
- return "";
-
- HaplotypeBuilder builder;
- builder.setTerminals(previousAnchor, currAnchor);
- builder.setIndex(pTargetBWT, pRevTargetBWT);
- builder.setKmerParameters(kmer, kmerThreshold);
-
- HaplotypeBuilderResult result;
- builder.run();
- builder.parseWalks(result);
-
- if(result.haplotypes.empty())
- return ""; // no correction found
-
- if(verbose)
- std::cout << "Built " << result.haplotypes.size() << " haplotype\n";
-
- // Take a subsequence of the query that these haplotypes replace
- size_t queryStart = previousAnchor.position;
- size_t queryStop = currAnchor.position + kmer - 1;
- std::string querySub = query.substr(queryStart, queryStop - queryStart + 1);
-
- int64_t bestScore = 0;
- size_t bestIndex = 0;
- for(size_t j = 0; j < result.haplotypes.size(); ++j)
- {
- int score = StdAlnTools::globalAlignment(querySub, result.haplotypes[j], verbose);
- if(score > bestScore)
- {
- bestScore = score;
- bestIndex = j;
- }
- }
-
- // Append in the sequence of the best haplotype
- // We skip the first k bases as these are part
- // of the previous anchor, which has already been appended
- std::string toAppend = result.haplotypes[bestIndex].substr(kmer);
- correctedSequence.append(toAppend);
- }
- else
- {
- // Adjancent anchors, append in the last base of the anchor
- char lastBase = currAnchor.sequence[currAnchor.sequence.size() - 1];
- correctedSequence.append(1, lastBase);
- }
- previousAnchor = currAnchor;
- }
-
- if(verbose)
- StdAlnTools::globalAlignment(query, correctedSequence, true);
- return correctedSequence;
-}
-
-} // namespace
54 src/Algorithm/LRCorrectionAlgorithm.h
View
@@ -1,54 +0,0 @@
-//-----------------------------------------------
-// Copyright 2011 Wellcome Trust Sanger Institute
-// Written by Jared Simpson (js18@sanger.ac.uk)
-// Released under the GPL
-//-----------------------------------------------
-//
-// LRCorrectionAlgorithm - Collection of algorithms for
-// correcting long reads with a set of short reads
-//
-#ifndef LRCORRECTION_H
-#define LRCORRECTION_H
-
-#include "LRAlignment.h"
-
-namespace LRCorrectionAlgorithm
-{
- // Main correction function, dispatching the call to one
- // of the actual correction algorithms
- std::string correct(const std::string& query,
- const BWT* pTargetBWT,
- const BWT* pRevTargetBWT,
- const SampledSuffixArray* pTargetSSA,
- const LRAlignment::LRParams& params);
-
- // Correct the query read by aligning it to all the reads in pTargetBWT
- // and calling a consensus sequence
- std::string correctAlignment(const std::string& query,
- const BWT* pTargetBWT,
- const SampledSuffixArray* pTargetSSA,
- const LRAlignment::LRParams& params);
-
- // Correct the query read by breaking it into pieces, aligning those
- // pieces to pTargetBWT then constructing a multialignment from the sub-alignments.
- std::string correctAlignmentPartial(const std::string& query,
- const BWT* pTargetBWT,
- const SampledSuffixArray* pTargetSSA,
- const LRAlignment::LRParams& params);
-
- // Correct a read by threading it through an implicit assembly graph
- // represented by pTargetBWT and pRevTargetBWT.
- std::string correctGraphThread(const std::string& query,
- const BWT* pTargetBWT,
- const BWT* pRevTargetBWT,
- const SampledSuffixArray* /*pTargetSSA*/,
- const LRAlignment::LRParams& /*params*/);
-
- //
- std::string correctDeBruijnPath(const std::string& query,
- const BWT* pTargetBWT,
- const BWT* pRevTargetBWT,
- bool verbose = false);
-};
-
-#endif
72 src/Algorithm/LRCorrectionProcess.cpp
View
@@ -1,72 +0,0 @@
-//-----------------------------------------------
-// Copyright 2011 Wellcome Trust Sanger Institute
-// Written by Jared Simpson (js18@sanger.ac.uk)
-// Released under the GPL
-//-----------------------------------------------
-//
-// LRCorrectionProcess - Wrapper class implementing
-// the long-read correction process
-//
-#include "LRCorrectionProcess.h"
-#include "LRCorrectionAlgorithm.h"
-
-// Constructor
-LRCorrectionProcess::LRCorrectionProcess(const LRCorrectionParameters params) : m_params(params)
-{
-
-}
-
-// Destructor
-LRCorrectionProcess::~LRCorrectionProcess()
-{
-
-}
-
-// Perform the actual correction
-LRCorrectionResult LRCorrectionProcess::process(const SequenceWorkItem& item)
-{
- LRCorrectionResult result;
- if((int)item.read.seq.length() > m_params.minLength)
- {
- result.correctedSequence = LRCorrectionAlgorithm::correct(item.read.seq.toString(),
- m_params.pBWT,
- m_params.pRBWT,
- m_params.pSSA,
- m_params.alignParams);
- }
- return result;
-}
-
-//
-// Post processor
-//
-LRCorrectionPostProcess::LRCorrectionPostProcess(std::ostream* pCorrectedWriter) : m_pCorrectedWriter(pCorrectedWriter),
- m_readsKept(0),
- m_readsDiscarded(0)
-{
-
-}
-
-//
-LRCorrectionPostProcess::~LRCorrectionPostProcess()
-{
- printf("Long read corrector kept %zu reads, discarded %zu\n", m_readsKept, m_readsDiscarded);
-}
-
-//
-void LRCorrectionPostProcess::process(const SequenceWorkItem& item, const LRCorrectionResult& result)
-{
- SeqRecord record = item.read;
- record.seq = result.correctedSequence;
- record.qual = "";
-
- if(!record.seq.empty())
- {
- record.write(*m_pCorrectedWriter);
- m_readsKept += 1;
- }
- else
- {
- m_readsDiscarded += 1;
- }
-}
74 src/Algorithm/LRCorrectionProcess.h
View
@@ -1,74 +0,0 @@
-//-----------------------------------------------
-// Copyright 2011 Wellcome Trust Sanger Institute
-// Written by Jared Simpson (js18@sanger.ac.uk)
-// Released under the GPL
-//-----------------------------------------------
-//
-// LRCorrectionProcess - Wrapper class implementing
-// the long-read correction process
-//
-#ifndef LRCORRECTION_PROCESS_H
-#define LRCORRECTION_PROCESS_H
-
-#include <string>
-#include "SequenceProcessFramework.h"
-#include "BWT.h"
-#include "SampledSuffixArray.h"
-#include "LRAlignment.h"
-
-// Parameters to the corrector
-class LRCorrectionParameters
-{
- public:
- const BWT* pBWT;
- const BWT* pRBWT;
- const SampledSuffixArray* pSSA;
- LRAlignment::LRParams alignParams;
- int minLength;
-};
-
-// Object holding the result of correcting one read
-class LRCorrectionResult
-{
- public:
- LRCorrectionResult() {}
-
- // data
- std::string correctedSequence;
-
-};
-
-//
-class LRCorrectionProcess
-{
- public:
- LRCorrectionProcess(const LRCorrectionParameters params);
- ~LRCorrectionProcess();
-
- LRCorrectionResult process(const SequenceWorkItem& item);
-
- private:
-
- LRCorrectionParameters m_params;
-};
-
-// Write the results from the overlap step to an ASQG file
-class LRCorrectionPostProcess
-{
- public:
- LRCorrectionPostProcess(std::ostream* pCorrectedWriter);
- ~LRCorrectionPostProcess();
-
- void process(const SequenceWorkItem& item, const LRCorrectionResult& result);
-
- private:
-
- std::ostream* m_pCorrectedWriter;
-
- size_t m_readsKept;
- size_t m_readsDiscarded;
-};
-
-
-
-#endif
2  src/Algorithm/Makefile.am
View
@@ -26,8 +26,6 @@ libalgorithm_a_SOURCES = \
ClusterProcess.h ClusterProcess.cpp \
ReadCluster.h ReadCluster.cpp \
LRAlignment.h LRAlignment.cpp \
- LRCorrectionAlgorithm.h LRCorrectionAlgorithm.cpp \
- LRCorrectionProcess.h LRCorrectionProcess.cpp \
StringThreader.h StringThreader.cpp \
HapgenProcess.h HapgenProcess.cpp \
ExtensionDP.h ExtensionDP.cpp \
1  src/SGA/Makefile.am
View
@@ -47,7 +47,6 @@ sga_SOURCES = sga.cpp \
filterBAM.h filterBAM.cpp \
cluster.h cluster.cpp \
gen-ssa.h gen-ssa.cpp \
- correct-long.h correct-long.cpp \
bwt2fa.h bwt2fa.cpp \
graph-diff.h graph-diff.cpp \
var2vcf.h var2vcf.cpp \
246 src/SGA/correct-long.cpp
View
@@ -1,246 +0,0 @@
-//-----------------------------------------------
-// Copyright 2009 Wellcome Trust Sanger Institute
-// Written by Jared Simpson (js18@sanger.ac.uk)
-// Released under the GPL
-//-----------------------------------------------
-//
-// correct-long - Correct sequencing errors in long reads
-//
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <iterator>
-#include "Util.h"
-#include "correct-long.h"
-#include "SuffixArray.h"
-#include "BWT.h"
-#include "SGACommon.h"
-#include "OverlapCommon.h"
-#include "Timer.h"
-#include "BWTAlgorithms.h"
-#include "ASQG.h"
-#include "gzstream.h"
-#include "SequenceProcessFramework.h"
-#include "LRCorrectionProcess.h"
-#include "CorrectionThresholds.h"
-#include "KmerDistribution.h"
-#include "LRCorrectionAlgorithm.h"
-
-// Defines
-#define PROCESS_LRC_SERIAL SequenceProcessFramework::processSequencesSerial<SequenceWorkItem, LRCorrectionResult, \
- LRCorrectionProcess, LRCorrectionPostProcess>
-
-#define PROCESS_LRC_PARALLEL SequenceProcessFramework::processSequencesParallel<SequenceWorkItem, LRCorrectionResult, \
- LRCorrectionProcess, LRCorrectionPostProcess>
-
-//
-// Getopt
-//
-#define SUBPROGRAM "correct-long"
-static const char *CORRECT_LONG_VERSION_MESSAGE =
-SUBPROGRAM " Version " PACKAGE_VERSION "\n"
-"Written by Jared Simpson.\n"
-"\n"
-"Copyright 2011 Wellcome Trust Sanger Institute\n";
-
-static const char *CORRECT_LONG_USAGE_MESSAGE =
-"Usage: " PACKAGE_NAME " " SUBPROGRAM " [OPTION] ... READSFILE\n"
-"Correct sequencing errors in the long reads in READSFILE\n"
-"\n"
-" --help display this help and exit\n"
-" -v, --verbose display verbose output\n"
-" -p, --prefix=PREFIX use PREFIX for the names of the index files\n"
-" -o, --outfile=FILE write the corrected reads to FILE (default: READSFILE.ec.fa)\n"
-" -m, --min-length=LEN only process reads with length at least LEN bp (default 200bp)\n"
-" -d, --sample-rate=N use occurrence array sample rate of N in the FM-index. Higher values use significantly\n"
-" less memory at the cost of higher runtime. This value must be a power of 2 (default: 128)\n"
-" -z, --z-best=N keep N hits at each node.\n"
-" -t, --threads=NUM use NUM threads for the computation (default: 1)\n"
-" --cut=STR use STR as the cell pruning heuristic. Options are strata, zbest, score, none.\n"
-"\nReport bugs to " PACKAGE_BUGREPORT "\n\n";
-
-//static const char* PROGRAM_IDENT =
-//PACKAGE_NAME "::" SUBPROGRAM;
-
-namespace opt
-{
- static unsigned int verbose;
- static int numThreads = 1;
- static int zBest = -1;
- static int minLength = 200;
- static std::string prefix;
- static std::string readsFile;
- static std::string outFile;
- static std::string discardFile;
- static std::string metricsFile;
-
- static LRAlignment::CutAlgorithm cutAlgorithm = LRAlignment::LRCA_DEFAULT;
- static int sampleRate = BWT::DEFAULT_SAMPLE_RATE_SMALL;
-}
-
-static const char* shortopts = "p:d:t:o:z:l:";
-
-enum { OPT_HELP = 1, OPT_VERSION, OPT_METRICS, OPT_DISCARD, OPT_LEARN, OPT_CUT };
-
-static const struct option longopts[] = {
- { "verbose", no_argument, NULL, 'v' },
- { "threads", required_argument, NULL, 't' },
- { "min-overlap", required_argument, NULL, 'm' },
- { "outfile", required_argument, NULL, 'o' },
- { "prefix", required_argument, NULL, 'p' },
- { "sample-rate", required_argument, NULL, 'd' },
- { "z-best", required_argument, NULL, 'z' },
- { "cut", required_argument, NULL, OPT_CUT },
- { "help", no_argument, NULL, OPT_HELP },
- { "version", no_argument, NULL, OPT_VERSION },
- { NULL, 0, NULL, 0 }
-};
-
-//
-// Main
-//
-int correctLongMain(int argc, char** argv)
-{
- parseCorrectLongOptions(argc, argv);
-
- BWT* pBWT = new BWT(opt::prefix + BWT_EXT, opt::sampleRate);
- BWT* pRBWT = new BWT(opt::prefix + RBWT_EXT, opt::sampleRate);
- SampledSuffixArray* pSSA = NULL;//new SampledSuffixArray(opt::prefix + SSA_EXT);
- std::ostream* pWriter = createWriter(opt::outFile);
-
- // Set the long read corrector options
- LRAlignment::LRParams alignParams;
- if(opt::zBest != -1)
- alignParams.zBest = opt::zBest;
-
- if(opt::cutAlgorithm != LRAlignment::LRCA_DEFAULT)
- alignParams.cutTailAlgorithm = opt::cutAlgorithm;
-
- LRCorrectionParameters params;
- params.pBWT = pBWT;
- params.pRBWT = pRBWT;
- params.pSSA = pSSA;
- params.alignParams = alignParams;
- params.minLength = opt::minLength;
-
- // Setup post-processor
- LRCorrectionPostProcess postProcessor(pWriter);
-
- if(opt::numThreads <= 1)
- {
- // Serial mode
- LRCorrectionProcess processor(params);
- PROCESS_LRC_SERIAL(opt::readsFile, &processor, &postProcessor);
- }
- else
- {
- // Parallel mode
- std::vector<LRCorrectionProcess*> processorVector;
- for(int i = 0; i < opt::numThreads; ++i)
- {
- LRCorrectionProcess* pProcessor = new LRCorrectionProcess(params);
- processorVector.push_back(pProcessor);
- }
-
- PROCESS_LRC_PARALLEL(opt::readsFile, processorVector, &postProcessor);
-
- for(int i = 0; i < opt::numThreads; ++i)
- {
- delete processorVector[i];
- }
- }
-
- delete pBWT;
- delete pRBWT;
- assert(pSSA == NULL);
- //delete pSSA;
- delete pWriter;
-
- if(opt::numThreads > 1)
- pthread_exit(NULL);
-
- return 0;
-}
-
-//
-// Handle command line arguments
-//
-void parseCorrectLongOptions(int argc, char** argv)
-{
- std::string algo_str;
- bool die = false;
- for (char c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;)
- {
- std::istringstream arg(optarg != NULL ? optarg : "");
- switch (c)
- {
- case 'l': arg >> opt::minLength; break;
- case 'p': arg >> opt::prefix; break;
- case 'o': arg >> opt::outFile; break;
- case 't': arg >> opt::numThreads; break;
- case 'd': arg >> opt::sampleRate; break;
- case '?': die = true; break;
- case 'v': opt::verbose++; break;
- case 'z': arg >> opt::zBest; break;
- case OPT_CUT: arg >> algo_str; break;
- case OPT_HELP:
- std::cout << CORRECT_LONG_USAGE_MESSAGE;
- exit(EXIT_SUCCESS);
- case OPT_VERSION:
- std::cout << CORRECT_LONG_VERSION_MESSAGE;
- exit(EXIT_SUCCESS);
- }
- }
-
- // Validate parameters
- if (argc - optind < 1)
- {
- std::cerr << SUBPROGRAM ": missing arguments\n";
- die = true;
- }
- else if (argc - optind > 1)
- {
- std::cerr << SUBPROGRAM ": too many arguments\n";
- die = true;
- }
-
- if(opt::numThreads <= 0)
- {
- std::cerr << SUBPROGRAM ": invalid number of threads: " << opt::numThreads << "\n";
- die = true;
- }
-
- if (die)
- {
- std::cout << "\n" << CORRECT_LONG_USAGE_MESSAGE;
- exit(EXIT_FAILURE);
- }
-
- // Parse the cut algorithm string
- if(!algo_str.empty())
- {
- if(algo_str == "zbest")
- opt::cutAlgorithm = LRAlignment::LRCA_Z_BEST;
- else if(algo_str == "strata")
- opt::cutAlgorithm = LRAlignment::LRCA_Z_BEST_STRATA;
- else if(algo_str == "score")
- opt::cutAlgorithm = LRAlignment::LRCA_SCORE_FRAC;
- else if(algo_str == "none")
- opt::cutAlgorithm = LRAlignment::LRCA_NONE;
- else
- {
- std::cerr << "Error: unrecognized cut algorithm " << algo_str << "\n";
- exit(EXIT_FAILURE);
- }
- }
-
- // Parse the input filenames
- opt::readsFile = argv[optind++];
-
- if(opt::prefix.empty())
- opt::prefix = stripFilename(opt::readsFile);
-
- std::string out_prefix = stripFilename(opt::readsFile);
- if(opt::outFile.empty())
- opt::outFile = out_prefix + ".ec.fa";
-}
26 src/SGA/correct-long.h
View
@@ -1,26 +0,0 @@
-//-----------------------------------------------
-// Copyright 2009 Wellcome Trust Sanger Institute
-// Written by Jared Simpson (js18@sanger.ac.uk)
-// Released under the GPL
-//-----------------------------------------------
-//
-// correct-long - Correct sequencing errors in long reads
-//
-#ifndef CORRECTLONG_H
-#define CORRECTLONG_H
-#include <getopt.h>
-#include "config.h"
-#include "BWT.h"
-#include "Match.h"
-#include "BWTAlgorithms.h"
-#include "OverlapAlgorithm.h"
-
-// functions
-
-//
-int correctLongMain(int argc, char** argv);
-
-// options
-void parseCorrectLongOptions(int argc, char** argv);
-
-#endif
4 src/SGA/sga.cpp
View
@@ -28,7 +28,6 @@
#include "filterBAM.h"
#include "cluster.h"
#include "gen-ssa.h"
-#include "correct-long.h"
#include "bwt2fa.h"
#include "graph-diff.h"
#include "hapgen.h"
@@ -77,7 +76,6 @@ static const char *SGA_USAGE_MESSAGE =
" stats print summary statistics about a read set\n"
" filterBAM filter out contaminating mate-pair data in a BAM file\n"
" cluster find clusters of reads belonging to the same connected component in an assembly graph\n"
-//" correct-long correct long reads\n"
//" connect resolve the complete sequence of a paired-end fragment\n"
//" var2vcf convert aligned variant sequences found by graph-diff into a VCF file\n"
//" hapgen generate candidate haplotypes from an assembly graph\n"
@@ -144,8 +142,6 @@ int main(int argc, char** argv)
clusterMain(argc - 1, argv + 1);
else if(command == "gen-ssa")
genSSAMain(argc - 1, argv + 1);
- else if(command == "correct-long")
- correctLongMain(argc - 1, argv + 1);
else if(command == "bwt2fa")
bwt2faMain(argc - 1, argv + 1);
else if(command == "graph-diff")
Please sign in to comment.
Something went wrong with that request. Please try again.