Commit upstream/2.2.4 - abyss

New upstream version 2.2.4 Michael R. Crusoe 4 years ago

28 changed file(s) with 3017 addition(s) and 2824 deletion(s). Raw diff Collapse all Expand all

+37

-32

ABYSS/abyss.cc less more

	0	#include "Assembly/Options.h"
0	1	#if PAIRED_DBG
1		# include "PairedDBG/SequenceCollection.h"
2		# include "PairedDBG/PairedDBGAlgorithms.h"
	2	#include "PairedDBG/PairedDBGAlgorithms.h"
	3	#include "PairedDBG/SequenceCollection.h"
3	4	#else
4		# include "Assembly/SequenceCollection.h"
	5	#include "Assembly/SequenceCollection.h"
5	6	#endif
6	7	#include "Assembly/AssemblyAlgorithms.h"
7	8	#include "Assembly/DotWriter.h"
	9	#include "DataBase/DB.h"
	10
8	11	#include <algorithm>
9	12	#include <cstdio> // for setvbuf
10	13	#include <fstream>
11	14	#include <iostream>
12	15	#include <sstream>
13		#include "DataBase/DB.h"
14	16
15	17	using namespace std;
16	18
17	19	DB db;
18	20
19		static void removeLowCoverageContigs(SequenceCollectionHash& g)
	21	static void
	22	removeLowCoverageContigs(SequenceCollectionHash& g)
20	23	{
21	24	AssemblyAlgorithms::markAmbiguous(&g);
22	25
23	26	cout << "Removing low-coverage contigs "
24		"(mean k-mer coverage < " << opt::coverage << ")\n";
	27	"(mean k-mer coverage < "
	28	<< opt::coverage << ")\n";
25	29	AssemblyAlgorithms::assemble(&g);
26	30	AssemblyAlgorithms::splitAmbiguous(&g);
27	31
28	32	opt::coverage = 0;
29	33	}
30	34
31		static void popBubbles(SequenceCollectionHash& g)
	35	static void
	36	popBubbles(SequenceCollectionHash& g)
32	37	{
33	38	cout << "Popping bubbles" << endl;
34	39	ofstream out;

38	43	cout << "Removed " << numPopped << " bubbles\n";
39	44	}
40	45
41		static void write_graph(const string& path,
42		const SequenceCollectionHash& c)
	46	static void
	47	write_graph(const string& path, const SequenceCollectionHash& c)
43	48	{
44	49	if (path.empty())
45	50	return;

48	53	DotWriter::write(out, c);
49	54	}
50	55
51		static void assemble(const string& pathIn, const string& pathOut)
	56	static void
	57	assemble(const string& pathIn, const string& pathOut)
52	58	{
53	59	Timer timer(__func__);
54	60	SequenceCollectionHash g;
55	61
56	62	if (!pathIn.empty())
57	63	AssemblyAlgorithms::loadSequences(&g, pathIn.c_str());
58		for_each(opt::inFiles.begin(), opt::inFiles.end(), bind1st(
59		ptr_fun(AssemblyAlgorithms::loadSequences<SequenceCollectionHash>),
60		&g));
	64	for_each(opt::inFiles.begin(), opt::inFiles.end(), [&g](std::string s) {
	65	AssemblyAlgorithms::loadSequences(&g, s);
	66	});
61	67	size_t numLoaded = g.size();
62	68	if (!opt::db.empty())
63	69	addToDb(db, "loadedKmer", numLoaded);

69	75	exit(EXIT_FAILURE);
70	76	}
71	77
72		AssemblyAlgorithms::setCoverageParameters(
73		AssemblyAlgorithms::coverageHistogram(g));
	78	AssemblyAlgorithms::setCoverageParameters(AssemblyAlgorithms::coverageHistogram(g));
74	79
75	80	if (opt::kc > 0) {
76	81	cout << "Minimum k-mer multiplicity kc is " << opt::kc << endl;
77	82	cout << "Removing low-multiplicity k-mers" << endl;
78	83	size_t removed = AssemblyAlgorithms::applyKmerCoverageThreshold(g, opt::kc);
79		cout << "Removed " << removed
80		<< " low-multiplicity k-mers, " << g.size()
81		<< " k-mers remaining" << std::endl;
	84	cout << "Removed " << removed << " low-multiplicity k-mers, " << g.size()
	85	<< " k-mers remaining" << std::endl;
82	86	}
83	87
84	88	cout << "Generating adjacency" << endl;

121	125
122	126	size_t numAssembled = g.size();
123	127	size_t numRemoved = numLoaded - numAssembled;
124		cout << "Removed " << numRemoved << " k-mer.\n"
125		"The signal-to-noise ratio (SNR) is "
126		<< 10 * log10((double)numAssembled / numRemoved)
127		<< " dB.\n";
	128	cout << "Removed " << numRemoved
	129	<< " k-mer.\n"
	130	"The signal-to-noise ratio (SNR) is "
	131	<< 10 * log10((double)numAssembled / numRemoved) << " dB.\n";
128	132	}
129	133
130		int main(int argc, char* const* argv)
	134	int
	135	main(int argc, char* const* argv)
131	136	{
132	137	Timer timer("Total");
133	138

141	146
142	147	bool krange = opt::kMin != opt::kMax;
143	148	if (krange)
144		cout << "Assembling k=" << opt::kMin << "-" << opt::kMax
145		<< ":" << opt::kStep << endl;
	149	cout << "Assembling k=" << opt::kMin << "-" << opt::kMax << ":" << opt::kStep << endl;
146	150
147	151	if (!opt::db.empty()) {
148		init(db,
149		opt::getUvalue(),
150		opt::getVvalue(),
151		"ABYSS",
152		opt::getCommand(),
153		opt::getMetaValue());
	152	init(
	153	db,
	154	opt::getUvalue(),
	155	opt::getVvalue(),
	156	"ABYSS",
	157	opt::getCommand(),
	158	opt::getMetaValue());
154	159	addToDb(db, "SS", opt::ss);
155	160	addToDb(db, "k", opt::kmerSize);
156	161	addToDb(db, "singleK", opt::singleKmerSize);

174	179	opt::erodeStrand = (unsigned)-1;
175	180	opt::coverage = -1;
176	181	opt::trimLen = k;
177		opt::bubbleLen = 3*k;
	182	opt::bubbleLen = 3 * k;
178	183	}
179	184
180	185	ostringstream k0, k1;

+184

-185

Assembly/BranchGroup.h less more

18	18	/** A container of BranchRecord. */
19	19	class BranchGroup
20	20	{
21		public:
22		typedef std::vector<BranchRecord> BranchGroupData;
23		typedef BranchGroupData::iterator iterator;
24		typedef BranchGroupData::const_iterator const_iterator;
25
26		BranchGroup()
27		: m_dir(SENSE), m_maxNumBranches(0),
28		m_noExt(false), m_status(BGS_ACTIVE)
29		{ }
30
31		BranchGroup(extDirection dir, size_t maxNumBranches,
32		const BranchRecord::V &origin)
33		: m_dir(dir), m_origin(origin),
34		m_maxNumBranches(maxNumBranches), m_noExt(false),
35		m_status(BGS_ACTIVE)
36		{
37		m_branches.reserve(m_maxNumBranches);
38		}
39
40		BranchGroup(extDirection dir, size_t maxNumBranches,
41		const BranchRecord::V &origin, const BranchRecord& branch)
42		: m_dir(dir), m_origin(origin),
43		m_maxNumBranches(maxNumBranches), m_noExt(false),
44		m_status(BGS_ACTIVE)
45		{
46		m_branches.reserve(m_maxNumBranches);
47		m_branches.push_back(branch);
48		}
49
50		BranchGroup(const BranchGroup& o)
51		: m_branches(o.m_branches), m_dir(o.m_dir),
52		m_origin(o.m_origin),
53		m_maxNumBranches(o.m_maxNumBranches),
54		m_noExt(o.m_noExt), m_status(o.m_status)
55		{
56		m_branches.reserve(m_maxNumBranches);
57		}
58
59		/** Add a branch to this group. */
60		BranchRecord& addBranch(const BranchRecord& branch)
61		{
62		assert(m_branches.size() < m_maxNumBranches);
63		m_branches.push_back(branch);
64		return m_branches.back();
65		}
66
67		/** Add a branch to this group and extend the new branch with
68		* the given k-mer. */
69		void addBranch(const BranchRecord& branch,
70		const BranchRecord::V& kmer)
71		{
72		if (m_branches.size() < m_maxNumBranches)
73		addBranch(branch).push_back(
74		std::make_pair(kmer, BranchRecord::VP()));
75		else
76		m_status = BGS_TOOMANYBRANCHES;
77		}
78
79		/** Return the specified branch. */
80		BranchRecord& operator [](unsigned id)
81		{
82		return m_branches[id];
83		}
84
85		/** Return the number of branches in this group. */
86		size_t size() const { return m_branches.size(); }
87
88		/** Return whether a branch contains the specified k-mer at
89		* the index i. */
90		bool exists(unsigned i, const BranchRecord::V& kmer) const
91		{
92		for (BranchGroupData::const_iterator it
93		= m_branches.begin();
94		it != m_branches.end(); ++it)
95		if (it->exists(i, kmer))
96		return true;
97		return false;
98		}
99
100		// return the current status of the branch
101		BranchGroupStatus getStatus() const { return m_status; }
102
103		// set the no extension flag
104		void setNoExtension() { m_noExt = true; }
105
106		// is the no extension flag set?
107		bool isNoExt() const { return m_noExt; }
108
109		// return the direction of growth
110		extDirection getDirection() const { return m_dir; }
111
112		iterator begin() { return m_branches.begin(); }
113		iterator end() { return m_branches.end(); }
114		const_iterator begin() const { return m_branches.begin(); }
115		const_iterator end() const { return m_branches.end(); }
116
117		// Check the stop conditions for the bubble growth
118		BranchGroupStatus
119		updateStatus(unsigned maxLength)
120		{
121		assert(m_branches.size() <= m_maxNumBranches);
122
123		if (m_status != BGS_ACTIVE)
124		return m_status;
125
126		// Check if the no extension flag is set
127		if(m_noExt)
128		{
129		m_status = BGS_NOEXT;
130		return m_status;
131		}
132
133		// Check if any branches are too long or any sequence has a loop
134		for (BranchGroupData::const_iterator iter = m_branches.begin();
135		iter != m_branches.end(); ++iter) {
136		if (iter->isTooLong(maxLength)) {
137		m_status = BGS_TOOLONG;
	21	public:
	22	typedef std::vector<BranchRecord> BranchGroupData;
	23	typedef BranchGroupData::iterator iterator;
	24	typedef BranchGroupData::const_iterator const_iterator;
	25
	26	BranchGroup()
	27	: m_dir(SENSE)
	28	, m_maxNumBranches(0)
	29	, m_noExt(false)
	30	, m_status(BGS_ACTIVE)
	31	{}
	32
	33	BranchGroup(extDirection dir, size_t maxNumBranches, const BranchRecord::V& origin)
	34	: m_dir(dir)
	35	, m_origin(origin)
	36	, m_maxNumBranches(maxNumBranches)
	37	, m_noExt(false)
	38	, m_status(BGS_ACTIVE)
	39	{
	40	m_branches.reserve(m_maxNumBranches);
	41	}
	42
	43	BranchGroup(
	44	extDirection dir,
	45	size_t maxNumBranches,
	46	const BranchRecord::V& origin,
	47	const BranchRecord& branch)
	48	: m_dir(dir)
	49	, m_origin(origin)
	50	, m_maxNumBranches(maxNumBranches)
	51	, m_noExt(false)
	52	, m_status(BGS_ACTIVE)
	53	{
	54	m_branches.reserve(m_maxNumBranches);
	55	m_branches.push_back(branch);
	56	}
	57
	58	BranchGroup(const BranchGroup& o)
	59	: m_branches(o.m_branches)
	60	, m_dir(o.m_dir)
	61	, m_origin(o.m_origin)
	62	, m_maxNumBranches(o.m_maxNumBranches)
	63	, m_noExt(o.m_noExt)
	64	, m_status(o.m_status)
	65	{
	66	m_branches.reserve(m_maxNumBranches);
	67	}
	68
	69	/** Add a branch to this group. */
	70	BranchRecord& addBranch(const BranchRecord& branch)
	71	{
	72	assert(m_branches.size() < m_maxNumBranches);
	73	m_branches.push_back(branch);
	74	return m_branches.back();
	75	}
	76
	77	/** Add a branch to this group and extend the new branch with
	78	* the given k-mer. */
	79	void addBranch(const BranchRecord& branch, const BranchRecord::V& kmer)
	80	{
	81	if (m_branches.size() < m_maxNumBranches)
	82	addBranch(branch).push_back(std::make_pair(kmer, BranchRecord::VP()));
	83	else
	84	m_status = BGS_TOOMANYBRANCHES;
	85	}
	86
	87	/** Return the specified branch. */
	88	BranchRecord& operator[](unsigned id) { return m_branches[id]; }
	89
	90	/** Return the number of branches in this group. */
	91	size_t size() const { return m_branches.size(); }
	92
	93	/** Return whether a branch contains the specified k-mer at
	94	* the index i. */
	95	bool exists(unsigned i, const BranchRecord::V& kmer) const
	96	{
	97	for (BranchGroupData::const_iterator it = m_branches.begin(); it != m_branches.end(); ++it)
	98	if (it->exists(i, kmer))
	99	return true;
	100	return false;
	101	}
	102
	103	// return the current status of the branch
	104	BranchGroupStatus getStatus() const { return m_status; }
	105
	106	// set the no extension flag
	107	void setNoExtension() { m_noExt = true; }
	108
	109	// is the no extension flag set?
	110	bool isNoExt() const { return m_noExt; }
	111
	112	// return the direction of growth
	113	extDirection getDirection() const { return m_dir; }
	114
	115	iterator begin() { return m_branches.begin(); }
	116	iterator end() { return m_branches.end(); }
	117	const_iterator begin() const { return m_branches.begin(); }
	118	const_iterator end() const { return m_branches.end(); }
	119
	120	// Check the stop conditions for the bubble growth
	121	BranchGroupStatus updateStatus(unsigned maxLength)
	122	{
	123	assert(m_branches.size() <= m_maxNumBranches);
	124
	125	if (m_status != BGS_ACTIVE)
	126	return m_status;
	127
	128	// Check if the no extension flag is set
	129	if (m_noExt) {
	130	m_status = BGS_NOEXT;
138	131	return m_status;
139	132	}
140		}
141
142		BranchGroupData::const_iterator it = m_branches.begin();
143		const BranchRecord::V& lastSeq = it->back().first;
144		while (++it != m_branches.end())
145		if (it->back().first != lastSeq)
146		return m_status = BGS_ACTIVE;
147
148		// All the branches of the bubble have joined.
149		// Remove the last base, which is identical for every branch.
150		std::for_each(m_branches.begin(), m_branches.end(),
151		std::mem_fun_ref(&BranchRecord::pop_back));
152
153		// Sort the branches by coverage.
154		sort_by_transform(m_branches.begin(), m_branches.end(),
155		std::mem_fun_ref(&BranchRecord::calculateBranchMultiplicity));
156		reverse(m_branches.begin(), m_branches.end());
157
158		return m_status = BGS_JOINED;
159		}
160
161		/** Return whether any branches of this group are active. */
162		bool
163		isActive() const
164		{
165		for (BranchGroupData::const_iterator it = m_branches.begin();
166		it != m_branches.end(); ++it)
167		if (it->isActive())
168		return true;
169		return false;
170		}
171
172		/** Return whether this branch is extendable. */
173		bool
174		isExtendable()
175		{
176		if (m_noExt)
	133
	134	// Check if any branches are too long or any sequence has a loop
	135	for (BranchGroupData::const_iterator iter = m_branches.begin(); iter != m_branches.end();
	136	++iter) {
	137	if (iter->isTooLong(maxLength)) {
	138	m_status = BGS_TOOLONG;
	139	return m_status;
	140	}
	141	}
	142
	143	BranchGroupData::const_iterator it = m_branches.begin();
	144	const BranchRecord::V& lastSeq = it->back().first;
	145	while (++it != m_branches.end())
	146	if (it->back().first != lastSeq)
	147	return m_status = BGS_ACTIVE;
	148
	149	// All the branches of the bubble have joined.
	150	// Remove the last base, which is identical for every branch.
	151	std::for_each(
	152	m_branches.begin(), m_branches.end(), [](BranchRecord& b) { return b.pop_back(); });
	153
	154	// Sort the branches by coverage.
	155	std::function<int(const BranchRecord&)> lambda = [](const BranchRecord& b) {
	156	return b.calculateBranchMultiplicity();
	157	};
	158	sort_by_transform(m_branches.begin(), m_branches.end(), lambda);
	159	reverse(m_branches.begin(), m_branches.end());
	160
	161	return m_status = BGS_JOINED;
	162	}
	163
	164	/** Return whether any branches of this group are active. */
	165	bool isActive() const
	166	{
	167	for (BranchGroupData::const_iterator it = m_branches.begin(); it != m_branches.end(); ++it)
	168	if (it->isActive())
	169	return true;
177	170	return false;
178
179		// A group is extendable when all the branches are the same
180		// length. All the branches are lockstepped for growth.
181		BranchGroupData::iterator it = m_branches.begin();
182		unsigned length = it++->size();
183		for (; it != m_branches.end(); ++it)
184		if (it->size() != length)
	171	}
	172
	173	/** Return whether this branch is extendable. */
	174	bool isExtendable()
	175	{
	176	if (m_noExt)
185	177	return false;
186		return true;
187		}
188
189		/** Return whether this branch is ambiguous at its origin. Also
190		* returns false if the origin of the branch has since been deleted.
191		*/
192		bool
193		isAmbiguous(const SequenceCollectionHash& g) const
194		{
195		// Get fresh data from the collection to check that this bubble
196		// does in fact still exist.
197		const BranchRecord::VP& data = g.getSeqAndData(m_origin).second;
198		return data.deleted() ? false : data.isAmbiguous(m_dir);
199		}
200
201		private:
202		BranchGroup& operator =(const BranchGroup& o);
203
204		BranchGroupData m_branches;
205		extDirection m_dir;
206		BranchRecord::V m_origin;
207		size_t m_maxNumBranches;
208		bool m_noExt;
209		BranchGroupStatus m_status;
	178
	179	// A group is extendable when all the branches are the same
	180	// length. All the branches are lockstepped for growth.
	181	BranchGroupData::iterator it = m_branches.begin();
	182	unsigned length = it++->size();
	183	for (; it != m_branches.end(); ++it)
	184	if (it->size() != length)
	185	return false;
	186	return true;
	187	}
	188
	189	/** Return whether this branch is ambiguous at its origin. Also
	190	* returns false if the origin of the branch has since been deleted.
	191	*/
	192	bool isAmbiguous(const SequenceCollectionHash& g) const
	193	{
	194	// Get fresh data from the collection to check that this bubble
	195	// does in fact still exist.
	196	const BranchRecord::VP& data = g.getSeqAndData(m_origin).second;
	197	return data.deleted() ? false : data.isAmbiguous(m_dir);
	198	}
	199
	200	private:
	201	BranchGroup& operator=(const BranchGroup& o);
	202
	203	BranchGroupData m_branches;
	204	extDirection m_dir;
	205	BranchRecord::V m_origin;
	206	size_t m_maxNumBranches;
	207	bool m_noExt;
	208	BranchGroupStatus m_status;
210	209	};
211	210
212	211	#endif

-1

Bloom/bloom.cc less more

98	98	" -n, --num-locks=N number of write locks on bloom filter [1000]\n"
99	99	" -q, --trim-quality=N trim bases from the ends of reads whose\n"
100	100	" quality is less than the threshold\n"
101		" -t, --bloom-type=STR 'konnector' or 'rolling-hash' [konnector]\n"
	101	" -t, --bloom-type=STR 'konnector', 'rolling-hash', or 'counting' [konnector]\n"
102	102	" --standard-quality zero quality is `!' (33)\n"
103	103	" default for FASTQ and SAM files\n"
104	104	" --illumina-quality zero quality is `@' (64)\n"

+31

-5

BloomDBG/bloom-dbg.h less more

90	90	}
91	91
92	92	/**
	93	* Returns the sum of all kmer multiplicities in `seq` by querying `bloom`
	94	*/
	95	template<typename CountingBloomT>
	96	inline static unsigned
	97	getSeqAbsoluteKmerCoverage(const Sequence& seq, const CountingBloomT& bloom)
	98	{
	99	const unsigned k = bloom.getKmerSize();
	100	const unsigned numHashes = bloom.getHashNum();
	101	assert(seq.length() >= k);
	102	unsigned coverage = 0;
	103	for (RollingHashIterator it(seq, numHashes, k); it != RollingHashIterator::end();
	104	++it) {
	105	coverage += bloom.minCount(*it);
	106	}
	107	return coverage;
	108	}
	109
	110	/**
93	111	* Translate a DNA sequence to an equivalent path in the
94	112	* de Bruijn graph.
95	113	*/

169	187	size_t contigID;
170	188	/** length of contig (bp) */
171	189	unsigned length;
	190	/** coverage of contig */
	191	unsigned coverage;
172	192	/** FASTA ID of seeding read */
173	193	std::string readID;
174	194	/** Type of sequence used to seed contig (branch k-mer or full read) */

432	452	inline static void
433	453	printContig(
434	454	const Sequence& seq,
	455	unsigned length,
	456	unsigned coverage,
435	457	size_t contigID,
436	458	const std::string& readID,
437	459	unsigned k,

447	469
448	470	/* add FASTA comment indicating extended read id */
449	471	std::ostringstream comment;
	472	comment << length << ' ' << coverage << ' ';
450	473	comment << "read:" << readID;
451	474	assert(id.good());
452	475	contig.id = id.str();

509	532	* Output a contig sequence if it is not redundant, i.e. it has not already
510	533	* been generated from a different read / thread of execution.
511	534	*/
512		template<typename AssembledKmerSetT, typename AssemblyStreamsT>
	535	template<typename SolidKmerSetT, typename AssembledKmerSetT, typename AssemblyStreamsT>
513	536	inline static void
514	537	outputContig(
515	538	const Path<Vertex>& contigPath,
516	539	ContigRecord& rec,
	540	SolidKmerSetT& solidKmerSet,
517	541	AssembledKmerSetT& assembledKmerSet,
518	542	KmerHash& contigEndKmers,
519	543	const AssemblyParams& params,

571	595	if (!redundant) {
572	596	#pragma omp critical(fasta)
573	597	{
	598	rec.length = seq.length();
	599	rec.coverage = getSeqAbsoluteKmerCoverage(seq, solidKmerSet);
	600
574	601	/* add contig to output FASTA */
575		printContig(seq, counters.contigID, rec.readID, params.k, streams.out);
	602	printContig(seq, rec.length, rec.coverage, counters.contigID, rec.readID, params.k, streams.out);
576	603
577	604	/* add contig to checkpoint FASTA file */
578	605	if (params.checkpointsEnabled())
579		printContig(seq, counters.contigID, rec.readID, params.k, streams.checkpointOut);
	606	printContig(seq, rec.length, rec.coverage, counters.contigID, rec.readID, params.k, streams.checkpointOut);
580	607
581	608	rec.contigID = counters.contigID;
582		rec.length = seq.length();
583	609
584	610	counters.contigID++;
585	611	counters.basesAssembled += seq.length();

841	867
842	868	/* output contig to FASTA file */
843	869	outputContig(
844		contigPath, contigRec, assembledKmerSet, contigEndKmers, params, counters, streams);
	870	contigPath, contigRec, solidKmerSet, assembledKmerSet, contigEndKmers, params, counters, streams);
845	871	}
846	872
847	873	/* mark contig k-mers as visited */

+17

-0

ChangeLog less more

	0	2020-01-30 Johnathan Wong <jowong@bcgsc.ca>
	1
	2	* Release version 2.2.4
	3
	4	General:
	5	* Refactor deprecated functions in clang-8
	6
	7	Sealer:
	8	* Remove unsupported -D option from help page
	9
	10	abyss-bloom:
	11	* Add counting Bloom Filter instruction to help page
	12
	13	abyss-bloom-dbg:
	14	* Report coverage information of unitigs
	15
	16
0	17	2019-09-20 Johnathan Wong <jowong@bcgsc.ca>
1	18
2	19	* Release version 2.2.3

+66

-76

FMIndex/BitArrays.h less more

22	22	static T SENTINEL() { return std::numeric_limits<T>::max(); }
23	23
24	24	public:
	25	/** Count the occurrences of the symbols of [first, last). */
	26	template<typename It>
	27	void assign(It first, It last)
	28	{
	29	assert(first < last);
	30	m_data.clear();
25	31
26		/** Count the occurrences of the symbols of [first, last). */
27		template<typename It>
28		void assign(It first, It last)
29		{
30		assert(first < last);
31		m_data.clear();
	32	// Determine the size of the alphabet ignoring the sentinel.
	33	T n = 0;
	34	for (It it = first; it != last; ++it)
	35	if (*it != SENTINEL())
	36	n = std::max(n, *it);
	37	n++;
32	38
33		// Determine the size of the alphabet ignoring the sentinel.
34		T n = 0;
35		for (It it = first; it != last; ++it)
36		if (*it != SENTINEL())
37		n = std::max(n, *it);
38		n++;
	39	assert(n < std::numeric_limits<T>::max());
	40	m_data.resize(n, wat_array::BitArray(last - first));
39	41
40		assert(n < std::numeric_limits<T>::max());
41		m_data.resize(n, wat_array::BitArray(last - first));
	42	size_t i = 0;
	43	for (It it = first; it != last; ++it, ++i) {
	44	T c = *it;
	45	if (c == SENTINEL())
	46	continue;
	47	assert(c < m_data.size());
	48	m_data[c].SetBit(1, i);
	49	}
42	50
43		size_t i = 0;
44		for (It it = first; it != last; ++it, ++i) {
45		T c = *it;
46		if (c == SENTINEL())
47		continue;
48		assert(c < m_data.size());
49		m_data[c].SetBit(1, i);
	51	std::for_each(
	52	m_data.begin(), m_data.end(), [](wat_array::BitArray& b) { return b.Build(); });
50	53	}
51	54
52		std::for_each(m_data.begin(), m_data.end(),
53		std::mem_fun_ref(&wat_array::BitArray::Build));
54		}
	55	/** Return the size of the string. */
	56	size_t size() const
	57	{
	58	assert(!m_data.empty());
	59	return m_data.front().length();
	60	}
55	61
56		/** Return the size of the string. */
57		size_t size() const
58		{
59		assert(!m_data.empty());
60		return m_data.front().length();
61		}
	62	/** Return the number of occurrences of the specified symbol. */
	63	size_t count(T c) const { return m_data[c].one_num(); }
62	64
63		/** Return the number of occurrences of the specified symbol. */
64		size_t count(T c) const
65		{
66		return m_data[c].one_num();
67		}
	65	/** Return the count of symbol c in s[0, i). */
	66	size_t rank(T c, size_t i) const { return m_data[c].Rank(1, i); }
68	67
69		/** Return the count of symbol c in s[0, i). */
70		size_t rank(T c, size_t i) const
71		{
72		return m_data[c].Rank(1, i);
73		}
	68	/** Return the symbol at the specified position. */
	69	T at(size_t i) const
	70	{
	71	assert(!m_data.empty());
	72	assert(i < m_data.front().length());
	73	for (Data::const_iterator it = m_data.begin(); it != m_data.end(); ++it)
	74	if (it->Lookup(i))
	75	return it - m_data.begin();
	76	return std::numeric_limits<T>::max();
	77	}
74	78
75		/** Return the symbol at the specified position. */
76		T at(size_t i) const
77		{
78		assert(!m_data.empty());
79		assert(i < m_data.front().length());
80		for (Data::const_iterator it = m_data.begin();
81		it != m_data.end(); ++it)
82		if (it->Lookup(i))
83		return it - m_data.begin();
84		return std::numeric_limits<T>::max();
85		}
	79	/** Store this data structure. */
	80	friend std::ostream& operator<<(std::ostream& out, const BitArrays& o)
	81	{
	82	uint32_t n = o.m_data.size();
	83	out.write(reinterpret_cast<char*>(&n), sizeof n);
	84	for (Data::const_iterator it = o.m_data.begin(); it != o.m_data.end(); ++it)
	85	it->Save(out);
	86	return out;
	87	}
86	88
87		/** Store this data structure. */
88		friend std::ostream& operator<<(std::ostream& out, const BitArrays& o)
89		{
90		uint32_t n = o.m_data.size();
91		out.write(reinterpret_cast<char*>(&n), sizeof n);
92		for (Data::const_iterator it = o.m_data.begin();
93		it != o.m_data.end(); ++it)
94		it->Save(out);
95		return out;
96		}
97
98		/** Load this data structure. */
99		friend std::istream& operator>>(std::istream& in, BitArrays& o)
100		{
101		o.m_data.clear();
102		uint32_t n = 0;
103		if (!in.read(reinterpret_cast<char*>(&n), sizeof n))
	89	/** Load this data structure. */
	90	friend std::istream& operator>>(std::istream& in, BitArrays& o)
	91	{
	92	o.m_data.clear();
	93	uint32_t n = 0;
	94	if (!in.read(reinterpret_cast<char*>(&n), sizeof n))
	95	return in;
	96	assert(n > 0);
	97	assert(n < std::numeric_limits<T>::max());
	98	o.m_data.resize(n);
	99	for (Data::iterator it = o.m_data.begin(); it != o.m_data.end(); ++it)
	100	it->Load(in);
104	101	return in;
105		assert(n > 0);
106		assert(n < std::numeric_limits<T>::max());
107		o.m_data.resize(n);
108		for (Data::iterator it = o.m_data.begin();
109		it != o.m_data.end(); ++it)
110		it->Load(in);
111		return in;
112		}
	102	}
113	103
114	104	private:
115	105	typedef std::vector<wat_array::BitArray> Data;

+283

-255

FilterGraph/FilterGraph.cc less more

8	8	#include "ContigPath.h"
9	9	#include "ContigProperties.h"
10	10	#include "FastaReader.h"
11		#include "IOUtil.h"
12		#include "Uncompress.h"
13	11	#include "Graph/ContigGraph.h"
14	12	#include "Graph/ContigGraphAlgorithms.h"
15	13	#include "Graph/DirectedGraph.h"
16	14	#include "Graph/GraphIO.h"
17	15	#include "Graph/GraphUtil.h"
	16	#include "IOUtil.h"
	17	#include "Uncompress.h"
	18	#include <algorithm>
18	19	#include <boost/lambda/bind.hpp>
19	20	#include <boost/lambda/lambda.hpp>
20		#include <algorithm>
21	21	#include <fstream>
22	22	#include <functional>
23	23	#include <getopt.h>

36	36	#define PROGRAM "abyss-filtergraph"
37	37
38	38	static const char VERSION_MESSAGE[] =
39		PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
40		"Written by Tony Raymond.\n"
41		"\n"
42		"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
	39	PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
	40	"Written by Tony Raymond.\n"
	41	"\n"
	42	"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
43	43
44	44	static const char USAGE_MESSAGE[] =
45		"Usage: " PROGRAM " -k<kmer> [OPTION]... ADJ [FASTA]\n"
46		"Remove short contigs that do not contribute any relevant\n"
47		"information to the assembly.\n"
48		"\n"
49		" Arguments:\n"
50		"\n"
51		" ADJ contig adjacency graph\n"
52		" FASTA contigs to check consistency of ADJ edges\n"
53		"\n"
54		" Options:\n"
55		"\n"
56		" -k, --kmer=N k-mer size\n"
57		" --SS expect contigs to be oriented correctly\n"
58		" --no-SS no assumption about contig orientation\n"
59		" -T, --island=N remove islands shorter than N [0]\n"
60		" -t, --tip=N remove tips shorter than N [0]\n"
61		" -l, --length=N remove contigs shorter than N [0]\n"
62		" -L, --max-length=N remove contigs longer than N [0]\n"
63		" -c, --coverage=FLOAT remove contigs with mean k-mer coverage less than FLOAT [0]\n"
64		" -C, --max-coverage=FLOAT remove contigs with mean k-mer coverage at least FLOAT [0]\n"
65		" --shim remove filler contigs that only contribute\n"
66		" to adjacency [default]\n"
67		" --no-shim disable filler contigs removal\n"
68		" --shim-max-degree=N only remove shims where the smaller of \n"
69		" in/out degree is smaller than N [1]\n"
70		" -m, --min-overlap=N require a minimum overlap of N bases [10]\n"
71		" --assemble assemble unambiguous paths\n"
72		" --no-assemble disable assembling of paths [default]\n"
73		" -g, --graph=FILE write the contig adjacency graph to FILE\n"
74		" -i, --ignore=FILE ignore contigs seen in FILE\n"
75		" -r, --remove=FILE remove contigs seen in FILE\n"
76		" --adj output the graph in ADJ format [default]\n"
77		" --asqg output the graph in ASQG format\n"
78		" --dot output the graph in GraphViz format\n"
79		" --gfa output the graph in GFA1 format\n"
80		" --gfa1 output the graph in GFA1 format\n"
81		" --gfa2 output the graph in GFA2 format\n"
82		" --gv output the graph in GraphViz format\n"
83		" --sam output the graph in SAM format\n"
84		" -v, --verbose display verbose output\n"
85		" --help display this help and exit\n"
86		" --version output version information and exit\n"
87		"\n"
88		"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
	45	"Usage: " PROGRAM " -k<kmer> [OPTION]... ADJ [FASTA]\n"
	46	"Remove short contigs that do not contribute any relevant\n"
	47	"information to the assembly.\n"
	48	"\n"
	49	" Arguments:\n"
	50	"\n"
	51	" ADJ contig adjacency graph\n"
	52	" FASTA contigs to check consistency of ADJ edges\n"
	53	"\n"
	54	" Options:\n"
	55	"\n"
	56	" -k, --kmer=N k-mer size\n"
	57	" --SS expect contigs to be oriented correctly\n"
	58	" --no-SS no assumption about contig orientation\n"
	59	" -T, --island=N remove islands shorter than N [0]\n"
	60	" -t, --tip=N remove tips shorter than N [0]\n"
	61	" -l, --length=N remove contigs shorter than N [0]\n"
	62	" -L, --max-length=N remove contigs longer than N [0]\n"
	63	" -c, --coverage=FLOAT remove contigs with mean k-mer coverage less than FLOAT [0]\n"
	64	" -C, --max-coverage=FLOAT remove contigs with mean k-mer coverage at least FLOAT [0]\n"
	65	" --shim remove filler contigs that only contribute\n"
	66	" to adjacency [default]\n"
	67	" --no-shim disable filler contigs removal\n"
	68	" --shim-max-degree=N only remove shims where the smaller of \n"
	69	" in/out degree is smaller than N [1]\n"
	70	" -m, --min-overlap=N require a minimum overlap of N bases [10]\n"
	71	" --assemble assemble unambiguous paths\n"
	72	" --no-assemble disable assembling of paths [default]\n"
	73	" -g, --graph=FILE write the contig adjacency graph to FILE\n"
	74	" -i, --ignore=FILE ignore contigs seen in FILE\n"
	75	" -r, --remove=FILE remove contigs seen in FILE\n"
	76	" --adj output the graph in ADJ format [default]\n"
	77	" --asqg output the graph in ASQG format\n"
	78	" --dot output the graph in GraphViz format\n"
	79	" --gfa output the graph in GFA1 format\n"
	80	" --gfa1 output the graph in GFA1 format\n"
	81	" --gfa2 output the graph in GFA2 format\n"
	82	" --gv output the graph in GraphViz format\n"
	83	" --sam output the graph in SAM format\n"
	84	" -v, --verbose display verbose output\n"
	85	" --help display this help and exit\n"
	86	" --version output version information and exit\n"
	87	"\n"
	88	"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
89	89
90	90	namespace opt {
91		unsigned k; // used by ContigProperties
92
93		/** Run a strand-specific RNA-Seq assembly. */
94		static int ss;
95
96		/** Remove island contigs less than this length. */
97		static unsigned minIslandLen = 0;
98
99		/** Remove tips less than this length. */
100		static unsigned minTipLen = 0;
101
102		/** Remove all contigs less than this length. */
103		static unsigned minLen = 0;
104
105		/** Remove all contigs more than this length. */
106		static unsigned maxLen = 0;
107
108		/** Remove contigs with mean k-mer coverage less than this threshold. */
109		static float minCoverage = 0;
110
111		/** Remove contigs with mean k-mer coverage at least this threshold. */
112		static float maxCoverage = 0;
113
114		/** Remove short contigs that don't contribute any sequence. */
115		static int shim = 1;
116
117		/** Only remove shims where the smaller of in/out degree is small
118		* enough. */
119		static unsigned shimMaxDegree = 1;
120
121		/** Assemble unambiguous paths. */
122		static int assemble = 0;
123
124		/** Write the contig adjacency graph to this file. */
125		static string graphPath;
126
127		/** Contigs to ignore. */
128		static string ignorePath;
129
130		/** Contigs to remove. */
131		static string removePath;
132
133		/** The minimum overlap allowed between two contigs. */
134		static int minOverlap = 10;
135
136		/** Output graph format. */
137		int format = ADJ; // used by ContigProperties
	91	unsigned k; // used by ContigProperties
	92
	93	/** Run a strand-specific RNA-Seq assembly. */
	94	static int ss;
	95
	96	/** Remove island contigs less than this length. */
	97	static unsigned minIslandLen = 0;
	98
	99	/** Remove tips less than this length. */
	100	static unsigned minTipLen = 0;
	101
	102	/** Remove all contigs less than this length. */
	103	static unsigned minLen = 0;
	104
	105	/** Remove all contigs more than this length. */
	106	static unsigned maxLen = 0;
	107
	108	/** Remove contigs with mean k-mer coverage less than this threshold. */
	109	static float minCoverage = 0;
	110
	111	/** Remove contigs with mean k-mer coverage at least this threshold. */
	112	static float maxCoverage = 0;
	113
	114	/** Remove short contigs that don't contribute any sequence. */
	115	static int shim = 1;
	116
	117	/** Only remove shims where the smaller of in/out degree is small
	118	* enough. */
	119	static unsigned shimMaxDegree = 1;
	120
	121	/** Assemble unambiguous paths. */
	122	static int assemble = 0;
	123
	124	/** Write the contig adjacency graph to this file. */
	125	static string graphPath;
	126
	127	/** Contigs to ignore. */
	128	static string ignorePath;
	129
	130	/** Contigs to remove. */
	131	static string removePath;
	132
	133	/** The minimum overlap allowed between two contigs. */
	134	static int minOverlap = 10;
	135
	136	/** Output graph format. */
	137	int format = ADJ; // used by ContigProperties
138	138	}
139	139
140	140	static const char shortopts[] = "c:C:g:i:r:k:l:L:m:t:T:v";
141	141
142		enum { OPT_HELP = 1, OPT_VERSION, OPT_SHIM_MAX_DEG };
	142	enum
	143	{
	144	OPT_HELP = 1,
	145	OPT_VERSION,
	146	OPT_SHIM_MAX_DEG
	147	};
143	148
144	149	static const struct option longopts[] = {
145		{ "adj", no_argument, &opt::format, ADJ },
146		{ "asqg", no_argument, &opt::format, ASQG },
147		{ "dot", no_argument, &opt::format, DOT },
148		{ "gfa", no_argument, &opt::format, GFA1 },
149		{ "gfa1", no_argument, &opt::format, GFA1 },
150		{ "gfa2", no_argument, &opt::format, GFA2 },
151		{ "gv", no_argument, &opt::format, DOT },
152		{ "sam", no_argument, &opt::format, SAM },
153		{ "graph", required_argument, NULL, 'g' },
154		{ "ignore", required_argument, NULL, 'i' },
155		{ "remove", required_argument, NULL, 'r' },
156		{ "SS", no_argument, &opt::ss, 1 },
157		{ "no-SS", no_argument, &opt::ss, 0 },
158		{ "kmer", required_argument, NULL, 'k' },
159		{ "island", required_argument, NULL, 'T' },
160		{ "tip", required_argument, NULL, 't' },
161		{ "length", required_argument, NULL, 'l' },
162		{ "max-length", required_argument, NULL, 'L' },
163		{ "coverage", required_argument, NULL, 'c' },
164		{ "max-coverage", required_argument, NULL, 'C' },
165		{ "shim", no_argument, &opt::shim, 1 },
166		{ "no-shim", no_argument, &opt::shim, 0 },
	150	{ "adj", no_argument, &opt::format, ADJ },
	151	{ "asqg", no_argument, &opt::format, ASQG },
	152	{ "dot", no_argument, &opt::format, DOT },
	153	{ "gfa", no_argument, &opt::format, GFA1 },
	154	{ "gfa1", no_argument, &opt::format, GFA1 },
	155	{ "gfa2", no_argument, &opt::format, GFA2 },
	156	{ "gv", no_argument, &opt::format, DOT },
	157	{ "sam", no_argument, &opt::format, SAM },
	158	{ "graph", required_argument, NULL, 'g' },
	159	{ "ignore", required_argument, NULL, 'i' },
	160	{ "remove", required_argument, NULL, 'r' },
	161	{ "SS", no_argument, &opt::ss, 1 },
	162	{ "no-SS", no_argument, &opt::ss, 0 },
	163	{ "kmer", required_argument, NULL, 'k' },
	164	{ "island", required_argument, NULL, 'T' },
	165	{ "tip", required_argument, NULL, 't' },
	166	{ "length", required_argument, NULL, 'l' },
	167	{ "max-length", required_argument, NULL, 'L' },
	168	{ "coverage", required_argument, NULL, 'c' },
	169	{ "max-coverage", required_argument, NULL, 'C' },
	170	{ "shim", no_argument, &opt::shim, 1 },
	171	{ "no-shim", no_argument, &opt::shim, 0 },
167	172	{ "shim-max-degree", required_argument, NULL, OPT_SHIM_MAX_DEG },
168		{ "assemble", no_argument, &opt::assemble, 1 },
169		{ "no-assemble", no_argument, &opt::assemble, 0 },
170		{ "min-overlap", required_argument, NULL, 'm' },
171		{ "verbose", no_argument, NULL, 'v' },
172		{ "help", no_argument, NULL, OPT_HELP },
173		{ "version", no_argument, NULL, OPT_VERSION },
	173	{ "assemble", no_argument, &opt::assemble, 1 },
	174	{ "no-assemble", no_argument, &opt::assemble, 0 },
	175	{ "min-overlap", required_argument, NULL, 'm' },
	176	{ "verbose", no_argument, NULL, 'v' },
	177	{ "help", no_argument, NULL, OPT_HELP },
	178	{ "version", no_argument, NULL, OPT_VERSION },
174	179	{ NULL, 0, NULL, 0 }
175	180	};
176	181
177	182	static vector<ContigID> g_removed;
178	183
179	184	/** Contig adjacency graph. */
180		typedef ContigGraph<DirectedGraph<ContigProperties, Distance> > Graph;
	185	typedef ContigGraph<DirectedGraph<ContigProperties, Distance>> Graph;
181	186	typedef Graph::vertex_descriptor vertex_descriptor;
182	187	typedef Graph::edge_descriptor edge_descriptor;
183	188
184	189	/** Data for verbose output. */
185		static struct {
	190	static struct
	191	{
186	192	unsigned removed;
187	193	unsigned tails;
188	194	unsigned too_long;

193	199	} g_count;
194	200
195	201	/** Returns if the contig can be removed from the graph. */
196		static bool removable(const Graph* pg, vertex_descriptor v)
	202	static bool
	203	removable(const Graph* pg, vertex_descriptor v)
197	204	{
198	205	typedef graph_traits<Graph> GTraits;
199	206	typedef GTraits::out_edge_iterator OEit;

247	254	if (g[maxvw].distance < g[vw].distance)
248	255	maxvw = vw;
249	256
250		if (g[maxuv].distance + (int)g[v].length + g[maxvw].distance >
251		-opt::minOverlap) {
	257	if (g[maxuv].distance + (int)g[v].length + g[maxvw].distance > -opt::minOverlap) {
252	258	g_count.too_long++;
253	259	return false;
254	260	}

256	262	}
257	263
258	264	/** Data to store information of an edge. */
259		struct EdgeInfo {
	265	struct EdgeInfo
	266	{
260	267	vertex_descriptor u;
261	268	vertex_descriptor w;
262	269	edge_bundle_type<Graph>::type ep;
263	270
264	271	EdgeInfo(vertex_descriptor u, vertex_descriptor w, int ep)
265		: u(u), w(w), ep(ep) {}
266		EdgeInfo() : u(), w(), ep() {}
	272	: u(u)
	273	, w(w)
	274	, ep(ep)
	275	{}
	276	EdgeInfo()
	277	: u()
	278	, w()
	279	, ep()
	280	{}
267	281	};
268	282
269	283	/** Returns a list of edges that may be added when the vertex v is
270	284	* removed. */
271		static bool findNewEdges(const Graph& g, vertex_descriptor v,
272		vector<EdgeInfo>& eds, vector<bool>& markedContigs)
	285	static bool
	286	findNewEdges(
	287	const Graph& g,
	288	vertex_descriptor v,
	289	vector<EdgeInfo>& eds,
	290	vector<bool>& markedContigs)
273	291	{
274	292	typedef graph_traits<Graph> GTraits;
275	293	typedef GTraits::vertex_descriptor V;

287	305	// for every edge from u->v and v->w we must add an edge u->w
288	306	for (IEit uv = iei0; uv != iei1; ++uv) {
289	307	for (OEit vw = oei0; vw != oei1; ++vw) {
290		int x = g[*uv].distance + (int)g[v].length +
291		g[*vw].distance;
	308	int x = g[uv].distance + (int)g[v].length + g[vw].distance;
292	309	assert(x <= 0);
293	310	EdgeInfo ed(source(uv, g), target(vw, g), x);
294	311	eds.push_back(ed);

298	315	marked.push_back(ed.w);
299	316	}
300	317	}
301		for (vector<V>::const_iterator it = marked.begin();
302		it != marked.end(); it++)
	318	for (vector<V>::const_iterator it = marked.begin(); it != marked.end(); it++)
303	319	markedContigs[get(vertex_index, g, *it)] = true;
304	320	return true;
305	321	}
306	322
307	323	/** Adds all edges described in the vector eds. */
308		static void addNewEdges(Graph& g, const vector<EdgeInfo>& eds)
309		{
310		for (vector<EdgeInfo>::const_iterator edsit = eds.begin();
311		edsit != eds.end(); ++edsit) {
	324	static void
	325	addNewEdges(Graph& g, const vector<EdgeInfo>& eds)
	326	{
	327	for (vector<EdgeInfo>::const_iterator edsit = eds.begin(); edsit != eds.end(); ++edsit) {
312	328	// Don't add parallel edges! This can happen when removing a palindrome.
313	329	if (edge(edsit->u, edsit->w, g).second) {
314	330	g_count.parallel_edge++;

319	335	}
320	336	}
321	337
322		static void removeContig(vertex_descriptor v, Graph& g)
323		{
324		clear_vertex(v, g);
325		remove_vertex(v, g);
326		g_removed.push_back(get(vertex_contig_index, g, v));
327		g_count.removed++;
	338	static void
	339	removeContig(vertex_descriptor v, Graph& g)
	340	{
	341	clear_vertex(v, g);
	342	remove_vertex(v, g);
	343	g_removed.push_back(get(vertex_contig_index, g, v));
	344	g_count.removed++;
328	345	}
329	346
330	347	/** Remove the specified contig from the adjacency graph. */
331		static void removeContigs(Graph& g, vector<vertex_descriptor>& sc)
	348	static void
	349	removeContigs(Graph& g, vector<vertex_descriptor>& sc)
332	350	{
333	351	typedef graph_traits<Graph> GTraits;
334	352	typedef GTraits::vertex_descriptor V;

337	355	out.reserve(sc.size());
338	356
339	357	vector<bool> markedContigs(g.num_vertices());
340		for (vector<vertex_descriptor>::iterator it = sc.begin();
341		it != sc.end(); ++it) {
	358	for (vector<vertex_descriptor>::iterator it = sc.begin(); it != sc.end(); ++it) {
342	359	V v = *it;
343	360	if (opt::verbose > 0 && ++g_count.checked % 10000000 == 0)
344		cerr << "Removed " << g_count.removed << "/"
345		<< g_count.checked
346		<< " vertices that have been checked.\n";
	361	cerr << "Removed " << g_count.removed << "/" << g_count.checked
	362	<< " vertices that have been checked.\n";
347	363
348	364	if (markedContigs[get(vertex_index, g, v)]) {
349	365	out.push_back(v);

365	381	}
366	382
367	383	/** Return the value of the bit at the specified index. */
368		struct Marked : unary_function<vertex_descriptor, bool> {
	384	struct Marked : unary_function<vertex_descriptor, bool>
	385	{
369	386	typedef vector<bool> Data;
370	387	Marked(const Graph& g, const Data& data)
371		: m_g(g), m_data(data) { }
372		bool operator()(vertex_descriptor u) const
373		{
374		return m_data[get(vertex_contig_index, m_g, u)];
375		}
	388	: m_g(g)
	389	, m_data(data)
	390	{}
	391	bool operator()(vertex_descriptor u) const { return m_data[get(vertex_contig_index, m_g, u)]; }
	392
376	393	private:
377	394	const Graph& m_g;
378	395	const Data& m_data;
379	396	};
380	397
381	398	/** Finds all potentially removable contigs in the graph. */
382		static void findShortContigs(const Graph& g, const vector<bool>& seen,
383		vector<vertex_descriptor>& sc)
	399	static void
	400	findShortContigs(const Graph& g, const vector<bool>& seen, vector<vertex_descriptor>& sc)
384	401	{
385	402	typedef graph_traits<Graph> GTraits;
386	403	typedef GTraits::vertex_iterator Vit;
387	404	Vit first, second;
388	405	tie(first, second) = vertices(g);
389		::copy_if(first, second, back_inserter(sc),
390		!boost::lambda::bind(Marked(g, seen), _1) && boost::lambda::bind(removable, &g, _1));
	406	::copy_if(
	407	first,
	408	second,
	409	back_inserter(sc),
	410	!boost::lambda::bind(Marked(g, seen), _1) && boost::lambda::bind(removable, &g, _1));
391	411	}
392	412
393	413	/** Functor used for sorting contigs based on degree, then size,
394	414	* and then ID. */
395		struct sortContigs {
	415	struct sortContigs
	416	{
396	417	const Graph& g;
397	418
398		sortContigs(const Graph& g) : g(g) {}
399
400		template <typename V>
401		bool operator() (V a, V b)
	419	sortContigs(const Graph& g)
	420	: g(g)
	421	{}
	422
	423	template<typename V>
	424	bool operator()(V a, V b)
402	425	{
403	426	const ContigProperties& ap = g[a];
404	427	const ContigProperties& bp = g[b];

406	429	unsigned dega = out_degree(a, g) * in_degree(a, g);
407	430	unsigned degb = out_degree(b, g) * in_degree(b, g);
408	431
409		return dega != degb ? dega < degb
410		: ap.length != bp.length ? ap.length < bp.length
411		: a < b;
	432	return dega != degb ? dega < degb : ap.length != bp.length ? ap.length < bp.length : a < b;
412	433	}
413	434	};
414	435
415		struct ShorterThanX : unary_function<vertex_descriptor, bool> {
	436	struct ShorterThanX : unary_function<vertex_descriptor, bool>
	437	{
416	438	const Graph& g;
417	439	const vector<bool>& seen;
418	440	size_t x;
419	441
420	442	ShorterThanX(const Graph& g, const vector<bool>& seen, size_t x)
421		: g(g), seen(seen), x(x) { }
	443	: g(g)
	444	, seen(seen)
	445	, x(x)
	446	{}
422	447
423	448	bool operator()(vertex_descriptor y) const
424	449	{
425		return g[y].length < x && !get(vertex_removed, g, y)
426		&& !seen[get(vertex_contig_index, g, y)];
	450	return g[y].length < x && !get(vertex_removed, g, y) &&
	451	!seen[get(vertex_contig_index, g, y)];
427	452	}
428	453	};
429	454
430		struct LongerThanX : unary_function<vertex_descriptor, bool> {
	455	struct LongerThanX : unary_function<vertex_descriptor, bool>
	456	{
431	457	const Graph& g;
432	458	const vector<bool>& seen;
433	459	size_t x;
434	460
435	461	LongerThanX(const Graph& g, const vector<bool>& seen, size_t x)
436		: g(g), seen(seen), x(x) { }
	462	: g(g)
	463	, seen(seen)
	464	, x(x)
	465	{}
437	466
438	467	bool operator()(vertex_descriptor y) const
439	468	{
440		return g[y].length > x && !get(vertex_removed, g, y)
441		&& !seen[get(vertex_contig_index, g, y)];
	469	return g[y].length > x && !get(vertex_removed, g, y) &&
	470	!seen[get(vertex_contig_index, g, y)];
442	471	}
443	472	};
444	473
445		struct CoverageLessThan : unary_function<vertex_descriptor, bool> {
	474	struct CoverageLessThan : unary_function<vertex_descriptor, bool>
	475	{
446	476	const Graph& g;
447	477	const vector<bool>& seen;
448	478	float minCov;
449	479
450	480	CoverageLessThan(const Graph& g, const vector<bool>& seen, float minCov)
451		: g(g), seen(seen), minCov(minCov) { }
	481	: g(g)
	482	, seen(seen)
	483	, minCov(minCov)
	484	{}
452	485
453	486	bool operator()(vertex_descriptor u) const
454	487	{
455	488	assert(opt::k > 0);
456	489	float meanCoverage = (float)g[u].coverage / (g[u].length - opt::k + 1);
457		return meanCoverage < minCov && !get(vertex_removed, g, u)
458		&& !seen[get(vertex_contig_index, g, u)];
	490	return meanCoverage < minCov && !get(vertex_removed, g, u) &&
	491	!seen[get(vertex_contig_index, g, u)];
459	492	}
460	493	};
461	494
462		static void removeShims(Graph& g, const vector<bool>& seen)
	495	static void
	496	removeShims(Graph& g, const vector<bool>& seen)
463	497	{
464	498	if (opt::verbose > 0)
465	499	cerr << "Removing shim contigs from the graph...\n";

467	501	findShortContigs(g, seen, shortContigs);
468	502	for (unsigned i = 0; !shortContigs.empty(); ++i) {
469	503	if (opt::verbose > 0)
470		cerr << "Pass " << i + 1 << ": Checking "
471		<< shortContigs.size() << " contigs.\n";
472		sort(shortContigs.begin(), shortContigs.end(),
473		sortContigs(g));
	504	cerr << "Pass " << i + 1 << ": Checking " << shortContigs.size() << " contigs.\n";
	505	sort(shortContigs.begin(), shortContigs.end(), sortContigs(g));
474	506	removeContigs(g, shortContigs);
475	507	}
476	508	if (opt::verbose > 0) {
477	509	cerr << "Shim removal stats:\n";
478		cerr << "Removed: " << g_count.removed/2
479		<< " Too Complex: " << g_count.too_complex/2
480		<< " Tails: " << g_count.tails/2
481		<< " Too Long: " << g_count.too_long/2
482		<< " Self Adjacent: " << g_count.self_adj/2
483		<< " Parallel Edges: " << g_count.parallel_edge/2 << '\n';
484		}
485		}
486
487		template <typename pred>
488		static void removeContigs_if(Graph& g, pred p)
	510	cerr << "Removed: " << g_count.removed / 2 << " Too Complex: " << g_count.too_complex / 2
	511	<< " Tails: " << g_count.tails / 2 << " Too Long: " << g_count.too_long / 2
	512	<< " Self Adjacent: " << g_count.self_adj / 2
	513	<< " Parallel Edges: " << g_count.parallel_edge / 2 << '\n';
	514	}
	515	}
	516
	517	template<typename pred>
	518	static void
	519	removeContigs_if(Graph& g, pred p)
489	520	{
490	521	typedef graph_traits<Graph> GTraits;
491	522	typedef GTraits::vertex_iterator Vit;

495	526	vector<V> sc;
496	527	::copy_if(first, second, back_inserter(sc), p);
497	528	remove_vertex_if(g, sc.begin(), sc.end(), True<V>());
498		transform(sc.begin(), sc.end(), back_inserter(g_removed),
499		mem_fun_ref(&ContigNode::contigIndex));
	529	transform(sc.begin(), sc.end(), back_inserter(g_removed), [](const ContigNode& c) {
	530	return c.contigIndex();
	531	});
500	532	if (opt::verbose > 0)
501		cerr << "Removed " << sc.size()/2 << " contigs.\n";
	533	cerr << "Removed " << sc.size() / 2 << " contigs.\n";
502	534	}
503	535
504	536	/** Contig sequences. */

506	538	static Contigs g_contigs;
507	539
508	540	/** Return the sequence of vertex u. */
509		static string getSequence(const Graph& g, vertex_descriptor u)
	541	static string
	542	getSequence(const Graph& g, vertex_descriptor u)
510	543	{
511	544	size_t i = get(vertex_contig_index, g, u);
512	545	assert(i < g_contigs.size());

515	548	}
516	549
517	550	/** Return whether the specified edge is inconsistent. */
518		struct is_edge_inconsistent : unary_function<edge_descriptor, bool> {
	551	struct is_edge_inconsistent : unary_function<edge_descriptor, bool>
	552	{
519	553	const Graph& g;
520	554
521	555	is_edge_inconsistent(const Graph& g)
522		: g(g) { }
	556	: g(g)
	557	{}
523	558
524	559	bool operator()(edge_descriptor e) const
525	560	{

540	575	}
541	576	};
542	577
543		template <typename It>
544		static void remove_edge(Graph& g, It first, It last)
	578	template<typename It>
	579	static void
	580	remove_edge(Graph& g, It first, It last)
545	581	{
546	582	for (; first != last; first++)
547	583	remove_edge(*first, g);
548	584	}
549	585
550	586	template<typename pred>
551		static void removeEdges_if(Graph& g, pred p)
	587	static void
	588	removeEdges_if(Graph& g, pred p)
552	589	{
553	590	typedef graph_traits<Graph> GTraits;
554	591	typedef GTraits::edge_iterator Eit;

564	601	}
565	602	}
566	603
567		int main(int argc, char** argv)
	604	int
	605	main(int argc, char** argv)
568	606	{
569	607	string commandLine;
570	608	{
571	609	ostringstream ss;
572	610	char** last = argv + argc - 1;
573		copy(argv, last, ostream_iterator<const char *>(ss, " "));
	611	copy(argv, last, ostream_iterator<const char*>(ss, " "));
574	612	ss << *last;
575	613	commandLine = ss.str();
576	614	}
577	615
578	616	bool die = false;
579		for (int c; (c = getopt_long(argc, argv,
580		shortopts, longopts, NULL)) != -1;) {
	617	for (int c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) {
581	618	istringstream arg(optarg != NULL ? optarg : "");
582	619	switch (c) {
583		case '?':
	620	case '?':
584	621	die = true;
585	622	break;
586		case 'c':
	623	case 'c':
587	624	arg >> opt::minCoverage;
588	625	break;
589		case 'C':
	626	case 'C':
590	627	arg >> opt::maxCoverage;
591	628	break;
592		case 'l':
	629	case 'l':
593	630	arg >> opt::minLen;
594	631	break;
595		case 'L':
	632	case 'L':
596	633	arg >> opt::maxLen;
597	634	break;
598		case 'm':
	635	case 'm':
599	636	arg >> opt::minOverlap;
600	637	break;
601		case 'g':
	638	case 'g':
602	639	arg >> opt::graphPath;
603	640	break;
604		case 'i':
	641	case 'i':
605	642	arg >> opt::ignorePath;
606	643	break;
607		case 'r':
	644	case 'r':
608	645	arg >> opt::removePath;
609	646	break;
610		case 'k':
	647	case 'k':
611	648	arg >> opt::k;
612	649	break;
613		case 'T':
	650	case 'T':
614	651	arg >> opt::minIslandLen;
615	652	break;
616		case 't':
	653	case 't':
617	654	arg >> opt::minTipLen;
618	655	break;
619		case 'v':
	656	case 'v':
620	657	opt::verbose++;
621	658	break;
622		case OPT_SHIM_MAX_DEG:
	659	case OPT_SHIM_MAX_DEG:
623	660	arg >> opt::shimMaxDegree;
624	661	break;
625		case OPT_HELP:
	662	case OPT_HELP:
626	663	cout << USAGE_MESSAGE;
627	664	exit(EXIT_SUCCESS);
628		case OPT_VERSION:
	665	case OPT_VERSION:
629	666	cout << VERSION_MESSAGE;
630	667	exit(EXIT_SUCCESS);
631	668	}
632	669	if (optarg != NULL && !arg.eof()) {
633		cerr << PROGRAM ": invalid option: `-"
634		<< (char)c << optarg << "'\n";
	670	cerr << PROGRAM ": invalid option: `-" << (char)c << optarg << "'\n";
635	671	exit(EXIT_FAILURE);
636	672	}
637	673	}
638	674
639	675	if (opt::minOverlap < 0) {
640	676	cerr << PROGRAM ": "
641		<< "--min-overlap must be a positive integer.\n";
	677	<< "--min-overlap must be a positive integer.\n";
642	678	die = true;
643	679	}
644	680
645	681	if (opt::k <= 0) {
646		cerr << PROGRAM ": " << "missing -k,--kmer option\n";
	682	cerr << PROGRAM ": "
	683	<< "missing -k,--kmer option\n";
647	684	die = true;
648	685	}
649	686

658	695	}
659	696
660	697	if (die) {
661		cerr << "Try `" << PROGRAM
662		<< " --help' for more information.\n";
	698	cerr << "Try `" << PROGRAM << " --help' for more information.\n";
663	699	exit(EXIT_FAILURE);
664	700	}
665	701

668	704	{
669	705	string adjPath(argv[optind++]);
670	706	if (opt::verbose > 0)
671		cerr << "Loading graph from file: " << adjPath
672		<< '\n';
	707	cerr << "Loading graph from file: " << adjPath << '\n';
673	708	ifstream fin(adjPath.c_str());
674	709	assert_good(fin, adjPath);
675	710	fin >> g;

697	732	size_t b = g_removed.size();
698	733	while (in >> s) {
699	734	size_t i = get(g_contigNames, s);
700		removeContig(ContigNode(i,0), g);
	735	removeContig(ContigNode(i, 0), g);
701	736	}
702	737	assert(in.eof());
703	738	if (opt::verbose)
704		cerr << "Removed " << g_removed.size() - b
705		<< " contigs.\n";
	739	cerr << "Removed " << g_removed.size() - b << " contigs.\n";
706	740	}
707	741
708	742	// Remove shims.

712	746	// Remove islands.
713	747	if (opt::minIslandLen > 0) {
714	748	size_t s = g_removed.size();
715		removeIslands_if(g, back_inserter(g_removed),
716		ShorterThanX(g, seen, opt::minIslandLen));
	749	removeIslands_if(g, back_inserter(g_removed), ShorterThanX(g, seen, opt::minIslandLen));
717	750	if (opt::verbose)
718		cerr << "Removed " << g_removed.size() - s
719		<< " islands.\n";
	751	cerr << "Removed " << g_removed.size() - s << " islands.\n";
720	752	}
721	753
722	754	// Remove tips.

725	757	s = g_removed.size();
726	758	do {
727	759	prev = g_removed.size();
728		pruneTips_if(g, back_inserter(g_removed),
729		ShorterThanX(g, seen, opt::minTipLen));
	760	pruneTips_if(g, back_inserter(g_removed), ShorterThanX(g, seen, opt::minTipLen));
730	761	} while (prev < g_removed.size());
731	762	if (opt::verbose)
732		cerr << "Removed " << g_removed.size() - s
733		<< " tips.\n";
	763	cerr << "Removed " << g_removed.size() - s << " tips.\n";
734	764	}
735	765
736	766	// Remove short contigs.

747	777
748	778	// Remove contigs with high mean k-mer coverage.
749	779	if (opt::maxCoverage > 0)
750		removeContigs_if(g,
751		std::not1(CoverageLessThan(g, seen, opt::maxCoverage)));
	780	removeContigs_if(g, std::not1(CoverageLessThan(g, seen, opt::maxCoverage)));
752	781
753	782	// Remove inconsistent edges of spaceseeds
754	783	if (argc - optind == 1) {

792	821	else
793	822	assemble(g, back_inserter(paths));
794	823	g_contigNames.unlock();
795		for (ContigPaths::const_iterator it = paths.begin();
796		it != paths.end(); ++it) {
	824	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
797	825	ContigNode u(numContigs + it - paths.begin(), false);
798	826	string name = createContigName();
799	827	put(vertex_name, g, u, name);

+99

-104

Graph/ContigGraphAlgorithms.h less more

6	6	#include "Common/Functional.h"
7	7	#include "Common/Iterator.h"
8	8	#include "Graph/ContigGraph.h"
	9	#include <algorithm>
9	10	#include <boost/graph/graph_traits.hpp>
10		#include <algorithm>
11	11	#include <cassert>
12	12	#include <functional>
13	13	#include <set>

17	17
18	18	/** Return true if the edge e is a palindrome. */
19	19	template<typename Graph>
20		struct IsPalindrome : std::unary_function<
21		typename graph_traits<Graph>::edge_descriptor, bool>
22		{
23		IsPalindrome(const Graph& g) : m_g(g) { }
24		bool operator()(
25		typename graph_traits<Graph>::edge_descriptor e) const
	20	struct IsPalindrome : std::unary_function<typename graph_traits<Graph>::edge_descriptor, bool>
	21	{
	22	IsPalindrome(const Graph& g)
	23	: m_g(g)
	24	{}
	25	bool operator()(typename graph_traits<Graph>::edge_descriptor e) const
26	26	{
27		return source(e, m_g)
28		== get(vertex_complement, m_g, target(e, m_g));
29		}
	27	return source(e, m_g) == get(vertex_complement, m_g, target(e, m_g));
	28	}
	29
30	30	private:
31	31	const Graph& m_g;
32	32	};
33	33
34	34	/** Return whether the outgoing edge of vertex u is contiguous. */
35	35	template<typename Graph>
36		bool contiguous_out(const Graph& g,
37		typename graph_traits<Graph>::vertex_descriptor u)
38		{
39		return out_degree(u, g) == 1
40		&& in_degree(*adjacent_vertices(u, g).first, g) == 1;
	36	bool
	37	contiguous_out(const Graph& g, typename graph_traits<Graph>::vertex_descriptor u)
	38	{
	39	return out_degree(u, g) == 1 && in_degree(*adjacent_vertices(u, g).first, g) == 1;
41	40	}
42	41
43	42	/** Return whether the incoming edge of vertex u is contiguous. */
44	43	template<typename Graph>
45		bool contiguous_in(const Graph& g,
46		typename graph_traits<Graph>::vertex_descriptor u)
	44	bool
	45	contiguous_in(const Graph& g, typename graph_traits<Graph>::vertex_descriptor u)
47	46	{
48	47	return contiguous_out(g, get(vertex_complement, g, u));
49	48	}
50	49
51	50	/** Add the outgoing edges of vertex u to vertex uout. */
52	51	template<typename Graph>
53		void copy_out_edges(Graph &g,
54		typename Graph::vertex_descriptor u,
55		typename Graph::vertex_descriptor uout)
56		{
57		typedef typename graph_traits<Graph>::vertex_descriptor
58		vertex_descriptor;
59		typedef typename graph_traits<Graph>::out_edge_iterator
60		out_edge_iterator;
	52	void
	53	copy_out_edges(
	54	Graph& g,
	55	typename Graph::vertex_descriptor u,
	56	typename Graph::vertex_descriptor uout)
	57	{
	58	typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
	59	typedef typename graph_traits<Graph>::out_edge_iterator out_edge_iterator;
61	60	typedef typename edge_property<Graph>::type edge_property_type;
62	61	assert(u != uout);
63		std::pair<out_edge_iterator, out_edge_iterator>
64		edges = g.out_edges(u);
	62	std::pair<out_edge_iterator, out_edge_iterator> edges = g.out_edges(u);
65	63	bool palindrome = false;
66	64	edge_property_type palindrome_ep;
67	65	for (out_edge_iterator e = edges.first; e != edges.second; ++e) {

86	84
87	85	/** Add the incoming edges of vertex u to vertex v. */
88	86	template<typename Graph>
89		void copy_in_edges(Graph& g,
90		typename Graph::vertex_descriptor u,
91		typename Graph::vertex_descriptor v)
92		{
93		copy_out_edges(g,
94		get(vertex_complement, g, u),
95		get(vertex_complement, g, v));
	87	void
	88	copy_in_edges(Graph& g, typename Graph::vertex_descriptor u, typename Graph::vertex_descriptor v)
	89	{
	90	copy_out_edges(g, get(vertex_complement, g, u), get(vertex_complement, g, v));
96	91	}
97	92
98	93	/** Assemble a path of unambigous out edges starting at vertex u.
99	94	* u itself is not copied to out.
100	95	*/
101	96	template<typename Graph, typename OutIt>
102		OutIt extend(const Graph& g,
103		typename Graph::vertex_descriptor u, OutIt out)
104		{
105		typedef typename graph_traits<Graph>::vertex_descriptor
106		vertex_descriptor;
	97	OutIt
	98	extend(const Graph& g, typename Graph::vertex_descriptor u, OutIt out)
	99	{
	100	typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
107	101	std::set<vertex_descriptor> seen;
108	102	while (out_degree(u, g) == 1 && seen.insert(u).second) {
109	103	u = *adjacent_vertices(u, g).first;

115	109	/** Assemble an unambiguous path starting at vertex u.
116	110	* Every edge must satisfy the predicate. */
117	111	template<typename Graph, typename OutIt, typename Predicate>
118		OutIt assemble_if(const Graph& g,
119		typename Graph::vertex_descriptor u, OutIt out,
120		Predicate pred)
121		{
122		typedef typename graph_traits<Graph>::edge_descriptor
123		edge_descriptor;
	112	OutIt
	113	assemble_if(const Graph& g, typename Graph::vertex_descriptor u, OutIt out, Predicate pred)
	114	{
	115	typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
124	116	while (contiguous_out(g, u)) {
125	117	edge_descriptor e = *out_edges(u, g).first;
126	118	if (!pred(e))

137	129	* are removed as well.
138	130	*/
139	131	template<typename Graph, typename It, typename Predicate>
140		void remove_vertex_if(Graph& g, It first, It last, Predicate p)
141		{
142		for_each_if(first, last,
143		bind1st(std::mem_fun(&Graph::clear_vertex), &g), p);
144		for_each_if(first, last,
145		bind1st(std::mem_fun(&Graph::remove_vertex), &g), p);
	132	void
	133	remove_vertex_if(Graph& g, It first, It last, Predicate p)
	134	{
	135	for_each_if(
	136	first, last, [&g](const ContigNode& c) { return g.clear_vertex(c); }, p);
	137	for_each_if(
	138	first, last, [&g](const ContigNode& c) { return g.remove_vertex(c); }, p);
146	139	}
147	140
148	141	/** Add the vertex and edge propeties of the path [first, last). */
149	142	template<typename Graph, typename It, typename VP>
150		VP addProp(const Graph& g, It first, It last, const VP*)
151		{
152		typedef typename graph_traits<Graph>::vertex_descriptor
153		vertex_descriptor;
	143	VP
	144	addProp(const Graph& g, It first, It last, const VP*)
	145	{
	146	typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
154	147	assert(first != last);
155	148	VP vp = get(vertex_bundle, g, *first);
156	149	for (It it = first + 1; it != last; ++it) {

163	156	}
164	157
165	158	template<typename Graph, typename It>
166		no_property addProp(const Graph&, It, It, const no_property*)
	159	no_property
	160	addProp(const Graph&, It, It, const no_property*)
167	161	{
168	162	return no_property();
169	163	}
170	164
171	165	template<typename Graph, typename It>
172		typename vertex_property<Graph>::type addProp(const Graph& g,
173		It first, It last)
174		{
175		return addProp(g, first, last,
176		(typename vertex_property<Graph>::type*)NULL);
	166	typename vertex_property<Graph>::type
	167	addProp(const Graph& g, It first, It last)
	168	{
	169	return addProp(g, first, last, (typename vertex_property<Graph>::type*)NULL);
177	170	}
178	171
179	172	/** Merge the vertices in the sequence [first, last).

184	177	typename graph_traits<Graph>::vertex_descriptor
185	178	merge(Graph& g, It first, It last)
186	179	{
187		typedef typename graph_traits<Graph>::vertex_descriptor
188		vertex_descriptor;
	180	typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
189	181	assert(first != last);
190	182	vertex_descriptor u = add_vertex(addProp(g, first, last), g);
191	183	copy_in_edges(g, *first, u);

196	188	/** Assemble unambiguous paths. Write the paths to out.
197	189	* Every edge must satisfy the predicate. */
198	190	template<typename Graph, typename OutIt, typename Predicate>
199		OutIt assemble_if(Graph& g, OutIt out, Predicate pred0)
	191	OutIt
	192	assemble_if(Graph& g, OutIt out, Predicate pred0)
200	193	{
201	194	typedef typename Graph::vertex_iterator vertex_iterator;
202	195	// pred(e) = !isPalindrome(e) && pred0(e)
203		binary_compose<std::logical_and<bool>,
204		std::unary_negate<IsPalindrome<Graph> >, Predicate>
205		pred(compose2(std::logical_and<bool>(),
206		std::not1(IsPalindrome<Graph>(g)), pred0));
	196	binary_compose<std::logical_and<bool>, std::unary_negate<IsPalindrome<Graph>>, Predicate> pred(
	197	compose2(std::logical_and<bool>(), std::not1(IsPalindrome<Graph>(g)), pred0));
207	198	std::pair<vertex_iterator, vertex_iterator> uit = g.vertices();
208	199	for (vertex_iterator u = uit.first; u != uit.second; ++u) {
209		if (!contiguous_out(g, u) \|\| contiguous_in(g, u)
210		\|\| !pred(out_edges(u, g).first))
	200	if (!contiguous_out(g, u) \|\| contiguous_in(g, u) \|\| !pred(out_edges(u, g).first))
211	201	continue;
212	202	typename output_iterator_traits<OutIt>::value_type path;
213	203	assemble_if(g, *u, back_inserter(path), pred);
214	204	assert(path.size() >= 2);
215	205	assert(path.front() != path.back());
216	206	merge(g, path.begin(), path.end());
217		remove_vertex_if(g, path.begin(), path.end(),
218		not1(std::mem_fun_ref(&ContigNode::ambiguous)));
	207	remove_vertex_if(
	208	g, path.begin(), path.end(), [](const ContigNode& c) { return !c.ambiguous(); });
219	209	*out++ = path;
220	210	}
221	211	return out;

223	213
224	214	/** Assemble unambiguous paths. Write the paths to out. */
225	215	template<typename Graph, typename OutIt>
226		OutIt assemble(Graph& g, OutIt out)
227		{
228		typedef typename graph_traits<Graph>::edge_descriptor
229		edge_descriptor;
	216	OutIt
	217	assemble(Graph& g, OutIt out)
	218	{
	219	typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
230	220	return assemble_if(g, out, True<edge_descriptor>());
231	221	}
232	222
233	223	/** Return true if the edge e is +ve sense. */
234	224	template<typename Graph>
235		struct IsPositive : std::unary_function<
236		typename graph_traits<Graph>::edge_descriptor, bool>
237		{
238		IsPositive(const Graph& g) : m_g(g) { }
239		bool operator()(
240		typename graph_traits<Graph>::edge_descriptor e) const
	225	struct IsPositive : std::unary_function<typename graph_traits<Graph>::edge_descriptor, bool>
	226	{
	227	IsPositive(const Graph& g)
	228	: m_g(g)
	229	{}
	230	bool operator()(typename graph_traits<Graph>::edge_descriptor e) const
241	231	{
242		return !get(vertex_sense, m_g, source(e, m_g))
243		&& !get(vertex_sense, m_g, target(e, m_g));
244		}
	232	return !get(vertex_sense, m_g, source(e, m_g)) && !get(vertex_sense, m_g, target(e, m_g));
	233	}
	234
245	235	private:
246	236	const Graph& m_g;
247	237	};

249	239	/** Assemble unambiguous paths in forward orientation only.
250	240	* Write the paths to out. */
251	241	template<typename Graph, typename OutIt>
252		OutIt assemble_stranded(Graph& g, OutIt out)
	242	OutIt
	243	assemble_stranded(Graph& g, OutIt out)
253	244	{
254	245	return assemble_if(g, out, IsPositive<Graph>(g));
255	246	}

259	250	* deg+(v) = 0, and p(v) is true.
260	251	* Stores all removed vertices in result.
261	252	*/
262		template <typename Graph, typename OutputIt, typename Pred>
263		OutputIt pruneTips_if(Graph& g, OutputIt result, Pred p)
	253	template<typename Graph, typename OutputIt, typename Pred>
	254	OutputIt
	255	pruneTips_if(Graph& g, OutputIt result, Pred p)
264	256	{
265	257	typedef typename graph_traits<Graph>::adjacency_iterator Vit;
266	258	typedef typename graph_traits<Graph>::vertex_iterator Uit;

276	268	std::pair<Vit, Vit> vrange = adjacent_vertices(u, g);
277	269	for (Vit vit = vrange.first; vit != vrange.second; ++vit) {
278	270	V v = *vit;
279		//assert(v != u);
	271	// assert(v != u);
280	272	if (out_degree(v, g) == 0 && p(v))
281	273	tips.push_back(v);
282	274	}

284	276
285	277	/** Remove the tips. */
286	278	remove_vertex_if(g, tips.begin(), tips.end(), True<V>());
287		std::transform(tips.begin(), tips.end(), result,
288		std::mem_fun_ref(&ContigNode::contigIndex));
289
	279	std::transform(
	280	tips.begin(), tips.end(), result, [](const ContigNode& c) { return c.contigIndex(); });
290	281	return result;
291	282	}
292	283
293	284	/** Return true if the vertex is a normal 1-in 0-out tip. */
294	285	template<typename Graph>
295		struct IsTip : std::unary_function<
296		typename graph_traits<Graph>::vertex_descriptor, bool>
297		{
298		IsTip(const Graph& g) : m_g(g) { }
299		bool operator()(
300		typename graph_traits<Graph>::vertex_descriptor v) const
	286	struct IsTip : std::unary_function<typename graph_traits<Graph>::vertex_descriptor, bool>
	287	{
	288	IsTip(const Graph& g)
	289	: m_g(g)
	290	{}
	291	bool operator()(typename graph_traits<Graph>::vertex_descriptor v) const
301	292	{
302	293	return in_degree(v, m_g) == 1;
303	294	}
	295
304	296	private:
305	297	const Graph& m_g;
306	298	};

310	302	* and deg-(v) = 1 and deg+(v) = 0.
311	303	* Stores all removed vertices in result.
312	304	*/
313		template <typename Graph, typename OutputIt>
314		OutputIt pruneTips(Graph& g, OutputIt result)
	305	template<typename Graph, typename OutputIt>
	306	OutputIt
	307	pruneTips(Graph& g, OutputIt result)
315	308	{
316	309	return pruneTips_if(g, result, IsTip<Graph>(g));
317	310	}

321	314	* true.
322	315	* Stores all removed vertices in result.
323	316	*/
324		template <typename Graph, typename OutputIt, typename Pred>
325		OutputIt removeIslands_if(Graph& g, OutputIt result, Pred p)
	317	template<typename Graph, typename OutputIt, typename Pred>
	318	OutputIt
	319	removeIslands_if(Graph& g, OutputIt result, Pred p)
326	320	{
327	321	typedef typename graph_traits<Graph>::vertex_iterator Uit;
328	322	typedef typename graph_traits<Graph>::vertex_descriptor V;

343	337	}
344	338
345	339	/** Add missing complementary edges. */
346		template <typename DG>
347		size_t addComplementaryEdges(ContigGraph<DG>& g)
	340	template<typename DG>
	341	size_t
	342	addComplementaryEdges(ContigGraph<DG>& g)
348	343	{
349	344	typedef ContigGraph<DG> Graph;
350	345	typedef graph_traits<Graph> GTraits;

+78

-85

KAligner/Aligner.h less more

0	0	#ifndef ALIGNER_H
1	1	#define ALIGNER_H 1
2	2
3		#include "config.h"
4		#include "KAligner/Options.h"
5	3	#include "Alignment.h"
6	4	#include "ConstString.h"
7	5	#include "Functional.h"
	6	#include "KAligner/Options.h"
8	7	#include "Kmer.h"
9	8	#include "UnorderedMap.h"
	9	#include "config.h"
10	10	#include <cassert>
11	11	#include <cstdlib>
12	12	#include <cstring> // for strcpy

26	26	{
27	27	uint32_t contig;
28	28	uint32_t pos; // 0 indexed
29		Position(uint32_t contig = std::numeric_limits<uint32_t>::max(),
30		uint32_t pos = std::numeric_limits<uint32_t>::max())
31		: contig(contig), pos(pos) { }
	29	Position(
	30	uint32_t contig = std::numeric_limits<uint32_t>::max(),
	31	uint32_t pos = std::numeric_limits<uint32_t>::max())
	32	: contig(contig)
	33	, pos(pos)
	34	{}
32	35
33	36	/** Mark this seed as a duplicate. */
34		void setDuplicate(const char* thisContig, const char* otherContig,
35		const Sequence& kmer)
	37	void setDuplicate(const char* thisContig, const char* otherContig, const Sequence& kmer)
36	38	{
37	39	if (opt::multimap == opt::IGNORE)
38	40	contig = std::numeric_limits<uint32_t>::max();
39	41	else {
40		std::cerr << "error: duplicate k-mer in "
41		<< thisContig
42		<< " also in "
43		<< otherContig
44		<< ": " << kmer << '\n';
	42	std::cerr << "error: duplicate k-mer in " << thisContig << " also in " << otherContig
	43	<< ": " << kmer << '\n';
45	44	exit(EXIT_FAILURE);
46	45	}
47	46	}
48	47
49	48	/** Return whether this seed is a duplciate. */
50		bool isDuplicate() const
51		{
52		return contig == std::numeric_limits<uint32_t>::max();
53		}
	49	bool isDuplicate() const { return contig == std::numeric_limits<uint32_t>::max(); }
54	50	};
55	51
56		typedef unordered_multimap<Kmer, Position, hash<Kmer> >
57		SeqPosHashMultiMap;
	52	typedef unordered_multimap<Kmer, Position, hash<Kmer>> SeqPosHashMultiMap;
58	53
59	54	#if HAVE_GOOGLE_SPARSE_HASH_MAP
60		# include <google/sparse_hash_map>
61		typedef google::sparse_hash_map<Kmer, Position, hash<Kmer> >
62		SeqPosHashUniqueMap;
	55	#include <google/sparse_hash_map>
	56	typedef google::sparse_hash_map<Kmer, Position, hash<Kmer>> SeqPosHashUniqueMap;
63	57	#else
64		typedef unordered_map<Kmer, Position, hash<Kmer> >
65		SeqPosHashUniqueMap;
	58	typedef unordered_map<Kmer, Position, hash<Kmer>> SeqPosHashUniqueMap;
66	59	#endif
67
68	60
69	61	typedef std::vector<Alignment> AlignmentVector;
70	62

72	64	* Index a target sequence and align query sequences to that indexed
73	65	* target.
74	66	*/
75		template <class SeqPosHashMap>
	67	template<class SeqPosHashMap>
76	68	class Aligner
77	69	{
78		public:
79		typedef typename SeqPosHashMap::iterator map_iterator;
80		typedef typename SeqPosHashMap::const_iterator
81		map_const_iterator;
	70	public:
	71	typedef typename SeqPosHashMap::iterator map_iterator;
	72	typedef typename SeqPosHashMap::const_iterator map_const_iterator;
82	73
83		Aligner(int hashSize, size_t buckets)
84		: m_hashSize(hashSize), m_target(buckets) { }
	74	Aligner(int hashSize, size_t buckets)
	75	: m_hashSize(hashSize)
	76	, m_target(buckets)
	77	{}
85	78
86		Aligner(int hashSize, size_t buckets, float factor)
87		: m_hashSize(hashSize)
88		{
89		m_target.max_load_factor(factor);
90		m_target.rehash(buckets);
91		}
	79	Aligner(int hashSize, size_t buckets, float factor)
	80	: m_hashSize(hashSize)
	81	{
	82	m_target.max_load_factor(factor);
	83	m_target.rehash(buckets);
	84	}
92	85
93		void addReferenceSequence(const StringID& id,
94		const Sequence& seq);
95		void addReferenceSequence(const Kmer& kmer, Position pos);
	86	void addReferenceSequence(const StringID& id, const Sequence& seq);
	87	void addReferenceSequence(const Kmer& kmer, Position pos);
96	88
97		template <class oiterator>
98		void alignRead(const std::string& qid, const Sequence& seq,
99		oiterator dest);
	89	template<class oiterator>
	90	void alignRead(const std::string& qid, const Sequence& seq, oiterator dest);
100	91
101		size_t size() const { return m_target.size(); }
102		size_t bucket_count() const
103		{
104		return m_target.bucket_count();
105		}
	92	size_t size() const { return m_target.size(); }
	93	size_t bucket_count() const { return m_target.bucket_count(); }
106	94
107		/** Return the number of duplicate k-mer in the target. */
108		size_t countDuplicates() const
109		{
110		assert(opt::multimap == opt::IGNORE);
111		return count_if(m_target.begin(), m_target.end(),
112		compose1(std::mem_fun_ref(&Position::isDuplicate),
113		mem_var(&SeqPosHashMap::value_type::second)));
114		}
	95	/** Return the number of duplicate k-mer in the target. */
	96	size_t countDuplicates() const
	97	{
	98	assert(opt::multimap == opt::IGNORE);
	99	return count_if(
	100	m_target.begin(), m_target.end(), [](const std::pair<const Kmer, Position>& s) {
	101	return s.second.isDuplicate();
	102	});
	103	}
115	104
116		private:
117		explicit Aligner(const Aligner&);
	105	private:
	106	explicit Aligner(const Aligner&);
118	107
119		typedef std::map<unsigned, AlignmentVector> AlignmentSet;
	108	typedef std::map<unsigned, AlignmentVector> AlignmentSet;
120	109
121		void alignKmer(
122		AlignmentSet& aligns, const Sequence& kmer,
123		bool isRC, bool good, int read_ind, int seqLen);
	110	void alignKmer(
	111	AlignmentSet& aligns,
	112	const Sequence& kmer,
	113	bool isRC,
	114	bool good,
	115	int read_ind,
	116	int seqLen);
124	117
125		AlignmentSet getAlignmentsInternal(
126		const Sequence& seq, bool isRC);
	118	AlignmentSet getAlignmentsInternal(const Sequence& seq, bool isRC);
127	119
128		template <class oiterator>
129		void coalesceAlignments(
130		const std::string& qid, const std::string& seq,
131		const AlignmentSet& alignSet,
132		oiterator& dest);
	120	template<class oiterator>
	121	void coalesceAlignments(
	122	const std::string& qid,
	123	const std::string& seq,
	124	const AlignmentSet& alignSet,
	125	oiterator& dest);
133	126
134		// The number of bases to hash on
135		int m_hashSize;
	127	// The number of bases to hash on
	128	int m_hashSize;
136	129
137		/** A map of k-mer to contig coordinates. */
138		SeqPosHashMap m_target;
	130	/** A map of k-mer to contig coordinates. */
	131	SeqPosHashMap m_target;
139	132
140		/** A dictionary of contig IDs. */
141		std::vector<const_string> m_dict;
	133	/** A dictionary of contig IDs. */
	134	std::vector<const_string> m_dict;
142	135
143		unsigned contigIDToIndex(const std::string& id)
144		{
145		m_dict.push_back(id);
146		return m_dict.size() - 1;
147		}
	136	unsigned contigIDToIndex(const std::string& id)
	137	{
	138	m_dict.push_back(id);
	139	return m_dict.size() - 1;
	140	}
148	141
149		cstring contigIndexToID(unsigned index)
150		{
151		assert(index < m_dict.size());
152		return m_dict[index];
153		}
	142	cstring contigIndexToID(unsigned index)
	143	{
	144	assert(index < m_dict.size());
	145	return m_dict[index];
	146	}
154	147	};
155	148
156	149	#endif

+13

-10

KAligner/PipeMux.h less more

1	1	#define PIPEMUX_H 1
2	2
3	3	#include "Pipe.h"
4		#include <semaphore.h>
	4	#include "Semaphore.h"
5	5	#include <pthread.h>
6	6	#include <vector>
7	7
8		template <class T>
9		class PipeMux {
	8	template<class T>
	9	class PipeMux
	10	{
10	11	public:
11		/** Default constructor. */
12		PipeMux(size_t pipe_size = 1)
13		: m_index(0), m_entry_num(0), m_pipe_size(pipe_size)
	12	/** Default constructor. */
	13	PipeMux(size_t pipe_size = 1)
	14	: m_index(0)
	15	, m_entry_num(0)
	16	, m_pipe_size(pipe_size)
14	17	{
15	18	pthread_rwlock_init(&m_rwlock_vecs, NULL);
16	19	pthread_mutex_init(&m_mutex_index, NULL);

93	96	}
94	97
95	98	/** Checks that the PipeMux is empty. */
96		bool empty() {
	99	bool empty()
	100	{
97	101	pthread_rwlock_rdlock(&m_rwlock_vecs);
98	102	bool isEmpty = m_pipes.empty();
99	103	pthread_rwlock_unlock(&m_rwlock_vecs);

127	131	}
128	132	assert(i < m_pipes.size());
129	133	delete m_pipes[i];
130		m_pipes.erase(m_pipes.begin()+i);
	134	m_pipes.erase(m_pipes.begin() + i);
131	135	assert(i < m_mutex_pipes.size());
132	136	pthread_mutex_destroy(m_mutex_pipes[i]);
133	137	delete m_mutex_pipes[i];
134		m_mutex_pipes.erase(m_mutex_pipes.begin()+i);
	138	m_mutex_pipes.erase(m_mutex_pipes.begin() + i);
135	139	// Make sure the index points to the next element.
136	140	pthread_mutex_lock(&m_mutex_index);
137	141	m_index = m_index == m_pipes.size() ? 0 : m_index;

139	143
140	144	pthread_rwlock_unlock(&m_rwlock_vecs);
141	145	}
142
143	146	};
144	147
145	148	#endif

+108

-108

Layout/layout.cc less more

0		#include "config.h"
1	0	#include "ContigPath.h"
2	1	#include "ContigProperties.h"
3		#include "Uncompress.h"
4	2	#include "Graph/Assemble.h"
5	3	#include "Graph/ContigGraph.h"
6	4	#include "Graph/ContigGraphAlgorithms.h"

8	6	#include "Graph/GraphAlgorithms.h"
9	7	#include "Graph/GraphIO.h"
10	8	#include "Graph/GraphUtil.h"
	9	#include "Uncompress.h"
	10	#include "config.h"
11	11	#include <cassert>
12	12	#include <cstdlib>
13	13	#include <fstream>

22	22
23	23	#define PROGRAM "abyss-layout"
24	24
25		static const char VERSION_MESSAGE[] =
26		PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
27		"Written by Shaun Jackman.\n"
28		"\n"
29		"Copyright 2012 Shaun Jackman\n";
	25	static const char VERSION_MESSAGE[] = PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
	26	"Written by Shaun Jackman.\n"
	27	"\n"
	28	"Copyright 2012 Shaun Jackman\n";
30	29
31	30	static const char USAGE_MESSAGE[] =
32		"Usage: " PROGRAM " [OPTION]... OVERLAP\n"
33		"Layout contigs using the sequence overlap graph.\n"
34		"Output sequence paths.\n"
35		"\n"
36		" Arguments:\n"
37		"\n"
38		" OVERLAP the sequence overlap graph\n"
39		"\n"
40		" Options:\n"
41		"\n"
42		" -s, --min-length=N minimum sequence length [0]\n"
43		" -m, --min-overlap=N minimum overlap [0]\n"
44		" -k, --kmer=N length of a k-mer\n"
45		" -o, --out=FILE write the paths to FILE\n"
46		" -g, --graph=FILE write the graph to FILE\n"
47		" --tred remove transitive edges\n"
48		" --no-tred do not remove transitive edges [default]\n"
49		" --SS expect contigs to be oriented correctly\n"
50		" --no-SS no assumption about contig orientation [default]\n"
51		" -v, --verbose display verbose output\n"
52		" --help display this help and exit\n"
53		" --version output version information and exit\n"
54		"\n"
55		"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
	31	"Usage: " PROGRAM " [OPTION]... OVERLAP\n"
	32	"Layout contigs using the sequence overlap graph.\n"
	33	"Output sequence paths.\n"
	34	"\n"
	35	" Arguments:\n"
	36	"\n"
	37	" OVERLAP the sequence overlap graph\n"
	38	"\n"
	39	" Options:\n"
	40	"\n"
	41	" -s, --min-length=N minimum sequence length [0]\n"
	42	" -m, --min-overlap=N minimum overlap [0]\n"
	43	" -k, --kmer=N length of a k-mer\n"
	44	" -o, --out=FILE write the paths to FILE\n"
	45	" -g, --graph=FILE write the graph to FILE\n"
	46	" --tred remove transitive edges\n"
	47	" --no-tred do not remove transitive edges [default]\n"
	48	" --SS expect contigs to be oriented correctly\n"
	49	" --no-SS no assumption about contig orientation [default]\n"
	50	" -v, --verbose display verbose output\n"
	51	" --help display this help and exit\n"
	52	" --version output version information and exit\n"
	53	"\n"
	54	"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
56	55
57	56	namespace opt {
58		unsigned k; // used by ContigProperties
59
60		/** Minimum sequence length. */
61		static unsigned minLength;
62
63		/** Minimum overlap. */
64		static unsigned minOverlap;
65
66		/** Write the paths to this file. */
67		static string out;
68
69		/** Write the graph to this file. */
70		static string graphPath;
71
72		/** Remove transitive edges. */
73		static int tred;
74
75		/** Run a strand-specific RNA-Seq assembly. */
76		static int ss;
77
78		/** Verbose output. */
79		int verbose; // used by PopBubbles
80
81		/** Output format */
82		int format = DOT;
	57	unsigned k; // used by ContigProperties
	58
	59	/** Minimum sequence length. */
	60	static unsigned minLength;
	61
	62	/** Minimum overlap. */
	63	static unsigned minOverlap;
	64
	65	/** Write the paths to this file. */
	66	static string out;
	67
	68	/** Write the graph to this file. */
	69	static string graphPath;
	70
	71	/** Remove transitive edges. */
	72	static int tred;
	73
	74	/** Run a strand-specific RNA-Seq assembly. */
	75	static int ss;
	76
	77	/** Verbose output. */
	78	int verbose; // used by PopBubbles
	79
	80	/** Output format */
	81	int format = DOT;
83	82	}
84	83
85	84	static const char shortopts[] = "g:k:m:o:s:v";
86	85
87		enum { OPT_HELP = 1, OPT_VERSION };
88
89		static const struct option longopts[] = {
90		{ "graph", required_argument, NULL, 'g' },
91		{ "kmer", required_argument, NULL, 'k' },
92		{ "min-overlap", required_argument, NULL, 'm' },
93		{ "out", required_argument, NULL, 'o' },
94		{ "min-length", required_argument, NULL, 's' },
95		{ "tred", no_argument, &opt::tred, true },
96		{ "no-tred", no_argument, &opt::tred, false },
97		{ "SS", no_argument, &opt::ss, 1 },
98		{ "no-SS", no_argument, &opt::ss, 0 },
99		{ "verbose", no_argument, NULL, 'v' },
100		{ "help", no_argument, NULL, OPT_HELP },
101		{ "version", no_argument, NULL, OPT_VERSION },
102		{ NULL, 0, NULL, 0 }
	86	enum
	87	{
	88	OPT_HELP = 1,
	89	OPT_VERSION
103	90	};
	91
	92	static const struct option longopts[] = { { "graph", required_argument, NULL, 'g' },
	93	{ "kmer", required_argument, NULL, 'k' },
	94	{ "min-overlap", required_argument, NULL, 'm' },
	95	{ "out", required_argument, NULL, 'o' },
	96	{ "min-length", required_argument, NULL, 's' },
	97	{ "tred", no_argument, &opt::tred, true },
	98	{ "no-tred", no_argument, &opt::tred, false },
	99	{ "SS", no_argument, &opt::ss, 1 },
	100	{ "no-SS", no_argument, &opt::ss, 0 },
	101	{ "verbose", no_argument, NULL, 'v' },
	102	{ "help", no_argument, NULL, OPT_HELP },
	103	{ "version", no_argument, NULL, OPT_VERSION },
	104	{ NULL, 0, NULL, 0 } };
104	105
105	106	/** An overlap graph. */
106	107	typedef DirectedGraph<Length, Distance> DG;
107	108	typedef ContigGraph<DG> Graph;
108	109
109	110	/** Remove short vertices. */
110		static void filterVertices(Graph& g, unsigned minLength)
	111	static void
	112	filterVertices(Graph& g, unsigned minLength)
111	113	{
112	114	typedef graph_traits<Graph> GTraits;
113	115	typedef GTraits::vertex_descriptor V;

130	132	}
131	133
132	134	if (opt::verbose > 0) {
133		cerr << "Ignored " << numRemoved << " sequences shorter than "
134		<< minLength << " bp.\n";
	135	cerr << "Ignored " << numRemoved << " sequences shorter than " << minLength << " bp.\n";
135	136	printGraphStats(cerr, g);
136	137	}
137	138	}
138	139
139	140	/** Return true if the edge is a small overlap. */
140		struct IsSmallOverlap {
141		IsSmallOverlap(Graph& g) : m_g(g) { }
	141	struct IsSmallOverlap
	142	{
	143	IsSmallOverlap(Graph& g)
	144	: m_g(g)
	145	{}
142	146	bool operator()(graph_traits<Graph>::edge_descriptor e) const
143	147	{
144	148	int maxDistance = -opt::minOverlap;

148	152	};
149	153
150	154	/** Remove small overlaps. */
151		static void filterEdges(Graph& g, unsigned minOverlap)
	155	static void
	156	filterEdges(Graph& g, unsigned minOverlap)
152	157	{
153	158	if (minOverlap == 0)
154	159	return;

162	167	}
163	168
164	169	/** Read a graph from the specified file. */
165		static void readGraph(const string& path, Graph& g)
	170	static void
	171	readGraph(const string& path, Graph& g)
166	172	{
167	173	if (opt::verbose > 0)
168	174	cerr << "Reading `" << path << "'...\n";

177	183	}
178	184
179	185	/** Return the length histogram. */
180		static Histogram buildLengthHistogram(const Graph& g)
	186	static Histogram
	187	buildLengthHistogram(const Graph& g)
181	188	{
182	189	typedef graph_traits<Graph>::vertex_descriptor V;
183	190	typedef graph_traits<Graph>::vertex_iterator Vit;

192	199	}
193	200
194	201	/** Run abyss-layout. */
195		int main(int argc, char** argv)
	202	int
	203	main(int argc, char** argv)
196	204	{
197	205	bool die = false;
198		for (int c; (c = getopt_long(argc, argv,
199		shortopts, longopts, NULL)) != -1;) {
	206	for (int c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) {
200	207	istringstream arg(optarg != NULL ? optarg : "");
201	208	switch (c) {
202		case '?':
	209	case '?':
203	210	die = true;
204	211	break;
205		case 'k':
	212	case 'k':
206	213	arg >> opt::k;
207	214	break;
208		case 'g':
	215	case 'g':
209	216	arg >> opt::graphPath;
210	217	break;
211		case 'm':
	218	case 'm':
212	219	arg >> opt::minOverlap;
213	220	break;
214		case 'o':
	221	case 'o':
215	222	arg >> opt::out;
216	223	break;
217		case 's':
	224	case 's':
218	225	arg >> opt::minLength;
219	226	break;
220		case 'v':
	227	case 'v':
221	228	opt::verbose++;
222	229	break;
223		case OPT_HELP:
	230	case OPT_HELP:
224	231	cout << USAGE_MESSAGE;
225	232	exit(EXIT_SUCCESS);
226		case OPT_VERSION:
	233	case OPT_VERSION:
227	234	cout << VERSION_MESSAGE;
228	235	exit(EXIT_SUCCESS);
229	236	}
230	237	if (optarg != NULL && !arg.eof()) {
231		cerr << PROGRAM ": invalid option: `-"
232		<< (char)c << optarg << "'\n";
	238	cerr << PROGRAM ": invalid option: `-" << (char)c << optarg << "'\n";
233	239	exit(EXIT_FAILURE);
234	240	}
235	241	}

240	246	}
241	247
242	248	if (die) {
243		cerr << "Try `" << PROGRAM
244		<< " --help' for more information.\n";
	249	cerr << "Try `" << PROGRAM << " --help' for more information.\n";
245	250	exit(EXIT_FAILURE);
246	251	}
247	252

262	267	if (opt::tred) {
263	268	unsigned numTransitive = remove_transitive_edges(g);
264	269	if (opt::verbose > 0) {
265		cerr << "Removed " << numTransitive
266		<< " transitive edges.\n";
	270	cerr << "Removed " << numTransitive << " transitive edges.\n";
267	271	printGraphStats(cerr, g);
268	272	}
269	273	}

277	281	sort(paths.begin(), paths.end());
278	282	if (opt::verbose > 0) {
279	283	unsigned n = 0;
280		for (ContigPaths::const_iterator it = paths.begin();
281		it != paths.end(); ++it)
	284	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it)
282	285	n += it->size();
283		cerr << "Assembled " << n << " sequences in "
284		<< paths.size() << " contigs.\n";
	286	cerr << "Assembled " << n << " sequences in " << paths.size() << " contigs.\n";
285	287	printGraphStats(cerr, g);
286	288	}
287	289

290	292	ostream& out = opt::out.empty() \|\| opt::out == "-" ? cout : fout;
291	293	assert_good(out, opt::out);
292	294	g_contigNames.unlock();
293		for (vector<ContigPath>::const_iterator it = paths.begin();
294		it != paths.end(); ++it)
	295	for (vector<ContigPath>::const_iterator it = paths.begin(); it != paths.end(); ++it)
295	296	out << createContigName() << '\t' << *it << '\n';
296	297	assert_good(out, opt::out);
297	298
298	299	// Create the new vertices.
299		for (vector<ContigPath>::const_iterator it = paths.begin();
300		it != paths.end(); ++it) {
	300	for (vector<ContigPath>::const_iterator it = paths.begin(); it != paths.end(); ++it) {
301	301	const ContigPath& path = *it;
302	302	merge(g, path.begin(), path.end());
303		remove_vertex_if(g, path.begin(), path.end(),
304		not1(std::mem_fun_ref(&ContigNode::ambiguous)));
	303	remove_vertex_if(
	304	g, path.begin(), path.end(), [](const ContigNode& c) { return !c.ambiguous(); });
305	305	}
306	306	if (opt::verbose > 0)
307	307	printGraphStats(cerr, g);

-0

Makefile.am less more

68	68	clang-format:
69	69	for i in Bloom/RollingBloomDBGVisitor.h Bloom/bloom.cc BloomDBG/BloomIO.h \
70	70	BloomDBG/Checkpoint.h BloomDBG/HashAgnosticCascadingBloom.h BloomDBG/bloom-dbg.* \
	71	ABYSS/abyss.cc Assembly/BranchGroup.h FMIndex/BitArrays.h FilterGraph/FilterGraph.cc \
	72	Graph/ContigGraphAlgorithms.h KAligner/Aligner.h KAligner/PipeMux.h Layout/layout.cc \
	73	MergePaths/MergeContigs.cpp MergePaths/MergePaths.cpp ParseAligns/ParseAligns.cpp \
	74	ParseAligns/abyss-fixmate.cc PathOverlap/PathOverlap.cpp PopBubbles/PopBubbles.cpp Scaffold/scaffold.cc \
71	75	Unittest/BloomDBG/HashAgnosticCascadingBloomTest.cpp; do clang-format -style=file $$i >$$i.fixed; done
72	76	for i in Bloom/RollingBloomDBGVisitor.h Bloom/bloom.cc BloomDBG/BloomIO.h \
73	77	BloomDBG/Checkpoint.h BloomDBG/HashAgnosticCascadingBloom.h BloomDBG/bloom-dbg.* \
	78	ABYSS/abyss.cc Assembly/BranchGroup.h FMIndex/BitArrays.h FilterGraph/FilterGraph.cc \
	79	Graph/ContigGraphAlgorithms.h KAligner/Aligner.h KAligner/PipeMux.h Layout/layout.cc \
	80	MergePaths/MergeContigs.cpp MergePaths/MergePaths.cpp ParseAligns/ParseAligns.cpp \
	81	ParseAligns/abyss-fixmate.cc PathOverlap/PathOverlap.cpp PopBubbles/PopBubbles.cpp Scaffold/scaffold.cc \
74	82	Unittest/BloomDBG/HashAgnosticCascadingBloomTest.cpp; do diff -su $$i $$i.fixed && rm -f $$i.fixed; done
75	83	if ls *.fixed; then exit 1; fi

+247

-231

MergePaths/MergeContigs.cpp less more

0		#include "config.h"
1	0	#include "Common/Options.h"
2	1	#include "ContigNode.h"
3	2	#include "ContigPath.h"
4	3	#include "ContigProperties.h"
	4	#include "DataBase/DB.h"
	5	#include "DataBase/Options.h"
5	6	#include "DataLayer/Options.h"
6	7	#include "Dictionary.h"
7	8	#include "FastaReader.h"
8		#include "Histogram.h"
9		#include "IOUtil.h"
10		#include "MemoryUtil.h"
11		#include "smith_waterman.h"
12		#include "Sequence.h"
13		#include "StringUtil.h"
14		#include "Uncompress.h"
15	9	#include "Graph/ContigGraph.h"
16	10	#include "Graph/ContigGraphAlgorithms.h"
17	11	#include "Graph/DirectedGraph.h"
18	12	#include "Graph/GraphIO.h"
19	13	#include "Graph/GraphUtil.h"
20	14	#include "Graph/Options.h"
	15	#include "Histogram.h"
	16	#include "IOUtil.h"
	17	#include "MemoryUtil.h"
	18	#include "Sequence.h"
	19	#include "StringUtil.h"
	20	#include "Uncompress.h"
	21	#include "config.h"
	22	#include "smith_waterman.h"
21	23	#include <algorithm>
22	24	#include <cstdlib>
23	25	#include <fstream>

25	27	#include <iostream>
26	28	#include <limits>
27	29	#include <vector>
28		#include "DataBase/Options.h"
29		#include "DataBase/DB.h"
30	30
31	31	using namespace std;
32	32

35	35	DB db;
36	36
37	37	static const char VERSION_MESSAGE[] =
38		PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
39		"Written by Shaun Jackman.\n"
40		"\n"
41		"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
	38	PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
	39	"Written by Shaun Jackman.\n"
	40	"\n"
	41	"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
42	42
43	43	static const char USAGE_MESSAGE[] =
44		"Usage: " PROGRAM " -k<kmer> -o<out.fa> [OPTION]... FASTA [OVERLAP] PATH\n"
45		"Merge paths of contigs to create larger contigs.\n"
46		"\n"
47		" Arguments:\n"
48		"\n"
49		" FASTA contigs in FASTA format\n"
50		" OVERLAP contig overlap graph\n"
51		" PATH sequences of contig IDs\n"
52		"\n"
53		" Options:\n"
54		"\n"
55		" -k, --kmer=KMER_SIZE k-mer size\n"
56		" -o, --out=FILE output the merged contigs to FILE [stdout]\n"
57		" -g, --graph=FILE write the contig overlap graph to FILE\n"
58		" --merged output only merged contigs\n"
59		" --adj output the graph in adj format\n"
60		" --dot output the graph in dot format [default]\n"
61		" --dot-meancov same as above but give the mean coverage\n"
62		" --gfa output the graph in GFA1 format\n"
63		" --gfa1 output the graph in GFA1 format\n"
64		" --gfa2 output the graph in GFA2 format\n"
65		" --gv output the graph in GraphViz format\n"
66		" --sam output the graph in SAM format\n"
67		" -v, --verbose display verbose output\n"
68		" --help display this help and exit\n"
69		" --version output version information and exit\n"
70		" --db=FILE specify path of database repository in FILE\n"
71		" --library=NAME specify library NAME for database\n"
72		" --strain=NAME specify strain NAME for database\n"
73		" --species=NAME specify species NAME for database\n"
74		"\n"
75		"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
	44	"Usage: " PROGRAM " -k<kmer> -o<out.fa> [OPTION]... FASTA [OVERLAP] PATH\n"
	45	"Merge paths of contigs to create larger contigs.\n"
	46	"\n"
	47	" Arguments:\n"
	48	"\n"
	49	" FASTA contigs in FASTA format\n"
	50	" OVERLAP contig overlap graph\n"
	51	" PATH sequences of contig IDs\n"
	52	"\n"
	53	" Options:\n"
	54	"\n"
	55	" -k, --kmer=KMER_SIZE k-mer size\n"
	56	" -o, --out=FILE output the merged contigs to FILE [stdout]\n"
	57	" -g, --graph=FILE write the contig overlap graph to FILE\n"
	58	" --merged output only merged contigs\n"
	59	" --adj output the graph in adj format\n"
	60	" --dot output the graph in dot format [default]\n"
	61	" --dot-meancov same as above but give the mean coverage\n"
	62	" --gfa output the graph in GFA1 format\n"
	63	" --gfa1 output the graph in GFA1 format\n"
	64	" --gfa2 output the graph in GFA2 format\n"
	65	" --gv output the graph in GraphViz format\n"
	66	" --sam output the graph in SAM format\n"
	67	" -v, --verbose display verbose output\n"
	68	" --help display this help and exit\n"
	69	" --version output version information and exit\n"
	70	" --db=FILE specify path of database repository in FILE\n"
	71	" --library=NAME specify library NAME for database\n"
	72	" --strain=NAME specify strain NAME for database\n"
	73	" --species=NAME specify species NAME for database\n"
	74	"\n"
	75	"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
76	76
77	77	namespace opt {
78		string db;
79		dbVars metaVars;
80		unsigned k; // used by ContigProperties
81		unsigned pathCount; // num of initial paths
82
83		/** Output FASTA path. */
84		static string out = "-";
85
86		/** Output graph path. */
87		static string graphPath;
88
89		/** Output graph format. */
90		int format = DOT;
91
92		/** Output only merged contigs. */
93		int onlyMerged;
94
95		/** Minimum overlap. */
96		static unsigned minOverlap = 20;
97
98		/** Minimum alignment identity. */
99		static float minIdentity = 0.9;
	78	string db;
	79	dbVars metaVars;
	80	unsigned k; // used by ContigProperties
	81	unsigned pathCount; // num of initial paths
	82
	83	/** Output FASTA path. */
	84	static string out = "-";
	85
	86	/** Output graph path. */
	87	static string graphPath;
	88
	89	/** Output graph format. */
	90	int format = DOT;
	91
	92	/** Output only merged contigs. */
	93	int onlyMerged;
	94
	95	/** Minimum overlap. */
	96	static unsigned minOverlap = 20;
	97
	98	/** Minimum alignment identity. */
	99	static float minIdentity = 0.9;
100	100	}
101	101
102	102	static const char shortopts[] = "g:k:o:v";
103	103
104		enum { OPT_HELP = 1, OPT_VERSION, OPT_DB, OPT_LIBRARY, OPT_STRAIN, OPT_SPECIES };
105		//enum { OPT_HELP = 1, OPT_VERSION };
106
107		static const struct option longopts[] = {
108		{ "adj", no_argument, &opt::format, ADJ },
109		{ "dot", no_argument, &opt::format, DOT },
110		{ "dot-meancov", no_argument, &opt::format, DOT_MEANCOV },
111		{ "gfa", no_argument, &opt::format, GFA1 },
112		{ "gfa1", no_argument, &opt::format, GFA1 },
113		{ "gfa2", no_argument, &opt::format, GFA2 },
114		{ "gv", no_argument, &opt::format, DOT },
115		{ "sam", no_argument, &opt::format, SAM },
116		{ "graph", required_argument, NULL, 'g' },
117		{ "kmer", required_argument, NULL, 'k' },
118		{ "merged", no_argument, &opt::onlyMerged, 1 },
119		{ "out", required_argument, NULL, 'o' },
120		{ "path", required_argument, NULL, 'p' },
121		{ "verbose", no_argument, NULL, 'v' },
122		{ "help", no_argument, NULL, OPT_HELP },
123		{ "version", no_argument, NULL, OPT_VERSION },
124		{ "db", required_argument, NULL, OPT_DB },
125		{ "library", required_argument, NULL, OPT_LIBRARY },
126		{ "strain", required_argument, NULL, OPT_STRAIN },
127		{ "species", required_argument, NULL, OPT_SPECIES },
128		{ NULL, 0, NULL, 0 }
	104	enum
	105	{
	106	OPT_HELP = 1,
	107	OPT_VERSION,
	108	OPT_DB,
	109	OPT_LIBRARY,
	110	OPT_STRAIN,
	111	OPT_SPECIES
129	112	};
	113	// enum { OPT_HELP = 1, OPT_VERSION };
	114
	115	static const struct option longopts[] = { { "adj", no_argument, &opt::format, ADJ },
	116	{ "dot", no_argument, &opt::format, DOT },
	117	{ "dot-meancov", no_argument, &opt::format, DOT_MEANCOV },
	118	{ "gfa", no_argument, &opt::format, GFA1 },
	119	{ "gfa1", no_argument, &opt::format, GFA1 },
	120	{ "gfa2", no_argument, &opt::format, GFA2 },
	121	{ "gv", no_argument, &opt::format, DOT },
	122	{ "sam", no_argument, &opt::format, SAM },
	123	{ "graph", required_argument, NULL, 'g' },
	124	{ "kmer", required_argument, NULL, 'k' },
	125	{ "merged", no_argument, &opt::onlyMerged, 1 },
	126	{ "out", required_argument, NULL, 'o' },
	127	{ "path", required_argument, NULL, 'p' },
	128	{ "verbose", no_argument, NULL, 'v' },
	129	{ "help", no_argument, NULL, OPT_HELP },
	130	{ "version", no_argument, NULL, OPT_VERSION },
	131	{ "db", required_argument, NULL, OPT_DB },
	132	{ "library", required_argument, NULL, OPT_LIBRARY },
	133	{ "strain", required_argument, NULL, OPT_STRAIN },
	134	{ "species", required_argument, NULL, OPT_SPECIES },
	135	{ NULL, 0, NULL, 0 } };
130	136
131	137	/* A contig sequence. */
132		struct Contig {
	138	struct Contig
	139	{
133	140	Contig(const string& comment, const string& seq)
134		: comment(comment), seq(seq) { }
135		Contig(const FastaRecord& o) : comment(o.comment), seq(o.seq) { }
	141	: comment(comment)
	142	, seq(seq)
	143	{}
	144	Contig(const FastaRecord& o)
	145	: comment(o.comment)
	146	, seq(o.seq)
	147	{}
136	148	string comment;
137	149	string seq;
138	150	};

143	155	/** Return the sequence of the specified contig node. The sequence
144	156	* may be ambiguous or reverse complemented.
145	157	*/
146		static Sequence sequence(const Contigs& contigs, const ContigNode& id)
	158	static Sequence
	159	sequence(const Contigs& contigs, const ContigNode& id)
147	160	{
148	161	if (id.ambiguous()) {
149	162	string s(id.ambiguousSequence());

159	172	/** Return a consensus sequence of a and b.
160	173	* @return an empty string if a consensus could not be found
161	174	*/
162		static string createConsensus(const Sequence& a, const Sequence& b)
	175	static string
	176	createConsensus(const Sequence& a, const Sequence& b)
163	177	{
164	178	assert(a.length() == b.length());
165	179	if (a == b)
166	180	return a;
167	181	string s;
168	182	s.reserve(a.length());
169		for (string::const_iterator ita = a.begin(), itb = b.begin();
170		ita != a.end(); ++ita, ++itb) {
	183	for (string::const_iterator ita = a.begin(), itb = b.begin(); ita != a.end(); ++ita, ++itb) {
171	184	bool mask = islower(ita) \|\| islower(itb);
172	185	char ca = toupper(ita), cb = toupper(itb);
173		char c = ca == cb ? ca
174		: ca == 'N' ? cb
175		: cb == 'N' ? ca
176		: ambiguityIsSubset(ca, cb) ? ambiguityOr(ca, cb)
177		: 'x';
	186	char c = ca == cb
	187	? ca
	188	: ca == 'N'
	189	? cb
	190	: cb == 'N' ? ca : ambiguityIsSubset(ca, cb) ? ambiguityOr(ca, cb) : 'x';
178	191	if (c == 'x')
179	192	return string("");
180	193	s += mask ? tolower(c) : c;

182	195	return s;
183	196	}
184	197
185		typedef ContigGraph<DirectedGraph<ContigProperties, Distance> > Graph;
	198	typedef ContigGraph<DirectedGraph<ContigProperties, Distance>> Graph;
186	199	typedef graph_traits<Graph>::vertex_descriptor vertex_descriptor;
187	200
188	201	/** Return the properties of the specified vertex, unless u is
189	202	* ambiguous, in which case return the length of the ambiguous
190	203	* sequence.
191	204	*/
192		static inline
193		ContigProperties get(vertex_bundle_t, const Graph& g, ContigNode u)
194		{
195		return u.ambiguous()
196		? ContigProperties(u.length() + opt::k - 1, 0)
197		: g[u];
	205	static inline ContigProperties
	206	get(vertex_bundle_t, const Graph& g, ContigNode u)
	207	{
	208	return u.ambiguous() ? ContigProperties(u.length() + opt::k - 1, 0) : g[u];
198	209	}
199	210
200	211	/** Append the sequence of contig v to seq. */
201		static void mergeContigs(const Graph& g, const Contigs& contigs,
202		vertex_descriptor u, vertex_descriptor v,
203		Sequence& seq, const ContigPath& path)
	212	static void
	213	mergeContigs(
	214	const Graph& g,
	215	const Contigs& contigs,
	216	vertex_descriptor u,
	217	vertex_descriptor v,
	218	Sequence& seq,
	219	const ContigPath& path)
204	220	{
205	221	int d = get(edge_bundle, g, u, v).distance;
206	222	assert(d < 0);

234	250	unsigned matches = o.overlap_match;
235	251	const string& consensus = o.overlap_str;
236	252	float identity = (float)matches / consensus.size();
237		good = matches >= opt::minOverlap
238		&& identity >= opt::minIdentity;
	253	good = matches >= opt::minOverlap && identity >= opt::minIdentity;
239	254	if (opt::verbose > 2)
240		cerr << matches << " / " << consensus.size()
241		<< " = " << identity
242		<< (matches < opt::minOverlap ? " (too few)"
243		: identity < opt::minIdentity ? " (too low)"
244		: " (good)") << '\n';
	255	cerr << matches << " / " << consensus.size() << " = " << identity
	256	<< (matches < opt::minOverlap
	257	? " (too few)"
	258	: identity < opt::minIdentity ? " (too low)" : " (good)")
	259	<< '\n';
245	260	}
246	261	if (good) {
247	262	assert(overlaps.size() == 1);

251	266	seq += Sequence(s, o.overlap_h_pos + 1);
252	267	} else {
253	268	cerr << "warning: the head of " << get(vertex_name, g, v)
254		<< " does not match the tail of the previous contig\n"
255		<< ao << '\n' << bo << '\n' << path << endl;
	269	<< " does not match the tail of the previous contig\n"
	270	<< ao << '\n'
	271	<< bo << '\n'
	272	<< path << endl;
256	273	seq += 'n';
257	274	seq += s;
258	275	}
259	276	}
260	277
261	278	/** Return a FASTA comment for the specified path. */
262		static void pathToComment(ostream& out,
263		const Graph& g, const ContigPath& path)
	279	static void
	280	pathToComment(ostream& out, const Graph& g, const ContigPath& path)
264	281	{
265	282	out << get(vertex_name, g, path.front());
266	283	if (path.size() == 1)

273	290	}
274	291
275	292	/** Merge the specified path. */
276		static Contig mergePath(const Graph& g, const Contigs& contigs,
277		const ContigPath& path)
	293	static Contig
	294	mergePath(const Graph& g, const Contigs& contigs, const ContigPath& path)
278	295	{
279	296	Sequence seq;
280	297	unsigned coverage = 0;
281		for (ContigPath::const_iterator it = path.begin();
282		it != path.end(); ++it) {
	298	for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it) {
283	299	if (!it->ambiguous())
284	300	coverage += g[*it].coverage;
285	301	if (seq.empty()) {
286	302	seq = sequence(contigs, *it);
287	303	} else {
288	304	assert(it != path.begin());
289		mergeContigs(g, contigs, (it-1), it, seq, path);
	305	mergeContigs(g, contigs, (it - 1), it, seq, path);
290	306	}
291	307	}
292	308	ostringstream ss;

301	317	/** Read contig paths from the specified file.
302	318	* @param ids [out] the string ID of the paths
303	319	*/
304		static ContigPaths readPaths(const string& inPath,
305		vector<string>* ids = NULL)
	320	static ContigPaths
	321	readPaths(const string& inPath, vector<string>* ids = NULL)
306	322	{
307	323	if (ids != NULL)
308	324	assert(ids->empty());

324	340
325	341	++count;
326	342	if (opt::verbose > 1 && count % 1000000 == 0)
327		cerr << "Read " << count << " paths. "
328		"Using " << toSI(getMemoryUsage())
329		<< "B of memory.\n";
	343	cerr << "Read " << count
	344	<< " paths. "
	345	"Using "
	346	<< toSI(getMemoryUsage()) << "B of memory.\n";
330	347	}
331	348	if (opt::verbose > 0)
332		cerr << "Read " << count << " paths. "
333		"Using " << toSI(getMemoryUsage()) << "B of memory.\n";
	349	cerr << "Read " << count
	350	<< " paths. "
	351	"Using "
	352	<< toSI(getMemoryUsage()) << "B of memory.\n";
334	353	if (!opt::db.empty())
335	354	addToDb(db, "Init_paths", count);
336	355	opt::pathCount = count;

340	359
341	360	/** Finds all contigs used in each path in paths, and
342	361	* marks them as seen in the vector seen. */
343		static void seenContigs(vector<bool>& seen, const ContigPaths& paths)
344		{
345		for (ContigPaths::const_iterator it = paths.begin();
346		it != paths.end(); ++it)
347		for (ContigPath::const_iterator itc = it->begin();
348		itc != it->end(); ++itc)
	362	static void
	363	seenContigs(vector<bool>& seen, const ContigPaths& paths)
	364	{
	365	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it)
	366	for (ContigPath::const_iterator itc = it->begin(); itc != it->end(); ++itc)
349	367	if (itc->id() < seen.size())
350	368	seen[itc->id()] = true;
351	369	}

353	371	/** Mark contigs for removal. An empty path indicates that a contig
354	372	* should be removed.
355	373	*/
356		static void markRemovedContigs(vector<bool>& marked,
357		const vector<string>& pathIDs, const ContigPaths& paths)
358		{
359		for (ContigPaths::const_iterator it = paths.begin();
360		it != paths.end(); ++it) {
	374	static void
	375	markRemovedContigs(vector<bool>& marked, const vector<string>& pathIDs, const ContigPaths& paths)
	376	{
	377	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
361	378	if (it->empty()) {
362		size_t i = get(g_contigNames,
363		pathIDs[it - paths.begin()]);
	379	size_t i = get(g_contigNames, pathIDs[it - paths.begin()]);
364	380	assert(i < marked.size());
365	381	marked[i] = true;
366	382	}

368	384	}
369	385
370	386	/** Output the updated overlap graph. */
371		static void outputGraph(Graph& g,
372		const vector<string>& pathIDs, const ContigPaths& paths,
373		const string& commandLine)
	387	static void
	388	outputGraph(
	389	Graph& g,
	390	const vector<string>& pathIDs,
	391	const ContigPaths& paths,
	392	const string& commandLine)
374	393	{
375	394	typedef graph_traits<Graph>::vertex_descriptor V;
376	395
377	396	// Add the path vertices.
378	397	g_contigNames.unlock();
379		for (ContigPaths::const_iterator it = paths.begin();
380		it != paths.end(); ++it) {
	398	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
381	399	const ContigPath& path = *it;
382	400	const string& id = pathIDs[it - paths.begin()];
383	401	if (!path.empty()) {

388	406	g_contigNames.lock();
389	407
390	408	// Remove the vertices that are used in paths.
391		for (ContigPaths::const_iterator it = paths.begin();
392		it != paths.end(); ++it) {
	409	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
393	410	const ContigPath& path = *it;
394	411	const string& id = pathIDs[it - paths.begin()];
395	412	if (path.empty()) {
396	413	remove_vertex(find_vertex(id, false, g), g);
397	414	} else {
398		remove_vertex_if(g, path.begin(), path.end(),
399		not1(std::mem_fun_ref(&ContigNode::ambiguous)));
	415	remove_vertex_if(
	416	g, path.begin(), path.end(), [](const ContigNode& c) { return !c.ambiguous(); });
400	417	}
401	418	}
402	419

413	430	printGraphStats(cerr, g);
414	431	}
415	432
416		int main(int argc, char** argv)
	433	int
	434	main(int argc, char** argv)
417	435	{
418	436	opt::trimMasked = false;
419	437

421	439	{
422	440	ostringstream ss;
423	441	char** last = argv + argc - 1;
424		copy(argv, last, ostream_iterator<const char *>(ss, " "));
	442	copy(argv, last, ostream_iterator<const char*>(ss, " "));
425	443	ss << *last;
426	444	commandLine = ss.str();
427	445	}

430	448	opt::metaVars.resize(3);
431	449
432	450	bool die = false;
433		for (int c; (c = getopt_long(argc, argv,
434		shortopts, longopts, NULL)) != -1;) {
	451	for (int c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) {
435	452	istringstream arg(optarg != NULL ? optarg : "");
436	453	switch (c) {
437		case '?': die = true; break;
438		case 'g': arg >> opt::graphPath; break;
439		case 'k': arg >> opt::k; break;
440		case 'o': arg >> opt::out; break;
441		case 'v': opt::verbose++; break;
442		case OPT_HELP:
443		cout << USAGE_MESSAGE;
444		exit(EXIT_SUCCESS);
445		case OPT_VERSION:
446		cout << VERSION_MESSAGE;
447		exit(EXIT_SUCCESS);
448		case OPT_DB:
449		arg >> opt::db; break;
450		case OPT_LIBRARY:
451		arg >> opt::metaVars[0]; break;
452		case OPT_STRAIN:
453		arg >> opt::metaVars[1]; break;
454		case OPT_SPECIES:
455		arg >> opt::metaVars[2]; break;
	454	case '?':
	455	die = true;
	456	break;
	457	case 'g':
	458	arg >> opt::graphPath;
	459	break;
	460	case 'k':
	461	arg >> opt::k;
	462	break;
	463	case 'o':
	464	arg >> opt::out;
	465	break;
	466	case 'v':
	467	opt::verbose++;
	468	break;
	469	case OPT_HELP:
	470	cout << USAGE_MESSAGE;
	471	exit(EXIT_SUCCESS);
	472	case OPT_VERSION:
	473	cout << VERSION_MESSAGE;
	474	exit(EXIT_SUCCESS);
	475	case OPT_DB:
	476	arg >> opt::db;
	477	break;
	478	case OPT_LIBRARY:
	479	arg >> opt::metaVars[0];
	480	break;
	481	case OPT_STRAIN:
	482	arg >> opt::metaVars[1];
	483	break;
	484	case OPT_SPECIES:
	485	arg >> opt::metaVars[2];
	486	break;
456	487	}
457	488	if (optarg != NULL && !arg.eof()) {
458		cerr << PROGRAM ": invalid option: `-"
459		<< (char)c << optarg << "'\n";
	489	cerr << PROGRAM ": invalid option: `-" << (char)c << optarg << "'\n";
460	490	exit(EXIT_FAILURE);
461	491	}
462	492	}

467	497	}
468	498
469	499	if (opt::out.empty()) {
470		cerr << PROGRAM ": " << "missing -o,--out option\n";
	500	cerr << PROGRAM ": "
	501	<< "missing -o,--out option\n";
471	502	die = true;
472	503	}
473	504

482	513	}
483	514
484	515	if (die) {
485		cerr << "Try `" << PROGRAM
486		<< " --help' for more information.\n";
	516	cerr << "Try `" << PROGRAM << " --help' for more information.\n";
487	517	exit(EXIT_FAILURE);
488	518	}
489	519
490	520	if (!opt::db.empty()) {
491		init(db,
492		opt::db,
493		opt::verbose,
494		PROGRAM,
495		opt::getCommand(argc, argv),
496		opt::metaVars
497		);
	521	init(db, opt::db, opt::verbose, PROGRAM, opt::getCommand(argc, argv), opt::metaVars);
498	522	addToDb(db, "K", opt::k);
499	523	}
500	524

512	536	fin >> g;
513	537	assert(fin.eof());
514	538	if (opt::verbose > 0)
515		cerr << "Read " << num_vertices(g) << " vertices. "
516		"Using " << toSI(getMemoryUsage())
517		<< "B of memory.\n";
	539	cerr << "Read " << num_vertices(g)
	540	<< " vertices. "
	541	"Using "
	542	<< toSI(getMemoryUsage()) << "B of memory.\n";
518	543	if (!opt::db.empty()) {
519	544	addToDb(db, "Init_vertices", num_vertices(g));
520	545	addToDb(db, "Init_edges", num_edges(g));

530	555	unsigned count = 0;
531	556	FastaReader in(contigFile, FastaReader::NO_FOLD_CASE);
532	557	for (FastaRecord rec; in >> rec;) {
533		if (!adjPath.empty()
534		&& g_contigNames.count(rec.id) == 0)
	558	if (!adjPath.empty() && g_contigNames.count(rec.id) == 0)
535	559	continue;
536	560	if (adjPath.empty()) {
537		graph_traits<Graph>::vertex_descriptor
538		u = add_vertex(ContigProperties(rec.seq.length(), 0), g);
	561	graph_traits<Graph>::vertex_descriptor u =
	562	add_vertex(ContigProperties(rec.seq.length(), 0), g);
539	563	put(vertex_name, g, u, rec.id);
540	564	}
541	565	assert(get(g_contigNames, rec.id) == contigs.size());

543	567
544	568	++count;
545	569	if (opt::verbose > 1 && count % 1000000 == 0)
546		cerr << "Read " << count << " sequences. "
547		"Using " << toSI(getMemoryUsage())
548		<< "B of memory.\n";
	570	cerr << "Read " << count
	571	<< " sequences. "
	572	"Using "
	573	<< toSI(getMemoryUsage()) << "B of memory.\n";
549	574	}
550	575	if (opt::verbose > 0)
551		cerr << "Read " << count << " sequences. "
552		"Using " << toSI(getMemoryUsage())
553		<< "B of memory.\n";
	576	cerr << "Read " << count
	577	<< " sequences. "
	578	"Using "
	579	<< toSI(getMemoryUsage()) << "B of memory.\n";
554	580	if (!opt::db.empty())
555	581	addToDb(db, "Init_seq", count);
556	582	assert(in.eof());

570	596	// Output those contigs that were not seen in a path.
571	597	Histogram lengthHistogram;
572	598	ofstream fout;
573		ostream& out = opt::out == "-" ? cout
574		: (fout.open(opt::out.c_str()), fout);
	599	ostream& out = opt::out == "-" ? cout : (fout.open(opt::out.c_str()), fout);
575	600	assert_good(out, opt::out);
576	601	if (!opt::onlyMerged) {
577		for (Contigs::const_iterator it = contigs.begin();
578		it != contigs.end(); ++it) {
	602	for (Contigs::const_iterator it = contigs.begin(); it != contigs.end(); ++it) {
579	603	ContigID id(it - contigs.begin());
580	604	if (!seen[id]) {
581	605	const Contig& contig = *it;

584	608	out << ' ' << contig.comment;
585	609	out << '\n' << contig.seq << '\n';
586	610	if (opt::verbose > 0)
587		lengthHistogram.insert(
588		count_if(contig.seq.begin(), contig.seq.end(),
589		isACGT));
	611	lengthHistogram.insert(count_if(contig.seq.begin(), contig.seq.end(), isACGT));
590	612	}
591	613	}
592	614	}
593	615
594	616	unsigned npaths = 0;
595		for (ContigPaths::const_iterator it = paths.begin();
596		it != paths.end(); ++it) {
	617	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
597	618	const ContigPath& path = *it;
598	619	if (path.empty())
599	620	continue;
600	621	Contig contig = mergePath(g, contigs, path);
601		out << '>' << pathIDs[it - paths.begin()]
602		<< ' ' << contig.comment << '\n'
603		<< contig.seq << '\n';
	622	out << '>' << pathIDs[it - paths.begin()] << ' ' << contig.comment << '\n'
	623	<< contig.seq << '\n';
604	624	assert_good(out, opt::out);
605	625	npaths++;
606	626	if (opt::verbose > 0)
607		lengthHistogram.insert(
608		count_if(contig.seq.begin(), contig.seq.end(),
609		isACGT));
	627	lengthHistogram.insert(count_if(contig.seq.begin(), contig.seq.end(), isACGT));
610	628	}
611	629
612	630	if (!opt::graphPath.empty())

616	634	return 0;
617	635
618	636	float minCov = numeric_limits<float>::infinity(),
619		minCovUsed = numeric_limits<float>::infinity();
	637	minCovUsed = numeric_limits<float>::infinity();
620	638	for (unsigned i = 0; i < contigs.size(); i++) {
621	639	ContigProperties vp = g[ContigNode(i, false)];
622	640	if (vp.coverage == 0 \|\| vp.length < opt::k)

627	645	minCovUsed = min(minCovUsed, cov);
628	646	}
629	647
630		cerr << "The minimum coverage of single-end contigs is "
631		<< minCov << ".\n"
632		<< "The minimum coverage of merged contigs is "
633		<< minCovUsed << ".\n";
	648	cerr << "The minimum coverage of single-end contigs is " << minCov << ".\n"
	649	<< "The minimum coverage of merged contigs is " << minCovUsed << ".\n";
634	650	if (minCov < minCovUsed)
635	651	cerr << "Consider increasing the coverage threshold "
636		"parameter, c, to " << minCovUsed << ".\n";
	652	"parameter, c, to "
	653	<< minCovUsed << ".\n";
637	654
638	655	if (opt::verbose > 0) {
639	656	const unsigned STATS_MIN_LENGTH = 200; // bp
640		printContiguityStats(cerr, lengthHistogram, STATS_MIN_LENGTH)
641		<< '\t' << opt::out << '\n';
	657	printContiguityStats(cerr, lengthHistogram, STATS_MIN_LENGTH) << '\t' << opt::out << '\n';
642	658	}
643	659	return 0;
644	660	}

+451

-454

MergePaths/MergePaths.cpp less more

0		#include "config.h"
1	0	#include "Common/Options.h"
2	1	#include "ContigID.h"
3	2	#include "ContigPath.h"
4	3	#include "Functional.h" // for mem_var
5		#include "IOUtil.h"
6		#include "Uncompress.h"
7	4	#include "Graph/Assemble.h"
8	5	#include "Graph/ContigGraph.h"
9	6	#include "Graph/DirectedGraph.h"
10	7	#include "Graph/DotIO.h"
11	8	#include "Graph/GraphAlgorithms.h"
12	9	#include "Graph/GraphUtil.h"
	10	#include "IOUtil.h"
	11	#include "Uncompress.h"
	12	#include "config.h"
	13	#include <algorithm>
13	14	#include <boost/tuple/tuple.hpp>
14		#include <algorithm>
15	15	#include <cassert>
16	16	#include <climits> // for UINT_MAX
17	17	#include <cstdlib>

26	26	#include <set>
27	27	#include <vector>
28	28	#if _OPENMP
29		# include <omp.h>
	29	#include <omp.h>
30	30	#endif
	31	#include "DataBase/DB.h"
31	32	#include "DataBase/Options.h"
32		#include "DataBase/DB.h"
33	33
34	34	using namespace std;
35	35	using boost::tie;

39	39	DB db;
40	40
41	41	static const char VERSION_MESSAGE[] =
42		PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
43		"Written by Jared Simpson and Shaun Jackman.\n"
44		"\n"
45		"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
	42	PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
	43	"Written by Jared Simpson and Shaun Jackman.\n"
	44	"\n"
	45	"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
46	46
47	47	static const char USAGE_MESSAGE[] =
48		"Usage: " PROGRAM " -k<kmer> [OPTION]... LEN PATH\n"
49		"Merge sequences of contigs IDs.\n"
50		"\n"
51		" Arguments:\n"
52		"\n"
53		" LEN lengths of the contigs\n"
54		" PATH sequences of contig IDs\n"
55		"\n"
56		" Options:\n"
57		"\n"
58		" -k, --kmer=KMER_SIZE k-mer size\n"
59		" -s, --seed-length=L minimum length of a seed contig [0]\n"
60		" -G, --genome-size=N expected genome size. Used to calculate NG50\n"
61		" and associated stats [disabled]\n"
62		" -o, --out=FILE write result to FILE\n"
63		" --no-greedy use the non-greedy algorithm [default]\n"
64		" --greedy use the greedy algorithm\n"
65		" -g, --graph=FILE write the path overlap graph to FILE\n"
66		" -j, --threads=N use N parallel threads [1]\n"
67		" -v, --verbose display verbose output\n"
68		" --help display this help and exit\n"
69		" --version output version information and exit\n"
70		" --db=FILE specify path of database repository in FILE\n"
71		" --library=NAME specify library NAME for database\n"
72		" --strain=NAME specify strain NAME for database\n"
73		" --species=NAME specify species NAME for database\n"
74		"\n"
75		"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
	48	"Usage: " PROGRAM " -k<kmer> [OPTION]... LEN PATH\n"
	49	"Merge sequences of contigs IDs.\n"
	50	"\n"
	51	" Arguments:\n"
	52	"\n"
	53	" LEN lengths of the contigs\n"
	54	" PATH sequences of contig IDs\n"
	55	"\n"
	56	" Options:\n"
	57	"\n"
	58	" -k, --kmer=KMER_SIZE k-mer size\n"
	59	" -s, --seed-length=L minimum length of a seed contig [0]\n"
	60	" -G, --genome-size=N expected genome size. Used to calculate NG50\n"
	61	" and associated stats [disabled]\n"
	62	" -o, --out=FILE write result to FILE\n"
	63	" --no-greedy use the non-greedy algorithm [default]\n"
	64	" --greedy use the greedy algorithm\n"
	65	" -g, --graph=FILE write the path overlap graph to FILE\n"
	66	" -j, --threads=N use N parallel threads [1]\n"
	67	" -v, --verbose display verbose output\n"
	68	" --help display this help and exit\n"
	69	" --version output version information and exit\n"
	70	" --db=FILE specify path of database repository in FILE\n"
	71	" --library=NAME specify library NAME for database\n"
	72	" --strain=NAME specify strain NAME for database\n"
	73	" --species=NAME specify species NAME for database\n"
	74	"\n"
	75	"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
76	76
77	77	namespace opt {
78		string db;
79		dbVars metaVars;
80		unsigned k; // used by GraphIO
81		static string out;
82		static int threads = 1;
83
84		/** Minimum length of a seed contig. */
85		static unsigned seedLen;
86
87		/** Use a greedy algorithm. */
88		static int greedy;
89
90		/** Genome size. Used to calculate NG50. */
91		static long long unsigned genomeSize;
92
93		/** Write the path overlap graph to this file. */
94		static string graphPath;
	78	string db;
	79	dbVars metaVars;
	80	unsigned k; // used by GraphIO
	81	static string out;
	82	static int threads = 1;
	83
	84	/** Minimum length of a seed contig. */
	85	static unsigned seedLen;
	86
	87	/** Use a greedy algorithm. */
	88	static int greedy;
	89
	90	/** Genome size. Used to calculate NG50. */
	91	static long long unsigned genomeSize;
	92
	93	/** Write the path overlap graph to this file. */
	94	static string graphPath;
95	95	}
96	96
97	97	static const char shortopts[] = "G:g:j:k:o:s:v";
98	98
99		enum { OPT_HELP = 1, OPT_VERSION, OPT_DB, OPT_LIBRARY, OPT_STRAIN, OPT_SPECIES };
100		//enum { OPT_HELP = 1, OPT_VERSION };
101
102		static const struct option longopts[] = {
103		{ "genome-size", required_argument, NULL, 'G' },
104		{ "graph", no_argument, NULL, 'g' },
105		{ "greedy", no_argument, &opt::greedy, true },
106		{ "no-greedy", no_argument, &opt::greedy, false },
107		{ "kmer", required_argument, NULL, 'k' },
108		{ "out", required_argument, NULL, 'o' },
109		{ "seed-length", required_argument, NULL, 's' },
110		{ "threads", required_argument, NULL, 'j' },
111		{ "verbose", no_argument, NULL, 'v' },
112		{ "help", no_argument, NULL, OPT_HELP },
113		{ "version", no_argument, NULL, OPT_VERSION },
114		{ "db", required_argument, NULL, OPT_DB },
115		{ "library", required_argument, NULL, OPT_LIBRARY },
116		{ "strain", required_argument, NULL, OPT_STRAIN },
117		{ "species", required_argument, NULL, OPT_SPECIES },
118		{ NULL, 0, NULL, 0 }
	99	enum
	100	{
	101	OPT_HELP = 1,
	102	OPT_VERSION,
	103	OPT_DB,
	104	OPT_LIBRARY,
	105	OPT_STRAIN,
	106	OPT_SPECIES
119	107	};
	108	// enum { OPT_HELP = 1, OPT_VERSION };
	109
	110	static const struct option longopts[] = { { "genome-size", required_argument, NULL, 'G' },
	111	{ "graph", no_argument, NULL, 'g' },
	112	{ "greedy", no_argument, &opt::greedy, true },
	113	{ "no-greedy", no_argument, &opt::greedy, false },
	114	{ "kmer", required_argument, NULL, 'k' },
	115	{ "out", required_argument, NULL, 'o' },
	116	{ "seed-length", required_argument, NULL, 's' },
	117	{ "threads", required_argument, NULL, 'j' },
	118	{ "verbose", no_argument, NULL, 'v' },
	119	{ "help", no_argument, NULL, OPT_HELP },
	120	{ "version", no_argument, NULL, OPT_VERSION },
	121	{ "db", required_argument, NULL, OPT_DB },
	122	{ "library", required_argument, NULL, OPT_LIBRARY },
	123	{ "strain", required_argument, NULL, OPT_STRAIN },
	124	{ "species", required_argument, NULL, OPT_SPECIES },
	125	{ NULL, 0, NULL, 0 } };
120	126
121	127	typedef map<ContigID, ContigPath> ContigPathMap;
122	128
123	129	/** Orientation of an edge. */
124		enum dir_type {
	130	enum dir_type
	131	{
125	132	DIR_X, // u--v none
126	133	DIR_F, // u->v forward
127	134	DIR_R, // u<-v reverse

131	138	/** Lengths of contigs measured in k-mer. */
132	139	typedef vector<unsigned> Lengths;
133	140
134		static ContigPath align(const Lengths& lengths,
135		const ContigPath& p1, const ContigPath& p2,
136		ContigNode pivot);
137		static ContigPath align(const Lengths& lengths,
138		const ContigPath& p1, const ContigPath& p2,
139		ContigNode pivot, dir_type& orientation);
	141	static ContigPath
	142	align(const Lengths& lengths, const ContigPath& p1, const ContigPath& p2, ContigNode pivot);
	143	static ContigPath
	144	align(
	145	const Lengths& lengths,
	146	const ContigPath& p1,
	147	const ContigPath& p2,
	148	ContigNode pivot,
	149	dir_type& orientation);
140	150
141	151	static bool gDebugPrint;
142	152
143	153	/**
144		* Build a histogram of the lengths of the assembled paths and unused contigs.
145		* Note: This function does not account for the ammount of overlap between contigs.
146		*/
	154	* Build a histogram of the lengths of the assembled paths and unused contigs.
	155	* Note: This function does not account for the ammount of overlap between contigs.
	156	*/
147	157	static Histogram
148	158	buildAssembledLengthHistogram(const Lengths& lengths, const ContigPaths& paths)
149	159	{

152	162	// Compute the lengths of the paths
153	163	// Mark the vertices that are used in paths
154	164	vector<bool> used(lengths.size());
155		for (ContigPaths::const_iterator pathIt = paths.begin();
156		pathIt != paths.end(); ++pathIt) {
	165	for (ContigPaths::const_iterator pathIt = paths.begin(); pathIt != paths.end(); ++pathIt) {
157	166	const ContigPath& path = *pathIt;
158	167	size_t totalLength = 0;
159	168	for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it) {

183	192	Histogram h = buildAssembledLengthHistogram(lengths, paths);
184	193	const unsigned STATS_MIN_LENGTH = opt::seedLen;
185	194	printContiguityStats(cerr, h, STATS_MIN_LENGTH, true, "\t", opt::genomeSize)
186		<< '\t' << opt::out << '\n';
	195	<< '\t' << opt::out << '\n';
187	196	}
188	197
189	198	/** Return all contigs that are tandem repeats, identified as those
190	199	* contigs that appear more than once in a single path.
191	200	*/
192		static set<ContigID> findRepeats(const ContigPathMap& paths)
	201	static set<ContigID>
	202	findRepeats(const ContigPathMap& paths)
193	203	{
194	204	set<ContigID> repeats;
195		for (ContigPathMap::const_iterator pathIt = paths.begin();
196		pathIt != paths.end(); ++pathIt) {
	205	for (ContigPathMap::const_iterator pathIt = paths.begin(); pathIt != paths.end(); ++pathIt) {
197	206	const ContigPath& path = pathIt->second;
198	207	map<ContigID, unsigned> count;
199		for (ContigPath::const_iterator it = path.begin();
200		it != path.end(); ++it)
	208	for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it)
201	209	if (!it->ambiguous())
202	210	count[it->contigIndex()]++;
203		for (map<ContigID, unsigned>::const_iterator
204		it = count.begin(); it != count.end(); ++it)
	211	for (map<ContigID, unsigned>::const_iterator it = count.begin(); it != count.end(); ++it)
205	212	if (it->second > 1)
206	213	repeats.insert(it->first);
207	214	}

211	218	/** Remove tandem repeats from the set of paths.
212	219	* @return the removed paths
213	220	*/
214		static set<ContigID> removeRepeats(ContigPathMap& paths)
	221	static set<ContigID>
	222	removeRepeats(ContigPathMap& paths)
215	223	{
216	224	set<ContigID> repeats = findRepeats(paths);
217	225	if (gDebugPrint) {
218	226	cout << "Repeats:";
219	227	if (!repeats.empty()) {
220		for (set<ContigID>::const_iterator it = repeats.begin();
221		it != repeats.end(); ++it)
	228	for (set<ContigID>::const_iterator it = repeats.begin(); it != repeats.end(); ++it)
222	229	cout << ' ' << get(g_contigNames, *it);
223	230	} else
224	231	cout << " none";

226	233	}
227	234
228	235	unsigned removed = 0;
229		for (set<ContigID>::const_iterator it = repeats.begin();
230		it != repeats.end(); ++it)
	236	for (set<ContigID>::const_iterator it = repeats.begin(); it != repeats.end(); ++it)
231	237	if (paths.count(*it) > 0)
232	238	removed++;
233	239	if (removed == paths.size()) {

238	244	}
239	245
240	246	ostringstream ss;
241		for (set<ContigID>::const_iterator it = repeats.begin();
242		it != repeats.end(); ++it)
	247	for (set<ContigID>::const_iterator it = repeats.begin(); it != repeats.end(); ++it)
243	248	if (paths.erase(*it) > 0)
244	249	ss << ' ' << get(g_contigNames, *it);
245	250

248	253	return repeats;
249	254	}
250	255
251		static void appendToMergeQ(deque<ContigNode>& mergeQ,
252		set<ContigNode>& seen, const ContigPath& path)
253		{
254		for (ContigPath::const_iterator it = path.begin();
255		it != path.end(); ++it)
	256	static void
	257	appendToMergeQ(deque<ContigNode>& mergeQ, set<ContigNode>& seen, const ContigPath& path)
	258	{
	259	for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it)
256	260	if (!it->ambiguous() && seen.insert(*it).second)
257	261	mergeQ.push_back(*it);
258	262	}
259	263
260	264	/** A path overlap graph. */
261		typedef ContigGraph<DirectedGraph<> > PathGraph;
	265	typedef ContigGraph<DirectedGraph<>> PathGraph;
262	266
263	267	/** Add an edge if the two paths overlap.
264	268	* @param pivot the pivot at which to seed the alignment
265	269	* @return whether an overlap was found
266	270	*/
267		static bool addOverlapEdge(const Lengths& lengths,
268		PathGraph& gout, ContigNode pivot,
269		ContigNode seed1, const ContigPath& path1,
270		ContigNode seed2, const ContigPath& path2)
	271	static bool
	272	addOverlapEdge(
	273	const Lengths& lengths,
	274	PathGraph& gout,
	275	ContigNode pivot,
	276	ContigNode seed1,
	277	const ContigPath& path1,
	278	ContigNode seed2,
	279	const ContigPath& path2)
271	280	{
272	281	assert(seed1 != seed2);
273	282
274	283	// Determine the orientation of the overlap edge.
275	284	dir_type orientation = DIR_X;
276		ContigPath consensus = align(lengths,
277		path1, path2, pivot, orientation);
	285	ContigPath consensus = align(lengths, path1, path2, pivot, orientation);
278	286	if (consensus.empty())
279	287	return false;
280	288	assert(orientation != DIR_X);
281	289	if (orientation == DIR_B) {
282	290	// One of the paths subsumes the other. Use the order of the
283	291	// seeds to determine the orientation of the edge.
284		orientation = find(consensus.begin(), consensus.end(), seed1)
285		< find(consensus.begin(), consensus.end(), seed2)
286		? DIR_F : DIR_R;
	292	orientation = find(consensus.begin(), consensus.end(), seed1) <
	293	find(consensus.begin(), consensus.end(), seed2)
	294	? DIR_F
	295	: DIR_R;
287	296	}
288	297	assert(orientation == DIR_F \|\| orientation == DIR_R);
289	298

300	309	}
301	310
302	311	/** Return the specified path. */
303		static ContigPath getPath(const ContigPathMap& paths, ContigNode u)
	312	static ContigPath
	313	getPath(const ContigPathMap& paths, ContigNode u)
304	314	{
305	315	ContigPathMap::const_iterator it = paths.find(u.contigIndex());
306	316	assert(it != paths.end());

311	321	}
312	322
313	323	/** Find the overlaps between paths and add edges to the graph. */
314		static void findPathOverlaps(const Lengths& lengths,
315		const ContigPathMap& paths,
316		const ContigNode& seed1, const ContigPath& path1,
317		PathGraph& gout)
318		{
319		for (ContigPath::const_iterator it = path1.begin();
320		it != path1.end(); ++it) {
	324	static void
	325	findPathOverlaps(
	326	const Lengths& lengths,
	327	const ContigPathMap& paths,
	328	const ContigNode& seed1,
	329	const ContigPath& path1,
	330	PathGraph& gout)
	331	{
	332	for (ContigPath::const_iterator it = path1.begin(); it != path1.end(); ++it) {
321	333	ContigNode seed2 = *it;
322	334	if (seed1 == seed2)
323	335	continue;
324	336	if (seed2.ambiguous())
325	337	continue;
326		ContigPathMap::const_iterator path2It
327		= paths.find(seed2.contigIndex());
	338	ContigPathMap::const_iterator path2It = paths.find(seed2.contigIndex());
328	339	if (path2It == paths.end())
329	340	continue;
330	341
331	342	ContigPath path2 = path2It->second;
332	343	if (seed2.sense())
333	344	reverseComplement(path2.begin(), path2.end());
334		addOverlapEdge(lengths,
335		gout, seed2, seed1, path1, seed2, path2);
	345	addOverlapEdge(lengths, gout, seed2, seed1, path1, seed2, path2);
336	346	}
337	347	}
338	348
339	349	/** Attempt to merge the paths specified in mergeQ with path.
340	350	* @return the number of paths merged
341	351	*/
342		static unsigned mergePaths(const Lengths& lengths,
343		ContigPath& path,
344		deque<ContigNode>& mergeQ, set<ContigNode>& seen,
345		const ContigPathMap& paths)
	352	static unsigned
	353	mergePaths(
	354	const Lengths& lengths,
	355	ContigPath& path,
	356	deque<ContigNode>& mergeQ,
	357	set<ContigNode>& seen,
	358	const ContigPathMap& paths)
346	359	{
347	360	unsigned merged = 0;
348	361	deque<ContigNode> invalid;
349	362	for (ContigNode pivot; !mergeQ.empty(); mergeQ.pop_front()) {
350	363	pivot = mergeQ.front();
351		ContigPathMap::const_iterator path2It
352		= paths.find(pivot.contigIndex());
	364	ContigPathMap::const_iterator path2It = paths.find(pivot.contigIndex());
353	365	if (path2It == paths.end())
354	366	continue;
355	367

366	378	path.swap(consensus);
367	379	if (gDebugPrint)
368	380	#pragma omp critical(cout)
369		cout << get(g_contigNames, pivot)
370		<< '\t' << path2 << '\n'
371		<< '\t' << path << '\n';
	381	cout << get(g_contigNames, pivot) << '\t' << path2 << '\n' << '\t' << path << '\n';
372	382	merged++;
373	383	}
374	384	mergeQ.swap(invalid);

378	388	/** Merge the paths of the specified seed path.
379	389	* @return the merged contig path
380	390	*/
381		static ContigPath mergePath(const Lengths& lengths,
382		const ContigPathMap& paths, const ContigPath& seedPath)
	391	static ContigPath
	392	mergePath(const Lengths& lengths, const ContigPathMap& paths, const ContigPath& seedPath)
383	393	{
384	394	assert(!seedPath.empty());
385	395	ContigNode seed1 = seedPath.front();
386		ContigPathMap::const_iterator path1It
387		= paths.find(seed1.contigIndex());
	396	ContigPathMap::const_iterator path1It = paths.find(seed1.contigIndex());
388	397	assert(path1It != paths.end());
389	398	ContigPath path(path1It->second);
390	399	if (seedPath.front().sense())

392	401	if (opt::verbose > 1)
393	402	#pragma omp critical(cout)
394	403	cout << "\n* " << seedPath << '\n'
395		<< get(g_contigNames, seedPath.front())
396		<< '\t' << path << '\n';
397		for (ContigPath::const_iterator it = seedPath.begin() + 1;
398		it != seedPath.end(); ++it) {
	404	<< get(g_contigNames, seedPath.front()) << '\t' << path << '\n';
	405	for (ContigPath::const_iterator it = seedPath.begin() + 1; it != seedPath.end(); ++it) {
399	406	ContigNode seed2 = *it;
400		ContigPathMap::const_iterator path2It
401		= paths.find(seed2.contigIndex());
	407	ContigPathMap::const_iterator path2It = paths.find(seed2.contigIndex());
402	408	assert(path2It != paths.end());
403	409	ContigPath path2 = path2It->second;
404	410	if (seed2.sense())
405	411	reverseComplement(path2.begin(), path2.end());
406	412
407		ContigNode pivot
408		= find(path.begin(), path.end(), seed2) != path.end()
409		? seed2 : seed1;
	413	ContigNode pivot = find(path.begin(), path.end(), seed2) != path.end() ? seed2 : seed1;
410	414	ContigPath consensus = align(lengths, path, path2, pivot);
411	415	if (consensus.empty()) {
412	416	// This seed could be removed from the seed path.
413	417	if (opt::verbose > 1)
414	418	#pragma omp critical(cout)
415		cout << get(g_contigNames, seed2)
416		<< '\t' << path2 << '\n'
417		<< "\tinvalid\n";
	419	cout << get(g_contigNames, seed2) << '\t' << path2 << '\n' << "\tinvalid\n";
418	420	} else {
419	421	path.swap(consensus);
420	422	if (opt::verbose > 1)
421	423	#pragma omp critical(cout)
422		cout << get(g_contigNames, seed2)
423		<< '\t' << path2 << '\n'
424		<< '\t' << path << '\n';
	424	cout << get(g_contigNames, seed2) << '\t' << path2 << '\n' << '\t' << path << '\n';
425	425	}
426	426	seed1 = seed2;
427	427	}

434	434	/** Merge the specified seed paths.
435	435	* @return the merged contig paths
436	436	*/
437		static ContigPaths mergeSeedPaths(const Lengths& lengths,
438		const ContigPathMap& paths, const ContigPaths& seedPaths)
	437	static ContigPaths
	438	mergeSeedPaths(const Lengths& lengths, const ContigPathMap& paths, const ContigPaths& seedPaths)
439	439	{
440	440	if (opt::verbose > 0)
441	441	cout << "\nMerging paths\n";
442	442
443	443	ContigPaths out;
444	444	out.reserve(seedPaths.size());
445		for (ContigPaths::const_iterator it = seedPaths.begin();
446		it != seedPaths.end(); ++it)
	445	for (ContigPaths::const_iterator it = seedPaths.begin(); it != seedPaths.end(); ++it)
447	446	out.push_back(mergePath(lengths, paths, *it));
448	447	return out;
449	448	}

451	450	/** Extend the specified path as long as is unambiguously possible and
452	451	* add the result to the specified container.
453	452	*/
454		static void extendPaths(const Lengths& lengths,
455		ContigID id, const ContigPathMap& paths,
456		ContigPathMap& out)
	453	static void
	454	extendPaths(const Lengths& lengths, ContigID id, const ContigPathMap& paths, ContigPathMap& out)
457	455	{
458	456	ContigPathMap::const_iterator pathIt = paths.find(id);
459	457	assert(pathIt != paths.end());
460	458
461	459	pair<ContigPathMap::iterator, bool> inserted;
462		#pragma omp critical(out)
	460	#pragma omp critical(out)
463	461	inserted = out.insert(*pathIt);
464	462	assert(inserted.second);
465	463	ContigPath& path = inserted.first->second;
466	464
467	465	if (gDebugPrint)
468		#pragma omp critical(cout)
469		cout << "\n* " << get(g_contigNames, id) << "+\n"
470		<< '\t' << path << '\n';
	466	#pragma omp critical(cout)
	467	cout << "\n* " << get(g_contigNames, id) << "+\n" << '\t' << path << '\n';
471	468
472	469	set<ContigNode> seen;
473	470	seen.insert(ContigNode(id, false));

477	474	;
478	475
479	476	if (!mergeQ.empty() && gDebugPrint) {
480		#pragma omp critical(cout)
	477	#pragma omp critical(cout)
481	478	{
482	479	cout << "invalid\n";
483		for (deque<ContigNode>::const_iterator it
484		= mergeQ.begin(); it != mergeQ.end(); ++it)
485		cout << get(g_contigNames, *it) << '\t'
486		<< paths.find(it->contigIndex())->second << '\n';
	480	for (deque<ContigNode>::const_iterator it = mergeQ.begin(); it != mergeQ.end(); ++it)
	481	cout << get(g_contigNames, *it) << '\t' << paths.find(it->contigIndex())->second
	482	<< '\n';
487	483	}
488	484	}
489	485	}
490	486
491	487	/** Return true if the contigs are equal or both are ambiguous. */
492		static bool equalOrBothAmbiguos(const ContigNode& a,
493		const ContigNode& b)
	488	static bool
	489	equalOrBothAmbiguos(const ContigNode& a, const ContigNode& b)
494	490	{
495	491	return a == b \|\| (a.ambiguous() && b.ambiguous());
496	492	}
497	493
498	494	/** Return true if both paths are equal, ignoring ambiguous nodes. */
499		static bool equalIgnoreAmbiguos(const ContigPath& a,
500		const ContigPath& b)
501		{
502		return a.size() == b.size()
503		&& equal(a.begin(), a.end(), b.begin(), equalOrBothAmbiguos);
	495	static bool
	496	equalIgnoreAmbiguos(const ContigPath& a, const ContigPath& b)
	497	{
	498	return a.size() == b.size() && equal(a.begin(), a.end(), b.begin(), equalOrBothAmbiguos);
504	499	}
505	500
506	501	/** Return whether this path is a cycle. */
507		static bool isCycle(const Lengths& lengths, const ContigPath& path)
	502	static bool
	503	isCycle(const Lengths& lengths, const ContigPath& path)
508	504	{
509	505	return !align(lengths, path, path, path.front()).empty();
510	506	}

513	509	* @param overlaps [out] paths that are found to overlap
514	510	* @return the ID of the subsuming path
515	511	*/
516		static ContigID identifySubsumedPaths(const Lengths& lengths,
517		ContigPathMap::const_iterator path1It,
518		ContigPathMap& paths,
519		set<ContigID>& out,
520		set<ContigID>& overlaps)
	512	static ContigID
	513	identifySubsumedPaths(
	514	const Lengths& lengths,
	515	ContigPathMap::const_iterator path1It,
	516	ContigPathMap& paths,
	517	set<ContigID>& out,
	518	set<ContigID>& overlaps)
521	519	{
522	520	ostringstream vout;
523	521	out.clear();
524	522	ContigID id(path1It->first);
525	523	const ContigPath& path = path1It->second;
526	524	if (gDebugPrint)
527		vout << get(g_contigNames, ContigNode(id, false))
528		<< '\t' << path << '\n';
529
530		for (ContigPath::const_iterator it = path.begin();
531		it != path.end(); ++it) {
	525	vout << get(g_contigNames, ContigNode(id, false)) << '\t' << path << '\n';
	526
	527	for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it) {
532	528	ContigNode pivot = *it;
533	529	if (pivot.ambiguous() \|\| pivot.id() == id)
534	530	continue;
535		ContigPathMap::iterator path2It
536		= paths.find(pivot.contigIndex());
	531	ContigPathMap::iterator path2It = paths.find(pivot.contigIndex());
537	532	if (path2It == paths.end())
538	533	continue;
539	534	ContigPath path2 = path2It->second;

544	539	continue;
545	540	if (equalIgnoreAmbiguos(consensus, path)) {
546	541	if (gDebugPrint)
547		vout << get(g_contigNames, pivot)
548		<< '\t' << path2 << '\n';
	542	vout << get(g_contigNames, pivot) << '\t' << path2 << '\n';
549	543	out.insert(path2It->first);
550	544	} else if (equalIgnoreAmbiguos(consensus, path2)) {
551	545	// This path is larger. Use it as the seed.
552		return identifySubsumedPaths(lengths, path2It, paths, out,
553		overlaps);
	546	return identifySubsumedPaths(lengths, path2It, paths, out, overlaps);
554	547	} else if (isCycle(lengths, consensus)) {
555	548	// The consensus path is a cycle.
556	549	bool isCyclePath1 = isCycle(lengths, path);

558	551	if (!isCyclePath1 && !isCyclePath2) {
559	552	// Neither path is a cycle.
560	553	if (gDebugPrint)
561		vout << get(g_contigNames, pivot)
562		<< '\t' << path2 << '\n'
563		<< "ignored\t" << consensus << '\n';
	554	vout << get(g_contigNames, pivot) << '\t' << path2 << '\n'
	555	<< "ignored\t" << consensus << '\n';
564	556	overlaps.insert(id);
565	557	overlaps.insert(path2It->first);
566	558	} else {
567	559	// At least one path is a cycle.
568	560	if (gDebugPrint)
569		vout << get(g_contigNames, pivot)
570		<< '\t' << path2 << '\n'
571		<< "cycle\t" << consensus << '\n';
	561	vout << get(g_contigNames, pivot) << '\t' << path2 << '\n'
	562	<< "cycle\t" << consensus << '\n';
572	563	if (isCyclePath1 && isCyclePath2)
573	564	out.insert(path2It->first);
574	565	else if (!isCyclePath1)

578	569	}
579	570	} else {
580	571	if (gDebugPrint)
581		vout << get(g_contigNames, pivot)
582		<< '\t' << path2 << '\n'
583		<< "ignored\t" << consensus << '\n';
	572	vout << get(g_contigNames, pivot) << '\t' << path2 << '\n'
	573	<< "ignored\t" << consensus << '\n';
584	574	overlaps.insert(id);
585	575	overlaps.insert(path2It->first);
586	576	}

594	584	* @param overlaps [out] paths that are found to overlap
595	585	* @return the next iterator after path1it
596	586	*/
597		static ContigPathMap::const_iterator removeSubsumedPaths(
598		const Lengths& lengths,
599		ContigPathMap::const_iterator path1It, ContigPathMap& paths,
600		ContigID& seed, set<ContigID>& overlaps)
	587	static ContigPathMap::const_iterator
	588	removeSubsumedPaths(
	589	const Lengths& lengths,
	590	ContigPathMap::const_iterator path1It,
	591	ContigPathMap& paths,
	592	ContigID& seed,
	593	set<ContigID>& overlaps)
601	594	{
602	595	if (gDebugPrint)
603	596	cout << '\n';
604	597	set<ContigID> eq;
605		seed = identifySubsumedPaths(lengths,
606		path1It, paths, eq, overlaps);
	598	seed = identifySubsumedPaths(lengths, path1It, paths, eq, overlaps);
607	599	++path1It;
608		for (set<ContigID>::const_iterator it = eq.begin();
609		it != eq.end(); ++it) {
	600	for (set<ContigID>::const_iterator it = eq.begin(); it != eq.end(); ++it) {
610	601	if (*it == path1It->first)
611	602	++path1It;
612	603	paths.erase(*it);

617	608	/** Remove paths subsumed by another path.
618	609	* @return paths that are found to overlap
619	610	*/
620		static set<ContigID> removeSubsumedPaths(const Lengths& lengths,
621		ContigPathMap& paths)
	611	static set<ContigID>
	612	removeSubsumedPaths(const Lengths& lengths, ContigPathMap& paths)
622	613	{
623	614	set<ContigID> overlaps, seen;
624		for (ContigPathMap::const_iterator iter = paths.begin();
625		iter != paths.end();) {
	615	for (ContigPathMap::const_iterator iter = paths.begin(); iter != paths.end();) {
626	616	if (seen.count(iter->first) == 0) {
627	617	ContigID seed;
628		iter = removeSubsumedPaths(lengths,
629		iter, paths, seed, overlaps);
	618	iter = removeSubsumedPaths(lengths, iter, paths, seed, overlaps);
630	619	seen.insert(seed);
631	620	} else
632	621	++iter;

638	627	* outgoing edges, (u,v1) and (u,v2), add the edge (v1,v2) if v1 < v2,
639	628	* and add the edge (v2,v1) if v2 < v1.
640	629	*/
641		static void addMissingEdges(const Lengths& lengths,
642		PathGraph& g, const ContigPathMap& paths)
	630	static void
	631	addMissingEdges(const Lengths& lengths, PathGraph& g, const ContigPathMap& paths)
643	632	{
644	633	typedef graph_traits<PathGraph>::adjacency_iterator Vit;
645	634	typedef graph_traits<PathGraph>::vertex_iterator Uit;

657	646	++vit1;
658	647	assert(v1 != u);
659	648	ContigPath path1 = getPath(paths, v1);
660		if (find(path1.begin(), path1.end(),
661		ContigPath::value_type(u)) == path1.end())
	649	if (find(path1.begin(), path1.end(), ContigPath::value_type(u)) == path1.end())
662	650	continue;
663	651	for (Vit vit2 = vit1; vit2 != vrange.second; ++vit2) {
664	652	V v2 = *vit2;

667	655	if (edge(v1, v2, g).second \|\| edge(v2, v1, g).second)
668	656	continue;
669	657	ContigPath path2 = getPath(paths, v2);
670		if (find(path2.begin(), path2.end(),
671		ContigPath::value_type(u)) == path2.end())
	658	if (find(path2.begin(), path2.end(), ContigPath::value_type(u)) == path2.end())
672	659	continue;
673		numAdded += addOverlapEdge(lengths,
674		g, u, v1, path1, v2, path2);
	660	numAdded += addOverlapEdge(lengths, g, u, v1, path1, v2, path2);
675	661	}
676	662	}
677	663	}

682	668	}
683	669
684	670	/** Remove transitive edges. */
685		static void removeTransitiveEdges(PathGraph& pathGraph)
	671	static void
	672	removeTransitiveEdges(PathGraph& pathGraph)
686	673	{
687	674	unsigned nbefore = num_edges(pathGraph);
688	675	unsigned nremoved = remove_transitive_edges(pathGraph);
689	676	unsigned nafter = num_edges(pathGraph);
690	677	if (opt::verbose > 0)
691		cout << "Removed " << nremoved << " transitive edges of "
692		<< nbefore << " edges leaving "
693		<< nafter << " edges.\n";
	678	cout << "Removed " << nremoved << " transitive edges of " << nbefore << " edges leaving "
	679	<< nafter << " edges.\n";
694	680	assert(nbefore - nremoved == nafter);
695	681	if (!opt::db.empty()) {
696	682	addToDb(db, "Edges_init", nbefore);

702	688	* Remove the edge (u,v) if deg+(u) > 1 and deg-(v) > 1 and the
703	689	* overlap of (u,v) is small.
704	690	*/
705		static void removeSmallOverlaps(PathGraph& g,
706		const ContigPathMap& paths)
	691	static void
	692	removeSmallOverlaps(PathGraph& g, const ContigPathMap& paths)
707	693	{
708	694	typedef graph_traits<PathGraph>::edge_descriptor E;
709	695	typedef graph_traits<PathGraph>::out_edge_iterator Eit;

725	711	if (in_degree(v, g) < 2)
726	712	continue;
727	713	ContigPath pathv = getPath(paths, v);
728		if (pathu.back() == pathv.front()
729		&& paths.count(pathu.back().contigIndex()) > 0)
	714	if (pathu.back() == pathv.front() && paths.count(pathu.back().contigIndex()) > 0)
730	715	edges.push_back(uv);
731	716	}
732	717	}
733	718	remove_edges(g, edges.begin(), edges.end());
734	719	if (opt::verbose > 0)
735		cout << "Removed " << edges.size()
736		<< " small overlap edges.\n";
	720	cout << "Removed " << edges.size() << " small overlap edges.\n";
737	721	if (!opt::db.empty())
738	722	addToDb(db, "Edges_removed_small_overlap", edges.size());
739	723	}
740	724
741	725	/** Output the path overlap graph. */
742		static void outputPathGraph(PathGraph& pathGraph)
	726	static void
	727	outputPathGraph(PathGraph& pathGraph)
743	728	{
744	729	if (opt::graphPath.empty())
745	730	return;

750	735	}
751	736
752	737	/** Sort and output the specified paths. */
753		static void outputSortedPaths(const Lengths& lengths, const ContigPathMap& paths)
	738	static void
	739	outputSortedPaths(const Lengths& lengths, const ContigPathMap& paths)
754	740	{
755	741	// Sort the paths.
756	742	vector<ContigPath> sortedPaths(paths.size());
757		transform(paths.begin(), paths.end(), sortedPaths.begin(),
758		mem_var(&ContigPathMap::value_type::second));
	743	transform(
	744	paths.begin(),
	745	paths.end(),
	746	sortedPaths.begin(),
	747	mem_var(&ContigPathMap::value_type::second));
759	748	sort(sortedPaths.begin(), sortedPaths.end());
760	749
761	750	// Output the paths.
762	751	ofstream fout(opt::out.c_str());
763	752	ostream& out = opt::out.empty() ? cout : fout;
764	753	assert_good(out, opt::out);
765		for (vector<ContigPath>::const_iterator it = sortedPaths.begin();
766		it != sortedPaths.end(); ++it)
	754	for (vector<ContigPath>::const_iterator it = sortedPaths.begin(); it != sortedPaths.end(); ++it)
767	755	out << createContigName() << '\t' << *it << '\n';
768	756	assert_good(out, opt::out);
769	757

772	760	}
773	761
774	762	/** Assemble the path overlap graph. */
775		static void assemblePathGraph(const Lengths& lengths,
776		PathGraph& pathGraph, ContigPathMap& paths)
	763	static void
	764	assemblePathGraph(const Lengths& lengths, PathGraph& pathGraph, ContigPathMap& paths)
777	765	{
778	766	ContigPaths seedPaths;
779	767	assembleDFS(pathGraph, back_inserter(seedPaths));
780		ContigPaths mergedPaths = mergeSeedPaths(lengths,
781		paths, seedPaths);
	768	ContigPaths mergedPaths = mergeSeedPaths(lengths, paths, seedPaths);
782	769	if (opt::verbose > 1)
783	770	cout << '\n';
784	771
785	772	// Replace each path with the merged path.
786		for (ContigPaths::const_iterator it1 = seedPaths.begin();
787		it1 != seedPaths.end(); ++it1) {
	773	for (ContigPaths::const_iterator it1 = seedPaths.begin(); it1 != seedPaths.end(); ++it1) {
788	774	const ContigPath& path(mergedPaths[it1 - seedPaths.begin()]);
789	775	ContigPath pathrc(path);
790	776	reverseComplement(pathrc.begin(), pathrc.end());
791		for (ContigPath::const_iterator it2 = it1->begin();
792		it2 != it1->end(); ++it2) {
	777	for (ContigPath::const_iterator it2 = it1->begin(); it2 != it1->end(); ++it2) {
793	778	ContigNode seed(*it2);
794	779	if (find(path.begin(), path.end(), seed) != path.end()) {
795		paths[seed.contigIndex()]
796		= seed.sense() ? pathrc : path;
	780	paths[seed.contigIndex()] = seed.sense() ? pathrc : path;
797	781	} else {
798	782	// This seed was not included in the merged path.
799	783	}

811	795	}
812	796
813	797	/** Read a set of paths from the specified file. */
814		static ContigPathMap readPaths(const Lengths& lengths,
815		const string& filePath)
	798	static ContigPathMap
	799	readPaths(const Lengths& lengths, const string& filePath)
816	800	{
817	801	if (opt::verbose > 0)
818	802	cerr << "Reading `" << filePath << "'..." << endl;

832	816	continue;
833	817	}
834	818
835		bool inserted = paths.insert(
836		make_pair(id, path)).second;
	819	bool inserted = paths.insert(make_pair(id, path)).second;
837	820	assert(inserted);
838	821	(void)inserted;
839	822	}
840	823	assert(in.eof());
841	824
842	825	if (opt::seedLen > 0)
843		cout << "Ignored " << tooSmall
844		<< " paths whose seeds are shorter than "
845		<< opt::seedLen << " bp.\n";
	826	cout << "Ignored " << tooSmall << " paths whose seeds are shorter than " << opt::seedLen
	827	<< " bp.\n";
846	828	return paths;
847	829	}
848	830

850	832	* @return true if out != last
851	833	*/
852	834	template<class T1, class T2, class T3>
853		bool atomicInc(T1& it, T2 last, T3& out)
854		{
855		#pragma omp critical(atomicInc)
	835	bool
	836	atomicInc(T1& it, T2 last, T3& out)
	837	{
	838	#pragma omp critical(atomicInc)
856	839	out = it == last ? it : it++;
857	840	return out != last;
858	841	}
859	842
860	843	/** Build the path overlap graph. */
861		static void buildPathGraph(const Lengths& lengths,
862		PathGraph& g, const ContigPathMap& paths)
	844	static void
	845	buildPathGraph(const Lengths& lengths, PathGraph& g, const ContigPathMap& paths)
863	846	{
864	847	// Create the vertices of the path overlap graph.
865	848	PathGraph(lengths.size()).swap(g);

873	856
874	857	// Find the overlapping paths.
875	858	ContigPathMap::const_iterator sharedIt = paths.begin();
876		#pragma omp parallel
877		for (ContigPathMap::const_iterator it;
878		atomicInc(sharedIt, paths.end(), it);)
879		findPathOverlaps(lengths, paths,
880		ContigNode(it->first, false), it->second, g);
	859	#pragma omp parallel
	860	for (ContigPathMap::const_iterator it; atomicInc(sharedIt, paths.end(), it);)
	861	findPathOverlaps(lengths, paths, ContigNode(it->first, false), it->second, g);
881	862	if (gDebugPrint)
882	863	cout << '\n';
883	864

889	870
890	871	// graph statistics
891	872	vector<int> vals = passGraphStatsVal(g);
892		vector<string> keys = make_vector<string>()
893		<< "V"
894		<< "E"
895		<< "degree0pctg"
896		<< "degree1pctg"
897		<< "degree234pctg"
898		<< "degree5pctg"
899		<< "degree_max";
	873	vector<string> keys = make_vector<string>() << "V"
	874	<< "E"
	875	<< "degree0pctg"
	876	<< "degree1pctg"
	877	<< "degree234pctg"
	878	<< "degree5pctg"
	879	<< "degree_max";
900	880	if (!opt::db.empty()) {
901		for (unsigned i=0; i<vals.size(); i++)
	881	for (unsigned i = 0; i < vals.size(); i++)
902	882	addToDb(db, keys[i], vals[i]);
903	883	}
904	884	outputPathGraph(g);
905	885	}
906	886
907	887	/** Read contig lengths. */
908		static Lengths readContigLengths(istream& in)
	888	static Lengths
	889	readContigLengths(istream& in)
909	890	{
910	891	assert(in);
911	892	assert(g_contigNames.empty());

925	906	}
926	907
927	908	/** Read contig lengths. */
928		static Lengths readContigLengths(const string& path)
	909	static Lengths
	910	readContigLengths(const string& path)
929	911	{
930	912	ifstream fin(path.c_str());
931	913	if (path != "-")

934	916	return readContigLengths(in);
935	917	}
936	918
937		int main(int argc, char** argv)
	919	int
	920	main(int argc, char** argv)
938	921	{
939	922	if (!opt::db.empty())
940	923	opt::metaVars.resize(3);
941	924
942	925	bool die = false;
943		for (int c; (c = getopt_long(argc, argv,
944		shortopts, longopts, NULL)) != -1;) {
	926	for (int c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) {
945	927	istringstream arg(optarg != NULL ? optarg : "");
946	928	switch (c) {
947		case '?': die = true; break;
948		case 'G': {
949		double x;
950		arg >> x;
951		opt::genomeSize = x;
952		break;
953		}
954		case 'g': arg >> opt::graphPath; break;
955		case 'j': arg >> opt::threads; break;
956		case 'k': arg >> opt::k; break;
957		case 'o': arg >> opt::out; break;
958		case 's': arg >> opt::seedLen; break;
959		case 'v': opt::verbose++; break;
960		case OPT_HELP:
961		cout << USAGE_MESSAGE;
962		exit(EXIT_SUCCESS);
963		case OPT_VERSION:
964		cout << VERSION_MESSAGE;
965		exit(EXIT_SUCCESS);
966		case OPT_DB:
967		arg >> opt::db; break;
968		case OPT_LIBRARY:
969		arg >> opt::metaVars[0]; break;
970		case OPT_STRAIN:
971		arg >> opt::metaVars[1]; break;
972		case OPT_SPECIES:
973		arg >> opt::metaVars[2]; break;
	929	case '?':
	930	die = true;
	931	break;
	932	case 'G': {
	933	double x;
	934	arg >> x;
	935	opt::genomeSize = x;
	936	break;
	937	}
	938	case 'g':
	939	arg >> opt::graphPath;
	940	break;
	941	case 'j':
	942	arg >> opt::threads;
	943	break;
	944	case 'k':
	945	arg >> opt::k;
	946	break;
	947	case 'o':
	948	arg >> opt::out;
	949	break;
	950	case 's':
	951	arg >> opt::seedLen;
	952	break;
	953	case 'v':
	954	opt::verbose++;
	955	break;
	956	case OPT_HELP:
	957	cout << USAGE_MESSAGE;
	958	exit(EXIT_SUCCESS);
	959	case OPT_VERSION:
	960	cout << VERSION_MESSAGE;
	961	exit(EXIT_SUCCESS);
	962	case OPT_DB:
	963	arg >> opt::db;
	964	break;
	965	case OPT_LIBRARY:
	966	arg >> opt::metaVars[0];
	967	break;
	968	case OPT_STRAIN:
	969	arg >> opt::metaVars[1];
	970	break;
	971	case OPT_SPECIES:
	972	arg >> opt::metaVars[2];
	973	break;
974	974	}
975	975	if (optarg != NULL && !arg.eof()) {
976		cerr << PROGRAM ": invalid option: `-"
977		<< (char)c << optarg << "'\n";
	976	cerr << PROGRAM ": invalid option: `-" << (char)c << optarg << "'\n";
978	977	exit(EXIT_FAILURE);
979	978	}
980	979	}

993	992	}
994	993
995	994	if (die) {
996		cerr << "Try `" << PROGRAM
997		<< " --help' for more information.\n";
	995	cerr << "Try `" << PROGRAM << " --help' for more information.\n";
998	996	exit(EXIT_FAILURE);
999	997	}
1000	998

1012	1010	cerr << "Reading `" << argv[optind] << "'..." << endl;
1013	1011
1014	1012	if (!opt::db.empty()) {
1015		init(db,
1016		opt::db,
1017		opt::verbose,
1018		PROGRAM,
1019		opt::getCommand(argc, argv),
1020		opt::metaVars
1021		);
	1013	init(db, opt::db, opt::verbose, PROGRAM, opt::getCommand(argc, argv), opt::metaVars);
1022	1014	}
1023	1015
1024	1016	Lengths lengths = readContigLengths(argv[optind++]);
1025		ContigPathMap originalPathMap = readPaths(
1026		lengths, argv[optind++]);
	1017	ContigPathMap originalPathMap = readPaths(lengths, argv[optind++]);
1027	1018
1028	1019	removeRepeats(originalPathMap);
1029	1020

1041	1032	ContigPathMap resultsPathMap;
1042	1033	#if _OPENMP
1043	1034	ContigPathMap::iterator sharedIt = originalPathMap.begin();
1044		#pragma omp parallel
1045		for (ContigPathMap::iterator it;
1046		atomicInc(sharedIt, originalPathMap.end(), it);)
1047		extendPaths(lengths,
1048		it->first, originalPathMap, resultsPathMap);
	1035	#pragma omp parallel
	1036	for (ContigPathMap::iterator it; atomicInc(sharedIt, originalPathMap.end(), it);)
	1037	extendPaths(lengths, it->first, originalPathMap, resultsPathMap);
1049	1038	#else
1050		for (ContigPathMap::const_iterator it = originalPathMap.begin();
1051		it != originalPathMap.end(); ++it)
1052		extendPaths(lengths,
1053		it->first, originalPathMap, resultsPathMap);
	1039	for (ContigPathMap::const_iterator it = originalPathMap.begin(); it != originalPathMap.end();
	1040	++it)
	1041	extendPaths(lengths, it->first, originalPathMap, resultsPathMap);
1054	1042	#endif
1055	1043	if (gDebugPrint)
1056	1044	cout << '\n';

1059	1047
1060	1048	if (gDebugPrint)
1061	1049	cout << "\nRemoving redundant contigs\n";
1062		set<ContigID> overlaps = removeSubsumedPaths(lengths,
1063		resultsPathMap);
	1050	set<ContigID> overlaps = removeSubsumedPaths(lengths, resultsPathMap);
1064	1051
1065	1052	if (!overlaps.empty() && !repeats.empty()) {
1066	1053	// Remove the newly-discovered repeat contigs from the
1067	1054	// original paths.
1068		for (set<ContigID>::const_iterator it = repeats.begin();
1069		it != repeats.end(); ++it)
	1055	for (set<ContigID>::const_iterator it = repeats.begin(); it != repeats.end(); ++it)
1070	1056	originalPathMap.erase(*it);
1071	1057
1072	1058	// Reassemble the paths that were found to overlap.
1073	1059	if (gDebugPrint) {
1074	1060	cout << "\nReassembling overlapping contigs:";
1075		for (set<ContigID>::const_iterator it = overlaps.begin();
1076		it != overlaps.end(); ++it)
	1061	for (set<ContigID>::const_iterator it = overlaps.begin(); it != overlaps.end(); ++it)
1077	1062	cout << ' ' << get(g_contigNames, *it);
1078	1063	cout << '\n';
1079	1064	}
1080	1065
1081		for (set<ContigID>::const_iterator it = overlaps.begin();
1082		it != overlaps.end(); ++it) {
	1066	for (set<ContigID>::const_iterator it = overlaps.begin(); it != overlaps.end(); ++it) {
1083	1067	if (originalPathMap.count(*it) == 0)
1084	1068	continue; // repeat
1085	1069	ContigPathMap::iterator oldIt = resultsPathMap.find(*it);

1087	1071	continue; // subsumed
1088	1072	ContigPath old = oldIt->second;
1089	1073	resultsPathMap.erase(oldIt);
1090		extendPaths(lengths,
1091		*it, originalPathMap, resultsPathMap);
	1074	extendPaths(lengths, *it, originalPathMap, resultsPathMap);
1092	1075	if (gDebugPrint) {
1093	1076	if (resultsPathMap[*it] == old)
1094	1077	cout << "no change\n";

1103	1086	overlaps = removeSubsumedPaths(lengths, resultsPathMap);
1104	1087	if (!overlaps.empty() && gDebugPrint) {
1105	1088	cout << "\nOverlapping contigs:";
1106		for (set<ContigID>::const_iterator it = overlaps.begin();
1107		it != overlaps.end(); ++it)
	1089	for (set<ContigID>::const_iterator it = overlaps.begin(); it != overlaps.end(); ++it)
1108	1090	cout << ' ' << get(g_contigNames, *it);
1109	1091	cout << '\n';
1110	1092	}

1116	1098	}
1117	1099
1118	1100	/** Return the length of the specified contig in k-mer. */
1119		static unsigned getLength(const Lengths& lengths,
1120		const ContigNode& u)
1121		{
1122		return u.ambiguous() ? u.length()
1123		: lengths.at(u.id());
	1101	static unsigned
	1102	getLength(const Lengths& lengths, const ContigNode& u)
	1103	{
	1104	return u.ambiguous() ? u.length() : lengths.at(u.id());
1124	1105	}
1125	1106
1126	1107	/** Functor to add the number of k-mer in two contigs. */
1127	1108	struct AddLength
1128	1109	{
1129		AddLength(const Lengths& lengths) : m_lengths(lengths) { }
	1110	AddLength(const Lengths& lengths)
	1111	: m_lengths(lengths)
	1112	{}
1130	1113	unsigned operator()(unsigned addend, const ContigNode& u) const
1131	1114	{
1132	1115	return addend + getLength(m_lengths, u);
1133	1116	}
	1117
1134	1118	private:
1135	1119	const Lengths& m_lengths;
1136	1120	};

1140	1124	* found.
1141	1125	* @return true if an alignment is found
1142	1126	*/
1143		template <class iterator, class oiterator>
1144		static bool alignCoordinates(const Lengths& lengths,
1145		iterator& first1, iterator last1,
1146		iterator& first2, iterator last2, oiterator& result)
	1127	template<class iterator, class oiterator>
	1128	static bool
	1129	alignCoordinates(
	1130	const Lengths& lengths,
	1131	iterator& first1,
	1132	iterator last1,
	1133	iterator& first2,
	1134	iterator last2,
	1135	oiterator& result)
1147	1136	{
1148	1137	oiterator out = result;
1149	1138

1205	1194	* the consensus at out if an alignment is found.
1206	1195	* @return true if an alignment is found
1207	1196	*/
1208		template <class iterator, class oiterator>
1209		static bool buildConsensus(const Lengths& lengths,
1210		iterator it1, iterator it1e,
1211		iterator it2, iterator it2e, oiterator& out)
	1197	template<class iterator, class oiterator>
	1198	static bool
	1199	buildConsensus(
	1200	const Lengths& lengths,
	1201	iterator it1,
	1202	iterator it1e,
	1203	iterator it2,
	1204	iterator it2e,
	1205	oiterator& out)
1212	1206	{
1213	1207	iterator it1b = it1 + 1;
1214	1208	assert(!it1b->ambiguous());

1228	1222
1229	1223	unsigned ambiguous1 = it1->length();
1230	1224	unsigned ambiguous2 = it2a->length();
1231		unsigned unambiguous1 = accumulate(it1b, it1e,
1232		0, AddLength(lengths));
1233		unsigned unambiguous2 = accumulate(it2, it2a,
1234		0, AddLength(lengths));
1235		if (ambiguous1 < unambiguous2
1236		\|\| ambiguous2 < unambiguous1) {
	1225	unsigned unambiguous1 = accumulate(it1b, it1e, 0, AddLength(lengths));
	1226	unsigned unambiguous2 = accumulate(it2, it2a, 0, AddLength(lengths));
	1227	if (ambiguous1 < unambiguous2 \|\| ambiguous2 < unambiguous1) {
1237	1228	// Two gaps overlap and either of the gaps is smaller
1238	1229	// than the unambiguous sequence that overlaps the
1239	1230	// gap. No alignment.
1240	1231	return false;
1241	1232	}
1242	1233
1243		unsigned n = max(1U,
1244		max(ambiguous2 - unambiguous1,
1245		ambiguous1 - unambiguous2));
	1234	unsigned n = max(1U, max(ambiguous2 - unambiguous1, ambiguous1 - unambiguous2));
1246	1235	out = copy(it2, it2a, out);
1247	1236	*out++ = ContigNode(n, 'N');
1248	1237	out = copy(it1b, it1e, out);

1254	1243	* in it1 and it2.
1255	1244	* @return true if an alignment is found
1256	1245	*/
1257		template <class iterator, class oiterator>
1258		static bool alignAtSeed(const Lengths& lengths,
1259		iterator& it1, iterator it1e, iterator last1,
1260		iterator& it2, iterator last2, oiterator& out)
	1246	template<class iterator, class oiterator>
	1247	static bool
	1248	alignAtSeed(
	1249	const Lengths& lengths,
	1250	iterator& it1,
	1251	iterator it1e,
	1252	iterator last1,
	1253	iterator& it2,
	1254	iterator last2,
	1255	oiterator& out)
1261	1256	{
1262	1257	assert(it1 != last1);
1263	1258	assert(it1->ambiguous());

1269	1264	// fewest number of contigs in the consensus sequence.
1270	1265	unsigned bestLen = UINT_MAX;
1271	1266	iterator bestIt2e;
1272		for (iterator it2e = it2;
1273		(it2e = find(it2e, last2, *it1e)) != last2; ++it2e) {
	1267	for (iterator it2e = it2; (it2e = find(it2e, last2, *it1e)) != last2; ++it2e) {
1274	1268	oiterator myOut = out;
1275		if (buildConsensus(lengths, it1, it1e, it2, it2e, myOut)
1276		&& align(lengths, it1e, last1, it2e, last2, myOut)) {
	1269	if (buildConsensus(lengths, it1, it1e, it2, it2e, myOut) &&
	1270	align(lengths, it1e, last1, it2e, last2, myOut)) {
1277	1271	unsigned len = myOut - out;
1278	1272	if (len <= bestLen) {
1279	1273	bestLen = len;

1282	1276	}
1283	1277	}
1284	1278	if (bestLen != UINT_MAX) {
1285		bool good = buildConsensus(lengths,
1286		it1, it1e, it2, bestIt2e, out);
	1279	bool good = buildConsensus(lengths, it1, it1e, it2, bestIt2e, out);
1287	1280	assert(good);
1288	1281	it1 = it1e;
1289	1282	it2 = bestIt2e;

1296	1289	* The end of the alignment is returned in it1 and it2.
1297	1290	* @return true if an alignment is found
1298	1291	*/
1299		template <class iterator, class oiterator>
1300		static bool alignAmbiguous(const Lengths& lengths,
1301		iterator& it1, iterator last1,
1302		iterator& it2, iterator last2, oiterator& out)
	1292	template<class iterator, class oiterator>
	1293	static bool
	1294	alignAmbiguous(
	1295	const Lengths& lengths,
	1296	iterator& it1,
	1297	iterator last1,
	1298	iterator& it2,
	1299	iterator last2,
	1300	oiterator& out)
1303	1301	{
1304	1302	assert(it1 != last1);
1305	1303	assert(it1->ambiguous());

1323	1321	* The end of the alignment is returned in it1 and it2.
1324	1322	* @return true if an alignment is found
1325	1323	*/
1326		template <class iterator, class oiterator>
1327		static bool alignOne(const Lengths& lengths,
1328		iterator& it1, iterator last1,
1329		iterator& it2, iterator last2, oiterator& out)
	1324	template<class iterator, class oiterator>
	1325	static bool
	1326	alignOne(
	1327	const Lengths& lengths,
	1328	iterator& it1,
	1329	iterator last1,
	1330	iterator& it2,
	1331	iterator last2,
	1332	oiterator& out)
1330	1333	{
1331	1334	// Check for a trivial alignment.
1332	1335	unsigned n1 = last1 - it1, n2 = last2 - it2;

1346	1349	return true;
1347	1350	}
1348	1351
1349		return
1350		it1->ambiguous() && it2->ambiguous()
1351		? (it1->length() > it2->length()
1352		? alignAmbiguous(lengths, it1, last1, it2, last2, out)
1353		: alignAmbiguous(lengths, it2, last2, it1, last1, out)
1354		)
1355		: it1->ambiguous()
1356		? alignAmbiguous(lengths, it1, last1, it2, last2, out)
1357		: it2->ambiguous()
1358		? alignAmbiguous(lengths, it2, last2, it1, last1, out)
1359		: (out++ = it1, it1++ == it2++);
	1352	return it1->ambiguous() && it2->ambiguous()
	1353	? (it1->length() > it2->length()
	1354	? alignAmbiguous(lengths, it1, last1, it2, last2, out)
	1355	: alignAmbiguous(lengths, it2, last2, it1, last1, out))
	1356	: it1->ambiguous()
	1357	? alignAmbiguous(lengths, it1, last1, it2, last2, out)
	1358	: it2->ambiguous() ? alignAmbiguous(lengths, it2, last2, it1, last1, out)
	1359	: (out++ = it1, it1++ == it2++);
1360	1360	}
1361	1361
1362	1362	/** Align the ambiguous region [it1, last1) to [it2, last2)

1364	1364	* @return the orientation of the alignment if an alignments is found
1365	1365	* or zero otherwise
1366	1366	*/
1367		template <class iterator, class oiterator>
1368		static dir_type align(const Lengths& lengths,
1369		iterator it1, iterator last1,
1370		iterator it2, iterator last2, oiterator& out)
	1367	template<class iterator, class oiterator>
	1368	static dir_type
	1369	align(
	1370	const Lengths& lengths,
	1371	iterator it1,
	1372	iterator last1,
	1373	iterator it2,
	1374	iterator last2,
	1375	oiterator& out)
1371	1376	{
1372	1377	assert(it1 != last1);
1373	1378	assert(it2 != last2);

1378	1383	out = copy(it1, last1, out);
1379	1384	out = copy(it2, last2, out);
1380	1385	return it1 == last1 && it2 == last2 ? DIR_B
1381		: it1 == last1 ? DIR_F
1382		: it2 == last2 ? DIR_R
1383		: DIR_X;
	1386	: it1 == last1 ? DIR_F : it2 == last2 ? DIR_R : DIR_X;
1384	1387	}
1385	1388
1386	1389	/** Find an equivalent region of the two specified paths, starting the

1388	1391	* @param[out] orientation the orientation of the alignment
1389	1392	* @return the consensus sequence
1390	1393	*/
1391		static ContigPath align(const Lengths& lengths,
1392		const ContigPath& p1, const ContigPath& p2,
1393		ContigPath::const_iterator pivot1,
1394		ContigPath::const_iterator pivot2,
1395		dir_type& orientation)
	1394	static ContigPath
	1395	align(
	1396	const Lengths& lengths,
	1397	const ContigPath& p1,
	1398	const ContigPath& p2,
	1399	ContigPath::const_iterator pivot1,
	1400	ContigPath::const_iterator pivot2,
	1401	dir_type& orientation)
1396	1402	{
1397	1403	assert(pivot1 == pivot2);
1398		ContigPath::const_reverse_iterator
1399		rit1 = ContigPath::const_reverse_iterator(pivot1+1),
1400		rit2 = ContigPath::const_reverse_iterator(pivot2+1);
	1404	ContigPath::const_reverse_iterator rit1 = ContigPath::const_reverse_iterator(pivot1 + 1),
	1405	rit2 = ContigPath::const_reverse_iterator(pivot2 + 1);
1401	1406	ContigPath alignmentr(p1.rend() - rit1 + p2.rend() - rit2);
1402	1407	ContigPath::iterator rout = alignmentr.begin();
1403		dir_type alignedr = align(lengths,
1404		rit1, p1.rend(), rit2, p2.rend(), rout);
	1408	dir_type alignedr = align(lengths, rit1, p1.rend(), rit2, p2.rend(), rout);
1405	1409	alignmentr.erase(rout, alignmentr.end());
1406	1410
1407	1411	ContigPath::const_iterator it1 = pivot1, it2 = pivot2;
1408	1412	ContigPath alignmentf(p1.end() - it1 + p2.end() - it2);
1409	1413	ContigPath::iterator fout = alignmentf.begin();
1410		dir_type alignedf = align(lengths,
1411		it1, p1.end(), it2, p2.end(), fout);
	1414	dir_type alignedf = align(lengths, it1, p1.end(), it2, p2.end(), fout);
1412	1415	alignmentf.erase(fout, alignmentf.end());
1413	1416
1414	1417	ContigPath consensus;

1416	1419	// Found an alignment.
1417	1420	assert(!alignmentf.empty());
1418	1421	assert(!alignmentr.empty());
1419		consensus.reserve(alignmentr.size()-1 + alignmentf.size());
1420		consensus.assign(alignmentr.rbegin(), alignmentr.rend()-1);
1421		consensus.insert(consensus.end(),
1422		alignmentf.begin(), alignmentf.end());
	1422	consensus.reserve(alignmentr.size() - 1 + alignmentf.size());
	1423	consensus.assign(alignmentr.rbegin(), alignmentr.rend() - 1);
	1424	consensus.insert(consensus.end(), alignmentf.begin(), alignmentf.end());
1423	1425
1424	1426	// Determine the orientation of the alignment.
1425	1427	unsigned dirs = alignedr << 2 \| alignedf;

1451	1453	/** Return a pivot suitable for aligning the two paths if one exists,
1452	1454	* otherwise return false.
1453	1455	*/
1454		static pair<ContigNode, bool> findPivot(
1455		const ContigPath& path1, const ContigPath& path2)
1456		{
1457		for (ContigPath::const_iterator it = path2.begin();
1458		it != path2.end(); ++it) {
	1456	static pair<ContigNode, bool>
	1457	findPivot(const ContigPath& path1, const ContigPath& path2)
	1458	{
	1459	for (ContigPath::const_iterator it = path2.begin(); it != path2.end(); ++it) {
1459	1460	if (it->ambiguous())
1460	1461	continue;
1461		if (count(path2.begin(), path2.end(), *it) == 1
1462		&& count(path1.begin(), path1.end(), *it) == 1)
	1462	if (count(path2.begin(), path2.end(), *it) == 1 &&
	1463	count(path1.begin(), path1.end(), *it) == 1)
1463	1464	return make_pair(*it, true);
1464	1465	}
1465	1466	return make_pair(ContigNode(0), false);

1469	1470	* @param[out] orientation the orientation of the alignment
1470	1471	* @return the consensus sequence
1471	1472	*/
1472		static ContigPath align(const Lengths& lengths,
1473		const ContigPath& path1, const ContigPath& path2,
1474		ContigNode pivot, dir_type& orientation)
	1473	static ContigPath
	1474	align(
	1475	const Lengths& lengths,
	1476	const ContigPath& path1,
	1477	const ContigPath& path2,
	1478	ContigNode pivot,
	1479	dir_type& orientation)
1475	1480	{
1476	1481	if (&path1 == &path2) {
1477	1482	// Ignore the trivial alignment when aligning a path to

1481	1486	orientation = DIR_B;
1482	1487	return path1;
1483	1488	} else {
1484		ContigPath::const_iterator it
1485		= search(path1.begin(), path1.end(),
1486		path2.begin(), path2.end());
	1489	ContigPath::const_iterator it =
	1490	search(path1.begin(), path1.end(), path2.begin(), path2.end());
1487	1491	if (it != path1.end()) {
1488	1492	// path2 is subsumed in path1.
1489	1493	// Determine the orientation of the edge.
1490		orientation
1491		= it == path1.begin() ? DIR_R
1492		: it + path2.size() == path1.end() ? DIR_F
1493		: DIR_B;
	1494	orientation =
	1495	it == path1.begin() ? DIR_R : it + path2.size() == path1.end() ? DIR_F : DIR_B;
1494	1496	return path1;
1495	1497	}
1496	1498	}
1497	1499
1498	1500	// Find a suitable pivot.
1499		if (find(path1.begin(), path1.end(), pivot) == path1.end()
1500		\|\| find(path2.begin(), path2.end(), pivot)
1501		== path2.end()) {
	1501	if (find(path1.begin(), path1.end(), pivot) == path1.end() \|\|
	1502	find(path2.begin(), path2.end(), pivot) == path2.end()) {
1502	1503	bool good;
1503	1504	tie(pivot, good) = findPivot(path1, path2);
1504	1505	if (!good)

1506	1507	}
1507	1508	assert(find(path1.begin(), path1.end(), pivot) != path1.end());
1508	1509
1509		ContigPath::const_iterator it2 = find(path2.begin(), path2.end(),
1510		pivot);
	1510	ContigPath::const_iterator it2 = find(path2.begin(), path2.end(), pivot);
1511	1511	assert(it2 != path2.end());
1512	1512	if (&path1 != &path2) {
1513	1513	// The seed must be unique in path2, unless we're aligning a
1514	1514	// path to itself.
1515		assert(count(it2+1, path2.end(), pivot) == 0);
	1515	assert(count(it2 + 1, path2.end(), pivot) == 0);
1516	1516	}
1517	1517
1518	1518	ContigPath consensus;
1519	1519	for (ContigPath::const_iterator it1 = find_if(
1520		path1.begin(), path1.end(),
1521		bind2nd(equal_to<ContigNode>(), pivot));
1522		it1 != path1.end();
1523		it1 = find_if(it1+1, path1.end(),
1524		bind2nd(equal_to<ContigNode>(), pivot))) {
	1520	path1.begin(), path1.end(), [&pivot](const ContigNode& c) { return c == pivot; });
	1521	it1 != path1.end();
	1522	it1 =
	1523	find_if(it1 + 1, path1.end(), [&pivot](const ContigNode& c) { return c == pivot; })) {
1525	1524	if (&it1 == &it2) {
1526	1525	// We are aligning a path to itself, and this is the
1527	1526	// trivial alignment, which we'll ignore.
1528	1527	continue;
1529	1528	}
1530		consensus = align(lengths,
1531		path1, path2, it1, it2, orientation);
	1529	consensus = align(lengths, path1, path2, it1, it2, orientation);
1532	1530	if (!consensus.empty())
1533	1531	return consensus;
1534	1532	}

1538	1536	/** Find an equivalent region of the two specified paths.
1539	1537	* @return the consensus sequence
1540	1538	*/
1541		static ContigPath align(const Lengths& lengths,
1542		const ContigPath& path1, const ContigPath& path2,
1543		ContigNode pivot)
	1539	static ContigPath
	1540	align(const Lengths& lengths, const ContigPath& path1, const ContigPath& path2, ContigNode pivot)
1544	1541	{
1545	1542	dir_type orientation;
1546	1543	return align(lengths, path1, path2, pivot, orientation);

-1

Misc/samtobreak.hs less more

278	278	where
279	279	help = putStr (usageInfo usage options) >> exitSuccess
280	280	tryHelp = "Try 'abyss-samtobreak --help' for more information."
281		version = "abyss-samtobreak (ABySS) 2.2.3\n"
	281	version = "abyss-samtobreak (ABySS) 2.2.4\n"
282	282	usage = "Usage: samtobreak [OPTION]... [FILE]...\n\
283	283	\Calculate contig and scaffold contiguity and correctness metrics.\n"
284	284

+272

-232

ParseAligns/ParseAligns.cpp less more

26	26	#define PROGRAM "ParseAligns"
27	27
28	28	static const char VERSION_MESSAGE[] =
29		PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
30		"Written by Jared Simpson and Shaun Jackman.\n"
31		"\n"
32		"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
	29	PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
	30	"Written by Jared Simpson and Shaun Jackman.\n"
	31	"\n"
	32	"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
33	33
34	34	static const char USAGE_MESSAGE[] =
35		"Usage: " PROGRAM " -k<kmer> [OPTION]... [FILE]...\n"
36		"Write pairs that map to the same contig to the file SAME.\n"
37		"Write pairs that map to different contigs to standard output.\n"
38		"Alignments may be read from FILE(s) or standard input.\n"
39		"\n"
40		" Options:\n"
41		"\n"
42		" -l, --min-align=N minimum alignment length\n"
43		" -d, --dist=DISTANCE write distance estimates to this file\n"
44		" -f, --frag=SAME write fragment sizes to this file\n"
45		" -h, --hist=FILE write the fragment size histogram to FILE\n"
46		" --sam alignments are in SAM format\n"
47		" --kaligner alignments are in KAligner format\n"
48		" -c, --cover=COVERAGE coverage cut-off for distance estimates\n"
49		" -v, --verbose display verbose output\n"
50		" --help display this help and exit\n"
51		" --version output version information and exit\n"
52		"\n"
53		"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
	35	"Usage: " PROGRAM " -k<kmer> [OPTION]... [FILE]...\n"
	36	"Write pairs that map to the same contig to the file SAME.\n"
	37	"Write pairs that map to different contigs to standard output.\n"
	38	"Alignments may be read from FILE(s) or standard input.\n"
	39	"\n"
	40	" Options:\n"
	41	"\n"
	42	" -l, --min-align=N minimum alignment length\n"
	43	" -d, --dist=DISTANCE write distance estimates to this file\n"
	44	" -f, --frag=SAME write fragment sizes to this file\n"
	45	" -h, --hist=FILE write the fragment size histogram to FILE\n"
	46	" --sam alignments are in SAM format\n"
	47	" --kaligner alignments are in KAligner format\n"
	48	" -c, --cover=COVERAGE coverage cut-off for distance estimates\n"
	49	" -v, --verbose display verbose output\n"
	50	" --help display this help and exit\n"
	51	" --version output version information and exit\n"
	52	"\n"
	53	"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
54	54
55	55	namespace opt {
56		unsigned k; // used by DistanceEst
57		static unsigned c;
58		static int verbose;
59		static string distPath;
60		static string fragPath;
61		static string histPath;
62
63		/** Input alignment format. */
64		static int inputFormat;
65		enum { KALIGNER, SAM };
66
67		/** Output format */
68		int format = ADJ; // used by Estimate
	56	unsigned k; // used by DistanceEst
	57	static unsigned c;
	58	static int verbose;
	59	static string distPath;
	60	static string fragPath;
	61	static string histPath;
	62
	63	/** Input alignment format. */
	64	static int inputFormat;
	65	enum
	66	{
	67	KALIGNER,
	68	SAM
	69	};
	70
	71	/** Output format */
	72	int format = ADJ; // used by Estimate
69	73	}
70	74
71	75	static const char shortopts[] = "d:l:f:h:c:v";
72	76
73		enum { OPT_HELP = 1, OPT_VERSION };
	77	enum
	78	{
	79	OPT_HELP = 1,
	80	OPT_VERSION
	81	};
74	82
75	83	static const struct option longopts[] = {
76		{ "dist", required_argument, NULL, 'd' },
	84	{ "dist", required_argument, NULL, 'd' },
77	85	{ "min-align", required_argument, NULL, 'l' },
78		{ "frag", required_argument, NULL, 'f' },
79		{ "hist", required_argument, NULL, 'h' },
80		{ "kaligner",no_argument, &opt::inputFormat, opt::KALIGNER },
81		{ "sam", no_argument, &opt::inputFormat, opt::SAM },
82		{ "cover", required_argument, NULL, 'c' },
83		{ "verbose", no_argument, NULL, 'v' },
84		{ "help", no_argument, NULL, OPT_HELP },
85		{ "version", no_argument, NULL, OPT_VERSION },
	86	{ "frag", required_argument, NULL, 'f' },
	87	{ "hist", required_argument, NULL, 'h' },
	88	{ "kaligner", no_argument, &opt::inputFormat, opt::KALIGNER },
	89	{ "sam", no_argument, &opt::inputFormat, opt::SAM },
	90	{ "cover", required_argument, NULL, 'c' },
	91	{ "verbose", no_argument, NULL, 'v' },
	92	{ "help", no_argument, NULL, OPT_HELP },
	93	{ "version", no_argument, NULL, OPT_VERSION },
86	94	{ NULL, 0, NULL, 0 }
87	95	};
88	96
89		static struct {
	97	static struct
	98	{
90	99	size_t alignments;
91	100	size_t bothUnaligned;
92	101	size_t oneUnaligned;

108	117	typedef unordered_map<string, EstimateRecord> EstimateMap;
109	118	static EstimateMap estMap;
110	119
111		static bool checkUniqueAlignments(const AlignmentVector& alignVec);
112		static string makePairID(string id);
	120	static bool
	121	checkUniqueAlignments(const AlignmentVector& alignVec);
	122	static string
	123	makePairID(string id);
113	124
114	125	/**
115	126	* Return the size of the fragment demarcated by the specified
116	127	* alignments.
117	128	*/
118		static int fragmentSize(const Alignment& a0, const Alignment& a1)
	129	static int
	130	fragmentSize(const Alignment& a0, const Alignment& a1)
119	131	{
120	132	assert(a0.contig == a1.contig);
121	133	assert(a0.isRC != a1.isRC);

127	139	typedef pair<ContigNode, DistanceEst> Estimate;
128	140	typedef vector<Estimate> Estimates;
129	141
130		static void addEstimate(EstimateMap& map, const Alignment& a,
131		Estimate& est, bool reverse)
132		{
133		//count up the number of estimates that agree
	142	static void
	143	addEstimate(EstimateMap& map, const Alignment& a, Estimate& est, bool reverse)
	144	{
	145	// count up the number of estimates that agree
134	146	bool placed = false;
135	147	bool a_isRC = a.isRC != reverse;
136	148	EstimateMap::iterator estimatesIt = map.find(a.contig);
137	149	if (estimatesIt != map.end()) {
138	150	Estimates& estimates = estimatesIt->second.estimates[a_isRC];
139		for (Estimates::iterator estIt = estimates.begin();
140		estIt != estimates.end(); ++estIt) {
	151	for (Estimates::iterator estIt = estimates.begin(); estIt != estimates.end(); ++estIt) {
141	152	if (estIt->first.id() == est.first.id()) {
142	153	estIt->second.numPairs++;
143	154	estIt->second.distance += est.second.distance;

148	159	}
149	160	if (!placed)
150	161	map[a.contig].estimates[a_isRC].push_back(est);
151
152		}
153
154		static void doReadIntegrity(const ReadAlignMap::value_type& a)
	162	}
	163
	164	static void
	165	doReadIntegrity(const ReadAlignMap::value_type& a)
155	166	{
156	167	AlignmentVector::const_iterator refAlignIter = a.second.begin();
157	168	unsigned firstStart, lastEnd, largestSize;

163	174	first = last = largest = *refAlignIter;
164	175	++refAlignIter;
165	176
166		//for each alignment in the vector a.second
	177	// for each alignment in the vector a.second
167	178	for (; refAlignIter != a.second.end(); ++refAlignIter) {
168	179	if ((unsigned)refAlignIter->read_start_pos < firstStart) {
169	180	firstStart = refAlignIter->read_start_pos;
170	181	first = *refAlignIter;
171	182	}
172		if ((unsigned)(refAlignIter->read_start_pos +
173		refAlignIter->align_length) > lastEnd) {
174		lastEnd = refAlignIter->read_start_pos +
175		refAlignIter->align_length;
	183	if ((unsigned)(refAlignIter->read_start_pos + refAlignIter->align_length) > lastEnd) {
	184	lastEnd = refAlignIter->read_start_pos + refAlignIter->align_length;
176	185	last = *refAlignIter;
177	186	}
178	187	if ((unsigned)refAlignIter->align_length > largestSize) {

183	192
184	193	if (largest.contig != last.contig) {
185	194	Estimate est;
186		unsigned largest_end =
187		largest.read_start_pos + largest.align_length - opt::k;
	195	unsigned largest_end = largest.read_start_pos + largest.align_length - opt::k;
188	196	int distance = last.read_start_pos - largest_end;
189		est.first = find_vertex(
190		last.contig, largest.isRC != last.isRC,
191		g_contigNames);
	197	est.first = find_vertex(last.contig, largest.isRC != last.isRC, g_contigNames);
192	198	est.second.distance = distance - opt::k;
193	199	est.second.numPairs = 1;
194	200	est.second.stdDev = 0;
195	201	addEstimate(estMap, largest, est, false);
196	202	}
197	203
198		if (largest.contig != first.contig &&
199		largest.contig != last.contig) {
	204	if (largest.contig != first.contig && largest.contig != last.contig) {
200	205	Estimate est;
201		unsigned first_end =
202		first.read_start_pos + first.align_length - opt::k;
	206	unsigned first_end = first.read_start_pos + first.align_length - opt::k;
203	207	int distance = last.read_start_pos - first_end;
204		est.first = find_vertex(
205		last.contig, first.isRC != last.isRC,
206		g_contigNames);
	208	est.first = find_vertex(last.contig, first.isRC != last.isRC, g_contigNames);
207	209	est.second.distance = distance - opt::k;
208	210	est.second.numPairs = 1;
209	211	est.second.stdDev = 0;

214	216	largest.flipQuery();
215	217	first.flipQuery();
216	218	Estimate est;
217		unsigned largest_end =
218		largest.read_start_pos + largest.align_length - opt::k;
	219	unsigned largest_end = largest.read_start_pos + largest.align_length - opt::k;
219	220	int distance = first.read_start_pos - largest_end;
220		est.first = find_vertex(
221		first.contig, largest.isRC != first.isRC,
222		g_contigNames);
	221	est.first = find_vertex(first.contig, largest.isRC != first.isRC, g_contigNames);
223	222	est.second.distance = distance - opt::k;
224	223	est.second.numPairs = 1;
225	224	est.second.stdDev = 0;

258	257	#endif
259	258	}
260	259
261		static void generateDistFile()
	260	static void
	261	generateDistFile()
262	262	{
263	263	ofstream distFile(opt::distPath.c_str());
264	264	assert(distFile.is_open());
265		for (EstimateMap::iterator mapIt = estMap.begin();
266		mapIt != estMap.end(); ++mapIt) {
267		//Skip empty iterators
	265	for (EstimateMap::iterator mapIt = estMap.begin(); mapIt != estMap.end(); ++mapIt) {
	266	// Skip empty iterators
268	267	assert(!mapIt->second.estimates[0].empty() \|\| !mapIt->second.estimates[1].empty());
269	268	distFile << mapIt->first;
270	269	for (int refIsRC = 0; refIsRC <= 1; refIsRC++) {
271	270	if (refIsRC)
272	271	distFile << " ;";
273	272
274		for (Estimates::iterator vecIt
275		= mapIt->second.estimates[refIsRC].begin();
276		vecIt != mapIt->second.estimates[refIsRC].end(); ++vecIt) {
277		vecIt->second.distance
278		= (int)round((double)vecIt->second.distance /
279		(double)vecIt->second.numPairs);
280		if (vecIt->second.numPairs >= opt::c
281		&& vecIt->second.numPairs != 0
282		/&& vecIt->distance > 1 - opt::k/)
283		distFile
284		<< ' ' << get(g_contigNames, vecIt->first)
285		<< ',' << vecIt->second;
	273	for (Estimates::iterator vecIt = mapIt->second.estimates[refIsRC].begin();
	274	vecIt != mapIt->second.estimates[refIsRC].end();
	275	++vecIt) {
	276	vecIt->second.distance =
	277	(int)round((double)vecIt->second.distance / (double)vecIt->second.numPairs);
	278	if (vecIt->second.numPairs >= opt::c && vecIt->second.numPairs != 0
	279	/&& vecIt->distance > 1 - opt::k/)
	280	distFile << ' ' << get(g_contigNames, vecIt->first) << ',' << vecIt->second;
286	281	}
287	282	}
288	283	distFile << '\n';

291	286	distFile.close();
292	287	}
293	288
294		static bool isSingleEnd(const string& id);
295		static bool needsFlipping(const string& id);
	289	static bool
	290	isSingleEnd(const string& id);
	291	static bool
	292	needsFlipping(const string& id);
296	293
297	294	/**
298	295	* Return an alignment flipped as necessary to produce an alignment

301	298	* alignment, so that the alignment is forward-reverse, which is
302	299	* required by DistanceEst.
303	300	*/
304		static const Alignment flipAlignment(const Alignment& a,
305		const string& id)
	301	static const Alignment
	302	flipAlignment(const Alignment& a, const string& id)
306	303	{
307	304	return needsFlipping(id) ? a.flipQuery() : a;
308	305	}
309	306
310		static void handleAlignmentPair(const ReadAlignMap::value_type& curr,
311		const ReadAlignMap::value_type& pair)
	307	static void
	308	handleAlignmentPair(const ReadAlignMap::value_type& curr, const ReadAlignMap::value_type& pair)
312	309	{
313	310	const string& currID = curr.first;
314	311	const string& pairID = pair.first;

322	319	stats.bothUnaligned++;
323	320	} else if (curr.second.empty() \|\| pair.second.empty()) {
324	321	stats.oneUnaligned++;
325		} else if (!checkUniqueAlignments(curr.second)
326		\|\| !checkUniqueAlignments(pair.second)) {
	322	} else if (!checkUniqueAlignments(curr.second) \|\| !checkUniqueAlignments(pair.second)) {
327	323	stats.numMulti++;
328		} else if (curr.second.size() > MAX_SPAN
329		&& pair.second.size() > MAX_SPAN) {
	324	} else if (curr.second.size() > MAX_SPAN && pair.second.size() > MAX_SPAN) {
330	325	stats.numSplit++;
331	326	} else {
332	327	// Iterate over the vectors, outputting the aligments
333	328	bool counted = false;
334		for (AlignmentVector::const_iterator refAlignIter
335		= curr.second.begin();
336		refAlignIter != curr.second.end(); ++refAlignIter) {
337		for (AlignmentVector::const_iterator pairAlignIter
338		= pair.second.begin();
339		pairAlignIter != pair.second.end();
340		++pairAlignIter) {
341		const Alignment& a0 = flipAlignment(*refAlignIter,
342		currID);
343		const Alignment& a1 = flipAlignment(*pairAlignIter,
344		pairID);
	329	for (AlignmentVector::const_iterator refAlignIter = curr.second.begin();
	330	refAlignIter != curr.second.end();
	331	++refAlignIter) {
	332	for (AlignmentVector::const_iterator pairAlignIter = pair.second.begin();
	333	pairAlignIter != pair.second.end();
	334	++pairAlignIter) {
	335	const Alignment& a0 = flipAlignment(*refAlignIter, currID);
	336	const Alignment& a1 = flipAlignment(*pairAlignIter, pairID);
345	337
346	338	bool sameTarget = a0.contig == a1.contig;
347		if (sameTarget
348		&& curr.second.size() == 1
349		&& pair.second.size() == 1) {
	339	if (sameTarget && curr.second.size() == 1 && pair.second.size() == 1) {
350	340	// Same target and the only alignment.
351	341	if (a0.isRC != a1.isRC) {
352	342	// Correctly oriented. Add this alignment to

362	352	counted = true;
363	353	}
364	354
365		bool outputSameTarget = opt::fragPath.empty()
366		&& opt::histPath.empty();
	355	bool outputSameTarget = opt::fragPath.empty() && opt::histPath.empty();
367	356	if (!sameTarget \|\| outputSameTarget) {
368		cout << SAMRecord(a0, a1) << '\n'
369		<< SAMRecord(a1, a0) << '\n';
	357	cout << SAMRecord(a0, a1) << '\n' << SAMRecord(a1, a0) << '\n';
370	358	assert(cout.good());
371	359	}
372	360	}

376	364	}
377	365	}
378	366
379		static void printProgress(const ReadAlignMap& map)
	367	static void
	368	printProgress(const ReadAlignMap& map)
380	369	{
381	370	if (opt::verbose == 0)
382	371	return;

389	378	if (stats.alignments % 1000000 == 0 \|\| buckets != prevBuckets) {
390	379	prevBuckets = buckets;
391	380	size_t size = map.size();
392		cerr << "Read " << stats.alignments << " alignments. "
393		"Hash load: " << size << " / " << buckets
394		<< " = " << (float)size / buckets
395		<< " using " << toSI(getMemoryUsage()) << "B." << endl;
396		}
397		}
398
399		static void handleAlignment(
400		const ReadAlignMap::value_type& alignments,
401		ReadAlignMap& out)
	381	cerr << "Read " << stats.alignments
	382	<< " alignments. "
	383	"Hash load: "
	384	<< size << " / " << buckets << " = " << (float)size / buckets << " using "
	385	<< toSI(getMemoryUsage()) << "B." << endl;
	386	}
	387	}
	388
	389	static void
	390	handleAlignment(const ReadAlignMap::value_type& alignments, ReadAlignMap& out)
402	391	{
403	392	if (!isSingleEnd(alignments.first)) {
404	393	string pairID = makePairID(alignments.first);

407	396	handleAlignmentPair(*pairIter, alignments);
408	397	out.erase(pairIter);
409	398	} else if (!out.insert(alignments).second) {
410		cerr << "error: duplicate read ID `" << alignments.first
411		<< "'\n";
	399	cerr << "error: duplicate read ID `" << alignments.first << "'\n";
412	400	exit(EXIT_FAILURE);
413	401	}
414	402	}

420	408	printProgress(out);
421	409	}
422	410
423		static void readAlignment(const string& line, ReadAlignMap& out)
	411	static void
	412	readAlignment(const string& line, ReadAlignMap& out)
424	413	{
425	414	istringstream s(line);
426	415	pair<string, AlignmentVector> v;
427	416	switch (opt::inputFormat) {
428		case opt::SAM:
429		{
	417	case opt::SAM: {
430	418	SAMRecord sam;
431	419	s >> sam;
432	420	assert(s);

438	426	if (!sam.isUnmapped())
439	427	v.second.push_back(sam);
440	428	break;
441		}
442		case opt::KALIGNER:
443		{
	429	}
	430	case opt::KALIGNER: {
444	431	s >> v.first;
445	432	assert(s);
446	433	v.second.reserve(count(line.begin(), line.end(), '\t'));
447		v.second.assign(
448		istream_iterator<Alignment>(s),
449		istream_iterator<Alignment>());
	434	v.second.assign(istream_iterator<Alignment>(s), istream_iterator<Alignment>());
450	435	assert(s.eof());
451	436	break;
452		}
	437	}
453	438	}
454	439	handleAlignment(v, out);
455	440	}
456	441
457		static void readAlignments(istream& in, ReadAlignMap* pout)
	442	static void
	443	readAlignments(istream& in, ReadAlignMap* pout)
458	444	{
459	445	for (string line; getline(in, line);)
460	446	if (line.empty() \|\| line[0] == '@')

464	450	assert(in.eof());
465	451	}
466	452
467		static void readAlignmentsFile(string path, ReadAlignMap* pout)
	453	static void
	454	readAlignmentsFile(string path, ReadAlignMap* pout)
468	455	{
469	456	if (opt::verbose > 0)
470	457	cerr << "Reading `" << path << "'..." << endl;

475	462	}
476	463
477	464	/** Return the specified number formatted as a percent. */
478		static string percent(size_t x, size_t n)
	465	static string
	466	percent(size_t x, size_t n)
479	467	{
480	468	ostringstream ss;
481	469	ss << setw((int)log10(n) + 1) << x;
482	470	if (x > 0)
483		ss << " " << setprecision(3) << (float)100*x/n << '%';
	471	ss << " " << setprecision(3) << (float)100 * x / n << '%';
484	472	return ss.str();
485	473	}
486	474
487		int main(int argc, char* const* argv)
	475	int
	476	main(int argc, char* const* argv)
488	477	{
489	478	bool die = false;
490		for (int c; (c = getopt_long(argc, argv,
491		shortopts, longopts, NULL)) != -1;) {
	479	for (int c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) {
492	480	istringstream arg(optarg != NULL ? optarg : "");
493	481	switch (c) {
494		case '?': die = true; break;
495		case 'l': arg >> opt::k; break;
496		case 'c': arg >> opt::c; break;
497		case 'd': arg >> opt::distPath; break;
498		case 'f': arg >> opt::fragPath; break;
499		case 'h': arg >> opt::histPath; break;
500		case 'v': opt::verbose++; break;
501		case OPT_HELP:
502		cout << USAGE_MESSAGE;
503		exit(EXIT_SUCCESS);
504		case OPT_VERSION:
505		cout << VERSION_MESSAGE;
506		exit(EXIT_SUCCESS);
	482	case '?':
	483	die = true;
	484	break;
	485	case 'l':
	486	arg >> opt::k;
	487	break;
	488	case 'c':
	489	arg >> opt::c;
	490	break;
	491	case 'd':
	492	arg >> opt::distPath;
	493	break;
	494	case 'f':
	495	arg >> opt::fragPath;
	496	break;
	497	case 'h':
	498	arg >> opt::histPath;
	499	break;
	500	case 'v':
	501	opt::verbose++;
	502	break;
	503	case OPT_HELP:
	504	cout << USAGE_MESSAGE;
	505	exit(EXIT_SUCCESS);
	506	case OPT_VERSION:
	507	cout << VERSION_MESSAGE;
	508	exit(EXIT_SUCCESS);
507	509	}
508	510	if (optarg != NULL && !arg.eof()) {
509		cerr << PROGRAM ": invalid option: `-"
510		<< (char)c << optarg << "'\n";
	511	cerr << PROGRAM ": invalid option: `-" << (char)c << optarg << "'\n";
511	512	exit(EXIT_FAILURE);
512	513	}
513	514	}
514	515
515	516	if (opt::k <= 0 && opt::inputFormat == opt::KALIGNER) {
516		cerr << PROGRAM ": " << "missing -k,--kmer option\n";
	517	cerr << PROGRAM ": "
	518	<< "missing -k,--kmer option\n";
517	519	die = true;
518	520	}
519	521
520	522	if (die) {
521		cerr << "Try `" << PROGRAM
522		<< " --help' for more information.\n";
	523	cerr << "Try `" << PROGRAM << " --help' for more information.\n";
523	524	exit(EXIT_FAILURE);
524	525	}
525	526

530	531
531	532	ReadAlignMap alignTable(1);
532	533	if (optind < argc) {
533		for_each(argv + optind, argv + argc,
534		bind2nd(ptr_fun(readAlignmentsFile), &alignTable));
	534	for_each(argv + optind, argv + argc, [&alignTable](const std::string& s) {
	535	readAlignmentsFile(s, &alignTable);
	536	});
535	537	} else {
536	538	if (opt::verbose > 0)
537	539	cerr << "Reading from standard input..." << endl;

542	544
543	545	unsigned numRF = histogram.count(INT_MIN, 0);
544	546	unsigned numFR = histogram.count(1, INT_MAX);
545		size_t sum = alignTable.size()
546		+ stats.bothUnaligned + stats.oneUnaligned
547		+ numFR + numRF + stats.numFF
548		+ stats.numDifferent + stats.numMulti + stats.numSplit;
549		cerr <<
550		"Mateless " << percent(alignTable.size(), sum) << "\n"
551		"Unaligned " << percent(stats.bothUnaligned, sum) << "\n"
552		"Singleton " << percent(stats.oneUnaligned, sum) << "\n"
553		"FR " << percent(numFR, sum) << "\n"
554		"RF " << percent(numRF, sum) << "\n"
555		"FF " << percent(stats.numFF, sum) << "\n"
556		"Different " << percent(stats.numDifferent, sum) << "\n"
557		"Multimap " << percent(stats.numMulti, sum) << "\n"
558		"Split " << percent(stats.numSplit, sum) << "\n"
559		"Total " << sum << endl;
	547	size_t sum = alignTable.size() + stats.bothUnaligned + stats.oneUnaligned + numFR + numRF +
	548	stats.numFF + stats.numDifferent + stats.numMulti + stats.numSplit;
	549	cerr << "Mateless " << percent(alignTable.size(), sum)
	550	<< "\n"
	551	"Unaligned "
	552	<< percent(stats.bothUnaligned, sum)
	553	<< "\n"
	554	"Singleton "
	555	<< percent(stats.oneUnaligned, sum)
	556	<< "\n"
	557	"FR "
	558	<< percent(numFR, sum)
	559	<< "\n"
	560	"RF "
	561	<< percent(numRF, sum)
	562	<< "\n"
	563	"FF "
	564	<< percent(stats.numFF, sum)
	565	<< "\n"
	566	"Different "
	567	<< percent(stats.numDifferent, sum)
	568	<< "\n"
	569	"Multimap "
	570	<< percent(stats.numMulti, sum)
	571	<< "\n"
	572	"Split "
	573	<< percent(stats.numSplit, sum)
	574	<< "\n"
	575	"Total "
	576	<< sum << endl;
560	577
561	578	if (!opt::distPath.empty())
562	579	generateDistFile();

579	596	histogram.removeOutliers();
580	597	Histogram h = histogram.trimFraction(0.0001);
581	598	if (opt::verbose > 0)
582		cerr << "Stats mean: " << setprecision(4) << h.mean() << " "
583		"median: " << setprecision(4) << h.median() << " "
584		"sd: " << setprecision(4) << h.sd() << " "
585		"n: " << h.size() << " "
586		"min: " << h.minimum() << " max: " << h.maximum() << '\n'
587		<< h.barplot() << endl;
	599	cerr << "Stats mean: " << setprecision(4) << h.mean()
	600	<< " "
	601	"median: "
	602	<< setprecision(4) << h.median()
	603	<< " "
	604	"sd: "
	605	<< setprecision(4) << h.sd()
	606	<< " "
	607	"n: "
	608	<< h.size()
	609	<< " "
	610	"min: "
	611	<< h.minimum() << " max: " << h.maximum() << '\n'
	612	<< h.barplot() << endl;
588	613
589	614	if (stats.numFF > numFR && stats.numFF > numRF) {
590	615	cerr << "error: The mate pairs of this library are oriented "
591		"forward-forward (FF), which is not supported by ABySS."
592		<< endl;
	616	"forward-forward (FF), which is not supported by ABySS."
	617	<< endl;
593	618	exit(EXIT_FAILURE);
594	619	}
595	620

598	623
599	624	/** Return whether any k-mer in the query is aligned more than once.
600	625	*/
601		static bool checkUniqueAlignments(const AlignmentVector& alignVec)
	626	static bool
	627	checkUniqueAlignments(const AlignmentVector& alignVec)
602	628	{
603	629	assert(!alignVec.empty());
604	630	if (alignVec.size() == 1)

607	633	unsigned nKmer = alignVec.front().read_length - opt::k + 1;
608	634	vector<unsigned> coverage(nKmer);
609	635
610		for (AlignmentVector::const_iterator iter = alignVec.begin();
611		iter != alignVec.end(); ++iter) {
	636	for (AlignmentVector::const_iterator iter = alignVec.begin(); iter != alignVec.end(); ++iter) {
612	637	assert((unsigned)iter->align_length >= opt::k);
613		unsigned end = iter->read_start_pos
614		+ iter->align_length - opt::k + 1;
	638	unsigned end = iter->read_start_pos + iter->align_length - opt::k + 1;
615	639	assert(end <= nKmer);
616	640	for (unsigned i = iter->read_start_pos; i < end; i++)
617	641	coverage[i]++;

623	647	return true;
624	648	}
625	649
626		static bool replaceSuffix(string& s,
627		const string& suffix0, const string& suffix1)
	650	static bool
	651	replaceSuffix(string& s, const string& suffix0, const string& suffix1)
628	652	{
629	653	if (endsWith(s, suffix0)) {
630		s.replace(s.length() - suffix0.length(), string::npos,
631		suffix1);
	654	s.replace(s.length() - suffix0.length(), string::npos, suffix1);
632	655	return true;
633	656	} else if (endsWith(s, suffix1)) {
634		s.replace(s.length() - suffix1.length(), string::npos,
635		suffix0);
	657	s.replace(s.length() - suffix1.length(), string::npos, suffix0);
636	658	return true;
637	659	} else
638	660	return false;
639	661	}
640	662
641	663	/** Return true if the specified read ID is of a single-end read. */
642		static bool isSingleEnd(const string& id)
	664	static bool
	665	isSingleEnd(const string& id)
643	666	{
644	667	unsigned l = id.length();
645		return endsWith(id, ".fn")
646		\|\| (l > 6 && id.substr(l-6, 5) == ".part");
	668	return endsWith(id, ".fn") \|\| (l > 6 && id.substr(l - 6, 5) == ".part");
647	669	}
648	670
649	671	/** Return the mate ID of the specified read ID. */
650		static string makePairID(string id)
	672	static string
	673	makePairID(string id)
651	674	{
652	675	if (equal(id.begin(), id.begin() + 3, "SRR"))
653	676	return id;

655	678	assert(!id.empty());
656	679	char& c = id[id.length() - 1];
657	680	switch (c) {
658		case '1': c = '2'; return id;
659		case '2': c = '1'; return id;
660		case 'A': c = 'B'; return id;
661		case 'B': c = 'A'; return id;
662		case 'F': c = 'R'; return id;
663		case 'R': c = 'F'; return id;
664		case 'f': c = 'r'; return id;
665		case 'r': c = 'f'; return id;
666		}
667
668		if (replaceSuffix(id, "forward", "reverse")
669		\|\| replaceSuffix(id, "F3", "R3"))
670		return id;
671
672		cerr << "error: read ID `" << id << "' must end in one of\n"
673		"\t1 and 2 or A and B or F and R or"
674		" F3 and R3 or forward and reverse\n";
	681	case '1':
	682	c = '2';
	683	return id;
	684	case '2':
	685	c = '1';
	686	return id;
	687	case 'A':
	688	c = 'B';
	689	return id;
	690	case 'B':
	691	c = 'A';
	692	return id;
	693	case 'F':
	694	c = 'R';
	695	return id;
	696	case 'R':
	697	c = 'F';
	698	return id;
	699	case 'f':
	700	c = 'r';
	701	return id;
	702	case 'r':
	703	c = 'f';
	704	return id;
	705	}
	706
	707	if (replaceSuffix(id, "forward", "reverse") \|\| replaceSuffix(id, "F3", "R3"))
	708	return id;
	709
	710	cerr << "error: read ID `" << id
	711	<< "' must end in one of\n"
	712	"\t1 and 2 or A and B or F and R or"
	713	" F3 and R3 or forward and reverse\n";
675	714	exit(EXIT_FAILURE);
676	715	}
677	716
678		static bool needsFlipping(const string& id)
	717	static bool
	718	needsFlipping(const string& id)
679	719	{
680	720	return endsWith(id, "F3");
681	721	}

+237

-211

ParseAligns/abyss-fixmate.cc less more

	0	#include "ContigID.h"
	1	#include "DataBase/DB.h"
	2	#include "DataBase/Options.h"
0	3	#include "Histogram.h"
1	4	#include "IOUtil.h"
2	5	#include "MemoryUtil.h"

4	7	#include "StringUtil.h"
5	8	#include "Uncompress.h"
6	9	#include "UnorderedMap.h"
7		#include "ContigID.h"
8	10	#include <algorithm>
	11	#include <boost/unordered_map.hpp>
9	12	#include <climits>
10	13	#include <cstdlib>
11	14	#include <fstream>

13	16	#include <getopt.h>
14	17	#include <iomanip>
15	18	#include <iostream>
16		#include <boost/unordered_map.hpp>
17		#include "DataBase/Options.h"
18		#include "DataBase/DB.h"
19	19
20	20	using namespace std;
21	21

24	24	DB db;
25	25
26	26	static const char VERSION_MESSAGE[] =
27		PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
28		"Written by Shaun Jackman.\n"
29		"\n"
30		"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
	27	PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
	28	"Written by Shaun Jackman.\n"
	29	"\n"
	30	"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
31	31
32	32	static const char USAGE_MESSAGE[] =
33		"Usage: " PROGRAM " [OPTION]... [FILE]...\n"
34		"Write read pairs that map to the same contig to the file SAME.\n"
35		"Write read pairs that map to different contigs to stdout.\n"
36		"Alignments may be in FILE(s) or standard input.\n"
37		"\n"
38		" Options:\n"
39		"\n"
40		" --no-qname set the qname to * [default]\n"
41		" --qname do not alter the qname\n"
42		" --all print all alignments\n"
43		" --diff print alignments that align to different\n"
44		" contigs [default]\n"
45		" -l, --min-align=N the minimal alignment size [1]\n"
46		" -s, --same=SAME write properly-paired reads to this file\n"
47		" -h, --hist=FILE write the fragment size histogram to FILE\n"
48		" -c, --cov=FILE write the physical coverage to FILE\n"
49		" -v, --verbose display verbose output\n"
50		" --help display this help and exit\n"
51		" --version output version information and exit\n"
52		" --db=FILE specify path of database repository in FILE\n"
53		" --library=NAME specify library NAME for sqlite\n"
54		" --strain=NAME specify strain NAME for sqlite\n"
55		" --species=NAME specify species NAME for sqlite\n"
56		"\n"
57		"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
	33	"Usage: " PROGRAM " [OPTION]... [FILE]...\n"
	34	"Write read pairs that map to the same contig to the file SAME.\n"
	35	"Write read pairs that map to different contigs to stdout.\n"
	36	"Alignments may be in FILE(s) or standard input.\n"
	37	"\n"
	38	" Options:\n"
	39	"\n"
	40	" --no-qname set the qname to * [default]\n"
	41	" --qname do not alter the qname\n"
	42	" --all print all alignments\n"
	43	" --diff print alignments that align to different\n"
	44	" contigs [default]\n"
	45	" -l, --min-align=N the minimal alignment size [1]\n"
	46	" -s, --same=SAME write properly-paired reads to this file\n"
	47	" -h, --hist=FILE write the fragment size histogram to FILE\n"
	48	" -c, --cov=FILE write the physical coverage to FILE\n"
	49	" -v, --verbose display verbose output\n"
	50	" --help display this help and exit\n"
	51	" --version output version information and exit\n"
	52	" --db=FILE specify path of database repository in FILE\n"
	53	" --library=NAME specify library NAME for sqlite\n"
	54	" --strain=NAME specify strain NAME for sqlite\n"
	55	" --species=NAME specify species NAME for sqlite\n"
	56	"\n"
	57	"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
58	58
59	59	namespace opt {
60		string db;
61		dbVars metaVars;
62		static string fragPath;
63		static string histPath;
64		static string covPath;
65		static int qname;
66		static int verbose;
67		static int print_all;
	60	string db;
	61	dbVars metaVars;
	62	static string fragPath;
	63	static string histPath;
	64	static string covPath;
	65	static int qname;
	66	static int verbose;
	67	static int print_all;
68	68	}
69	69
70	70	// for sqlite params

73	73
74	74	static const char shortopts[] = "h:c:l:s:v";
75	75
76		enum { OPT_HELP = 1, OPT_VERSION, OPT_DB, OPT_LIBRARY, OPT_STRAIN, OPT_SPECIES };
77
78		static const struct option longopts[] = {
79		{ "qname", no_argument, &opt::qname, 1 },
80		{ "no-qname", no_argument, &opt::qname, 0 },
81		{ "all", no_argument, &opt::print_all, 1 },
82		{ "diff", no_argument, &opt::print_all, 0 },
83		{ "min-align", required_argument, NULL, 'l' },
84		{ "hist", required_argument, NULL, 'h' },
85		{ "cov", required_argument, NULL, 'c' },
86		{ "same", required_argument, NULL, 's' },
87		{ "verbose", no_argument, NULL, 'v' },
88		{ "help", no_argument, NULL, OPT_HELP },
89		{ "version", no_argument, NULL, OPT_VERSION },
90		{ "db", required_argument, NULL, OPT_DB },
91		{ "library", required_argument, NULL, OPT_LIBRARY },
92		{ "strain", required_argument, NULL, OPT_STRAIN },
93		{ "species", required_argument, NULL, OPT_SPECIES },
94		{ NULL, 0, NULL, 0 }
	76	enum
	77	{
	78	OPT_HELP = 1,
	79	OPT_VERSION,
	80	OPT_DB,
	81	OPT_LIBRARY,
	82	OPT_STRAIN,
	83	OPT_SPECIES
95	84	};
96	85
97		static struct {
	86	static const struct option longopts[] = { { "qname", no_argument, &opt::qname, 1 },
	87	{ "no-qname", no_argument, &opt::qname, 0 },
	88	{ "all", no_argument, &opt::print_all, 1 },
	89	{ "diff", no_argument, &opt::print_all, 0 },
	90	{ "min-align", required_argument, NULL, 'l' },
	91	{ "hist", required_argument, NULL, 'h' },
	92	{ "cov", required_argument, NULL, 'c' },
	93	{ "same", required_argument, NULL, 's' },
	94	{ "verbose", no_argument, NULL, 'v' },
	95	{ "help", no_argument, NULL, OPT_HELP },
	96	{ "version", no_argument, NULL, OPT_VERSION },
	97	{ "db", required_argument, NULL, OPT_DB },
	98	{ "library", required_argument, NULL, OPT_LIBRARY },
	99	{ "strain", required_argument, NULL, OPT_STRAIN },
	100	{ "species", required_argument, NULL, OPT_SPECIES },
	101	{ NULL, 0, NULL, 0 } };
	102
	103	static struct
	104	{
98	105	size_t alignments;
99	106	size_t bothUnaligned;
100	107	size_t oneUnaligned;

105	112	static ofstream g_fragFile;
106	113	static Histogram g_histogram;
107	114	static ofstream g_covFile;
108		static vector< vector<int> > g_contigCov;
109
110		static void incrementRange(SAMRecord& a)
	115	static vector<vector<int>> g_contigCov;
	116
	117	static void
	118	incrementRange(SAMRecord& a)
111	119	{
112	120	unsigned inx = get(g_contigNames, a.rname);
113	121	g_contigCov[inx][a.pos]++;

118	126	g_contigCov[inx][end]--;
119	127	}
120	128
121		static void handlePair(SAMRecord& a0, SAMRecord& a1)
122		{
123		if ((a0.isRead1() && a1.isRead1())
124		\|\| (a0.isRead2() && a1.isRead2())) {
125		cerr << "error: duplicate read ID `" << a0.qname
126		<< (a0.isRead1() ? "/1" : "")
127		<< (a0.isRead2() ? "/2" : "")
128		<< "'\n";
	129	static void
	130	handlePair(SAMRecord& a0, SAMRecord& a1)
	131	{
	132	if ((a0.isRead1() && a1.isRead1()) \|\| (a0.isRead2() && a1.isRead2())) {
	133	cerr << "error: duplicate read ID `" << a0.qname << (a0.isRead1() ? "/1" : "")
	134	<< (a0.isRead2() ? "/2" : "") << "'\n";
129	135	exit(EXIT_FAILURE);
130	136	}
131	137

174	180	typedef boost::unordered_map<string, SAMAlignment> Alignments;
175	181	#endif
176	182
177		static void printProgress(const Alignments& map)
	183	static void
	184	printProgress(const Alignments& map)
178	185	{
179	186	if (opt::verbose == 0)
180	187	return;

188	195	prevBuckets = buckets;
189	196	size_t size = map.size();
190	197	cerr << "Read " << stats.alignments << " alignments. "
191		<< "Hash load: " << size << " / " << buckets
192		<< " = " << (float)size / buckets
193		<< " using " << toSI(getMemoryUsage()) << "B." << endl;
194		}
195		}
196
197		static void handleAlignment(SAMRecord& sam, Alignments& map)
198		{
199		pair<Alignments::iterator, bool> it = map.insert(
200		make_pair(sam.qname, sam));
	198	<< "Hash load: " << size << " / " << buckets << " = " << (float)size / buckets
	199	<< " using " << toSI(getMemoryUsage()) << "B." << endl;
	200	}
	201	}
	202
	203	static void
	204	handleAlignment(SAMRecord& sam, Alignments& map)
	205	{
	206	pair<Alignments::iterator, bool> it = map.insert(make_pair(sam.qname, sam));
201	207	if (!it.second) {
202	208	#if SAM_SEQ_QUAL
203	209	SAMRecord& a0 = it.first->second;

221	227	printProgress(map);
222	228	}
223	229
224		static void assert_eof(istream& in)
	230	static void
	231	assert_eof(istream& in)
225	232	{
226	233	if (in.eof())
227	234	return;

233	240	}
234	241
235	242	/** Print physical coverage in wiggle format. */
236		static void printCov(string file)
	243	static void
	244	printCov(string file)
237	245	{
238	246	ofstream out(file.c_str());
239	247	for (unsigned i = 0; i < g_contigCov.size(); i++) {
240	248	out << "variableStep\tchrom=" << get(g_contigNames, i) << '\n';
241	249	int prev = g_contigCov[i][0];
242		if (prev != 0) out << "0\t" << prev << '\n';
	250	if (prev != 0)
	251	out << "0\t" << prev << '\n';
243	252	for (unsigned j = 1; j < g_contigCov[i].size(); j++) {
244	253	prev += g_contigCov[i][j];
245		if (prev != 0) out << j << "\t" << prev << '\n';
246		}
247		}
248		}
249
250		void parseTag(string line) {
	254	if (prev != 0)
	255	out << j << "\t" << prev << '\n';
	256	}
	257	}
	258	}
	259
	260	void
	261	parseTag(string line)
	262	{
251	263	stringstream ss(line);
252	264	string tag;
253	265	char type[2];

268	280	assert(length > 0);
269	281	assert(id.size() > 0);
270	282	put(g_contigNames, g_contigCov.size(), id);
271		g_contigCov.push_back(vector<int>(length));
272		}
273
274		static void readAlignments(istream& in, Alignments* pMap)
	283	g_contigCov.push_back(vector<int>(length));
	284	}
	285
	286	static void
	287	readAlignments(istream& in, Alignments* pMap)
275	288	{
276	289	for (SAMRecord sam; in >> ws;) {
277	290	if (in.peek() == '@') {

293	306	assert_eof(in);
294	307	}
295	308
296		static void readAlignmentsFile(string path, Alignments* pMap)
	309	static void
	310	readAlignmentsFile(string path, Alignments* pMap)
297	311	{
298	312	if (opt::verbose > 0)
299	313	cerr << "Reading `" << path << "'..." << endl;

304	318	}
305	319
306	320	/** Return the specified number formatted as a percent. */
307		static string percent(size_t x, size_t n)
	321	static string
	322	percent(size_t x, size_t n)
308	323	{
309	324	ostringstream ss;
310	325	ss << setw((int)log10(n) + 1) << x;
311	326	if (x > 0)
312		ss << " " << setprecision(3) << (float)100*x/n << '%';
	327	ss << " " << setprecision(3) << (float)100 * x / n << '%';
313	328	return ss.str();
314	329	}
315	330
316	331	/** Print statistics of the specified histogram. h not passed by
317		* reference because we want to make a copy
	332	* reference because we want to make a copy
318	333	**/
319		static void printHistogramStats(Histogram h)
	334	static void
	335	printHistogramStats(Histogram h)
320	336	{
321	337	unsigned n_orig = h.size();
322	338	h.eraseNegative();
323	339	h.removeNoise();
324	340	h.removeOutliers();
325	341	h = h.trimFraction(0.0001);
326		cerr << "Stats mean: " << setprecision(4) << h.mean() << " "
327		"median: " << setprecision(4) << h.median() << " "
328		"sd: " << setprecision(4) << h.sd() << " "
329		"n: " << h.size() << " "
330		"min: " << h.minimum() << " "
331		"max: " << h.maximum() << " "
332		"ignored: " << n_orig - h.size() << '\n'
333		<< h.barplot() << endl;
	342	cerr << "Stats mean: " << setprecision(4) << h.mean()
	343	<< " "
	344	"median: "
	345	<< setprecision(4) << h.median()
	346	<< " "
	347	"sd: "
	348	<< setprecision(4) << h.sd()
	349	<< " "
	350	"n: "
	351	<< h.size()
	352	<< " "
	353	"min: "
	354	<< h.minimum()
	355	<< " "
	356	"max: "
	357	<< h.maximum()
	358	<< " "
	359	"ignored: "
	360	<< n_orig - h.size() << '\n'
	361	<< h.barplot() << endl;
334	362	if (!opt::db.empty()) {
335		vals = make_vector<int>()
336		<< (int)round(h.mean())
337		<< h.median()
338		<< (int)round(h.sd())
339		<< h.size()
340		<< h.minimum()
341		<< h.maximum()
342		<< n_orig-h.size();
343
344		keys = make_vector<string>()
345		<< "mean"
346		<< "median"
347		<< "sd"
348		<< "n"
349		<< "min"
350		<< "max"
351		<< "ignored";
352
353		for (unsigned i=0; i<vals.size(); i++)
	363	vals = make_vector<int>() << (int)round(h.mean()) << h.median() << (int)round(h.sd())
	364	<< h.size() << h.minimum() << h.maximum() << n_orig - h.size();
	365
	366	keys = make_vector<string>() << "mean"
	367	<< "median"
	368	<< "sd"
	369	<< "n"
	370	<< "min"
	371	<< "max"
	372	<< "ignored";
	373
	374	for (unsigned i = 0; i < vals.size(); i++)
354	375	addToDb(db, keys[i], vals[i]);
355	376	}
356	377	}
357	378
358		int main(int argc, char* const* argv)
	379	int
	380	main(int argc, char* const* argv)
359	381	{
360	382	opt::metaVars.resize(3);
361	383
362	384	bool die = false;
363		for (int c; (c = getopt_long(argc, argv,
364		shortopts, longopts, NULL)) != -1;) {
	385	for (int c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) {
365	386	istringstream arg(optarg != NULL ? optarg : "");
366	387	switch (c) {
367		case '?': die = true; break;
368		case 'l':
369		arg >> opt::minAlign;
370		break;
371		case 's': arg >> opt::fragPath; break;
372		case 'h': arg >> opt::histPath; break;
373		case 'c': arg >> opt::covPath; break;
374		case 'v': opt::verbose++; break;
375		case OPT_HELP:
376		cout << USAGE_MESSAGE;
377		exit(EXIT_SUCCESS);
378		case OPT_VERSION:
379		cout << VERSION_MESSAGE;
380		exit(EXIT_SUCCESS);
381		case OPT_DB:
382		arg >> opt::db;
383		break;
384		case OPT_LIBRARY:
385		arg >> opt::metaVars[0];
386		break;
387		case OPT_STRAIN:
388		arg >> opt::metaVars[1];
389		break;
390		case OPT_SPECIES:
391		arg >> opt::metaVars[2];
392		break;
	388	case '?':
	389	die = true;
	390	break;
	391	case 'l':
	392	arg >> opt::minAlign;
	393	break;
	394	case 's':
	395	arg >> opt::fragPath;
	396	break;
	397	case 'h':
	398	arg >> opt::histPath;
	399	break;
	400	case 'c':
	401	arg >> opt::covPath;
	402	break;
	403	case 'v':
	404	opt::verbose++;
	405	break;
	406	case OPT_HELP:
	407	cout << USAGE_MESSAGE;
	408	exit(EXIT_SUCCESS);
	409	case OPT_VERSION:
	410	cout << VERSION_MESSAGE;
	411	exit(EXIT_SUCCESS);
	412	case OPT_DB:
	413	arg >> opt::db;
	414	break;
	415	case OPT_LIBRARY:
	416	arg >> opt::metaVars[0];
	417	break;
	418	case OPT_STRAIN:
	419	arg >> opt::metaVars[1];
	420	break;
	421	case OPT_SPECIES:
	422	arg >> opt::metaVars[2];
	423	break;
393	424	}
394	425	if (optarg != NULL && !arg.eof()) {
395		cerr << PROGRAM ": invalid option: `-"
396		<< (char)c << optarg << "'\n";
	426	cerr << PROGRAM ": invalid option: `-" << (char)c << optarg << "'\n";
397	427	exit(EXIT_FAILURE);
398	428	}
399	429	}
400	430
401	431	if (die) {
402		cerr << "Try `" << PROGRAM
403		<< " --help' for more information.\n";
	432	cerr << "Try `" << PROGRAM << " --help' for more information.\n";
404	433	exit(EXIT_FAILURE);
405	434	}
406	435

410	439	}
411	440
412	441	if (!opt::db.empty())
413		init(db,
414		opt::db,
415		opt::verbose,
416		PROGRAM,
417		opt::getCommand(argc, argv),
418		opt::metaVars
419		);
	442	init(db, opt::db, opt::verbose, PROGRAM, opt::getCommand(argc, argv), opt::metaVars);
420	443
421	444	Alignments alignments(1);
422	445	if (optind < argc) {
423		for_each(argv + optind, argv + argc,
424		bind2nd(ptr_fun(readAlignmentsFile), &alignments));
	446	for_each(argv + optind, argv + argc, [&alignments](const std::string& s) {
	447	readAlignmentsFile(s, &alignments);
	448	});
425	449	} else {
426	450	if (opt::verbose > 0)
427	451	cerr << "Reading from standard input..." << endl;

434	458
435	459	// Print the unpaired alignments.
436	460	if (opt::print_all) {
437		for (Alignments::iterator it = alignments.begin();
438		it != alignments.end(); it++) {
	461	for (Alignments::iterator it = alignments.begin(); it != alignments.end(); it++) {
439	462	#if SAM_SEQ_QUAL
440	463	SAMRecord& a0 = it->second;
441	464	#else

449	472
450	473	unsigned numRF = g_histogram.count(INT_MIN, 0);
451	474	unsigned numFR = g_histogram.count(1, INT_MAX);
452		size_t sum = alignments.size()
453		+ stats.bothUnaligned + stats.oneUnaligned
454		+ numFR + numRF + stats.numFF
455		+ stats.numDifferent;
456		cerr <<
457		"Mateless " << percent(alignments.size(), sum) << "\n"
458		"Unaligned " << percent(stats.bothUnaligned, sum) << "\n"
459		"Singleton " << percent(stats.oneUnaligned, sum) << "\n"
460		"FR " << percent(numFR, sum) << "\n"
461		"RF " << percent(numRF, sum) << "\n"
462		"FF " << percent(stats.numFF, sum) << "\n"
463		"Different " << percent(stats.numDifferent, sum) << "\n"
464		"Total " << sum << endl;
	475	size_t sum = alignments.size() + stats.bothUnaligned + stats.oneUnaligned + numFR + numRF +
	476	stats.numFF + stats.numDifferent;
	477	cerr << "Mateless " << percent(alignments.size(), sum)
	478	<< "\n"
	479	"Unaligned "
	480	<< percent(stats.bothUnaligned, sum)
	481	<< "\n"
	482	"Singleton "
	483	<< percent(stats.oneUnaligned, sum)
	484	<< "\n"
	485	"FR "
	486	<< percent(numFR, sum)
	487	<< "\n"
	488	"RF "
	489	<< percent(numRF, sum)
	490	<< "\n"
	491	"FF "
	492	<< percent(stats.numFF, sum)
	493	<< "\n"
	494	"Different "
	495	<< percent(stats.numDifferent, sum)
	496	<< "\n"
	497	"Total "
	498	<< sum << endl;
465	499
466	500	if (!opt::db.empty()) {
467		vals = make_vector<int>()
468		<< alignments.size()
469		<< stats.bothUnaligned
470		<< stats.oneUnaligned
471		<< numFR
472		<< numRF
473		<< stats.numFF
474		<< stats.numDifferent
475		<< sum;
476
477		keys = make_vector<string>()
478		<< "Mateless"
479		<< "Unaligned"
480		<< "Singleton"
481		<< "FR"
482		<< "RF"
483		<< "FF"
484		<< "Different"
485		<< "Total";
486
487		for (unsigned i=0; i<vals.size(); i++)
	501	vals = make_vector<int>() << alignments.size() << stats.bothUnaligned << stats.oneUnaligned
	502	<< numFR << numRF << stats.numFF << stats.numDifferent << sum;
	503
	504	keys = make_vector<string>() << "Mateless"
	505	<< "Unaligned"
	506	<< "Singleton"
	507	<< "FR"
	508	<< "RF"
	509	<< "FF"
	510	<< "Different"
	511	<< "Total";
	512
	513	for (unsigned i = 0; i < vals.size(); i++)
488	514	addToDb(db, keys[i], vals[i]);
489	515	}
490	516
491	517	if (alignments.size() == sum) {
492	518	cerr << PROGRAM ": error: All reads are mateless. This "
493		"can happen when first and second read IDs do not match."
494		<< endl;
	519	"can happen when first and second read IDs do not match."
	520	<< endl;
495	521	exit(EXIT_FAILURE);
496	522	}
497	523

524	550
525	551	if (stats.numFF > numFR && stats.numFF > numRF) {
526	552	cerr << PROGRAM ": error: The mate pairs of this library are "
527		"oriented forward-forward (FF), which is not supported "
528		"by ABySS."
529		<< endl;
	553	"oriented forward-forward (FF), which is not supported "
	554	"by ABySS."
	555	<< endl;
530	556	exit(EXIT_FAILURE);
531	557	}
532	558

+289

-283

PathOverlap/PathOverlap.cpp less more

0		#include "config.h"
1	0	#include "ContigID.h"
2	1	#include "ContigPath.h"
3	2	#include "ContigProperties.h"
	3	#include "DataBase/DB.h"
	4	#include "DataBase/Options.h"
4	5	#include "Functional.h"
5		#include "IOUtil.h"
6		#include "Uncompress.h"
7	6	#include "Graph/ContigGraph.h"
8	7	#include "Graph/ContigGraphAlgorithms.h"
9	8	#include "Graph/DirectedGraph.h"
10	9	#include "Graph/GraphIO.h"
	10	#include "IOUtil.h"
	11	#include "Uncompress.h"
	12	#include "config.h"
11	13	#include <algorithm>
12	14	#include <cassert>
13	15	#include <cerrno>
	16	#include <cstdlib>
14	17	#include <cstring> // for strerror
15		#include <cstdlib>
	18	#include <fstream>
16	19	#include <functional>
	20	#include <getopt.h>
17	21	#include <iostream>
18		#include <fstream>
19		#include <getopt.h>
20	22	#include <map>
21	23	#include <vector>
22		#include "DataBase/Options.h"
23		#include "DataBase/DB.h"
24	24
25	25	using namespace std;
26	26

28	28
29	29	DB db;
30	30
31		static const char *VERSION_MESSAGE =
32		PROGRAM " (ABySS) " VERSION "\n"
33		"Written by Shaun Jackman and Tony Raymond.\n"
34		"\n"
35		"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
36
37		static const char *USAGE_MESSAGE =
38		"Usage: " PROGRAM " -k<kmer> [OPTION]... ADJ PATH\n"
39		"Find paths that overlap. Either output the graph of overlapping\n"
40		"paths, assemble overlapping paths into larger paths, or trim the\n"
41		"overlapping paths.\n"
42		"\n"
43		" Arguments:\n"
44		"\n"
45		" ADJ contig adjacency graph\n"
46		" PATH sequences of contig IDs\n"
47		"\n"
48		" Options:\n"
49		"\n"
50		" -k, --kmer=N k-mer size\n"
51		" -g, --graph=FILE write the contig adjacency graph to FILE\n"
52		" -r, --repeats=FILE write repeat contigs to FILE\n"
53		" --overlap find overlapping paths [default]\n"
54		" --assemble assemble overlapping paths\n"
55		" --trim trim overlapping paths\n"
56		" --adj output the graph in ADJ format [default]\n"
57		" --asqg output the graph in ASQG format\n"
58		" --dot output the graph in GraphViz format\n"
59		" --gfa output the graph in GFA1 format\n"
60		" --gfa1 output the graph in GFA1 format\n"
61		" --gfa2 output the graph in GFA2 format\n"
62		" --gv output the graph in GraphViz format\n"
63		" --sam output the graph in SAM format\n"
64		" --SS expect contigs to be oriented correctly\n"
65		" --no-SS no assumption about contig orientation [default]\n"
66		" -v, --verbose display verbose output\n"
67		" --help display this help and exit\n"
68		" --version output version information and exit\n"
69		" --db=FILE specify path of database repository in FILE\n"
70		" --library=NAME specify library NAME for sqlite\n"
71		" --strain=NAME specify strain NAME for sqlite\n"
72		" --species=NAME specify species NAME for sqlite\n"
73		"\n"
74		"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
	31	static const char* VERSION_MESSAGE =
	32	PROGRAM " (ABySS) " VERSION "\n"
	33	"Written by Shaun Jackman and Tony Raymond.\n"
	34	"\n"
	35	"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
	36
	37	static const char* USAGE_MESSAGE =
	38	"Usage: " PROGRAM " -k<kmer> [OPTION]... ADJ PATH\n"
	39	"Find paths that overlap. Either output the graph of overlapping\n"
	40	"paths, assemble overlapping paths into larger paths, or trim the\n"
	41	"overlapping paths.\n"
	42	"\n"
	43	" Arguments:\n"
	44	"\n"
	45	" ADJ contig adjacency graph\n"
	46	" PATH sequences of contig IDs\n"
	47	"\n"
	48	" Options:\n"
	49	"\n"
	50	" -k, --kmer=N k-mer size\n"
	51	" -g, --graph=FILE write the contig adjacency graph to FILE\n"
	52	" -r, --repeats=FILE write repeat contigs to FILE\n"
	53	" --overlap find overlapping paths [default]\n"
	54	" --assemble assemble overlapping paths\n"
	55	" --trim trim overlapping paths\n"
	56	" --adj output the graph in ADJ format [default]\n"
	57	" --asqg output the graph in ASQG format\n"
	58	" --dot output the graph in GraphViz format\n"
	59	" --gfa output the graph in GFA1 format\n"
	60	" --gfa1 output the graph in GFA1 format\n"
	61	" --gfa2 output the graph in GFA2 format\n"
	62	" --gv output the graph in GraphViz format\n"
	63	" --sam output the graph in SAM format\n"
	64	" --SS expect contigs to be oriented correctly\n"
	65	" --no-SS no assumption about contig orientation [default]\n"
	66	" -v, --verbose display verbose output\n"
	67	" --help display this help and exit\n"
	68	" --version output version information and exit\n"
	69	" --db=FILE specify path of database repository in FILE\n"
	70	" --library=NAME specify library NAME for sqlite\n"
	71	" --strain=NAME specify strain NAME for sqlite\n"
	72	" --species=NAME specify species NAME for sqlite\n"
	73	"\n"
	74	"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
75	75
76	76	namespace opt {
77		string db;
78		dbVars metaVars;
79		unsigned k;
80
81		/** Output format. */
82		int format; // used by ContigProperties
83
84		/** Write the contig adjacency graph to this file. */
85		static string graphPath;
86
87		/** Output the IDs of contigs in overlaps to this file. */
88		static string repeatContigs;
89
90		/** Run a strand-specific RNA-Seq assembly. */
91		static int ss;
92
93		/** Mode of operation. */
94		enum {
95		/** Find overlapping paths, do not assemble. */
96		OVERLAP,
97		/** Assemble overlapping paths. */
98		ASSEMBLE,
99		/** Trim overlapping paths. */
100		TRIM,
101		};
102		static int mode;
103
104		static int verbose;
	77	string db;
	78	dbVars metaVars;
	79	unsigned k;
	80
	81	/** Output format. */
	82	int format; // used by ContigProperties
	83
	84	/** Write the contig adjacency graph to this file. */
	85	static string graphPath;
	86
	87	/** Output the IDs of contigs in overlaps to this file. */
	88	static string repeatContigs;
	89
	90	/** Run a strand-specific RNA-Seq assembly. */
	91	static int ss;
	92
	93	/** Mode of operation. */
	94	enum
	95	{
	96	/** Find overlapping paths, do not assemble. */
	97	OVERLAP,
	98	/** Assemble overlapping paths. */
	99	ASSEMBLE,
	100	/** Trim overlapping paths. */
	101	TRIM,
	102	};
	103	static int mode;
	104
	105	static int verbose;
105	106	}
106	107
107	108	static const char* shortopts = "g:k:r:v";
108	109
109		enum { OPT_HELP = 1, OPT_VERSION, OPT_DB, OPT_LIBRARY, OPT_STRAIN, OPT_SPECIES };
110		//enum { OPT_HELP = 1, OPT_VERSION };
111
112		static const struct option longopts[] = {
113		{ "graph", required_argument, NULL, 'g' },
114		{ "kmer", required_argument, NULL, 'k' },
115		{ "assemble", no_argument, &opt::mode, opt::ASSEMBLE },
116		{ "overlap", no_argument, &opt::mode, opt::OVERLAP },
117		{ "trim", no_argument, &opt::mode, opt::TRIM },
118		{ "adj", no_argument, &opt::format, ADJ },
119		{ "asqg", no_argument, &opt::format, ASQG },
120		{ "dot", no_argument, &opt::format, DOT },
121		{ "gfa", no_argument, &opt::format, GFA1 },
122		{ "gfa1", no_argument, &opt::format, GFA1 },
123		{ "gfa2", no_argument, &opt::format, GFA2 },
124		{ "gv", no_argument, &opt::format, DOT },
125		{ "sam", no_argument, &opt::format, SAM },
126		{ "SS", no_argument, &opt::ss, 1 },
127		{ "no-SS", no_argument, &opt::ss, 0 },
128		{ "repeats", required_argument, NULL, 'r' },
129		{ "verbose", no_argument, NULL, 'v' },
130		{ "help", no_argument, NULL, OPT_HELP },
131		{ "version", no_argument, NULL, OPT_VERSION },
132		{ "db", required_argument, NULL, OPT_DB },
133		{ "library", required_argument, NULL, OPT_LIBRARY },
134		{ "strain", required_argument, NULL, OPT_STRAIN },
135		{ "species", required_argument, NULL, OPT_SPECIES },
136		{ NULL, 0, NULL, 0 }
	110	enum
	111	{
	112	OPT_HELP = 1,
	113	OPT_VERSION,
	114	OPT_DB,
	115	OPT_LIBRARY,
	116	OPT_STRAIN,
	117	OPT_SPECIES
137	118	};
	119	// enum { OPT_HELP = 1, OPT_VERSION };
	120
	121	static const struct option longopts[] = { { "graph", required_argument, NULL, 'g' },
	122	{ "kmer", required_argument, NULL, 'k' },
	123	{ "assemble", no_argument, &opt::mode, opt::ASSEMBLE },
	124	{ "overlap", no_argument, &opt::mode, opt::OVERLAP },
	125	{ "trim", no_argument, &opt::mode, opt::TRIM },
	126	{ "adj", no_argument, &opt::format, ADJ },
	127	{ "asqg", no_argument, &opt::format, ASQG },
	128	{ "dot", no_argument, &opt::format, DOT },
	129	{ "gfa", no_argument, &opt::format, GFA1 },
	130	{ "gfa1", no_argument, &opt::format, GFA1 },
	131	{ "gfa2", no_argument, &opt::format, GFA2 },
	132	{ "gv", no_argument, &opt::format, DOT },
	133	{ "sam", no_argument, &opt::format, SAM },
	134	{ "SS", no_argument, &opt::ss, 1 },
	135	{ "no-SS", no_argument, &opt::ss, 0 },
	136	{ "repeats", required_argument, NULL, 'r' },
	137	{ "verbose", no_argument, NULL, 'v' },
	138	{ "help", no_argument, NULL, OPT_HELP },
	139	{ "version", no_argument, NULL, OPT_VERSION },
	140	{ "db", required_argument, NULL, OPT_DB },
	141	{ "library", required_argument, NULL, OPT_LIBRARY },
	142	{ "strain", required_argument, NULL, OPT_STRAIN },
	143	{ "species", required_argument, NULL, OPT_SPECIES },
	144	{ NULL, 0, NULL, 0 } };
138	145
139	146	/** A vertex of the overlap graph. */
140		struct Vertex {
	147	struct Vertex
	148	{
141	149	unsigned id;
142	150	bool sense;
143	151

145	153	static unsigned s_offset;
146	154
147	155	Vertex(unsigned id, bool sense)
148		: id(id), sense(sense) { }
149
150		bool operator ==(const Vertex& v) const
151		{
152		return id == v.id && sense == v.sense;
153		}
154
155		ContigNode descriptor() const
156		{
157		return ContigNode(s_offset + id, sense);
158		}
	156	: id(id)
	157	, sense(sense)
	158	{}
	159
	160	bool operator==(const Vertex& v) const { return id == v.id && sense == v.sense; }
	161
	162	ContigNode descriptor() const { return ContigNode(s_offset + id, sense); }
159	163	};
160	164
161	165	unsigned Vertex::s_offset;
162	166
163	167	/** An alignment of two overlapping contigs. */
164		struct Overlap {
	168	struct Overlap
	169	{
165	170	Vertex source;
166	171	Vertex target;
167	172

171	176	/** Overlap measured in bp. */
172	177	int distance;
173	178
174		Overlap(const Vertex& source, const Vertex& target,
175		unsigned overlap, int distance)
176		: source(source), target(target),
177		overlap(overlap), distance(distance) { }
	179	Overlap(const Vertex& source, const Vertex& target, unsigned overlap, int distance)
	180	: source(source)
	181	, target(target)
	182	, overlap(overlap)
	183	, distance(distance)
	184	{}
178	185	};
179	186
180	187	/** The contig IDs that have been removed from paths. */

187	194	typedef vector<ContigPath> Paths;
188	195
189	196	/** Return whether this vertex is a path or a contig. */
190		static bool isPath(const ContigNode& u)
	197	static bool
	198	isPath(const ContigNode& u)
191	199	{
192	200	return u.id() >= Vertex::s_offset;
193	201	}
194	202
195	203	/** Return a path, complemented if necessary. */
196		static ContigPath getPath(const Paths& paths, const ContigNode& u)
	204	static ContigPath
	205	getPath(const Paths& paths, const ContigNode& u)
197	206	{
198	207	if (isPath(u)) {
199	208	unsigned i = u.id() - Vertex::s_offset;

208	217	* @param[out] pathIDs the path IDs
209	218	* @return the paths
210	219	*/
211		static Paths readPaths(Graph& g,
212		const string& inPath, vector<string>& pathIDs)
	220	static Paths
	221	readPaths(Graph& g, const string& inPath, vector<string>& pathIDs)
213	222	{
214	223	typedef graph_traits<Graph>::vertex_descriptor V;
215	224

244	253
245	254	/** Index the first and last contig of each path to facilitate finding
246	255	* overlaps between paths. */
247		static SeedMap makeSeedMap(const Paths& paths)
	256	static SeedMap
	257	makeSeedMap(const Paths& paths)
248	258	{
249	259	SeedMap seedMap;
250		for (Paths::const_iterator it = paths.begin();
251		it != paths.end(); ++it) {
	260	for (Paths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
252	261	if (it->empty())
253	262	continue;
254	263	assert(!it->front().ambiguous());
255		seedMap.insert(make_pair(it->front(),
256		Vertex(it - paths.begin(), false)));
	264	seedMap.insert(make_pair(it->front(), Vertex(it - paths.begin(), false)));
257	265	assert(!it->back().ambiguous());
258		seedMap.insert(make_pair(it->back() ^ 1,
259		Vertex(it - paths.begin(), true)));
	266	seedMap.insert(make_pair(it->back() ^ 1, Vertex(it - paths.begin(), true)));
260	267	}
261	268	return seedMap;
262	269	}
263	270
264	271	/** Check whether path starts with the sequence [first, last). */
265		static bool startsWith(ContigPath path, bool rc,
266		ContigPath::const_iterator first,
267		ContigPath::const_iterator last)
	272	static bool
	273	startsWith(
	274	ContigPath path,
	275	bool rc,
	276	ContigPath::const_iterator first,
	277	ContigPath::const_iterator last)
268	278	{
269	279	if (rc)
270	280	reverseComplement(path.begin(), path.end());
271	281	assert(*first == path.front());
272	282	assert(first < last);
273		return unsigned(last - first) > path.size() ? false
274		: equal(first, last, path.begin());
	283	return unsigned(last - first) > path.size() ? false : equal(first, last, path.begin());
275	284	}
276	285
277	286	/** Check whether path starts with the sequence [first, last). */
278		static unsigned findOverlap(const Graph& g,
279		const Paths& paths,
280		ContigPath::const_iterator first,
281		ContigPath::const_iterator last,
282		const Vertex& v, int &distance)
	287	static unsigned
	288	findOverlap(
	289	const Graph& g,
	290	const Paths& paths,
	291	ContigPath::const_iterator first,
	292	ContigPath::const_iterator last,
	293	const Vertex& v,
	294	int& distance)
283	295	{
284	296	if (!startsWith(paths[v.id], v.sense, first, last))
285	297	return 0;

290	302	typedef vector<Overlap> Overlaps;
291	303
292	304	/** Find every path that overlaps with the specified path. */
293		static void findOverlaps(const Graph& g,
294		const Paths& paths, const SeedMap& seedMap,
295		const Vertex& v, Overlaps& overlaps)
	305	static void
	306	findOverlaps(
	307	const Graph& g,
	308	const Paths& paths,
	309	const SeedMap& seedMap,
	310	const Vertex& v,
	311	Overlaps& overlaps)
296	312	{
297	313	ContigPath rc;
298	314	if (v.sense) {

301	317	}
302	318	const ContigPath& path = v.sense ? rc : paths[v.id];
303	319
304		for (ContigPath::const_iterator it = path.begin();
305		it != path.end(); ++it) {
	320	for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it) {
306	321	if (it->ambiguous())
307	322	continue;
308	323
309		pair<SeedMap::const_iterator, SeedMap::const_iterator>
310		range = seedMap.equal_range(*it);
311		for (SeedMap::const_iterator seed = range.first;
312		seed != range.second; ++seed) {
	324	pair<SeedMap::const_iterator, SeedMap::const_iterator> range = seedMap.equal_range(*it);
	325	for (SeedMap::const_iterator seed = range.first; seed != range.second; ++seed) {
313	326	if (v == seed->second)
314	327	continue;
315	328	int distance = 0;
316		unsigned overlap = findOverlap(g, paths, it, path.end(),
317		seed->second, distance);
	329	unsigned overlap = findOverlap(g, paths, it, path.end(), seed->second, distance);
318	330	if (overlap > 0)
319		overlaps.push_back(Overlap(v, seed->second,
320		overlap, distance));
321
	331	overlaps.push_back(Overlap(v, seed->second, overlap, distance));
322	332	}
323	333	}
324	334	}
325	335
326	336	/** Find every pair of overlapping paths. */
327		static Overlaps findOverlaps(const Graph& g, const Paths& paths)
	337	static Overlaps
	338	findOverlaps(const Graph& g, const Paths& paths)
328	339	{
329	340	SeedMap seedMap = makeSeedMap(paths);
330	341
331	342	Overlaps overlaps;
332		for (Paths::const_iterator it = paths.begin();
333		it != paths.end(); ++it) {
	343	for (Paths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
334	344	unsigned i = it - paths.begin();
335	345	findOverlaps(g, paths, seedMap, Vertex(i, false), overlaps);
336	346	findOverlaps(g, paths, seedMap, Vertex(i, true), overlaps);

339	349	}
340	350
341	351	/** Record the trimmed contigs. */
342		static void recordTrimmedContigs(
343		ContigPath::const_iterator first,
344		ContigPath::const_iterator last)
	352	static void
	353	recordTrimmedContigs(ContigPath::const_iterator first, ContigPath::const_iterator last)
345	354	{
346	355	for (ContigPath::const_iterator it = first; it != last; ++it)
347	356	if (!it->ambiguous())

349	358	}
350	359
351	360	/** Remove ambiguous contigs from the ends of the path. */
352		static void removeAmbiguousContigs(ContigPath& path)
	361	static void
	362	removeAmbiguousContigs(ContigPath& path)
353	363	{
354	364	if (!path.empty() && path.back().ambiguous())
355	365	path.erase(path.end() - 1);

358	368	}
359	369
360	370	/** Remove the overlapping portion of the specified contig. */
361		static void removeContigs(ContigPath& path,
362		unsigned first, unsigned last)
	371	static void
	372	removeContigs(ContigPath& path, unsigned first, unsigned last)
363	373	{
364	374	assert(first <= path.size());
365	375	assert(last <= path.size());

376	386	}
377	387
378	388	/** Find the largest overlap for each contig and remove it. */
379		static void trimOverlaps(Paths& paths, const Overlaps& overlaps)
	389	static void
	390	trimOverlaps(Paths& paths, const Overlaps& overlaps)
380	391	{
381	392	vector<unsigned> removed[2];
382	393	removed[0].resize(paths.size());
383	394	removed[1].resize(paths.size());
384	395
385		for (Overlaps::const_iterator it = overlaps.begin();
386		it != overlaps.end(); ++it) {
	396	for (Overlaps::const_iterator it = overlaps.begin(); it != overlaps.end(); ++it) {
387	397	unsigned& a = removed[!it->source.sense][it->source.id];
388	398	unsigned& b = removed[it->target.sense][it->target.id];
389	399	a = max(a, it->overlap);

391	401	}
392	402
393	403	for (Paths::iterator it = paths.begin(); it != paths.end(); ++it)
394		removeContigs(*it, removed[0][it - paths.begin()],
395		it->size() - removed[1][it - paths.begin()]);
	404	removeContigs(
	405	*it, removed[0][it - paths.begin()], it->size() - removed[1][it - paths.begin()]);
396	406	}
397	407
398	408	/** Trim the ends of paths that overlap another path. */
399		static void trimOverlaps(const Graph& g, Paths& paths)
400		{
401		for (Overlaps overlaps = findOverlaps(g, paths);
402		!overlaps.empty();
403		overlaps = findOverlaps(g, paths)) {
	409	static void
	410	trimOverlaps(const Graph& g, Paths& paths)
	411	{
	412	for (Overlaps overlaps = findOverlaps(g, paths); !overlaps.empty();
	413	overlaps = findOverlaps(g, paths)) {
404	414	cerr << "Found " << overlaps.size() / 2 << " overlaps.\n";
405	415	trimOverlaps(paths, overlaps);
406	416	}
407	417	}
408	418
409		static inline
410		ContigProperties get(vertex_bundle_t, const Graph& g, ContigNode u)
411		{
412		return u.ambiguous()
413		? ContigProperties(u.length() + opt::k - 1, 0)
414		: g[u];
	419	static inline ContigProperties
	420	get(vertex_bundle_t, const Graph& g, ContigNode u)
	421	{
	422	return u.ambiguous() ? ContigProperties(u.length() + opt::k - 1, 0) : g[u];
415	423	}
416	424
417	425	/** Add the path overlap edges to the specified graph. */
418		static void addPathOverlapEdges(Graph& g,
419		const Paths& paths, const vector<string>& pathIDs,
420		const Overlaps& overlaps)
	426	static void
	427	addPathOverlapEdges(
	428	Graph& g,
	429	const Paths& paths,
	430	const vector<string>& pathIDs,
	431	const Overlaps& overlaps)
421	432	{
422	433	typedef graph_traits<Graph>::vertex_descriptor V;
423	434	const bool allowParallelEdge = opt::mode == opt::ASSEMBLE;
424	435
425	436	// Add the path vertices.
426	437	g_contigNames.unlock();
427		for (Paths::const_iterator it = paths.begin();
428		it != paths.end(); ++it) {
	438	for (Paths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
429	439	const ContigPath& path = *it;
430	440	const string& id = pathIDs[it - paths.begin()];
431	441	if (!path.empty()) {

436	446	g_contigNames.lock();
437	447
438	448	// Remove the single-end contigs that are in paths.
439		for (Paths::const_iterator it = paths.begin();
440		it != paths.end(); ++it)
441		remove_vertex_if(g, it->begin(), it->end(),
442		not1(std::mem_fun_ref(&ContigNode::ambiguous)));
	449	for (Paths::const_iterator it = paths.begin(); it != paths.end(); ++it)
	450	remove_vertex_if(
	451	g, it->begin(), it->end(), [](const ContigNode& c) { return !c.ambiguous(); });
443	452
444	453	// Add the path edges.
445		for (Overlaps::const_iterator it = overlaps.begin();
446		it != overlaps.end(); ++it) {
	454	for (Overlaps::const_iterator it = overlaps.begin(); it != overlaps.end(); ++it) {
447	455	V u = it->source.descriptor();
448	456	V v = it->target.descriptor();
449	457	if (allowParallelEdge \|\| !edge(u, v, g).second)
450	458	add_edge(u, v, it->distance, static_cast<DG&>(g));
451	459	else if (opt::verbose > 0)
452		cerr << "ambiguous overlap: " << get(vertex_name, g, u)
453		<< " -> " << get(vertex_name, g, v) << '\n';
	460	cerr << "ambiguous overlap: " << get(vertex_name, g, u) << " -> "
	461	<< get(vertex_name, g, v) << '\n';
454	462	}
455	463	}
456	464

461	469	typedef map<edge_descriptor, unsigned> OverlapMap;
462	470
463	471	/** Return the number of contigs by which the two paths overlap. */
464		static unsigned getOverlap(const OverlapMap& pmap,
465		graph_traits<Graph>::vertex_descriptor u,
466		graph_traits<Graph>::vertex_descriptor v)
	472	static unsigned
	473	getOverlap(
	474	const OverlapMap& pmap,
	475	graph_traits<Graph>::vertex_descriptor u,
	476	graph_traits<Graph>::vertex_descriptor v)
467	477	{
468	478	if (isPath(u) && isPath(v)) {
469	479	// Both vertices are paths.
470		OverlapMap::const_iterator it = pmap.find(
471		edge_descriptor(u, v));
	480	OverlapMap::const_iterator it = pmap.find(edge_descriptor(u, v));
472	481	return it == pmap.end() ? 0 : it->second;
473	482	} else {
474	483	// One of the two vertices is a contig.

477	486	}
478	487
479	488	/** Merge a sequence of overlapping paths. */
480		static ContigPath mergePaths(const Paths& paths,
481		const OverlapMap& overlaps, const ContigPath& merge)
	489	static ContigPath
	490	mergePaths(const Paths& paths, const OverlapMap& overlaps, const ContigPath& merge)
482	491	{
483	492	assert(!merge.empty());
484	493	ContigNode u = merge.front();
485	494	ContigPath path(getPath(paths, u));
486		for (ContigPath::const_iterator it = merge.begin() + 1;
487		it != merge.end(); ++it) {
	495	for (ContigPath::const_iterator it = merge.begin() + 1; it != merge.end(); ++it) {
488	496	ContigNode v = *it;
489	497	ContigPath vpath(getPath(paths, v));
490	498	unsigned overlap = getOverlap(overlaps, u, v);
491	499	assert(path.size() > overlap);
492	500	assert(vpath.size() > overlap);
493		assert(equal(path.end() - overlap, path.end(),
494		vpath.begin()));
	501	assert(equal(path.end() - overlap, path.end(), vpath.begin()));
495	502	path.insert(path.end(), vpath.begin() + overlap, vpath.end());
496	503	u = v;
497	504	}

499	506	}
500	507
501	508	/** Return true if the edge e is a path overlap. */
502		struct IsPathOverlap : unary_function<edge_descriptor, bool> {
503		IsPathOverlap(const Graph& g, const OverlapMap& pmap,
504		const IsPositive<Graph>& pred)
505		: m_g(g), m_pmap(pmap), m_isPositive(pred) { }
	509	struct IsPathOverlap : unary_function<edge_descriptor, bool>
	510	{
	511	IsPathOverlap(const Graph& g, const OverlapMap& pmap, const IsPositive<Graph>& pred)
	512	: m_g(g)
	513	, m_pmap(pmap)
	514	, m_isPositive(pred)
	515	{}
506	516	bool operator()(edge_descriptor e) const
507	517	{
508	518	bool stranded = true;
509	519	if (opt::ss)
510	520	stranded = m_isPositive(e);
511		return stranded &&
512		getOverlap(m_pmap, source(e, m_g), target(e, m_g));
513		}
	521	return stranded && getOverlap(m_pmap, source(e, m_g), target(e, m_g));
	522	}
	523
514	524	private:
515	525	const Graph& m_g;
516	526	const OverlapMap& m_pmap;

518	528	};
519	529
520	530	/** Assemble overlapping paths. */
521		static void assembleOverlappingPaths(Graph& g,
522		Paths& paths, vector<string>& pathIDs)
	531	static void
	532	assembleOverlappingPaths(Graph& g, Paths& paths, vector<string>& pathIDs)
523	533	{
524	534	if (paths.empty())
525	535	return;

530	540
531	541	// Create a property map of path overlaps.
532	542	OverlapMap overlapMap;
533		for (Overlaps::const_iterator it = overlaps.begin();
534		it != overlaps.end(); ++it)
	543	for (Overlaps::const_iterator it = overlaps.begin(); it != overlaps.end(); ++it)
535	544	overlapMap.insert(OverlapMap::value_type(
536		OverlapMap::key_type(
537		it->source.descriptor(),
538		it->target.descriptor()),
539		it->overlap));
	545	OverlapMap::key_type(it->source.descriptor(), it->target.descriptor()), it->overlap));
540	546
541	547	// Assemble unambiguously overlapping paths.
542	548	Paths merges;
543		assemble_if(g, back_inserter(merges),
544		IsPathOverlap(g, overlapMap, IsPositive<Graph>(g)));
	549	assemble_if(g, back_inserter(merges), IsPathOverlap(g, overlapMap, IsPositive<Graph>(g)));
545	550
546	551	// Merge overlapping paths.
547	552	g_contigNames.unlock();
548	553	assert(!pathIDs.empty());
549	554	setNextContigName(pathIDs.back());
550		for (Paths::const_iterator it = merges.begin();
551		it != merges.end(); ++it) {
	555	for (Paths::const_iterator it = merges.begin(); it != merges.end(); ++it) {
552	556	string name = createContigName();
553	557	if (opt::verbose > 0)
554	558	cerr << name << '\t' << *it << '\n';

558	562	paths.push_back(mergePaths(paths, overlapMap, *it));
559	563
560	564	// Remove the merged paths.
561		for (ContigPath::const_iterator it2 = it->begin();
562		it2 != it->end(); ++it2) {
	565	for (ContigPath::const_iterator it2 = it->begin(); it2 != it->end(); ++it2) {
563	566	if (isPath(*it2))
564	567	paths[it2->id() - Vertex::s_offset].clear();
565	568	}

567	570	g_contigNames.lock();
568	571	}
569	572
570		int main(int argc, char** argv)
	573	int
	574	main(int argc, char** argv)
571	575	{
572	576	string commandLine;
573	577	{
574	578	ostringstream ss;
575	579	char** last = argv + argc - 1;
576		copy(argv, last, ostream_iterator<const char *>(ss, " "));
	580	copy(argv, last, ostream_iterator<const char*>(ss, " "));
577	581	ss << *last;
578	582	commandLine = ss.str();
579	583	}

582	586	opt::metaVars.resize(3);
583	587
584	588	bool die = false;
585		for (int c; (c = getopt_long(argc, argv,
586		shortopts, longopts, NULL)) != -1;) {
	589	for (int c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) {
587	590	istringstream arg(optarg != NULL ? optarg : "");
588	591	switch (c) {
589		case '?': die = true; break;
590		case 'g': arg >> opt::graphPath; break;
591		case 'k': arg >> opt::k; break;
592		case 'r': arg >> opt::repeatContigs; break;
593		case 'v': opt::verbose++; break;
594		case OPT_HELP:
595		cout << USAGE_MESSAGE;
596		exit(EXIT_SUCCESS);
597		case OPT_VERSION:
598		cout << VERSION_MESSAGE;
599		exit(EXIT_SUCCESS);
600		case OPT_DB:
601		arg >> opt::db; break;
602		case OPT_LIBRARY:
603		arg >> opt::metaVars[0]; break;
604		case OPT_STRAIN:
605		arg >> opt::metaVars[1]; break;
606		case OPT_SPECIES:
607		arg >> opt::metaVars[2]; break;
	592	case '?':
	593	die = true;
	594	break;
	595	case 'g':
	596	arg >> opt::graphPath;
	597	break;
	598	case 'k':
	599	arg >> opt::k;
	600	break;
	601	case 'r':
	602	arg >> opt::repeatContigs;
	603	break;
	604	case 'v':
	605	opt::verbose++;
	606	break;
	607	case OPT_HELP:
	608	cout << USAGE_MESSAGE;
	609	exit(EXIT_SUCCESS);
	610	case OPT_VERSION:
	611	cout << VERSION_MESSAGE;
	612	exit(EXIT_SUCCESS);
	613	case OPT_DB:
	614	arg >> opt::db;
	615	break;
	616	case OPT_LIBRARY:
	617	arg >> opt::metaVars[0];
	618	break;
	619	case OPT_STRAIN:
	620	arg >> opt::metaVars[1];
	621	break;
	622	case OPT_SPECIES:
	623	arg >> opt::metaVars[2];
	624	break;
608	625	}
609	626	if (optarg != NULL && !arg.eof()) {
610		cerr << PROGRAM ": invalid option: `-"
611		<< (char)c << optarg << "'\n";
	627	cerr << PROGRAM ": invalid option: `-" << (char)c << optarg << "'\n";
612	628	exit(EXIT_FAILURE);
613	629	}
614	630	}

627	643	}
628	644
629	645	if (die) {
630		cerr << "Try `" << PROGRAM
631		<< " --help' for more information.\n";
	646	cerr << "Try `" << PROGRAM << " --help' for more information.\n";
632	647	exit(EXIT_FAILURE);
633	648	}
634	649
635		const char *adjPath = argv[optind++];
	650	const char* adjPath = argv[optind++];
636	651	if (opt::verbose > 0)
637	652	cerr << "Reading `" << adjPath << "'..." << endl;
638	653	ifstream fin(adjPath);

646	661	Paths paths = readPaths(g, pathsFile, pathIDs);
647	662
648	663	switch (opt::mode) {
649		case opt::OVERLAP:
	664	case opt::OVERLAP:
650	665	// Find overlapping paths, do not assemble.
651		addPathOverlapEdges(g, paths, pathIDs,
652		findOverlaps(g, paths));
	666	addPathOverlapEdges(g, paths, pathIDs, findOverlaps(g, paths));
653	667	paths.clear();
654	668	if (opt::graphPath.empty())
655	669	opt::graphPath = "-";
656	670	break;
657	671
658		case opt::ASSEMBLE:
	672	case opt::ASSEMBLE:
659	673	// Assemble overlapping paths.
660	674	assembleOverlappingPaths(g, paths, pathIDs);
661	675	break;
662	676
663		case opt::TRIM:
	677	case opt::TRIM:
664	678	// Trim overlapping paths.
665	679	trimOverlaps(g, paths);
666	680	// Remove paths consisting of a single contig.
667		for_each_if(paths.begin(), paths.end(),
668		mem_fun_ref(&ContigPath::clear),
669		compose1(
670		bind2nd(equal_to<ContigPath::size_type>(), 1),
671		mem_fun_ref(&ContigPath::size)));
	681	for_each_if(
	682	paths.begin(),
	683	paths.end(),
	684	[](ContigPath& c) { return c.clear(); },
	685	[](const ContigPath& c) { return c.size() == 1; });
672	686	// Add the paths to the graph.
673	687	addPathOverlapEdges(g, paths, pathIDs, Overlaps());
674	688	break;
675	689	}
676	690
677	691	// Output the paths.
678		for (Paths::const_iterator it = paths.begin();
679		it != paths.end(); ++it) {
	692	for (Paths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
680	693	if (it->empty())
681	694	continue;
682	695	assert(it->size() != 1);

687	700	// Output the graph.
688	701	if (!opt::graphPath.empty()) {
689	702	ofstream fout;
690		ostream& out = opt::graphPath == "-" ? cout
691		: (fout.open(opt::graphPath.c_str()), fout);
	703	ostream& out = opt::graphPath == "-" ? cout : (fout.open(opt::graphPath.c_str()), fout);
692	704	assert_good(out, opt::graphPath);
693	705	write_graph(out, g, PROGRAM, commandLine);
694	706	assert_good(out, opt::graphPath);

698	710	if (!opt::repeatContigs.empty()) {
699	711	sort(s_trimmedContigs.begin(), s_trimmedContigs.end());
700	712	s_trimmedContigs.erase(
701		unique(s_trimmedContigs.begin(),
702		s_trimmedContigs.end()), s_trimmedContigs.end());
	713	unique(s_trimmedContigs.begin(), s_trimmedContigs.end()), s_trimmedContigs.end());
703	714	ofstream out(opt::repeatContigs.c_str());
704	715	assert_good(out, opt::repeatContigs);
705		for (vector<ContigID>::const_iterator it
706		= s_trimmedContigs.begin();
707		it != s_trimmedContigs.end(); ++it)
	716	for (vector<ContigID>::const_iterator it = s_trimmedContigs.begin();
	717	it != s_trimmedContigs.end();
	718	++it)
708	719	out << get(g_contigNames, *it) << '\n';
709	720	assert_good(out, opt::repeatContigs);
710	721	}
711	722
712	723	if (!opt::db.empty()) {
713		init(db,
714		opt::db,
715		opt::verbose,
716		PROGRAM,
717		opt::getCommand(argc, argv),
718		opt::metaVars);
	724	init(db, opt::db, opt::verbose, PROGRAM, opt::getCommand(argc, argv), opt::metaVars);
719	725	addToDb(db, "SS", opt::ss);
720	726	addToDb(db, "K", opt::k);
721	727	}

+253

-229

PopBubbles/PopBubbles.cpp less more

2	2	* Written by Shaun Jackman <sjackman@bcgsc.ca>.
3	3	*/
4	4
5		#include "config.h"
	5	#include "Graph/PopBubbles.h"
6	6	#include "Common/Options.h"
7	7	#include "ConstString.h"
8	8	#include "ContigPath.h"
9	9	#include "ContigProperties.h"
10	10	#include "FastaReader.h"
11		#include "IOUtil.h"
12		#include "Sequence.h"
13		#include "Uncompress.h"
14		#include "alignGlobal.h"
15	11	#include "Graph/ContigGraph.h"
16	12	#include "Graph/ContigGraphAlgorithms.h"
17	13	#include "Graph/DepthFirstSearch.h"
18	14	#include "Graph/DirectedGraph.h"
19	15	#include "Graph/GraphIO.h"
20	16	#include "Graph/GraphUtil.h"
21		#include "Graph/PopBubbles.h"
	17	#include "IOUtil.h"
	18	#include "Sequence.h"
	19	#include "Uncompress.h"
	20	#include "alignGlobal.h"
	21	#include "config.h"
	22	#include <algorithm>
22	23	#include <boost/lambda/bind.hpp>
23	24	#include <boost/lambda/lambda.hpp>
24		#include <algorithm>
25	25	#include <climits> // for UINT_MAX
26	26	#include <fstream>
27	27	#include <functional>
28	28	#include <getopt.h>
29		#include <map>
30	29	#include <iostream>
31	30	#include <iterator>
	31	#include <map>
32	32	#include <set>
33	33	#include <sstream>
34	34	#include <string>
35	35	#include <utility>
36	36	#include <vector>
37	37	#if _OPENMP
38		# include <omp.h>
	38	#include <omp.h>
39	39	#endif
40	40
41	41	using namespace std;

45	45	#define PROGRAM "PopBubbles"
46	46
47	47	static const char VERSION_MESSAGE[] =
48		PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
49		"Written by Shaun Jackman.\n"
50		"\n"
51		"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
	48	PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
	49	"Written by Shaun Jackman.\n"
	50	"\n"
	51	"Copyright 2014 Canada's Michael Smith Genome Sciences Centre\n";
52	52
53	53	static const char USAGE_MESSAGE[] =
54		"Usage: " PROGRAM " -k<kmer> [OPTION]... FASTA ADJ\n"
55		"Identify and pop simple bubbles.\n"
56		"\n"
57		" Arguments:\n"
58		"\n"
59		" FASTA contigs in FASTA format\n"
60		" ADJ contig adjacency graph\n"
61		"\n"
62		" Options:\n"
63		"\n"
64		" -k, --kmer=N k-mer size\n"
65		" -a, --branches=N maximum number of branches, default: 2\n"
66		" -b, --bubble-length=N pop bubbles shorter than N bp\n"
67		" default is 10000\n"
68		" -p, --identity=REAL minimum identity, default: 0.9\n"
69		" -c, --coverage=REAL remove contigs with mean k-mer coverage\n"
70		" less than this threshold [0]\n"
71		" --scaffold scaffold over bubbles that have\n"
72		" insufficient identity\n"
73		" --no-scaffold disable scaffolding [default]\n"
74		" --SS expect contigs to be oriented correctly\n"
75		" --no-SS no assumption about contig orientation [default]\n"
76		" -g, --graph=FILE write the contig adjacency graph to FILE\n"
77		" --adj output the graph in ADJ format [default]\n"
78		" --asqg output the graph in ASQG format\n"
79		" --dot output the graph in GraphViz format\n"
80		" --gfa output the graph in GFA1 format\n"
81		" --gfa1 output the graph in GFA1 format\n"
82		" --gfa2 output the graph in GFA2 format\n"
83		" --gv output the graph in GraphViz format\n"
84		" --sam output the graph in SAM format\n"
85		" --bubble-graph output a graph of the bubbles\n"
86		" -j, --threads=N use N parallel threads [1]\n"
87		" -v, --verbose display verbose output\n"
88		" --help display this help and exit\n"
89		" --version output version information and exit\n"
90		"\n"
91		"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
	54	"Usage: " PROGRAM " -k<kmer> [OPTION]... FASTA ADJ\n"
	55	"Identify and pop simple bubbles.\n"
	56	"\n"
	57	" Arguments:\n"
	58	"\n"
	59	" FASTA contigs in FASTA format\n"
	60	" ADJ contig adjacency graph\n"
	61	"\n"
	62	" Options:\n"
	63	"\n"
	64	" -k, --kmer=N k-mer size\n"
	65	" -a, --branches=N maximum number of branches, default: 2\n"
	66	" -b, --bubble-length=N pop bubbles shorter than N bp\n"
	67	" default is 10000\n"
	68	" -p, --identity=REAL minimum identity, default: 0.9\n"
	69	" -c, --coverage=REAL remove contigs with mean k-mer coverage\n"
	70	" less than this threshold [0]\n"
	71	" --scaffold scaffold over bubbles that have\n"
	72	" insufficient identity\n"
	73	" --no-scaffold disable scaffolding [default]\n"
	74	" --SS expect contigs to be oriented correctly\n"
	75	" --no-SS no assumption about contig orientation [default]\n"
	76	" -g, --graph=FILE write the contig adjacency graph to FILE\n"
	77	" --adj output the graph in ADJ format [default]\n"
	78	" --asqg output the graph in ASQG format\n"
	79	" --dot output the graph in GraphViz format\n"
	80	" --gfa output the graph in GFA1 format\n"
	81	" --gfa1 output the graph in GFA1 format\n"
	82	" --gfa2 output the graph in GFA2 format\n"
	83	" --gv output the graph in GraphViz format\n"
	84	" --sam output the graph in SAM format\n"
	85	" --bubble-graph output a graph of the bubbles\n"
	86	" -j, --threads=N use N parallel threads [1]\n"
	87	" -v, --verbose display verbose output\n"
	88	" --help display this help and exit\n"
	89	" --version output version information and exit\n"
	90	"\n"
	91	"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
92	92
93	93	namespace opt {
94		unsigned k; // used by ContigProperties
95
96		/** Maximum number of branches. */
97		static unsigned maxBranches = 2;
98
99		/** Pop bubbles shorter than this threshold. */
100		static unsigned maxLength = 10000;
101
102		/** Minimum identity. */
103		static float identity = 0.9;
104
105		/** Minimum mean k-mer coverage. */
106		static float minCoverage;
107
108		/** Scaffold over bubbles that have insufficient identity. */
109		static int scaffold;
110
111		/** Write the contig adjacency graph to this file. */
112		static string graphPath;
113
114		/** Output a graph of the bubbles. */
115		static int bubbleGraph;
116
117		int format; // used by ContigProperties
118
119		/** Run a strand-specific RNA-Seq assembly. */
120		static int ss;
121
122		/** Number of threads. */
123		static int threads = 1;
	94	unsigned k; // used by ContigProperties
	95
	96	/** Maximum number of branches. */
	97	static unsigned maxBranches = 2;
	98
	99	/** Pop bubbles shorter than this threshold. */
	100	static unsigned maxLength = 10000;
	101
	102	/** Minimum identity. */
	103	static float identity = 0.9;
	104
	105	/** Minimum mean k-mer coverage. */
	106	static float minCoverage;
	107
	108	/** Scaffold over bubbles that have insufficient identity. */
	109	static int scaffold;
	110
	111	/** Write the contig adjacency graph to this file. */
	112	static string graphPath;
	113
	114	/** Output a graph of the bubbles. */
	115	static int bubbleGraph;
	116
	117	int format; // used by ContigProperties
	118
	119	/** Run a strand-specific RNA-Seq assembly. */
	120	static int ss;
	121
	122	/** Number of threads. */
	123	static int threads = 1;
124	124	}
125	125
126	126	static const char shortopts[] = "a:b:c:g:j:k:p:v";
127	127
128		enum { OPT_HELP = 1, OPT_VERSION };
129
130		static const struct option longopts[] = {
131		{ "branches", required_argument, NULL, 'a' },
132		{ "bubble-length", required_argument, NULL, 'b' },
133		{ "coverage", required_argument, NULL, 'c' },
134		{ "bubble-graph", no_argument, &opt::bubbleGraph, 1, },
135		{ "graph", required_argument, NULL, 'g' },
136		{ "adj", no_argument, &opt::format, ADJ },
137		{ "asqg", no_argument, &opt::format, ASQG },
138		{ "dot", no_argument, &opt::format, DOT },
139		{ "gfa", no_argument, &opt::format, GFA1 },
140		{ "gfa1", no_argument, &opt::format, GFA1 },
141		{ "gfa2", no_argument, &opt::format, GFA2 },
142		{ "gv", no_argument, &opt::format, DOT },
143		{ "sam", no_argument, &opt::format, SAM },
144		{ "kmer", required_argument, NULL, 'k' },
145		{ "identity", required_argument, NULL, 'p' },
146		{ "scaffold", no_argument, &opt::scaffold, 1},
147		{ "no-scaffold", no_argument, &opt::scaffold, 0},
148		{ "SS", no_argument, &opt::ss, 1 },
149		{ "no-SS", no_argument, &opt::ss, 0 },
150		{ "threads", required_argument, NULL, 'j' },
151		{ "verbose", no_argument, NULL, 'v' },
152		{ "help", no_argument, NULL, OPT_HELP },
153		{ "version", no_argument, NULL, OPT_VERSION },
154		{ NULL, 0, NULL, 0 }
	128	enum
	129	{
	130	OPT_HELP = 1,
	131	OPT_VERSION
155	132	};
	133
	134	static const struct option longopts[] = { { "branches", required_argument, NULL, 'a' },
	135	{ "bubble-length", required_argument, NULL, 'b' },
	136	{ "coverage", required_argument, NULL, 'c' },
	137	{
	138	"bubble-graph",
	139	no_argument,
	140	&opt::bubbleGraph,
	141	1,
	142	},
	143	{ "graph", required_argument, NULL, 'g' },
	144	{ "adj", no_argument, &opt::format, ADJ },
	145	{ "asqg", no_argument, &opt::format, ASQG },
	146	{ "dot", no_argument, &opt::format, DOT },
	147	{ "gfa", no_argument, &opt::format, GFA1 },
	148	{ "gfa1", no_argument, &opt::format, GFA1 },
	149	{ "gfa2", no_argument, &opt::format, GFA2 },
	150	{ "gv", no_argument, &opt::format, DOT },
	151	{ "sam", no_argument, &opt::format, SAM },
	152	{ "kmer", required_argument, NULL, 'k' },
	153	{ "identity", required_argument, NULL, 'p' },
	154	{ "scaffold", no_argument, &opt::scaffold, 1 },
	155	{ "no-scaffold", no_argument, &opt::scaffold, 0 },
	156	{ "SS", no_argument, &opt::ss, 1 },
	157	{ "no-SS", no_argument, &opt::ss, 0 },
	158	{ "threads", required_argument, NULL, 'j' },
	159	{ "verbose", no_argument, NULL, 'v' },
	160	{ "help", no_argument, NULL, OPT_HELP },
	161	{ "version", no_argument, NULL, OPT_VERSION },
	162	{ NULL, 0, NULL, 0 } };
156	163
157	164	/** Popped branches. */
158	165	static vector<ContigID> g_popped;
159	166
160	167	/** Contig adjacency graph. */
161		typedef ContigGraph<DirectedGraph<ContigProperties, Distance> > Graph;
	168	typedef ContigGraph<DirectedGraph<ContigProperties, Distance>> Graph;
162	169	typedef Graph::vertex_descriptor vertex_descriptor;
163	170	typedef Graph::adjacency_iterator adjacency_iterator;
164	171
165	172	/** Return the distance from vertex u to v. */
166		static int getDistance(const Graph& g,
167		vertex_descriptor u, vertex_descriptor v)
	173	static int
	174	getDistance(const Graph& g, vertex_descriptor u, vertex_descriptor v)
168	175	{
169	176	typedef graph_traits<Graph>::edge_descriptor edge_descriptor;
170	177	pair<edge_descriptor, bool> e = edge(u, v, g);

172	179	return g[e.first].distance;
173	180	}
174	181
175		struct CompareCoverage {
	182	struct CompareCoverage
	183	{
176	184	const Graph& g;
177		CompareCoverage(const Graph& g) : g(g) { }
	185	CompareCoverage(const Graph& g)
	186	: g(g)
	187	{}
178	188	bool operator()(vertex_descriptor u, vertex_descriptor v)
179	189	{
180	190	return g[u].coverage > g[v].coverage;

182	192	};
183	193
184	194	/** Pop the bubble between vertices v and tail. */
185		static void popBubble(Graph& g,
186		vertex_descriptor v, vertex_descriptor tail)
	195	static void
	196	popBubble(Graph& g, vertex_descriptor v, vertex_descriptor tail)
187	197	{
188	198	unsigned nbranches = g.out_degree(v);
189	199	assert(nbranches > 1);
190	200	assert(nbranches == g.in_degree(tail));
191	201	vector<vertex_descriptor> sorted(nbranches);
192		pair<adjacency_iterator, adjacency_iterator>
193		adj = g.adjacent_vertices(v);
	202	pair<adjacency_iterator, adjacency_iterator> adj = g.adjacent_vertices(v);
194	203	copy(adj.first, adj.second, sorted.begin());
195	204	sort(sorted.begin(), sorted.end(), CompareCoverage(g));
196	205	if (opt::bubbleGraph)
197	206	#pragma omp critical(cout)
198	207	{
199	208	cout << '"' << get(vertex_name, g, v) << "\" -> {";
200		for (vector<vertex_descriptor>::const_iterator
201		it = sorted.begin(); it != sorted.end(); ++it)
	209	for (vector<vertex_descriptor>::const_iterator it = sorted.begin(); it != sorted.end();
	210	++it)
202	211	cout << " \"" << get(vertex_name, g, *it) << '"';
203	212	cout << " } -> \"" << get(vertex_name, g, tail) << "\"\n";
204	213	}
205	214	#pragma omp critical(g_popped)
206		transform(sorted.begin() + 1, sorted.end(),
207		back_inserter(g_popped),
208		mem_fun_ref(&ContigNode::contigIndex));
209		}
210
211		static struct {
	215	transform(sorted.begin() + 1, sorted.end(), back_inserter(g_popped), [](const ContigNode& c) {
	216	return c.contigIndex();
	217	});
	218	}
	219
	220	static struct
	221	{
212	222	unsigned bubbles;
213	223	unsigned popped;
214	224	unsigned scaffold;

223	233	static Contigs g_contigs;
224	234
225	235	/** Return the sequence of vertex u. */
226		static string getSequence(const Graph* g, vertex_descriptor u)
	236	static string
	237	getSequence(const Graph* g, vertex_descriptor u)
227	238	{
228	239	size_t i = get(vertex_contig_index, *g, u);
229	240	assert(i < g_contigs.size());

232	243	}
233	244
234	245	/** Return the length of vertex v. */
235		static unsigned getLength(const Graph* g, vertex_descriptor v)
	246	static unsigned
	247	getLength(const Graph* g, vertex_descriptor v)
236	248	{
237	249	return (*g)[v].length;
238	250	}

242	254	* @param v the vertex to the right of the bubble
243	255	* @return the identity of the global alignment
244	256	*/
245		template <typename It>
246		static float getAlignmentIdentity(const Graph& g,
247		vertex_descriptor t, vertex_descriptor v,
248		It first, It last)
	257	template<typename It>
	258	static float
	259	getAlignmentIdentity(const Graph& g, vertex_descriptor t, vertex_descriptor v, It first, It last)
249	260	{
250	261	unsigned nbranches = distance(first, last);
251	262	vector<int> inDists(nbranches);
252		transform(first, last, inDists.begin(),
253		boost::lambda::bind(getDistance, boost::cref(g), t, _1));
	263	transform(
	264	first, last, inDists.begin(), boost::lambda::bind(getDistance, boost::cref(g), t, _1));
254	265	vector<int> outDists(nbranches);
255		transform(first, last, outDists.begin(),
256		boost::lambda::bind(getDistance, boost::cref(g), _1, v));
	266	transform(
	267	first, last, outDists.begin(), boost::lambda::bind(getDistance, boost::cref(g), _1, v));
257	268	vector<int> insertLens(nbranches);
258		transform(first, last, insertLens.begin(),
259		boost::lambda::bind(getDistance, boost::cref(g), t, _1)
260		+ boost::lambda::bind(getLength, &g, _1)
261		+ boost::lambda::bind(getDistance, boost::cref(g), _1, v));
262
263		int max_in_overlap = -(*min_element(inDists.begin(),
264		inDists.end()));
	269	transform(
	270	first,
	271	last,
	272	insertLens.begin(),
	273	boost::lambda::bind(getDistance, boost::cref(g), t, _1) +
	274	boost::lambda::bind(getLength, &g, _1) +
	275	boost::lambda::bind(getDistance, boost::cref(g), _1, v));
	276
	277	int max_in_overlap = -(*min_element(inDists.begin(), inDists.end()));
265	278	assert(max_in_overlap >= 0);
266		int max_out_overlap = -(*min_element(outDists.begin(),
267		outDists.end()));
	279	int max_out_overlap = -(*min_element(outDists.begin(), outDists.end()));
268	280	assert(max_out_overlap >= 0);
269		int min_insert_len = *min_element(insertLens.begin(),
270		insertLens.end());
271		int max_insert_len = *max_element(insertLens.begin(),
272		insertLens.end());
273
274		float max_identity =
275		(float)(min_insert_len + max_in_overlap + max_out_overlap) /
276		(max_insert_len + max_in_overlap + max_out_overlap);
	281	int min_insert_len = *min_element(insertLens.begin(), insertLens.end());
	282	int max_insert_len = *max_element(insertLens.begin(), insertLens.end());
	283
	284	float max_identity = (float)(min_insert_len + max_in_overlap + max_out_overlap) /
	285	(max_insert_len + max_in_overlap + max_out_overlap);
277	286	if (min_insert_len <= 0 \|\| max_identity < opt::identity)
278	287	return max_identity;
279	288

290	299	unsigned matches, consensusSize;
291	300	tie(matches, consensusSize) = align(seqs);
292	301	return (float)(matches + max_in_overlap + max_out_overlap) /
293		(consensusSize + max_in_overlap + max_out_overlap);
	302	(consensusSize + max_in_overlap + max_out_overlap);
294	303	}
295	304
296	305	/** Pop the specified bubble if it is a simple bubble.
297	306	* @return whether the bubble is popped
298	307	*/
299		static bool popSimpleBubble(Graph* pg, vertex_descriptor v)
	308	static bool
	309	popSimpleBubble(Graph* pg, vertex_descriptor v)
300	310	{
301	311	Graph& g = *pg;
302	312	unsigned nbranches = g.out_degree(v);

309	319	}
310	320	vertex_descriptor tail = *g.adjacent_vertices(v1).first;
311	321	if (v == get(vertex_complement, g, tail) // Palindrome
312		\|\| g.in_degree(tail) != nbranches) {
	322	\|\| g.in_degree(tail) != nbranches) {
313	323	#pragma omp atomic
314	324	g_count.notSimple++;
315	325	return false;
316	326	}
317	327
318	328	// Check that every branch is simple and ends at the same node.
319		pair<adjacency_iterator, adjacency_iterator>
320		adj = g.adjacent_vertices(v);
	329	pair<adjacency_iterator, adjacency_iterator> adj = g.adjacent_vertices(v);
321	330	for (adjacency_iterator it = adj.first; it != adj.second; ++it) {
322	331	if (g.out_degree(it) != 1 \|\| g.in_degree(it) != 1) {
323	332	#pragma omp atomic

336	345	#pragma omp critical(cerr)
337	346	{
338	347	cerr << "\n* " << get(vertex_name, g, v) << " ->";
339		for (adjacency_iterator it = adj.first;
340		it != adj.second; ++it)
	348	for (adjacency_iterator it = adj.first; it != adj.second; ++it)
341	349	cerr << ' ' << get(vertex_name, g, *it);
342	350	cerr << " -> " << get(vertex_name, g, tail) << '\n';
343	351	}

353	361	}
354	362
355	363	vector<unsigned> lengths(nbranches);
356		transform(adj.first, adj.second, lengths.begin(),
357		bind1st(ptr_fun(getLength), &g));
	364	transform(adj.first, adj.second, lengths.begin(), [&g](const ContigNode& c) {
	365	return getLength(&g, c);
	366	});
358	367	unsigned minLength = *min_element(lengths.begin(), lengths.end());
359	368	unsigned maxLength = *max_element(lengths.begin(), lengths.end());
360	369	if (maxLength >= opt::maxLength) {

363	372	g_count.tooLong++;
364	373	if (opt::verbose > 1)
365	374	#pragma omp critical(cerr)
366		cerr << minLength << '\t' << maxLength
367		<< "\t0\t(too long)\n";
	375	cerr << minLength << '\t' << maxLength << "\t0\t(too long)\n";
368	376	return false;
369	377	}
370	378
371		float identity = opt::identity == 0 ? 0
372		: getAlignmentIdentity(g, v, tail, adj.first, adj.second);
	379	float identity =
	380	opt::identity == 0 ? 0 : getAlignmentIdentity(g, v, tail, adj.first, adj.second);
373	381	bool dissimilar = identity < opt::identity;
374	382	if (opt::verbose > 1)
375	383	#pragma omp critical(cerr)
376	384	cerr << minLength << '\t' << maxLength << '\t' << identity
377		<< (dissimilar ? "\t(dissimilar)" : "") << '\n';
	385	<< (dissimilar ? "\t(dissimilar)" : "") << '\n';
378	386	if (dissimilar) {
379	387	// Insufficient identity.
380	388	#pragma omp atomic

389	397	}
390	398
391	399	/** Add distances to a path. */
392		static ContigPath addDistance(const Graph& g, const ContigPath& path)
	400	static ContigPath
	401	addDistance(const Graph& g, const ContigPath& path)
393	402	{
394	403	ContigPath out;
395	404	out.reserve(path.size());
396	405	ContigNode u = path.front();
397	406	out.push_back(u);
398		for (ContigPath::const_iterator it = path.begin() + 1;
399		it != path.end(); ++it) {
	407	for (ContigPath::const_iterator it = path.begin() + 1; it != path.end(); ++it) {
400	408	ContigNode v = *it;
401	409	int distance = getDistance(g, u, v);
402	410	if (distance >= 0) {

412	420	}
413	421
414	422	/** Return the length of the longest path through the bubble. */
415		static int longestPath(const Graph& g, const Bubble& topo)
	423	static int
	424	longestPath(const Graph& g, const Bubble& topo)
416	425	{
417	426	typedef graph_traits<Graph>::edge_descriptor E;
418	427	typedef graph_traits<Graph>::out_edge_iterator Eit;

421	430	EdgeWeightMap<Graph> weight(g);
422	431	map<ContigNode, int> distance;
423	432	distance[topo.front()] = 0;
424		for (Bubble::const_iterator it = topo.begin();
425		it != topo.end(); ++it) {
	433	for (Bubble::const_iterator it = topo.begin(); it != topo.end(); ++it) {
426	434	V u = *it;
427	435	Eit eit, elast;
428	436	for (tie(eit, elast) = out_edges(u, g); eit != elast; ++eit) {

439	447	* Add an edge (u,w) with the distance property set to the length of
440	448	* the largest branch of the bubble.
441	449	*/
442		static void scaffoldBubble(Graph& g, const Bubble& bubble)
	450	static void
	451	scaffoldBubble(Graph& g, const Bubble& bubble)
443	452	{
444	453	typedef graph_traits<Graph>::vertex_descriptor V;
445	454	assert(opt::scaffold);

455	464	assert(bubble.size() > 2);
456	465	size_t n = bubble.size() - 2;
457	466	g_popped.reserve(g_popped.size() + n);
458		for (Bubble::const_iterator it = bubble.begin() + 1;
459		it != bubble.end() - 1; ++it)
	467	for (Bubble::const_iterator it = bubble.begin() + 1; it != bubble.end() - 1; ++it)
460	468	g_popped.push_back(it->contigIndex());
461	469
462	470	add_edge(u, w, max(longestPath(g, bubble), 1), g);
463	471	}
464	472
465	473	/** Pop the specified bubble if it is simple, otherwise scaffold. */
466		static void popOrScaffoldBubble(Graph& g, const Bubble& bubble)
	474	static void
	475	popOrScaffoldBubble(Graph& g, const Bubble& bubble)
467	476	{
468	477	#pragma omp atomic
469	478	g_count.bubbles++;

475	484	}
476	485
477	486	/** Return the length of the specified vertex in k-mer. */
478		static unsigned getKmerLength(const ContigProperties& vp)
	487	static unsigned
	488	getKmerLength(const ContigProperties& vp)
479	489	{
480	490	assert(vp.length >= opt::k);
481	491	return vp.length - opt::k + 1;
482	492	}
483	493
484	494	/** Return the mean k-mer coverage of the specified vertex. */
485		static float getMeanCoverage(const ContigProperties& vp)
	495	static float
	496	getMeanCoverage(const ContigProperties& vp)
486	497	{
487	498	return (float)vp.coverage / getKmerLength(vp);
488	499	}
489	500
490	501	/** Remove contigs with insufficient coverage. */
491		static void filterGraph(Graph& g)
	502	static void
	503	filterGraph(Graph& g)
492	504	{
493	505	typedef graph_traits<Graph> GTraits;
494	506	typedef GTraits::vertex_descriptor V;

510	522	}
511	523	}
512	524	if (opt::verbose > 0) {
513		cerr << "Removed " << removedKmer << " k-mer in "
514		<< removedContigs << " contigs with mean k-mer coverage "
515		"less than " << opt::minCoverage << ".\n";
	525	cerr << "Removed " << removedKmer << " k-mer in " << removedContigs
	526	<< " contigs with mean k-mer coverage "
	527	"less than "
	528	<< opt::minCoverage << ".\n";
516	529	printGraphStats(cerr, g);
517	530	}
518	531	}
519	532
520	533	/** Remove the specified contig from the adjacency graph. */
521		static void removeContig(Graph* g, ContigID id)
	534	static void
	535	removeContig(Graph* g, ContigID id)
522	536	{
523	537	ContigNode v(id, false);
524	538	g->clear_vertex(v);
525	539	g->remove_vertex(v);
526	540	}
527	541
528		int main(int argc, char** argv)
	542	int
	543	main(int argc, char** argv)
529	544	{
530	545	string commandLine;
531	546	{
532	547	ostringstream ss;
533	548	char** last = argv + argc - 1;
534		copy(argv, last, ostream_iterator<const char *>(ss, " "));
	549	copy(argv, last, ostream_iterator<const char*>(ss, " "));
535	550	ss << *last;
536	551	commandLine = ss.str();
537	552	}
538	553
539	554	bool die = false;
540		for (int c; (c = getopt_long(argc, argv,
541		shortopts, longopts, NULL)) != -1;) {
	555	for (int c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) {
542	556	istringstream arg(optarg != NULL ? optarg : "");
543	557	switch (c) {
544		case '?': die = true; break;
545		case 'a': arg >> opt::maxBranches; break;
546		case 'b': arg >> opt::maxLength; break;
547		case 'c': arg >> opt::minCoverage; break;
548		case 'g': arg >> opt::graphPath; break;
549		case 'j': arg >> opt::threads; break;
550		case 'k': arg >> opt::k; break;
551		case 'p': arg >> opt::identity; break;
552		case 'v': opt::verbose++; break;
553		case OPT_HELP:
554		cout << USAGE_MESSAGE;
555		exit(EXIT_SUCCESS);
556		case OPT_VERSION:
557		cout << VERSION_MESSAGE;
558		exit(EXIT_SUCCESS);
	558	case '?':
	559	die = true;
	560	break;
	561	case 'a':
	562	arg >> opt::maxBranches;
	563	break;
	564	case 'b':
	565	arg >> opt::maxLength;
	566	break;
	567	case 'c':
	568	arg >> opt::minCoverage;
	569	break;
	570	case 'g':
	571	arg >> opt::graphPath;
	572	break;
	573	case 'j':
	574	arg >> opt::threads;
	575	break;
	576	case 'k':
	577	arg >> opt::k;
	578	break;
	579	case 'p':
	580	arg >> opt::identity;
	581	break;
	582	case 'v':
	583	opt::verbose++;
	584	break;
	585	case OPT_HELP:
	586	cout << USAGE_MESSAGE;
	587	exit(EXIT_SUCCESS);
	588	case OPT_VERSION:
	589	cout << VERSION_MESSAGE;
	590	exit(EXIT_SUCCESS);
559	591	}
560	592	if (optarg != NULL && !arg.eof()) {
561		cerr << PROGRAM ": invalid option: `-"
562		<< (char)c << optarg << "'\n";
	593	cerr << PROGRAM ": invalid option: `-" << (char)c << optarg << "'\n";
563	594	exit(EXIT_FAILURE);
564	595	}
565	596	}
566	597
567	598	if (opt::k <= 0) {
568		cerr << PROGRAM ": " << "missing -k,--kmer option\n";
	599	cerr << PROGRAM ": "
	600	<< "missing -k,--kmer option\n";
569	601	die = true;
570	602	}
571	603

580	612	}
581	613
582	614	if (die) {
583		cerr << "Try `" << PROGRAM
584		<< " --help' for more information.\n";
	615	cerr << "Try `" << PROGRAM << " --help' for more information.\n";
585	616	exit(EXIT_FAILURE);
586	617	}
587	618

625	656	cout << "digraph bubbles {\n";
626	657
627	658	Bubbles bubbles = discoverBubbles(g);
628		for (Bubbles::const_iterator it = bubbles.begin();
629		it != bubbles.end(); ++it)
	659	for (Bubbles::const_iterator it = bubbles.begin(); it != bubbles.end(); ++it)
630	660	popOrScaffoldBubble(g, *it);
631	661
632	662	// Each bubble should be identified twice. Remove the duplicate.
633	663	sort(g_popped.begin(), g_popped.end());
634		g_popped.erase(unique(g_popped.begin(), g_popped.end()),
635		g_popped.end());
	664	g_popped.erase(unique(g_popped.begin(), g_popped.end()), g_popped.end());
636	665
637	666	if (opt::bubbleGraph) {
638	667	cout << "}\n";
639	668	} else {
640		for (vector<ContigID>::const_iterator it = g_popped.begin();
641		it != g_popped.end(); ++it)
	669	for (vector<ContigID>::const_iterator it = g_popped.begin(); it != g_popped.end(); ++it)
642	670	cout << get(g_contigNames, *it) << '\n';
643	671	}
644	672
645	673	if (opt::verbose > 0)
646		cerr << "Bubbles: " << (g_count.bubbles + 1) / 2
647		<< " Popped: " << (g_count.popped + 1) / 2
648		<< " Scaffolds: " << (g_count.scaffold + 1) / 2
649		<< " Complex: " << (g_count.notSimple + 1) / 2
650		<< " Too long: " << (g_count.tooLong + 1) / 2
651		<< " Too many: " << (g_count.tooMany + 1) / 2
652		<< " Dissimilar: " << (g_count.dissimilar + 1) / 2
653		<< '\n';
	674	cerr << "Bubbles: " << (g_count.bubbles + 1) / 2 << " Popped: " << (g_count.popped + 1) / 2
	675	<< " Scaffolds: " << (g_count.scaffold + 1) / 2
	676	<< " Complex: " << (g_count.notSimple + 1) / 2
	677	<< " Too long: " << (g_count.tooLong + 1) / 2
	678	<< " Too many: " << (g_count.tooMany + 1) / 2
	679	<< " Dissimilar: " << (g_count.dissimilar + 1) / 2 << '\n';
654	680
655	681	if (!opt::graphPath.empty()) {
656	682	// Remove the popped contigs from the adjacency graph.
657		for_each(g_popped.begin(), g_popped.end(),
658		bind1st(ptr_fun(removeContig), &g));
	683	for_each(g_popped.begin(), g_popped.end(), [&g](const ContigID& c) {
	684	return removeContig(&g, c);
	685	});
659	686
660	687	// Assemble unambiguous paths.
661	688	g_contigNames.unlock();

668	695	assemble_stranded(g, back_inserter(paths));
669	696	else
670	697	assemble(g, back_inserter(paths));
671		for (ContigPaths::const_iterator it = paths.begin();
672		it != paths.end(); ++it) {
	698	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
673	699	ContigNode u(numContigs + it - paths.begin(), false);
674	700	string name = createContigName();
675	701	put(vertex_name, g, u, name);
676		cout << name << '\t'
677		<< addDistance(gorig, *it) << '\n';
	702	cout << name << '\t' << addDistance(gorig, *it) << '\n';
678	703	}
679	704	} else {
680	705	if (opt::ss)
681	706	assemble_stranded(g, back_inserter(paths));
682	707	else
683	708	assemble(g, back_inserter(paths));
684		for (ContigPaths::const_iterator it = paths.begin();
685		it != paths.end(); ++it) {
	709	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
686	710	ContigNode u(numContigs + it - paths.begin(), false);
687	711	string name = createContigName();
688	712	put(vertex_name, g, u, name);

-0

README.md less more

	0	[![Release](https://img.shields.io/github/release/bcgsc/abyss.svg)](https://github.com/bcgsc/abyss/releases)
	1	[![Downloads](https://img.shields.io/github/downloads/bcgsc/abyss/total?logo=github)](https://github.com/bcgsc/abyss/releases/download/2.2.3/abyss-2.2.3.tar.gz)
	2	[![Conda](https://img.shields.io/conda/dn/bioconda/abyss?label=Conda)](https://anaconda.org/bioconda/abyss)
	3	[![Issues](https://img.shields.io/github/issues/bcgsc/abyss.svg)](https://github.com/bcgsc/abyss/issues)
	4
0	5	ABySS
1	6	=====
2	7

+328

-312

Scaffold/scaffold.cc less more

0		#include "config.h"
	0	#include "Common/UnorderedMap.h"
1	1	#include "ContigNode.h"
2	2	#include "ContigPath.h"
3	3	#include "ContigProperties.h"
	4	#include "DataBase/DB.h"
	5	#include "DataBase/Options.h"
4	6	#include "Estimate.h"
5		#include "IOUtil.h"
6		#include "Iterator.h"
7		#include "Uncompress.h"
8		#include "Common/UnorderedMap.h"
9	7	#include "Graph/Assemble.h"
10	8	#include "Graph/ContigGraph.h"
11	9	#include "Graph/ContigGraphAlgorithms.h"

14	12	#include "Graph/GraphIO.h"
15	13	#include "Graph/GraphUtil.h"
16	14	#include "Graph/PopBubbles.h"
	15	#include "IOUtil.h"
	16	#include "Iterator.h"
	17	#include "Uncompress.h"
	18	#include "config.h"
17	19	#include <cassert>
18	20	#include <climits>
19	21	#include <cmath>

23	25	#include <getopt.h>
24	26	#include <iostream>
25	27	#include <utility>
26		#include "DataBase/Options.h"
27		#include "DataBase/DB.h"
28	28
29	29	using namespace std;
30	30	using namespace std::rel_ops;

36	36	DB db;
37	37
38	38	static const char VERSION_MESSAGE[] =
39		PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
40		"Written by Shaun Jackman.\n"
41		"\n"
42		"Copyright 2018 Canada's Michael Smith Genome Sciences Centre\n";
	39	PROGRAM " (" PACKAGE_NAME ") " VERSION "\n"
	40	"Written by Shaun Jackman.\n"
	41	"\n"
	42	"Copyright 2018 Canada's Michael Smith Genome Sciences Centre\n";
43	43
44	44	static const char USAGE_MESSAGE[] =
45		"Usage: " PROGRAM " -k<kmer> [OPTION]... FASTA\|OVERLAP DIST...\n"
46		"Scaffold contigs using the distance estimate graph.\n"
47		"\n"
48		" Arguments:\n"
49		"\n"
50		" FASTA contigs in FASTA format\n"
51		" OVERLAP the contig overlap graph\n"
52		" DIST estimates of the distance between contigs\n"
53		"\n"
54		" Options:\n"
55		"\n"
56		" -n, --npairs=N minimum number of pairs [0]\n"
57		" or -n A-B:S Find the value of n in [A,B] with step size S\n"
58		" that maximizes the scaffold N50.\n"
59		" Default value for the step size is 1, if unspecified.\n"
60		" -s, --seed-length=N minimum contig length [1000]\n"
61		" or -s A-B Find the value of s in [A,B]\n"
62		" that maximizes the scaffold N50.\n"
63		" --grid optimize using a grid search [default]\n"
64		" --line optimize using a line search\n"
65		" -k, --kmer=N length of a k-mer\n"
66		" -G, --genome-size=N expected genome size. Used to calculate NG50\n"
67		" and associated stats [disabled]\n"
68		" --min-gap=N minimum scaffold gap length to output [50]\n"
69		" --max-gap=N maximum scaffold gap length to output [inf]\n"
70		" --complex remove complex transitive edges\n"
71		" --no-complex don't remove complex transitive edges [default]\n"
72		" --SS expect contigs to be oriented correctly\n"
73		" --no-SS no assumption about contig orientation [default]\n"
74		" -o, --out=FILE write the paths to FILE\n"
75		" -g, --graph=FILE write the graph to FILE\n"
76		" -v, --verbose display verbose output\n"
77		" --help display this help and exit\n"
78		" --version output version information and exit\n"
79		" --db=FILE specify path of database repository in FILE\n"
80		" --library=NAME specify library NAME for sqlite\n"
81		" --strain=NAME specify strain NAME for sqlite\n"
82		" --species=NAME specify species NAME for sqlite\n"
83		"\n"
84		"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
	45	"Usage: " PROGRAM " -k<kmer> [OPTION]... FASTA\|OVERLAP DIST...\n"
	46	"Scaffold contigs using the distance estimate graph.\n"
	47	"\n"
	48	" Arguments:\n"
	49	"\n"
	50	" FASTA contigs in FASTA format\n"
	51	" OVERLAP the contig overlap graph\n"
	52	" DIST estimates of the distance between contigs\n"
	53	"\n"
	54	" Options:\n"
	55	"\n"
	56	" -n, --npairs=N minimum number of pairs [0]\n"
	57	" or -n A-B:S Find the value of n in [A,B] with step size S\n"
	58	" that maximizes the scaffold N50.\n"
	59	" Default value for the step size is 1, if unspecified.\n"
	60	" -s, --seed-length=N minimum contig length [1000]\n"
	61	" or -s A-B Find the value of s in [A,B]\n"
	62	" that maximizes the scaffold N50.\n"
	63	" --grid optimize using a grid search [default]\n"
	64	" --line optimize using a line search\n"
	65	" -k, --kmer=N length of a k-mer\n"
	66	" -G, --genome-size=N expected genome size. Used to calculate NG50\n"
	67	" and associated stats [disabled]\n"
	68	" --min-gap=N minimum scaffold gap length to output [50]\n"
	69	" --max-gap=N maximum scaffold gap length to output [inf]\n"
	70	" --complex remove complex transitive edges\n"
	71	" --no-complex don't remove complex transitive edges [default]\n"
	72	" --SS expect contigs to be oriented correctly\n"
	73	" --no-SS no assumption about contig orientation [default]\n"
	74	" -o, --out=FILE write the paths to FILE\n"
	75	" -g, --graph=FILE write the graph to FILE\n"
	76	" -v, --verbose display verbose output\n"
	77	" --help display this help and exit\n"
	78	" --version output version information and exit\n"
	79	" --db=FILE specify path of database repository in FILE\n"
	80	" --library=NAME specify library NAME for sqlite\n"
	81	" --strain=NAME specify strain NAME for sqlite\n"
	82	" --species=NAME specify species NAME for sqlite\n"
	83	"\n"
	84	"Report bugs to <" PACKAGE_BUGREPORT ">.\n";
85	85
86	86	namespace opt {
87		string db;
88		dbVars metaVars;
89
90		unsigned k; // used by ContigProperties
91
92		/** Optimization search strategy. */
93		static int searchStrategy;
94
95		/** Minimum number of pairs. */
96		static unsigned minEdgeWeight;
97		static unsigned minEdgeWeightEnd;
98		static unsigned minEdgeWeightStep;
99
100		/** Minimum contig length. */
101		static unsigned minContigLength = 1000;
102		static unsigned minContigLengthEnd = 1000;
103
104		/** Genome size. Used to calculate NG50. */
105		static long long unsigned genomeSize;
106
107		/** Minimum scaffold gap length to output. */
108		static int minGap = 50;
109
110		/** Maximum scaffold gap length to output.
111		* -ve value means no maximum. */
112		static int maxGap = -1;
113
114		/** Write the paths to this file. */
115		static string out;
116
117		/** Write the graph to this file. */
118		static string graphPath;
119
120		/** Run a strand-specific RNA-Seq assembly. */
121		static int ss;
122
123		/** Verbose output. */
124		int verbose; // used by PopBubbles
125
126		/** Output format */
127		int format = DOT; // used by DistanceEst
128
129		/** Remove complex transitive edges */
130		static int comp_trans;
	87	string db;
	88	dbVars metaVars;
	89
	90	unsigned k; // used by ContigProperties
	91
	92	/** Optimization search strategy. */
	93	static int searchStrategy;
	94
	95	/** Minimum number of pairs. */
	96	static unsigned minEdgeWeight;
	97	static unsigned minEdgeWeightEnd;
	98	static unsigned minEdgeWeightStep;
	99
	100	/** Minimum contig length. */
	101	static unsigned minContigLength = 1000;
	102	static unsigned minContigLengthEnd = 1000;
	103
	104	/** Genome size. Used to calculate NG50. */
	105	static long long unsigned genomeSize;
	106
	107	/** Minimum scaffold gap length to output. */
	108	static int minGap = 50;
	109
	110	/** Maximum scaffold gap length to output.
	111	* -ve value means no maximum. */
	112	static int maxGap = -1;
	113
	114	/** Write the paths to this file. */
	115	static string out;
	116
	117	/** Write the graph to this file. */
	118	static string graphPath;
	119
	120	/** Run a strand-specific RNA-Seq assembly. */
	121	static int ss;
	122
	123	/** Verbose output. */
	124	int verbose; // used by PopBubbles
	125
	126	/** Output format */
	127	int format = DOT; // used by DistanceEst
	128
	129	/** Remove complex transitive edges */
	130	static int comp_trans;
131	131	}
132	132
133	133	static const char shortopts[] = "G:g:k:n:o:s:v";
134	134
135		enum { OPT_HELP = 1, OPT_VERSION, OPT_MIN_GAP, OPT_MAX_GAP, OPT_COMP,
136		OPT_DB, OPT_LIBRARY, OPT_STRAIN, OPT_SPECIES };
	135	enum
	136	{
	137	OPT_HELP = 1,
	138	OPT_VERSION,
	139	OPT_MIN_GAP,
	140	OPT_MAX_GAP,
	141	OPT_COMP,
	142	OPT_DB,
	143	OPT_LIBRARY,
	144	OPT_STRAIN,
	145	OPT_SPECIES
	146	};
137	147
138	148	/** Optimization search strategy. */
139		enum { GRID_SEARCH, LINE_SEARCH };
	149	enum
	150	{
	151	GRID_SEARCH,
	152	LINE_SEARCH
	153	};
140	154
141	155	static const struct option longopts[] = {
142		{ "graph", no_argument, NULL, 'g' },
143		{ "kmer", required_argument, NULL, 'k' },
	156	{ "graph", no_argument, NULL, 'g' },
	157	{ "kmer", required_argument, NULL, 'k' },
144	158	{ "genome-size", required_argument, NULL, 'G' },
145		{ "min-gap", required_argument, NULL, OPT_MIN_GAP },
146		{ "max-gap", required_argument, NULL, OPT_MAX_GAP },
147		{ "npairs", required_argument, NULL, 'n' },
148		{ "grid", no_argument, &opt::searchStrategy, GRID_SEARCH },
149		{ "line", no_argument, &opt::searchStrategy, LINE_SEARCH },
150		{ "out", required_argument, NULL, 'o' },
	159	{ "min-gap", required_argument, NULL, OPT_MIN_GAP },
	160	{ "max-gap", required_argument, NULL, OPT_MAX_GAP },
	161	{ "npairs", required_argument, NULL, 'n' },
	162	{ "grid", no_argument, &opt::searchStrategy, GRID_SEARCH },
	163	{ "line", no_argument, &opt::searchStrategy, LINE_SEARCH },
	164	{ "out", required_argument, NULL, 'o' },
151	165	{ "seed-length", required_argument, NULL, 's' },
152		{ "complex", no_argument, &opt::comp_trans, 1 },
153		{ "no-complex", no_argument, &opt::comp_trans, 0 },
154		{ "SS", no_argument, &opt::ss, 1 },
155		{ "no-SS", no_argument, &opt::ss, 0 },
156		{ "verbose", no_argument, NULL, 'v' },
157		{ "help", no_argument, NULL, OPT_HELP },
158		{ "version", no_argument, NULL, OPT_VERSION },
159		{ "db", required_argument, NULL, OPT_DB },
160		{ "library", required_argument, NULL, OPT_LIBRARY },
161		{ "strain", required_argument, NULL, OPT_STRAIN },
162		{ "species", required_argument, NULL, OPT_SPECIES },
	166	{ "complex", no_argument, &opt::comp_trans, 1 },
	167	{ "no-complex", no_argument, &opt::comp_trans, 0 },
	168	{ "SS", no_argument, &opt::ss, 1 },
	169	{ "no-SS", no_argument, &opt::ss, 0 },
	170	{ "verbose", no_argument, NULL, 'v' },
	171	{ "help", no_argument, NULL, OPT_HELP },
	172	{ "version", no_argument, NULL, OPT_VERSION },
	173	{ "db", required_argument, NULL, OPT_DB },
	174	{ "library", required_argument, NULL, OPT_LIBRARY },
	175	{ "strain", required_argument, NULL, OPT_STRAIN },
	176	{ "species", required_argument, NULL, OPT_SPECIES },
163	177	{ NULL, 0, NULL, 0 }
164	178	};
165	179

171	185	* An edge is invalid when the overlap is larger than the length of
172	186	* either of its incident sequences.
173	187	*/
174		struct InvalidEdge {
175		InvalidEdge(Graph& g) : m_g(g) { }
	188	struct InvalidEdge
	189	{
	190	InvalidEdge(Graph& g)
	191	: m_g(g)
	192	{}
176	193	bool operator()(graph_traits<Graph>::edge_descriptor e) const
177	194	{
178	195	int d = m_g[e].distance;

184	201	};
185	202
186	203	/** Return whether the specified edges has sufficient support. */
187		struct PoorSupport {
188		PoorSupport(Graph& g, unsigned minEdgeWeight) : m_g(g), m_minEdgeWeight(minEdgeWeight) { }
	204	struct PoorSupport
	205	{
	206	PoorSupport(Graph& g, unsigned minEdgeWeight)
	207	: m_g(g)
	208	, m_minEdgeWeight(minEdgeWeight)
	209	{}
189	210	bool operator()(graph_traits<Graph>::edge_descriptor e) const
190	211	{
191	212	return m_g[e].numPairs < m_minEdgeWeight;

195	216	};
196	217
197	218	/** Remove short vertices and unsupported edges from the graph. */
198		static void filterGraph(Graph& g, unsigned minEdgeWeight, unsigned minContigLength)
	219	static void
	220	filterGraph(Graph& g, unsigned minEdgeWeight, unsigned minContigLength)
199	221	{
200	222	typedef graph_traits<Graph> GTraits;
201	223	typedef GTraits::vertex_descriptor V;

229	251	}
230	252
231	253	/** Return true if the specified edge is a cycle. */
232		static bool isCycle(Graph& g, graph_traits<Graph>::edge_descriptor e)
	254	static bool
	255	isCycle(Graph& g, graph_traits<Graph>::edge_descriptor e)
233	256	{
234	257	return edge(target(e, g), source(e, g), g).second;
235	258	}
236	259
237	260	/** Remove simple cycles of length two from the graph. */
238		static void removeCycles(Graph& g)
	261	static void
	262	removeCycles(Graph& g)
239	263	{
240	264	typedef graph_traits<Graph>::edge_descriptor E;
241	265	typedef graph_traits<Graph>::edge_iterator Eit;

264	288	* For a pair of edges (u,v1) and (u,v2) in g, if exactly one of the
265	289	* edges (v1,v2) or (v2,v1) exists in g0, add that edge to g.
266	290	*/
267		static void resolveForks(Graph& g, const Graph& g0)
	291	static void
	292	resolveForks(Graph& g, const Graph& g0)
268	293	{
269	294	typedef graph_traits<Graph>::adjacency_iterator Vit;
270	295	typedef graph_traits<Graph>::edge_descriptor E;

292	317	pair<E, bool> e21 = edge(v2, v1, g0);
293	318	if (e12.second && e21.second) {
294	319	if (opt::verbose > 1)
295		cerr << "cycle: " << get(vertex_name, g, v1)
296		<< ' ' << get(vertex_name, g, v2) << '\n';
	320	cerr << "cycle: " << get(vertex_name, g, v1) << ' '
	321	<< get(vertex_name, g, v2) << '\n';
297	322	} else if (e12.second \|\| e21.second) {
298	323	E e = e12.second ? e12.first : e21.first;
299	324	V v = source(e, g0), w = target(e, g0);
300	325	add_edge(v, w, g0[e], g);
301	326	numEdges++;
302	327	if (opt::verbose > 1)
303		cerr << get(vertex_name, g, u)
304		<< " -> " << get(vertex_name, g, v)
305		<< " -> " << get(vertex_name, g, w)
306		<< " [" << g0[e] << "]\n";
	328	cerr << get(vertex_name, g, u) << " -> " << get(vertex_name, g, v) << " -> "
	329	<< get(vertex_name, g, w) << " [" << g0[e] << "]\n";
307	330	}
308	331	}
309	332	}
310	333	}
311	334	if (opt::verbose > 0)
312		cerr << "Added " << numEdges
313		<< " edges to ambiguous vertices.\n";
	335	cerr << "Added " << numEdges << " edges to ambiguous vertices.\n";
314	336	if (!opt::db.empty())
315	337	addToDb(db, "E_added_ambig", numEdges);
316	338	}

319	341	* For an edge (u,v), remove the vertex v if deg+(u) > 1
320	342	* and deg-(v) = 1 and deg+(v) = 0.
321	343	*/
322		static void pruneTips(Graph& g)
	344	static void
	345	pruneTips(Graph& g)
323	346	{
324	347	/** Identify the tips. */
325	348	size_t n = 0;

339	362	* operation: remove vertex u
340	363	* output: digraph g { t1->v1 t2->v2 }
341	364	*/
342		static void removeRepeats(Graph& g)
	365	static void
	366	removeRepeats(Graph& g)
343	367	{
344	368	typedef graph_traits<Graph>::adjacency_iterator Ait;
345	369	typedef graph_traits<Graph>::edge_descriptor E;

348	372	vector<V> repeats;
349	373	vector<E> transitive;
350	374	find_transitive_edges(g, back_inserter(transitive));
351		for (vector<E>::const_iterator it = transitive.begin();
352		it != transitive.end(); ++it) {
	375	for (vector<E>::const_iterator it = transitive.begin(); it != transitive.end(); ++it) {
353	376	// Iterate through the transitive edges, u->w1.
354	377	V u = source(it, g), w1 = target(it, g);
355	378	Ait vit, vlast;
356		for (tie(vit, vlast) = adjacent_vertices(u, g);
357		vit != vlast; ++vit) {
	379	for (tie(vit, vlast) = adjacent_vertices(u, g); vit != vlast; ++vit) {
358	380	V v = *vit;
359	381	assert(u != v); // no self loops
360	382	if (!edge(v, w1, g).second)
361	383	continue;
362	384	// u->w1 is a transitive edge spanning u->v->w1.
363	385	Ait wit, wlast;
364		for (tie(wit, wlast) = adjacent_vertices(v, g);
365		wit != wlast; ++wit) {
	386	for (tie(wit, wlast) = adjacent_vertices(v, g); wit != wlast; ++wit) {
366	387	// For each edge v->w2, check that an edge
367	388	// w1->w2 or w2->w1 exists. If not, v is a repeat.
368	389	V w2 = *wit;
369	390	assert(v != w2); // no self loops
370		if (w1 != w2
371		&& !edge(w1, w2, g).second
372		&& !edge(w2, w1, g).second) {
	391	if (w1 != w2 && !edge(w1, w2, g).second && !edge(w2, w1, g).second) {
373	392	repeats.push_back(v);
374	393	break;
375	394	}

378	397	}
379	398
380	399	sort(repeats.begin(), repeats.end());
381		repeats.erase(unique(repeats.begin(), repeats.end()),
382		repeats.end());
	400	repeats.erase(unique(repeats.begin(), repeats.end()), repeats.end());
383	401	if (opt::verbose > 1) {
384	402	cerr << "Ambiguous:";
385		for (vector<V>::const_iterator it = repeats.begin();
386		it != repeats.end(); ++it)
	403	for (vector<V>::const_iterator it = repeats.begin(); it != repeats.end(); ++it)
387	404	cerr << ' ' << get(vertex_name, g, *it);
388	405	cerr << '\n';
389	406	}
390	407
391	408	// Remove the repetitive vertices.
392	409	unsigned numRemoved = 0;
393		for (vector<V>::const_iterator it = repeats.begin();
394		it != repeats.end(); ++it) {
	410	for (vector<V>::const_iterator it = repeats.begin(); it != repeats.end(); ++it) {
395	411	V u = *it;
396	412	V uc = get(vertex_complement, g, u);
397	413	clear_out_edges(u, g);

402	418	}
403	419
404	420	if (opt::verbose > 0) {
405		cerr << "Cleared "
406		<< repeats.size() << " ambiguous vertices.\n"
407		<< "Removed "
408		<< numRemoved << " ambiguous vertices.\n";
	421	cerr << "Cleared " << repeats.size() << " ambiguous vertices.\n"
	422	<< "Removed " << numRemoved << " ambiguous vertices.\n";
409	423	printGraphStats(cerr, g);
410	424	}
411	425	if (!opt::db.empty()) {

420	434	* operation: remove edge u1->v2
421	435	* output: digraph g {u1->v1 u2->v2 }
422	436	*/
423		static void removeWeakEdges(Graph& g)
	437	static void
	438	removeWeakEdges(Graph& g)
424	439	{
425	440	typedef graph_traits<Graph>::edge_descriptor E;
426	441	typedef graph_traits<Graph>::edge_iterator Eit;

477	492
478	493	if (opt::verbose > 1) {
479	494	cerr << "Weak edges:\n";
480		for (vector<E>::const_iterator it = weak.begin();
481		it != weak.end(); ++it) {
	495	for (vector<E>::const_iterator it = weak.begin(); it != weak.end(); ++it) {
482	496	E e = *it;
483		cerr << '\t' << get(edge_name, g, e)
484		<< " [" << g[e] << "]\n";
	497	cerr << '\t' << get(edge_name, g, e) << " [" << g[e] << "]\n";
485	498	}
486	499	}
487	500

495	508	addToDb(db, "E_removed_weak", weak.size());
496	509	}
497	510
498		static void removeLongEdges(Graph& g)
	511	static void
	512	removeLongEdges(Graph& g)
499	513	{
500	514	typedef graph_traits<Graph>::edge_descriptor E;
501	515	typedef graph_traits<Graph>::edge_iterator Eit;

513	527	/** Return whether the specified distance estimate is an exact
514	528	* overlap.
515	529	*/
516		static bool isOverlap(const DistanceEst& d)
	530	static bool
	531	isOverlap(const DistanceEst& d)
517	532	{
518	533	if (d.stdDev == 0) {
519	534	assert(d.distance < 0);

526	541	* @param g0 the original graph
527	542	* @param g1 the transformed graph
528	543	*/
529		static ContigPath addDistEst(const Graph& g0, const Graph& g1,
530		const ContigPath& path)
	544	static ContigPath
	545	addDistEst(const Graph& g0, const Graph& g1, const ContigPath& path)
531	546	{
532	547	typedef graph_traits<Graph>::edge_descriptor E;
533	548	typedef edge_bundle_type<Graph>::type EP;

536	551	out.reserve(2 * path.size());
537	552	ContigNode u = path.front();
538	553	out.push_back(u);
539		for (ContigPath::const_iterator it = path.begin() + 1;
540		it != path.end(); ++it) {
	554	for (ContigPath::const_iterator it = path.begin() + 1; it != path.end(); ++it) {
541	555	ContigNode v = *it;
542	556	assert(!v.ambiguous());
543	557	pair<E, bool> e0 = edge(u, v, g0);
544	558	pair<E, bool> e1 = edge(u, v, g1);
545	559	if (!e0.second && !e1.second)
546		std::cerr << "error: missing edge: " << get(vertex_name, g0, u) << " -> " << get(vertex_name, g0, v) << '\n';
	560	std::cerr << "error: missing edge: " << get(vertex_name, g0, u) << " -> "
	561	<< get(vertex_name, g0, v) << '\n';
547	562	assert(e0.second \|\| e1.second);
548	563	const EP& ep = e0.second ? g0[e0.first] : g1[e1.first];
549	564	if (!isOverlap(ep)) {

560	575	}
561	576
562	577	/** Read a graph from the specified file. */
563		static void readGraph(const string& path, Graph& g)
	578	static void
	579	readGraph(const string& path, Graph& g)
564	580	{
565	581	if (opt::verbose > 0)
566	582	cerr << "Reading `" << path << "'...\n";

573	589	printGraphStats(cerr, g);
574	590
575	591	vector<int> vals = passGraphStatsVal(g);
576		vector<string> keys = make_vector<string>()
577		<< "V_readGraph"
578		<< "E_readGraph"
579		<< "degree0_readGraph"
580		<< "degree1_readGraph"
581		<< "degree234_readGraph"
582		<< "degree5_readGraph"
583		<< "max_readGraph";
	592	vector<string> keys = make_vector<string>() << "V_readGraph"
	593	<< "E_readGraph"
	594	<< "degree0_readGraph"
	595	<< "degree1_readGraph"
	596	<< "degree234_readGraph"
	597	<< "degree5_readGraph"
	598	<< "max_readGraph";
584	599
585	600	if (!opt::db.empty()) {
586		for(unsigned i=0; i<vals.size(); i++)
	601	for (unsigned i = 0; i < vals.size(); i++)
587	602	addToDb(db, keys[i], vals[i]);
588	603	}
589	604	g_contigNames.lock();

591	606
592	607	/** Return the scaffold length of [first, last), not counting gaps. */
593	608	template<typename It>
594		unsigned addLength(const Graph& g, It first, It last)
	609	unsigned
	610	addLength(const Graph& g, It first, It last)
595	611	{
596	612	typedef typename graph_traits<Graph>::vertex_descriptor V;
597	613	assert(first != last);

609	625	typedef vector<ContigPath> ContigPaths;
610	626
611	627	/**
612		* Build the scaffold length histogram.
613		* @param g The graph g is destroyed.
614		*/
615		static Histogram buildScaffoldLengthHistogram(
616		Graph& g, const ContigPaths& paths)
	628	* Build the scaffold length histogram.
	629	* @param g The graph g is destroyed.
	630	*/
	631	static Histogram
	632	buildScaffoldLengthHistogram(Graph& g, const ContigPaths& paths)
617	633	{
618	634	Histogram h;
619	635

625	641
626	642	// Remove the vertices that are used in paths
627	643	// and add the lengths of the scaffolds.
628		for (ContigPaths::const_iterator it = paths.begin();
629		it != paths.end(); ++it) {
	644	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it) {
630	645	h.insert(addLength(g, it->begin(), it->end()));
631		remove_vertex_if(g, it->begin(), it->end(),
632		not1(std::mem_fun_ref(&ContigNode::ambiguous)));
	646	remove_vertex_if(
	647	g, it->begin(), it->end(), [](const ContigNode& c) { return !c.ambiguous(); });
633	648	}
634	649
635	650	// Add the contigs that were not used in paths.

644	659	}
645	660
646	661	/** Add contiguity stats to database */
647		static void addCntgStatsToDb(
648		const Histogram h, const unsigned min)
	662	static void
	663	addCntgStatsToDb(const Histogram h, const unsigned min)
649	664	{
650	665	vector<int> vals = passContiguityStatsVal(h, min);
651		vector<string> keys = make_vector<string>()
652		<< "n"
653		<< "n200"
654		<< "nN50"
655		<< "min"
656		<< "N75"
657		<< "N50"
658		<< "N25"
659		<< "Esize"
660		<< "max"
661		<< "sum"
662		<< "nNG50"
663		<< "NG50";
	666	vector<string> keys = make_vector<string>() << "n"
	667	<< "n200"
	668	<< "nN50"
	669	<< "min"
	670	<< "N75"
	671	<< "N50"
	672	<< "N25"
	673	<< "Esize"
	674	<< "max"
	675	<< "sum"
	676	<< "nNG50"
	677	<< "NG50";
664	678	if (!opt::db.empty()) {
665		for(unsigned i=0; i<vals.size(); i++)
	679	for (unsigned i = 0; i < vals.size(); i++)
666	680	addToDb(db, keys[i], vals[i]);
667	681	}
668	682	}
669	683
670	684	/** Parameters of scaffolding. */
671		struct ScaffoldParam {
672		ScaffoldParam(unsigned n, unsigned s) : n(n), s(s) { }
	685	struct ScaffoldParam
	686	{
	687	ScaffoldParam(unsigned n, unsigned s)
	688	: n(n)
	689	, s(s)
	690	{}
673	691	bool operator==(const ScaffoldParam& o) const { return n == o.n && s == o.s; }
674	692	unsigned n;
675	693	unsigned s;
676	694	};
677	695
678	696	NAMESPACE_STD_HASH_BEGIN
679		template <> struct hash<ScaffoldParam> {
680		size_t operator()(const ScaffoldParam& param) const
681		{
682		return hash<unsigned>()(param.n) ^ hash<unsigned>()(param.s);
683		}
684		};
	697	template<>
	698	struct hash<ScaffoldParam>
	699	{
	700	size_t operator()(const ScaffoldParam& param) const
	701	{
	702	return hash<unsigned>()(param.n) ^ hash<unsigned>()(param.s);
	703	}
	704	};
685	705	NAMESPACE_STD_HASH_END
686	706
687	707	/** Result of scaffolding. */
688		struct ScaffoldResult : ScaffoldParam{
689		ScaffoldResult() : ScaffoldParam(0, 0), n50(0) { }
	708	struct ScaffoldResult : ScaffoldParam
	709	{
	710	ScaffoldResult()
	711	: ScaffoldParam(0, 0)
	712	, n50(0)
	713	{}
690	714	ScaffoldResult(unsigned n, unsigned s, unsigned n50, std::string metrics)
691		: ScaffoldParam(n, s), n50(n50), metrics(metrics) { }
	715	: ScaffoldParam(n, s)
	716	, n50(n50)
	717	, metrics(metrics)
	718	{}
692	719	unsigned n50;
693	720	std::string metrics;
694	721	};

698	725	* @return the scaffold N50
699	726	*/
700	727	ScaffoldResult
701		scaffold(const Graph& g0,
702		unsigned minEdgeWeight, unsigned minContigLength,
703		bool output)
	728	scaffold(const Graph& g0, unsigned minEdgeWeight, unsigned minContigLength, bool output)
704	729	{
705	730	Graph g(g0);
706	731

743	768	typedef graph_traits<Graph>::vertex_descriptor V;
744	769	vector<V> popped = popBubbles(g);
745	770	if (opt::verbose > 0) {
746		cerr << "Removed " << popped.size()
747		<< " vertices in bubbles.\n";
	771	cerr << "Removed " << popped.size() << " vertices in bubbles.\n";
748	772	printGraphStats(cerr, g);
749	773	}
750	774

753	777
754	778	if (opt::verbose > 1) {
755	779	cerr << "Popped:";
756		for (vector<V>::const_iterator it = popped.begin();
757		it != popped.end(); ++it)
	780	for (vector<V>::const_iterator it = popped.begin(); it != popped.end(); ++it)
758	781	cerr << ' ' << get(vertex_name, g, *it);
759	782	cerr << '\n';
760	783	}

772	795	sort(paths.begin(), paths.end());
773	796	unsigned n = 0;
774	797	if (opt::verbose > 0) {
775		for (ContigPaths::const_iterator it = paths.begin();
776		it != paths.end(); ++it)
	798	for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it)
777	799	n += it->size();
778		cerr << "Assembled " << n << " contigs in "
779		<< paths.size() << " scaffolds.\n";
	800	cerr << "Assembled " << n << " contigs in " << paths.size() << " scaffolds.\n";
780	801	printGraphStats(cerr, g);
781	802	}
782	803

791	812	ostream& out = opt::out.empty() \|\| opt::out == "-" ? cout : fout;
792	813	assert_good(out, opt::out);
793	814	g_contigNames.unlock();
794		for (vector<ContigPath>::const_iterator it = paths.begin();
795		it != paths.end(); ++it)
796		out << createContigName() << '\t'
797		<< addDistEst(g0, g, *it) << '\n';
	815	for (vector<ContigPath>::const_iterator it = paths.begin(); it != paths.end(); ++it)
	816	out << createContigName() << '\t' << addDistEst(g0, g, *it) << '\n';
798	817	assert_good(out, opt::out);
799	818
800	819	// Output the graph.

810	829	const unsigned STATS_MIN_LENGTH = opt::minContigLength;
811	830	std::ostringstream ss;
812	831	Histogram scaffold_histogram = buildScaffoldLengthHistogram(g, paths);
813		printContiguityStats(ss, scaffold_histogram, STATS_MIN_LENGTH,
814		false, "\t", opt::genomeSize)
815		<< "\tn=" << minEdgeWeight << " s=" << minContigLength << '\n';
	832	printContiguityStats(ss, scaffold_histogram, STATS_MIN_LENGTH, false, "\t", opt::genomeSize)
	833	<< "\tn=" << minEdgeWeight << " s=" << minContigLength << '\n';
816	834	std::string metrics = ss.str();
817	835	addCntgStatsToDb(scaffold_histogram, STATS_MIN_LENGTH);
818	836
819		return ScaffoldResult(minEdgeWeight, minContigLength,
820		scaffold_histogram.trimLow(STATS_MIN_LENGTH).n50(),
821		metrics);
	837	return ScaffoldResult(
	838	minEdgeWeight,
	839	minContigLength,
	840	scaffold_histogram.trimLow(STATS_MIN_LENGTH).n50(),
	841	metrics);
822	842	}
823	843
824	844	/** Memoize the optimization results so far. */

857	877
858	878	/** Find the value of n that maximizes the scaffold N50. */
859	879	static ScaffoldResult
860		optimize_n(const Graph& g,
861		std::pair<unsigned, unsigned> minEdgeWeight,
862		unsigned minContigLength,
863		ScaffoldMemo& memo)
	880	optimize_n(
	881	const Graph& g,
	882	std::pair<unsigned, unsigned> minEdgeWeight,
	883	unsigned minContigLength,
	884	ScaffoldMemo& memo)
864	885	{
865	886	std::string metrics_table;
866	887	unsigned bestn = 0, bestN50 = 0;

878	899
879	900	/** Find the value of s that maximizes the scaffold N50. */
880	901	static ScaffoldResult
881		optimize_s(const Graph& g,
882		unsigned minEdgeWeight,
883		std::pair<unsigned, unsigned> minContigLength,
884		ScaffoldMemo& memo)
	902	optimize_s(
	903	const Graph& g,
	904	unsigned minEdgeWeight,
	905	std::pair<unsigned, unsigned> minContigLength,
	906	ScaffoldMemo& memo)
885	907	{
886	908	std::string metrics_table;
887	909	unsigned bests = 0, bestN50 = 0;
888	910	const double STEP = cbrt(10); // Three steps per decade.
889		unsigned ilast = (unsigned)round(
890		log(minContigLength.second) / log(STEP));
891		for (unsigned i = (unsigned)round(
892		log(minContigLength.first) / log(STEP));
893		i <= ilast; ++i) {
	911	unsigned ilast = (unsigned)round(log(minContigLength.second) / log(STEP));
	912	for (unsigned i = (unsigned)round(log(minContigLength.first) / log(STEP)); i <= ilast; ++i) {
894	913	unsigned s = (unsigned)pow(STEP, (int)i);
895	914
896	915	// Round to 1 figure.

910	929
911	930	/** Find the values of n and s that maximizes the scaffold N50. */
912	931	static ScaffoldResult
913		optimize_grid_search(const Graph& g,
914		std::pair<unsigned, unsigned> minEdgeWeight,
915		std::pair<unsigned, unsigned> minContigLength)
	932	optimize_grid_search(
	933	const Graph& g,
	934	std::pair<unsigned, unsigned> minEdgeWeight,
	935	std::pair<unsigned, unsigned> minContigLength)
916	936	{
917	937	const unsigned STATS_MIN_LENGTH = opt::minContigLength;
918	938	if (opt::verbose == 0)

934	954
935	955	/** Find the values of n and s that maximizes the scaffold N50. */
936	956	static ScaffoldResult
937		optimize_line_search(const Graph& g,
938		std::pair<unsigned, unsigned> minEdgeWeight,
939		std::pair<unsigned, unsigned> minContigLength)
	957	optimize_line_search(
	958	const Graph& g,
	959	std::pair<unsigned, unsigned> minEdgeWeight,
	960	std::pair<unsigned, unsigned> minContigLength)
940	961	{
941	962	const unsigned STATS_MIN_LENGTH = opt::minContigLength;
942	963	if (opt::verbose == 0)

945	966	ScaffoldMemo memo;
946	967	std::string metrics_table;
947	968	ScaffoldResult best(
948		(minEdgeWeight.first + minEdgeWeight.second) / 2,
949		minContigLength.second, 0, "");
	969	(minEdgeWeight.first + minEdgeWeight.second) / 2, minContigLength.second, 0, "");
950	970	// An upper limit on the number of iterations.
951		const unsigned MAX_ITERATIONS = 1 + (minEdgeWeight.second - minEdgeWeight.first) / opt::minEdgeWeightStep;
	971	const unsigned MAX_ITERATIONS =
	972	1 + (minEdgeWeight.second - minEdgeWeight.first) / opt::minEdgeWeightStep;
952	973	for (unsigned i = 0; i < MAX_ITERATIONS; ++i) {
953	974	// Optimize s.
954	975	if (opt::verbose > 0) {

980	1001	}
981	1002
982	1003	/** Run abyss-scaffold. */
983		int main(int argc, char** argv)
	1004	int
	1005	main(int argc, char** argv)
984	1006	{
985	1007	if (!opt::db.empty())
986	1008	opt::metaVars.resize(3);
987	1009
988	1010	bool die = false;
989		for (int c; (c = getopt_long(argc, argv,
990		shortopts, longopts, NULL)) != -1;) {
	1011	for (int c; (c = getopt_long(argc, argv, shortopts, longopts, NULL)) != -1;) {
991	1012	istringstream arg(optarg != NULL ? optarg : "");
992	1013	switch (c) {
993		case '?':
	1014	case '?':
994	1015	die = true;
995	1016	break;
996		case 'k':
	1017	case 'k':
997	1018	arg >> opt::k;
998	1019	break;
999		case 'G':
1000		{
1001		double x;
1002		arg >> x;
1003		opt::genomeSize = x;
1004		break;
1005		}
1006		case 'g':
	1020	case 'G': {
	1021	double x;
	1022	arg >> x;
	1023	opt::genomeSize = x;
	1024	break;
	1025	}
	1026	case 'g':
1007	1027	arg >> opt::graphPath;
1008	1028	break;
1009		case 'n':
	1029	case 'n':
1010	1030	arg >> opt::minEdgeWeight;
1011	1031	if (arg.peek() == '-') {
1012	1032	arg >> expect("-") >> opt::minEdgeWeightEnd;

1018	1038	else
1019	1039	opt::minEdgeWeightStep = 1;
1020	1040	break;
1021		case 'o':
	1041	case 'o':
1022	1042	arg >> opt::out;
1023	1043	break;
1024		case 's':
	1044	case 's':
1025	1045	arg >> opt::minContigLength;
1026	1046	if (arg.peek() == '-') {
1027	1047	opt::minContigLengthEnd = 100 * opt::minContigLength;
1028	1048	arg >> expect("-") >> opt::minContigLengthEnd;
1029		assert(opt::minContigLength
1030		<= opt::minContigLengthEnd);
	1049	assert(opt::minContigLength <= opt::minContigLengthEnd);
1031	1050	} else
1032	1051	opt::minContigLengthEnd = opt::minContigLength;
1033	1052	break;
1034		case 'v':
	1053	case 'v':
1035	1054	opt::verbose++;
1036	1055	break;
1037		case OPT_MIN_GAP:
	1056	case OPT_MIN_GAP:
1038	1057	arg >> opt::minGap;
1039	1058	break;
1040		case OPT_MAX_GAP:
	1059	case OPT_MAX_GAP:
1041	1060	arg >> opt::maxGap;
1042	1061	break;
1043		case OPT_HELP:
	1062	case OPT_HELP:
1044	1063	cout << USAGE_MESSAGE;
1045	1064	exit(EXIT_SUCCESS);
1046		case OPT_VERSION:
	1065	case OPT_VERSION:
1047	1066	cout << VERSION_MESSAGE;
1048	1067	exit(EXIT_SUCCESS);
1049		case OPT_DB:
	1068	case OPT_DB:
1050	1069	arg >> opt::db;
1051	1070	break;
1052		case OPT_LIBRARY:
	1071	case OPT_LIBRARY:
1053	1072	arg >> opt::metaVars[0];
1054	1073	break;
1055		case OPT_STRAIN:
	1074	case OPT_STRAIN:
1056	1075	arg >> opt::metaVars[1];
1057	1076	break;
1058		case OPT_SPECIES:
	1077	case OPT_SPECIES:
1059	1078	arg >> opt::metaVars[2];
1060	1079	break;
1061	1080	}
1062	1081	if (optarg != NULL && !arg.eof()) {
1063		cerr << PROGRAM ": invalid option: `-"
1064		<< (char)c << optarg << "'\n";
	1082	cerr << PROGRAM ": invalid option: `-" << (char)c << optarg << "'\n";
1065	1083	exit(EXIT_FAILURE);
1066	1084	}
1067	1085	}
1068	1086
1069	1087	if (opt::k <= 0) {
1070		cerr << PROGRAM ": " << "missing -k,--kmer option\n";
	1088	cerr << PROGRAM ": "
	1089	<< "missing -k,--kmer option\n";
1071	1090	die = true;
1072	1091	}
1073	1092

1077	1096	}
1078	1097
1079	1098	if (die) {
1080		cerr << "Try `" << PROGRAM
1081		<< " --help' for more information.\n";
	1099	cerr << "Try `" << PROGRAM << " --help' for more information.\n";
1082	1100	exit(EXIT_FAILURE);
1083	1101	}
1084	1102	if (!opt::db.empty()) {
1085		init(db,
1086		opt::db,
1087		opt::verbose,
1088		PROGRAM,
1089		opt::getCommand(argc, argv),
1090		opt::metaVars);
	1103	init(db, opt::db, opt::verbose, PROGRAM, opt::getCommand(argc, argv), opt::metaVars);
1091	1104	addToDb(db, "K", opt::k);
1092	1105	}
1093	1106

1113	1126	remove_edge_if(InvalidEdge(g), static_cast<DG&>(g));
1114	1127	unsigned numRemoved = numBefore - num_edges(g);
1115	1128	if (numRemoved > 0)
1116		cerr << "warning: Removed "
1117		<< numRemoved << " invalid edges.\n";
	1129	cerr << "warning: Removed " << numRemoved << " invalid edges.\n";
1118	1130
1119	1131	if (!opt::db.empty())
1120	1132	addToDb(db, "Edges_invalid", numRemoved);
1121	1133
1122	1134	const unsigned STATS_MIN_LENGTH = opt::minContigLength;
1123		if (opt::minEdgeWeight == opt::minEdgeWeightEnd
1124		&& opt::minContigLength == opt::minContigLengthEnd) {
	1135	if (opt::minEdgeWeight == opt::minEdgeWeightEnd &&
	1136	opt::minContigLength == opt::minContigLengthEnd) {
1125	1137	ScaffoldResult result = scaffold(g, opt::minEdgeWeight, opt::minContigLength, true);
1126	1138	// Print assembly contiguity statistics.
1127	1139	if (opt::verbose > 0)

1131	1143	} else {
1132	1144	ScaffoldResult best(0, 0, 0, "");
1133	1145	switch (opt::searchStrategy) {
1134		case GRID_SEARCH:
1135		best = optimize_grid_search(g,
1136		std::make_pair(opt::minEdgeWeight, opt::minEdgeWeightEnd),
1137		std::make_pair(opt::minContigLength, opt::minContigLengthEnd));
1138		break;
1139		case LINE_SEARCH:
1140		best = optimize_line_search(g,
1141		std::make_pair(opt::minEdgeWeight, opt::minEdgeWeightEnd),
1142		std::make_pair(opt::minContigLength, opt::minContigLengthEnd));
1143		break;
1144		default:
1145		abort();
1146		break;
	1146	case GRID_SEARCH:
	1147	best = optimize_grid_search(
	1148	g,
	1149	std::make_pair(opt::minEdgeWeight, opt::minEdgeWeightEnd),
	1150	std::make_pair(opt::minContigLength, opt::minContigLengthEnd));
	1151	break;
	1152	case LINE_SEARCH:
	1153	best = optimize_line_search(
	1154	g,
	1155	std::make_pair(opt::minEdgeWeight, opt::minEdgeWeightEnd),
	1156	std::make_pair(opt::minContigLength, opt::minContigLengthEnd));
	1157	break;
	1158	default:
	1159	abort();
	1160	break;
1147	1161	}
1148	1162
1149	1163	if (opt::verbose > 0)

1157	1171	std::cerr << best.metrics;
1158	1172	}
1159	1173
1160		std::cerr << '\n' << "Best scaffold N50 is " << best.n50 << " at n=" << best.n << " s=" << best.s << ".\n";
	1174	std::cerr << '\n'
	1175	<< "Best scaffold N50 is " << best.n50 << " at n=" << best.n << " s=" << best.s
	1176	<< ".\n";
1161	1177
1162	1178	// Print assembly contiguity statistics.
1163	1179	std::cerr << '\n';

-2

Sealer/README.md less more

23	23	Description
24	24	===========
25	25
26		Sealer is an application of Konnector that closes intra-scaffold gaps. It performs three sequential functions. First, regions with Ns are identified from an input scaffold. Flanking nucleotues (2 x 100bp) are extracted from those regions while respecting the strand (5' to 3') direction on the sequence immediately downstream of each gap. In the second step, flanking sequence pairs are used as input to Konnector along with a set of reads with a high level of coverage redundancy. Ideally, the reads should represent the original dataset from which the draft assembly is generated, or further whole genome shotgun (WGS) sequencing data generated from the same sample. Within Konnector, the input WGS reads are used to populate a Bloom filter, tiling the reads with a sliding window of length k, thus generating a probabilistic representation of all the k-mers in the reads. Konnector also uses crude error removal and correctional algorithms, eliminating singletons (k-mers that are observed only once) and fixing base mismatches in the flanking sequence pairs. Sealer launches Konnector processes using a user-input range of k-mer lengths. In the third and final operation, succesfully merged sequences are inserted into the gaps of the original scaffolds, and Sealer outputs a new gap-filled scaffold file.
	26	Sealer is an application of Konnector that closes intra-scaffold gaps. It performs three sequential functions. First, regions with Ns are identified from an input scaffold. Flanking nucleotues (2 x 100bp) are extracted from those regions while respecting the strand (5' to 3') direction on the sequence immediately downstream of each gap. In the second step, flanking sequence pairs are used as input to Konnector along with a set of reads with a high level of coverage redundancy. Ideally, the reads should represent the original dataset from which the draft assembly is generated, or further whole genome shotgun (WGS) sequencing data generated from the same sample. Within Konnector, the input WGS reads are used to populate a Bloom filter, tiling the reads with a sliding window of length k, thus generating a probabilistic representation of all the k-mers in the reads. Konnector also uses crude error removal and correctional algorithms, eliminating singletons (k-mers that are observed only once) and fixing base mismatches in the flanking sequence pairs. Sealer launches Konnector processes using a user-input range of k-mer lengths. In the third and final operation, successfully merged sequences are inserted into the gaps of the original scaffolds, and Sealer outputs a new gap-filled scaffold file.
27	27
28	28	Installation
29	29	============

158	158	* `--help`: display this help and exit
159	159	* `--version`: output version information and exit
160	160
161		k is the size of k-mer for the de Bruijn graph. You may specify multiple values of k, which will increase the nubmer of gaps closed at the cost of increased run time. Multiple values of k ought to be specified in increasing order, as lower values of k have fewer coverage gaps and are less likely to misassemble.
	161	k is the size of k-mer for the de Bruijn graph. You may specify multiple values of k, which will increase the number of gaps closed at the cost of increased run time. Multiple values of k ought to be specified in increasing order, as lower values of k have fewer coverage gaps and are less likely to misassemble.
162	162
163	163	P is the threshold for number of paths allowed to be traversed. When set to 10, Konnector will attempt to close gaps even when there are 10 different paths found. It would attempt to create a consensus sequence between these paths. The default setting is 2.

-1

Sealer/sealer.cc less more

70	70	" --print-flanks outputs flank files\n"
71	71	" -S, --input-scaffold=FILE load scaffold from FILE\n"
72	72	" -L, --flank-length=N length of flanks to be used as pseudoreads [100]\n"
73		" -D, --flank-distance=N distance of flank from gap [0]\n"
74	73	" -G, --max-gap-length=N max gap size to fill in bp [800]; runtime increases\n"
75	74	" exponentially with respect to this parameter\n"
76	75	" -j, --threads=N use N parallel threads [1]\n"

-1

bin/abyss-pe less more

397	397	@echo 'Report bugs to https://github.com/bcgsc/abyss/issues or abyss-users@bcgsc.ca.'
398	398
399	399	version:
400		@echo "abyss-pe (ABySS) 2.2.3"
	400	@echo "abyss-pe (ABySS) 2.2.4"
401	401	@echo "Written by Shaun Jackman and Anthony Raymond."
402	402	@echo
403	403	@echo "Copyright 2012 Canada's Michael Smith Genome Science Centre"

-1

configure.ac less more

0	0	AC_PREREQ(2.62)
1		AC_INIT(ABySS, 2.2.3, abyss-users@bcgsc.ca, abyss,
	1	AC_INIT(ABySS, 2.2.4, abyss-users@bcgsc.ca, abyss,
2	2	http://www.bcgsc.ca/platform/bioinfo/software/abyss)
3	3
4	4	AC_CONFIG_MACRO_DIR([m4])

-1

doc/ABYSS.1 less more

0		.TH ABYSS "1" "2015-May" "ABYSS (ABySS) 2.2.3" "User Commands"
	0	.TH ABYSS "1" "2015-May" "ABYSS (ABySS) 2.2.4" "User Commands"
1	1	.SH NAME
2	2	ABYSS \- assemble short reads into contigs
3	3	.SH SYNOPSIS

-3

doc/abyss-pe.1 less more

0		.TH abyss-pe "1" "2015-May" "abyss-pe (ABySS) 2.2.3" "User Commands"
	0	.TH abyss-pe "1" "2015-May" "abyss-pe (ABySS) 2.2.4" "User Commands"
1	1	.SH NAME
2	2	abyss-pe - assemble reads into contigs
3	3	.SH SYNOPSIS

112	112	SS=--SS to assemble in strand-specific mode
113	113	.br
114	114	Requires that all libraries are strand-specific RNA-Seq libraries.
115		Assumes that the first read in a read pair is reveresed WRT the
	115	Assumes that the first read in a read pair is reversed WRT the
116	116	transcripts sequenced.
117	117	.TP
118	118	.B t

241	241
242	242	.SS "MPI COMPATIBILITY"
243	243	Due to its use of multi-threading, DIDA has known deadlocking issues
244		with OpenMPI. Using the MPICH MPI library is strongly recommmended
	244	with OpenMPI. Using the MPICH MPI library is strongly recommended
245	245	when running assemblies with DIDA. Testing was done with MPICH 3.1.3,
246	246	compiled with --enable-threads=funneled.
247	247

-1

doc/abyss-tofastq.1 less more

0		.TH abyss-tofastq "1" "2015-May" "ABySS 2.2.3" "User Commands"
	0	.TH abyss-tofastq "1" "2015-May" "ABySS 2.2.4" "User Commands"
1	1	.SH NAME
2	2	abyss-tofastq \- convert various file formats to FASTQ format
3	3	.br