ngs_server 0.1 → 0.2

data/ext/vcftools/cpp/vcf_entry.h

@@ -0,0 +1,190 @@
+/*
+ * vcf_entry.h
+ *
+ *  Created on: Aug 19, 2009
+ *      Author: Adam Auton
+ *      ($Revision: 230 $)
+ */
+
+#ifndef VCF_ENTRY_H_
+#define VCF_ENTRY_H_
+
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <cassert>
+
+#include "output_log.h"
+
+using namespace std;
+
+enum Type_enum {Integer=0, Float=1, Character=2, String=3, Flag=4};
+
+class Field_description
+{
+public:
+	string ID;
+	int N_entries;
+	Type_enum Type;
+	string Description;
+
+	Field_description() : ID(""), N_entries(0), Type(Integer), Description("") {};
+	~Field_description() {};
+};
+
+class vcf_entry {
+public:
+	vcf_entry(const unsigned int N_indv);
+	vcf_entry(const unsigned int N_indv, const string &data_line);
+	~vcf_entry();
+
+	const unsigned int N_indv;
+
+	void parse_basic_entry(bool parse_ALT=false, bool parse_FILTER=false, bool parse_INFO=false);
+	void parse_full_entry(bool parse_FORMAT=true);
+	void parse_genotype_entry(unsigned int indv, bool GT=false, bool GQ=false, bool DP=false, bool FT=false);
+	void parse_genotype_entries(bool GT=false, bool GQ=false, bool DP=false, bool FT=false);
+
+	void reset(const string &vcf_data_line);
+
+	string get_CHROM() const;
+	void get_CHROM(string &out) const;
+	int get_POS() const;
+	string get_ID() const;
+	string get_REF() const;
+	string get_ALT() const;
+	string get_ALT_allele(int allele_num) const;
+	void get_allele(int allele_num, string &out) const;
+	void get_alleles_vector(vector<string> &out) const;
+	string get_FILTER() const;
+	void get_FILTER_vector(vector<string> &out) const;
+	double get_QUAL() const;
+	string get_INFO(const set<string> &INFO_to_keep) const;
+	string get_INFO_value(const string &key) const;
+	string get_FORMAT() const;
+	void get_indv_GENOTYPE_ids(unsigned int indv, pair<int, int> &out) const;
+	void get_indv_GENOTYPE_strings(unsigned int indv, pair<string, string> &out) const;
+	char get_indv_PHASE(unsigned int indv) const;
+	double get_indv_GQUALITY(unsigned int indv) const;
+	int get_indv_DEPTH(unsigned int indv) const;
+	void get_indv_GFILTER(unsigned int indv, string &out) const;
+	void get_indv_GFILTER_vector(unsigned int indv, vector<string> &out) const;
+	int get_indv_ploidy(unsigned int indv) const;
+
+	bool is_SNP() const;
+	bool is_biallelic_SNP() const;
+	bool is_diploid(const vector<bool> &include_indv, const vector<bool> &include_genotype) const;
+
+	void read_indv_generic_entry(unsigned int indv, const string &FORMAT_id, string &out);
+	bool FORMAT_id_exists(const string &FORMAT_id);
+
+	unsigned int get_N_alleles() const;
+	unsigned int get_N_chr(const vector<bool> &include_indv, const vector<bool> &include_genotype) const;
+
+	void set_CHROM(const string &in);
+	void set_POS(const int in);
+	void set_ID(const string &in);
+	void set_REF(const string &in);
+	void set_ALT(const string &in);
+	void set_QUAL(const double in);
+	void set_FILTER(const string &FILTER_str);
+	void set_FORMAT(const string &in);
+	void set_INFO(const string &INFO_str);
+
+	void add_ALT_allele(const string &in);
+	void add_FILTER_entry(const string &in);
+	void add_FORMAT_entry(const string &in, unsigned int pos);
+
+	void set_indv_GENOTYPE_and_PHASE(unsigned int indv, const string &in);
+	void set_indv_GENOTYPE_and_PHASE(unsigned int indv, const pair<string, string> &genotype, char phase);
+	void set_indv_GENOTYPE_and_PHASE(unsigned int indv, const pair<int, int> &genotype, char phase);
+	void set_indv_GENOTYPE_alleles(unsigned int indv, const pair<string, string> &in);
+	void set_indv_GENOTYPE_alleles(unsigned int indv, char a1, char a2);
+	void set_indv_GENOTYPE_ids(unsigned int indv, const pair<int, int> &in);
+	void set_indv_PHASE(unsigned int indv, char in);
+	void set_indv_GQUALITY(unsigned int indv, double in);
+	void set_indv_DEPTH(unsigned int indv, int in);
+	void set_indv_GFILTER(unsigned int indv, const string &in);
+
+	void add_indv_GFILTER(unsigned int indv, const string &in);
+
+	static void add_INFO_descriptor(const string &in);
+	static void add_FILTER_descriptor(const string &in);
+	static void add_FORMAT_descriptor(const string &in);
+
+	void print(ostream &out);
+	void print(ostream &out, const set<string> &INFO_to_keep, bool keep_all_INFO=false);
+	void print(ostream &out, const set<string> &INFO_to_keep, bool keep_all_INFO, const vector<bool> &include_indv, const vector<bool> &include_genotype);
+
+	void filter_genotypes_by_depth(vector<bool> &include_genotype_out, int min_depth, int max_depth);
+	void filter_genotypes_by_quality(vector<bool> &include_genotype_out, double min_genotype_quality);
+	void filter_genotypes_by_filter_status(vector<bool> &include_genotype_out, const set<string> &filter_flags_to_remove, bool remove_all = false);
+
+	void get_allele_counts(vector<int> &out, unsigned int &N_non_missing_chr_out, const vector<bool> &include_indv, const vector<bool> &include_genotype) const;
+	void get_genotype_counts(const vector<bool> &include_indv, const vector<bool> &include_genotype, unsigned int &out_N_hom1, unsigned int &out_N_het, unsigned int &out_N_hom2) const;
+
+	static double SNPHWE(int obs_hets, int obs_hom1, int obs_hom2);
+private:
+	istringstream data_stream;
+
+	bool basic_parsed;
+	bool fully_parsed;
+	bool parsed_ALT;
+	bool parsed_FILTER;
+	bool parsed_INFO;
+	bool parsed_FORMAT;
+
+	string CHROM;
+	int POS;
+	string ID;
+	string REF;
+	vector<string> ALT;
+	double QUAL;
+	vector<string> FILTER;
+	bool passed_filters;
+	vector<pair<string, string> > INFO;
+	vector<string> FORMAT;
+
+	vector< pair<int,int> > GENOTYPE;
+	vector<int> ploidy;
+	vector<char>  PHASE;
+	vector<double> GQUALITY;
+	vector<int>   DEPTH;
+	vector< vector<string> > GFILTER;
+
+	vector<bool> parsed_GT;
+	vector<bool> parsed_GQ;
+	vector<bool> parsed_DP;
+	vector<bool> parsed_FT;
+
+	int GT_idx;
+	int GQ_idx;
+	int DP_idx;
+	int FT_idx;
+
+	string ALT_str, FILTER_str, INFO_str, FORMAT_str, QUAL_str;
+	vector<string> GENOTYPE_str;
+
+	map<string, unsigned int> FORMAT_to_idx;
+
+	static map<string, Field_description> INFO_map;
+	static map<string, string> FILTER_map;
+	static map<string, Field_description> FORMAT_map;
+
+	static int str2int(const string &in, const int missing_value=-1);
+	static double str2double(const string &in, const double missing_value=-1.0);
+
+	static string int2str(const int in, const int missing_value=-1);
+	static string double2str(const double in, const double missing_value=-1.0);
+
+	static void tokenize(const string &in, char token, vector<string> &out);
+};
+
+#endif /* VCF_ENTRY_H_ */

data/ext/vcftools/cpp/vcf_entry_getters.cpp

@@ -0,0 +1,421 @@
+/*
+ * vcf_entry_getters.cpp
+ *
+ *  Created on: Nov 11, 2009
+ *      Author: Adam Auton
+ *      ($Revision: 230 $)
+ */
+
+#include "vcf_entry.h"
+
+// Return the CHROMosome name
+string vcf_entry::get_CHROM() const
+{
+	return CHROM;
+}
+
+// Return the CHROMosome name
+void vcf_entry::get_CHROM(string &out) const
+{
+	out = CHROM;
+}
+
+int vcf_entry::get_POS() const
+{
+	return POS;
+}
+
+string vcf_entry::get_ID() const
+{
+	if (ID.size() == 0)
+		return ".";
+	return ID;
+}
+
+string vcf_entry::get_REF() const
+{
+	return REF;
+}
+
+string vcf_entry::get_ALT() const
+{
+	assert(parsed_ALT == true);
+
+	string out;
+	if (ALT.size() == 0)
+		out = ".";
+	else
+	{
+		out = ALT[0];
+		for (unsigned int ui=1; ui<ALT.size(); ui++)
+			out += "," + ALT[ui];
+	}
+	return out;
+}
+
+bool vcf_entry::is_SNP() const
+{
+	assert(parsed_ALT == true);
+
+	if (REF.size() != 1)
+		return false;	// Reference isn't a single base
+
+	if (ALT.size() == 0)
+		return false;	// No alternative allele
+
+	for (unsigned int ui=0; ui<ALT.size(); ui++)
+		if (ALT[ui].size() != 1)
+			return false;	// Alternative allele isn't a single base
+
+	return true;
+}
+
+bool vcf_entry::is_biallelic_SNP() const
+{
+	assert(parsed_ALT == true);
+
+	if (REF.size() != 1)
+		return false;	// Reference isn't a single base
+
+	if (ALT.size() != 1)
+		return false;	// Not biallelic
+
+	if (ALT[0].size() != 1)
+		return false;	// Alternative allele isn't a single base
+
+	return true;
+}
+
+bool vcf_entry::is_diploid(const vector<bool> &include_indv, const vector<bool> &include_genotype) const
+{
+	for (unsigned int ui=0; ui<N_indv; ui++)
+	{
+		if ((include_indv[ui] == true) && (include_genotype[ui] == true))
+		{
+			assert(parsed_GT[ui] == true);
+			if (ploidy[ui] != 2)
+				return false;
+		}
+	}
+	return true;
+}
+
+void vcf_entry::get_allele(int allele_num, string &out) const
+{
+	assert(parsed_ALT == true);
+
+	if (allele_num == 0)
+		out = REF;
+	else if ((allele_num < 0) || (unsigned(allele_num - 1) >=  ALT.size()))
+		out = ".";
+	else
+		out = ALT[allele_num-1];
+}
+
+string vcf_entry::get_ALT_allele(int allele_num) const
+{
+	assert(parsed_ALT == true);
+
+	if ((allele_num < 0) || (unsigned(allele_num) >=  ALT.size()))
+		return ".";
+	return ALT[allele_num];
+}
+
+void vcf_entry::get_alleles_vector(vector<string> &out) const
+{
+	assert(parsed_ALT == true);
+	out.resize(ALT.size()+1);
+	out[0] = REF;
+	copy(ALT.begin(), ALT.end(), out.begin()+1);
+}
+
+double vcf_entry::get_QUAL() const
+{
+	return QUAL;
+}
+
+
+string vcf_entry::get_FILTER() const
+{
+	assert(parsed_FILTER == true);
+
+	ostringstream out;
+	if ((passed_filters == false) && (FILTER.size() == 0))
+		out << ".";
+	else if (passed_filters == true)
+		out << "PASS";
+	else
+	{
+		out << FILTER[0];
+		for (unsigned int ui=1; ui<FILTER.size(); ui++)
+		{
+			out << "," << FILTER[ui];
+		}
+	}
+	return out.str();
+}
+
+void vcf_entry::get_FILTER_vector(vector<string> &out) const
+{
+	assert(parsed_FILTER == true);
+	out = FILTER;
+}
+
+
+string vcf_entry::get_INFO(const set<string> &INFO_to_keep) const
+{
+	assert(parsed_INFO == true);
+
+	ostringstream out;
+	bool first=true;
+	if ((INFO.size() > 0) && (INFO_to_keep.size() > 0))
+	{
+		string key;
+		for (unsigned int ui=0; ui<INFO.size();ui++)
+		{
+			key = INFO[ui].first;
+			if (INFO_to_keep.find(key) != INFO_to_keep.end())
+			{
+				if (first != true)
+					out << ";";
+				out << key << "=" << INFO[ui].second;
+				first = false;
+			}
+		}
+	}
+
+	if (first == true)
+	{	// Didn't find any INFO fields to keep
+		out.str(".");
+	}
+	return out.str();
+}
+
+string vcf_entry::get_INFO_value(const string &key) const
+{
+	assert(parsed_INFO == true);
+
+	for (unsigned int ui=0; ui<INFO.size(); ui++)
+	{
+		if (INFO[ui].first == key)
+			return INFO[ui].second;
+	}
+	return "?";
+}
+
+string vcf_entry::get_FORMAT() const
+{
+	assert(parsed_FORMAT == true);
+
+	string out;
+	bool first = true;
+	for (unsigned int ui=0; ui<FORMAT.size(); ui++)
+	{
+		if (first == false)
+			out += ":";
+		out += FORMAT[ui];
+		first = false;
+	}
+	return out;
+}
+
+// Return the alleles of a genotype as a pair of strings.
+void vcf_entry::get_indv_GENOTYPE_strings(unsigned int indv, pair<string, string> &out) const
+{
+	assert(parsed_GT[indv] == true);
+
+	static string out_allele1, out_allele2;
+
+	get_allele(GENOTYPE[indv].first, out_allele1);
+	get_allele(GENOTYPE[indv].second, out_allele2);
+	out = make_pair(out_allele1, out_allele2);
+}
+
+
+void vcf_entry::get_indv_GENOTYPE_ids(unsigned int indv, pair<int, int> &out) const
+{
+	assert(parsed_GT[indv] == true);
+	out = GENOTYPE[indv];
+}
+
+char vcf_entry::get_indv_PHASE(unsigned int indv) const
+{
+	assert(parsed_GT[indv] == true);
+	return PHASE[indv];
+}
+
+int vcf_entry::get_indv_DEPTH(unsigned int indv) const
+{
+	assert(parsed_DP[indv] == true);
+	if (DEPTH.size() == 0)
+		return -1;
+	return DEPTH[indv];
+}
+
+double vcf_entry::get_indv_GQUALITY(unsigned int indv) const
+{
+	assert(parsed_GQ[indv] == true);
+	if (GQUALITY.size() == 0)
+		return -1;
+	return GQUALITY[indv];
+}
+
+void vcf_entry::get_indv_GFILTER_vector(unsigned int indv, vector<string> &out) const
+{
+	assert(parsed_FT[indv] == true);
+	if (GFILTER.size() > 0)
+		out = GFILTER[indv];
+	else
+		out.resize(0);
+}
+
+void vcf_entry::get_indv_GFILTER(unsigned int indv, string &out) const
+{
+	assert(parsed_FT[indv] == true);
+
+	if ((GFILTER.size() > 0) && (GFILTER[indv].size()>0))
+	{
+		out="";
+		for (unsigned int ui=0; ui<GFILTER[indv].size(); ui++)
+		{
+			if (ui!=0)
+				out += ";";
+			out += GFILTER[indv][ui];
+		}
+	}
+	else
+		out = ".";
+}
+
+int vcf_entry::get_indv_ploidy(unsigned int indv) const
+{
+	assert (parsed_GT[indv]==true);
+	return ploidy[indv];
+}
+
+void vcf_entry::read_indv_generic_entry(unsigned int indv, const string &FORMAT_id, string &out)
+{
+	if (fully_parsed == false)
+		parse_full_entry(true);
+
+	if (parsed_FORMAT == false)
+		set_FORMAT(FORMAT_str);
+
+	out = ".";
+
+	if (FORMAT_to_idx.find(FORMAT_id) != FORMAT_to_idx.end())
+	{
+		unsigned int idx = FORMAT_to_idx[FORMAT_id];
+		static string tmpstr;
+		static istringstream ss;
+		ss.clear();
+		ss.str(GENOTYPE_str[indv]);
+
+		for (unsigned int ui=0; ui <= idx; ui++)
+		{
+			getline(ss, tmpstr, ':');
+			if (ui == idx)
+			{
+				out = tmpstr;
+				break;
+			}
+			if (!ss.good())
+				break;
+		}
+	}
+}
+
+bool vcf_entry::FORMAT_id_exists(const string &FORMAT_id)
+{
+	assert(parsed_FORMAT == true);
+	if (FORMAT_to_idx.find(FORMAT_id) != FORMAT_to_idx.end())
+		return true;
+	return false;
+}
+
+unsigned int vcf_entry::get_N_alleles() const
+{
+	assert(parsed_ALT == true);
+	return (ALT.size()+1);
+}
+
+unsigned int vcf_entry::get_N_chr(const vector<bool> &include_indv, const vector<bool> &include_genotype) const
+{
+	unsigned int out=0;
+
+	for (unsigned int ui=0; ui<N_indv; ui++)
+	{
+		if ((include_indv[ui] == true) && (include_genotype[ui] == true))
+		{
+			assert(parsed_GT[ui] == true);
+			out += ploidy[ui];
+		}
+	}
+	return out;
+}
+
+
+// Return the frequency (counts) of each allele.
+void vcf_entry::get_allele_counts(vector<int> &out, unsigned int &N_non_missing_chr_out, const vector<bool> &include_indv, const vector<bool> &include_genotype) const
+{
+	pair<int,int> genotype;
+	vector<int> allele_counts(get_N_alleles(), 0);
+	N_non_missing_chr_out = 0;
+
+	for (unsigned int ui=0; ui<N_indv; ui++)
+	{
+		if ((include_indv[ui] == true) && (include_genotype[ui] == true))
+		{
+			assert(parsed_GT[ui] == true);
+			get_indv_GENOTYPE_ids(ui, genotype);
+			if (genotype.first != -1)
+			{
+				allele_counts[genotype.first]++;
+				N_non_missing_chr_out++;
+			}
+			if (genotype.second != -1)
+			{
+				allele_counts[genotype.second]++;
+				N_non_missing_chr_out++;
+			}
+		}
+	}
+	out = allele_counts;
+}
+
+// Return the counts of homozygote1, heterozygotes, and homozygote2
+void vcf_entry::get_genotype_counts(const vector<bool> &include_indv, const vector<bool> &include_genotype, unsigned int &out_N_hom1, unsigned int &out_N_het, unsigned int &out_N_hom2) const
+{
+	out_N_hom1 = 0; out_N_hom2 = 0; out_N_het = 0;
+	pair<int, int> genotype;
+	if (ALT.size() > 1)
+		error("Tried to return the genotype counts of a non-biallelic SNP", 99);
+
+	for (unsigned int ui=0; ui<N_indv; ui++)
+	{
+		if ((include_indv[ui] == true) && (include_genotype[ui] == true))
+		{
+			assert(parsed_GT[ui] == true);
+			get_indv_GENOTYPE_ids(ui, genotype);
+			if ((genotype.first != -1) && (genotype.second != -1))
+			{
+				if (genotype.first != genotype.second)
+				{
+					out_N_het++;
+				}
+				else if (genotype.first == 0)
+				{
+					out_N_hom1++;
+				}
+				else if (genotype.first == 1)
+				{
+					out_N_hom2++;
+				}
+				else
+				{
+					error("Unknown allele in genotype", 98);
+				}
+			}
+		}
+	}
+}