diff --git "a/data/dataset_Allele.csv" "b/data/dataset_Allele.csv" new file mode 100644--- /dev/null +++ "b/data/dataset_Allele.csv" @@ -0,0 +1,156076 @@ +"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language" +"Allele","Shuhua-Group/ArchaicSeeker2.0","examples.sh",".sh","162","2","./ArchaicSeeker2 -v examples/vcf.par -r examples/remap.par -m examples/model.txt -X examples/outgroup.par -p examples/pop.par -A examples/anc.par -o examples/Han +","Shell" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/104.ArchaicAllelePro/run.sh",".sh","151","2","../000.scripts/archaicAllelePro ../102.ArchaicConsist/Han.Neanderthal.chr22.txt.gz ../103.AF.anc/YRI.anc.txt.gz Han.Neanderthal.archaic.allele.pro.txt +","Shell" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/103.AF.anc/run.sh",".sh","193","5","zcat ../../examples/YRI.chr22.vcf.gz | ../000.scripts/getAF | gzip > YRI.af.txt.gz + +../000.scripts/annoAnc YRI.af.txt.gz ../../examples/homo_sapiens_ancestor 22 22 YRI.anc.txt +gzip YRI.anc.txt +","Shell" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/101.Seg/run.sh",".sh","165","3","../000.scripts/getSeg ind.txt Han_chr22.seg chr22 +cat chr22_Neanderthal.txt | ../000.scripts/segFiltMerge | ../000.scripts/con2gvcf | bgzip > Han_Neanderthal.vcf.gz +","Shell" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/102.ArchaicConsist/run.sh",".sh","165","3","../000.scripts/getArchaicCon ../../examples/Han.chr22.vcf.gz ../101.Seg/Han_Neanderthal.vcf.gz pops.txt Han Han.Neanderthal.chr22.txt +gzip Han.Neanderthal.chr22.txt +","Shell" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/000.scripts/getSeg.cpp",".cpp","2554","106","# include +# include +# include +# include +# include +# include + +using namespace std; + +class bed +{ + public: + long start, end; + double gstart, gend; +}; + +int main(int argc, char **argv) +{ + ifstream fpind(argv[1]); + map idCheck; + vector ids; + string tid, tpop; + while(fpind >> tid) + { + idCheck[tid + ""_1""] = ids.size(); + ids.push_back(tid + ""_1""); + idCheck[tid + ""_2""] = ids.size(); + ids.push_back(tid + ""_2""); + } + int nind = ids.size(); + vector > >data; + data.resize(nind); + ifstream fpi(argv[2]); + string line; + getline(fpi,line); + set labs; + map > pos; + string chr; + map gmap; + while(getline(fpi,line)) + { + istringstream cl(line); + bed t; + string lab; + cl >> tid >> chr >> t.start >> t.end >> t.gstart >> t.gend >> lab; + if(lab == ""YRI_Modern_Denisova_Neanderthal"" || lab == ""Denisova_Neanderthal"") + lab = ""Others""; + else if(lab != ""Denisova"" && lab != ""Neanderthal"") + continue; + if(idCheck.count(tid) == 0) + continue; + labs.insert(lab); + pos[lab].insert(t.start); + pos[lab].insert(t.end); + gmap[t.start] = t.gstart; + gmap[t.end] = t.gend; + data[idCheck[tid]][lab].push_back(t); + } + for(set::iterator it = labs.begin(); it != labs.end(); ++it) + { + if(pos.count(*it) == 0) + continue; + vector curPos(pos[*it].begin(), pos[*it].end()); + int npos = curPos.size(); + vector > mat; + mat.resize(npos - 1); + for(int i = 0 ; i < npos - 1; ++i) + mat[i].resize(nind, 0); + for(int i = 0 ; i < nind; ++i) + { + if(data[i].count(*it) == 0) + continue; + vector& curBed(data[i][*it]); + int p(0); + int nbed(curBed.size()); + for(int j = 0 ; j < npos - 1; ++j) + { + if(p == nbed) + break; + long start = curPos[j]; + long end = curPos[j + 1]; + if(curBed[p].start > end) + continue; + else if(curBed[p].start <= start && curBed[p].end >=end) + mat[j][i] = 1; + if(curBed[p].end == end) + ++p; + } + } + string out(argv[3]); + string path = out + ""_"" + *it + "".txt""; + ofstream fpo(path.c_str()); + fpo << ""Contig\tStart(bp)\tEnd(bp)\tStart(cM)\tEnd(cM)""; + for(int i = 0 ; i < nind ; i += 2) + fpo << '\t' << ids[i].substr(0,ids[i].size() - 2); + fpo << endl; + for(int i = 0 ; i < npos - 1; ++i) + { + fpo << chr << '\t' << curPos[i] << '\t' << curPos[i + 1] << '\t' << gmap[curPos[i]] << '\t' << gmap[curPos[i+1]]; + for(int j = 0 ; j < nind ; j += 2) + fpo << '\t' << mat[i][j] << ""|"" << mat[i][j + 1]; + fpo << endl; + } + } +} +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/000.scripts/segFiltMerge.cpp",".cpp","417","27","# include +# include +# include +# include + +using namespace std; + +int main() +{ + string line, tmp; + getline(cin,line); + cout << line << endl; + while(getline(cin,line)) + { + if(line[0] == 'C') + continue; + istringstream cl(line); + cl >> tmp >> tmp >> tmp >> tmp >> tmp; + while(cl >> tmp) + if(tmp[0] == '1' || tmp[2] == '1') + { + cout << line << endl; + break; + } + } +} +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/000.scripts/archaicAllelePro.cpp",".cpp","2133","90","# include +# include +# include +# include +# include + +using namespace std; + +class snp +{ + public: + long pos; + char ref, alt, anc; + int nafr, sumafr; +}; + +const int MAX = 4096 * 16; + +double power(0.95); + +int main(int argc, char **argv) +{ + gzFile fdt, fdafr; + fdt = gzopen(argv[1], ""rb""); + fdafr = gzopen(argv[2], ""rb""); + ofstream fpo(argv[3]); + vector > data; + data.resize(23); + char buff[MAX]; + gzgets(fdafr, buff, MAX); + snp tsnp; + while(gzgets(fdafr, buff, MAX)) + { + istringstream cl(buff); + int chr; + cl >> chr >> tsnp.pos >> tsnp.ref >> tsnp.alt >> tsnp.anc >> tsnp.nafr >> tsnp.sumafr; + data[chr].push_back(tsnp); + } + fpo << ""CHR\tPOS\tREF\tALT\tANC\tAncConfid\tAfrDerFreq\tArchaicDerFreq\tModDerFreq\tArchaicAlleleProb"" << endl; + gzgets(fdt, buff, MAX); + vector count; + count.resize(23, 0); + while(gzgets(fdt, buff, MAX)) + { + istringstream cl(buff); + int chr; + long pos; + char ref, alt; + int nas, sumas, nmod, summod, sum; + cl >> chr >> pos >> ref >> alt >> nas >> sumas >> nmod >> summod >> sum; + if(sumas == 0 || nas == 0) + continue; + while(count[chr] < data[chr].size() && data[chr][count[chr]].pos < pos) + ++count[chr]; + if(data[chr][count[chr]].pos > pos || count[chr] == data[chr].size()) + continue; + if(data[chr][count[chr]].pos == pos) + { + snp& cur(data[chr][count[chr]]); + int state(0); + if(cur.ref == ref && cur.alt == alt) + { + char anc(cur.anc); + anc &= ~' '; + if(anc == cur.ref) + state = 0; + else if(anc == cur.alt) + state = 1; + else + state = -9; + fpo << chr << '\t' << pos << '\t' << ref << '\t' << alt << '\t' << cur.anc << '\t' << state; + double afrf, archf, modf, pro; + afrf = (double) cur.nafr / cur.sumafr; + archf = (double) nas / sumas; + modf = (double) nmod / summod; + if(state == 1) + { + afrf = 1 - afrf; + archf = 1 - archf; + modf = 1 - modf; + } + if(nmod == 0) + modf = 0; + pro = ( modf * ( 1 - power ) + 1 - modf ) * ( afrf * 0.003 + 1 - afrf ); + fpo << '\t' << afrf << '\t' << archf << '\t' << modf << '\t' << pro << endl; + } + } + } +} +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/000.scripts/con2gvcf.cpp",".cpp","708","32","# include +# include +# include +# include + +using namespace std; + +int main() +{ + cout << ""#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT""; + string line; + getline(cin,line); + istringstream head(line); + head >> line >> line >> line >> line >> line; + int nind(0); + while(head >> line) + cout << '\t' << line; + cout << endl; + while(getline(cin,line)) + { + istringstream cl(line); + string chr; + long start, end; + double gstart, gend; + cl >> chr >> start >> end >> gstart >> gend; + cout << chr << '\t' << start << ""\t.\t.\t.\t.\tGenetDis:"" << gstart << ""-"" << gend << ""\tEND="" << end - 1 << ""\tGT""; + while(cl >> line) + cout << '\t' << line; + cout << endl; + } +} +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/000.scripts/annoAnc.cpp",".cpp","1248","54","# include +# include +# include +# include +# include +# include + +using namespace std; + +const int MAX = 4096 * 16; + +int main(int argc, char **argv) +{ + gzFile fdaf; + fdaf = gzopen(argv[1], ""rb""); + string pre(argv[2]); + int chr_start = stoi(argv[3]); + int chr_end = stoi(argv[4]); + ofstream fpo(argv[5]); + vector > anc; + anc.resize(23); + char buff[MAX]; + for(int i = chr_start; i <= chr_end; ++i) + { + ostringstream path; + path << pre << ""_"" << i << "".fa.gz""; + gzFile fdanc; + fdanc = gzopen(path.str().c_str(), ""rb""); + gzgets(fdanc, buff, MAX); + while(gzgets(fdanc, buff, MAX)) + { + string line(buff); + anc[i].push_back(line); +// cout << line.size() << endl; + } + gzclose(fdanc); + } + int n(anc[chr_start].front().size() - 1); + fpo << ""CHR\tPOS\tREF\tALT\tANC\tN\tSum"" << endl; + gzgets(fdaf, buff, MAX); + while(gzgets(fdaf, buff, MAX)) + { + istringstream cl(buff); + int chr; + long pos; + string ref, alt, num, sum; + cl >> chr >> pos >> ref >> alt >> num >> sum; + char a(anc[chr][(pos - 1) / n][(pos - 1) % n]); + //char b(anc[chr][pos / n][pos % n]); + + fpo << chr << '\t' << pos << '\t' << ref << '\t' << alt << '\t' << a << '\t' << num << '\t' << sum << endl; + } +} +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/000.scripts/getArchaicCon.cpp",".cpp","3295","181","/* + * getArchaicMK.cpp + * + * Created on: Mar 9, 2020 + * Author: kyuan + */ + +# include +# include +# include +# include +# include +# include +# include +# include +# include ""boost/dynamic_bitset.hpp"" + +using namespace std; + +class reg +{ +public: + int chr; + long start, end; + boost::dynamic_bitset<> snp; +}; + +class pos +{ +public: + int chr; + long p; + string ref, alt; + boost::dynamic_bitset<> snp; +}; + +//-1 pos < reg; 0 pos -> reg; 1 pos > reg +int cmp(const pos& p, const reg& r) +{ + if(p.chr < r.chr) + return -1; + if(p.chr > r.chr) + return 1; + if(p.p < r.start) + return -1; + if(p.p > r.end) + return 1; + return 0; +} + +int cmp(const pos& p1, const pos& p2) +{ + if(p1.chr < p2.chr) + return -1; + if(p1.chr > p2.chr) + return 1; + if(p1.p < p2.p) + return -1; + if(p1.p > p2.p) + return 1; + return 0; +} + +const int MAX = 4096 * 16; + +int main(int argc, char **argv) +{ + gzFile fptest, fpas; + fptest = gzopen(argv[1], ""rb""); + fpas = gzopen(argv[2], ""rb""); + ifstream fpind(argv[3]); + string pop(argv[4]); + ofstream fpo(argv[5]); + + set ids; + string id, p; + while(fpind >> id >> p) + if(p == pop) + ids.insert(id); + + map check; + vector sel; + char buff[MAX]; + gzgets(fpas, buff, MAX); + istringstream ashead(buff); + string line; + for(int i = 0 ; i < 9 ; ++i) + ashead >> line; + int n(0); + while(ashead >> line) + if(ids.count(line)) + { + check[line] = n; + ++n; + sel.push_back(1); + } + else + sel.push_back(0); + vector asReg; + reg treg; + treg.snp.resize(n * 2); + while(gzgets(fpas, buff, MAX)) + { + istringstream cl(buff); + treg.snp.reset(); + cl >> treg.chr >> treg.start >> line >> line >> line >> line >> line >> line; + treg.end = atol(line.substr(4).c_str()); + cl >> line; + int m(0); + for(int i = 0 ; i < sel.size() ; ++i) + { + cl >> line; + if(sel[i]) + { + if(line[0] == '1') + treg.snp.set(m * 2); + if(line[2] == '1') + treg.snp.set(m * 2 + 1); + ++m; + } + } + asReg.push_back(treg); + } + + while(gzgets(fptest, buff, MAX)) + if(buff[1] != '#') + break; + istringstream head(buff); + for(int i = 0 ; i < 9 ; ++i) + head >> line; + vector index; + int count(0); + while(head >> id) + { + if(check.count(id)) + index.push_back(check[id]); + else + index.push_back(-1); + } + pos tpos; + tpos.snp.resize(n * 2); + int s(0); + fpo << ""CHR\tPos\tRef\tAlt\tAltArchaic\tNArchaic\tAltMod\tNMod\tSum"" << endl; + while(gzgets(fptest, buff, MAX)) + { + istringstream cl(buff); + cl >> tpos.chr >> tpos.p >> line >> tpos.ref >> tpos.alt >> line >> line >> line >> line; + tpos.snp.reset(); + for(int i = 0 ; i < index.size(); ++i) + { + cl >> line; + if(index[i] >= 0) + { + if(line[0] == '1') + tpos.snp.set(index[i] * 2); + if(line[2] == '1') + tpos.snp.set(index[i] * 2 + 1); + } + } + int c(cmp(tpos, asReg[s])); + if(c == -1) + continue; + while(c == 1) + { + ++s; + if(s == asReg.size()) + break; + if(cmp(tpos, asReg[s]) <= 0) + break; + } + if(s == asReg.size()) + break; + if(c == 0) + { + fpo << tpos.chr<<'\t' << tpos.p << '\t' << tpos.ref << '\t' << tpos.alt << '\t' << (tpos.snp & asReg[s].snp).count() << '\t' << asReg[s].snp.count() << '\t' << (tpos.snp & (~asReg[s].snp) ).count() << '\t' << (~asReg[s].snp).count() << '\t' << n * 2 << endl; + } + } +} + + +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","ArchaicAllele/000.scripts/getAF.cpp",".cpp","1365","79","# include +# include +# include +# include +# include +# include + +using namespace std; + +int main(int argc, char **argv) +{ + bool all(false); + if(argc >= 2) + all = true; + ifstream fpind; + if(!all) + fpind.open(argv[1]); + set ids; + string id; + vector check; + string line; + cout << ""#CHR\tPOS\tREF\tALT\tN\tSum"" << endl; + while(getline(cin, line)) + if(line[1] != '#') + break; + istringstream head(line); + + if(all) + { + while(fpind >> id) + ids.insert(id); + for(int i = 0 ; i < 9 ; ++i) + head >> line; + while(head >> id) + if(ids.count(id)) + check.push_back(1); + else + check.push_back(0); + } + else + { + for(int i = 0 ; i < 9 ; ++i) + head >> line; + while(head >> id) + check.push_back(1); + } + while(getline(cin, line)) + { + istringstream cl(line); + if(line[0] == '#') + continue; + string chr, pos, ref, alt; + cl >> chr >> pos >> line >> ref >> alt >> line >> line >> line >> line; + int n(0), sum(0); + for(int i = 0 ; i < check.size(); ++i) + { + cl >> line; + if(check[i]) + { + if(line[0] == '1') + { + ++n; + ++sum; + } + else if(line[0] == '0') + ++sum; + if(line[2] == '1') + { + ++n; + ++sum; + } + else if(line[2] == '0') + ++sum; + } + } + cout << chr << '\t' << pos << '\t' << ref << '\t' << alt << '\t' << n << '\t' << sum << endl; + } +} +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","WaveEstimate/getAS2Seg/getAS2Seg.cpp",".cpp","3358","148","# include +# include +# include +# include +# include +# include +# include +# include +# include + +using namespace std; + +const int MAX = 4096 * 256; + +class gmap +{ + public: + string gmapPath; + gmap(string gmapPath): gmapPath(gmapPath) + { + pos.resize(23); + gdis.resize(23); + mem.resize(23); + for(int i = 1 ; i <= 22 ; ++i) + { + ostringstream path; + path << gmapPath << ""/genetic_map_chr"" << i << ""_combined_b37.txt""; + ifstream fpi(path.str().c_str()); + vector &curPos(pos[i]); + vector &curGdis(gdis[i]); + curPos.clear(); + curGdis.clear(); + string line; + fpi >> line >> line >> line; + long tpos; + double tgdis; + while(fpi >> tpos >> line >> tgdis) + { + curPos.push_back(tpos); + curGdis.push_back(tgdis); + } + } + } + double search(int chr, long p) + { + if(mem[chr].count(p)) + return mem[chr][p]; + const vector& curPos(pos[chr]); + const vector& curGdis(gdis[chr]); + int start(0), end(curPos.size() - 1); + int mid; + while(end - start > 1) + { + mid = (end + start) / 2; + if(curPos[mid] > p) + end = mid; + else if(curPos[mid] < p) + start = mid; + else + { + mem[chr][p] = curGdis[mid]; + return curGdis[mid]; + } + } + while(start < curPos.size() && curPos[start] < p) + ++start; + if(start == curPos.size()) + { + mem[chr][p] = curGdis.back(); + return curGdis.back(); + } + else if(start <= 1) + { + mem[chr][p] = curGdis.front(); + return curGdis.front(); + } + --start; + double r = curGdis[start] + ( p - curPos[start] ) * ( curGdis[start + 1] - curGdis[start] ) / ( curPos[start + 1] - curPos[start] ); + mem[chr][p] = r; + return r; + } + vector > mem; + vector > pos; + vector > gdis; +}; + +class bed +{ + public: + int chr; + long start, end; + double gstart, gend; + string id; +}; + +int main(int argc, char **argv) +{ + string gmapPath(argv[1]); + gmap g(gmapPath); + ifstream fpi(argv[2]); + string out(argv[3]); + set check; + for(int i = 3; i < argc ; ++i) + check.insert(argv[i]); + string line; + getline(fpi,line); + map > > segs; + while(getline(fpi, line)) + { + istringstream cl(line); + string lab; + bed tbed; + cl >> tbed.id >> tbed.chr >> tbed.start >> tbed.end >> line >> line >> lab; + if(!check.count(lab)) + continue; + tbed.gstart = g.search(tbed.chr, tbed.start); + tbed.gend = g.search(tbed.chr, tbed.end); + segs[tbed.id].resize(23); + segs[tbed.id][tbed.chr].push_back(tbed); + } + string path; + path = out + "".seg""; + ofstream fpo(path.c_str()); + fpo << setprecision(20); + + for(map > >::iterator it = segs.begin(); it != segs.end(); ++it) + { + for(int i = 1 ; i <= 22 ; ++i) + { + const vector & curData(it->second.at(i)); + if(curData.size() ==0) + continue; + double gstart(g.gdis[i].front()); + long start(g.pos[i].front()); + for(int j = 0 ; j < curData.size(); ++j) + { + fpo << gstart / 100 << '\t' << curData[j].gstart / 100 << ""\tModern"" << endl; + fpo << curData[j].gstart / 100 << '\t' << curData[j].gend / 100 << ""\tArchaic"" << endl; + gstart = curData[j].gend; + start = curData[j].end; + } + fpo << gstart / 100 << '\t' << g.gdis[i].back() / 100 << ""\tModern"" << endl; + } + } +} + + +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","WaveEstimate/MultiWaver2.1/ParamExp.hpp",".hpp","2777","124","/* + * ParamExp.hpp + * + * Created on: May 26, 2015 + * Author: young + */ +/****************************************************************************** + * @brief Parameters of EM + * Class ParamExp to store the parameters of EM + * Here assume the observations are from the combination of K sets of numbers + * which following exponential distributions, with parameters lambda[j], and the + * mix proportions prop[j], the purpose of EM is used to estimate the parameters + * lambda[j] and mix proportions[j], where j in [1,2,...,K] + *****************************************************************************/ + +#ifndef PARAMEXP_HPP_ +#define PARAMEXP_HPP_ + +//const double kDelta = 0.000001; //converge condition + +# include + +class ParamExp +{ +public: + + /* + * @brief Constructor with given value K + * @param K number of exponential distribution + */ + ParamExp(int K = 1); + + ParamExp(int K, std::vector observ); + + /* + * @brief Constructor with given value K, lambdas and proportions + * @param K number of exponential distribution + * @param lambda initial value of lambda + * @param prop initial value of proportions + */ + ParamExp(int K, double *lambda, double *prop); + + /* + * @brief Copy constructor + * @param rhs old parameter + */ + ParamExp(const ParamExp &rhs); + + /* + * @brief overloading of operator = + * @param rhs old parameter + */ + ParamExp & operator=(const ParamExp &rhs); + + /* + * @brief get the number of exponential distributions + * @return integer number + */ + int getK() const; + + /* + * @brief get the value of lambda with given index + * @param index the exponential distribution + * @return the value of lambda + */ + double getLambda(int index) const; + + /* + * @brief get the value of proportion with given index + * @param index the exponential distribution + * @return the value of proportion + */ + double getProp(int index) const; +// void setK(int); +// void setLambda(int index, double lambda); + + /* + * set the Proportion at index + */ + void setProp(int index, double prop); + + /* + * @brief check if the parameter is converged + * @param par old parameter + * @param epsilon epsilon to check whether a parameter converge or not + * @return true if is converged + */ + bool isConverge(const ParamExp &par, double epsilon = 0.000001); + + /* + * @brief sort the parameter by lambda in ascend order + */ + void sortByLambda(); + + /* + * @brief print the value of parameters + */ + void print(); + + /* + * @brief destructor + */ + virtual ~ParamExp(); + +private: + + /* + * number of exponential distributions + */ + int K; + + /* + * parameter lambdas for exponential distributions + */ + double *lambda; + + /* + * mix proportions for exponential distributions + */ + double *prop; +}; + +#endif /* PARAMEXP_HPP_ */ +","Unknown" +"Allele","Shuhua-Group/ArchaicSeeker2.0","WaveEstimate/MultiWaver2.1/EMExp.hpp",".hpp","2944","119","/* + * EMExp.hpp + * + * Created on: May 26, 2015 + * Author: young + */ +/****************************************************************************** + * @brief A class perform EM + * Class EMExp to perform EM algorithm in parameters estimation with hidden variable + * The EMExp class has three attributes: + * 1) parameters to be estimated; + * 2) a sequence of observations, which used to estimate the parameters; + * 3) and the likelihood corresponding to the observations and parameters. + + * The method iterate is used to perform EM algorithm, including two steps: + * E-Step: + * 1) calculate p_j=prob(z_i=j|x_i, theta_t) + * =prob(x_i|z_i=j,theta_t)*prob(z_i=j,theta_t)/(sum_j{from 1 to K}(.) + * denotes the numerator + * 2) calculate p_j*xi ; j=1,...,K + * theta_t: parameters at the t-th iteration + * M-Step: + * 1) update prop, refer as m, m_j=sum(p_j)/sum(p_1+p_2+...+p_K)=sum(p_j)/n + * 2) update lambda, lambda_j=sum(p_j)/sum(p_j*x_i) + * note: update the parameters for t+1 times iteration + ******************************************************************************/ +#ifndef EMEXP_HPP_ +#define EMEXP_HPP_ + +#include +#include ""ParamExp.hpp"" + +/* + * summation over data, with certain size + */ +double sum(double *data, int size); + +double modernWaver(unsigned int n, const double *x, double *grad, void *data); + +double archaicWaver(unsigned int n, const double *x, double *grad, void *data); + +double archaicWaverConstraint(unsigned n, const double *x, double *grad, void *data); + +class waverData +{ +public: + waverData(const std::vector& _observ, double _lb, double _ub) : \ + lb(_lb), ub(_ub), observ(_observ) {}; + double lb, ub; + const std::vector& observ; +}; + +class EMExp +{ +public: + + /* + * @brief constructor + * @param par Parameter for EM algorithm + * @param observ Observations of data used to estimate parameter of EM + */ + EMExp(const ParamExp &par, const std::vector &observ); + + /* + * @brief get the log likelihood + * @return the log likelihood of current data and parameter + */ + double getLik() const; + + /* + * @brief get parameter of EM + * @return the reference of EM parameter + */ + ParamExp & getPar(); + + /* + * @brief set a new parameter for EM + * @param new parameter to be set + */ + void setPar(const ParamExp &par); + + /* + * @brief update the log likelihood, usually when parameter is updated + */ + void updateLik(); + + /* + * @brief perform EM iteration + * @param maxIter max number of iteration, the EM iteration terminate either + * parameter is converged, or reach the max number of iteration + */ + void iterate(int maxIter, double epsilon); + + void iterateClassify(int maxIter, double epsilon); + + /* + * destructor + */ + virtual ~EMExp(); + +private: + /* + * log likelihood value + */ + double lik; + + /* + * Parameter of EM + */ + ParamExp par; + + /* + * a vector of observations + */ + std::vector observ; +}; + +#endif /* EMEXP_HPP_ */ +","Unknown" +"Allele","Shuhua-Group/ArchaicSeeker2.0","WaveEstimate/MultiWaver2.1/ParamExp.cpp",".cpp","3330","191","/* + * ParamExp.cpp + * + * Created on: May 26, 2015 + * Author: young + */ +#include +#include +#include +#include +#include + +#include ""ParamExp.hpp"" + +using namespace std; + +/* constructor + * Initial with K exponential distributions + * parameters lambda are randomly initial with value between 0 and 1 + * proportions are randomly initial with value between 0 and 1, and + * the summation equals 1 + */ +ParamExp::ParamExp(int K) : + K(K) +{ + lambda = new double[K]; + prop = new double[K]; + for (int i = 0; i < K; ++i) + { + lambda[i] = 1.0 * rand() / RAND_MAX; + prop[i] = 1.0 / K; + } + +// double tmp = 0; +// for (int i = 0; i < (K - 1); ++i) +// { +// prop[i] = rand() / (1.0 * K * RAND_MAX); +// tmp += prop[i]; +// } +// //ensure sum to one +// prop[K - 1] = 1 - tmp; +} + +ParamExp::ParamExp(int K, std::vector observ) : K(K) +{ + sort(observ.begin(), observ.end()); + lambda = new double[K]; + prop = new double[K]; + if(K == 1) + { + lambda[0] = 1.0 * rand() / RAND_MAX; + prop[0] = 1.0; + } + else + { + int nobserv = observ.size(); + for(int i = 0 ; i < K ; ++i) + { + int index = i * (double) nobserv / (K - 1); + if(index >= nobserv) + index = nobserv - 1; + lambda[i] = 1.0 / observ[index]; + prop[i] = 1.0 / K; + } + } +} + +/* another constructor + * initialize with K, lambdas and proportions + */ +ParamExp::ParamExp(int K, double *l, double *p) : + K(K) +{ + lambda = new double[K]; + prop = new double[K]; + for (int i = 0; i < K; ++i) + { + lambda[i] = l[i]; + prop[i] = p[i]; + } +} + +//copy constructor +ParamExp::ParamExp(const ParamExp &rhs) +{ + K = rhs.K; + lambda = new double[K]; + prop = new double[K]; + for (int i = 0; i < K; ++i) + { + lambda[i] = rhs.lambda[i]; + prop[i] = rhs.prop[i]; + } +} + +//overloading operator assignment +ParamExp & ParamExp::operator=(const ParamExp &rhs) +{ + if (this != &rhs) + { + K = rhs.K; + if (lambda != NULL) + delete[] lambda; + if (prop != NULL) + delete[] prop; + lambda = new double[K]; + prop = new double[K]; + for (int i = 0; i < K; ++i) + { + lambda[i] = rhs.lambda[i]; + prop[i] = rhs.prop[i]; + } + } + return *this; +} + +int ParamExp::getK() const +{ + return K; +} + +double ParamExp::getLambda(int index) const +{ + return lambda[index]; +} + +double ParamExp::getProp(int index) const +{ + return prop[index]; +} + +void ParamExp::setProp(int index, double prop) +{ + this->prop[index] = prop; +} + +//test convergence +bool ParamExp::isConverge(const ParamExp &par, double epsilon) +{ + bool converge = true; + for (int i = 0; i < K; ++i) + { + if (abs(lambda[i] - par.getLambda(i)) > epsilon || abs(prop[i] - par.getProp(i)) > epsilon) + { + converge = false; + break; + } + } + return converge; +} + +void ParamExp::sortByLambda() +{ + /* + * the key of map are automatically sorted, therefore can be used + * to sort lambda and corresponding proportion accordingly + */ + map temp; + int i; + for (i = 0; i < K; ++i) + { + temp[lambda[i]] = prop[i]; + } + i = 0; + for (map::iterator it = temp.begin(); it != temp.end(); it++) + { + lambda[i] = it->first; + prop[i] = it->second; + i++; + } +} + +void ParamExp::print() +{ + cout << ""par=(""; + for (int i = 0; i < K; ++i) + { + cout << lambda[i] << "", "" << prop[i] << ""; ""; + } + cout << "")"" << endl; +} + +// +ParamExp::~ParamExp() +{ + if (lambda != NULL) + delete[] lambda; + if (prop != NULL) + delete[] prop; +} +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","WaveEstimate/MultiWaver2.1/Utils.cpp",".cpp","5187","193","/* + * Utils.cpp + * + * Created on: Aug 26, 2015 + * Author: young + */ +#include +#include +#include ""EMExp.hpp"" +#include ""Utils.hpp"" +#include + +using namespace std; + +double cv_chisq(int df, double alpha) +{ + boost::math::chi_squared dist(df); + return boost::math::quantile(dist, 1 - alpha); +} + +ParamExp findOptPar(const vector &observ, int K, int maxIter, double ancestryProp, \ + double criticalValue, double epsilon, double minP, bool simple) +{ +// bool findOpt = false; +// int k = 1; +// ParamExp parPrev(K); +// EMExp em(parPrev, observ); +// em.iterateClassify(maxIter, epsilon); +// double llkPrev = em.getLik(); +// parPrev = em.getPar(); +// if (simple) +// { +// parPrev.sortByLambda(); +// return parPrev; +// } +// while (!findOpt) +// { +// k++; + ParamExp parCur(K); + EMExp em(parCur, observ); + em.setPar(parCur); + //em.updateLik(); + em.iterate(maxIter, epsilon); + //cout << ""K="" << k << ""; Likelihood="" << setprecision(8) << em.getLik() << ""; ""; + //em.getPar().print(); +// double llkCur = em.getLik(); +// if (2 * (llkCur - llkPrev) < criticalValue) +// { + //cout << ""Optimal K "" << k - 1 << endl; +// findOpt = true; +// } +// else +// { + /* + * check survival proportion for each wave, + * if any one less than minP, stop to increase to larger K + */ +/* ParamExp tmpPar = em.getPar(); + tmpPar.sortByLambda(); + double tempSum = 0; + double temp[k]; + for (int i = 0; i < k; ++i) + { + temp[i] = tmpPar.getProp(i) / tmpPar.getLambda(i); + tempSum += temp[i] / temp[0]; + } + tempSum = ancestryProp / tempSum; + for (int i = 0; i < k; ++i) + { + if (tempSum * temp[i] / temp[0] < minP) + { + findOpt = true; + break; + } + } + if (!findOpt) + { + llkPrev = llkCur; + parPrev = em.getPar(); + } + } + } + //parPrev.print(); + */ +// parPrev.sortByLambda(); + em.getPar().sortByLambda(); + return em.getPar(); +} + +ParamExp findOptPar(const vector &observ, int maxIter, double ancestryProp, \ + double criticalValue, double epsilon, double minP, bool simple) +{ + bool findOpt = false; + int k = 1; + ParamExp parPrev(k); + EMExp em(parPrev, observ); + em.iterate(maxIter, epsilon); + double llkPrev = em.getLik(); + parPrev = em.getPar(); + if (simple) + { + parPrev.sortByLambda(); + return parPrev; + } + while (!findOpt) + { + k++; + ParamExp parCur(k); + em.setPar(parCur); + //em.updateLik(); + em.iterate(maxIter, epsilon); + //cout << ""K="" << k << ""; Likelihood="" << setprecision(8) << em.getLik() << ""; ""; + //em.getPar().print(); + double llkCur = em.getLik(); + if (2 * (llkCur - llkPrev) < criticalValue) + { + //cout << ""Optimal K "" << k - 1 << endl; + findOpt = true; + } + else + { + /* + * check survival proportion for each wave, + * if any one less than minP, stop to increase to larger K + */ + ParamExp tmpPar = em.getPar(); + tmpPar.sortByLambda(); + double tempSum = 0; + double temp[k]; + for (int i = 0; i < k; ++i) + { + temp[i] = tmpPar.getProp(i) / tmpPar.getLambda(i); + tempSum += temp[i] / temp[0]; + } + tempSum = ancestryProp / tempSum; + for (int i = 0; i < k; ++i) + { + if (tempSum * temp[i] / temp[0] < minP) + { + findOpt = true; + break; + } + } + if (!findOpt) + { + llkPrev = llkCur; + parPrev = em.getPar(); + } + } + } + //parPrev.print(); + parPrev.sortByLambda(); + return parPrev; +} + +void solveTrueProp(ParamExp &par, double lower) +{ + int numOfWave = par.getK(); + double temp[numOfWave]; + temp[0] = 1.0; + double tempSum = temp[0]; + for (int i = 1; i < numOfWave; ++i) + { + temp[i] = par.getProp(i) * exp((par.getLambda(i) - par.getLambda(0)) * lower) / par.getProp(0); + tempSum += temp[i]; + } + par.setProp(0, 1.0 / tempSum); + for(int i = 1; i < numOfWave; ++i) + { + par.setProp(i, par.getProp(0) * temp[i]); + } +} + +void help() +{ + cout << kProgramName << "" v"" << kVersion << endl; + cout << kProgramName << "" is designed to scan for multiple waves of admixture events and estimated corresponding parameters."" << endl; + cout << ""General usage: "" << kProgramName << "" [options]"" << endl; + cout << ""Arguments"" << endl; + cout << ""\t-i/--input\t\tInput of the ancestral tracks [required]"" << endl; + cout << ""\t-l/--lower\t[double]\tLower bound to discard short tracks [optional, default 0]"" << endl; + cout << ""\t-b/--bootstrap\t[integer]\tNumber of bootstrapping [optional, default 100]"" << endl; + cout << ""\t-a/--alpha\t[double]\tSignificance level to reject null hypothesis in LRT [optional, default 0.001]"" << endl; + cout << ""\t-e/--epsilon\t[double]\tEpsilon to check whether a parameter converge or not [optional, default 1.0e-6] "" << endl; + cout << ""\t-p/--minProp\t[double]\tMinimum survival proportion for a wave at the final generation [optional, default 0.05]"" << endl; + cout << ""\t-m/--maxIter\t[integer]\tMaximum number of iterations to scan for waves of admixture events [optional, default 10000]"" << endl; + cout << ""\t-t/--thread\t[integer]\tNumber of threads [optional, default 1]"" << endl; + cout << ""\t-o/--output\t\tPrefix of output [required]"" << endl; + cout << ""Options"" << endl; + cout << ""\t-h/--help\tPrint help message, default is OFF"" << endl; +} + +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","WaveEstimate/MultiWaver2.1/Utils.hpp",".hpp","1762","70","/* + * Utils.hpp + * + * Created on: Aug 26, 2015 + * Author: young + */ + +#ifndef UTILS_HPP_ +#define UTILS_HPP_ + +#include +#include +#include +#include ""ParamExp.hpp"" + +//const double kMinP = 0.05; //minimum proportion for a wave +//const double kCriticalValue = 5.991; //chi-squared value for p-value 0.05 with degree of freedom 2 +const std::string kVersion = ""1.0.2""; +const std::string kProgramName = ""MultiWaver""; + +/* + * perform permutation over a sequence + */ +template +std::vector > perm(std::vector &seq) +{ + std::vector > result; + int size = seq.size(); + std::sort(seq.begin(), seq.end()); + do + { + if (seq.at(size - 1) == seq.at(size - 2)) + continue; + int rsize = result.size(); + if (rsize > 0 && result.at(rsize - 1).at(size - 2) == seq.at(size - 1)) + continue; + result.push_back(seq); + } while (std::next_permutation(seq.begin(), seq.end())); + return result; +} + +/* + * calculate the critical value of chi-squared distribution with significance level alpha + */ +double cv_chisq(int df, double alpha = 0.05); + +/* + * perform EM to find the best number of exponential distribution and estimate + * corresponding parameters + */ +ParamExp findOptPar(const std::vector &observ, int maxIter, double aProp, \ + double cValue = 5.991, double epsilon = 0.000001, double minP = 0.001, \ + bool simple = false); +ParamExp findOptPar(const std::vector &observ, int K, int maxIter, double aProp, \ + double cValue = 5.991, double epsilon = 0.000001, double minP = 0.001, \ + bool simple = false); + + +/* + * solve for proportion when considering lower bound +*/ +void solveTrueProp(ParamExp &par, double lower = 0); + +/* + * print help information + */ +void help(); + +#endif /* UTILS_HPP_ */ +","Unknown" +"Allele","Shuhua-Group/ArchaicSeeker2.0","WaveEstimate/MultiWaver2.1/EMExp.cpp",".cpp","7216","340","/* + * EMExp.cpp + * + * Created on: May 26, 2015 + * Author: young + */ + +#include +#include +#include +#include ""EMExp.hpp"" + +double sum(double * data, int size) +{ + double tmp = 0; + for (int i = 0; i < size; ++i) + { + tmp += data[i]; + } + return tmp; +} + +double modernWaver(unsigned int n, const double *x, double *grad, void *data) +{ + waverData *d = (waverData * ) data; + double u (x[0]); + double expLb(exp( - u * d->lb ) ), expUb(exp( - u * d->ub ) ); + double a ( log( u / ( expLb - expUb ) ) ); + int nobserv(d->observ.size()); + double b (0); + const std::vector& curObserv(d->observ); + for(int i = 0 ; i < nobserv; ++i) + b += curObserv[i]; + if(grad) + { + grad[0] = 1.0 / u + (d->lb * expLb - d->ub * expUb) / (expLb - expUb) - b / nobserv; + } +// std::cout << grad[0] << std::endl; + double ret(a * nobserv - u * b); + return ret; +} + +double archaicWaver(unsigned int n, const double *x, double *grad, void *data) +{ + //x[0 .. n / 2] u + //x[n / 2 .. n] w + int nwave(n/2); + const double *u(x) , *w(x + nwave); + double *ugrad, *wgrad; + if(grad) + { + ugrad = grad; + wgrad = grad + nwave; + } + waverData *d = (waverData * ) data; + double lb(d->lb), ub(d->ub); + double denom(0); + double dev_euc[nwave]; + double dev_ceuc[nwave]; + for(int i = 0 ; i < nwave ; ++i) + { + double euc1, euc2; + euc1 = exp(-u[i] * lb); + euc2 = exp(-u[i] * ub); + dev_euc[i] = euc1 - euc2; + denom += w[i] * dev_euc[i]; + dev_ceuc[i] = lb * euc1 - ub * euc2; + } + const std::vector& curObserv(d->observ); + int nobserv(curObserv.size()); + double ret(0); + double eux[nwave], ueux[nwave]; + if(grad) + { + memset(grad, 0, sizeof(double) * nwave * 2); + for(int i = 0 ; i < nobserv; ++i) + { + double x = curObserv[i]; + double sum_wueux(0); + for(int j = 0 ; j < nwave ; ++j) + { + eux[j] = exp(-u[j] * x); + ueux[j] = eux[j] * u[j]; + sum_wueux += ueux[j] * w[j]; + } + ret += log(sum_wueux / denom); + for(int j = 0 ; j < nwave; ++j) + { + wgrad[j] += ueux[j] / sum_wueux - dev_euc[j] / denom; + ugrad[j] += w[j] * ( eux[j] - u[j] * ueux[j] ) / sum_wueux \ + + w[j] * dev_ceuc[j] / denom; + } + } + } + else + for(int i = 0 ; i < nobserv; ++i) + { + double x = curObserv[i]; + double sum_wueux(0); + for(int j = 0 ; j < nwave ; ++j) + sum_wueux += exp(-u[j] * x) * u[j] * w[j]; + ret += log(sum_wueux / denom); + } +// std::cout << ""Iter"" << std::endl; +// for(int i = 0 ; i < nwave ; ++i) +// std::cout << '\t' << u[i] << '\t' << w[i] << std::endl; +// for(int i = 0 ; i < nwave ; ++i) +// std::cout << '\t' << ugrad[i] << '\t' << wgrad[i] << std::endl; +// std::cout << ret << std::endl; + return ret; +} + +double archaicWaverConstraint(unsigned int n, const double *x, double *grad, void *data) +{ + double ret(0); + unsigned int nwave(n / 2); + for(unsigned int i = nwave ; i < n ; ++i) + ret += x[i]; + if(grad) + { + for(unsigned int i = 0 ; i < nwave ; ++i) + grad[i] = 0; + for(unsigned int i = nwave ; i < n; ++i) + grad[i] = 1; + } + ret -= 1; + return ret; +} + +using namespace std; + +//constructor +EMExp::EMExp(const ParamExp &par, const vector &observ) : + par(par), observ(observ) +{ + updateLik(); +} + +double EMExp::getLik() const +{ + return lik; +} + +ParamExp & EMExp::getPar() +{ + return par; +} + +void EMExp::setPar(const ParamExp &par) +{ + this->par = par; +} +//update likelihood +/* + * Log-lik = sum(log(sum(m_j*l_j*exp(-l_j*x_i)))) + */ +void EMExp::updateLik() +{ + double tmp = 0; + for (size_t i = 0; i < observ.size(); ++i) + { + int k = par.getK(); + double fval = 0; + for (int j = 0; j < k; ++j) + { + double m = par.getProp(j); + double l = par.getLambda(j); + fval += m * l * exp(-l * observ.at(i)); + } + tmp += log(fval); + } + lik = tmp; +} + +//EM iteration, converge or reach max iteration time will terminate +void EMExp::iterate(int maxIter, double epsilon) +{ + int it = 0; //iteration number + int kval = par.getK(); + int size = observ.size(); + double *nlambda; //new lambda + double *nprop; //new proportion + double **pval; + double **pxval; + nlambda = new double[kval]; + nprop = new double[kval]; + pval = new double *[kval]; + pxval = new double *[kval]; + for (int i = 0; i < kval; ++i) + { + pval[i] = new double[size]; + pxval[i] = new double[size]; + } + while (++it < maxIter) + { + //E-step + for (int i = 0; i < size; ++i) + { + double denormator = 0; + for (int j = 0; j < kval; ++j) + { + double mj = par.getProp(j); + double lj = par.getLambda(j); + pval[j][i] = mj * lj * exp(-lj * observ.at(i)); + denormator += pval[j][i]; + } + for (int j = 0; j < kval; ++j) + { + pval[j][i] /= denormator; + pxval[j][i] = pval[j][i] * observ.at(i); + } + } + //M-step + for (int i = 0; i < kval; ++i) + { + double sump = sum(pval[i], size); + nprop[i] = sump / size; + nlambda[i] = sump / sum(pxval[i], size); + } + ParamExp updatedPar(kval, nlambda, nprop); + /* + * check converge or not, if converge, jump out of loop + */ + if (par.isConverge(updatedPar, epsilon)) + { + par = updatedPar; + updateLik(); + break; + } + else + { + par = updatedPar; + updateLik(); + } + //cout << ""Iteration "" << ++it << "" --> llk: "" << getLik() << ""; ""; + //getPar().print(); + } +// if (it >= maxIter) +// { +// cerr << ""Warning: Max iteration reached before convergence, set a larger number"" << endl; +// } + //clean stuff + delete[] nlambda; + delete[] nprop; + for (int i = 0; i < kval; ++i) + { + delete[] pval[i]; + delete[] pxval[i]; + } + delete[] pval; + delete[] pxval; +} + +void EMExp::iterateClassify(int maxIter, double epsilon) +{ + int it = 0; //iteration number + int kval = par.getK(); + int size = observ.size(); + double *nlambda; //new lambda + double *nprop; //new proportion + double *sumLen; + int *count; + int *lab; + nlambda = new double[kval]; + nprop = new double[kval]; + sumLen = new double[kval]; + count = new int[kval]; + lab = new int[size]; + double sum(0); + for(int i = 0 ; i < size; ++i) + sum += observ[i]; + while(++it < maxIter) + { + for(int i = 0 ; i < size ; ++i) + { + double x = observ[i]; + lab[i] = 0; + double lambda = par.getLambda(0); + double maxLk = lambda * exp(-lambda * x); + for(int j = 1 ; j < kval; ++j) + { + double lk; + lambda = par.getLambda(j); + lk = lambda * exp(-lambda * x); + if(lk > maxLk) + { + lab[i] = j; + maxLk = lk; + } + } + } + memset(sumLen, 0, sizeof(double) * kval); + memset(count, 0, sizeof(int) * kval); + for(int i = 0 ; i < size ; ++i) + { + sumLen[lab[i]] += observ[i]; + ++count[lab[i]]; + } + for(int i = 0 ; i < kval; ++i) + { + nlambda[i] = count[i] / sumLen[i]; + nprop[i] = sumLen[i] / sum; +// std::cout << '\t' << i << '\t' << nlambda[i] << '\t' << nprop[i] << std::endl; + } + + ParamExp updatedPar(kval, nlambda, nprop); + /* + * check converge or not, if converge, jump out of loop + */ + if (par.isConverge(updatedPar, epsilon)) + { + par = updatedPar; + updateLik(); + break; + } + else + { + par = updatedPar; + updateLik(); + } + //cout << ""Iteration "" << ++it << "" --> llk: "" << getLik() << ""; ""; + //getPar().print(); + } + if (it >= maxIter) + { + cerr << ""Warning: Max iteration reached before convergence, set a larger number"" << endl; + } + //clean stuff + delete[] nlambda; + delete[] nprop; + delete[] sumLen; + delete[] count; + delete[] lab; +} + +EMExp::~EMExp() +{ +} + +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","WaveEstimate/MultiWaver2.1/MultiWaver.cpp",".cpp","8991","331","/* + * MultiWaveInfer.cpp + * + * Created on: May 26, 2015 + * Author: young + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include ""Utils.hpp"" + +#include ""omp.h"" + +using namespace std; + + +int main(int argc, char **argv) +{ + if (argc < 2) + { + cerr << ""Need more arguments than provided, please use -h/--help to get help"" << endl; + exit(1); + } + string filename = """"; + double lower = 0; + double alpha = 0.001; + double epsilon = 0.000001; + double minP = 0.0001; + int maxIter = 10000; + int nbootstrap(100); + int nthread(1); + string outPrefix(""""); + for (int i = 1; i < argc; ++i) + { + string arg(argv[i]); + if (arg == ""-h"" || arg == ""--help"") + { + help(); + exit(0); + } + else if (arg == ""-i"" || arg == ""--input"") + { + filename = string(argv[++i]); + } + else if (arg == ""-l"" || arg == ""--lower"") + { + lower = atof(argv[++i]); + } + else if (arg == ""-m"" || arg == ""--maxIter"") + { + maxIter = atoi(argv[++i]); + } + else if (arg == ""-a"" || arg == ""--alpha"") + { + alpha = atof(argv[++i]); + } + else if (arg == ""-e"" || arg == ""--epsilon"") + { + epsilon = atof(argv[++i]); + } + else if (arg == ""-p"" || arg == ""--minProp"") + { + minP = atof(argv[++i]); + } + else if (arg == ""-b"" || arg == ""--bootstrap"") + { + nbootstrap = atol(argv[++i]); + } + else if (arg == ""-o"" || arg == ""--output"") + { + outPrefix = argv[++i]; + } + else if (arg == ""-t"" || arg == ""--thread"") + { + nthread = atol(argv[++i]); + } + else + { + cerr << ""unrecognizable argument found, please check again!"" << endl; + exit(1); + } + } + if (filename.size() == 0) + { + cerr << ""Input file name required, please check help"" << endl; + exit(1); + } + omp_set_num_threads(nthread); + srand(time(NULL)); + vector observ; + //Reading test data from file named as test.dat + ifstream fin(filename.c_str()); + if (!fin.is_open()) + { + cerr << ""Can't open file "" << filename << endl; + exit(1); + } + vector segs; + map sumLengths; + vector labels; + labels.push_back(""Archaic""); + labels.push_back(""Modern""); + double totalLength = 0; + string line; + while (getline(fin, line)) + { + istringstream ss(line); + double start, end; + string label; + ss >> start >> end >> label; + double len = end - start; + + if (label == ""Archaic"") + { + if(len > lower) + segs.push_back(len - lower); + } + else if (label != ""Modern"") + { + cerr << ""Cannot identify "" << label << endl; + return 1; + } + sumLengths[label] += len; + totalLength += len; + } + fin.close(); + + if(segs.size() <= 0) + { + cerr << ""No effective segment length input."" << endl; + return 1; + } + + map mixtureProps; //S_k + ParamExp optPar; + double criticalValue = cv_chisq(2, alpha); + for (int i = 0 ; i < 2 ; ++i) + mixtureProps[labels[i]] = sumLengths[labels[i]] / totalLength; + + optPar = findOptPar(segs, maxIter, mixtureProps.at(""Archaic""), criticalValue, epsilon, minP, false); + solveTrueProp(optPar, lower); + + int totalNumOfWaves = optPar.getK(); + vector popOrder; + double tempSum = 0; + double temp[totalNumOfWaves]; + for (int i = 0 ; i < totalNumOfWaves; ++i) + { + popOrder.push_back(i); + temp[i] = optPar.getProp(i) / optPar.getLambda(i); + tempSum += temp[i] / temp[0]; + } + tempSum = mixtureProps.at(""Archaic"") / tempSum; + + double mInOrder[totalNumOfWaves]; + for (int i = 0; i < totalNumOfWaves; ++i) + mInOrder[i] = tempSum * temp[i] / temp[0]; + + double alphaInOrder[totalNumOfWaves]; + double multiplier = 1.0; + alphaInOrder[0] = mInOrder[0]; + for (int i = 1; i < totalNumOfWaves; ++i) + { + multiplier *= (1 - alphaInOrder[i - 1]); + alphaInOrder[i] = mInOrder[i] / multiplier; + } + + double hInOrder[totalNumOfWaves]; + hInOrder[totalNumOfWaves - 1] = alphaInOrder[totalNumOfWaves - 1]; + for(int i = totalNumOfWaves - 2; i >= 0; --i) + hInOrder[i] = hInOrder[i + 1] * ( 1 - alphaInOrder[i]) + alphaInOrder[i]; +// hInOrder[totalNumOfWaves - 1] = hInOrder[totalNumOfWaves - 2]; + + + double admixTime[totalNumOfWaves]; + for (int i = 0; i < totalNumOfWaves; ++i) + { + double tempSum = 0; + for (int k = 0; k < i; ++k) + { + tempSum += (1 - hInOrder[k]) * admixTime[k]; + } + double rate = optPar.getLambda(i) - tempSum; + admixTime[i] = rate / (1 - hInOrder[i]); + } + + for (int i = 1; i < totalNumOfWaves; ++i) + { + admixTime[i] += admixTime[i - 1]; + } +// cout << '\t'; +// for(int i = 0; i < totalNumOfWaves; ++i) +// cout << admixTime[i] << '(' << alphaInOrder[i] << ""),""; +// cout << endl; + + + vector > bootstrapAdmixTime, bootstrapAlpha; + bootstrapAdmixTime.resize(nbootstrap); + bootstrapAlpha.resize(nbootstrap); + string path; + path = outPrefix + "".bootstrap""; + ofstream fpoboot(path.c_str()); + fpoboot << ""NumBootstrap\tNumArchaic\tTime"" << endl; + +#pragma omp parallel for + for(int iterBoot = 0 ; iterBoot < nbootstrap; ++iterBoot) + { + vector curSegs; + int nseg(segs.size()); + curSegs.resize(nseg); + for(int i = 0 ; i < nseg ; ++i) + curSegs[i] = segs[rand() % nseg]; + ParamExp curOptPar; + + curOptPar = findOptPar(curSegs, maxIter, mixtureProps.at(""Archaic""), criticalValue, epsilon, minP, false); + solveTrueProp(curOptPar, lower); + + int curTotalNumOfWaves = curOptPar.getK(); + vector curPopOrder; + double curTempSum = 0; + double curTemp[curTotalNumOfWaves]; + for (int i = 0 ; i < curTotalNumOfWaves; ++i) + { + curPopOrder.push_back(i); + curTemp[i] = curOptPar.getProp(i) / curOptPar.getLambda(i); + curTempSum += curTemp[i] / curTemp[0]; + } + curTempSum = mixtureProps.at(""Archaic"") / curTempSum; + + double mInOrder[curTotalNumOfWaves]; + for (int i = 0; i < curTotalNumOfWaves; ++i) + mInOrder[i] = curTempSum * curTemp[i] / curTemp[0]; + + vector & alphaInOrder = bootstrapAlpha[iterBoot]; +#pragma omp critical + alphaInOrder.resize(curTotalNumOfWaves, 0); + double multiplier = 1.0; + alphaInOrder[0] = mInOrder[0]; + for (int i = 1; i < curTotalNumOfWaves; ++i) + { + multiplier *= (1 - alphaInOrder[i - 1]); + alphaInOrder[i] = mInOrder[i] / multiplier; + } + + double hInOrder[curTotalNumOfWaves]; + hInOrder[curTotalNumOfWaves - 1] = alphaInOrder[curTotalNumOfWaves - 1]; + for(int i = curTotalNumOfWaves - 2; i >= 0; --i) + hInOrder[i] = hInOrder[i + 1] * ( 1 - alphaInOrder[i]) + alphaInOrder[i]; + // hInOrder[totalNumOfWaves - 1] = hInOrder[totalNumOfWaves - 2]; + + + vector & admixTime = bootstrapAdmixTime[iterBoot]; +#pragma omp critical + admixTime.resize(curTotalNumOfWaves, 0); + for (int i = 0; i < curTotalNumOfWaves; ++i) + { + double tempSum = 0; + for (int k = 0; k < i; ++k) + { + tempSum += (1 - hInOrder[k]) * admixTime[k]; + } + double rate = curOptPar.getLambda(i) - tempSum; + admixTime[i] = rate / (1 - hInOrder[i]); + } + + for (int i = 1; i < curTotalNumOfWaves; ++i) + { + admixTime[i] += admixTime[i - 1]; + } +#pragma omp critical + { + fpoboot << iterBoot << ""\t"" << curTotalNumOfWaves << ""\t""; + for(int i = 0 ; i < curTotalNumOfWaves - 1; ++i) + fpoboot << admixTime[i] << ""("" << alphaInOrder[i] << ""),""; + fpoboot << admixTime[curTotalNumOfWaves - 1] << ""("" << alphaInOrder[curTotalNumOfWaves - 1] << "")"" << endl; + } + } + map wavesCount; + map > > adTimeSum, adProSum; + for(int i = 0 ; i < nbootstrap; ++i) + { + int nwave = bootstrapAdmixTime[i].size(); + if(adTimeSum.count(nwave) == 0) + { + adTimeSum[nwave].resize(nwave); + adProSum[nwave].resize(nwave); + } + ++wavesCount[nwave]; + for(int j = 0 ; j < nwave ; ++j) + { + adTimeSum[nwave][j].push_back(bootstrapAdmixTime[i][j]); + adProSum[nwave][j].push_back(bootstrapAlpha[i][j]); + } + } + path = outPrefix + "".sum""; + ofstream fposum(path.c_str()); + fposum << ""Dataset\tSupportRatio\tSupportNum\tNumOfArchaic\tTime(Generation)"" << endl; + fposum << ""CompleteData\t-\t-\t"" << totalNumOfWaves << ""\t""; + for(int i = 0 ; i < totalNumOfWaves - 1; ++i) + fposum << admixTime[i] << ""("" << alphaInOrder[i] << ""),""; + fposum << admixTime[totalNumOfWaves - 1] << ""("" << alphaInOrder[totalNumOfWaves - 1] << "")"" << endl; + for(map::iterator it = wavesCount.begin(); it != wavesCount.end(); ++it) + { + int n(it->second); + int nwave(it->first); + fposum << ""BootstrapData\t"" << (double) n / nbootstrap * 100 << ""%\t"" << n << '\t' << nwave << ""\t""; + for(int i = 0 ; i < nwave - 1; ++i) + { + vector& curAdTime(adTimeSum.at(nwave).at(i)); + sort(curAdTime.begin(), curAdTime.end()); + vector& curPro(adProSum.at(nwave).at(i)); + sort(curPro.begin(), curPro.end()); + fposum << curAdTime[n * 0.025] << ""~"" << curAdTime[n * 0.975] << \ + ""("" << curPro[n * 0.025] << ""~"" << curPro[n * 0.975] << ""),""; + } + vector& curAdTime(adTimeSum.at(nwave).at(nwave - 1)); + sort(curAdTime.begin(), curAdTime.end()); + vector& curPro(adProSum.at(nwave).at(nwave - 1)); + sort(curPro.begin(), curPro.end()); + fposum << curAdTime[n * 0.025] << ""~"" << curAdTime[n * 0.975] << \ + ""("" << curPro[n * 0.025] << ""~"" << curPro[n * 0.975] << "")"" << endl; + } + + return 0; +} +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","src/gzfstream.hpp",".hpp","1710","78","/* + * gzfstream.hpp + * + * Created on: Sep 30, 2018 + * Author: yuankai + */ + +#ifndef GZFSTREAM_HPP_ +#define GZFSTREAM_HPP_ + +# include +# include +# include +# include +# include + +# include + +class igzfd : public boost::iostreams::source +{ +public: + typedef char char_type; + typedef boost::iostreams::source_tag category; + + igzfd(const std::string& path); + igzfd(); + + std::streamsize read(char* s, std::streamsize n); + boost::iostreams::stream_offset seek(boost::iostreams::stream_offset off,\ + std::ios_base::seekdir way); + int open(const std::string& path); + void close(); + +private: + gzFile fd; +}; + +class ogzfd : public boost::iostreams::sink +{ +public: + typedef char char_type; + typedef boost::iostreams::sink_tag category; + + ogzfd(const std::string& path); + ogzfd(); + + std::streamsize write(const char* s, std::streamsize n); + boost::iostreams::stream_offset seek(boost::iostreams::stream_offset off,\ + std::ios_base::seekdir way); + int open(const std::string& path); + void close(); + +private: + gzFile fd; +}; + +class gzifstream : public boost::iostreams::stream +{ +public: + gzifstream() : boost::iostreams::stream("""") {}; + gzifstream(const std::string& path) : boost::iostreams::stream(path) {}; + ~gzifstream(); + + int open(const std::string& path); +}; + +class gzofstream : public boost::iostreams::stream +{ +public: + gzofstream() : boost::iostreams::stream("""") {}; + gzofstream(const std::string& path) : boost::iostreams::stream(path) {}; + ~gzofstream(); + + int open(const std::string& path); +}; + +#endif /* GZFSTREAM_HPP_ */ +","Unknown" +"Allele","Shuhua-Group/ArchaicSeeker2.0","src/gzfstream.cpp",".cpp","1955","113","/* + * gzfstream.cpp + * + * Created on: Sep 30, 2018 + * Author: yuankai + */ + +# include ""gzfstream.hpp"" + +igzfd::igzfd(const std::string& path) +{ + fd = gzopen(path.c_str(), ""rb""); +} + +std::streamsize igzfd::read(char* s, std::streamsize n) +{ + std::streamsize rd = gzread(fd, s, n); + if(rd != 0) + return rd; + else + return -1; +} + +boost::iostreams::stream_offset igzfd::seek(boost::iostreams::stream_offset off, \ + std::ios_base::seekdir way) +{ + if(off < 0) + throw std::ios_base::failure(""bad seek offset""); + if(way == std::ios_base::cur) + gzseek(fd, off, SEEK_CUR); + else if(way == std::ios_base::beg) + gzseek(fd, off, SEEK_SET); + else + throw std::ios_base::failure(""bad seek direction""); + return gztell(fd); +} + +int igzfd::open(const std::string& path) +{ + fd = gzopen(path.c_str(), ""rb""); + int ret = 1; + if(NULL == fd) + ret = 0; + return ret; +} + +void igzfd::close() +{ + gzclose(fd); +} + +ogzfd::ogzfd(const std::string& path) +{ + fd = gzopen(path.c_str(), ""wb""); +} + +std::streamsize ogzfd::write(const char* s, std::streamsize n) +{ + std::streamsize wd = gzwrite(fd, s, n); + return wd; +} + +boost::iostreams::stream_offset ogzfd::seek(boost::iostreams::stream_offset off, \ + std::ios_base::seekdir way) +{ + if(off < 0) + throw std::ios_base::failure(""bad seek offset""); + if(way == std::ios_base::cur) + gzseek(fd, off, SEEK_CUR); + else if(way == std::ios_base::beg) + gzseek(fd, off, SEEK_SET); + else + throw std::ios_base::failure(""bad seek direction""); + return gztell(fd); +} + +int ogzfd::open(const std::string& path) +{ + fd = gzopen(path.c_str(), ""wb""); + int ret = 1; + if(NULL == fd) + ret = 0; + return ret; +} + +void ogzfd::close() +{ + gzclose(fd); +} + +gzifstream::~gzifstream() +{ + this->operator->()->close(); +} + +int gzifstream::open(const std::string& path) +{ + return this->operator->()->open(path); +} + +gzofstream::~gzofstream() +{ + this->operator->()->close(); +} + +int gzofstream::open(const std::string& path) +{ + return this->operator->()->open(path); +} + + + +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","src/seeker.cpp",".cpp","46913","1722","/* + * seeker.cpp + * + * Created on: Oct 10, 2018 + * Author: yuankai + */ + +# include ""seeker.hpp"" +# include ""data.hpp"" +# include ""matching.hpp"" + +# include +# include +# include +# include +# include + +# include + +class transMat +{ +public: + void setP(double a, double t, double d) + { + double e = exp( - t * d ); + if(d < 0) + e = 0; + /* + * pro[0] Modern -> Modern + * pro[1] Archaic -> Modern + * pro[2] Modern -> Archaic + * pro[3] Archaic -> Archaic + */ + pro[0] = 1 - a * ( 1 - e ); + pro[1] = ( 1 - a ) * ( 1 - e ); + pro[2] = a * ( 1 - e ); + pro[3] = e + a * ( 1 - e ); + } + long double pro[4]; +}; + +class stateHMM +{ +public: + void setInit(double a, double e0, double e1) + { + pro[0] = (1 - a) * e0; + pro[1] = a * e1; + c = 0; + check(); + } + void trans(const stateHMM& pre, const transMat& transP, double e0, double e1) + { + pro[0] = pre.pro[0] * transP.pro[0] + pre.pro[1] * transP.pro[1]; + pro[0] *= e0; + pro[1] = pre.pro[0] * transP.pro[2] + pre.pro[1] * transP.pro[3]; + pro[1] *= e1; + c = pre.c; + check(); + } + int bestState() const + { + if(pro[0] < pro[1]) + return 1; + else + return 0; + } + long double pro[2]; + long c; + static long double scale ; +private: + void check() + { + if(pro[0] < scale) + { + pro[0] /= scale; + pro[1] /= scale; + ++c; + } + } + //0 Modern, 1 Archaic +}; + +long double stateHMM::scale = 1.0e-150 ; + +void stateForward(const std::vector& transP, std::vector& sites, \ + const std::vector& state, double emit[2][4]) +{ + int nsite = sites.size(); + double* e0 = emit[0]; + double* e1 = emit[1]; + for(int i = 1; i < nsite; ++i) + sites[i].trans(sites.at(i - 1), transP.at(i), e0[state[i]], e1[state[i]]); +} + +void stateViterbi(const std::vector& sites, std::vector& bestState) +{ + int nsite = sites.size(); + bestState.clear(); + bestState.resize(nsite, 0); + for(int i = 0; i < nsite ; ++i) + bestState[i] = sites[i].bestState(); +} + +class bed +{ +public: + bed() : pstart(0), pend(0), start(0), end(0), t(0) + { + diff = new double [nleaf]; + memset(diff, 0, sizeof(double) * nleaf); + memset(state, 0, sizeof(int) * 4); + } + ~bed() { delete []diff; } + bed(const bed& rhs) + { + if(this != &rhs) + { + pstart = rhs.pstart; + pend = rhs.pend; + start = rhs.start; + end = rhs.end; + t = rhs.t; + memcpy(state, rhs.state, sizeof(int) * 4); + diff = new double [nleaf]; + memcpy(diff, rhs.diff, sizeof(double) * nleaf); + } + } + void clear() + { + memset(diff, 0, sizeof(double) * nleaf); + memset(state, 0, sizeof(int) * 4); + } + int state[4]; + long pstart, pend; + double start, end, t; + double *diff; + + static int nleaf; +}; + +int bed::nleaf; + +void archaicSeekerHMM(archaicSeekerPar& ASpar, const genomePar& gpar) +{ + genome data(gpar); + int ncontig(data.comContigs.size()); + int nind(data.comIDs.size()); + + matchModel seekM(ASpar.seekModel); + int nleaf(seekM.leafLabs.size()); + int nlab(seekM.labels.size()); + bed::nleaf = nleaf; + std::vector& matLabels(seekM.labels); + std::map popCorrespond; + std::vector archaicPops; + for(int i = 0 ; i < nleaf ; ++i) + popCorrespond[seekM.leafLabs[i]] = i; + for(int i = 0 ; i < nlab; ++i) + { + if(gpar.ASpopCheck.count(matLabels[i]) && gpar.ASpopCheck.at(matLabels[i]) == 0) + archaicPops.push_back(i); + } + int narchaicPops(archaicPops.size()); + + std::vector indexPop; + indexPop.resize(nind); + for(int i = 0 ; i < nind; ++i) + { + assert(popCorrespond.count(data.comPop[i])); + indexPop[i] = popCorrespond[data.comPop[i]]; + } + + std::vector > > altAf, refAf; + altAf.resize(ncontig); + refAf.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + altAf[i].resize(nleaf); + refAf[i].resize(nleaf); + int nsite(data.comPos[i].size()); + for(int j = 0 ; j < nleaf; ++j) + { + altAf[i][j].resize(nsite, 0); + refAf[i][j].resize(nsite, 0); + } + } + + std::vector > outGroup; + outGroup.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + std::vector& curOutGroup(outGroup[i]); + const std::vector& curPos(data.comPos[i]); + const std::vector& curRefAllele(data.comRefAllele[i]), \ + & curAltAllele(data.comAltAllele[i]); + int nsite(curPos.size()); + curOutGroup.resize(nsite); + assert(-1 != access(gpar.outgroupFastaPaths.at(data.comContigs[i]).c_str(), R_OK)); + gzifstream fpog(gpar.outgroupFastaPaths.at(data.comContigs[i])); + std::string faInfo; + getline(fpog, faInfo); + int p(0); + int total(0); + while(p < nsite) + { + while(total < curPos[p]) + { + getline(fpog, faInfo); + if(!fpog) + break; + total += faInfo.size(); + } + if(!fpog) + { + do + { + curOutGroup[p] = -1; + ++p; + } + while(p < nsite); + break; + } + char allele(toupper(faInfo[curPos[p] - total + faInfo.size() - 1])); + if(allele == curRefAllele[p]) + curOutGroup[p] = 0; + else if(allele == curAltAllele[p]) + curOutGroup[p] = 1; + else if(allele == 'A' || allele == 'T' || allele == 'G' || allele == 'C') + curOutGroup[p] = 2; + else + curOutGroup[p] = -1; + ++p; + } + + std::vector > altCount, sumCount; + altCount.resize(nleaf); + sumCount.resize(nleaf); + for(int j = 0 ; j < nleaf; ++j) + { + altCount[j].resize(nsite, 0); + sumCount[j].resize(nsite, 0); + } + for(int j = 0 ; j < nind; ++j) + { + const hapInfo& curHap1(data.haplotypes[i][j * 2]), \ + & curHap2(data.haplotypes[i][j * 2 + 1]); + std::vector& curAlt(altCount[indexPop[j]]), \ + & curSum(sumCount[indexPop[j]]); + if(data.phased[j]) + { + for(int n = 0 ; n < 2; ++n) + { + const hapInfo& curH(data.haplotypes[i][j * 2 + n]); + for(int k = 0 ; k < nsite; ++k) + { + if(curH[k]) + ++curAlt[k]; + ++curSum[k]; + } + } + } + else + { + for(int k = 0 ; k < nsite; ++k) + { + if(curHap1[k] && !curHap2[k]) + { + ++curAlt[k]; + curSum[k] += 2; + } + else if(!curHap1[k] && curHap2[k]) + { + curAlt[k] += 2; + curSum[k] += 2; + } + else if(!(curHap1[k] || curHap2[k])) + curSum[k] += 2; + } + } + } + for(int j = 0; j < nleaf; ++j) + { + std::vector& curAlt(altCount[j]), & curSum(sumCount[j]); + std::vector& curAltAf(altAf[i][j]), & curRefAf(refAf[i][j]); + for(int k = 0 ; k < nsite; ++k) + { + if(curSum[k]) + { + curAltAf[k] = (double)curAlt[k] / curSum[k]; + curRefAf[k] = 1 - curAltAf[k]; + } + } + } + } + std::map outgroupCheck; + for(int i = 0 ; i < ncontig; ++i) + { + int nsite(data.comPos[i].size()); + for(int j = 0 ; j < nsite; ++j) + ++outgroupCheck[outGroup[i][j]]; + } +// std::cout << ""Outgroup:"" << std::endl; +// for(int i = -1; i <=2; ++i) +// std::cout << '\t' << i << '\t' << outgroupCheck[i] << std::endl; + + std::vector > pairDiff; + pairDiff.resize(nleaf); + for(int i = 0 ; i < nleaf; ++i) + pairDiff[i].resize(nleaf, 0); + for(int i = 0 ; i < ncontig; ++i) + { + const std::vector >& curRefAf(refAf[i]), & curAltAf(altAf[i]); + const std::vector& curOutGroup(outGroup[i]); + int nsite(data.comPos[i].size()); + for(int j = 0 ; j < nsite; ++j) + { + if(curOutGroup[j] >= 0) + { + for(int m = 0; m < nleaf; ++m) + for(int n = 0; n < m ; ++n) + pairDiff[m][n] += curRefAf[m][j] * curAltAf[n][j] + \ + curAltAf[m][j] * curRefAf[n][j]; + if(curOutGroup[j] == 0) + for(int m = 0 ; m < nleaf; ++m) + pairDiff[m][m] += curAltAf[m][j]; + else if(curOutGroup[j] == 1) + for(int m = 0 ; m < nleaf; ++m) + pairDiff[m][m] += curRefAf[m][j]; + else if(curOutGroup[j] == 2) + for(int m = 0 ; m < nleaf; ++m) + pairDiff[m][m] += 1; + } + } + } + std::string path; +// path = ASpar.outPrefix + ""_contigs.txt""; +// std::ofstream fpcontig(path.c_str()); +// fpcontig << ""Contig\tTotalLength"" << std::endl; + const std::vector& contigs = data.comContigs; + long sumRegion(0); + std::map contigLen; + std::map hmmProp; + for(int i = 0 ; i < ncontig; ++i) + { + long curContigLen(0); + const std::vector& curPos(data.comPos[i]); + int curNsite(curPos.size()); + for(int j = 1; j < curNsite; ++j) + { + long len(curPos[j] - curPos[j - 1]); + if(len < MAXINTER) + curContigLen += len; + } + contigLen[contigs[i]] = curContigLen; + sumRegion += curContigLen; +// fpcontig << contigs[i] << '\t' << curContigLen << std::endl; + } + + seekM.modelCalibrate(pairDiff, sumRegion); +// path = ASpar.outPrefix + ""_calibratedModel.txt""; +// std::ofstream fpcm(path.c_str()); +// for(int i = 0 ; i < nleaf; ++i) +// for(int j = 0 ; j < i ; ++j) +// fpcm << seekM.leafLabs[i] << '\t' << seekM.leafLabs[j] << '\t' << \ +// pairDiff[i][j] << std::endl; +// for(int i = 0 ; i < nlab ; ++i) +// fpcm << seekM.labels[i] << '\t' << seekM.calibratedLen[i] << std::endl; + + std::vector& asPopLabel = data.comASPop; + + + double emit[2][4]; + /* + * emit[0][] Modern + * emit[1][] Archaic + * emit[][0-3] stands for observed state 2, 1, 3, 4 + */ + + emit[0][1] = ASpar.emit * ( 1 - ASpar.emit ); //ASpar.emit * ( 1 - ASpar.emit ) + emit[0][0] = ( 1 - ASpar.emit ) * ( 1 - ASpar.emit ); + emit[0][2] = ASpar.emit * ASpar.emit; + emit[0][3] = ASpar.emit * ( 1 - ASpar.emit );//emmit[0][1]; + emit[1][1] = emit[0][3]; + emit[1][0] = emit[0][2]; + emit[1][2] = emit[0][0]; + emit[1][3] = emit[0][1]; + + std::vector > > observS; + observS.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + observS[i].resize(nind * 2); +// for(int j = 0 ; j < nind * 2 ; ++j) +// observS[i][j].resize(4); + } + for(int i = 0 ; i < ncontig; ++i) + { + hapInfo afrT, afrF, archT, archF, stateCheck; + std::vector& curComPos(data.comPos[i]); + int nsite(curComPos.size()); + afrT.resize(nsite); + afrT.set(); + afrF.resize(nsite); + afrF.reset(); + archT.resize(nsite); + archT.set(); + archF.resize(nsite); + archF.reset(); + std::vector& curHap = data.haplotypes[i];; + for(int j = 0 ; j < nind; ++j) + { + if(asPopLabel[j] == 0) + { + stateCheck = curHap[j * 2] & curHap[j * 2 + 1]; + stateCheck.flip(); + archT &= curHap[j * 2 + 1] & stateCheck; + archF |= ( curHap[j * 2] | curHap[j * 2 + 1] ) & stateCheck; + } + else if(asPopLabel[j] == 1) + { + stateCheck = curHap[j * 2] & curHap[j * 2 + 1]; + stateCheck.flip(); + afrT &= curHap[j * 2 + 1] & stateCheck; + afrF |= ( curHap[j * 2] | curHap[j * 2 + 1] ) & stateCheck; + } + } + archF.flip(); + afrF.flip(); + hapInfo afrAnc, archAnc; + hapInfo& curAnc(data.ancestralState[i]); + hapInfo curAncN(~curAnc); + afrAnc = ( afrT & curAnc ) | ( afrF & curAncN ); + archAnc = ( archT & curAnc ) | ( archF & curAncN ); + hapInfo afrAncN, archAncN; + afrAncN = ~afrAnc; + archAncN = ~archAnc; + + for(int j = 0; j < nind * 2; ++j) + { + if(asPopLabel[j / 2] == 2) + { + std::vector& obs(observS[i][j]); + obs.resize(nsite); + hapInfo s[4]; + hapInfo& cur(curHap[j]); + hapInfo curDer; + curDer = cur ^ curAnc; + //s[0] state2, s[1] state1, s[2] state3, s[3] state4 + s[1] = curDer & afrAnc & archAnc; + s[0] = curDer & archAncN & afrAnc; + s[2] = curDer & afrAncN & archAnc; + s[3] = ~(s[0] | s[1] | s[2]); + for(int k = 0 ; k < nsite ; ++k) + for(int l = 0 ; l < 4 ; ++l) + if(s[l][k]) + { + obs[k] = l; + break; + } + } + } + } +/* + for(int i = 0 ; i < ncontig; ++i) + { + hapInfo afrT, afrF, archT, archF, stateCheck; + std::vector& curComPos(data.comPos[i]); + int nsite(curComPos.size()); + afrT.resize(nsite); + afrT.set(); + afrF.resize(nsite); + afrF.reset(); + archT.resize(nsite); + archT.set(); + archF.resize(nsite); + archF.reset(); + std::vector& curHap = data.haplotypes[i];; + for(int j = 0 ; j < nind; ++j) + { + if(asPopLabel[j] == 0) + { + stateCheck = curHap[j * 2] & curHap[j * 2 + 1]; + stateCheck.flip(); + archT &= curHap[j * 2 + 1] & stateCheck; + archF |= ( curHap[j * 2] | curHap[j * 2 + 1] ) & stateCheck; + } + else if(asPopLabel[j] == 1) + { + stateCheck = curHap[j * 2] & curHap[j * 2 + 1]; + stateCheck.flip(); + afrT &= curHap[j * 2 + 1] & stateCheck; + afrF |= ( curHap[j * 2] | curHap[j * 2 + 1] ) & stateCheck; + } + } + archF.flip(); + afrF.flip(); + hapInfo afrTarchT, afrFarchF, afrTarchNT, afrFarchNF, \ + afrNTarchT, afrNFarchF, afrNTarchNT, afrNFarchNF; + afrTarchT = afrT & archT; + afrFarchF = afrF & archF; + afrTarchNT = afrT & (~archT); + afrFarchNF = afrF & (~archF); + afrNTarchT = (~afrT) & archT; + afrNFarchF = (~afrF) & archF; + afrNTarchNT = (~afrT) & (~archT); + afrNFarchNF = (~afrF) & (~archF); + for(int j = 0; j < nind * 2; ++j) + { + if(asPopLabel[j / 2] == 2) + { + std::vector& obs(observS[i][j]); + obs.resize(nsite); + hapInfo s[4]; + hapInfo& cur(curHap[j]); + hapInfo curN(~cur); + //s[0] state2, s[1] state1, s[2] state3, s[3] state4 + s[1] = ( afrTarchT & curN ) | ( afrFarchF & cur ); + s[0] = ( afrTarchNT & curN ) | ( afrFarchNF & cur ); + s[2] = ( afrNTarchT & curN ) | ( afrNFarchF & cur ); + s[3] = ( afrNTarchNT & curN ) | ( afrNFarchNF & cur ); + for(int k = 0 ; k < nsite ; ++k) + for(int l = 0 ; l < 4 ; ++l) + if(s[l][k]) + { + obs[k] = l; + break; + } + } + } + } +*/ + double sumGdis(0); + for(int i = 0 ; i < ncontig; ++i) + sumGdis += (data.gdisData[i].back() - data.gdisData[i].front()) / 100; + int testInd(0); + for(unsigned int i = 0 ; i < asPopLabel.size(); ++i) + if(asPopLabel[i] == 2) + ++testInd; + indexPop.resize(nind); + for(int i = 0 ; i < nind; ++i) + { + assert(popCorrespond.count(data.comPop[i])); + indexPop[i] = popCorrespond[data.comPop[i]]; + } + + std::set introTcheck; + for(int iter = 0 ; iter < 100 ; ++iter) + { + std::cout << ""Start iter: "" << iter << std::endl; + std::cout << ""\tAlpha: "" << ASpar.alpha << ""\n\tintroT: "" << ASpar.introT << std::endl; +// std::cout << ""\tEmmit: "" << std::endl; +// for(int i = 0 ; i < 2 ; ++i) +// { +// for(int j = 0 ; j < 4 ; ++j) +// std::cout << ""\t\t["" << i << ""]["" << j << ""] "" << emit[i][j] << std::endl; +// } + + double minMod(-log(0.975) / ASpar.alpha / ASpar.introT * 100); + double minArch(-log(0.975) / (1 - ASpar.alpha) / ASpar.introT * 100); + std::vector > > candidate; + candidate.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + std::vector& curComPos(data.comPos[i]); + int nsite(curComPos.size()); + const std::vector >& curAltAf(altAf[i]); + const std::vector >& curRefAf(refAf[i]); + std::vector transP; + transP.resize(nsite); + std::vector& curGdis = data.gdisData[i]; + candidate[i].resize(nind * 2); + for(int j = 1; j < nsite; ++j) + transP[j].setP(ASpar.alpha, ASpar.introT, ( curGdis[j] - curGdis[j - 1] ) / 100); + for(int j = 0; j < nind * 2; ++j) + { + if(asPopLabel[j / 2] == 2) + { + std::vector& curCandidate(candidate[i][j]); + const std::vector& s(observS[i][j]); + const hapInfo& curTest(data.haplotypes[i][j]); + std::vector sites; + sites.resize(nsite); + sites.front().setInit(ASpar.alpha, emit[0][s[0]], emit[0][s[0]]); + + stateForward(transP, sites, s, emit); + std::vector states; + stateViterbi(sites, states); + bool preArchaic(false); + bed tbed; + tbed.pstart = curComPos[0]; + tbed.pend = curComPos[0]; + tbed.start = curGdis[0]; + tbed.end = curGdis[0]; + + ++tbed.state[s[0]]; + if(curTest[0]) + { + for(int n = 0 ; n < nleaf; ++n) + tbed.diff[n] += curRefAf[n][0]; + } + else + { + for(int n = 0 ; n < nleaf ; ++n) + tbed.diff[n] += curAltAf[n][0]; + } + if(states[0]) + { + tbed.t = 1; + preArchaic = true; + } + else + { + tbed.t = -1; + preArchaic = false; + } + for(int k = 1 ; k < nsite; ++k) + { + double gdis = curGdis[k]; + long pos = curComPos[k]; + if(states[k]) + { + if(!preArchaic) + { + tbed.end = gdis; + tbed.pend = pos; + curCandidate.push_back(tbed); + + tbed.clear(); + tbed.t = 1; + tbed.start = gdis; + tbed.pstart = pos; + preArchaic = true; + } + tbed.end = gdis; + tbed.pend = pos; + ++tbed.state[s[k]]; + if(curTest[k]) + { + for(int n = 0 ; n < nleaf; ++n) + tbed.diff[n] += curRefAf[n][k]; + } + else + { + for(int n = 0 ; n < nleaf ; ++n) + tbed.diff[n] += curAltAf[n][k]; + } + } + else + { + if(preArchaic) + { + curCandidate.push_back(tbed); + tbed.clear(); + tbed.t = -1; + tbed.start = curGdis[k - 1]; + tbed.pstart = curComPos[k - 1]; + preArchaic = false; + } + tbed.end = gdis; + tbed.pend = pos; + ++tbed.state[s[k]]; + if(tbed.end - tbed.start >= minMod) + { + if(curTest[k]) + { + for(int n = 0 ; n < nleaf; ++n) + tbed.diff[n] += curRefAf[n][k]; + } + else + { + for(int n = 0 ; n < nleaf ; ++n) + tbed.diff[n] += curAltAf[n][k]; + } + } + } + } + if(preArchaic) + curCandidate.push_back(tbed); + } + } + } + std::cout << ""HMM done"" << std::endl; + double diff[nleaf], llk[nlab], mat[nlab]; + int obsAcc[4], obsUpd[4]; + std::vector > segs; + segs.resize(nlab); + std::vector > obsCount; + obsCount.resize(nlab); + for(int i = 0 ; i < nlab; ++i) + obsCount[i].resize(4, 0); + std::vector modCount; + modCount.resize(4, 0); + for(int i = 0 ; i < ncontig; ++i) + for(int j = 0 ; j < nind * 2; ++j) + { + std::vector& curCandidate(candidate[i][j]); + int nseg(curCandidate.size()); + int testPop = indexPop[j / 2]; + for(int k = 0; k < nseg; ++k) + { + const bed& startBed(curCandidate[k]); + double segStart, segEnd; + long segPstart; + if(startBed.t > 0) + { + int preMatch = seekM.segMatchLK (startBed.diff, \ + startBed.pend - startBed.pstart, testPop, mat, llk); + ++k; + segStart = startBed.start; + segPstart = startBed.pstart; + segEnd = startBed.end; + for(int l = 0 ; l < nleaf; ++l) + diff[l] = startBed.diff[l]; + for(int l = 0 ; l < 4 ; ++l) + obsAcc[l] = startBed.state[l]; + memset(obsUpd, 0, sizeof(int) * 4); + while(k < nseg) + { + const bed& curBed(curCandidate[k]); + for(int l = 0 ; l < nleaf ; ++l) + diff[l] += curBed.diff[l]; + for(int l = 0 ; l < 4 ; ++l) + obsUpd[l] += curBed.state[l]; + if(curBed.t > 0) + { + int match = seekM.segMatchLK(curBed.diff, \ + curBed.pend - curBed.pstart, testPop, mat, llk); + if(match == preMatch) + { + match = seekM.segMatchLK(diff, \ + curBed.pend - segPstart, testPop, mat, llk); + if(match == preMatch) + { + segEnd = curBed.end; + for(int l = 0 ; l < 4 ; ++l) + obsAcc[l] += obsUpd[l]; + memset(obsUpd, 0, sizeof(int) * 4); + } + else + { + segs[preMatch].push_back(segEnd - segStart); + for(int l = 0 ; l < 4 ; ++l) + { + obsCount[preMatch][l] += obsAcc[l]; + modCount[l] += obsUpd[l] - curBed.state[l]; + } + --k; + break; + } + } + else + { + segs[preMatch].push_back(segEnd - segStart); + for(int l = 0 ; l < 4 ; ++l) + { + obsCount[preMatch][l] += obsAcc[l]; + modCount[l] += obsUpd[l] - curBed.state[l]; + } + --k; + break; + } + } + else if(curBed.end - curBed.start > minMod) + { + segs[preMatch].push_back(segEnd - segStart); + for(int l = 0 ; l < 4 ; ++l) + { + obsCount[preMatch][l] += obsAcc[l]; + modCount[l] += curBed.state[l]; + } + break; + } + ++k; + } + if(k == nseg) + { + segs[preMatch].push_back(segEnd - segStart); + for(int l = 0 ; l < 4 ; ++l) + obsCount[preMatch][l] += obsAcc[l]; + } + } + } + } + std::cout << ""Matching done"" << std::endl; + double archaicLen(0); + int narchaic(0); + double temit[2][4]; + memset(temit[1], 0, sizeof(double) * 4); + +// for(int i = 0 ; i < nlab ; ++i) +// std::cout << i << '\t' << matLabels[i] << '\t' << segs[i].size() << std::endl; + for(int i = 0 ; i < narchaicPops; ++i) + { + int nseg(segs[archaicPops[i]].size()); + for(int j = 0 ; j < nseg ; ++j) + { + double s(segs[archaicPops[i]][j]); + if(s > minArch) + { + archaicLen += s; + ++narchaic; + } + } + for(int j = 0 ; j < 4 ; ++j) + temit[1][j] += obsCount[archaicPops[i]][j]; + } + double sumemit(0); + for(int i = 0 ; i < 3 ; ++i) + { + temit[0][i] = modCount[i]; + sumemit += temit[0][i]; + } + temit[0][3] = sumemit * (1 - ASpar.emit); + sumemit += temit[0][3]; + for(int i = 0 ; i < 4 ; ++i) + emit[0][i] = temit[0][i] / sumemit; + if(emit[0][0] < 1e-10) + emit[0][0] = 1e-10; + sumemit = 0; + for(int i = 0 ; i < 2 ; ++i) + sumemit += temit[1][i]; + temit[1][2] = sumemit * (1 - ASpar.emit) * (1 - ASpar.emit); + temit[1][3] = sumemit * (1 - ASpar.emit); + sumemit += temit[1][2]; + sumemit += temit[1][3]; + for(int i = 0 ; i < 4 ; ++i) + emit[1][i] = temit[1][i] / sumemit; + + double averLen(archaicLen / narchaic / 100); + double talpha, tintroT; + talpha = archaicLen / 100 / sumGdis / testInd / 2; + tintroT = 1.0 / (1 - talpha) / averLen; + + long tcheck((long)(tintroT * 100)); + + if(introTcheck.count(tcheck) || abs(tintroT - ASpar.introT) < 0.01) + { + ASpar.introT = tintroT; + ASpar.alpha = talpha; + std::cout << ""Alpha and introT converged after "" << iter << "" iteration."" << std::endl; + std::cout << ""\tAlpha: \t"" << ASpar.alpha << std::endl; + std::cout << ""\tintroT: \t"" << ASpar.introT << std::endl; + std::cout << ""\tEmmit:"" << std::endl; + for(int i = 0 ; i < 2 ; ++i) + { + for(int j = 0 ; j < 4 ; ++j) + std::cout << ""\t\t["" << i << ""]["" << j << ""] "" << emit[i][j] << std::endl; + } + break; + } + else + { + ASpar.introT = tintroT; + ASpar.alpha = talpha; + introTcheck.insert(tcheck); + } + } + { + //output + std::string path; +// path = ASpar.outPrefix + ""_hmm.seg""; +// std::ofstream fpohmmseg(path.c_str()); +// fpohmmseg << ""ID\tContig\tStart(bp)\tEnd(bp)\tStart(cM)\tEnd(cM)"" << std::endl; +// path = ASpar.outPrefix + ""_hmm.sum""; +// std::ofstream fpohmmsum(path.c_str()); +// fpohmmsum << ""ID\tArchaicProp(cM)"" << std::endl; + double minMod(-log(0.975) / ASpar.alpha / ASpar.introT * 100); + double minArch(-log(0.975) / (1 - ASpar.alpha) / ASpar.introT * 100); + //double minMod(0), minArch(0); + std::vector > > candidate; + candidate.resize(ncontig); + double hmmLen[nind * 2]; + memset(hmmLen, 0, sizeof(double) * nind * 2); + for(int i = 0 ; i < ncontig; ++i) + { + std::vector& curComPos(data.comPos[i]); + int nsite(curComPos.size()); + const std::vector >& curAltAf(altAf[i]); + const std::vector >& curRefAf(refAf[i]); + std::vector transP; + transP.resize(nsite); + std::vector& curGdis = data.gdisData[i]; + candidate[i].resize(nind * 2); + for(int j = 1; j < nsite; ++j) + transP[j].setP(ASpar.alpha, ASpar.introT, ( curGdis[j] - curGdis[j - 1] ) / 100); + for(int j = 0; j < nind * 2; ++j) + { + if(asPopLabel[j / 2] == 2) + { + std::ostringstream curHapID; + curHapID << data.comIDs[j / 2] << ""_"" << (j % 2) + 1; + const std::string& curHapIDStr(curHapID.str()); + std::vector& curCandidate(candidate[i][j]); + const std::vector& s(observS[i][j]); + const hapInfo& curTest(data.haplotypes[i][j]); + std::vector sites; + sites.resize(nsite); + for(int k = 0; k < 4 ; ++k) + sites.front().setInit(ASpar.alpha, emit[0][s[0]], emit[0][s[0]]); + + stateForward(transP, sites, s, emit); + std::vector states; + stateViterbi(sites, states); + bool preArchaic(false); + bed tbed; + tbed.pstart = curComPos[0]; + tbed.pend = curComPos[0]; + tbed.start = curGdis[0]; + tbed.end = curGdis[0]; + if(curTest[0]) + { + for(int n = 0 ; n < nleaf; ++n) + tbed.diff[n] += curRefAf[n][0]; + } + else + { + for(int n = 0 ; n < nleaf ; ++n) + tbed.diff[n] += curAltAf[n][0]; + } + if(states[0]) + { + tbed.t = 1; + preArchaic = true; + } + else + { + tbed.t = -1; + preArchaic = false; + } + for(int k = 1 ; k < nsite; ++k) + { + double gdis = curGdis[k]; + long pos = curComPos[k]; + if(states[k]) + { + if(!preArchaic) + { + tbed.end = gdis; + tbed.pend = pos; + curCandidate.push_back(tbed); + + tbed.clear(); + tbed.t = 1; + tbed.start = gdis; + tbed.pstart = pos; + preArchaic = true; + } + tbed.end = gdis; + tbed.pend = pos; + if(curTest[k]) + { + for(int n = 0 ; n < nleaf; ++n) + tbed.diff[n] += curRefAf[n][k]; + } + else + { + for(int n = 0 ; n < nleaf ; ++n) + tbed.diff[n] += curAltAf[n][k]; + } + } + else + { + if(preArchaic) + { + curCandidate.push_back(tbed); + hmmLen[j] += tbed.end - tbed.start; + //fpohmmseg << curHapIDStr << ""\t"" << contigs[i] << '\t' \ + << tbed.pstart << '\t' << tbed.pend << '\t' \ + << tbed.start << '\t' << tbed.end << std::endl; + tbed.clear(); + tbed.t = -1; + tbed.start = curGdis[k - 1]; + tbed.pstart = curComPos[k - 1]; + preArchaic = false; + } + tbed.end = gdis; + tbed.pend = pos; + if(tbed.end - tbed.start >= minMod) + { + if(curTest[k]) + { + for(int n = 0 ; n < nleaf; ++n) + tbed.diff[n] += curRefAf[n][k]; + } + else + { + for(int n = 0 ; n < nleaf ; ++n) + tbed.diff[n] += curAltAf[n][k]; + } + } + } + } + if(preArchaic) + { + curCandidate.push_back(tbed); + hmmLen[j] += tbed.end - tbed.start; + //fpohmmseg << curHapIDStr << ""\t"" << contigs[i] << '\t' \ + << tbed.pstart << '\t' << tbed.pend << '\t' \ + << tbed.start << '\t' << tbed.end << std::endl; + } + } + } + } +// for(int j = 0 ; j < nind ; ++j) +// { +// if(asPopLabel[j] == 2) +// { +// fpohmmsum << data.comIDs[j] << '\t' << \ + (double) (hmmLen[j * 2] + hmmLen[j * 2 + 1]) / sumGdis / 2 \ + << ""%"" << std::endl; +// } +// } + + path = ASpar.outPrefix + "".seg""; + std::ofstream fpomseg(path.c_str()); + fpomseg << ""ID\tContig\tStart(bp)\tEnd(bp)\tStart(cM)\tEnd(cM)\tBestMatchedPop\tBestMatchedTime"" << std::endl; + path = ASpar.outPrefix + "".sum""; + std::ofstream fpomsum(path.c_str()); + fpomsum << ""ID""; + for(int i = 0; i < nlab; ++i) + fpomsum << '\t' << seekM.labels[i] << ""(cM)""; + fpomsum << std::endl; + double diff[nleaf], llk[nlab], mat[nlab]; + + std::vector > mergeLen; + mergeLen.resize(nind * 2); + for(int i = 0 ; i < nind * 2; ++i) + mergeLen[i].resize(nlab, 0); + + for(int i = 0 ; i < ncontig; ++i) + for(int j = 0 ; j < nind * 2; ++j) + { + std::ostringstream curHapID; + curHapID << data.comIDs[j / 2] << ""_"" << (j % 2) + 1; + const std::string& curHapIDStr(curHapID.str()); + std::vector& curCandidate(candidate[i][j]); + int nseg(curCandidate.size()); + int testPop = indexPop[j / 2]; + for(int k = 0; k < nseg; ++k) + { + const bed& startBed(curCandidate[k]); + double segStart, segEnd; + long segPstart, segPend; + double bestT; + if(startBed.t > 0) + { + int preMatch = seekM.segMatchLK (startBed.diff, \ + startBed.pend - startBed.pstart, testPop, mat, llk); + ++k; + segStart = startBed.start; + segPstart = startBed.pstart; + segEnd = startBed.end; + segPend = startBed.pend; + if(preMatch >= 0) + bestT = mat[preMatch]; + else + bestT = 0; + for(int l = 0 ; l < nleaf; ++l) + diff[l] = startBed.diff[l]; + while(k < nseg) + { + const bed& curBed(curCandidate[k]); + for(int l = 0 ; l < nleaf ; ++l) + diff[l] += curBed.diff[l]; + if(curBed.t > 0) + { + int match = seekM.segMatchLK(curBed.diff, \ + curBed.pend - curBed.pstart, testPop, mat, llk); + if(match == preMatch) + { + match = seekM.segMatchLK(diff, \ + curBed.pend - segPstart, testPop, mat, llk); + if(match == preMatch) + { + segEnd = curBed.end; + segPend = curBed.pend; + if(preMatch >= 0) + bestT = mat[preMatch]; } + else + { + if(segEnd - segStart > minArch) + { + mergeLen[j][preMatch] += segEnd - segStart; + fpomseg << curHapIDStr << '\t' << contigs[i] << '\t' \ + << segPstart << '\t' << segPend << '\t' \ + << segStart << '\t' << segEnd << '\t' \ + << seekM.labels[preMatch] << '\t' \ + << bestT << std::endl; + } + --k; + break; + } + } + else + { + if(segEnd - segStart > minArch) + { + mergeLen[j][preMatch] += segEnd - segStart; + fpomseg << curHapIDStr << '\t' << contigs[i] << '\t' \ + << segPstart << '\t' << segPend << '\t' \ + << segStart << '\t' << segEnd << '\t' \ + << seekM.labels[preMatch] << '\t' \ + << bestT << std::endl; + } + --k; + break; + } + } + else if(curBed.end - curBed.start > minMod) + { + if(segEnd - segStart > minArch) + { + mergeLen[j][preMatch] += segEnd - segStart; + fpomseg << curHapIDStr << '\t' << contigs[i] << '\t' \ + << segPstart << '\t' << segPend << '\t' \ + << segStart << '\t' << segEnd << '\t' \ + << seekM.labels[preMatch] << '\t' \ + << bestT << std::endl; + } + break; + } + ++k; + } + if(k == nseg) + { + if(segEnd - segStart > minArch) + { + mergeLen[j][preMatch] += segEnd - segStart; + fpomseg << curHapIDStr << '\t' << contigs[i] << '\t' \ + << segPstart << '\t' << segPend << '\t' \ + << segStart << '\t' << segEnd << '\t' \ + << seekM.labels[preMatch] << '\t' \ + << bestT << std::endl; + } + } + } + } + } + for(int i = 0 ; i < nind ; ++i) + { + if(asPopLabel[i] == 2) + { + fpomsum << data.comIDs[i]; + for(int j = 0 ; j < nlab; ++j) + { + fpomsum << '\t' << \ + (mergeLen[i * 2][j] + mergeLen[i * 2 + 1][j]) / sumGdis / 2 \ + << '%'; + } + fpomsum << std::endl; + } + } + std::cout << ""Matching done"" << std::endl; + } +} + + + + + +/* + std::vector > > region, regionPointer; //[region][haplotype] + region.resize(ncontig); + regionPointer.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + region[i].resize(nind * 2); + regionPointer[i].resize(nind * 2); + std::vector& curComPos(data.comPos[i]); + int nsite(curComPos.size()); +// std::vector& curHap = data.haplotypes[i]; + std::vector transP; + transP.resize(nsite); + std::vector& curGdis = data.gdisData[i]; + for(int j = 1; j < nsite; ++j) + transP[j].setP(ASpar.alpha, ASpar.introT, ( curGdis[j] - curGdis[j - 1] ) / 100); + + for(int j = 0; j < nind * 2; ++j) + { + if(asPopLabel[j / 2] == 2) + { + std::vector& curRegion(region[i][j]); + std::vector& curRegionPointer(regionPointer[i][j]); + const std::vector& s(observS[i][j]); + + std::vector sites; + sites.resize(nsite); + for(int k = 0; k < 4 ; ++k) + if(s[k][0]) + //if(s[k].count(0, SEARCHMK)) + { + sites.front().setInit(ASpar.alpha, emmit[0][k], emmit[1][k]); + break; + } + stateForward(transP, sites, s, emmit); + //std::vector states; + hapInfo states; + stateViterbi(sites, states); + long start(0), end(0), itStart(0), itEnd(0); + bool preArchaic(false); + for(int k = 0 ; k < nsite; ++k) + { + long pos = curComPos[k]; + if(!states[k]) + { + if(preArchaic) + { + if(end != start) + { + bed t; + t.start = start; + t.end = end; + curRegion.push_back(t); + t.start = itStart; + t.end = itEnd; + curRegionPointer.push_back(t); + } + } + preArchaic = false; + } + else if(states[k]) + { + if(!preArchaic) + { + start = pos; + itStart = k; + preArchaic = true; + } + else if(preArchaic && pos - curComPos[k - 1] > MAXINTER) + { + bed t; + t.start = start; + t.end = end; + curRegion.push_back(t); + t.start = itStart; + t.end = itEnd; + curRegionPointer.push_back(t); + start = pos; + itStart = k; + } + end = pos; + itEnd = k; + } + } + if(preArchaic && end != start) + { + bed t; + t.start = start; + t.end = end; + curRegion.push_back(t); + t.start = itStart; + t.end = itEnd; + curRegionPointer.push_back(t); + } + } + } + } + + std::string path; + path = ASpar.outPrefix + ""_hmm.seg""; + std::ofstream fpseg(path.c_str()); + fpseg << ""ID\tContig\tStart\tEnd"" << std::endl; + path = ASpar.outPrefix + ""_hmm.sum""; + std::ofstream fpsum(path.c_str()); + fpsum << ""ID\tArchaicProp"" << std::endl; + path = ASpar.outPrefix + ""_contigs.txt""; + std::ofstream fpcontig(path.c_str()); + fpcontig << ""Contig\tTotalLength"" << std::endl; + const std::vector& contigs = data.comContigs; + long sumRegion(0); + std::map contigLen; + std::map hmmProp; + for(int i = 0 ; i < ncontig; ++i) + { + long curContigLen(0); + const std::vector& curPos(data.comPos[i]); + int curNsite(curPos.size()); + for(int j = 1; j < curNsite; ++j) + { + long len(curPos[j] - curPos[j - 1]); + if(len < MAXINTER) + curContigLen += len; + } + contigLen[contigs[i]] = curContigLen; + sumRegion += curContigLen; + fpcontig << contigs[i] << '\t' << curContigLen << std::endl; + } + for(int i = 0 ; i < ncontig; ++i) + { + for(int j = 0 ; j < nind ; ++j) + { + if(asPopLabel[j] == 2) + { + std::string& curID(data.comIDs[j]); + for(int k = 1; k <= 2 ; ++k) + { + long length(0); + std::vector& curSeg = region[i][j * 2 + k - 1]; + int nseg = curSeg.size(); + std::ostringstream curHapID; + curHapID << curID << ""_"" << k; + std::string curHapIDStr(curHapID.str()); + if(nseg == 0) + { + hmmProp[curHapIDStr] = 0; + continue; + } + for(int l = 0; l < nseg; ++l) + { + fpseg << curHapIDStr << '\t' << contigs[i] << '\t' << \ + curSeg[l].start << '\t' << curSeg[l].end << std::endl; + length += curSeg[l].end - curSeg[l].start; + hmmProp[curHapIDStr] += curSeg[l].end - curSeg[l].start; + } + } + } + } + } + for(std::map::iterator it = hmmProp.begin(); it != hmmProp.end(); ++it) + fpsum << it->first << '\t' << (double) it->second / sumRegion << std::endl; + + matchModel seekM(ASpar.seekModel); + int nleaf(seekM.leafLabs.size()); + int nlab(seekM.labels.size()); + std::vector& matLabels = seekM.labels; + std::map popCorrespond; + for(int i = 0 ; i < nleaf ; ++i) + popCorrespond[seekM.leafLabs[i]] = i; + std::vector indexPop; + indexPop.resize(nind); + for(int i = 0 ; i < nind; ++i) + { + assert(popCorrespond.count(data.comPop[i])); + indexPop[i] = popCorrespond[data.comPop[i]]; + } + + std::vector > > altAf, refAf; + altAf.resize(ncontig); + refAf.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + altAf[i].resize(nleaf); + refAf[i].resize(nleaf); + int nsite(data.comPos[i].size()); + for(int j = 0 ; j < nleaf; ++j) + { + altAf[i][j].resize(nsite, 0); + refAf[i][j].resize(nsite, 0); + } + } + std::vector > outGroup; + outGroup.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + std::vector& curOutGroup(outGroup[i]); + const std::vector& curPos(data.comPos[i]); + const std::vector& curRefAllele(data.comRefAllele[i]), \ + & curAltAllele(data.comAltAllele[i]); + int nsite(curPos.size()); + curOutGroup.resize(nsite); + gzifstream fpog(gpar.outgroupFastaPaths.at(data.comContigs[i])); + std::string faInfo; + getline(fpog, faInfo); + getline(fpog, faInfo); + int block(0); + for(int j = 0 ; j < nsite ; ++j) + { + long p(curPos[j]); + int pBlock((p - 1) / 50); + while(pBlock > block) + { + getline(fpog, faInfo); + ++block; + } + assert(pBlock == block); + int pSite((p - 1) % 50); + char allele(toupper(faInfo[pSite])); + if(allele == curRefAllele[j]) + curOutGroup[j] = 0; + else if(allele == curAltAllele[j]) + curOutGroup[j] = 1; + else if(allele == 'A' || allele == 'T' || allele == 'G' || allele == 'C') + curOutGroup[j] = 2; + else + curOutGroup[j] = -1; + } + std::vector > altCount, sumCount; + altCount.resize(nleaf); + sumCount.resize(nleaf); + for(int j = 0 ; j < nleaf; ++j) + { + altCount[j].resize(nsite, 0); + sumCount[j].resize(nsite, 0); + } + for(int j = 0 ; j < nind; ++j) + { + const hapInfo& curHap1(data.haplotypes[i][j * 2]), \ + & curHap2(data.haplotypes[i][j * 2 + 1]); + std::vector& curAlt(altCount[indexPop[j]]), \ + & curSum(sumCount[indexPop[j]]); + if(data.phased[j]) + { + for(int n = 0 ; n < 2; ++n) + { + const std::vector& curP(regionPointer[i][j * 2 + n]); + const hapInfo& curH(data.haplotypes[i][j * 2 + n]); + int p(0), curNseg(curP.size()); + for(int k = 0 ; k < nsite; ++k) + { + if(p != curNseg) + { + if(curP[p].start == k) + { + k = curP[p].end; + ++p; + continue; + } + } + if(curH[k]) + ++curAlt[k]; + ++curSum[k]; + } + } + } + else + { + for(int k = 0 ; k < nsite; ++k) + { + if(curHap1[k] && !curHap2[k]) + { + ++curAlt[k]; + curSum[k] += 2; + } + else if(!curHap1[k] && curHap2[k]) + { + curAlt[k] += 2; + curSum[k] += 2; + } + else if(!(curHap1[k] || curHap2[k])) + curSum[k] += 2; + } + } + } + for(int j = 0; j < nleaf; ++j) + { + std::vector& curAlt(altCount[j]), & curSum(sumCount[j]); + std::vector& curAltAf(altAf[i][j]), & curRefAf(refAf[i][j]); + for(int k = 0 ; k < nsite; ++k) + { + if(curSum[k]) + { + curAltAf[k] = (double)curAlt[k] / curSum[k]; + curRefAf[k] = 1 - curAltAf[k]; + } + } + } + } + std::map outgroupCheck; + for(int i = 0 ; i < ncontig; ++i) + { + int nsite(data.comPos[i].size()); + for(int j = 0 ; j < nsite; ++j) + ++outgroupCheck[outGroup[i][j]]; + } +// std::cout << ""Outgroup:"" << std::endl; +// for(int i = -1; i <=2; ++i) +// std::cout << '\t' << i << '\t' << outgroupCheck[i] << std::endl; + std::vector > pairDiff; + pairDiff.resize(nleaf); + for(int i = 0 ; i < nleaf; ++i) + pairDiff[i].resize(nleaf, 0); + for(int i = 0 ; i < ncontig; ++i) + { + const std::vector >& curRefAf(refAf[i]), & curAltAf(altAf[i]); + const std::vector& curOutGroup(outGroup[i]); + int nsite(data.comPos[i].size()); + for(int j = 0 ; j < nsite; ++j) + { + if(curOutGroup[j] >= 0) + { + for(int m = 0; m < nleaf; ++m) + for(int n = 0; n < m ; ++n) + pairDiff[m][n] += curRefAf[m][j] * curAltAf[n][j] + \ + curAltAf[m][j] * curRefAf[n][j]; + if(curOutGroup[j] == 0) + for(int m = 0 ; m < nleaf; ++m) + pairDiff[m][m] += curAltAf[m][j]; + else if(curOutGroup[j] == 1) + for(int m = 0 ; m < nleaf; ++m) + pairDiff[m][m] += curRefAf[m][j]; + else if(curOutGroup[j] == 2) + for(int m = 0 ; m < nleaf; ++m) + pairDiff[m][m] += 1; + } + } + } + seekM.modelCalibrate(pairDiff, sumRegion); + path = ASpar.outPrefix + ""_calibratedModel.txt""; + std::ofstream fpcm(path.c_str()); + for(int i = 0 ; i < nleaf; ++i) + for(int j = 0 ; j < i ; ++j) + fpcm << seekM.leafLabs[i] << '\t' << seekM.leafLabs[j] << '\t' << \ + pairDiff[i][j] << std::endl; + for(int i = 0 ; i < nlab ; ++i) + fpcm << seekM.labels[i] << '\t' << seekM.calibratedLen[i] << std::endl; + + double minMod(-log(0.975) / ASpar.alpha / ASpar.introT * 100); + double minArch(-log(0.975) / (1 - ASpar.alpha) / ASpar.introT * 100); + + std::vector< std::map > > matProp; + matProp.resize(ncontig); + indexPop.resize(nind); + for(int i = 0 ; i < nind; ++i) + { + assert(popCorrespond.count(data.comPop[i])); + indexPop[i] = popCorrespond[data.comPop[i]]; + } + std::vector > > matchRe; + matchRe.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + matchRe[i].resize(nind * 2); + for(int i = 0 ; i < ncontig; ++i) + { + std::map >& curMatProp(matProp[i]); + const std::vector& curGdis(data.gdisData[i]); + const std::vector& curPos(data.comPos[i]); + const std::vector >& curAltAf(altAf[i]), & curRefAf(refAf[i]); + for(int j = 0; j < nind * 2; ++j) + { + if(asPopLabel[j / 2] == 2) + { + int testPop = indexPop[j / 2]; + const hapInfo& curTest(data.haplotypes[i][j]); + std::vector& curRegionPointer(regionPointer[i][j]); + std::ostringstream curHapID; + curHapID << data.comIDs[j / 2] << ""_"" << (j % 2) + 1; + std::string curHapIDStr(curHapID.str()); + if(curMatProp[curHapIDStr].size() == 0) + curMatProp[curHapIDStr].resize(nlab, 0); + int nseg(curRegionPointer.size()); + if(nseg == 0) + continue; + std::vector hmmMatch; + hmmMatch.resize(nseg, 0); + for(int k = 0 ; k < nseg; ++k) + { + double diff[nleaf], mat[nlab], llk[nlab]; + memset(diff, 0, sizeof(double) * nleaf); + int start(curRegionPointer[k].start), end(curRegionPointer[k].end); + for(int l = start; l <= end; ++l) + { + if(curTest[l]) + { + for(int n = 0 ; n < nleaf; ++n) + diff[n] += curRefAf[n][l]; + } + else + { + for(int n = 0 ; n < nleaf; ++n) + diff[n] += curAltAf[n][l]; + } + } + double curLen(curPos[end] - curPos[start]); + hmmMatch[k] = seekM.segMatchLK(diff, curLen, testPop, mat, llk); + curRegionPointer[k].t = mat[hmmMatch[k]]; + } + bed t(curRegionPointer[0]); + int preMatch(hmmMatch[0]); + std::vector& curResults(matchRe[i][j]); + for(int k = 1 ; k < nseg; ++k) + { + //0.128 + if(curGdis[curRegionPointer[k].start] - curGdis[t.end] > minMod || \ + (t.end - curRegionPointer[k].start <= 1 && \ + curPos[t.end] - curPos[curRegionPointer[k].start] > MAXINTER)) + { + if(curGdis[t.end] - curGdis[t.start] > minArch) + { + std::ostringstream tre; + tre << curHapIDStr << '\t' << contigs[i] << '\t' << \ + curPos[t.start] << '\t' << curPos[t.end] << '\t'; + if(preMatch == -1) + tre << ""Unknown\t-""; + else + { + tre << matLabels[preMatch] << '\t' << t.t; + curMatProp[curHapIDStr][preMatch] += curPos[t.end] - \ + curPos[t.start]; + } + curResults.push_back(tre.str()); + } + t.start = curRegionPointer[k].start; + t.end = curRegionPointer[k].end; + t.t = curRegionPointer[k].t; + preMatch = hmmMatch[k]; + } + else + { + if(preMatch == hmmMatch[k]) + { + double diff[nleaf], mat[nlab], llk[nlab]; + memset(diff, 0, sizeof(double) * nleaf); + for(int l = t.start; l <= curRegionPointer[k].end; ++l) + { + if(curTest[l]) + { + for(int n = 0 ; n < nleaf; ++n) + diff[n] += curRefAf[n][l]; + } + else + { + for(int n = 0 ; n < nleaf; ++n) + diff[n] += curAltAf[n][l]; + } + } + double curLen(curPos[curRegionPointer[k].end] - curPos[t.start]); + int best = seekM.segMatchLK(diff, curLen, testPop, mat, llk); + if(best == preMatch) + { + t.end = curRegionPointer[k].end; + t.t = mat[best]; + } + else + { + if(curGdis[t.end] - curGdis[t.start] > minArch) + { + std::ostringstream tre; + tre << curHapIDStr << '\t' << contigs[i] << '\t' << \ + curPos[t.start] << '\t' << curPos[t.end] << '\t'; + if(preMatch == -1) + tre << ""Unknown\t-""; + else + { + tre << matLabels[preMatch] << '\t' << t.t; + curMatProp[curHapIDStr][preMatch] += curPos[t.end] - \ + curPos[t.start]; + } + curResults.push_back(tre.str()); + } + t.start = curRegionPointer[k].start; + t.end = curRegionPointer[k].end; + t.t = curRegionPointer[k].t; + preMatch = hmmMatch[k]; + } + } + else + { + if(curGdis[t.end] - curGdis[t.start] > minArch) + { + std::ostringstream tre; + tre << curHapIDStr << '\t' << contigs[i] << '\t' << \ + curPos[t.start] << '\t' << curPos[t.end] << '\t'; + if(preMatch == -1) + tre << ""Unknown\t-""; + else + { + tre << matLabels[preMatch] << '\t' << t.t; + curMatProp[curHapIDStr][preMatch] += curPos[t.end] - \ + curPos[t.start]; + } + curResults.push_back(tre.str()); + } + t.start = curRegionPointer[k].start; + t.end = curRegionPointer[k].end; + t.t = curRegionPointer[k].t; + preMatch = hmmMatch[k]; + } + } + } + if(curGdis[t.end] - curGdis[t.start] > minArch) + { + std::ostringstream tre; + tre << curHapIDStr << '\t' << contigs[i] << '\t' << curPos[t.start] << \ + '\t' << curPos[t.end] << '\t'; + if(preMatch == -1) + tre << ""Unknown\t-""; + else + { + tre << matLabels[preMatch] << '\t' << t.t; + curMatProp[curHapIDStr][preMatch] += curPos[t.end] - curPos[t.start]; + } + curResults.push_back(tre.str()); + } + } + } + } + path = ASpar.outPrefix + ""_mergeLK.seg""; + std::ofstream fpmerge(path.c_str()); + fpmerge << ""ID\tContig\tStart\tEnd\tBestMatchedPop\tBestMatchedTime"" << std::endl; + for(int i = 0 ; i < ncontig; ++i) + for(int j = 0 ; j < nind * 2; ++j) + for(unsigned int k = 0 ; k < matchRe[i][j].size(); ++k) + fpmerge << matchRe[i][j][k] << std::endl; + path = ASpar.outPrefix + ""_mergeLK.sum""; + std::ofstream fpmergeSum(path.c_str()); + fpmergeSum << ""ID""; + for(int i = 0; i < nlab; ++i) + fpmergeSum << '\t' << seekM.labels[i]; + fpmergeSum << std::endl; + for(std::map >::iterator it = matProp[0].begin(); \ + it != matProp[0].end(); ++it) + { + std::string id(it->first); + fpmergeSum << id; + double len[nlab]; + memset(len, 0, sizeof(double) * nlab); + for(int i = 0 ; i < ncontig; ++i) + { + for(int j = 0 ; j < nlab; ++j) + len[j] += matProp[i][id][j]; + } + for(int i = 0 ; i < nlab ; ++i) + fpmergeSum << '\t' << len[i] / sumRegion; + fpmergeSum << std::endl; + } +} + + +*/ + +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","src/ArchaicSeeker.cpp",".cpp","3167","105","/* + * ArchaicSeeker.cpp + * + * Created on: Oct 10, 2018 + * Author: yuankai + */ + +# include ""data.hpp"" +# include ""seeker.hpp"" + +# include +# include +# include +# include +# include + +static struct option archaicSeekerHMMOpt[] = +{ + {""alpha"", required_argument, NULL, 'a'}, + {""introT"", required_argument, NULL, 'T'}, + {""emit"", required_argument, NULL, 'e'}, + {""out"", required_argument, NULL, 'o'}, + {""vcf"", required_argument, NULL, 'v'}, + {""pop"", required_argument, NULL, 'p'}, + {""remap"", required_argument, NULL, 'r'}, + {""model"", required_argument, NULL, 'm'}, + {""outgroup"", required_argument, NULL, 'X'}, + {""anc"", required_argument, NULL, 'A'}, + {""help"", required_argument, NULL, 'h'}, +}; + +void archaicSeekerHMMHelp() +{ + std::cout << ""ArchaicSeekerHMM v2.0"" << std::endl; + std::cout << "" -a / --alpha [0.02] Introgression proportion."" << std::endl; + std::cout << "" -T / --introT [2000] Introgression time(in generation)."" << std::endl; + std::cout << "" -e / --emit [0.99] Emission probability parameter."" << std::endl; + std::cout << "" -o / --out Output prefix."" << std::endl; + std::cout << "" -v / --vcf VCF configuration file"" << std::endl; + std::cout << "" -p / --pop Population annotation file."" << std::endl; + std::cout << "" -r / --remap Recombination configuration file."" << std::endl; + std::cout << "" -X / --outgroup Outgroup genome configuration file."" << std::endl; + std::cout << "" -A / --anc Ancestral state configuration file."" << std::endl; + std::cout << "" -m / --model Admixture model file."" << std::endl; + std::cout << "" -h / --help Print this help."" << std::endl; + exit(0); +} + +int main(int argc, char **argv) +{ + archaicSeekerPar ASpar; + genomePar gpar; + if(argc <= 1) + archaicSeekerHMMHelp(); + char optstring[] = ""a:T:e:o:v:p:r:X:A:m:h""; + char opt; + std::map parCheck; + while((opt = getopt_long_only(argc, argv, optstring, archaicSeekerHMMOpt, NULL)) != -1) + { + switch (opt) + { + case 'a': ASpar.alpha = atof(optarg); break; + case 'T': ASpar.introT = atof(optarg); break; + case 'e': ASpar.emit = atof(optarg); break; + case 'o': ASpar.outPrefix = optarg; break; + case 'v': gpar.vcfPar = optarg; break; + case 'p': gpar.popPar = optarg; break; + case 'r': gpar.remapPar = optarg; break; + case 'X': gpar.outgroupPar = optarg; break; + case 'A': gpar.ancestralPar = optarg; break; + case 'm': ASpar.seekModel = optarg; break; + case 'h': archaicSeekerHMMHelp(); break; + case '?': std::cout << ""Cannot identify parameter "" << opt << std::endl; + archaicSeekerHMMHelp(); + } + ++parCheck[opt]; + } + assert(parCheck['a'] <= 1); + assert(parCheck['T'] <= 1); + assert(parCheck['e'] <= 1); + assert(parCheck['m'] == 1); + assert(parCheck['o'] == 1); + assert(parCheck['v'] == 1); + assert(parCheck['p'] == 1); + assert(parCheck['r'] == 1); + assert(parCheck['X'] == 1); + assert(parCheck['A'] == 1); + + std::ifstream fpi(ASpar.seekModel.c_str()); + getline(fpi, ASpar.seekModel); +// omp_set_num_threads(ASpar.nthreads); + gpar.load(); + archaicSeekerHMM(ASpar, gpar); +} + + + + + + + + + + +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","src/seeker.hpp",".hpp","544","31","/* + * seeker.hpp + * + * Created on: Oct 10, 2018 + * Author: yuankai + */ + +#ifndef SEEKER_HPP_ +#define SEEKER_HPP_ + +# include ""data.hpp"" +# include ""gzfstream.hpp"" + +# include + +const long MAXINTER = 100000; + +class archaicSeekerPar +{ +public: + archaicSeekerPar() : alpha(0.02), introT(2000), emit(0.99), nthreads(1), \ + outPrefix(""""), seekModel("""") {} + double alpha, introT, emit; + int nthreads; + std::string outPrefix, seekModel; +}; + +void archaicSeekerHMM(archaicSeekerPar& ASpar, const genomePar& gpar); + +#endif /* SEEKER_HPP_ */ +","Unknown" +"Allele","Shuhua-Group/ArchaicSeeker2.0","src/matching.cpp",".cpp","14493","612","/* + * matching.cpp + * + * Created on: Oct 10, 2018 + * Author: yuankai + */ + +# include ""matching.hpp"" + +# include +# include +# include +# include + +# include ""boost/algorithm/string.hpp"" + +const int MAXEVAL = 10000; + +newickNode::newickNode(const std::string& tree) : label(""""), dis(0), \ + nchild(0), child(NULL), parent(NULL) +{ + std::string str = boost::algorithm::trim_copy(tree); + if(str[str.size() - 1] == ';') + str = str.substr(0, str.size() - 1); + str += "":0""; + label = _load(str, NULL); +} + +newickNode::~newickNode() +{ + if(nchild) + delete[] child; +} + +//Go through all the node from up to bottom +void newickNode::traversal(newickFunc& func) +{ + func(*this); + for(int i = 0 ; i < nchild; ++i) + child[i].traversal(func); +} + +void newickNode::search(newickDirFunc& func) +{ + if(func.check.count(this)) + return; + func.check.insert(this); + func(*this); + bool curFirst(func.isFirst); + if(func.isFirst) + func.isFirst = false; + if(parent) + { + func.preNode = this; + func.upper = true; + if(curFirst) + func.upSearchStat = 1; + parent->search(func); + } + if(nchild) + for(int i = 0 ; i < nchild; ++i) + { + func.preNode = this; + func.upper = false; + if(curFirst) + func.upSearchStat = -1; + child[i].search(func); + } +} + +void labcheck::operator ()(newickNode& node) +{ + assert(access.count(node.getLab()) == 0); + access[node.getLab()] = &node; +} + +void getNodeLab::operator ()(newickNode& node) +{ + if(node.nchild == 0) + leafLab.push_back(node.getLab()); + else if(node.parent != NULL) + midLab.push_back(node.getLab()); + labels.push_back(node.getLab()); +} + +#ifdef DEBUG + +void labprint::operator ()(newickNode& node) +{ + std::cout << node.getLab() << '\t' << node.getDis() << std::endl; + if(node.parent != NULL) + std::cout << ""\tParent:\t"" << node.parent->getLab() << std::endl; + if(node.nchild != 0) + { + std::cout << ""\tChild:""; + for(int i = 0 ; i < node.nchild; ++i) + std::cout << '\t' << node.child[i].getLab() ; + std::cout << std::endl; + } +} + +#endif//DEBUG + +void disSearch::operator ()(newickNode& node) +{ + if(preNode) + { + if(upper) + { + disMem[&node] = preNode->getDis() + disMem[preNode]; + nodeCheck[node.getLab()] = nodeCheck[preNode->getLab()]; + nodeCheck[node.getLab()].insert(preNode->getLab()); + } + else + { + disMem[&node] = node.getDis() + disMem[preNode]; + nodeCheck[node.getLab()] = nodeCheck[preNode->getLab()]; + nodeCheck[node.getLab()].insert(node.getLab()); + } + } + else + disMem[&node] = 0; + labDis[node.getLab()] = disMem[&node]; + isUpSearch[node.getLab()] = upSearchStat; +} + +std::string newickNode::_load(const std::string& subTree, newickNode* upper) +{ + parent = upper; + int p(subTree.size() - 1); + while(p > 0 && subTree[p] != ':') + --p; + assert(p != 0); + assert(p != (int)subTree.size() - 1); + + dis = atof(subTree.substr(p + 1).c_str()); + + if(subTree[0] == '(') + { + assert(p >= 2); + assert(subTree[p - 1] == ')'); + std::vector sp; + std::string t = subTree.substr(1, p - 2); + int bracket(0); + uint pre(0); + for(uint i = 0 ; i < t.size(); ++i) + { + if(t[i] == '(') + ++bracket; + else if(t[i] == ')') + --bracket; + else if(t[i] == ',' && bracket == 0) + { + sp.push_back(t.substr(pre, i - pre)); + pre = i + 1; + } + } + sp.push_back(t.substr(pre)); + nchild = sp.size(); + child = new newickNode[nchild]; + label = child[0]._load(sp[0], this); + for(int i = 1 ; i < nchild ; ++i) + label += ""_"" + child[i]._load(sp[i], this); + } + else + label = subTree.substr(0, p); + return label; +} + +matFuncData::~matFuncData() +{ + if(nleaf) + { + for(int i = 0 ; i < nleaf; ++i) + { + for(int j = 0 ; j < nlab; ++j) + delete[] dc[i][j]; + delete[] dc[i]; + } + for(int i = 0 ; i < nlab ; ++i) + delete[] eta[i]; + delete[] dc; + delete[] eta; + delete[] diff; + } +} + +void matFuncData::init(int _nleaf, int _nlab) +{ + if(nleaf || nlab) + { + for(int i = 0 ; i < nleaf; ++i) + { + for(int j = 0 ; j < nlab; ++j) + delete[] dc[i][j]; + delete[] dc[i]; + } + for(int i = 0 ; i < nlab ; ++i) + delete[] eta[i]; + delete[] dc; + delete[] eta; + delete[] diff; + } + assert(_nleaf); + assert(_nlab); + nleaf = _nleaf; + nlab = _nlab; + dc = new double** [nleaf]; + for(int i = 0 ; i < nleaf; ++i) + { + dc[i] = new double* [nlab]; + for(int j = 0 ; j < nlab; ++j) + { + dc[i][j] = new double [nleaf]; + memset(dc[i][j], 0, sizeof(double) * nleaf); + } + } + eta = new double* [nlab]; + for(int i = 0 ; i < nlab; ++i) + { + eta[i] = new double[nleaf]; + memset(eta[i], 0, sizeof(double) * nleaf); + } + diff = new double [nleaf]; + memset(diff, 0, sizeof(double) * nleaf); +} + +double matLKFunc(unsigned int n, const double *x, double *grad, void *matData) +{ + curMatFuncData *data = (curMatFuncData *) matData; + double denon[data->nleaf]; +// std::cout << ""mu: "" << data->mu << std::endl; + double mu(data->mu); + double len(data->len); + for(int i = 0 ; i < data->nleaf; ++i) + denon[i] = data->curDc[i] + data->curEta[i] * x[0]; + if(grad) + { + grad[0] = 0; + for(int i = 0 ; i < data->nleaf; ++i) + { + grad[0] += data->curDiff[i] / len / mu * data->curEta[i] / denon[i] \ + - data->curEta[i]; + } + } + double ret(0); + for(int i = 0 ; i < data->nleaf; ++i) + { + ret += data->curDiff[i] / len / mu * log(denon[i]) - denon[i]; + } +/* ++data->inter; + + std::cout << ""iter: "" << data->inter << std::endl; + for(int i = 0 ; i < data->nleaf; ++i) + std::cout << '\t' << data->curDiff[i]; + std::cout << std::endl; + for(int i = 0 ; i < data->nleaf; ++i) + std::cout << '\t' << data->curEta[i]; + std::cout << std::endl; + std::cout << grad[0] << '\t' << grad[1] << std::endl; + std::cout << x[0] << '\t' << x[1] << std::endl; +*/ + return ret; +} + +double modelCalibrateFunc(unsigned int n, const double *x, double *grad, void *matData) +{ + modelCalibrateData *data = (modelCalibrateData *) matData; + int nlab(data->nlab), nleaf(data->nleaf); + double mu(data->mu), length(data->length); + double ret(0); + if(grad) + { + memset(grad, 0, sizeof(double) * ( nlab )); + for(int i = 0 ; i < nleaf ; ++i) + { + for(int j = 0 ; j < i ; ++j) + { + const double& diff(data->pairDiff[i][j] / length / mu); + double t(0); + const std::vector& curLab(data->pairLab[i][j]); + for(int k = 0 ; k < nlab; ++k) + { + t += curLab[k] * x[k]; + } + for(int k = 0 ; k < nlab; ++k) + grad[k] += curLab[k] * ( diff / t - 1.0 ); + ret += diff * log( t ) - t; + } + double rt(0); + const std::vector& curRootLab(data->rootLab[i]); + for(int k = 0 ; k < nlab; ++k) + rt += curRootLab[k] * x[k]; + const double& rdiff(data->pairDiff[i][i] / length / mu); + for(int k = 0 ; k < nlab; ++k) + grad[k] += curRootLab[k] * ( rdiff / rt - 1.0 ); + ret += rdiff * log(rt) - rt; + } + } + else + { + for(int i = 0 ; i < nleaf ; ++i) + { + for(int j = 0 ; j < i ; ++j) + { + const double& diff(data->pairDiff[i][j] / length / mu); + double t(0); + const std::vector& curLab(data->pairLab[i][j]); + for(int k = 0 ; k < nlab; ++k) + t += curLab[k] * x[k]; + ret += diff * log( t ) - t; + } + double rt(0); + const std::vector& curRootLab(data->rootLab[i]); + for(int k = 0 ; k < nlab; ++k) + rt += curRootLab[k] * x[k]; + const double& rdiff(data->pairDiff[i][i] / length / mu); + ret += rdiff * log(rt) - rt; + } + } + return ret; +} + +double modelCalibrateConstraintFunc(unsigned int n, const double *x, double *grad, \ + void *cData) +{ + modelCalibrateConstraintData *data = (modelCalibrateConstraintData *) cData; + int nlab(data->lab1.size()); + if(grad) + { + for(int i = 0 ; i < nlab; ++i) + grad[i] = data->lab1[i] - data->lab2[i]; + grad[nlab] = 0; + } + double ret(0); + for(int i = 0 ; i < nlab ; ++i) + { + ret += data->lab1[i] * x[i] - data->lab2[i] * x[i]; + } + ret -= data->diff; + return ret; +} + +matchModel::matchModel(const std::string& m) : model(m) +{ + model.traversal(access); + getNodeLab gleaf(labels, leafLabs, midLabs); + model.traversal(gleaf); + int nlab = labels.size(); + int nleaf = leafLabs.size(); + nodeTestUpbound.resize(nlab); + for(int i = 0 ; i < nlab; ++i) + { + access.access.at(labels[i])->search(search[labels[i]]); + nodeTestUpbound[i] = access.access.at(labels[i])->dis; + } + assert(nlab > 2); + nodeLen.resize(nleaf); + rootLen.resize(nlab); + const disSearch& rootSearch = search[model.getLab()]; + double maxLen(0); + for(int i = 0; i < nleaf; ++i) + nodeLen[i] = rootSearch.labDis.at(leafLabs[i]); + for(int i = 0; i < nlab ; ++i) + { + rootLen[i] = rootSearch.labDis.at(labels[i]); + if(maxLen < rootLen[i]) + maxLen = rootLen[i]; + } + nodeTestUpbound[0] = maxLen; + nodeDis.resize(nlab); + for(int i = 0; i < nlab; ++i) + { + std::vector& curDis = nodeDis[i]; + const disSearch& curSearch = search.at(labels[i]); + curDis.resize(nleaf); + for(int j = 0; j < nleaf; ++j) + curDis[j] = curSearch.labDis.at(leafLabs[j]); + } + matData.init(nleaf, nlab); + initVal = new double* [nlab]; + lb = new double* [nlab]; + ub = new double* [nlab]; + for(int i = 0 ; i < nlab; ++i) + { + lb[i] = new double[1]; + lb[i][0] = 1e-128; + ub[i] = new double[1]; + ub[i][0] = nodeTestUpbound[i]; + initVal[i] = new double[1]; + initVal[i][0] = nodeTestUpbound[i] / 2; + } + for(int i = 0 ; i < nlab; ++i) + { + const disSearch& curSearch = search[labels[i]]; + for(int j = 0; j < nleaf; ++j) + if(curSearch.isUpSearch.at(leafLabs[j]) != 1) + matData.eta[i][j] = 2; + } + for(int i = 0 ; i < nleaf; ++i) + for(int j = 0 ; j < nlab; ++j) + { + double d(nodeLen[i] - rootLen[j]); + for(int k = 0 ; k < nleaf; ++k) + matData.dc[i][j][k] = d + nodeDis[j][k]; + } + pairTreeDis.resize(nleaf); + pairLab.resize(nleaf); + for(int i = 0; i < nlab; ++i) + { + std::vector& curDis = nodeDis[i]; + const disSearch& curSearch = search.at(labels[i]); + curDis.resize(nleaf); + for(int j = 0; j < nleaf; ++j) + curDis[j] = curSearch.labDis.at(leafLabs[j]); + } + for(int i = 0; i < nleaf; ++i) + { + pairTreeDis[i].resize(nleaf, 0); + pairLab[i].resize(nleaf); + const disSearch& curSearch = search.at(leafLabs[i]); + for(int j = 0 ; j < i; ++j) + { + pairTreeDis[i][j] = curSearch.labDis.at(leafLabs[j]); + pairLab[i][j].resize(nlab, 0); + for(int k = 0 ; k < nlab ; ++k) + { + if(curSearch.nodeCheck.at(leafLabs[j]).count(labels[k])) + pairLab[i][j][k] = 1; + } + } + } + rootLab.resize(nleaf); + for(int i = 0 ; i < nleaf; ++i) + { + rootLab[i].resize(nlab, 0); + rootLab[i][0] = 1; + for(int j = 1 ; j < nlab ; ++j) + { + if(rootSearch.nodeCheck.at(leafLabs[i]).count(labels[j])) + rootLab[i][j] = 1; + } + } + mu = -1; +} + +matchModel::~matchModel() +{ + int nlab = labels.size(); + for(int i = 0 ; i < nlab; ++i) + { + delete[] initVal[i]; + delete[] lb[i]; + delete[] ub[i]; + } + delete[] initVal; + delete[] lb; + delete[] ub; +} + +int matchModel::segMatchLK(double* ndiff, double length, int recep, double* mat, double* llk) const +{ + int nleaf (leafLabs.size()), nlab(labels.size()); + for(int i = 0 ; i < nleaf; ++i) + matData.diff[i] = ndiff[i]; + double x; + double tol(1e-9); + for(int i = 0 ; i < nlab; ++i) + { + nlopt_opt opt; + opt = nlopt_create(NLOPT_LD_MMA, 1); + nlopt_set_lower_bounds(opt, lb[i]); + nlopt_set_upper_bounds(opt, ub[i]); + curMatFuncData d(matData, length, recep, i); + nlopt_set_max_objective(opt, matLKFunc, &d); + x = initVal[i][0]; + nlopt_set_xtol_abs(opt, &tol); + nlopt_set_maxeval(opt, MAXEVAL); + double tllk; + if(nlopt_optimize(opt, &x, &tllk) < 0) + llk[i] = -HUGE_VAL; + else + { + llk[i] = tllk; + mat[i] = x; + } + nlopt_destroy(opt); + } + double maxLK(llk[0]); + int maxP(0); + for(int i = 2; i < nlab; ++i) + if(maxLK < llk[i]) + { + maxP = i; + maxLK = llk[i]; + } + return maxP; +} + +void matchModel::modelCalibrate(const std::vector >& pairDiff, long len) +{ + int nleaf(leafLabs.size()); + int nlab(labels.size()); + double sum(0), sumLen(0); + for(int i = 0 ; i < nleaf; ++i) + for(int j = 0 ; j < i ; ++j) + { + sum += pairDiff[i][j] / len; + sumLen += pairTreeDis[i][j]; + } + mu = sum / sumLen; + modelCalibrateData cData(pairDiff, pairLab, rootLab, mu, len); + double calLen[nlab]; + nlopt_opt opt; + opt = nlopt_create(NLOPT_LD_MMA, nlab); + double clb[nlab], cub[nlab], ctol[nlab]; + for(int i = 0 ; i < nlab ; ++i) + { + calLen[i] = nodeTestUpbound[i]; + clb[i] = 1e-128; + cub[i] = HUGE_VAL; + ctol[i] = 1e-9; + } + double llk(0); + nlopt_set_lower_bounds(opt, clb); + nlopt_set_upper_bounds(opt, cub); + nlopt_set_max_objective(opt, modelCalibrateFunc, &cData); +/* std::vector constraintData; + for(int i = 0 ; i < nleaf ; ++i) + for(int j = 0 ; j < i ; ++j) + { + constraintData.push_back(modelCalibrateConstraintData(rootLab[i], rootLab[j], \ + nodeLen[i] - nodeLen[j]) ); + std::cout << leafLabs[i] << '\t' << leafLabs[j] << '\t' << \ + nodeLen[i] - nodeLen[j] << std::endl; + nlopt_add_equality_constraint(opt, modelCalibrateConstraintFunc, \ + &constraintData, 1e-9); + } + */ + nlopt_set_xtol_abs(opt, ctol); + nlopt_set_maxeval(opt, MAXEVAL); + if(nlopt_optimize(opt, calLen, &llk) < 0) + { + std::cout << ""Cannot find the opt"" << std::endl; + llk = -HUGE_VAL; + } + + nlopt_destroy(opt); + calibratedLen.resize(nlab, 0); + for(int i = 0 ; i < nlab ; ++i) + calibratedLen[i] = calLen[i]; + + for(int i = 0 ; i < nlab ; ++i) + { + access.access.at(labels[i])->dis = calibratedLen[i]; + nodeTestUpbound[i] = calibratedLen[i]; + } + search.clear(); + for(int i = 0 ; i < nlab ; ++i) + access.access.at(labels[i])->search(search[labels[i]]); + + const disSearch& rootSearch = search[model.getLab()]; + double maxLen(0); + for(int i = 0; i < nleaf; ++i) + nodeLen[i] = rootSearch.labDis.at(leafLabs[i]); + for(int i = 0; i < nlab ; ++i) + { + rootLen[i] = rootSearch.labDis.at(labels[i]); + if(maxLen < rootLen[i]) + maxLen = rootLen[i]; + } + nodeTestUpbound[0] = maxLen; + for(int i = 0; i < nlab; ++i) + { + ub[i][0] = nodeTestUpbound[i]; + initVal[i][0] = nodeTestUpbound[i] / 2; + } + for(int i = 0; i < nlab; ++i) + { + std::vector& curDis = nodeDis[i]; + const disSearch& curSearch = search.at(labels[i]); + for(int j = 0; j < nleaf; ++j) + curDis[j] = curSearch.labDis.at(leafLabs[j]); + } + for(int i = 0; i < nleaf; ++i) + { + const disSearch& curSearch = search.at(leafLabs[i]); + for(int j = 0 ; j < i; ++j) + { + pairTreeDis[i][j] = curSearch.labDis.at(leafLabs[j]); + } + } + + for(int i = 0 ; i < nleaf; ++i) + for(int j = 0 ; j < nlab; ++j) + { + double d(nodeLen[i] - rootLen[j]); + //std::cout << d << std::endl; + for(int k = 0 ; k < nleaf; ++k) + matData.dc[i][j][k] = d + nodeDis[j][k]; + } + matData.mu = mu; +// std::cout << matData.mu << std::endl; +// std::cout << mu << std::endl; +} + + + + + + +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","src/data.hpp",".hpp","4563","172","/* + * data.hpp + * + * Created on: Sep 29, 2018 + * Author: yuankai + */ + +#ifndef DATA_HPP_ +#define DATA_HPP_ + +# include +# include +# include +# include +# include +# include + +class hapInfo +{ +public: + hapInfo() : nBlock(0), nByte(0), capBlock(16), nInfo(0), mem(NULL) + { mem = new unsigned char[16]; memset(mem, 0, 16);} + hapInfo(const hapInfo& rhs); + hapInfo(int cap); + ~hapInfo() { delete[] mem; } + + void set(int n); + void set(); + void reset(int n); + void reset(); + void flip(); + int count() const; + int count(int start, int end) const; + int size() const; + void resize(int s); + void reserve(int s); + + hapInfo operator&(const hapInfo& rhs) const; + void operator&=(const hapInfo& rhs); + hapInfo operator|(const hapInfo& rhs) const; + void operator|=(const hapInfo& rhs); + hapInfo operator^(const hapInfo& rhs) const; + void operator^=(const hapInfo& rhs); + bool operator[](const int n) const; + hapInfo& operator=(const hapInfo& rhs); + hapInfo operator~() const; + + friend int hapDiff(const hapInfo& a, const hapInfo& b); + friend int hapDiff(const hapInfo& a, const hapInfo& b, int start, int end); + +#ifdef DEBUG + void print() + { + std::cout << ""nBlock:\t"" << nBlock << std::endl; + std::cout << ""nByte:\t"" << nByte << std::endl; + std::cout << ""capBlock:\t"" << capBlock << std::endl; + std::cout << ""nInfo:\t"" << nInfo << std::endl; + for(int i = 0 ; i < capBlock; ++i) + { + std::cout << i << '\t'; + std::cout << std::bitset<8>(mem[i]); + std::cout << std::endl; + } + } + void simplePrint() + { + for(int i = 0 ; i < capBlock; ++i) + std::cout << std::bitset<8>(mem[i]) << '\t'; + std::cout << std::endl; + } + std::string to_string() + { + std::ostringstream s; + for(int i = 0 ; i < nBlock; ++i) + s << std::bitset<8>(mem[i]) << '\t'; + if(nByte) + s << std::bitset<8>(mem[nBlock]).to_string().substr(8-nByte); + return s.str(); + } +#endif //DEBUG +private: + //nBlock, nByte and nInfo are the current end of the haplotype; capBlock is the capability. + int nBlock, nByte, capBlock, nInfo; + + unsigned char *mem; +}; + +int hapDiff(const hapInfo& a, const hapInfo& b); +int hapDiff(const hapInfo& a, const hapInfo& b, int start, int end); + +class genomePar +{ +public: + genomePar(){}; + genomePar(const std::string& _vcfPar, const std::string& _popPar, \ + const std::string& _remapPar) : vcfPar(_vcfPar), popPar(_popPar), \ + remapPar(_remapPar) { vcfParLoad(); remapParLoad(); popParLoad(); } + + void load() {vcfParLoad(); remapParLoad(); popParLoad(); outgroupFastaPathLoad(); \ + ancestralFastaPathLoad(); } + + //Path to vcf par file, path to recombination par file and path to pop info file + std::string vcfPar, popPar, remapPar; + + //Path to outgroup par file + std::string outgroupPar; + + //Path to ancestral par file + std::string ancestralPar; + + //vcf file paths, recombination map file paths, recombination map contigs + std::vector vcfPaths, remapPaths, remapContigs; + + //ID info for ""Archaic""(0), ""African""(1) and ""Test""(2) population + //corresponding population information + std::vector > idInfos, popInfos; + + //From id to pop label + std::map popCheck; + + //From id to as pop label + std::map ASpopCheck; + + //Outgroup fasta + std::map outgroupFastaPaths; + + //Ancestral fasta + std::map ancestralFastaPaths; +private: + void vcfParLoad(); + void remapParLoad(); + void popParLoad(); + void outgroupFastaPathLoad(); + void ancestralFastaPathLoad(); +}; + +class genome +{ +public: + genome(const genomePar& _par) : par(_par) + { + remapLoad(par.remapPaths, par.remapContigs); + vcfsLoad(par.vcfPaths); + ancestralLoad(par.ancestralFastaPaths); + }; + + const genomePar& par; + + std::vector comIDs, comPop, comContigs; + std::vector comASPop; + std::vector > comPos; + std::vector > comRefAllele, comAltAllele; + std::vector phased; + //[contig] [id] + std::vector > haplotypes; + //T means Alt is ancestral allele, F is other + std::vector ancestralState; + std::vector > gdisData; + +private: + void vcfsLoad(const std::vector& paths); + void remapLoad(const std::vector& paths, \ + const std::vector& contigs); + void ancestralLoad(const std::map& ancestralFastaPaths); + + std::vector > gdisMap; + std::vector > posMap; + std::map contigMap; +}; + +#endif /* DATA_HPP_ */ +","Unknown" +"Allele","Shuhua-Group/ArchaicSeeker2.0","src/data.cpp",".cpp","23294","954","/* + * data.cpp + * + * Created on: Sep 29, 2018 + * Author: yuankai + */ + +# include ""data.hpp"" +# include ""gzfstream.hpp"" + +# include +# include +# include +# include + +const unsigned char bitTable[] = {1, 2, 4, 8, 16, 32, 64, 128}; + +const int byteCountTable[] = +{ +0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, +1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, +1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, +2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, +1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, +2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, +2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, +3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 +}; + +hapInfo::hapInfo(const hapInfo& rhs) : nBlock(rhs.nBlock), nByte(rhs.nByte), \ + capBlock(rhs.capBlock), nInfo(rhs.nInfo) +{ + mem = new unsigned char[capBlock]; + memcpy(mem, rhs.mem, capBlock); +} + +hapInfo::hapInfo(int s) : mem(NULL) +{ + nBlock = s >> 3; + nByte = s % 8; + nInfo = s; + capBlock = nBlock + 1; + mem = new unsigned char[capBlock]; + memset(mem, 0, capBlock); +} + +void hapInfo::set(int n) +{ + assert(n < nInfo && n >= 0 ); + int block(n >> 3), bit(n % 8); + mem[block] |= bitTable[bit]; +} + +void hapInfo::set() +{ + memset(mem, -1, nBlock); + if(nByte) + mem[nBlock] = -1; +} + +void hapInfo::reset(int n) +{ + assert(n < nInfo && n >= 0); + int block(n >> 3), bit(n % 8); + mem[block] &= ~bitTable[bit]; +} + +void hapInfo::reset() +{ + memset(mem, 0, nBlock); + if(nByte) + mem[nBlock] = 0; +} + +void hapInfo::flip() +{ + for(int i = 0 ; i < nBlock ; ++i) + mem[i] = ~mem[i]; + if(nByte) + mem[nBlock] = ~mem[nBlock]; +} + +int hapInfo::count() const +{ + int ret(0); + for(int i = 0 ; i < nBlock; ++i) + ret += byteCountTable[mem[i]]; + if(nByte) + { + unsigned char mask = -1; + mask <<= (8 - nByte); + mask >>= (8 - nByte); + ret += byteCountTable[mem[nBlock] & mask]; + } + return ret; +} + +int hapInfo::count(int start, int end) const +{ + int ret(0); + --end; + if(start < 0) + start = 0; + if(end > nInfo) + end = nInfo; + int startBlock(start >> 3), startByte(start % 8); + int endBlock(end >> 3), endByte(end % 8); + if(startBlock != endBlock) + { + unsigned char mask(-1), tmp; + mask >>= startByte; + mask <<= startByte; + tmp = mem[startBlock] & mask; + ret += byteCountTable[tmp]; + mask = -1; + mask <<= (7 - endByte); + mask >>= (7 - endByte); + tmp = mem[endBlock] & mask; + ret += byteCountTable[tmp]; + } + else + { + unsigned char mask(-1), tmp; + mask >>= startByte; + mask <<= startByte + (7 - endByte); + mask >>= 7 - endByte; + tmp = mem[startBlock] & mask; + ret += byteCountTable[tmp]; + } + for(int i = startBlock + 1; i < endBlock; ++i) + ret += byteCountTable[mem[i]]; + return ret; +} + +int hapInfo::size() const +{ + return nInfo; +} + +void hapInfo::resize(int s) +{ + assert(s >= 0); + int block = s >> 3; + if(block > capBlock) + { + unsigned char *newMem; + capBlock = block + 1; + newMem = new unsigned char[capBlock]; + memset(newMem, 0, capBlock); + if(nByte) + memcpy(newMem, mem, nBlock + 1); + else + memcpy(newMem, mem, nBlock); + delete []mem; + mem = newMem; + } + nBlock = block; + nByte = s % 8; + nInfo = s; +} + +void hapInfo::reserve(int s) +{ + assert(s >= 0); + int block = s >> 3; + if(block > capBlock) + { + unsigned char *newMem; + capBlock = block + 1; + newMem = new unsigned char[capBlock]; + memset(newMem, 0, capBlock); + if(nByte) + memcpy(newMem, mem, nBlock + 1); + else + memcpy(newMem, mem, nBlock); + delete []mem; + mem = newMem; + } +} + +hapInfo hapInfo::operator &(const hapInfo& rhs) const +{ + assert(nInfo == rhs.size()); + hapInfo ret(nInfo); + for(int i = 0 ; i < nBlock ; ++i) + ret.mem[i] = mem[i] & rhs.mem[i]; + if(nByte) + ret.mem[nBlock] = mem[nBlock] & rhs.mem[nBlock]; + return ret; +} + +void hapInfo::operator &=(const hapInfo& rhs) +{ + assert(nInfo == rhs.size()); + for(int i = 0 ; i < nBlock ; ++i) + mem[i] &= rhs.mem[i]; + if(nByte) + mem[nBlock] &= rhs.mem[nBlock]; +} + +hapInfo hapInfo::operator |(const hapInfo& rhs) const +{ + assert(nInfo == rhs.size()); + hapInfo ret(nInfo); + for(int i = 0 ; i < nBlock ; ++i) + ret.mem[i] = mem[i] | rhs.mem[i]; + if(nByte) + ret.mem[nBlock] = mem[nBlock] | rhs.mem[nBlock]; + return ret; +} + +void hapInfo::operator |=(const hapInfo& rhs) +{ + assert(nInfo == rhs.size()); + for(int i = 0 ; i < nBlock ; ++i) + mem[i] |= rhs.mem[i]; + if(nByte) + mem[nBlock] |= rhs.mem[nBlock]; +} + +hapInfo hapInfo::operator ^(const hapInfo& rhs) const +{ + assert(nInfo == rhs.size()); + hapInfo ret(nInfo); + for(int i = 0 ; i < nBlock ; ++i) + ret.mem[i] = mem[i] ^ rhs.mem[i]; + if(nByte) + ret.mem[nBlock] = mem[nBlock] ^ rhs.mem[nBlock]; + return ret; +} + +void hapInfo::operator ^=(const hapInfo& rhs) +{ + assert(nInfo == rhs.size()); + for(int i = 0 ; i < nBlock ; ++i) + mem[i] ^= rhs.mem[i]; + if(nByte) + mem[nBlock] ^= rhs.mem[nBlock]; +} + +bool hapInfo::operator [](int n) const +{ + assert(n < nInfo && n>=0); + int block(n >> 3), byte(n % 8); + return mem[block] & bitTable[byte]; +} + +hapInfo& hapInfo::operator =(const hapInfo& rhs) +{ + if(this == &rhs) + return *this; + if(capBlock < rhs.capBlock) + { + delete[] mem; + mem = new unsigned char[rhs.capBlock]; + capBlock = rhs.capBlock; + } + memcpy(mem, rhs.mem, rhs.capBlock); + nBlock = rhs.nBlock; + nByte = rhs.nByte; + nInfo = rhs.nInfo; + return *this; +} + +hapInfo hapInfo::operator~() const +{ + hapInfo ret(*this); + ret.flip(); + return ret; +} + +int hapDiff(const hapInfo& a, const hapInfo& b) +{ + assert(a.size() == b.size()); + int ret(0); + unsigned char tmp; + int block(a.nBlock); + for(int i = 0 ; i < block; ++i) + { + tmp = a.mem[i] ^ b.mem[i]; + ret += byteCountTable[tmp]; + } + if(a.nByte) + { + unsigned char mask(-1); + mask <<= (8 - a.nByte); + mask >>= (8 - a.nByte); + tmp = ( a.mem[block] ^ b.mem[block] ) & mask; + ret += byteCountTable[tmp]; + } + return ret; +} + +int hapDiff(const hapInfo& a, const hapInfo& b, int start, int end) +{ + assert(a.size() == b.size() && end > start && start >= 0); + --end; + int ret(0); + int startBlock(start >> 3), startByte(start % 8); + int endBlock(end >> 3), endByte(end % 8); + if(startBlock != endBlock) + { + unsigned char mask(-1), tmp; + mask >>= startByte; + mask <<= startByte; + tmp = ( a.mem[startBlock] ^ b.mem[startBlock] ) & mask; + ret += byteCountTable[tmp]; + mask = -1; + mask <<= (7 - endByte); + mask >>= (7 - endByte); + tmp = ( a.mem[endBlock] ^ b.mem[endBlock] ) & mask; + ret += byteCountTable[tmp]; + } + else + { + unsigned char mask(-1), tmp; + mask >>= startByte; + mask <<= startByte + (7 - endByte); + mask >>= 7 - endByte; + tmp = ( a.mem[startBlock] ^ b.mem[startBlock] ) & mask; + ret += byteCountTable[tmp]; + } + for(int i = startBlock + 1; i < endBlock; ++i) + { + unsigned char tmp; + tmp = a.mem[i] ^ b.mem[i]; + ret += byteCountTable[tmp]; + } + return ret; +} + +void genomePar::vcfParLoad() +{ + assert(-1 != access(vcfPar.c_str(), R_OK)); + gzifstream fpi(vcfPar); + std::string path; + fpi >> path; + assert(path == ""vcf""); + while(fpi >> path) + vcfPaths.push_back(path); + assert(vcfPaths.size()); +} + +void genomePar::remapParLoad() +{ + assert(-1 != access(remapPar.c_str(), R_OK)); + gzifstream fpi(remapPar); + std::string path, contig; + fpi >> path >> contig; + assert(path == ""remap""); + assert(contig == ""contig""); + while(fpi >> path >> contig) + { + remapPaths.push_back(path); + remapContigs.push_back(contig); + } + assert(remapPaths.size() && remapContigs.size()); +} + +void genomePar::popParLoad() +{ + assert(-1 != access(popPar.c_str(), R_OK)); + gzifstream fpi(popPar); + std::string id, pop, asPop; + fpi >> id >> pop >> asPop; + assert(id == ""ID""); + assert(pop == ""Pop""); + assert(asPop == ""ArchaicSeekerPop""); + idInfos.resize(3); + popInfos.resize(3); + while(fpi >> id >> pop >> asPop) + { + int asLab(-1); + if(asPop == ""Archaic"") + asLab = 0; + else if(asPop == ""African"") + asLab = 1; + else if(asPop == ""Test"") + asLab = 2; + assert(asLab >= 0); + if(ASpopCheck.count(pop)) + assert(ASpopCheck[pop] == asLab); + else + ASpopCheck[pop] = asLab; + assert(popCheck.count(id) == 0); + popCheck[id] = pop; + idInfos[asLab].push_back(id); + popInfos[asLab].push_back(pop); + } + for(int i = 0 ; i < 3; ++i) + { + assert(idInfos[i].size()); + assert(popInfos[i].size()); + } +} + +void genomePar::outgroupFastaPathLoad() +{ + assert(-1 != access(outgroupPar.c_str(), R_OK)); + gzifstream fpi(outgroupPar); + std::string path, contig; + fpi >> path >> contig; + assert(path == ""outgroup""); + assert(contig == ""contig""); + while(fpi >> path >> contig) + outgroupFastaPaths[contig] = path; + assert(outgroupFastaPaths.size()); +} + +void genomePar::ancestralFastaPathLoad() +{ + assert(-1 != access(ancestralPar.c_str(), R_OK)); + gzifstream fpi(ancestralPar); + std::string path, contig; + fpi >> path >> contig; + assert(path == ""ancestor""); + assert(contig == ""contig""); + while(fpi >> path >> contig) + ancestralFastaPaths[contig] = path; + assert(ancestralFastaPaths.size()); +} + +class comSNP +//Only used in vcfsLoad(). +{ +public: + comSNP() : ref(' '), alt(' '), findT(false), findF(false), count(0), pos(0) {} + char ref, alt; + bool findT, findF; + short count; + long pos; +}; + +void genome::vcfsLoad(const std::vector& paths) +{ + assert(paths.size()); + int npath = paths.size(); + std::map > idContigFileCheck; + std::map > consistSNPCount; + std::map contigFileCount; + for(int i = 0 ; i < npath; ++i) + { + std::cout << ""Loading SNP information from "" << paths[i] << std::endl; + assert(-1 != access(paths[i].c_str(), R_OK)); + gzifstream fpi(paths[i]); + std::string line; + while(getline(fpi, line)) + if(line[1] != '#') + break; + std::istringstream head(line); + std::vector tids; + std::string tid; + for(int j = 0 ; j < 9 ; ++j) + head >> tid; + std::set idRepCheck; + while(head >> tid) + { + tids.push_back(tid); + assert(idRepCheck.count(tid) == 0); + assert(par.popCheck.count(tid)); + idRepCheck.insert(tid); + } + int nind(tids.size()); + long tpos, prePos(0); + std::string tchr, preChr(""""), ref, alt; + std::set checkContigs; + int p(0); + std::vector* curSNPs(NULL); + bool newAdd(false); + int curNsnp(0); + while(getline(fpi, line)) + { + std::istringstream cl(line); + cl >> tchr >> tpos >> line >> ref >> alt >> line >> line >> line >> line; + bool findT(false), findF(false); + while(cl >> line && !(findT && findF)) + { + if(line[0] == '0' || line[2] == '0') + findF = true; + if(line[0] == '1' || line[2] == '1') + findT = true; + } + if(contigMap.count(tchr) == 0) + continue; + if(preChr != tchr) + { + assert(checkContigs.count(tchr) == 0); + checkContigs.insert(tchr); + if(consistSNPCount.count(tchr) == 0) + newAdd = true; + else + { + newAdd = false; + curNsnp = consistSNPCount[tchr].size(); + } + curSNPs = & (consistSNPCount[tchr]); + p = 0; + } + else + assert(tpos > prePos); + prePos = tpos; + preChr = tchr; + if(newAdd) + { + if(ref.size() == 1 && alt.size() == 1) + { + comSNP t; + t.ref = ref[0]; + t.alt = alt[0]; + t.count = 1; + t.pos = tpos; + t.findF = findF; + t.findT = findT; + curSNPs->push_back(t); + } + } + else + { + if(p == curNsnp) + continue; + while(p < curNsnp && tpos > (*curSNPs)[p].pos) + ++p; + if(p == curNsnp || tpos < (*curSNPs)[p].pos) + continue; + if(ref.size() == 1 && alt.size() == 1 && \ + ref[0] == (*curSNPs)[p].ref) + { + if(alt[0] == (*curSNPs)[p].alt || alt[0] == '.') + { + ++(*curSNPs)[p].count; + (*curSNPs)[p].findF |= findF; + (*curSNPs)[p].findT |= findT; + } + else if((*curSNPs)[p].alt == '.') + { + ++(*curSNPs)[p].count; + (*curSNPs)[p].alt = alt[0]; + (*curSNPs)[p].findF |= findF; + (*curSNPs)[p].findT |= findT; + } + } + } + } + for(std::set::iterator it = checkContigs.begin(); \ + it != checkContigs.end(); ++it) + { + ++contigFileCount[*it]; + for(int j = 0; j < nind; ++j) + { + const std::string& curID = tids[j]; + assert(idContigFileCheck[curID].count(*it) == 0); + idContigFileCheck[curID][*it] = i; + } + } + } +#ifdef DEBUG_VCF_INTER + std::cout << ""idContigFileCheck [ID] [contig] [file]"" << std::endl; + for(std::map >::iterator \ + it = idContigFileCheck.begin(); it != idContigFileCheck.end(); ++it) + { + std::cout << ""\tID: "" << it->first << std::endl; + std::map& contigFile = it->second; + for(std::map::iterator tit = \ + contigFile.begin(); tit != contigFile.end(); ++tit) + std::cout << ""\t\t"" << tit->first << '\t' << tit->second << std::endl; + } + std::cout << ""consistSNPCount [contig] [position] [comSNP]"" << std::endl; + for(std::map >::iterator \ + it = consistSNPCount.begin(); it != consistSNPCount.end(); ++it) + { + std::cout << ""\tID: "" << it->first << std::endl; + std::vector& snpCount = it->second; + for(std::vector::iterator tit = \ + snpCount.begin(); tit != snpCount.end(); ++tit) + std::cout << ""\t\t"" << tit->pos << '\t' << tit->ref << '\t' \ + << tit->alt << '\t' << tit->count << std::endl; + } + std::cout << ""contigFileCount [contig] [int]"" << std::endl; + for(std::map::iterator it = contigFileCount.begin(); \ + it != contigFileCount.end(); ++it) + std::cout << ""\t"" << it->first << '\t' << it->second << std::endl; +#endif//DEBUG_VCF_INTER + + int nind(idContigFileCheck.size()); + int ncontig(contigFileCount.size()); + std::vector > idContigCheckTable; + std::vector contigCountCheck; + idContigCheckTable.resize(nind); + for(int i = 0 ; i < nind ; ++i) + idContigCheckTable[i].resize(ncontig, 0); + contigCountCheck.resize(ncontig, 0); //should be = nind + + comIDs.resize(nind); + comPop.resize(nind); + comASPop.resize(nind); + std::map comIDCheckTable; + int idc(0), contigc(0); + for(std::map >::iterator \ + it = idContigFileCheck.begin(); it != idContigFileCheck.end(); ++it) + { + contigc = 0; + comIDs[idc] = it->first; + comPop[idc] = par.popCheck.at(comIDs[idc]); + comASPop[idc] = par.ASpopCheck.at(comPop[idc]); + comIDCheckTable[it->first] = idc; + for(std::map::iterator tit = contigFileCount.begin(); \ + tit != contigFileCount.end(); ++tit) + { + if(it->second.count(tit->first)) + { + idContigCheckTable[idc][contigc] = 1; + ++contigCountCheck[contigc]; + } + ++contigc; + } + ++idc; + } + std::map comContigCheckTable; + contigc = 0; + for(std::map::iterator it = contigFileCount.begin(); \ + it != contigFileCount.end(); ++it) + { + if(contigCountCheck[contigc] == nind) + { + comContigCheckTable[it->first] = comContigs.size(); + comContigs.push_back(it->first); + } + ++contigc; + } + ncontig = comContigs.size(); + comPos.resize(ncontig); + comRefAllele.resize(ncontig); + comAltAllele.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + std::vector& curPos = comPos[i]; + std::vector& curRefAllele = comRefAllele[i]; + std::vector& curAltAllele = comAltAllele[i]; + std::vector& curContig = consistSNPCount[comContigs[i]]; + int nfile = contigFileCount[comContigs[i]]; + for(std::vector::iterator it = curContig.begin(); it != curContig.end(); \ + ++it) + if(it->count == nfile && it->findF && it->findT) + { + curPos.push_back(it->pos); + curRefAllele.push_back(it->ref); + curAltAllele.push_back(it->alt); + } + } +#ifdef DEBUG_VCF_INTER + std::cout << ""comIDs\tcomPop\tcomASPop"" << std::endl; + for(int i = 0 ; i < nind; ++i) + std::cout << comIDs[i] << '\t' << comPop[i] << '\t' << comASPop[i] << std::endl; + std::cout << ""comConigs & comPos"" << std::endl; + for(int i = 0 ; i < ncontig; ++i) + { + std::cout << comContigs[i] << std::endl; + int npos = comPos[i].size(); + for(int j = 0 ; j < npos; ++j) + std::cout << '\t' << comPos[i][j] << std::endl; + } + std::cout << ""idContigCheckTable"" << std::endl; + for(std::map::iterator tit = contigFileCount.begin(); \ + tit != contigFileCount.end(); ++tit) + std::cout << '\t' << tit->first ; + std::cout << std::endl; + for(int i = 0 ; i < nind ; ++i) + { + std::cout << comIDs[i]; + for(unsigned int j = 0 ; j < idContigCheckTable[i].size(); ++j) + std::cout << '\t' << (int)idContigCheckTable[i][j]; + std::cout << std::endl; + } +#endif//DEBUG_VCF_INTER + + haplotypes.resize(ncontig); + phased.resize(nind, 0); + for(int i = 0 ; i < ncontig; ++i) + { + std::vector& curHap = haplotypes[i]; + curHap.resize(nind * 2); + int nmk(comPos[i].size()); + for(int j = 0 ; j < nind * 2; ++j) + { + curHap[j].resize(nmk); + curHap[j].reset(); + } + } + for(int i = 0 ; i < nind; ++i) + if(comASPop[i] == 2) + phased[i] = 1; + else + phased[i] = 0; + for(int i = 0 ; i < npath ; ++i) + { + std::cout << ""Loading genotype information from "" << paths[i] << std::endl; + gzifstream fpi(paths[i]); + std::string line; + while(getline(fpi, line)) + if(line[1] != '#') + break; + std::istringstream head(line); + std::vector tids; + std::string tid; + for(int j = 0 ; j < 9 ; ++j) + head >> tid; + std::vector check; + int isphased(-1); + while(head >> tid) + { + int index(comIDCheckTable[tid]); + check.push_back(index); + if(isphased == -1) + isphased = phased[index]; + else + assert(isphased == phased[index]); + } + int tnind = check.size(); + std::string pchr(""""), tchr; + long tpos; + int p(0); + std::vector* curHap(NULL); + std::vector* curPos(NULL); + int curNpos(1024); + if(isphased) + while(getline(fpi,line) && p < curNpos) + { + std::istringstream cl(line); + cl >> tchr >> tpos; + if(pchr != tchr || curHap == NULL) + { + if(comContigCheckTable.count(tchr) == 0) + continue; + p = 0; + pchr = tchr; + int chrIndex(comContigCheckTable[tchr]); + curHap = &haplotypes[chrIndex]; + curPos = &comPos[chrIndex]; + curNpos = curPos->size(); + } + if(tpos < (*curPos)[p]) + continue; + assert(tpos == (*curPos)[p]); + for(int j = 0 ; j < 7 ; ++j) + cl >> line; + for(int j = 0 ; j < tnind; ++j) + { + cl >> line; + int idp(check[j] * 2); + if(line[0] == '1') + (*curHap)[idp].set(p); + else + assert(line[0] == '0'); + if(line[2] == '1') + (*curHap)[idp + 1].set(p); + else + assert(line[2] == '0'); + assert(line[1] == '|'); + } + ++p; + } + else + while(getline(fpi,line) && p < curNpos) + { + std::istringstream cl(line); + cl >> tchr >> tpos; + if(pchr != tchr || curHap == NULL) + { + if(comContigCheckTable.count(tchr) == 0) + continue; + p = 0; + pchr = tchr; + int chrIndex(comContigCheckTable[tchr]); + curHap = &haplotypes[chrIndex]; + curPos = &comPos[chrIndex]; + curNpos = curPos->size(); + } + if(tpos < (*curPos)[p]) + continue; + assert(tpos == (*curPos)[p]); + for(int j = 0 ; j < 7 ; ++j) + cl >> line; + for(int j = 0 ; j < tnind; ++j) + { + cl >> line; + int n(0), s(2); + int idp(check[j] * 2); + if(line[0] == '1') + ++n; + else if(line[0] == '.') + --s; + else + assert(line[0] == '0'); + if(line[2] == '1') + ++n; + else if(line[2] == '.') + --s; + else + assert(line[2] == '0'); + if(s != 2) + { + (*curHap)[idp].set(p); + (*curHap)[idp + 1].set(p); + } + else if(n == 1) + (*curHap)[idp].set(p); + else if(n == 2) + (*curHap)[idp + 1].set(p); + else + assert(n == 0); + } + ++p; + } + } +#ifdef DEBUG_VCF_INTER + std::cout << ""haplotypes"" << std::endl; + for(int i = 0 ; i < ncontig; ++i) + { + std::cout << ""\tcontig: "" << comContigs[i] << std::endl; + for(int j = 0; j < nind * 2; ++j) + { + std::cout << ""\t\t"" << j << "" ""; + haplotypes[i][j].simplePrint(); + } + } +#endif//DEBUG_VCF_INTER + + gdisData.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + std::vector& curPosMap = posMap[contigMap[comContigs[i]]]; + std::vector& curGdisMap = gdisMap[contigMap[comContigs[i]]]; + std::vector& curComPos = comPos[i]; + std::vector& curGdisData = gdisData[i]; + int ncomPos(curComPos.size()), nmap(curPosMap.size()); + curGdisData.resize(ncomPos); + int pMap(0), pData(0); + while(pData < ncomPos && curComPos[pData] <= curPosMap.front()) + { + curGdisData[pData] = 0; + ++pData; + } + if(pData == ncomPos) + continue; + while(pData < ncomPos) + { + while(pMap < nmap && curPosMap[pMap] <= curComPos[pData]) + ++pMap; + if(pMap == nmap) + break; + curGdisData[pData] = ( curGdisMap[pMap] - curGdisMap[pMap - 1] ) / \ + ( curPosMap[pMap] - curPosMap[pMap - 1] ) * \ + ( curComPos[pData] - curPosMap[pMap - 1] ) + curGdisMap[pMap - 1]; + ++pData; + } + while(pData < ncomPos) + { + curGdisData[pData] = curGdisMap.back(); + ++pData; + } + } +#ifdef DEBUG_VCF_INTER + std::cout << ""gdisData"" << std::endl; + for(int i = 0 ; i < ncontig; ++i) + { + std::cout << ""\tcontig: "" << comContigs[i] << std::endl; + std::cout << ""\t map:"" << std::endl; + for(unsigned int j = 0 ; j < gdisMap[i].size(); ++j) + std::cout << ""\t\t"" << posMap[i][j] << '\t' << gdisMap[i][j] << std::endl; + std::cout << ""\t data:"" << std::endl; + int nmk(gdisData[i].size()); + for(int j = 0 ; j < nmk; ++j) + std::cout << ""\t\t"" << comPos[i][j] << '\t' << gdisData[i][j] << std::endl; + } +#endif//DEBUG_VCF_INTER +} + +void genome::remapLoad(const std::vector& paths, \ + const std::vector& contigs) +{ + assert(paths.size() == contigs.size()); + int npath = paths.size(); + gdisMap.resize(npath); + posMap.resize(npath); + for(int i = 0 ; i < npath; ++i) + { + assert(-1 != access(paths[i].c_str(), R_OK)); + gzifstream fpi(paths[i]); + std::string line; + getline(fpi, line); + long tpos; + double trate, tgdis; + std::vector& curPos = posMap[i]; + std::vector& curGdis = gdisMap[i]; + while(fpi >> tpos >> trate >> tgdis) + { + curPos.push_back(tpos); + curGdis.push_back(tgdis); + } + assert(curPos.size() && curGdis.size()); + contigMap[contigs[i]] = i; + } +} + +void genome::ancestralLoad(const std::map& ancestralFastaPaths) +{ + int ncontig(comContigs.size()); + ancestralState.resize(ncontig); + for(int i = 0 ; i < ncontig; ++i) + { + assert(ancestralFastaPaths.count(comContigs[i])); + const std::string& curPath(ancestralFastaPaths.at(comContigs[i])); + assert(-1 != access(curPath.c_str(), R_OK)); + gzifstream fpi(curPath); + std::string line; + getline(fpi, line); + int p(0); + const std::vector& curPos(comPos[i]); + const std::vector& curAlt(comAltAllele[i]); + int nsite(curPos.size()); + hapInfo& curAnc(ancestralState[i]); + curAnc.resize(nsite); + curAnc.reset(); + int total(0); + while(p < nsite) + { + while(total < curPos[p]) + { + getline(fpi,line); + if(!fpi) + break; + total += line.size(); + } + if(!fpi) + break; + if(curAlt[p] == line[curPos[p] - total + line.size() - 1]) + curAnc.set(p); + ++p; + } + } +} + + + + + + + + + + + + +","C++" +"Allele","Shuhua-Group/ArchaicSeeker2.0","src/matching.hpp",".hpp","6333","234","/* + * matching.hpp + * + * Created on: Oct 10, 2018 + * Author: yuankai + */ + +#ifndef MATCHING_HPP_ +#define MATCHING_HPP_ + +# include +# include +# include +# include +# include + +# include + +class matchModel; + +class newickFunc; + +class newickDirFunc; + +class newickNode +{ +public: + newickNode() : label(""""), dis(0), nchild(0), child(NULL), parent(NULL) {}; + newickNode(const std::string& tree); + ~newickNode(); + + std::string getLab() const { return label; } + double getDis() const { return dis; } + + void traversal(newickFunc& func); + void search(newickDirFunc& func); + + std::string _load(const std::string &subTree, newickNode* upper); + + std::string label; + double dis; + int nchild; + newickNode *child, *parent; +}; + +class newickFunc +{ +public: + virtual ~newickFunc() {}; + virtual void operator() (newickNode& node) = 0; +}; + +class newickDirFunc +{ +public: + newickDirFunc() : preNode(NULL), upper(true), isFirst(true), upSearchStat(-1) {}; + virtual ~newickDirFunc() {}; + virtual void operator() (newickNode& node) = 0; + + newickNode* preNode; + bool upper; + + bool isFirst; + int upSearchStat; // 1 up search, -1 down search, -1 cur + std::set check; +}; + +class labcheck : public newickFunc +{ +public: + void operator() (newickNode& node); + std::map access; +}; + +class getNodeLab : public newickFunc +{ +public: + getNodeLab(std::vector& _labels, std::vector& _leafLab, \ + std::vector& _midLab) : labels(_labels), leafLab(_leafLab), midLab(_midLab) {} + void operator() (newickNode& node); + std::vector& labels, & leafLab, & midLab; +}; + +#ifdef DEBUG + +class labprint : public newickFunc +{ +public: + void operator() (newickNode& node); +}; + +#endif//DEBUG + +class disSearch : public newickDirFunc +{ +public: + disSearch() : newickDirFunc() {}; + void operator() (newickNode& node); + std::map disMem; + std::map labDis; + std::map isUpSearch; // 1 up search, -1 down search, -1 cur + std::map > nodeCheck; +}; + +class matFuncData +{ +public: + matFuncData() : nleaf(0), nlab(0), dc(NULL), eta(NULL), diff(NULL), mu(0) {} + ~matFuncData(); + void init(int _nlaef, int _nlab); + + int nleaf, nlab; + double ***dc; //[leaf]testRecNode [lab]testIntorNode [leaf] + double **eta; //[lab] [leaf] + double *diff; //[leaf] + double mu; +}; + +class curMatFuncData +{ +public: + curMatFuncData(const matFuncData& data, double length, int testRec, int testIntro) : + nleaf(data.nleaf), inter(0), curDc(data.dc[testRec][testIntro]), + curEta(data.eta[testIntro]), curDiff(data.diff), mu(data.mu), len(length) {} + int nleaf, inter; + double *curDc, *curEta, *curDiff; + double mu, len; +}; + +double matLKFunc(unsigned int n, const double *x, double *grad, void *matData); + +double globalMatFunc(unsigned int n, const double *x, double *grad, void *matData); + +class modelCalibrateData +{ +public: + modelCalibrateData(const std::vector >& _pairDiff, \ + const std::vector > >& _pairLab, \ + const std::vector >& _rootLab, \ + double _mu, long _length) : \ + pairDiff(_pairDiff), pairLab(_pairLab), rootLab(_rootLab), \ + nlab(_pairLab[1].front().size()), \ + nleaf(_pairLab.size()), mu(_mu), length(_length){}; + const std::vector > &pairDiff; + const std::vector > > &pairLab; + const std::vector > &rootLab; + int nlab, nleaf; + double mu, length; +}; + +double modelCalibrateFunc(unsigned int n, const double *x, double *grad, void *matData); + +class modelCalibrateConstraintData +{ +public: + modelCalibrateConstraintData(const std::vector& _lab1, \ + const std::vector& _lab2, double _diff) :\ + lab1(_lab1), lab2(_lab2), diff(_diff) {}; + const std::vector &lab1, &lab2; + double diff; +}; + +double modelCalibrateConstraintFunc(unsigned int n, const double *x, double *grad, \ + void *cData); + +class matchModel +{ +public: + matchModel(const std::string& m); + + ~matchModel(); + + friend class newickNode; + + //return the best matched lab + int segMatchLK(double* ndiff, double length, int recp, double* mat, double* llk) const; + + void modelCalibrate(const std::vector >& pairDiff, long len); + +#ifdef DEBUG + + void print() { labprint p; model.traversal(p); } + +#endif//DEBUG + + newickNode model; + labcheck access; + + std::map search; + std::vector labels, leafLabs, midLabs; + std::vector nodeLen, rootLen, nodeTestUpbound; + std::vector > rootLab; //[nleaf] + std::vector > nodeDis; //[labels] [leafs] + std::vector > pairTreeDis; //[leafs] [leafs] + std::vector > > pairLab; //[leafs] [leafs] [labels] + std::vector calibratedLen; +/* + * m node and n leafs + * t stands for the time before introgress node's time + * For a specific introgress node, the time to the test node is d + * alpha = 1 / ( L * mu ) + * if is upper search eta = 0, or eta = 2 + * diff = ( d + dis_intro2leaf + eta * t ) * alpha + * x = t * alpha; y = alpha; + * f(x,y) = sum(1->n){( (d + c) * y + eta * x - diff ) ^ 2} + * df/dx = sum(1->n){ 2 * eta * ( (d + c) * y + eta * x - diff ) } = 0 + * df/dy = sum(1->n){ 2 * (d + c) * ( (d + c) * y + eta * x - diff) } = 0 + * A = sum(1->n){ eta * (d + c) } [n][m] TestRecieveNode TestIntroNode + * B = sum(1->n){ eta ^ 2 } [m] TestIntroNode + * C = sum(1->n){ eta * diff } eta[m][n] TestIntroNode PairDifference + * D = sum(1->n){ (d + c) ^ 2 } [n][m] TestRecieveNode TestIntroNode + * E = sum(1->n){ (d + c) * diff } (d + c)[n][m][n] TestRecieveNode TestIntroNode PairDifference + * F = sum(1->n){ diff ^ 2 } + * x = (C*D - A*E) / (B*D - A^2) + * y = (B*E - A*C) / (B*D - A^2) + * t = x / y = (C*D - A*E) / (B*E - A*C) + * sqrt = D * y^2 + B * x^2 + F + 2 * A * xy - 2 * E * y - 2 * C *x + */ + +/* + * L(x,y) = sum(1->n){ diff * log( (d + c + eta * t ) * alpha ) - (d + c + eta * t ) * alpha + * - log(diff!) } + * x[0] = t, x[1] = alpha + * dL/dt = sum(1->n){ diff * eta / (d + c + eta * t) - alpha * eta} + * dL/d(alpha) = sum(1->n){ diff / alpha - (d + c + eta * t)} + */ + matFuncData matData; + double** initVal, ** lb, ** ub;//[nlab] [2]; + + double mu; +}; + +#endif /* MATCHING_HPP_ */ +","Unknown" +"Allele","BGI-shenzhen/RRSelection","config.h",".h","2781","98","/* config.h. Generated from config.h.in by configure. */ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the `z' library (-lz). */ +#define HAVE_LIBZ 1 + +/* Define to 1 if your system has a GNU libc compatible `malloc' function, and + to 0 otherwise. */ +#define HAVE_MALLOC 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_MATH_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the `memset' function. */ +#define HAVE_MEMSET 1 + +/* Define to 1 if your system has a GNU libc compatible `realloc' function, + and to 0 otherwise. */ +#define HAVE_REALLOC 1 + +/* Define to 1 if you have the `regcomp' function. */ +#define HAVE_REGCOMP 1 + +/* Define to 1 if you have the `sqrt' function. */ +/* #undef HAVE_SQRT */ + +/* Define to 1 if you have the header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the `strdup' function. */ +#define HAVE_STRDUP 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the `strncasecmp' function. */ +#define HAVE_STRNCASECMP 1 + +/* Define to 1 if you have the `strtol' function. */ +#define HAVE_STRTOL 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_UNISTD_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_ZLIB_H 1 + +/* Name of package */ +#define PACKAGE ""bin/RRSelection"" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT ""hewm2008@gmail.com"" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME ""bin/RRSelection"" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING ""bin/RRSelection 0.8"" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME ""bin-rrselection"" + +/* Define to the home page for this package. */ +#define PACKAGE_URL """" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION ""0.8"" + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Version number of package */ +#define VERSION ""0.8"" + +/* Define to rpl_malloc if the replacement function should be used. */ +/* #undef malloc */ + +/* Define to rpl_realloc if the replacement function should be used. */ +/* #undef realloc */ +","Unknown" +"Allele","BGI-shenzhen/RRSelection","src/CommFun.h",".h","1349","66","#ifndef comm_H_ +#define comm_H_ + + +using namespace std; +typedef int llong ; + + +//////////////////////////////// some small funtion ///////////////////////////////////////////// + + +inline void LogLackArg( string flag ) +{ + cerr << ""\t\tLack Argument for [ -""<& tokens, const string& delimiters = "" "") +{ + string::size_type lastPos = str.find_first_not_of(delimiters, 0); + string::size_type pos = str.find_first_of(delimiters, lastPos); + while (string::npos != pos || string::npos != lastPos) + { + tokens.push_back(str.substr(lastPos, pos - lastPos)); + lastPos = str.find_first_not_of(delimiters, pos); + pos = str.find_first_of(delimiters, lastPos); + } +} + + + + + +///////////////////swimming in the sky & flying in the sea///////////////////////////// + + + + + +#endif // comm_H_ ; + + +","Unknown" +"Allele","BGI-shenzhen/RRSelection","src/Calculate.h",".h","3828","169","#ifndef calculate_H_ +#define calculate_H_ + + +using namespace std; + + +///////////////////////// method1 ///////////////////////////////// +int cal_RR_MA ( vector & Base1 , vector & Base2 , double & CalResult, statementVar & Var ) +{ + Var.DDE[0][0]=0; Var.DDE[0][1]=0; Var.DDE[1][0]=0; Var.DDE[1][1]=0; + for (Var.i=0 ;Var.i > & SNPList , StarRsult * All_Stat[]) +{ + double CalResult; + llong Dis=0; + statementVar Var; + map > :: iterator key2; + map > :: iterator key2_se; + + key2=SNPList.begin(); + Var.Asize= (key2->second).size(); + for ( ; key2!=SNPList.end(); key2++) + { + key2_se=key2 ; key2_se++ ; + for( ; key2_se!=SNPList.end(); key2_se++) + { + Dis=(key2_se->first)-(key2->first); + if ( Dis> (paraFA04->WindowSize)) + { + break ; + } + if (cal_RR_MA( key2->second , key2_se->second ,CalResult, Var) ==1) + { + int count=int((key2->first)/(paraFA04->bin)); + int SeCount=int(Dis/(paraFA04->bin)); + All_Stat[SeCount][count].Count++; + All_Stat[SeCount][count].sumRR+=CalResult; + } + } + } +} + +///*////// + + +///* +void PairWiseRRCal(In3str1v * paraFA04, Para_18 * para_18 , map > & SNPList , StarRsult * All_Stat[]) +{ + double CalResult; + llong Dis=0; + statementVar Var; + map > :: iterator key2; + map > :: iterator key2_se; + + key2=SNPList.begin(); + Var.Asize= (key2->second).size(); + + double *Weight = new double [(paraFA04->WindowSize)+2]; + Weight[0]=0.0; + Weight[1]=1.0; + for (int jj=2; jj< ((paraFA04->WindowSize)+2) ; jj++) + { + double DDtmp=(1.0/(jj*jj)); + if (DDtmp < 1e-8) { DDtmp=1e-5;} // Dis 10000 ~ W ( 10K with Hight Weight) + if (isfinite(DDtmp)) + { + Weight[jj]=Weight[jj-1]+DDtmp; + } + else + { + Weight[jj]=Weight[jj-1]; + } + } + + for (int jj=2; jj< ((paraFA04->WindowSize)+2) ; jj++) + { + if (isnormal(Weight[jj])) + { + Weight[jj]=int(Weight[jj]*100000)*1.0/100000; + } + else + { + Weight[jj]=Weight[jj-1]; + } + } + + for ( ; key2!=SNPList.end(); key2++) + { + key2_se=key2 ; key2_se++ ; + for( ; key2_se!=SNPList.end(); key2_se++) + { + Dis=(key2_se->first)-(key2->first); + if ( Dis> (paraFA04->WindowSize)) + { + break ; + } + if (cal_RR_MA( key2->second , key2_se->second ,CalResult, Var) ==1) + { + int count=int((key2->first)/(paraFA04->bin)); + int SeCount=int(Dis/(paraFA04->bin)); + All_Stat[SeCount][count].Count+=Weight[Dis]; + All_Stat[SeCount][count].sumRR+=CalResult*Weight[Dis]; + } + } + } + + + delete [] Weight ; +} + +///*//// + + + +#endif // calculate_H_ ; + + + + + + +","Unknown" +"Allele","BGI-shenzhen/RRSelection","src/make.sh",".sh","302","10","#!/bin/sh +#$ -S /bin/sh +echo Start Time : +date +echo g++ -g -O2 RRSelection.cpp -lz -L/usr/lib/ -L./include/zlib/ -o ../bin/RRSelection +g++ -g -O2 RRSelection.cpp -lz -L/usr/lib64/ -L/usr/lib/ -L./include/zlib/ -o ../bin/RRSelection +echo done see the [ ../bin/RRSelection ] +echo End Time : +date +","Shell" +"Allele","BGI-shenzhen/RRSelection","src/Make_static.sh",".sh","315","9","#!/bin/sh +#$ -S /bin/sh +#Version1.0 hewm@genomics.org.cn 2018-12-27 +echo Start Time : +date +g++ -g -O2 *.cpp -lz -L/usr/lib64/ -L/usr/lib/ -L./include/zlib/ -o ../bin/RRSelection_static -static -lz -I /ifshk4/BC_PUB/biosoft/newblc/01.Usr/include/ -L /ifshk4/BC_PUB/biosoft/newblc/01.Usr/lib +echo End Time : +date +","Shell" +"Allele","BGI-shenzhen/RRSelection","src/CalOnePop.h",".h","10647","458","#ifndef processOnePop_H_ +#define processOnePop_H_ + +#include ""Bmath/pnorm.c"" + +using namespace std; + +////////////////////////////////////////////////////////////////// one Group Deal /////////////////////////////////////////////////// + + +void DrawRRSliding_One( string File , In3str1v * paraFA04, Para_18 * para_18 ) +{ + // OUTSS<<""Chr\tStart\tEnd\tRLV\tSum_r^2\tCount\tZScore\tPvalue\n""; + + string OutPlotTmp=(paraFA04->InStr2)+"".tmp""; + ofstream OUTPLOT (OutPlotTmp.c_str()); + + igzstream LIST (File.c_str(),ifstream::in); + + string chr=""""; + getline(LIST,chr); + getline(LIST,chr); + string Start,End,RLV; + map VecChr; + map > Value; + map > :: iterator iTValue; + + map :: iterator itVecChr ; + while(!LIST.eof()) + { + string line ; + getline(LIST,line); + if (line.length()<=0) { continue ;} + istringstream isone (line,istringstream::in); + isone>>chr>>Start>>End>>RLV ; + itVecChr=VecChr.find(chr); + if (itVecChr==VecChr.end()) + { + VecChr.insert(map ::value_type(chr,1)); + map DataEE; + DataEE[0]=RLV; + Value.insert(map > ::value_type(chr,DataEE)); + } + else + { + iTValue=Value.find(chr); + (iTValue->second).insert(map ::value_type(itVecChr->second,RLV)); + itVecChr->second++; + } + } + LIST.close(); + + int MaxXX=0; + OUTPLOT<<""Site""; + for(itVecChr=VecChr.begin();itVecChr!=VecChr.end();itVecChr++) + { + if (MaxXX<(itVecChr->second)) {MaxXX=itVecChr->second;} + OUTPLOT<<""\t""<first; + } + OUTPLOT< :: iterator itEEEE; + for (int ii=0 ; ii< MaxXX ; ii++) + { + OUTPLOT< (itVecChr->second)) + { + OUTPLOT<<""\t0.0""; + continue ; + } + iTValue=Value.find(itVecChr->first); + itEEEE=(iTValue->second).find(ii); + if (itEEEE==(iTValue->second).end()) + { + OUTPLOT<<""\tNA""; + } + else + { + OUTPLOT<<""\t""<second ; + } + } + OUTPLOT<InStr2)+"".tmp.r""; + ofstream OUTR (OutPlotr.c_str()); + + OUTR<<"""" + ""\n"" + ""library(ggplot2);\nlibrary(reshape2);\n"" + ""read.table(\""""<data;\n"" + ""data2<-melt(data,id=1);\n"" + ""p <- ggplot(data = data2)+geom_tile(aes(x = Site,y = variable, fill=value))+scale_fill_gradient(limit=c(0,1),low ='white',high ='red',na.value=\""grey50\"")\n"" + ""pdf(\""""<<(paraFA04->InStr2)<<"".sliding.pdf\"",h=6,w=25);\n"" + ""p\n"" + ""dev.off()\n"" + ""png(\""""<<(paraFA04->InStr2)<<"".sliding.png\"",h=6,w=25);\n"" + ""p\n"" + ""dev.off()\n""< /dev/null ""; + memset( buf, '\0', sizeof(buf) ); + FILE *stream ; + stream=popen(cc.c_str(),""r"") ; + fread( buf, sizeof(char), sizeof(buf), stream); + string binPath=buf; + binPath=binPath.substr(0,binPath.length()-1); + if (binPath == """" ) + { + cout <<""\twarning: can't find the [Rscript] in your $PATH ; no png Figure Out""<TF) + { + //cc=binPath+""\t""+OutPlotr ; + cc=binPath+""\t""+OutPlotr+"" ; rm -rf ""+ OutPlotr+"" ""+ OutPlotTmp ; + std::system(cc.c_str()) ; + } + else + { + cc=binPath+""\t""+OutPlotr ; + std::system(cc.c_str()) ; + cout <<""\t\tRePlot : Rscript ""<InStr2)+"".tmp2""; + ofstream OUTPLOT (OutPlotTmp.c_str()); + + igzstream LIST (File1.c_str(),ifstream::in); + + string chr=""""; + getline(LIST,chr); + getline(LIST,chr); + string Start,End,RLVV1; + + map < string,pair > ValueV1; + map < string,pair > :: iterator AA_it; + + while(!LIST.eof()) + { + string line ; + getline(LIST,line); + if (line.length()<=0) {continue;} + istringstream isone (line,istringstream::in); + isone>>chr>>Start>>End>>RLVV1; + if(RLVV1!=""NA"") + { + RLVV1=RLVV1.substr(0,4); + AA_it=ValueV1.find(RLVV1); + if (AA_it==ValueV1.end()) + { + pair dataS (1,1); + ValueV1.insert( map < string,pair >::value_type(RLVV1,dataS)); + } + else + { + (AA_it->second).first++; + } + } + } + LIST.close(); + + igzstream LIST2 (File2.c_str(),ifstream::in); + getline(LIST2,chr); + while(!LIST2.eof()) + { + string line ; + getline(LIST2,line); + if (line.length()<=0) {continue;} + istringstream isone (line,istringstream::in); + isone>>chr>>Start>>End>>RLVV1; + if(RLVV1!=""NA"" ) + { + RLVV1=RLVV1.substr(0,4); + AA_it=ValueV1.find(RLVV1); + if(RLVV1<""0.200"") + { + (AA_it->second).second=2; + } + else + { + (AA_it->second).second=3; + } + } + } + LIST2.close(); + + + int MaxXX=0; + OUTPLOT<<""RLV\tNum\tType\n""; + + for(AA_it=ValueV1.begin();AA_it!=ValueV1.end();AA_it++) + { + + if((AA_it->second).second==1) + { + OUTPLOT<first<<""\t""<<(AA_it->second).first<<""\tNoSele\n""; + } + else if ((AA_it->second).second==2) + { + OUTPLOT<first<<""\t""<<(AA_it->second).first<<""\tSeleLow\n""; + } + else + { + OUTPLOT<first<<""\t""<<(AA_it->second).first<<""\tSeleHigh\n""; + } + } + OUTPLOT.close(); + + string OutPlotr=(paraFA04->InStr2)+"".tmp2.r""; + ofstream OUTR (OutPlotr.c_str()); + + OUTR<<"""" + ""\n"" + ""library(ggplot2);library(ggthemes);\n"" + ""read.table(\""""<data;\n"" + ""RLV<-data[,1];\nNum<-data[,2];\nsele<-data[,3];\n"" + ""df <- data.frame(RLV,Num);\n"" + ""p <- ggplot(df, aes(x = RLV, y = Num, col = sele,fill=factor(sele) ) ) + geom_bar(stat = \""identity\"") + theme_economist();\n"" + ""pdf(\""""<<(paraFA04->InStr2)<<"".Dis.pdf\"");\n"" + ""p\n"" + ""dev.off()\n"" + ""png(\""""<<(paraFA04->InStr2)<<"".Dis.png\"");\n"" + ""p\n"" + ""dev.off()\n""< /dev/null ""; + memset( buf, '\0', sizeof(buf) ); + FILE *stream ; + stream=popen(cc.c_str(),""r"") ; + fread( buf, sizeof(char), sizeof(buf), stream); + string binPath=buf; + binPath=binPath.substr(0,binPath.length()-1); + if (binPath == """" ) + { + cout <<""\twarning: can't find the [Rscript] in your $PATH ; no png Figure Out""<TF) + { + //cc=binPath+""\t""+OutPlotr ; + cc=binPath+""\t""+OutPlotr+"" ; rm -rf ""+ OutPlotr+ "" ""+ OutPlotTmp; + std::system(cc.c_str()) ; + } + else + { + cc=binPath+""\t""+OutPlotr ; + std::system(cc.c_str()) ; + cout <<""\t\tRePlot : Rscript ""< > > & SNPList , map & MaxSNPSite) +{ + string Stat=(paraFA04->InStr2)+"".winRR.temp.gz""; + ogzstream OUT ((Stat).c_str()); + if((!OUT.good())) + { + cerr << ""open OUT File error: ""< :: iterator MaxIT ; + map > > :: iterator key1_it ; + + int ALL_count=0; + double SumRLV=0.0; + + for (MaxIT=MaxSNPSite.begin(); MaxIT!=MaxSNPSite.end();MaxIT++) + { + int MaxBin=int((MaxIT->second)/(paraFA04->bin))+1; + (paraFA04->count)++; + StarRsult **All_Stat = new StarRsult *[(paraFA04->count)]; + for (int kk=0 ; kk<(paraFA04->count) ; kk++) + { + All_Stat[kk]=new StarRsult[MaxBin]; + } + + key1_it=SNPList.find(MaxIT->first); + (paraFA04->count)--; + PairWiseRRCal( paraFA04, para_18, key1_it->second , All_Stat); + + MaxBin=MaxBin-(paraFA04->count)+1; + for (int ii=0 ; iicount); jj++) + { + for (int uu=jj ; uu<(paraFA04->count) ; uu++) + { + count+=(All_Stat[uu][ii+jj]).Count; + SumRR+=(All_Stat[uu][ii+jj]).sumRR; + } + } + if (count<(paraFA04->Masked)) {continue;} + double RLV=SumRR/count; + llong Start=ii*(paraFA04->bin); + llong End=Start+(paraFA04->WindowSize); + SumRLV+=RLV; + ALL_count++; + OUT<first<<""\t""<count) ; kk++) + { + delete [] All_Stat[kk]; + } + + delete [] All_Stat ; + } + OUT.close(); + + + + double meaWolRR=SumRLV/ALL_count; + + + igzstream INAA (Stat.c_str(),ifstream::in); + if (INAA.fail()) + { + cerr << ""open Sub Group IN File error: ""<InStr2)+"".winRR.gz""; + ogzstream OUTSS ((StatSS).c_str()); + if((!OUTSS.good())) + { + cerr << ""open OUT File error: ""<InStr2)+"".selection.gz""; + ogzstream OUTSELE ((StatSELE).c_str()); + if((!OUTSELE.good())) + { + cerr << ""open OUT File error: ""<>chr>>start>>end>>AARR; + diff=AARR-meaWolRR; + SD+=(diff*diff); + } + INAA.close(); + SD=sqrt(SD/ALL_count); + + + igzstream INBB (Stat.c_str(),ifstream::in); + if (INBB.fail()) + { + cerr << ""open Sub Group IN File error: ""<>chr>>start>>end>>AARR; + diff=AARR-meaWolRR; + if (diff<0) + { + PValue=pnorm5(AARR, meaWolRR , SD , 1 , 0 ); + } + else + { + PValue=(1-pnorm5(AARR, meaWolRR , SD , 1 , 0 )); + } + + ZScore=diff/SD; + if (ZScore<0){ZScore=0-ZScore;} + OUTSS<0 && PValue<(paraFA04->Pvalue)) + { + OUTSELE<InStr2)+"".tmp""; + ofstream OUTPLOT (OutPlotTmp.c_str()); + + igzstream LIST (File.c_str(),ifstream::in); + + string chr=""""; + getline(LIST,chr); + getline(LIST,chr); + getline(LIST,chr); + getline(LIST,chr); + string Start,End,RLVV1,SumESV1,CountV1,RLVV2; + + map VecChr; + map > ValueV1; + map > ValueV2; + map > :: iterator iTValue; + + map :: iterator itVecChr ; + while(!LIST.eof()) + { + string line ; + getline(LIST,line); + if (line.length()<=0) { continue ;} + istringstream isone (line,istringstream::in); + isone>>chr>>Start>>End>>RLVV1>>SumESV1>>CountV1>>RLVV2 ; + + itVecChr=VecChr.find(chr); + if (itVecChr==VecChr.end()) + { + VecChr.insert(map ::value_type(chr,1)); + map DataEEV1; + map DataEEV2; + DataEEV1[0]=RLVV1; + DataEEV2[0]=RLVV2; + ValueV1.insert(map > ::value_type(chr,DataEEV1)); + ValueV2.insert(map > ::value_type(chr,DataEEV2)); + } + else + { + iTValue=ValueV1.find(chr); + (iTValue->second).insert(map ::value_type(itVecChr->second,RLVV1)); + iTValue=ValueV2.find(chr); + (iTValue->second).insert(map ::value_type(itVecChr->second,RLVV2)); + itVecChr->second++; + } + } + LIST.close(); + + int MaxXX=0; + OUTPLOT<<""Site""; + for(itVecChr=VecChr.begin();itVecChr!=VecChr.end();itVecChr++) + { + if (MaxXX<(itVecChr->second)) {MaxXX=itVecChr->second;} + OUTPLOT<<""\t""<first<<""\t""<first; + } + OUTPLOT< :: iterator itEEEE; + for (int ii=0 ; ii< MaxXX ; ii++) + { + OUTPLOT< (itVecChr->second) ) + { + OUTPLOT<<""\t0.0\t0.0""; + continue ; + } + + iTValue=ValueV1.find(itVecChr->first); + itEEEE=(iTValue->second).find(ii); + + if (itEEEE==(iTValue->second).end()) + { + OUTPLOT<<""\tNA""; + } + else + { + OUTPLOT<<""\t""<second; + } + + iTValue=ValueV2.find(itVecChr->first); + itEEEE=(iTValue->second).find(ii); + if (itEEEE==(iTValue->second).end()) + { + OUTPLOT<<""\tNA""; + } + else + { + OUTPLOT<<""\t""<second ; + } + } + OUTPLOT<InStr2)+"".tmp.r""; + ofstream OUTR (OutPlotr.c_str()); + + OUTR<<"""" + ""\n"" + ""library(ggplot2);\nlibrary(reshape2);\n"" + ""read.table(\""""<data;\n"" + ""data2<-melt(data,id=1);\n"" + ""p <- ggplot(data = data2)+geom_tile(aes(x = Site,y = variable, fill=value))+scale_fill_gradient(limit=c(0,1),low ='white',high ='red',na.value=\""grey50\"")\n"" + ""pdf(\""""<<(paraFA04->InStr2)<<"".sliding.pdf\"",h=6,w=25);\n"" + ""p\n"" + ""dev.off()\n"" + ""png(\""""<<(paraFA04->InStr2)<<"".sliding.png\"",h=6,w=25);\n"" + ""p\n"" + ""dev.off()\n""< /dev/null ""; + memset( buf, '\0', sizeof(buf) ); + FILE *stream ; + stream=popen(cc.c_str(),""r"") ; + fread( buf, sizeof(char), sizeof(buf), stream); + string binPath=buf; + binPath=binPath.substr(0,binPath.length()-1); + if (binPath == """" ) + { + cout <<""\twarning: can't find the [Rscript] in your $PATH ; no png Figure Out""<TF) + { + //cc=binPath+""\t""+OutPlotr; + cc=binPath+""\t""+OutPlotr+"" ; rm -rf ""+ OutPlotr + "" ""+ OutPlotTmp ; + std::system(cc.c_str()) ; + } + else + { + cc=binPath+""\t""+OutPlotr ; + std::system(cc.c_str()) ; + cout <<""\t\tRePlot : Rscript ""<InStr2)+"".tmp2""; + ofstream OUTPLOT (OutPlotTmp.c_str()); + + igzstream LIST (File1.c_str(),ifstream::in); + + string chr=""""; + getline(LIST,chr); + getline(LIST,chr); + getline(LIST,chr); + getline(LIST,chr); + string Start,End,RLVV1,SumESV1,CountV1,RLVV2; + + map > > ValueV1; + map > > :: iterator AA_it; + map < string,pair > :: iterator BB_it ; + + while(!LIST.eof()) + { + string line ; + getline(LIST,line); + if (line.length()<=0) {continue;} + istringstream isone (line,istringstream::in); + isone>>chr>>Start>>End>>RLVV1>>SumESV1>>CountV1>>RLVV2; + if(RLVV1!=""NA"" && RLVV2!=""NA"" ) + { + RLVV1=RLVV1.substr(0,4); + RLVV2=RLVV2.substr(0,4); + AA_it=ValueV1.find(RLVV1); + if (AA_it==ValueV1.end()) + { + pair dataS (1,1); + map < string,pair > BBHash; + BBHash[RLVV2]=dataS; + ValueV1.insert(map > >::value_type(RLVV1,BBHash)); + } + else + { + BB_it=(AA_it->second).find(RLVV2); + if(BB_it==(AA_it->second).end()) + { + pair dataS (1,1); + (AA_it->second).insert(map < string,pair >::value_type(RLVV2,dataS)); + } + else + { + (BB_it->second).first++; + } + } + } + } + LIST.close(); + + igzstream LIST2 (File2.c_str(),ifstream::in); + getline(LIST2,chr); + while(!LIST2.eof()) + { + string line ; + getline(LIST2,line); + if (line.length()<=0) {continue;} + istringstream isone (line,istringstream::in); + isone>>chr>>Start>>End>>RLVV1>>SumESV1>>CountV1>>RLVV2; + if(RLVV1!=""NA"" && RLVV2!=""NA"" ) + { + RLVV1=RLVV1.substr(0,4); + RLVV2=RLVV2.substr(0,4); + AA_it=ValueV1.find(RLVV1); + BB_it=(AA_it->second).find(RLVV2); + if(RLVV1>RLVV2) + { + (BB_it->second).second=2; + } + else + { + (BB_it->second).second=3; + } + } + } + LIST2.close(); + + + int MaxXX=0; + OUTPLOT<<""RLVA\tRLVB\tNum\tType\n""; + + for(AA_it=ValueV1.begin();AA_it!=ValueV1.end();AA_it++) + { + for(BB_it=(AA_it->second).begin();BB_it!=(AA_it->second).end();BB_it++) + { + if((BB_it->second).second==1) + { + OUTPLOT<first<<""\t""<first<<""\t""<<(BB_it->second).first<<""\tNoSele\n""; + } + else if ((BB_it->second).second==2) + { + OUTPLOT<first<<""\t""<first<<""\t""<<(BB_it->second).first<<""\tSele""<first<<""\t""<first<<""\t""<<(BB_it->second).first<<""\tSele""<InStr2)+"".tmp2.r""; + ofstream OUTR (OutPlotr.c_str()); + + OUTR<<"""" + ""\n"" + ""library(ggplot2);library(gridExtra);library(ggExtra);\n"" + ""read.table(\""""<data;\n"" + ""RLVA<-data[,1];\nRLVB<-data[,2];\nNum<-data[,3];\nType<-data[,4];\n"" + ""df <- data.frame(RLVA,RLVB);\n"" + ""p <- ggplot(df, aes(RLVA, RLVB,colour=Num,shape=Type)) + geom_point(size=1.5) +theme(legend.direction=\""horizontal\"",legend.position= \""bottom\"",legend.title = element_text(face =\""bold\"",size=7));\n"" + ""pdf(\""""<<(paraFA04->InStr2)<<"".Dis.pdf\"");\n"" + ""ggExtra::ggMarginal(p, type = \""histogram\"");\n"" + ""dev.off()\n"" + ""png(\""""<<(paraFA04->InStr2)<<"".Dis.png\"");\n"" + ""ggExtra::ggMarginal(p, type = \""histogram\"");\n"" + ""dev.off()\n""< /dev/null ""; + memset( buf, '\0', sizeof(buf) ); + FILE *stream ; + stream=popen(cc.c_str(),""r"") ; + fread( buf, sizeof(char), sizeof(buf), stream); + string binPath=buf; + binPath=binPath.substr(0,binPath.length()-1); + if (binPath == """" ) + { + cout <<""\twarning: can't find the [Rscript] in your $PATH ; no png Figure Out""<TF) + { + //cc=binPath+""\t""+OutPlotr ; + cc=binPath+""\t""+OutPlotr+"" ; rm -rf ""+ OutPlotr + "" ""+ OutPlotTmp; + std::system(cc.c_str()) ; + } + else + { + cc=binPath+""\t""+OutPlotr ; + std::system(cc.c_str()) ; + cout <<""\t\tRePlot : Rscript ""< > > & SNPListV1 , map > > & SNPListV2 , map & MaxSNPSite , map & GroupID ) +{ + string Stat=(paraFA04->InStr2)+"".winRR.temp.gz""; + ogzstream OUT ((Stat).c_str()); + if((!OUT.good())) + { + cerr << ""open OUT File error: ""< :: iterator ITID ; + for (ITID=GroupID.begin(); ITID!=GroupID.end();ITID++) + { + if ((ITID->second)==1) + { + IDA=ITID->first; + } + else if ((ITID->second)==2) + { + IDB=ITID->first; + } + } + OUT<<""#Chr\tStart\tEnd\tRLV_""< :: iterator MaxIT ; + map > > :: iterator key1_it ; + + int ALL_countV1=0; + int ALL_countV2=0; + double SumRLVV1=0.0; + double SumRLVV2=0.0; + double DiffSum=0.0; + int ALL_count_Diff=0; + + + for (MaxIT=MaxSNPSite.begin(); MaxIT!=MaxSNPSite.end();MaxIT++) + { + int MaxBin=int((MaxIT->second)/(paraFA04->bin))+1; + + (paraFA04->count)++; + StarRsult **All_StatV1 = new StarRsult *[(paraFA04->count)]; + StarRsult **All_StatV2 = new StarRsult *[(paraFA04->count)]; + for (int kk=0 ; kk<(paraFA04->count) ; kk++) + { + All_StatV1[kk]=new StarRsult[MaxBin]; + All_StatV2[kk]=new StarRsult[MaxBin]; + } + + (paraFA04->count)--; + + key1_it=SNPListV1.find(MaxIT->first); + PairWiseRRCal( paraFA04, para_18, key1_it->second , All_StatV1); + key1_it=SNPListV2.find(MaxIT->first); + PairWiseRRCal( paraFA04, para_18, key1_it->second , All_StatV2); + +// cout<count)<count)+1; + for (int ii=0 ; iibin); + llong End=Start+(paraFA04->WindowSize); + + double countV1=0; + double countV2=0; + double SumRRV1=0; + double SumRRV2=0; + for (int jj=0; jj<(paraFA04->count); jj++) + { + for (int uu=jj ; uu<(paraFA04->count) ; uu++) + { + countV1+=(All_StatV1[uu][ii+jj]).Count; + SumRRV1+=(All_StatV1[uu][ii+jj]).sumRR; + countV2+=(All_StatV2[uu][ii+jj]).Count; + SumRRV2+=(All_StatV2[uu][ii+jj]).sumRR; + } + } + double RLVV1=-1; + double RLVV2=-1; + double Diff=-8; + if ( (countV1>=(paraFA04->Masked) ) && (countV2>=(paraFA04->Masked)) ) + { + RLVV1=SumRRV1/countV1; + SumRLVV1+=RLVV1; + ALL_countV1++; + RLVV2=SumRRV2/countV2; + SumRLVV2+=RLVV2; + ALL_countV2++; + Diff=RLVV1-RLVV2 ; + ALL_count_Diff++; + DiffSum+=Diff; + } + else if ( (countV1>=(paraFA04->Masked)) && (countV2<(paraFA04->Masked)) ) + { + RLVV1=SumRRV1/countV1; + SumRLVV1+=RLVV1; + ALL_countV1++; + } + else if ( (countV1<(paraFA04->Masked)) && (countV2>=(paraFA04->Masked)) ) + { + RLVV2=SumRRV2/countV2; + SumRLVV2+=RLVV2; + ALL_countV2++; + } + + OUT<first<<""\t""<count) ; kk++) + { + delete [] All_StatV1[kk]; + delete [] All_StatV2[kk]; + } + delete [] All_StatV1 ; + delete [] All_StatV2 ; + } + OUT.close(); + + + + double meaWolRRV1=SumRLVV1/ALL_countV1; + double meaWolRRV2=SumRLVV2/ALL_countV2; + double meaWolDiff=DiffSum/ALL_count_Diff; + + igzstream INAA (Stat.c_str(),ifstream::in); + if (INAA.fail()) + { + cerr << ""open Sub Group IN File error: ""<InStr2)+"".winRR.gz""; + ogzstream OUTSS ((StatSS).c_str()); + if((!OUTSS.good())) + { + cerr << ""open OUT File error: ""<InStr2)+"".diffRegion.gz""; + ogzstream OUTSELE ((StatSELE).c_str()); + if((!OUTSELE.good())) + { + cerr << ""open OUT File error: ""<>chr>>start>>end>>AARRV1>>SumESV1>>CountV1>>AARRV2>>SumESV2>>CountV2>>DiffHere; + if (AARRV1>=0 ) + { + diffV1=AARRV1-meaWolRRV1; + SDV1+=(diffV1*diffV1); + } + if (AARRV2>=0) + { + diffV2=AARRV2-meaWolRRV2; + SDV2+=(diffV2*diffV2); + } + if ( DiffHere>-6) + { + diffDiff=DiffHere-meaWolDiff; + SDDiff+=(diffDiff*diffDiff); + } + + } + INAA.close(); + SDV1=sqrt(SDV1/ALL_countV1); + SDV2=sqrt(SDV2/ALL_countV2); + SDDiff=sqrt(SDDiff/ALL_count_Diff); + + + igzstream INBB (Stat.c_str(),ifstream::in); + if (INBB.fail()) + { + cerr << ""open Sub Group IN File error: ""<>chr>>start>>end>>AARRV1>>SumESV1>>CountV1>>AARRV2>>SumESV2>>CountV2>>DiffHere; + if ( DiffHere> -6 ) + { + diffV1=DiffHere-meaWolDiff; + if (diffV1<0) + { + PValue=pnorm5(DiffHere, meaWolDiff , SDDiff , 1 , 0 ); + } + else + { + PValue=(1-pnorm5(DiffHere, meaWolDiff , SDDiff , 1 , 0 )); + } + + ZScore=diffV1/SDDiff; + OUTSS<Pvalue)) + { + OUTSELE<=0) + { + OUTSS< -OutPut \n"" + ""\n"" + ""\t\t-InVCF Input SNP VCF Format\n"" + ""\t\t-OutPut OutPut sliding stat mean r^2 Result\n"" + ""\n"" + ""\t\t-SubGroup one/two sub-group Sample List File,-h for more help\n"" + ""\t\t-Windows Sliding windows bin (kb),MaxDis between two pairwise SNP[300]\n"" + ""\t\t-Step Step ratio(0,1] of windows,1:NoOverlap [0.2]\n"" + ""\t\t-Masked Masked windows when the SNP Number too low[10]\n"" + ""\t\t\n"" + ""\t\t-MAF Min minor allele frequency filter [0.05]\n"" + ""\t\t-Het Max ratio of het allele filter [0.88]\n"" + ""\t\t-Miss Max ratio of miss allele filter [0.25]\n"" + ""\t\t\n"" + ""\t\t-Pvalue T-test Pvalue to pick out selection region[0.005]\n"" + ""\t\t-KeepR Keep Rscript used to modify and plots\n"" + ""\t\t\n"" + ""\t\t-help See more help [hewm2008 Beta v0.85]\n"" + ""\n""; +} + +void More_HelpRRSelection() +{ + cout<<"""" + ""\n"" + ""\t\t More Help document please see the Manual.pdf file\n"" + ""\t\t 1. Para [-SubGroup] only can accept one or two groups\n"" + ""\t\t (1.1) For two sub group, the input file should be fixed format(groupID : samaple list), For example :\n"" + ""\t\t cultivation : CulSampleNameA CulSampleNameB ... CulSampleNameN\n"" + ""\t\t wild : WildSampleNameA WildSampleNameB ... WildSampleNameN\n"" + ""\t\t (1.2) For one sub group, the input file should be fixed or not. Rows or Columns is ok\n"" + ""\t\t wild : WildSampleNameA WildSampleNameB ... WildSampleNameN\n"" + ""\n""; +} + +int LDdecay_help01(int argc, char **argv , In3str1v * paraFA04, Para_18 * para_18) +{ + if (argc <2 ) {RRSelection_help();return 0;} + + for(int i = 1; i < argc ; i++) + { + if(argv[i][0] != '-') + { + cerr << ""command option error! please check."" << endl; + return 0; + } + string flag=argv[i] ; + flag=replace_all(flag,""-"",""""); + + if (flag == ""InVCF"" || flag == ""i"") + { + if(i + 1 == argc) {LogLackArg(flag); return 0;} + i++; + paraFA04->InStr1=argv[i]; + } + else if (flag == ""SubGroup"" || flag == ""s"") + { + if(i + 1 == argc) {LogLackArg(flag); return 0;} + i++; + paraFA04->SubPop=argv[i]; + } + else if (flag == ""OutPut"" || flag == ""o"" ) + { + if(i + 1 == argc) {LogLackArg(flag); return 0;} + i++; + paraFA04->InStr2=argv[i]; + } + else if (flag == ""Het"" ) + { + if(i + 1 == argc) {LogLackArg(flag); return 0;} + i++; + para_18->Het=atof(argv[i]); + } + else if (flag == ""Masked"") + { + if(i + 1 == argc) {LogLackArg(flag); return 0;} + i++; + paraFA04->Masked=atoi(argv[i]); + } + else if (flag == ""MAF"") + { + if(i + 1== argc) {LogLackArg(flag);return 0;} + i++; + para_18->MAF=atof(argv[i]); + } + else if (flag == ""Pvalue"") + { + if(i + 1 == argc) {LogLackArg(flag);return 0;} + i++; + paraFA04->Pvalue=atof(argv[i]); + } + else if (flag == ""Miss"") + { + if(i + 1 == argc) {LogLackArg(flag);return 0;} + i++; + para_18->Miss=atof(argv[i]); + } + else if (flag == ""Windows"" ) + { + if(i + 1 == argc) {LogLackArg(flag);return 0;} + i++; + paraFA04->WindowSize=atoi(argv[i]); + } + else if (flag == ""Step"") + { + if(i + 1 == argc) {LogLackArg(flag);return 0;} + i++; + paraFA04->Step=atof(argv[i]); + if ( (paraFA04->Step)>0 && (paraFA04->Step)<=1.0) {} else + { + cerr <<""ratio should be in the Number region (0,1]\n""; + return 0; + } + } + else if (flag == ""KeepR"") + { + paraFA04->TF=false; + } + else if (flag == ""help"" || flag == ""h"") + { + More_HelpRRSelection();return 0; + } + else + { + cerr << ""UnKnow argument -""<InStr2).empty() || (paraFA04->InStr1).empty() ) + { + cerr<< ""lack argument for the must""<InStr2); + string ext =Stat.substr(Stat.rfind('.') ==string::npos ? Stat.length() : Stat.rfind('.') + 1); + if (ext == ""gz"") + { + (paraFA04->InStr2)=(paraFA04->InStr2).substr(0,(paraFA04->InStr2).length()-3); + } + + Stat=(paraFA04->InStr2); + ext =Stat.substr(Stat.rfind('/') ==string::npos ? Stat.length() : Stat.rfind('/') + 1); + + if (ext != ""stat"") + { + ext =Stat.substr(Stat.rfind('.') ==string::npos ? Stat.length() : Stat.rfind('.') + 1); + if (ext == ""stat"") + { + (paraFA04->InStr2)=(paraFA04->InStr2).substr(0,(paraFA04->InStr2).length()-5); + } + } + return 1 ; +} + + + +int main(int argc, char *argv[]) +{ + In3str1v *paraFA04 = new In3str1v; + Para_18 * para_18 = new Para_18 ; + if ((LDdecay_help01(argc, argv, paraFA04, para_18)==0)) + { + delete paraFA04 ; + delete para_18 ; + return 1 ; + } + + (paraFA04->WindowSize)=(paraFA04->WindowSize)*1000; + (paraFA04->count)=int(1/(paraFA04->Step)); + (paraFA04->Step)=1.0/(paraFA04->count); + (paraFA04->bin)=int((paraFA04->WindowSize)/(paraFA04->count)); + (paraFA04->Masked)=int(((paraFA04->Masked)*((paraFA04->Masked)-1)/2)* 1.6449); // sum(1/(n*n))= pi^2/6 =1.6449 + + //*///////////////////////////Test Out File is OK ///////////////////////////////*// + string Stat=(paraFA04->InStr2); + Stat=(paraFA04->InStr2)+"".winRR.gz""; + ogzstream OUTTest ((Stat).c_str()); + if((!OUTTest.good())) + { + cerr << ""open OUT File error: ""< > > SNPList ; + map MaxSNPSite; + map > > SNPListSub ; + int Flag_for_pro=0; + + map GroupID ; + + /////* VCF IN Deal //////////////////////*//// + bool PhaseVCF=DeleVCFPhase(paraFA04->InStr1); + + int IFTwoGroup=1 ; + if (!(paraFA04->SubPop).empty() ) + { + map SubVetor ; + IFTwoGroup=Identify_subgroup(paraFA04->SubPop, SubVetor,GroupID ); + if ( IFTwoGroup ==2 ) // two group Read + { + if ( PhaseVCF ) + { + Read_TwoPopVCF_IN_Phase( paraFA04, para_18 ,SubVetor , SNPList,SNPListSub ,MaxSNPSite, Flag_for_pro); + } + else + { + Read_TwoPopVCF_IN( paraFA04, para_18 ,SubVetor, SNPList,SNPListSub,MaxSNPSite, Flag_for_pro); + } + } + else if (IFTwoGroup >2 ) // muti group wrong exit + { + delete para_18; + delete paraFA04 ; return 1 ; + } + else // one group with sub pop + { + if ( PhaseVCF ) + { + Read_SubPopVCF_IN_Phase( paraFA04, para_18 , SNPList,MaxSNPSite, Flag_for_pro); + } + else + { + Read_SubPopVCF_IN( paraFA04, para_18 , SNPList,MaxSNPSite, Flag_for_pro); + } + } + } + else // one group with all sample + { + if ( PhaseVCF ) + { + Read_VCF_IN_Phase( paraFA04, para_18 , SNPList, MaxSNPSite, Flag_for_pro); + } + else + { + Read_VCF_IN( paraFA04, para_18 , SNPList,MaxSNPSite, Flag_for_pro); + } + } + + + + //*///////////////////////////PairWise Compare//////////////////////////////////*// + + if ( IFTwoGroup ==1 ) // run one group + { + cout<<""##begin pair-wise R^2 cal. after filter Remain SNP Number :\t""<WindowSize)<WindowSize)< SubVetor , map > > & SNPListV1, map > > & SNPListV2, map & MaxSNPSite ,int & Flag_for_pro) +{ + + igzstream VCFIN ((paraFA04->InStr1).c_str(),ifstream::in); + if (VCFIN.fail()) + { + cerr << ""open VCF File IN File error: ""<<(paraFA04->InStr1)< SampleSiteV1; + vector SampleSiteV2; + vector Vsample; + map :: iterator it; + map CountSample ; + for (it = SubVetor.begin(); it!=SubVetor.end(); it++) + { + CountSample.insert(map ::value_type(it->first,0)); + } + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ;} + else if ( line[0] == '#' && line[1] == '#') { continue ; } + else if ( line[0] == '#' && line[1] != '#') + { + Vsample.clear(); + split(line,Vsample,"" \t""); + if ( Vsample[0] != ""#CHROM"") + { + continue ; + } + int A=Vsample.size(); + for (int ii=9 ; ii< A ; ii++) + { + it=SubVetor.find(Vsample[ii]); + if (it!=SubVetor.end()) + { + if ((it->second)==1) + { + SampleSiteV1.push_back(ii); + } + else if ((it->second)==2) + { + SampleSiteV2.push_back(ii); + } + CountSample[Vsample[ii]]++; + } + } + break ; + } + else if ( line[0] != '#' && line[1] != '#' ) + { + cerr<<""wrong Line : ""<=10, SubGroup One sample size: ""<=10, SubGroup Two sample size: ""<second)==0) + { + cerr<<""warning : Sample [ ""<<(it->first)<<"" ] can't be found in the VCF Header\n""; + } + else if ((it->second)>1) + { + cerr<<""warning : Sample [ ""<<(it->first)<<"" ] can be found [Repeat] in the VCF Header\n""; + } + } + + + int Asample=Vsample.size(); + + int BadSite=0; + int BadIndelSite=0; + + vector Alt ; + vector Btmp ; + int Base_len ; + llong Site ; + int Het_count=0; + int Miss_count=0; + char ABase ; + char BBase ; + + int BaseConut=0; + char best_base='N'; + char sed_base='N'; + int Max=0; + int SeD=0; + map :: iterator itSS ; + int ERA=0; + vector genotype ; + vector genotypeVE ; + + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ; } + istringstream isoneLine (line,istringstream::in); + for (int iik=0 ; iik>Vsample[iik]; + } + + Base_len=Vsample[3].length(); + Alt.clear(); + split(Vsample[4],Alt,"",""); + for (int ii=0 ; iiBase_len) + { + Base_len=Alt[ii].length(); + } + } + + if (Base_len>1) + { + BadIndelSite++; + continue ; + } + + + for (int kkkk=0 ; kkkk<2 ; kkkk++) + { + if (kkkk==0) + { + map Count ; + Het_count=0; + Miss_count=0; + + for (int kk=0 ; kk< NumberSubGroupV1 ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSiteV1[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + + if ( Genotype[0] == '.' ) + { + Miss_count++; + } + else + { + if (Genotype[0] != Genotype[2] ) + { + Het_count++; + } + Count[Genotype[0]]++; + Count[Genotype[2]]++; + } + } + + + if ( ( (Miss_count*1.0/NumberSubGroupV1) >(para_18->Miss) ) ) + { + continue ; + } + + if ( ( (Het_count*1.0/NumberSubGroupV1) >(para_18->Het) ) ) + { + continue ; + } + + BaseConut=0; + best_base='N'; + sed_base='N'; + Max=0; + SeD=0; + + for ( itSS=Count.begin(); itSS!=Count.end(); itSS++ ) + { + if ( (itSS->first ) == 'N' ) + { + continue ; + } + else if ((itSS->second) > Max ) + { + SeD=Max; + sed_base=best_base; + Max=(itSS->second); + best_base=itSS->first; + } + else if ( (itSS->second) >= SeD ) + { + SeD=(itSS->second); + sed_base=itSS->first; + } + BaseConut++; + } + if (BaseConut==1 || BaseConut >2 ) + { + BadSite++; + continue ; + } + + //if ( ( (1-(Max*0.5/NumberSubGroup)) < (para_18->MAF) ) ) + if ( (SeD*1.0/(SeD+Max)) < (para_18->MAF) ) + { + continue ; + } + + genotypeVE.clear(); + genotype.clear(); + // vector genotypeVE ; + + BaseType TypeA; + + // vector genotype ; + for (int kk=0 ; kk< NumberSubGroupV1 ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSiteV1[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + ABase=Genotype[0]; + if ( ABase == '.' ) + { + genotype.push_back('N'); + genotype.push_back('N'); + } + else + { + BBase=Genotype[2]; + genotype.push_back(ABase); // phase + genotype.push_back(BBase); + } + } + + + ERA=genotype.size(); + for (int hh=0 ; hh> Site ; + + + map > > :: iterator itSNP=SNPListV1.find(Vsample[0]); + + + if (itSNP == SNPListV1.end()) + { + map > DD; + DD[Site]=genotypeVE; + SNPListV1.insert(map > > ::value_type(Vsample[0],DD)); + Flag_for_pro++; + MaxSNPSite.insert(map ::value_type(Vsample[0],Site)); + } + else + { + (itSNP->second).insert(map > :: value_type(Site,genotypeVE)); + Flag_for_pro++; + map :: iterator MaxIT =MaxSNPSite.find(Vsample[0]); + if ( (MaxIT->second) < Site ) + { + MaxIT->second=Site ; + } + } + + + } + else + { + + + + + + map Count ; + Het_count=0; + Miss_count=0; + + for (int kk=0 ; kk< NumberSubGroupV2 ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSiteV2[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + + if ( Genotype[0] == '.') + { + Miss_count++; + } + else + { + if (Genotype[0] != Genotype[2]) + { + Het_count++; + } + Count[Genotype[0]]++; + Count[Genotype[2]]++; + } + } + + + if ( ( (Miss_count*1.0/NumberSubGroupV2) >(para_18->Miss) ) ) + { + continue ; + } + + if ( ( (Het_count*1.0/NumberSubGroupV2) >(para_18->Het) ) ) + { + continue ; + } + + BaseConut=0; + best_base='N'; + sed_base='N'; + Max=0; + SeD=0; + + for ( itSS=Count.begin(); itSS!=Count.end(); itSS++ ) + { + if ( (itSS->first ) == 'N' ) + { + continue ; + } + else if ((itSS->second) > Max ) + { + SeD=Max; + sed_base=best_base; + Max=(itSS->second); + best_base=itSS->first; + } + else if ( (itSS->second) >= SeD ) + { + SeD=(itSS->second); + sed_base=itSS->first; + } + BaseConut++; + } + if (BaseConut==1 || BaseConut >2 ) + { + BadSite++; + continue ; + } + + //if ( ( (1-(Max*0.5/NumberSubGroup)) < (para_18->MAF) ) ) + if ( (SeD*1.0/(SeD+Max)) < (para_18->MAF) ) + { + continue ; + } + + genotypeVE.clear(); + genotype.clear(); + // vector genotypeVE ; + + BaseType TypeA; + + // vector genotype ; + for (int kk=0 ; kk< NumberSubGroupV2 ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSiteV2[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + ABase=Genotype[0]; + if ( ABase == '.' ) + { + genotype.push_back('N'); + genotype.push_back('N'); + } + else + { + BBase=Genotype[2]; + genotype.push_back(ABase); // phase VCF + genotype.push_back(BBase); // phase VCF + } + } + + + ERA=genotype.size(); + for (int hh=0 ; hh> Site ; + + + map > > :: iterator itSNP=SNPListV2.find(Vsample[0]); + + + if (itSNP == SNPListV2.end()) + { + map > DD; + DD[Site]=genotypeVE; + SNPListV2.insert(map > > ::value_type(Vsample[0],DD)); + Flag_for_pro++; + MaxSNPSite.insert(map ::value_type(Vsample[0],Site)); + } + else + { + (itSNP->second).insert(map > :: value_type(Site,genotypeVE)); + Flag_for_pro++; + map :: iterator MaxIT =MaxSNPSite.find(Vsample[0]); + if ( (MaxIT->second) < Site ) + { + MaxIT->second=Site ; + } + } + + + + + + } + } + + } + if(BadIndelSite!=0) + { + cout<<""warning skip Indel site, there are total skip Indel sites number is : ""< SubVetor , map > > & SNPListV1, map > > & SNPListV2, map & MaxSNPSite ,int & Flag_for_pro) +{ + + igzstream VCFIN ((paraFA04->InStr1).c_str(),ifstream::in); + if (VCFIN.fail()) + { + cerr << ""open VCF File IN File error: ""<<(paraFA04->InStr1)< SampleSiteV1; + vector SampleSiteV2; + vector Vsample ; + map :: iterator it; + map CountSample; + for (it = SubVetor.begin(); it!=SubVetor.end(); it++) + { + CountSample.insert(map ::value_type(it->first,0)); + } + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ;} + else if ( line[0] == '#' && line[1] == '#') { continue ; } + else if ( line[0] == '#' && line[1] != '#') + { + Vsample.clear(); + split(line,Vsample,"" \t""); + if ( Vsample[0] != ""#CHROM"") + { + continue ; + } + int A=Vsample.size(); + for (int ii=9 ; ii< A ; ii++) + { + it=SubVetor.find(Vsample[ii]); + if (it!=SubVetor.end()) + { + if ((it->second)==1) + { + SampleSiteV1.push_back(ii); + } + else if ((it->second)==2) + { + SampleSiteV2.push_back(ii); + } + CountSample[Vsample[ii]]++; + } + } + break ; + } + else if ( line[0] != '#' && line[1] != '#' ) + { + cerr<<""wrong Line : ""<=10, SubGroup One sample size: ""<=10, SubGroup Two sample size: ""<second)==0) + { + cerr<<""warning : Sample [ ""<<(it->first)<<"" ] can't be found in the VCF Header\n""; + } + else if ((it->second)>1) + { + cerr<<""warning : Sample [ ""<<(it->first)<<"" ] can be found [Repeat] in the VCF Header\n""; + } + } + + + int Asample=Vsample.size(); + + int BadSite=0; + int BadIndelSite=0; + + vector Alt ; + vector Btmp ; + int Base_len ; + llong Site ; + int Het_count=0; + int Miss_count=0; + char ABase ; + char BBase ; + + int BaseConut=0; + char best_base='N'; + char sed_base='N'; + int Max=0; + int SeD=0; + map :: iterator itSS ; + int ERA=0; + vector genotype ; + vector genotypeVE ; + + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ; } + istringstream isoneLine (line,istringstream::in); + for (int iik=0 ; iik>Vsample[iik]; + } + + Base_len=Vsample[3].length(); + Alt.clear(); + split(Vsample[4],Alt,"",""); + for (int ii=0 ; iiBase_len) + { + Base_len=Alt[ii].length(); + } + } + + if (Base_len>1) + { + BadIndelSite++; + continue ; + } + + + for (int kkkk=0 ; kkkk<2 ; kkkk++) + { + if (kkkk==0) + { + map Count ; + Het_count=0; + Miss_count=0; + + for (int kk=0 ; kk< NumberSubGroupV1 ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSiteV1[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + + if ( Genotype[0] == '.' ) + { + Miss_count++; + } + else + { + if (Genotype[0] != Genotype[2] ) + { + Het_count++; + } + Count[Genotype[0]]++; + Count[Genotype[2]]++; + } + } + + + if ( ( (Miss_count*1.0/NumberSubGroupV1) >(para_18->Miss) ) ) + { + continue ; + } + + if ( ( (Het_count*1.0/NumberSubGroupV1) >(para_18->Het) ) ) + { + continue ; + } + + BaseConut=0; + best_base='N'; + sed_base='N'; + Max=0; + SeD=0; + + for ( itSS=Count.begin(); itSS!=Count.end(); itSS++ ) + { + if ( (itSS->first ) == 'N' ) + { + continue ; + } + else if ((itSS->second) > Max ) + { + SeD=Max; + sed_base=best_base; + Max=(itSS->second); + best_base=itSS->first; + } + else if ( (itSS->second) >= SeD ) + { + SeD=(itSS->second); + sed_base=itSS->first; + } + BaseConut++; + } + if (BaseConut==1 || BaseConut >2 ) + { + BadSite++; + continue ; + } + + //if ( ( (1-(Max*0.5/NumberSubGroup)) < (para_18->MAF) ) ) + if ( (SeD*1.0/(SeD+Max)) < (para_18->MAF) ) + { + continue ; + } + + genotypeVE.clear(); + genotype.clear(); + // vector genotypeVE ; + + BaseType TypeA; + + // vector genotype ; + for (int kk=0 ; kk< NumberSubGroupV1 ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSiteV1[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + ABase=Genotype[0]; + if ( ABase == '.' ) + { + genotype.push_back('N'); + genotype.push_back('N'); + } + else + { + BBase=Genotype[2]; + if (ABase != BBase) + { + genotype.push_back(best_base); // best and sed base to phase + genotype.push_back(sed_base); + } + else + { + genotype.push_back(ABase); + genotype.push_back(BBase); + } + } + } + + + ERA=genotype.size(); + for (int hh=0 ; hh> Site ; + + + map > > :: iterator itSNP=SNPListV1.find(Vsample[0]); + + + if (itSNP == SNPListV1.end()) + { + map > DD; + DD[Site]=genotypeVE; + SNPListV1.insert(map > > ::value_type(Vsample[0],DD)); + Flag_for_pro++; + MaxSNPSite.insert(map ::value_type(Vsample[0],Site)); + } + else + { + (itSNP->second).insert(map > :: value_type(Site,genotypeVE)); + Flag_for_pro++; + map :: iterator MaxIT =MaxSNPSite.find(Vsample[0]); + if ( (MaxIT->second) < Site ) + { + MaxIT->second=Site ; + } + } + + + } + else + { + + + + + + map Count ; + Het_count=0; + Miss_count=0; + + for (int kk=0 ; kk< NumberSubGroupV2 ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSiteV2[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + + if ( Genotype[0] == '.') + { + Miss_count++; + } + else + { + if (Genotype[0] != Genotype[2]) + { + Het_count++; + } + Count[Genotype[0]]++; + Count[Genotype[2]]++; + } + } + + + if ( ( (Miss_count*1.0/NumberSubGroupV2) >(para_18->Miss) ) ) + { + continue ; + } + + if ( ( (Het_count*1.0/NumberSubGroupV2) >(para_18->Het) ) ) + { + continue ; + } + + BaseConut=0; + best_base='N'; + sed_base='N'; + Max=0; + SeD=0; + + for ( itSS=Count.begin(); itSS!=Count.end(); itSS++ ) + { + if ( (itSS->first ) == 'N' ) + { + continue ; + } + else if ((itSS->second) > Max ) + { + SeD=Max; + sed_base=best_base; + Max=(itSS->second); + best_base=itSS->first; + } + else if ( (itSS->second) >= SeD ) + { + SeD=(itSS->second); + sed_base=itSS->first; + } + BaseConut++; + } + if (BaseConut==1 || BaseConut >2 ) + { + BadSite++; + continue ; + } + + //if ( ( (1-(Max*0.5/NumberSubGroup)) < (para_18->MAF) ) ) + if ( (SeD*1.0/(SeD+Max)) < (para_18->MAF) ) + { + continue ; + } + + genotypeVE.clear(); + genotype.clear(); + // vector genotypeVE ; + + BaseType TypeA; + + // vector genotype ; + for (int kk=0 ; kk< NumberSubGroupV2 ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSiteV2[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + ABase=Genotype[0]; + if ( ABase == '.' ) + { + genotype.push_back('N'); + genotype.push_back('N'); + } + else + { + BBase=Genotype[2]; + if (ABase != BBase) + { + genotype.push_back(best_base); // best and sed base to phase + genotype.push_back(sed_base); + } + else + { + genotype.push_back(ABase); + genotype.push_back(BBase); + } + } + } + + + ERA=genotype.size(); + for (int hh=0 ; hh> Site ; + + + map > > :: iterator itSNP=SNPListV2.find(Vsample[0]); + + + if (itSNP == SNPListV2.end()) + { + map > DD; + DD[Site]=genotypeVE; + SNPListV2.insert(map > > ::value_type(Vsample[0],DD)); + Flag_for_pro++; + MaxSNPSite.insert(map ::value_type(Vsample[0],Site)); + } + else + { + (itSNP->second).insert(map > :: value_type(Site,genotypeVE)); + Flag_for_pro++; + map :: iterator MaxIT =MaxSNPSite.find(Vsample[0]); + if ( (MaxIT->second) < Site ) + { + MaxIT->second=Site ; + } + } + + + + + + } + } + + } + if(BadIndelSite!=0) + { + cout<<""warning skip Indel site, there are total skip Indel sites number is : ""< > > & SNPList, map & MaxSNPSite ,int & Flag_for_pro) +{ + igzstream SampleList ((paraFA04->SubPop).c_str(),ifstream::in); + if (SampleList.fail()) + { + cerr << ""open Sub Group IN File error: ""<<(paraFA04->SubPop)< SubVetor; + map :: iterator it; + + while(!SampleList.eof()) + { + string line ; + getline(SampleList,line); + if (line.length()<=0 || line[0] == '#' ) { continue ; } + line =line.substr(line.find(':') ==string::npos ? 0 : line.find(':') + 1); + vector inf; + split(line,inf,"" \t""); + int A=inf.size(); + for(int ii=0 ; ii ::value_type(inf[ii],0)); + } + } + } + SampleList.close(); + + igzstream VCFIN ((paraFA04->InStr1).c_str(),ifstream::in); + if (VCFIN.fail()) + { + cerr << ""open VCF File IN File error: ""<<(paraFA04->InStr1)< SampleSite; + vector Vsample ; + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ; } + else if ( line[0] == '#' && line[1] == '#' ) { continue ; } + else if ( line[0] == '#' && line[1] != '#' ) + { + Vsample.clear(); + split(line,Vsample,"" \t""); + if ( Vsample[0] != ""#CHROM"") + { + continue ; + } + int A=Vsample.size(); + + for (int ii=9 ; ii< A ; ii++) + { + it=SubVetor.find(Vsample[ii]); + if (it!=SubVetor.end()) + { + SampleSite.push_back(ii); + (it->second)++; + } + } + break ; + } + else if ( line[0] != '#' && line[1] != '#' ) + { + cerr<<""wrong Line : ""<=10, SubGroup sample size: ""<second)==0) + { + cerr<<""warning : Sample [ ""<<(it->first)<<"" ] can't be found in the VCF Header\n""; + } + else if ((it->second)>1) + { + cerr<<""warning : Sample [ ""<<(it->first)<<"" ] can be found [Repeat] in the VCF Header\n""; + } + } + + int Asample=Vsample.size(); + + int BadSite=0; + int BadIndelSite=0; + + vector Alt ; + vector Btmp ; + int Base_len ; + llong Site ; + int Het_count=0; + int Miss_count=0; + char ABase ; + char BBase ; + + int BaseConut=0; + char best_base='N'; + char sed_base='N'; + int Max=0; + int SeD=0; + map :: iterator itSS ; + int ERA=0; + vector genotype ; + vector genotypeVE ; + + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ; } + istringstream isoneLine (line,istringstream::in); + for (int iik=0 ; iik>Vsample[iik]; + } + + Base_len=Vsample[3].length(); + Alt.clear(); + split(Vsample[4],Alt,"",""); + for (int ii=0 ; iiBase_len) + { + Base_len=Alt[ii].length(); + } + } + + if (Base_len>1) + { + BadIndelSite++; + continue ; + } + + map Count ; + Het_count=0; + Miss_count=0; + + for (int kk=0 ; kk< NumberSubGroup ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSite[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + + if ( Genotype[0] == '.' ) + { + Miss_count++ ; + } + else + { + if (Genotype[0] != Genotype[2] ) + { + Het_count++; + } + Count[Genotype[0]]++; + Count[Genotype[2]]++; + } + } + + + if ( ( (Miss_count*1.0/NumberSubGroup) >(para_18->Miss) ) ) + { + continue ; + } + + if ( ( (Het_count*1.0/NumberSubGroup) >(para_18->Het) ) ) + { + continue ; + } + + BaseConut=0; + best_base='N'; + sed_base='N'; + Max=0; + SeD=0; + + for ( itSS=Count.begin(); itSS!=Count.end(); itSS++ ) + { + if ( (itSS->first ) == 'N' ) + { + continue ; + } + else if ((itSS->second) > Max ) + { + SeD=Max; + sed_base=best_base; + Max=(itSS->second); + best_base=itSS->first; + } + else if ( (itSS->second) >= SeD ) + { + SeD=(itSS->second); + sed_base=itSS->first; + } + BaseConut++; + } + if (BaseConut==1 || BaseConut >2 ) + { + BadSite++; + continue ; + } + + //if ( ( (1-(Max*0.5/NumberSubGroup)) < (para_18->MAF) ) ) + if ( (SeD*1.0/(SeD+Max)) < (para_18->MAF) ) + { + continue ; + } + + genotypeVE.clear(); + genotype.clear(); + // vector genotypeVE ; + + BaseType TypeA; + + // vector genotype ; + for (int kk=0 ; kk< NumberSubGroup ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSite[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + ABase=Genotype[0]; + if ( ABase == '.' ) + { + genotype.push_back('N'); + genotype.push_back('N'); + } + else + { + BBase=Genotype[2]; + if (ABase != BBase) + { + genotype.push_back(best_base); // best and sed base to phase + genotype.push_back(sed_base); + } + else + { + genotype.push_back(ABase); + genotype.push_back(BBase); + } + } + } + + + ERA=genotype.size(); + for (int hh=0 ; hh> Site ; + + + map > > :: iterator itSNP=SNPList.find(Vsample[0]); + + + if (itSNP == SNPList.end()) + { + map > DD; + DD[Site]=genotypeVE; + SNPList.insert(map > > ::value_type(Vsample[0],DD)); + Flag_for_pro++; + MaxSNPSite.insert(map ::value_type(Vsample[0],Site)); + } + else + { + (itSNP->second).insert(map > :: value_type(Site,genotypeVE)); + Flag_for_pro++; + map :: iterator MaxIT =MaxSNPSite.find(Vsample[0]); + if ( (MaxIT->second) < Site ) + { + MaxIT->second=Site ; + } + + } + } + + if(BadIndelSite!=0) + { + cout<<""warning skip Indel site, there are total skip Indel sites number is : ""< inf ; + bool TTFF=false ; + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ; } + else if ( line[0] == '#' ) { continue ; } + else + { + split(line,inf,"" \t""); + if ((inf[9])[1] == '|') + { + TTFF=true; + } + break ; + } + } + VCFIN.close(); + if (TTFF) + { + cout <<""#Detected VCF File is phased file with '|', Read VCF in Phase mode""< > > & SNPList ,map & MaxSNPSite,int & Flag_for_pro ) +{ + + igzstream VCFIN ((paraFA04->InStr1).c_str(),ifstream::in); + + if (VCFIN.fail()) + { + cerr << ""open VCF File IN File error: ""<<(paraFA04->InStr1)< inf ; + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ; } + else if ( line[0] == '#' && line[1] == '#' ) { continue ; } + else if ( line[0] == '#' && line[1] != '#' ) + { + inf.clear(); + split(line,inf,"" \t""); + if ( inf[0] != ""#CHROM"") + { + continue ; + } + break ; + } + else if ( line[0] != '#' && line[1] != '#' ) + { + cerr<<""wrong Line : ""<=10,but sample size: ""< Alt ; + vector Btmp ; + int Base_len ; + llong Site ; + int Het_count=0; + int Miss_count=0; + + int BaseConut=0; + char best_base='N'; + char sed_base='N'; + int Max=0; + int SeD=0; + map :: iterator it ; + int ERA=0; + vector genotype ; + vector genotypeVE ; + + + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0) { continue ; } + + istringstream isoneLine (line,istringstream::in); + for (int iik=0 ; iik>inf[iik]; + } + Base_len=inf[3].length(); + Alt.clear(); + split(inf[4],Alt,"",""); + + for (int ii=0 ; iiBase_len) + { + Base_len=Alt[ii].length(); + } + } + + if (Base_len>1) + { + BadIndelSite++; + continue ; + } + + map Count ; + Het_count=0; + Miss_count=0; + + for (int jj=9 ; jj< Asample ;jj++ ) + { + Btmp.clear(); + split(inf[jj], Btmp,"":""); + string Genotype=Btmp[0]; + if ( Genotype[0] == '.' ) + { + Miss_count++ ; + } + else + { + if (Genotype[0] != Genotype[2] ) + { + Het_count++; + } + Count[Genotype[0]]++; + Count[Genotype[2]]++; + } + } + + if ( ( (Miss_count*1.0/SampleNum) >(para_18->Miss) ) ) + { + continue ; + } + + if ( ( (Het_count*1.0/SampleNum) >(para_18->Het) ) ) + { + continue ; + } + + BaseConut=0; + best_base='N'; + sed_base='N'; + Max=0; + SeD=0; + + for ( it=Count.begin(); it!=Count.end(); it++ ) + { + if ( (it->first ) == 'N' ) + { + continue ; + } + else if ((it->second) > Max ) + { + SeD=Max; + sed_base=best_base; + Max=(it->second); + best_base=it->first; + } + else if ( (it->second) >= SeD ) + { + SeD=(it->second); + sed_base=it->first; + } + BaseConut++; + } + if (BaseConut==1 || BaseConut >2 ) + { + BadSite++; + continue ; + } + + if ( (SeD*1.0/(SeD+Max)) < (para_18->MAF) ) + { + continue ; + } + + genotype.clear(); + + for (int jj=9 ; jj< Asample ;jj++ ) + { + Btmp.clear(); + split(inf[jj], Btmp,"":""); + string Genotype=Btmp[0]; + if ( Genotype[0] == '.' ) + { + genotype.push_back('N'); + genotype.push_back('N'); + } + else + { + if (Genotype[0] != Genotype[2] ) + { + genotype.push_back(best_base); + genotype.push_back(sed_base); + } + else + { + genotype.push_back(Genotype[0]); + genotype.push_back(Genotype[2]); + } + } + } + + + + genotypeVE.clear(); + + BaseType TypeA; + + ERA=genotype.size(); + + for (int hh=0 ; hh> Site ; + + + map > > :: iterator itSNP=SNPList.find(inf[0]); + + if (itSNP == SNPList.end()) + { + map > DD; + DD[Site]=genotypeVE; + SNPList.insert(map > > ::value_type(inf[0],DD)); + Flag_for_pro++; + MaxSNPSite.insert(map ::value_type(inf[0],Site)); + } + else + { + (itSNP->second).insert(map > :: value_type(Site,genotypeVE)) ; + Flag_for_pro++; + map :: iterator MaxIT =MaxSNPSite.find(inf[0]); + if ( (MaxIT->second) < Site ) + { + MaxIT->second=Site ; + } + + } + } + + + + VCFIN.close(); + + if(BadIndelSite!=0) + { + cout<<""warning skip Indel site, there are total skip Indel sites number is : ""<InStr2)+"".stat.gz""; + ogzstream OUT ((Stat).c_str()); + if((!OUT.good())) + { + cerr << ""open OUT File error: ""<WindowSize)++; + + for (int ii=1 ; ii<(paraFA04->WindowSize) ; ii++ ) + { + int count=(All_Stat[ii]).Count; + if (count==0) {continue ;} + double SumRR=(All_Stat[ii]).sumRR; + double SumD=(All_Stat[ii]).sumD; + + double MeanRR=SumRR/count; + double MeanD=SumD/count; + OUT< > > & SNPList, map & MaxSNPSite,int & Flag_for_pro ) +{ + igzstream SampleList ((paraFA04->SubPop).c_str(),ifstream::in); + if (SampleList.fail()) + { + cerr << ""open Sub Group IN File error: ""<<(paraFA04->SubPop)< SubVetor; + map :: iterator it; + + while(!SampleList.eof()) + { + string line ; + getline(SampleList,line); + if (line.length()<=0 || line[0] == '#' ) { continue ; } + line =line.substr(line.find(':') ==string::npos ? 0 : line.find(':') + 1); + vector inf; + split(line,inf,"" \t""); + int A=inf.size(); + for(int ii=0 ; ii ::value_type(inf[ii],0)); + } + } + } + SampleList.close(); + + igzstream VCFIN ((paraFA04->InStr1).c_str(),ifstream::in); + if (VCFIN.fail()) + { + cerr << ""open VCF File IN File error: ""<<(paraFA04->InStr1)< SampleSite; + vector Vsample ; + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ; } + else if ( line[0] == '#' && line[1] == '#' ) { continue ; } + else if ( line[0] == '#' && line[1] != '#' ) + { + Vsample.clear(); + split(line,Vsample,"" \t""); + if ( Vsample[0] != ""#CHROM"") + { + continue ; + } + int A=Vsample.size(); + + for (int ii=9 ; ii< A ; ii++) + { + it=SubVetor.find(Vsample[ii]); + if (it!=SubVetor.end()) + { + SampleSite.push_back(ii); + (it->second)++; + } + } + break ; + } + else if ( line[0] != '#' && line[1] != '#' ) + { + cerr<<""wrong Line : ""<=10, SubGroup sample size: ""<second)==0) + { + cerr<<""warning : Sample [ ""<<(it->first)<<"" ] can't be found in the VCF Header\n""; + } + else if ((it->second)>1) + { + cerr<<""warning : Sample [ ""<<(it->first)<<"" ] can be found [Repeat] in the VCF Header\n""; + } + } + + + int Asample=Vsample.size(); + + int BadSite=0; + int BadIndelSite=0; + + vector Alt ; + vector Btmp ; + int Base_len ; + llong Site ; + int Het_count=0; + int Miss_count=0; + char ABase ; + char BBase ; + + int BaseConut=0; + char best_base='N'; + char sed_base='N'; + int Max=0; + int SeD=0; + map :: iterator itSS ; + int ERA=0; + vector genotype ; + vector genotypeVE ; + + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ; } + istringstream isoneLine (line,istringstream::in); + for (int iik=0 ; iik>Vsample[iik]; + } + + Base_len=Vsample[3].length(); + Alt.clear(); + split(Vsample[4],Alt,"",""); + for (int ii=0 ; iiBase_len) + { + Base_len=Alt[ii].length(); + } + } + + if (Base_len>1) + { + BadIndelSite++; + continue ; + } + + map Count ; + Het_count=0; + Miss_count=0; + + for (int kk=0 ; kk< NumberSubGroup ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSite[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + + if ( Genotype[0] == '.' ) + { + Miss_count++ ; + } + else + { + if (Genotype[0] != Genotype[2] ) + { + Het_count++; + } + Count[Genotype[0]]++; + Count[Genotype[2]]++; + } + } + + + if ( ( (Miss_count*1.0/NumberSubGroup) >(para_18->Miss) ) ) + { + continue ; + } + + if ( ( (Het_count*1.0/NumberSubGroup) >(para_18->Het) ) ) + { + continue ; + } + + BaseConut=0; + best_base='N'; + sed_base='N'; + Max=0; + SeD=0; + + for ( itSS=Count.begin(); itSS!=Count.end(); itSS++ ) + { + if ( (itSS->first ) == 'N' ) + { + continue ; + } + else if ((itSS->second) > Max ) + { + SeD=Max; + sed_base=best_base; + Max=(itSS->second); + best_base=itSS->first; + } + else if ( (itSS->second) >= SeD ) + { + SeD=(itSS->second); + sed_base=itSS->first; + } + BaseConut++; + } + + if (BaseConut==1 || BaseConut >2 ) + { + BadSite++; + continue ; + } + + //if ( ( (1-(Max*0.5/NumberSubGroup)) < (para_18->MAF) ) ) + if ( (SeD*1.0/(SeD+Max)) < (para_18->MAF) ) + { + continue ; + } + + genotypeVE.clear(); + genotype.clear(); + + + BaseType TypeA; + + for (int kk=0 ; kk< NumberSubGroup ; kk++) + { + Btmp.clear(); + split(Vsample[SampleSite[kk]], Btmp,"":""); + string Genotype=Btmp[0]; + ABase=Genotype[0]; + if ( ABase == '.' ) + { + genotype.push_back('N'); + genotype.push_back('N'); + } + else + { + BBase=Genotype[2]; + genotype.push_back(ABase); // phase VCF + genotype.push_back(BBase); // phase VCF + } + } + + + ERA=genotype.size(); + for (int hh=0 ; hh> Site ; + + + map > > :: iterator itSNP=SNPList.find(Vsample[0]); + + if (itSNP == SNPList.end()) + { + map > DD; + DD[Site]=genotypeVE; + SNPList.insert(map > > ::value_type(Vsample[0],DD)); + Flag_for_pro++; + MaxSNPSite.insert(map ::value_type(Vsample[0],Site)); + } + else + { + (itSNP->second).insert(map > :: value_type(Site,genotypeVE)) ; + Flag_for_pro++; + map :: iterator MaxIT =MaxSNPSite.find(Vsample[0]); + if ( (MaxIT->second) < Site ) + { + MaxIT->second=Site ; + } + + } + } + + if(BadIndelSite!=0) + { + cout<<""warning skip Indel site, there are total skip Indel sites number is : ""< > > & SNPList ,map & MaxSNPSite,int & Flag_for_pro ) +{ + igzstream VCFIN ((paraFA04->InStr1).c_str(),ifstream::in); + + if (VCFIN.fail()) + { + cerr << ""open VCF File IN File error: ""<<(paraFA04->InStr1)< inf ; + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0 ) { continue ; } + else if ( line[0] == '#' && line[1] == '#' ) { continue ; } + else if ( line[0] == '#' && line[1] != '#' ) + { + inf.clear(); + split(line,inf,"" \t""); + if ( inf[0] != ""#CHROM"") + { + continue ; + } + break ; + } + else if ( line[0] != '#' && line[1] != '#' ) + { + cerr<<""wrong Line : ""<=10, SubGroup sample size: ""< Alt ; + vector Btmp ; + int Base_len ; + llong Site ; + int Het_count=0; + int Miss_count=0; + + int BaseConut=0; + char best_base='N'; + char sed_base='N'; + int Max=0; + int SeD=0; + map :: iterator it ; + int ERA=0; + vector genotype ; + vector genotypeVE ; + + while(!VCFIN.eof()) + { + string line ; + getline(VCFIN,line); + if (line.length()<=0) { continue ; } + + istringstream isoneLine (line,istringstream::in); + for (int iik=0 ; iik>inf[iik]; + } + Base_len=inf[3].length(); + Alt.clear(); + split(inf[4],Alt,"",""); + + for (int ii=0 ; iiBase_len) + { + Base_len=Alt[ii].length(); + } + } + + if (Base_len>1) + { + BadIndelSite++; + continue ; + } + + map Count ; + Het_count=0; + Miss_count=0; + + for (int jj=9 ; jj< Asample ;jj++ ) + { + Btmp.clear(); + split(inf[jj], Btmp,"":""); + string Genotype=Btmp[0]; + if ( Genotype[0] == '.' ) + { + Miss_count++ ; + } + else + { + if (Genotype[0] != Genotype[2] ) + { + Het_count++; + } + Count[Genotype[0]]++; + Count[Genotype[2]]++; + } + } + + if ( ( (Miss_count*1.0/SampleNum) >(para_18->Miss) ) ) + { + continue ; + } + + if ( ( (Het_count*1.0/SampleNum) >(para_18->Het) ) ) + { + continue ; + } + + BaseConut=0; + best_base='N'; + sed_base='N'; + Max=0; + SeD=0; + + for ( it=Count.begin(); it!=Count.end(); it++ ) + { + if ( (it->first ) == 'N' ) + { + continue ; + } + else if ((it->second) > Max ) + { + SeD=Max; + sed_base=best_base; + Max=(it->second); + best_base=it->first; + } + else if ( (it->second) >= SeD ) + { + SeD=(it->second); + sed_base=it->first; + } + BaseConut++; + } + if (BaseConut==1 || BaseConut >2 ) + { + BadSite++; + continue ; + } + + if ( (SeD*1.0/(SeD+Max)) < (para_18->MAF) ) + { + continue ; + } + + genotype.clear(); + + for (int jj=9 ; jj< Asample ;jj++ ) + { + Btmp.clear(); + split(inf[jj], Btmp,"":""); + string Genotype=Btmp[0]; + if ( Genotype[0] == '.' ) + { + genotype.push_back('N'); + genotype.push_back('N'); + } + else + { + genotype.push_back(Genotype[0]); // phase VCF + genotype.push_back(Genotype[2]); // phase VCF + } + } + + + + genotypeVE.clear(); + + BaseType TypeA; + + ERA=genotype.size(); + + for (int hh=0 ; hh> Site ; + + + map > > :: iterator itSNP=SNPList.find(inf[0]); + + if (itSNP == SNPList.end()) + { + map > DD; + DD[Site]=genotypeVE; + SNPList.insert(map > > ::value_type(inf[0],DD)); + Flag_for_pro++; + MaxSNPSite.insert(map ::value_type(inf[0],Site)); + } + else + { + (itSNP->second).insert(map > :: value_type(Site,genotypeVE)) ; + Flag_for_pro++; + map :: iterator MaxIT =MaxSNPSite.find(inf[0]); + if ( (MaxIT->second) < Site ) + { + MaxIT->second=Site ; + } + + } + } + + + VCFIN.close(); + + if(BadIndelSite!=0) + { + cout<<""warning skip Indel site, there are total skip Indel sites number is : ""< & SubVetor , map & GroupID ) +{ + igzstream SampleList (ListFile.c_str(),ifstream::in); + if (SampleList.fail()) + { + cerr << ""open Sub Group IN File error: ""< :: iterator it; + map :: iterator IT_GID; + + int subpopNum=0; + int Thisub=0; + while(!SampleList.eof()) + { + string line ; + getline(SampleList,line); + if (line.length()<=0 || line[0] == '#' ) { continue ;} + if (line.find(':') ==string::npos) + { + } + else + { + vector tee ; + split(line,tee,"" \t:""); + line=line.substr(line.find(':')+1); + IT_GID=GroupID.find(tee[0]); + if ( IT_GID==GroupID.end() ) + { + subpopNum++; + Thisub=subpopNum ; + GroupID.insert(map ::value_type(tee[0],subpopNum)); + } + else + { + Thisub=IT_GID->second; + } + } + vector inf; + split(line,inf,"" \t""); + int A=inf.size(); + for (int ii=0 ; ii ::value_type(inf[ii],Thisub)); + } + } + } + SampleList.close(); + + if (subpopNum>2) + { + cerr <<""\tIdentifying multiple groups : ""; + for (it =GroupID.begin();it!=GroupID.end(); it++ ) + { + cerr<<"" ""<first; + } + cerr<<""\n\tThe software only accepts up to two groups. but Identify by symbol ':' Number is :"" <second)==1) + { + NumA++; + } + else if ((it->second)==2) + { + NumB++; + } + } + + for (it =GroupID.begin();it!=GroupID.end(); it++ ) + { + if ((it->second)==1) + { + cout << ""subgroup [""<first<<""] sample size is ""<first<<""] sample size is ""<3) || (NumB*1.0/NumA>3) ) + { + cerr <<""In order to get the selection region by compair the two groups, it is recommended that the sample size of the two groups should not differ too much.(0.3--3) and ever subgroup sample size should >=10 ; exit(1) \n""; + return 3; + } + else + { + + return 2; + } + } + else + { + return 1 ; + } +} + + +////////// +#endif // +///////// swimming in the sky and flying in the sea //////////// + + +","Unknown" +"Allele","BGI-shenzhen/RRSelection","src/DataClass.h",".h","1875","140"," +////////////////////////swimming in the sea & flying in the sky ////////////////// + + +/* + * DataClass.h + * + * Created on: 2011-11-21 + * Author: hewm@genomics.org.cn + */ + +#ifndef DataClass_H_ +#define DataClass_H_ + + +using namespace std; + + +class In3str1v { + public: + string InStr1; + string InStr2; + string SubPop; + int bin ; + int Masked ; + int WindowSize ; + int count ; + bool TF; + double Step ; + double Pvalue; + In3str1v() + { + InStr1=""""; + InStr2=""""; + SubPop=""""; + bin=1; + Step=0.2; + count=1; + WindowSize=300; + TF=true; + Masked=10; + Pvalue=0.005; + } +}; + + +class Para_18 { + public: + string input ; + string output ; + double Het ; + double Miss ; + double MAF ; + int Cut3base ; + Para_18() + { + input=""""; + output=""""; + Het=0.88 ; + Miss=0.25 ; + Cut3base=0; + MAF=0.05; + } +}; + + +class StarRsult +{ + public: + double Count; + double sumRR; +// double sumD; + StarRsult() + { + Count=0.0; + sumRR=0.0; +// sumD=0.0; + } +}; + + +class statementVar +{ + public: + double LN10; + int Asize ; + + double ALL_count ; + map :: iterator it; + double D_A; + double Cal_A ; + double Cal_B ; + double D_max; + + + double XpA1_pA2; + double XpA1_pB2; + double XpB1_pA2; + double XpB1_pB2; + + + double known[5]; + double probHaps[4]; + double lsurface[101]; + double cut5off ; + unsigned short int DDE[3][3]; + double pA1, pB1, pA2, pB2, loglike1, loglike0; + + double tmpAA, tmpAB, tmpBA, tmpBB, dpr;// tmp2AA, tmp2AB, tmp2BA, tmp2BB; + int i; + short int low_i ; + short int high_i; + double total_prob; + double sum_prob ; + // double tmp;//g,h,m,tmp,r; + + statementVar() + { + LN10=log(10.0); + total_prob= 0.0; + sum_prob=0.0; + low_i = 0; + high_i = 0; + + } + + +}; + + +struct BaseType +{ + unsigned short int Value:2 ; +}; + + +#endif /* DataClass_H_ */ + +//////////////// swimming in the sky and flying in the sea //////////////// +","Unknown" +"Allele","BGI-shenzhen/RRSelection","src/HeadIN.h",".h","337","23"," +#ifndef HeadIN_H_ +#define HeadIN_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include ""./include/gzstream/gzstream.c"" + +#include ""./DataClass.h"" +#include ""./CommFun.h"" + +#endif // end HeadIN + + +","Unknown" +"Allele","BGI-shenzhen/RRSelection","src/Bmath/dpq.h",".h","4541","125","/* + * R : A Computer Language for Statistical Data Analysis + * Copyright (C) 2000--2007 R Core Team + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, a copy is available at + * http://www.r-project.org/Licenses/ + */ + /* Utilities for `dpq' handling (density/probability/quantile) */ + +/* give_log in ""d""; log_p in ""p"" & ""q"" : */ +#define give_log log_p + /* ""DEFAULT"" */ + /* --------- */ +#define R_D__0 (log_p ? ML_NEGINF : 0.) /* 0 */ +#define R_D__1 (log_p ? 0. : 1.) /* 1 */ +#define R_DT_0 (lower_tail ? R_D__0 : R_D__1) /* 0 */ +#define R_DT_1 (lower_tail ? R_D__1 : R_D__0) /* 1 */ + +/* Use 0.5 - p + 0.5 to perhaps gain 1 bit of accuracy */ +#define R_D_Lval(p) (lower_tail ? (p) : (0.5 - (p) + 0.5)) /* p */ +#define R_D_Cval(p) (lower_tail ? (0.5 - (p) + 0.5) : (p)) /* 1 - p */ + +#define R_D_val(x) (log_p ? log(x) : (x)) /* x in pF(x,..) */ +#define R_D_qIv(p) (log_p ? exp(p) : (p)) /* p in qF(p,..) */ +#define R_D_exp(x) (log_p ? (x) : exp(x)) /* exp(x) */ +#define R_D_log(p) (log_p ? (p) : log(p)) /* log(p) */ +#define R_D_Clog(p) (log_p ? log1p(-(p)) : (0.5 - (p) + 0.5)) /* [log](1-p) */ + +/* log(1 - exp(x)) in more stable form than log1p(- R_D_qIv(x))) : */ +#define R_Log1_Exp(x) ((x) > -M_LN2 ? log(-expm1(x)) : log1p(-exp(x))) + +/* log(1-exp(x)): R_D_LExp(x) == (log1p(- R_D_qIv(x))) but even more stable:*/ +#define R_D_LExp(x) (log_p ? R_Log1_Exp(x) : log1p(-x)) + +#define R_DT_val(x) (lower_tail ? R_D_val(x) : R_D_Clog(x)) +#define R_DT_Cval(x) (lower_tail ? R_D_Clog(x) : R_D_val(x)) + +/*#define R_DT_qIv(p) R_D_Lval(R_D_qIv(p)) * p in qF ! */ +#define R_DT_qIv(p) (log_p ? (lower_tail ? exp(p) : - expm1(p)) \ + : R_D_Lval(p)) + +/*#define R_DT_CIv(p) R_D_Cval(R_D_qIv(p)) * 1 - p in qF */ +#define R_DT_CIv(p) (log_p ? (lower_tail ? -expm1(p) : exp(p)) \ + : R_D_Cval(p)) + +#define R_DT_exp(x) R_D_exp(R_D_Lval(x)) /* exp(x) */ +#define R_DT_Cexp(x) R_D_exp(R_D_Cval(x)) /* exp(1 - x) */ + +#define R_DT_log(p) (lower_tail? R_D_log(p) : R_D_LExp(p))/* log(p) in qF */ +#define R_DT_Clog(p) (lower_tail? R_D_LExp(p): R_D_log(p))/* log(1-p) in qF*/ +#define R_DT_Log(p) (lower_tail? (p) : R_Log1_Exp(p)) +/* == R_DT_log when we already ""know"" log_p == TRUE :*/ + + +#define R_Q_P01_check(p) \ + if ((log_p && p > 0) || \ + (!log_p && (p < 0 || p > 1)) ) \ + ML_ERR_return_NAN + +/* Do the boundaries exactly for q*() functions : + * Often _LEFT_ = ML_NEGINF , and very often _RIGHT_ = ML_POSINF; + * + * R_Q_P01_boundaries(p, _LEFT_, _RIGHT_) :<==> + * + * R_Q_P01_check(p); + * if (p == R_DT_0) return _LEFT_ ; + * if (p == R_DT_1) return _RIGHT_; + * + * the following implementation should be more efficient (less tests): + */ +#define R_Q_P01_boundaries(p, _LEFT_, _RIGHT_) \ + if (log_p) { \ + if(p > 0) \ + ML_ERR_return_NAN; \ + if(p == 0) /* upper bound*/ \ + return lower_tail ? _RIGHT_ : _LEFT_; \ + if(p == ML_NEGINF) \ + return lower_tail ? _LEFT_ : _RIGHT_; \ + } \ + else { /* !log_p */ \ + if(p < 0 || p > 1) \ + ML_ERR_return_NAN; \ + if(p == 0) \ + return lower_tail ? _LEFT_ : _RIGHT_; \ + if(p == 1) \ + return lower_tail ? _RIGHT_ : _LEFT_; \ + } + +#define R_P_bounds_01(x, x_min, x_max) \ + if(x <= x_min) return R_DT_0; \ + if(x >= x_max) return R_DT_1 +/* is typically not quite optimal for (-Inf,Inf) where + * you'd rather have */ +#define R_P_bounds_Inf_01(x) \ + if(!R_FINITE(x)) { \ + if (x > 0) return R_DT_1; \ + /* x < 0 */return R_DT_0; \ + } + + + +/* additions for density functions (C.Loader) */ +#define R_D_fexp(f,x) (give_log ? -0.5*log(f)+(x) : exp(x)/sqrt(f)) +#define R_D_forceint(x) floor((x) + 0.5) +#define R_D_nonint(x) (fabs((x) - floor((x)+0.5)) > 1e-7) +/* [neg]ative or [non int]eger : */ +#define R_D_negInonint(x) (x < 0. || R_D_nonint(x)) + +#define R_D_nonint_check(x) \ + if(R_D_nonint(x)) { \ + MATHLIB_WARNING(""non-integer x = %f"", x); \ + return R_D__0; \ + } +","Unknown" +"Allele","BGI-shenzhen/RRSelection","src/Bmath/pnorm.c",".c","8553","331","/* + * Mathlib : A C Library of Special Functions + * Copyright (C) 1998 Ross Ihaka + * Copyright (C) 2000-2010 The R Core Team + * Copyright (C) 2003 The R Foundation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, a copy is available at + * http://www.r-project.org/Licenses/ + * + * SYNOPSIS + * + * #include + * + * double pnorm5(double x, double mu, double sigma, int lower_tail,int log_p); + * {pnorm (..) is synonymous and preferred inside R} + * + * void pnorm_both(double x, double *cum, double *ccum, + * int i_tail, int log_p); + * + * DESCRIPTION + * + * The main computation evaluates near-minimax approximations derived + * from those in ""Rational Chebyshev approximations for the error + * function"" by W. J. Cody, Math. Comp., 1969, 631-637. This + * transportable program uses rational functions that theoretically + * approximate the normal distribution function to at least 18 + * significant decimal digits. The accuracy achieved depends on the + * arithmetic system, the compiler, the intrinsic functions, and + * proper selection of the machine-dependent constants. + * + * REFERENCE + * + * Cody, W. D. (1993). + * ALGORITHM 715: SPECFUN - A Portable FORTRAN Package of + * Special Function Routines and Test Drivers"". + * ACM Transactions on Mathematical Software. 19, 22-32. + * + * EXTENSIONS + * + * The ""_both"" , lower, upper, and log_p variants were added by + * Martin Maechler, Jan.2000; + * as well as log1p() and similar improvements later on. + * + * James M. Rath contributed bug report PR#699 and patches correcting SIXTEN + * and if() clauses {with a bug: ""|| instead of &&"" -> PR #2883) more in line + * with the original Cody code. + */ + +//#include ""nmath.h"" + + +///hewe +//*///////////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef pnorm_H_ +#define pnorm_H_ + + + +#define ML_POSINF ( 1.0 ) +#define ML_NEGINF (-1.0 ) +#define ML_NAN ( 0.0 ) + +//#define ME_DOMAIN 1 + + +//#define ML_ERR_return_NAN { return ML_NAN; } +#define R_FINITE(x) R_finite(x) + +#define M_SQRT_32 5.656854249492380195206754896838 +#define M_1_SQRT_2PI 0.398942280401432677939946059934 +#define DBL_EPSILON 2.2204460492503131e-16 + +#ifndef isnan +#if __cplusplus <= 199711L // c++98 or older +# define isnan(x) ::isnan(x) +#else +# define isnan(x) std::isnan(x) +#endif +#endif + +int R_finite(double x) +{ +#ifdef HAVE_WORKING_ISFINITE + return isfinite(x); +# else + return (!isnan(x) & (x != ML_POSINF) & (x != ML_NEGINF)); +#endif +} + + + + + +/////////////////////////////////////////////////////////////////////////////////////////////////*/ + + + +#include ""dpq.h"" + + + +#define SIXTEN 16 /* Cutoff allowing exact ""*"" and ""/"" */ + +void pnorm_both(double x, double *cum, double *ccum, int i_tail, int log_p) +{ + /* i_tail in {0,1,2} means: ""lower"", ""upper"", or ""both"" : + if(lower) return *cum := P[X <= x] + if(upper) return *ccum := P[X > x] = 1 - P[X <= x] + */ + const static double a[5] = { + 2.2352520354606839287, + 161.02823106855587881, + 1067.6894854603709582, + 18154.981253343561249, + 0.065682337918207449113 + }; + const static double b[4] = { + 47.20258190468824187, + 976.09855173777669322, + 10260.932208618978205, + 45507.789335026729956 + }; + const static double c[9] = { + 0.39894151208813466764, + 8.8831497943883759412, + 93.506656132177855979, + 597.27027639480026226, + 2494.5375852903726711, + 6848.1904505362823326, + 11602.651437647350124, + 9842.7148383839780218, + 1.0765576773720192317e-8 + }; + const static double d[8] = { + 22.266688044328115691, + 235.38790178262499861, + 1519.377599407554805, + 6485.558298266760755, + 18615.571640885098091, + 34900.952721145977266, + 38912.003286093271411, + 19685.429676859990727 + }; + const static double p[6] = { + 0.21589853405795699, + 0.1274011611602473639, + 0.022235277870649807, + 0.001421619193227893466, + 2.9112874951168792e-5, + 0.02307344176494017303 + }; + const static double q[5] = { + 1.28426009614491121, + 0.468238212480865118, + 0.0659881378689285515, + 0.00378239633202758244, + 7.29751555083966205e-5 + }; + + double xden, xnum, temp, del, eps, xsq, y; +#ifdef NO_DENORMS + double min = DBL_MIN; +#endif + int i, lower, upper; + + /* Consider changing these : */ + eps = DBL_EPSILON * 0.5; + + /* i_tail in {0,1,2} =^= {lower, upper, both} */ + lower = i_tail != 1; + upper = i_tail != 0; + + y = fabs(x); + if (y <= 0.67448975) { /* qnorm(3/4) = .6744.... -- earlier had 0.66291 */ + if (y > eps) { + xsq = x * x; + xnum = a[4] * xsq; + xden = xsq; + for (i = 0; i < 3; ++i) { + xnum = (xnum + a[i]) * xsq; + xden = (xden + b[i]) * xsq; + } + } else xnum = xden = 0.0; + + temp = x * (xnum + a[3]) / (xden + b[3]); + if(lower) *cum = 0.5 + temp; + if(upper) *ccum = 0.5 - temp; + if(log_p) { + if(lower) *cum = log(*cum); + if(upper) *ccum = log(*ccum); + } + } + else if (y <= M_SQRT_32) { + + /* Evaluate pnorm for 0.674.. = qnorm(3/4) < |x| <= sqrt(32) ~= 5.657 */ + + xnum = c[8] * y; + xden = y; + for (i = 0; i < 7; ++i) { + xnum = (xnum + c[i]) * y; + xden = (xden + d[i]) * y; + } + temp = (xnum + c[7]) / (xden + d[7]); + +#define do_del(X) \ + xsq = trunc(X * SIXTEN) / SIXTEN; \ + del = (X - xsq) * (X + xsq); \ + if(log_p) { \ + *cum = (-xsq * xsq * 0.5) + (-del * 0.5) + log(temp); \ + if((lower && x > 0.) || (upper && x <= 0.)) \ + *ccum = log1p(-exp(-xsq * xsq * 0.5) * \ + exp(-del * 0.5) * temp); \ + } \ + else { \ + *cum = exp(-xsq * xsq * 0.5) * exp(-del * 0.5) * temp; \ + *ccum = 1.0 - *cum; \ + } + +#define swap_tail \ + if (x > 0.) {/* swap ccum <--> cum */ \ + temp = *cum; if(lower) *cum = *ccum; *ccum = temp; \ + } + + do_del(y); + swap_tail; + } + + /* else |x| > sqrt(32) = 5.657 : + * the next two case differentiations were really for lower=T, log=F + * Particularly *not* for log_p ! + + * Cody had (-37.5193 < x && x < 8.2924) ; R originally had y < 50 + * + * Note that we do want symmetry(0), lower/upper -> hence use y + */ + else if((log_p && y < 1e170) /* avoid underflow below */ + /* ^^^^^ MM FIXME: can speedup for log_p and much larger |x| ! + * Then, make use of Abramowitz & Stegun, 26.2.13, something like + + xsq = x*x; + + if(xsq * DBL_EPSILON < 1.) + del = (1. - (1. - 5./(xsq+6.)) / (xsq+4.)) / (xsq+2.); + else + del = 0.; + *cum = -.5*xsq - M_LN_SQRT_2PI - log(x) + log1p(-del); + *ccum = log1p(-exp(*cum)); /.* ~ log(1) = 0 *./ + + swap_tail; + + [Yes, but xsq might be infinite.] + +*/ + || (lower && -37.5193 < x && x < 8.2924) + || (upper && -8.2924 < x && x < 37.5193) + ) { + + /* Evaluate pnorm for x in (-37.5, -5.657) union (5.657, 37.5) */ + xsq = 1.0 / (x * x); /* (1./x)*(1./x) might be better */ + xnum = p[5] * xsq; + xden = xsq; + for (i = 0; i < 4; ++i) { + xnum = (xnum + p[i]) * xsq; + xden = (xden + q[i]) * xsq; + } + temp = xsq * (xnum + p[4]) / (xden + q[4]); + temp = (M_1_SQRT_2PI - temp) / y; + + do_del(x); + swap_tail; + } else { /* large x such that probs are 0 or 1 */ + if(x > 0) { *cum = R_D__1; *ccum = R_D__0; } + else { *cum = R_D__0; *ccum = R_D__1; } + } + + +#ifdef NO_DENORMS + /* do not return ""denormalized"" -- we do in R */ + if(log_p) { + if(*cum > -min) *cum = -0.; + if(*ccum > -min)*ccum = -0.; + } + else { + if(*cum < min) *cum = 0.; + if(*ccum < min) *ccum = 0.; + } +#endif + return; +} + + + + + +double pnorm5(double x, double mu, double sigma, int lower_tail, int log_p) +{ + double p, cp; + + /* Note: The structure of these checks has been carefully thought through. + * For example, if x == mu and sigma == 0, we get the correct answer 1. + */ + if(!R_FINITE(x) && mu == x) return ML_NAN;/* x-mu is NaN */ + if (sigma <= 0) { + // if(sigma < 0) ML_ERR_return_NAN; + if(sigma < 0) return ML_NAN; ; + /* sigma = 0 : */ + return (x < mu) ? R_DT_0 : R_DT_1; + } + p = (x - mu) / sigma; + if(!R_FINITE(p)) + return (x < mu) ? R_DT_0 : R_DT_1; + x = p; + + pnorm_both(x, &p, &cp, (lower_tail ? 0 : 1), log_p); + + return(lower_tail ? p : cp); +} +#endif // pnorm +","C" +"Allele","BGI-shenzhen/RRSelection","src/include/gzstream/gzstream.c",".c","5093","166","// ============================================================================ +// gzstream, C++ iostream classes wrapping the zlib compression library. +// Copyright (C) 2001 Deepak Bandyopadhyay, Lutz Kettner +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// ============================================================================ +// +// File : gzstream.C +// Revision : $Revision: 1.7 $ +// Revision_date : $Date: 2003/01/08 14:41:27 $ +// Author(s) : Deepak Bandyopadhyay, Lutz Kettner +// +// Standard streambuf implementation following Nicolai Josuttis, ""The +// Standard C++ Library"". +// ============================================================================ + +#include ""gzstream.h"" +#include +#include // for memcpy + +#ifdef GZSTREAM_NAMESPACE +namespace GZSTREAM_NAMESPACE { +#endif + +// ---------------------------------------------------------------------------- +// Internal classes to implement gzstream. See header file for user classes. +// ---------------------------------------------------------------------------- + +// -------------------------------------- +// class gzstreambuf: +// -------------------------------------- + +gzstreambuf* gzstreambuf::open( const char* name, int open_mode) { + if ( is_open()) + return (gzstreambuf*)0; + mode = open_mode; + // no append nor read/write mode + if ((mode & std::ios::ate) || (mode & std::ios::app) + || ((mode & std::ios::in) && (mode & std::ios::out))) + return (gzstreambuf*)0; + char fmode[10]; + char* fmodeptr = fmode; + if ( mode & std::ios::in) + *fmodeptr++ = 'r'; + else if ( mode & std::ios::out) + *fmodeptr++ = 'w'; + *fmodeptr++ = 'b'; + *fmodeptr = '\0'; + file = gzopen( name, fmode); + if (file == 0) + return (gzstreambuf*)0; + opened = 1; + return this; +} + +gzstreambuf * gzstreambuf::close() { + if ( is_open()) { + sync(); + opened = 0; + if ( gzclose( file) == Z_OK) + return this; + } + return (gzstreambuf*)0; +} + +int gzstreambuf::underflow() { // used for input buffer only + if ( gptr() && ( gptr() < egptr())) + return * reinterpret_cast( gptr()); + + if ( ! (mode & std::ios::in) || ! opened) + return EOF; + // Josuttis' implementation of inbuf + int n_putback = gptr() - eback(); + if ( n_putback > 4) + n_putback = 4; + memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback); + + int num = gzread( file, buffer+4, bufferSize-4); + if (num <= 0) // ERROR or EOF + return EOF; + + // reset buffer pointers + setg( buffer + (4 - n_putback), // beginning of putback area + buffer + 4, // read position + buffer + 4 + num); // end of buffer + + // return next character + return * reinterpret_cast( gptr()); +} + +int gzstreambuf::flush_buffer() { + // Separate the writing of the buffer from overflow() and + // sync() operation. + int w = pptr() - pbase(); + if ( gzwrite( file, pbase(), w) != w) + return EOF; + pbump( -w); + return w; +} + +int gzstreambuf::overflow( int c) { // used for output buffer only + if ( ! ( mode & std::ios::out) || ! opened) + return EOF; + if (c != EOF) { + *pptr() = c; + pbump(1); + } + if ( flush_buffer() == EOF) + return EOF; + return c; +} + +int gzstreambuf::sync() { + // Changed to use flush_buffer() instead of overflow( EOF) + // which caused improper behavior with std::endl and flush(), + // bug reported by Vincent Ricard. + if ( pptr() && pptr() > pbase()) { + if ( flush_buffer() == EOF) + return -1; + } + return 0; +} + +// -------------------------------------- +// class gzstreambase: +// -------------------------------------- + +gzstreambase::gzstreambase( const char* name, int mode) { + init( &buf); + open( name, mode); +} + +gzstreambase::~gzstreambase() { + buf.close(); +} + +void gzstreambase::open( const char* name, int open_mode) { + if ( ! buf.open( name, open_mode)) + clear( rdstate() | std::ios::badbit); +} + +void gzstreambase::close() { + if ( buf.is_open()) + if ( ! buf.close()) + clear( rdstate() | std::ios::badbit); +} + +#ifdef GZSTREAM_NAMESPACE +} // namespace GZSTREAM_NAMESPACE +#endif + +// ============================================================================ +// EOF // +","C" +"Allele","BGI-shenzhen/RRSelection","src/include/gzstream/gzstream.h",".h","4603","122","// ============================================================================ +// gzstream, C++ iostream classes wrapping the zlib compression library. +// Copyright (C) 2001 Deepak Bandyopadhyay, Lutz Kettner +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// ============================================================================ +// +// File : gzstream.h +// Revision : $Revision: 1.5 $ +// Revision_date : $Date: 2002/04/26 23:30:15 $ +// Author(s) : Deepak Bandyopadhyay, Lutz Kettner +// +// Standard streambuf implementation following Nicolai Josuttis, ""The +// Standard C++ Library"". +// ============================================================================ + +#ifndef GZSTREAM_H +#define GZSTREAM_H 1 + +// standard C++ with new header file names and std:: namespace +#include +#include +#include + +#ifdef GZSTREAM_NAMESPACE +namespace GZSTREAM_NAMESPACE { +#endif + +// ---------------------------------------------------------------------------- +// Internal classes to implement gzstream. See below for user classes. +// ---------------------------------------------------------------------------- + +class gzstreambuf : public std::streambuf { +private: + static const int bufferSize = 47+256; // size of data buff + // totals 512 bytes under g++ for igzstream at the end. + + gzFile file; // file handle for compressed file + char buffer[bufferSize]; // data buffer + char opened; // open/close state of stream + int mode; // I/O mode + + int flush_buffer(); +public: + gzstreambuf() : opened(0) { + setp( buffer, buffer + (bufferSize-1)); + setg( buffer + 4, // beginning of putback area + buffer + 4, // read position + buffer + 4); // end position + // ASSERT: both input & output capabilities will not be used together + } + int is_open() { return opened; } + gzstreambuf* open( const char* name, int open_mode); + gzstreambuf* close(); + ~gzstreambuf() { close(); } + + virtual int overflow( int c = EOF); + virtual int underflow(); + virtual int sync(); +}; + +class gzstreambase : virtual public std::ios { +protected: + gzstreambuf buf; +public: + gzstreambase() { init(&buf); } + gzstreambase( const char* name, int open_mode); + ~gzstreambase(); + void open( const char* name, int open_mode); + void close(); + gzstreambuf* rdbuf() { return &buf; } +}; + +// ---------------------------------------------------------------------------- +// User classes. Use igzstream and ogzstream analogously to ifstream and +// ofstream respectively. They read and write files based on the gz* +// function interface of the zlib. Files are compatible with gzip compression. +// ---------------------------------------------------------------------------- + +class igzstream : public gzstreambase, public std::istream { +public: + igzstream() : std::istream( &buf) {} + igzstream( const char* name, int open_mode = std::ios::in) + : gzstreambase( name, open_mode), std::istream( &buf) {} + gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); } + void open( const char* name, int open_mode = std::ios::in) { + gzstreambase::open( name, open_mode); + } +}; + +class ogzstream : public gzstreambase, public std::ostream { +public: + ogzstream() : std::ostream( &buf) {} + ogzstream( const char* name, int mode = std::ios::out) + : gzstreambase( name, mode), std::ostream( &buf) {} + gzstreambuf* rdbuf() { return gzstreambase::rdbuf(); } + void open( const char* name, int open_mode = std::ios::out) { + gzstreambase::open( name, open_mode); + } +}; + +#ifdef GZSTREAM_NAMESPACE +} // namespace GZSTREAM_NAMESPACE +#endif + +#endif // GZSTREAM_H +// ============================================================================ +// EOF // + +","Unknown" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/treemix_iterations.sh",".sh","561","26","#!/bin/bash +# Load the software with module if applicable: +# module load treemix + +# Global parameters +id=$1 +mig=$2 +TIMESTAMP=$(date +%Y-%m-%d_%Hh%Mm%Ss) +LOG_DIR=""10-log_files"" + +echo ""creating log folder"" +mkdir 10-log_files 2>/dev/null + +# Treemix options +# Comments option you don't want +i=""-i treemix.frq.gz"" #name of input file +m=""-m"" #migration +o=""-o out_stem_mig"" +b=""-bootstrap"" +k=""-k 100"" +root=""-root ""$rout"" "" +#se=""-se"" + +# Run treemix +treemix $i $m ""$mig"" $se $b $k -o out_stem_mig""$mig"".replicate.""$id"" 2>&1 | tee 10-log_files/""$TIMESTAMP""_treemix.log +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/02.treemix.parralel.sh",".sh","1444","66","#!/bin/bash + +TIMESTAMP=$(date +%Y-%m-%d_%Hh%Mm%Ss) +LOG_DIR=""10-log_files"" +NUM_CPUS=4 + +if [[ ! -d ""$LOG_DIR"" ]] +then + echo ""creating log folder"" + mkdir 10-log_files +fi + +boot_folder=""02.boot_results"" +if [[ ! -d ""$boot_folder"" ]] +then + echo ""creating 02.results"" + mkdir ""$boot_folder"" +fi + +# Treemix options +# Comment options that you don't want +mig=$1 #number of migration event to test +rout=$2 #name of root +bootrep=500 + + +# Report if migration is not used +if [ -z ""$mig"" ] +then + echo ""-----------------------------------"" + echo "" running treemix without migration "" + echo ""-----------------------------------"" + sleep 1s +fi + +# Report if outgroup is not used +if [ -z ""$rout"" ] +then + echo ""----------------------------------"" + echo "" running treemix without outgroup "" + echo ""----------------------------------"" + sleep 1s +fi + +echo ""--------------------------------------"" +echo "" $bootrep bootsratp will be performed "" +echo ""--------------------------------------"" + +# Move to folder +cd ""$boot_folder"" +mkdir treemix_boot_mig.""$mig"" +cd treemix_boot_mig.""$mig"" +cp ../../00.data/treemix.frq.gz . + +# Run bootstrap : +seq $bootrep |parallel -j ""$NUM_CPUS"" ../../01.scripts/treemix_iterations.sh {} ""$mig"" + +#run ML tree: +#i=""-i ../00.data/treemix.frq.gz"" #name of input file +#m=""-m"" #migration +#o=""-o out_stem_mig"" +#b=""-bootstrap"" +#k=""-k 100"" +#se=""-se"" +#treemix ""$i"" ""$m"" ""$mig"" ""$se"" ""$k"" -o out_stem_mig""$mig"" +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/01.treemix_no_boot.sh",".sh","1072","50","#!/bin/bash + +TIMESTAMP=$(date +%Y-%m-%d_%Hh%Mm%Ss) +LOG_DIR=""10-log_files"" + +if [[ ! -d ""$LOG_DIR"" ]] +then + echo ""creating log folder"" + mkdir 10-log_files +fi + +if [[ ! -d 02.results ]] +then + echo ""creating 02.results"" + mkdir 02.results +fi + +# Treemix options +# Comment options that you don't want +mig=$1 #number of migration event to test +rout=$2 #name of root +#root=""-root $rout"" +i=""-i 00.data/treemix.frq.gz"" #name of input file +m=""-m"" #migration +o=""-o out_stem_mig"" +#b=""-bootstrap"" +k=""-k 100"" +se=""-se"" + +# Report if migration is not used +if [ -z ""$mig"" ] +then + echo ""-----------------------------------"" + echo "" running treemix without migration "" + echo ""-----------------------------------"" + sleep 1s +fi + +# Report if outgroup is not used +if [ -z ""$rout"" ] +then + echo ""----------------------------------"" + echo "" running treemix without outgroup "" + echo ""----------------------------------"" + sleep 1s +fi + +# Run treemix +treemix $i $rout $m ""$mig"" $se $b $k -o 02.results/out_stem_mig""$mig"" | tee 10-log_files/""$TIMESTAMP""_treemix.log +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/katak_jobs/02.treemix.parralel.sh",".sh","717","33","#!/bin/bash +#SBATCH -J ""se_treemix"" +#SBATCH -o log_%j +#SBATCH -c 1 +#SBATCH -p large +##SBATCH --mail-type=FAIL +##SBATCH --mail-user=asdf +#SBATCH --time=10-00:00 +#SBATCH --mem=4G + +# Load the software with module if applicable: +module load treemix + +mig=$1 #number of migration event to test +if [ -z ""$mig"" ] +then + echo ""-----------------------------------"" + echo "" running treemix without migration "" + echo ""-----------------------------------"" + sleep 1s +fi + +rout=$2 #name of root +if [ -z ""$rout"" ] +then + echo ""----------------------------------"" + echo "" running treemix without outgroup "" + echo ""----------------------------------"" + sleep 1s +fi + +./01.scripts/02.treemix.parralel.sh $mig $rout +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/katak_jobs/01.treemix_no_boot.sh",".sh","717","33","#!/bin/bash +#SBATCH -J ""se_treemix"" +#SBATCH -o log_%j +#SBATCH -c 1 +#SBATCH -p large +##SBATCH --mail-type=FAIL +##SBATCH --mail-user=asdf +#SBATCH --time=10-00:00 +#SBATCH --mem=4G + +# Load the software with module if applicable: +module load treemix + +mig=$1 #number of migration event to test +if [ -z ""$mig"" ] +then + echo ""-----------------------------------"" + echo "" running treemix without migration "" + echo ""-----------------------------------"" + sleep 1s +fi + +root=$2 #name of root +if [ -z ""$root"" ] +then + echo ""----------------------------------"" + echo "" running treemix without outgroup "" + echo ""----------------------------------"" + sleep 1s +fi + +./01.scripts/01.treemix_no_boot.sh $mig $root +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/colosse_jobs/02.treemix.parralel_m2.sh",".sh","921","36","#!/bin/bash +#PBS -A ihv-653-aa +#PBS -N merge__ +#PBS -l walltime=48:00:00 +#PBS -l nodes=1:ppn=8 +#PBS -r n + +# Move to job submission directory +cd $PBS_O_WORKDIR + + +# Load the software with module if applicable: +source /clumeq/bin/enable_cc_cvmfs +module load nixpkgs/16.09 gcc/7.3.0 +module load treemix/1.13 + +mig=2 #$1 #number of migration event to test +if [ -z ""$mig"" ] +then + echo ""-----------------------------------"" + echo "" running treemix without migration "" + echo ""-----------------------------------"" + sleep 1s +fi + +rout=$2 #name of root +if [ -z ""$rout"" ] +then + echo ""----------------------------------"" + echo "" running treemix without outgroup "" + echo ""----------------------------------"" + sleep 1s +fi + +./01.scripts/02.treemix.parralel.sh $mig $rout +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/colosse_jobs/02.treemix.parralel_m4.sh",".sh","920","35","#!/bin/bash +#PBS -A ihv-653-aa +#PBS -N merge__ +#PBS -l walltime=48:00:00 +#PBS -l nodes=1:ppn=8 +#PBS -r n + +# Move to job submission directory +cd $PBS_O_WORKDIR + +# Load the software with module if applicable: +source /clumeq/bin/enable_cc_cvmfs +module load nixpkgs/16.09 gcc/7.3.0 +module load treemix/1.13 + +mig=4 #$1 #number of migration event to test +if [ -z ""$mig"" ] +then + echo ""-----------------------------------"" + echo "" running treemix without migration "" + echo ""-----------------------------------"" + sleep 1s +fi + +rout=$2 #name of root +if [ -z ""$rout"" ] +then + echo ""----------------------------------"" + echo "" running treemix without outgroup "" + echo ""----------------------------------"" + sleep 1s +fi + +./01.scripts/02.treemix.parralel.sh $mig $rout +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/colosse_jobs/02.treemix.parralel_m5.sh",".sh","920","35","#!/bin/bash +#PBS -A ihv-653-aa +#PBS -N merge__ +#PBS -l walltime=48:00:00 +#PBS -l nodes=1:ppn=8 +#PBS -r n + +# Move to job submission directory +cd $PBS_O_WORKDIR + +# Load the software with module if applicable: +source /clumeq/bin/enable_cc_cvmfs +module load nixpkgs/16.09 gcc/7.3.0 +module load treemix/1.13 + +mig=5 #$1 #number of migration event to test +if [ -z ""$mig"" ] +then + echo ""-----------------------------------"" + echo "" running treemix without migration "" + echo ""-----------------------------------"" + sleep 1s +fi + +rout=$2 #name of root +if [ -z ""$rout"" ] +then + echo ""----------------------------------"" + echo "" running treemix without outgroup "" + echo ""----------------------------------"" + sleep 1s +fi + +./01.scripts/02.treemix.parralel.sh $mig $rout +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/colosse_jobs/02.treemix.parralel_m3.sh",".sh","921","36","#!/bin/bash +#PBS -A ihv-653-aa +#PBS -N merge__ +#PBS -l walltime=48:00:00 +#PBS -l nodes=1:ppn=8 +#PBS -r n + +# Move to job submission directory +cd $PBS_O_WORKDIR + + +# Load the software with module if applicable: +source /clumeq/bin/enable_cc_cvmfs +module load nixpkgs/16.09 gcc/7.3.0 +module load treemix/1.13 + +mig=3 #$1 #number of migration event to test +if [ -z ""$mig"" ] +then + echo ""-----------------------------------"" + echo "" running treemix without migration "" + echo ""-----------------------------------"" + sleep 1s +fi + +rout=$2 #name of root +if [ -z ""$rout"" ] +then + echo ""----------------------------------"" + echo "" running treemix without outgroup "" + echo ""----------------------------------"" + sleep 1s +fi + +./01.scripts/02.treemix.parralel.sh $mig $rout +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/utility_scripts/00.vcf_to_treemix.sh",".sh","756","38","#!/bin/bash + +# Global parameters +input=$1 #vcffile +cluster=$2 #strata.txt + +if [ -z ""$input"" ] +then + echo ""error please provide vcffile"" + exit +fi + +if [ -z ""$cluster"" ] +then + echo ""error please provide strata file"" + echo ""strata file 3 colomns of the form:"" + echo ""FID\tIIDs\tCLUSTER"" + exit +fi + +plink --vcf ""$input"" --allow-extra-chr --recode + +awk '{print $1, $1""_""$2 }' plink.ped > pop_ind.tmp +cut -d "" "" -f 3- plink.ped > geno.tmp +cp plink.ped plink.ped.back +paste pop_ind.tmp geno.tmp > plink.ped +rm *.tmp + +plink --file plink \ + --allow-extra-chr \ + --freq --missing --within ""$cluster"" \ + --out plink + +gzip plink.frq.strat +./01.scripts/utility_scripts/plink2treemix.py plink.frq.strat.gz treemix.frq.gz + +echo ""input file is ready for treemix"" +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/utility_scripts/plotting_funcs.R",".R","15960","538"," +# +# functions for plotting a tree +# + +library(RColorBrewer) +set_y_coords = function(d){ + i = which(d[,3]==""ROOT"") + y = d[i,8]/ (d[i,8]+d[i,10]) + d[i,]$y = 1-y + d[i,]$ymin = 0 + d[i,]$ymax = 1 + c1 = d[i,7] + c2 = d[i,9] + ni = which(d[,1]==c1) + ny = d[ni,8]/ (d[ni,8]+d[ni,10]) + d[ni,]$ymin = 1-y + d[ni,]$ymax = 1 + d[ni,]$y = 1- ny*(y) + + ni = which(d[,1]==c2) + ny = d[ni,8]/ (d[ni,8]+d[ni,10]) + d[ni,]$ymin = 0 + d[ni,]$ymax = 1-y + d[ni,]$y = (1-y)-ny*(1-y) + + for (j in 1:nrow(d)){ + d = set_y_coord(d, j) + } + return(d) +} + +set_y_coord = function(d, i){ + index = d[i,1] + parent = d[i,6] + if (!is.na(d[i,]$y)){ + return(d) + } + tmp = d[d[,1] == parent,] + if ( is.na(tmp[1,]$y)){ + d = set_y_coord(d, which(d[,1]==parent)) + tmp = d[d[,1]== parent,] + } + py = tmp[1,]$y + pymin = tmp[1,]$ymin + pymax = tmp[1,]$ymax + f = d[i,8]/( d[i,8]+d[i,10]) + #print (paste(i, index, py, pymin, pymax, f)) + if (tmp[1,7] == index){ + d[i,]$ymin = py + d[i,]$ymax = pymax + d[i,]$y = pymax-f*(pymax-py) + if (d[i,5]== ""TIP""){ + d[i,]$y = (py+pymax)/2 + } + } + else{ + d[i,]$ymin = pymin + d[i,]$ymax = py + d[i,]$y = py-f*(py-pymin) + if (d[i,5]== ""TIP""){ + d[i,]$y = (pymin+py)/2 + } + + } + return(d) +} + + +set_x_coords = function(d, e){ + i = which(d[,3]==""ROOT"") + index = d[i,1] + d[i,]$x = 0 + c1 = d[i,7] + c2 = d[i,9] + ni = which(d[,1]==c1) + tmpx = e[e[,1]==index & e[,2] == c1,3] + if (length(tmpx) == 0){ + tmp = e[e[,1] == index,] + tmpc1 = tmp[1,2] + if ( d[d[,1]==tmpc1,4] != ""MIG""){ + tmpc1 = tmp[2,2] + } + tmpx = get_dist_to_nmig(d, e, index, tmpc1) + } + if(tmpx < 0){ + tmpx = 0 + } + d[ni,]$x = tmpx + + ni = which(d[,1]==c2) + tmpx = e[e[,1]==index & e[,2] == c2,3] + if (length(tmpx) == 0){ + tmp = e[e[,1] == index,] + tmpc2 = tmp[2,2] + if ( d[d[,1]==tmpc2,4] != ""MIG""){ + tmpc2 = tmp[1,2] + } + tmpx = get_dist_to_nmig(d, e, index, tmpc2) + } + if(tmpx < 0){ + tmpx = 0 + } + d[ni,]$x = tmpx + + for (j in 1:nrow(d)){ + d = set_x_coord(d, e, j) + } + return(d) + print(d) +} + + +set_x_coord = function(d, e, i){ + index = d[i,1] + parent = d[i,6] + if (!is.na(d[i,]$x)){ + return(d) + } + tmp = d[d[,1] == parent,] + if ( is.na(tmp[1,]$x)){ + d = set_x_coord(d, e, which(d[,1]==parent)) + tmp = d[d[,1]== parent,] + } + #print (paste(parent, index)) + tmpx = e[e[,1]==parent & e[,2] == index,3] + if (length(tmpx) == 0){ + tmp2 = e[e[,1] == parent,] + tmpc2 = tmp2[2,2] + #print + if ( d[d[,1]==tmpc2,4] != ""MIG""){ + tmpc2 = tmp2[1,2] + } + tmpx = get_dist_to_nmig(d, e, parent, tmpc2) + } + if(tmpx < 0){ + tmpx = 0 + } + d[i,]$x = tmp[1,]$x+ tmpx + return(d) +} + +plot_tree_internal = function(d, e, o = NA, cex = 1, disp = 0.005, plus = 0.005, arrow = 0.05, ybar = 0.01, scale = T, mbar = T, mse = 0.01, plotmig = T, plotnames = T, xmin = 0, lwd = 1, font = 1){ + plot(d$x, d$y, axes = F, ylab = """", xlab = ""Drift parameter"", xlim = c(xmin, max(d$x)+plus), pch = """") + axis(1) + mw = max(e[e[,5]==""MIG"",4]) + mcols = rev(heat.colors(150)) + for(i in 1:nrow(e)){ + col = ""black"" + if (e[i,5] == ""MIG""){ + w = floor(e[i,4]*200)+50 + if (mw > 0.5){ + w = floor(e[i,4]*100)+50 + } + col = mcols[w] + if (is.na(col)){ + col = ""blue"" + } + } + v1 = d[d[,1] == e[i,1],] + v2 = d[d[,1] == e[i,2],] + if (e[i,5] == ""MIG""){ + if (plotmig){ + arrows( v1[1,]$x, v1[1,]$y, v2[1,]$x, v2[1,]$y, col = col, length = arrow) + } + } + else{ + lines( c(v1[1,]$x, v2[1,]$x), c(v1[1,]$y, v2[1,]$y), col = col, lwd = lwd) + } + } + tmp = d[d[,5] == ""TIP"",] + print(tmp$x) + print(disp) + if ( !is.na(o)){ + for(i in 1:nrow(tmp)){ + tcol = o[o[,1] == tmp[i,2],2] + if(plotnames){ + #print(tmp[i,2]) + text(tmp[i,]$x+disp, tmp[i,]$y, labels = tmp[i,2], adj = 0, cex = cex, col = tcol, font = font) + } + } + } + else{ + if (plotnames){ + text(tmp$x+disp, tmp$y, labels = tmp[,2], adj = 0, cex = cex, font = font) + } + } + if (scale){ + print (paste(""mse"", mse)) + lines(c(0, mse*10), c(ybar, ybar)) + text( 0, ybar - 0.04, lab = ""10 s.e."", adj = 0, cex = 0.8) + lines( c(0, 0), c( ybar - 0.01, ybar+0.01)) + lines( c(mse*10, mse*10), c(ybar- 0.01, ybar+ 0.01)) + } + if (mbar){ + mcols = rev( heat.colors(150) ) + mcols = mcols[50:length(mcols)] + ymi = ybar+0.15 + yma = ybar+0.35 + l = 0.2 + w = l/100 + xma = max(d$x/20) + rect( rep(0, 100), ymi+(0:99)*w, rep(xma, 100), ymi+(1:100)*w, col = mcols, border = mcols) + text(xma+disp, ymi, lab = ""0"", adj = 0, cex = 0.7) + if ( mw >0.5){ text(xma+disp, yma, lab = ""1"", adj = 0, cex = 0.7)} + else{ + text(xma+disp, yma, lab = ""0.5"", adj = 0, cex =0.7) + } + text(0, yma+0.06, lab = ""Migration"", adj = 0 , cex = 0.6) + text(0, yma+0.03, lab = ""weight"", adj = 0 , cex = 0.6) + } +} + +set_mig_coords = function(d, e){ + for (j in 1:nrow(d)){ + if (d[j,4] == ""MIG""){ + p = d[d[,1] == d[j,6],] + c = d[d[,1] == d[j,7],] + tmpe = e[e[,1] == d[j,1],] + y1 = p[1,]$y + y2 = c[1,]$y + x1 = p[1,]$x + x2 = c[1,]$x + + mf = tmpe[1,6] + if (is.nan(mf)){ + mf = 0 + } + #d[j,]$y = (y1+y2)* mf + #d[j,]$x = (x1+x2) *mf + d[j,]$y = y1+(y2-y1)* mf + print(paste(mf, x1, x2)) + d[j,]$x = x1+(x2-x1) *mf + } + + } + return(d) + +} + +get_f = function(stem){ + d = paste(stem, "".cov.gz"", sep = """") + d2 = paste(stem, "".modelcov.gz"", sep = """") + d = read.table(gzfile(d), as.is = T, comment.char = """", quote = """") + d2 = read.table(gzfile(d2), as.is = T, comment.char = """", quote = """") + d = d[order(names(d)), order(names(d))] + d2 = d2[order(names(d2)), order(names(d2))] + tmpcf = vector() + tmpmcf = vector() + for (j in 1:nrow(d)){ + for (k in (j+1):nrow(d)){ + tmpcf = append(tmpcf, d[j,k]) + tmpmcf = append(tmpmcf, d[j,k] - d2[j,k]) + } + } + tmpv = var(tmpmcf)/var(tmpcf) + return(1-tmpv) + +} + +plot_tree = function(stem, o = NA, cex = 0.5, disp = 0.003, plus = 0.01, flip = vector(), arrow = 0.05, scale = T, ybar = 0.1, mbar = T, plotmig = T, plotnames = T, xmin = 0, lwd = 1, font = 1){ + d = paste(stem, "".vertices.gz"", sep = """") + e = paste(stem, "".edges.gz"", sep = """") + se = paste(stem, "".covse.gz"", sep = """") + d = read.table(gzfile(d), as.is = T, comment.char = """", quote = """") + e = read.table(gzfile(e), as.is = T, comment.char = """", quote = """") + if (!is.na(o)){ + o = read.table(o, as.is = T, comment.char = """", quote = """") + } + e[,3] = e[,3]*e[,4] + e[,3] = e[,3]*e[,4] + + se = read.table(gzfile(se), as.is = T, comment.char = """", quote = """") + m1 = apply(se, 1, mean) + m = mean(m1) + #m = 0 + for(i in 1:length(flip)){ + d = flip_node(d, flip[i]) + } + d$x = ""NA"" + d$y = ""NA"" + d$ymin = ""NA"" + d$ymax = ""NA"" + d$x = as.numeric(d$x) + d$y = as.numeric(d$y) + d$ymin = as.numeric(d$ymin) + d$ymax = as.numeric(d$ymax) + + d = set_y_coords(d) + d = set_x_coords(d, e) + print(d) + d = set_mig_coords(d, e) + plot_tree_internal(d, e, o = o, cex = cex, xmin = xmin, disp = disp, plus = plus, arrow = arrow, ybar = ybar, mbar = mbar, mse = m, scale = scale, plotmig = plotmig, plotnames = plotnames, lwd = lwd, font = font) + return(list( d= d, e = e)) +} + +get_dist_to_nmig = function(d, e, n1, n2){ + toreturn = e[e[,1] == n1 & e[,2] == n2,3] + #print(toreturn) + while ( d[d[,1] ==n2,4] == ""MIG""){ + tmp = e[e[,1] == n2 & e[,5] == ""NOT_MIG"",] + toreturn = toreturn+tmp[1,3] + n2 = tmp[1,2] + } + return(toreturn) +} + +flip_node = function(d, n){ + i = which(d[,1] == n) + t1 = d[i,7] + t2 = d[i,8] + d[i,7] = d[i,9] + d[i,8] = d[i,10] + d[i,9] = t1 + d[i,10] = t2 + return(d) + +} + +plot_modelcov = function(stem, pop_order, min = -0.009, max = 0.009, cex = 1, usemax = T){ + c = read.table(gzfile(paste(stem, "".modelcov.gz"", sep = """")), as.is = T, head = T) + o = read.table(pop_order, as.is = T, comment.char = """", quote = """") + + + toplot = data.frame(matrix(nrow = nrow(c), ncol = ncol(c))) + for(i in 1:nrow(o)){ + for( j in 1:nrow(o)){ + + toplot[i, j] = c[which(names(c)==o[i,1]), which(names(c)==o[j,1])] + } + } + if (usemax){ + m1 = max(abs(toplot)) + max = m1*1.1 + min = -(m1*1.1) + } + names(toplot) = o[,1] + plot_resid_internal(toplot, max = max, min = min) +} + + + +plot_cov = function(stem, pop_order, min = -0.009, max = 0.009, cex = 1, usemax = T, wcols = """"){ + c = read.table(gzfile(paste(stem, "".cov.gz"", sep = """")), as.is = T, head = T) + o = read.table(pop_order, as.is = T) + + + toplot = data.frame(matrix(nrow = nrow(c), ncol = ncol(c))) + for(i in 1:nrow(o)){ + for( j in 1:nrow(o)){ + + toplot[i, j] = c[which(names(c)==o[i,1]), which(names(c)==o[j,1])] + } + } + if (usemax){ + m1 = max(abs(toplot)) + max = m1*1.1 + min = 0 + } + names(toplot) = o[,1] + plot_cov_internal(toplot, max = max, min = min, wcols = wcols, o = o, cex = cex) +} + + +plot_resid = function(stem, pop_order, min = -0.009, max = 0.009, cex = 1, usemax = T, wcols = ""r""){ + c = read.table(gzfile(paste(stem, "".cov.gz"", sep = """")), as.is = T, head = T, quote = """", comment.char = """") + m = read.table(gzfile(paste(stem, "".modelcov.gz"", sep = """")), as.is = T, head = T, quote = """", comment.char = """") + names(c) = rownames(c) + names(m) = rownames(m) + o = read.table(pop_order, as.is = T, comment.char = """", quote = """") + se = read.table(gzfile(paste(stem, "".covse.gz"", sep = """")), as.is = T, head = T, quote = """", comment.char = """") + mse = apply(se, 1, mean) + mse = mean(mse) + print(mse) + c = c[order(names(c)), order(names(c))] + m = m[order(names(m)), order(names(m))] + tmp = c -m + #tmp = m - c + #tmp = (m-c)/m + #print(tmp) + toplot = data.frame(matrix(nrow = nrow(tmp), ncol = ncol(tmp))) + for(i in 1:nrow(o)){ + for( j in 1:nrow(o)){ + #print(paste(o[i,1], o[j,1])) + if (o[i,1] %in% names(tmp) ==F){ + print(paste(""not found"", o[i,1])) + } + if (o[j,1] %in% names(tmp) ==F){ + print(paste(""not found"", o[j,1])) + } + toplot[i, j] = tmp[which(names(tmp)==o[i,1]), which(names(tmp)==o[j,1])] + } + } + #print(toplot) + if (usemax){ + m1 = max(abs(toplot), na.rm = T) + max = m1*1.02 + min = -(m1*1.02) + } + print(""here"") + names(toplot) = o[,1] + toreturn = plot_resid_internal(toplot, max = max, min = min, wcols = wcols, mse = mse, o = o, cex = cex) + return(toreturn) +} + +plot_cov_internal = function(d, o = NA, max = 0.009, min = -0.009, cex =0.5, wcols = """", mse = 5){ + npop = nrow(d) + width = 1/npop + height = 1/npop + colors = brewer.pal(9, ""Spectral"") + colors = c(""red"", ""orange"",""yellow"", ""white"", ""green"", ""blue"", ""black"") + pal = colorRampPalette(colors) + ncol = 80 + cols = pal(ncol) + plot(""NA"", xlim = c(0, 1), ylim = c(0, 1), axes = F, xlab = """", ylab = """") + for (i in 1:npop){ + for( j in 1:i){ + v = d[i,j] + col= ""white"" + if (v < 0){ + if (wcols == ""rb""){ + col = rgb(0, 0, 1, v/min) + } + else{ + #col = rgb(0, 0, 1, 0.1+0.9*(v/min)) + col = cols[ncol/2-floor( (v/min)*(ncol/2))] + } + } + else{ + if (wcols == ""rb""){ + col = rgb(1, 0, 0, v/max) + } + else{ + #col = rgb(1, 0, 0, 0.1+0.9*(v/max)) + col = cols[ceiling((v/max)*(ncol))] + } + } + xmin = j/npop - 1/npop + xmax = j/npop + ymin = 1-(i/npop) + ymax = 1-(i/npop)+1/npop + if (v == 0){ col = ""white""} + rect(xmin, ymin, xmax, ymax, col = col, border = col) + } + tcol = ""black"" + tmp = o[o[,1] == names(d)[i],] + if (length(tmp) != 1){ + tcol = tmp[1,2] + } + mtext(names(d)[i], side = 2, at = 1-i/npop+0.5/npop, las = 1, cex = cex, col = tcol) + mtext(names(d)[i], side = 1, at = i/npop-0.5/npop, las = 3, cex = cex, col = tcol) + } + if ( !is.na(mse)){ + ymi = 0.5 + yma = 0.9 + w = (yma-ymi)/ncol + xma = 0.80 + lmi = round(min, digits = 1) + lma = round(max, digits = 1) + print(cols) + print(ymi+(0:ncol)*w) + rect( rep(0.75, ncol), ymi+(0:(ncol-1))*w, rep(xma, ncol), ymi+(1:ncol)*w, col = cols, border = cols) + text(xma+0.01, ymi, lab = paste(lmi), adj = 0, cex = 0.8) + text(xma+0.01, yma, lab = paste(lma, ""(Variance)""), adj = 0, cex = 0.8) + + } + return(d) + #image(as.matrix(d), col = cols) +} + +plot_resid_internal = function(d, o = NA, max = 0.009, min = -0.009, cex =0.5, wcols = ""rb"", mse = NA){ + npop = nrow(d) + width = 1/npop + height = 1/npop + colors = brewer.pal(9, ""Spectral"") + colors = c(""red"", ""orange"",""yellow"", ""white"", ""green"", ""blue"", ""black"") + pal = colorRampPalette(colors) + ncol = 80 + cols = pal(ncol) + plot(""NA"", xlim = c(0, 1), ylim = c(0, 1), axes = F, xlab = """", ylab = """") + for (i in 1:npop){ + for( j in 1:i){ + v = d[i,j] + print(paste(i, j, v)) + col= ""white"" + if (v < 0){ + if (wcols == ""rb""){ + col = rgb(0, 0, 1, v/min) + } + else{ + #col = rgb(0, 0, 1, 0.1+0.9*(v/min)) + col = cols[ncol/2-floor( (v/min)*(ncol/2))] + #col = ""white"" + } + } + else{ + if (wcols == ""rb""){ + col = rgb(1, 0, 0, v/max) + } + else{ + #col = rgb(1, 0, 0, 0.1+0.9*(v/max)) + col = cols[ncol/2+ceiling((v/max)*(ncol/2))] + } + } + xmin = j/npop - 1/npop + xmax = j/npop + ymin = 1-(i/npop) + ymax = 1-(i/npop)+1/npop + rect(xmin, ymin, xmax, ymax, col = col, border = col) + } + tcol = ""black"" + tmp = o[o[,1] == names(d)[i],] + if (length(tmp) != 1){ + tcol = tmp[1,2] + } + mtext(names(d)[i], side = 2, at = 1-i/npop+0.5/npop, las = 1, cex = cex, col = tcol) + mtext(names(d)[i], side = 1, at = i/npop-0.5/npop, las = 3, cex = cex, col = tcol) + } + if ( !is.na(mse)){ + ymi = 0.5 + yma = 0.9 + w = (yma-ymi)/ncol + xma = 0.80 + lmi = round(min/mse, digits = 1) + lma = round(max/mse, digits = 1) + print(cols) + print(ymi+(0:ncol)*w) + rect( rep(0.75, ncol), ymi+(0:(ncol-1))*w, rep(xma, ncol), ymi+(1:ncol)*w, col = cols, border = cols) + text(xma+0.01, ymi, lab = paste(lmi, ""SE""), adj = 0, cex = 0.8) + text(xma+0.01, yma, lab = paste(lma, ""SE""), adj = 0, cex = 0.8) + + } + return(d) + #image(as.matrix(d), col = cols) +} + + +","R" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/utility_scripts/plink2treemix.py",".py","1126","60","#!/usr/bin/env python2 +""""""Usage: + plink2treemix.py [gzipped input file] [gzipped output file] +"""""" + +# Modules +import sys, os, gzip + +# Parsing user input +try: + infile = gzip.open(sys.argv[1]) + outfile = gzip.open(sys.argv[2], ""w"") +except: + print(__doc__) + sys.exit(1) + +# Initialize variables +pop2rs = dict() +rss = list() +rss2 = set() + +# Read first two lines +line = infile.readline() +line = infile.readline() + +# Start treating file at second line +while line: + line = line.strip().split() + rs = line[1] + pop = line[2] + mc = line[6] + total = line[7] + + if rs not in rss2: + rss.append(rs) + rss2.add(rs) + + if pop2rs.has_key(pop)==0: + pop2rs[pop] = dict() + + if pop2rs[pop].has_key(rs)==0: + pop2rs[pop][rs] = "" "".join([mc, total]) + + line = infile.readline() + +pops = pop2rs.keys() +for pop in pops: + print >> outfile, pop, + +print >> outfile, """" + +for rs in rss: + for pop in pops: + tmp = pop2rs[pop][rs].split() + c1 = int(tmp[0]) + c2 = int(tmp[1]) + c3 = c2-c1 + print >> outfile, "","".join([str(c1), str(c3)]), + print >> outfile, """" +","Python" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/utility_scripts/01.build_consensus_tree.sh",".sh","2247","53","#bin/bash + +#this relies on sumtrees.py +#see: http://pythonhosted.org/DendroPy/programs/sumtrees.html +#or: pip install --user -U dendropy + +mig=$1 #number of migration event for which we build a consensus tree +boot_folder=$2 #the path to the folder containing the bootstraped trees +ml_tree=$3 #the maximum likelihood tree +root=""False"" #$4 + +if [[ -z ""$mig"" ]] +then + echo ""prepparing tree without migration"" + zcat $boot_folder/*.treeout.gz > sumtrees.no_mig.tree + zcat out_stem_no.mig.treeout.gz > out.nomig.treeout + #to do : treat case where rooted versus undrooted + if [ $root = ""False"" ] + then + sumtrees.py -t out.nomig.treeout -o bootree.no.mig.txt sumtree.no_mig.tree + else + sumtrees.py --rooted -t out.nomig.treeout -o bootree.no.mig.txt sumtree.no_mig.tree + fi +else + echo ""preparing tree with migration"" + for j in $(ls $boot_folder/*treeout.gz |sed ""s:$boot_folder\/::g"" ) ; + do + zcat $boot_folder/*.treeout.gz |sed -n '1p' >> sumtrees.""$mig"".tree + zcat $boot_folder/*.treeout.gz |sed '1d' |cut -d "" "" -f 5- |for j in $(seq $mig) ;do sed -n '1p' >> sumtrees.""$mig"".migration_edge.""$j"".tree ; done + #note : I am not sure this is correct to build a consensus of migration edge.. + #I don""t use this anyway. + #for i in $(seq $mig) ; + #do + #zcat ""$boot_folder""/*.treeout.gz |sed '1d' |cut -d "" "" -f 5- |awk '{print $1}' | awk -v i=$i 'NR==i'|sed 's/$/;/g' >> migration_edge.mig""$mig"".""$i"".left + #zcat ""$boot_folder""/*.treeout.gz |sed '1d' |cut -d "" "" -f 5- |awk '{print $2}' | awk -v i=$i 'NR==i'|sed 's/$/;/g' >> migration_edge.mig""$mig"".""$i"".right + #; done + + done + #récuperer l'arbre ML ici: + zcat ""$ml_tree"" | sed -n '1p' > out_stem_mig.""$mig"".treeout + zcat ""$ml_tree"" | sed '1d' |cut -d "" "" -f 5- > out_stem_migration_edges.""$mig"".treeout + + if [ $root = ""False"" ] + then + echo ""building unrooted consensus tree "" + sumtrees.py -t out_stem_mig.""$mig"".treeout -o bootree.""$mig"".txt sumtrees.""$mig"".tree + #sumtrees.py -t out_stem_mig.""$mig"".treeout -o bootree.""$mig"".txt sumtrees.""$mig"".tree #consensus pour les arbres de migrations + else + echo ""building rooted consensus tree"" + sumtrees.py --rooted -t out.""$mig"".treeout -o bootree.""$mig"".txt sumtrees.""$mig"".tree + fi +fi +","Shell" +"Allele","QuentinRougemont/treemix_workflow","01.scripts/utility_scripts/plotremix.R",".R","1419","57","#!/usr/bin/Rscript + +#move to 02.results before running me! +#can be run from the terminal no need to open R +source('../01.scripts/utility_scripts/plotting_funcs.R') + +argv <- commandArgs(TRUE) +pop.uniq <- argv[1] +#pop.uniq <-""../00.data/pop.uniq"" #a list of the uniq pop name +if(!file.exists(pop.uniq)){ + print(""error please provide a list with population name..."") + print(""list shoud contain one pop by line "") + stop(""program stopped because of the previous errors"") +} + + + +all.files=list.files(pattern=""covse.gz"") +all.files=all.files[-1] + +for(i in 1:length(all.files)){ + pdf(file=paste(""treemix.m."",i,"".pdf"",sep=""""),12,8) + plot_tree(paste(""out_stem_mig"",i, sep="""")) + dev.off() +} + +pdf(file=""treemix.no.mig.pdf"",12,8) + plot_tree(""out_stem_mig"") +dev.off() + +get_f(""out_stem_mig"") ->m0 + +m=NULL +z=NULL + +for(i in 1:length(all.files)) + { + m[i] <- get_f(paste(""out_stem_mig"",i, sep="""")) + z <- (c(m0,m)) + } + +write.table(z,""variance_f.res"",quote=F,col.names=F,row.names=F) + +pdf(file=""migration.edge.choice.pdf"") +plot(seq(0,length(all.files)),z,pch=""*"",cex=2,col=""blue"", type=""b"",xlab=""migration edge number"", ylab=""% explained variance"") +dev.off() + +pdf(file=""resid1.pdf"") +plot_resid(""out_stem_mig"",pop.uniq) +dev.off() + +for(i in 1:length(all.files)){ + pdf(file=paste(""treemix.residuals.m."",i,"".pdf"",sep="""")) + plot_resid(paste(""out_stem_mig"",i,sep=""""),pop.uniq) + dev.off() +} +","R" +"Allele","mgaynor1/nQuack","inst/include/nQuack.h",".h","246","10","// Generated by using Rcpp::compileAttributes() -> do not edit by hand +// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#ifndef RCPP_nQuack_H_GEN_ +#define RCPP_nQuack_H_GEN_ + +#include ""nQuack_RcppExports.h"" + +#endif // RCPP_nQuack_H_GEN_ +","Unknown" +"Allele","mgaynor1/nQuack","inst/include/nQuack_RcppExports.h",".h","955","31","// Generated by using Rcpp::compileAttributes() -> do not edit by hand +// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#ifndef RCPP_nQuack_RCPPEXPORTS_H_GEN_ +#define RCPP_nQuack_RCPPEXPORTS_H_GEN_ + +#include +#include + +namespace nQuack { + + using namespace Rcpp; + + namespace { + void validateSignature(const char* sig) { + Rcpp::Function require = Rcpp::Environment::base_env()[""require""]; + require(""nQuack"", Rcpp::Named(""quietly"") = true); + typedef int(*Ptr_validate)(const char*); + static Ptr_validate p_validate = (Ptr_validate) + R_GetCCallable(""nQuack"", ""_nQuack_RcppExport_validate""); + if (!p_validate(sig)) { + throw Rcpp::function_not_exported( + ""C++ function with signature '"" + std::string(sig) + ""' not found in nQuack""); + } + } + } + +} + +#endif // RCPP_nQuack_RCPPEXPORTS_H_GEN_ +","Unknown" +"Allele","mgaynor1/nQuack","src/extradistrbbd.h",".h","526","17","#ifndef EXTRADISTRBBD_H +#define EXTRADISTRBBD_H + +#include + +// [[Rcpp::interfaces(r, cpp)]] +// [[Rcpp::plugins(cpp11)]] + + +using Rcpp::NumericVector; + + +NumericVector cpp_dbbinom( const NumericVector& x, const NumericVector& size, const NumericVector& alpha, const NumericVector& beta, const bool& log_prob = false); +NumericVector cpp_pbbinom( const NumericVector& x, const NumericVector& size, const NumericVector& alpha, const NumericVector& beta, const bool& lower_tail = true, const bool& log_prob = false); + +#endif +","Unknown" +"Allele","mgaynor1/nQuack","src/EMbetauniform.cpp",".cpp","15272","467","// [[Rcpp::plugins(cpp11)]] +// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; + +#include ""emshared.h"" +#include + + +// title E-Step for Expectation Maximization - Beta+Uniform Distribution +// description This function is used in expectation maximization. Here we complete +// the E-Step and calculate the log-likelihood. Modifications include a correction for +// the truncated distribution. +// param parmlist A list containing initial alpha, mu, and sigma values. +// param xi List of observations, in this case allele frequencies. +// param type String indicating ""free"", ""fixed"", ""fixed_2"", and ""fixed_3"". +// param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +// return A list with the following elements: +// \item logL: Log-likelihood of the mixture model. +// \item Zprobs.mat: Matrix where rows represent data points and columns represent each +// mixture model. Observations are the scaled probability of each data point belonging +// to each mixture model. +// \item Sj.vec: A vector of column sums for each mixture model. +// \item parm.list: Supplied list containing initial alpha, mu, and sigma values. +// \item xi: List of allele frequencies. +Rcpp::List estepBU(const Rcpp::List parmlist, const arma::vec xi, std::string type, + const arma::vec trunc){ + + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + + const int m = mvec.size(); + const int xl = xi.size(); + arma::mat zprob( xl, (m+1) ); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0){ + for(int i = 0; i < m; i++) { + arma::vec ab = alphabetacalcA( mvec(i), svec(i) ) ; + arma::vec ppv = dbetaV(xi, ab(0), ab(1), 0); + zprob.col(i) = (avec(i) * ppv); + } + } else{ + for(int i = 0; i < m; i++) { + arma::vec ab = alphabetacalcA( mvec(i), svec(i) ) ; + double F2F1 = R::pbeta(trunc(1), ab(0), ab(1), 1, 0) - R::pbeta(trunc(0), ab(0), ab(1), 1, 0); + arma::vec pp = dbetaV(xi, ab(0), ab(1), 0); + pp = (pp/F2F1); + zprob.col(i) = (avec(i) * pp); + } + } + + //Uniform distribution + double avecsum = sum(avec(span(0, (m-1)))); + double ae = (1.0 - avecsum); + zprob.col(m) = (ae*prob_unif_vec(xi)); + + arma::vec denom = arma::sum(zprob, 1); + + arma::mat zprobb( xl, (m+1) ); + for(int i = 0; i < (m+1); i++){ + zprobb.col(i) = ( zprob.col(i) /denom ); + } + + Rcpp::List P = Rcpp::List::create( Rcpp::Named(""avec"") = avec, Rcpp::_[""mvec""] = mvec, Rcpp::_[""svec""] = svec); + return( Rcpp::List::create( Rcpp::_[""zprob""] = zprobb, Rcpp::_[""parm.list""] = P, Rcpp::_[""xi""] = xi, Rcpp::_[""denom""] = denom, Rcpp::_[""trunc""] = trunc, Rcpp::_[""type""]=type )); + +} + +// Augmented Likelihood Calculation - Beta+Uniform Distribution +double llcalcBU(const arma::vec avec, const arma::vec mvec, const arma::vec svec, + const int zcols, const arma::vec xi, const arma::mat zprob, + const arma::vec denom, const arma::vec trunc) { + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < (zcols-1); i++){ + arma::vec ab = alphabetacalcA(mvec(i), svec(i)); + arma::vec right = (lavec(i) +(dbetaV(xi, ab(0), ab(1), 1))); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < (zcols-1); i++){ + arma::vec ab = alphabetacalcA(mvec(i), svec(i)); + double F2F1 = log(R::pbeta(trunc(1), ab(0), ab(1), 1, 0) - R::pbeta(trunc(0), ab(0), ab(1), 1, 0)); + arma::vec right = (lavec(i) +((dbetaV(xi, ab(0), ab(1), 1))-F2F1)); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } + + // Add uniform + double ae = lavec(zcols-1); + sumit += sum(zprob.col(zcols-1) % (ae+prob_unif_vec(xi, 1))); + + return sumit; +} + +// Augmented Likelihood Calculation - Beta+Uniform Distribution +double lnlikecalcBU(const Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::mat Zprobsmat = eout[""zprob""]; + arma::vec xi = eout[""xi""]; + arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + arma::vec trunc = eout[""trunc""]; + + const int zcols = avec.size(); + + double lnlike = llcalcBU(avec, mvec, svec, zcols, xi, Zprobsmat, denom, trunc); + return((lnlike*-1.0)); + } + + +// MSTEP +/// Set up for optim +// Defining Ething class + class Ething { + public: + vec xi; + int zcols; + mat zdata; + vec denom; + vec trunc; + vec parms; + int pl; + int flag; + + Ething(vec xi, int zcols, mat zdata, vec denom, vec trunc, vec parms, int pl, int flag) : xi(xi), zcols(zcols), zdata(zdata), denom(denom), trunc(trunc), parms(parms), pl(pl), flag(flag){} + }; + + // Defining the optim function + typedef double optimfn(int n, double *par, void *ex); + +// Numerical Optimization - Beta+Uniform Distribution +// description This function is used in nnmin for numeric optimization +// which is necessary for expectation maximization to maximize the parameter values. +// param n Number of parameters in par. +// param par The parameters to be optimized. +// param ex Pointer containing all additional information needed. +// return Log likelihood. + double elnlikeBU(int n, double *par, void *ex) { + + Ething *et = (Ething *) ex; + + // zprobsmat + const int nmixt = et ->zcols; + arma::mat zprob = et ->zdata; + const int m = (nmixt - 1); + // xi + arma::vec xi = et ->xi; + + // denom + arma::vec denom = et -> denom; + + // trunc + arma::vec trunc = et -> trunc; + double tsum = (trunc(0) + trunc(1)); + + // myguess + arma::vec myguess(n); + for(int iy = 0; iyflag; + + if(flag == 0){ + avec = invmlogitcU(myguess(span(0, (m-1)))); + mvec = mutransformA(myguess(span(m, ((m*2)-1)))); + svec = stransformA(myguess(span((m*2), (n-1)))); + }else if(flag == 1){ //alpha-free + avec = invmlogitcU(myguess(span(0, (m-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + mvec = parms(span(0, (m-1))); + svec = parms(span(m, (pl-1))); + }else if(flag == 2){ //alpha-variance-free + avec = invmlogitcU(myguess(span(0, (m-1)))); + svec = stransformA(myguess(span(m, (n-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + mvec = parms(span(0, pl-1)); + } else if(flag == 3){ //variance free + svec = stransformA(myguess(span(0, (m-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + avec = parms(span(0, m)); + mvec = parms(span(m+1, pl-1)); + } + + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(tsum == 0){ + for(int i = 0; i < m; i++){ + arma::vec ab = alphabetacalcA(mvec(i), svec(i)); + arma::vec right = (lavec(i) +(dbetaV(xi, ab(0), ab(1), 1))); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < m; i++){ + arma::vec ab = alphabetacalcA(mvec(i), svec(i)); + double F2F1 = log(R::pbeta(trunc(1), ab(0), ab(1), 1, 0) - R::pbeta(trunc(0), ab(0), ab(1), 1, 0)); + arma::vec right = (lavec(i) +((dbetaV(xi, ab(0), ab(1), 1))-F2F1)); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } + + // Add uniform + double ae = log(avec(m)); + sumit += sum(zprob.col(m) % (ae+prob_unif_vec(xi, 1))); + + + //Rcpp::Rcout << sumit << std::endl; + return(sumit*(-1.0)); + } + + +// Defining elnlikeBU as an optim function +optimfn elnlikeBU; + +// Setting up nmmin +extern ""C"" { + void nmmin(int n, double *xin, double *x, double *Fmin, optimfn fn, + int *fail, double abstol, double intol, void *ex, + double alpha, double beta, double gamma, int trace, + int *fncount, int maxit); +} + +// M-Step with Numerical Optimization for Expectation Maximization - Beta+Uniform Distribution +// +// description This function is used in expectation maximization to maximize the parameter values. +// param eout List with output from the estep +// param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$.] +Rcpp::List mstepBU(Rcpp::List eout){ + + const Rcpp::List parmlist = eout[""parm.list""]; + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + const arma::mat Zprobsmat = eout[""zprob""]; + const arma::vec xi = eout[""xi""]; + const arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + const arma::vec trunc = eout[""trunc""]; + + const int nmixt = avec.size(); + const int m = mvec.size(); + + arma::vec fgp = sampFTBU(type, m); + int flag = fgp(0); + int gl = fgp(1); + int pl = fgp(2); + + arma::vec guess(gl); + arma::vec parms(pl); + + if(flag == 0){ + parms(0) = 0; + guess(span(0,(m-1))) = mlogitcU(avec, nmixt); + guess(span(m, ((m*2)-1))) = mvecinA(mvec); + guess(span((m*2), (gl-1))) = svecinA(svec); + }else if(flag == 1){ //alpha + guess(span(0, (m-1))) = mlogitcU(avec, nmixt); + parms(span(0, (m-1))) = mvec; + parms(span(m, (pl-1))) = svec; + } else if(flag == 2){ //both + guess(span(0,(m-1))) = mlogitcU(avec, nmixt); + guess(span(m, (gl-1))) = svecinA(svec); + parms(span(0, (m-1))) = mvec; + + } else if(flag == 3){ + guess(span(0,(m-1))) = svecinA(svec); + + parms(span(0, m)) = avec; + parms(span((m+1), (pl-1))) = mvec; + } + + Ething et(xi, nmixt, Zprobsmat, denom, trunc, parms, pl, flag); + + arma::vec vec(gl); + for(int nn = 0; nn < gl; nn++){ + vec(nn) = guess(nn); + } + + arma::vec opar(gl); + double Fmin = 0.0; + int fail = 0; + const double abstol = 1.0e-8; + const double intol = 1.0e-8; + const double alpha = 1.0; + const double beta = 0.5; + const double gamma = 2.0; + const int trace = 0; + int fncount = 0; + const int maxit = 500; + + nmmin(gl, vec.begin(), opar.begin(), &Fmin, + elnlikeBU, &fail, abstol, intol, &et, alpha, beta, + gamma, trace, &fncount, maxit); + + // Transform oparback + arma::vec oparback(gl); + for(int ou = 0; ou < gl; ou++){ + oparback(ou) = opar[ou]; + } + + arma::vec ahats(m+1); + arma::vec mhats(m); + arma::vec shats(m); + + if(flag == 0){ + ahats = invmlogitcU(oparback(span(0, (m-1)))); + mhats = mutransformA(oparback(span(m, ((m*2)-1)))); + shats = stransformA(oparback(span((m*2), (gl-1)))); + }else if(flag == 1){ + ahats = invmlogitcU(oparback(span(0, (m-1)))); + mhats = mvec; + shats = svec; + } else if(flag == 2){ + ahats = invmlogitcU(oparback(span(0, (m-1)))); + shats = stransformA(oparback(span(m, (gl-1)))); + mhats = mvec; + + } else if(flag == 3){ + shats = stransformA(oparback(span(0, (m-1)))); + ahats = avec; + mhats = mvec; + } + + // Logic check + if(ahats.has_nan() == true || all(ahats) == false){ //if all are non.zero = false + ahats = avec; + } + if(shats.has_nan() == true || all(shats) == false){ + shats = svec; + } + if(mhats.has_nan() == true || all(mhats) == false){ + mhats = mvec; + } + + + Rcpp::List res = Rcpp::List::create(Rcpp::_[""avec""] = ahats, Rcpp::_[""mvec""] = mhats, Rcpp::_[""svec""] = shats); + return(res); + } + + +// Log-Likelihood for BIC +double llcalcfinalBU(Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::vec xi = eout[""xi""]; + arma::vec trunc = eout[""trunc""]; + + //int n = avec.size(); + int m = mvec.size(); + int xl = xi.size(); + + arma::mat mixit(xl, (m+1)); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < m; i++){ + arma::vec ab = alphabetacalcA( mvec(i), svec(i) ) ; + mixit.col(i) = (avec(i)*dbetaV(xi, ab(0), ab(1), 0)); + } + }else{ + for(int i = 0; i < m; i++) { + arma::vec ab = alphabetacalcA( mvec(i), svec(i) ) ; + double F2F1 = R::pbeta(trunc(1), ab(0), ab(1), 1, 0) - R::pbeta(trunc(0), ab(0), ab(1), 1, 0); + arma::vec pp = (avec(i)*dbetaV(xi, ab(0), ab(1), 0)); + mixit.col(i) = (pp/F2F1); + } + } + + // Add Uniform Mixture + mixit.col(m) = (avec(m)*prob_unif_vec(xi)); + + arma::vec sumrows = arma::sum(mixit, 1); + if(all(sumrows) == false){ //if all are non.zero = false + for(int i = 0; i < xl; i++){ + if(sumrows(i) == 0){ + sumrows(i) = DBL_MIN; + } + } + } + + //arma::vec sumrows = arma::sum(mixit, 1); + double sumit = sum(log(sumrows)); + return sumit; +} + +//' @title Expectation maximization - Beta and Uniform Distributions +//' +//' @description This function calculates the log-likelihood using +//' the expectation maximization algorithm with Nelder-Mead numerical optimization +//' and beta distribution with one uniform mixture. +//' +//' @param parmlist A list containing initial alpha, mean, and variance values. +//' @param xi List of observations, in this case allele frequencies. +//' @param niter Max number of iterates. +//' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +//' below this value, convergence is reached. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +//' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +//' If avec is length of 1, fixed and fixed_3 will not be able to return a log-likelihood. +//' +//' @returns List of elements including the log likelihood, the negative log likelihood, the number of iterates, +//' and the optimized parameter values. +//' +// [[Rcpp::export]] +Rcpp::List emstepBU(Rcpp::List parmlist, arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type = ""free""){ + // Set up progress + // Progress p(niter, true); + + Rcpp::List mint = parmlist; + // E-step + Rcpp::List eint = estepBU(mint, xi, type, trunc); + double lnlikeint = lnlikecalcBU(eint); + + int count = 0; + // Iterating E and M steps until convergence is below epsilon + for(int j = 0; j < (niter + 1); j++){ + Rcpp::checkUserInterrupt(); + //p.increment(); + count = count + 1; + + // M-step + Rcpp::List moutip = mstepBU(eint); + + // E-step + Rcpp::List eoutip = estepBU(moutip, xi, type, trunc); + double lnlikeip = lnlikecalcBU(eoutip); + double deltalogL = (lnlikeint - lnlikeip); + deltalogL = std::abs(deltalogL); + // Rprintf(""%f \n"", deltalogL); + + // Set next iter + eint = eoutip; + lnlikeint = lnlikeip; + + if(deltalogL +using namespace Rcpp; + +#include +#include +#include +#include +#include +#include + + +// samtools mpileup +int mpileF(std::string name, std::string inpath, std::string tempfolder) { + std::string command = ""samtools mpileup "" + inpath + name + "".bam > "" + tempfolder + ""/test.mpileup --no-BAQ --ff UNMAP,DUP -A -Q 0 -q 0""; + + int result = system(command.c_str()); + + if (result == 0) { + Rcpp::Rcout << ""mpileup executed successfully."" << ""\n""; + } else { + Rcpp::Rcout << ""mpileup execution failed."" << ""\n""; + } + + return 0; +} + + +// Extract fifth field from mpileup output +std::string extractFifthFieldF(const std::string& line) { + + std::istringstream iss(line); + std::string field; + + // Skip the first four fields + for (int i = 0; i < 3; ++i) { + std::getline(iss, field, '\t'); + } + + // Extract the fifth field + std::getline(iss, field, '\t'); + + return field; +} + +// mainBash - count ACGT, compare sums, remove indels and deletions +int mainBashF(std::string name, std::string outpath, std::string tempfolder) { + + // Count number of ACGTs + std::ifstream inputFile1(tempfolder + ""/test.mpileup""); + std::ofstream cleanFile(tempfolder + ""/clean.mpileup""); + + if (!inputFile1.is_open() || !cleanFile.is_open() ) { + Rcpp::Rcerr << ""Failed to open files."" << ""\n""; + return 1; + } + + std::string line1; + while (std::getline(inputFile1, line1)) { + std::string nucleotides = extractFifthFieldF(line1.substr(line1.find('\t')+1)); + // Count deletions and insertions + std::regex patterndelt(""[^-]""); + std::string delOnly = std::regex_replace(nucleotides, patterndelt, """"); + + std::regex patterninst(""[^+]""); + std::string instOnly = std::regex_replace(nucleotides, patterninst, """"); + double mount = 0.0; + mount += (delOnly.size() + instOnly.size()); + //Rcpp::Rcout << mount << std::endl; + //std::string mout; + //std::getline(inputFile1, mout); + + if(mount == 0.0){ + cleanFile << line1 << ""\n""; + } else{ + } + } + + inputFile1.close(); + cleanFile.close(); + + // Count number of ACGTs + std::ifstream inputFile(tempfolder + ""/clean.mpileup""); + std::ofstream outputCounts(tempfolder + ""/temp_counts.txt""); + + if (!inputFile.is_open() || !outputCounts.is_open() ) { + Rcpp::Rcerr << ""Failed to open files."" << ""\n""; + return 1; + } + + std::string line; + while (std::getline(inputFile, line)) { + std::string nucleotides = extractFifthFieldF(line.substr(line.find('\t')+1)); + + // Count A + std::regex patterna(""[^Aa]""); + std::string aOnly = std::regex_replace(nucleotides, patterna, """"); + + // Count C + std::regex patternc(""[^Cc]""); + std::string cOnly = std::regex_replace(nucleotides, patternc, """"); + + // Count G + std::regex patterng(""[^Gg]""); + std::string gOnly = std::regex_replace(nucleotides, patterng, """"); + + // Count T + std::regex patternt(""[^Tt]""); + std::string tOnly = std::regex_replace(nucleotides, patternt, """"); + + // Make sum of counts + double total = (aOnly.size() + cOnly.size() + gOnly.size() + tOnly.size()); + + // Extract columns 1, 2, and 4 from mpileup output + // This is the contig/chromosome, position, and depth/coverage + std::istringstream iss(line); + std::vector columns; + std::string field; + for (int i = 0; i < 4; ++i) { + std::getline(iss, field, '\t'); + if (i == 0 || i == 1 || i == 3) { + columns.push_back(field); + } + } + + // Write the extracted columns to the output file + for (const auto& column : columns) { + outputCounts << column << '\t'; + } + outputCounts << aOnly.size() << '\t'<< cOnly.size() << '\t' << gOnly.size() << '\t' << tOnly.size() << '\t' << total << '\n'; + + } + + + inputFile.close(); + outputCounts.close(); + + + // Compare sum of ACGTs to mpileup & combine + // Remove INDELS & potential errors in calculation (mpileup != ACGTs sum) + + std::ifstream inputCounts(tempfolder + ""/temp_counts.txt""); + std::ofstream outputCompare(tempfolder + ""/temp_compare.txt""); + std::ofstream outputCounts4(tempfolder + ""/temp_counts4.txt""); + + if (!inputCounts.is_open() || !outputCompare.is_open() || !outputCounts4.is_open()) { + Rcpp::Rcerr << ""Failed to open files."" << ""\n""; + return 1; + } + + + std::string line2; + while (std::getline(inputCounts, line2)) { + + std::istringstream iss(line2); + // std::string out; + //std::getline(inputCounts, out); + + + std::string field; + int column3; + int column8; + + // Extract values from columns 3 and 8 + for (int i = 0; i < 8; ++i) { + if (i == 2) { + iss >> column3; + } else if (i == 7) { + iss >> column8; + } else { + iss >> field; + } + } + + // Compare values and write the result to the output file + if (column3 == column8) { + outputCompare << ""TRUE"" << '\n'; + outputCounts4 << line2 << ""\n""; + } else { + outputCompare << ""FALSE"" << '\n'; + } + + } + + inputCounts.close(); + outputCompare.close(); + outputCounts4.close(); + + // Extract relevant columns and add header + std::ifstream inputCounts4(tempfolder + ""/temp_counts4.txt""); + std::ofstream outputFinal(""""+ outpath + name + "".txt""); + + if (!inputCounts4.is_open() || !outputFinal.is_open()) { + Rcpp::Rcerr << ""Failed to open files."" << ""\n""; + return 1; + } + + outputFinal << ""chr\tpos\tdepth\tA\tC\tG\tT\n""; + + std::string countsLine; + while (std::getline(inputCounts4, countsLine)) { + + std::istringstream iss2(countsLine); + std::vector columns2; + std::string field2; + for (int i = 0; i < 7; ++i) { + std::getline(iss2, field2, '\t'); + if (i == 0 || i == 1 || i ==2 || i == 3 || i == 4 || i == 5 || i == 6) { + columns2.push_back(field2); + } + } + + // Write the extracted columns to the output file + for (const auto& column2 : columns2) { + outputFinal << column2 << '\t'; + } + outputFinal << '\n'; + } + + inputCounts4.close(); + outputFinal.close(); + + + // Remove Temporary Files + //std::remove(""temp/temp_counts.txt""); + // std::remove(""temp/temp_compare.txt""); + //std::remove(""temp/temp_counts4.txt""); + //std::remove(""temp/clean.mpileup""); + + Rcpp::Rcout << ""mpileup is now readable!."" << ""\n""; + + return 0; + } + +//' @title Prepare data - Step 1 +//' +//' @description This function transforms a BAM file into a text file. +//' Specifically, this function uses [samtools mpileup](http://www.htslib.org/doc/samtools-mpileup.html) +//' to translate your BAM into a tab-separated file. We then filter this file to remove indels and deletions. +//' When running this function, a temporary folder will be created (named 'temp/'), however this folder will be +//' removed once the process is complete. +//' +//' @details Warning, due to the processing time needed for samtools mpileup, +//' this step may take some time. This function also requires samtools to be located locally. Please see +//' our [Data Preparation](mlgaynor.com/nQuack/DataPreparation.html) article for more information. Warning, this writes a temporary folder +//' titled 'temp'. If you want to run multiple samples at once, we suggest you set the working directory to separate locations to ensure that +//' your temp folder/files are not overwritten. +//' +//' @param name File name without the suffix. For example, if your file is called ""frog.bam"", this input should be ""frog"". +//' @param inpath Location of input file. +//' @param outpath Location for output file. +//' @param tempfolder Location for temp folder. +//' +//' @returns Writes text file with the following columns: chromosome, position, depth, A, C, G, and T. +//' +// [[Rcpp::export]] +void prepare_data(std::string name, std::string inpath, std::string outpath, std::string tempfolder = ""temp"") { + std::string command1 = ""mkdir "" + tempfolder; + int result1 = system(command1.c_str()); + mpileF(name, inpath, tempfolder); + mainBashF(name, outpath, tempfolder); + std::string command2 = ""rm -rf "" + tempfolder; + int result2 = system(command2.c_str()); + std::string command3 =""perl -pi -e 's/\t\n/\n/g' -i "" + outpath + name + "".txt""; + int result3 = system(command3.c_str()); + if(result1 + result2 + result3 == 1){ + Rcpp::Rcout << ""done"" << ""\n""; + } +} +","C++" +"Allele","mgaynor1/nQuack","src/emshared.h",".h","961","29","#ifndef EMSHARED_H +#define EMSHARED_H + + +// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; + + +double exp_sum(const arma::vec v); +arma::vec mlogitcU(const arma::vec avec, const int nmixt); +double mlogitcD(const arma::vec avec, const int nmixt); +arma::vec invmlogitcA(const arma::vec betas); +arma::vec invmlogitcU(const arma::vec betas); +arma::vec invmlogitcD(const double betas); +double prob_unif_nq(double minfrac, double x); +arma::vec prob_unif_vec(arma::vec xi, int logit = 0); +arma::vec prob_unif_vec_bb(arma::vec xm, int logit = 0); +arma::vec alphabetacalcA(const double mu, const double var); +arma::vec mutransformA(const arma::vec mvec); +arma::vec mvecinA(const arma::vec mvec); +arma::vec stransformA(const arma::vec svec); +arma::vec svecinA(const arma::vec svec); +arma::vec dbetaV(arma::vec xi, double a, double b, int log); +arma::vec sampFT(std::string type, int m); +arma::vec sampFTBU(std::string type, int m); + +#endif +","Unknown" +"Allele","mgaynor1/nQuack","src/EMB3.cpp",".cpp","11747","376","// [[Rcpp::plugins(cpp11)]] +// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; +// [[Rcpp::depends(RcppProgress)]] +#include +#include ""emshared.h"" + + + +//' @title E-Step for Expectation Maximization - Beta + Beta + Beta Distribution +//' @description This is used in the `Bclean()` function. Here we complete +//' the E-Step and calculate the log-likelihood. Modifications include a correction for +//' the truncated distribution. +//' @param parmlist A list containing initial alpha, mean, and variance. +//' @param xi List of observations, in this case allele frequencies. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//[[Rcpp::export]] +Rcpp::List estepB3(const Rcpp::List parmlist, const arma::vec xi, + const arma::vec trunc){ + + const arma::vec avec = parmlist[""avec""]; + const arma::vec t1vec = parmlist[""t1vec""]; + const arma::vec t2vec = parmlist[""t2vec""]; + + const int m = avec.size(); + const int xl = xi.size(); + arma::mat zprob( xl, m ); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0){ + for(int i = 0; i < m; i++) { + arma::vec ppv = dbetaV(xi, t1vec(i), t2vec(i), 0); + zprob.col(i) = (avec(i) * ppv); + } + } else{ + for(int i = 0; i < m; i++) { + double F2F1 = (R::pbeta(trunc(1), t1vec(i), t2vec(i), 1, 0) - R::pbeta(trunc(0), t1vec(i), t2vec(i), 1, 0)); + arma::vec pp = dbetaV(xi, t1vec(i), t2vec(i),0); + pp = (pp/F2F1); + zprob.col(i) = (avec(i) * pp); + } + } + + arma::vec denom = arma::sum(zprob, 1); + + arma::mat zprobb( xl, m ); + for(int i = 0; i < m; i++){ + zprobb.col(i) = ( zprob.col(i) /denom ) ; + } + + Rcpp::List P = Rcpp::List::create( Rcpp::Named(""avec"") = avec, Rcpp::_[""t1vec""] = t1vec, Rcpp::_[""t2vec""] = t2vec); + return( Rcpp::List::create( Rcpp::_[""zprob""] = zprobb, Rcpp::_[""parm.list""] = P, Rcpp::_[""xi""] = xi, Rcpp::_[""denom""] = denom, Rcpp::_[""trunc""] = trunc)); + +} + +// Augmented Likelihood Calculation - beta Distribution +double llcalcB3(const arma::vec avec, const arma::vec t1vec, const arma::vec t2vec, + const int zcols, const arma::vec xi, const arma::mat zprob, + const arma::vec denom, const arma::vec trunc) { + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < zcols; i++){ + arma::vec right = lavec(i) + dbetaV(xi, t1vec(i), t2vec(i), 1); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < zcols; i++){ + double F2F1 = log(R::pbeta(trunc(1), t1vec(i), t2vec(i), 1, 0) - R::pbeta(trunc(0), t1vec(i), t2vec(i), 1, 0)); + arma::vec pp = (dbetaV(xi, t1vec(i), t2vec(i), 1)- F2F1); + arma::vec right = (lavec(i) + pp); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } + return sumit; +} + +// Augmented Likelihood Calculation - Beta Distribution +double lnlikecalcB3(const Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec t1vec = parmlist[""t1vec""]; + arma::vec t2vec = parmlist[""t2vec""]; + arma::mat Zprobsmat = eout[""zprob""]; + arma::vec xi = eout[""xi""]; + arma::vec denom = eout[""denom""]; + arma::vec trunc = eout[""trunc""]; + + const int zcols = avec.size(); + double lnlike = llcalcB3(avec, t1vec, t2vec, zcols, xi, Zprobsmat, denom, trunc); + return((lnlike*-1.0)); +} + +// MSTEP +/// Set up for optim +// Defining Ething class +class EthingB3 { +public: + vec xi; + int zcols; + mat zdata; + vec denom; + vec trunc; + EthingB3(vec xi, int zcols, mat zdata, vec denom, vec trunc) : xi(xi), zcols(zcols), zdata(zdata), denom(denom), trunc(trunc){} +}; + +// Defining the optim function +typedef double optimfn(int n, double *par, void *ex); + +// Numerical Optimization - Beta Distribution +// +// description This function is used in nnmin for numeric optimization +// which is necessary for expectation maximization to maximize the parameter values. +// param n Number of parameters in par. +// param par The parameters to be optimized. +// param ex Pointer containing all additional information needed. +// return Log likelihood. +double elnlikeB3(int n, double *par, void *ex) { + + EthingB3 *et = (EthingB3 *) ex; + + // zprobsmat + const int m = et ->zcols; + arma::mat zprob = et ->zdata; + + // xi + arma::vec xi = et ->xi; + + // denom + arma::vec denom = et -> denom; + + // trunc + arma::vec trunc = et -> trunc; + double tsum = (trunc(0) + trunc(1)); + + // myguess + arma::vec myguess(n); + for(int iy = 0; iy 2){ + guess(span(0,(m-2))) = mlogitcU(avec, m); + } else{ + guess(0) = mlogitcD(avec, m); + } + + + guess(span((m-1), ((m*2)-4))) = log(t1vec(span(0, m-3)) - 1.0); + guess((m*2)-3) = (log(t1vec(m-2)) - log(1.0 - t1vec(m-2)) ); + guess((m*2)-2) = (log(t1vec(m-1)) - log(1.0 - t1vec(m-1)) ); + + guess(span(((m*2)-1), ((m*3)-4))) = log(t2vec(span(0, m-3)) - 1.0); + guess((m*3)-3) = (log(t2vec(m-2)) - log(1.0 - t2vec(m-2)) ); + guess((m*3)-2) = (log(t2vec(m-1)) - log(1.0 - t2vec(m-1)) ); + + EthingB3 et(xi, m, Zprobsmat, denom, trunc); + + arma::vec vec(gl); + for(int nn = 0; nn < gl; nn++){ + vec(nn) = guess(nn); + } + + arma::vec opar(gl); + double Fmin = 0.0; + int fail = 0; + const double abstol = 1.0e-8; + const double intol = 1.0e-8; + const double alpha = 1.0; + const double beta = 0.5; + const double gamma = 2.0; + const int trace = 0; + int fncount = 0; + const int maxit = 500; + + nmmin(gl, vec.begin(), opar.begin(), &Fmin, + elnlikeB3, &fail, abstol, intol, &et, alpha, beta, + gamma, trace, &fncount, maxit); + + // Transform oparback + arma::vec oparback(gl); + for(int ou = 0; ou < gl; ou++){ + oparback(ou) = opar[ou]; + } + + arma::vec ahats(m); + arma::vec t1hats(m); + arma::vec t2hats(m); + + if(m == 2){ + ahats = invmlogitcD(oparback(0)); + }else{ + ahats = invmlogitcU(oparback(span(0, (m-2)))); + } + + t1hats(span(0, (m-3))) = (1.0 + exp(oparback(span((m-1), ((m*2)-4))))); + t1hats(m-2) =(1.0/(1.0 + exp(-1.0*oparback((m*2)-3)) )); + t1hats(m-1) =(1.0/(1.0 + exp(-1.0*oparback((m*2)-2)) )); + + t2hats(span(0, (m-3))) = (1.0 + exp(oparback(span(((m*2)-1), (gl-3))))); + t2hats(m-2) = (1.0/(1.0 + exp(-1.0*oparback(gl-2)) )); + t2hats(m-1) = (1.0/(1.0 + exp(-1.0*oparback(gl-1)) )); + + + Rcpp::List res = Rcpp::List::create(Rcpp::_[""avec""] = ahats, Rcpp::_[""t1vec""] = t1hats, Rcpp::_[""t2vec""] = t2hats); + return(res); +} + + +// Log-Likelihood for BIC +double llcalcfinalB3(Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec t1vec = parmlist[""t1vec""]; + arma::vec t2vec = parmlist[""t2vec""]; + arma::mat xi = eout[""xi""]; + arma::vec trunc = eout[""trunc""]; + + int n = avec.size(); + int xl = xi.size(); + + arma::mat mixit(xl, n); + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < n; i++){ + mixit.col(i) = (avec(i)*(dbetaV(xi, t1vec(i), t2vec(i), 0))); + } + }else{ + for(int i = 0; i < n; i++) { + double F2F1 = log(R::pbeta(trunc(1), t1vec(i), t2vec(i), 1, 0) - R::pbeta(trunc(0), t1vec(i), t2vec(i), 1, 0)); + arma::vec pp = (avec(i)*(dbetaV(xi, t1vec(i), t2vec(i), 0)));; + mixit.col(i) = (pp/F2F1); + } + } + + arma::vec sumrows = arma::sum(mixit, 1); + double sumit = sum(log(sumrows)); + return sumit; +} + + +//' @title Expectation maximization - Beta + Beta + Beta Distribution +//' +//' @description This function is made for the `Bclean()` function and preforms expectation maximization with Nelder-Mead +//' numerical optimization for beta distribution. +//' +//' @param parmlist A list containing initial alpha, mean, and variance. +//' @param xi Matrix where the first column is total coverage and the second is the count of base A or B. +//' @param niter Max number of iterates. +//' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +//' below this value, convergence is reached. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' +//' @returns List of elements including the negative log likelihood, the number of iterates, +//' and the optimized parameter values. +//' +//' +// [[Rcpp::export]] + Rcpp::List emstepB3(Rcpp::List parmlist, arma::vec xi, int niter, double epsilon, arma::vec trunc){ + Progress p(niter, true); + Rcpp::List mint = parmlist; + // E-step + Rcpp::List eint = estepB3(mint, xi, trunc); + double lnlikeint = lnlikecalcB3(eint); + + int count = 0; + + // Iterating E and M steps until convergence is below epsilon + for(int j = 0; j < (niter + 1); j++){ + count = count+1; + Rcpp::checkUserInterrupt(); + // M-step + Rcpp::List moutip = mstepB3(eint); + p.increment(); + + // E-step + Rcpp::List eoutip = estepB3(moutip, xi, trunc); + double lnlikeip = lnlikecalcB3(eoutip); + double deltalogL = (lnlikeint - lnlikeip); + deltalogL = std::abs(deltalogL); + + // Set next iter + eint = eoutip; + lnlikeint = lnlikeip; + + if(deltalogL niter){ + break; + } + } + + double llreturn = llcalcfinalB3(eint); + return Rcpp::List::create(Rcpp::_[""loglikelihood""] = llreturn, Rcpp::_[""negloglikelihood""] = lnlikeint, Rcpp::_[""parm.list""] = eint[""parm.list""], Rcpp::_[""niter.done""] = count, Rcpp::_[""pir""]=eint[""zprob""]); + } + + +","C++" +"Allele","mgaynor1/nQuack","src/betabinomial.cpp",".cpp","1747","61","// [[Rcpp::plugins(cpp11)]] +// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; + +#include ""extradistrbbd.h"" + +// t1vec calc +arma::mat t1veccalc(arma::vec mu, arma::vec var){ + vec y(mu.size(), fill::ones); + arma::vec t1vec = (( ( ( mu % (y - mu) ) / var ) - y) % mu); + return (t1vec); +} + +//t2vec +arma::mat t2veccalc(arma::vec mu, arma::vec var){ + vec y(mu.size(), fill::ones); + arma::vec t2vec = (( ( ( mu % (y - mu) ) / var ) - y) % (y - mu)); + return (t2vec); +} + +// dbbinomV +// param xm1 vector of x. +// param xm2 vector of size +// param t1 alpha +// param t2 beta +// param log logical; if TRUE, dbbinom is given as log. +arma::vec dbbinomV(arma::vec xm1, arma::vec xm2, const double t1, const double t2, bool log){ + + + Rcpp::NumericVector rxm1 = Rcpp::NumericVector(Rcpp::wrap(xm1)); + Rcpp::NumericVector rxm2 = Rcpp::NumericVector(Rcpp::wrap(xm2)); + Rcpp::NumericVector t1v = Rcpp::NumericVector::create(t1); + Rcpp::NumericVector t2v = Rcpp::NumericVector::create(t2); + + + Rcpp::NumericVector samp = cpp_dbbinom(rxm1, rxm2, t1v, t2v, log); + + arma::vec out = Rcpp::as(Rcpp::wrap(samp)); + return(out); +} + +// pbbinomV +// param ttxm vector of x. +// param xm2 vector of size +// param t1 alpha +// param t2 beta +arma::vec pbbinomV(arma::vec ttxm, arma::vec xm1, const double t1, const double t2){ + + Rcpp::NumericVector rttx = Rcpp::NumericVector(Rcpp::wrap(ttxm)); + Rcpp::NumericVector rxm1 = Rcpp::NumericVector(Rcpp::wrap(xm1)); + Rcpp::NumericVector t1v = Rcpp::NumericVector::create(t1); + Rcpp::NumericVector t2v = Rcpp::NumericVector::create(t2); + + + Rcpp::NumericVector samp = cpp_pbbinom(rttx, rxm1, t1v, t2v); + + arma::vec out = Rcpp::as(Rcpp::wrap(samp)); + return(out); +} +","C++" +"Allele","mgaynor1/nQuack","src/extradistrbbd.cpp",".cpp","6230","262","#include + +// [[Rcpp::interfaces(r, cpp)]] +// [[Rcpp::plugins(cpp11)]] + + +using Rcpp::NumericVector; + +// Note, this is not my code! extraDist +// https://github.com/twolodzko/extraDistr/blob/master/src/beta-binomial-distribution.cpp + +// https://github.com/twolodzko/extraDistr/blob/master/src/shared.h + +// MACROS + +#define GETV(x, i) x[i % x.length()] // wrapped indexing of vector +#define GETM(x, i, j) x(i % x.nrow(), j) // wrapped indexing of matrix +#define VALID_PROB(p) ((p >= 0.0) && (p <= 1.0)) + +// +// functions + +inline bool isInteger(double x, bool warn = true); + +//https://github.com/twolodzko/extraDistr/blob/master/src/shared.cpp + +inline bool isInteger(double x, bool warn) { + if (ISNAN(x)) + return false; + if (((x < 0.0) ? std::ceil(x) : std::floor(x)) != x) { + if (warn) { + char msg[55]; + std::snprintf(msg, sizeof(msg), ""non-integer: %f"", x); + Rcpp::warning(msg); + } + return false; + } + return true; +} + +// https://github.com/twolodzko/extraDistr/blob/master/src/shared_inline.h +inline bool is_large_int(double x) { + if (x > std::numeric_limits::max()) + return true; + return false; +} + +inline int to_pos_int(double x) { + if (x < 0.0 || ISNAN(x)) + Rcpp::stop(""value cannot be coerced to integer""); + if (is_large_int(x)) + Rcpp::stop(""value out of integer range""); + return static_cast(x); +} + +inline double to_dbl(int x) { + return static_cast(x); +} + + +// https://github.com/twolodzko/extraDistr/blob/master/src/beta-binomial-distribution.cpp + +// for dbbinom +inline double logpmf_bbinom(double k, double n, double alpha, + double beta, bool& throw_warning) { +#ifdef IEEE_754 + if (ISNAN(k) || ISNAN(n) || ISNAN(alpha) || ISNAN(beta)) + return k+n+alpha+beta; +#endif + if (alpha < 0.0 || beta < 0.0 || n < 0.0 || !isInteger(n, false)) { + throw_warning = true; + return NAN; + } + if (!isInteger(k) || k < 0.0 || k > n) + return R_NegInf; + // R::choose(n, k) * R::beta(k+alpha, n-k+beta) / R::beta(alpha, beta); + return R::lchoose(n, k) + R::lbeta(k+alpha, n-k+beta) - R::lbeta(alpha, beta); +} + +// for pbbinom +inline std::vector cdf_bbinom_table(double k, double n, + double alpha, double beta) { + + if (k < 0.0 || k > n || alpha < 0.0 || beta < 0.0) + Rcpp::stop(""inadmissible values""); + + int ik = to_pos_int(k); + std::vector p_tab(ik+1); + double nck, bab, gx, gy, gxy; + + bab = R::lbeta(alpha, beta); + gxy = R::lgammafn(alpha + beta + n); + + // k = 0 + + nck = 0.0; + gx = R::lgammafn(alpha); + gy = R::lgammafn(beta + n); + p_tab[0] = std::exp(nck + gx + gy - gxy - bab); + + if (ik < 1) + return p_tab; + + // k < 2 + + nck += std::log(n); + gx += std::log(alpha); + gy -= std::log(n + beta - 1.0); + p_tab[1] = p_tab[0] + std::exp(nck + gx + gy - gxy - bab); + + if (ik < 2) + return p_tab; + + // k >= 1 + + double dj; + + for (int j = 2; j <= ik; j++) { + if (j % 10000 == 0) + Rcpp::checkUserInterrupt(); + dj = to_dbl(j); + nck += std::log((n + 1.0 - dj)/dj); + gx += std::log(dj + alpha - 1.0); + gy -= std::log(n + beta - dj); + p_tab[j] = p_tab[j-1] + std::exp(nck + gx + gy - gxy - bab); + } + + return p_tab; +} + + +NumericVector cpp_dbbinom( + const NumericVector& x, + const NumericVector& size, + const NumericVector& alpha, + const NumericVector& beta, + const bool& log_prob = false + ) { + + if (std::min({x.length(), size.length(), + alpha.length(), beta.length()}) < 1) { + return NumericVector(0); + } + + int Nmax = std::max({ + x.length(), + size.length(), + alpha.length(), + beta.length() + }); + NumericVector p(Nmax); + + bool throw_warning = false; + + for (int i = 0; i < Nmax; i++) + p[i] = logpmf_bbinom(GETV(x, i), GETV(size, i), + GETV(alpha, i), GETV(beta, i), + throw_warning); + + if (!log_prob) + p = Rcpp::exp(p); + + if (throw_warning) + Rcpp::warning(""NaNs produced""); + + return p; +} + + +NumericVector cpp_pbbinom( + const NumericVector& x, + const NumericVector& size, + const NumericVector& alpha, + const NumericVector& beta, + const bool& lower_tail = true, + const bool& log_prob = false + ) { + + if (std::min({x.length(), size.length(), + alpha.length(), beta.length()}) < 1) { + return NumericVector(0); + } + + int Nmax = std::max({ + x.length(), + size.length(), + alpha.length(), + beta.length() + }); + NumericVector p(Nmax); + + bool throw_warning = false; + + std::map, std::vector> memo; + + // maximum modulo size.length(), bounded in [0, size] + int n = x.length(); + int k = size.length(); + NumericVector mx(k, 0.0); + for (int i = 0; i < std::max(n, k); i++) { + if (mx[i % k] < GETV(x, i)) { + mx[i % k] = std::min(GETV(x, i), GETV(size, i)); + } + } + + for (int i = 0; i < Nmax; i++) { + + if (i % 100 == 0) + Rcpp::checkUserInterrupt(); + +#ifdef IEEE_754 + if (ISNAN(GETV(x, i)) || ISNAN(GETV(size, i)) || + ISNAN(GETV(alpha, i)) || ISNAN(GETV(beta, i))) { + p[i] = GETV(x, i) + GETV(size, i) + GETV(alpha, i) + GETV(beta, i); + continue; + } +#endif + + if (GETV(alpha, i) <= 0.0 || GETV(beta, i) <= 0.0 || + GETV(size, i) < 0.0 || !isInteger(GETV(size, i), false)) { + throw_warning = true; + p[i] = NAN; + } else if (GETV(x, i) < 0.0) { + p[i] = 0.0; + } else if (GETV(x, i) >= GETV(size, i)) { + p[i] = 1.0; + } else if (is_large_int(GETV(x, i))) { + p[i] = NA_REAL; + Rcpp::warning(""NAs introduced by coercion to integer range""); + } else { + + std::vector& tmp = memo[std::make_tuple( + static_cast(i % size.length()), + static_cast(i % alpha.length()), + static_cast(i % beta.length()) + )]; + + if (!tmp.size()) { + // double mxi = std::min(mx[i % size.length()], GETV(size, i)); + tmp = cdf_bbinom_table(mx[i % size.length()], GETV(size, i), GETV(alpha, i), GETV(beta, i)); + } + p[i] = tmp[to_pos_int(GETV(x, i))]; + + } + } + + if (!lower_tail) + p = 1.0 - p; + + if (log_prob) + p = Rcpp::log(p); + + if (throw_warning) + Rcpp::warning(""NaNs produced""); + + return p; +} + + + + +","C++" +"Allele","mgaynor1/nQuack","src/betabinomial.h",".h","421","15","#ifndef BETABINOMIAL_h +#define BETABINOMIAL_h + +// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; + + +arma::mat t1veccalc(arma::vec mu, arma::vec var); +arma::mat t2veccalc(arma::vec mu, arma::vec var); +arma::vec dbbinomV(arma::vec xm1, arma::vec xm2, const double t1, const double t2, bool log); +arma::vec pbbinomV(arma::vec ttxm, arma::vec xm1, const double t1, const double t2); + +#endif +","Unknown" +"Allele","mgaynor1/nQuack","src/RcppExports.cpp",".cpp","15379","316","// Generated by using Rcpp::compileAttributes() -> do not edit by hand +// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#include ""../inst/include/nQuack.h"" +#include +#include +#include +#include + +using namespace Rcpp; + +#ifdef RCPP_USE_GLOBAL_ROSTREAM +Rcpp::Rostream& Rcpp::Rcout = Rcpp::Rcpp_cout_get(); +Rcpp::Rostream& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get(); +#endif + +// estepB3 +Rcpp::List estepB3(const Rcpp::List parmlist, const arma::vec xi, const arma::vec trunc); +RcppExport SEXP _nQuack_estepB3(SEXP parmlistSEXP, SEXP xiSEXP, SEXP truncSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< const arma::vec >::type xi(xiSEXP); + Rcpp::traits::input_parameter< const arma::vec >::type trunc(truncSEXP); + rcpp_result_gen = Rcpp::wrap(estepB3(parmlist, xi, trunc)); + return rcpp_result_gen; +END_RCPP +} +// emstepB3 +Rcpp::List emstepB3(Rcpp::List parmlist, arma::vec xi, int niter, double epsilon, arma::vec trunc); +RcppExport SEXP _nQuack_emstepB3(SEXP parmlistSEXP, SEXP xiSEXP, SEXP niterSEXP, SEXP epsilonSEXP, SEXP truncSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< arma::vec >::type xi(xiSEXP); + Rcpp::traits::input_parameter< int >::type niter(niterSEXP); + Rcpp::traits::input_parameter< double >::type epsilon(epsilonSEXP); + Rcpp::traits::input_parameter< arma::vec >::type trunc(truncSEXP); + rcpp_result_gen = Rcpp::wrap(emstepB3(parmlist, xi, niter, epsilon, trunc)); + return rcpp_result_gen; +END_RCPP +} +// emstepN +Rcpp::List emstepN(Rcpp::List parmlist, const arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type); +RcppExport SEXP _nQuack_emstepN(SEXP parmlistSEXP, SEXP xiSEXP, SEXP niterSEXP, SEXP epsilonSEXP, SEXP truncSEXP, SEXP typeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< const arma::vec >::type xi(xiSEXP); + Rcpp::traits::input_parameter< int >::type niter(niterSEXP); + Rcpp::traits::input_parameter< double >::type epsilon(epsilonSEXP); + Rcpp::traits::input_parameter< arma::vec >::type trunc(truncSEXP); + Rcpp::traits::input_parameter< std::string >::type type(typeSEXP); + rcpp_result_gen = Rcpp::wrap(emstepN(parmlist, xi, niter, epsilon, trunc, type)); + return rcpp_result_gen; +END_RCPP +} +// emstepNA +Rcpp::List emstepNA(Rcpp::List parmlist, const arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type); +RcppExport SEXP _nQuack_emstepNA(SEXP parmlistSEXP, SEXP xiSEXP, SEXP niterSEXP, SEXP epsilonSEXP, SEXP truncSEXP, SEXP typeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< const arma::vec >::type xi(xiSEXP); + Rcpp::traits::input_parameter< int >::type niter(niterSEXP); + Rcpp::traits::input_parameter< double >::type epsilon(epsilonSEXP); + Rcpp::traits::input_parameter< arma::vec >::type trunc(truncSEXP); + Rcpp::traits::input_parameter< std::string >::type type(typeSEXP); + rcpp_result_gen = Rcpp::wrap(emstepNA(parmlist, xi, niter, epsilon, trunc, type)); + return rcpp_result_gen; +END_RCPP +} +// emstepNU +Rcpp::List emstepNU(Rcpp::List parmlist, const arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type); +RcppExport SEXP _nQuack_emstepNU(SEXP parmlistSEXP, SEXP xiSEXP, SEXP niterSEXP, SEXP epsilonSEXP, SEXP truncSEXP, SEXP typeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< const arma::vec >::type xi(xiSEXP); + Rcpp::traits::input_parameter< int >::type niter(niterSEXP); + Rcpp::traits::input_parameter< double >::type epsilon(epsilonSEXP); + Rcpp::traits::input_parameter< arma::vec >::type trunc(truncSEXP); + Rcpp::traits::input_parameter< std::string >::type type(typeSEXP); + rcpp_result_gen = Rcpp::wrap(emstepNU(parmlist, xi, niter, epsilon, trunc, type)); + return rcpp_result_gen; +END_RCPP +} +// emstepNUA +Rcpp::List emstepNUA(Rcpp::List parmlist, const arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type); +RcppExport SEXP _nQuack_emstepNUA(SEXP parmlistSEXP, SEXP xiSEXP, SEXP niterSEXP, SEXP epsilonSEXP, SEXP truncSEXP, SEXP typeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< const arma::vec >::type xi(xiSEXP); + Rcpp::traits::input_parameter< int >::type niter(niterSEXP); + Rcpp::traits::input_parameter< double >::type epsilon(epsilonSEXP); + Rcpp::traits::input_parameter< arma::vec >::type trunc(truncSEXP); + Rcpp::traits::input_parameter< std::string >::type type(typeSEXP); + rcpp_result_gen = Rcpp::wrap(emstepNUA(parmlist, xi, niter, epsilon, trunc, type)); + return rcpp_result_gen; +END_RCPP +} +// emstepB +Rcpp::List emstepB(Rcpp::List parmlist, arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type); +RcppExport SEXP _nQuack_emstepB(SEXP parmlistSEXP, SEXP xiSEXP, SEXP niterSEXP, SEXP epsilonSEXP, SEXP truncSEXP, SEXP typeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< arma::vec >::type xi(xiSEXP); + Rcpp::traits::input_parameter< int >::type niter(niterSEXP); + Rcpp::traits::input_parameter< double >::type epsilon(epsilonSEXP); + Rcpp::traits::input_parameter< arma::vec >::type trunc(truncSEXP); + Rcpp::traits::input_parameter< std::string >::type type(typeSEXP); + rcpp_result_gen = Rcpp::wrap(emstepB(parmlist, xi, niter, epsilon, trunc, type)); + return rcpp_result_gen; +END_RCPP +} +// emstepBB +Rcpp::List emstepBB(Rcpp::List parmlist, arma::mat xm, int niter, double epsilon, arma::vec trunc, std::string type); +RcppExport SEXP _nQuack_emstepBB(SEXP parmlistSEXP, SEXP xmSEXP, SEXP niterSEXP, SEXP epsilonSEXP, SEXP truncSEXP, SEXP typeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< arma::mat >::type xm(xmSEXP); + Rcpp::traits::input_parameter< int >::type niter(niterSEXP); + Rcpp::traits::input_parameter< double >::type epsilon(epsilonSEXP); + Rcpp::traits::input_parameter< arma::vec >::type trunc(truncSEXP); + Rcpp::traits::input_parameter< std::string >::type type(typeSEXP); + rcpp_result_gen = Rcpp::wrap(emstepBB(parmlist, xm, niter, epsilon, trunc, type)); + return rcpp_result_gen; +END_RCPP +} +// emstepBBU +Rcpp::List emstepBBU(Rcpp::List parmlist, arma::mat xm, int niter, double epsilon, arma::vec trunc, std::string type); +RcppExport SEXP _nQuack_emstepBBU(SEXP parmlistSEXP, SEXP xmSEXP, SEXP niterSEXP, SEXP epsilonSEXP, SEXP truncSEXP, SEXP typeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< arma::mat >::type xm(xmSEXP); + Rcpp::traits::input_parameter< int >::type niter(niterSEXP); + Rcpp::traits::input_parameter< double >::type epsilon(epsilonSEXP); + Rcpp::traits::input_parameter< arma::vec >::type trunc(truncSEXP); + Rcpp::traits::input_parameter< std::string >::type type(typeSEXP); + rcpp_result_gen = Rcpp::wrap(emstepBBU(parmlist, xm, niter, epsilon, trunc, type)); + return rcpp_result_gen; +END_RCPP +} +// emstepBU +Rcpp::List emstepBU(Rcpp::List parmlist, arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type); +RcppExport SEXP _nQuack_emstepBU(SEXP parmlistSEXP, SEXP xiSEXP, SEXP niterSEXP, SEXP epsilonSEXP, SEXP truncSEXP, SEXP typeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< Rcpp::List >::type parmlist(parmlistSEXP); + Rcpp::traits::input_parameter< arma::vec >::type xi(xiSEXP); + Rcpp::traits::input_parameter< int >::type niter(niterSEXP); + Rcpp::traits::input_parameter< double >::type epsilon(epsilonSEXP); + Rcpp::traits::input_parameter< arma::vec >::type trunc(truncSEXP); + Rcpp::traits::input_parameter< std::string >::type type(typeSEXP); + rcpp_result_gen = Rcpp::wrap(emstepBU(parmlist, xi, niter, epsilon, trunc, type)); + return rcpp_result_gen; +END_RCPP +} +// alphabetacalc +arma::vec alphabetacalc(const double mu, const double var); +RcppExport SEXP _nQuack_alphabetacalc(SEXP muSEXP, SEXP varSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const double >::type mu(muSEXP); + Rcpp::traits::input_parameter< const double >::type var(varSEXP); + rcpp_result_gen = Rcpp::wrap(alphabetacalc(mu, var)); + return rcpp_result_gen; +END_RCPP +} +// alphabetacalcvec +arma::mat alphabetacalcvec(arma::vec mu, arma::vec var); +RcppExport SEXP _nQuack_alphabetacalcvec(SEXP muSEXP, SEXP varSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< arma::vec >::type mu(muSEXP); + Rcpp::traits::input_parameter< arma::vec >::type var(varSEXP); + rcpp_result_gen = Rcpp::wrap(alphabetacalcvec(mu, var)); + return rcpp_result_gen; +END_RCPP +} +// alphabetacalctau +arma::vec alphabetacalctau(const double mu, const double tau, const double error); +RcppExport SEXP _nQuack_alphabetacalctau(SEXP muSEXP, SEXP tauSEXP, SEXP errorSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const double >::type mu(muSEXP); + Rcpp::traits::input_parameter< const double >::type tau(tauSEXP); + Rcpp::traits::input_parameter< const double >::type error(errorSEXP); + rcpp_result_gen = Rcpp::wrap(alphabetacalctau(mu, tau, error)); + return rcpp_result_gen; +END_RCPP +} +// alphabetacalctauvec +arma::mat alphabetacalctauvec(arma::vec mu, const double tau, const double error); +RcppExport SEXP _nQuack_alphabetacalctauvec(SEXP muSEXP, SEXP tauSEXP, SEXP errorSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< arma::vec >::type mu(muSEXP); + Rcpp::traits::input_parameter< const double >::type tau(tauSEXP); + Rcpp::traits::input_parameter< const double >::type error(errorSEXP); + rcpp_result_gen = Rcpp::wrap(alphabetacalctauvec(mu, tau, error)); + return rcpp_result_gen; +END_RCPP +} +// prepare_data +void prepare_data(std::string name, std::string inpath, std::string outpath, std::string tempfolder); +RcppExport SEXP _nQuack_prepare_data(SEXP nameSEXP, SEXP inpathSEXP, SEXP outpathSEXP, SEXP tempfolderSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< std::string >::type name(nameSEXP); + Rcpp::traits::input_parameter< std::string >::type inpath(inpathSEXP); + Rcpp::traits::input_parameter< std::string >::type outpath(outpathSEXP); + Rcpp::traits::input_parameter< std::string >::type tempfolder(tempfolderSEXP); + prepare_data(name, inpath, outpath, tempfolder); + return R_NilValue; +END_RCPP +} +// resample_xm +arma::mat resample_xm(arma::mat xm, int n); +RcppExport SEXP _nQuack_resample_xm(SEXP xmSEXP, SEXP nSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< arma::mat >::type xm(xmSEXP); + Rcpp::traits::input_parameter< int >::type n(nSEXP); + rcpp_result_gen = Rcpp::wrap(resample_xm(xm, n)); + return rcpp_result_gen; +END_RCPP +} +// nQuire_reformat +NumericMatrix nQuire_reformat(NumericMatrix xm); +RcppExport SEXP _nQuack_nQuire_reformat(SEXP xmSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< NumericMatrix >::type xm(xmSEXP); + rcpp_result_gen = Rcpp::wrap(nQuire_reformat(xm)); + return rcpp_result_gen; +END_RCPP +} +// process_rcpp +NumericMatrix process_rcpp(NumericMatrix x, int mindepth, double maxprob, NumericVector trunc, double error); +RcppExport SEXP _nQuack_process_rcpp(SEXP xSEXP, SEXP mindepthSEXP, SEXP maxprobSEXP, SEXP truncSEXP, SEXP errorSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< NumericMatrix >::type x(xSEXP); + Rcpp::traits::input_parameter< int >::type mindepth(mindepthSEXP); + Rcpp::traits::input_parameter< double >::type maxprob(maxprobSEXP); + Rcpp::traits::input_parameter< NumericVector >::type trunc(truncSEXP); + Rcpp::traits::input_parameter< double >::type error(errorSEXP); + rcpp_result_gen = Rcpp::wrap(process_rcpp(x, mindepth, maxprob, trunc, error)); + return rcpp_result_gen; +END_RCPP +} + +// validate (ensure exported C++ functions exist before calling them) +static int _nQuack_RcppExport_validate(const char* sig) { + static std::set signatures; + if (signatures.empty()) { + } + return signatures.find(sig) != signatures.end(); +} + +// registerCCallable (register entry points for exported C++ functions) +RcppExport SEXP _nQuack_RcppExport_registerCCallable() { + R_RegisterCCallable(""nQuack"", ""_nQuack_RcppExport_validate"", (DL_FUNC)_nQuack_RcppExport_validate); + return R_NilValue; +} + +static const R_CallMethodDef CallEntries[] = { + {""_nQuack_estepB3"", (DL_FUNC) &_nQuack_estepB3, 3}, + {""_nQuack_emstepB3"", (DL_FUNC) &_nQuack_emstepB3, 5}, + {""_nQuack_emstepN"", (DL_FUNC) &_nQuack_emstepN, 6}, + {""_nQuack_emstepNA"", (DL_FUNC) &_nQuack_emstepNA, 6}, + {""_nQuack_emstepNU"", (DL_FUNC) &_nQuack_emstepNU, 6}, + {""_nQuack_emstepNUA"", (DL_FUNC) &_nQuack_emstepNUA, 6}, + {""_nQuack_emstepB"", (DL_FUNC) &_nQuack_emstepB, 6}, + {""_nQuack_emstepBB"", (DL_FUNC) &_nQuack_emstepBB, 6}, + {""_nQuack_emstepBBU"", (DL_FUNC) &_nQuack_emstepBBU, 6}, + {""_nQuack_emstepBU"", (DL_FUNC) &_nQuack_emstepBU, 6}, + {""_nQuack_alphabetacalc"", (DL_FUNC) &_nQuack_alphabetacalc, 2}, + {""_nQuack_alphabetacalcvec"", (DL_FUNC) &_nQuack_alphabetacalcvec, 2}, + {""_nQuack_alphabetacalctau"", (DL_FUNC) &_nQuack_alphabetacalctau, 3}, + {""_nQuack_alphabetacalctauvec"", (DL_FUNC) &_nQuack_alphabetacalctauvec, 3}, + {""_nQuack_prepare_data"", (DL_FUNC) &_nQuack_prepare_data, 4}, + {""_nQuack_resample_xm"", (DL_FUNC) &_nQuack_resample_xm, 2}, + {""_nQuack_nQuire_reformat"", (DL_FUNC) &_nQuack_nQuire_reformat, 1}, + {""_nQuack_process_rcpp"", (DL_FUNC) &_nQuack_process_rcpp, 5}, + {""_nQuack_RcppExport_registerCCallable"", (DL_FUNC) &_nQuack_RcppExport_registerCCallable, 0}, + {NULL, NULL, 0} +}; + +RcppExport void R_init_nQuack(DllInfo *dll) { + R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); + R_useDynamicSymbols(dll, FALSE); +} +","C++" +"Allele","mgaynor1/nQuack","src/ushared.cpp",".cpp","2957","106","// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; + +#include ""emshared.h"" + +// dnormV +// +// param xi Vector of doubles. +// param a Mean parameter. +// param b Standard deviation parameter +// param log Interger indicating to log or not to log. +// +// return Numeric vector from dbeta. +arma::vec dnormV(arma::vec xi, double a, double b, int log){ + int xil = xi.size(); + arma::vec out(xil); + for(int i = 0; i < xil; i++){ + out(i) = R::dnorm(xi(i), a, b, log); + //out(i) = (1/(b * sqrt(2*M_PI))) * exp( -( pow(xi(i) - a, 2) / (2 * pow(b, 2)) )); + } + return out; +} + +// Log-Likelihood for BIC - Normal +double llcalcfinalN(Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::vec xi = eout[""xi""]; + arma::vec trunc = eout[""trunc""]; + + const int m = mvec.size(); + int xl = xi.size(); + + arma::mat mixit(xl, m); + // double ua = 1.0 - sum(avec); + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < m; i++){ + mixit.col(i) = avec(i)*(dnormV(xi, mvec(i), svec(i), 0)); + } + }else{ + for(int i = 0; i < m; i++) { + double F2F1 = R::pnorm(trunc(1), mvec(i), svec(i), 1, 0) - R::pnorm(trunc(0), mvec(i), svec(i), 1, 0); + arma::vec pp = (avec(i)*dnormV(xi, mvec(i), svec(i), 0)); + mixit.col(i) = (pp/F2F1); + } + } + + // Uniform distribution + //mixit.col(m) = (avec(m)*prob_unif_vec(xi)); + + arma::vec sumrows = arma::sum(mixit, 1); + if(all(sumrows) == false){ //if all are non.zero = false + for(int i = 0; i < xl; i++){ + if(sumrows(i) == 0){ + sumrows(i) = DBL_MIN; + } + } + } + double sumit = sum(log(sumrows)); + return sumit; +} + +// Log-Likelihood for BIC - Normal + Uniform +double llcalcfinalNU(Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::vec xi = eout[""xi""]; + arma::vec trunc = eout[""trunc""]; + + const int m = mvec.size(); + int xl = xi.size(); + + arma::mat mixit(xl, (m+1)); + // double ua = 1.0 - sum(avec); + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < m; i++){ + mixit.col(i) = avec(i)*(dnormV(xi, mvec(i), svec(i), 0)); + } + }else{ + for(int i = 0; i < m; i++) { + double F2F1 = R::pnorm(trunc(1), mvec(i), svec(i), 1, 0) - R::pnorm(trunc(0), mvec(i), svec(i), 1, 0); + arma::vec pp = (avec(i)*dnormV(xi, mvec(i), svec(i), 0)); + mixit.col(i) = (pp/F2F1); + } + } + + // Uniform distribution + mixit.col(m) = (avec(m)*prob_unif_vec(xi)); + + arma::vec sumrows = arma::sum(mixit, 1); + if(all(sumrows) == false){ //if all are non.zero = false + for(int i = 0; i < xl; i++){ + if(sumrows(i) == 0){ + sumrows(i) = DBL_MIN; + } + } + } + double sumit = sum(log(sumrows)); + return sumit; +} +","C++" +"Allele","mgaynor1/nQuack","src/EMbetabinomialuniform.cpp",".cpp","15898","476","// [[Rcpp::plugins(cpp11)]] +// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; + +#include ""emshared.h"" +#include ""extradistrbbd.h"" +#include ""betabinomial.h"" + + + +// title E-Step for Expectation Maximization - Beta-Binomial+Uniform Distribution +// description This function is used in expectation maximization. Here we complete +// the E-Step and calculate the log-likelihood. Modifications include a correction for +// the truncated distribution. +// param parmlist A list containing initial alpha, $theta_{1}$, and $theta_{2}$ values. +// param xm Matrix where the first column is total coverage and the second is the count of base A or B. +// param type String indicating ""Free"" or ""Fixed"". +// param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +// return A list with the following elements: +// \item logL: Log-likelihood of the mixture model. +// \item Zprobs.mat: Matrix where rows represent data points and columns represent each +// mixture model. Observations are the scaled probability of each data point belonging +// to each mixture model. +// \item Sj.vec: A vector of column sums for each mixture model. +// \item parm.list: Supplied list containing initial alpha, mu, and sigma values. +// \item xm: Matrix of coverage and sequencing depth at a site. +Rcpp::List estepBBU(const Rcpp::List parmlist, const arma::mat xm, std::string type, + const arma::vec trunc){ + + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + + arma::vec t1vec = t1veccalc(mvec, svec); + arma::vec t2vec = t2veccalc(mvec, svec); + + const int m = mvec.size(); + const int xl = xm.n_rows; + arma::mat zprob( xl, (m+1) ); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0){ + for(int i = 0; i < m; i++) { + arma::vec ppv = dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), false); + zprob.col(i) = (avec(i) * ppv); + } + } else{ + for(int i = 0; i < m; i++) { + arma::vec F2F1 = pbbinomV((xm.col(0)*trunc(1)), xm.col(0), t1vec(i), t2vec(i)) - pbbinomV((xm.col(0)*trunc(0)), xm.col(0), t1vec(i), t2vec(i)); + arma::vec pp = dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), false); + pp = (pp/F2F1); + zprob.col(i) = (avec(i) * pp); + } + } + + //Uniform distribution + double avecsum = sum(avec(span(0, (m-1)))); + double ae = (1.0 - avecsum); + zprob.col(m) = (ae*prob_unif_vec_bb(xm.col(0))); + + arma::vec denom = arma::sum(zprob, 1); + + arma::mat zprobb( xl, (m+1) ); + for(int i = 0; i < (m+1); i++){ + zprobb.col(i) = ( zprob.col(i) /denom ); + } + + Rcpp::List P = Rcpp::List::create( Rcpp::Named(""avec"") = avec, Rcpp::_[""mvec""] = mvec, Rcpp::_[""svec""] = svec); + return( Rcpp::List::create( Rcpp::_[""zprob""] = zprobb, Rcpp::_[""parm.list""] = P, Rcpp::_[""xm""] = xm, Rcpp::_[""denom""] = denom, Rcpp::_[""trunc""] = trunc, Rcpp::_[""type""]=type )); + +} + +// Augmented Likelihood Calculation - Beta-Binomial-Uniform Distribution +double llcalcBBU(const arma::vec avec, const arma::vec t1vec, const arma::vec t2vec, + const int zcols, const arma::mat xm, const arma::mat zprob, + const arma::vec denom, const arma::vec trunc) { + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < (zcols-1); i++){ + arma::vec right = lavec(i) +(dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), true)); + arma::vec left = zprob.col(i); + + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < (zcols-1); i++){ + arma::vec F2F1 = log(pbbinomV((xm.col(0)*trunc(1)), xm.col(0), t1vec(i), t2vec(i)) - pbbinomV((xm.col(0)*trunc(0)), xm.col(0), t1vec(i), t2vec(i))); + arma::vec pp = (dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), true) - F2F1); + arma::vec right = (lavec(i) + pp); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } + // Add uniform + double ae = lavec(zcols-1); + sumit += sum(zprob.col(zcols-1) % (ae+prob_unif_vec_bb(xm.col(0), 1))); + + return sumit; +} + +// Augmented Likelihood Calculation - Continued +double lnlikecalcBBU(const Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::mat Zprobsmat = eout[""zprob""]; + arma::mat xm = eout[""xm""]; + arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + arma::vec trunc = eout[""trunc""]; + + arma::vec t1vec = t1veccalc(mvec, svec); + arma::vec t2vec = t2veccalc(mvec, svec); + + const int zcols = avec.size(); + + double lnlike = llcalcBBU(avec, t1vec, t2vec, zcols, xm, Zprobsmat, denom, trunc); + return((lnlike*-1.0)); +} + + +// MSTEP +/// Set up for optim +// Defining Ething class +class EthingBB { +public: + mat xm; + int zcols; + mat zdata; + vec denom; + vec trunc; + vec parms; + int pl; + int flag; + + EthingBB(mat xm, int zcols, mat zdata, vec denom, vec trunc, vec parms, int pl, int flag) : xm(xm), zcols(zcols), zdata(zdata), denom(denom), trunc(trunc), parms(parms), pl(pl), flag(flag) {} +}; + + + // Defining the optim function + typedef double optimfn(int n, double *par, void *ex); + +// Numerical Optimization - Beta-Binomial+Uniform Distribution +// description This function is used in nnmin for numeric optimization +// which is necessary for expectation maximization to maximize the parameter values. +// param n Number of parameters in par. +// param par The parameters to be optimized. +// param ex Pointer containing all additional information needed. +// return Log likelihood. + double elnlikeBBU(int n, double *par, void *ex) { + + EthingBB *et = (EthingBB *) ex; + + // zprobsmat + const int nmixt = et ->zcols; + arma::mat zprob = et ->zdata; + const int m = (nmixt - 1); + // xi + arma::mat xm = et ->xm; + + // denom + arma::vec denom = et -> denom; + + // trunc + arma::vec trunc = et -> trunc; + double tsum = (trunc(0) + trunc(1)); + + // myguess + arma::vec myguess(n); + for(int iy = 0; iyflag; + + if(flag == 0){ + avec = invmlogitcU(myguess(span(0, (m-1)))); + mvec = mutransformA(myguess(span(m, ((m*2)-1)))); + svec = stransformA(myguess(span((m*2), (n-1)))); + }else if(flag == 1){ //alpha-free + avec = invmlogitcU(myguess(span(0, (m-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + mvec = parms(span(0, (m-1))); + svec = parms(span(m, (pl-1))); + }else if(flag == 2){ //alpha-variance-free + avec = invmlogitcU(myguess(span(0, (m-1)))); + svec = stransformA(myguess(span(m, (n-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + mvec = parms(span(0, pl-1)); + } else if(flag == 3){ //variance free + svec = stransformA(myguess(span(0, (m-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + avec = parms(span(0, m)); + mvec = parms(span(m+1, pl-1)); + } + + arma::vec t1vec = t1veccalc(mvec, svec); + arma::vec t2vec = t2veccalc(mvec, svec); + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(tsum == 0){ + for(int i = 0; i < m; i++){ + arma::vec right = lavec(i) +(dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), true)); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < m; i++){ + arma::vec F2F1 = log(pbbinomV((xm.col(0)*trunc(1)), xm.col(0), t1vec(i), t2vec(i)) - pbbinomV((xm.col(0)*trunc(0)), xm.col(0), t1vec(i), t2vec(i))); + arma::vec pp = (dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), true) - F2F1); + arma::vec right = (lavec(i) + pp); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + + } + } + + + // Add uniform + double ae = lavec(m); + sumit += sum(zprob.col(m) % (ae+prob_unif_vec_bb(xm.col(0), 1))); + + + //Rcpp::Rcout << sumit << std::endl; + return(sumit*(-1.0)); + } + + +// Defining elnlikeB as an optim function +optimfn elnlikeBBU; + +// Setting up nmmin +extern ""C"" { + void nmmin(int n, double *xin, double *x, double *Fmin, optimfn fn, + int *fail, double abstol, double intol, void *ex, + double alpha, double beta, double gamma, int trace, + int *fncount, int maxit); +} + +// M-Step with Numerical Optimization for Expectation Maximization - Beta-Binomial+Uniform Distribution +// +// description This function is used in expectation maximization to maximize the parameter values. +// param eout List with output from the estep +// param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$.] +Rcpp::List mstepBBU(Rcpp::List eout){ + + const Rcpp::List parmlist = eout[""parm.list""]; + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + const arma::mat Zprobsmat = eout[""zprob""]; + const arma::mat xm = eout[""xm""]; + const arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + const arma::vec trunc = eout[""trunc""]; + + const int nmixt = avec.size(); + const int m = mvec.size(); + + arma::vec fgp = sampFTBU(type, m); + int flag = fgp(0); + int gl = fgp(1); + int pl = fgp(2); + + arma::vec guess(gl); + arma::vec parms(pl); + + if(flag == 0){ + parms(0) = 0; + guess(span(0,(m-1))) = mlogitcU(avec, nmixt); + guess(span(m, ((m*2)-1))) = mvecinA(mvec); + guess(span((m*2), (gl-1))) = svecinA(svec); + }else if(flag == 1){ //alpha + guess(span(0, (m-1))) = mlogitcU(avec, nmixt); + parms(span(0, (m-1))) = mvec; + parms(span(m, (pl-1))) = svec; + } else if(flag == 2){ //both + guess(span(0,(m-1))) = mlogitcU(avec, nmixt); + guess(span(m, (gl-1))) = svecinA(svec); + parms(span(0, (m-1))) = mvec; + + } else if(flag == 3){ + guess(span(0,(m-1))) = svecinA(svec); + + parms(span(0, m)) = avec; + parms(span((m+1), (pl-1))) = mvec; + } + + EthingBB et(xm, nmixt, Zprobsmat, denom, trunc, parms, pl, flag); + + arma::vec vec(gl); + for(int nn = 0; nn < gl; nn++){ + vec(nn) = guess(nn); + } + + arma::vec opar(gl); + double Fmin = 0.0; + int fail = 0; + const double abstol = 1.0e-8; + const double intol = 1.0e-8; + const double alpha = 1.0; + const double beta = 0.5; + const double gamma = 2.0; + const int trace = 0; + int fncount = 0; + const int maxit = 500; + + nmmin(gl, vec.begin(), opar.begin(), &Fmin, + elnlikeBBU, &fail, abstol, intol, &et, alpha, beta, + gamma, trace, &fncount, maxit); + + // Transform oparback + arma::vec oparback(gl); + for(int ou = 0; ou < gl; ou++){ + oparback(ou) = opar[ou]; + } + + arma::vec ahats(m+1); + arma::vec mhats(m); + arma::vec shats(m); + + if(flag == 0){ + ahats = invmlogitcU(oparback(span(0, (m-1)))); + mhats = mutransformA(oparback(span(m, ((m*2)-1)))); + shats = stransformA(oparback(span((m*2), (gl-1)))); + }else if(flag == 1){ + ahats = invmlogitcU(oparback(span(0, (m-1)))); + mhats = mvec; + shats = svec; + } else if(flag == 2){ + ahats = invmlogitcU(oparback(span(0, (m-1)))); + shats = stransformA(oparback(span(m, (gl-1)))); + mhats = mvec; + + } else if(flag == 3){ + shats = stransformA(oparback(span(0, (m-1)))); + ahats = avec; + mhats = mvec; + } + + // Logic check + // Logic check + double acheck = ::Rf_fround(arma::min(ahats), 6); + if(ahats.has_nan() == true || all(ahats) == false || all(acheck) == false ){ //if all are non.zero = false + ahats = avec; + } + if(shats.has_nan() == true || all(shats) == false ){ //if all are non.zero = false + shats = svec; + } + if(mhats.has_nan() == true || all(mhats) == false){ + mhats = mvec; + } + + + Rcpp::List res = Rcpp::List::create(Rcpp::_[""avec""] = ahats, Rcpp::_[""mvec""] = mhats, Rcpp::_[""svec""] = shats); + return(res); + } + + +// Log-Likelihood for BIC +double llcalcfinalBBU(Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::mat xm = eout[""xm""]; + arma::vec trunc = eout[""trunc""]; + + arma::vec t1vec = t1veccalc(mvec, svec); + arma::vec t2vec = t2veccalc(mvec, svec); + + int m = mvec.size(); + int xl = xm.n_rows; + + arma::mat mixit(xl, (m+1)); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < m; i++){ + mixit.col(i) = (avec(i)*dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i),false)); + } + }else{ + for(int i = 0; i < m; i++) { + arma::vec F2F1 = (pbbinomV((xm.col(0)*trunc(1)), xm.col(0), t1vec(i), t2vec(i)) - pbbinomV((xm.col(0)*trunc(0)), xm.col(0), t1vec(i), t2vec(i))); + arma::vec pp = (avec(i)*dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), false)); + mixit.col(i) = (pp/F2F1); + } + } + // Add Uniform Mixture + mixit.col(m) = (avec(m)*prob_unif_vec_bb(xm.col(0))); + + arma::vec sumrows = arma::sum(mixit, 1); + if(all(sumrows) == false){ //if all are non.zero = false + for(int i = 0; i < xl; i++){ + if(sumrows(i) == 0){ + sumrows(i) = DBL_MIN; + } + } + } + + //arma::vec sumrows = arma::sum(mixit, 1); + double sumit = sum(log(sumrows)); + return sumit; +} + +//' @title Expectation maximization - Beta-Binomial and Uniform Distributions +//' +//' @description This function calculates the log-likelihood using +//' the expectation-maximization algorithm with Nelder-Mead numerical optimization +//' and beta distribution with one uniform mixture. +//' +//' @param parmlist A list containing initial alpha, mean, and variance values. +//' @param xm Matrix where the first column is total coverage and the second is the count of base A or B. +//' @param niter Max number of iterates. +//' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +//' below this value, convergence is reached. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +//' ""fixed-2"" (estimated parameter(s): alpha and variance), or ""fixed-3"" (estimated parameter(s): variance). +//' If avec is length of 1, fixed and fixed-3 will not be able to return a log-likelihood. +//' +//' @returns List of elements including the log likelihood, the negative log likelihood, the number of iterates, +//' and the optimized parameter values. +//' +// [[Rcpp::export]] +Rcpp::List emstepBBU(Rcpp::List parmlist, arma::mat xm, int niter, double epsilon, arma::vec trunc, std::string type = ""free""){ + // Set up progress + // Progress p(niter, true); + + Rcpp::List mint = parmlist; + // E-step + Rcpp::List eint = estepBBU(mint, xm, type, trunc); + double lnlikeint = lnlikecalcBBU(eint); + + int count = 0; + // Iterating E and M steps until convergence is below epsilon + for(int j = 0; j < (niter + 1); j++){ + Rcpp::checkUserInterrupt(); + //p.increment(); + count = count + 1; + + // M-step + Rcpp::List moutip = mstepBBU(eint); + + // E-step + Rcpp::List eoutip = estepBBU(moutip, xm, type, trunc); + double lnlikeip = lnlikecalcBBU(eoutip); + double deltalogL = (lnlikeint - lnlikeip); + deltalogL = std::abs(deltalogL); + + // Set next iter + eint = eoutip; + lnlikeint = lnlikeip; + + if(deltalogL +using namespace Rcpp; + +// Counts A, C, G, and T +// +// param x Matrix with five columns: Depth, A, C, G, and T. +// +// return Logical Vector indicating where the depth and total count are equal. +LogicalVector countACGTrcpp(NumericMatrix x) { + int dfrows = x.nrow(); + int dfcols = x.ncol(); + NumericVector ACGTcount(dfrows); + LogicalVector ACGTcountlog(dfrows); + for( int i = 0; i < dfrows; i++){ + double tempcount = 0; + for(int j = 1; j < dfcols; j++){ + tempcount+= x(i, j); + } + ACGTcount(i) = tempcount; + ACGTcountlog(i) = ACGTcount(i) == x(i, 0); + } + return(ACGTcountlog); +} + +// Classifies Type +// +// param x Matrix with five columns: Depth, A, C, G, and T. +// +// return Logical Vector indicating where type = 2, or only counts for two nucleotides is detected. +LogicalVector typeACGTrcpp(NumericMatrix x) { + int dfrows = x.nrow(); + int dfcols = x.ncol(); + NumericVector ACGTtype(dfrows); + + for( int i = 0; i < dfrows; i++){ + double tempcount = 0; + for(int j = 1; j < dfcols; j++){ + double obs = x(i, j); + if(obs != 0){ + tempcount++; + } + } + ACGTtype(i) = tempcount; + } + LogicalVector ACGTtypelog = ACGTtype == 2; + return(ACGTtypelog); +} + +// Depth filter +// +// param x Matrix with five columns: Depth, A, C, G, and T. +// param mindepth Minimum depth, default = 15. +// param maxprob Maximum depth quantile cut off, default = 0.9. +// +// return Logical Vector indicating where depth fits the cut off standards +LogicalVector depthfilter(NumericMatrix xy, int mindepth, double maxprob){ + NumericVector x = xy( _ , 0 ); + Environment stats(""package:stats""); + Function quantile = stats[""quantile""]; + double maxdepth = as(quantile(x, maxprob)); + LogicalVector lx = ((x >= mindepth) & (x <= maxdepth)); + return(lx); +} + +// Logical Vector Sum +// +// param a Logical Vector indicating where the depth and total count are equal. +// param b Logical Vector indicating where type = 2, or only counts for two nucleotides is detected. +// param c Logical Vector indicating where depth fits the cut off standards. +// +// return Numeric Vector equal to the sum of the three logical vectors. +NumericVector addlogic(LogicalVector a, LogicalVector b, LogicalVector c){ + int n = a.size(); + NumericVector abcsum(n); + for( int i = 0; i < n; i++){ + abcsum(i) = (a(i) + b(i) + c(i)); + } + return(abcsum); +} + +// Filters Numeric Matrix - EW Goolsby +// +// @param X input matrix. +// @param Logical Vector indicating if each row fulfills the condition. +// +// @return Numeric matrix filtered to only rows that fulfill the condition. +NumericMatrix submat_rcpp(NumericMatrix X, LogicalVector condition) { + int n=X.nrow(); + int k=X.ncol(); + NumericMatrix out(sum(condition),k); + for (int i = 0, j = 0; i < n; i++) { + if(condition[i]) { + out(j,_) = X(i,_); + j = j+1; + } + } + return(out); +} + + +// Calculates and sums the three logical vectors +// +// @param x Matrix with five columns: Depth, A, C, G, and T. +// @param mindepth Minimum depth, default = 15. +// @param maxprob Maximum depth quantile cut off, default = 0.9. +// +// @return Numeric Vector equal to the sum of the three logical vectors. +NumericVector firstfilter(NumericMatrix x, int mindepth, double maxprob){ + LogicalVector log1 = depthfilter(x, mindepth, maxprob); + LogicalVector log2 = typeACGTrcpp(x); + LogicalVector log3 = countACGTrcpp(x); + NumericVector abc = addlogic(log1, log2, log3); + return(abc); +} + + +// Make three columns +// +// @param x Matrix with total coverage, coverage of A, coverage of T, coverage of C, and coverage of G +NumericMatrix makethreecolumns(NumericMatrix x){ + int dfrows = x.nrow(); + NumericMatrix xy(dfrows, 3); + for(int i = 0; i < dfrows; i++){ + NumericVector y = x(i,_); + // Rcout << y << std::endl; + std::sort(y.begin(), y.end(), std::greater()); + //Rcout << y << std::endl; + xy(i, _) = y; + } + return(xy); +} + +// Filter by Sequencing Error Rate +// +// @param x Matrix with total coverage, coverage of allele A, and coverage of allele B. +// @param error Sequencing error rate. +// +NumericMatrix errorfilter(NumericMatrix x, double error){ + if(error != 0.0){ + int dfrows = x.nrow(); + + LogicalMatrix refaltlog(dfrows, 2); + NumericVector refaltsum(dfrows); + for(int i = 0; i < dfrows; i++){ + NumericVector y = x(i, _); + double lowend = (error*y(0)); + double highend = ((1-error)*y(0)); + refaltlog(i, 0) = (y(1) > lowend && y(1) < highend); + refaltlog(i, 1) = (y(2) > lowend && y(2) < highend) ; + refaltsum(i) = refaltlog(i, 0) + refaltlog(i, 1); + } + LogicalVector logicvec = refaltsum == 2; + + NumericMatrix table = submat_rcpp(x, logicvec); + return table; + + } else{ + return x; + } + + } + +// Calculates allele frequencies for ref/alt bases +// +// @param x Matrix with three columbs: Total Coverage, Allele A, Allele B. +// +// @return List including a two column matrix of allele frequencies and a logical vector indicating +// if the allele frequencies are less than 0.9, but greater than 0.1. +NumericMatrix refaltcalc(NumericMatrix x, NumericVector trunc){ + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) != 0.0){ + int dfrows = x.nrow(); + + + NumericMatrix refalt(dfrows, 2); + for(int i = 0; i < dfrows; i++){ + NumericVector y = x(i, _); + refalt(i, 0) = (y(1)/y(0)); + refalt(i, 1) = (y(2)/y(0)); + } + + LogicalMatrix refaltlog(dfrows, 2); + NumericVector refaltsum(dfrows); + for(int i = 0; i < dfrows; i++){ + NumericVector y = x(i, _); + refaltlog(i, 0) = (refalt(i, 0) >= trunc[0] && refalt(i, 0) <= trunc[1]); + refaltlog(i, 1) = (refalt(i, 1) >= trunc[0] && refalt(i, 1) <= trunc[1]) ; + refaltsum(i) = refaltlog(i, 0) + refaltlog(i, 1); + } + LogicalVector logicvec = refaltsum == 2; + NumericMatrix ready = submat_rcpp(x, logicvec); + return(ready); + } else{ + return(x); + } + +} + +// Samples the reference or alternative allele frequency at every site. +// +// @param x Matrix with two columns: ref and alt. +// +// @return Numeric vector with one allele frequency per site +NumericMatrix samplefreq(NumericMatrix x){ + int dfrows = x.nrow(); + NumericMatrix freqsamp(dfrows, 2); + for(int i = 0; i < dfrows; i++){ + freqsamp(i, 0) = x(i, 0); + NumericVector y(2); + y[0] = x(i,1); + y[1] = x(i,2); + NumericVector prob = NumericVector::create(0.5, 0.5); + double samp = as(sample(y, 1, false, prob)); + freqsamp(i, 1) = samp; + } + return(freqsamp); +} + + +//' @name process_rcpp +//' @title Data Preparation - Matrix Filtering +//' @description Based on supplied matrix with total depth and sequencing coverage for each +//' nucleotide (A, C, G, and T) this function remove all but single nucelotide polymorphisms. +//' When supplied, this function will filter on coverage or allele frequency. Finally, the function +//' samples a single allele frequency per site to avoid data duplication. +//' +//' @param x Matrix with five columns: Depth, A, C, G, and T. +//' @param mindepth Minimum depth, default = 15. +//' @param maxprob Maximum depth quantile cut off, default = 0.9. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' @param error Sequencing error rate. +//' +//' @return Numeric Matrix with total coverage and coverage for a randomly sampled allele. +//' +// [[Rcpp::export]] +NumericMatrix process_rcpp(NumericMatrix x, int mindepth, double maxprob, NumericVector trunc, double error) { + NumericVector logicsum = firstfilter(x, mindepth, maxprob); + LogicalVector condition = logicsum == 3; + NumericMatrix out = submat_rcpp(x, condition); + NumericMatrix cout = makethreecolumns(out); + NumericMatrix cond = errorfilter(cout, error); + NumericMatrix condount = refaltcalc(cond, trunc); + NumericMatrix ready = samplefreq(condount); + return(ready); +} +","C++" +"Allele","mgaynor1/nQuack","src/EMNormalUniformAugmented.cpp",".cpp","8805","264","// [[Rcpp::plugins(cpp11)]] +// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; + +#include ""emshared.h"" +#include ""ushared.h"" +#include + + + +// title E-Step for Expectation Maximization - Normal + Uniform Distribution - Same as EMNormalUniform.cpp +// description This function is used in expectation maximization. Here we complete +// the E-Step and calculate the log-likelihood. Modifications include a correction for +// the truncated distribution. +Rcpp::List estepNUA(const Rcpp::List parmlist, const arma::vec xi, std::string type, + const arma::vec trunc){ + + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + + const int m = mvec.size(); + + //int pl = (n == m ? 1 : 2); + + const int xl = xi.size(); + arma::mat zprob( xl, (m+1) ); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0){ + for(int i = 0; i < m; i++) { + arma::vec ppv = dnormV(xi, mvec(i), svec(i), 0); + zprob.col(i) = (avec(i) * ppv); + } + } else{ + for(int i = 0; i < m; i++) { + double F2F1 = R::pnorm(trunc(1), mvec(i), svec(i), 1, 0) - R::pnorm(trunc(0), mvec(i), svec(i), 1, 0); + arma::vec pp = dnormV(xi, mvec(i), svec(i), 0); + pp = (pp/F2F1); + zprob.col(i) = (avec(i) * pp); + } +} + + // Uniform distribution + double avecsum = 0.00; + for(int i = 0; i < m; i++){ + avecsum += avec(i); + } + + double ae = (1 - avecsum); + zprob.col(m) = (ae*prob_unif_vec(xi)); + + arma::vec denom = arma::sum(zprob, 1); + + arma::mat zprobb( xl, m+1 ); + arma::vec sjvec(m+1); + for(int i = 0; i < m+1; i++){ + zprobb.col(i) = ( zprob.col(i) /denom ) ; + sjvec(i) = sum(zprobb.col(i)); + } + double ll = sum(log(denom)); + + Rcpp::List P = Rcpp::List::create( Rcpp::Named(""avec"") = avec, Rcpp::_[""mvec""] = mvec, Rcpp::_[""svec""] = svec); + return( Rcpp::List::create( Rcpp::_[""zprob""] = zprobb, Rcpp::_[""parm.list""] = P, Rcpp::_[""xi""] = xi, Rcpp::_[""denom""] = denom, Rcpp::_[""trunc""] = trunc, Rcpp::_[""type""]=type, Rcpp::_[""sjvec""]=sjvec, Rcpp::_[""LL""]=ll)); + +} + +// Augmented Likelihood Calculation - Normal-Uniform Distribution +double llcalcNUA(const arma::vec avec, const arma::vec mvec, const arma::vec svec, + const int zcols, const arma::vec xi, const arma::mat zprob, + const arma::vec denom, const arma::vec trunc) { + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + + for(int i = 0; i < (zcols-1); i++){ + arma::vec right = (lavec(i) +(dnormV(xi, mvec(i), svec(i), 1))); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < (zcols-1); i++){ + double F2F1 = log(R::pnorm(trunc(1), mvec(i), svec(i), 1, 0) - R::pnorm(trunc(0), mvec(i), svec(i), 1, 0)); + arma::vec right = (lavec(i) +((dnormV(xi, mvec(i), svec(i), 1))-F2F1)); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } + + // Add uniform + double ae = lavec(zcols-1); + sumit += sum(zprob.col(zcols-1) % (ae+prob_unif_vec(xi, 1))); + + + return sumit; +} + +// Augmented Likelihood Calculation - Normal Distribution +double lnlikecalcNUA(const Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::mat Zprobsmat = eout[""zprob""]; + arma::vec xi = eout[""xi""]; + arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + arma::vec trunc = eout[""trunc""]; + + const int zcols = avec.size(); + + double lnlike = llcalcNUA(avec, mvec, svec, zcols, xi, Zprobsmat, denom, trunc); + return((lnlike*-1.0)); +} + +// M-Step with Numerical Optimization for Expectation Maximization - Normal+Uniform Distribution - Same as EMNormalUniform.cpp +// +// description This function is used in expectation maximization to maximize the parameter values. +// param eout List with output from the estep +Rcpp::List mstepNUA(Rcpp::List eout){ + + const Rcpp::List parmlist = eout[""parm.list""]; + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + const arma::mat Zprobsmat = eout[""zprob""]; + const arma::vec xi = eout[""xi""]; + //const arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + //const arma::vec trunc = eout[""trunc""]; + const arma::vec sjvec = eout[""sjvec""]; + + int nmixt = avec.size(); + int m = mvec.size(); + int n = xi.n_rows; + + arma::vec ahats(m); + arma::vec mhats(m); + arma::vec shats(m); + + if(type == ""free""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = arma::square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = ((1/sj)*(sum(gamma % xi))); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + + } + } else if(type == ""fixed""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = mvec(i); + shats(i) = svec(i); + } + } else if(type == ""fixed_2""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = mvec(i); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + } + } else if(type == ""fixed_3""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = avec(i); + mhats(i) = mvec(i); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + } + } + + // Logic check + if(ahats.has_nan() == true || all(ahats) == false){ //if all are non.zero = false + //Rcpp::Rcout << ahats << std::endl; + ahats = avec; + } + if(shats.has_nan() == true || all(shats) == false){ + //Rcpp::Rcout << shats << std::endl; + shats = svec; + } + if(mhats.has_nan() == true || all(mhats) == false){ + //Rcpp::Rcout << mhats << std::endl; + mhats = mvec; + + } + // Add the Uniform + double ah = sum(ahats); + ahats.resize(nmixt); + ahats(nmixt-1) = (1 - ah); + + Rcpp::List res = Rcpp::List::create(Rcpp::_[""avec""] = ahats, Rcpp::_[""mvec""] = mhats, Rcpp::_[""svec""] = shats); + return(res); +} + + + + +//' @title Expectation maximization - Normal Distribution +//' +//' @description This function calculates the log-likelihood using +//' the expectation maximization algorithm with the Normal-Uniform Distribution. +//' This code is not identical to nQuire and uses an augmented likelihood. +//' +//' @param parmlist A list containing initial alpha, mean, and variance values. The list of alpha must include a proportion for the uniform mixture. +//' @param xi List of observations, in this case allele frequencies. +//' @param niter Max number of iterates. +//' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +//' below this value, convergence is reached. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +//' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +//' +//' @returns List of elements including the log-likelihood, the number of iterates, +//' and the optimized parameter values. +//' +// [[Rcpp::export]] +Rcpp::List emstepNUA(Rcpp::List parmlist, const arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type = ""free""){ + // Set up progress + + Rcpp::List mint = parmlist; + // E-step + Rcpp::List eint = estepNUA(mint, xi, type, trunc); + double lnlikeint = lnlikecalcNUA(eint); + + int count = 0; + // Iterating E and M steps until convergence is below epsilon + for(int j = 0; j < (niter + 1); j++){ + Rcpp::checkUserInterrupt(); + //p.increment(); + count = count + 1; + + // M-step + Rcpp::List moutip = mstepNUA(eint); + + // E-step + Rcpp::List eoutip = estepNUA(moutip, xi, type, trunc); + double lnlikeip = lnlikecalcNUA(eoutip); + double deltalogL = (lnlikeint - lnlikeip); + deltalogL = std::abs(deltalogL); + + // Set next iter + eint = eoutip; + lnlikeint = lnlikeip; + + if(deltalogL +using namespace arma; + +#include ""emshared.h"" +#include ""extradistrbbd.h"" +#include ""betabinomial.h"" + + +// name estepBB +// title E-Step for Expectation Maximization - Beta-Binomial Distribution +// description This function is used in expectation maximization. Here we complete +// the E-Step and calculate the log-likelihood. Modifications include a correction for +// the truncated distribution. +// param parmlist A list containing initial alpha, $theta_{1}$, and $theta_{2}$ values. +// param xm Matrix where the first column is total coverage and the second is the count of base A or B. +// param type String indicating ""Free"" or ""Fixed"". +// param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +// return A list with the following elements: +// \item logL: Log-likelihood of the mixture model. +// \item Zprobs.mat: Matrix where rows represent data points and columns represent each +// mixture model. Observations are the scaled probability of each data point belonging +// to each mixture model. +// \item Sj.vec: A vector of column sums for each mixture model. +// \item parm.list: Supplied list containing initial alpha, mu, and sigma values. +// \item xm: Matrix of coverage and sequencing depth at a site. +Rcpp::List estepBB(const Rcpp::List parmlist, const arma::mat xm, std::string type, + const arma::vec trunc){ + + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + + arma::vec t1vec = t1veccalc(mvec, svec); + arma::vec t2vec = t2veccalc(mvec, svec); + + const int m = mvec.size(); + const int xl = xm.n_rows; + arma::mat zprob( xl, m ); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0){ + for(int i = 0; i < m; i++) { + arma::vec ppv = dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), false); + zprob.col(i) = (avec(i) * ppv); + } + } else{ + for(int i = 0; i < m; i++) { + arma::vec F2F1 = pbbinomV((xm.col(0)*trunc(1)), xm.col(0), t1vec(i), t2vec(i)) - pbbinomV((xm.col(0)*trunc(0)), xm.col(0), t1vec(i), t2vec(i)); + arma::vec pp = dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), false); + pp = (pp/F2F1); + zprob.col(i) = (avec(i) * pp); + } + } + + arma::vec denom = arma::sum(zprob, 1); + + arma::mat zprobb( xl, m ); + for(int i = 0; i < m; i++){ + zprobb.col(i) = ( zprob.col(i) /denom ) ; + } + + Rcpp::List P = Rcpp::List::create( Rcpp::Named(""avec"") = avec, Rcpp::_[""mvec""] = mvec, Rcpp::_[""svec""] = svec); + return( Rcpp::List::create( Rcpp::_[""zprob""] = zprobb, Rcpp::_[""parm.list""] = P, Rcpp::_[""xm""] = xm, Rcpp::_[""denom""] = denom, Rcpp::_[""trunc""] = trunc, Rcpp::_[""type""]=type )); + + } + +// Augmented Likelihood Calculation - Beta-Binomial Distribution +double llcalcBB(const arma::vec avec, const arma::vec t1vec, const arma::vec t2vec, + const int zcols, const arma::mat xm, const arma::mat zprob, + const arma::vec denom, const arma::vec trunc) { + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < zcols; i++){ + arma::vec right = lavec(i) +(dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), true)); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < zcols; i++){ + arma::vec F2F1 = log(pbbinomV((xm.col(0)*trunc(1)), xm.col(0), t1vec(i), t2vec(i)) - pbbinomV((xm.col(0)*trunc(0)), xm.col(0), t1vec(i), t2vec(i))); + arma::vec pp = (dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), true) - F2F1); + arma::vec right = (lavec(i) + pp); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } + return sumit; + } + +// Augmented Likelihood Calculation - Beta-Binomial Distribution +double lnlikecalcBB(const Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::mat Zprobsmat = eout[""zprob""]; + arma::mat xm = eout[""xm""]; + arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + arma::vec trunc = eout[""trunc""]; + + arma::vec t1vec = t1veccalc(mvec, svec); + arma::vec t2vec = t2veccalc(mvec, svec); + + const int zcols = avec.size(); + + double lnlike = llcalcBB(avec, t1vec, t2vec, zcols, xm, Zprobsmat, denom, trunc); + //Rprintf(""%f \n"",lnlike); + return((lnlike*-1.0)); + } + +// MSTEP +/// Set up for optim +// Defining Ething class +class EthingBB { +public: + mat xm; + int zcols; + mat zdata; + vec denom; + vec trunc; + vec parms; + int pl; + int flag; + + EthingBB(mat xm, int zcols, mat zdata, vec denom, vec trunc, vec parms, int pl, int flag) : xm(xm), zcols(zcols), zdata(zdata), denom(denom), trunc(trunc), parms(parms), pl(pl), flag(flag) {} +}; + +// Defining the optim function +typedef double optimfn(int n, double *par, void *ex); + +// Numerical Optimization - Beta-Binomial Distribution +// +// description This function is used in nnmin for numeric optimization +// which is necessary for expectation maximization to maximize the parameter values. +// param n Number of parameters in par. +// param par The parameters to be optimized. +// param ex Pointer containing all additional information needed. +// return Log likelihood. +double elnlikeBB(int n, double *par, void *ex) { + + EthingBB *et = (EthingBB *) ex; + + // zprobsmat + const int m = et ->zcols; + arma::mat zprob = et ->zdata; + + // xi + arma::mat xm = et ->xm; + + // denom + arma::vec denom = et -> denom; + + // trunc + arma::vec trunc = et -> trunc; + double tsum = (trunc(0) + trunc(1)); + + // myguess + arma::vec myguess(n); + for(int iy = 0; iyflag; + + if(flag == 0){ + if(m == 1){ + avec(0) = 1.0; + mvec(0) = (1.0/(exp(myguess(0)*-1.0)+1.0)); + svec(0) = exp(myguess(1)); + }else { + if(m == 2){ + avec = invmlogitcD(myguess(0)); + }else{ + avec = invmlogitcU(myguess(span(0, (m-2)))); + } + mvec = mutransformA(myguess(span((m-1), ((m*2)-2)))); + svec = stransformA(myguess(span(((m*2)-1), (n-1)))); + } + }else if(flag == 1){ //alpha-free + if(m == 2){ + avec = invmlogitcD(myguess(0)); + }else{ + avec = invmlogitcU(myguess(span(0, (m-2)))); + } + + arma::vec parms = et -> parms; + int pl = et -> pl; + mvec = parms(span(0, (m-1))); + svec = parms(span(m, (pl-1))); + }else if(flag == 2){ //alpha-variance-free + if(m == 1){ + svec(0) = exp(myguess(0)); + arma::vec parms = et -> parms; + avec(0) = 1.0; + mvec(0) = parms(1); + } else{ + if (m == 2){ + avec = invmlogitcD(myguess(0)); + } else{ + avec = invmlogitcU(myguess(span(0, (m-2)))); + } + svec = stransformA(myguess(span((m-1), (n-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + mvec = parms(span(0, pl-1)); + } + } else if(flag == 3){ //variance free + svec = stransformA(myguess(span(0, (m-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + avec(span(0, (m-1))) = parms(span(0, (m-1))); + mvec(span(0, (m-1))) = parms(span(m, (pl-1))); + } + + arma::vec t1vec = t1veccalc(mvec, svec); + arma::vec t2vec = t2veccalc(mvec, svec); + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(tsum == 0){ + for(int i = 0; i < m; i++){ + arma::vec right = lavec(i) +(dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), true)); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < m; i++){ + arma::vec F2F1 = log(pbbinomV((xm.col(0)*trunc(1)), xm.col(0), t1vec(i), t2vec(i)) - pbbinomV((xm.col(0)*trunc(0)), xm.col(0), t1vec(i), t2vec(i))); + arma::vec pp = (dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), true) - F2F1); + arma::vec right = (lavec(i) + pp); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + + } + } + + return(sumit*(-1.0)); + } + + + +// Defining elnlikeB as an optim function +optimfn elnlikeBB; + +// Setting up nmmin +extern ""C"" { + void nmmin(int n, double *xin, double *x, double *Fmin, optimfn fn, + int *fail, double abstol, double intol, void *ex, + double alpha, double beta, double gamma, int trace, + int *fncount, int maxit); + } + +// M-Step with Numerical Optimization for Expectation Maximization - Beta-Binomial Distribution +// +// description This function is used in expectation maximization to maximize the parameter values. +// param eout List with output from the estep +// param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +Rcpp::List mstepBB(Rcpp::List eout){ + + const Rcpp::List parmlist = eout[""parm.list""]; + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + const arma::mat Zprobsmat = eout[""zprob""]; + const arma::mat xm = eout[""xm""]; + const arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + const arma::vec trunc = eout[""trunc""]; + + const int nmixt = avec.size(); + const int m = mvec.size(); + + arma::vec fgp = sampFT(type, m); + int flag = fgp(0); + int gl = fgp(1); + int pl = fgp(2); + + arma::vec guess(gl); + arma::vec parms(pl); + + if(flag == 0){ + if(m == 1){ + parms(0) = 1.0; + guess(0) = (log(mvec(0)) - log(1.0 - mvec(0))); + guess(1) = log(svec(0)); + }else{ + parms(0) = 0; + if(m == 2){ + guess(0) = mlogitcD(avec, nmixt); + } else{ + guess(span(0,(m-2))) = mlogitcU(avec, nmixt); + } + guess(span(m-1, ((m*2)-2))) = mvecinA(mvec); // 4-7 + guess(span((m*2)-1, (gl-1))) = svecinA(svec); // 8 -12 + } + }else if(flag == 1){ //alpha + if(m == 2){ + guess(0) = mlogitcD(avec, nmixt); + } else{ + guess(span(0, (m-2))) = mlogitcU(avec, nmixt); + } + parms(span(0, (m-1))) = mvec; + parms(span(m, (pl-1))) = svec; + }else if(flag == 2){ //both + if(m == 1){ + guess(0) = log(svec(0)); + parms(0) = 1.0; + parms(1) = mvec(0); + } else{ + if(m == 2){ + guess(0) = mlogitcD(avec, nmixt); + } else{ + guess(span(0,(m-2))) = mlogitcU(avec, nmixt); + + } + guess(span((m-1), (gl-1))) = svecinA(svec); + parms(span(0, (m-1))) = mvec; + } + }else if(flag == 3){ + guess(span(0,(m-1))) = svecinA(svec); + parms(span(0, (m-1))) = avec; + parms(span(m, (pl-1))) = mvec; + } + + + EthingBB et(xm, nmixt, Zprobsmat, denom, trunc, parms, pl, flag); + + arma::vec vec(gl); + for(int nn = 0; nn < gl; nn++){ + vec(nn) = guess(nn); + } + + arma::vec opar(gl); + double Fmin = 0.0; + int fail = 0; + const double abstol = 1.0e-8; + const double intol = 1.0e-8; + const double alpha = 1.0; + const double beta = 0.5; + const double gamma = 2.0; + const int trace = 0; + int fncount = 0; + const int maxit = 500; + + nmmin(gl, vec.begin(), opar.begin(), &Fmin, + elnlikeBB, &fail, abstol, intol, &et, alpha, beta, + gamma, trace, &fncount, maxit); + + + // Transform oparback + arma::vec oparback(gl); + for(int ou = 0; ou < gl; ou++){ + oparback(ou) = opar[ou]; + } + + + arma::vec ahats(m); + arma::vec mhats(m); + arma::vec shats(m); + + if(flag == 0){ + if(m == 1){ + ahats(0) = 1.0; + mhats(0) = (1.0/(exp(-1.0*oparback(0)) + 1.0)); + shats(0) = exp(oparback(1)); + }else{ + if(m == 2){ + ahats = invmlogitcD(oparback(0)); + }else{ + ahats = invmlogitcU(oparback(span(0, (m-2)))); + } + mhats = mutransformA(oparback(span((m-1), ((m*2)-2)))); + shats = stransformA(oparback(span(((m*2)-1), (gl-1)))); + } + }else if(flag == 1){ + if(m == 2){ + ahats = invmlogitcD(oparback(0)); + }else{ + ahats = invmlogitcU(oparback(span(0, (m-2)))); + } + mhats = mvec; + shats = svec; + }else if(flag == 2){ + if(m == 1){ + ahats(0) = 1.0; + mhats(0) = mvec(0); + shats(0) = exp(oparback(0)); + } else { + + if (m == 2){ + ahats = invmlogitcD(oparback(0)); + }else{ + ahats = invmlogitcU(oparback(span(0, (m-2)))); + } + shats = stransformA(oparback(span((m-1), (m*2)-2))); + mhats = mvec; + + } + }else if(flag == 3){ + shats = stransformA(oparback(span(0, (m-1)))); + ahats = avec; + mhats = mvec; + } + + // Logic check + double acheck = ::Rf_fround(arma::min(ahats), 6); + if(ahats.has_nan() == true || all(acheck) == false ){ //if all are non.zero = false + ahats = avec; + } + + + Rcpp::List res = Rcpp::List::create(Rcpp::_[""avec""] = ahats, Rcpp::_[""mvec""] = mhats, Rcpp::_[""svec""] = shats); + return(res); + } + + +// Log-Likelihood for BIC +double llcalcfinalBB(Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::mat xm = eout[""xm""]; + arma::vec trunc = eout[""trunc""]; + + arma::vec t1vec = t1veccalc(mvec, svec); + arma::vec t2vec = t2veccalc(mvec, svec); + + int n = avec.size(); + int xl = xm.n_rows; + + arma::mat mixit(xl, n); + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < n; i++){ + mixit.col(i) = (avec(i)*dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i),false)); + } + }else{ + for(int i = 0; i < n; i++) { + arma::vec F2F1 = (pbbinomV((xm.col(0)*trunc(1)), xm.col(0), t1vec(i), t2vec(i)) - pbbinomV((xm.col(0)*trunc(0)), xm.col(0), t1vec(i), t2vec(i))); + arma::vec pp = (avec(i)*dbbinomV(xm.col(1), xm.col(0), t1vec(i), t2vec(i), false)); + mixit.col(i) = (pp/F2F1); + } + } + + arma::vec sumrows = arma::sum(mixit, 1); + double sumit = sum(log(sumrows)); + return sumit; +} + + +//' @title Expectation maximization - Beta-Binomial Distribution +//' +//' @description This function calculates the negative log-likelihood using +//' the expectation maximization algorithm with Nelder-Mead numerical optimization +//' and beta-binomial distribution. +//' +//' @param parmlist A list containing initial alpha, mean, and variance. +//' @param xm Matrix where the first column is total coverage and the second is the count of base A or B. +//' @param niter Max number of iterates. +//' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +//' below this value, convergence is reached. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' @param type String indicating ""Free"" or ""Fixed"". +//' +//' @returns List of elements including the negative log likelihood, the number of iterates, +//' and the optimized parameter values. +//' +//' +// [[Rcpp::export]] +Rcpp::List emstepBB(Rcpp::List parmlist, arma::mat xm, int niter, double epsilon, arma::vec trunc, std::string type = ""free""){ + Rcpp::List mint = parmlist; + // E-step + Rcpp::List eint = estepBB(mint, xm, type, trunc); + double lnlikeint = lnlikecalcBB(eint); + //Rprintf(""%f \n"", lnlikeint); + + int count = 0; + + // Iterating E and M steps until convergence is below epsilon + for(int j = 0; j < (niter + 1); j++){ + count = count+1; + Rcpp::checkUserInterrupt(); + // M-step + Rcpp::List moutip = mstepBB(eint); + + // E-step + Rcpp::List eoutip = estepBB(moutip, xm, type, trunc); + double lnlikeip = lnlikecalcBB(eoutip); + double deltalogL = (lnlikeint - lnlikeip); + deltalogL = std::abs(deltalogL); + //Rprintf(""%f \n"", deltalogL); + + // Set next iter + eint = eoutip; + lnlikeint = lnlikeip; + + if(deltalogL +using namespace arma; + +#include ""emshared.h"" +#include + + +// title E-Step for Expectation Maximization - Beta Distribution +// description This function is used in expectation maximization. Here we complete +// the E-Step and calculate the log-likelihood. Modifications include a correction for +// the truncated distribution. +// param parmlist A list containing initial alpha, mu, and sigma values. +// param xi List of observations, in this case allele frequencies. +// param type String indicating ""Free"" or ""Fixed"". +// param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +// return A list with the following elements: +// \item logL: Log-likelihood of the mixture model. +// \item Zprobs.mat: Matrix where rows represent data points and columns represent each +// mixture model. Observations are the scaled probability of each data point belonging +// to each mixture model. +// \item Sj.vec: A vector of column sums for each mixture model. +// \item parm.list: Supplied list containing initial alpha, mu, and sigma values. +// \item xi: List of allele frequencies. +Rcpp::List estepB(const Rcpp::List parmlist, const arma::vec xi, std::string type, + const arma::vec trunc){ + + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + + const int m = mvec.size(); + const int xl = xi.size(); + arma::mat zprob( xl, m ); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0){ + for(int i = 0; i < m; i++) { + arma::vec ab = alphabetacalcA( mvec(i), svec(i) ) ; + arma::vec ppv = dbetaV(xi, ab(0), ab(1), 0); + zprob.col(i) = (avec(i) * ppv); + } + } else{ + for(int i = 0; i < m; i++) { + arma::vec ab = alphabetacalcA( mvec(i), svec(i) ) ; + double F2F1 = R::pbeta(trunc(1), ab(0), ab(1), 1, 0) - R::pbeta(trunc(0), ab(0), ab(1), 1, 0); + arma::vec pp = dbetaV(xi, ab(0), ab(1), 0); + pp = (pp/F2F1); + zprob.col(i) = (avec(i) * pp); + } + } + + arma::vec denom = arma::sum(zprob, 1); + + arma::mat zprobb( xl, m ); + for(int i = 0; i < m; i++){ + zprobb.col(i) = ( zprob.col(i) /denom ); + } + + Rcpp::List P = Rcpp::List::create( Rcpp::Named(""avec"") = avec, Rcpp::_[""mvec""] = mvec, Rcpp::_[""svec""] = svec); + return( Rcpp::List::create( Rcpp::_[""zprob""] = zprobb, Rcpp::_[""parm.list""] = P, Rcpp::_[""xi""] = xi, Rcpp::_[""denom""] = denom, Rcpp::_[""trunc""] = trunc, Rcpp::_[""type""]=type )); + +} + +// Augmented Likelihood Calculation - Beta Distribution +double llcalcB(const arma::vec avec, const arma::vec mvec, const arma::vec svec, + const int zcols, const arma::vec xi, const arma::mat zprob, + const arma::vec denom, const arma::vec trunc) { + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + + for(int i = 0; i < zcols; i++){ + arma::vec ab = alphabetacalcA(mvec(i), svec(i)); + arma::vec right = (lavec(i) +(dbetaV(xi, ab(0), ab(1), 1))); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < zcols; i++){ + arma::vec ab = alphabetacalcA(mvec(i), svec(i)); + double F2F1 = log(R::pbeta(trunc(1), ab(0), ab(1), 1, 0) - R::pbeta(trunc(0), ab(0), ab(1), 1, 0)); + arma::vec right = (lavec(i) +((dbetaV(xi, ab(0), ab(1), 1))-F2F1)); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } + + return sumit; +} + +// Augmented Likelihood Calculation - lnlikecalcB - Beta Distribution +double lnlikecalcB(const Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::mat Zprobsmat = eout[""zprob""]; + arma::vec xi = eout[""xi""]; + arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + arma::vec trunc = eout[""trunc""]; + + const int zcols = mvec.size(); + + double lnlike = llcalcB(avec, mvec, svec, zcols, xi, Zprobsmat, denom, trunc); + return((lnlike*-1.0)); + } + + +// MSTEP +/// Set up for optim +// Defining Ething class + class Ething { + public: + vec xi; + int zcols; + mat zdata; + vec denom; + vec trunc; + vec parms; + int pl; + int flag; + + Ething(vec xi, int zcols, mat zdata, vec denom, vec trunc, vec parms, int pl, int flag) : xi(xi), zcols(zcols), zdata(zdata), denom(denom), trunc(trunc), parms(parms), pl(pl), flag(flag){} + }; + + // Defining the optim function + typedef double optimfn(int n, double *par, void *ex); + +// Numerical Optimization - Beta Distribution +// description This function is used in nnmin for numeric optimization +// which is necessary for expectation maximization to maximize the parameter values. +// param n Number of parameters in par. +// param par The parameters to be optimized. +// param ex Pointer containing all additional information needed. +// return Log likelihood. + double elnlikeB(int n, double *par, void *ex) { + + Ething *et = (Ething *) ex; + + // zprobsmat + const int m = et ->zcols; + arma::mat zprob = et ->zdata; + + // xi + arma::vec xi = et ->xi; + + // denom + arma::vec denom = et -> denom; + + // trunc + arma::vec trunc = et -> trunc; + double tsum = (trunc(0) + trunc(1)); + + // myguess + arma::vec myguess(n); + for(int iy = 0; iyflag; + + if(flag == 0){ + if(m == 1){ + avec(0) = 1.0; + mvec(0) = (1.0/(exp(myguess(0)*-1.0)+1.0)); + svec(0) = exp(myguess(1)); + }else { + if(m == 2){ + avec = invmlogitcD(myguess(0)); + }else{ + avec = invmlogitcU(myguess(span(0, (m-2)))); + } + mvec = mutransformA(myguess(span((m-1), ((m*2)-2)))); + svec = stransformA(myguess(span(((m*2)-1), (n-1)))); + + } + }else if(flag == 1){ //alpha-free + if(m == 2){ + avec = invmlogitcD(myguess(0)); + }else{ + avec = invmlogitcU(myguess(span(0, (m-2)))); + } + + arma::vec parms = et -> parms; + int pl = et -> pl; + mvec = parms(span(0, (m-1))); + svec = parms(span(m, (pl-1))); + }else if(flag == 2){ //alpha-variance-free + if(m == 1){ + svec(0) = exp(myguess(0)); + arma::vec parms = et -> parms; + avec(0) = 1.0; + mvec(0) = parms(1); + } else{ + if (m == 2){ + avec = invmlogitcD(myguess(0)); + } else{ + avec = invmlogitcU(myguess(span(0, (m-2)))); + } + svec = stransformA(myguess(span((m-1), (n-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + mvec = parms(span(0, pl-1)); + } + } else if(flag == 3){ //variance free + svec = stransformA(myguess(span(0, (m-1)))); + arma::vec parms = et -> parms; + int pl = et -> pl; + avec(span(0, (m-1))) = parms(span(0, (m-1))); + mvec(span(0, (m-1))) = parms(span(m, (pl-1))); + } + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(tsum == 0){ + for(int i = 0; i < m; i++){ + arma::vec ab = alphabetacalcA(mvec(i), svec(i)); + arma::vec right = (lavec(i) +(dbetaV(xi, ab(0), ab(1), 1))); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < m; i++){ + arma::vec ab = alphabetacalcA(mvec(i), svec(i)); + double F2F1 = log(R::pbeta(trunc(1), ab(0), ab(1), 1, 0) - R::pbeta(trunc(0), ab(0), ab(1), 1, 0)); + arma::vec right = (lavec(i) +((dbetaV(xi, ab(0), ab(1), 1))-F2F1)); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } + Rcpp::checkUserInterrupt(); + return(sumit*(-1.0)); + } + + +// Defining elnlikeB as an optim function +optimfn elnlikeB; + +// Setting up nmmin +extern ""C"" { + void nmmin(int n, double *xin, double *x, double *Fmin, optimfn fn, + int *fail, double abstol, double intol, void *ex, + double alpha, double beta, double gamma, int trace, + int *fncount, int maxit); +} + +// M-Step with Numerical Optimization for Expectation Maximization - Beta Distribution +// +// description This function is used in expectation maximization to maximize the parameter values. +// param eout List with output from the estep +Rcpp::List mstepB(Rcpp::List eout){ + + const Rcpp::List parmlist = eout[""parm.list""]; + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + const arma::mat Zprobsmat = eout[""zprob""]; + const arma::vec xi = eout[""xi""]; + const arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + const arma::vec trunc = eout[""trunc""]; + + const int nmixt = avec.size(); + const int m = mvec.size(); + + arma::vec fgp = sampFT(type, m); + int flag = fgp(0); + int gl = fgp(1); + int pl = fgp(2); + + arma::vec guess(gl); + arma::vec parms(pl); + + if(flag == 0){ + if(m == 1){ + parms(0) = 1.0; + guess(0) = (log(mvec(0)) - log(1.0 - mvec(0))); + guess(1) = log(svec(0)); + }else{ + parms(0) = 0; + if(m == 2){ + guess(0) = mlogitcD(avec, nmixt); + } else{ + guess(span(0,(m-2))) = mlogitcU(avec, nmixt); + } + guess(span(m-1, ((m*2)-2))) = mvecinA(mvec); // 4-7 + guess(span((m*2)-1, (gl-1))) = svecinA(svec); // 8 -12 + } + }else if(flag == 1){ //alpha + if(m == 2){ + guess(0) = mlogitcD(avec, nmixt); + } else{ + guess(span(0, (m-2))) = mlogitcU(avec, nmixt); + } + parms(span(0, (m-1))) = mvec; + parms(span(m, (pl-1))) = svec; + }else if(flag == 2){ //both + if(m == 1){ + guess(0) = log(svec(0)); + parms(0) = 1.0; + parms(1) = mvec(0); + } else{ + if(m == 2){ + guess(0) = mlogitcD(avec, nmixt); + } else{ + guess(span(0,(m-2))) = mlogitcU(avec, nmixt); + } + guess(span((m-1), (gl-1))) = svecinA(svec); + parms(span(0, (m-1))) = mvec; + } + }else if(flag == 3){ + guess(span(0,(m-1))) = svecinA(svec); + parms(span(0, (m-1))) = avec; + parms(span(m, (pl-1))) = mvec; + } + + + Ething et(xi, nmixt, Zprobsmat, denom, trunc, parms, pl, flag); + + arma::vec vec(gl); + for(int nn = 0; nn < gl; nn++){ + vec(nn) = guess(nn); + } + + arma::vec opar(gl); + double Fmin = 0.0; + int fail = 0; + const double abstol = 1.0e-8; + const double intol = 1.0e-8; + const double alpha = 1.0; + const double beta = 0.5; + const double gamma = 2.0; + const int trace = 0; + int fncount = 0; + const int maxit = 500; + + nmmin(gl, vec.begin(), opar.begin(), &Fmin, + elnlikeB, &fail, abstol, intol, &et, alpha, beta, + gamma, trace, &fncount, maxit); + + + // Transform oparback + arma::vec oparback(gl); + for(int ou = 0; ou < gl; ou++){ + oparback(ou) = opar[ou]; + } + + arma::vec ahats(m); + arma::vec mhats(m); + arma::vec shats(m); + + if(flag == 0){ + if(m == 1){ + ahats(0) = 1.0; + mhats(0) = (1.0/(exp(-1.0*oparback(0)) + 1.0)); + shats(0) = exp(oparback(1)); + }else{ + if(m == 2){ + ahats = invmlogitcD(oparback(0)); + }else{ + ahats = invmlogitcU(oparback(span(0, (m-2)))); + } + mhats = mutransformA(oparback(span((m-1), ((m*2)-2)))); + shats = stransformA(oparback(span(((m*2)-1), (gl-1)))); + } + }else if(flag == 1){ + if(m == 2){ + ahats = invmlogitcD(oparback(0)); + }else{ + ahats = invmlogitcU(oparback(span(0, (m-2)))); + } + mhats = mvec; + shats = svec; + }else if(flag == 2){ + if(m == 1){ + ahats(0) = 1.0; + mhats(0) = mvec(0); + shats(0) = exp(oparback(0)); + } else { + + if (m == 2){ + ahats = invmlogitcD(oparback(0)); + }else{ + ahats = invmlogitcU(oparback(span(0, (m-2)))); + } + shats = stransformA(oparback(span((m-1), (m*2)-2))); + mhats = mvec; + + } + }else if(flag == 3){ + shats = stransformA(oparback(span(0, (m-1)))); + ahats = avec; + mhats = mvec; + } + + + Rcpp::List res = Rcpp::List::create(Rcpp::_[""avec""] = ahats, Rcpp::_[""mvec""] = mhats, Rcpp::_[""svec""] = shats); + return(res); + } + + +// Log-Likelihood for BIC +double llcalcfinal(Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::vec xi = eout[""xi""]; + arma::vec trunc = eout[""trunc""]; + + int m = mvec.size(); + int xl = xi.size(); + + arma::mat mixit(xl, m); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < m; i++){ + arma::vec ab = alphabetacalcA( mvec(i), svec(i) ) ; + mixit.col(i) = (avec(i)*dbetaV(xi, ab(0), ab(1), 0)); + } + }else{ + for(int i = 0; i < m; i++) { + arma::vec ab = alphabetacalcA( mvec(i), svec(i) ) ; + double F2F1 = R::pbeta(trunc(1), ab(0), ab(1), 1, 0) - R::pbeta(trunc(0), ab(0), ab(1), 1, 0); + arma::vec pp = (avec(i)*dbetaV(xi, ab(0), ab(1), 0)); + mixit.col(i) = (pp/F2F1); + } + } + + + arma::vec sumrows = arma::sum(mixit, 1); + if(all(sumrows) == false){ //if all are non.zero = false + for(int i = 0; i < xl; i++){ + if(sumrows(i) == 0){ + sumrows(i) = DBL_MIN; + } + } + } + + double sumit = sum(log(sumrows)); + return sumit; +} + +//' @title Expectation maximization - Beta Distribution +//' +//' @description This function calculates the log-likelihood using +//' the expectation maximization algorithm with Nelder-Mead numerical optimization +//' and a beta distribution. +//' +//' @param parmlist A list containing initial alpha, mean, and variance values. +//' @param xi List of observations, in this case allele frequencies. +//' @param niter Max number of iterates. +//' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +//' below this value, convergence is reached. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +//' ""fixed-2"" (estimated parameter(s): alpha and variance), or ""fixed-3"" (estimated parameter(s): variance). +//' If avec is length of 1, fixed and fixed-3 will not be able to return a log-likelihood. +//' +//' @returns List of elements including the log likelihood, the negative log likelihood, the number of iterates, +//' and the optimized parameter values. +//' +// [[Rcpp::export]] +Rcpp::List emstepB(Rcpp::List parmlist, arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type = ""free""){ + // Set up progress + // Progress p(niter, true); + + Rcpp::List mint = parmlist; + // E-step + Rcpp::List eint = estepB(mint, xi, type, trunc); + double lnlikeint = lnlikecalcB(eint); + + int count = 0; + // Iterating E and M steps until convergence is below epsilon + for(int j = 0; j < (niter + 1); j++){ + Rcpp::checkUserInterrupt(); + //p.increment(); + count = count + 1; + + // M-step + Rcpp::List moutip = mstepB(eint); + + // E-step + Rcpp::List eoutip = estepB(moutip, xi, type, trunc); + double lnlikeip = lnlikecalcB(eoutip); + double deltalogL = (lnlikeint - lnlikeip); + deltalogL = std::abs(deltalogL); + // Rprintf(""%f \n"", deltalogL); + + // Set next iter + eint = eoutip; + lnlikeint = lnlikeip; + + if(deltalogL +using namespace arma; + +#include ""emshared.h"" +#include ""ushared.h"" +#include + + +// title E-Step for Expectation Maximization - Normal Distribution - Same as EMNormal.cpp +// description This function is used in expectation maximization. Here we complete +// the E-Step and calculate the log-likelihood. Modifications include a correction for +// the truncated distribution. +Rcpp::List estepNA(const Rcpp::List parmlist, const arma::vec xi, std::string type, + const arma::vec trunc){ + + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + + const int m = mvec.size(); + + //int pl = (n == m ? 1 : 2); + + const int xl = xi.size(); + arma::mat zprob( xl, m ); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0){ + for(int i = 0; i < m; i++) { + arma::vec ppv = dnormV(xi, mvec(i), svec(i), 0); + zprob.col(i) = (avec(i) * ppv); + } + } else{ + for(int i = 0; i < m; i++) { + double F2F1 = R::pnorm(trunc(1), mvec(i), svec(i), 1, 0) - R::pnorm(trunc(0), mvec(i), svec(i), 1, 0); + arma::vec pp = dnormV(xi, mvec(i), svec(i), 0); + pp = (pp/F2F1); + zprob.col(i) = (avec(i) * pp); + } +} + + + arma::vec denom = arma::sum(zprob, 1); + + arma::mat zprobb( xl, m ); + arma::vec sjvec(m ); + for(int i = 0; i < m ; i++){ + zprobb.col(i) = ( zprob.col(i) /denom ) ; + sjvec(i) = sum(zprobb.col(i)); + } + double ll = sum(log(denom)); + + Rcpp::List P = Rcpp::List::create( Rcpp::Named(""avec"") = avec, Rcpp::_[""mvec""] = mvec, Rcpp::_[""svec""] = svec); + return( Rcpp::List::create( Rcpp::_[""zprob""] = zprobb, Rcpp::_[""parm.list""] = P, Rcpp::_[""xi""] = xi, Rcpp::_[""denom""] = denom, Rcpp::_[""trunc""] = trunc, Rcpp::_[""type""]=type, Rcpp::_[""sjvec""]=sjvec, Rcpp::_[""LL""]=ll)); + +} + +// Augmented Likelihood Calculation - Normal Distribution +double llcalcNA(const arma::vec avec, const arma::vec mvec, const arma::vec svec, + const int zcols, const arma::vec xi, const arma::mat zprob, + const arma::vec denom, const arma::vec trunc) { + + double sumit = 0.0; + arma::vec lavec = log(avec); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + + for(int i = 0; i < zcols; i++){ + arma::vec right = (lavec(i) +(dnormV(xi, mvec(i), svec(i), 1))); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } else{ + for(int i = 0; i < zcols; i++){ + double F2F1 = log(R::pnorm(trunc(1), mvec(i), svec(i), 1, 0) - R::pnorm(trunc(0), mvec(i), svec(i), 1, 0)); + arma::vec right = (lavec(i) +((dnormV(xi, mvec(i), svec(i), 1))-F2F1)); + arma::vec left = zprob.col(i); + sumit += sum(left % right); + } + } + + return sumit; +} + +// Augmented Likelihood Calculation - Normal Distribution - Continued +double lnlikecalcNA(const Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::mat Zprobsmat = eout[""zprob""]; + arma::vec xi = eout[""xi""]; + arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + arma::vec trunc = eout[""trunc""]; + + const int zcols = mvec.size(); + + double lnlike = llcalcNA(avec, mvec, svec, zcols, xi, Zprobsmat, denom, trunc); + return((lnlike*-1.0)); +} + + + +// Log-Likelihood for BIC +double llcalcfinalNA(Rcpp::List eout){ + Rcpp::List parmlist = eout[""parm.list""]; + arma::vec avec = parmlist[""avec""]; + arma::vec mvec = parmlist[""mvec""]; + arma::vec svec = parmlist[""svec""]; + arma::vec xi = eout[""xi""]; + arma::vec trunc = eout[""trunc""]; + + const int m = mvec.size(); + int xl = xi.size(); + + arma::mat mixit(xl, m); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0.0){ + for(int i = 0; i < m; i++){ + mixit.col(i) = avec(i)*(dnormV(xi, mvec(i), svec(i), 0)); + } + }else{ + for(int i = 0; i < m; i++) { + double F2F1 = R::pnorm(trunc(1), mvec(i), svec(i), 1, 0) - R::pnorm(trunc(0), mvec(i), svec(i), 1, 0); + arma::vec pp = (avec(i)*dnormV(xi, mvec(i), svec(i), 0)); + mixit.col(i) = (pp/F2F1); + } + } + + arma::vec sumrows = arma::sum(mixit, 1); + if(all(sumrows) == false){ //if all are non.zero = false + for(int i = 0; i < xl; i++){ + if(sumrows(i) == 0){ + sumrows(i) = DBL_MIN; + } + } + } + double sumit = sum(log(sumrows)); + return sumit; +} + + +// M-Step with Numerical Optimization for Expectation Maximization - Normal Distribution - Same as EMNormal.cpp +// +// description This function is used in expectation maximization to maximize the parameter values. +// param eout List with output from the estep +Rcpp::List mstepNA(Rcpp::List eout){ + + const Rcpp::List parmlist = eout[""parm.list""]; + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + const arma::mat Zprobsmat = eout[""zprob""]; + const arma::vec xi = eout[""xi""]; + //const arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + //const arma::vec trunc = eout[""trunc""]; + const arma::vec sjvec = eout[""sjvec""]; + + //int nmixt = avec.size(); + int m = mvec.size(); + int n = xi.n_rows; + + arma::vec ahats(m); + arma::vec mhats(m); + arma::vec shats(m); + + if(type == ""free""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = arma::square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = ((1/sj)*(sum(gamma % xi))); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + + } + } else if(type == ""fixed""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = mvec(i); + shats(i) = svec(i); + } + } else if(type == ""fixed_2""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = mvec(i); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + } + } else if(type == ""fixed_3""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = avec(i); + mhats(i) = mvec(i); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + } + } + + // Logic check + if(ahats.has_nan() == true || all(ahats) == false){ //if all are non.zero = false + //Rcpp::Rcout << ahats << std::endl; + ahats = avec; + } + if(shats.has_nan() == true || all(shats) == false){ + shats = svec; + } + if(mhats.has_nan() == true || all(mhats) == false){ + mhats = mvec; + } + + + Rcpp::List res = Rcpp::List::create(Rcpp::_[""avec""] = ahats, Rcpp::_[""mvec""] = mhats, Rcpp::_[""svec""] = shats); + return(res); +} + + + + +//' @title Expectation maximization - Normal Distribution +//' +//' @description This function calculates the log-likelihood using +//' the expectation maximization algorithm with the Normal Distribution. +//' This code is not identical to nQuire and uses an augmented likelihood. +//' +//' @param parmlist A list containing initial alpha, mean, and variance values. +//' @param xi List of observations, in this case allele frequencies. +//' @param niter Max number of iterates. +//' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +//' below this value, convergence is reached. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +//' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +//' +//' @returns List of elements including the log-likelihood, the number of iterates, +//' and the optimized parameter values. +//' +// [[Rcpp::export]] +Rcpp::List emstepNA(Rcpp::List parmlist, const arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type = ""free""){ + // Set up progress + + Rcpp::List mint = parmlist; + // E-step + Rcpp::List eint = estepNA(mint, xi, type, trunc); + double lnlikeint = lnlikecalcNA(eint); + + int count = 0; + // Iterating E and M steps until convergence is below epsilon + for(int j = 0; j < (niter + 1); j++){ + Rcpp::checkUserInterrupt(); + //p.increment(); + count = count + 1; + + // M-step + Rcpp::List moutip = mstepNA(eint); + + + // E-step + Rcpp::List eoutip = estepNA(moutip, xi, type, trunc); + double lnlikeip = lnlikecalcNA(eoutip); + double deltalogL = (lnlikeint - lnlikeip); + deltalogL = std::abs(deltalogL); + + // Set next iter + eint = eoutip; + lnlikeint = lnlikeip; + + if(deltalogL +using namespace arma; + + +//' Calculate Alpha and Beta from Mean and Variance +//' +//' @param mu Mean. +//' @param var Variance. +//' +//' @return Numeric vector of alpha and beta. +// [[Rcpp::export]] +arma::vec alphabetacalc(const double mu, const double var){ + arma::vec ab(2); + const double comm = ( ( ( mu * (1.0 - mu) ) / var ) - 1.0); + ab[0] = (mu * comm); + ab[1] = ( ( 1.0 - mu ) * comm); + return (ab); +} + + +//' Vector-based - Calculate Alpha and Beta from Mean and Variance +//' +//' @param mu Vector of mean. +//' @param var Vector of variance. +//' +//' @return Numeric matrix of alpha and beta. +// [[Rcpp::export]] +arma::mat alphabetacalcvec(arma::vec mu, arma::vec var){ + const int ml = mu.size(); + arma::mat ab(ml, 2); + vec y(mu.size(), fill::ones); + arma::vec comm = ( ( ( mu % (y - mu) ) / var ) - y); + ab.col(0) = (mu % comm); + ab.col(1) = ( ( y - mu ) % comm); + return (ab); +} + + +//' Calculate Alpha and Beta from Mean, Tau, and Error rate. +//' +//' @param mu Mean. +//' @param tau Overdispersion parameter. Ranges from 0 to 1, where 0 indicates less overdispersion and 1 indicates high overdispersion. Here tau must be greater than 0. +//' @param error Sequencing error rate. +//' +//' @return Numeric vector of alpha and beta. +// [[Rcpp::export]] + arma::vec alphabetacalctau(const double mu, const double tau, const double error){ + arma::vec ab(2); + const double mm = ((mu*(1.0-error)) + ((1.0-mu)*error)); + ab[0] = (((1.0-tau)*mm)/tau); + ab[1] = (((1.0-mm)*(1.0-tau))/tau); + return (ab); + } + + +//' Vector-based - Calculate Alpha and Beta from Mean, Tau, and Error rate. +//' +//' @param mu Vector of mean. +//' @param tau Overdispersion parameter. Ranges from 0 to 1, where 0 indicates less overdispersion and 1 indicates high overdispersion. Here tau must be greater than 0. +//' @param error Sequencing error rate. Ranges from 0 to 1. +//' +//' @return Numeric matrix of alpha and beta. +// [[Rcpp::export]] +arma::mat alphabetacalctauvec(arma::vec mu, const double tau, const double error){ + const int ml = mu.size(); + arma::mat ab(ml, 2); + arma::vec y(mu.size(), fill::ones); + arma::vec t(mu.size(), fill::value(tau)); + arma::vec erv(mu.size(), fill::value(error)); + arma::vec mm = ((mu%(y-erv)) + ((y-mu)%erv)); + ab.col(0) = (((y-t)%mm)/t); + ab.col(1) = (((y-mm)%(y-t))/t); + return (ab); +} + + + + + +","C++" +"Allele","mgaynor1/nQuack","src/emshared.cpp",".cpp","5740","261","// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; + +// Helper +// Numeric vector exponential sum +// +// param v Numeric vector. +// +// return Sum of exponential of each value in a numeric vector. +double exp_sum(const arma::vec v){ + arma::vec vv = exp(v); + return(std::accumulate(vv.begin(), vv.end(), 0.0)); +} + + +// LINK FUNCTIONS +// mlogitc +// description To force the final alpha estimates to be between 0 and 1, and add up to 1, +// we use logit transformations. +// param avec List of alpha of nmixt length. +// param nmixt Length of alphas. +// +// return Logit-transform of the first (nmixt-1) alpha values +arma::vec mlogitcU(const arma::vec avec, const int nmixt){ + arma::vec pis = avec(span(0, (nmixt-2))); + double pim = avec((nmixt-1)); + return log(pis/pim); +} + +double mlogitcD(const arma::vec avec, const int nmixt){ + double pis = avec(0); + double pim = avec(1); + return log(pis/pim); +} + + +// invmlogitc +// +// param betas List of betas to transform. +// +// return Numeric vector of alpha and beta. +arma::vec invmlogitcA(const arma::vec betas){ + double denom = (1.0 + exp_sum(betas)); + arma::vec nom = exp(betas); + arma::vec out = nom/denom; + return(out); +} +arma::vec invmlogitcU(const arma::vec betas){ + int b = betas.size(); + arma::vec out(b+1); + double denom = (1.0 + exp_sum(betas)); + arma::vec nom = exp(betas); + out(span(0, b-1)) = (nom/denom); + out(b) = (1.0 - sum(out(span(0, b-1)))); + return(out); +} + +arma::vec invmlogitcD(const double betas){ + arma::vec out(2); + double denom = (1.0 + exp(betas)); + out(0) = (exp(betas)/denom); + out(1) = (1.0 - out(0)); + return(out); +} + +// prob_unif_nq - from nQuire +// +// param minfrac Minimum allele frequency. +// param x Allele frequency at a site. +// return Uniform distribution. +double prob_unif_nq(double minfrac, double x){ + double unif = 0; + double upper = 1.0 - minfrac; + if(x >= minfrac && x <= upper){ + unif = 1 / (upper - minfrac); + } + return(unif); +} + +// prob_unif_vec - vectorized +// +// param xi Vector of allele frequency. +// +// return Sampled uniform distribution. +arma::vec prob_unif_vec(arma::vec xi, int logit = 0){ + double minfrac = min(xi); + double upper = max(xi); + double dif = (upper - minfrac); + + arma::vec unif(xi.size()); + + for(int i = 0; i < xi.size(); i++){ + if(xi(i) >= minfrac && xi(i) <= upper){ + if(logit == 0){ + unif(i) = (1 / dif); + } else if (logit == 1){ + unif(i) = log(1.0/dif); + } + } else{ + unif(i) = 0; + } + } + return(unif); +} + + + +// prob_unif_vec - for Beta-Binomial +// +// param xi Vector of allele frequency. +// +// return Sampled uniform distribution. +arma::vec prob_unif_vec_bb(arma::vec xm, int logit = 0){ + arma::vec unif(xm.size()); + + for(int i = 0; i < xm.size(); i++){ + if(logit == 0){ + unif(i) = (1 / xm(i)); + } else if (logit == 1){ + unif(i) = log(1.0/xm(i)); + } + } + return(unif); +} + +// Alpha and Beta calculation +// +// param mu Mean. +// param var Variance. +// +// return Numeric vector of alpha and beta. +arma::vec alphabetacalcA(const double mu, const double var){ + arma::vec ab(2); + const double comm = ( ( ( mu * (1.0 - mu) ) / var ) - 1.0); + ab[0] = (mu * comm); + ab[1] = ( ( 1.0 - mu ) * comm); + return (ab); +} + +// mutransform +// +// param mvec List of means. +// +// return Numeric vector transformed +arma::vec mutransformA(const arma::vec mvec){ + arma::vec mveout = ((exp(mvec * -1.0)) + 1.0); + return 1/mveout; +} + +// mvecin +// +// param mvec List of means. +// +// return Numeric vector transformed +arma::vec mvecinA(const arma::vec mvec){ + arma::vec l = log(mvec); + arma::vec r = log(1.0 - mvec); + return (l-r); +} + +// stransform +// +// param svec List of variance. +// +// return Numeric vector transformed. +arma::vec stransformA(const arma::vec svec){ + return(exp(svec)); +} + +// svecin +// +// param svec List of variance. +// +// return Numeric vector transformed +arma::vec svecinA(const arma::vec svec){ + return(log(svec)); +} + + + +// dbetaV +// +// param xi Vector of doubles. +// param a Alpha parameter. +// param b Beta parameter +// param log Interger indicating to log or not to log. +// +// return Numeric vector from dbeta. +arma::vec dbetaV(arma::vec xi, double a, double b, int log){ + int xil = xi.size(); + arma::vec out(xil); + for(int i = 0; i < xil; i++){ + out(i) = R::dbeta(xi(i), a, b, log); + } + return out; +} + + +// Flag sample +arma::vec sampFT(std::string type, int m){ + arma::vec iglpl(3); + if(type == ""free""){ + iglpl(0) = 0; + if(m == 1){ + iglpl(1) = 2; + iglpl(2) = 1; + } else{ + iglpl(1) = ((3*m)-1); + iglpl(2) = 1; + } + } else if(type == ""fixed""){ //alpha + iglpl(0) = 1; + iglpl(1) = (m-1); + iglpl(2) = (2*m); + } else if(type == ""fixed_2""){ //both + iglpl(0) = 2; + if(m == 1){ + iglpl(1) = 1; + iglpl(2) = 2; + } else{ + iglpl(1) = ((2*m)-1); + iglpl(2) = m; + } + } else if(type == ""fixed_3""){ + iglpl(0) = 3; + iglpl(1) = m; + iglpl(2) = (2*m); + } else{ + Rcpp::Rcerr << ""Parameter is not allowed. Type may equal free, fixed, fixed_2, or fixed_3"" << std::endl; + } + return iglpl; +} + +// Flag type +// Distribution-Uniform-only +arma::vec sampFTBU(std::string type, int m){ + arma::vec iglpl(3); + if(type == ""free""){ + iglpl(0) = 0; + iglpl(1) = (3*m); + iglpl(2) = 1; + } else if(type == ""fixed""){ //alpha + iglpl(0) = 1; + iglpl(1) = m; + iglpl(2) = (2*m); + } else if(type == ""fixed_2""){ //both + iglpl(0) = 2; + iglpl(1) = (2*m); + iglpl(2) = m; + } else if(type == ""fixed_3""){ + iglpl(0) = 3; + iglpl(1) = m; + iglpl(2) = ((2*m)+1); + } else{ + Rcpp::Rcerr << ""Parameter is not allowed. Type may equal free, fixed, fixed_2, or fixed_3"" << std::endl; + } + return iglpl; +} + +","C++" +"Allele","mgaynor1/nQuack","src/bootstrap.cpp",".cpp","621","24","// [[Rcpp::plugins(cpp11)]] +// [[Rcpp::depends(RcppArmadillo)]] +#include +#include + +using namespace arma; + +//' Calculate Alpha and Beta from Mean and Variance +//' +//' @param xm Matrix with total coverage and coverage at a randomly sampled allele. +//' @param n Length of matrix. +//' +//' @return Randomly sampled matrix. +// [[Rcpp::export]] +arma::mat resample_xm(arma::mat xm, int n){ + arma::uvec index = arma::linspace(0, n-1, n); + arma::uvec locs = Rcpp::RcppArmadillo::sample(index,n,true); + arma::mat resample = xm.rows(locs); + return resample; +} + + + +","C++" +"Allele","mgaynor1/nQuack","src/EMNormalUniform.cpp",".cpp","7108","215","// [[Rcpp::plugins(cpp11)]] +// [[Rcpp::depends(RcppArmadillo)]] +#include +using namespace arma; + +#include ""emshared.h"" +#include ""ushared.h"" +#include + + +// title E-Step for Expectation Maximization - Normal+Uniform Distribution +// description This function is used in expectation maximization. Here we complete +// the E-Step and calculate the log-likelihood. Modifications include a correction for +// the truncated distribution. +Rcpp::List estepNU(const Rcpp::List parmlist, const arma::vec xi, std::string type, + const arma::vec trunc){ + + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + + const int m = mvec.size(); + + //int pl = (n == m ? 1 : 2); + + const int xl = xi.size(); + arma::mat zprob( xl, (m+1) ); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0){ + for(int i = 0; i < m; i++) { + arma::vec ppv = dnormV(xi, mvec(i), svec(i), 0); + zprob.col(i) = (avec(i) * ppv); + } + } else{ + for(int i = 0; i < m; i++) { + double F2F1 = R::pnorm(trunc(1), mvec(i), svec(i), 1, 0) - R::pnorm(trunc(0), mvec(i), svec(i), 1, 0); + arma::vec pp = dnormV(xi, mvec(i), svec(i), 0); + pp = (pp/F2F1); + zprob.col(i) = (avec(i) * pp); + } +} + + // Uniform distribution + double avecsum = 0.00; + for(int i = 0; i < m; i++){ + avecsum += avec(i); + } + + double ae = (1 - avecsum); + zprob.col(m) = (ae*prob_unif_vec(xi)); + + arma::vec denom = arma::sum(zprob, 1); + + arma::mat zprobb( xl, m+1 ); + arma::vec sjvec(m+1); + for(int i = 0; i < m+1; i++){ + zprobb.col(i) = ( zprob.col(i) /denom ) ; + sjvec(i) = sum(zprobb.col(i)); + } + double ll = sum(log(denom)); + + Rcpp::List P = Rcpp::List::create( Rcpp::Named(""avec"") = avec, Rcpp::_[""mvec""] = mvec, Rcpp::_[""svec""] = svec); + return( Rcpp::List::create( Rcpp::_[""zprob""] = zprobb, Rcpp::_[""parm.list""] = P, Rcpp::_[""xi""] = xi, Rcpp::_[""denom""] = denom, Rcpp::_[""trunc""] = trunc, Rcpp::_[""type""]=type, Rcpp::_[""sjvec""]=sjvec, Rcpp::_[""LL""]=ll)); + +} + + +// M-Step with Numerical Optimization for Expectation Maximization - Normal Distribution +// +// description This function is used in expectation maximization to maximize the parameter values. +// param eout List with output from the estep +Rcpp::List mstepNU(Rcpp::List eout){ + + const Rcpp::List parmlist = eout[""parm.list""]; + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + const arma::mat Zprobsmat = eout[""zprob""]; + const arma::vec xi = eout[""xi""]; + //const arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + //const arma::vec trunc = eout[""trunc""]; + const arma::vec sjvec = eout[""sjvec""]; + + int nmixt = avec.size(); + int m = mvec.size(); + int n = xi.n_rows; + + arma::vec ahats(m); + arma::vec mhats(m); + arma::vec shats(m); + + if(type == ""free""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = arma::square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = ((1/sj)*(sum(gamma % xi))); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + + } + } else if(type == ""fixed""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = mvec(i); + shats(i) = svec(i); + } + } else if(type == ""fixed_2""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = mvec(i); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + } + } else if(type == ""fixed_3""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = avec(i); + mhats(i) = mvec(i); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + } + } + + // Logic check + if(ahats.has_nan() == true || all(ahats) == false){ //if all are non.zero = false + //Rcpp::Rcout << ahats << std::endl; + ahats = avec; + } + if(shats.has_nan() == true || all(shats) == false){ + //Rcpp::Rcout << shats << std::endl; + shats = svec; + } + if(mhats.has_nan() == true || all(mhats) == false){ + //Rcpp::Rcout << mhats << std::endl; + mhats = mvec; + + } + // Add the Uniform + double ah = sum(ahats); + ahats.resize(nmixt); + ahats(nmixt-1) = (1 - ah); + + Rcpp::List res = Rcpp::List::create(Rcpp::_[""avec""] = ahats, Rcpp::_[""mvec""] = mhats, Rcpp::_[""svec""] = shats); + return(res); +} + + + + +//' @title Expectation maximization - Normal and Uniform Distribution +//' +//' @description This function calculates the log-likelihood using +//' the expectation maximization algorithm with the Normal-Uniform Distribution. +//' This code follows nQuire and does not use an augmented likelihood. +//' +//' @param parmlist A list containing initial alpha, mean, and variance values. The list of alpha must include a proportion for the uniform mixture. +//' @param xi List of observations, in this case allele frequencies. +//' @param niter Max number of iterates. +//' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +//' below this value, convergence is reached. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +//' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +//' +//' @returns List of elements including the log-likelihood, the number of iterates, +//' and the optimized parameter values. +//' +// [[Rcpp::export]] +Rcpp::List emstepNU(Rcpp::List parmlist, const arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type = ""free""){ + // Set up progress + + Rcpp::List mint = parmlist; + // E-step + Rcpp::List eint = estepNU(mint, xi, type, trunc); + double lnlikeint = llcalcfinalNU(eint); + + int count = 0; + // Iterating E and M steps until convergence is below epsilon + for(int j = 0; j < (niter + 1); j++){ + Rcpp::checkUserInterrupt(); + //p.increment(); + count = count + 1; + + // M-step + Rcpp::List moutip = mstepNU(eint); + + + // E-step + Rcpp::List eoutip = estepNU(moutip, xi, type, trunc); + double lnlikeip = llcalcfinalNU(eoutip); + double deltalogL = (lnlikeint - lnlikeip); + deltalogL = std::abs(deltalogL); + + // Set next iter + eint = eoutip; + lnlikeint = lnlikeip; + + if(deltalogL +using namespace arma; + +#include ""emshared.h"" +#include ""ushared.h"" +#include + + +// title E-Step for Expectation Maximization - Normal Distribution +// description This function is used in expectation maximization. Here we complete +// the E-Step and calculate the log-likelihood. Modifications include a correction for +// the truncated distribution. +Rcpp::List estepN(const Rcpp::List parmlist, const arma::vec xi, std::string type, + const arma::vec trunc){ + + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + + const int m = mvec.size(); + + //int pl = (n == m ? 1 : 2); + + const int xl = xi.size(); + arma::mat zprob( xl, m ); + + if(std::accumulate(trunc.begin(), trunc.end(), 0.0) == 0){ + for(int i = 0; i < m; i++) { + arma::vec ppv = dnormV(xi, mvec(i), svec(i), 0); + zprob.col(i) = (avec(i) * ppv); + } + } else{ + for(int i = 0; i < m; i++) { + double F2F1 = R::pnorm(trunc(1), mvec(i), svec(i), 1, 0) - R::pnorm(trunc(0), mvec(i), svec(i), 1, 0); + arma::vec pp = dnormV(xi, mvec(i), svec(i), 0); + pp = (pp/F2F1); + zprob.col(i) = (avec(i) * pp); + } +} + + + arma::vec denom = arma::sum(zprob, 1); + + arma::mat zprobb( xl, m ); + arma::vec sjvec(m ); + for(int i = 0; i < m ; i++){ + zprobb.col(i) = ( zprob.col(i) /denom ) ; + sjvec(i) = sum(zprobb.col(i)); + } + double ll = sum(log(denom)); + + Rcpp::List P = Rcpp::List::create( Rcpp::Named(""avec"") = avec, Rcpp::_[""mvec""] = mvec, Rcpp::_[""svec""] = svec); + return( Rcpp::List::create( Rcpp::_[""zprob""] = zprobb, Rcpp::_[""parm.list""] = P, Rcpp::_[""xi""] = xi, Rcpp::_[""denom""] = denom, Rcpp::_[""trunc""] = trunc, Rcpp::_[""type""]=type, Rcpp::_[""sjvec""]=sjvec, Rcpp::_[""LL""]=ll)); + +} + + + + + +// M-Step with Numerical Optimization for Expectation Maximization - Normal Distribution +// +// description This function is used in expectation maximization to maximize the parameter values. +// param eout List with output from the estep +Rcpp::List mstepN(Rcpp::List eout){ + + const Rcpp::List parmlist = eout[""parm.list""]; + const arma::vec avec = parmlist[""avec""]; + const arma::vec mvec = parmlist[""mvec""]; + const arma::vec svec = parmlist[""svec""]; + const arma::mat Zprobsmat = eout[""zprob""]; + const arma::vec xi = eout[""xi""]; + //const arma::vec denom = eout[""denom""]; + std::string type = eout[""type""]; + //const arma::vec trunc = eout[""trunc""]; + const arma::vec sjvec = eout[""sjvec""]; + + //int nmixt = avec.size(); + int m = mvec.size(); + int n = xi.n_rows; + + arma::vec ahats(m); + arma::vec mhats(m); + arma::vec shats(m); + + if(type == ""free""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = arma::square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = ((1/sj)*(sum(gamma % xi))); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + + } + } else if(type == ""fixed""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = mvec(i); + shats(i) = svec(i); + } + } else if(type == ""fixed_2""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = (sj/n); + mhats(i) = mvec(i); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + } + } else if(type == ""fixed_3""){ + for(int i = 0; i < m; i++){ + arma::vec gamma = Zprobsmat.col(i); + double sj = sjvec(i); + arma::vec sp = square(xi - mvec(i)); + ahats(i) = avec(i); + mhats(i) = mvec(i); + shats(i) = sqrt((1/sj)*(sum(gamma % sp))); + } + } + + // Logic check + if(ahats.has_nan() == true || all(ahats) == false){ //if all are non.zero = false + //Rcpp::Rcout << ahats << std::endl; + ahats = avec; + } + if(shats.has_nan() == true || all(shats) == false){ + //Rcpp::Rcout << shats << std::endl; + shats = svec; + } + if(mhats.has_nan() == true || all(mhats) == false){ + //Rcpp::Rcout << mhats << std::endl; + mhats = mvec; + + } + // Add the Uniform + //double ah = sum(ahats); + // ahats.resize(nmixt); + //ahats(nmixt-1) = (1 - ah); + + Rcpp::List res = Rcpp::List::create(Rcpp::_[""avec""] = ahats, Rcpp::_[""mvec""] = mhats, Rcpp::_[""svec""] = shats); + return(res); +} + + + + +//' @title Expectation maximization - Normal Distribution +//' +//' @description This function calculates the log-likelihood using +//' the expectation maximization algorithm with the Normal Distribution. +//' This code follows nQuire and does not use an augmented likelihood. +//' +//' @param parmlist A list containing initial alpha, mean, and variance values. +//' @param xi List of observations, in this case allele frequencies. +//' @param niter Max number of iterates. +//' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +//' below this value, convergence is reached. +//' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +//' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +//' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +//' +//' @returns List of elements including the log-likelihood, the number of iterates, +//' and the optimized parameter values. +//' +// [[Rcpp::export]] +Rcpp::List emstepN(Rcpp::List parmlist, const arma::vec xi, int niter, double epsilon, arma::vec trunc, std::string type = ""free""){ + // Set up progress + + Rcpp::List mint = parmlist; + // E-step + Rcpp::List eint = estepN(mint, xi, type, trunc); + double lnlikeint = llcalcfinalN(eint); + + int count = 0; + // Iterating E and M steps until convergence is below epsilon + for(int j = 0; j < (niter + 1); j++){ + Rcpp::checkUserInterrupt(); + //p.increment(); + count = count + 1; + + // M-step + Rcpp::List moutip = mstepN(eint); + + + // E-step + Rcpp::List eoutip = estepN(moutip, xi, type, trunc); + double lnlikeip = llcalcfinalN(eoutip); + double deltalogL = (lnlikeint - lnlikeip); + deltalogL = std::abs(deltalogL); + + // Set next iter + eint = eoutip; + lnlikeint = lnlikeip; + + if(deltalogL +using namespace arma; + +arma::vec dnormV(arma::vec xi, double a, double b, int log); +double llcalcfinalNU(Rcpp::List eout); +double llcalcfinalN(Rcpp::List eout); + + +#endif +","Unknown" +"Allele","mgaynor1/nQuack","src/datahelper.cpp",".cpp","856","28","#include +using namespace Rcpp; + +//' @title Data Preparation - Use nQuire's Data +//' +//' @description This function reduce a three column data frame to +//' two columns by randomly sampling allele A or B for every site. This is used in our function `process_nquire()` +//' +//' @param xm A matrix with three columns: Total Coverage, Counts for Allele A, and Counts for Allele B. +//' +//' @returns Numeric Matrix with total coverage and coverage for a randomly sampled allele. +// [[Rcpp::export]] +NumericMatrix nQuire_reformat(NumericMatrix xm){ + int xl = xm.nrow(); + NumericMatrix xmo(xl, 2); + xmo(_, 0) = xm(_, 0); + NumericVector prob = {0.5, 0.5}; + for(int i = 0; i < xl; i++){ + NumericVector y(2); + y[0] = xm(i, 1); + y[1] = xm(i, 2); + double samp = as(sample(y, 1, false, prob)); + xmo(i, 1) = samp; + } + return(xmo); +} + +","C++" +"Allele","mgaynor1/nQuack","R/quackit.R",".R","2537","66","#' Model Selection - Based on BIC or Log-Likelihood +#' +#' @description This function is for model interpretation. +#' +#' @param model_out Data frame containing, at minimum, columns labeled LL, type, mixture, distribution, and BIC. +#' @param summary_statistic May be equal to BIC or LL. +#' @param mixtures Defaults to `c(""diploid"", ""triploid"", ""tetraploid"", ""hexaploid"", ""pentaploid"")`. +#' +#' @return Returns data frame with the most likely model for each set of mixtures. Includes the best and second best mixtures, as well as the difference between the two. +#' +#' +quackit <- function(model_out, summary_statistic = ""BIC"", + mixtures = c(""diploid"", ""triploid"", ""tetraploid"", ""hexaploid"", ""pentaploid"")){ + if(summary_statistic == ""dLL""){ + summary_statistic <- ""LL"" + }else{ + summary_statistic <- summary_statistic + } + # Set up + if(length(mixtures) != 5){ + model_out <- model_out[which(model_out$mixture %in% mixtures), ] + }else{ + model_out <- model_out + } + if(length(which(model_out$mixture== ""free"")) != 0){ + model_out <- model_out[which(model_out$mixture != ""free""), ] + } else{ + model_out <- model_out + } + + # Subsample by distribution type and fixed type + results <- c() + + dl <- unique(model_out$distribution) + for(j in 1:length(dl)){ + dset <- model_out[which(model_out$distribution == dl[j]), ] + fl <- unique(dset$type) + winners <- as.data.frame(matrix(nrow = length(fl), ncol = 6 )) + for(k in 1:length(fl)){ + dfsub <- dset[which(dset$type == fl[k]), ] + winnerBIC <- (dfsub[which(dfsub[[summary_statistic]] == min(dfsub[[summary_statistic]] )), ])[[summary_statistic]] + subsub <- dfsub[-c(which(dfsub[[summary_statistic]] == min(dfsub[[summary_statistic]] ))), ] + secondBIC <- min(subsub[[summary_statistic]] ) + BICdif <- (winnerBIC - secondBIC) + winners[k, 1] <- (winnerBIC - secondBIC) + winners[k, 2] <- (dfsub[which(dfsub[[summary_statistic]] == winnerBIC), ])$mixture + winners[k, 3] <- (dfsub[which(dfsub[[summary_statistic]] == secondBIC), ])$mixture + winners[k, 4] <- unique(dfsub$distribution) + winners[k, 5] <- unique(dfsub$type) + winners[k, 6] <- unique(dfsub$sample) + + } + results[[j]] <- winners + } + + out2go <- do.call(rbind, results) + + if(summary_statistic == ""BIC""){ + colnames( out2go) <- c(""BICdif"", ""winnerBIC"", ""secondBIC"", ""Distribution"", ""Type"", ""sample"") + } else if(summary_statistic == ""LL""){ + colnames( out2go) <- c(""LLdif"", ""winnerLL"", ""secondLL"", ""Distribution"", ""Type"", ""sample"") + } + return(out2go) + +} +","R" +"Allele","mgaynor1/nQuack","R/setconvert.R",".R","710","21","#' Calculate Variance from Mean, Tau, and Sequencing Error +#' +#' @description This function is used to replace variance in mixture model sets. +#' +#' @param set A list of lists, each of the lists must contain avec, mvec, and svec. +#' @param tau Sequence overdispersion parameter for read counts. +#' @param error Sequencing error rate. +#' +#' @returns Mean and variance for the associated tau and error. +setconvert <- function(set, tau, error){ + setout <- list() + for(i in 1:length(set)){ + varout <- muvarcalcvec(set[[i]]$mvec, tau, error) + setout[[i]] <- list(avec = c(set[[i]]$avec), + mvec = c(set[[i]]$mvec), + svec = c(varout$var)) + + } + return(setout) +} +","R" +"Allele","mgaynor1/nQuack","R/bestquack.R",".R","12711","299","#' Model Selection - Expectation Maximization - Choose your distribution and type +#' +#' @description This function was made to run a subset of models based on a selected distribution and type. +#' There are many limitations to this function to make this tractable, as there are 128 models that could be run with our package. +#' Here we do not include models or comparisons we found unhelpful, this includes the nQuire implementation and log-likelihood ratio tests. +#' +#' @param xm Matrix with two columns with total coverage and coverage +#' for a randomly sampled allele. +#' @param distribution May be set to normal, beta, or beta-binomial. We do not include the implementation with nQuire. +#' @param type May be equal to fixed, fixed_2, or fixed_3. +#' @param uniform If equal to 1, a uniform mixture is included. If equal to 0, no uniform mixture is included. +#' @param mixtures Defaults to `c(""diploid"", ""triploid"", ""tetraploid"", ""hexaploid"", ""pentaploid"")`. +#' @param samplename Name of sample to be included in output. +#' @param trunc List of two values representing the lower and upper bounds for +#' allele frequency truncation ,$c\_{L}$ and \eqn{c_{U}}. If allele frequency +#' truncation was done to remove error, then you do not need to truncate +#' the expected. If no truncation has been done, this should be set to c(0,0), +#' which is the default. +#' @param tau Sequencing overdispersion parameter. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. +#' If not, the variance by default is equal to 0.01 or 0.001. +#' @param error Sequencing error rate. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. If not, the variance by default is equal to 0.01 or 0.001. +#' @param lowvar Default to FALSE. When false, variance is equal to 0.01. +#' If set to TRUE and tau and error are not provided, +#' the variance will be set as 0.001. +#' +#' @return BIC scores and log-likelihood (LL) for the included mixture models. +#' For BIC, the smallest score is the most likely model. +#' For LL, the largest score is the most likely model. +#' +#' @importFrom stats dbeta pbeta + + +bestquack <- function(xm, distribution, type, uniform, + mixtures = c(""diploid"", ""triploid"", ""tetraploid"", ""hexaploid"", ""pentaploid""), + samplename, + trunc = c(0.0,0.0), lowvar = FALSE, + tau = NA, error = NA){ + + cat(paste0("" \t\t <(.)__ <(.)__ <(-)__"", + ""\n \t\t (___/ (___/ (___/ nQuack-in-progress"", ""\n"")) + + # Input data setup + xm <- as.matrix(xm) + xi <- (xm[,2]/xm[,1]) + n <- length(xi) + lnn <- log(n) + + # Input parameters + set <- list() + setU <- list() + + if(lowvar == FALSE){ + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.01)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01,0.01)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01,0.01, 0.01, 0.01)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.01)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01, 0.01)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01,0.01, 0.01, 0.01)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + vv <- 0.01 + }else if(lowvar == TRUE){ + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.001)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001,0.001)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.001)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001, 0.001)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + vv <- 0.001 + } + + if((is.na(tau) + is.na(error)) == 2 ){ + set <- set + setU <- setU + }else{ + set <- setconvert(set, tau, error) + setU <- setconvert(setU, tau, error) + } + + # Mixture subset + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""hexaploid"", ""pentaploid"") + if(length(mixtures) != 5){ + subme <- which(mixturekey %in% mixtures) + + set <- set[subme] + setU <- setU[subme] + }else{ + set <- set + setU <- setU + } + + + if(distribution == ""normal""){ + # Set up parm list for BIC calculations + parmlistN <- c() + parmlistN[[1]] <- c(1,2, 3, 4, 5) + parmlistN[[2]] <- c(2,4, 6, 8, 10) + parmlistN[[3]] <- c(1,2, 3, 4, 5) + + parmlistU <- c() + parmlistU[[1]] <- c(2,3, 4, 5, 6) + parmlistU[[2]] <- c(3,5, 7, 9, 11) + parmlistU[[3]] <- c(1,2, 3, 4, 5) + + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""hexaploid"", ""pentaploid"") + + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + subme2 <- which(bvec %in% type) + parmlistN <- parmlistN[[subme2]] + parmlistU <- parmlistU[[subme2]] + if(length(mixtures) != 5){ + subme <- which(mixturekey %in% mixtures) + + parmlistN <- parmlistN[subme] + parmlistU <- parmlistU[subme] + }else{ + parmlistN <- parmlistN + parmlistU <- parmlistU + } + + niter = 1000 + epsilon = 0.1 + + if(uniform == 0){ + d <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + for(i in 1:length(mixtures)){ + obj <- nQuack::emstepNA(set[[i]], xi, niter, epsilon, trunc, type = type) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[i])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type=type, mixture=mixtures[i], distribution = ""normal"", BIC = BICout)) + } + }else if(uniform == 1){ + d <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + + + for(i in 1:length(mixtures)){ + obj <- nQuack::emstepNUA(setU[[i]], xi, niter, epsilon, trunc, type = type) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[i])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type=type, mixture=mixtures[i], distribution = ""normal-uniform"", BIC = BICout)) + } + } + + + }else if(distribution == ""beta""){ + # Set up parm list for BIC calculations + parmlistN <- c() + parmlistN[[1]] <- c(0, 2, 3, 4, 5) + parmlistN[[2]] <- c(2, 4, 6, 8, 10) #fixed_2 + parmlistN[[3]] <- c(1, 2, 3, 4, 5) #fixed_3 + + parmlistU <- c() + parmlistU[[1]] <- c(2, 3, 4, 5, 6) + parmlistU[[2]] <- c(3, 5, 7, 9, 11) + parmlistU[[3]] <- c(1, 2, 3, 4, 5) + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""hexaploid"", ""pentaploid"") + + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + subme2 <- which(bvec %in% type) + parmlistN <- parmlistN[[subme2]] + parmlistU <- parmlistU[[subme2]] + if(length(mixtures) != 5){ + subme <- which(mixturekey %in% mixtures) + + parmlistN <- parmlistN[subme] + parmlistU <- parmlistU[subme] + }else{ + parmlistN <- parmlistN + parmlistU <- parmlistU + } + + # EM setup + niter = 1000 + epsilon = 0.1 + tt <- ifelse(sum(trunc) > 0, TRUE, FALSE) + + if(uniform == 0){ + d <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + + for(i in 1:length(mixtures)){ + if(mixtures[i] == ""diploid"" & type == ""fixed""){ + ab <- alphabetacalc(set[[1]]$mvec, set[[1]]$svec) + if(tt == TRUE){ + obj <- list(loglikelihood = c(sum(log(dbeta(xi, ab[1,1], ab[2,1], log = FALSE)/(pbeta(trunc[2], ab[1,1], ab[2,1], 1, 0) - pbeta(trunc[1], ab[1,1], ab[2,1], 1, 0)))))) + }else{ + obj <- list(loglikelihood = c(sum(dbeta(xi, ab[1,1], ab[2,1], log = TRUE)))) + } + } else{ + obj <- emstepB(set[[i]], xi, niter, epsilon, trunc, type = type) + } + + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[i])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type=type, mixture=mixtures[i], distribution = ""beta"", BIC = BICout)) + } + + }else if (uniform == 1){ + + d <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + + for(i in 1:length(mixtures)){ + obj <- emstepBU(setU[[i]], xi, niter, epsilon, trunc, type = type) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[i])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type=type, mixture=mixtures[i], distribution = ""beta-uniform"", BIC = BICout)) + } + } + + + }else if(distribution == ""beta-binomial""){ + n <- nrow(xm) + lnn <- log(n) + # Set up parm list for BIC calculations + parmlistN <- c() + parmlistN[[1]] <- c(0, 2, 3, 4, 5) + parmlistN[[2]] <- c(2, 4, 6, 8, 10) #fixed_2 + parmlistN[[3]] <- c(1, 2, 3, 4, 5) #fixed_3 + + parmlistU <- c() + parmlistU[[1]] <- c(2, 3, 4, 5, 6) + parmlistU[[2]] <- c(3, 5, 7, 9, 11) + parmlistU[[3]] <- c(1, 2, 3, 4, 5) + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""hexaploid"", ""pentaploid"") + + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + subme2 <- which(bvec %in% type) + parmlistN <- parmlistN[[subme2]] + parmlistU <- parmlistU[[subme2]] + if(length(mixtures) != 5){ + subme <- which(mixturekey %in% mixtures) + + parmlistN <- parmlistN[subme] + parmlistU <- parmlistU[subme] + }else{ + parmlistN <- parmlistN + parmlistU <- parmlistU + } + + # EM setup + niter = 1000 + epsilon = 0.1 + tt <- ifelse(sum(trunc) > 0, TRUE, FALSE) + + if(uniform == 0){ + d <- as.data.frame(matrix(ncol = 5, nrow = 0)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + + for(i in 1:length(mixtures)){ + if(mixtures[i] == ""diploid"" & type == ""fixed""){ + ab <- alphabetacalc(0.5, vv) + if(tt == TRUE){ + obj <- list(loglikelihood = sum(log(extraDistr::dbbinom(xm[,2], xm[,1], ab[1,1], ab[2,1], log = FALSE)/(extraDistr::pbbinom((xm[,1]*trunc[2]), xm[,1], ab[1,1], ab[2,1]) - extraDistr::pbbinom((xm[,1]*trunc[1]), xm[,1], ab[1,1], ab[2,1]))))) + }else{ + obj <- list(loglikelihood = sum(extraDistr::dbbinom(xm[,2], xm[,1], ab[1,1], ab[2,1], log = TRUE))) + } + }else{ + obj <- emstepBB(set[[i]], xm, niter, epsilon, trunc, type = type) + } + + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[i])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type= type, mixture=mixtures[i], distribution = ""beta-binomial"", BIC = BICout)) + } + + + + + + }else if (uniform == 1){ + d <- as.data.frame(matrix(ncol = 5, nrow = 0)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + for(i in 1:length(mixtures)){ + obj <- emstepBBU(setU[[i]], xm, niter, epsilon, trunc, type = type) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[i])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type=type, mixture=mixtures[i], distribution = ""beta-binomial-uniform"", BIC = BICout)) + + } + } + + }else{ + message(""distribution may equal normal, beta, or beta-binomial"") + } + + out <- d + out$sample <- samplename + return(out) +} +","R" +"Allele","mgaynor1/nQuack","R/quackBeta.R",".R","11364","247","#' Model Selection - Expectation Maximization - Beta Mixture +#' +#' @description This function uses the expectation maximization of both the beta and beta-uniform mixture models for model selection. +#' Here we can run up to 32 mixture models. +#' +#' @param xm Matrix with two columns with total coverage and coverage +#' for a randomly sampled allele. +#' @param samplename Name of sample to be included in output. +#' @param cores Threads available to run process in parallel. +#' @param parallel default = FALSE, set to true if cores > 1. +#' @param trunc List of two values representing the lower and upper bounds for +#' allele frequency truncation , c_L and c_U. If allele frequency +#' truncation was done to remove error, then you do not need to truncate +#' the expected. If no truncation has been done, this should be set to c(0,0), +#' which is the default. +#' @param tau Sequencing overdispersion parameter. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. +#' If not, the variance by default is equal to 0.01 or 0.001. +#' @param error Sequencing error rate. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. If not, the variance by default is equal to 0.01 or 0.001. +#' @param lowvar Default to FALSE. When false, variance is equal to 0.01. +#' If set to TRUE and tau and error are not provided, +#' the variance will be set as 0.001. +#' @param free default = FALSE, skip the free model calculation and does not +#' calculate delta log-likelihood. +#' +#' @return BIC scores and log-likelihood (LL) mixture models including diploid, +#' triploid, tetraploid, pentaploid, and hexaploid. When free = TRUE, +#' the delta log-likelihood (dLL) is calculated based on +#' the associated free model (without or with a uniform mixture). +#' For BIC or delta-log likelihood, the smallest score is the most likely model. +#' For LL, the largest score is the most likely model. +#' +#' +#' @importFrom foreach foreach %dopar% %:% +#' @importFrom future plan availableCores multisession +#' @importFrom parallel makeCluster +#' @importFrom doParallel registerDoParallel +#' @importFrom stats dbeta pbeta +#' + +quackBeta <- function(xm, samplename, cores, parallel= FALSE, + trunc = c(0.0,0.0), lowvar = FALSE, + tau = NA, error = NA, free = FALSE){ + cat(paste0("" \t\t <(.)__ <(.)__ <(-)__"", + ""\n \t\t (___/ (___/ (___/ nQuack-in-progress"", ""\n"")) + parallel <- ifelse(cores > 1, TRUE, FALSE) + message(paste0(""parallel set to "", parallel)) + # Input data setup + xm <- as.matrix(xm) + xi <- (xm[,2]/xm[,1]) + n <- length(xi) + lnn <- log(n) + + # Input parameters + set <- list() + setU <- list() + if(lowvar == FALSE){ + ## Model Params + pu = list(avec = c(0.11, 0.22, 0.33, 0.22, 0.11, 0.01), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + p = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.01)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01,0.01)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01,0.01, 0.01, 0.01)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.01)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01, 0.01)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01,0.01, 0.01, 0.01)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + }else if(lowvar == TRUE){ + pu = list(avec = c(0.11, 0.22, 0.33, 0.22, 0.11, 0.01), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + p = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.001)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001,0.001)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.001)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001, 0.001)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + } + + + if((is.na(tau) + is.na(error)) == 2 ){ + set <- set + setU <- setU + }else{ + set <- setconvert(set, tau, error) + setU <- setconvert(setU, tau, error) + } + + # Set up parm list for BIC calculations + parmlistN <- c() + parmlistN[[1]] <- c(0, 2, 3, 4, 5) + parmlistN[[2]] <- c(2, 4, 6, 8, 10) #fixed_2 + parmlistN[[3]] <- c(1, 2, 3, 4, 5) #fixed_3 + + parmlistU <- c() + parmlistU[[1]] <- c(2, 3, 4, 5, 6) + parmlistU[[2]] <- c(3, 5, 7, 9, 11) + parmlistU[[3]] <- c(1, 2, 3, 4, 5) + + # EM setup + niter = 1000 + epsilon = 0.1 + + if(free == TRUE){ + type = ""free"" + + message(""Free Model Calculations Started"") + # Free models + LL1 <- data.frame(LL = (emstepB(p, xi, niter, epsilon, trunc, ""free""))$loglikelihood, type = ""free"", mixture = ""free"", distribution = ""beta"") + LL2 <- data.frame(LL = (emstepBU(pu, xi, niter, epsilon, trunc, ""free""))$loglikelihood, type = ""free"", mixture = ""free"", distribution = ""beta-uniform"") + + LL1$BIC <- 0 + LL2$BIC <- 0 + + }else if(free == FALSE){ + message(""Free Model Skipped. Log-likelihood ratio will not be included"") + } + + # Fixed models + if(is.na(cores)){ + cores <- (future::availableCores()-1) + } + + if(parallel == TRUE){ + cl <- parallel::makeCluster(cores) + + ## Register parallel + doParallel::registerDoParallel(cl) + + opts <- list(chunkSize=2) + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""pentaploid"", ""hexaploid"") + tt <- ifelse(sum(trunc) > 0, TRUE, FALSE) + + message(""Calculating likelihood of each mixture with a beta distibution."") + d <- foreach(type=1:3, .combine='rbind', .options.nws=opts) %:% + foreach::foreach(iter = 1:5, .combine='rbind', .packages = ""nQuack"") %dopar% { + if(iter == 1 & type == 1){ + ab <- nQuack::alphabetacalc(set[[1]]$mvec, set[[1]]$svec) + if(tt == TRUE){ + obj <- list(loglikelihood = c(sum(log(dbeta(xi, ab[1,1], ab[2,1], log = FALSE)/(pbeta(trunc[2], ab[1,1], ab[2,1], 1, 0) - pbeta(trunc[1], ab[1,1], ab[2,1], 1, 0)))))) + }else{ + obj <- list(loglikelihood = c(sum(dbeta(xi, ab[1,1], ab[2,1], log = TRUE)))) + } + } else{ + obj <- nQuack::emstepB(set[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + } + + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[[type]][iter])) + data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""beta"", BIC = BICout) + } + + message(""Calculating likelihood of each mixture with a beta + uniform distibution."") + opts <- list(chunkSize=2) + du <- foreach(type=1:3, .combine='rbind', .options.nws=opts) %:% + foreach::foreach(iter = 1:5, .combine='rbind', .packages = ""nQuack"") %dopar% { + obj <- nQuack::emstepBU(setU[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[[type]][iter])) + data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""beta-uniform"", BIC = BICout) + } + + # Stop cluster + parallel::stopCluster(cl) + + }else if(parallel == FALSE){ + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""pentaploid"", ""hexaploid"") + tt <- ifelse(sum(trunc) > 0, TRUE, FALSE) + + d <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + + message(""Calculating likelihood of each mixture with a beta distibution."") + for(type in 1:3){ + for(iter in 1:5){ + if(iter == 1 & type == 1){ + ab <- alphabetacalc(set[[1]]$mvec, set[[1]]$svec) + if(tt == TRUE){ + obj <- list(loglikelihood = c(sum(log(dbeta(xi, ab[1,1], ab[2,1], log = FALSE)/(pbeta(trunc[2], ab[1,1], ab[2,1], 1, 0) - pbeta(trunc[1], ab[1,1], ab[2,1], 1, 0)))))) + }else{ + obj <- list(loglikelihood = c(sum(dbeta(xi, ab[1,1], ab[2,1], log = TRUE)))) + } + } else{ + obj <- emstepB(set[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + } + + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[[type]][iter])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""beta"", BIC = BICout)) + } + } + + message(""Calculating likelihood of each mixture with a beta + unform distibution."") + + du <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(du) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + + for(type in 1:3){ + for(iter in 1:5){ + obj <- emstepBU(setU[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[[type]][iter])) + du <- rbind(du, data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""beta-uniform"", BIC = BICout)) + } + } + + + } + + if(free == TRUE){ + + dLL <- c() + for(kk in 1:nrow(d)){ + dLL[kk] <-(LL1$LL - d$LL[kk]) + } + d$dLL <- dLL + + dULL <- c() + for(kk in 1:nrow(du)){ + dULL[kk] <-(LL2$LL - du$LL[kk]) + } + du$dLL <- dULL + + LL1$dLL <- 0 + LL2$dLL <- 0 + + + out <- rbind(LL1, LL2, d, du) + + }else if(free == FALSE){ + out <- rbind( d, du) + } + out$sample <- samplename + return(out) +} + + +","R" +"Allele","mgaynor1/nQuack","R/quackNboots.R",".R","1922","48","#' Bootstrapping - Expectation Maximization - Choose your distribution and type +#' +#' @description This function was made to assist with bootstrap replication for a set of models run a subset of models based on a selected distribution and type. +#' There are many limitations to this function to make this tractable, as there are 128 models that could be run with our package. +#' Here we do not include models or comparisons we found unhelpful, this includes the nQuire implementation and log-likelihood ratio tests. +#' +#' @inheritParams bestquack +#' @param nboots Number of bootstrap replicates to examine. +#' +#' @return BIC scores and log-likelihood (LL) for included mixture models. +#' For both, the smallest score is the most likely model. + + +quackNboots <- function(xm, nboots = 100, distribution, type, uniform, + mixtures = c(""diploid"", ""triploid"", ""tetraploid"", ""hexaploid"", ""pentaploid""), + samplename, + trunc = c(0.0,0.0), lowvar = FALSE, + tau = NA, error = NA){ + + og <- bestquack(xm, distribution, type, uniform, mixtures, samplename, trunc, lowvar, tau, error) + ogpick <- (quackit(og))$winnerBIC + message(paste0(""The best pick for the original data is "", ogpick)) + + bootits <- c() + for(i in 1:nboots){ + bootits[[i]] <- resample_xm(xm, nrow(xm)) + } + + bootscheck <- c() + for(i in 1:nboots){ + check <- bestquack(bootits[[i]], distribution, type, uniform, mixtures, samplename, trunc, lowvar, tau, error) + bootscheck[i] <- (quackit(check))$winnerBIC + } + + results <- data.frame(matrix(nrow = 2, ncol = length(mixtures))) + colnames(results) <- mixtures + rownames(results) <- c(""original"", ""bootstrap.replicates"") + results[1, ogpick] <- 1 + + out <- data.frame(table(bootscheck)) + for(j in 1:nrow(out)){ + results[2, as.character(out[j, 1])] <- as.numeric(out[j, 2]) +} +results$sample <- samplename + return(results) + +} +","R" +"Allele","mgaynor1/nQuack","R/quackBetaBinom.R",".R","11158","246","#' Model Selection - Expectation Maximization - Beta-Binomial Mixture +#' +#' @description This function uses the expectation maximization of both +#' the beta-binomial and beta-binomial-uniform mixture models for model selection. +#' Here we can run up to 32 mixture models. +#' +#' @param xm Matrix with two columns with total coverage and coverage +#' for a randomly sampled allele. +#' @param samplename Name of sample to be included in output. +#' @param cores Threads available to run process in parallel. +#' @param parallel default = FALSE, set to true if cores > 1. +#' @param trunc List of two values representing the lower and upper bounds for +#' allele frequency truncation , c_L and c_U. If allele frequency +#' truncation was done to remove error, then you do not need to truncate +#' the expected. If no truncation has been done, this should be set to c(0,0), +#' which is the default. +#' @param tau Sequencing overdispersion parameter. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. +#' If not, the variance by default is equal to 0.01 or 0.001. +#' @param error Sequencing error rate. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. If not, the variance by default is equal to 0.01 or 0.001. +#' @param lowvar Default to FALSE. When false, variance is equal to 0.01. +#' If set to TRUE and tau and error are not provided, +#' the variance will be set as 0.001. +#' @param free default = FALSE, skip the free model calculation and does not +#' calculate delta log-likelihood. +#' +#' @return BIC scores and log-likelihood (LL) mixture models including diploid, +#' triploid, tetraploid, pentaploid, and hexaploid. When free = TRUE, +#' the delta log-likelihood (dLL) is calculated based on +#' the associated free model (without or with a uniform mixture). +#' For BIC or delta-log likelihood, the smallest score is the most likely model. +#' For LL, the largest score is the most likely model. +#' +#' @importFrom foreach foreach %dopar% %:% +#' @importFrom future plan availableCores multisession +#' @importFrom parallel makeCluster +#' @importFrom doParallel registerDoParallel +#' + +quackBetaBinom <- function(xm, samplename, cores, parallel= FALSE, trunc = c(0.0,0.0), + lowvar = FALSE, tau = NA, error = NA, free = FALSE){ + cat(paste0("" \t\t <(.)__ <(.)__ <(-)__"", + ""\n \t\t (___/ (___/ (___/ nQuack-in-progress"", ""\n"")) + + parallel <- ifelse(cores > 1, TRUE, FALSE) + message(paste0(""parallel set to "", parallel)) + + # Input data setup + xm <- as.matrix(xm) + n <- nrow(xm) + lnn <- log(n) + + # Input parameters + set <- list() + setU <- list() + if(lowvar == FALSE){ + ## Model Params + pu = list(avec = c(0.11, 0.22, 0.33, 0.22, 0.11, 0.01), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + p = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.01)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01, 0.01)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01, 0.01, 0.01, 0.01)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.01)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01, 0.01)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01,0.01, 0.01, 0.01)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + vv <- 0.01 + }else{ + pu = list(avec = c(0.11, 0.22, 0.33, 0.22, 0.11, 0.01), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + p = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.001)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001,0.001)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.001)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001, 0.001)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + vv <- 0.001 + } + + + if((is.na(tau) + is.na(error)) == 2 ){ + set <- set + setU <- setU + }else{ + set <- setconvert(set, tau, error) + setU <- setconvert(setU, tau, error) + } + + + # Set up parm list for BIC calculations + parmlistN <- c() + parmlistN[[1]] <- c(0, 2, 3, 4, 5) + parmlistN[[2]] <- c(2, 4, 6, 8, 10) #fixed_2 + parmlistN[[3]] <- c(1, 2, 3, 4, 5) #fixed_3 + + parmlistU <- c() + parmlistU[[1]] <- c(2, 3, 4, 5, 6) + parmlistU[[2]] <- c(3, 5, 7, 9, 11) + parmlistU[[3]] <- c(1, 2, 3, 4, 5) + + # EM setup + niter = 1000 + epsilon = 0.1 + + if(free == TRUE){ + type = ""free"" + + message(""Free Model Calculations Started"") + # Free models + LL1 <- data.frame(LL = (emstepBB(p, xm, niter, epsilon, trunc, ""free""))$loglikelihood, type = ""free"", mixture = ""free"", distribution = ""beta-binomial"") + LL2 <- data.frame(LL = (emstepBBU(pu, xm, niter, epsilon, trunc, ""free""))$loglikelihood, type = ""free"", mixture = ""free"", distribution = ""beta-binomial-uniform"") + + LL1$BIC <- 0 + LL2$BIC <- 0 + + }else if(free == FALSE){ + message(""Free Model Skipped. Log-likelihood ratio will not be included"") + } + # Fixed models + if(is.na(cores)){ + cores <- (future::availableCores()-1) + } + + if(parallel == TRUE){ + cl <- parallel::makeCluster(cores) + + ## Register parallel + doParallel::registerDoParallel(cl) + + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""pentaploid"", ""hexaploid"") + tt <- ifelse(sum(trunc) > 0, TRUE, FALSE) + opts <- list(chunkSize=2) + + message(""Calculating likelihood of each mixture with a beta-binomial distibution."") + d <- foreach(type=1:3, .combine='rbind', .options.nws=opts) %:% + foreach::foreach(iter = 1:5, .combine='rbind', .packages = ""nQuack"") %dopar% { + if(iter == 1 & type == 1){ + ab <- nQuack::alphabetacalc(set[[1]]$mvec, set[[1]]$svec) + if(tt == TRUE){ + obj <- list(loglikelihood = sum(log(extraDistr::dbbinom(xm[,2], xm[,1], ab[1,1], ab[2,1], log = FALSE)/(extraDistr::pbbinom((xm[,1]*trunc[2]), xm[,1], ab[1,1], ab[2,1]) - extraDistr::pbbinom((xm[,1]*trunc[1]), xm[,1], ab[1,1], ab[2,1]))))) + }else{ + obj <- list(loglikelihood = sum(extraDistr::dbbinom(xm[,2], xm[,1], ab[1,1], ab[2,1], log = TRUE))) + + } + } else{ + obj <- nQuack::emstepBB(set[[iter]], xm, niter, epsilon, trunc, type = bvec[type]) + } + + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[[type]][iter])) + data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""beta-binomial"", BIC = BICout) + } + + message(""Calculating likelihood of each mixture with a beta-binomial + uniform distibution."") + opts <- list(chunkSize=2) + du <- foreach(type=1:3, .combine='rbind', .options.nws=opts) %:% + foreach::foreach(iter = 1:5, .combine='rbind', .packages = ""nQuack"") %dopar% { + obj <- nQuack::emstepBBU(setU[[iter]], xm, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[[type]][iter])) + data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""beta-binomial-uniform"", BIC = BICout) + } + + # Stop cluster + parallel::stopCluster(cl) + + }else if(parallel == FALSE){ + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""pentaploid"", ""hexaploid"") + tt <- ifelse(sum(trunc) > 0, TRUE, FALSE) + + d <- as.data.frame(matrix(ncol = 5, nrow = 0)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + message(""Calculating likelihood of each mixture with a beta-binomial distibution."") + for(type in 1:3){ + for(iter in 1:5){ + if(iter == 1 & type == 1){ + ab <- alphabetacalc(0.5, vv) + if(tt == TRUE){ + obj <- list(loglikelihood = sum(log(extraDistr::dbbinom(xm[,2], xm[,1], ab[1,1], ab[2,1], log = FALSE)/(extraDistr::pbbinom((xm[,1]*trunc[2]), xm[,1], ab[1,1], ab[2,1]) - extraDistr::pbbinom((xm[,1]*trunc[1]), xm[,1], ab[1,1], ab[2,1]))))) + }else{ + obj <- list(loglikelihood = sum(extraDistr::dbbinom(xm[,2], xm[,1], ab[1,1], ab[2,1], log = TRUE))) + } + } else{ + obj <- emstepBB(set[[iter]], xm, niter, epsilon, trunc, type = bvec[type]) + } + + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[[type]][iter])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""beta-binomial"", BIC = BICout)) + } + } + + du <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(du) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + message(""Calculating likelihood of each mixture with a beta-binomial + uniform distibution."") + + for(type in 1:3){ + for(iter in 1:5){ + obj <- emstepBBU(setU[[iter]], xm, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[[type]][iter])) + du <- rbind(du, data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""beta-binomial-uniform"", BIC = BICout)) + } + } + + + } + if(free == TRUE){ + dLL <- c() + for(kk in 1:nrow(d)){ + dLL[kk] <-(LL1$LL - d$LL[kk]) + } + d$dLL <- dLL + + dULL <- c() + for(kk in 1:nrow(du)){ + dULL[kk] <-(LL2$LL - du$LL[kk]) + } + du$dLL <- dULL + + LL1$dLL <- 0 + LL2$dLL <- 0 + + + out <- rbind(LL1, LL2, d, du) + + }else if(free == FALSE){ + out <- rbind( d, du) + } + out$sample <- samplename + colnames(out) + return(out) +} + + +","R" +"Allele","mgaynor1/nQuack","R/denoise_data.R",".R","5976","172","#' Denoise Data +#' +#' @description Here we filter allele frequencies with a normal + uniform +#' mixture model. nQuack utilizes the scaled probability of each data point belonging +#' to each mixture model, which is inferred in the expectation maximization algorithm. +#' We remove allele frequencies where probability of belonging to uniform mixture is higher than their +#' probability of belonging to any other mixture. We also implement nQuire's denoise method here, which +#' utilizes the inferred alpha parameter and a histogram of base frequencies to filter the data. +#' +#' @param xm Matrix with total coverage and coverage for a randomly sampled allele. +#' @param plot Default to TRUE. The plots do not share the same y-axis, so careful interpretation is key. +#' Warning, if nothing is removed, the plot of removed data will be missing. +#' @param filter Indicates which method to remove data based upon. Options: 'both', 'nquire', or 'nquack'. nQuack +#' utilizes the scaled probability of each data point belonging to each mixture model, removing sites where the probability of belonging to uniform mixture is higher than their +#' probability of belonging to any other mixture. nQuire utilizes the inferred alpha parameter and a histogram of base frequencies to filter the data. +#' +#' @return Numeric matrix with total coverage and coverage for a randomly sampled allele. +#' +#' @importFrom graphics hist par +#' @importFrom stats runif +#' + +denoise_data <- function(xm, plot = TRUE, filter = ""both""){ + + # Setup data + xm <- as.matrix(xm) + xi <- xm[,2]/xm[,1] + + # Free Model Run + set <- list(avec = c(0.11, 0.22, 0.33, 0.22, 0.11, 0.01), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + nout <- emstepNUA(set, xi, 1000, 0.1, c(0,0), ""free"" ) + pir <- nout$pir + + # nQuire's way: + if(min(xi) > 0){ + os = round(min(xi)*100) + size = 100-(2*os) + }else if(min(xi) == 0 | is.na(min(xi))){ + os = 1 + size = 100 + } + + min = ((length(xi) * nout$parm.list$avec[6])/size) + details <- hist(xi, breaks = size, plot = FALSE) + y <- details$counts + for(i in 1:size){ + f = ((y[i] - min)/y[i]) + + if(f < 0.01 | is.na(f)){ + y[i] = 0.01 + }else{ + y[i] = f + } + } + rl <- c() + for(i in 1:length(xi)){ + val = round(xi[i]*100) + ys = val-os + if(ys == 0 | is.na(ys)){ys <- 1}else if(ys > size){ ys <- size-1} + if((val >= os) & (val <= (100-os)) & (runif(1) < y[ys]) ){ + rl[i] <- 1 + } else{ + rl[i] <- 0 + } + } + + # nQuack's way + removelist <- c() + for(i in 1:length(xi)){ + if(which(pir[i,] == max(pir[i,])) == 6){ + removelist[i] <- 0 + }else{ + removelist[i] <- 1 + } + } + + if(filter == ""both""){ + if(plot == TRUE){ + xikeep <- xi[which(removelist == 1)] + xiremove <- xi[which(removelist == 0)] + xiQkeep <- xi[which(rl == 1)] + xiQremove <- xi[which(rl == 0)] + bothkeep <- xi[-which(removelist == 0 | rl == 0)] + par(mfrow = c(3, 3)) + + hist(xi,xlim = c(0, 1), main = ""Original Data"", xlab = ""Allele Frequency"", breaks = size ) + + if(length(xikeep) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + }else{ + hist(xikeep, xlim = c(0, 1), main = ""Data Retained - nQuack"", xlab = ""Allele Frequency"", breaks = size) + } + + if(length(xiremove) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + } else{ + hist(xiremove, xlim = c(0, 1), main = ""Data Removed - nQuack"", xlab = ""Allele Frequency"", breaks = size) + } + + hist(xi,xlim = c(0, 1), main = ""Original Data"", xlab = ""Allele Frequency"", breaks = size ) + if(length(xiQkeep) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + }else{ + hist(xiQkeep, xlim = c(0, 1), main = ""Data Retained - nQuire"", xlab = ""Allele Frequency"", breaks = size) + } + if(length(xiQremove) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + }else{ + hist(xiQremove, xlim = c(0, 1), main = ""Data Removed - nQuire"", xlab = ""Allele Frequency"", breaks = size) + } + + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + + if(length(bothkeep) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + }else{ + hist(bothkeep,xlim = c(0, 1), main = ""Combined - Data Returned"", xlab = ""Allele Frequency"", breaks = size ) + } + } + + xmout <- xm[-which(removelist == 0 | rl == 0), ] + return(xmout) + }else if(filter == ""nquire""){ + if(plot == TRUE){ + + xiQkeep <- xi[which(rl == 1)] + xiQremove <- xi[which(rl == 0)] + par(mfrow = c(1, 3)) + + hist(xi,xlim = c(0, 1), main = ""Original Data"", xlab = ""Allele Frequency"", breaks = size ) + + if(length(xiQkeep) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + }else{ + hist(xiQkeep, xlim = c(0, 1), main = ""Data Retained - nQuire"", xlab = ""Allele Frequency"", breaks = size) + } + if(length(xiQremove) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + }else{ + hist(xiQremove, xlim = c(0, 1), main = ""Data Removed - nQuire"", xlab = ""Allele Frequency"", breaks = size) + } + } + xmout <- xm[-which(rl == 0),] + return(xmout) + } else if(filter == ""nquack""){ + if(plot == TRUE){ + xikeep <- xi[which(removelist == 1)] + xiremove <- xi[which(removelist == 0)] + par(mfrow = c(1, 3)) + + hist(xi,xlim = c(0, 1), main = ""Original Data"", xlab = ""Allele Frequency"", breaks = size ) + + if(length(xikeep) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + }else{ + hist(xikeep, xlim = c(0, 1), main = ""Data Retained - nQuack"", xlab = ""Allele Frequency"", breaks = size) + } + + if(length(xiremove) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + }else{ + hist(xiremove, xlim = c(0, 1), main = ""Data Removed - nQuack"", xlab = ""Allele Frequency"", breaks = size) + } + } + + xmout <- xm[-which(removelist == 0),] + return(xmout) + } + + +} +","R" +"Allele","mgaynor1/nQuack","R/process_data.R",".R","2171","39","#' Process data - Step 2 +#' +#' @description Based on the file generated with `prepare_data()`, which contains the total depth and sequencing coverage for each +#' nucleotide (A, C, G, and T), this function remove all but single nucelotide polymorphisms. +#' When supplied, this function will filter on coverage or allele frequency. To filter by total coverage, +#' a user must supply the `min.depth` and `max.depth.quantile.prob`. If an `error` is provided, +#' sites will be retained where allele coverage is greater than the sequencing error rate times +#' the total coverage, but less than one minus the sequencing error rate times the total coverage. +#' Lastly, based on `trunc`, allele frequencies will be filtered based on a provided lower +#' and upper bound. Finally, the function samples a single allele frequency per site to avoid data duplication. +#' +#' @param file Output txt file created with `prepare_data()`. +#' @param min.depth Minimum sequencing depth, default as 2. +#' @param max.depth.quantile.prob Maximum sequencing depth quantile cut off, default = 0.9. +#' @param trunc List of two values representing the lower and upper bounds, \eqn{c_{L}} and \eqn{c_{U}} which are used to filter allele frequencies. +#' @param error Sequencing error rate. If an `error` is provided, +#' sites will be retained where allele coverage is greater than the sequencing error rate times +#' the total coverage, but less than one minus the sequencing error rate times the total coverage. +#' +#' @return Numeric matrix with total coverage and coverage for a randomly sampled allele. +#' @importFrom data.table fread +#' @importFrom stats na.omit + +process_data <- function(file, min.depth = 2, max.depth.quantile.prob = 0.9, + error = 0.01, trunc = c(0,0)){ + df <- data.table::fread(file, sep = ""\t"") + if(ncol(df) != 7){ + message(""Did you run `prepare_data()` on this file? Your data is in the wrong format, please correct and try again."") + } else{ + df <- df[,3:7] + df <- stats::na.omit(df) + dfm <- as.matrix(df) + + allelefreq <- process_rcpp(dfm, min.depth, max.depth.quantile.prob, trunc, error ) + return(allelefreq) + } +} + +","R" +"Allele","mgaynor1/nQuack","R/quackNormal.R",".R","9915","227","#' Model Selection - Expectation Maximization - Normal Mixture +#' +#' @description This function uses the expectation maximization of both +#' the normal and normal-uniform mixture models for model selection. +#' Here we can run up to 32 mixture models. +#' +#' @param xm Matrix with two columns with total coverage and coverage +#' for a randomly sampled allele. +#' @param samplename Name of sample to be included in output. +#' @param cores Threads available to run process in parallel. +#' @param parallel default = FALSE, set to true if cores > 1. +#' @param trunc List of two values representing the lower and upper bounds for +#' allele frequency truncation, c_L and c_U. If allele frequency +#' truncation was done to remove error, then you do not need to truncate +#' the expected. If no truncation has been done, this should be set to c(0,0), +#' which is the default. +#' @param tau Sequencing overdispersion parameter. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. +#' If not, the variance by default is equal to 0.01 or 0.001. +#' @param error Sequencing error rate. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. +#' @param lowvar Default to FALSE. When false, variance is equal to 0.01. +#' If set to TRUE and tau and error are not provided, +#' the variance will be set as 0.001. +#' @param free default = FALSE, skip the free model calculation and does not +#' calculate delta log-likelihood. +#' +#' @return BIC scores and log-likelihood (LL) mixture models including diploid, +#' triploid, tetraploid, pentaploid, and hexaploid. When free = TRUE, +#' the delta log-likelihood (dLL) is calculated based on +#' the associated free model (without or with a uniform mixture). +#' For BIC or delta-log likelihood, the smallest score is the most likely model. +#' For LL, the largest score is the most likely model. +#' +#' +#' @importFrom foreach foreach %dopar% %:% +#' @importFrom future plan availableCores multisession +#' @importFrom parallel makeCluster +#' @importFrom doParallel registerDoParallel + +quackNormal <- function(xm, samplename, cores, parallel= FALSE, + trunc = c(0.0,0.0), lowvar = FALSE, + tau = NA, error = NA, free = FALSE){ + + cat(paste0("" \t\t <(.)__ <(.)__ <(-)__"", + ""\n \t\t (___/ (___/ (___/ nQuack-in-progress"", ""\n"")) + parallel <- ifelse(cores > 1, TRUE, FALSE) + message(paste0(""parallel set to "", parallel)) + + # Input data setup + xm <- as.matrix(xm) + xi <- (xm[,2]/xm[,1]) + n <- length(xi) + lnn <- log(n) + # Input parameters + set <- list() + setU <- list() + + if(lowvar == FALSE){ + + ## Model Params + pu = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11, 0.0), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + p = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.01)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01,0.01)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01,0.01, 0.01, 0.01)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.01)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01, 0.01)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01,0.01, 0.01, 0.01)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + }else if(lowvar == TRUE){ + pu = list(avec = c(0.11, 0.22, 0.33, 0.22, 0.11, 0.01), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + p = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.001)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001,0.001)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.001)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001, 0.001)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + } + + if((is.na(tau) + is.na(error)) == 2 ){ + set <- set + setU <- setU + }else{ + set <- setconvert(set, tau, error) + setU <- setconvert(setU, tau, error) + } + + # Set up parm list for BIC calculations + parmlistN <- c() + parmlistN[[1]] <- c(1,2, 3, 4, 5) + parmlistN[[2]] <- c(2,4, 6, 8, 10) + parmlistN[[3]] <- c(1,2, 3, 4, 5) + + parmlistU <- c() + parmlistU[[1]] <- c(2,3, 4, 5, 6) + parmlistU[[2]] <- c(3,5, 7, 9, 11) + parmlistU[[3]] <- c(1,2, 3, 4, 5) + + + niter = 1000 + epsilon = 0.1 + + if(free == TRUE){ + type = ""free"" + + message(""Free Model Calculations Started"") + # Free models + + LL1 <- data.frame(LL = (emstepNUA(pu, xi, niter, epsilon, trunc))$loglikelihood, type = ""free"", mixture = ""free"", distribution = ""normal-uniform"") + LL2 <- data.frame(LL = (emstepNA(p, xi, niter, epsilon, trunc))$loglikelihood, type = ""free"", mixture = ""free"", distribution = ""normal"") + + LL1$BIC <- 0 + LL2$BIC <- 0 + }else if(free == FALSE){ + message(""Free Model Skipped. Log-likelihood ratio will not be included"") + } + + + # Fixed models + if(is.na(cores)){ + cores <- (future::availableCores()-1) + } + + if(parallel == TRUE){ + cl <- parallel::makeCluster(cores) + + ## Register parallel + doParallel::registerDoParallel(cl) + + opts <- list(chunkSize=2) + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""pentaploid"", ""hexaploid"") + #tt <- ifelse(sum(trunc) > 0, TRUE, FALSE) + + message(""Calculating likelihood of each mixture with a normal distibution."") + d <- foreach(type=1:3, .combine='rbind', .options.nws=opts) %:% + foreach::foreach(iter = 1:5, .combine='rbind', .packages = ""nQuack"") %dopar% { + obj <- nQuack::emstepNA(set[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[[type]][iter])) + data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""normal"", BIC = BICout) + } + + opts <- list(chunkSize=2) + message(""Calculating likelihood of each mixture with a normal+uniform distibution."") + + du <- foreach(type=1:3, .combine='rbind', .options.nws=opts) %:% + foreach::foreach(iter = 1:5, .combine='rbind', .packages = ""nQuack"") %dopar% { + obj <- nQuack::emstepNUA(setU[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[[type]][iter])) + data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""normal-uniform"", BIC = BICout) + } + + parallel::stopCluster(cl) + }else if(parallel == FALSE){ + message(""Calculating likelihood of each mixture with a normal distibution."") + + d <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""pentaploid"", ""hexaploid"") + + + for(type in 1:3){ + for(iter in 1:5){ + obj <- nQuack::emstepNA(set[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[[type]][iter])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""normal"", BIC = BICout)) + + } + } + + + du <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(du) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + + message(""Calculating likelihood of each mixture with a normal+uniform distibution."") + + for(type in 1:3){ + for(iter in 1:5){ + obj <- nQuack::emstepNUA(setU[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[[type]][iter])) + du <- rbind(du, data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""normal-uniform"", BIC = BICout)) + } + } + + } + if(free == TRUE){ + + dLL <- c() + for(kk in 1:nrow(d)){ + dLL[kk] <-(LL1$LL - d$LL[kk]) + } + d$dLL <- dLL + + dULL <- c() + for(kk in 1:nrow(du)){ + dULL[kk] <-(LL2$LL - du$LL[kk]) + } + du$dLL <- dULL + + LL1$dLL <- 0 + LL2$dLL <- 0 + + + out <- rbind(LL1, LL2, d, du) + + }else if(free == FALSE){ + out <- rbind( d, du) + } + out$sample <- samplename + return(out) +} +","R" +"Allele","mgaynor1/nQuack","R/sim.ind.BB.R",".R","5272","114","#' Simulate Allele Counts for Single Individual - Beta-Binomial Distribution +#' +#' @description This function is used to simulate coverage of each allele at +#' biallelic heterozygous sites assuming a beta binomial distribution. Here we +#' sample sequence depth from a truncated poisson distribution between a set minimum, maximum, +#' and lambda. Only heterozygous sites are returned. +#' Based on input variables, the sites may be filtered based on the total coverage (`filter.coverage`), allele +#' sequencing coverage (`filter.error`), or allele frequency (`filter.freq`). +#' +#' @param mvec Vector of mean values of allele frequency. +#' @param avec Vector of alpha values representing the proportion expected of each mean. +#' @param svec Vector of variance values. +#' @param error Sequencing error rate. Default as 0.001, or very low error. +#' @param s.size Number of biallelic sites to generate. Defaults to 50000. Warning, +#' the number of sites generated will not be the number of sites returned +#' due to filtering steps. +#' @param max.coverage Maximum sequencing depth per site. Defaults to 20. +#' @param min.coverage Minimum sequencing depth per site. Defaults to 2. +#' @param lambda Set lambda for the truncated poisson distrubtion. Defaults to 11. +#' @param filter.coverage Default as TRUE. Filters to only retain sites where total sequencing depth +#' is greater than the provided minimum coverage and less than the max quantile depth (set with the max.depth.quantile.prob). +#' @param max.depth.quantile.prob Maximum depth quantile probability. Defaults to 0.9. +#' @param filter.error Default as TRUE. Filter to only retain sites where allele coverage +#' is greater than the sequencing error rate times the total coverage, but +#' less than one minus the sequencing error rate times the total coverage. +#' @param filter.freq Default as FALSE. When set to true, sites are filtered based on provided `trunc`. +#' @param trunc List of two values representing the lower and upper bounds,\eqn{c_{L}} and \eqn{c_{U}}. +#' Defaults as c(0,0) to represent no truncation. +#' @param sampled Default as TRUE. Will randomly sample allele A or allele B, then return a data +#' frame with total coverage and coverage of a randomly sampled allele will be returned. +#' +#' @return If sampled = FALSE, a data frame with total coverage, coverage of allele A, +#' and coverage of allele B will be returned. If sampled = TRUE, a data frame with total coverage +#' and coverage of a randomly sampled allele will be returned. +#' +#' +#' @importFrom truncdist rtrunc +#' @importFrom stats rbeta rbinom quantile + + + +sim.ind.BB <- function(mvec, avec, svec, error = 0.001, + s.size = 50000, lambda = 11, + max.coverage = 20, min.coverage = 2, + filter.coverage = TRUE, max.depth.quantile.prob = 0.9, + filter.error = TRUE, + filter.freq = FALSE, trunc = c(0, 0), sampled = TRUE){ + + alpha.beta <- alphabetacalcvec(mvec, svec) + smax <- (length(avec)) + all.sites <- data.frame(matrix(nrow = s.size, ncol = 3)) + coverage.dist <- truncdist::rtrunc(s.size, spec=""pois"", a = min.coverage, b=max.coverage, lambda=lambda) + + for(i in 1:s.size) { + ## Which heterozygote + which.type <- sample(1:smax, size = 1, replace = TRUE, prob = avec) + ## Sequencing Depth + cover <- sample(x= coverage.dist, size=1) + ## Fill out the matrix + P <- rbeta(n = 1, alpha.beta[which.type, 1], alpha.beta[which.type, 2]) + all.sites[i, 2] <- rbinom(n = 1, size = cover, prob = P ) + all.sites[i, 1] <- cover + all.sites[i, 3] <- all.sites[i, 1] - all.sites[i, 2] + } + + + # Filter simulated data + ## Remove homozygote sites + all.sites <- all.sites[which(all.sites[,1] >= 2 & all.sites[,2] != 0 & all.sites[,3] != 0),] + + if(filter.coverage == TRUE){ + max <- ceiling(quantile(all.sites[,1], max.depth.quantile.prob)) + all.sites <- all.sites[which(all.sites[,1] > min.coverage & (all.sites[,1] < max)), ] + } + + if(filter.error == TRUE){ + ## If Coverage(A) > e*Coverage(A+B) + ## If Covergae(A) < (1-e)*Coverage(A+B) + all.sites <- all.sites[which(all.sites[,2] > (error*all.sites[,1]) & (all.sites[,2] < ((1-error)*all.sites[,1]) )), ] + all.sites <- all.sites[which(all.sites[,3] > (error*all.sites[,1]) & (all.sites[,3] < ((1-error)*all.sites[,1]) )), ] + } + + if(filter.freq == TRUE){ + if(sum(trunc) > 0){ + for(i in 1:nrow(all.sites)){ + all.sites[i,4] <- (all.sites[i,2]/all.sites[i,1]) + all.sites[i,5] <- (all.sites[i,3]/all.sites[i,1]) + } + + all.sites <- all.sites[which(all.sites[,4] >= trunc[1] & all.sites[,4] <= trunc[2] & all.sites[,5] >= trunc[1] & all.sites[,5] <= trunc[2]), ] + + } else{ + print(""Set trunc"") + } + } + + all.sites <- all.sites[,1:3] + + if(sampled == TRUE){ + all.sites.sample <- data.frame(matrix(nrow = nrow(all.sites), ncol = 2)) + for(i in 1:nrow(all.sites)){ + all.sites.sample[i, 1] <- all.sites[i, 1] + all.sites.sample[i, 2] <- sample(x = all.sites[i, 2:3], size = 1, prob = c(0.5, 0.5)) + } + return(all.sites.sample) + } else{ + colnames(all.sites) <- c(""Total.Coverage"", ""Allele.A"", ""Allele.B"") + return(all.sites) + } +} + + + +","R" +"Allele","mgaynor1/nQuack","R/RcppExports.R",".R","17306","326","# Generated by using Rcpp::compileAttributes() -> do not edit by hand +# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#' @title E-Step for Expectation Maximization - Beta + Beta + Beta Distribution +#' @description This is used in the `Bclean()` function. Here we complete +#' the E-Step and calculate the log-likelihood. Modifications include a correction for +#' the truncated distribution. +#' @param parmlist A list containing initial alpha, mean, and variance. +#' @param xi List of observations, in this case allele frequencies. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +estepB3 <- function(parmlist, xi, trunc) { + .Call('_nQuack_estepB3', PACKAGE = 'nQuack', parmlist, xi, trunc) +} + +#' @title Expectation maximization - Beta + Beta + Beta Distribution +#' +#' @description This function is made for the `Bclean()` function and preforms expectation maximization with Nelder-Mead +#' numerical optimization for beta distribution. +#' +#' @param parmlist A list containing initial alpha, mean, and variance. +#' @param xi Matrix where the first column is total coverage and the second is the count of base A or B. +#' @param niter Max number of iterates. +#' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +#' below this value, convergence is reached. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' +#' @returns List of elements including the negative log likelihood, the number of iterates, +#' and the optimized parameter values. +#' +#' +emstepB3 <- function(parmlist, xi, niter, epsilon, trunc) { + .Call('_nQuack_emstepB3', PACKAGE = 'nQuack', parmlist, xi, niter, epsilon, trunc) +} + +#' @title Expectation maximization - Normal Distribution +#' +#' @description This function calculates the log-likelihood using +#' the expectation maximization algorithm with the Normal Distribution. +#' This code follows nQuire and does not use an augmented likelihood. +#' +#' @param parmlist A list containing initial alpha, mean, and variance values. +#' @param xi List of observations, in this case allele frequencies. +#' @param niter Max number of iterates. +#' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +#' below this value, convergence is reached. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +#' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +#' +#' @returns List of elements including the log-likelihood, the number of iterates, +#' and the optimized parameter values. +#' +emstepN <- function(parmlist, xi, niter, epsilon, trunc, type = ""free"") { + .Call('_nQuack_emstepN', PACKAGE = 'nQuack', parmlist, xi, niter, epsilon, trunc, type) +} + +#' @title Expectation maximization - Normal Distribution +#' +#' @description This function calculates the log-likelihood using +#' the expectation maximization algorithm with the Normal Distribution. +#' This code is not identical to nQuire and uses an augmented likelihood. +#' +#' @param parmlist A list containing initial alpha, mean, and variance values. +#' @param xi List of observations, in this case allele frequencies. +#' @param niter Max number of iterates. +#' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +#' below this value, convergence is reached. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +#' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +#' +#' @returns List of elements including the log-likelihood, the number of iterates, +#' and the optimized parameter values. +#' +emstepNA <- function(parmlist, xi, niter, epsilon, trunc, type = ""free"") { + .Call('_nQuack_emstepNA', PACKAGE = 'nQuack', parmlist, xi, niter, epsilon, trunc, type) +} + +#' @title Expectation maximization - Normal and Uniform Distribution +#' +#' @description This function calculates the log-likelihood using +#' the expectation maximization algorithm with the Normal-Uniform Distribution. +#' This code follows nQuire and does not use an augmented likelihood. +#' +#' @param parmlist A list containing initial alpha, mean, and variance values. The list of alpha must include a proportion for the uniform mixture. +#' @param xi List of observations, in this case allele frequencies. +#' @param niter Max number of iterates. +#' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +#' below this value, convergence is reached. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +#' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +#' +#' @returns List of elements including the log-likelihood, the number of iterates, +#' and the optimized parameter values. +#' +emstepNU <- function(parmlist, xi, niter, epsilon, trunc, type = ""free"") { + .Call('_nQuack_emstepNU', PACKAGE = 'nQuack', parmlist, xi, niter, epsilon, trunc, type) +} + +#' @title Expectation maximization - Normal Distribution +#' +#' @description This function calculates the log-likelihood using +#' the expectation maximization algorithm with the Normal-Uniform Distribution. +#' This code is not identical to nQuire and uses an augmented likelihood. +#' +#' @param parmlist A list containing initial alpha, mean, and variance values. The list of alpha must include a proportion for the uniform mixture. +#' @param xi List of observations, in this case allele frequencies. +#' @param niter Max number of iterates. +#' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +#' below this value, convergence is reached. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +#' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +#' +#' @returns List of elements including the log-likelihood, the number of iterates, +#' and the optimized parameter values. +#' +emstepNUA <- function(parmlist, xi, niter, epsilon, trunc, type = ""free"") { + .Call('_nQuack_emstepNUA', PACKAGE = 'nQuack', parmlist, xi, niter, epsilon, trunc, type) +} + +#' @title Expectation maximization - Beta Distribution +#' +#' @description This function calculates the log-likelihood using +#' the expectation maximization algorithm with Nelder-Mead numerical optimization +#' and a beta distribution. +#' +#' @param parmlist A list containing initial alpha, mean, and variance values. +#' @param xi List of observations, in this case allele frequencies. +#' @param niter Max number of iterates. +#' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +#' below this value, convergence is reached. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +#' ""fixed-2"" (estimated parameter(s): alpha and variance), or ""fixed-3"" (estimated parameter(s): variance). +#' If avec is length of 1, fixed and fixed-3 will not be able to return a log-likelihood. +#' +#' @returns List of elements including the log likelihood, the negative log likelihood, the number of iterates, +#' and the optimized parameter values. +#' +emstepB <- function(parmlist, xi, niter, epsilon, trunc, type = ""free"") { + .Call('_nQuack_emstepB', PACKAGE = 'nQuack', parmlist, xi, niter, epsilon, trunc, type) +} + +#' @title Expectation maximization - Beta-Binomial Distribution +#' +#' @description This function calculates the negative log-likelihood using +#' the expectation maximization algorithm with Nelder-Mead numerical optimization +#' and beta-binomial distribution. +#' +#' @param parmlist A list containing initial alpha, mean, and variance. +#' @param xm Matrix where the first column is total coverage and the second is the count of base A or B. +#' @param niter Max number of iterates. +#' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +#' below this value, convergence is reached. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' @param type String indicating ""Free"" or ""Fixed"". +#' +#' @returns List of elements including the negative log likelihood, the number of iterates, +#' and the optimized parameter values. +#' +#' +emstepBB <- function(parmlist, xm, niter, epsilon, trunc, type = ""free"") { + .Call('_nQuack_emstepBB', PACKAGE = 'nQuack', parmlist, xm, niter, epsilon, trunc, type) +} + +#' @title Expectation maximization - Beta-Binomial and Uniform Distributions +#' +#' @description This function calculates the log-likelihood using +#' the expectation-maximization algorithm with Nelder-Mead numerical optimization +#' and beta distribution with one uniform mixture. +#' +#' @param parmlist A list containing initial alpha, mean, and variance values. +#' @param xm Matrix where the first column is total coverage and the second is the count of base A or B. +#' @param niter Max number of iterates. +#' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +#' below this value, convergence is reached. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +#' ""fixed-2"" (estimated parameter(s): alpha and variance), or ""fixed-3"" (estimated parameter(s): variance). +#' If avec is length of 1, fixed and fixed-3 will not be able to return a log-likelihood. +#' +#' @returns List of elements including the log likelihood, the negative log likelihood, the number of iterates, +#' and the optimized parameter values. +#' +emstepBBU <- function(parmlist, xm, niter, epsilon, trunc, type = ""free"") { + .Call('_nQuack_emstepBBU', PACKAGE = 'nQuack', parmlist, xm, niter, epsilon, trunc, type) +} + +#' @title Expectation maximization - Beta and Uniform Distributions +#' +#' @description This function calculates the log-likelihood using +#' the expectation maximization algorithm with Nelder-Mead numerical optimization +#' and beta distribution with one uniform mixture. +#' +#' @param parmlist A list containing initial alpha, mean, and variance values. +#' @param xi List of observations, in this case allele frequencies. +#' @param niter Max number of iterates. +#' @param epsilon Epsilon value for convergence tolerance. When the absolute delta log-likelihood is +#' below this value, convergence is reached. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' @param type String indicating model type. Options: ""free"" (estimated parameter(s): alpha, mean, and variance), ""fixed"" (estimated parameter(s): alpha), +#' ""fixed_2"" (estimated parameter(s): alpha and variance), or ""fixed_3"" (estimated parameter(s): variance). +#' If avec is length of 1, fixed and fixed_3 will not be able to return a log-likelihood. +#' +#' @returns List of elements including the log likelihood, the negative log likelihood, the number of iterates, +#' and the optimized parameter values. +#' +emstepBU <- function(parmlist, xi, niter, epsilon, trunc, type = ""free"") { + .Call('_nQuack_emstepBU', PACKAGE = 'nQuack', parmlist, xi, niter, epsilon, trunc, type) +} + +#' Calculate Alpha and Beta from Mean and Variance +#' +#' @param mu Mean. +#' @param var Variance. +#' +#' @return Numeric vector of alpha and beta. +alphabetacalc <- function(mu, var) { + .Call('_nQuack_alphabetacalc', PACKAGE = 'nQuack', mu, var) +} + +#' Vector-based - Calculate Alpha and Beta from Mean and Variance +#' +#' @param mu Vector of mean. +#' @param var Vector of variance. +#' +#' @return Numeric matrix of alpha and beta. +alphabetacalcvec <- function(mu, var) { + .Call('_nQuack_alphabetacalcvec', PACKAGE = 'nQuack', mu, var) +} + +#' Calculate Alpha and Beta from Mean, Tau, and Error rate. +#' +#' @param mu Mean. +#' @param tau Overdispersion parameter. Ranges from 0 to 1, where 0 indicates less overdispersion and 1 indicates high overdispersion. Here tau must be greater than 0. +#' @param error Sequencing error rate. +#' +#' @return Numeric vector of alpha and beta. +alphabetacalctau <- function(mu, tau, error) { + .Call('_nQuack_alphabetacalctau', PACKAGE = 'nQuack', mu, tau, error) +} + +#' Vector-based - Calculate Alpha and Beta from Mean, Tau, and Error rate. +#' +#' @param mu Vector of mean. +#' @param tau Overdispersion parameter. Ranges from 0 to 1, where 0 indicates less overdispersion and 1 indicates high overdispersion. Here tau must be greater than 0. +#' @param error Sequencing error rate. Ranges from 0 to 1. +#' +#' @return Numeric matrix of alpha and beta. +alphabetacalctauvec <- function(mu, tau, error) { + .Call('_nQuack_alphabetacalctauvec', PACKAGE = 'nQuack', mu, tau, error) +} + +#' @title Prepare data - Step 1 +#' +#' @description This function transforms a BAM file into a text file. +#' Specifically, this function uses [samtools mpileup](http://www.htslib.org/doc/samtools-mpileup.html) +#' to translate your BAM into a tab-separated file. We then filter this file to remove indels and deletions. +#' When running this function, a temporary folder will be created (named 'temp/'), however this folder will be +#' removed once the process is complete. +#' +#' @details Warning, due to the processing time needed for samtools mpileup, +#' this step may take some time. This function also requires samtools to be located locally. Please see +#' our [Data Preparation](mlgaynor.com/nQuack/DataPreparation.html) article for more information. Warning, this writes a temporary folder +#' titled 'temp'. If you want to run multiple samples at once, we suggest you set the working directory to separate locations to ensure that +#' your temp folder/files are not overwritten. +#' +#' @param name File name without the suffix. For example, if your file is called ""frog.bam"", this input should be ""frog"". +#' @param inpath Location of input file. +#' @param outpath Location for output file. +#' @param tempfolder Location for temp folder. +#' +#' @returns Writes text file with the following columns: chromosome, position, depth, A, C, G, and T. +#' +prepare_data <- function(name, inpath, outpath, tempfolder = ""temp"") { + invisible(.Call('_nQuack_prepare_data', PACKAGE = 'nQuack', name, inpath, outpath, tempfolder)) +} + +#' Calculate Alpha and Beta from Mean and Variance +#' +#' @param xm Matrix with total coverage and coverage at a randomly sampled allele. +#' @param n Length of matrix. +#' +#' @return Randomly sampled matrix. +resample_xm <- function(xm, n) { + .Call('_nQuack_resample_xm', PACKAGE = 'nQuack', xm, n) +} + +#' @title Data Preparation - Use nQuire's Data +#' +#' @description This function reduce a three column data frame to +#' two columns by randomly sampling allele A or B for every site. This is used in our function `process_nquire()` +#' +#' @param xm A matrix with three columns: Total Coverage, Counts for Allele A, and Counts for Allele B. +#' +#' @returns Numeric Matrix with total coverage and coverage for a randomly sampled allele. +nQuire_reformat <- function(xm) { + .Call('_nQuack_nQuire_reformat', PACKAGE = 'nQuack', xm) +} + +#' @name process_rcpp +#' @title Data Preparation - Matrix Filtering +#' @description Based on supplied matrix with total depth and sequencing coverage for each +#' nucleotide (A, C, G, and T) this function remove all but single nucelotide polymorphisms. +#' When supplied, this function will filter on coverage or allele frequency. Finally, the function +#' samples a single allele frequency per site to avoid data duplication. +#' +#' @param x Matrix with five columns: Depth, A, C, G, and T. +#' @param mindepth Minimum depth, default = 15. +#' @param maxprob Maximum depth quantile cut off, default = 0.9. +#' @param trunc List of two values representing the lower and upper bounds, $c_{L}$ and $c_{U}$. +#' @param error Sequencing error rate. +#' +#' @return Numeric Matrix with total coverage and coverage for a randomly sampled allele. +#' +process_rcpp <- function(x, mindepth, maxprob, trunc, error) { + .Call('_nQuack_process_rcpp', PACKAGE = 'nQuack', x, mindepth, maxprob, trunc, error) +} + +# Register entry points for exported C++ functions +methods::setLoadAction(function(ns) { + .Call('_nQuack_RcppExport_registerCCallable', PACKAGE = 'nQuack') +}) +","R" +"Allele","mgaynor1/nQuack","R/process_nquire.R",".R","724","19","#' Use nQuire's Data +#' +#' @description If you happen to like nQuire's data preparation more than ours, +#' uses their data in our program. After processing samples with nQuire's `create` and `view` functions, +#' the resulting text file can be read into R. To prepare the data frame for nQuack, we reduce the three +#' column data frame to two columns by randomly sampling allele A or B for every site. +#' +#' @param file Output text file created with nQuire. +#' +#' @return Numeric matrix with total coverage and coverage for a randomly sampled allele. +#' +#' @importFrom data.table fread + +process_nquire <- function(file){ + df <- data.table::fread(file, sep = ""\t"") + dfout <- nQuire_reformat(as.matrix(df)) + return(dfout) +} +","R" +"Allele","mgaynor1/nQuack","R/sim.ind.BB.tau.R",".R","5309","112","#' Simulate Allele Counts for Single Individual - Beta-Binomial Distribution with Overdispersion and Error +#' +#' @description This function is used to simulate the frequency of +#' biallelic heterozygous sites assuming a beta-binomial distribution. Here we +#' sample sequence depth from a truncated poisson distribution between a set minimum, maximum, +#' and lambda. Only heterozygous sites are returned. +#' Based on input variables, the sites may be filtered based on the total coverage (`filter.coverage`), allele +#' sequencing coverage (`filter.error`), or allele frequency (`filter.freq`). +#' +#' @param mvec Vector of mean values of allele frequency. +#' @param avec Vector of alpha values representing the proportion expected of each mean. +#' @param tau Overdispersion parameter. Defaults to 0.01. +#' @param error Sequencing error rate. Defaults to 0.001. +#' @param s.size Number of biallelic sites to generate. Defaults to 50000. Warning, +#' the number of sites generated will not be the number of sites returned +#' due to filtering steps. +#' @param max.coverage Maximum sequencing depth per site. Defaults to 20. +#' @param min.coverage Minimum sequencing depth per site. Defaults to 2. +#' @param lambda Set lambda for the truncated poisson distrubtion. Defaults to 11. +#' @param filter.coverage Default as TRUE. Filters to only retain sites where total sequencing depth +#' is greater than the provided minimum coverage and less than the max quantile depth (set with the max.depth.quantile.prob). +#' @param max.depth.quantile.prob Maximum depth quantile probability. Defaults to 0.9. +#' @param filter.error Default as TRUE. Filter to only retain sites where allele coverage +#' is greater than the sequencing error rate times the total coverage, but +#' less than one minus the sequencing error rate times the total coverage. +#' @param filter.freq Default as FALSE. When set to true, sites are filtered based on provided `trunc`. +#' @param trunc List of two values representing the lower and upper bounds, \eqn{c_{L}} and \eqn{c_{U}}. +#' Defaults as c(0,0) to represent no truncation. +#' @param sampled Default as TRUE. Will randomly sample allele A or allele B, then return a data +#' frame with total coverage and coverage of a randomly sampled allele will be returned. +#' +#' @return If sampled = FALSE, a data frame with total coverage, coverage of allele A, +#' and coverage of allele B will be returned. If sampled = TRUE, a data frame with total coverage +#' and coverage of a randomly sampled allele will be returned. +#' +#' @importFrom truncdist rtrunc +#' @importFrom stats rbeta rbinom quantile + + +sim.ind.BB.tau <- function(mvec, avec, tau = 0.01, error = 0.001, + s.size = 50000, lambda = 11, + max.coverage = 20, min.coverage = 2, + filter.coverage = TRUE, max.depth.quantile.prob = 0.9, + filter.error = TRUE, + filter.freq = FALSE, trunc = c(0, 0), sampled = TRUE){ + + alpha.beta <- alphabetacalctauvec(mvec, tau, error) + smax <- (length(avec)) + all.sites <- data.frame(matrix(nrow = s.size, ncol = 3)) + coverage.dist <- truncdist::rtrunc(s.size, spec=""pois"", a = min.coverage, b=max.coverage, lambda=lambda) + + for(i in 1:s.size) { + ## Which heterozygote + which.type <- sample(1:smax, size = 1, replace = TRUE, prob = avec) + ## Sequencing Depth + cover <- sample(x= coverage.dist, size=1) + ## Fill out the matrix + P <- rbeta(n = 1, alpha.beta[which.type, 1], alpha.beta[which.type, 2]) + all.sites[i, 2] <- rbinom(n = 1, size = cover, prob = P ) + all.sites[i, 1] <- cover + all.sites[i, 3] <- all.sites[i, 1] - all.sites[i, 2] + } + + + # Filter simulated data + ## Remove homozygote sites + all.sites <- all.sites[which(all.sites[,1] >= 2 & all.sites[,2] != 0 & all.sites[,3] != 0),] + + if(filter.coverage == TRUE){ + max <- ceiling(quantile(all.sites[,1], max.depth.quantile.prob)) + all.sites <- all.sites[which(all.sites[,1] > min.coverage & (all.sites[,1] < max)), ] + } + + if(filter.error == TRUE){ + ## If Coverage(A) > e*Coverage(A+B) + ## If Covergae(A) < (1-e)*Coverage(A+B) + all.sites <- all.sites[which(all.sites[,2] > (error*all.sites[,1]) & (all.sites[,2] < ((1-error)*all.sites[,1]) )), ] + all.sites <- all.sites[which(all.sites[,3] > (error*all.sites[,1]) & (all.sites[,3] < ((1-error)*all.sites[,1]) )), ] + } + + if(filter.freq == TRUE){ + if(sum(trunc) > 0){ + for(i in 1:nrow(all.sites)){ + all.sites[i,4] <- (all.sites[i,2]/all.sites[i,1]) + all.sites[i,5] <- (all.sites[i,3]/all.sites[i,1]) + } + + all.sites <- all.sites[which(all.sites[,4] >= trunc[1] & all.sites[,4] <= trunc[2] & all.sites[,5] >= trunc[1] & all.sites[,5] <= trunc[2]), ] + + } else{ + print(""Set trunc"") + } + } + + all.sites <- all.sites[,1:3] + if(sampled == TRUE){ + all.sites.sample <- data.frame(matrix(nrow = nrow(all.sites), ncol = 2)) + for(i in 1:nrow(all.sites)){ + all.sites.sample[i, 1] <- all.sites[i, 1] + all.sites.sample[i, 2] <- sample(x = all.sites[i, 2:3], size = 1, prob = c(0.5, 0.5)) + } + return(all.sites.sample) + } else{ + colnames(all.sites) <- c(""Total.Coverage"", ""Allele.A"", ""Allele.B"") + return(all.sites) + } + +} + + + +","R" +"Allele","mgaynor1/nQuack","R/muvarcalcvec.R",".R","554","20","#' Variance calculation from Mean, Tau, and Sequencing Error +#' +#' @description This function is used to calculate variance. +#' +#' @param mu Vector of means. +#' @param tau Sequence overdispersion parameter for read counts. +#' @param error Sequencing error rate. +#' +#' @returns Mean and variance for the associated tau and error. + +muvarcalcvec <- function(mu, tau, error){ + var.out <- c() + for(z in 1:length(mu)){ + m <- ((mu[z]*(1-error))+((1-mu[z])*error)) + var.out[z] <- (m*(1-m)*tau) + } + parm.list <- list(var = var.out) + return(parm.list) +} +","R" +"Allele","mgaynor1/nQuack","R/Bclean.R",".R","3455","91","#' Remove noise with the beta distribution +#' +#' @description Here we filter allele frequencies with a beta mixture model that contains 5 mixtures: +#' three mixtures representing cytotypes included in nQuack and two mixtures representing a U-shaped distribution. +#' We constrained the first three mixtures to have shape and scale parameters above 1, +#' while the last two mixtures shape and scale are constrained to be less than 1. +#' With this implementation of expectation-maximization, we utilizes the scaled probability of each data point belonging +#' to each mixture model to remove site where the probability of belonging to a U-shaped mixture is higher than the +#' probability of belonging to any other mixture. Due to the computational time needed +#' to run the expectation-maximization algorithm, by default, we simple calculate this probability matrix with the E-step and do not +#' run the complete algorithm. +#' +#' @param xm Matrix with total coverage and coverage for a randomly sampled allele. +#' @param plot Default to TRUE. The plots do not share the same y-axis, so careful interpretation is key. +#' Warning, if nothing is removed, the plot of removed data will be missing. +#' @param quick Default to TRUE. If set as FALSE, the expectation-maximization algorithm will be run in full. +#' +#' @return Numeric matrix with total coverage and coverage for a randomly sampled allele. +#' +#' @importFrom graphics hist par +#' @importFrom stats runif +#' + +Bclean <- function(xm, plot = TRUE, quick = TRUE){ + # Setup data + xm <- as.matrix(xm) + xi <- xm[,2]/xm[,1] + + cL <- min(xi) + cU <- max(xi) + # Model + + #tcalcfull <- alphabetacalcvec(mu = c(0.20, 0.33, 0.50, 0.67, 0.80), var = c(0.01, 0.01, 0.01, 0.01, 0.01)) + #set <- list(avec = c(0.11, 0.22, 0.33, 0.22, 0.11, 0.01), t1vec = c(tcalc[,1], 0.5), t2vec = c(tcalc[,2], 0.33)) + + tcalc <- alphabetacalcvec(mu = c(0.287, 0.50, 0.713), var = c(0.01, 0.01, 0.01)) + set <- list(avec = c(0.25, 0.25, 0.25, 0.125, 0.125), t1vec = c(tcalc[,1], 0.5, 0.33), t2vec = c(tcalc[,2], 0.33, 0.5)) + + if(quick == FALSE){ + message(""Stay tune: Starting expectation-maximization algorithm now! nQuack calculations may take a long time to complete."") + checkB <- emstepB3(set, xi, 1000, 0.1, c(cL,cU)) + pir <- checkB$pir + }else if(quick == TRUE){ + checkB <- estepB3(set, xi, c(cL,cU)) + pir <- checkB$zprob + } + + # Make Remove Set + removelist <- c() + + for(i in 1:length(xi)){ + if(which(pir[i,] == max(pir[i,])) == 4 |which(pir[i,] == max(pir[i,])) == 5 ){ + removelist[i] <- 0 + }else{ + removelist[i] <- 1 + } + } + + if(min(xi) > 0){ + os = round(min(xi)*100) + size = 100-(2*os) + }else if(min(xi) == 0 | is.na(min(xi))){ + os = 1 + size = 100 + } + + if(plot == TRUE){ + xikeep <- xi[which(removelist == 1)] + xiremove <- xi[which(removelist == 0)] + + par(mfrow = c(1, 3)) + + hist(xi,xlim = c(0, 1), main = ""Original Data"", xlab = ""Allele Frequency"", breaks = size ) + + if(length(xikeep) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + }else{ + hist(xikeep, xlim = c(0, 1), main = ""Data Retained - nQuack"", xlab = ""Allele Frequency"", breaks = size) + } + + if(length(xiremove) == 0){ + plot(0, type=""n"", axes=FALSE, xlab="""", ylab="""") + } else{ + hist(xiremove, xlim = c(0, 1), main = ""Data Removed - nQuack"", xlab = ""Allele Frequency"", breaks = size) + } + } + + xmout <- xm[which(removelist == 1),] + return(xmout) +} +","R" +"Allele","mgaynor1/nQuack","R/sim.ind.simple.R",".R","1807","47","#' Simulate Allele Counts for Single Individual - Simple Approach +#' +#' @description This function is used to simulate coverage of each allele at +#' biallelic heterozygous sites assuming a binomial distribution. +#' +#' @param mvec Vector of means. +#' @param s.size Number of biallelic sites to generate. Defaults to 50000. Warning, +#' the number of sites generated will not be the number of sites returned +#' due to filtering steps. +#' @param cover Coverage of sites. +#' @param sampled Default as TRUE. Will randomly sample allele A or allele B, then return a data +#' frame with total coverage and coverage of a randomly sampled allele will be returned. +#' +#' @return If sampled = FALSE, a data frame with total coverage, coverage of allele A, +#' and coverage of allele B will be returned. If sampled = TRUE, a data frame with total coverage +#' and coverage of a randomly sampled allele will be returned. + + + + +sim.ind.simple <- function(mvec, cover = 100, s.size = 50000, sampled = TRUE){ + + all.sites <- data.frame(matrix(nrow = s.size, ncol = 3)) + all.sites[, 1] <- cover + all.sites[, 2] <- rbinom(n = s.size, size = cover, prob = mvec) + + for(i in 1:s.size) { + all.sites[i, 3] <- all.sites[i, 1] - all.sites[i, 2] + } + + # Remove homozygotes + all.sites <- all.sites[which(all.sites[,1] >= 2 & all.sites[,2] != 0 & all.sites[,3] != 0),] + + # Reduce data duplication + if(sampled == TRUE){ + all.sites.sample <- data.frame(matrix(nrow = nrow(all.sites), ncol = 2)) + for(i in 1:nrow(all.sites)){ + all.sites.sample[i, 1] <- all.sites[i, 1] + all.sites.sample[i, 2] <- sample(x = all.sites[i, 2:3], size = 1, prob = c(0.5, 0.5)) + } + return(all.sites.sample) + } else{ + colnames(all.sites) <- c(""Total.Coverage"", ""Allele.A"", ""Allele.B"") + return(all.sites) + } +} +","R" +"Allele","mgaynor1/nQuack","R/quackNormalNQ.R",".R","10213","225","#' Model Selection - Expectation Maximization - Normal Mixture (nQuire) +#' +#' @description This function uses the expectation maximization of both +#' the normal and normal-uniform mixture models for model selection +#' based on the nQuire approach. Here we can run up to 32 mixture models. +#' +#' @param xm Matrix with two columns with total coverage and coverage +#' for a randomly sampled allele. +#' @param samplename Name of sample to be included in output. +#' @param cores Threads available to run process in parallel. +#' @param parallel default = FALSE, set to true if cores > 1. +#' @param trunc List of two values representing the lower and upper bounds for +#' allele frequency truncation , c_L and c_U. If allele frequency +#' truncation was done to remove error, then you do not need to truncate +#' the expected. If no truncation has been done, this should be set to c(0,0), +#' which is the default. +#' @param tau Sequencing overdispersion parameter. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. +#' If not, the variance by default is equal to 0.01 or 0.001. +#' @param error Sequencing error rate. If tau and error are provided, +#' the variance of each mixture will be inferred from these values. +#' @param lowvar Default to FALSE. When false, variance is equal to 0.01. +#' If set to TRUE and tau and error are not provided, +#' the variance will be set as 0.001. +#' @param free default = FALSE, skip the free model calculation and does not +#' calculate delta log-likelihood. +#' +#' @return BIC scores and log-likelihood (LL) mixture models including diploid, +#' triploid, tetraploid, pentaploid, and hexaploid. When free = TRUE, +#' the delta log-likelihood (dLL) is calculated based on +#' the associated free model (without or with a uniform mixture). +#' For BIC or delta-log likelihood, the smallest score is the most likely model. +#' For LL, the largest score is the most likely model. +#' +#' +#' +#' +#' @importFrom foreach foreach %dopar% %:% +#' @importFrom future plan availableCores multisession +#' @importFrom parallel makeCluster +#' @importFrom doParallel registerDoParallel +#' +#' + +quackNormalNQ <- function(xm, samplename, cores, parallel= FALSE, + trunc = c(0.0,0.0), lowvar = FALSE, + tau = NA, error = NA, free = FALSE){ + + cat(paste0("" \t\t <(.)__ <(.)__ <(-)__"", + ""\n \t\t (___/ (___/ (___/ nQuack-in-progress"", ""\n"")) + parallel <- ifelse(cores > 1, TRUE, FALSE) + message(paste0(""parallel set to "", parallel)) + + # Input data setup + xm <- as.matrix(xm) + xi <- (xm[,2]/xm[,1]) + n <- length(xi) + lnn <- log(n) + # Input parameters + set <- list() + setU <- list() + if(lowvar == FALSE){ + ## Model Params + pu = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11, 0.0), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + p = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.01)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01,0.01)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01,0.01, 0.01, 0.01)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.01)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.01, 0.01)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.01, 0.01, 0.01)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.01,0.01, 0.01, 0.01)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.01, 0.01, 0.01, 0.01, 0.01)); + }else if(lowvar == TRUE){ + pu = list(avec = c(0.11, 0.22, 0.33, 0.22, 0.11, 0.01), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + p = list(avec = c(0.11, 0.22, 0.34, 0.22, 0.11), mvec = c(0.20, 0.33, 0.50, 0.67, 0.80), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + set[[1]] = list(avec = c(1.00), mvec = c(0.50), svec = c(0.001)); + set[[2]] = list(avec = c(0.50, 0.50), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + set[[3]] = list(avec = c(0.33, 0.33, 0.33), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001,0.001)); + set[[4]] = list(avec = c(0.25, 0.25, 0.25, 0.25), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + set[[5]] = list(avec = c(0.20, 0.20, 0.20, 0.20, 0.20), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + setU[[1]] = list(avec = c(0.9, 0.1), mvec = c(0.50), svec = c(0.001)); + setU[[2]] = list(avec = c(0.45, 0.45, 0.1), mvec = c(0.67, 0.33), svec = c(0.001, 0.001)); + setU[[3]] = list(avec = c(0.3, 0.3, 0.3, 0.1), mvec = c(0.25, 0.50, 0.75), svec = c(0.001, 0.001, 0.001)); + setU[[4]] = list(avec = c(0.225, 0.225, 0.225, 0.225, 0.1), mvec = c(0.20, 0.40, 0.60, 0.80), svec = c(0.001,0.001, 0.001, 0.001)); + setU[[5]] = list(avec = c(0.18, 0.18, 0.18, 0.18, 0.18, 0.1), mvec = c(0.17, 0.33, 0.50, 0.67, 0.83), svec = c(0.001, 0.001, 0.001, 0.001, 0.001)); + + } + + if((is.na(tau) + is.na(error)) == 2 ){ + set <- set + setU <- setU + }else{ + set <- setconvert(set, tau, error) + setU <- setconvert(setU, tau, error) + } + + # Set up parm list for BIC calculations + parmlistN <- c() + parmlistN[[1]] <- c(1,2, 3, 4, 5) + parmlistN[[2]] <- c(2,4, 6, 8, 10) + parmlistN[[3]] <- c(1,2, 3, 4, 5) + + parmlistU <- c() + parmlistU[[1]] <- c(2,3, 4, 5, 6) + parmlistU[[2]] <- c(3,5, 7, 9, 11) + parmlistU[[3]] <- c(1,2, 3, 4, 5) + + # EM setup + niter = 1000 + epsilon = 0.1 + + if(free == TRUE){ + type = ""free"" + + message(""Free Model Calculations Started"") + LL1 <- data.frame(LL = (emstepN(p, xi, niter, epsilon, trunc))$loglikelihood, type = ""free"", mixture = ""free"", distribution = ""normalNQ"") + LL2 <- data.frame(LL = (emstepNU(pu, xi, niter, epsilon, trunc))$loglikelihood, type = ""free"", mixture = ""free"", distribution = ""normalNQ-uniform"") + + LL1$BIC <- 0 + LL2$BIC <- 0 + }else if(free == FALSE){ + message(""Free Model Skipped. Log-likelihood ratio will not be included."") + } + + # Fixed models + if(is.na(cores)){ + cores <- (future::availableCores()-1) + } + + if(parallel == TRUE){ + cl <- parallel::makeCluster(cores) + ## Register parallel + doParallel::registerDoParallel(cl) + + + opts <- list(chunkSize=2) + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""pentaploid"", ""hexaploid"") + message(""Calculating likelihood of each mixture with a normal distibution."") + + d <- foreach(type=1:3, .combine='rbind', .options.nws=opts) %:% + foreach::foreach(iter = 1:5, .combine='rbind', .packages = ""nQuack"") %dopar% { + + obj <- nQuack::emstepN(set[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[[type]][iter])) + data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""normalNQ"", BIC = BICout) + } + message(""Calculating likelihood of each mixture with a normal + uniform distibution."") + + opts <- list(chunkSize=2) + du <- foreach(type=1:3, .combine='rbind', .options.nws=opts) %:% + foreach::foreach(iter = 1:5, .combine='rbind', .packages = ""nQuack"") %dopar% { + obj <- nQuack::emstepNU(setU[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[[type]][iter])) + data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""normalNQ-uniform"", BIC = BICout) + } + + # Stop cluster + parallel::stopCluster(cl) + + }else if(parallel == FALSE){ + + bvec <- c(""fixed"", ""fixed_2"", ""fixed_3"") + mixturekey <- c(""diploid"", ""triploid"", ""tetraploid"", ""pentaploid"", ""hexaploid"") + + d <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(d) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + message(""Calculating likelihood of each mixture with a normal distibution."") + + for(type in 1:3){ + for(iter in 1:5){ + obj <- nQuack::emstepN(set[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistN[[type]][iter])) + d <- rbind(d, data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""normalNQ"", BIC = BICout)) + } + } + + + du <- as.data.frame(matrix(nrow = 0, ncol = 5)) + colnames(du) <- c(""LL"", ""type"", ""mixture"", ""distribution"", ""BIC"") + for(type in 1:3){ + for(iter in 1:5){ + obj <- nQuack::emstepNU(setU[[iter]], xi, niter, epsilon, trunc, type = bvec[type]) + BICout <- ((-2*obj$loglikelihood) + (lnn*parmlistU[[type]][iter])) + du <- rbind(du, data.frame(LL=obj$loglikelihood, type=bvec[type], mixture=mixturekey[iter], distribution = ""normalNQ-uniform"", BIC = BICout)) + } + } + } + + + if(free == TRUE){ + + dLL <- c() + for(kk in 1:nrow(d)){ + dLL[kk] <-(LL1$LL - d$LL[kk]) + } + d$dLL <- dLL + + dULL <- c() + for(kk in 1:nrow(du)){ + dULL[kk] <-(LL2$LL - du$LL[kk]) + } + du$dLL <- dULL + + LL1$dLL <- 0 + LL2$dLL <- 0 + + + out <- rbind(LL1, LL2, d, du) + + }else if(free == FALSE){ + out <- rbind( d, du) + } + + out$sample <- samplename + return(out) +} +","R" +"Allele","raphael-group/hatchet","setup.py",".py","2809","86","import os +import re +import sys +import platform +import subprocess +import shutil + +from setuptools import setup, Extension +from setuptools.command.build_ext import build_ext +from distutils.version import LooseVersion + + +class CMakeExtension(Extension): + def __init__(self, name, sourcedir=""""): + Extension.__init__(self, name, sources=[]) + self.sourcedir = os.path.abspath(sourcedir) + + +class CMakeBuild(build_ext): + def run(self): + try: + out = subprocess.check_output([""cmake"", ""--version""]) + except OSError: + raise RuntimeError( + ""CMake must be installed to build the following extensions: "" + + "", "".join(e.name for e in self.extensions) + ) + + if platform.system() == ""Windows"": + cmake_version = LooseVersion( + re.search(r""version\s*([\d.]+)"", out.decode()).group(1) + ) + if cmake_version < ""3.1.0"": + raise RuntimeError(""CMake >= 3.1.0 is required on Windows"") + + for ext in self.extensions: + self.build_extension(ext) + + def build_extension(self, ext): + extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name))) + cmake_args = [ + ""-DCMAKE_INSTALL_PREFIX="" + extdir, + ""-DCMAKE_LIBRARY_OUTPUT_DIRECTORY="" + extdir, + ""-DGUROBI_HOME="" + os.environ.get(""GUROBI_HOME"", """"), + ""-DPYTHON_EXECUTABLE="" + sys.executable, + ] + + # TODO: ""Release"" generates a solve binary that coredumps on Linux - investigate. + cfg = ""Debug"" if self.debug else """" # else 'Release' + build_args = [""--config"", cfg] + + if platform.system() == ""Windows"": + cmake_args += [ + ""-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}"".format(cfg.upper(), extdir) + ] + if sys.maxsize > 2**32: + cmake_args += [""-A"", ""x64""] + build_args += [""--"", ""/m""] + else: + cmake_args += [""-DCMAKE_BUILD_TYPE="" + cfg] + build_args += [""--"", ""-j2""] + + env = os.environ.copy() + env[""CXXFLAGS""] = '{} -DVERSION_INFO=\\""{}\\""'.format( + env.get(""CXXFLAGS"", """"), self.distribution.get_version() + ) + if os.path.exists(self.build_temp): + shutil.rmtree(self.build_temp) + os.makedirs(self.build_temp) + + subprocess.check_call( + [""cmake"", ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env + ) + subprocess.check_call( + [""cmake"", ""--build"", ""."", ""--target"", ""install""] + build_args, + cwd=self.build_temp, + ) + + +setup( + ext_modules=[] + if os.environ.get(""HATCHET_BUILD_NOEXT"", ""0"") == ""1"" + else [CMakeExtension(""hatchet.solve"")], + cmdclass=dict(build_ext=CMakeBuild), +) +","Python" +"Allele","raphael-group/hatchet","custom/setup-preprocess/setup.md",".md","3097","75","# Automatic installation for HATCHet's preprocessing +: ex: set ft=markdown ;:<<'```shell' # + +The following script allows the user to setup all the required requisites for running the preprocessing steps of HATCHet. + +## Preliminary setup + +First we define the `SETUP_HOME` directory as the current dictory, however any path can be alternatively chosen. Please update this path accoring to your requirements. + +```shell +export SETUP_HOME=$(pwd) +:<<'```shell' # Ignore this line +``` + +We also ask the setup to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Downloading and installing SAMtools and BCFtools v1.6 + +We download and install SAMtools 1.6 within `${SETUP_HOME}/samtools-1.6` + +```shell +wget https://github.com/samtools/samtools/releases/download/1.6/samtools-1.6.tar.bz2 -P ${SETUP_HOME}/ +tar -xvjf ${SETUP_HOME}/samtools-1.6.tar.bz2 -C ${SETUP_HOME}/ && rm -f ${SETUP_HOME}/samtools-1.6.tar.bz2 +(cd ${SETUP_HOME}/samtools-1.6 && ./configure --prefix=${SETUP_HOME}/samtools-1.6/ && make -j && make -j install) +echo 'export PATH='${SETUP_HOME}'/samtools-1.6/bin/:${PATH}' > ${SETUP_HOME}/setup_hatchet.sh +:<<'```shell' # Ignore this line +``` + +We download and install BCFtools 1.6 within `${SETUP_HOME}/bcftools-1.6` + +```shell +wget https://github.com/samtools/bcftools/releases/download/1.6/bcftools-1.6.tar.bz2 -P ${SETUP_HOME}/ +tar -xvjf ${SETUP_HOME}/bcftools-1.6.tar.bz2 -C ${SETUP_HOME}/ && rm -f ${SETUP_HOME}/bcftools-1.6.tar.bz2 +(cd ${SETUP_HOME}/bcftools-1.6 && ./configure --prefix=${SETUP_HOME}/bcftools-1.6/ && make -j && make -j install) +echo 'export PATH='${SETUP_HOME}'/bcftools-1.6/bin/:${PATH}' >> ${SETUP_HOME}/setup_hatchet.sh +:<<'```shell' # Ignore this line +``` + +## Setting up the python environment + +We download and install Miniconda to create virtual environment specific to HATCHet. + +```shell +wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -P ${SETUP_HOME}/ +bash ${SETUP_HOME}/Miniconda3-latest-Linux-x86_64.sh -b -f -p ${SETUP_HOME}/miniconda/ && rm -f ${SETUP_HOME}/Miniconda3-latest-Linux-x86_64.sh +${SETUP_HOME}/miniconda/bin/conda create -y -n hatchet python=3.8 +# install HATCHet +source ${SETUP_HOME}/miniconda/bin/activate hatchet +pip install -U pip +pip install -U setuptools +pip install . +# set up bioconda and install mosdepth +conda config --add channels defaults +conda config --add channels bioconda +conda config --add channels conda-forge +conda install mosdepth +echo ""source ${SETUP_HOME}/miniconda/bin/activate hatchet"" >> ${SETUP_HOME}/setup_hatchet.sh +:<<'```shell' # Ignore this line +``` + +## Using this setup for HATCHet + +All the previous steps are one-time only, however the environments that we prepared should be activated in every new session before using HATCHet. This can be achieved by simply running the following command once per new session before running HATCHet, where `${SETUP_HOME}` is the path that we chose at the beginning: + +```shell +source ${SETUP_HOME}/setup_hatchet.sh +exit $? +``` +","Markdown" +"Allele","raphael-group/hatchet","custom/setup-preprocess/setup.sh",".sh","3097","75","# Automatic installation for HATCHet's preprocessing +: ex: set ft=markdown ;:<<'```shell' # + +The following script allows the user to setup all the required requisites for running the preprocessing steps of HATCHet. + +## Preliminary setup + +First we define the `SETUP_HOME` directory as the current dictory, however any path can be alternatively chosen. Please update this path accoring to your requirements. + +```shell +export SETUP_HOME=$(pwd) +:<<'```shell' # Ignore this line +``` + +We also ask the setup to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Downloading and installing SAMtools and BCFtools v1.6 + +We download and install SAMtools 1.6 within `${SETUP_HOME}/samtools-1.6` + +```shell +wget https://github.com/samtools/samtools/releases/download/1.6/samtools-1.6.tar.bz2 -P ${SETUP_HOME}/ +tar -xvjf ${SETUP_HOME}/samtools-1.6.tar.bz2 -C ${SETUP_HOME}/ && rm -f ${SETUP_HOME}/samtools-1.6.tar.bz2 +(cd ${SETUP_HOME}/samtools-1.6 && ./configure --prefix=${SETUP_HOME}/samtools-1.6/ && make -j && make -j install) +echo 'export PATH='${SETUP_HOME}'/samtools-1.6/bin/:${PATH}' > ${SETUP_HOME}/setup_hatchet.sh +:<<'```shell' # Ignore this line +``` + +We download and install BCFtools 1.6 within `${SETUP_HOME}/bcftools-1.6` + +```shell +wget https://github.com/samtools/bcftools/releases/download/1.6/bcftools-1.6.tar.bz2 -P ${SETUP_HOME}/ +tar -xvjf ${SETUP_HOME}/bcftools-1.6.tar.bz2 -C ${SETUP_HOME}/ && rm -f ${SETUP_HOME}/bcftools-1.6.tar.bz2 +(cd ${SETUP_HOME}/bcftools-1.6 && ./configure --prefix=${SETUP_HOME}/bcftools-1.6/ && make -j && make -j install) +echo 'export PATH='${SETUP_HOME}'/bcftools-1.6/bin/:${PATH}' >> ${SETUP_HOME}/setup_hatchet.sh +:<<'```shell' # Ignore this line +``` + +## Setting up the python environment + +We download and install Miniconda to create virtual environment specific to HATCHet. + +```shell +wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -P ${SETUP_HOME}/ +bash ${SETUP_HOME}/Miniconda3-latest-Linux-x86_64.sh -b -f -p ${SETUP_HOME}/miniconda/ && rm -f ${SETUP_HOME}/Miniconda3-latest-Linux-x86_64.sh +${SETUP_HOME}/miniconda/bin/conda create -y -n hatchet python=3.8 +# install HATCHet +source ${SETUP_HOME}/miniconda/bin/activate hatchet +pip install -U pip +pip install -U setuptools +pip install . +# set up bioconda and install mosdepth +conda config --add channels defaults +conda config --add channels bioconda +conda config --add channels conda-forge +conda install mosdepth +echo ""source ${SETUP_HOME}/miniconda/bin/activate hatchet"" >> ${SETUP_HOME}/setup_hatchet.sh +:<<'```shell' # Ignore this line +``` + +## Using this setup for HATCHet + +All the previous steps are one-time only, however the environments that we prepared should be activated in every new session before using HATCHet. This can be achieved by simply running the following command once per new session before running HATCHet, where `${SETUP_HOME}` is the path that we chose at the beginning: + +```shell +source ${SETUP_HOME}/setup_hatchet.sh +exit $? +``` +","Shell" +"Allele","raphael-group/hatchet","custom/GATK4-CNV/custom-gatk4-cnv.sh",".sh","1720","49","#!/usr/bin/bash + +# This is a custom complete pipeline of HATCHet which considers in input segmented files for one or more samples from the same patient, produced by the GATK4 CNV pipeline. + +HATCHET_HOME=""/path/to/hatchet_home"" # Provide the full path to HATCHet's repository + +CNVTOBB=""${HATCHET_HOME}/custom/GATK4-CNV/gatk4cnsToBB.py"" + +XDIR=""/path/to/running-dir/"" # Specify running directory where all results will be written +SEGS=""/path/to/tumor-sample1.seg /path/to/tumor-sample2.seg"" # Specify the full path to segmented files +NAMES=""Sample1 Sample2"" # Specify the names of samples in the same order as above +J=22 # Specify the number of threads that can be used + +set -e +set -o xtrace +PS4='\''[\t]'\' +#source /path/to/virtualenv-python3.8/bin/activate + +BB=${XDIR}bb/ +mkdir -p ${BB} +BBC=${XDIR}bbc/ +mkdir -p ${BBC} +ANA=${XDIR}analysis/ +mkdir -p ${ANA} +RES=${XDIR}results/ +mkdir -p ${RES} +EVA=${XDIR}evaluation/ +mkdir -p ${EVA} + +cd ${XDIR} + +\time -v python3 ${CNVTOBB} ""${SEGS}"" -- samples ""${NAMES}"" > ${BB}bulk.bb + +\time -v python3 -m hatchet cluster-bins ${BB}bulk.bb -o ${BBC}bulk.seg -O ${BBC}bulk.bbc -e 12 -tB 0.04 -tR 0.15 -d 0.08 + +cd ${ANA} +\time -v python3 -m hatchet plot-bins -c RD --figsize 6,3 ${BBC}bulk.bbc & +\time -v python3 -m hatchet plot-bins -c CRD --figsize 6,3 ${BBC}bulk.bbc & +\time -v python3 -m hatchet plot-bins -c BAF --figsize 6,3 ${BBC}bulk.bbc & +\time -v python3 -m hatchet plot-bins -c BB ${BBC}bulk.bbc & +\time -v python3 -m hatchet plot-bins -c CBB ${BBC}bulk.bbc & +wait + +cd ${RES} +\time -v python3 -m hatchet solve -i ${BBC}bulk -n2,8 -p 400 -v 3 -u 0.03 -r 12 -j ${J} -eD 6 -eT 12 -g 0.35 -l 0.6 |& tee hatchet.log + +cd ${EVA} +\time -v python3 -m hatchet plot-cn ${RES}/best.bbc.ucn +","Shell" +"Allele","raphael-group/hatchet","custom/GATK4-CNV/demo-gatk4-cnv.md",".md","10823","148","# Demo of the custom pipeline for GATK4 CNV data +: ex: set ft=markdown ;:<<'```shell' # This line makes this file both a guieded and executable DEMO. The file can be both displayed as a Markdown file, where to read the instructions and descriptions of the demo and results, and a BASH script, which can be directly executed with BASH to execute the demo after setting the first requirements. + +The following HATCHet's demo represents a guided example of the custom pipeline designed to start from the data produced by the [GATK4 CNV pipeline](https://software.broadinstitute.org/gatk/best-practices/workflow?id=11147). This custom pipeline considers one or more tumor samples from the same patient which have been segmented through the GATK4 CNV pipeline, such that for each sample a **segmented file** is available. The expected format of each segmented file is first described in the following section. Next, the requirements for this demo are described and the guided demo is detailed across the different steps. + +## Input format + +Ths GATK4 CNV pipeline takes in input segmented files for one or more tumor samples from the same patient. Each segmented file is a tab-separated file with the following header subsequently followed by the specified fields: +- *HEADER*: The header is composed of lines starting with the symbol `@` which provide several details concerning the sample and are ignored by this pipeline. +- *Fields*: The fields contain the the segments and the related data; in particular, the first line specified the name of the fields starting with the word `CONTIG` and next each line corresponds to a different segments. The fields are the following: + +| Field | Description | USED/IGNORED | +|-------|-------------|--------------| +| `CONTIG` | Name of a chromosome | USED | +| `START` | Start genomic position of segment | USED | +| `END` | End genomic positon of segment | USED | +| `NUM_POINTS_COPY_RATIO` | Number of points used to estimate RDR | IGNORED | +| `NUM_POINTS_ALLELE_FRACTION` | Number of points used to estimate BAF | IGNORED | +| `LOG2_COPY_RATIO_POSTERIOR_10` | RDR posterior 10 | IGNORED | +| `LOG2_COPY_RATIO_POSTERIOR_50` | Estimated RDR | USED | +| `LOG2_COPY_RATIO_POSTERIOR_90` | RDR posterior 90 | IGNORED | +| `MINOR_ALLELE_FRACTION_POSTERIOR_10` | BAF posterior 10 | IGNORED | +| `MINOR_ALLELE_FRACTION_POSTERIOR_50` | Estimated BAF | USED | +| `MINOR_ALLELE_FRACTION_POSTERIOR_90` | BAF posterior 90 | IGNORED| + +Two example segmented files in this format for two tumor samples from the same patient are included with this demo as [sample1.GATK4.CNV.seg](../../sample1.GATK4.CNV.seg) and [sample2.GATK4.CNV.seg](../../sample2.GATK4.CNV.seg). + +## Requirements and set up + +The demo requires that HATCHet has been succesfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: + +```shell +PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required modules. When this corresponds to the standard version, the user can keep the given value of `python3` +:<<'```shell' # Ignore this line +``` + +The following paths are consequently obtained to point to the required components of HATCHet + +```shell +CLUSTERBINS=""${PY} -m hatchet cluster-bins"" +PLOTBINS=""${PY} -m hatchet plot-bins"" +INFER=""${PY} -m hatchet solve"" +PLOTCN=""${PY} -m hatchet plot-cn"" +GATK4CNSTOBB=""${PY} gatk4cnsToBB.py"" +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Generating input BB file + +The first step of this custom pipeline aims to generate an input BB file for HATCHet starting from the given segmented files; in this case, we consider the two examples included with this demo `sample1.GATK4.CNV.seg` and `sample2.GATK4.CNV.seg`. The corresponding BB file can be easily obtained by using the custom python script [gatk4cnsToBB.py](gatk4cnsToBB.py) included in the custom pipeline. We apply the script by specifiying the two segmented files in a white-sperated list between apices and specifying the names of the samples in the same order with `--samples`. In addition, we consider the default values of the parameters and we run it as follows: + +```shell +${GATK4CNSTOBB} ""sample1.GATK4.CNV.seg sample2.GATK4.CNV.seg"" --samples ""Sample1 Sample2"" > samples.GATK4.CNV.bb +:<<'```shell' # Ignore this line +``` + +In addition, one could consider different size of the resulting bins by using the option `-b`, e.g. `-b 10kb`. + +## Global custering + +Having the input BB file, we can continue by executing the standard HATCHet pipeline and skipping the pre-processing steps (`count-reads`, `count-alleles`, and `combine-counts`). As such, the next main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: + +```shell +${CLUSTERBINS} samples.GATK4.CNV.bb -o samples.GATK4.CNV.seg -O samples.GATK4.CNV.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 +:<<'```shell' # Ignore this line +``` + +To assess the quality of the clustering we generate the cluster plot using the `CBB` command of `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data. For simplicity, we also use the following option `-tS 0.001` which asks to plot only the clusters which cover at least the `0.1%` of the genome. This is useful to clean the figure and focus on the main components. + +```shell +${PLOTBINS} -c CBB samples.GATK4.CNV.bbc -tS 0.001 +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![CBB](cbb.png) + +We can easily notice that the clustering is good and not tuning is needed as every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. + +## hatchet's step + +Next we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. +We apply the last step with default parameters and, for simplicity of this demo, we consider 6 clones, which can be easily considered by HATCHet in this case, and we only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. + +```shell +${INFER} -i samples.GATK4.CNV -n2,6 -p 100 -v 2 -u 0.03 -r 12 -eD 6 -eT 12 -l 0.6 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results: + + # Selecting best solution + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 5.145092 - score: -0.61889027446 + ## Diploid with 3 clones - OBJ: 0.417317 - score: 0.345368628644 + ## Diploid with 4 clones - OBJ: 0.311055 - score: -0.052709774101 + ## Diploid with 5 clones - OBJ: 0.215455 - score: 0.208536290615 + ## Diploid with 6 clones - OBJ: 0.194167 - score: -0.201195145158 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 13.22581 - score: -0.647943150552 + ## Tetraploid with 3 clones - OBJ: 0.688494 - score: 0.198212911078 + ## Tetraploid with 4 clones - OBJ: 0.411866 - score: 0.230287135053 + ## Tetraploid with 5 clones - OBJ: 0.341231 - score: 0.171499953868 + ## Tetraploid with 6 clones - OBJ: 0.34156 - score: -0.3 + # The chosen diploid solution has 3 clones with OBJ: 0.417317 and score: 0.345368628644 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 4 clones with OBJ: 0.411866 and score: 0.230287135053 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is diploid with 3 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet predicts the presence of 3 clones in the 2 tumor samples and, especially, predicts that a sample contains two distinct tumor clones, according to the true clonal composition, and one of these clones is shared with the other sample. + +## Analyzing inferred results + +Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows + +```shell +${PLOTCN} best.bbc.ucn +exit $? +``` + +First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: + + ### SAMPLE: Sample1 -- PURITY: 0.799622 -- PLOIDY: 2.00463946866 -- CLASSIFICATION: DIPLOID + ### SAMPLE: Sample2 -- PURITY: 0.948195 -- PLOIDY: 2.01049490767 -- CLASSIFICATION: DIPLOID + +Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly interesting. + +The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). +![intratumor-clones-totalcn.pdf](totalcn.png) +Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. + +The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. +![intratumor-clones-allelecn.pdf](allelecn.png) + +The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. +![intratumor-clones-allelecn.pdf](profiles.png) +The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. +","Markdown" +"Allele","raphael-group/hatchet","custom/GATK4-CNV/demo-gatk4-cnv.sh",".sh","10823","148","# Demo of the custom pipeline for GATK4 CNV data +: ex: set ft=markdown ;:<<'```shell' # This line makes this file both a guieded and executable DEMO. The file can be both displayed as a Markdown file, where to read the instructions and descriptions of the demo and results, and a BASH script, which can be directly executed with BASH to execute the demo after setting the first requirements. + +The following HATCHet's demo represents a guided example of the custom pipeline designed to start from the data produced by the [GATK4 CNV pipeline](https://software.broadinstitute.org/gatk/best-practices/workflow?id=11147). This custom pipeline considers one or more tumor samples from the same patient which have been segmented through the GATK4 CNV pipeline, such that for each sample a **segmented file** is available. The expected format of each segmented file is first described in the following section. Next, the requirements for this demo are described and the guided demo is detailed across the different steps. + +## Input format + +Ths GATK4 CNV pipeline takes in input segmented files for one or more tumor samples from the same patient. Each segmented file is a tab-separated file with the following header subsequently followed by the specified fields: +- *HEADER*: The header is composed of lines starting with the symbol `@` which provide several details concerning the sample and are ignored by this pipeline. +- *Fields*: The fields contain the the segments and the related data; in particular, the first line specified the name of the fields starting with the word `CONTIG` and next each line corresponds to a different segments. The fields are the following: + +| Field | Description | USED/IGNORED | +|-------|-------------|--------------| +| `CONTIG` | Name of a chromosome | USED | +| `START` | Start genomic position of segment | USED | +| `END` | End genomic positon of segment | USED | +| `NUM_POINTS_COPY_RATIO` | Number of points used to estimate RDR | IGNORED | +| `NUM_POINTS_ALLELE_FRACTION` | Number of points used to estimate BAF | IGNORED | +| `LOG2_COPY_RATIO_POSTERIOR_10` | RDR posterior 10 | IGNORED | +| `LOG2_COPY_RATIO_POSTERIOR_50` | Estimated RDR | USED | +| `LOG2_COPY_RATIO_POSTERIOR_90` | RDR posterior 90 | IGNORED | +| `MINOR_ALLELE_FRACTION_POSTERIOR_10` | BAF posterior 10 | IGNORED | +| `MINOR_ALLELE_FRACTION_POSTERIOR_50` | Estimated BAF | USED | +| `MINOR_ALLELE_FRACTION_POSTERIOR_90` | BAF posterior 90 | IGNORED| + +Two example segmented files in this format for two tumor samples from the same patient are included with this demo as [sample1.GATK4.CNV.seg](../../sample1.GATK4.CNV.seg) and [sample2.GATK4.CNV.seg](../../sample2.GATK4.CNV.seg). + +## Requirements and set up + +The demo requires that HATCHet has been succesfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: + +```shell +PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required modules. When this corresponds to the standard version, the user can keep the given value of `python3` +:<<'```shell' # Ignore this line +``` + +The following paths are consequently obtained to point to the required components of HATCHet + +```shell +CLUSTERBINS=""${PY} -m hatchet cluster-bins"" +PLOTBINS=""${PY} -m hatchet plot-bins"" +INFER=""${PY} -m hatchet solve"" +PLOTCN=""${PY} -m hatchet plot-cn"" +GATK4CNSTOBB=""${PY} gatk4cnsToBB.py"" +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Generating input BB file + +The first step of this custom pipeline aims to generate an input BB file for HATCHet starting from the given segmented files; in this case, we consider the two examples included with this demo `sample1.GATK4.CNV.seg` and `sample2.GATK4.CNV.seg`. The corresponding BB file can be easily obtained by using the custom python script [gatk4cnsToBB.py](gatk4cnsToBB.py) included in the custom pipeline. We apply the script by specifiying the two segmented files in a white-sperated list between apices and specifying the names of the samples in the same order with `--samples`. In addition, we consider the default values of the parameters and we run it as follows: + +```shell +${GATK4CNSTOBB} ""sample1.GATK4.CNV.seg sample2.GATK4.CNV.seg"" --samples ""Sample1 Sample2"" > samples.GATK4.CNV.bb +:<<'```shell' # Ignore this line +``` + +In addition, one could consider different size of the resulting bins by using the option `-b`, e.g. `-b 10kb`. + +## Global custering + +Having the input BB file, we can continue by executing the standard HATCHet pipeline and skipping the pre-processing steps (`count-reads`, `count-alleles`, and `combine-counts`). As such, the next main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: + +```shell +${CLUSTERBINS} samples.GATK4.CNV.bb -o samples.GATK4.CNV.seg -O samples.GATK4.CNV.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 +:<<'```shell' # Ignore this line +``` + +To assess the quality of the clustering we generate the cluster plot using the `CBB` command of `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data. For simplicity, we also use the following option `-tS 0.001` which asks to plot only the clusters which cover at least the `0.1%` of the genome. This is useful to clean the figure and focus on the main components. + +```shell +${PLOTBINS} -c CBB samples.GATK4.CNV.bbc -tS 0.001 +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![CBB](cbb.png) + +We can easily notice that the clustering is good and not tuning is needed as every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. + +## hatchet's step + +Next we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. +We apply the last step with default parameters and, for simplicity of this demo, we consider 6 clones, which can be easily considered by HATCHet in this case, and we only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. + +```shell +${INFER} -i samples.GATK4.CNV -n2,6 -p 100 -v 2 -u 0.03 -r 12 -eD 6 -eT 12 -l 0.6 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results: + + # Selecting best solution + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 5.145092 - score: -0.61889027446 + ## Diploid with 3 clones - OBJ: 0.417317 - score: 0.345368628644 + ## Diploid with 4 clones - OBJ: 0.311055 - score: -0.052709774101 + ## Diploid with 5 clones - OBJ: 0.215455 - score: 0.208536290615 + ## Diploid with 6 clones - OBJ: 0.194167 - score: -0.201195145158 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 13.22581 - score: -0.647943150552 + ## Tetraploid with 3 clones - OBJ: 0.688494 - score: 0.198212911078 + ## Tetraploid with 4 clones - OBJ: 0.411866 - score: 0.230287135053 + ## Tetraploid with 5 clones - OBJ: 0.341231 - score: 0.171499953868 + ## Tetraploid with 6 clones - OBJ: 0.34156 - score: -0.3 + # The chosen diploid solution has 3 clones with OBJ: 0.417317 and score: 0.345368628644 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 4 clones with OBJ: 0.411866 and score: 0.230287135053 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is diploid with 3 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet predicts the presence of 3 clones in the 2 tumor samples and, especially, predicts that a sample contains two distinct tumor clones, according to the true clonal composition, and one of these clones is shared with the other sample. + +## Analyzing inferred results + +Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows + +```shell +${PLOTCN} best.bbc.ucn +exit $? +``` + +First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: + + ### SAMPLE: Sample1 -- PURITY: 0.799622 -- PLOIDY: 2.00463946866 -- CLASSIFICATION: DIPLOID + ### SAMPLE: Sample2 -- PURITY: 0.948195 -- PLOIDY: 2.01049490767 -- CLASSIFICATION: DIPLOID + +Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly interesting. + +The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). +![intratumor-clones-totalcn.pdf](totalcn.png) +Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. + +The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. +![intratumor-clones-allelecn.pdf](allelecn.png) + +The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. +![intratumor-clones-allelecn.pdf](profiles.png) +The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. +","Shell" +"Allele","raphael-group/hatchet","custom/GATK4-CNV/gatk4cnsToBB.py",".py","11082","339","import sys +import os +import argparse +import math +import numpy as np + +from collections import deque +from hatchet import __version__ + + +def parse_args(): + description = ( + ""This method takes in input multiple samples from the same patient, where each sample is a "" + ""segmented CNV file produced by GATK4 CNV pipeline, and produces a BB input file for HATCHet."" + ) + parser = argparse.ArgumentParser(description=description) + parser.add_argument( + ""INPUT"", + type=str, + help=( + ""A white-space-separated list between apices where each element is a segmented CNV file produced by "" + ""GATK4 CNV pipeline. The file format is describe in the HATCHet's repository."" + ), + ) + parser.add_argument( + ""--samples"", + type=str, + required=False, + default=None, + help=( + ""A white-space-separated list containing the name of sample in the same order as given (default: "" + ""filenames are used)."" + ), + ) + parser.add_argument( + ""-b"", + ""--binsize"", + required=False, + default=""50kb"", + type=str, + help='Size of the bins, specified as a full number or using the notations either ""kb"" or ""Mb"" (default: 50kb).', + ) + parser.add_argument( + ""-r"", + ""--devRDR"", + type=float, + required=False, + default=0.05, + help=""Standard deviation for the RDR of bins obtained from RDR of the corresponding segment (default: 0,05)."", + ) + parser.add_argument( + ""-a"", + ""--devBAF"", + type=float, + required=False, + default=0.02, + help=""Standard deviation for the RDR of bins obtained from RDR of the corresponding segment (default: 0.02)."", + ) + parser.add_argument( + ""-s"", + ""--seed"", + type=int, + required=False, + default=None, + help=""Starting seed for random number generator (default: not specified)."", + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args() + + samples = args.INPUT.strip().split() + for s in samples: + if not os.path.isfile(s): + raise ValueError(""ERROR: sample {} does not exist!"".format(s)) + + if args.samples: + names = args.samples.strip().split() + if len(names) != len(samples): + raise ValueError( + ""ERROR: a sample name must be specified for every given sample!"" + ) + samples = {n: s for n, s in zip(names, samples)} + else: + samples = {n: s for n, s in zip(samples, samples)} + + size = 0 + try: + if args.binsize[-2:] == ""kb"": + size = int(args.binsize[:-2]) * 1000 + elif args.binsize[-2:] == ""Mb"": + size = int(args.binsize[:-2]) * 1000000 + else: + size = int(args.binsize) + except (IndexError, ValueError): + raise ValueError( + 'Size must be a number, optionally ending with either ""kb"" or ""Mb""!' + ) + + if args.devRDR < 0.0: + raise ValueError(""ERROR: deviation of RDR must be grater or equal than 0.0!"") + + if args.devBAF < 0.0: + raise ValueError(""ERROR: deviation of BAF must be grater or equal than 0.0!"") + + if args.seed: + np.random.seed(args.seed) + + return { + ""samples"": samples, + ""binsize"": size, + ""devrdr"": args.devRDR, + ""devbaf"": args.devBAF, + } + + +def main(): + log(""Parsing and checking input arguments"") + args = parse_args() + + log(""Reading input files"") + segs = read_segs(args[""samples""]) + + log(""Segmenting all samples jointly"") + segs = jsegmentation(segs) + + log(""Binning the segments across all samples"") + bins = binning(segs, size=args[""binsize""], drdr=args[""devrdr""], dbaf=args[""devbaf""]) + + log(""Writing the corresponding BB file"") + print( + ""\t"".join( + [ + ""#CHR"", + ""START"", + ""END"", + ""SAMPLE"", + ""RD"", + ""#SNPS"", + ""COV"", + ""ALPHA"", + ""BETA"", + ""BAF"", + ] + ) + ) + orderchrs = lambda x: int("""".join([l for l in x if l.isdigit()])) + nsnp = lambda L: int(round(L / 1000.0)) + cov = lambda R: R * 60.0 + AB = lambda R, B, L: list(splitBAF(baf=B, scale=max(1000, R * L / 250.0))) + dat = lambda c, b, p, L, R, B: [R, nsnp(L), cov(R)] + AB(R, B, L) + [B] + row = lambda c, b, p: [c, b[0], b[1], p] + dat( + c, b, p, float(b[1] - b[0]), bins[c][b][p][""RDR""], bins[c][b][p][""BAF""] + ) + print( + ""\n"".join( + [ + ""\t"".join(map(str, row(c, b, p))) + for c in sorted(bins, key=orderchrs) + for b in sorted(bins[c]) + for p in sorted(bins[c][b]) + ] + ) + ) + + +def read_segs(samples): + def read_sample(s): + d = {} + with open(s, ""r"") as i: + for l in i: + if l[0] != ""#"" and l[0] != ""@"" and len(l) > 1: + p = l.strip().split() + if p[0] != ""CONTIG"": + h = p[0] + seg = (int(p[1]), int(p[2])) + if p[6].upper() not in [""NAN"", ""NONE""] and p[9].upper() not in [ + ""NAN"", + ""NONE"", + ]: + rdr = math.pow(2.0, float(p[6])) + if rdr < 0.0: + raise ValueError( + ""ERROR: the log of RDR expected to be positive but value {} found!"".format( + rdr + ) + ) + baf = float(p[9]) + if not 0.0 <= baf <= 0.5: + raise ValueError( + ""ERROR: BAF expected to be in [0, 0.5] but value {} found!"".format( + baf + ) + ) + if h not in d: + d[h] = {} + assert ( + seg not in d[h] + ), ""ERROR: Found a duplicate segment {}:{}-{}"".format( + h, seg[0], seg[1] + ) + check = lambda b: (b[0] <= b[1] <= seg[0]) or ( + seg[1] <= b[0] <= b[1] + ) + assert False not in set( + check(b) for b in d[h] + ), ""ERROR: found overlapping segment {}:{}-{}"".format( + h, seg[0], seg[1] + ) + d[h][seg] = {""RDR"": rdr, ""BAF"": baf} + return d + + return {s: read_sample(samples[s]) for s in samples} + + +def jsegmentation(segs): + chrs = set(c for p in segs for c in segs[p]) + bk = lambda p, c: set(k for s in segs[p][c] for k in s) + bks = { + c: sorted(set(k for p in segs if c in segs[p] for k in bk(p, c))) for c in chrs + } + counts = {c: {s: 0 for s in zip(bks[c][:-1], bks[c][1:])} for c in bks} + bmap = {p: {c: {s: None for s in counts[c]} for c in counts} for p in segs} + + for p in segs: + for c in segs[p]: + bk = deque(bks[c]) + left = -1 + right = bk.popleft() + for l, r in sorted(segs[p][c], key=(lambda x: x[0])): + while right != r: + left = right + right = bk.popleft() + if l <= left and right <= r: + counts[c][left, right] += 1 + bmap[p][c][left, right] = (l, r) + + tak = {c: set(s for s in counts[c] if counts[c][s] == len(segs)) for c in counts} + tak = {c: tak[c] for c in tak if len(tak[c]) > 0} + + tot = float(sum(s[1] - s[0] for c in counts for s in counts[c])) + cov = sum(s[1] - s[0] for c in tak for s in tak[c]) + log( + ""##Coverage from joint segmentation is {0:.2f}%"".format( + float(100.0 * cov) / tot + ) + ) + + res = { + p: {c: {s: segs[p][c][bmap[p][c][s]] for s in tak[c]} for c in tak} + for p in segs + } + + chrs = set(c for p in res for c in res[p]) + pos = {c: set(s for p in res for s in res[p][c]) for c in chrs} + + join = {p: {c: {} for c in segs[p]} for p in segs} + for c in chrs: + l = None + r = None + val = None + for s in sorted(pos[c], key=(lambda x: x[0])): + if l is None: + l = s[0] + val = {p: res[p][c][s] for p in res} + elif val != {p: res[p][c][s] for p in res}: + for p in join: + join[p][c][l, r] = val[p] + l = s[0] + val = {p: res[p][c][s] for p in res} + r = s[1] + for p in join: + join[p][c][l, r] = val[p] + + assert False not in set( + cov == sum(s[1] - s[0] for c in join[p] for s in join[p][c]) for p in res + ) + + return join + + +def binning(segs, size, drdr, dbaf): + tg = list(segs.keys())[0] + chrs = segs[tg].keys() + pos = {c: sorted([s for s in segs[tg][c]], key=(lambda x: x[0])) for c in chrs} + norm = np.random.normal + BAF = ( + lambda x: min(x, 1.0 - x) + if 0.0 <= x <= 1.0 + else (BAF(1.0) if x > 1.0 else BAF(-x)) + ) + gen = lambda d: { + ""RDR"": norm(d[""RDR""], drdr), + ""BAF"": BAF(norm(d[""BAF""], dbaf)), + } + + bins = {} + for c in chrs: + bins[c] = {} + for s in pos[c]: + assert ( + s[1] - s[0] > 0 + ), ""ERROR: START and END cannot be equal: {}:{}-{}"".format(c, s[0], s[1]) + part = list(range(s[0], s[1], size)) + part = part + [s[1]] if part[-1] != s[1] else part + for b in zip(part[:-1], part[1:]): + bins[c][b] = {p: gen(segs[p][c][s]) for p in segs} + + return bins + + +def splitBAF(baf, scale): + BAF = float(baf) + assert 0.0 <= BAF <= 0.5 + SUM = float(scale) + + roundings = [] + roundings.append((int(math.floor(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) + roundings.append((int(math.floor(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) + roundings.append((int(math.ceil(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) + roundings.append((int(math.ceil(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) + roundings = [(int(min(a, b)), int(max(a, b))) for (a, b) in roundings] + + estimations = [ + float(a) / float(a + b) if a + b > 0 else 1.0 for (a, b) in roundings + ] + diff = [abs(est - BAF) for est in estimations] + best = np.argmin(diff) + + return roundings[best][0], roundings[best][1] + + +def log(M): + sys.stderr.write(""#"" + M + ""\n"") + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","cloud/_run.sh",".sh","3485","84","#!/usr/bin/env bash + +set -e +set -o xtrace + +# ----------------------------------- +# Reference Genome +# ----------------------------------- +# Uncomment ONE of the REFERENCE lines below +# Links obtained from +# https://gatk.broadinstitute.org/hc/en-us/articles/360035890711?id=23390 +# https://cloud.google.com/life-sciences/docs/resources/public-datasets/reference-genomes +# GRCh37 +# REFERENCE=ftp://ftp.ncbi.nlm.nih.gov/genomes/refseq/vertebrate_mammalian/Homo_sapiens/all_assembly_versions/GCF_000001405.25_GRCh37.p13/GCF_000001405.25_GRCh37.p13_genomic.fna.gz +# GRCh37lite +# REFERENCE=https://www.bcgsc.ca/downloads/genomes/9606/hg19/1000genomes/bwa_ind/genome/GRCh37-lite.fa +# hg19 +REFERENCE=http://hgdownload.cse.ucsc.edu/goldenPath/hg19/bigZips/hg19.fa.gz +# b37 +# REFERENCE=ftp://ftp.broadinstitute.org/pub/seq/references/Homo_sapiens_assembly19.fasta +# hs37d5 +# REFERENCE=ftp://ftp.1000genomes.ebi.ac.uk/vol1/ftp/technical/reference/phase2_reference_assembly_sequence/hs37d5.fa.gz +# HumanG1Kv37 +# REFERENCE=http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/technical/reference/human_g1k_v37.fasta.gz +# GRCh38 +# REFERENCE=http://hgdownload.soe.ucsc.edu/goldenPath/hg38/bigZips/hg38.fa.gz +# GRCh38_Verily_v1 +# REFERENCE=ftp://ftp.ncbi.nlm.nih.gov/genomes/all/GCA/000/001/405/GCA_000001405.15_GRCh38/seqs_for_alignment_pipelines.ucsc_ids/GCA_000001405.15_GRCh38_no_alt_plus_hs38d1_analysis_set.fna.gz + +REFERENCE_FILENAME=$(basename -- ""$REFERENCE"") +wget $REFERENCE -P /mnt/data/ +if [[ $REFERENCE_FILENAME == *.gz ]] +then + gunzip /mnt/data/$REFERENCE_FILENAME + REFERENCE_FILENAME=""${REFERENCE_FILENAME%.*}"" +fi +REFERENCE_NAME=""${REFERENCE_FILENAME%.*}"" + +$HATCHET_PATHS_SAMTOOLS/samtools faidx /mnt/data/$REFERENCE_FILENAME +$HATCHET_PATHS_SAMTOOLS/samtools dict /mnt/data/$REFERENCE_FILENAME > /mnt/data/$REFERENCE_NAME.dict +export HATCHET_PATHS_REFERENCE=/mnt/data/$REFERENCE_FILENAME +# ----------------------------------- + +TUMOR_BAMS="""" +ALLNAMES=""NORMAL"" +for BAM_N in ""${!TUMORBAM@}""; do + TUMOR_BAM=""${!BAM_N}"" + TUMOR_BAMS+="" ${TUMOR_BAM}"" + TUMOR_BAM_NAME=""$(basename ""${TUMOR_BAM}"")"" + TUMOR_BAM_NAME=""${TUMOR_BAM_NAME%.*}"" + ALLNAMES+="" ${TUMOR_BAM_NAME}"" +done + +BIN=${OUTPUT_FOLDER}/bin/ +BAF=${OUTPUT_FOLDER}/baf/ +BB=${OUTPUT_FOLDER}/bb/ +BBC=${OUTPUT_FOLDER}/bbc/ +ANA=${OUTPUT_FOLDER}/analysis/ +RES=${OUTPUT_FOLDER}/results/ +EVA=${OUTPUT_FOLDER}/evaluation/ + +mkdir -p ${BIN} ${BAF} ${BB} ${BBC} ${ANA} ${RES} ${EVA} + +python -m hatchet count-reads -N ${NORMALBAM} -T ${TUMOR_BAMS} -S ${ALLNAMES} -b 50kb -O ${BIN}normal.1bed -o ${BIN}bulk.1bed &> ${BIN}bins.log +python -m hatchet count-alleles -N ${NORMALBAM} -T ${TUMOR_BAMS} -S ${ALLNAMES} -O ${BAF}normal.1bed -o ${BAF}bulk.1bed &> ${BAF}bafs.log +python -m hatchet combine-counts -c ${BIN}normal.1bed -C ${BIN}bulk.1bed -B ${BAF}bulk.1bed > ${BB}bulk.bb +python -m hatchet cluster-bins ${BB}bulk.bb -o ${BBC}bulk.seg -O ${BBC}bulk.bbc + +cd ${ANA} +python -m hatchet plot-bins -c RD ${BBC}bulk.bbc +python -m hatchet plot-bins -c CRD ${BBC}bulk.bbc +python -m hatchet plot-bins -c BAF ${BBC}bulk.bbc +python -m hatchet plot-bins -c BB ${BBC}bulk.bbc +python -m hatchet plot-bins -c CBB ${BBC}bulk.bbc + +# ------------------------------------------------------ +# Commented out till the solver works inside a container +# ------------------------------------------------------ +# cd ${RES} +# python -m hatchet compute-cn -i ${BBC}bulk &> >(tee >(grep -v Progress > hatchet.log)) + +# cd ${EVA} +# python -m hatchet plot-cn ${RES}/best.bbc.ucn +","Shell" +"Allele","raphael-group/hatchet","cloud/cloud_run.sh",".sh","843","18","#!/bin/bash + +dsub \ + --provider google-v2 \ + --project PROJECT_ID \ + --regions us-east1 \ + --logging ""gs://BUCKET_NAME/RUN_NAME/logging"" \ + --disk-size 1000 \ + --name ""RUN_NAME"" \ + --image gcr.io/durable-tracer-294016/hatchet \ + --input NORMALBAM=""gs://gdc-tcga-phs000178-controlled/BRCA/DNA/WGS/WUGSC/ILLUMINA/b9774dd35c320f70de8f2b81c15d5a98.bam"" \ + --input NORMALBAI=""gs://gdc-tcga-phs000178-controlled/BRCA/DNA/WGS/WUGSC/ILLUMINA/b9774dd35c320f70de8f2b81c15d5a98.bam.bai"" \ + --input TUMORBAM1=""gs://gdc-tcga-phs000178-controlled/BRCA/DNA/WGS/WUGSC/ILLUMINA/2258e57e8e0af9db6969a1da86177ca7.bam"" \ + --input TUMORBAI1=""gs://gdc-tcga-phs000178-controlled/BRCA/DNA/WGS/WUGSC/ILLUMINA/2258e57e8e0af9db6969a1da86177ca7.bam.bai"" \ + --output-recursive OUTPUT_FOLDER=""gs://BUCKET_NAME/RUN_NAME/output"" \ + --script ""_run.sh"" \ + --wait +","Shell" +"Allele","raphael-group/hatchet","src/utils.h",".h","3061","119","#ifndef _UTILS_H_ +#define _UTILS_H_ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define TOL 0.001 + +/// Random number generator +extern std::mt19937_64 g_rng; +extern std::mutex g_mutex; +extern std::mutex g_output_mutex; + +typedef enum { + NONE = 0, + ESSENTIAL = 1, + VERBOSE = 2, + DEBUGGING = 3 +} VERBOSITY_t; + +typedef enum { + BOTH = 0, + ILP = 1, + CD = 2 +} SOLVE_t; + +typedef enum { + FULL = 0, + CARCH = 1, + UARCH = 2 +} MODE_t; + +typedef std::vector IntArray; +typedef std::vector IntMatrix; +typedef std::vector Int3Matrix; +typedef std::vector Int4Matrix; + +typedef std::vector DoubleArray; +typedef std::vector DoubleMatrix; +typedef std::vector Double3Matrix; +typedef std::vector Double4Matrix; + +typedef std::pair Bin; +typedef std::set StringSet; +typedef std::map StringMap; +typedef std::vector > BinMap; +typedef std::vector > > > DoubleBBRecord; +typedef std::vector > > > IntBBRecord; +typedef std::vector > ClusterBBRecord; + +typedef std::set IntSet; +typedef std::pair IntSetPair; + +typedef std::pair CNState; +typedef std::map CNAssignCluster; +typedef std::map CNMap; + +int countElements(const IntMatrix arg); +int countElements(const Int3Matrix arg); +int countElements(const Int4Matrix arg); + +int countElements(const DoubleMatrix arg); +int countElements(const Double3Matrix arg); +int countElements(const Double4Matrix arg); + +int sum_of_elements(const IntArray arg); + +std::string timestamp(); + +void log(const std::string& msg, const VERBOSITY_t lb, const VERBOSITY_t curr); +void warning(const std::string& msg); + +bool getBit(const int num, const int pos); + +void split(const std::string &s, const char d, std::vector &out); +std::vector split(const std::string &s, const char d); + +std::string rtrim(const std::string &s); +std::string ltrim(const std::string &s); +std::string trim(const std::string &s); + +IntArray sort_indexes(const IntArray &v); +DoubleMatrix transpose(const DoubleMatrix &M); + +std::string toString(const IntArray &M); +std::string toString(const DoubleArray &M); +std::string toString(const IntMatrix &M); +std::string toString(const DoubleMatrix &M); + +int maxCeil(const DoubleMatrix &M); + +std::string base_name(std::string const& path); +std::string remove_extension(std::string const& filename); + +#endif // _UTILS_H_ +","Unknown" +"Allele","raphael-group/hatchet","src/worker.h",".h","2193","107","#ifndef _WORKER_H_ +#define _WORKER_H_ + + +#include ""utils.h"" +#include ""ilp-min.h"" +#include ""input_instance.h"" + +class Worker +{ +public: + Worker(const DoubleMatrix& FA, + const DoubleMatrix& FB, + const DoubleArray& bins, + const int m, + const int k, + const int n, + const int cmax, + const int d, + const double mu, + const int base, + const bool ampdel, + const CNMap& cn, + const int iterConvergence, + const int maxIter, + const int timeLimit, + const int memoryLimit, + const int nrThreads, + const DoubleMatrix& M0, + const int seedIndex, + const VERBOSITY_t v); + + /// Solve for given seed M0 + double solve(); + + const IntMatrix getCA() const + { + return _allCA.back(); + } + + const IntMatrix getCB() const + { + return _allCB.back(); + } + + const DoubleMatrix getU() const + { + return _allU.back(); + } + +private: + /// + const DoubleMatrix& _FA; + /// + const DoubleMatrix& _FB; + /// + const DoubleArray& _bins; + /// + const int _m; + /// + const int _k; + /// Number of clones + const int _n; + /// + const int _cmax; + /// + const int _d; + /// + const double _mu; + /// + const int _base; + /// + const bool _ampdel; + /// + const CNMap& _cn; + /// Number of iterations for checking convergence + const unsigned int _iterConvergence; + /// Maximum number of iterations for each seed + const unsigned int _maxIter; + /// Time limit (seconds) + const int _timeLimit; + /// Memory limit (MB) + const int _memoryLimit; + /// Number of threads + const int _nrThreads; + /// Initial M0 + const DoubleMatrix& _M0; + /// All C matrices + Int3Matrix _allCA; + /// All C matrices + Int3Matrix _allCB; + /// All M matrices + Double3Matrix _allU; + /// All objective values for the C-steps + DoubleArray _allObjC; + /// All objective values for the M-steps + DoubleArray _allObjU; + /// Seed index + const int _seedIndex; + /// + const VERBOSITY_t _v; + +}; + + +#endif //_WORKER_H_ +","Unknown" +"Allele","raphael-group/hatchet","src/coordinate_descent.cpp",".cpp","5910","196","#include ""coordinate_descent.h"" + +CoordinateDescent::CoordinateDescent(const DoubleMatrix& FA, + const DoubleMatrix& FB, + const DoubleArray& bins, + const int m, + const int k, + const int n, + const int cmax, + const int d, + const double mu, + const int base, + const bool ampdel, + const CNMap& cn, + const unsigned int iterConvergence, + const unsigned int maxIter, + const int nrSeeds, + const int nrWorkers, + const int nrILPthreads, + const int timeLimit, + const int memoryLimit, + const VERBOSITY_t v) + : _FA(FA) + , _FB(FB) + , _bins(bins) + , _m(m) + , _k(k) + , _n(n) + , _cmax(cmax) + , _d(d) + , _mu(mu) + , _base(base) + , _ampdel(ampdel) + , _cn(cn) + , _iterConvergence(iterConvergence) + , _maxIter(maxIter) + , _nrSeeds(nrSeeds) + , _nrWorkers(nrWorkers) + , _nrILPthreads(nrILPthreads) + , _timeLimit(timeLimit) + , _memoryLimit(memoryLimit) + , _sizeBubbles(-1) + , _seeds() + , _seedidx(0) + , _threads() + , _mutexTasks() + , _mutexResults() + , _objs() + , _CAs() + , _CBs() + , _Us() + , _best(-1) + , _v(v) +{ + if(mu <= 0.1) { + _sizeBubbles = 10; + } else if(mu <= 0.15) { + _sizeBubbles = 6; + } else if(mu <= 0.2) { + _sizeBubbles = 5; + } else { + _sizeBubbles = 3; + } +} + + +void CoordinateDescent::run() +{ + for (int i = 0; i < _nrSeeds; ++i) + { + _seeds.push_back(buildRandomU()); + } + + log(""Detailed data about coordinate descence is going to be written in: coordinate_descence.tsv"", VERBOSITY_t::DEBUGGING, _v); + if(_v >= VERBOSITY_t::VERBOSE) + { + std::ofstream coordinate_out(""coordinate_descence.tsv"", std::ofstream::out); + coordinate_out << """"; + } + log(""Coordinate Descence {"", VERBOSITY_t::VERBOSE, _v); + for(int i = 0; i < _nrWorkers; ++i) + { + _threads.emplace_back(&CoordinateDescent::runWorker, this); + } + + for(auto& thread : _threads) + { + thread.join(); + } + + log(""}"", VERBOSITY_t::VERBOSE, _v); + _best = std::distance(_objs.begin(), std::min_element(_objs.begin(), _objs.end())); +} + + +DoubleMatrix CoordinateDescent::buildRandomU() +{ + DoubleMatrix U; + for(unsigned int p = 0; p < _k; ++p) + { + std::uniform_int_distribution<> uni(1, _n); + int non_zeros = std::max(uni(g_rng), uni(g_rng)); + non_zeros = std::min(non_zeros, _sizeBubbles); + U.push_back(buildPartitionVector(non_zeros)); + } + DoubleMatrix T(transpose(U)); + log(""SEED "" + std::to_string(_seeds.size()) + "":\n"" + toString(T), VERBOSITY_t::DEBUGGING, _v); + return T; +} + + +DoubleArray CoordinateDescent::buildPartitionVector(const int num_parts) +{ + assert(num_parts <= _sizeBubbles); + IntArray positions(_n); + std::iota(positions.begin(), positions.end(), 0); + std::shuffle(positions.begin(), positions.end(), g_rng); + + DoubleArray result(_n, 0.0); + if(num_parts > 1) + { + IntArray samples(_sizeBubbles - 1); + std::iota(samples.begin(), samples.end(), 1); + assert(samples.front() == 1 && samples.back() == _sizeBubbles - 1); + std::shuffle(samples.begin(), samples.end(), g_rng); + + DoubleArray bubbles(num_parts - 1, 0.0); + for(unsigned int i = 0; i < num_parts - 1; ++i) + { + bubbles[i] = (double)samples.back() / (double)_sizeBubbles; + samples.pop_back(); + } + std::sort(bubbles.begin(), bubbles.end()); + + for(unsigned int i = 0; i < num_parts; ++i) + { + if(i == 0) + { + result[positions[i]] = bubbles[i]; + } + else if(i == (num_parts-1)) + { + result[positions[i]] = 1.0 - bubbles.back(); + } + else + { + result[positions[i]] = bubbles[i] - bubbles[i-1]; + } + if(_mu - TOL <= result[positions[i]] && result[positions[i]] < _mu) + { + result[positions[i]] = _mu; + } + assert(result[positions[i]] >= _mu); + } + } + else { + result[positions[0]] = 1.0; + } + return result; +} + + +void CoordinateDescent::runWorker() +{ + while(true) + { + int seed = -1; + { + std::lock_guard lock(_mutexTasks); + seed = _seedidx < _seeds.size() ? _seedidx++ : -1; + } + std::this_thread::sleep_for(std::chrono::seconds(2)); + if(seed > -1) { + Worker worker(_FA, _FB, _bins, _m, _k, _n, _cmax, _d, _mu, _base, _ampdel, _cn, _iterConvergence, _maxIter, + _timeLimit, _memoryLimit, _nrILPthreads, _seeds[seed], seed, _v); + double obj = worker.solve(); + + { + std::lock_guard lock(_mutexResults); + _objs.push_back(obj); + _CAs.push_back(worker.getCA()); + _CBs.push_back(worker.getCB()); + _Us.push_back(worker.getU()); + } + + { + std::lock_guard lock(g_output_mutex); + std::locale::global(std::locale(""C"")); + log(std::to_string(obj) + ""; "", VERBOSITY_t::VERBOSE, _v); + } + } else { + break; + } + } +} +","C++" +"Allele","raphael-group/hatchet","src/worker.cpp",".cpp","3898","125","#include ""worker.h"" + + +Worker::Worker(const DoubleMatrix& FA, + const DoubleMatrix& FB, + const DoubleArray& bins, + const int m, + const int k, + const int n, + const int cmax, + const int d, + const double mu, + const int base, + const bool ampdel, + const CNMap& cn, + const int iterConvergence, + const int maxIter, + const int timeLimit, + const int memoryLimit, + const int nrThreads, + const DoubleMatrix& M0, + const int seedIndex, + const VERBOSITY_t v) + : _FA(FA) + , _FB(FB) + , _bins(bins) + , _m(m) + , _k(k) + , _n(n) + , _cmax(cmax) + , _d(d) + , _mu(mu) + , _base(base) + , _ampdel(ampdel) + , _cn(cn) + , _iterConvergence(iterConvergence) + , _maxIter(maxIter) + , _timeLimit(timeLimit) + , _memoryLimit(memoryLimit) + , _nrThreads(nrThreads) + , _M0(M0) + , _allCA() + , _allCB() + , _allU() + , _allObjC() + , _allObjU() + , _seedIndex(seedIndex) + , _v(v) +{ + std::locale::global(std::locale(""C"")); +} + + +double Worker::solve() +{ + unsigned int iter_convergence = 0; + unsigned int iter = 0; + bool first = true; + + std::pair hotstart; + hotstart = IlpSubset::firstHotStart(_FA, _FB, _m, _k, _n, _cmax, _d, _base, _ampdel, _cn); + + while((iter_convergence < _iterConvergence) && (iter < _maxIter)) + { + g_mutex.lock(); + IlpSubset carch(_n, _m, _k, _cmax, _d, _mu, _base, _ampdel, _cn, _FA, _FB, _bins, _v); + g_mutex.unlock(); + + carch.fixU(_allU.empty() ? _M0 : _allU.back()); + carch.init(); + carch.hotStart(hotstart.first, hotstart.second); + bool status = carch.solve(_timeLimit, _memoryLimit, _nrThreads); + assert(status); + + _allObjC.push_back(carch.getObjs()[0]); + _allCA.push_back(carch.getACNs()[0]); + _allCB.push_back(carch.getBCNs()[0]); + hotstart = std::make_pair(_allCA.back(), _allCB.back()); + //assert(first || _allObjC.back() - TOL <= carch.getObjs()[0]); + + if(_v >= VERBOSITY_t::VERBOSE) + { + std::lock_guard lock(g_output_mutex); + std::ofstream coordinate_out(""coordinate_descence.tsv"", std::ofstream::out | std::ofstream::app); + char buf[1024]; + snprintf(buf, 2014, ""%d\t%d\t%s\t%f\t%f\t%f"", _seedIndex, iter, ""C"", _allObjC.back(), carch.gap(), carch.runtime()); + coordinate_out << buf << std::endl; + } + + g_mutex.lock(); + IlpSubset uarch(_n, _m, _k, _cmax, _d, _mu, _base, _ampdel, _cn, _FA, _FB, _bins, _v); + g_mutex.unlock(); + + uarch.fixC(_allCA.back(), _allCB.back()); + uarch.init(); + status = uarch.solve(_timeLimit, _memoryLimit, _nrThreads); + assert(status); + + _allObjU.push_back(uarch.getObjs()[0]); + _allU.push_back(uarch.getUs()[0]); + //assert(first || _allObjU.back() - TOL <= carch.getObjs()[0]); + + if(_allObjC.back() - TOL <= _allObjU.back() && _allObjU.back() <= _allObjC.back() + TOL) + { + ++iter_convergence; + } else { + iter_convergence = 0; + } + + if(_v >= VERBOSITY_t::VERBOSE) + { + std::lock_guard lock(g_output_mutex); + std::ofstream coordinate_out(""coordinate_descence.tsv"", std::ofstream::out | std::ofstream::app); + char buf[1024]; + snprintf(buf, 2014, ""%d\t%d\t%s\t%f\t%f\t%f"", _seedIndex, iter, ""U"", _allObjU.back(), 0.0, uarch.runtime()); + coordinate_out << buf << std::endl; + } + + first = false; + ++iter; + } + assert(iter_convergence >= _iterConvergence | iter == _maxIter); + return _allObjU.back(); +} +","C++" +"Allele","raphael-group/hatchet","src/argparse.cpp",".cpp","18645","526","#include ""argparse.h"" + + +ArgParse::ArgParse(int argc, char** argv) + : _argc(argc) + , _argv(argv) + , _input() + , _inputSEG() + , _inputBBC() + , _cn() + , _scalingcn() + , _h(false) + , _n() + , _d(-1) + , _e(-1) + , _j(std::max((int)std::thread::hardware_concurrency(), 1)) + , _p(400) + , _u(0.01) + , _m(-1) + , _s(-1) + , _i(10) + , _r(-1) + , _M(SOLVE_t::BOTH) + , _v(VERBOSITY_t::ESSENTIAL) + , _o() + , _t(0.1) + , _base(1) + , _f(false) + , _args() + , _required() + , _optional() +{ + _args.insert(""-h""); + _args.insert(""-n""); + _args.insert(""-d""); + _args.insert(""-e""); + _args.insert(""-j""); + _args.insert(""-p""); + _args.insert(""-u""); + _args.insert(""-m""); + _args.insert(""-s""); + _args.insert(""-r""); + _args.insert(""-i""); + _args.insert(""-c""); + _args.insert(""-M""); + _args.insert(""-v""); + _args.insert(""-o""); + _args.insert(""-t""); + _args.insert(""-f""); + + _required.insert(std::make_pair(""input"", false)); + _required.insert(std::make_pair(""-n"", false)); + + _optional[""-h""] = false; + _optional[""-d""] = false; + _optional[""-e""] = false; + _optional[""-j""] = false; + _optional[""-p""] = false; + _optional[""-u""] = false; + _optional[""-m""] = false; + _optional[""-s""] = false; + _optional[""-r""] = false; + _optional[""-i""] = false; + _optional[""-c""] = false; + _optional[""-M""] = false; + _optional[""-v""] = false; + _optional[""-o""] = false; + _optional[""-t""] = false; + _optional[""-f""] = false; + + parse(); + + if(!_optional.at(""-o"")) + { + _o = base_name(_input); + } + + if(2 * _base > _e && _e != -1) + { + throw ""Maximum copy number cannot be lower than "" + std::to_string(2 * _base) + ""!""; + } +} + + +std::string ArgParse::help() +{ + std::stringstream res; + res << ""\033[96m"" << ""\033[1m"" << ""USAGE:"" << ""\033[0m"" << ""\033[96m"" << std::endl; + res << ""\t./solve input -n INT [-e INT] [-j INT] [-m INT] [-s INT] [-c COPYNUMBERS] [-v] [-h]"" << std::endl; + res << ""\033[96m"" << ""\033[1m"" << ""WHERE:"" << ""\033[0m"" << ""\033[96m"" << std::endl; + res << ""\tinput PREFIX-INPUT\n\t\tCommon prefix for the input files .seg and .bbc (required)"" << std::endl; + res << ""\t-n INT-NUMCLONES\n\t\tNumber of tumor clones to infer (required)"" << std::endl; + res << ""\t-c COPYNUBERS 'ID-CLUSTER:INT-COPYNUMBER [, ID-CLUSTER:INT-COPYNUMBER]'\n\t\tClonal copy numbers for one or two clusters in the input. When the copy number for only one cluster is provided, its copy number must be equal to 2 as it corresponds to the diploid cluster.\n\t\tThe format of copy numbers is 'ID-CLUSTER:INT-COPYNUMBER [, ID-CLUSTER:INT-COPYNUMBER]' (default: diploid cluster automatically infferred)"" << std::endl; + res << ""\t-d INT-MAXCNSTATES\n\t\tMaximum number of copy number states (default: 3)"" << std::endl; + res << ""\t-e INT-MAXCOPYNUMBER\n\t\tMaximum integer copy number (default: inferred from fractions)"" << std::endl; + res << ""\t-j INT-JOBS\n\t\tNumber of parallel jobs (default: maximum number of available processors)"" << std::endl; + res << ""\t-p SEEDS\n\t\tNumber of seeds for coordinate descent (default: 400)"" << std::endl; + res << ""\t-u MIN-PROP\n\t\tMinimum clone proporion in each sample (default: 0.01)"" << std::endl; + res << ""\t-m INT-MAXMEMORY\n\t\tMaximum resident memory used by Gurobi expressed in Mbytes (default: automatically inferred from the maximum of the machine)"" << std::endl; + res << ""\t-s INT-TIMELIMIT\n\t\tTime limit in seconds for the ilp solving of Gurobi, after the time limit the best found solution is returned (default: no timelimit)"" << std::endl; + res << ""\t-i INT-ITERATIONS\n\t\tMaximum number of iterations composed of C-step/U-step for each seed (default: 10)"" << std::endl; + res << ""\t-r INT-RANDOMSEED\n\t\tRandom seed for generator (default: none)"" << std::endl; + res << ""\t-M INT-SOLVINGMODE\n\t\tSolving mode among: Coordinate Descent + exact ILP (0), exact ILP only (1), and Coordinate-descent only (2) (default: 0)"" << std::endl; + res << ""\t-v VERBOSITY\n\t\tLevel of verbosity among: none (0), essential (1), verbose (2), and debug (3) (default: 1)"" << std::endl; + res << ""\t-o PREFIX-OUTPUT\n\t\tPrefix of the output files that will be generated (default: current directory with the basename of the input prefix)""<< std::endl; + res << ""\t-t DIPLOID\n\t\tMaximum BAF shift for diploid cluster used to automatically infer the diploid cluster (default: 0.1)"" << std::endl; + res << ""\t-f FORCE-AMPDEL\n\t\tForce every mutated segment (not 2 in diploid tumors and not 4 in tetraploid tumors) to be either amplified or deleted in all the clones (default: not applied)"" << ""\033[0m"" << std::endl; + return res.str(); +} + + +std::string ArgParse::toString() +{ + std::stringstream res; + res << ""\tInput prefix: "" << _input << std::endl; + res << ""\tInput SEG: "" << _inputSEG << std::endl; + res << ""\tInput BBC: "" << _inputBBC << std::endl; + res << ""\tNumber of clones: "" << _n << std::endl; + res << ""\tClonal copy numbers: ""; + for(auto const& state : _cn) + { + res << ""{ "" << state.first << "" [Cluster] : "" << state.second.first << ""|"" << state.second.second << "" [CN] } ""; + } + res << std::endl; + res << ""\tHelp message: "" << _h << std::endl; + res << ""\tMaximum number of copy-number states: "" << _d << std::endl; + res << ""\tMaximum integer copy number: "" << _e << std::endl; + res << ""\tNumber of jobs: "" << _j << std::endl; + res << ""\tNumber of seeds: "" << _p << std::endl; + res << ""\tMinimum tumor-clone threshold: "" << _u << std::endl; + res << ""\tMaximum resident memory: "" << _m << std::endl; + res << ""\tTime limit: "" << _s << std::endl; + res << ""\tMaximum number of iteratios: "" << _i << std::endl; + res << ""\tRandom seed: "" << _r << std::endl; + res << ""\tSolving mode: "" << (_M == SOLVE_t::BOTH ? ""Coordinate-descent + exact ILP"" : _M == SOLVE_t::ILP ? ""exact ILP only"" : ""Coordinate-descent only"") << std::endl; + res << ""\tVerbose: "" << _v << std::endl; + res << ""\tOutput prefix: "" << _o << std::endl; + res << ""\tDiploid threshold: "" << _t << std::endl; + res << ""\tBase: "" << _base << std::endl; + res << ""\tForce amp-del: "" << _f; + return res.str(); +} + + +void ArgParse::setClonalCluster(const CNAssignCluster& inferred) +{ + _cn.clear(); + _scalingcn.clear(); + for(auto const& pair : inferred) + { + _cn.emplace(pair.first, pair.second); + _scalingcn.emplace(pair.first, pair.second); + } +} + + +void ArgParse::parse() +{ + for(int idx = 1; idx < _argc; ++idx) + { + std::string arg = std::string(_argv[idx]); + if(_args.find(arg) != _args.end()) + { + if (arg == ""-h"") { + parseOptional(arg, """"); + }else if (arg == ""-f"") { + parseOptional(arg, """"); + } else if (++idx < _argc) { + parseOptional(arg, std::string(_argv[idx])); + } else { + throw ""Missing argument values!""; + } + } else { + if((*_required.find(""input"")).second) + { + throw ""Multiple default arguments found! Please specify only one default argument as input file!""; + } else { + _input = arg; + (*_required.find(""input"")).second = true; + + std::string seg = arg + "".seg""; + std::ifstream inputSEG(seg.c_str()); + if(!inputSEG.good()) + { + throw ""The specified input file \"""" + seg + ""\"" does not exists or cannot be opened!""; + } else { + _inputSEG = seg; + } + inputSEG.close(); + + std::string bbc = arg + "".bbc""; + std::ifstream inputBBC(bbc.c_str()); + if(!inputBBC.good()) + { + throw ""The specified input file \"""" + bbc + ""\"" does not exists or cannot be opened!""; + } else { + _inputBBC = bbc; + } + inputBBC.close(); + } + } + } + + if(_h) + { + std::cout << help(); + std::exit(EXIT_SUCCESS); + } else { + for(std::map::const_iterator it = _required.begin(); + it != _required.end(); + ++it) + { + if(!(*it).second) + { + throw ""The required input argument \"""" + (*it).first + ""\"" is missing!""; + } + } + } +} + + +void ArgParse::parseOptional(const std::string &arg, const std::string &value) +{ + if(arg == ""-h"") + { + _h = true; + if((*_optional.find(""-h"")).second) + { + throw ""Multiple -h argument found!""; + } else { + (*_optional.find(""-h"")).second = true; + } + } else if (arg == ""-n"") { + if((*_required.find(""-n"")).second) + { + throw ""Multiple -n arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The number of clone argument -n must be a positive integer!""; + } else { + (*_required.find(""-n"")).second = true; + _n = std::atoi(value.c_str()); + } + } + } else if (arg == ""-d"") { + if((*_optional.find(""-d"")).second) + { + throw ""Multiple -d arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The maximum-cn-states argument -d must be a positive integer!""; + } else { + (*_optional.find(""-d"")).second = true; + _d = std::atoi(value.c_str()); + } + } + } else if (arg == ""-e"") { + if((*_optional.find(""-e"")).second) + { + throw ""Multiple -e arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The maximum-copy-number argument -e must be a positive integer!""; + } else { + (*_optional.find(""-e"")).second = true; + _e = std::atoi(value.c_str()); + } + } + } else if (arg == ""-j"") { + if((*_optional.find(""-j"")).second) + { + throw ""Multiple -j arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The number of thread argument -j must be a positive integer!""; + } else { + (*_optional.find(""-j"")).second = true; + _j = std::atoi(value.c_str()); + } + } + } else if (arg == ""-p"") { + if((*_optional.find(""-p"")).second) + { + throw ""Multiple -p arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The seed argument -p must be a positive integer!""; + } else { + (*_optional.find(""-p"")).second = true; + _p = std::atoi(value.c_str()); + } + } + } else if (arg == ""-u"") { + if((*_optional.find(""-u"")).second) + { + throw ""Multiple -u arguments found!""; + } else { + double cast = std::stod(value); + if(cast < 0.0 || cast > 0.3) + { + throw ""The minimum tumor-clone proportion argument -u must be in [0, 0.3]!""; + } else { + (*_optional.find(""-u"")).second = true; + _u = cast; + } + } + } else if (arg == ""-m"") { + if((*_optional.find(""-m"")).second) + { + throw ""Multiple -m arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The number of thread argument -m must be a positive integer!""; + } else { + (*_optional.find(""-m"")).second = true; + _m = std::atoi(value.c_str()); + } + } + } else if (arg == ""-s"") { + if((*_optional.find(""-s"")).second) + { + throw ""Multiple -s arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The number of thread argument -s must be a positive integer!""; + } else { + (*_optional.find(""-s"")).second = true; + _s = std::atoi(value.c_str()); + } + } + } else if (arg == ""-r"") { + if((*_optional.find(""-r"")).second) + { + throw ""Multiple -r arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The random-seed argument -r must be a positive integer!""; + } else { + (*_optional.find(""-r"")).second = true; + _r = std::atoi(value.c_str()); + } + } + } else if (arg == ""-i"") { + if((*_optional.find(""-i"")).second) + { + throw ""Multiple -i arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The number of max-iteration argument -i must be a positive integer!""; + } else { + (*_optional.find(""-i"")).second = true; + _i = std::atoi(value.c_str()); + } + } + } else if (arg == ""-f"") { + if((*_optional.find(""-f"")).second) + { + throw ""Multiple -f arguments found!""; + } else { + (*_optional.find(""-f"")).second = true; + _f = true; + } + } else if (arg == ""-M"") { + if((*_optional.find(""-M"")).second) + { + throw ""Multiple -M arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The solving-mode argument -M must be a positive integer!""; + } else { + (*_optional.find(""-M"")).second = true; + int M = std::atoi(value.c_str()); + switch (M) { + case 0: _M = SOLVE_t::BOTH; + break; + case 1: _M = SOLVE_t::ILP; + break; + case 2: _M = SOLVE_t::CD; + break; + default: + throw ""The solving mode must be a value among {0, 1, 2}""; + break; + } + } + } + } else if (arg == ""-v"") { + if((*_optional.find(""-v"")).second) + { + throw ""Multiple -v arguments found!""; + } else { + if(!checkInt(value)) + { + throw ""The verbosity argument -v must be a positive integer!""; + } else { + (*_optional.find(""-v"")).second = true; + int v = std::atoi(value.c_str()); + switch (v) { + case 0: _v = VERBOSITY_t::NONE; + break; + case 1: _v = VERBOSITY_t::ESSENTIAL; + break; + case 2: _v = VERBOSITY_t::VERBOSE; + break; + case 3: _v = VERBOSITY_t::DEBUGGING; + break; + default: + throw ""The verbosity level must be a value among {0, 1, 2, 3}""; + break; + } + } + } + } else if (arg == ""-c"") { + if((*_optional.find(""-c"")).second) + { + throw ""Multiple -c arguments found!""; + } else { + _optional.find(""-c"")->second = true; + parseClonalCopyNumbers(value); + } + } else if (arg == ""-o"") { + if((*_optional.find(""-o"")).second) + { + throw ""Multiple -o arguments found!""; + } else { + _optional.find(""-o"")->second = true; + _o = value; + } + } else { + throw ""Unknown flag found!""; + } +} + + +void ArgParse::parseClonalCopyNumbers(const std::string &value) +{ + std::vector tokens = split(trim(value), ','); + if (tokens.size() == 1) + { + _base = 1; + + std::vector parsed = split(tokens[0], ':'); + if(parsed.size() != 3 || !checkInt(parsed[1]) || !checkInt(parsed[2])) + { + throw ""The specified clonal copy number \"""" + value + ""\"" has wrong format!""; + } else { + int A = std::stoi(parsed[1]); + int B = std::stoi(parsed[2]); + + if (A + B != 2) { + throw ""When only one clonal copy number is given, it must be for a diploid cluster with copy number equal to 2 in the format \""ID:1:1\"" or \""ID:2:0\""!""; + } else { + assert(_cn.count(parsed[0]) == 0); + _cn.emplace(parsed[0], CNState(A, B)); + _scalingcn.emplace(parsed[0], CNState(A, B)); + } + } + } else if (tokens.size() >= 2) { + _base = 2; + + for(auto const& token : tokens) + { + std::vector parsed = split(token, ':'); + if(parsed.size() != 3 || !checkInt(parsed[1]) || !checkInt(parsed[2])) + { + throw ""The specified clonal copy number \"""" + value + ""\"" has wrong format!""; + } else { + int A = std::stoi(parsed[1]); + int B = std::stoi(parsed[2]); + + if (_cn.count(parsed[0]) == 0) + { + _cn.emplace(parsed[0], CNState(A, B)); + } else { + throw ""In WGD mode, the first two clonal cluster must refer to two different clusters!""; + } + + if(_cn.size() == 1) + { + _scalingcn.emplace(parsed[0], CNState(A, B)); + } else if (_cn.size() == 2) + { + _scalingcn.emplace(parsed[0], CNState(A, B)); + } + } + } + + auto it = _scalingcn.begin(); + CNState state1 = it->second; + std::advance(it, 1); + CNState state2 = it->second; + + if((state1.first + state1.second) == (state2.first + state2.second)) + { + throw ""When two clonal copy numbers are given, they first two must be different in the two segmental clusters!""; + } + + for(auto const& ccluster : _cn) + { + if(ccluster.second.first + ccluster.second.second == 2) + { + warning(""When a clonal cluster has copy number equal to 2, you can speficy only that!""); + break; + } + } + + } else { + throw ""Please specify only two clonal copy numbers for two clusters!""; + } +} + + +bool ArgParse::checkInt(const std::string &s) +{ + return s.find_first_not_of( ""0123456789"" ) == std::string::npos; +} +","C++" +"Allele","raphael-group/hatchet","src/bbc_instance.cpp",".cpp","5392","136"," +#include ""bbc_instance.h"" + + +BBCInstance::BBCInstance() + : _m() + , _k() + , _chromosomes() + , _clusters() + , _bins() + , _samples() + , _mapSampleToIdx() + , _binsToSampleRdBaf() + , _binsToSampleSCAB() + , _binsToCluster() +{ +} + + +std::ostream& operator<<(std::ostream& out, const BBCInstance& instance) +{ + out << ""#CHR\tSTART\tEND\tSAMPLE\tRD\t#SNPS\tCOV\tALPHA\tBETA\tBAF\tCLUSTER"" << std::endl; + for(auto const& chr : instance._chromosomes) + { + size_t idx_chr = chr.second; + for(auto const& bin : instance._bins[idx_chr]) + { + size_t idx_bin = bin.second; + for(auto const& sample : instance._binsToSampleRdBaf[idx_chr][idx_bin]) + { + auto const& scab = instance._binsToSampleSCAB[idx_chr][idx_bin].at(sample.first); + out << chr.first << '\t' << bin.first.first << '\t' << bin.first.second << '\t' << sample.first << '\t' << sample.second.first << '\t' << std::get<0>(scab) << '\t' << std::get<1>(scab) << '\t' << std::get<2>(scab) << '\t' << std::get<3>(scab) << '\t' << instance._binsToCluster[idx_chr][idx_bin] << std::endl; + } + } + } + return out; +}; + + +std::istream& operator>>(std::istream& in, BBCInstance& instance) +{ + instance._chromosomes.clear(); + instance._clusters.clear(); + instance._samples.clear(); + instance._bins.clear(); + instance._binsToSampleRdBaf.clear(); + instance._binsToSampleSCAB.clear(); + instance._binsToCluster.clear(); + + std::string line; + std::vector tokens; + + while(!in.eof()) + { + std::getline(in, line, '\n'); + if(!line.empty() && line[0] != '#') + { + std::replace(line.begin(), line.end(), '\t', ' '); + tokens = split(rtrim(ltrim(line)), ' '); + + std::string chr(tokens[0]); + size_t idx_chr = -1; + if(instance._chromosomes.find(chr) == instance._chromosomes.end()) + { + idx_chr = instance._chromosomes.size(); + instance._chromosomes[chr] = idx_chr; + instance._bins.emplace_back(); + instance._binsToSampleRdBaf.emplace_back(); + instance._binsToSampleSCAB.emplace_back(); + instance._binsToCluster.emplace_back(); + } else { + idx_chr = instance._chromosomes.at(chr); + } + + std::string sample(tokens[3]); + instance._samples.insert(sample); + + std::pair bin = std::make_pair(std::stoll(tokens[1]), std::stoll(tokens[2])); + size_t idx_bin = -1; + if(instance._bins[idx_chr].find(bin) == instance._bins[idx_chr].end()) + { + idx_bin = instance._bins[idx_chr].size(); + instance._bins[idx_chr][bin] = idx_bin; + + assert(instance._binsToSampleRdBaf[idx_chr].size() == idx_bin); + instance._binsToSampleRdBaf[idx_chr].emplace_back(); + instance._binsToSampleRdBaf[idx_chr][idx_bin][sample] = std::make_pair(std::stod(tokens[4]), std::stod(tokens[9])); + + assert(instance._binsToSampleSCAB[idx_chr].size() == idx_bin); + instance._binsToSampleSCAB[idx_chr].emplace_back(); + instance._binsToSampleSCAB[idx_chr][idx_bin][sample] = std::make_tuple(std::stoi(tokens[5]), std::stoi(tokens[6]), std::stoi(tokens[7]), std::stoi(tokens[8])); + + assert(instance._binsToCluster[idx_chr].size() == idx_bin); + instance._binsToCluster[idx_chr].emplace_back(tokens[10]); + } else { + idx_bin = instance._bins[idx_chr].at(bin); + + if(instance._binsToSampleRdBaf[idx_chr][idx_bin].find(sample) != instance._binsToSampleRdBaf[idx_chr][idx_bin].end()) + { + throw std::string(""Found a bin defined multiple times for the same sample!\n\t"" + line); + } else { + instance._binsToSampleRdBaf[idx_chr][idx_bin][sample] = std::make_pair(std::stod(tokens[4]), std::stod(tokens[9])); + } + + assert(instance._binsToSampleSCAB[idx_chr][idx_bin].find(sample) == instance._binsToSampleSCAB[idx_chr][idx_bin].end()); + instance._binsToSampleSCAB[idx_chr][idx_bin][sample] = std::make_tuple(std::stoi(tokens[5]), std::stoi(tokens[6]), std::stoi(tokens[7]), std::stoi(tokens[8])); + + if(instance._binsToCluster[idx_chr].at(idx_bin) != tokens[10]) + { + throw std::string(""Found a bin with different clusters in different samples!\n\t"" + line); + } + } + } + } + + for(auto const& chr : instance._chromosomes) + { + size_t idx_chr = chr.second; + for(auto const& bin : instance._bins[idx_chr]) + { + size_t idx_bin = bin.second; + StringSet samples; + for(auto const& sample : instance._binsToSampleRdBaf[idx_chr][idx_bin]) + { + samples.insert(sample.first); + } + if(samples != instance._samples) + { + throw std::string(""Found a bin not defined for every sample:\tChromosome= "" + chr.first + "" interval= ("" + std::to_string(bin.first.first) + "", "" + std::to_string(bin.first.second) + "")""); + } + } + } + + return in; +}; +","C++" +"Allele","raphael-group/hatchet","src/argparse.h",".h","2913","192","#ifndef _ARGPARSE_H_ +#define _ARGPARSE_H_ + +#include ""utils.h"" + + +class ArgParse +{ +public: + + ArgParse(int argc, char** argv); + + std::string help(); + std::string toString(); + + void setClonalCluster(const CNAssignCluster& inferred); + + std::string input() const + { + return _input; + } + + std::string inputSEG() const + { + return _inputSEG; + } + + std::string inputBBC() const + { + return _inputBBC; + } + + int n() const + { + return _n; + } + + int d() const + { + return _d; + } + + int cmax() const + { + return _e; + } + + int j() const + { + return _j; + } + + int nrSeeds() const + { + return _p; + } + + double minprop() const + { + return _u; + } + + int m() const + { + return _m; + } + + int s() const + { + return _s; + } + + int maxiter() const + { + return _i; + } + + int rnd() const + { + return _r; + } + + CNAssignCluster cn() const + { + return _cn; + } + + CNAssignCluster scalingCN() const + { + return _scalingcn; + } + + SOLVE_t M() const + { + return _M; + } + + VERBOSITY_t v() const + { + return _v; + } + + const std::string o() const + { + return _o; + } + + double diploidThreshold() const + { + return _t; + } + + int base() const + { + return _base; + } + + double forceAMPDEL() const + { + return _f; + } + +private: + + /// Number of arguments + int _argc; + /// Arguments + char** _argv; + + /// Input .seg file + std::string _input; + /// Input .seg file + std::string _inputSEG; + /// Input .seg file + std::string _inputBBC; + /// Clonal segments + CNAssignCluster _cn; + // + CNAssignCluster _scalingcn; + /// Help option + bool _h; + /// Number of distinct clones + int _n; + /// Maximum number of distinct copy-number states + int _d; + /// Maximum copy number + int _e; + /// Number of parallel threads for Gurobi + int _j; + /// Number of seeds + int _p; + /// + double _u; + /// Maximum resident memory + int _m; + /// Time limit + int _s; + /// + int _i; + /// + int _r; + /// + SOLVE_t _M; + /// Verbosity of the logging + VERBOSITY_t _v; + /// + std::string _o; + /// + double _t; + /// + int _base; + /// + bool _f; + + /// Set of total arguments + std::set _args; + /// Map of boolean to record the presence of required arguments + std::map _required; + /// Map of boolean to record the present of optional arguments + std::map _optional; + + void parse(); + void parseOptional(const std::string &arg, const std::string &value); + void parseClonalCopyNumbers(const std::string &value); + bool checkInt(const std::string &s); +}; + + + + +#endif // _UTILS_GUROBI_H_ +","Unknown" +"Allele","raphael-group/hatchet","src/ilp-min.cpp",".cpp","33026","1182","#include ""ilp-min.h"" + +IlpSubset::IlpSubset(const int n, + const int m, + const int k, + const int cmax, + const int d, + const double mu, + const int base, + const bool ampdel, + const CNMap& cn, + const DoubleMatrix& FA, + const DoubleMatrix& FB, + const DoubleArray& w, + const VERBOSITY_t v) + : _n(n) + , _m(m) + , _k(k) + , _cmax(cmax) + , _d(d) + , _mu(mu) + , _base(base) + , _ampdel(ampdel) + , _cn(cn) + , _FA(FA) + , _FB(FB) + , _w(w) + , _v(v) + , _barCA() + , _barCB() + , _barU() + , _mode(MODE_t::FULL) + , _M(floor(log2(cmax)) + 1) + , _env() + , _model(_env) + , _yA() + , _yB() + , _fA() + , _fB() + , _cA() + , _cB() + , _bitcA() + , _bitcB() + , _u() + , _x() + , _adA() + , _adB() + , _vA() + , _vB() + , _barcIJA() + , _barcIJB() + , _objs() + , _CAs() + , _CBs() + , _Us() +{ +} + + +void IlpSubset::fixC(const IntMatrix& barCA, const IntMatrix& barCB) +{ + _barCA = barCA; + _barCB = barCB; + _mode = MODE_t::UARCH; + for(int s = 0; s < _m; ++s) + { + int upper = 0; + if(_cn.count(s) > 0) + { + upper = _cn.at(s).first + _cn.at(s).second; + } else { + upper = _cmax; + } + + int adA = 0; + int adB = 0; + for(int i = 0; i < _n; ++i) + { + if(i > 0) + { + assert(barCA[s][i] + barCB[s][i] <= upper); + assert(barCA[s][i] >= 0 && barCB[s][i] >= 0); + if(_ampdel) + { + adA = adA == 0 && barCA[s][i] > _base ? 1 : adA; + adA = adA == 0 && barCA[s][i] < _base ? -1 : adA; + adB = adB == 0 && barCB[s][i] > _base ? 1 : adB; + adB = adB == 0 && barCB[s][i] < _base ? -1 : adB; + + assert(adA <= 0 || barCA[s][i] >= _base); + assert(adA >= 0 || barCA[s][i] <= _base); + assert(adB <= 0 || barCB[s][i] >= _base); + assert(adB >= 0 || barCB[s][i] <= _base); + } + } else { + assert(barCA[s][i] == 1); + assert(barCB[s][i] == 1); + } + } + } +} + + +void IlpSubset::init() +{ + buildVariables(); + if(_d > 0 && (_mode == MODE_t::FULL || _mode == MODE_t::CARCH)) + { + buildOptionalVariables(); + } + + buildConstraints(); + if(_d > 0 && (_mode == MODE_t::FULL || _mode == MODE_t::CARCH)) + { + buildOptionalConstraints(); + } + if(_mode == MODE_t::FULL || _mode == MODE_t::CARCH) + { + buildSymmetryBreaking(); + fixGivenCN(); + } + + buildObjective(); + //test(); + _model.update(); +} + + +void IlpSubset::hotStart(const IntMatrix& hCA, const IntMatrix& hCB) +{ + if(_mode == MODE_t::UARCH) + { + throw ""A Hot Start cannot be provided in UARCH mode when mixing proportions U are fixed!""; + } else { + IntArray rank(_n, 0); + if(hCA.size() != _m || hCB.size() != _m) + { + throw ""The rows of both hot starts must be equal to the current number m of segments!""; + } + for(int s = 0; s < _m; ++s) + { + if(hCA[s].size() != _n || hCB[s].size() != _n) + { + throw ""The columns of both hot starts must be equal to the current number n of clones!""; + } + for(int i = 0; i < _n; ++i) + { + if(i > 0) + { + rank[i] += hCA[s][i] * symmCoeff(s) + hCB[s][i] * symmCoeff(s); + } else { + rank[0] = -1; + if(hCA[s][0] != 1 || hCB[s][0] != 1) + { + std::cout << toString(hCB) << std::endl; + throw ""The first clone must have only allele-specific copy numbers equal to 1""; + } + } + } + } + + IntArray map = sort_indexes(rank); + assert(checkRank(hCA, hCB, map)); + + for(int s = 0; s < _m; ++s) + { + for(int i = 0; i < _n; ++i) + { + _cA[s][map[i]].set(GRB_DoubleAttr_Start, hCA[s][i]); + _cB[s][map[i]].set(GRB_DoubleAttr_Start, hCB[s][i]); + } + } + } +} + + +int IlpSubset::solve(const int timeLimit, const int memoryLimit, const int nrThreads) +{ + return solve(timeLimit, memoryLimit, nrThreads, 1); +} + + +int IlpSubset::solve(const int timeLimit, const int memoryLimit, const int nrThreads, const int maxIter) +{ + int count = 0; + try + { + if (timeLimit > 0) + { + _model.getEnv().set(GRB_DoubleParam_TimeLimit, timeLimit); + } + if (memoryLimit > 0) + { + _model.getEnv().set(GRB_DoubleParam_NodeLimit, memoryLimit); + } + if (nrThreads > 0) + { + _model.getEnv().set(GRB_IntParam_Threads, nrThreads); + } + if(_mode == MODE_t::CARCH || _mode == MODE_t::UARCH || _v <= VERBOSITY_t::ESSENTIAL) + { + _model.getEnv().set(GRB_IntParam_LogToConsole, 0); + } + + bool proceed = true; + do { + _model.optimize(); + //printValues(); + int status = _model.get(GRB_IntAttr_Status); + + if (status == GRB_OPTIMAL || status == GRB_TIME_LIMIT) + { + _objs.push_back(_model.get(GRB_DoubleAttr_ObjVal)); + _CAs.push_back(getCA()); + _CBs.push_back(getCB()); + _Us.push_back(getU()); + if(_mode == MODE_t::FULL) + { + buildNext(); + } + proceed = true; + ++count; + } + else if (status == GRB_INF_OR_UNBD) + { + std::cerr << ""Model is infeasible or unbounded"" << std::endl; + _model.computeIIS(); + _model.write(""iis.ilp""); + proceed = false; + } + else if (status == GRB_INFEASIBLE) + { + std::cerr << ""Model is infeasible"" << std::endl; + _model.computeIIS(); + _model.write(""iis.ilp""); + proceed = false; + } + else if (status == GRB_UNBOUNDED) + { + std::cerr << ""Model is unbounded"" << std::endl; + _model.computeIIS(); + _model.write(""iis.ilp""); + proceed = false; + } + } while(proceed && (maxIter == 0 || count < maxIter)); + + return count; + } + catch (const GRBException& e) + { + std::cerr << ""Error code = "" << e.getErrorCode() << std::endl; + std::cerr << e.getMessage() << std::endl; + + return -1; + } + catch (...) + { + return -1; + } + + return 0; +} + + +void IlpSubset::exportModel(const std::string& filename) +{ + _model.write(filename); +} + + +void IlpSubset::printValues() +{ + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + std::cerr << _yA[s][p].get(GRB_StringAttr_VarName) << "" = "" << _yA[s][p].get(GRB_DoubleAttr_X) << std::endl; + std::cerr << _yB[s][p].get(GRB_StringAttr_VarName) << "" = "" << _yB[s][p].get(GRB_DoubleAttr_X) << std::endl; + } + } + + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + std::cerr << _fA[s][p].get(GRB_StringAttr_VarName) << "" = "" << _fA[s][p].get(GRB_DoubleAttr_X) << std::endl; + std::cerr << _fB[s][p].get(GRB_StringAttr_VarName) << "" = "" << _fB[s][p].get(GRB_DoubleAttr_X) << std::endl; + } + } + + if(_mode == MODE_t::FULL || _mode == MODE_t::CARCH) + { + for(int s = 0; s < _m; ++s) + { + for(int i = 0; i < _n; ++i) + { + std::cerr << _cA[s][i].get(GRB_StringAttr_VarName) << "" = "" << _cA[s][i].get(GRB_DoubleAttr_X) << std::endl; + std::cerr << _cB[s][i].get(GRB_StringAttr_VarName) << "" = "" << _cB[s][i].get(GRB_DoubleAttr_X) << std::endl; + } + } + + for(int b = 0; b < _M; ++b) + { + for(int s = 0; s < _m; ++s) + { + for(int i = 0; i < _n; ++i) + { + std::cerr << _bitcA[b][s][i].get(GRB_StringAttr_VarName) << "" = "" << _bitcA[b][s][i].get(GRB_DoubleAttr_X) << std::endl; + std::cerr << _bitcB[b][s][i].get(GRB_StringAttr_VarName) << "" = "" << _bitcB[b][s][i].get(GRB_DoubleAttr_X) << std::endl; + } + } + } + } + + if(_mode == MODE_t::FULL || _mode == MODE_t::UARCH) + { + for(int i =0; i < _n; ++i) + { + for(int p = 0; p < _k; ++p) + { + std::cerr << _u[i][p].get(GRB_StringAttr_VarName) << "" = "" << _u[i][p].get(GRB_DoubleAttr_X) << std::endl; + } + } + } + + if(_mode == MODE_t::FULL) + { + for(int b = 0; b < _M; ++b) + { + for(int s = 0; s < _m; ++s) + { + for(int i = 0; i < _n; ++i) + { + for(int p = 0; p < _k; ++p) + { + std::cerr << _vA[b][s][i][p].get(GRB_StringAttr_VarName) << "" = "" << _vA[b][s][i][p].get(GRB_DoubleAttr_X) << std::endl; + std::cerr << _vB[b][s][i][p].get(GRB_StringAttr_VarName) << "" = "" << _vB[b][s][i][p].get(GRB_DoubleAttr_X) << std::endl; + } + } + } + } + } +} + + +std::pair IlpSubset::firstHotStart(const DoubleMatrix &FA, const DoubleMatrix &FB, const int m, const int k, const int n, + const int cmax, const int d, const int base, const bool ampdel, const CNMap& cn) +{ + IntMatrix targetA; + IntMatrix targetB; + if(d > 0) + { + IntMatrix optionsA(m); + IntMatrix optionsB(m); + for(int s = 0; s < m; ++s) + { + optionsA[s] = IntArray(); + optionsB[s] = IntArray(); + for(int p = 0; p < k; ++p) + { + optionsA[s].push_back((int)std::round(FA[s][p])); + optionsB[s].push_back((int)std::round(FB[s][p])); + } + std::shuffle(optionsA[s].begin(), optionsA[s].end(), g_rng); + while(optionsA[s].size() > d) + { + optionsA[s].pop_back(); + std::shuffle(optionsA[s].begin(), optionsA[s].end(), g_rng); + } + std::shuffle(optionsB[s].begin(), optionsB[s].end(), g_rng); + while(optionsB[s].size() > d) + { + optionsB[s].pop_back(); + std::shuffle(optionsB[s].begin(), optionsB[s].end(), g_rng); + } + } + targetA = IntMatrix(m); + targetB = IntMatrix(m); + for(int s = 0; s < m; ++s) + { + targetA[s] = IntArray(d); + targetB[s] = IntArray(d); + for(int l = 0; l < d; ++l) + { + targetA[s][l] = optionsA[s][l % optionsA[s].size()]; + targetB[s][l] = optionsB[s][l % optionsB[s].size()]; + } + } + } else { + targetA = IntMatrix(m); + targetB = IntMatrix(m); + for(int s = 0; s < m; ++s) + { + targetA[s] = IntArray(k); + targetB[s] = IntArray(k); + for(int p = 0; p < k; ++p) + { + targetA[s][p] = std::round(FA[s][p]); + targetB[s][p] = std::round(FB[s][p]); + } + } + } + + IntMatrix hCA(m); + IntMatrix hCB(m); + for(int s = 0; s < m; ++s) + { + hCA[s] = IntArray(n); + hCB[s] = IntArray(n); + int adA = 0; + int adB = 0; + for(int i = 0; i < n; ++i) + { + if(i > 0) + { + if(cn.count(s) == 0) + { + int mod = std::min(n, k); + int a = std::min(targetA[s][i % mod], cmax); + int b = std::min(targetB[s][i % mod], cmax); + + if(ampdel) + { + adA = adA == 0 && a > base ? 1 : adA; + adA = adA == 0 && a < base ? -1 : adA; + adB = adB == 0 && b > base ? 1 : adB; + adB = adB == 0 && b < base ? -1 : adB; + + a = adA >= 0 ? std::max(a, base) : std::min(a, base); + b = adB >= 0 ? std::max(b, base) : std::min(b, base); + + if(a + b > cmax) + { + a = cmax - base; + b = cmax - a; + } + } + + if(a + b <= cmax) + { + hCA[s][i] = a; + hCB[s][i] = b; + } else { + hCA[s][i] = a; + hCB[s][i] = std::max(cmax - a, 0); + } + assert(hCA[s][i] + hCB[s][i] <= cmax); + assert(hCA[s][i] >= 0); + assert(hCB[s][i] >= 0); + } else { + hCA[s][i] = cn.at(s).first; + hCB[s][i] = cn.at(s).second; + } + } else { + hCA[s][0] = 1; + hCB[s][0] = 1; + } + } + } + + return std::make_pair(hCA, hCB); +} + + +void IlpSubset::buildVariables() +{ + char buf[1024]; + + _yA = VarMatrix(_m); + _yB = VarMatrix(_m); + for(int s = 0; s < _m; ++s) + { + _yA[s] = VarArray(_k); + _yB[s] = VarArray(_k); + for(int p = 0; p < _k; ++p) + { + snprintf(buf, 1024, ""yA_%d_%d"", s+1, p+1); + _yA[s][p] = _model.addVar(0.0, GRB_INFINITY, 0, GRB_CONTINUOUS, buf); + + snprintf(buf, 1024, ""yB_%d_%d"", s+1, p+1); + _yB[s][p] = _model.addVar(0.0, GRB_INFINITY, 0, GRB_CONTINUOUS, buf); + } + } + + _fA = VarMatrix(_m); + _fB = VarMatrix(_m); + for(int s = 0; s < _m; ++s) + { + int upper = 0; + if(_cn.count(s) > 0) + { + upper = std::max(_cn.at(s).first + _cn.at(s).second, _cmax); + } else { + upper = _cmax; + } + + _fA[s] = VarArray(_k); + _fB[s] = VarArray(_k); + for(int p = 0; p < _k; ++p) + { + snprintf(buf, 1024, ""fA_%d_%d"", s+1, p+1); + _fA[s][p] = _model.addVar(0.0, upper, 0, GRB_CONTINUOUS, buf); + + snprintf(buf, 1024, ""fB_%d_%d"", s+1, p+1); + _fB[s][p] = _model.addVar(0.0, upper, 0, GRB_CONTINUOUS, buf); + } + } + + if(_mode == MODE_t::FULL || _mode == MODE_t::CARCH) + { + _cA = VarMatrix(_m); + _cB = VarMatrix(_m); + for(int s = 0; s < _m; ++s) + { + int upper = 0; + if(_cn.count(s) > 0) + { + upper = std::max(_cn.at(s).first + _cn.at(s).second, _cmax); + } else { + upper = _cmax; + } + + _cA[s] = VarArray(_n); + _cB[s] = VarArray(_n); + for(int i = 0; i < _n; ++i) + { + snprintf(buf, 1024, ""cA_%d_%d"", s+1, i+1); + _cA[s][i] = _model.addVar(0, upper, 0, GRB_INTEGER, buf); + + snprintf(buf, 1024, ""cB_%d_%d"", s+1, i+1); + _cB[s][i] = _model.addVar(0, upper, 0, GRB_INTEGER, buf); + } + } + + if(_ampdel) + { + _adA = VarArray(_m); + _adB = VarArray(_m); + for(int s = 0; s < _m; ++s) + { + if(_cn.count(s) == 0) + { + snprintf(buf, 1024, ""adA_%d"", s+1); + _adA[s] = _model.addVar(0, 1, 0, GRB_BINARY, buf); + + snprintf(buf, 1024, ""adB_%d"", s+1); + _adB[s] = _model.addVar(0, 1, 0, GRB_BINARY, buf); + } + } + } + } + + if(_mode == MODE_t::FULL || (_d > 0 && _mode == MODE_t::CARCH)) + { + _bitcA = Var3Matrix(_M); + _bitcB = Var3Matrix(_M); + for(int b = 0; b < _M; ++b) + { + _bitcA[b] = VarMatrix(_m); + _bitcB[b] = VarMatrix(_m); + for(int s = 0; s < _m; ++s) + { + _bitcA[b][s] = VarArray(_n); + _bitcB[b][s] = VarArray(_n); + for(int i = 0; i < _n; ++i) + { + snprintf(buf, 1024, ""bitcA_%d_%d_%d"", b+1, s+1, i+1); + _bitcA[b][s][i] = _model.addVar(0, 1, 0, GRB_BINARY, buf); + + snprintf(buf, 1024, ""bitcB_%d_%d_%d"", b+1, s+1, i+1); + _bitcB[b][s][i] = _model.addVar(0, 1, 0, GRB_BINARY, buf); + } + } + } + } + + if(_mode == MODE_t::FULL || _mode == MODE_t::UARCH) + { + _u = VarMatrix(_n); + for(int i = 0; i < _n; ++i) + { + _u[i] = VarArray(_k); + for(int p = 0; p < _k; ++p) + { + snprintf(buf, 1024, ""u_%d_%d"", i+1, p+1); + _u[i][p] = _model.addVar(0, 1, 0, GRB_CONTINUOUS, buf); + } + } + } + + if(_mode == MODE_t::FULL) + { + _vA = Var4Matrix(_M); + _vB = Var4Matrix(_M); + for(int b = 0; b < _M; ++b) + { + _vA[b] = Var3Matrix(_m); + _vB[b] = Var3Matrix(_m); + for(int s = 0; s < _m; ++s) + { + _vA[b][s] = VarMatrix(_n); + _vB[b][s] = VarMatrix(_n); + for(int i = 0; i < _n; ++i) + { + _vA[b][s][i] = VarArray(_k); + _vB[b][s][i] = VarArray(_k); + for(int p = 0; p < _k; ++p) + { + snprintf(buf, 1024, ""vA_%d_%d_%d_%d"", b+1, s+1, i+1, p+1); + _vA[b][s][i][p] = _model.addVar(0, 1, 0, GRB_CONTINUOUS, buf); + + snprintf(buf, 1024, ""vB_%d_%d_%d_%d"", b+1, s+1, i+1, p+1); + _vB[b][s][i][p] = _model.addVar(0, 1, 0, GRB_CONTINUOUS, buf); + } + } + } + } + } + + if((_mode == MODE_t::FULL || _mode == MODE_t::UARCH) && _mu > 0.0) + { + _x = VarMatrix(_n); + for(int i = 0; i < _n; ++i) + { + _x[i] = VarArray(_k); + for(int p = 0; p < _k; ++p) + { + snprintf(buf, 1024, ""x_%d_%d"", i+1, p+1); + _x[i][p] = _model.addVar(0, 1, 0, GRB_BINARY, buf); + } + } + } + + _model.update(); +} + + +void IlpSubset::buildOptionalVariables() +{ + char buf[1024]; + + _z = Var3Matrix(_m); + for(int s = 0; s < _m; ++s) + { + _z[s] = VarMatrix(_n); + for(int i = 1; i < _n; ++i) + { + _z[s][i] = VarArray(_d); + for(int l = 0; l < _d; ++l) + { + snprintf(buf, 1024, ""z_%d_%d_%d"", s+1, i+1, l+1); + _z[s][i][l] = _model.addVar(0, 1, 0, GRB_BINARY, buf); + } + } + } + + _model.update(); +} + + +void IlpSubset::buildConstraints() +{ + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + _model.addConstr(_FA[s][p] - _fA[s][p] <= _yA[s][p]); + _model.addConstr(_fA[s][p] - _FA[s][p] <= _yA[s][p]); + + _model.addConstr(_FB[s][p] - _fB[s][p] <= _yB[s][p]); + _model.addConstr(_fB[s][p] - _FB[s][p] <= _yB[s][p]); + } + } + + if(_mode == MODE_t::FULL) + { + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + GRBLinExpr sum; + sum = 0; + for(int i = 0; i < _n; ++i) + { + for(int b = 0; b < _M; ++b) + { + sum += _vA[b][s][i][p] * pow(2, b); + _model.addConstr(_vA[b][s][i][p] <= _bitcA[b][s][i]); + _model.addConstr(_vA[b][s][i][p] <= _u[i][p]); + _model.addConstr(_vA[b][s][i][p] >= _bitcA[b][s][i] + _u[i][p] - 1); + } + } + _model.addConstr(_fA[s][p] == sum); + sum.clear(); + } + } + + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + GRBLinExpr sumB; + sumB = 0; + for(int i = 0; i < _n; ++i) + { + for(int b = 0; b < _M; ++b) + { + sumB += _vB[b][s][i][p] * pow(2, b); + _model.addConstr(_vB[b][s][i][p] <= _bitcB[b][s][i]); + _model.addConstr(_vB[b][s][i][p] <= _u[i][p]); + _model.addConstr(_vB[b][s][i][p] >= _bitcB[b][s][i] + _u[i][p] - 1); + } + } + _model.addConstr(_fB[s][p] == sumB); + sumB.clear(); + } + } + + for(int i = 0; i < _n; ++i) + { + for(int p = 0; p < _k; ++p) + { + GRBLinExpr sum; + sum = 0; + for(int s = 0; s < _m; ++s) + { + for(int b = 0; b < _M; ++b) + { + sum += _bitcA[b][s][i] + _bitcB[b][s][i]; + } + } + _model.addConstr(sum >= _u[i][p]); + sum.clear(); + } + } + + } + + if(_mode == MODE_t::FULL || (_d > 0 && _mode == MODE_t::CARCH)) + { + for(int s = 0; s < _m; ++s) + { + int upper = 0; + if(_cn.count(s) > 0) + { + upper = std::max(_cn.at(s).first + _cn.at(s).second, _cmax); + } else { + upper = _cmax; + } + + for(int i = 0; i < _n; ++i) + { + GRBLinExpr sumA; + sumA = 0; + for(int b = 0; b < _M; ++b) + { + sumA += _bitcA[b][s][i] * pow(2, b); + } + GRBLinExpr sumB; + sumB = 0; + for (int b = 0; b < _M; ++b) { + sumB += _bitcB[b][s][i] * pow(2, b); + } + _model.addConstr(_cA[s][i] == sumA); + _model.addConstr(_cB[s][i] == sumB); + _model.addConstr(_cA[s][i] + _cB[s][i] <= upper); + sumA.clear(); + sumB.clear(); + } + } + + } + + if (_mode == MODE_t::CARCH) { + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + GRBLinExpr sum; + sum = 0; + for(int i = 0; i < _n; ++i) + { + if(_barU[i][p] >= _mu - TOL) + { + sum += _cA[s][i] * _barU[i][p]; + } + } + _model.addConstr(_fA[s][p] == sum); + sum.clear(); + } + } + + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + GRBLinExpr sumB; + sumB = 0; + for(int i = 0; i < _n; ++i) + { + if(_barU[i][p] >= _mu - TOL) + { + sumB += _cB[s][i] * _barU[i][p]; + } + } + _model.addConstr(_fB[s][p] == sumB); + sumB.clear(); + } + } + + for(int s = 0; s < _m; ++s) + { + int upper = 0; + if(_cn.count(s) > 0) + { + upper = std::max(_cn.at(s).first + _cn.at(s).second, _cmax); + } else { + upper = _cmax; + } + + for(int i = 0; i < _n; ++i) + { + _model.addConstr(_cA[s][i] + _cB[s][i] <= upper); + } + } + } + + if(_mode == MODE_t::FULL || _mode == MODE_t::CARCH) + { + for(int s = 0; s < _m; ++s) + { + _model.addConstr(_cA[s][0] == 1); + _model.addConstr(_cB[s][0] == 1); + } + + if(_ampdel) + { + for(int s = 0; s < _m; ++s) + { + if(_cn.count(s) == 0) + { + for(int i = 1; i < _n; ++i) + { + _model.addConstr(_cA[s][i] <= _cmax * _adA[s] + _base - _base * _adA[s]); + _model.addConstr(_cA[s][i] >= _base * _adA[s]); + + _model.addConstr(_cB[s][i] <= _cmax * _adB[s] + _base - _base * _adB[s]); + _model.addConstr(_cB[s][i] >= _base * _adB[s]); + } + } + } + } + } + + if (_mode == MODE_t::UARCH) { + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + GRBLinExpr sum; + sum = 0; + for(int i = 0; i < _n; ++i) + { + sum += _barCA[s][i] * _u[i][p]; + } + _model.addConstr(_fA[s][p] == sum); + sum.clear(); + } + } + + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + GRBLinExpr sumB; + sumB = 0; + for(int i = 0; i < _n; ++i) + { + sumB += _barCB[s][i] * _u[i][p]; + } + _model.addConstr(_fB[s][p] == sumB); + sumB.clear(); + } + } + } + + if(_mode == MODE_t::FULL || _mode == MODE_t::UARCH) + { + for(int p = 0; p < _k; ++p) + { + GRBLinExpr sum; + sum = 0; + for(int i = 0; i < _n; ++i) + { + sum += _u[i][p]; + } + _model.addConstr(sum == 1); + sum.clear(); + } + } + + if((_mode == MODE_t::FULL || _mode == MODE_t::UARCH) && _mu > 0.0) + { + for(int p = 0; p < _k; ++p) + { + for(int i = 1; i < _n; ++i) + { + _model.addConstr(_x[i][p] >= _u[i][p]); + _model.addConstr(_u[i][p] >= _mu * _x[i][p]); + } + } + } + + _model.update(); +} + + +void IlpSubset::buildOptionalConstraints() +{ + for(int s = 0; s < _m; ++s) + { + for(int i = 1; i < _n; ++i) + { + GRBLinExpr sum; + sum = 0; + for(int l = 0; l < _d; ++l) + { + sum += _z[s][i][l]; + } + _model.addConstr(sum == 1); + } + } + + for(int s = 0; s < _m; ++s) + { + for(int b = 0; b < _M; ++b) + { + for(int l = 0; l < _d; ++l) + { + for(int i = 1; i < _n - 1; ++i) + { + for(int j = i; j < _n; ++j) + { + _model.addConstr(_bitcA[b][s][i] - _bitcA[b][s][j] <= 2 - _z[s][i][l] - _z[s][j][l]); + _model.addConstr(_bitcA[b][s][j] - _bitcA[b][s][i] <= 2 - _z[s][i][l] - _z[s][j][l]); + + _model.addConstr(_bitcB[b][s][i] - _bitcB[b][s][j] <= 2 - _z[s][i][l] - _z[s][j][l]); + _model.addConstr(_bitcB[b][s][j] - _bitcB[b][s][i] <= 2 - _z[s][i][l] - _z[s][j][l]); + } + } + } + } + } + + for(int s = 0; s < _m; ++s) + { + for(int l = 0; l < _d - 1; ++l) + { + GRBLinExpr sumL; + GRBLinExpr sumL1; + sumL = 0; + sumL1 = 0; + for(int i = 1; i < _n; ++i) + { + sumL += _z[s][i][l] * symmCoeff(i); + sumL1 += _z[s][i][l+1] * symmCoeff(i); + } + _model.addConstr(sumL <= sumL1); + sumL.clear(); + sumL1.clear(); + } + } + + _model.update(); +} + + +void IlpSubset::buildSymmetryBreaking() +{ + for(int i = 1; i < _n - 1; ++i) + { + GRBLinExpr sumI; + GRBLinExpr sumI1; + sumI = 0; + sumI1 = 0; + for(int s = 0; s < _m; ++s) + { + sumI += _cA[s][i] * symmCoeff(s) + _cB[s][i] * symmCoeff(s); + sumI1 += _cA[s][i] * symmCoeff(s) + _cB[s][i] * symmCoeff(s); + } + _model.addConstr(sumI <= sumI1); + sumI.clear(); + sumI1.clear(); + } + + _model.update(); +} + +void IlpSubset::fixGivenCN() +{ + for(auto const& cluster : _cn) + { + int s = cluster.first; + CNState cnstate = cluster.second; + for(int i = 1; i < _n; ++i) + { + _model.addConstr(_cA[s][i] == cnstate.first); + _model.addConstr(_cB[s][i] == cnstate.second); + } + } +} + +void IlpSubset::buildObjective() +{ + GRBLinExpr obj; + obj = 0; + + double norm = std::accumulate(_w.begin(), _w.end(), 0.0); + DoubleArray ws; + if(_mode == MODE_t::FULL) {log(""Cluster objective weights: "", VERBOSITY_t::DEBUGGING, _v);} + for(auto& w : _w) + { + ws.push_back((double)w * 100.0 / (double)norm); + if(_mode == MODE_t::FULL) {log(std::to_string(w) + ""= "" + std::to_string(ws.back()) + "", "", VERBOSITY_t::DEBUGGING, _v);} + } + if(_mode == MODE_t::FULL) {log(""\n"", VERBOSITY_t::DEBUGGING, _v);} + + for(int s = 0; s < _m; ++s) + { + for(int p = 0; p < _k; ++p) + { + obj += _yA[s][p] * ws[s] + _yB[s][p] * ws[s]; + } + } + + _model.setObjective(obj, GRB_MINIMIZE); + _model.update(); +} + +/// Based on (Balas and Jeroslow, J. of App. Math., 1972) +void IlpSubset::buildNext() +{ + GRBLinExpr sum1; + GRBLinExpr sum0; + sum1 = 0; + sum0 = 0; + int count1 = 0; + + for(int s = 0; s < _m; ++s) + { + for(int i = 0; i < _n; ++i) + { + for(int b = 0; b < _M; ++b) + { + if(round(_bitcA[b][s][i].get(GRB_DoubleAttr_X)) == 1) + { + sum1 += _bitcA[b][s][i]; + ++count1; + } else { + sum0 += _bitcA[b][s][i]; + } + } + + for(int b = 0; b < _M; ++b) + { + if(round(_bitcB[b][s][i].get(GRB_DoubleAttr_X)) == 1) + { + sum1 += _bitcB[b][s][i]; + ++count1; + } else { + sum0 += _bitcB[b][s][i]; + } + } + } + } + + _model.addConstr(sum1 - sum0 <= count1 - 1); +} + + +void IlpSubset::test() +{ +// _model.addConstr(_cA[0][0] == 1); +// _model.addConstr(_cA[1][0] == 1); +// _model.addConstr(_cA[2][0] == 1); +// _model.addConstr(_cA[3][0] == 1); +// _model.addConstr(_cA[4][0] == 1); +// +// _model.addConstr(_cB[0][0] == 1); +// _model.addConstr(_cB[1][0] == 1); +// _model.addConstr(_cB[2][0] == 1); +// _model.addConstr(_cB[3][0] == 1); +// _model.addConstr(_cB[4][0] == 1); + + _model.computeIIS(); + _model.write(""iis.ilp""); +} + + +IntMatrix IlpSubset::getCA() +{ + if(_mode == MODE_t::FULL || _mode == MODE_t::CARCH) + { + IntMatrix CA(_m); + for(int s = 0; s < _m; ++s) + { + CA[s] = IntArray(_n); + for(int i = 0; i < _n; ++i) + { + CA[s][i] = round(_cA[s][i].get(GRB_DoubleAttr_X)); + } + } + return CA; + } else { + return _barCA; + } +} + + +IntMatrix IlpSubset::getCB() +{ + if(_mode == MODE_t::FULL || _mode == MODE_t::CARCH) + { + IntMatrix CB(_m); + for(int s = 0; s < _m; ++s) + { + CB[s] = IntArray(_n); + for(int i = 0; i < _n; ++i) + { + CB[s][i] = round(_cB[s][i].get(GRB_DoubleAttr_X)); + } + } + return CB; + } else { + return _barCB; + } +} + + +DoubleMatrix IlpSubset::getU() +{ + if(_mode == MODE_t::FULL || _mode == MODE_t::UARCH) + { + DoubleMatrix U(_n); + for(int i = 0; i < _n; ++i) + { + U[i] = DoubleArray(_k); + for(int p = 0; p < _k; ++p) + { + U[i][p] = _u[i][p].get(GRB_DoubleAttr_X); + } + } + return U; + } else { + return _barU; + } +} + + +bool IlpSubset::checkRank(const IntMatrix &hCA, const IntMatrix &hCB, const IntArray &map) +{ + bool flag = true; + for(int i = 1; i < _n - 1; ++i) + { + int sumI = 0; + int sumI1 = 0; + for(int s = 0; s < _m; ++s) + { + sumI += hCA[s][map[i]] * symmCoeff(s) + hCB[s][map[i]] * symmCoeff(s); + sumI1 += hCA[s][map[i+1]] * symmCoeff(s) + hCB[s][map[i+1]] * symmCoeff(s); + } + flag = flag && (sumI <= sumI1); + } + return flag; +} + + +double IlpSubset::symmCoeff(const int index) +{ + return std::pow(index+1, 1); +} +","C++" +"Allele","raphael-group/hatchet","src/bbc_instance.h",".h","1585","94","#ifndef _BBCINSTANCE_H_ +#define _BBCINSTANCE_H_ + +#include ""utils.h"" + + +class BBCInstance +{ + +public: + BBCInstance(); + + friend std::ostream& operator<<(std::ostream& out, const BBCInstance& instance); + friend std::istream& operator>>(std::istream& in, BBCInstance& instance); + + int m() const + { + return _m; + } + + int k() const + { + return _k; + } + + const StringMap& chromosomes() const + { + return _chromosomes; + } + + const StringSet& clusters() const + { + return _clusters; + } + + const BinMap& bins() const + { + return _bins; + } + + const StringSet& samples() const + { + return _samples; + } + + const StringMap& mapSampleToIdx() const + { + return _mapSampleToIdx; + } + + const DoubleBBRecord& binsToSampleRdBaf() const + { + return _binsToSampleRdBaf; + } + + const IntBBRecord& binsToSampleSCAB() const + { + return _binsToSampleSCAB; + } + + const ClusterBBRecord& binsToCluster() const + { + return _binsToCluster; + } + +private: + + /// + int _m; + /// + int _k; + /// + StringMap _chromosomes; + /// + StringSet _clusters; + /// + BinMap _bins; + /// + StringSet _samples; + /// + StringMap _mapSampleToIdx; + /// + DoubleBBRecord _binsToSampleRdBaf; + /// + IntBBRecord _binsToSampleSCAB; + /// + ClusterBBRecord _binsToCluster; + +}; +std::ostream& operator<<(std::ostream& out, const BBCInstance& instance); +std::istream& operator>>(std::istream& in, BBCInstance& instance); + +#endif // _INPUTINSTANCE_H_ +","Unknown" +"Allele","raphael-group/hatchet","src/gurobi-utils.h",".h","573","23","#ifndef _UTILS_GUROBI_H_ +#define _UTILS_GUROBI_H_ + +#include ""utils.h"" +#include + +/// Gurobi variable array +typedef std::vector VarArray; +/// Gurobi variable matrix +typedef std::vector VarMatrix; +/// Gurobi variable 3D matrix +typedef std::vector Var3Matrix; +/// Gurobi variable 4D matrix +typedef std::vector Var4Matrix; +/// Gurobi variable 5D matrix +typedef std::vector Var5Matrix; +/// Gurobi variable 6D matrix +typedef std::vector Var6Matrix; + +#define NON_ZERO 0.01 + +#endif // _UTILS_GUROBI_H_ +","Unknown" +"Allele","raphael-group/hatchet","src/solve.cpp",".cpp","18765","458"," +#include ""utils.h"" +#include ""argparse.h"" +#include ""input_instance.h"" +#include ""bbc_instance.h"" +#include ""ilp-min.h"" +#include ""coordinate_descent.h"" + + +CNAssignCluster inferDiploid(const InputInstance& instance, const ArgParse& argparse); +DoubleMatrix scaleReadDepth(const DoubleMatrix &R, const CNAssignCluster &cn, const int m, const int k, const std::map &clusterToIdx, const VERBOSITY_t verbose); +void splitFractions(const DoubleMatrix &B, const DoubleMatrix &F, const int m, const int k, DoubleMatrix &FA, DoubleMatrix &FB); +void printSolutions(const int k, const double obj, const IntMatrix& CA, const IntMatrix& CB, const DoubleMatrix& U); +void printSolutions(const int k, const int numSolutions, const DoubleArray& obj, const Int3Matrix& CA, const Int3Matrix& CB, const Double3Matrix& U); +void segmentation(const InputInstance& instance, const BBCInstance& bbc, const int n, const IntMatrix& ACN, const IntMatrix& BCN, const DoubleMatrix& U, const std::string& outprefix, const VERBOSITY_t& verbosity); +CNMap getCNMap(const ArgParse& argparse, const InputInstance& instance); +std::string printFractions(const DoubleMatrix &F, const InputInstance &instance); + + + +int main(int argc, char** argv) +{ + try { + ArgParse argparse(argc, argv); + + log(""Parsing and checking input arguments"", VERBOSITY_t::ESSENTIAL, argparse.v()); + log(argparse.toString(), VERBOSITY_t::VERBOSE, argparse.v()); + g_rng = argparse.rnd() > 0 ? std::mt19937_64(argparse.rnd()) : std::mt19937_64(); + + log(""Reading the input SEG file"", VERBOSITY_t::ESSENTIAL, argparse.v()); + InputInstance instance; + std::ifstream input(argparse.inputSEG()); + input >> instance; + + if(argparse.v() >= VERBOSITY_t::DEBUGGING) {std::cerr << instance;} + + + if (argparse.cn().size() > 0) + { + log(""Scale the read-depth ratios into fractional copy numbers using the provided copy numbers"", VERBOSITY_t::ESSENTIAL, argparse.v()); + } else { + argparse.setClonalCluster(inferDiploid(instance, argparse)); + log(""Automatically selecting cluster "" + argparse.scalingCN().begin()->first + "" as diploid"", VERBOSITY_t::ESSENTIAL, argparse.v()); + log(""Scale the read-depth ratios into fractional copy numbers using the automaticall selected diploid cluster"", VERBOSITY_t::ESSENTIAL, argparse.v()); + } + DoubleMatrix F(scaleReadDepth(instance.R(), argparse.scalingCN(), instance.m(), instance.k(), instance.clusterToIdx(), argparse.v())); + log(""Fractional copy numbers:\n"" + printFractions(F, instance), VERBOSITY_t::DEBUGGING, argparse.v()); + + CNMap cn(getCNMap(argparse, instance)); + + int cmax = argparse.cmax() > 0 ? argparse.cmax() : maxCeil(F); + log(""Inferred maximum copy number:"" + std::to_string(cmax), VERBOSITY_t::DEBUGGING, argparse.v()); + + log(""Compute allele-specific fractional copy numbers using BAF"", VERBOSITY_t::ESSENTIAL, argparse.v()); + DoubleMatrix FA; + DoubleMatrix FB; + splitFractions(instance.B(), F, instance.m(), instance.k(), FA, FB); + log(""A-Allele fractional copy numbers:\n"" + printFractions(FA, instance), VERBOSITY_t::DEBUGGING, argparse.v()); + log(""B-Allele fractional copy numbers:\n"" + printFractions(FB, instance), VERBOSITY_t::DEBUGGING, argparse.v()); + + double obj; + IntMatrix ACN; + IntMatrix BCN; + DoubleMatrix U; + + if(argparse.M() == SOLVE_t::BOTH) + { + log(""Starting coordinate descent algorithm on "" + std::to_string(argparse.nrSeeds()) + "" seeds"", VERBOSITY_t::ESSENTIAL, argparse.v()); + CoordinateDescent cd(FA, FB, instance.w(), instance.m(), instance.k(), argparse.n(), cmax, argparse.d(), argparse.minprop(), argparse.base(), + argparse.forceAMPDEL(), cn, 2, argparse.maxiter(), argparse.nrSeeds(), argparse.j(), 1, argparse.s(), argparse.m(), argparse.v()); + cd.run(); + log(""Objective value from coordinate descent:\t"" + std::to_string(cd.getObjValue()), VERBOSITY_t::ESSENTIAL, argparse.v()); + + log(""Starting exact ILP for improving solution found by coordinate descent"", VERBOSITY_t::ESSENTIAL, argparse.v()); + IlpSubset ilp(argparse.n(), instance.m(), instance.k(), cmax, argparse.d(), argparse.minprop(), argparse.base(), + argparse.forceAMPDEL(), cn, FA, FB, instance.w(), argparse.v()); + ilp.init(); + ilp.hotStart(cd.getACN(), cd.getBCN()); + ilp.solve(argparse.s(), argparse.m(), argparse.j()); + + log(""Runtime:\t"" + std::to_string(ilp.runtime()), VERBOSITY_t::ESSENTIAL, argparse.v()); + log(""Gap:\t"" + std::to_string(ilp.gap()), VERBOSITY_t::ESSENTIAL, argparse.v()); + log(""Final objective:\t"" + std::to_string(ilp.getObjs()[0]), VERBOSITY_t::ESSENTIAL, argparse.v()); + printSolutions(instance.k(), 1, ilp.getObjs(), ilp.getACNs(), ilp.getBCNs(), ilp.getUs()); + + obj = ilp.getObjs()[0]; + ACN = ilp.getACNs()[0]; + BCN = ilp.getBCNs()[0]; + U = ilp.getUs()[0]; + + } else if (argparse.M() == SOLVE_t::ILP) + { + log(""Starting exact ILP"", VERBOSITY_t::ESSENTIAL, argparse.v()); + IlpSubset ilp(argparse.n(), instance.m(), instance.k(), cmax, argparse.d(), argparse.minprop(), argparse.base(), + argparse.forceAMPDEL(), cn, FA, FB, instance.w(), argparse.v()); + ilp.init(); + std::pair hotstart; + hotstart = IlpSubset::firstHotStart(FA, FB, instance.m(), instance.k(), argparse.n(), cmax, argparse.d(), argparse.base(), argparse.forceAMPDEL(), cn); + ilp.hotStart(hotstart.first, hotstart.second); + ilp.solve(argparse.s(), argparse.m(), argparse.j()); + + log(""Runtime:\t"" + std::to_string(ilp.runtime()), VERBOSITY_t::ESSENTIAL, argparse.v()); + log(""Gap:\t"" + std::to_string(ilp.gap()), VERBOSITY_t::ESSENTIAL, argparse.v()); + log(""Final objective:\t"" + std::to_string(ilp.getObjs()[0]), VERBOSITY_t::ESSENTIAL, argparse.v()); + printSolutions(instance.k(), 1, ilp.getObjs(), ilp.getACNs(), ilp.getBCNs(), ilp.getUs()); + + obj = ilp.getObjs()[0]; + ACN = ilp.getACNs()[0]; + BCN = ilp.getBCNs()[0]; + U = ilp.getUs()[0]; + + } else if (argparse.M() == SOLVE_t::CD) + { + log(""Starting coordinate descent algorithm on "" + std::to_string(argparse.nrSeeds()) + "" seeds"", VERBOSITY_t::ESSENTIAL, argparse.v()); + CoordinateDescent cd(FA, FB, instance.w(), instance.m(), instance.k(), argparse.n(), cmax, argparse.d(), argparse.minprop(), argparse.base(), + argparse.forceAMPDEL(), cn, 2, argparse.maxiter(), argparse.nrSeeds(), argparse.j(), 1, argparse.s(), argparse.m(), argparse.v()); + cd.run(); + + log(""Final objective:\t"" + std::to_string(cd.getObjValue()), VERBOSITY_t::ESSENTIAL, argparse.v()); + printSolutions(instance.k(), cd.getObjValue(), cd.getACN(), cd.getBCN(), cd.getU()); + + obj = cd.getObjValue(); + ACN = cd.getACN(); + BCN = cd.getBCN(); + U = cd.getU(); + + } else { + throw ""Unknown solving mode!""; + } + + log(""Reading the input BBC file"", VERBOSITY_t::ESSENTIAL, argparse.v()); + BBCInstance bbc; + std::ifstream bbffile(argparse.inputBBC()); + bbffile >> bbc; + + log(""Segmenting the genome with the inferred copy numbers"", VERBOSITY_t::ESSENTIAL, argparse.v()); + segmentation(instance, bbc, argparse.n(), ACN, BCN, U, argparse.o(), argparse.v()); + + log(""KTHXBYE!"", VERBOSITY_t::ESSENTIAL, argparse.v()); + } catch(const std::string &e) { + std::cerr << ""\033[91m"" << e << ""\033[0m"" << std::endl; + std::exit(EXIT_FAILURE); + } catch(const char * e) { + std::cerr << ""\033[91m"" << e << ""\033[0m"" << std::endl; + std::exit(EXIT_FAILURE); + } +} + + +CNAssignCluster inferDiploid(const InputInstance& instance, const ArgParse& argparse) +{ + double max = -1; + std::string name; + for(std::string const& cluster : instance.clusters()) + { + int s = instance.clusterToIdx().at(cluster); + bool flag = true; + for(auto const& sampleR : instance.R()[s]) + { + flag = flag && (sampleR >= (0.5 - argparse.diploidThreshold())); + } + + if (flag && (instance.w()[s] > max)) + { + max = instance.w()[s]; + name = cluster; + } + } + + if (max == -1) { + throw ""No diploid cluster found with a diploid-read-depth-ratio threshold of "" + std::to_string(argparse.diploidThreshold()); + } + + CNAssignCluster result; + result.emplace(name, CNState(1, 1)); + + return result; +} + + +DoubleMatrix scaleReadDepth(const DoubleMatrix &R, const CNAssignCluster &cn, const int m, const int k, const std::map &clusterToIdx, const VERBOSITY_t verbose) +{ + std::vector cscale(k); + + if(cn.size() == 1) + { + log(""Scaling using:\t"" + cn.begin()->first + "":"" + std::to_string(cn.begin()->second.first) + "":"" + std::to_string(cn.begin()->second.second), VERBOSITY_t::DEBUGGING, verbose); + + for(int p = 0; p < k; ++p) + { + double denom = R[(*clusterToIdx.find(cn.begin()->first)).second][p]; + if (denom <= 0) + { + throw ""Only clusters with a positive read-depth ratio can be selected as diploid segments!""; + } + cscale[p] = 2.0 / denom; + } + + } else if (cn.size() >= 2) { + auto it = cn.begin(); + std::string logging = ""Scaling using:\t""; + + int s1 = (*clusterToIdx.find(it->first)).second; + CNState state1 = it->second; + int c1 = state1.first + state1.second; + logging += it->first + "":"" + std::to_string(state1.first) + "":"" + std::to_string(state1.second) + ""\t""; + + std::advance(it, 1); + + int s2 = (*clusterToIdx.find(it->first)).second; + CNState state2 = it->second; + int c2 = state2.first + state2.second; + logging += it->first + "":"" + std::to_string(state2.first) + "":"" + std::to_string(state2.second); + + log(logging, VERBOSITY_t::DEBUGGING, verbose); + + for(int p = 0; p < k; ++p) + { + double purity = (2.0 * R[s1][p] - 2.0 * R[s2][p]) / (2.0 * R[s1][p] - c2 * R[s1][p] - 2.0 * R[s2][p] + c1 * R[s2][p]); + if(1.0 <= purity && purity <= 1.05) + { + purity = 1.0; + } + if(-0.05 <= purity && purity <= 0.0) + { + purity = 0.0; + } + + cscale[p] = (2.0 - 2.0 * purity + purity * c1) / R[s1][p]; + + if(purity < 0 || purity > 1 || cscale[p] < 0) + { + throw ""The given copy-numbers do not allow to scale the read-depth ratios into corresponding fractional copy numbers, having RDRs of "" + std::to_string(R[s1][p]) + "" and "" + std::to_string(R[s2][p]) + ""!""; + } + } + + } else { + throw ""At least one clonal copy number should be provided!""; + } + + log(""Scaling factors:\n"" + toString(cscale), VERBOSITY_t::DEBUGGING, verbose); + + DoubleMatrix F(m); + for(int s = 0; s < m; ++s) + { + F[s] = DoubleArray(k); + for(int p = 0; p < k; ++p) + { + F[s][p] = R[s][p] * cscale[p]; + } + } + + return F; +} + + +void splitFractions(const DoubleMatrix &B, const DoubleMatrix &F, const int m, const int k, DoubleMatrix &FA, DoubleMatrix &FB) +{ + FA.clear(); + FB.clear(); + + FA = DoubleMatrix(m); + FB = DoubleMatrix(m); + for(int s = 0; s < m; ++s) + { + FA[s] = DoubleArray(k); + FB[s] = DoubleArray(k); + for(int p = 0; p < k; ++p) + { + FB[s][p] = B[s][p] * F[s][p]; + FA[s][p] = F[s][p] - FB[s][p]; + } + } +} + + +void printSolutions(const int k, const double obj, const IntMatrix& CA, const IntMatrix& CB, const DoubleMatrix& U) +{ + std::cout << ""Obj : "" << obj << std::endl; + std::cout << std::endl; + + for(int i = 0; i < CA[0].size(); ++i) + { + std::cout << ""Clone "" << i << "" : ""; + for(int s = 0; s < CA.size(); ++s) + { + std::cout << CA[s][i] << "":"" << CB[s][i] << "" ""; + } + std::cout << std::endl; + } + std::cout << std::endl; + + for(int p = 0; p < k; ++p) + { + std::cout << ""Sample "" << p << "": ""; + for(int i = 0; i < U.size(); ++i) + { + std::cout << U[i][p] << "" ""; + } + std::cout << std::endl; + } + std::cout << std::endl; +} + + +void printSolutions(const int k, const int numSolutions, const DoubleArray& obj, const Int3Matrix& CA, const Int3Matrix& CB, const Double3Matrix& U) +{ + for(int sol = 0; sol < numSolutions; ++sol) + { + std::cout << ""=== SOL: "" << sol+1 << std::endl; + printSolutions(k, obj[sol], CA[sol], CB[sol], U[sol]); + } +} + + +void segmentation(const InputInstance& instance, const BBCInstance& bbc, const int n, const IntMatrix& ACN, const IntMatrix& BCN, const DoubleMatrix& U, const std::string& outprefix, const VERBOSITY_t& verbosity) +{ + std::ofstream outbbc((outprefix + "".bbc.ucn.tsv"").c_str()); + outbbc << ""#CHR\tSTART\tEND\tSAMPLE\tRD\t#SNPS\tCOV\tALPHA\tBETA\tBAF\tCLUSTER""; + std::ofstream outseg((outprefix + "".seg.ucn.tsv"").c_str()); + outseg << ""#CHR\tSTART\tEND\tSAMPLE""; + outbbc << ""\tcn_normal"" << ""\tu_normal""; + outseg << ""\tcn_normal"" << ""\tu_normal""; + for(int i = 1; i < n; ++i) + { + outbbc << ""\tcn_clone"" << i << ""\tu_clone"" << i; + outseg << ""\tcn_clone"" << i << ""\tu_clone"" << i; + } + outbbc << std::endl; + outseg << std::endl; + + for(auto const& chr : bbc.chromosomes()) + { + size_t idx_chr = chr.second; + + std::vector supp; + for(auto const& mbin : bbc.bins()[idx_chr]) + { + supp.emplace_back(mbin.first.first, mbin.first.second); + } + std::sort(supp.begin(), supp.end(), [](const Bin& l, const Bin& r) {return l.first < r.first;}); + + long long start = supp[0].first; + long long end = supp[0].second; + IntArray previousA(n, -1); + IntArray previousB(n, -1); + bool first = true; + bool sameseg = true; + + for(auto const& bin : supp) + { + size_t idx_bin = bbc.bins()[idx_chr].at(bin); + for(auto const& sample : bbc.binsToSampleRdBaf()[idx_chr][idx_bin]) + { + std::string cluster = bbc.binsToCluster()[idx_chr][idx_bin]; + auto const& scab = bbc.binsToSampleSCAB()[idx_chr][idx_bin].at(sample.first); + outbbc << chr.first << '\t' << bin.first << '\t' << bin.second << '\t' << sample.first << '\t' << sample.second.first << '\t' << std::get<0>(scab) << '\t' << std::get<1>(scab) << '\t' << std::get<2>(scab) << '\t' << std::get<3>(scab) << '\t' << sample.second.second << '\t' << cluster; + for(int i = 0; i < n; ++i) + { + int s = instance.clusterToIdx().at(cluster); + outbbc << '\t' << ACN[s][i] << '|' << BCN[s][i]; + outbbc << '\t' << U[i][instance.sampleToIdx().at(sample.first)]; + } + outbbc << std::endl; + } + + for(int i = 0; i < n; ++i) + { + std::string cluster = bbc.binsToCluster()[idx_chr][idx_bin]; + int s = instance.clusterToIdx().at(cluster); + if(first) + { + first = false; + start = bin.first; + end = bin.second; + previousA.assign(ACN[s].begin(), ACN[s].end()); + previousB.assign(BCN[s].begin(), BCN[s].end()); + break; + } else if(ACN[s][i] != previousA[i] || BCN[s][i] != previousB[i] || bin.first != end) { + + sameseg = false; + for(auto const& sample : instance.samples()) + { + outseg << chr.first << '\t' << start << '\t' << end << '\t' << sample; + for(int i = 0; i < n; ++i) + { + outseg << '\t' << previousA[i] << '|' << previousB[i]; + outseg << '\t' << U[i][instance.sampleToIdx().at(sample)]; + } + outseg << std::endl; + } + start = bin.first; + end = bin.second; + previousA.assign(ACN[s].begin(), ACN[s].end()); + previousB.assign(BCN[s].begin(), BCN[s].end()); + break; + } + } + + if(sameseg) + { + end = bin.second; + } else { + sameseg = true; + } + } + + for(auto const& sample : instance.samples()) + { + outseg << chr.first << '\t' << start << '\t' << end << '\t' << sample; + for(int i = 0; i < n; ++i) + { + outseg << '\t' << previousA[i] << '|' << previousB[i]; + outseg << '\t' << U[i][instance.sampleToIdx().at(sample)]; + } + outseg << std::endl; + } + } + + outbbc.close(); + log(""A BBC file with inferred copy numbers and proportion have written in: "" + outprefix + "".bbc.ucn.tsv"", VERBOSITY_t::ESSENTIAL, verbosity); + outseg.close(); + log(""The tumor-clone segmented genomes with corresponding copy numbers have been written in: "" + outprefix + "".seg.ucn.tsv"", VERBOSITY_t::ESSENTIAL, verbosity); +} + + +CNMap getCNMap(const ArgParse& argparse, const InputInstance& instance) +{ + CNMap cnmap; + for(auto const& cn : argparse.cn()) + { + std::string cluster = cn.first; + if(instance.clusters().find(cluster) == instance.clusters().end()) + { + throw ""The cluster with ID "" + cluster + "" specified in the input arguments has not been found in the input seg file!""; + } + + int idx = instance.clusterToIdx().at(cluster); + cnmap.emplace(idx, CNState(cn.second.first, cn.second.second)); + } + return cnmap; +} + +std::string printFractions(const DoubleMatrix &F, const InputInstance &instance) +{ + std::stringstream s; + for(DoubleMatrix::const_iterator it = F.begin(); it != F.end(); ++it) + { + s << instance.idxToCluster().at(std::distance(F.begin(), it)) << "" : ""; + for(DoubleArray::const_iterator itt = (*it).begin(); itt != (*it).end(); ++itt) + { + s << (*itt) << "" ""; + } + s << std::endl; + } + return s.str(); +} +","C++" +"Allele","raphael-group/hatchet","src/utils.cpp",".cpp","6284","274","#include ""utils.h"" + +std::mt19937_64 g_rng; +std::mutex g_mutex; +std::mutex g_output_mutex; + +int countElements(const IntMatrix arg) +{ + int res = 0; + for(IntMatrix::const_iterator it = arg.begin(); + it != arg.end(); + ++it) + { + res += (*it).size(); + } + return res; +} + +int countElements(const Int3Matrix arg) +{ + int res = 0; + for(Int3Matrix::const_iterator it = arg.begin(); + it != arg.end(); + ++it) + { + res += countElements(*it); + } + return res; +} + +int countElements(const Int4Matrix arg) +{ + int res = 0; + for(Int4Matrix::const_iterator it = arg.begin(); + it != arg.end(); + ++it) + { + res += countElements(*it); + } + return res; +} + +int countElements(const DoubleMatrix arg) +{ + int res = 0; + for(DoubleMatrix::const_iterator it = arg.begin(); + it != arg.end(); + ++it) + { + res += (*it).size(); + } + return res; +} + +int countElements(const Double3Matrix arg) +{ + int res = 0; + for(Double3Matrix::const_iterator it = arg.begin(); + it != arg.end(); + ++it) + { + res += countElements(*it); + } + return res; +} + +int countElements(const Double4Matrix arg) +{ + int res = 0; + for(Double4Matrix::const_iterator it = arg.begin(); + it != arg.end(); + ++it) + { + res += countElements(*it); + } + return res; +} + +int sum_of_elements(const IntArray arg) +{ + int sum = 0; + for(IntArray::const_iterator it = arg.begin(); + it != arg.end(); + ++it) + { + sum += *it; + } + return sum; +} + +std::string timestamp() +{ + time_t now = time(NULL); + struct tm tstruct; + char buf[40]; + tstruct = *localtime(&now); + //format: HH:mm:ss + strftime(buf, sizeof(buf), ""[%X]"", &tstruct); + return buf; + // std::stringstream ss; + // std::chrono::system_clock::time_point now = std::chrono::system_clock::now(); + // std::time_t now_c = std::chrono::system_clock::to_time_t(now - std::chrono::hours(24)); + // ss << std::put_time(std::localtime(&now_c), ""[%F %T]""); + // return ss.str(); + //std::time_t result = std::time(nullptr); + //return std::asctime(std::localtime(&result)); + /** + time_facet *facet = new time_facet(""%d-%b-%Y %H:%M:%S""); + out.imbue(locale(out.getloc(), facet)); + out << ""["" << second_clock::local_time() << ""]""; + **/ +} + +void log(const std::string& msg, const VERBOSITY_t lb, const VERBOSITY_t curr) +{ + if(curr >= lb) {std::cerr << ((lb == VERBOSITY_t::ESSENTIAL) ? ""\033[95m\033[1m"" + timestamp() + ""### "" : + (lb == VERBOSITY_t::VERBOSE) ? ""\033[92m""+ timestamp() + ""## "" : + ""\033[96m# "") << msg << ""\t\033[0m"" << std::endl;} +} + +void warning(const std::string& msg) +{ + std::cerr << ""\033[93m\033[1m"" << timestamp() << ""### "" << msg << ""\t\033[0m"" << std::endl; +} + + +bool getBit(const int num, const int pos) +{ + return (num >> pos) & 1; +} + + +void split(const std::string &s, const char d, std::vector &out) +{ + std::stringstream ss(s); + std::string item; + while (std::getline(ss, item, d)) { + if(!item.empty()) + { + out.push_back(item); + } + } +} + + +std::vector split(const std::string &s, const char d) +{ + std::vector tokens; + split(s, d, tokens); + return tokens; +} + + +std::string rtrim(const std::string &s) +{ + return std::string(s).erase(s.find_last_not_of("" \t\n\r\f\v"") + 1); +} + + +std::string ltrim(const std::string &s) +{ + return std::string(s).erase(0, s.find_first_not_of("" \t\n\r\f\v"")); +} + + +std::string trim(const std::string &s) +{ + std::string res(s); + res.erase(std::remove(res.begin(), res.end(), ' '), res.end()); + res.erase(std::remove(res.begin(), res.end(), '\t'), res.end()); + res.erase(std::remove(res.begin(), res.end(), '\n'), res.end()); + return res; +} + +IntArray sort_indexes(const IntArray &v) { + + // initialize original index locations + IntArray idx(v.size()); + std::iota(idx.begin(), idx.end(), 0); + + // sort indexes based on comparing values in v + std::sort(idx.begin(), idx.end(), + [&v](size_t i1, size_t i2) {return v[i1] < v[i2];}); + + return idx; +} + +DoubleMatrix transpose(const DoubleMatrix &M) +{ + DoubleMatrix T(M[0].size(), DoubleArray(M.size(), 0.0)); + for(int i = 0; i < M.size(); ++i) + { + for(int j = 0; j < M[i].size(); ++j) + { + T[j][i] = M[i][j]; + } + } + return T; +} + +std::string toString(const IntArray &M) +{ + std::stringstream s; + for(IntArray::const_iterator it = M.begin(); it != M.end(); ++it) + { + s << (*it) << "" ""; + } + s << std::endl; + return s.str(); +} + +std::string toString(const DoubleArray &M) +{ + std::stringstream s; + for(DoubleArray::const_iterator it = M.begin(); it != M.end(); ++it) + { + s << (*it) << "" ""; + } + s << std::endl; + return s.str(); +} + +std::string toString(const IntMatrix &M) +{ + std::stringstream s; + for(IntMatrix::const_iterator it = M.begin(); it != M.end(); ++it) + { + for(IntArray::const_iterator itt = (*it).begin(); itt != (*it).end(); ++itt) + { + s << (*itt) << "" ""; + } + s << std::endl; + } + return s.str(); +} + +std::string toString(const DoubleMatrix &M) +{ + std::stringstream s; + for(DoubleMatrix::const_iterator it = M.begin(); it != M.end(); ++it) + { + for(DoubleArray::const_iterator itt = (*it).begin(); itt != (*it).end(); ++itt) + { + s << (*itt) << "" ""; + } + s << std::endl; + } + return s.str(); +} + +int maxCeil(const DoubleMatrix &M) +{ + int max = (int)M[0][0]; + for(DoubleMatrix::const_iterator it = M.begin(); it != M.end(); ++it) + { + for(DoubleArray::const_iterator itt = (*it).begin(); itt != (*it).end(); ++itt) + { + max = std::max((int)std::ceil(*itt), max); + } + } + return max; +} + +std::string base_name(std::string const& path) +{ + return path.substr(path.find_last_of(""/\\"") + 1); +} + +std::string remove_extension(std::string const& filename) +{ + typename std::string::size_type const p(filename.find_last_of('.')); + return p > 0 && p != std::string::npos ? filename.substr(0, p) : filename; +} +","C++" +"Allele","raphael-group/hatchet","src/ilp-min.h",".h","6398","216","#ifndef ILPSUBSET_H +#define ILPSUBSET_H + +#include ""utils.h"" +#include ""gurobi-utils.h"" +#include + +class IlpSubset +{ + +public: + + IlpSubset(const int n, + const int m, + const int k, + const int maxc, + const int d, + const double mu, + const int base, + const bool ampdel, + const CNMap& cn, + const DoubleMatrix& FA, + const DoubleMatrix& FB, + const DoubleArray& w, + const VERBOSITY_t v); + + + void fixC(const IntMatrix& barCA, const IntMatrix& barCB); + + void fixU(const DoubleMatrix& barU) + { + _barU = barU; + _mode = MODE_t::CARCH; + for(int p = 0; p < _k; ++p) + { + double sum = 0.0; + for(int i = 0; i < _n; ++i) + { + sum += barU[i][p]; + assert( (0.0 - TOL <= barU[i][p] && barU[i][p] <= 0.0 + TOL) || (barU[i][p] >= _mu - TOL) || i == 0); + } + assert(sum >= 1.0 - TOL && sum <= 1.0 + TOL); + } + } + + void init(); + + void hotStart(const IntMatrix& hCA, const IntMatrix& hCB); + + int solve(const int timeLimit, const int memoryLimit, const int nrThreads); + int solve(const int timeLimit, const int memoryLimit, const int nrThreads, const int maxIter); + + void exportModel(const std::string& filename); + + DoubleArray getObjs() + { + return _objs; + } + Int3Matrix getACNs() + { + return _CAs; + } + Int3Matrix getBCNs() + { + return _CBs; + } + Double3Matrix getUs() + { + return _Us; + } + + double runtime() + { + return _model.get(GRB_DoubleAttr_Runtime); + } + + double gap() + { + return _model.get(GRB_DoubleAttr_MIPGap); + } + + double LB() + { + return _model.get(GRB_DoubleAttr_LB); + } + + double UB() + { + return _model.get(GRB_DoubleAttr_UB); + } + + void printValues(); + + static std::pair firstHotStart(const DoubleMatrix &FA, const DoubleMatrix &FB, const int m, const int k, const int n, + const int cmax, const int d, const int base, const bool ampdel, const CNMap& cn); + +private: + + /// Build main common variables + void buildVariables(); + /// Build the variables that depend on the chosen second objective + void buildOptionalVariables(); + /// Build main common constraints + void buildConstraints(); + /// Build the constraints that depend on the chosen second objective + void buildOptionalConstraints(); + /// Build the constraints used to break the symmetry by avoid permutations of non-null columns + void buildSymmetryBreaking(); + /// + void fixGivenCN(); + /// Build objective + void buildObjective(); + /// Add the constraint to avoid current solution and to find the next one + void buildNext(); + /// Set specific values of variables for testing + void test(); + /// Extract from current solution the values of the variables corresponding to copy numbers of clones + IntMatrix getCA(); + /// Extract from current solution the values of the variables corresponding to B-allele copy numbers of clones + IntMatrix getCB(); + /// Extract from current solution the values of the variables corresponding to the proportions + DoubleMatrix getU(); + /// + bool checkRank(const IntMatrix &hCA, const IntMatrix &hCB, const IntArray &map); + /// + double symmCoeff(const int index); + + /// Number of clones + const int _n; + /// Number of total segments + const int _m; + /// Number of samples + const int _k; + /// Maximum copy number + const int _cmax; + /// Maximum number of distinct copy-number states + const int _d; + /// + const double _mu; + /// + const int _base; + /// + const bool _ampdel; + /// + const CNMap& _cn; + /// Read depth ratio r_{t, p} for each segment t in each sample p + const DoubleMatrix& _FA; + /// B-allele frequency d_{t, p} for each segment t in each sample p + const DoubleMatrix& _FB; + /// + const DoubleArray& _w; + /// + const VERBOSITY_t _v; + /// + IntMatrix _barCA; + /// + IntMatrix _barCB; + /// + DoubleMatrix _barU; + /// + MODE_t _mode; + /// Maximum B-allele copy number + const int _M; + + /// Gurobi environment + GRBEnv _env; + /// Gurobi model + GRBModel _model; + /// Variable yA[s][p] is the error between observed and estimated fractional A-allele copy number of segment s in sample p + VarMatrix _yA; + /// Variable yB[s][p] is the error between observed and estimated fractional B-allele copy number of segment s in sample p + VarMatrix _yB; + /// Variable fA[t][p] is the fractional A-allele copy number of chosen segment t in sample p + VarMatrix _fA; + /// Variable fB[t][p] is the fractional B-allele copy number of chosen segment t in sample p + VarMatrix _fB; + /// Variable cA[t][i] is the integer A-allele copy number of the chosen segment t in clone i + VarMatrix _cA; + /// Variable cB[t][i] is the integer B-allele copy number of the chosen segment t in clone i + VarMatrix _cB; + /// Variable cA[b][t][i] is the b-th bit in the binary representation of cA[t][i] + Var3Matrix _bitcA; + /// Variable cB[b][t][i] is the b-th bit in the binary representation of cB[t][i] + Var3Matrix _bitcB; + /// Variable u[i][p] is the proportion of clone i in sample p + VarMatrix _u; + /// + VarMatrix _x; + /// + VarArray _adA; + /// + VarArray _adB; + /// Variable z[b][t][i][p] is the product between c[b][t][i] and u[i][p] + Var4Matrix _vA; + /// Variable zB[b][t][i][p] is the product between cB[b][t][i] and u[i][p] + Var4Matrix _vB; + /// + Var3Matrix _z; + /// Variable barcA[b][t][i][j] = 1 iff _cA[b][t][i] and _cA[b][t][j] are different + Var4Matrix _barcIJA; + /// Variable barcB[b][t][i][j] = 1 iff _cB[b][t][i] and _cB[b][t][j] are different + Var4Matrix _barcIJB; + + /// Objective value for each found solution + DoubleArray _objs; + /// Integer A-allele copy numbers of the clones for each solution + Int3Matrix _CAs; + /// Integer B-allele copy numbers of the clones for each solution + Int3Matrix _CBs; + /// Proportions of the clones in the samples for each solution + Double3Matrix _Us; + +}; + +#endif // ILPSUBSET_H +","Unknown" +"Allele","raphael-group/hatchet","src/coordinate_descent.h",".h","2920","132","#ifndef _COORDINATE_H_ +#define _COORDINATE_H_ + +#include ""utils.h"" +#include ""worker.h"" + + +class CoordinateDescent +{ +public: + CoordinateDescent(const DoubleMatrix& FA, + const DoubleMatrix& FB, + const DoubleArray& bins, + const int m, + const int k, + const int n, + const int cmax, + const int d, + const double mu, + const int base, + const bool ampdel, + const CNMap& cn, + const unsigned int iterConvergence, + const unsigned int maxIter, + const int nrSeeds, + const int nrWorkers, + const int nrILPthreads, + const int timeLimit, + const int memoryLimit, + const VERBOSITY_t v); + +public: + /// Run the method + void run(); + /// Get best objective value + double getObjValue() const + { + return _objs[_best]; + } + + IntMatrix getACN() const + { + return _CAs[_best]; + } + + IntMatrix getBCN() const + { + return _CBs[_best]; + } + + DoubleMatrix getU() const + { + return _Us[_best]; + } + +private: + /// + const DoubleMatrix& _FA; + /// + const DoubleMatrix& _FB; + /// + const DoubleArray& _bins; + /// + const int _m; + /// + const int _k; + /// Number of clones + const int _n; + /// + const int _cmax; + /// + const int _d; + /// + const double _mu; + /// + const int _base; + /// + const bool _ampdel; + /// + const CNMap& _cn; + /// Number of iterations for checking convergence + const unsigned int _iterConvergence; + /// Maximum number of iterations for each seed + const unsigned int _maxIter; + /// Number of seeds + const int _nrSeeds; + /// Number of workers + const int _nrWorkers; + /// Number of LPthreads + const int _nrILPthreads; + /// Time limit (seconds) + const int _timeLimit; + /// Memory limit (MB) + const int _memoryLimit; + + /// Dirichlet parameter for generating initial M + int _sizeBubbles; + /// All initial seeds + Double3Matrix _seeds; + /// + int _seedidx; + /// Thread group + std::vector _threads; + /// Mutex + std::mutex _mutexTasks; + /// Mutex + std::mutex _mutexResults; + /// + DoubleArray _objs; + /// + Int3Matrix _CAs; + /// + Int3Matrix _CBs; + /// + Double3Matrix _Us; + /// + int _best; + /// + const VERBOSITY_t _v; + + /// Construct random M + DoubleMatrix buildRandomU(); + /// Construct random vector summing up to 1 + DoubleArray buildPartitionVector(const int num_parts); + /// + void runWorker(); + /// + void runInstance(const int seedIdx); +}; + +#endif // _COORDINATE_H_ +","Unknown" +"Allele","raphael-group/hatchet","src/input_instance.h",".h","2208","102","#ifndef _INPUTINSTANCE_H_ +#define _INPUTINSTANCE_H_ + +#include ""utils.h"" + + +class InputInstance +{ + +public: + InputInstance(); + + friend std::ostream& operator<<(std::ostream& out, const InputInstance& instance); + friend std::istream& operator>>(std::istream& in, InputInstance& instance); + + int m() const + { + return _m; + } + + int k() const + { + return _k; + } + + const DoubleMatrix& R() const + { + return _R; + } + + const DoubleMatrix& B() const + { + return _B; + } + + const DoubleArray& w() const + { + return _w; + } + + const std::set& clusters() const + { + return _clusters; + } + + const std::map& clusterToIdx() const + { + return _clusterToIdx; + } + + const std::map& idxToCluster() const + { + return _idxToCluster; + } + + const std::set& samples() const + { + return _samples; + } + + const std::map& sampleToIdx() const + { + return _sampleToIdx; + } + + const std::map& idxToSample() const + { + return _idxToSample; + } + + +private: + /// Number of segmental clusters + int _m; + /// Number of samples + int _k; + /// Read-depth ratios F[s][p] for each segmental cluster s in sample p + DoubleMatrix _R; + /// B-Allele frequency B[s][p] for each segmental cluster s in sample p + DoubleMatrix _B; + /// Bin size w[s] for each segmental cluster s + DoubleArray _w; + /// IDs of input segmental clusters + std::set _clusters; + /// Map cluster to corresponding index + std::map _clusterToIdx; + /// Map index to corresponding cluster + std::map _idxToCluster; + /// Names of input samples + std::set _samples; + /// Map sample to corresponding index + std::map _sampleToIdx; + /// Map index to corresponding sample + std::map _idxToSample; + +}; + +std::ostream& operator<<(std::ostream& out, const InputInstance& instance); +std::istream& operator>>(std::istream& in, InputInstance& instance); + +#endif // _INPUTINSTANCE_H_ +","Unknown" +"Allele","raphael-group/hatchet","src/input_instance.cpp",".cpp","3110","103","#include ""input_instance.h"" + + +InputInstance::InputInstance() + : _m(-1) + , _k(-1) + , _R() + , _B() + , _w() + , _clusters() + , _clusterToIdx() + , _idxToCluster() + , _samples() + , _sampleToIdx() + , _idxToSample() +{ +} + + +std::ostream& operator<<(std::ostream& out, const InputInstance& instance) +{ + out << ""#PARAMS"" << std::endl; + out << instance._m << ""# number of segmental clusters"" << std::endl; + out << instance._k << ""# number of samples"" << std::endl; + out << ""#ID\tSAMPLE\t#BINS\tRD\tBAF"" << std::endl; + for(int s = 0; s < instance._m; ++s) + { + for(int p = 0; p < instance._k; ++p) + { + out << instance._idxToCluster.find(s)->second << ""\t"" << instance._idxToSample.find(p)->second << ""\t"" << instance._w[s] << ""\t"" << instance.R()[s][p] << ""\t"" << instance.B()[s][p] << std::endl; + } + } + return out; +}; + + + +std::istream& operator>>(std::istream& in, InputInstance& instance) +{ + instance._R.clear(); + instance._B.clear(); + + std::string line; + std::vector tokens; + + std::vector> keys; + std::vector> values; + + while(!in.eof()) + { + std::getline(in, line, '\n'); + if(!line.empty() && line[0] != '#') + { + std::replace(line.begin(), line.end(), '\t', ' '); + tokens = split(rtrim(ltrim(line)), ' '); + + std::string cluster(tokens[0]); + if(instance._clusters.find(cluster) == instance._clusters.end()) + { + int idx_cluster = instance._clusters.size(); + instance._clusters.insert(cluster); + instance._clusterToIdx[cluster] = idx_cluster; + instance._idxToCluster[idx_cluster] = cluster; + double w = std::atoi(tokens[2].c_str()); + instance._w.push_back(w); + assert(idx_cluster + 1 == instance._w.size()); + } + + std::string sample(tokens[1]); + if(instance._samples.find(sample) == instance._samples.end()) + { + int idx_sample = instance._samples.size(); + instance._samples.insert(sample); + instance._sampleToIdx[sample] = idx_sample; + instance._idxToSample[idx_sample] = sample; + } + + double rd = std::atof(tokens[3].c_str()); + double baf = std::atof(tokens[8].c_str()); + + keys.push_back(std::make_pair(cluster, sample)); + values.push_back(std::make_pair(rd, baf)); + } + } + + instance._m = instance._clusters.size(); + instance._k = instance._samples.size(); + + instance._R = DoubleMatrix(instance._m, DoubleArray(instance._k, 0.0)); + instance._B = DoubleMatrix(instance._m, DoubleArray(instance._k, 0.0)); + + for(int i = 0; i < keys.size(); ++i) + { + int s = instance._clusterToIdx[keys[i].first]; + int p = instance._sampleToIdx[keys[i].second]; + + instance._R[s][p] = values[i].first; + instance._B[s][p] = values[i].second; + } + + return in; +}; +","C++" +"Allele","raphael-group/hatchet","src/hatchet/__init__.py",".py","585","17","__version__ = ""2.1.0"" + +import os.path +from importlib.resources import path +import hatchet +from hatchet.utils.config import Config + + +with path(hatchet, ""hatchet.ini"") as ini_file: + filenames = [ini_file] + # If a hatchet.ini file exists where we were imported from, use it after the pre-packaged .ini file + # This allows overriding of values without having to alter the pre-packaged .ini file, which may + # be buried deep inside the site-packages folder. + if os.path.exists(""hatchet.ini""): + filenames.append(""hatchet.ini"") + config = Config(""hatchet"", filenames) +","Python" +"Allele","raphael-group/hatchet","src/hatchet/__main__.py",".py","2330","65",""""""" +The HATCHet package can be run as a module by invoking it as: +python -m hatchet .. +"""""" + +import sys +import warnings +import hatchet + +from hatchet.utils.commands import commands, command_aliases + +from hatchet.utils.count_reads import main as count_reads # noqa: F401 +from hatchet.utils.count_reads_fw import main as count_reads_fw # noqa: F401 +from hatchet.utils.genotype_snps import main as genotype_snps # noqa: F401 +from hatchet.utils.count_alleles import main as count_alleles # noqa: F401 +from hatchet.utils.combine_counts import main as combine_counts # noqa: F401 +from hatchet.utils.combine_counts_fw import main as combine_counts_fw # noqa: F401 +from hatchet.utils.cluster_bins_gmm import main as cluster_bins_gmm # noqa: F401 +from hatchet.utils.cluster_bins import main as cluster_bins # noqa: F401 + +from hatchet.utils.plot_bins import main as plot_bins # noqa: F401 +from hatchet.utils.plot_bins_1d2d import main as plot_bins_1d2d # noqa: F401 +from hatchet.bin.HATCHet import main as compute_cn # noqa: F401 +from hatchet.utils.plot_cn import main as plot_cn # noqa: F401 +from hatchet.utils.plot_cn_1d2d import main as plot_cn_1d2d # noqa: F401 + +from hatchet.utils.run import main as run # noqa: F401 +from hatchet.utils.download_panel import main as download_panel # noqa: F401 +from hatchet.utils.phase_snps import main as phase_snps # noqa: F401 + +from hatchet.utils.check import main as check # noqa: F401 + + +def print_usage(): + print(""HATCHet v"" + hatchet.__version__) + print(""Usage: hatchet "") + print(""\nThe following commands are supported:\n "" + ""\n "".join(commands)) + + +def main(): + if len(sys.argv) < 2: + print_usage() + sys.exit(0) + + command = sys.argv[1] + args = sys.argv[2:] + + if command in command_aliases: + msg = ( + f'The HATCHet command ""{command}"" has been replaced by ""{command_aliases[command]}"" and will be absent in ' + f""future releases. Please update your scripts accordingly."" + ) + warnings.warn(msg, FutureWarning) + elif command not in commands: + print_usage() + sys.exit(1) + + command = command_aliases.get(command, command) + command = command.replace(""-"", ""_"") + globals()[command](args) + + +if __name__ == ""__main__"": + sys.exit(main()) +","Python" +"Allele","raphael-group/hatchet","src/hatchet/bin/HATCHet.py",".py","66814","1998","import os +import sys +import argparse +import shutil +import subprocess +import shlex +from collections import Counter + +import hatchet +from hatchet import config, __version__ +from hatchet.utils.Supporting import ensure, log, error +from hatchet.utils.solve import solve +from hatchet.utils.solve.utils import segmentation + + +def parsing_arguments(args=None): + """""" + Parse command line arguments + Returns: + """""" + description = """" + parser = argparse.ArgumentParser( + prog=""hatchet compute-cn"", + description=description, + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + ""SOLVER"", type=str, nargs=""?"", help=""Path to the executable solver"" + ) + parser.add_argument( + ""-i"", + ""--input"", + type=str, + required=True, + help=""Prefix path to seg and bbc input files (required)"", + ) + parser.add_argument( + ""-x"", + ""--runningdir"", + type=str, + required=False, + default=config.compute_cn.runningdir, + help=""Running directory (default: ./)"", + ) + parser.add_argument( + ""-n"", + ""--clones"", + type=str, + required=False, + default=config.compute_cn.clones, + help=( + ""Either an estimated number of clones or an interval where the\nnumber of clones should be looked for "" + ""given in the form LOWER,UPPER where LOWER and UPPER are two integer defining the interval "" + ""(default: 2,8)"" + ), + ) + parser.add_argument( + ""-f"", + ""--noampdel"", + action=""store_true"", + default=config.compute_cn.noampdel, + required=False, + help=( + ""Remove amp-del assumption where each mutated allele of every segment can be either amplified or "" + ""deleted in all tumor clones w.r.t. base (2 for diploid and 4 for tetraploid) (default: use assumption)"" + ), + ) + parser.add_argument( + ""-c"", + ""--clonal"", + type=str, + required=False, + default=config.compute_cn.clonal, + help=""Clonal clusters to fix for tetraploid (default: automatically inferred)"", + ) + parser.add_argument( + ""-d"", + ""--cnstates"", + type=int, + required=False, + default=config.compute_cn.cnstates, + help=""Maximum number of distinct copy-number states for each segment (default: None, no limit)"", + ) + parser.add_argument( + ""-eD"", + ""--diploidcmax"", + type=int, + required=False, + default=config.compute_cn.diploidcmax, + help=( + ""Maximum copy-number value overall segments (default: 6, 0 means inferred from scaled fractional copy "" + ""numbers)"" + ), + ) + parser.add_argument( + ""-eT"", + ""--tetraploidcmax"", + type=int, + required=False, + default=config.compute_cn.tetraploidcmax, + help=( + ""Maximum copy-number value overall segments (default: 12, 0 means inferred from scaled fractional "" + ""copy numbers)"" + ), + ) + parser.add_argument( + ""-ts"", + ""--minsize"", + type=float, + required=False, + default=config.compute_cn.minsize, + help=""The minimum proportion of covered genome for potential clonal clusters (default: 0.008)"", + ) + parser.add_argument( + ""-tc"", + ""--minchrs"", + type=int, + required=False, + default=config.compute_cn.minchrs, + help=""The minimum number of covered chromosomes for potential clonal clusters (default: 1)"", + ) + parser.add_argument( + ""-td"", + ""--maxneutralshift"", + type=float, + required=False, + default=config.compute_cn.maxneutralshift, + help=( + ""Maximum BAF shift for neutral cluster used to automatically infer the diploid/tetraploid cluster "" + ""(default: 0.1)"" + ), + ) + parser.add_argument( + ""--merge"", + action=""store_true"", + default=config.compute_cn.merge, + required=False, + help=""Merge the clusters (default: false)"", + ) + parser.add_argument( + ""-mR"", + ""--mergeRDR"", + type=float, + required=False, + default=config.compute_cn.mergerdr, + help=""RDR tolerance used for finding the clonal copy numbers (default: 0.08)"", + ) + parser.add_argument( + ""-mB"", + ""--mergeBAF"", + type=float, + required=False, + default=config.compute_cn.mergebaf, + help=""BAF tolerance used for finding the clonal copy numbers (default: 0.04)"", + ) + parser.add_argument( + ""-l"", + ""--limitinc"", + type=float, + required=False, + default=config.compute_cn.limitinc, + help=( + ""Upper bound to the relative increase of objective function. When there are significant small CNAs, "" + ""their effect on the objective function may be confounded by only larger events, use this value to "" + ""limit the relative increase of OBJ so that fitting small CNAs is more considered (default: None)"" + ), + ) + parser.add_argument( + ""-g"", + ""--ghostprop"", + type=float, + required=False, + default=config.compute_cn.ghostprop, + help=( + ""Increasing proportion used to compute the value of the first ghost point added in the solution "" + ""selection (default: 0.3)"" + ), + ) + parser.add_argument( + ""-tR"", + ""--toleranceRDR"", + type=float, + required=False, + default=config.compute_cn.tolerancerdr, + help=""RDR tolerance used for finding the clonal copy numbers (default: 0.08)"", + ) + parser.add_argument( + ""-tB"", + ""--toleranceBAF"", + type=float, + required=False, + default=config.compute_cn.tolerancebaf, + help=""BAF tolerance used for finding the clonal copy numbers (default: 0.04)"", + ) + parser.add_argument( + ""-p"", + ""--seeds"", + type=int, + required=False, + default=config.compute_cn.seeds, + help=""Number of seeds for coordinate-descent method (default: 400)"", + ) + parser.add_argument( + ""-j"", + ""--jobs"", + type=int, + required=False, + default=config.compute_cn.jobs, + help=""Number of parallel jobs (default: maximum available on the machine)"", + ) + parser.add_argument( + ""-r"", + ""--randomseed"", + type=int, + required=False, + default=config.compute_cn.randomseed, + help=""Random seed (default: None)"", + ) + parser.add_argument( + ""-s"", + ""--timelimit"", + type=int, + required=False, + default=config.compute_cn.timelimit, + help=""Time limit for each ILP run (default: None)"", + ) + parser.add_argument( + ""-m"", + ""--memlimit"", + type=int, + required=False, + default=config.compute_cn.memlimit, + help=""Memory limit for each ILP run (default: None)"", + ) + parser.add_argument( + ""-u"", + ""--minprop"", + type=float, + required=False, + default=config.compute_cn.minprop, + help=""Minimum clone proporion in each sample (default: 0.03)"", + ) + parser.add_argument( + ""--maxiterations"", + type=int, + required=False, + default=config.compute_cn.maxiterations, + help=""Maximum number of iterations composed of C-step/U-step for each seed (default: 10)"", + ) + parser.add_argument( + ""--mode"", + type=int, + required=False, + default=config.compute_cn.mode, + help=( + ""Solving mode among: Coordinate Descent + exact ILP (0), exact ILP only (1), and Coordinate-descent "" + ""only (2) (default: 2)"" + ), + ) + parser.add_argument( + ""--diploid"", + action=""store_true"", + default=config.compute_cn.diploid, + required=False, + help=""Force the tumor clones to be diploid without WGD (default: false)"", + ) + parser.add_argument( + ""--tetraploid"", + action=""store_true"", + default=config.compute_cn.tetraploid, + required=False, + help=""Force the tumor clones to be tetraploid with an occured WGD (default: false)"", + ) + parser.add_argument( + ""-v"", + ""--verbosity"", + type=int, + required=False, + default=config.compute_cn.verbosity, + help=""Level of verbosity among: none (0), essential (1), verbose (2), and debug (3) (default: 1)"", + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + parser.add_argument( + ""-b"", + ""--binwise"", + action=""store_true"", + default=config.compute_cn.binwise, + required=False, + help=( + ""Use bin-wise objective function which requires more variables and constraints but accounts for cluster "" + ""variances (default False). Only works with non-cpp solvers."" + ), + ) + parser.add_argument( + ""-P"", + ""--purities"", + type=str, + default=config.run.purities, + required=False, + help=""To fix purities for each sample, pass a space-separated list of purities"", + ) + args = parser.parse_args(args) + + if config.compute_cn.solver == ""cpp"": + if args.SOLVER is None: + args.SOLVER = os.path.join(os.path.dirname(hatchet.__file__), ""solve"") + if not os.path.isfile(args.SOLVER): + raise ValueError(error(""Solver not found in {}!"".format(args.SOLVER))) + + if config.compute_cn.solver == ""cpp"" and args.binwise: + raise ValueError( + error( + ""The bin-wise objective is not supported for the solver 'cpp'. Please use a pyomo solver."" + ) + ) + + clusters = args.input + "".seg"" + if not os.path.isfile(clusters): + raise ValueError(error(""SEG file {} not found!"".format(clusters))) + bbc = args.input + "".bbc"" + if not os.path.isfile(bbc): + raise ValueError(error(""BBC file {} not found!"".format(bbc))) + + if args.clones.isdigit(): + ln = int(args.clones) + un = int(args.clones) + else: + parsed = args.clones.split("","") + if len(parsed) != 2 or not parsed[0].isdigit() or not parsed[1].isdigit(): + raise ValueError(error(""Wrong format for interval of clone numbers!"")) + else: + ln = int(parsed[0]) + un = int(parsed[1]) + if ln < 2: + raise ValueError( + error( + ""The lower bound in the number of clones must be greater or equal than 2!"" + ) + ) + + if args.cnstates is not None and args.cnstates <= 0: + raise ValueError( + error( + ""The maximum number of copy-number states should be default None or a positive non-zero integer!"" + ) + ) + if args.diploidcmax == 0: + args.diploidcmax = None + if args.diploidcmax is not None and args.diploidcmax <= 0: + raise ValueError( + error(""The maximum diploid copy number a positive non-zero integer!"") + ) + if args.tetraploidcmax == 0: + args.tetraploidcmax = None + if args.tetraploidcmax is not None and args.tetraploidcmax <= 0: + raise ValueError( + error(""The maximum tetraploid copy number a positive non-zero integer!"") + ) + if args.minsize < 0.0 or args.minsize > 1.0: + raise ValueError( + error( + ""The genome-size proportions for potential clonal clusters must be in [0, 1]!"" + ) + ) + if args.minchrs < 0 or args.minchrs > 22: + raise ValueError( + error( + ""The number of chromosomes for potential clonal clusters must be in {0, .., 22}!"" + ) + ) + if args.maxneutralshift < 0.0 or args.maxneutralshift > 1.0: + raise ValueError( + error(""The maximum BAF shift for neutral cluster must be in [0, 1]!"") + ) + if args.toleranceRDR < 0.0 or args.toleranceRDR > 1.0: + raise ValueError( + error( + ""The RDR tolerance for finding clonal copy numbers must be in [0, 1]!"" + ) + ) + if args.toleranceBAF < 0.0 or args.toleranceBAF > 1.0: + raise ValueError( + error( + ""The BAF tolerance for finding clonal copy numbers must be in [0, 1]!"" + ) + ) + if args.mergeRDR < 0.0 or args.mergeRDR > 1.0: + raise ValueError( + error(""The RDR tolerance for merging clusters must be in [0, 1]!"") + ) + if args.mergeBAF < 0.0 or args.mergeBAF > 1.0: + raise ValueError( + error(""The BAF tolerance for merging clusters must be in [0, 1]!"") + ) + if args.limitinc is not None and (args.limitinc < 0.0 or args.limitinc > 1.0): + raise ValueError(error(""The increasing limit must be in [0, 1]!"")) + if args.ghostprop < 0.0 or args.ghostprop > 1.0: + raise ValueError( + error(""The increasing proportion of the ghost point must be in [0, 1]!"") + ) + if args.seeds <= 0: + raise ValueError( + error(""The number of seeds should be a positive non-zero integer"") + ) + if args.jobs is not None and args.jobs <= 0: + raise ValueError( + error(""The number of jobs should be a positive non-zero integer"") + ) + if args.randomseed is not None and args.randomseed <= 0: + raise ValueError( + error( + ""The random seed should be a positive non-zero integer or default None!"" + ) + ) + if args.timelimit is not None and args.timelimit <= 0: + raise ValueError( + error( + ""The time limit should be a positive non-zero integer or default None!"" + ) + ) + if args.memlimit is not None and args.memlimit <= 0: + raise ValueError( + error( + ""The memory limit should be a positive non-zero integer or default None!"" + ) + ) + if args.minprop is not None and (args.minprop < 0 or args.minprop > 0.3): + raise ValueError( + error(""The minimum proportion of clones on each sample must be in [0, 0.3]"") + ) + if args.maxiterations is not None and args.maxiterations < 0: + raise ValueError(error(""The max-iteration number must be a positive integer!"")) + ensure(args.mode in (None, 0, 1, 2), ""The mode integer must be in (0, 1, 2)!"") + + if args.diploid and args.tetraploid: + raise ValueError( + error(""Diploid and tetraploid cannot be forced at the same time!"") + ) + + if not os.path.isdir(args.runningdir): + raise ValueError(error(""Running directory not found!"")) + if not 0 <= args.verbosity <= 3: + raise ValueError(error(""The verbosity level must be a value within 0,1,2,3!"")) + if args.purities != ""None"": + args.purities = [float(p) for p in args.purities.split()] + for p in args.purities: + if not 0 <= float(p) <= 1: + raise ValueError( + error(""One of the purities given is not between 0 and 1!"") + ) + else: + args.purities = None + + return { + ""solver"": args.SOLVER, + ""input"": args.input, + ""seg"": clusters, + ""bbc"": bbc, + ""ln"": ln, + ""un"": un, + ""clonal"": args.clonal, + ""ampdel"": not args.noampdel, + ""d"": args.cnstates, + ""eD"": args.diploidcmax, + ""eT"": args.tetraploidcmax, + ""ts"": args.minsize, + ""tc"": args.minchrs, + ""td"": args.maxneutralshift, + ""tR"": args.toleranceRDR, + ""tB"": args.toleranceBAF, + ""mR"": args.mergeRDR, + ""mB"": args.mergeBAF, + ""limit"": args.limitinc, + ""g"": args.ghostprop, + ""p"": args.seeds, + ""j"": args.jobs, + ""r"": args.randomseed, + ""s"": args.timelimit, + ""m"": args.memlimit, + ""u"": args.minprop, + ""f"": args.maxiterations, + ""M"": args.mode, + ""x"": args.runningdir, + ""diploid"": args.diploid, + ""tetraploid"": args.tetraploid, + ""v"": args.verbosity, + ""binwise"": args.binwise, + ""purities"": args.purities, + } + + +def logArgs(args, width): + text = ""\n"" + for key in args: + text += ""\t{}: {}\n"".format(key, args[key]) + sys.stderr.write(log(text)) + + +def main(args=None): + sys.stderr.write(log(""# Checking and parsing input arguments\n"")) + args = parsing_arguments(args) + if args[""v""] >= 2: + sys.stdout.write( + info( + ""\n"".join([""## {}:\t{}"".format(key, args[key]) for key in args]) + ""\n"" + ) + ) + logArgs(args, 80) + + sys.stderr.write(log(""# Reading and parsing clustered bins in BBC file\n"")) + bbc, bsamples = readBBC(args[""bbc""]) + + sys.stderr.write(log(""# Reading and parsing bin clusters in SEG file\n"")) + seg, ssamples = readSEG(args[""seg""]) + + assert bsamples == ssamples, error( + ""Samples in BBC files does not match the ones in SEG file!"" + ) + samples = ssamples + if args[""purities""]: + assert len(args[""purities""]) == len(samples), error( + ""The number of purities given in space-separated list does not match the number of samples!"" + ) + + sys.stderr.write(log(""# Computing the cluster sizes\n"")) + size = computeSizes(seg=seg, bbc=bbc, samples=samples) + + sys.stderr.write( + log( + ""# Filtering clusters based on covered genome size and covered chromosomes\n"" + ) + ) + fbbc, fseg = filtering( + bbc=bbc, + seg=seg, + size=size, + ts=args[""ts""], + tc=args[""tc""], + mB=args[""mB""], + mR=args[""mR""], + samples=samples, + v=args[""v""], + ) + + if not args[""diploid""] and not args[""tetraploid""]: + sys.stderr.write( + log( + '## Neither ""diploid"" nor ""tetraploid"" was fixed. ' + 'Model selection will be performed and the ""clonal"" argument' + ""will not be used for scaling.\n"" + ) + ) + + sys.stderr.write(log(""# Finding the neutral diploid/tetraploid cluster\n"")) + neutral = findNeutralCluster( + seg=fseg, size=size, td=args[""td""], samples=samples, v=args[""v""] + ) + + sys.stderr.write(log(""# Running diploid\n"")) + diploidObjs = runningDiploid(neutral=neutral, args=args) + + if args[""clonal""] is None: + sys.stderr.write(log(""# Finding clonal clusters and their copy numbers\n"")) + clonal, scale = findClonalClusters( + fseg=fseg, + neutral=neutral, + size=size, + tB=args[""tB""], + tR=args[""tR""], + samples=samples, + v=args[""v""], + ) + else: + sys.stderr.write(log(""# Parsing given clonal copy numbers\n"")) + clonal, scale = parseClonalClusters( + clonal=args[""clonal""], + fseg=fseg, + size=size, + samples=samples, + v=args[""v""], + ) + + if len(clonal) > 0: + sys.stderr.write(log(""# Running tetraploid\n"")) + tetraploidObjs = runningTetraploid( + clonal=clonal, scale=scale, size=size, args=args + ) + + sys.stderr.write(log(""# Selecting best solution\n"")) + select( + diploid=diploidObjs, + tetraploid=tetraploidObjs, + v=args[""v""], + rundir=args[""x""], + g=args[""g""], + limit=args[""limit""], + ) + else: + sys.stderr.write( + warning( + ( + ""# No potential clonal patterns found, the input is likely to be diploid.\n If the heuristic "" + ""failed to identify a clonal cluster due to high noisy in the data, there are two main "" + ""parameters which user may tune:\n\t1. Increase the values of tB and tR which define the "" + ""thresholds to predict the RDR and BAF of clonal clusters.\n\t2. Decrease the value of -ts "" + ""which define the minimum coverage of the genome for clusters to be considered potentially "" + ""clonal. As such, more clusters will be considered. \nLast, please assess the quality of the "" + ""clustering through cluster-bins and increase the corresponding thresholds (-tR and -tB) to "" + ""avoid overfitting of the data and overclustering.\n"" + ) + ) + ) + + sys.stderr.write(log(""# Selecting best diploid solution\n"")) + selectDiploid( + diploid=diploidObjs, + v=args[""v""], + rundir=args[""x""], + g=args[""g""], + limit=args[""limit""], + ) + + elif args[""diploid""]: + sys.stderr.write(log(""# Running diploid\n"")) + + if args[""clonal""] is not None: + clonal = parse_clonal_diploid(args[""clonal""]) + neutral = None + else: + sys.stderr.write(log(""# Finding the neutral diploid cluster\n"")) + neutral = findNeutralCluster( + seg=fseg, + size=size, + td=args[""td""], + samples=samples, + v=args[""v""], + ) + clonal = None + + diploidObjs = runningDiploid(neutral=neutral, args=args, clonal=clonal) + + sys.stderr.write(log(""# Selecting best diploid solution\n"")) + selectDiploid( + diploid=diploidObjs, + v=args[""v""], + rundir=args[""x""], + g=args[""g""], + limit=args[""limit""], + ) + + elif args[""tetraploid""]: + if args[""clonal""] is None: + sys.stderr.write(log(""# Finding clonal clusters and their copy numbers\n"")) + neutral = findNeutralCluster( + seg=fseg, + size=size, + td=args[""td""], + samples=samples, + v=args[""v""], + ) + + clonal, scale = findClonalClusters( + fseg=fseg, + neutral=neutral, + size=size, + tB=args[""tB""], + tR=args[""tR""], + samples=samples, + v=args[""v""], + ) + else: + sys.stderr.write(log(""# Parsing given clonal copy numbers\n"")) + clonal = parse_clonal_tetraploid(args[""clonal""]) + + clonal, scale = parseClonalClusters( + clonal=clonal, + fseg=fseg, + size=size, + samples=samples, + v=args[""v""], + ) + + if len(clonal) > 0: + sys.stderr.write(log(""# Running tetraploid\n"")) + tetraploidObjs = runningTetraploid( + clonal=clonal, scale=scale, size=size, args=args + ) + + sys.stderr.write(log(""# Selecting best tetraploid solution\n"")) + selectTetraploid( + tetraploid=tetraploidObjs, + v=args[""v""], + rundir=args[""x""], + g=args[""g""], + limit=args[""limit""], + ) + else: + sys.stderr.write( + warning( + ( + ""# No potential clonal patterns found, the input is likely to be diploid.\n If the heuristic "" + ""failed to identify a clonal cluster due to high noisy in the data, there are two main "" + ""parameters which user may tune:\n\t1. Increase the values of tB and tR which define the "" + ""thresholds to predict the RDR and BAF of clonal clusters.\n\t2. Decrease the value of -ts "" + ""which define the minimum coverage of the genome for clusters to be considered potentially "" + ""clonal. As such, more clusters will be considered. \nLast, please assess the quality of the "" + ""clustering through cluster-bins and increase the corresponding thresholds (-tR and -tB) to "" + ""avoid overfitting of the data and overclustering.\n"" + ) + ) + ) + + +t2s = lambda x: [str(a) for a in x] + + +def parse_clonal_diploid(clonal): + """""" + Given a list of clonal cluster copy numbers, this function tries to order them to be compatible + with the HATCHet C++ factorization module. + For diploid scaling, this module requires: + -the first cluster is indicated with copy-number 1,1 + -the second cluster has a total copy number different from 2 + """""" + clonal_list = [[int(a) for a in c.split("":"")] for c in clonal.split("","")] + diploid_clusters = [t for t in clonal_list if t[1] == 1 and t[2] == 1] + if len(diploid_clusters) == 1: + my_diploid = diploid_clusters[0] + elif len(diploid_clusters) > 1: + if diploid_clusters[0] == clonal_list[0]: + my_diploid = diploid_clusters[0] + else: + raise ValueError( + error( + ""Found more than 1 cluster indicated as clonal (1,1) and "" + ""neither was the first argument to 'clonal'. Please select one for scaling and place "" + ""it first."" + ) + ) + else: + raise ValueError( + error( + ""No cluster was indicated as (1,1) in argument to 'clonal' with "" + ""'diploid'=True. HATCHet solving module requires specification of (1,1) cluster for the "" + ""'clonal' argument to be used in this case."" + ) + ) + + candidate_second = [ + t for t in clonal_list if t[0] != my_diploid[0] and t[1] + t[2] != 2 + ] + if len(candidate_second) == 0: + raise ValueError( + error( + ""No cluster with total copy number different from 2 was included "" + ""in 'clonal'. At least one such cluster is required for this argument to be used with "" + ""'diploid'=True."" + ) + ) + else: + my_second = candidate_second[0] + used_clusters = set([my_diploid[0], my_second[0]]) + + clonal = "","".join( + [ + "":"".join(t2s(t)) + for t in [my_diploid] + + [my_second] + + [t2 for t2 in clonal_list if t2[0] not in used_clusters] + ] + ) + log( + msg=f"" NOTE: cluster {my_diploid[0]} with copy number (1,1) will be used to scale fractional copy numbers.\n"", + level=""INFO"", + ) + log(msg=f"" Reordered 'clonal' argument={clonal}.\n"", level=""INFO"") + + return clonal + + +def parse_clonal_tetraploid(clonal): + """""" + Given a list of clonal cluster copy numbers, this function tries to order them to be compatible + with the HATCHet C++ factorization module. + For tetraploid scaling, this module requires: + -the first cluster is indicated with copy-number 2,2 + -the second cluster has a total copy number different from 4 + """""" + clonal_list = [[int(a) for a in c.split("":"")] for c in clonal.split("","")] + wgd_clusters = [t for t in clonal_list if t[1] == 2 and t[2] == 2] + if len(wgd_clusters) == 1: + my_wgd = wgd_clusters[0] + elif len(wgd_clusters) > 1: + if wgd_clusters[0] == clonal_list[0]: + my_wgd = wgd_clusters[0] + else: + raise ValueError( + error( + ""Found more than 1 cluster indicated as clonal (2,2) and "" + ""neither was the first argument to 'clonal'. Please select one "" + ""for scaling and place it first."" + ) + ) + else: + raise ValueError( + error( + ""No cluster was indicated as (2,2) in argument to 'clonal' with "" + ""'tetraploid'=True. HATCHet solving module requires specification of (2,2) cluster for the "" + ""'clonal' argument to be used in this case."" + ) + ) + + candidate_second = [ + t for t in clonal_list if t[0] != my_wgd[0] and t[1] + t[2] != 4 + ] + if len(candidate_second) == 0: + raise ValueError( + error( + ""No cluster with total copy number different from 4 was included "" + ""in 'clonal'. At least one such cluster is required for this "" + ""argument to be used with 'tetraploid'=True."" + ) + ) + else: + my_second = candidate_second[0] + used_clusters = set([my_wgd[0], my_second[0]]) + + clonal = "","".join( + [ + "":"".join(t2s(t)) + for t in [my_wgd] + + [my_second] + + [t2 for t2 in clonal_list if t2[0] not in used_clusters] + ] + ) + sys.stderr.write( + log( + f""# NOTE: cluster {my_wgd[0]} with copy number (2,2) and cluster {my_second[0]} with "" + f""copy number ({my_second[1]}, {my_second[2]}) will be used to scale fractional copy numbers.\n"" + ) + ) + sys.stderr.write(log(f""# Reordered 'clonal' argument={clonal}.\n"")) + return clonal + + +def readBBC(filename): + samples = set() + bbc = {} + with open(filename, ""r"") as f: + for line in f: + parsed = line.strip().split() + if len(parsed) == 11 and line[0] != ""#"": + chro = str(parsed[0]) + start = int(parsed[1]) + end = int(parsed[2]) + sample = str(parsed[3]) + if chro not in bbc: + bbc[chro] = {} + if (start, end) not in bbc[chro]: + bbc[chro][start, end] = {} + if sample not in bbc[chro][start, end]: + bbc[chro][start, end][sample] = {} + bbc[chro][start, end][sample][""rdr""] = float(parsed[4]) + bbc[chro][start, end][sample][""snps""] = int(parsed[5]) + bbc[chro][start, end][sample][""cov""] = float(parsed[6]) + bbc[chro][start, end][sample][""alpha""] = int(parsed[7]) + bbc[chro][start, end][sample][""beta""] = int(parsed[8]) + bbc[chro][start, end][sample][""baf""] = float(parsed[9]) + bbc[chro][start, end][sample][""cluster""] = str(parsed[10]) + samples.add(sample) + elif line[0] != ""#"" and len(parsed) > 0: + raise ValueError(error('Found a bad-formatted line: ""{}""'.format(line))) + + for c in bbc: + for seg in bbc[c]: + for p in samples: + assert p in bbc[c][seg], error( + ""ERROR: bin ({}:{}-{}) not defined in sample {}"".format( + c, seg[0], seg[1], p + ) + ) + + return bbc, samples + + +def readSEG(filename): + samples = set() + seg = {} + with open(filename, ""r"") as f: + for line in f: + parsed = line.strip().split() + if len(parsed) == 9 and line[0] != ""#"": + idx = str(parsed[0]) + sample = str(parsed[1]) + if idx not in seg: + seg[idx] = {} + if sample not in seg[idx]: + seg[idx][sample] = {} + seg[idx][sample][""bins""] = int(parsed[2]) + seg[idx][sample][""rdr""] = float(parsed[3]) + seg[idx][sample][""snps""] = int(parsed[4]) + seg[idx][sample][""cov""] = float(parsed[5]) + seg[idx][sample][""alpha""] = int(parsed[6]) + seg[idx][sample][""beta""] = int(parsed[7]) + seg[idx][sample][""baf""] = float(parsed[8]) + samples.add(sample) + elif line[0] != ""#"" and len(parsed) > 0: + raise ValueError(error('Found a bad-formatted line: ""{}""'.format(line))) + + for i in seg: + for p in samples: + assert p in seg[i], error( + ""ERROR: cluster {} not defined in sample {}"".format(i, p) + ) + + return seg, samples + + +def computeSizes(seg, bbc, samples): + sample = list(samples)[0] + size = { + idx: sum( + float(b[1] - b[0]) + for c in bbc + for b in bbc[c] + if bbc[c][b][sample][""cluster""] == idx + ) + for idx in seg + } + for idx in seg: + for p in samples: + seg[idx][p][""avgbaf""] = ( + sum( + bbc[c][b][p][""baf""] * float(b[1] - b[0]) + for c in bbc + for b in bbc[c] + if bbc[c][b][p][""cluster""] == idx + ) + / size[idx] + ) + return size + + +def filtering(bbc, seg, size, ts, tc, mB, mR, samples, v): + sample = list(samples)[0] + totsize = float(sum(seg[1] - seg[0] for c in bbc for seg in bbc[c])) + chrs = { + idx: set( + c for c in bbc for seg in bbc[c] if bbc[c][seg][sample][""cluster""] == idx + ) + for idx in seg + } + assert sum(size[idx] for idx in size) == totsize + printrdrbaf = lambda s: ""-"".join( + [""({}, {})"".format(seg[s][p][""rdr""], seg[s][p][""baf""]) for p in samples] + ) + + if v >= 3: + sys.stderr.write(debug(""### Clusters and their features:\n"")) + + selected = set(idx for idx in seg) + merge_selected = set() + for idx in sorted(selected, key=(lambda i: size[i]), reverse=True): + merge = None + for ins in sorted(merge_selected, key=(lambda i: size[i]), reverse=True): + if set( + abs(seg[idx][p][""rdr""] - seg[ins][p][""rdr""]) <= mR + and abs(seg[idx][p][""baf""] - seg[ins][p][""baf""]) <= mB + for p in samples + ) == {True}: + merge = ins + break + if merge is None: + merge_selected.add(idx) + if v >= 3: + sys.stderr.write( + debug( + ""### {}: SIZE= {}\t#CHRS= {}\t(RDR, BAF)= {}\n"".format( + idx, size[idx], len(chrs[idx]), printrdrbaf(idx) + ) + ) + ) + else: + size[merge] += size[idx] + chrs[merge] = chrs[merge] | chrs[idx] + if v >= 3: + sys.stderr.write( + warning( + ""### {} merged with {}: SIZE= {}\t#CHRS= {}\t(RDR, BAF)= {}\n"".format( + idx, + merge, + size[idx], + len(chrs[idx]), + printrdrbaf(idx), + ) + ) + ) + selected = merge_selected + + selected = set( + idx for idx in selected if size[idx] >= totsize * ts and len(chrs[idx]) >= tc + ) + + fbbc = { + c: { + seg: bbc[c][seg] + for seg in bbc[c] + if bbc[c][seg][sample][""cluster""] in selected + } + for c in bbc + } + fseg = {idx: seg[idx] for idx in selected} + + if v >= 1: + sys.stderr.write( + info(""# Selected clusters: "" + "", "".join([idx for idx in selected]) + ""\n"") + ) + if v >= 2: + sys.stderr.write(info(""## Features of selected clusters:\n"")) + sys.stderr.write( + info( + ""\n"".join( + [ + ""## {}: SIZE= {}\t#CHRS= {}\t(RDR, BAF)= {}"".format( + idx, size[idx], len(chrs[idx]), printrdrbaf(idx) + ) + for idx in selected + ] + ) + + ""\n"" + ) + ) + + return fbbc, fseg + + +def findNeutralCluster(seg, size, td, samples, v): + selected = set( + idx + for idx in seg + if set(p for p in samples if abs(0.5 - seg[idx][p][""baf""]) <= td) == samples + ) + if len(selected) == 0: + raise ValueError( + error(""None potential neutral cluster found with given parameters!"") + ) + neutral = max(selected, key=(lambda k: size[k])) + + if v >= 2: + sys.stderr.write( + info( + ""## Cluster selected as neutral (diploid/tetraploid) is {}\n"".format( + neutral + ) + ) + ) + + return neutral + + +def runningDiploid(neutral, args, clonal=None): + results = [] + if clonal is not None: + args[""c""] = clonal + else: + args[""c""] = ""{}:1:1"".format(neutral) + + args[""e""] = args[""eD""] + basecmd = makeBaseCMD(args, args[""eD""]) + "" -c "" + args[""c""] + + for n in range(args[""ln""], args[""un""] + 1): + if args[""v""] >= 2: + sys.stderr.write(log(""## Running diploid with {} clones\n"".format(n))) + outprefix = os.path.join(args[""x""], ""results.diploid.n{}"".format(n)) + results.append((n, execute(args, basecmd, n, outprefix), outprefix)) + + return results + + +def makeBaseCMD(args, e): + basecmd = ""{} {}"".format(args[""solver""], args[""input""]) + if args[""ampdel""]: + basecmd += "" -f "" + if args[""d""] is not None: + basecmd += "" -d {}"".format(args[""d""]) + if e is not None: + basecmd += "" -e {}"".format(e) + if args[""j""] is not None: + basecmd += "" -j {}"".format(args[""j""]) + if args[""p""] is not None: + basecmd += "" -p {}"".format(args[""p""]) + if args[""u""] is not None: + basecmd += "" -u {}"".format(args[""u""]) + if args[""m""] is not None: + basecmd += "" -m {}"".format(args[""m""]) + if args[""s""] is not None: + basecmd += "" -s {}"".format(args[""s""]) + if args[""f""] is not None: + basecmd += "" -i {}"".format(args[""f""]) + if args[""r""] is not None: + basecmd += "" -r {}"".format(args[""r""]) + if args[""M""] is not None: + basecmd += "" -M {}"".format(args[""M""]) + basecmd += "" -v 2"" + # if args['td'] is not None: + # basecmd += ' -t {}'.format(args['td']) + return basecmd + + +def findClonalClusters(fseg, neutral, size, tB, tR, samples, v): + topbaf = {p: float(min(fseg[idx][p][""avgbaf""] for idx in fseg)) for p in samples} + heigh = { + p: (abs(fseg[neutral][p][""avgbaf""] - topbaf[p]) / 4.0) > tB for p in samples + } + + location = {} + level = {} + for idx in fseg: + locp = [] + levp = {} + + for p in samples: + t = topbaf[p] + n = fseg[neutral][p][""avgbaf""] + x = fseg[idx][p][""avgbaf""] + d = { + ""top"": abs(t - x), + ""mid"": abs(((t + n) / 2.0) - x), + ""midbot"": abs(((t + 3 * n) / 4.0) - x), + ""bot"": abs(n - x), + } + + if d[""top""] < d[""bot""] and abs(d[""top""] - d[""bot""]) > tB: + levp[p] = [""top""] + elif d[""bot""] < d[""top""] and abs(d[""top""] - d[""bot""]) > tB: + levp[p] = [""bot""] + else: + levp[p] = [""top"", ""bot""] + + c = argmin(d) + locp.append(c) + if c != ""top"" and d[""top""] <= tB: + locp.append(""top"") + if c != ""mid"" and d[""mid""] <= tB: + locp.append(""mid"") + if c != ""midbot"" and d[""midbot""] <= tB: + locp.append(""midbot"") + if c != ""bot"" and d[""bot""] <= tB: + locp.append(""bot"") + + count = Counter([levv for p in samples for levv in levp[p]]) + count = sorted(count.keys(), key=(lambda x: count[x]), reverse=True) + + for lev in count: + if False not in set(lev in levp[p] for p in samples): + level[idx] = lev + locp = Counter(locp) + loc = argmax(locp) + location[idx] = loc + break + + clusters = sorted( + [idx for idx in fseg if idx != neutral and idx in location], + key=(lambda i: size[i]), + reverse=True, + ) + allclonal = [ + (2, 0), + (2, 1), + (3, 2), + (4, 2), + (1, 0), + (3, 0), + (3, 1), + (4, 0), + (4, 1), + (5, 0), + ] + found_pattern = [] + best_pattern = {} + best_scale = () + best_value = 0 + + for cluster in clusters: + rightpos = sum( + (fseg[cluster][p][""rdr""] - fseg[neutral][p][""rdr""]) > tR for p in samples + ) + leftpos = sum( + (fseg[cluster][p][""rdr""] - fseg[neutral][p][""rdr""]) < -tR for p in samples + ) + + eqbaf = lambda p: abs(fseg[cluster][p][""baf""] - fseg[neutral][p][""baf""]) <= tB + eqrdr = lambda p: abs(fseg[cluster][p][""rdr""] - fseg[neutral][p][""rdr""]) <= tR + + if True in set(eqbaf(p) and heigh[p] for p in samples): + continue + if True in set(eqbaf(p) and eqrdr(p) and heigh[p] for p in samples): + continue + + if rightpos == len(samples): + if location[cluster] == ""bot"" or location[cluster] == ""midbot"": + options = [(3, 2), (4, 2)] + elif location[cluster] == ""mid"" or location[cluster] == ""top"": + options = [(4, 2), (3, 2)] + else: + assert False + # if sum(abs(fseg[cluster][p]['baf'] - fseg[neutral][p]['baf']) <= tB for p in samples) == len(samples): + # options = [(4, 4)] + options + elif leftpos == len(samples): + if level[cluster] == ""top"" and location[cluster] == ""top"": + options = [(2, 0)] + elif level[cluster] == ""top"": + options = [(2, 0), (2, 1)] + elif level[cluster] == ""bot"": + options = [(2, 1)] + else: + assert False + # if sum(abs(fseg[cluster][p]['baf'] - fseg[neutral][p]['baf']) <= tB for p in samples) == len(samples): + # options = [(1, 1), (0, 0)] + options + else: + options = [] + continue + + if v >= 3: + sys.stderr.write( + debug( + ""### Potential clonal cluster {} with copy numbers {}\n"".format( + cluster, options + ) + ) + ) + + regPurity = ( + lambda v: 1.0 if 1.0 <= v <= 1.05 else (0.0 if -0.05 <= v <= 0.0 else v) + ) + calcPurity = lambda d, c, r: regPurity( + float(2 * d - 2 * r) / float(2 * r + 2 * d - c * d) + ) + calcScalingFactor = lambda p, d: float(2.0 + 2.0 * p) / float(d) + calcFraction = lambda p, cn: float(2.0 * (1.0 - p) + sum(cn) * p) + calcRDR = lambda p, cn, s: calcFraction(p, cn) / float(s) + calcBAF = lambda p, cn: float(1.0 * (1.0 - p) + min(cn) * p) / calcFraction( + p, cn + ) + + for opt in options: + purity = { + p: calcPurity( + fseg[neutral][p][""rdr""], sum(opt), fseg[cluster][p][""rdr""] + ) + for p in samples + } + if False in set(0.0 <= purity[p] <= 1.0 for p in samples): + continue + scaling = { + p: calcScalingFactor(purity[p], fseg[neutral][p][""rdr""]) + for p in samples + } + if False in set(scaling[p] >= 0.0 for p in samples): + continue + curr_pattern = {} + curr_pattern[neutral] = (2, 2) + curr_pattern[cluster] = opt + curr_scale = (neutral, cluster) + curr_value = size[neutral] + size[cluster] + for cn in [a for a in allclonal if a != opt]: + estRDR = {p: calcRDR(purity[p], cn, scaling[p]) for p in samples} + estBAF = {p: calcBAF(purity[p], cn) for p in samples} + checkRDR = ( + lambda r, i: set( + p for p in samples if abs(r[p] - fseg[i][p][""rdr""]) <= tR + ) + == samples + ) + checkBAF = ( + lambda b, i: set( + p for p in samples if abs(b[p] - fseg[i][p][""baf""]) <= tB + ) + == samples + ) + candidates = [ + idx + for idx in clusters + if idx not in curr_pattern + and checkRDR(estRDR, idx) + and checkBAF(estBAF, idx) + ] + if len(candidates) > 0: + choice = max(candidates, key=(lambda i: size[i])) + curr_pattern[choice] = cn + curr_value += size[choice] + + if v >= 2: + if curr_pattern not in found_pattern: + sys.stderr.write( + info( + ""## Found pattern of size {}: {}\n"".format( + curr_value, curr_pattern + ) + ) + ) + if curr_pattern not in found_pattern: + found_pattern.append(curr_pattern) + + if curr_value > best_value: + best_pattern = curr_pattern + best_value = curr_value + best_scale = curr_scale + + if v >= 1: + sys.stderr.write( + info(""## Chosen pattern of size {}: {}\n"".format(best_value, best_pattern)) + ) + + return best_pattern, best_scale + + +def parseClonalClusters(clonal, fseg, size, samples, v): + given = clonal.split("","") + if len(given) < 2: + raise RuntimeError(error(""At least two clonal clusters must be provided!"")) + + for i, e in enumerate(given): + p = e.split("":"") + if len(p) != 3: + raise RuntimeError(error(""Wrong format of clonal clusters!"")) + if i < 2 and p[0] not in set( + fseg + ): # check only the first 2 clusters, used for scaling + raise RuntimeError( + error( + ""A specified clonal cluster does not exist or is not selected! {}"".format( + p[0] + ) + ) + ) + + tmp = given[0].split("":"") + neutral = tmp[0] + """""" + if int(tmp[1]) != 2 or int(tmp[1]) != 2: + raise RuntimeError(error('The first clonal cluster must be the neutral with copy numbers 2:2!')) + """""" + tmp = given[1].split("":"") + second = tmp[0] + cn = int(tmp[1]) + int(tmp[2]) + + calcPurity = lambda d, c, r: float(2 * d - 2 * r) / float(2 * r + 2 * d - c * d) + calcScalingFactor = lambda p, d: float(2.0 + 2.0 * p) / float(d) + + purity = { + p: calcPurity(fseg[neutral][p][""rdr""], cn, fseg[second][p][""rdr""]) + for p in samples + } + if False in set(0.0 <= purity[p] <= 1.0 for p in samples): + raise RuntimeError( + error( + ""The specified clonal clusters do not allow for scaling because resulting purity is {}!"".format( + purity + ) + ) + ) + scaling = { + p: calcScalingFactor(purity[p], fseg[neutral][p][""rdr""]) for p in samples + } + if False in set(scaling[p] >= 0.0 for p in samples): + raise RuntimeError( + error( + ""The specified clonal clusters do not allow for scaling because resulting scaling factor is {}!"".format( + scaling + ) + ) + ) + + pattern = { + e.split("":"")[0]: (int(e.split("":"")[1]), int(e.split("":"")[2])) for e in given + } + scale = (neutral, second) + + return pattern, scale + + +def runningTetraploid(clonal, scale, size, args): + results = [] + cn = ""{}:{}:{}"".format(scale[0], clonal[scale[0]][0], clonal[scale[0]][1]) + cn += "",{}:{}:{}"".format(scale[1], clonal[scale[1]][0], clonal[scale[1]][1]) + if len(clonal) > 2: + cn = ( + cn + + "","" + + "","".join( + [ + ""{}:{}:{}"".format(s, clonal[s][0], clonal[s][1]) + for s in clonal + if s not in scale + ] + ) + ) + + args[""c""] = cn + args[""e""] = args[""eT""] + basecmd = makeBaseCMD(args, args[""eT""]) + "" -c {}"".format(cn) + + for n in range(args[""ln""], args[""un""] + 1): + if args[""v""] >= 2: + sys.stderr.write(log(""## Running tetraploid with {} clones\n"".format(n))) + outprefix = os.path.join(args[""x""], ""results.tetraploid.n{}"".format(n)) + results.append((n, execute(args, basecmd, n, outprefix), outprefix)) + + return results + + +def execute_python(solver, args, n, outprefix): + bbc_out_file = outprefix + "".bbc.ucn.tsv"" + seg_out_file = outprefix + "".seg.ucn.tsv"" + + _mode = (""both"", ""ilp"", ""cd"")[args[""M""]] + + obj, cA, cB, u, cluster_ids, sample_ids = solve( + solver=solver, + clonal=args[""c""], + bbc_file=args[""bbc""], + seg_file=args[""seg""], + n=n, + solve_mode=_mode, + d=-1 if args[""d""] is None else args[""d""], + cn_max=args[""e""], + mu=args[""u""], + diploid_threshold=0.1, + ampdel=args[""ampdel""], + n_seed=args[""p""], + n_worker=args[""j""], + random_seed=args[""r""], + max_iters=args[""f""], + timelimit=args[""s""], + binwise=args[""binwise""], + purities=args[""purities""], + ) + + segmentation( + cA, + cB, + u, + cluster_ids, + sample_ids, + bbc_file=args[""bbc""], + bbc_out_file=bbc_out_file, + seg_out_file=seg_out_file, + ) + + if args[""v""] >= 1: + sys.stderr.write( + info(""# Best objective found with {} clones: {}\n"".format(n, obj)) + ) + + return obj + + +def execute(args, basecmd, n, outprefix): + if config.compute_cn.solver != ""cpp"": + return execute_python(config.compute_cn.solver, args, n, outprefix) + progressbar = ProgressBar(total=args[""p""], length=min(50, args[""p""]), verbose=False) + cmd = basecmd + "" -n {} -o {}"".format(n, outprefix) + if args[""v""] >= 3: + sys.stderr.write(debug(""### Running command: {}\n"".format(cmd))) + + FNULL = open(os.devnull, ""w"") + process = subprocess.Popen( + shlex.split(cmd), + stdout=FNULL, + stderr=subprocess.PIPE, + universal_newlines=True, + ) + buffer = [] + + if args[""v""] >= 2: + while True: + nextline = process.stderr.readline().strip() + buffer.append(nextline) + if "";"" in nextline: + progressbar.progress( + advance=True, + msg=""Obj value {}"".format(float(nextline.split()[-2][:-1])), + ) + if not nextline and process.poll() is not None: + break + + stdout, stderr = process.communicate() + exitcode = process.returncode + if exitcode == 0: + obj = -1 + for line in reversed(buffer): + if ""Final objective"" in line: + for e in line.split(): + if isfloat(e): + obj = float(e) + break + if obj >= 0: + if args[""v""] >= 1: + sys.stderr.write( + info(""# Best objective found with {} clones: {}\n"".format(n, obj)) + ) + else: + raise RuntimeError( + error( + ( + ""Failed to parse the output of the following command because the final objective was not "" + ""found: \n\t\t{cmd}\n"" + ) + ) + ) + else: + if any(""GRBException"" in line for line in buffer): + msg = ( + ""\nYou likely have a licensing issue with Gurobi. Please run `hatchet check-solver` to ensure that "" + ""the solver is working correctly."" + ) + else: + msg = ( + ""\nUnexpected error during solve. Please run `hatchet check-solver` to ensure that the solver is "" + ""working correctly."" + ) + raise RuntimeError( + error( + ""The following command failed: \n\t\t{}\nwith {}\n{}"".format( + cmd, buffer, msg + ) + ) + ) + + return obj + + +def select(diploid, tetraploid, v, rundir, g, limit): + assert len(diploid) == len(tetraploid), error( + ""The number of diploid and tetraploid results must be the same"" + ) + dscores = {} + tscores = {} + + if len(diploid) == 1 or len(diploid) == 2: + for dip in diploid: + dscores[dip[0]] = dip[1] + if v >= 2: + sys.stderr.write( + info(""## Objective value is used as scores for diploid results\n"") + ) + sys.stderr.write( + info( + ""\n"".join( + [ + ""## Diploid with {} clones - OBJ: {} - score: {}"".format( + d[0], d[1], dscores[d[0]] + ) + for d in diploid + ] + ) + + ""\n"" + ) + ) + + for tet in tetraploid: + tscores[tet[0]] = tet[1] + if v >= 2: + sys.stderr.write( + info(""## Objective value is used as scores for tetraploid results\n"") + ) + sys.stderr.write( + info( + ""\n"".join( + [ + ""## Tetraploid with {} clones - OBJ: {} - score: {}"".format( + t[0], t[1], tscores[t[0]] + ) + for t in tetraploid + ] + ) + + ""\n"" + ) + ) + else: + for i, dip in enumerate(diploid): + if i == 0: + dscores[dip[0]] = forward(diploid, i, g, limit) + elif i == len(diploid) - 1: + dscores[dip[0]] = backward(diploid, i, g, limit) + else: + dscores[dip[0]] = central(diploid, i, g, limit) + + if v >= 2: + sys.stderr.write( + info(""## Scores approximating second derivative for diploid results\n"") + ) + sys.stderr.write( + info( + ""\n"".join( + [ + ""## Diploid with {} clones - OBJ: {} - score: {}"".format( + d[0], d[1], dscores[d[0]] + ) + for d in diploid + ] + ) + + ""\n"" + ) + ) + + for i, tet in enumerate(tetraploid): + if i == 0: + tscores[tet[0]] = estimate_forward(tetraploid, i, g, diploid, limit) + elif i == len(tetraploid) - 1: + tscores[tet[0]] = backward(tetraploid, i, g, limit) + else: + tscores[tet[0]] = central(tetraploid, i, g, limit) + + if v >= 2: + sys.stderr.write( + info( + ""## Scores approximating second derivative for tetraploid results\n"" + ) + ) + sys.stderr.write( + info( + ""\n"".join( + [ + ""## Tetraploid with {} clones - OBJ: {} - score: {}"".format( + t[0], t[1], tscores[t[0]] + ) + for t in tetraploid + ] + ) + + ""\n"" + ) + ) + + dchosen = max(diploid, key=(lambda x: dscores[x[0]])) + dbout = os.path.join(rundir, ""chosen.diploid.bbc.ucn"") + shutil.copy2(dchosen[2] + "".bbc.ucn.tsv"", dbout) + dsout = os.path.join(rundir, ""chosen.diploid.seg.ucn"") + shutil.copy2(dchosen[2] + "".seg.ucn.tsv"", dsout) + if v >= 1: + sys.stderr.write( + info( + ""# The chosen diploid solution has {} clones with OBJ: {} and score: {}\n"".format( + dchosen[0], dchosen[1], dscores[dchosen[0]] + ) + ) + ) + if v >= 2: + sys.stderr.write( + info( + ""## The related-diploid resulting files are copied to {} and {}\n"".format( + dbout, dsout + ) + ) + ) + + tchosen = max(tetraploid, key=(lambda x: tscores[x[0]])) + tbout = os.path.join(rundir, ""chosen.tetraploid.bbc.ucn"") + shutil.copy2(tchosen[2] + "".bbc.ucn.tsv"", tbout) + tsout = os.path.join(rundir, ""chosen.tetraploid.seg.ucn"") + shutil.copy2(tchosen[2] + "".seg.ucn.tsv"", tsout) + if v >= 1: + sys.stderr.write( + info( + ""# The chosen tetraploid solution has {} clones with OBJ: {} and score: {}\n"".format( + tchosen[0], tchosen[1], tscores[tchosen[0]] + ) + ) + ) + if v >= 2: + sys.stderr.write( + info( + ""## The related-tetraploid resulting files are copied to {} and {}\n"".format( + tbout, tsout + ) + ) + ) + + bbest = os.path.join(rundir, ""best.bbc.ucn"") + sbest = os.path.join(rundir, ""best.seg.ucn"") + if tchosen[0] < dchosen[0]: + shutil.copy2(tchosen[2] + "".bbc.ucn.tsv"", bbest) + shutil.copy2(tchosen[2] + "".seg.ucn.tsv"", sbest) + sys.stderr.write( + info( + ""# The chosen solution is tetraploid with {} clones and is written in {} and {}\n"".format( + tchosen[0], bbest, sbest + ) + ) + ) + else: + shutil.copy2(dchosen[2] + "".bbc.ucn.tsv"", bbest) + shutil.copy2(dchosen[2] + "".seg.ucn.tsv"", sbest) + sys.stderr.write( + info( + ""# The chosen solution is diploid with {} clones and is written in {} and {}\n"".format( + dchosen[0], bbest, sbest + ) + ) + ) + + +def selectDiploid(diploid, v, rundir, g, limit): + dscores = {} + + if len(diploid) == 1 or len(diploid) == 2: + for dip in diploid: + dscores[dip[0]] = dip[1] + if v >= 2: + sys.stderr.write( + info(""## Objective value is used as scores for diploid results\n"") + ) + sys.stderr.write( + info( + ""\n"".join( + [ + ""## Diploid with {} clones - OBJ: {} - score: {}"".format( + d[0], d[1], dscores[d[0]] + ) + for d in diploid + ] + ) + + ""\n"" + ) + ) + else: + for i, dip in enumerate(diploid): + if i == 0: + dscores[dip[0]] = forward(diploid, i, g, limit) + elif i == len(diploid) - 1: + dscores[dip[0]] = backward(diploid, i, g, limit) + else: + dscores[dip[0]] = central(diploid, i, g, limit) + + if v >= 2: + sys.stderr.write( + info(""## Scores approximating second derivative for diploid results\n"") + ) + sys.stderr.write( + info( + ""\n"".join( + [ + ""## Diploid with {} clones - OBJ: {} - score: {}"".format( + d[0], d[1], dscores[d[0]] + ) + for d in diploid + ] + ) + + ""\n"" + ) + ) + + dchosen = max(diploid, key=(lambda x: dscores[x[0]])) + dbout = os.path.join(rundir, ""chosen.diploid.bbc.ucn"") + shutil.copy2(dchosen[2] + "".bbc.ucn.tsv"", dbout) + dsout = os.path.join(rundir, ""chosen.diploid.seg.ucn"") + shutil.copy2(dchosen[2] + "".seg.ucn.tsv"", dsout) + if v >= 1: + sys.stderr.write( + info( + ""# The chosen diploid solution has {} clones with OBJ: {} and score: {}\n"".format( + dchosen[0], dchosen[1], dscores[dchosen[0]] + ) + ) + ) + if v >= 2: + sys.stderr.write( + info( + ""## The related-diploid resulting files are copied to {} and {}\n"".format( + dbout, dsout + ) + ) + ) + + bbest = os.path.join(rundir, ""best.bbc.ucn"") + sbest = os.path.join(rundir, ""best.seg.ucn"") + + shutil.copy2(dchosen[2] + "".bbc.ucn.tsv"", bbest) + shutil.copy2(dchosen[2] + "".seg.ucn.tsv"", sbest) + sys.stderr.write( + info( + ""# The chosen solution is diploid with {} clones and is written in {} and {}\n"".format( + dchosen[0], bbest, sbest + ) + ) + ) + + +def selectTetraploid(tetraploid, v, rundir, g, limit): + tscores = {} + + if len(tetraploid) == 1 or len(tetraploid) == 2: + for tet in tetraploid: + tscores[tet[0]] = tet[1] + if v >= 2: + sys.stderr.write( + info(""## Objective value is used as scores for tetraploid results\n"") + ) + sys.stderr.write( + info( + ""\n"".join( + [ + ""## Tetraploid with {} clones - OBJ: {} - score: {}"".format( + t[0], t[1], tscores[t[0]] + ) + for t in tetraploid + ] + ) + + ""\n"" + ) + ) + else: + for i, tet in enumerate(tetraploid): + if i == 0: + tscores[tet[0]] = forward(tetraploid, i, g, limit) + elif i == len(tetraploid) - 1: + tscores[tet[0]] = backward(tetraploid, i, g, limit) + else: + tscores[tet[0]] = central(tetraploid, i, g, limit) + + if v >= 2: + sys.stderr.write( + info( + ""## Scores approximating second derivative for tetraploid results\n"" + ) + ) + sys.stderr.write( + info( + ""\n"".join( + [ + ""## Tetraploid with {} clones - OBJ: {} - score: {}"".format( + t[0], t[1], tscores[t[0]] + ) + for t in tetraploid + ] + ) + + ""\n"" + ) + ) + + tchosen = max(tetraploid, key=(lambda x: tscores[x[0]])) + tbout = os.path.join(rundir, ""chosen.tetraploid.bbc.ucn"") + shutil.copy2(tchosen[2] + "".bbc.ucn.tsv"", tbout) + tsout = os.path.join(rundir, ""chosen.tetraploid.seg.ucn"") + shutil.copy2(tchosen[2] + "".seg.ucn.tsv"", tsout) + if v >= 1: + sys.stderr.write( + info( + ""# The chosen tetraploid solution has {} clones with OBJ: {} and score: {}\n"".format( + tchosen[0], tchosen[1], tscores[tchosen[0]] + ) + ) + ) + if v >= 2: + sys.stderr.write( + info( + ""## The related-tetraploid resulting files are copied to {} and {}\n"".format( + tbout, tsout + ) + ) + ) + + bbest = os.path.join(rundir, ""best.bbc.ucn"") + sbest = os.path.join(rundir, ""best.seg.ucn"") + shutil.copy2(tchosen[2] + "".bbc.ucn.tsv"", bbest) + shutil.copy2(tchosen[2] + "".seg.ucn.tsv"", sbest) + sys.stderr.write( + info( + ""# The chosen solution is tetraploid with {} clones and is written in {} and {}\n"".format( + tchosen[0], bbest, sbest + ) + ) + ) + + +def safediv(v): + return v if v > 0 else 1.0 + + +def forward(f, i, g, limit): + if limit is None: + left = g + else: + left = min(g, limit) + right = float(max(f[i][1] - f[i + 1][1], 0.0) / safediv(f[i][1])) + return left - right + + +def estimate_forward(f, i, g, knw, limit): + left = max(g, float(max(knw[i][1] - knw[i + 1][1], 0.0) / safediv(knw[i][1]))) + if limit is not None: + left = min(left, limit) + right = float(max(f[i][1] - f[i + 1][1], 0.0) / safediv(f[i][1])) + return left - right + + +def central(f, i, g, limit): + if limit is None: + left = float(max(f[i - 1][1] - f[i][1], 0.0) / safediv(f[i - 1][1])) + else: + left = min( + limit, + float(max(f[i - 1][1] - f[i][1], 0.0) / safediv(f[i - 1][1])), + ) + right = float(max(f[i][1] - f[i + 1][1], 0.0) / safediv(f[i][1])) + return left - right + + +def backward(f, i, g, limit): + if limit is None: + left = float(max(f[i - 1][1] - f[i][1], 0.0) / safediv(f[i - 1][1])) + else: + left = min( + limit, + float(max(f[i - 1][1] - f[i][1], 0.0) / safediv(f[i - 1][1])), + ) + right = g + return left - right + + +def argmin(d): + return min(d, key=d.get) + + +def argmax(d): + return max(d, key=d.get) + + +def isfloat(value): + try: + float(value) + return True + except ValueError: + return False + + +def warning(msg): + return ""{}{}{}"".format(""\033[93m"", msg, ""\033[0m"") + + +def info(msg): + return ""{}{}{}"".format(""\033[96m"", msg, ""\033[0m"") + + +def debug(msg): + return ""{}{}{}"".format(""\033[92m"", msg, ""\033[0m"") + + +class ProgressBar: + def __init__( + self, + total, + length, + counter=0, + verbose=False, + decimals=1, + fill=chr(9608), + prefix=""Progress:"", + suffix=""Complete"", + ): + self.total = total + self.length = length + self.decimals = decimals + self.fill = fill + self.prefix = prefix + self.suffix = suffix + self.counter = counter + self.verbose = verbose + + def progress(self, advance=True, msg=""""): + flush = sys.stderr.flush + write = sys.stderr.write + if advance: + self.counter += 1 + percent = (""{0:."" + str(self.decimals) + ""f}"").format( + 100 * (self.counter / float(self.total)) + ) + filledLength = int(self.length * self.counter // self.total) + bar = self.fill * filledLength + ""-"" * (self.length - filledLength) + rewind = ""\x1b[2K\r"" + result = ""%s |%s| %s%% %s"" % (self.prefix, bar, percent, self.suffix) + if not self.verbose: + toprint = rewind + result + "" [%s]"" % (msg) + else: + toprint = rewind + msg + ""\n"" + result + write(toprint) + flush() + if self.counter == self.total: + write(""\n"") + flush() + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/bin/HATCHet-preprocess.py",".py","9993","323","import sys +import os +import argparse +import subprocess as sp +import multiprocessing as mp +import shlex +import re + +from hatchet.utils.Supporting import log +import hatchet.utils as utils +from hatchet import config, __version__ + + +def parse_args(): + description = ( + ""This command automatically runs the HATCHet's preprocessing pipeline, which is composed of "" + ""three steps: (1) count-reads, (2) count-alleles, and (3) combine-counts."" + ) + parser = argparse.ArgumentParser(description=description) + parser.add_argument( + ""-t"", + ""--tumor"", + required=True, + type=str, + help=( + ""White-space separated list of input tumor BAM files, corresponding to multiple samples from the same "" + ""patient (list must be within quotes)"" + ), + ) + parser.add_argument( + ""-n"", + ""--normal"", + required=True, + type=str, + help=""Matched-normal BAM file"", + ) + parser.add_argument( + ""-r"", ""--reference"", type=str, required=True, help=""Reference genome"" + ) + parser.add_argument( + ""-s"", + ""--samplenames"", + required=False, + type=str, + default=config.preprocess.samplenames, + help=( + ""Tumor sample names in a white-space separated list in the same order as the corresponding BAM files "" + ""(default: file names are used as names)"" + ), + ) + parser.add_argument( + ""-b"", + ""--size"", + type=str, + required=False, + default=config.preprocess.size, + help='Bin size, with or without ""kb"" or ""Mb"" (default: 250kb)', + ) + parser.add_argument( + ""-c"", + ""--minreads"", + type=int, + required=False, + default=config.preprocess.minreads, + help=""Minimum read counts for heterozygous germline SNPs (default: 8)"", + ) + parser.add_argument( + ""-C"", + ""--maxreads"", + type=int, + required=False, + default=config.preprocess.maxreads, + help=""Maximum read counts for heterozygous germline SNPs (default: 1000)"", + ) + parser.add_argument( + ""-p"", + ""--phred"", + type=int, + required=False, + default=config.preprocess.phred, + help=""Phred quality score (default: 11)"", + ) + parser.add_argument( + ""-x"", + ""--rundir"", + required=False, + default=config.preprocess.rundir, + type=str, + help=""Running directory (default: current directory)"", + ) + parser.add_argument( + ""--bcftools"", + required=False, + default=config.paths.bcftools, + type=str, + help=( + 'Path to the directory to ""bcftools"" executable, required in default mode (default: bcftools is ' + ""directly called as it is in user $PATH)"" + ), + ) + parser.add_argument( + ""--samtools"", + required=False, + default=config.paths.samtools, + type=str, + help=( + 'Path to the directory to ""samtools"" executable, required in default mode (default: samtools is ' + ""directly called as it is in user $PATH)"" + ), + ) + parser.add_argument( + ""--seed"", + required=False, + type=int, + default=config.preprocess.seed, + help=""Random seed for replication (default: None)"", + ) + parser.add_argument( + ""-j"", + ""--jobs"", + required=False, + type=int, + default=config.preprocess.jobs, + help=""Number of parallele jobs to use (default: equal to number of available processors)"", + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args() + + tumor = set(t for t in args.tumor.split()) + for t in tumor: + if not os.path.isfile(t): + raise ValueError(""The following BAM file does not exist: {}"".format(t)) + if args.samplenames is None: + names = set(os.path.splitext(os.path.basename(t))[0] for t in tumor) + if len(names) != len(tumor): + names = tumor + else: + names = set(t for t in args.samplenames.split()) + if len(names) != len(tumor): + raise ValueError( + ( + ""A different number of samples names has been provided compared to the number of BAM files, "" + ""remember to add the list within quotes!"" + ) + ) + + tumor = set(os.path.abspath(t) for t in tumor) + if not os.path.isdir(args.rundir): + raise ValueError(""Running directory does not exists: {}"".format(args.rundir)) + if not os.path.isfile(args.normal): + raise ValueError( + ""Matched-normal BAM file does not exist: {}"".format(args.normal) + ) + if not os.path.isfile(args.reference): + raise ValueError( + ""Reference genome file does not exist: {}"".format(args.reference) + ) + if args.seed and args.seed < 1: + raise ValueError(""The random seed must be positive!"") + if args.minreads < 1: + raise ValueError(""The minimum number of reads must be positive!"") + if args.maxreads < 1: + raise ValueError(""The maximum number of reads must be positive!"") + + size = 0 + try: + if args.size[-2:] == ""kb"": + size = int(args.size[:-2]) * 1000 + elif args.size[-2:] == ""Mb"": + size = int(args.size[:-2]) * 1000000 + else: + size = int(args.size) + except (IndexError, ValueError): + raise ValueError( + 'Size must be a number, optionally ending with either ""kb"" or ""Mb""!' + ) + + if not args.jobs: + args.jobs = mp.cpu_count() + if args.jobs < 1: + raise ValueError(""The number of jobs must be positive!"") + + return { + ""tumor"": list(tumor), + ""normal"": os.path.abspath(args.normal), + ""ref"": os.path.abspath(args.reference), + ""names"": list(names), + ""size"": size, + ""samtools"": args.samtools, + ""bcftools"": args.bcftools, + ""J"": args.jobs, + ""minreads"": args.minreads, + ""maxreads"": args.maxreads, + ""phred"": args.phred, + ""rundir"": os.path.abspath(args.rundir), + ""seed"": args.seed, + } + + +def main(): + log(""Parsing and checking arguments\n"", level=""PROGRESS"") + args = parse_args() + log( + ""\n"".join([""Arguments:""] + [""\t{} : {}"".format(a, args[a]) for a in args]) + + ""\n"", + level=""INFO"", + ) + + log(""Setting directories\n"", level=""PROGRESS"") + dbaf, drdr, dbb = setup(args) + + def get_comp(name): + comp = os.path.join(utils, name) + if not os.path.isfile(comp): + raise ValueError( + ""{} not found in utils directory of HATCHet's home i.e. {}, is anything been moved?"".format( + name, utils + ) + ) + return comp + + log(""Computing RDRs\n"", level=""PROGRESS"") + cmd = ""python3 {} -N {} -T {} -S {} -b {} -g {} -j {} -q {} -O {} -o {}"" + nbin = os.path.join(drdr, ""normal.1bed"") + tbin = os.path.join(drdr, ""bulk.1bed"") + cmd = cmd.format( + get_comp(""count_reads.py""), + args[""normal""], + "" "".join(args[""tumor""]), + ""normal "" + "" "".join(args[""names""]), + args[""size""], + args[""ref""], + args[""J""], + args[""phred""], + nbin, + tbin, + ) + if args[""samtools""] is not None: + cmd += "" --samtools {}"".format(args[""samtools""]) + runcmd(cmd, drdr, log=""bins.log"", rundir=args[""rundir""]) + + log(""Computing BAFs\n"", level=""PROGRESS"") + cmd = ""python3 {} -N {} -T {} -S {} -r {} -j {} -q {} -Q {} -U {} -c {} -C {} -O {} -o {}"" + nbaf = os.path.join(dbaf, ""normal.1bed"") + tbaf = os.path.join(dbaf, ""bulk.1bed"") + cmd = cmd.format( + get_comp(""count_alleles.py""), + args[""normal""], + "" "".join(args[""tumor""]), + ""normal "" + "" "".join(args[""names""]), + args[""ref""], + args[""J""], + args[""phred""], + args[""phred""], + args[""phred""], + args[""minreads""], + args[""maxreads""], + nbaf, + tbaf, + ) + if args[""samtools""] is not None: + cmd += "" --samtools {}"".format(args[""samtools""]) + if args[""bcftools""] is not None: + cmd += "" --bcftools {}"".format(args[""bcftools""]) + runcmd(cmd, dbaf, log=""bafs.log"", rundir=args[""rundir""]) + + log(""Combining RDRs and BAFs\n"", level=""PROGRESS"") + ctot = os.path.join(args[""rundir""], ""total_read.counts"") + cmd = ""python3 {} -c {} -C {} -B {} -m MIRROR -t {}"" + cmd = cmd.format(get_comp(""combine_counts.py""), nbin, tbin, tbaf, ctot) + if args[""seed""] is not None: + cmd += "" -e {}"".format(args[""seed""]) + runcmd(cmd, dbb, out=""bulk.bb"", log=""combo.log"", rundir=args[""rundir""]) + + +def setup(args): + dbaf = os.path.join(args[""rundir""], ""baf"") + if not os.path.isdir(dbaf): + os.mkdir(dbaf) + + drdr = os.path.join(args[""rundir""], ""rdr"") + if not os.path.isdir(drdr): + os.mkdir(drdr) + + dbb = os.path.join(args[""rundir""], ""bb"") + if not os.path.isdir(dbb): + os.mkdir(dbb) + + return dbaf, drdr, dbb + + +def runcmd(cmd, xdir, out=None, log=""log"", rundir=None): + j = os.path.join + tmp = log + ""_TMP"" + sout = open(j(xdir, out), ""w"") if out is not None else sp.PIPE + with open(j(xdir, tmp), ""w"") as serr: + proc = sp.Popen( + shlex.split(cmd), + stdout=sout, + stderr=sp.PIPE, + cwd=rundir, + universal_newlines=True, + ) + for line in iter(lambda: proc.stderr.read(1), """"): + sys.stderr.write(line) + serr.write(line) + if out is not None: + sout.flush() + sout.close() + + with open(j(xdir, tmp), ""r"") as i: + with open(j(xdir, log), ""w"") as o: + for l in i: + if ""Progress"" not in l: + o.write(re.sub(r""\033\[[0-9]*m"", """", l)) + os.remove(j(xdir, tmp)) + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/bin/__init__.py",".py","0","0","","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/BAMBinning.py",".py","3984","150","from multiprocessing import Process, Queue, JoinableQueue, Lock, Value +from collections import deque +import pysam + +import hatchet.utils.ProgressBar as pb + + +def bin( + samtools, + samples, + chromosomes, + num_workers, + q, + size, + regions, + verbose=False, +): + # Define a Lock and a shared value for log printing through ProgressBar + err_lock = Lock() + counter = Value(""i"", 0) + progress_bar = pb.ProgressBar( + total=len(samples) * len(chromosomes), + length=40, + lock=err_lock, + counter=counter, + verbose=verbose, + ) + + # Establish communication queues + tasks = JoinableQueue() + results = Queue() + + # Enqueue jobs + jobs_count = 0 + for bam in samples: + for chro in chromosomes: + tasks.put((bam[0], bam[1], chro)) + jobs_count += 1 + + # Setting up the workers + workers = [ + Binner(tasks, results, progress_bar, samtools, q, size, regions, verbose) + for i in range(min(num_workers, jobs_count)) + ] + + # Add a poison pill for each worker + for i in range(len(workers)): + tasks.put(None) + + # Start the workers + for w in workers: + w.start() + + # Wait for all of the tasks to finish + tasks.join() + + # Get the results + sorted_results = {} + for i in range(jobs_count): + res = results.get() + sorted_results[res[0][0], res[0][1]] = res + + # Close Queues + tasks.close() + results.close() + + # Ensure each worker terminates + for w in workers: + w.terminate() + w.join() + + return sorted_results + + +class Binner(Process): + def __init__( + self, + task_queue, + result_queue, + progress_bar, + samtools, + q, + size, + regions, + verbose, + ): + Process.__init__(self) + self.task_queue = task_queue + self.result_queue = result_queue + self.progress_bar = progress_bar + self.samtools = samtools + self.q = q + self.size = size + self.regions = regions + self.verbose = verbose + + def run(self): + while True: + next_task = self.task_queue.get() + if next_task is None: + # Poison pill means shutdown + self.task_queue.task_done() + break + + self.progress_bar.progress( + advance=False, + msg=""{} starts on {} for {})"".format( + self.name, next_task[1], next_task[2] + ), + ) + bins = self.binChr( + bamfile=next_task[0], + samplename=next_task[1], + chromosome=next_task[2], + ) + self.progress_bar.progress( + advance=True, + msg=""{} ends on {} for {})"".format( + self.name, next_task[1], next_task[2] + ), + ) + self.task_queue.task_done() + self.result_queue.put(bins) + return + + def binChr(self, bamfile, samplename, chromosome): + read_callback = lambda r: r.mapping_quality >= self.q + sam = pysam.AlignmentFile(bamfile, ""rb"") + bins = deque() + for start, end in self.regions[chromosome]: + while start < end: + stop = min(start + self.size, end) + if start > 0: + n_reads = sam.count( + chromosome, + start=start - 1, + stop=stop, + read_callback=read_callback, + ) + else: + n_reads = sam.count( + chromosome, + start=0, + stop=stop, + read_callback=read_callback, + ) + bins.append((samplename, chromosome, max(start, 1), stop, str(n_reads))) + start += self.size + return list(bins) +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/combine_counts.py",".py","48021","1400","from multiprocessing import Pool +import os +import subprocess +import traceback +from importlib.resources import path +import numpy as np +import pandas as pd +from scipy.stats import binom, norm +from scipy.special import softmax + +import hatchet.data +from hatchet.utils.ArgParsing import parse_combine_counts_args +import hatchet.utils.Supporting as sp +from hatchet.utils.rd_gccorrect import rd_gccorrect + + +def main(args=None): + sp.log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") + args = parse_combine_counts_args(args) + sp.logArgs(args, 80) + + baffile = args[""baffile""] + threads = args[""processes""] + chromosomes = args[""chromosomes""] + outfile = args[""outfile""] + all_names = args[""sample_names""] + msr = args[""min_snp_reads""] + mtr = args[""min_total_reads""] + use_chr = args[""use_chr""] + phase = args[""phase""] + blocksize = args[""blocksize""] + max_snps_per_block = args[""max_snps_per_block""] + test_alpha = args[""test_alpha""] + multisample = args[""multisample""] + referencefasta = args[""referencefasta""] + + n_workers = min(len(chromosomes), threads) + + # Read in centromere locations table + with path(hatchet.data, f'{args[""ref_version""]}.centromeres.txt') as centromeres: + centromeres = pd.read_table( + centromeres, + header=None, + names=[""CHR"", ""START"", ""END"", ""NAME"", ""gieStain""], + ) + chr2centro = {} + for ch in centromeres.CHR.unique(): + my_df = centromeres[centromeres.CHR == ch] + assert (my_df.gieStain == ""acen"").all() + # Each centromere should consist of 2 adjacent segments + assert len(my_df == 2) + assert my_df.START.max() == my_df.END.min() + if use_chr: + if ch.startswith(""chr""): + chr2centro[ch] = my_df.START.min(), my_df.END.max() + else: + chr2centro[""chr"" + ch] = my_df.START.min(), my_df.END.max() + else: + if ch.startswith(""chr""): + chr2centro[ch[3:]] = my_df.START.min(), my_df.END.max() + else: + chr2centro[ch] = my_df.START.min(), my_df.END.max() + + for ch in chromosomes: + if ch not in chr2centro: + raise ValueError( + sp.error( + f""Chromosome {ch} not found in centromeres file. Inspect file provided as -C argument."" + ) + ) + + isX = {ch: ch.endswith(""X"") for ch in chromosomes} + isY = {ch: ch.endswith(""Y"") for ch in chromosomes} + + # form parameters for each worker + params = [ + ( + baffile, + all_names, + ch, + outfile + f"".{ch}"", + chr2centro[ch][0], + chr2centro[ch][1], + msr, + mtr, + args[""array""], + isX[ch] or isY[ch], + multisample, + phase, + blocksize, + max_snps_per_block, + test_alpha, + ) + for ch in chromosomes + ] + # dispatch workers + """""" + for p in params: + run_chromosome_wrapper(p) + """""" + with Pool(n_workers) as p: + p.map(run_chromosome_wrapper, params) + + sp.log( + msg=""# Merging per-chromosome bb files and correcting read counts\n"", + level=""STEP"", + ) + # merge all BB files together to get the one remaining BB file + outfiles = [a[3] for a in params] + bbs = [pd.read_table(bb, dtype={""#CHR"": str}) for bb in outfiles] + big_bb = pd.concat(bbs) + big_bb = big_bb.sort_values(by=[""#CHR"", ""START"", ""SAMPLE""]) + + big_bb[""CORRECTED_READS""] = np.NAN + + # For each sample, correct read counts to account for differences in coverage (as in HATCHet) + # (i.e., multiply read counts by total-reads-normal/total-reads-sample) + rc = pd.read_table(args[""totalcounts""], header=None, names=[""SAMPLE"", ""#READS""]) + normal_name = all_names[0] + nreads_normal = rc[rc.SAMPLE == normal_name].iloc[0][""#READS""] + for sample in rc.SAMPLE.unique(): + if sample == normal_name: + continue + nreads_sample = rc[rc.SAMPLE == sample].iloc[0][""#READS""] + correction = nreads_normal / nreads_sample + my_bb = big_bb[big_bb.SAMPLE == sample] + + # Correct the tumor reads propotionally to the total reads in corresponding samples + big_bb.loc[big_bb.SAMPLE == sample, ""CORRECTED_READS""] = ( + my_bb.TOTAL_READS * correction + ).astype(np.int64) + + # Recompute RDR according to the corrected tumor reads + big_bb.loc[big_bb.SAMPLE == sample, ""RD""] = ( + big_bb.loc[big_bb.SAMPLE == sample, ""CORRECTED_READS""] + / big_bb.loc[big_bb.SAMPLE == sample, ""NORMAL_READS""] + ) + + if ""NORMAL_READS"" not in big_bb: + sp.log(""# NOTE: adding NORMAL_READS column to bb file"", level=""INFO"") + big_bb[""NORMAL_READS""] = (big_bb.CORRECTED_READS / big_bb.RD).astype(np.uint32) + + sp.log( + msg=""# Performing GC bias correction on read depth signal\n"", + level=""STEP"", + ) + + autosomes = set( + [ch for ch in big_bb[""#CHR""] if not (ch.endswith(""X"") or ch.endswith(""Y""))] + ) + autosomal_bb = big_bb[big_bb[""#CHR""].isin(autosomes)].copy() + + # perform GC bias correction + autosomal_bb = rd_gccorrect(autosomal_bb, referencefasta) + + # Convert intervals from closed to half-open to match .1bed/HATCHet standard format + autosomal_bb.END = autosomal_bb.END + 1 + autosomal_bb.to_csv(outfile, index=False, sep=""\t"") + + big_bb.END = big_bb.END + 1 + big_bb.to_csv(outfile + "".withXY"", index=False, sep=""\t"") + + # Remove intermediate BB files + [os.remove(f) for f in outfiles] + + sp.log(msg=""# Done\n"", level=""STEP"") + + +def read_snps(baf_file, ch, all_names, phasefile=None): + """""" + Read and validate SNP data for this patient (TSV table output from HATCHet deBAF.py). + """""" + all_names = all_names[ + 1: + ] # remove normal sample -- not looking for SNP counts from normal + + # Read in HATCHet BAF table + all_snps = pd.read_table( + baf_file, + names=[""CHR"", ""POS"", ""SAMPLE"", ""ALT"", ""REF""], + dtype={ + ""CHR"": object, + ""POS"": np.uint32, + ""SAMPLE"": object, + ""ALT"": np.uint32, + ""REF"": np.uint32, + }, + ) + + # Keep only SNPs on this chromosome + snps = all_snps[all_snps.CHR == ch].sort_values(by=[""POS"", ""SAMPLE""]) + snps = snps.reset_index(drop=True) + + if len(snps) == 0: + raise ValueError( + sp.error( + f""Chromosome {ch} not found in SNPs file (chromosomes in file: {all_snps.CHR.unique()})"" + ) + ) + + n_samples = len(all_names) + if n_samples != len(snps.SAMPLE.unique()): + raise ValueError( + sp.error( + f""Expected {n_samples} samples, found {len(snps.SAMPLE.unique())} samples in SNPs file."" + ) + ) + + if set(all_names) != set(snps.SAMPLE.unique()): + raise ValueError( + sp.error( + f""Expected sample names did not match sample names in SNPs file.\n\ + Expected: {sorted(all_names)}\n Found:{sorted(snps.SAMPLE.unique())}"" + ) + ) + + # Add total counts column + snpsv = snps.copy() + snpsv[""TOTAL""] = snpsv.ALT + snpsv.REF + + if phasefile is not None: + # Read in phasing output + phases = pd.read_table( + phasefile, + compression=""gzip"", + comment=""#"", + names=""CHR\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tPHASE"".split(), + usecols=[""CHR"", ""POS"", ""PHASE""], + quoting=3, + low_memory=False, + dtype={""CHR"": object, ""POS"": np.uint32}, + ) + phases[""FLIP""] = phases.PHASE.str.contains(""1|0"", regex=False).astype(np.int8) # noqa: W605 + phases[""NOFLIP""] = phases.PHASE.str.contains(""0|1"", regex=False).astype(np.int8) # noqa: W605 + + # Drop entries without phasing output + phases = phases[phases.FLIP + phases.NOFLIP > 0] + + # For exact duplicate entries, drop one + phases = phases.drop_duplicates() + + # For duplicate entries with the same (CHR, POS) but different phase, drop all + phases = phases.drop_duplicates(subset=[""CHR"", ""POS""], keep=False) + + # Merge tables: keep only those SNPs for which we have phasing output + snpsv = pd.merge(snpsv, phases, on=[""CHR"", ""POS""], how=""left"") + + # Create counts array and find SNPs that are not present in all samples + snp_counts = snpsv.pivot(index=""POS"", columns=""SAMPLE"", values=""TOTAL"") + missing_pos = snp_counts.isna().any(axis=1) + + # Remove SNPs that are absent in any sample + snp_counts = snp_counts.dropna(axis=0) + snpsv = snpsv[~snpsv.POS.isin(missing_pos[missing_pos].index)] + + # Pivot table for dataframe should match counts array and have no missing entries + check_pivot = snpsv.pivot(index=""POS"", columns=""SAMPLE"", values=""TOTAL"") + assert np.array_equal(check_pivot, snp_counts), ""SNP file reading failed"" + assert not np.any(check_pivot.isna()), ""SNP file reading failed"" + assert np.array_equal( + all_names, list(snp_counts.columns) + ) # make sure that sample order is the same + + return np.array(snp_counts.index), np.array(snp_counts), snpsv + + +def adaptive_bins_arm( + snp_thresholds, + total_counts, + snp_positions, + snp_counts, + min_snp_reads=2000, + min_total_reads=5000, +): + """""" + Compute adaptive bins for a single chromosome arm. + Parameters: + snp_thresholds: length array of 1-based genomic positions of candidate bin thresholds + + total_counts: x <2d> np.ndarray + entry [i, 2j] contains the number of reads starting in [snp_thresholds[i], snp_thresholds[i + 1]) in sample + j (only the first n-1 positions are populated) entry [i, 2j + 1] contains the number of reads covering + position snp_thresholds[i] in sample j + + snp_positions: length list of 1-based genomic positions of SNPs + NOTE: this function requires that m = n-1 for convenience of programming (could be relaxed in a different + implementation) + snp_counts: x np.ndarray containing the number of overlapping reads at each of the snp + positions in samples + + min_snp_reads: the minimum number of SNP-covering reads required in each bin and each sample + min_total_reads: the minimum number of total reads required in each bin and each sample + + """""" + assert len(snp_thresholds) == len(total_counts) + assert len(snp_positions) == len(snp_counts) + assert len(snp_positions) == len(snp_thresholds) - 1, ( + len(snp_positions), + len(snp_thresholds), + ) + assert np.all(snp_positions > snp_thresholds[0]) + assert len(snp_positions) > 0 + assert len(snp_thresholds) >= 2 + + n_samples = int(total_counts.shape[1] / 2) + + # number of reads that start between snp_thresholds[i] and snp_thresholds[i + 1] + even_index = np.array([i * 2 for i in range(int(n_samples))], dtype=np.int8) + # number of reads overlapping position snp_thresholds[i] + odd_index = np.array([i * 2 + 1 for i in range(int(n_samples))], dtype=np.int8) + + bin_total = np.zeros(n_samples) + bin_snp = np.zeros(n_samples - 1) + + starts = [] + ends = [] + + my_start = snp_thresholds[0] + + rdrs = [] + totals = [] + i = 1 + while i < len(snp_thresholds - 1): + # Extend the current bin to the next threshold + next_threshold = snp_thresholds[i] + + # add the intervening reads to the current bin + # adding SNP reads + assert snp_positions[i - 1] >= snp_thresholds[i - 1] + assert snp_positions[i - 1] <= snp_thresholds[i], ( + i, + snp_positions[i - 1], + snp_thresholds[i], + ) + + bin_snp += snp_counts[i - 1] + + # adding total reads + bin_total += total_counts[i - 1, even_index] + + if np.all(bin_snp >= min_snp_reads) and np.all( + bin_total - total_counts[i, odd_index] >= min_total_reads + ): + # end this bin + starts.append(my_start) + ends.append(next_threshold) + + # to get the total reads, subtract the number of reads covering the threshold position + bin_total -= total_counts[i, odd_index] + totals.append(bin_total) + + # compute RDR + rdrs.append(bin_total[1:] / bin_total[0]) + + # and start a new one + bin_total = np.zeros(n_samples) + bin_snp = np.zeros(n_samples - 1) + my_start = ends[-1] + 1 + + i += 1 + + # handle the case of 1 bin + if len(ends) == 0: + sp.log( + msg=""WARNING: found only 1 bin in chromosome arm, may not meet MSR and MTR\t"", + level=""WARN"", + ) + assert len(starts) == 0 + starts.append(snp_thresholds[0]) + ends.append(snp_thresholds[-1]) + + bin_total = ( + np.sum(total_counts[:, even_index], axis=0) - total_counts[-1, odd_index] + ) + totals.append(bin_total) + rdrs.append(bin_total[1:] / bin_total[0]) + + # add whatever excess at the end to the last bin + if ends[-1] < snp_thresholds[-1]: + # combine the last complete bin with the remainder + last_start_idx = np.where( + (snp_thresholds == starts[-1] - 1) | (snp_thresholds == starts[-1]) + )[0][0] + bin_total = ( + np.sum(total_counts[last_start_idx:, even_index], axis=0) + - total_counts[-1, odd_index] + ) + totals[-1] = bin_total + rdrs[-1] = bin_total[1:] / bin_total[0] + ends[-1] = snp_thresholds[-1] + + return starts, ends, totals, rdrs + + +def EM(totals_in, alts_in, start, tol=1e-6): + """""" + Adapted from chisel/Combiner.py + """""" + totals = np.array(totals_in) + alts = np.array(alts_in) + assert totals.size == alts.size and 0 < start < 1 and np.all(totals >= alts) + if np.all(np.logical_or(totals == alts, alts == 0)): + return 0.0, np.ones(len(totals_in)) * 0.5, 0.0 + else: + baf = start + prev = None + while prev is None or abs(prev - baf) >= tol: + prev = baf + + # E-step + assert 0 + tol < baf < 1 - tol, (baf, totals, alts, start) + M = (totals - 2.0 * alts) * np.log(baf) + (2.0 * alts - totals) * np.log( + 1.0 - baf + ) + M = np.exp(np.clip(a=M, a_min=-100, a_max=100)) + phases = np.reciprocal(1 + M) + + # M-step + baf = float( + np.sum(totals * (1 - phases) + alts * (2.0 * phases - 1)) + ) / float(np.sum(totals)) + + assert 0 + tol < baf < 1 - tol, (baf, totals, alts, start) + lpmf = binom.logpmf + log_likelihood = float( + np.sum( + phases * lpmf(k=alts, n=totals, p=baf) + + (1 - phases) * lpmf(k=alts, n=totals, p=1 - baf) + ) + ) + return baf, phases, log_likelihood + + +def apply_EM(totals_in, alts_in): + baf, phases, logl = max( + (EM(totals_in, alts_in, start=st) for st in np.linspace(0.01, 0.49, 50)), + key=(lambda x: x[2]), + ) + refs = totals_in - alts_in + phases = phases.round().astype(np.int8) + return ( + baf, + np.sum(np.choose(phases, [refs, alts_in])), + np.sum(np.choose(phases, [alts_in, refs])), + ) + + +def compute_baf_wrapper( + bin_snps, blocksize, max_snps_per_block, test_alpha, multisample +): + if multisample: + return compute_baf_task_multi( + bin_snps, blocksize, max_snps_per_block, test_alpha + ) + else: + return compute_baf_task_single( + bin_snps, blocksize, max_snps_per_block, test_alpha + ) + + +def compute_baf_task_single(bin_snps, blocksize, max_snps_per_block, test_alpha): + """""" + Estimates the BAF for the bin containing exactly SNPs. + is a dataframe with at least ALT and REF columns containing read counts. + , , and are used only for constructing phase blocks. + """""" + + samples = sorted(bin_snps.SAMPLE.unique()) + result = {} + + phasing = ""PHASE"" in bin_snps.columns + if phasing: + # TODO: select the highest coverage sample to use for constructing phase blocks? + # or maybe use all samples for BAF test? + all_phase_data = [ + phase_blocks_sequential( + d, + blocksize=blocksize, + max_snps_per_block=max_snps_per_block, + alpha=test_alpha, + ) + for _, d in bin_snps.groupby(""SAMPLE"") + ] + phase_data = merge_phasing(bin_snps, all_phase_data) + + for sample in samples: + # Compute BAF + my_snps = bin_snps[bin_snps.SAMPLE == sample] + n_snps = len(my_snps) + + if phasing: + my_snps = collapse_blocks(my_snps, *phase_data, bin_snps.iloc[0].CHR) + + baf, alpha, beta = apply_EM(totals_in=my_snps.TOTAL, alts_in=my_snps.ALT) + + cov = np.sum(alpha + beta) / n_snps + + result[sample] = n_snps, cov, baf, alpha, beta + return result + + +def compute_baf_task_multi(bin_snps, blocksize, max_snps_per_block, test_alpha): + """""" + Estimates the BAF for the bin containing exactly SNPs. + is a dataframe with at least ALT and REF columns containing read counts. + , , and are used only for constructing phase blocks. + """""" + + samples = sorted(bin_snps.SAMPLE.unique()) + result = {} + + phasing = ""PHASE"" in bin_snps.columns + if phasing: + # TODO: select the highest coverage sample to use for constructing phase blocks? + # or maybe use all samples for BAF test? + all_phase_data = [ + phase_blocks_sequential( + d, + blocksize=blocksize, + max_snps_per_block=max_snps_per_block, + alpha=test_alpha, + ) + for _, d in bin_snps.groupby(""SAMPLE"") + ] + phase_data = merge_phasing(bin_snps, all_phase_data) + + bin_snps = collapse_blocks(bin_snps, *phase_data, bin_snps.iloc[0].CHR) + + alts = bin_snps.pivot(index=""SAMPLE"", columns=""START"", values=""ALT"").to_numpy() + refs = bin_snps.pivot(index=""SAMPLE"", columns=""START"", values=""REF"").to_numpy() + n_snps = (bin_snps[""#SNPS""].sum() / len(bin_snps.SAMPLE.unique())).astype( + np.uint32 + ) + + else: + alts = bin_snps.pivot(index=""SAMPLE"", columns=""POS"", values=""ALT"").to_numpy() + refs = bin_snps.pivot(index=""SAMPLE"", columns=""POS"", values=""REF"").to_numpy() + n_snps = alts.shape[1] + + runs = {b: multisample_em(alts, refs, b) for b in np.arange(0.05, 0.5, 0.05)} + bafs, phases, ll = max(runs.values(), key=lambda x: x[-1]) + + # Need hard phasing to assign ref/alt reads to alpha/beta + phases = np.round(phases).astype(np.int8) + + # Compose results table + for i in range(len(samples)): + sample = samples[i] + + # Check that sample indexing lines up + my_snps = bin_snps[bin_snps.SAMPLE == sample] + assert np.array_equal(my_snps.ALT, alts[i]) + assert np.array_equal(my_snps.REF, refs[i]) + + alpha = np.sum(np.choose(phases, [refs[i], alts[i]])) + beta = np.sum(np.choose(phases, [alts[i], refs[i]])) + baf = bafs[i] + cov = np.sum(alpha + beta) / n_snps + + result[sample] = n_snps, cov, baf, alpha, beta + return result + + +def multisample_em(alts, refs, start, tol=10e-6): + assert ( + refs.shape == alts.shape + ), ""Alternate and reference count arrays must have the same shape"" + assert 0 < start <= 0.5, ""Initial estimate must be in (0, 0.5]"" + + totals = alts + refs + + n_samples, n_snps = alts.shape + totals_sum = np.sum(totals, axis=1) + assert np.all( + totals_sum > 0 + ), ""Every bin must have >0 SNP-covering reads in each sample!"" + + e_arr = np.zeros((2, n_snps)) + + if np.all(np.logical_or(refs == 0, alts == 0)): + return np.array([0.0] * n_samples), np.ones(n_snps) * 0.5, 0.0 + else: + theta = np.repeat(start, n_samples) + prev = None + while prev is None or np.all(np.abs(prev - theta) >= tol): + prev = theta + + # Ensure that theta is not exactly 0 or 1 to avoid log(0) + theta = np.clip(theta, tol, 1 - tol) + + # E-step in log space + e_arr[0] = np.log(theta) @ refs + np.log(1 - theta) @ alts + e_arr[1] = np.log(1 - theta) @ refs + np.log(theta) @ alts + phases = softmax(e_arr, axis=0)[0, :] + assert not np.any(np.isnan(phases)), (phases, e_arr) + + # M-step + t1 = refs @ phases + alts @ (1 - phases) + theta = t1 / totals_sum + assert not np.any(np.isnan(theta)), (theta, t1) + + # If mean(BAF) > 0.5, flip phases accordingly + if np.mean(theta) > 0.5: + theta = np.clip(theta, tol, 1 - tol) + + theta = 1 - theta + t1 = np.sum(np.log(theta) @ refs + np.log(1 - theta) @ alts, axis=0) + t2 = np.sum(np.log(1 - theta) @ refs + np.log(theta) @ alts, axis=0) + phases = softmax(np.vstack([t1, t2]), axis=0)[0, :] + + t1 = np.sum(np.log(theta) * (phases * refs).T, axis=0) + t2 = np.sum(np.log(1 - theta) * (phases * alts).T, axis=0) + t3 = np.sum(np.log(theta) * ((1 - phases) * alts).T, axis=0) + t4 = np.sum(np.log(1 - theta) * ((1 - phases) * refs).T, axis=0) + log_likelihood = np.sum(t1 + t2 + t3 + t4) + + return theta, phases, log_likelihood + + +def merge_phasing(_, all_phase_data): + """""" + Merge phasing results across all samples: + if a pair of SNPs is split in any sample, they won't be split. + """""" + + if len(all_phase_data) == 1: + return all_phase_data[0] + + singletons = set() + orphans = set() + breaks = set() + for i in range(len(all_phase_data)): + # Merge singletons and orphans + singletons = singletons.union(all_phase_data[i][1]) + orphans = orphans.union(all_phase_data[i][2]) + + # Identify breaks + blocking = all_phase_data[i][0] + j = 0 + for j in range(len(blocking) - 1): + if blocking[j][-1] == blocking[j + 1][0] - 1: + breaks.add(blocking[j][-1]) + + # Split blocking in sample 1 to match other breaks + blocks = [] + for b in all_phase_data[0][0]: + br = np.argwhere([a in breaks or a in orphans for a in b[:-1]]) + blocks.extend([list(a) for a in np.split(b, br.flatten() + 1)]) + + orphans = orphans.union([a[0] for a in blocks if len(a) == 1]) + blocks = [b for b in blocks if len(b) > 1] + + return blocks, singletons, orphans + + +def binom_prop_test(alt1, ref1, flip1, alt2, ref2, flip2, alpha=0.1): + """""" + Returns True if there is sufficient evidence that SNPs 1 and 2 should not be merged, False otherwise. + """""" + if np.isnan(flip1) or np.isnan(flip2): + return True + + x1 = ref1 if flip1 > 0 else alt1 + x2 = ref2 if flip2 > 0 else alt2 + n1 = max(1, alt1 + ref1) + n2 = max(1, alt2 + ref2) + + p1 = x1 / n1 + p2 = x2 / n2 + + p = (x1 + x2) / (n1 + n2) + if p == 0: + p = 0.001 + elif p == 1: + p = 0.999 + denom = np.sqrt(p * (1 - p) * (1 / n1 + 1 / n2)) + z = (p1 - p2) / denom + + if z > 0: + return 2 * (1 - norm.cdf(z)) < alpha + else: + return 2 * norm.cdf(z) < alpha + + +def block_segment(df, blocksize, max_snps_per_block): + """""" + Given a pandas dataframe containing read counts for a contiguous segment of SNPs, + collects SNPs into phase blocks of size at most containing at most + SNPs each. + """""" + splits = [] + df = df.copy().reset_index(drop=True) + + # walk along segment until either blocksize or max_snps_per_block is reached + my_start = df.iloc[0].POS + n = 1 + for i, r in df.iterrows(): + if i == 0: + continue + + if n >= max_snps_per_block or r.POS - my_start > blocksize: + splits.append(i) + my_start = r.POS + n = 1 + else: + n += 1 + return np.split(np.arange(len(df)), splits) + + +def consecutive(data, stepsize=1): + return np.split(data, np.where(np.diff(data) != stepsize)[0] + 1) + + +def phase_blocks_sequential(df, blocksize=50e3, max_snps_per_block=10, alpha=0): + if len(df) == 0: + return [] + + """"""NOTE: this currently only supports single-sample data"""""" + assert len(df.SAMPLE.unique()) == 1 + assert len(df.CHR.unique()) == 1 + + df = df.copy() + df = df.reset_index(drop=True) + + # Identify contiguous segments of SNPs with phasing information + segments = consecutive(np.where(~df.PHASE.isna())[0]) + + if alpha < 1: + ### Use binomial test to split adjacent SNPs with very different phased BAFs + # (further dividing the segments identified above) + # identify indices of adj SNPs that are significantly different + df_merged = pd.concat([df, df.shift(-1).add_prefix(""next_"")], axis=1) + # no_merge is the left index of each such pair + no_merge = np.where( + df_merged[:-1].apply( + lambda x: binom_prop_test( + x.ALT, + x.REF, + x.FLIP, + x.next_ALT, + x.next_REF, + x.next_FLIP, + alpha=alpha, + ), + axis=1, + ) + )[0] + # stack the adjacent indices (top is left, bottom is right = left + 1) + nm = np.vstack([no_merge, no_merge + 1]) + + new_segments = [] + orphans = set() + for seg in segments: + # identify adjacent pairs that violate test (p 1]) + + segments = new_segments + + blocks = [] + + for segment in segments: + if len(segment) == 0: + pass + elif len(segment) == 1: + blocks.append(list(segment)) + else: + my_df = df.iloc[segment] + ## Run blocking on my_df + my_blocks = block_segment(my_df, blocksize, max_snps_per_block) + mapping = {i: my_df.iloc[i].name for i in range(len(my_df))} + blocks.extend([[mapping[a] for a in b] for b in my_blocks]) + + blocks = sorted(blocks, key=lambda x: x[0]) + singletons = set(np.where(df.PHASE.isna())[0]) + + return blocks, singletons, orphans + + +def collapse_blocks(df, blocks, singletons, orphans, ch): + ### Construct blocked 1-bed table + # First, merge blocks for those SNPs that are in the same block + + rows = [] + for sample, df0 in df.groupby(""SAMPLE""): + i = 0 + j = 0 + while i < len(df0): + if i in singletons or i in orphans: + r = df0.iloc[i] + rows.append([ch, r.POS, r.POS, sample, r.ALT, r.REF, r.TOTAL, 1]) + i += 1 + else: + block = blocks[j] + assert i in block, (block, i) + i += len(block) + j += 1 + + my_snps = df0.iloc[block] + start = my_snps.POS.min() + end = my_snps.POS.max() + alt = np.sum( + my_snps.FLIP * my_snps.REF + (1 - my_snps.FLIP) * my_snps.ALT + ).astype(np.uint64) + ref = np.sum( + my_snps.FLIP * my_snps.ALT + (1 - my_snps.FLIP) * my_snps.REF + ).astype(np.uint64) + total = np.sum(my_snps.TOTAL) + n_snps = len(my_snps) + rows.append([ch, start, end, sample, alt, ref, total, n_snps]) + + return pd.DataFrame( + rows, + columns=[ + ""CHR"", + ""START"", + ""END"", + ""SAMPLE"", + ""ALT"", + ""REF"", + ""TOTAL"", + ""#SNPS"", + ], + ).sort_values(by=[""CHR"", ""START"", ""SAMPLE""]) + + +def merge_data(bins, dfs, bafs, sample_names, chromosome): + """""" + Merge bins data (starts, ends, total counts, RDRs) with SNP data and BAF data for each bin. + Parameters: + bins: output from call to adaptive_bins_arm + dfs: (only for troubleshooting) pandas DataFrame, each containing the SNP information for the corresponding bin + bafs: the ith element is the output from compute_baf_task(dfs[i]) + + Produces a BB file with a few additional columns. + """""" + + rows = [] + sample_names = sample_names[1:] # ignore the normal sample (first in the list) + for i in range(len(bins[0])): + start = bins[0][i] + end = bins[1][i] + totals = bins[2][i] + rdrs = bins[3][i] + + if dfs is not None: + assert dfs[i].POS.min() >= start and dfs[i].POS.max() <= end, ( + start, + end, + i, + dfs[i].POS.min(), + dfs[i].POS.max(), + ) + snpcounts_from_df = ( + dfs[i].pivot(index=""POS"", columns=""SAMPLE"", values=""TOTAL"").sum(axis=0) + ) + + for j in range(len(sample_names)): + sample = sample_names[j] + total = totals[j + 1] + normal_reads = totals[0] + rdr = rdrs[j] + + if dfs is not None: + nsnps, cov, baf, alpha, beta = bafs[i][sample] + assert snpcounts_from_df[sample] == alpha + beta, (i, sample) + else: + nsnps, cov, baf, alpha, beta = 0, 0, 0, 0, 0 + + rows.append( + [ + chromosome, + start, + end, + sample, + rdr, + nsnps, + cov, + alpha, + beta, + baf, + total, + normal_reads, + ] + ) + + return pd.DataFrame( + rows, + columns=[ + ""#CHR"", + ""START"", + ""END"", + ""SAMPLE"", + ""RD"", + ""#SNPS"", + ""COV"", + ""ALPHA"", + ""BETA"", + ""BAF"", + ""TOTAL_READS"", + ""NORMAL_READS"", + ], + ) + + +def get_chr_end(stem, chromosome): + fname = os.path.join(stem, chromosome + "".thresholds.gz"") + zcat = subprocess.Popen((""zcat"", fname), stdout=subprocess.PIPE) + tail = subprocess.Popen((""tail"", ""-1""), stdin=zcat.stdout, stdout=subprocess.PIPE) + last_start = int(tail.stdout.read().decode(""utf-8"").strip()) + + return last_start + + +def backtrack(bp): + n, p = bp.shape + + starts = [bp[-1, -1]] + for i in range(p - 1, 0, -1): + starts.append(bp[starts[-1] - 1, i - 1]) + + thresholds = starts[::-1] + [n] + return thresholds + + +def segmented_piecewise(X, pieces=2): + n, s = X.shape + segcost_memo = {} + + def segment_cost(i, j): + if (i, j) in segcost_memo: + return segcost_memo[i, j] + else: + my_mean = np.mean(X[i:j], axis=0) if j > i else 0 + result = np.sum(np.square(X[i:j] - my_mean)) + segcost_memo[i, j] = result + return result + + # penalty A[i, p] is the minimum error possible for fitting X[0] with p+1 pieces + A = np.zeros((n, pieces)) + backpoint = np.zeros((n, pieces), dtype=int) + + A[:, 0] = [segment_cost(0, i) for i in range(n)] + + for p in range(1, pieces): + for t in range(1, n): + # search over t' < t + best_cost = np.inf + best_tprime = None + for tprime in range(t + 1): + # compute cost for making a new segment from tprime through t + cost = A[tprime, p - 1] + segment_cost(tprime, t) + if cost < best_cost: + best_cost = cost + best_tprime = tprime + + A[t, p] = best_cost + backpoint[t, p] = ( + best_tprime # if this throws a TypeError for int(None), then X may have NaNs + ) + return A, backpoint + + +def correct_haplotypes( + orig_bafs, + min_prop_switch=0.01, + n_segments=20, + min_switch_density=0.1, + min_mean_baf=0.48, + minmax_al_imb=0.02, +): + n_bins = orig_bafs.shape[0] + if n_bins == 1: + sp.log( + msg=""Only one bin in the chromosome arm, skipping correction.\n"", + level=""INFO"", + ) + return orig_bafs, None + elif n_bins < n_segments: + # Assume that with this few bins, there is only 1 segment + sp.log( + msg=f""Only {orig_bafs.shape[0]} bins < {n_segments} segments parameter, using 1 segment instead.\n"", + level=""INFO"", + ) + n_segments = 1 + + # Count switches using only samples with mean allelic imbalance above + imb_samples = np.where(np.mean(np.abs(orig_bafs - 0.5), axis=0) > minmax_al_imb)[0] + + if len(imb_samples) == 0: + sp.log( + msg=f""No sample with avg. allelic imbalance above [{minmax_al_imb}], skipping correction.\n"", + level=""INFO"", + ) + return orig_bafs, None + + bafs = orig_bafs[:, imb_samples] + + # Look for haplotype switches + above_mid = bafs > 0.5 + is_alternating = np.concatenate( + [ + np.zeros((1, bafs.shape[1]), dtype=bool), + np.logical_xor(above_mid[1:], above_mid[:-1]), + ] + ) + haplotype_switches = np.where(np.all(is_alternating, axis=1))[0] + prop_switched = len(haplotype_switches) / len(is_alternating) + sp.log( + msg=f""Found haplotype switches in {prop_switched *100 : .2f}% of bins\n"", + level=""INFO"", + ) + + if prop_switched > min_prop_switch: + # If sufficient switches are found, run segmentation to identify segments w/ many switches + + sp.log( + msg=f""Checking haplotype switching using [{n_segments}] segments\n"", + level=""INFO"", + ) + # Segment using the mean BAFs only - faster and more reliable than using all samples + A, bp = segmented_piecewise( + np.mean(bafs, axis=1).reshape(-1, 1), pieces=n_segments + ) + + ts = backtrack(bp[:, :n_segments]) + + for idx in np.where(np.diff(ts) == 0)[0]: + del ts[idx] + + # hacky bugfix: handle bug where backtracking gets to 0 and then adds more segments... + new_start = np.where(np.array(ts) == 0)[0][-1] + ts = ts[new_start:] + + segments = [orig_bafs[ts[i] : ts[i + 1]] for i in range(len(ts) - 1)] + + # Identify problematic segments as those with many switches and mean near 0.5 + # (note that mean(BAF_i) across samples i is always <= 0.5 by def. from EM function) + switch_densities = np.array( + [ + len( + haplotype_switches[ + (haplotype_switches >= ts[i]) & (haplotype_switches < ts[i + 1]) + ] + ) + / (ts[i + 1] - ts[i]) + for i in range(len(ts) - 1) + ] + ) + segment_means = np.array( + [(np.mean(s) if len(s) > 0 else 0.5) for s in segments] + ) + + # ALSO only correct segments with allelic imbalance at least in at least 1 sample + segment_imbalances = np.array( + [ + ( + np.max(np.abs(0.5 - np.mean(np.minimum(s, 1 - s), axis=0))) + if len(s) > 0 + else 0 + ) + for s in segments + ] + ) + + """""" + segment_lengths = [len(s) for s in segments] + [sp.log(msg=f'Segment {i}: length {a},\tmean {b:.3f},\timbalance {c:.3f},\tswitch prop. {d:.3f}\n', + level = 'INFO') + for i, (a,b,c, d) + in enumerate(zip(segment_lengths, segment_means, segment_imbalances, switch_densities))] + """""" + + bad_segments = np.where( + np.logical_and( + np.logical_and( + switch_densities >= min_switch_density, + segment_means >= min_mean_baf, + ), + segment_imbalances >= minmax_al_imb, + ) + )[0] + + sp.log( + msg=f""Identified {len(bad_segments)} segments with haplotype switching\n"", + level=""INFO"", + ) + final_segments = [] + + for s_idx in range(len(segments)): + if s_idx in bad_segments: + seg = segments[s_idx].copy() + assert ( + len(seg) > 0 + ), ""Haplotype switch correction flagged a length-0 segment"" + + # Identify the sample with the most extreme allelic imbalance for this segment + minseg = np.minimum(seg, 1 - seg) + mmeans = np.mean(minseg, axis=0) + extreme_sample = np.argmin(mmeans) + + # Flip all of those bins with mhBAF > 0.5 in the corresponding sample + my_flips = np.where(seg[:, extreme_sample] > 0.5) + + seg[my_flips] = 1 - seg[my_flips] + + my_mean = np.mean(seg) + + # If this ends up choosing the haplotype that is more abundant on average, + if my_mean > 0.5: + # flip all bins to select the minor haplotype instead + seg = 1 - seg + + final_segments.append(seg) + else: + final_segments.append(segments[s_idx]) + + return np.concatenate(final_segments), ts + else: + sp.log( + msg=f""Insufficient haplotype switching detected (<[{min_prop_switch}]), skipping correction.\n"", + level=""INFO"", + ) + return orig_bafs, None + + +def run_chromosome( + baffile, + all_names, + chromosome, + outfile, + centromere_start, + centromere_end, + min_snp_reads, + min_total_reads, + arraystem, + xy, + multisample, + phasefile, + blocksize, + max_snps_per_block, + test_alpha, +): + """""" + Perform adaptive binning and infer BAFs to produce a HATCHet BB file for a single chromosome. + """""" + + try: + if os.path.exists(outfile): + sp.log( + msg=f""Output file already exists, skipping chromosome {chromosome}\n"", + level=""INFO"", + ) + return + + sp.log( + msg=f""Loading intermediate files for chromosome {chromosome}\n"", + level=""INFO"", + ) + total_counts = np.loadtxt( + os.path.join(arraystem, f""{chromosome}.total""), dtype=np.uint32 + ) + complete_thresholds = np.loadtxt( + os.path.join(arraystem, f""{chromosome}.thresholds""), + dtype=np.uint32, + ) + + # TODO: identify whether XX or XY, and only avoid SNPs/BAFs for XY + if xy: + sp.log( + msg=""Running on sex chromosome -- ignoring SNPs \n"", + level=""INFO"", + ) + min_snp_reads = 0 + + # TODO: do this procedure only for XY individuals + ### construct dummy SNP positions and all-0 snpcounts array for binning + before_centromere = complete_thresholds[ + complete_thresholds <= centromere_start + ] + after_centromere = complete_thresholds[ + complete_thresholds >= centromere_end + ] + positions_p = np.mean( + np.vstack([before_centromere[:-1], before_centromere[1:]]), + axis=0, + ).astype(np.uint64) + positions_q = np.mean( + np.vstack([after_centromere[:-1], after_centromere[1:]]), + axis=0, + ).astype(np.uint64) + positions = np.concatenate([positions_p, positions_q]) + snp_counts = np.zeros((len(positions), len(all_names) - 1), dtype=np.int8) + snpsv = None + + else: + # sp.log(msg=f""Reading SNPs file for chromosome {chromosome}\n"", level = ""INFO"") + # Load SNP positions and counts for this chromosome + positions, snp_counts, snpsv = read_snps( + baffile, chromosome, all_names, phasefile=phasefile + ) + + sp.log(msg=f""Binning p arm of chromosome {chromosome}\n"", level=""INFO"") + if len(np.where(positions <= centromere_start)[0]) > 0: + # There may not be a SNP between the centromere end and the next SNP threshold + # Goal for p arm is to END at the FIRST threshold that is AFTER the LAST SNP BEFORE the centromere + last_snp_before_centromere = positions[ + np.where(positions < centromere_start)[0][-1] + ] + last_threshold_before_centromere = complete_thresholds[ + np.where(complete_thresholds > last_snp_before_centromere)[0][0] + ] + + p_idx = np.where(complete_thresholds <= last_threshold_before_centromere)[0] + p_thresholds = complete_thresholds[p_idx] + p_counts = total_counts[p_idx] + + p_snp_idx = np.where(positions <= last_threshold_before_centromere)[0] + p_positions = positions[p_snp_idx] + p_snpcounts = snp_counts[p_snp_idx] + + # Identify bins + bins_p = adaptive_bins_arm( + snp_thresholds=p_thresholds, + total_counts=p_counts, + snp_positions=p_positions, + snp_counts=p_snpcounts, + min_snp_reads=min_snp_reads, + min_total_reads=min_total_reads, + ) + + starts_p = bins_p[0] + ends_p = bins_p[1] + # Partition SNPs for BAF inference + + # Infer BAF + if xy: + # TODO: compute BAFs for XX + dfs_p = None + bafs_p = None + else: + dfs_p = [ + snpsv[(snpsv.POS >= starts_p[i]) & (snpsv.POS <= ends_p[i])] + for i in range(len(starts_p)) + ] + + if len(dfs_p) > 1: + for i in range(len(dfs_p)): + assert np.all( + dfs_p[i] + .pivot(index=""POS"", columns=""SAMPLE"", values=""TOTAL"") + .sum(axis=0) + >= min_snp_reads + ), i + + bafs_p = [ + compute_baf_wrapper( + d, + blocksize, + max_snps_per_block, + test_alpha, + multisample, + ) + for d in dfs_p + ] + + bb_p = merge_data(bins_p, dfs_p, bafs_p, all_names, chromosome) + + bafs_p = bb_p.pivot( + index=[""#CHR"", ""START""], columns=""SAMPLE"", values=""BAF"" + ).to_numpy() + if bafs_p.shape[0] > 2: + sp.log(msg=""Correcting haplotype switches on p arm...\n"", level=""STEP"") + # TODO: pass through other parameters to correct_haplotypes + corrected_bafs_p, _ = correct_haplotypes(bafs_p) + + sp.log( + msg=f""{len(bb_p)}, {len(bb_p.SAMPLE.unique())}, \ + {bafs_p.shape}, {corrected_bafs_p.shape} {corrected_bafs_p.flatten().shape}\n"", + level=""DEBUG"", + ) + + # flatten these results out and put them back into the BAF array + bb_p[""ORIGINAL_BAF""] = bb_p.BAF + bb_p[""BAF""] = corrected_bafs_p.flatten() + else: + sp.log(msg=f""No SNPs found in p arm for {chromosome}\n"", level=""INFO"") + bb_p = None + + sp.log(msg=f""Binning q arm of chromosome {chromosome}\n"", level=""INFO"") + + if len(np.where(positions >= centromere_end)[0]) > 0: + # There may not be a SNP between the centromere end and the next SNP threshold + # Goal for q arm is to start at the latest threshold that is before the first SNP after the centromere + first_snp_after_centromere = positions[ + np.where(positions > centromere_end)[0][0] + ] + first_threshold_after_centromere = complete_thresholds[ + np.where(complete_thresholds < first_snp_after_centromere)[0][-1] + ] + + q_idx = np.where(complete_thresholds >= first_threshold_after_centromere)[0] + q_thresholds = complete_thresholds[q_idx] + q_counts = total_counts[q_idx] + + q_snp_idx = np.where(positions >= first_threshold_after_centromere)[0] + q_positions = positions[q_snp_idx] + q_snpcounts = snp_counts[q_snp_idx] + + bins_q = adaptive_bins_arm( + snp_thresholds=q_thresholds, + total_counts=q_counts, + snp_positions=q_positions, + snp_counts=q_snpcounts, + min_snp_reads=min_snp_reads, + min_total_reads=min_total_reads, + ) + + starts_q = bins_q[0] + ends_q = bins_q[1] + + if xy: + dfs_q = None + bafs_q = None + else: + # Partition SNPs for BAF inference + dfs_q = [ + snpsv[(snpsv.POS >= starts_q[i]) & (snpsv.POS <= ends_q[i])] + for i in range(len(starts_q)) + ] + + if len(dfs_q) > 1: + for i in range(len(dfs_q)): + assert np.all( + dfs_q[i] + .pivot(index=""POS"", columns=""SAMPLE"", values=""TOTAL"") + .sum(axis=0) + >= min_snp_reads + ), i + + # Infer BAF + bafs_q = [ + compute_baf_wrapper( + d, + blocksize, + max_snps_per_block, + test_alpha, + multisample, + ) + for d in dfs_q + ] + + bb_q = merge_data(bins_q, dfs_q, bafs_q, all_names, chromosome) + + bafs_q = bb_q.pivot( + index=[""#CHR"", ""START""], columns=""SAMPLE"", values=""BAF"" + ).to_numpy() + if bafs_q.shape[0] > 2: + sp.log(msg=""Correcting haplotype switches on q arm...\n"", level=""STEP"") + # TODO: pass through other parameters to correct_haplotypes + corrected_bafs_q, _ = correct_haplotypes(bafs_q) + + # flatten these results out and put them back into the BAF array + bb_q[""ORIGINAL_BAF""] = bb_q.BAF + bb_q[""BAF""] = corrected_bafs_q.flatten() + else: + sp.log(msg=f""No SNPs found in q arm for {chromosome}\n"", level=""INFO"") + bb_q = None + + if bb_p is None and bb_q is None: + raise ValueError( + sp.error(f""No SNPs found on either arm of chromosome {chromosome}!"") + ) + + bb = pd.concat([bb_p, bb_q]) + bb.to_csv(outfile, index=False, sep=""\t"") + # np.savetxt(outfile + '.totalcounts', total_counts) + # np.savetxt(outfile + '.thresholds', complete_thresholds) + + sp.log(msg=f""Done chromosome {chromosome}\n"", level=""INFO"") + except Exception as e: + sp.log(msg=f""Error in chromosome {chromosome}:"", level=""ERROR"") + sp.log(msg=str(e), level=""ERROR"") + traceback.print_exc() + raise e + + +def run_chromosome_wrapper(param): + run_chromosome(*param) + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/Supporting.py",".py","5867","226","import sys +import os +import os.path +import subprocess +import datetime +import requests +import hashlib +from urllib.parse import urlparse +import tarfile +from string import ascii_uppercase + + +def checksum(filepath): + return hashlib.md5(open(filepath, ""rb"").read()).hexdigest() + + +def naturalOrder(text): + return [int(s) if s.isdigit() else ord(s) for s in text] + + +def numericOrder(text): + if len(digits(text)) > 0: + return int(digits(text)) + else: + if not (text.endswith(""X"") or text.endswith(""Y"")): + raise ValueError(f""Found chromosome ID that is not numeric or X/Y: {text}"") + return ascii_uppercase.index(text[-1]) + + +def digits(string): + return """".join(x for x in string if x.isdigit()) + + +def argmax(d): + return max(d, key=(lambda x: d[x])) + + +def argmin(d): + return min(d, key=(lambda x: d[x])) + + +def to_tuple(s, n=2, typ=int, error_message=None): + if error_message is None: + error_message = f""Unable to parse {s} into a tuple of type {typ}"" + if n is not None: + error_message += f"" of length {n}"" + + parsed = s.strip().replace("" "", """").replace(""("", """").replace("")"", """").split("","") + + try: + if n is not None: + assert len(parsed) == n + + parsed = [typ(p) for p in parsed] + except (AssertionError, ValueError): + raise + else: + return parsed + + +def which(program): + def is_exe(fpath): + return os.path.isfile(fpath) and os.access(fpath, os.X_OK) + + fpath, fname = os.path.split(program) + if fpath: + if is_exe(program): + return program + else: + for path in os.environ[""PATH""].split(os.pathsep): + path = path.strip('""') + exe_file = os.path.join(path, program) + if is_exe(exe_file): + return exe_file + + return None + + +def url_exists(path): + r = requests.head(path) + return r.status_code == requests.codes.ok + + +class bcolors: + HEADER = ""\033[95m"" + OKBLUE = ""\033[94m"" + BBLUE = ""\033[96m"" + OKGREEN = ""\033[92m"" + WARNING = ""\033[93m"" + FAIL = ""\033[91m"" + ENDC = ""\033[0m"" + BOLD = ""\033[1m"" + UNDERLINE = ""\033[4m"" + + +# format strings with 'timestamp' and 'msg' as placeholders +MSG_FORMAT_STRINGS = { + ""STEP"": bcolors.BOLD + bcolors.HEADER + ""[{timestamp}]{msg}"" + bcolors.ENDC, + ""INFO"": bcolors.OKGREEN + ""{msg}"" + bcolors.ENDC, + ""WARN"": bcolors.WARNING + ""{msg}"" + bcolors.ENDC, + ""PROGRESS"": bcolors.BBLUE + ""{msg}"" + bcolors.ENDC, + ""ERROR"": bcolors.FAIL + ""{msg}"" + bcolors.ENDC, +} + + +def log( + msg, + level=None, + lock=None, + raise_exception=False, + exception_class=ValueError, +): + timestamp = ""{:%Y-%b-%d %H:%M:%S}"".format(datetime.datetime.now()) + format_string = MSG_FORMAT_STRINGS.get(level) or ""{msg}"" + formatted_msg = format_string.format(msg=msg, timestamp=timestamp) + + if lock is None: + sys.stderr.write(formatted_msg) + else: + with lock: + sys.stderr.write(formatted_msg) + + if level == ""ERROR"" and raise_exception: + raise exception_class(msg) + else: + return formatted_msg + + +def logArgs(args, width=40): + text = ""\n"" + for key in args: + text += ""\t{}: {}\n"".format(key, args[key]) + log(msg=text, level=""INFO"") + + +def error(msg, raise_exception=False, exception_class=ValueError): + return log( + msg, + level=""ERROR"", + raise_exception=raise_exception, + exception_class=exception_class, + ) + + +def ensure(pred, msg, exception_class=ValueError): + if not pred: + return error(msg, raise_exception=True, exception_class=exception_class) + + +def close(msg): + log(msg=msg, level=""WARN"") + sys.exit(0) + + +def run( + commands, + stdouterr_filepath=None, + check_return_codes=True, + error_msg=None, + stdouterr_filepath_autoremove=True, + **kwargs, +): + singleton = isinstance(commands, str) + if singleton: + commands = [commands] + return_codes = [] + + # Very commonly used options in our code + if ""universal_newlines"" not in kwargs: + kwargs[""universal_newlines""] = True + if ""shell"" not in kwargs: + kwargs[""shell""] = True + + f = open(stdouterr_filepath, ""w"") if stdouterr_filepath is not None else None + for command in commands: + p = subprocess.run(command, stdout=f, stderr=f, **kwargs) + return_codes.append(p.returncode) + if f: + f.close() + + if check_return_codes: + if error_msg is None: + error_msg = 'Command ""{command}"" did not run successfully.' + if stdouterr_filepath: + error_msg += f"" Please check {stdouterr_filepath} for possible hints."" + + for command, return_code in zip(commands, return_codes): + if return_code != 0: + error(error_msg.format(command=command), raise_exception=True) + + if stdouterr_filepath and stdouterr_filepath_autoremove: + os.remove(stdouterr_filepath) + + return return_codes[0] if singleton else return_codes + + +def download( + url, + dirpath, + overwrite=False, + extract=True, + sentinel_file=None, + chunk_size=8192, +): + out_basename = os.path.basename(urlparse(url).path) + out_filepath = os.path.join(dirpath, out_basename) + + if sentinel_file is None or not os.path.exists( + os.path.join(dirpath, sentinel_file) + ): + if overwrite or not os.path.exists(out_filepath): + with requests.get(url, stream=True) as r: + r.raise_for_status() + with open(out_filepath, ""wb"") as f: + for chunk in r.iter_content(chunk_size=chunk_size): + f.write(chunk) + + if ( + out_basename.endswith("".tar.gz"") or out_basename.endswith("".tgz"") + ) and extract: + t = tarfile.open(out_filepath) + t.extractall(dirpath) + t.close() + + return out_filepath +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/plot_cn_1d2d.py",".py","23210","735","import os +from collections import Counter +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns +import matplotlib.colors as mcolors +from matplotlib import collections +from matplotlib.patches import Rectangle + +from hatchet.utils.ArgParsing import parse_plot_cn_1d2d_args +from hatchet.utils.Supporting import log, logArgs, error + +plt.rcParams[""savefig.dpi""] = 300 +plt.style.use(""ggplot"") +sns.set_style(""whitegrid"") + +MAX_CLONES = 20 + + +def main(args=None): + log(""# Checking and parsing input arguments\n"") + args = parse_plot_cn_1d2d_args(args) + logArgs(args, 80) + + ### THESE VARIABLES ARE CURRENTLY DUMMIES ### + # Consider exposing these as command-line arguments in the future + title = None + resample_balanced = False + + generate_1D2D_plots( + bbc=pd.read_table(args[""input""]), + fcn_lim=(args[""minfcn""], args[""maxfcn""]), + baf_lim=(args[""minbaf""], args[""maxbaf""]), + by_sample=args[""bysample""], + outdir=args[""outdir""], + # dummy variables + title=title, + show_centromeres=args[""centromeres""], + resample_balanced=resample_balanced, + ) + + +def generate_1D2D_plots( + bbc, + fcn_lim=None, + baf_lim=None, + title=None, + show_centromeres=False, + by_sample=False, + outdir=None, + resample_balanced=False, +): + if ""#CHR"" not in bbc: + # throw HATCHet error + raise ValueError(""Input table is malformed (missing #CHR column)"") + + # Prepend 'chr' to #CHR column if not already present + using_chr = [str(a).startswith(""chr"") for a in bbc[""#CHR""].unique()] + if any(using_chr): + if not all(using_chr): + raise ValueError( + error(""Some chromosomes use 'chr' notation while others do not."") + ) + use_chr = True + else: + use_chr = False + if not use_chr: + bbc = bbc.copy() + bbc[""#CHR""] = ""chr"" + bbc[""#CHR""].astype(""str"") + + ### code below assumes that chromosomes in BBC table are named with prefix 'chr' ### + chrlengths = {str(c): df.END.max() for c, df in bbc.groupby(""#CHR"")} + chr_ends = [0] + for i in range(22): + chr_ends.append(chr_ends[-1] + chrlengths.get(f""chr{i + 1}"", 0)) + + n_clones = max([i for i in range(MAX_CLONES) if f""cn_clone{i}"" in bbc.columns]) + _, mapping = reindex( + [k for k, _ in bbc.groupby([f""cn_clone{i + 1}"" for i in range(n_clones)])] + ) + + ss_bbc = bbc[bbc.SAMPLE == bbc.iloc[0].SAMPLE] + break_idx = np.where( + np.logical_and( + ss_bbc.END.to_numpy()[:-1] != ss_bbc.START.to_numpy()[1:], + ss_bbc[""#CHR""].to_numpy()[:-1] == ss_bbc[""#CHR""].to_numpy()[1:], + ) + )[0] + chr2centro = {} + for i in break_idx: + rows = ss_bbc.iloc[i : i + 2] + chr2centro[rows.iloc[0][""#CHR""]] = ( + rows.iloc[0].END, + rows.iloc[1].START, + ) + + if resample_balanced: + # Reflect BAF about 0.5 w.p. 0.5 for clusters where all clones are balanced + bbc = bbc.copy() + pt = pd.concat( + [ + bbc[f""cn_clone{i}""].str.split(""|"", expand=True) + for i in range(1, n_clones + 1) + ], + axis=1, + ) + + balanced_indices = pt[0].to_numpy() == pt[1].to_numpy() + + if n_clones > 1: + balanced_indices = balanced_indices.all(axis=1) + + np.random.seed(0) + flips = np.random.randint(2, size=np.count_nonzero(balanced_indices)) + bbc.loc[balanced_indices, ""BAF""] = np.choose( + flips, + [ + bbc.loc[balanced_indices, ""BAF""], + 1 - bbc.loc[balanced_indices, ""BAF""], + ], + ) + + log(""Plotting copy-number states in 2D\n"", level=""INFO"") + if by_sample: + plot_clusters( + bbc, + mapping, + xlim=baf_lim, + ylim=fcn_lim, + dpi=300, + save_samples=True, + save_prefix=os.path.join(outdir, ""2D""), + ) + else: + plot_clusters( + bbc, + mapping, + xlim=baf_lim, + ylim=fcn_lim, + dpi=300, + fname=os.path.join(outdir, ""2D-plot.png""), + ) + + log(""Plotting copy-number segments in 1D along the genome\n"", level=""INFO"") + if by_sample: + plot_genome( + bbc, + mapping, + chr_ends, + chr2centro, + show_centromeres=show_centromeres, + baf_ylim=baf_lim, + fcn_ylim=fcn_lim, + save_samples=True, + save_prefix=os.path.join(outdir, ""1D""), + ) + else: + plot_genome( + bbc, + mapping, + chr_ends, + chr2centro, + show_centromeres=show_centromeres, + baf_ylim=baf_lim, + fcn_ylim=fcn_lim, + fname=os.path.join(outdir, ""1D-plot.png""), + ) + + log(""Done\n"", level=""INFO"") + + +def limits_valid(lim): + return ( + lim is not None and len(lim) == 2 and lim[0] is not None and lim[1] is not None + ) + + +def recompose_state(l): + """""" + Read copy-number state vector from list of allele-specific values + """""" + r = [] + for i in range(int(len(l) / 2)): + r.append((int(l[i * 2]), int(l[i * 2 + 1]))) + return tuple(r) + + +str2cn = lambda x: tuple([int(a) for a in x.split(""|"")]) +cn2totals = lambda x: tuple(sum(a) for a in x) +str2state = lambda cn: tuple([int(a) for a in cn.split(""|"")]) + + +def reindex(labels): + """""" + Given a list of labels, reindex them as integers from 1 to n_labels + Labels are in nonincreasing order of prevalence + """""" + old2new = {} + j = 1 + for i, _ in Counter(labels).most_common(): + old2new[i] = j + j += 1 + old2newf = lambda x: old2new[x] + + return [old2newf(a) for a in labels], old2new + + +def cn2total(s): + tkns = s.split(""|"") + assert len(tkns) == 2 + return int(tkns[0]) + int(tkns[1]) + + +def compute_gamma(bbc): + bbc = bbc.reset_index(drop=True) + n_clones = int((len(bbc.columns) - 13) / 2) + bbc[""fractional_cn""] = sum( + [ + bbc.iloc[:, 11 + 2 * i].map(cn2total) * bbc.iloc[:, 12 + 2 * i] + for i in range(n_clones + 1) + ] + ) + largest_clone = np.argmax( + [bbc[""u_clone{}"".format(i + 1)][0] for i in range(n_clones)] + ) + dominant_cns = Counter(bbc[""cn_clone{}"".format(largest_clone + 1)]) + balanced_options = set([""1|1"", ""2|2"", ""3|3"", ""4|4""]) + largest_balanced = max(balanced_options, key=lambda x: dominant_cns[x]) + balanced_idx = [ + i + for i in range(len(bbc)) + if all( + [ + bbc[""cn_clone{}"".format(j + 1)][i] == largest_balanced + for j in range(n_clones) + ] + ) + and bbc.loc[i, ""RD""] > 0 + ] + if len(balanced_idx) == 0: + balanced_options.remove(largest_balanced) + largest_balanced = max(balanced_options, key=lambda x: dominant_cns[x]) + balanced_idx = [ + i + for i in range(len(bbc)) + if all( + [ + bbc[""cn_clone{}"".format(j + 1)][i] == largest_balanced + for j in range(n_clones) + ] + ) + and bbc.loc[i, ""RD""] > 0 + ] + + # print(""Computing gamma using {} balanced bins across all {} clones"".format(len(balanced_idx), n_clones)) + return n_clones, np.mean( + bbc.iloc[balanced_idx].fractional_cn / bbc.iloc[balanced_idx].RD + ) + + +def cn2evs(cns, props): + assert len(cns) == len(props) + A = np.array([x[0] for x in cns]) + B = np.array([x[1] for x in cns]) + + return np.sum((A + B) * props), np.sum(B * props) / np.sum((A + B) * props) + + +def plot_genome( + big_bbc, + mapping, + chr_ends, + chr2centro, + chromosomes=None, + dpi=400, + figsize=(8, 5), + fname=None, + show_centromeres=False, + fcn_ylim=None, + baf_ylim=None, + save_samples=False, + save_prefix=None, +): + if save_samples: + if save_prefix is None: + raise ValueError( + ""If save_samples=True, 1D plotting requires filename prefix in [save_prefix] but found [None]."" + ) + + big_bbc = big_bbc.copy() + np.random.seed(0) + + colors1 = plt.cm.tab20b(np.arange(20)) + colors2 = plt.cm.tab20c(np.arange(20)) + + # combine them and build a new colormap + colors = np.vstack((colors1, colors2)) + cmap = mcolors.LinearSegmentedColormap.from_list(""my_colormap"", colors) + + samples = big_bbc.SAMPLE.unique() + + if save_samples: + fig, axes = plt.subplots(2, dpi=dpi, figsize=figsize) + else: + fig, axes = plt.subplots( + 2 * len(samples), + dpi=dpi, + figsize=(figsize[0], int(len(samples) * figsize[1])), + ) + + n_states = len(mapping) + mapping = mapping.copy() + + n_bins = len(big_bbc) / len(samples) + + # markersize decreases from 4 at 1-500 bins to 1 at >1500 bins + markersize = int(max(1, 4 - np.floor(n_bins / 500))) + + if n_states <= 20: + cmap = plt.get_cmap(""tab20"") + mapping = {k: v % 20 for k, v in mapping.items()} + + else: + colors1 = plt.cm.tab20b(np.arange(20)) + colors2 = plt.cm.tab20c(np.arange(20)) + + # combine them and build a new colormap + colors = np.vstack((colors1, colors2)) + cmap = mcolors.LinearSegmentedColormap.from_list(""my_colormap"", colors) + mapping = {k: v % 40 / n_states for k, v in mapping.items()} + + for idx, sample in enumerate(samples): + if save_samples: + # Ignore the sample index and write on first 2 axes + idx = 0 + + bbc_ = big_bbc[big_bbc.SAMPLE == sample] + bbc_ = bbc_.reset_index(drop=True) + + if chromosomes is None: + # chromosomes = sorted(big_bbc['#CHR'].unique(), key = lambda x: int(x[3:])) + # WARNING: THIS WILL PUT CHROMOSOMES OUT OF ORDER IF USING 'chr' NOTATION + chromosomes = sorted(bbc_[""#CHR""].unique()) + + n_clones = max([i for i in range(MAX_CLONES) if f""cn_clone{i}"" in bbc_.columns]) + props = np.array([bbc_.iloc[0, 2 * i + 12] for i in range(n_clones + 1)]).round( + 6 + ) + n_clones2, gamma = compute_gamma(bbc_) + assert n_clones2 == n_clones + + # fig, axes = plt.subplots(2, 1, dpi = dpi, figsize = figsize) + + if limits_valid(fcn_ylim): + minFCN, maxFCN = fcn_ylim + else: + minFCN = np.min(bbc_.RD * gamma) + maxFCN = np.max(bbc_.RD * gamma) + + if limits_valid(baf_ylim): + minBAF, _ = baf_ylim + else: + minBAF = np.min(bbc_.BAF) + maxBAF = np.max(bbc_.BAF) + + chrkey = ""CHR"" if ""CHR"" in bbc_.columns else ""#CHR"" + + for chromosome in chromosomes: + bbc = bbc_[bbc_[chrkey] == chromosome] + chr_start = chr_ends[int(chromosome[3:]) - 1] + + flag = bbc[""#CHR""] == chromosome + bbc = bbc[flag] + + midpoint = np.mean(np.array([bbc.START, bbc.END]), axis=0) + chr_start + + # Add black bars indicating expected values for CN states + fcn_lines = [] + baf_lines = [] + colors = [] + for _, r in bbc.iterrows(): + x0 = r.START + chr_start + x1 = r.END + chr_start + state = [(1, 1)] + [ + str2state(r[f""cn_clone{i + 1}""]) for i in range(n_clones) + ] + y_fcn, y_baf = cn2evs(state, props) + fcn_lines.append([(x0, y_fcn), (x1, y_fcn)]) + baf_lines.append([(x0, y_baf), (x1, y_baf)]) + + colors.append((0, 0, 0, 1)) + + lc_fcn = collections.LineCollection(fcn_lines, linewidth=2, colors=colors) + axes[idx * 2 + 0].add_collection(lc_fcn) + lc_baf = collections.LineCollection(baf_lines, linewidth=2, colors=colors) + axes[idx * 2 + 1].add_collection(lc_baf) + + if show_centromeres: + if chromosome in chr2centro: + centro = chr2centro[chromosome] + axes[idx * 2 + 0].add_patch( + Rectangle( + (centro[0] + chr_start, minFCN - 0.1), + centro[1] - centro[0], + maxFCN - minFCN + 0.2, + linewidth=0, + color=(0, 0, 0, 0.4), + ) + ) + axes[idx * 2 + 1].add_patch( + Rectangle( + (centro[0] + chr_start, minBAF - 0.02), + centro[1] - centro[0], + maxBAF - minBAF + 0.04, + linewidth=0, + color=(0, 0, 0, 0.4), + ) + ) + + if n_clones == 1: + my_colors = [cmap(mapping[tuple([r])]) for r in bbc.cn_clone1] + else: + my_colors = [ + cmap(mapping[tuple(r)]) + for _, r in bbc[ + [f""cn_clone{i + 1}"" for i in range(n_clones)] + ].iterrows() + ] + + axes[idx * 2 + 0].scatter( + midpoint, bbc.RD * gamma, s=markersize, alpha=1, c=my_colors + ) + axes[idx * 2 + 1].scatter( + midpoint, bbc.BAF, s=markersize, alpha=1, c=my_colors + ) + + if show_centromeres: + axes[idx * 2 + 0].grid(False) + axes[idx * 2 + 1].grid(False) + + if limits_valid(fcn_ylim): + axes[idx * 2 + 0].set_ylim(fcn_ylim) + else: + axes[idx * 2 + 0].set_ylim([minFCN - 0.1, maxFCN + 0.1]) + + axes[idx * 2 + 0].set_xlim([0, chr_ends[-1]]) + axes[idx * 2 + 0].set_ylabel(""Fractional copy number"") + + if limits_valid(baf_ylim): + axes[idx * 2 + 1].set_ylim(baf_ylim) + else: + axes[idx * 2 + 1].set_ylim([minBAF - 0.02, maxBAF + 0.02]) + + axes[idx * 2 + 1].set_xlim([0, chr_ends[-1]]) + axes[idx * 2 + 1].set_ylabel(""Mirrored haplotype BAF"") + + axes[idx * 2 + 0].vlines( + chr_ends[1:-1], + minFCN - 0.1, + maxFCN + 0.1, + linewidth=0.5, + colors=""k"", + ) + axes[idx * 2 + 1].vlines( + chr_ends[1:-1], + minBAF - 0.02, + (1 - minBAF) + 0.02, + linewidth=0.5, + colors=""k"", + ) + axes[idx * 2 + 1].hlines( + y=0.5, + xmin=0, + xmax=chr_ends[-1], + colors=""grey"", + linestyle="":"", + linewidth=1, + ) + xtick_labels = [f""chr{i}"" for i in range(1, 23)] + xtick_locs = [(chr_ends[i] + chr_ends[i + 1]) / 2 for i in range(22)] + axes[idx * 2 + 0].set_xticks(xtick_locs) + axes[idx * 2 + 0].set_xticklabels(xtick_labels) + axes[idx * 2 + 0].tick_params(axis=""x"", rotation=70) + axes[idx * 2 + 1].set_xticks(xtick_locs) + axes[idx * 2 + 1].set_xticklabels(xtick_labels) + axes[idx * 2 + 1].tick_params(axis=""x"", rotation=70) + + axes[idx * 2 + 0].title.set_text(f""Sample: {sample}"") + axes[idx * 2 + 1].title.set_text(f""Sample: {sample}"") + + axes[idx * 2 + 0].grid(False) + axes[idx * 2 + 1].grid(False) + + if save_samples: + plt.tight_layout() + plt.savefig(f""{save_prefix}_{sample}.png"") + plt.close() + fig, axes = plt.subplots(2, dpi=dpi, figsize=figsize) + + if not save_samples and fname is not None: + plt.tight_layout() + plt.savefig(fname) + + plt.close() + + +def plot_clusters( + bbc, + mapping, + figsize=(4, 4), + fname=None, + dpi=300, + xlim=None, + ylim=None, + save_samples=False, + save_prefix=None, + coloring=""original"", +): + if save_samples: + if save_prefix is None: + raise ValueError( + ""If save_samples=True, 2D plotting requires filename prefix in [save_prefix] but found [None]."" + ) + + samples = bbc.SAMPLE.unique() + if save_samples: + fig, axs = plt.subplots(figsize=figsize) + else: + fig, axs = plt.subplots( + len(samples), figsize=(figsize[0], int(len(samples) * figsize[1])) + ) + + n_states = len(mapping) + mapping = mapping.copy() + + if n_states <= 20: + cmap = plt.get_cmap(""tab20"") + mapping = {k: v % 20 for k, v in mapping.items()} + + else: + colors1 = plt.cm.tab20b(np.arange(20)) + colors2 = plt.cm.tab20c(np.arange(20)) + + # combine them and build a new colormap + colors = np.vstack((colors1, colors2)) + cmap = mcolors.LinearSegmentedColormap.from_list(""my_colormap"", colors) + + # incorporate normalization in mapping + mapping = {k: v % 40 / n_states for k, v in mapping.items()} + + for idx, sample in enumerate(samples): + my_ax = axs[idx] if len(samples) > 1 and not save_samples else axs + + bbc_ = bbc[bbc.SAMPLE == sample] + bbc_ = bbc_.reset_index(drop=True) + + n_clones = max([i for i in range(MAX_CLONES) if f""cn_clone{i}"" in bbc_.columns]) + props = np.array([bbc_.iloc[0, 2 * i + 12] for i in range(n_clones + 1)]).round( + 6 + ) + n_clones2, gamma = compute_gamma(bbc_) + assert n_clones2 == n_clones, (n_clones2, n_clones) + + if n_clones == 1: + my_colors = [cmap(mapping[tuple([r])]) for r in bbc_.cn_clone1] + else: + my_colors = [ + cmap(mapping[tuple(r)]) + for _, r in bbc_[ + [f""cn_clone{i + 1}"" for i in range(n_clones)] + ].iterrows() + ] + + if coloring == ""local"": + # not yet implemented + raise NotImplementedError(""This coloring has not yet been implemented"") + + elif coloring == ""hybrid"": + my_ax.scatter(bbc_.BAF, bbc_.RD * gamma, c=my_colors, s=1) + + exs = [] + eys = [] + cs = [] + + present_clones = np.array([i for i, p in enumerate(props) if p > 0]) + + already_written = set() + for k, _ in bbc_.groupby([f""cn_clone{i + 1}"" for i in range(n_clones)]): + if type(k) is str: + # 1-clone case + state = [(1, 1), str2state(k)] + else: + state = [(1, 1)] + [str2state(a) for a in k] + state = [state[i] for i in present_clones] + + # some states may come up more than once + # (since they may only be different among clones not present in this sample) + statekey = ""|"".join([str(a) for a in state]) + if statekey in already_written: + continue + else: + already_written.add(statekey) + + ey, ex = cn2evs(state, props[present_clones]) + if all([a == state[1] for a in state[1:]]) and len(present_clones) > 2: + my_ax.annotate( + f""{str(state[1])} "", + (ex, ey), + fontsize=""x-small"", + fontweight=""bold"", + ha=""right"", + va=""center"", + ) + else: + my_ax.annotate( + f'{"","".join([str(a) for a in state[1:]])} ', + (ex, ey), + fontsize=""x-small"", + ha=""right"", + va=""center"", + ) + exs.append(ex) + eys.append(ey) + cs.append(cmap(mapping[k])) + + my_ax.scatter(exs, eys, s=10, c=cs, edgecolor=""k"", linewidth=0.8) + + legendstr = [] + for i in present_clones: + if i == 0: + legendstr.append(""Normal: {:.3f}"".format(bbc_.u_normal[0])) + else: + legendstr.append( + ""Clone {}: {:.3f}"".format(i, bbc_[""u_clone{}"".format(i)][0]) + ) + + else: + assert coloring == ""original"" + my_ax.scatter(bbc_.BAF, bbc_.RD * gamma, c=my_colors, s=1) + + exs = [] + eys = [] + cs = [] + for k, _ in bbc_.groupby([f""cn_clone{i + 1}"" for i in range(n_clones)]): + if type(k) is str: + state = [(1, 1), str2state(k)] + else: + state = [(1, 1)] + [str2state(a) for a in k] + ey, ex = cn2evs(state, props) + if all([a == state[1] for a in state[1:]]) and n_clones > 1: + my_ax.annotate( + f""{str(state[1])} "", + (ex, ey), + fontsize=""x-small"", + fontweight=""bold"", + ) + else: + my_ax.annotate( + f'{"","".join([str(a) for a in state[1:]])} ', + (ex, ey), + fontsize=""x-small"", + ) + exs.append(ex) + eys.append(ey) + cs.append(cmap(mapping[k])) + + my_ax.scatter(exs, eys, s=10, c=cs, edgecolor=""k"", linewidth=0.8) + + legendstr = [] + for i in range(n_clones + 1): + if i == 0: + legendstr.append(""Normal: {:.3f}"".format(bbc_.u_normal[0])) + else: + legendstr.append( + ""Clone {}: {:.3f}"".format(i, bbc_[""u_clone{}"".format(i)][0]) + ) + + handles = [Rectangle((0, 0), 1, 1, fc=""white"", ec=""white"", lw=0, alpha=0)] + my_ax.legend( + handles, + [""\n"".join(legendstr)], + loc=""best"", + fontsize=""small"", + fancybox=True, + framealpha=0.7, + handlelength=0, + handletextpad=0, + ) + + if len(samples) > 1: + my_ax.set_title(sample) + + if limits_valid(xlim): + my_ax.set_xlim(xlim) + else: + xmin, xmax = my_ax.get_xlim() + + if limits_valid(ylim): + my_ax.set_ylim(ylim) + ymin, ymax = ylim + else: + ymin, ymax = my_ax.get_ylim() + + my_ax.vlines( + ymin=ymin, + ymax=ymax, + x=0.5, + linestyle="":"", + linewidth=1, + colors=""grey"", + ) + my_ax.set_ylim(ymin, ymax) + + my_ax.set_ylabel(""Fractional Copy Number"") + if idx == len(samples) - 1 or save_samples: + my_ax.set_xlabel(""Mirrored haplotype BAF"") + + if save_samples: + plt.title(sample) + plt.tight_layout() + plt.savefig(f""{save_prefix}_{sample}.png"") + plt.close() + fig, axs = plt.subplots(figsize=figsize) + + if fname is not None and not save_samples: + plt.tight_layout() + plt.savefig(fname) + + plt.close() + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/plot_bins_1d2d.py",".py","8370","319","import os +import numpy as np +import seaborn as sns +import pandas as pd +import matplotlib.pyplot as plt +from matplotlib.patches import Rectangle +import matplotlib.colors as mcolors + +from hatchet.utils.ArgParsing import parse_plot_bins_1d2d_args +from hatchet.utils import Supporting as sp + +plt.rcParams[""savefig.dpi""] = 300 +plt.style.use(""ggplot"") +sns.set_style(""white"") + + +def main(args=None): + sp.log(""# Checking and parsing input arguments\n"") + args = parse_plot_bins_1d2d_args(args) + sp.logArgs(args, 80) + + bbc = pd.read_table(args[""bbc""]) + + segf = args[""seg""] + if segf is not None: + seg = pd.read_table(segf) + + show_centers = args[""centers""] + outdir = args[""outdir""] + alpha = args[""alpha""] + show_centromeres = args[""centromeres""] + + if args[""minbaf""] is not None: + baf_lim = args[""minbaf""], args[""maxbaf""] + else: + baf_lim = None + if args[""minrdr""] is not None: + rdr_lim = args[""minrdr""], args[""maxrdr""] + else: + rdr_lim = None + + colors1 = plt.cm.tab20b(np.arange(20)) + colors2 = plt.cm.tab20c(np.arange(20)) + + # combine them and build a new colormap + colors = np.vstack((colors1, colors2)) + global mymap + mymap = mcolors.LinearSegmentedColormap.from_list(""my_colormap"", colors) + + sp.log("" Starting plotting\n"", level=""STEP"") + + display = False # setting display=True produces plots when run interactively + plot_2d( + bbc=bbc, + seg=seg, + show_centers=show_centers, + xlim=baf_lim, + ylim=rdr_lim, + display=display, + outdir=outdir, + alpha=alpha, + ) + + plot_1d( + bbc=bbc, + baf_lim=baf_lim, + rdr_lim=rdr_lim, + display=display, + outdir=outdir, + alpha=alpha, + show_centromeres=show_centromeres, + ) + sp.log("" Done plotting\n"", level=""STEP"") + + +def plot_2d( + bbc, + seg=None, + show_centers=False, + xlim=None, + ylim=None, + figsize=(4, 4), + display=True, + outdir=None, + alpha=1, +): + """""" + For each sample, plot the mBAF and RDR of each bin colored by cluster. + Colors will match clusters in corresponding 1D plots. + """""" + for s, df in bbc.groupby(""SAMPLE""): + plt.figure(figsize=figsize) + plt.scatter(df.BAF, df.RD, c=df.CLUSTER, cmap=mymap, s=1, alpha=alpha) + plt.xlabel(""Mirrored BAF"") + plt.ylabel(""Read-depth ratio"") + + if ylim is not None: + plt.ylim(ylim) + ymin, ymax = ylim + else: + ymin = df.RD.min() + ymax = df.RD.max() + + if xlim is not None: + xlim = xlim[0], min(df.BAF.max() + 0.02, xlim[1]) + plt.xlim(xlim) + + plt.vlines( + ymin=ymin, + ymax=ymax, + x=0.5, + linestyle="":"", + linewidth=1, + colors=""grey"", + ) + + if show_centers: + my_seg = seg[seg.SAMPLE == s] + plt.scatter( + my_seg.BAF, + my_seg.RD, + c=my_seg[""#ID""], + cmap=mymap, + s=10, + linewidth=1, + edgecolor=""k"", + ) + + for _, r in my_seg.iterrows(): + plt.annotate(r[""#ID""], (r.BAF, r.RD)) + + plt.title(s) + plt.tight_layout() + + if outdir is not None: + plt.savefig(os.path.join(outdir, f""2D_{s}.png"")) + + if not display: + plt.close() + + +def plot_1d( + bbc, + baf_lim=None, + rdr_lim=None, + display=False, + outdir=None, + alpha=1, + show_centromeres=False, +): + # Prepend 'chr' to #CHR column if not already present + using_chr = [str(a).startswith(""chr"") for a in bbc[""#CHR""].unique()] + if any(using_chr): + if not all(using_chr): + raise ValueError( + sp.error(""Some chromosomes use 'chr' notation while others do not."") + ) + use_chr = True + else: + use_chr = False + if not use_chr: + bbc[""#CHR""] = ""chr"" + bbc[""#CHR""].astype(""str"") + + ### code below assumes that chromosomes in BBC table are named with prefix 'chr' ### + chrlengths = {str(c): df.END.max() for c, df in bbc.groupby(""#CHR"")} + chr_ends = [0] + for i in range(22): + chr_ends.append(chr_ends[-1] + chrlengths.get(f""chr{i + 1}"", 0)) + + # NOTE: this implementation assumes that the only gaps between bins are centromeres + # If this is not the case in the future this needs to be updated + chr2centro = {} + ss_bbc = bbc[bbc.SAMPLE == bbc.iloc[0].SAMPLE] + break_idx = np.where( + np.logical_and( + ss_bbc.END.to_numpy()[:-1] != ss_bbc.START.to_numpy()[1:], + ss_bbc[""#CHR""].to_numpy()[:-1] == ss_bbc[""#CHR""].to_numpy()[1:], + ) + )[0] + chr2centro = {} + for i in break_idx: + rows = ss_bbc.iloc[i : i + 2] + chr2centro[rows.iloc[0][""#CHR""]] = ( + rows.iloc[0].END, + rows.iloc[1].START, + ) + + for s, df in bbc.groupby(""SAMPLE""): + plt.figure(figsize=(8, 5.6)) + plt.title(s) + plt.subplot(211) + plot_track( + df, + chr_ends, + chr2centro, + yval=""RD"", + ylabel=""Read-depth ratio"", + color_field=""CLUSTER"", + ylim=rdr_lim, + display=display, + alpha=alpha, + title=s, + show_centromeres=show_centromeres, + ) + plt.gca().grid(False) + + plt.subplot(212) + plot_track( + df, + chr_ends, + chr2centro, + yval=""BAF"", + ylabel=""mhBAF"", + color_field=""CLUSTER"", + ylim=baf_lim, + display=display, + alpha=alpha, + title=s, + show_centromeres=show_centromeres, + ) + plt.gca().grid(False) + + if outdir is not None: + plt.savefig(os.path.join(outdir, f""1D_{s}.png"")) + + if not display: + plt.close() + + +def plot_track( + bb, + chr_ends, + chr2centro, + yval=""RD"", + ylabel=None, + display=True, + ylim=None, + alpha=1, + color_field=None, + title=None, + show_centromeres=False, +): + """""" + NOTE: this function assumes that + 1) bb contains data for a single sample + 2) chromosomes are specified using ""chr"" notation + """""" + xs = [ + int(r[""START""]) + + chr_ends[int(r[""#CHR""][3:]) - 1] + + 0.5 * (r[""END""] - r[""START""]) + for _, r in bb.iterrows() + ] + ys = bb[yval] + + markersize = int(max(1, 4 - np.floor(len(bb) / 500))) + + xtick_labels = [f""chr{i}"" for i in range(1, 23)] + xtick_locs = [(chr_ends[i] + chr_ends[i + 1]) / 2 for i in range(22)] + + if color_field is not None: + # TODO: throw specific value error if ""color_field"" is not a column in ""bb"" + plt.scatter(xs, ys, s=markersize, c=bb[color_field], alpha=alpha, cmap=mymap) + else: + plt.scatter(xs, ys, s=markersize, alpha=alpha) + + minx = np.min(xs) + maxx = np.max(xs) + + if ylim is not None: + plt.ylim(ylim) + miny = ylim[0] + maxy = ylim[1] + else: + miny = np.min(ys) + maxy = np.max(ys) + + plt.vlines(x=chr_ends[1:-1], ymin=miny, ymax=maxy, colors=""k"", linewidth=0.5) + if yval == ""BAF"": + plt.hlines( + y=0.5, + xmin=minx, + xmax=maxx, + colors=""grey"", + linestyle="":"", + linewidth=1, + ) + + if show_centromeres: + chromosomes = sorted(bb[""#CHR""].unique(), key=lambda x: int(x[3:])) + ax = plt.gca() + ax.grid(False) + for i, ch in enumerate(chromosomes): + chr_start = chr_ends[i] + if ch in chr2centro: + cent_start, cent_end = chr2centro[ch] + ax.add_patch( + Rectangle( + xy=(cent_start + chr_start, miny), + width=cent_end - cent_start, + height=maxy - miny, + linewidth=0, + color=(0, 0, 0, 0.3), + ) + ) + + plt.xlim([minx - 1, maxx + 1]) + plt.ylim([miny, maxy]) + plt.xticks(xtick_locs, xtick_labels, rotation=70) + + if title is not None: + plt.title(title) + if ylabel is None: + plt.ylabel(yval) + else: + plt.ylabel(ylabel) + + plt.tight_layout() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/plot_cn.py",".py","57879","1759","import sys +import os +import argparse +import warnings +import numpy as np +import seaborn as sns +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt +from matplotlib.backends.backend_pdf import PdfPages +from matplotlib.colors import LinearSegmentedColormap +from collections import Counter +from collections import deque +from itertools import cycle + +from hatchet.utils.Supporting import to_tuple +from hatchet import config, __version__ + +mpl.use(""Agg"") +plt.style.use(""ggplot"") +sns.set_style(""whitegrid"") + + +def parsing_arguments(args=None): + """""" + Parse command line arguments + Returns: + """""" + description = """" + parser = argparse.ArgumentParser( + prog=""hatchet plot-cn"", + description=description, + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + ""INPUT"", help=""One or more space-separated files in CN_BBC format"" + ) + parser.add_argument( + ""-n"", + ""--patientnames"", + required=False, + default=config.plot_cn.patientnames, + type=str, + help=""One or more space-separated patient names (default: inferred from filenames)"", + ) + parser.add_argument( + ""-u"", + ""--minu"", + required=False, + default=config.plot_cn.minu, + type=float, + help='Minimum proportion of a CNA to be considered subclonal (default: 0.2)""', + ) + parser.add_argument( + ""-x"", + ""--rundir"", + required=False, + default=config.plot_cn.rundir, + type=str, + help=""Running directory (default: current directory)"", + ) + parser.add_argument( + ""-b"", + ""--baseCN"", + required=False, + default=config.plot_cn.basecn, + type=int, + help=""Base copy number (default: inferred from tumor ploidy)"", + ) + parser.add_argument( + ""-sC"", + ""--figsizeclones"", + required=False, + default=config.plot_cn.figsizeclones, + type=str, + help='Size of clone plots in the form ""(X-SIZE, Y-SIZE)""', + ) + parser.add_argument( + ""-sP"", + ""--figsizecn"", + required=False, + default=config.plot_cn.figsizecn, + type=str, + help='Size of CN plots in the form ""(X-SIZE, Y-SIZE)""', + ) + parser.add_argument( + ""-sG"", + ""--figsizegrid"", + required=False, + default=config.plot_cn.figsizegrid, + type=str, + help='Size of grid plots in the form ""(X-SIZE, Y-SIZE)""', + ) + parser.add_argument( + ""-rC"", + ""--resolutionclones"", + required=False, + default=config.plot_cn.resolutionclones, + type=int, + help='Number of bins to merge together for plotting clone profiles (default: 100)""', + ) + parser.add_argument( + ""-rP"", + ""--resolutioncn"", + required=False, + default=config.plot_cn.resolutioncn, + type=int, + help='Number of bins to merge together for plotting proportions (default: 500)""', + ) + parser.add_argument( + ""-rG"", + ""--resolutiongrid"", + required=False, + default=config.plot_cn.resolutiongrid, + type=int, + help='Number of bins to merge together in grids (default: 100)""', + ) + parser.add_argument( + ""-e"", + ""--threshold"", + required=False, + default=config.plot_cn.threshold, + type=float, + help='Threshold used to classify a tumor into either diploid or tetraploid (default: 3.0)""', + ) + parser.add_argument( + ""--ymax"", + required=False, + default=config.plot_cn.ymax, + type=int, + help='Maximum values in y-axis (default: automatically inferred)""', + ) + parser.add_argument( + ""--ymin"", + required=False, + default=config.plot_cn.ymin, + type=int, + help='Minimum values in y-axis (default: automatically inferred)""', + ) + parser.add_argument( + ""--clonepalette"", + required=False, + default=config.plot_cn.clonepalette, + type=str, + help='Palette for coloring the clones among Set1, Set2, Set3, Paired (default: Set1)""', + ) + parser.add_argument( + ""--linkage"", + required=False, + default=config.plot_cn.linkage, + type=str, + help=( + ""Linkage method used for clustering (default: single, available (single, complete, average, weighted, "" + 'centroid, median, ward) from SciPy)""' + ), + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args(args) + + if len(args.INPUT.split()) == 0: + raise ValueError(error(""Please specify at least one sample as input!"")) + if args.patientnames is None: + patientnames = {fil: os.path.basename(fil) for fil in args.INPUT.split()} + else: + patientnames = { + f: n for f, n in zip(args.INPUT.split(), args.patientnames.split()) + } + if len(args.INPUT.split()) != len(set(patientnames.values())): + raise ValueError( + error(""Multiple patients have the same name but they should unique!"") + ) + if args.figsizeclones is not None: + figsizeclones = to_tuple( + args.figsizeclones, error_message=""Wrong format of figsizeclones!"" + ) + if args.figsizecn is not None: + figsizecn = to_tuple(args.figsizecn, error_message=""Wrong format of figsizecn!"") + if args.figsizegrid is not None: + figsizegrid = to_tuple( + args.figsizegrid, error_message=""Wrong format of figsizegrid!"" + ) + + if not os.path.isdir(args.rundir): + raise ValueError(error(""Running directory does not exist!"")) + if not 0.0 <= args.minu <= 1.0: + raise ValueError( + error(""The minimum proportion for subclonal CNAs must be in [0, 1]!"") + ) + if args.baseCN is not None and args.baseCN < 2: + raise ValueError(error(""Base CN must be greater or equal than 2!"")) + if args.resolutionclones is not None and args.resolutionclones < 1: + raise ValueError(error(""Resolution must be greater than 1!"")) + if args.resolutioncn is not None and args.resolutioncn < 1: + raise ValueError(error(""Resolution must be greater than 1!"")) + if args.resolutiongrid is not None and args.resolutiongrid < 1: + raise ValueError(error(""Resolution must be greater than 1!"")) + if args.threshold < 0: + raise ValueError(error(""Threshold must be positive!"")) + if args.linkage not in { + ""single"", + ""complete"", + ""average"", + ""weighted"", + ""centroid"", + ""median"", + ""ward"", + }: + raise ValueError(error(""Unknown linkage method!"")) + + if args.clonepalette == ""Set1"": + pal = plt.cm.Set1 + elif args.clonepalette == ""Set2"": + pal = plt.cm.Set2 + elif args.clonepalette == ""Set3"": + pal = plt.cm.Set3 + elif args.clonepalette == ""Paired"": + pal = plt.cm.Paired + else: + raise ValueError(error(""Unknown clone palette!"")) + + return { + ""input"": args.INPUT.split(), + ""names"": patientnames, + ""rundir"": args.rundir, + ""minu"": args.minu, + ""base"": args.baseCN, + ""clonefigsize"": figsizeclones, + ""propsfigsize"": figsizecn, + ""clusterfigsize"": figsizegrid, + ""profileres"": args.resolutionclones, + ""cnres"": args.resolutioncn, + ""clusterres"": args.resolutiongrid, + ""threshold"": args.threshold, + ""linkage"": args.linkage, + ""ymax"": args.ymax, + ""ymin"": args.ymin, + ""clonepalette"": pal, + } + + +def main(args=None): + sys.stderr.write(log(""# Checking and parsing input arguments\n"")) + args = parsing_arguments(args) + sys.stdout.write( + info(""\n"".join([""## {}:\t{}"".format(key, args[key]) for key in args]) + ""\n"") + ) + + sys.stderr.write(log(""# Read BBC.UCN files\n"")) + tumors, clones, props = readUCN(args[""input""], args[""names""]) + + sys.stderr.write( + log(""# Compute purity and tumor ploidy of each sample from each patient\n"") + ) + infbase = pp(tumors, clones, props, args) + + if args[""base""] is None: + sys.stderr.write(log(""# The estimated basic copy number for each patient is\n"")) + sys.stderr.write( + info(""\n"".join([""## {}: {}"".format(b, infbase[b]) for b in infbase]) + ""\n"") + ) + base = infbase + else: + base = {pat: args[""base""] for pat in tumors} + + if len(tumors) == 1: + sys.stderr.write(log(""# Intra-tumor analysis\n"")) + single( + tumors[list(tumors)[0]], + clones[list(clones)[0]], + props[list(props)[0]], + base[list(base)[0]], + args, + ) + else: + sys.stderr.write(log(""# Inter-tumors analysis\n"")) + multiple(tumors, clones, props, base, args) + + +def pp(tumor, clones, props, args): + bases = {} + for patient in tumor: + sys.stderr.write(info(""## PATIENT: {}\n"".format(patient))) + counter = [] + for sample in props[patient]: + purity = sum( + float(props[patient][sample][i]) + for i in props[patient][sample] + if i != ""normal"" + ) + scaled = { + i: (props[patient][sample][i] / purity) if purity > 0.0 else 0.0 + for i in props[patient][sample] + if i != ""normal"" + } + length = sum( + float(s[1] - s[0]) for c in tumor[patient] for s in tumor[patient][c] + ) + ploidy = ( + sum( + float(sum(tumor[patient][c][s][i])) * float(s[1] - s[0]) * scaled[i] + for c in tumor[patient] + for s in tumor[patient][c] + for i in scaled + ) + / length + ) + wgd = 2 if ploidy < args[""threshold""] else 4 + sys.stderr.write( + info( + ""### SAMPLE: {} -- PURITY: {} -- PLOIDY: {} -- CLASSIFICATION: {}\n"".format( + sample, + purity, + ploidy, + ""DIPLOID"" if wgd == 2 else ""TETRAPLOID"", + ) + ) + ) + counter.append(wgd) + counter = Counter(counter) + bases[patient] = argmax(counter) + return bases + + +def single(tumor, clones, props, base, args): + out = ""intratumor-clones-totalcn.pdf"" + sys.stderr.write( + log( + ""# Plotting total copy-number clone profiles in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + profiles(tumor, clones, props, args, out) + + out = ""intratumor-clones-allelecn.pdf"" + sys.stderr.write( + log( + ""# Plotting allele-specific copy-number clone profiles in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + allelicprofiles(tumor, clones, props, args, out) + + out = ""intratumor-copynumber-totalcn.pdf"" + sys.stderr.write( + log( + ""# Plotting total copy-number proportions in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + cnproportions(tumor, base, clones, props, args, out) + + out = ""intratumor-copynumber-allelecn.pdf"" + sys.stderr.write( + log( + ""# Plotting allele-specific copy-number proportions in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + allelicproportions(tumor, int(float(base) / 2), clones, props, args, out) + + out = ""intratumor-profiles.pdf"" + sys.stderr.write( + log( + ""# Plotting clone profiles in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + gridprofiles(tumor, base, clones, props, args, out) + + out = ""intratumor-profilesreduced.pdf"" + sys.stderr.write( + log( + ""# Plotting reduced-clone profiles in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + gridprofilesreduced(tumor, base, clones, props, args, out) + + # Run tumor mixture analyses if we have a multiple tumor samples (keys in props) + if len(props) > 1: + out = ""intratumor-mixtures.pdf"" + sys.stderr.write( + log( + ""# Plotting reduced mixtures in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + gridmixtures(tumor, base, clones, props, args, out) + + out = ""intratumor-subclonality.pdf"" + sys.stderr.write( + log( + ""# Plotting reduced mixtures in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + subclonal(tumor, base, clones, props, args, out) + + +def profiles(tumor, clones, props, args, out): + proj = join(tumor, clones, args[""profileres""]) + + tclones = [i for i in clones if i != ""normal""] + shift = 0.1 + if len(tclones) % 2 == 0: + available = [-shift / 2] + [ + -shift / 2 - shift * (i + 1) for i in range(int(len(tclones) / 2) - 1) + ] + available += [shift / 2] + [ + shift / 2 + shift * (i + 1) for i in range(int(len(tclones) / 2) - 1) + ] + available = iter(sorted(available)) + level = {clone: next(available) for clone in tclones} + else: + available = ( + [0] + + [-shift * (i + 1) for i in range(int(len(tclones) / 2))] + + [shift * (i + 1) for i in range(int(len(tclones) / 2))] + ) + available = iter(sorted(available)) + level = {clone: next(available) for clone in tclones} + pal = iter( + map( + mpl.colors.rgb2hex, + args[""clonepalette""](np.linspace(0, 1, len(tclones))), + ) + ) + style = {name: next(pal) for i, name in enumerate(tclones)} + + plt.figure(figsize=args[""clonefigsize""]) + pos = [] + x = 0 + for c in sorted(proj, key=sortchr): + for s in sorted(proj[c], key=(lambda x: x[0])): + pos.append((c, x)) + for i in proj[c][s]: + if i in tclones: + y = sum(proj[c][s][i]) + level[i] + plt.scatter(x, y, c=style[i], marker=""|"", s=12) + x += 1 + plt.xlim(xmin=0, xmax=x) + ymin, ymax = plt.ylim() + x = 0 + for c in sorted(proj, key=sortchr): + for s in sorted(proj[c], key=(lambda x: x[0])): + x += 1 + plt.plot((x, x), (0, ymax + 0.4), ""--b"", linewidth=0.2) + addchrplt(pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + + +def allelicprofiles(tumor, clones, props, args, out): + proj = join(tumor, clones, args[""profileres""]) + + tclones = [i for i in clones if i != ""normal""] + shift = 0.1 + if len(tclones) % 2 == 0: + available = [-shift / 2] + [ + -shift / 2 - shift * (i + 1) for i in range(int(len(tclones) / 2) - 1) + ] + available += [shift / 2] + [ + shift / 2 + shift * (i + 1) for i in range(int(len(tclones) / 2) - 1) + ] + available = iter(sorted(available)) + level = {clone: next(available) for clone in tclones} + else: + available = ( + [0] + + [-shift * (i + 1) for i in range(int(len(tclones) / 2))] + + [shift * (i + 1) for i in range(int(len(tclones) / 2))] + ) + available = iter(sorted(available)) + level = {clone: next(available) for clone in tclones} + pal = iter( + map( + mpl.colors.rgb2hex, + args[""clonepalette""](np.linspace(0, 1, len(tclones))), + ) + ) + style = {name: next(pal) for i, name in enumerate(tclones)} + + plt.figure(figsize=args[""clonefigsize""]) + + x = 0 + pos = [] + for c in sorted(proj, key=sortchr): + for s in sorted(proj[c], key=(lambda x: x[0])): + pos.append((c, x)) + for i in proj[c][s]: + if i != ""normal"": + yA = proj[c][s][i][0] + level[i] + yB = -(proj[c][s][i][1] + level[i]) + plt.scatter(x, yA, c=style[i], marker=""|"", s=12) + plt.scatter(x, yB, c=style[i], marker=""|"", s=12) + x += 1 + + plt.xlim(xmin=0, xmax=x) + ymin, ymax = plt.ylim() + ymin -= 0.4 + ymax += 0.4 + x = 0 + for c in sorted(proj, key=sortchr): + for s in sorted(proj[c], key=(lambda x: x[0])): + x += 1 + plt.plot((x, x), (ymin, ymax), ""--b"", linewidth=0.2) + plt.fill_between( + range(0, x), + [0 for i in range(x)], + [ymax for i in range(x)], + facecolor=""red"", + interpolate=True, + alpha=0.05, + ) + plt.fill_between( + range(0, x), + [ymin for i in range(x)], + [0 for i in range(x)], + facecolor=""blue"", + interpolate=True, + alpha=0.05, + ) + addchrplt(pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + + +def cnproportions(tumor, base, clones, props, args, out): + with PdfPages(os.path.join(args[""rundir""], out)) as pdf: + for sample in props: + sys.stderr.write(info(""## Plotting for sample {}...\n"".format(sample))) + proj = join(tumor, clones, args[""cnres""]) + sumu = lambda cns, cn: sum( + float(props[sample][i]) for i in cns if cns[i] == cn + ) + merge = { + c: { + s: { + sum(cn): sumu(proj[c][s], cn) for cn in set(proj[c][s].values()) + } + for s in proj[c] + } + for c in proj + } + + pos = [ + (c, s) + for c in sorted(merge, key=sortchr) + for s in sorted(merge[c], key=(lambda x: x[0])) + ] + cns = sorted( + set(cn for c in merge for s in merge[c] for cn in merge[c][s]), + reverse=True, + ) + pal2 = iter(sns.color_palette(""coolwarm"", 1)) + style = {base: next(pal2)} + # palA = iter(sns.color_palette(""Reds"", len([cn for cn in cns if cn > base]))) + palA = iter( + sns.color_palette(""YlOrRd_r"", len([cn for cn in cns if cn > base])) + ) + for x in [cn for cn in cns if cn > base]: + style[x] = next(palA) + # palD = iter(sns.color_palette(""Blues"", len([cn for cn in cns if cn < base]))) + palD = iter( + sns.color_palette(""YlGnBu"", len([cn for cn in cns if cn < base])) + ) + for x in [cn for cn in cns if cn < base]: + style[x] = next(palD) + level = {s: 1.0 for s in pos} + + fig = plt.figure(figsize=args[""propsfigsize""]) + + for cn in cns: + g = lambda s: merge[s[0]][s[1]][cn] if cn in merge[s[0]][s[1]] else 0.0 + minv = lambda v: v if v > 0.02 else 0.0 + df = pd.DataFrame( + [ + { + ""Genome positions"": x, + ""Copy-number Proportions"": minv(level[s]), + } + for x, s in enumerate(pos) + ] + ) + sns.barplot( + data=df, + x=""Genome positions"", + y=""Copy-number Proportions"", + color=style[cn], + label=str(cn), + ) + level = {s: level[s] - g(s) for s in pos} + + ticks = [ + (x, s[0]) + for x, s in enumerate(pos) + if x == 0 or pos[x - 1][0] != pos[x][0] + ] + plt.xticks([x[0] for x in ticks], [x[1] for x in ticks]) + plt.legend( + loc=""center left"", + fancybox=True, + shadow=True, + bbox_to_anchor=(1, 0.5), + ) + plt.ylim(ymin=0, ymax=1.0) + fig.autofmt_xdate() + pdf.savefig() + plt.close() + + +def allelicproportions(tumor, base, clones, props, args, out): + with PdfPages(os.path.join(args[""rundir""], out)) as pdf: + for sample in props: + sys.stderr.write(info(""## Plotting for sample {}...\n"".format(sample))) + proj = join( + tumor, + [i for i in clones if props[sample][i] > 0.0], + args[""cnres""], + ) + sumu = lambda cns, cn: sum( + float(props[sample][i]) for i in cns if cns[i][0] == cn[0] + ) + mergeA = { + c: { + s: {cn[0]: sumu(proj[c][s], cn) for cn in set(proj[c][s].values())} + for s in proj[c] + } + for c in proj + } + sumu = lambda cns, cn: sum( + float(props[sample][i]) for i in cns if cns[i][1] == cn[1] + ) + mergeB = { + c: { + s: {cn[1]: sumu(proj[c][s], cn) for cn in set(proj[c][s].values())} + for s in proj[c] + } + for c in proj + } + + pos = [ + (c, s) + for c in sorted(mergeA, key=sortchr) + for s in sorted(mergeA[c], key=(lambda x: x[0])) + ] + cnsA = sorted( + set(cn for c in mergeA for s in mergeA[c] for cn in mergeA[c][s]), + reverse=True, + ) + cnsB = sorted( + set(cn for c in mergeB for s in mergeB[c] for cn in mergeB[c][s]), + reverse=True, + ) + cns = sorted(set(cnsA) | set(cnsB)) + + pal2 = iter(sns.color_palette(""coolwarm"", 1)) + style = {base: next(pal2)} + # palA = iter(sns.color_palette(""Reds"", len([cn for cn in cns if cn > base]))) + palA = iter( + sns.color_palette(""YlOrRd"", len([cn for cn in cns if cn > base])) + ) + for x in [cn for cn in cns if cn > base]: + style[x] = next(palA) + # palD = iter(sns.color_palette(""Blues"", len([cn for cn in cns if cn < base]))) + palD = iter( + sns.color_palette(""YlGnBu"", len([cn for cn in cns if cn < base])) + ) + for x in [cn for cn in cns if cn < base]: + style[x] = next(palD) + + fig = plt.figure(figsize=args[""propsfigsize""]) + + # Plot allele A + + level = {s: 1.0 for s in pos} + for cn in cns: + g = ( + lambda s: mergeA[s[0]][s[1]][cn] + if cn in mergeA[s[0]][s[1]] + else 0.0 + ) + minv = lambda v: v if v > 0.02 else 0.0 + df = pd.DataFrame( + [ + { + ""Genome positions"": x, + ""Copy-number Proportions"": minv(level[s]), + } + for x, s in enumerate(pos) + ] + ) + sns.barplot( + data=df, + x=""Genome positions"", + y=""Copy-number Proportions"", + color=style[cn], + label=str(cn), + ) + level = {s: level[s] - g(s) for s in pos} + + # Plot allele B + + level = {s: -1.0 for s in pos} + for cn in cns: + g = ( + lambda s: mergeB[s[0]][s[1]][cn] + if cn in mergeB[s[0]][s[1]] + else 0.0 + ) + minv = lambda v: v if v < 0.02 else 0.0 + df = pd.DataFrame( + [ + { + ""Genome positions"": x, + ""Copy-number Proportions"": level[s], + } + for x, s in enumerate(pos) + ] + ) + sns.barplot( + data=df, + x=""Genome positions"", + y=""Copy-number Proportions"", + color=style[cn], + label=str(cn), + ) + level = {s: level[s] + g(s) for s in pos} + + ticks = [ + (x, s[0]) + for x, s in enumerate(pos) + if x == 0 or pos[x - 1][0] != pos[x][0] + ] + plt.xticks([x[0] for x in ticks], [x[1] for x in ticks]) + plt.legend( + loc=""center left"", + fancybox=True, + shadow=True, + bbox_to_anchor=(1, 0.5), + ) + plt.ylim(ymin=-1.0, ymax=1.0) + fig.autofmt_xdate() + pdf.savefig() + plt.close() + + +def gridprofiles(tumor, base, clones, props, args, out): + proj = join(tumor, clones, args[""clusterres""]) + pos = [ + (c, s) + for c in sorted(proj, key=sortchr) + for s in sorted(proj[c], key=(lambda x: x[0])) + ] + pal_sample = sns.color_palette(""YlGn"", 10) + palette = cycle([""#525252"", ""#969696"", ""#cccccc""]) + chr_colors = {c: next(palette) for c in sorted(tumor, key=sortchr)} + col_colors = {} + row_colors = {} + am = set() + de = set() + + data = [] + for c in sorted([i for i in clones]): + for x, s in enumerate(pos): + cn = sum(proj[s[0]][s[1]][c]) + data.append({""Clone"": c, ""Genome"": x, ""Amp-Del"": cn}) + if cn > base: + am.add(cn) + elif cn < base: + de.add(cn) + col_colors[x] = chr_colors[s[0]] + row_colors[c] = { + sam: pal_sample[min(9, int(round(props[sam][c] * 10)))] for sam in props + } + if len(am) == 0: + am.add(base) + if len(de) == 0: + de.add(base) + + df = pd.DataFrame(data) + table = pd.pivot_table( + df, + values=""Amp-Del"", + columns=[""Genome""], + index=[""Clone""], + aggfunc=""first"", + ) + + para = {} + para[""data""] = table + para[""cmap""] = ""coolwarm"" + para[""center""] = base + para[""cbar_kws""] = {""ticks"": range(min(de), max(am) + 1)} + para[""yticklabels""] = True + para[""row_cluster""] = True + para[""xticklabels""] = False + para[""col_cluster""] = False + para[""method""] = args[""linkage""] + para[""metric""] = cndistance + para[""figsize""] = args[""clusterfigsize""] + para[""col_colors""] = pd.DataFrame( + [{""index"": s, ""chromosomes"": col_colors[s]} for s in table.columns] + ).set_index(""index"") + para[""row_colors""] = pd.DataFrame( + [ + dict(list({""index"": row}.items()) + list(row_colors[row].items())) + for row in table.index + ] + ).set_index(""index"") + g = sns.clustermap(**para) + + addchr(g, pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + plt.close() + + +def gridprofilesreduced(tumor, base, clones, props, args, out): + proj = join(tumor, clones, args[""clusterres""]) + red = reduction(proj, base) + pos = [ + (c, s) + for c in sorted(red, key=sortchr) + for s in sorted(red[c], key=(lambda x: x[0])) + ] + pal_sample = sns.color_palette(""YlGn"", 10) + palette = cycle([""#525252"", ""#969696"", ""#cccccc""]) + chr_colors = {c: next(palette) for c in sorted(tumor, key=sortchr)} + col_colors = {} + row_colors = {} + + data = [] + for c in sorted([i for i in clones]): + for x, s in enumerate(pos): + data.append({""Clone"": c, ""Genome"": x, ""Amp-Del"": red[s[0]][s[1]][c]}) + col_colors[x] = chr_colors[s[0]] + row_colors[c] = { + sam: pal_sample[min(9, int(round(props[sam][c] * 10)))] for sam in props + } + + df = pd.DataFrame(data) + table = pd.pivot_table( + df, + values=""Amp-Del"", + columns=[""Genome""], + index=[""Clone""], + aggfunc=""first"", + ) + myColors = (""#67a9cf"", ""#f7f7f7"", ""#ef8a62"") + cmap = LinearSegmentedColormap.from_list(""Custom"", myColors, len(myColors)) + + para = {} + para[""data""] = table + para[""cmap""] = cmap + para[""cbar_kws""] = { + ""ticks"": [-1, 0, 1], + ""boundaries"": np.linspace(-1, 1, 4), + } + para[""yticklabels""] = True + para[""row_cluster""] = True + para[""xticklabels""] = False + para[""col_cluster""] = False + para[""method""] = args[""linkage""] + para[""metric""] = cndistance + para[""figsize""] = args[""clusterfigsize""] + para[""col_colors""] = pd.DataFrame( + [{""index"": s, ""chromosomes"": col_colors[s]} for s in table.columns] + ).set_index(""index"") + para[""row_colors""] = pd.DataFrame( + [ + dict(list({""index"": row}.items()) + list(row_colors[row].items())) + for row in table.index + ] + ).set_index(""index"") + g = sns.clustermap(**para) + + addchr(g, pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + plt.close() + + +def gridmixtures(tumor, base, clones, props, args, out): + projp = join(tumor, clones, args[""clusterres""]) + redp = reduction(projp, base) + pos = [ + (c, s) + for c in sorted(redp, key=sortchr) + for s in sorted(redp[c], key=(lambda x: x[0])) + ] + pal_clone = sns.color_palette(""YlGn"", 10) + palette = cycle([""#525252"", ""#969696"", ""#cccccc""]) + chr_colors = {c: next(palette) for c in sorted(tumor, key=sortchr)} + col_colors = {} + row_colors = {} + + data = [] + for p in props: + sumu = lambda cns, cn: sum(float(props[p][i]) for i in cns if cns[i] == cn) + mergep = { + c: { + s: {cn: sumu(redp[c][s], cn) for cn in set(redp[c][s].values())} + for s in redp[c] + } + for c in redp + } + assert False not in set( + 0.99 <= sum(mergep[c][s][cn] for cn in mergep[c][s]) <= 1.01 + for c in mergep + for s in mergep[c] + ) + for x, s in enumerate(pos): + value = sum(mergep[s[0]][s[1]][cn] * cn for cn in mergep[s[0]][s[1]]) + data.append({""Sample"": p, ""Genome"": x, ""value"": value}) + col_colors[x] = chr_colors[s[0]] + row_colors[p] = { + i: pal_clone[min(9, int(round(props[p][i] * 10)))] for i in clones + } + + df = pd.DataFrame(data) + table = pd.pivot_table( + df, + values=""value"", + columns=[""Genome""], + index=[""Sample""], + aggfunc=""first"", + ) + + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"") + para = {} + para[""data""] = table + para[""cmap""] = ""coolwarm"" # ""RdBu_r"" + # para['cbar_kws'] = {""ticks"":[-2, -1, 0, 1, 2], ""boundaries"": np.linspace(-2, 2, 6)} + para[""yticklabels""] = True + para[""row_cluster""] = True + para[""xticklabels""] = False + para[""col_cluster""] = False + para[""method""] = args[""linkage""] + para[""metric""] = similaritysample + para[""figsize""] = args[""clusterfigsize""] + para[""col_colors""] = pd.DataFrame( + [{""index"": s, ""chromosomes"": col_colors[s]} for s in table.columns] + ).set_index(""index"") + para[""row_colors""] = pd.DataFrame( + [ + dict(list({""index"": row}.items()) + list(row_colors[row].items())) + for row in table.index + ] + ).set_index(""index"") + g = sns.clustermap(**para) + + addchr(g, pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + plt.close() + + +def subclonal(tumor, base, clones, props, args, out): + assert base in {2, 4} + abase = 1 if base == 2 else 2 + proj = join(tumor, clones, args[""clusterres""]) + pos = [ + (c, s) + for c in sorted(proj, key=sortchr) + for s in sorted(proj[c], key=(lambda x: x[0])) + ] + pal_clone = sns.color_palette(""YlGn"", 10) + palette = cycle([""#525252"", ""#969696"", ""#cccccc""]) + chr_colors = {c: next(palette) for c in sorted(tumor, key=sortchr)} + col_colors = {} + row_colors = {} + + data = [] + for p in props: + for x, s in enumerate(pos): + cns = set(proj[s[0]][s[1]][i] for i in proj[s[0]][s[1]] if i != ""normal"") + merge = { + cn: sum( + props[p][i] + for i in proj[s[0]][s[1]] + if proj[s[0]][s[1]][i] == cn and i != ""normal"" + ) + for cn in cns + } + cns = set(cn for cn in cns if merge[cn] >= args[""minu""]) + if cns == {(abase, abase)}: + value = 0 + elif False not in set(n[0] >= abase and n[1] >= abase for n in cns): + if len(cns) == 1: + value = 2 + else: + value = 1 + elif False not in set(n[0] <= abase and n[1] <= abase for n in cns): + if len(cns) == 1: + value = -2 + else: + value = -1 + else: + if len(cns) == 1: + value = 4 + else: + value = 3 + data.append({""Sample"": p, ""Genome"": x, ""value"": value}) + col_colors[x] = chr_colors[s[0]] + row_colors[p] = { + i: pal_clone[min(9, int(round(props[p][i] * 10)))] for i in clones + } + + df = pd.DataFrame(data) + table = pd.pivot_table( + df, + values=""value"", + columns=[""Genome""], + index=[""Sample""], + aggfunc=""first"", + ) + myColors = ( + ""#92c5de"", + ""#0571b0"", + ""#f7f7f7"", + ""#ca0020"", + ""#f4a582"", + ""#7b3294"", + ""#c2a5cf"", + ) + cmap = LinearSegmentedColormap.from_list(""Custom"", myColors, len(myColors)) + + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"") + para = {} + para[""data""] = table + para[""cmap""] = cmap + labels = [ + ""Clonal deletion"", + ""Subclonal deletion"", + ""Neutral"", + ""Subclonal amplification"", + ""Clonal amplification"", + ""Sublonal mix"", + ""Clonal mix"", + ] + para[""cbar_kws""] = { + ""ticks"": [-2, -1, 0, 1, 2, 3, 4], + ""boundaries"": np.linspace(-2, 4, 8), + } + para[""yticklabels""] = True + para[""row_cluster""] = True + para[""xticklabels""] = False + para[""col_cluster""] = False + para[""method""] = args[""linkage""] + para[""metric""] = similarity + para[""figsize""] = args[""clusterfigsize""] + para[""col_colors""] = pd.DataFrame( + [{""index"": s, ""chromosomes"": col_colors[s]} for s in table.columns] + ).set_index(""index"") + para[""row_colors""] = pd.DataFrame( + [ + dict(list({""index"": row}.items()) + list(row_colors[row].items())) + for row in table.index + ] + ).set_index(""index"") + g = sns.clustermap(**para) + cax = plt.gcf().axes[-1] + cax.set_yticklabels(labels) + + addchr(g, pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + plt.close() + + +def reduction(proj, base): + classify = lambda c, i: 0 if c == base or i == ""normal"" else 1 if c > base else -1 + reduction = { + c: { + s: {i: classify(sum(proj[c][s][i]), i) for i in proj[c][s]} for s in proj[c] + } + for c in proj + } + assert False not in set( + reduction[c][s][""normal""] == 0 for c in proj for s in proj[c] + ) + return reduction + + +def join(tumor, clones, resolution): + proj = {} + for c in tumor: + bins = sorted(list(tumor[c]), key=(lambda x: x[0])) + proj[c] = {} + while bins: + tmp = bins[:resolution] + counts = {i: dict(Counter([tumor[c][s][i] for s in tmp])) for i in clones} + proj[c][tmp[0][0], tmp[-1][1]] = { + i: max(counts[i], key=(lambda x: counts[i][x])) for i in clones + } + bins = bins[resolution:] + return proj + + +def multiple(tumor, clones, props, base, args): + sys.stderr.write(log(""# Uniforming bin segmention across all patients\n"")) + tumor = segmenting(tumor, clones, props) + + out = ""intertumors-profilesfull.pdf"" + sys.stderr.write( + log( + ""# Plotting inter-tumors clone profiles in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + intergridfullprofiles(tumor, base, clones, props, args, out) + + out = ""intertumors-profilesreduced.pdf"" + sys.stderr.write( + log( + ""# Plotting inter-tumors reduced-clone profiles in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + intergridreducedprofiles(tumor, base, clones, props, args, out) + + out = ""intertumors-mixtures.pdf"" + sys.stderr.write( + log( + ""# Plotting inter-tumors mixtures in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + intergridsamplesclusters(tumor, base, clones, props, args, out) + + out = ""intertumors-subclonality.pdf"" + sys.stderr.write( + log( + ""# Plotting inter-tumors subclonality in {}\n"".format( + os.path.join(args[""rundir""], out) + ) + ) + ) + intergridsubclonality(tumor, base, clones, props, args, out) + + +def intergridfullprofiles(tumor, base, clones, props, args, out): + proj = interjoin(tumor, clones, args[""clusterres""]) + t = list(proj)[0] + pos = [ + (c, s) + for c in sorted(proj[t], key=sortchr) + for s in sorted(proj[t][c], key=(lambda x: x[0])) + ] + palette = cycle(sns.color_palette(""Pastel1"", min(10, len(list(tumor))))) + pat_colors = {pat: next(palette) for pat in tumor} + palette = cycle([""#525252"", ""#969696"", ""#cccccc""]) + chr_colors = {c: next(palette) for c in sorted(tumor[list(tumor)[0]], key=sortchr)} + col_colors = {} + row_colors = {} + + data = [] + for pat1 in proj: + for c1 in [t for t in clones[pat1] if t != ""normal""]: + for x, s in enumerate(pos): + data.append( + { + ""Patient clone"": ""{}:{}"".format(pat1, c1), + ""Genome"": x, + ""value"": sum(proj[pat1][s[0]][s[1]][c1]), + } + ) + col_colors[x] = chr_colors[s[0]] + row_colors[""{}:{}"".format(pat1, c1)] = pat_colors[pat1] + + df = pd.DataFrame(data) + table = pd.pivot_table( + df, + values=""value"", + columns=[""Genome""], + index=[""Patient clone""], + aggfunc=""first"", + ) + + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"") + para = {} + para[""data""] = table + para[""cmap""] = ""coolwarm"" + para[""center""] = 2 + para[""xticklabels""] = True + para[""yticklabels""] = True + para[""xticklabels""] = False + para[""row_cluster""] = False + para[""col_cluster""] = False + para[""cbar_kws""] = {""label"": ""Total copy number""} + para[""figsize""] = args[""clusterfigsize""] + para[""method""] = args[""linkage""] + para[""metric""] = cndistance + para[""col_colors""] = pd.DataFrame( + [{""index"": s, ""chromosomes"": col_colors[s]} for s in table.columns] + ).set_index(""index"") + para[""row_colors""] = pd.DataFrame( + [{""index"": row, ""patient"": row_colors[row]} for row in table.index] + ).set_index(""index"") + g = sns.clustermap(**para) + + addchr(g, pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + plt.close() + + +def intergridreducedprofiles(tumor, base, clones, props, args, out): + proj = interjoin(tumor, clones, args[""clusterres""]) + red = interreduction(proj, base) + t = list(red)[0] + pos = [ + (c, s) + for c in sorted(red[t], key=sortchr) + for s in sorted(red[t][c], key=(lambda x: x[0])) + ] + palette = cycle(sns.color_palette(""Pastel1"", min(9, len(list(tumor))))) + pat_colors = {pat: next(palette) for pat in tumor} + palette = cycle([""#525252"", ""#969696"", ""#cccccc""]) + chr_colors = {c: next(palette) for c in sorted(tumor[list(tumor)[0]], key=sortchr)} + col_colors = {} + row_colors = {} + + data = [] + for pat1 in red: + for c1 in [t for t in clones[pat1] if t != ""normal""]: + for x, s in enumerate(pos): + data.append( + { + ""Patient clone"": ""{}:{}"".format(pat1, c1), + ""Genome"": x, + ""value"": red[pat1][s[0]][s[1]][c1], + } + ) + col_colors[x] = chr_colors[s[0]] + row_colors[""{}:{}"".format(pat1, c1)] = pat_colors[pat1] + + df = pd.DataFrame(data) + table = pd.pivot_table( + df, + values=""value"", + columns=[""Genome""], + index=[""Patient clone""], + aggfunc=""first"", + ) + + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"") + para = {} + para[""data""] = table + para[""cmap""] = ""coolwarm"" + para[""xticklabels""] = True + para[""yticklabels""] = True + para[""xticklabels""] = False + para[""col_cluster""] = False + para[""figsize""] = args[""clusterfigsize""] + para[""cbar_kws""] = { + ""ticks"": [-1, 0, 1], + ""boundaries"": np.linspace(-1, 1, 4), + } + para[""method""] = args[""linkage""] + para[""metric""] = similarity + para[""col_colors""] = pd.DataFrame( + [{""index"": s, ""chromosomes"": col_colors[s]} for s in table.columns] + ).set_index(""index"") + para[""row_colors""] = pd.DataFrame( + [{""index"": row, ""patient"": row_colors[row]} for row in table.index] + ).set_index(""index"") + g = sns.clustermap(**para) + + addchr(g, pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + plt.close() + + +def intergridsamplesclusters(tumor, base, clones, props, args, out): + data = [] + proj = interjoin(tumor, clones, args[""clusterres""]) + red = interreduction(proj, base) + t = list(red)[0] + pos = [ + (c, s) + for c in sorted(red[t], key=sortchr) + for s in sorted(red[t][c], key=(lambda x: x[0])) + ] + palette = cycle(sns.color_palette(""Pastel1"", min(9, len(list(tumor))))) + pat_colors = {pat: next(palette) for pat in tumor} + palette = cycle([""#525252"", ""#969696"", ""#cccccc""]) + chr_colors = {c: next(palette) for c in sorted(tumor[list(tumor)[0]], key=sortchr)} + col_colors = {} + row_colors = {} + + for pat in tumor: + for p in props[pat]: + sumu = lambda cns, cn: sum( + float(props[pat][p][i]) if i in props[pat][p] else 0.0 + for i in cns + if cns[i] == cn + ) + mergep = { + c: { + s: { + cn: sumu(red[pat][c][s], cn) + for cn in set(red[pat][c][s].values()) + } + for s in red[pat][c] + } + for c in red[pat] + } + assert False not in set( + 0.99 <= sum(mergep[c][s][cn] for cn in mergep[c][s]) <= 1.01 + for c in mergep + for s in mergep[c] + ) + + for x, s in enumerate(pos): + value = sum(mergep[s[0]][s[1]][cn] * cn for cn in mergep[s[0]][s[1]]) + data.append( + { + ""Patient sample"": ""{}-{}"".format(pat, p), + ""Genome"": x, + ""value"": value, + } + ) + col_colors[x] = chr_colors[s[0]] + row_colors[""{}-{}"".format(pat, p)] = pat_colors[pat] + + df = pd.DataFrame(data) + table = pd.pivot_table( + df, + values=""value"", + columns=[""Genome""], + index=[""Patient sample""], + aggfunc=""first"", + ) + + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"") + para = {} + para[""data""] = table + para[""cmap""] = ""coolwarm"" + para[""xticklabels""] = True + para[""yticklabels""] = True + para[""xticklabels""] = False + para[""col_cluster""] = False + para[""figsize""] = args[""clusterfigsize""] + para[""method""] = args[""linkage""] + para[""metric""] = similaritysample + para[""col_colors""] = pd.DataFrame( + [{""index"": s, ""chromosomes"": col_colors[s]} for s in table.columns] + ).set_index(""index"") + para[""row_colors""] = pd.DataFrame( + [{""index"": row, ""patient"": row_colors[row]} for row in table.index] + ).set_index(""index"") + g = sns.clustermap(**para) + + addchr(g, pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + plt.close() + + +def intergridsubclonality(tumor, base, clones, props, args, out): + data = [] + proj = interjoin(tumor, clones, args[""clusterres""]) + t = list(proj)[0] + pos = [ + (c, s) + for c in sorted(proj[t], key=sortchr) + for s in sorted(proj[t][c], key=(lambda x: x[0])) + ] + palette = cycle(sns.color_palette(""Pastel1"", min(9, len(list(tumor))))) + pat_colors = {pat: next(palette) for pat in tumor} + palette = cycle([""#525252"", ""#969696"", ""#cccccc""]) + chr_colors = {c: next(palette) for c in sorted(tumor[list(tumor)[0]], key=sortchr)} + col_colors = {} + row_colors = {} + + for pat in tumor: + assert base[pat] == 2 or base[pat] == 4 + abase = 1 if base[pat] == 2 else 2 + for p in props[pat]: + for x, s in enumerate(pos): + cns = set( + proj[pat][s[0]][s[1]][i] + for i in proj[pat][s[0]][s[1]] + if i != ""normal"" + ) + merge = { + cn: sum( + props[pat][p][i] + for i in proj[pat][s[0]][s[1]] + if proj[pat][s[0]][s[1]][i] == cn and i != ""normal"" + ) + for cn in cns + } + cns = set(cn for cn in cns if merge[cn] >= args[""minu""]) + if cns == {(abase, abase)}: + value = 0 + elif False not in set(n[0] >= abase and n[1] >= abase for n in cns): + if len(cns) == 1: + value = 2 + else: + value = 1 + elif False not in set(n[0] <= abase and n[1] <= abase for n in cns): + if len(cns) == 1: + value = -2 + else: + value = -1 + else: + if len(cns) == 1: + value = 4 + else: + value = 3 + data.append( + { + ""Patient sample"": ""{}-{}"".format(pat, p), + ""Genome"": x, + ""value"": value, + } + ) + col_colors[x] = chr_colors[s[0]] + row_colors[""{}-{}"".format(pat, p)] = pat_colors[pat] + + df = pd.DataFrame(data) + table = pd.pivot_table( + df, + values=""value"", + columns=[""Genome""], + index=[""Patient sample""], + aggfunc=""first"", + ) + myColors = ( + ""#92c5de"", + ""#0571b0"", + ""#f7f7f7"", + ""#ca0020"", + ""#f4a582"", + ""#7b3294"", + ""#c2a5cf"", + ) + cmap = LinearSegmentedColormap.from_list(""Custom"", myColors, len(myColors)) + + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"") + para = {} + para[""data""] = table + para[""cmap""] = cmap + labels = [ + ""Clonal deletion"", + ""Subclonal deletion"", + ""Neutral"", + ""Subclonal amplification"", + ""Clonal amplification"", + ""Sublonal mix"", + ""Clonal mix"", + ] + para[""cbar_kws""] = { + ""ticks"": [-2, -1, 0, 1, 2, 3, 4], + ""boundaries"": np.linspace(-2, 4, 8), + } + para[""xticklabels""] = True + para[""yticklabels""] = True + para[""xticklabels""] = False + para[""col_cluster""] = False + para[""figsize""] = args[""clusterfigsize""] + para[""method""] = args[""linkage""] + para[""metric""] = similaritysample + para[""col_colors""] = pd.DataFrame( + [{""index"": s, ""chromosomes"": col_colors[s]} for s in table.columns] + ).set_index(""index"") + para[""row_colors""] = pd.DataFrame( + [{""index"": row, ""patient"": row_colors[row]} for row in table.index] + ).set_index(""index"") + g = sns.clustermap(**para) + cax = plt.gcf().axes[-1] + cax.set_yticklabels(labels) + + addchr(g, pos) + plt.savefig(os.path.join(args[""rundir""], out), bbox_inches=""tight"") + plt.close() + + +def segmenting(tumor, clones, props): + numpat = len(tumor) + cbk = lambda c: set(b for pat in tumor for s in tumor[pat][c] for b in s) + bk = {c: cbk(c) for c in set(c for pat in tumor for c in tumor[pat])} + bk = {c: sorted(bk[c]) for c in bk} + counts = {c: {b: 0 for b in zip(bk[c][:-1], bk[c][1:])} for c in bk} + maps = {pat: {c: {b: None for b in counts[c]} for c in counts} for pat in tumor} + + def select(d, m, counts, breakpoints, numpat): + for c in d: + bk = deque(breakpoints[c]) + left = -1 + right = bk.popleft() + for _left, _right in sorted(d[c], key=(lambda x: x[0])): + while right != _right: + left = right + right = bk.popleft() + if _left <= left and right <= _right: + counts[c][left, right] += 1 + assert counts[c][left, right] <= numpat + m[c][left, right] = (_left, _right) + + for pat in tumor: + select(tumor[pat], maps[pat], counts, bk, numpat) + + taken = {c: set(b for b in counts[c] if counts[c][b] == numpat) for c in counts} + tottaken = sum(1.0 for c in counts for b in counts[c] if counts[c][b] == numpat) + tot = sum(1.0 for c in counts for b in counts[c]) + sys.stderr.write( + info( + ""## Proportion of common bins kept: {}%\n"".format( + (tottaken / tot * 100) if tot > 0 else 1 + ) + ) + ) + + return { + pat: {c: {b: tumor[pat][c][maps[pat][c][b]] for b in taken[c]} for c in taken} + for pat in tumor + } + + +def interreduction(proj, base): + classify = ( + lambda c, pat, i: 0 + if c == base[pat] or i == ""normal"" + else 1 + if c > base[pat] + else -1 + ) + reduction = { + pat: { + c: { + s: { + i: classify(sum(proj[pat][c][s][i]), pat, i) + for i in proj[pat][c][s] + } + for s in proj[pat][c] + } + for c in proj[pat] + } + for pat in proj + } + assert False not in set( + reduction[pat][c][s][""normal""] == 0 + for pat in proj + for c in proj[pat] + for s in proj[pat][c] + ) + return reduction + + +def interjoin(tumor, clones, resolution): + proj = {} + for pat in tumor: + proj[pat] = {} + for c in tumor[pat]: + bins = sorted(list(tumor[pat][c]), key=(lambda x: x[0])) + proj[pat][c] = {} + while bins: + tmp = bins[:resolution] + counts = { + i: dict(Counter([tumor[pat][c][s][i] for s in tmp])) + for i in clones[pat] + } + proj[pat][c][tmp[0][0], tmp[-1][1]] = { + i: max(counts[i], key=(lambda x: counts[i][x])) for i in clones[pat] + } + bins = bins[resolution:] + return proj + + +def cndistance(u, v): + diff = list(u - v) + amps = [abs(x) if x > 0 else 0 for x in diff] + dels = [abs(x) if x < 0 else 0 for x in diff] + dist = sum(max(amps[i] - amps[i - 1], 0) for i, x in enumerate(amps)) + dist += sum(max(dels[i] - dels[i - 1], 0) for i, x in enumerate(dels)) + return dist + + +def similarity(u, v): + a = float(sum(u[i] == v[i] and u[i] != 0.0 and v[i] != 0 for i in range(len(u)))) + b = float(sum(u[i] != 0 or v[i] != 0 for i in range(len(u)))) + return (a / b) if b > 0 else 0 + + +def similaritysample(u, v): + bothamp = lambda x, y: x > 0.0 and y > 0.0 + bothdel = lambda x, y: x < 0.0 and y < 0.0 + a = float( + sum( + (bothamp(u[i], v[i]) or bothdel(u[i], v[i])) and u[i] != 0 and v[i] != 0 + for i in range(len(u)) + ) + ) + b = float(sum(u[i] != 0 or v[i] != 0 for i in range(len(u)))) + return (a / b) if b > 0 else 0 + + +def readUCN(inputs, patnames): + tumors = {} + samples = {} + clones = {} + props = {} + for fil in inputs: + sys.stderr.write(info(""## Reading {} as {}...\n"".format(fil, patnames[fil]))) + with open(fil, ""r"") as f: + patient = patnames[fil] + tumors[patient] = {} + samples[patient] = set() + clones[patient] = [] + props[patient] = {} + for line in f: + if len(clones[patient]) == 0: + assert line[0] == ""#"" + clones[patient] = [ + f.split(""_"")[1] + for i, f in enumerate(line.strip().split()[11:]) + if i % 2 == 0 + ] + if ""normal"" not in clones[patient]: + raise ValueError( + error( + ""normal is not present as a clone in {}"".format(patient) + ) + ) + else: + if len(line) > 1 and line[0] != ""#"": + parsed = line.strip().split() + sample = parsed[3] + samples[patient].add(sample) + chro = parsed[0] + if chro not in tumors[patient]: + tumors[patient][chro] = {} + start = int(parsed[1]) + end = int(parsed[2]) + pair = lambda l: [ + (tuple(map(int, e.split(""|""))), float(l[i + 1])) + for i, e in enumerate(l) + if i % 2 == 0 + ] + read = { + clones[patient][i]: e[0] + for i, e in enumerate(pair(parsed[11:])) + } + if (start, end) not in tumors[patient][chro]: + tumors[patient][chro][start, end] = read + else: + for i in read: + read[i] == tumors[patient][chro][start, end][i] + check = { + clones[patient][i]: e[1] + for i, e in enumerate(pair(parsed[11:])) + } + if sample in props[patient]: + for i in clones[patient]: + assert check[i] == props[patient][sample][i] + else: + props[patient][sample] = { + i: check[i] for i in clones[patient] + } + assert 0.999 <= sum(check[i] for i in clones[patient]) <= 1.001 + + return tumors, clones, props + + +def addchrplt(pos): + corners = [] + prev = 0 + val = pos[0][0] + for x, s in enumerate(pos): + if x != 0 and pos[x - 1][0] != pos[x][0]: + corners.append((prev, x, val)) + prev = x + val = s[0] + corners.append((prev, x, val)) + ticks = [(int(float(o[1] + o[0] + 1) / 2.0), o[2]) for o in corners] + plt.xticks([x[0] for x in ticks], [x[1] for x in ticks], rotation=45, ha=""center"") + plt.yticks(rotation=0) + + +def addchr(g, pos, color=None): + corners = [] + prev = 0 + for x, s in enumerate(pos): + if x != 0 and pos[x - 1][0] != pos[x][0]: + corners.append((prev, x)) + prev = x + corners.append((prev, x)) + ax = g.ax_heatmap + ticks = [] + for o in corners: + ax.set_xticks(np.append(ax.get_xticks(), int(float(o[1] + o[0] + 1) / 2.0))) + ticks.append(pos[o[0]][0]) + ax.set_xticklabels(ticks, rotation=45, ha=""center"") + ax.set_yticklabels(ax.get_yticklabels(), rotation=0) + + +def sortchr(x): + if x.endswith(""X""): + return 23 + elif x.endswith(""Y""): + return 24 + else: + return int("""".join([d for d in x if d.isdigit()])) + + +def argmax(d): + return max(d, key=(lambda x: d[x])) + + +def argmin(d): + return min(d, key=(lambda x: d[x])) + + +def isfloat(value): + try: + float(value) + return True + except ValueError: + return False + + +def error(msg): + return ""{}{}{}"".format(""\033[91m\033[1m"", msg, ""\033[0m"") + + +def warning(msg): + return ""{}{}{}"".format(""\033[93m\033[1m"", msg, ""\033[0m"") + + +def log(msg): + return ""{}{}{}"".format(""\033[95m\033[1m"", msg, ""\033[0m"") + + +def info(msg): + return ""{}{}{}"".format(""\033[96m"", msg, ""\033[0m"") + + +def debug(msg): + return ""{}{}{}"".format(""\033[92m"", msg, ""\033[0m"") + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/phase_snps.py",".py","13462","383","import os.path +import subprocess as pr +import glob +import shlex +import shutil + +import hatchet.utils.ArgParsing as ap +from hatchet.utils.Supporting import log, logArgs, error, ensure, run +from hatchet.utils.multiprocessing import Worker + + +def main(args=None): + log(msg=""# log notes\n"", level=""STEP"") + args = ap.parse_phase_snps_arguments(args) + logArgs(args, 80) + + bcftools = args[""bcftools""] + shapeit = args[""shapeit""] + picard = args[""picard""] + bgzip = args[""bgzip""] + outdir = args[""outdir""] + + rpd = args[""refpaneldir""] + panel = os.path.join(rpd, ""1000GP_Phase3"") + + # path to hg19, 1000GP in hg19 coords, potentially needed for liftover + hg19_path = """" + # chain files for liftover, chains['hg38_hg19']=path, chains['hg19_hg38']=path + chains = """" + # file for renaming chrs with bcftools, rename_files[0] for removing 'chr, rename_files[1] for adding 'chr' + rename_files = """" + + if args[""refvers""] == ""hg38"": + # Download reference panel genome and chain files + hg19_path = os.path.join(rpd, ""hg19_no_chr.fa"") + if args[""chrnot""]: + chains = { + ""hg38_hg19"": os.path.join(rpd, ""hg38ToHg19.chr.chain""), + ""hg19_hg38"": os.path.join(rpd, ""hg19ToHg38.chr.chain""), + } + else: + chains = { + ""hg38_hg19"": os.path.join(rpd, ""hg38ToHg19.no_chr.chain""), + ""hg19_hg38"": os.path.join(rpd, ""hg19ToHg38.no_chr.chain""), + } + + ensure( + os.path.isfile(chains[""hg38_hg19""]) and os.path.isfile(chains[""hg19_hg38""]), + ""The appropriate liftover chain files could not be located! Please run the download-panel "" + ""command that downloads these"", + ) + + elif args[""refvers""] == ""hg19"" and args[""chrnot""]: + rename_files = [os.path.join(rpd, f""rename_chrs{i}.txt"") for i in range(1, 3)] + + # liftover VCFs, phase, liftover again to original coordinates + os.makedirs(outdir, exist_ok=True) + + chromosomes = [] + for chro in args[""chromosomes""]: + if chro.endswith(""X"") or chro.endswith(""Y""): + log( + msg=f""Skipping chromosome {chro} (because it ends with X or Y)\n"", + level=""WARN"", + ) + else: + chromosomes.append(chro) + + n_instances = min(max(1, int(args[""j""])), len(chromosomes)) + phaser = Phaser( + panel, + outdir=outdir, + hg19=hg19_path, + ref=args[""refgenome""], + chains=chains, + rename=rename_files, + refvers=args[""refvers""], + chrnot=args[""chrnot""], + verbose=False, + bcftools=bcftools, + shapeit=shapeit, + picard=picard, + bgzip=bgzip, + ) + + _snplist = args[""snps""] + phaser_args = [(_snplist[chro], chro) for chro in chromosomes] + vcfs = phaser.run(work=phaser_args, n_instances=n_instances) + concat(vcfs, outdir=outdir, bcftools=bcftools) + + # read shapeit output, print fraction of phased snps per chromosome + print_log(path=outdir, chromosomes=chromosomes) + cleanup(outdir) + + +def cleanup(outdir): + f = [] + # shapeit logs + [f.extend(glob.glob(f""shapeit*{ext}"")) for ext in ["".log"", "".mm"", "".hh""]] + # intermediate files + exts = [ + ""_phased.vcf.gz"", + ""_phased.vcf.gz.csi"", + ""_filtered.vcf.gz"", + ""_rejected.vcf.gz"", + ""_lifted.vcf.gz"", + ""_lifted.vcf.gz.tbi"", + ""_toFilter.vcf.gz"", + ""_toConcat.vcf.gz"", + ""_toConcat.vcf.gz.csi"", + "".haps"", + "".sample"", + ""_alignments.snp.strand"", + ""_alignments.snp.strand.exclude"", + ] + [f.append(os.path.join(outdir, f""{c}{e}"")) for c in range(1, 23) for e in exts] + [os.remove(i) for i in f if os.path.isfile(i)] + + +def print_log(path, chromosomes): + out = open(os.path.join(path, ""phased.log""), ""w"") + print( + ""chrom"", + ""phased_snps"", + ""original_snps"", + ""proportion"", + file=out, + sep=""\t"", + ) + for c in chromosomes: + for l in open(os.path.join(path, f""{c}_alignments.log""), ""r""): + if ""SNPs included"" in l: + snps = int(l.split()[1]) + elif ""reference panel sites included"" in l: + phased_snps = int(l.split()[1]) + print(c, phased_snps, snps, float(phased_snps / snps), file=out, sep=""\t"") + + +def concat(vcfs, outdir, bcftools): + infiles = "" "".join(vcfs) + outfile = os.path.join(outdir, ""phased.vcf.gz"") + run( + f""{bcftools} concat --output-type z --output {outfile} {infiles}"", + stdouterr_filepath=os.path.join(outdir, ""concat.log""), + ) + return outfile + + +class Phaser(Worker): + def __init__( + self, + panel, + outdir, + hg19, + ref, + chains, + rename, + refvers, + chrnot, + verbose, + bcftools, + shapeit, + picard, + bgzip, + ): + self.panel = panel + self.outdir = outdir + self.hg19 = hg19 + self.ref = ref + self.chains = chains + self.rename = rename + self.refvers = refvers + self.chrnot = chrnot + self.verbose = verbose + self.bcftools = bcftools + self.shapeit = shapeit + self.picard = picard + self.bgzip = bgzip + + def work(self, *args): + vcf, chromosome = args + + # (1) PREPROCESS + if self.refvers == ""hg19"": + # no need for liftover, just deal with chr annotation + if self.chrnot: + vcf_toFilter = self.change_chr( + infile=vcf, + chromosome=chromosome, + outname=""toFilter"", + rename=self.rename[0], + ) + else: + # just copy files, vcfs already appropriately formatted + vcf_toFilter = self.stage_vcfs(infile=vcf, chromosome=chromosome) + else: + # liftover + vcf_toFilter = self.liftover( + infile=vcf, + chromosome=chromosome, + outname=""toFilter"", + chain=self.chains[""hg38_hg19""], + refgen=self.hg19, + ch=False, + ) + + # (2) FILTERING AND PHASING + # filter out multi-allelic sites and indels + vcf_filtered = self.biallelic(infile=vcf_toFilter, chromosome=chromosome) + vcf_phased = self.run_shapeit( + infile=vcf_filtered, chromosome=chromosome + ) # phase + + # (3) POSTPROCESS + if self.refvers == ""hg19"": + if self.chrnot: + vcf_to_concat = self.change_chr( + infile=vcf_phased, + chromosome=chromosome, + outname=""toConcat"", + rename=self.rename[1], + ) + # re-index with bcftools after renaming + self.index(infile=vcf_to_concat, chromosome=chromosome) + else: + vcf_to_concat = ( + vcf_phased # do nothing; vcfs already in original format + ) + else: + vcf_to_concat = self.liftover( + infile=vcf_phased, + chromosome=chromosome, + outname=""toConcat"", + chain=self.chains[""hg19_hg38""], + refgen=self.ref, + ch=self.chrnot, + ) + + return vcf_to_concat + + def liftover(self, infile, chromosome, outname, chain, refgen, ch): + errname = os.path.join(self.outdir, f""{chromosome}_picard.log"") + # output from picard liftover, to be filtered + tmpfile = os.path.join(self.outdir, f""{chromosome}_lifted.vcf.gz"") + # filtered with bcftools + outfile = os.path.join(self.outdir, f""{chromosome}_{outname}.vcf.gz"") + # required file of SNPs that didn't liftover + rejfile = os.path.join(self.outdir, f""{chromosome}_rejected.vcf.gz"") + + # --WARN_ON_MISSING_CONTIG true: throws out liftovers to contigs not present in target reference, + # e.g. small contigs variably present among the assemblies + + cmd1 = ( + f""{self.picard} LiftoverVcf -I {infile} -O {tmpfile} -CHAIN {chain} -R {refgen} -REJECT {rejfile} "" + ""--WARN_ON_MISSING_CONTIG true"" + ) + # need to change 'chr' notation depending on liftover direction + c = chromosome if not ch else f""chr{chromosome}"" + # filter out mapping to other chromosomes/contigs! + cmd2 = f""{self.bcftools} filter --output-type z --regions {c} {tmpfile}"" + # remove duplicate sites from liftover + cmd3 = f""{self.bcftools} norm --remove-duplicates --output {outfile}"" + + with open(errname, ""w"") as err: + pic = pr.run(cmd1.split(), stdout=err, stderr=err, universal_newlines=True) + filt = pr.Popen( + shlex.split(cmd2), + stdout=pr.PIPE, + stderr=err, + universal_newlines=True, + ) + norm = pr.Popen( + shlex.split(cmd3), + stdin=filt.stdout, + stdout=err, + stderr=err, + universal_newlines=True, + ) + codes = list(map(lambda p: p.wait(), [filt, norm])) + if any(c != 0 for c in codes) or pic.returncode != 0: + log(msg=cmd1, level=""ERROR"") + error( + f""Failed to liftover chromosomes with picard on {infile}."", + raise_exception=True, + ) + else: + os.remove(errname) + return outfile + + def change_chr(self, infile, chromosome, outname, rename): + # use bcftools to rename chromosomes + outfile = os.path.join(self.outdir, f""{chromosome}_{outname}.vcf.gz"") + errname = os.path.join(self.outdir, f""{chromosome}_bcftools.log"") + + run( + f""{self.bcftools} annotate --rename-chrs {rename} --output-type z --output {outfile} {infile}"", + stdouterr_filepath=errname, + error_msg=f""Failed to re-annotate chromosomes with bcftools on {infile}."", + ) + return outfile + + def stage_vcfs(self, infile, chromosome): + # copy file, so that phasing takes same input file name regardless of conditions, unzip + outfile = os.path.join(self.outdir, f""{chromosome}_toFilter.vcf.gz"") + shutil.copyfile(infile, outfile) + return outfile + + def biallelic(self, infile, chromosome): + # use bcftools to discard multi-allelic sites and indels + outfile = os.path.join(self.outdir, f""{chromosome}_filtered.vcf.gz"") + run( + ( + f""{self.bcftools} view --max-alleles 2 --exclude-types indels --output-type z --output-file {outfile} "" + f""{infile}"" + ), + stdouterr_filepath=os.path.join(self.outdir, f""{chromosome}_bcftools.log""), + error_msg=f""Biallelic sites filtering failed on {infile}."", + ) + return outfile + + def run_shapeit(self, infile, chromosome): + # use shapeit with reference panel to phase vcf files + errname = os.path.join(self.outdir, f""{chromosome}_shapeit.log"") + + # define params used across shapeit functions + inmap = f""{self.panel}/genetic_map_chr{chromosome}_combined_b37.txt"" + inref = ( + f""{self.panel}/1000GP_Phase3_chr{chromosome}.hap.gz "" + f""{self.panel}/1000GP_Phase3_chr{chromosome}.legend.gz "" + f""{self.panel}/1000GP_Phase3.sample"" + ) + + # check data with shapeit -check; get list of sites to exclude, + # such as sites in target VCF that are not present in reference panel + cmd_check = ( + f""{self.shapeit} -check --input-vcf {self.outdir}/{chromosome}_filtered.vcf.gz "" + f""--input-map {inmap} "" + f""--input-ref {inref} "" + f""--output-log {self.outdir}/{chromosome}_alignments"" + ) + cmd_touch = f""touch {self.outdir}/{chromosome}_alignments.snp.strand.exclude"" + + cmd_phase = ( + f""{self.shapeit} --input-vcf {self.outdir}/{chromosome}_filtered.vcf.gz "" + f""--input-map {inmap} "" + f""--input-ref {inref} "" + f""--exclude-snp {self.outdir}/{chromosome}_alignments.snp.strand.exclude "" + f""--output-max {self.outdir}/{chromosome}.haps {self.outdir}/{chromosome}.sample "" + ""--chrX --no-mcmc "" + ""--seed 0"" + ) + + cmd_convert = ( + f""{self.shapeit} -convert --input-haps {self.outdir}/{chromosome} "" + f""--output-vcf {self.outdir}/{chromosome}_phased.vcf"" + ) + + cmd_compress = f""{self.bgzip} -f {self.outdir}/{chromosome}_phased.vcf"" + + cmd_index = f""{self.bcftools} index -f {self.outdir}/{chromosome}_phased.vcf.gz"" + + run( + cmd_check, stdouterr_filepath=errname, check_return_codes=False + ) # May return 1 + run( + [cmd_touch, cmd_phase, cmd_convert, cmd_compress, cmd_index], + stdouterr_filepath=errname, + error_msg=f""Phasing failed on {infile}."", + ) + + return os.path.join(self.outdir, f""{chromosome}_phased.vcf.gz"") + + def index(self, infile, chromosome): + run( + f""{self.bcftools} index -f {infile}"", + stdouterr_filepath=os.path.join(self.outdir, f""{chromosome}_bcftools.log""), + error_msg=f""Failed to index {infile} with bcftools."", + ) + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/__init__.py",".py","0","0","","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/cluster_bins.py",".py","14133","473","from collections import Counter +import numpy as np +import pandas as pd + +from sklearn.preprocessing import StandardScaler +from sklearn.metrics import silhouette_score +from scipy.special import logsumexp +from scipy.spatial.distance import pdist, squareform +from hmmlearn import hmm + +from hatchet.utils.ArgParsing import parse_cluster_bins_args +import hatchet.utils.Supporting as sp + + +def main(args=None): + sp.log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") + args = parse_cluster_bins_args(args) + sp.logArgs(args, 80) + + sp.log(msg=""# Reading the combined BB file\n"", level=""STEP"") + tracks, bb, sample_labels, chr_labels = read_bb( + args[""bbfile""], subset=args[""subset""], allow_gaps=args[""allow_gaps""] + ) + + if args[""exactK""] > 0: + minK = args[""exactK""] + maxK = args[""exactK""] + else: + minK = args[""minK""] + maxK = args[""maxK""] + + if minK <= 1: + sp.log( + msg=""# WARNING: model selection does not support comparing K=1 to K>1. K=1 will be ignored.\n"", + level=""WARNING"", + ) + + if args[""exactK""] > 0 and args[""exactK""] == 1: + sp.log( + msg=""# Found exactK=1, returning trivial clustering.\n"", + level=""STEP"", + ) + best_labels = [1] * int(len(bb) / len(sample_labels)) + else: + sp.log( + msg=""# Clustering bins by RD and BAF across tumor samples using locality\n"", + level=""STEP"", + ) + ( + best_score, + best_model, + best_labels, + best_K, + results, + ) = hmm_model_select( + tracks, + minK=minK, + maxK=maxK, + covar=args[""covar""], + decode_alg=args[""decoding""], + tmat=args[""transmat""], + tau=args[""tau""], + state_selection=args[""selection""], + restarts=args[""restarts""], + ) + + best_labels = reindex(best_labels) + bb[""CLUSTER""] = np.repeat(best_labels, len(sample_labels)) + + sp.log(msg=""# Checking consistency of results\n"", level=""STEP"") + pivot_check = bb.pivot( + index=[""#CHR"", ""START"", ""END""], columns=""SAMPLE"", values=""CLUSTER"" + ) + + if not args[""allow_gaps""]: + # Verify that the array lengths and order match the bins in the BB file + chr_idx = 0 + bin_indices = pivot_check.index.to_numpy() + i = 0 + while chr_idx < len(tracks): + my_chr = chr_labels[chr_idx][:-2] + + start_row = bin_indices[i] + assert str(start_row[0]) == my_chr, (start_row[0], my_chr) + + prev_end = start_row[-1] + + start_idx = i + i += 1 + while ( + i < len(bin_indices) + and bin_indices[i][0] == start_row[0] + and bin_indices[i][1] == prev_end + ): + prev_end = bin_indices[i][2] + i += 1 + + # check the array lengths + assert tracks[chr_idx].shape[1] == i - start_idx, ( + tracks[chr_idx].shape[1], + i - start_idx, + ) + + chr_idx += 1 + + # Verify that cluster labels were applied correctly + cl_check = pivot_check.to_numpy().T + assert np.all(cl_check == cl_check[0]) + + sp.log(msg=""# Writing output\n"", level=""STEP"") + bb = bb[ + [ + ""#CHR"", + ""START"", + ""END"", + ""SAMPLE"", + ""RD"", + ""#SNPS"", + ""COV"", + ""ALPHA"", + ""BETA"", + ""BAF"", + ""CLUSTER"", + ] + ] + bb.to_csv(args[""outbins""], index=False, sep=""\t"") + + seg = form_seg(bb, args[""diploidbaf""]) + seg.to_csv(args[""outsegments""], index=False, sep=""\t"") + + sp.log(msg=""# Done\n"", level=""STEP"") + + +def read_bb(bbfile, subset=None, allow_gaps=False): + """""" + Constructs arrays to represent the bin in each chromosome or arm. + If bbfile was binned around chromosome arm, then uses chromosome arms. + Otherwise, uses chromosomes. + + Returns: + botht: list of np.ndarrays of size (n_bins, n_tracks) + where n_tracks = n_samples * 2 + bb: table read from input bbfile + sample_labels: order in which samples are represented in each array in botht + chr_lables: order in which chromosomes or arms are represented in botht + + each array contains + 1 track per sample for a single chromosome arm. + """""" + + bb = pd.read_table(bbfile) + if subset is not None: + bb = bb[bb.SAMPLE.isin(subset)] + + tracks = [] + + sample_labels = [] + populated_labels = False + + chr_labels = [] + for ch, df0 in bb.groupby(""#CHR""): + df0 = df0.sort_values(""START"") + + if allow_gaps: + pt = df0.pivot( + index=[""START"", ""END""], columns=""SAMPLE"", values=[""RD"", ""BAF""] + ).reset_index() + sample_labels = list(pt[""RD""].columns) + populated_labels = True + gaps = np.where(pt.START.to_numpy()[1:] - pt.END.to_numpy()[:-1] > 0)[0] + 1 + + chunks = [] + prev_end = 0 + for gap in gaps: + chunks.append(pt.iloc[prev_end:gap]) + prev_end = gap + + if prev_end < len(pt): + chunks.append(pt.iloc[prev_end:]) + + for i, chunk in enumerate(chunks): + track = np.empty((len(sample_labels) * 2, len(chunk))) + track[0::2] = chunk.BAF.values.T + track[1::2] = chunk.RD.values.T + tracks.append(track) + chr_labels.append(f""{ch}_section{i}"") + + else: + p_arrs = [] + q_arrs = [] + + for sample, df in df0.groupby(""SAMPLE""): + if not populated_labels: + sample_labels.append(sample) + + gaps = np.where(df.START.to_numpy()[1:] - df.END.to_numpy()[:-1] > 0)[0] + # print(ch, gaps) + + if len(gaps) > 0: + assert ( + len(gaps) == 1 + ), ""Found a chromosome with >1 gaps between bins"" + gap = gaps[0] + 1 + + df_p = df.iloc[:gap] + df_q = df.iloc[gap:] + + p_arrs.append(df_p.BAF.to_numpy()) + p_arrs.append(df_p.RD.to_numpy()) + + q_arrs.append(df_q.BAF.to_numpy()) + q_arrs.append(df_q.RD.to_numpy()) + else: + df_p = df + p_arrs.append(df_p.BAF.to_numpy()) + p_arrs.append(df_p.RD.to_numpy()) + + if len(q_arrs) > 0: + tracks.append(np.array(p_arrs)) + chr_labels.append(str(ch) + ""_p"") + + tracks.append(np.array(q_arrs)) + chr_labels.append(str(ch) + ""_q"") + else: + tracks.append(np.array(p_arrs)) + chr_labels.append(str(ch) + ""_p"") + + populated_labels = True + + return ( + tracks, + bb.sort_values(by=[""#CHR"", ""START"", ""SAMPLE""]), + sample_labels, + chr_labels, + ) + + +def hmm_model_select( + tracks, + minK=20, + maxK=50, + tau=10e-6, + tmat=""diag"", + decode_alg=""viterbi"", + covar=""diag"", + state_selection=""bic"", + restarts=10, +): + assert tmat in [""fixed"", ""diag"", ""free""] + assert decode_alg in [""map"", ""viterbi""] + assert state_selection in [""silhouette"", ""bic""] + + # format input + tracks = [a for a in tracks if a.shape[0] > 0 and a.shape[1] > 0] + if len(tracks) > 1: + X = np.concatenate(tracks, axis=1).T + lengths = [a.shape[1] for a in tracks] + else: + X = tracks[0].T + lengths = [tracks[0].shape[1]] + + best_K = 0 + if state_selection == ""silhouette"": + best_score = -1.01 # below minimum silhouette score value + else: + best_score = np.inf # BIC is always negative + best_model = None + best_labels = None + + scaler = StandardScaler() + X_scaled = scaler.fit_transform(X) + C = squareform(pdist(X_scaled)) + + rs = {} + for K in range(minK, maxK + 1): + # print(K, datetime.now()) + + my_best_ll = -1 * np.inf + my_best_labels = None + my_best_model = None + for s in range(restarts): + # construct initial transition matrix + A = make_transmat(1 - tau, K) + assert np.all(A > 0), ( + ""Found 0 or negative elements in transition matrix."" + ""This is likely a numerical precision issue -- try increasing tau."", + A, + ) + assert np.allclose(np.sum(A, axis=1), 1), ( + ""Not all rows in transition matrix sum to 1."", + A, + ) + + if tmat == ""fixed"": + model = hmm.GaussianHMM( + n_components=K, + init_params=""mc"", + params=""smc"", + covariance_type=covar, + random_state=s, + ) + elif tmat == ""free"": + model = hmm.GaussianHMM( + n_components=K, + init_params=""mc"", + params=""smct"", + covariance_type=covar, + random_state=s, + ) + else: + model = DiagGHMM( + n_components=K, + init_params=""mc"", + params=""smct"", + covariance_type=covar, + random_state=s, + ) + + model.startprob_ = np.ones(K) / K + model.transmat_ = A + model.fit(X, lengths) + + prob, labels = model.decode(X, lengths, algorithm=decode_alg) + if prob > my_best_ll: + my_best_labels = labels + my_best_ll = prob + my_best_model = model + + if state_selection == ""silhouette"": + score = silhouette_score(C, my_best_labels, metric=""precomputed"") + beats_the_current_best = score > best_score + else: # bic + score = model.bic(X) + beats_the_current_best = score < best_score + + rs[K] = my_best_ll, score, my_best_labels + if beats_the_current_best: + best_score = score + best_model = my_best_model + best_labels = my_best_labels + best_K = K + + return best_score, best_model, best_labels, best_K, rs + + +class DiagGHMM(hmm.GaussianHMM): + def _accumulate_sufficient_statistics( + self, stats, obs, framelogprob, posteriors, fwdlattice, bwdlattice + ): + super()._accumulate_sufficient_statistics( + stats, obs, framelogprob, posteriors, fwdlattice, bwdlattice + ) + + if ""t"" in self.params: + # for each ij, recover sum_t xi_ij from the inferred transition matrix + bothlattice = fwdlattice + bwdlattice + loggamma = (bothlattice.T - logsumexp(bothlattice, axis=1)).T + + # denominator for each ij is the sum of gammas over i + denoms = np.sum(np.exp(loggamma), axis=0) + # transpose to perform row-wise multiplication + stats[""denoms""] = denoms + + def _do_mstep(self, stats): + super()._do_mstep(stats) + if ""t"" in self.params: + denoms = stats[""denoms""] + x = (self.transmat_.T * denoms).T + + # numerator is the sum of ii elements + num = np.sum(np.diag(x)) + # denominator is the sum of all elements + denom = np.sum(x) + + # (this is the same as sum_i gamma_i) + # assert np.isclose(denom, np.sum(denoms)) + + stats[""diag""] = num / denom + # print(num.shape) + # print(denom.shape) + + self.transmat_ = self.form_transition_matrix(stats[""diag""]) + + def form_transition_matrix(self, diag): + tol = 1e-10 + diag = np.clip(diag, tol, 1 - tol) + + offdiag = (1 - diag) / (self.n_components - 1) + transmat_ = np.diag([diag - offdiag] * self.n_components) + transmat_ += offdiag + # assert np.all(transmat_ > 0), (diag, offdiag, transmat_) + return transmat_ + + +def make_transmat(diag, K): + offdiag = (1 - diag) / (K - 1) + transmat_ = np.diag([diag - offdiag] * K) + transmat_ += offdiag + return transmat_ + + +def reindex(labels): + """""" + Given a list of labels, reindex them as integers from 1 to n_labels + Also orders them in nonincreasing order of prevalence + """""" + old2new = {} + j = 1 + for i, _ in Counter(labels).most_common(): + old2new[i] = j + j += 1 + old2newf = lambda x: old2new[x] + + return [old2newf(a) for a in labels] + + +def form_seg(bbc, balanced_threshold): + segments = [] + for key, df_ in bbc.groupby(""CLUSTER""): + nbins = [] + rd = [] + nsnps = [] + cov = [] + baf = [] + a = [] + b = [] + samples = [] + + for sample, df in df_.groupby(""SAMPLE""): + nbins.append(len(df)) + rd.append(df.RD.mean()) + nsnps.append(df[""#SNPS""].sum()) + cov.append(df.COV.mean()) + baf.append(df.BAF.mean()) + smaller = np.sum(np.minimum(df.ALPHA, df.BETA)) + larger = np.sum(np.maximum(df.ALPHA, df.BETA)) + if baf[-1] <= 0.5: + a.append(smaller) + b.append(larger) + else: + a.append(larger) + b.append(smaller) + samples.append(sample) + + keys = [key] * len(baf) + if all([abs(0.5 - baf_) < balanced_threshold for baf_ in baf]): + baf = [0.5] * len(baf) + + [ + segments.append(t) + for t in zip(keys, samples, nbins, rd, nsnps, cov, a, b, baf) + ] + + seg = pd.DataFrame( + segments, + columns=[ + ""#ID"", + ""SAMPLE"", + ""#BINS"", + ""RD"", + ""#SNPS"", + ""COV"", + ""ALPHA"", + ""BETA"", + ""BAF"", + ], + ) + return seg + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/genotype_snps.py",".py","8908","320","import os +import os.path +import shlex +import subprocess as pr +from multiprocessing import Process, Queue, JoinableQueue, Lock, Value + +from hatchet.utils.ArgParsing import parse_genotype_snps_arguments +from hatchet.utils.Supporting import log, logArgs, error +import hatchet.utils.ProgressBar as pb + + +def main(args=None): + log( + msg=( + ""# Parsing the input arguments, checking the consistency of given files, and extracting required "", + ""information\n"", + ), + level=""STEP"", + ) + args = parse_genotype_snps_arguments(args) + logArgs(args, 80) + + log(msg=""# Inferring SNPs from the normal sample\n"", level=""STEP"") + snps = call( + bcftools=args[""bcftools""], + reference=args[""reference""], + samples=[args[""normal""]], + chromosomes=args[""chromosomes""], + num_workers=args[""j""], + q=args[""q""], + Q=args[""Q""], + mincov=args[""mincov""], + dp=args[""maxcov""], + E=args[""E""], + snplist=args[""snps""], + outdir=args[""outputsnps""], + verbose=args[""verbose""], + ) + + log(msg=""# Counting number of identified SNPs\n"", level=""STEP"") + + def count(f): + cmd_bcf = ""{} query -f '%CHROM,%POS\n' {}"".format(args[""bcftools""], f) + cmd_wcl = ""wc -l"" + bcf = pr.Popen( + shlex.split(cmd_bcf), + stdout=pr.PIPE, + stderr=pr.PIPE, + universal_newlines=True, + ) + number = pr.Popen( + shlex.split(cmd_wcl), + stdin=bcf.stdout, + stdout=pr.PIPE, + stderr=pr.PIPE, + universal_newlines=True, + ).communicate()[0] + number = """".join([_l for _l in number if _l.isdigit()]) + return int(number) if len(number) > 0 else 0 + + number_snps = sum(count(f) for f in snps) + + if number_snps == 0: + raise ValueError(error(""No SNPs found in the normal!\n"")) + else: + log( + msg=""{} SNPs have been identified in total\n"".format(number_snps), + level=""INFO"", + ) + + log(msg=""# SNP Calling is concluded\n"", level=""STEP"") + log( + msg=""## Called SNPs have been written per chromosome in:\n{}\n"".format( + ""\n"".join(snps) + ), + level=""INFO"", + ) + + +def call( + bcftools, + reference, + samples, + chromosomes, + num_workers, + q, + Q, + mincov, + dp, + E, + outdir, + snplist=None, + verbose=False, +): + # Define a Lock and a shared value for log printing through ProgressBar + err_lock = Lock() + counter = Value(""i"", 0) + progress_bar = pb.ProgressBar( + total=len(samples) * len(chromosomes), + length=40, + lock=err_lock, + counter=counter, + verbose=verbose, + ) + + # Establish communication queues + tasks = JoinableQueue() + results = Queue() + + # Enqueue jobs + jobs_count = 0 + for bam in samples: + for chro in chromosomes: + tasks.put((bam[0], bam[1], chro)) + jobs_count += 1 + + # Setting up the workers + workers = [ + Caller( + tasks, + results, + progress_bar, + bcftools, + reference, + q, + Q, + mincov, + dp, + E, + outdir, + snplist, + verbose, + ) + for i in range(min(num_workers, jobs_count)) + ] + + # Add a poison pill for each worker + for i in range(len(workers)): + tasks.put(None) + + # Start the workers + for w in workers: + w.start() + + # Wait for all of the tasks to finish + tasks.join() + + # Get the results + sorted_results = sorted([results.get() for i in range(jobs_count)]) + + # Close Queues + tasks.close() + results.close() + + # Ensure each worker terminates + for w in workers: + w.terminate() + w.join() + + return sorted_results + + +class Caller(Process): + def __init__( + self, + task_queue, + result_queue, + progress_bar, + bcftools, + reference, + q, + Q, + mincov, + dp, + E, + outdir, + snplist, + verbose, + ): + Process.__init__(self) + self.task_queue = task_queue + self.result_queue = result_queue + self.progress_bar = progress_bar + self.bcftools = bcftools + self.reference = reference + self.q = q + self.Q = Q + self.mincov = mincov + self.dp = dp + self.E = E + self.outdir = outdir + self.snplist = snplist + self.verbose = verbose + + def run(self): + while True: + next_task = self.task_queue.get() + if next_task is None: + # Poison pill means shutdown + self.task_queue.task_done() + break + + self.progress_bar.progress( + advance=False, + msg=""{} starts on {} for {})"".format( + self.name, next_task[1], next_task[2] + ), + ) + snps = self.callSNPs( + bamfile=next_task[0], + samplename=next_task[1], + chromosome=next_task[2], + ) + self.progress_bar.progress( + advance=True, + msg=""{} ends on {} for {})"".format( + self.name, next_task[1], next_task[2] + ), + ) + self.task_queue.task_done() + self.result_queue.put(snps) + return + + def callSNPs(self, bamfile, samplename, chromosome): + errname = os.path.join( + self.outdir, ""{}_{}_bcftools.log"".format(samplename, chromosome) + ) + + outfile = os.path.join(self.outdir, ""{}.vcf.gz"".format(chromosome)) + + if self.snplist is not None: + cmd_tgt = ""{} query -f '%CHROM\t%POS\n' -r {} {}"".format( + self.bcftools, chromosome, self.snplist + ) + cmd_gzip = ""gzip -9 -"" + tgtfile = os.path.join(self.outdir, ""target_{}.pos.gz"".format(chromosome)) + with open(tgtfile, ""w"") as tout, open(errname, ""w"") as err: + tgt = pr.Popen( + shlex.split(cmd_tgt), + stdout=pr.PIPE, + stderr=err, + universal_newlines=True, + ) + gzip = pr.Popen( + shlex.split(cmd_gzip), + stdin=tgt.stdout, + stdout=tout, + stderr=err, + universal_newlines=True, + ) + codes = map(lambda p: p.wait(), [tgt, gzip]) + if any(c != 0 for c in codes): + raise ValueError( + error( + ""SNP Calling failed on {} of {}, please check errors in {}!"".format( + chromosome, samplename, errname + ) + ) + ) + else: + os.remove(errname) + + cmd_mpileup = ""{} mpileup {} -Ou -f {} --skip-indels -a INFO/AD,AD,DP -q {} -Q {} -d {}"".format( + self.bcftools, bamfile, self.reference, self.q, self.Q, self.dp + ) + + if self.snplist is not None: + assert os.path.isfile(tgtfile) + cmd_mpileup += "" -T {}"".format(tgtfile) + else: + cmd_mpileup += "" -r {}"".format(chromosome) + if self.E: + cmd_mpileup += "" -E"" + cmd_call = ""{} call -mv -Ou"".format(self.bcftools) + cmd_filter = ""{} view -i 'FMT/DP>={}' -Oz -o {}"".format( + self.bcftools, self.mincov, outfile + ) + + with open(errname, ""w"") as err: + pcss = [] + mpileup = pr.Popen( + shlex.split(cmd_mpileup), + stdout=pr.PIPE, + stderr=err, + universal_newlines=True, + ) + pcss.append(mpileup) + call = pr.Popen( + shlex.split(cmd_call), + stdin=mpileup.stdout, + stdout=pr.PIPE, + stderr=err, + universal_newlines=True, + ) + pcss.append(call) + filter = pr.Popen( + shlex.split(cmd_filter), + stdin=call.stdout, + stdout=pr.PIPE, + stderr=err, + universal_newlines=True, + ) + pcss.append(filter) + codes = [p.wait() for p in pcss] + if any(c != 0 for c in codes): + raise ValueError( + error( + ""SNP Calling failed on {} of {}, please check errors in {}!"" + ).format(chromosome, samplename, errname) + ) + else: + os.remove(errname) + if self.snplist is not None: + os.remove(tgtfile) + return outfile + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/plot_bins.py",".py","22355","704","import sys +import os +from itertools import cycle +from collections import Counter +import numpy as np +import pandas as pd +import seaborn as sns +from scipy.stats import gaussian_kde +import matplotlib as mpl +import matplotlib.pyplot as plt +from matplotlib.backends.backend_pdf import PdfPages +import matplotlib.ticker as ticker +import matplotlib.colors as col + +from hatchet.utils.ArgParsing import parse_plot_bins_args + +mpl.use(""Agg"") +plt.style.use(""ggplot"") +sns.set_style(""whitegrid"") + + +def main(args=None): + sys.stderr.write(log(""# Parsing and checking input arguments\n"")) + args = parse_plot_bins_args(args) + sys.stdout.write( + info(""\n"".join([""## {}:\t{}"".format(key, args[key]) for key in args]) + ""\n"") + ) + + sys.stderr.write(log(""# Reading input BBC file\n"")) + bbc, clusters = readBBC(args[""input""]) + + sys.stderr.write( + log(""# Bin's clusters are selected accordingly to the provided thresholds\n"") + ) + clust_order, pal = select(bbc, clusters, args) + + if args[""fontscale""] != 1: + sns.set(font_scale=args[""fontscale""]) + + if args[""resolution""] is not None: + sys.stderr.write(log(""# Merging bins according to resolution\n"")) + bbc, clusters = join(bbc, clusters, args[""resolution""]) + + if args[""command""] is None or args[""command""] == ""RD"": + out = os.path.join(args[""x""], ""readdepthratio.pdf"") + sys.stderr.write( + log( + ""# [RD] Plotting read-depth ratio (RDR) for all samples in {}\n"".format( + out + ) + ) + ) + rdr(bbc, args, out) + + if args[""command""] is None or args[""command""] == ""CRD"": + out = os.path.join(args[""x""], ""readdepthratio_clustered.pdf"") + sys.stderr.write( + log( + ""# [CRD] Plotting the clustered read-depth ratio (RDR) for each sample in {}\n"".format( + out + ) + ) + ) + clurdr(bbc, clusters, args, out) + + if args[""command""] is None or args[""command""] == ""BAF"": + out = os.path.join(args[""x""], ""ballelefrequency.pdf"") + sys.stderr.write( + log( + ""# [BAF] Plotting B-allele frequency (BAF) for all samples in {}\n"".format( + out + ) + ) + ) + baf(bbc, args, out) + + if args[""command""] is None or args[""command""] == ""CBAF"": + out = os.path.join(args[""x""], ""ballelefrequency_clustered.pdf"") + sys.stderr.write( + log( + ""# [CBAF] Plotting the clustered B-allele frequency (BAF) for each sample in {}\n"".format( + out + ) + ) + ) + clubaf(bbc, clusters, args, out) + + if args[""command""] is None or args[""command""] == ""BB"": + out = os.path.join(args[""x""], ""bb.pdf"") + sys.stderr.write( + log(""# [BB] Plotting RDR-BB for all samples in {}\n"".format(out)) + ) + bb(bbc, clusters, args, out) + + if args[""command""] is None or args[""command""] == ""CBB"": + out = os.path.join( + args[""x""], + ""bb_clustered.pdf"" if args[""pdf""] else ""bb_clustered.png"", + ) + sys.stderr.write( + log(""# [CBB] Plotting clustered RDR-BB for all samples in {}\n"".format(out)) + ) + cluster_bins(bbc, clusters, args, out, clust_order, pal) + + if args[""command""] is None or args[""command""] == ""CLUSTER"": + if args[""segfile""] is not None: + seg = readSEG(args[""segfile""]) + out = os.path.join(args[""x""], ""clusters.pdf"") + sys.stderr.write( + log(""# [CLUSTER] Plotting clusters for all samples in {}\n"".format(out)) + ) + clus(seg, args, out) + else: + sys.stderr.write(warning(""### Provide a .seg file to also plot CLUSTER\n"")) + + +def rdr(bbc, args, out): + pos = [ + (c, s) + for c in sorted(bbc, key=sortchr) + for s in sorted(bbc[c], key=(lambda z: z[0])) + ] + lx = ""Genome"" + ly = ""Read-depth ratio (RDR)"" + lh = ""Sample"" + data = [ + {lx: x, ly: bbc[b[0]][b[1]][p][""RDR""], lh: p} + for x, b in enumerate(pos) + for p in bbc[b[0]][b[1]] + ] + df = pd.DataFrame(data) + df.sort_values([lx, lh], ascending=[True, False]) + figsize = args[""figsize""] if args[""figsize""] is not None else (8, 2) + s = args[""markersize""] if args[""markersize""] > 0 else 20 + mpl.rcParams[""figure.figsize""] = (figsize[0], figsize[1]) + + with PdfPages(out) as pdf: + sys.stderr.write(info(""## Plotting for all samples..\n"")) + g = sns.lmplot( + data=df, + x=lx, + y=ly, + hue=lh, + palette=args[""cmap""], + fit_reg=False, + height=figsize[0], + aspect=figsize[1], + markers=""|"", + scatter_kws={""s"": s}, + ) + addchr(pos) + coordinates(args, g) + plt.xlim(xmin=0, xmax=(len(pos) + 1)) + coordinates(args, g) + pdf.savefig(bbox_inches=""tight"") + plt.close() + + for sample, group in df.groupby(lh): + sys.stderr.write(info(""## Plotting for {}..\n"".format(sample))) + g = sns.lmplot( + data=group, + x=lx, + y=ly, + fit_reg=False, + height=figsize[0], + aspect=figsize[1], + markers=""|"", + scatter_kws={""s"": s}, + ) + addchr(pos) + coordinates(args, g) + plt.title(""Read-depth ratio in {}"".format(sample)) + plt.xlim(xmin=0, xmax=(len(pos) + 1)) + coordinates(args, g) + pdf.savefig(bbox_inches=""tight"") + plt.close() + + +def clurdr(bbc, clusters, args, out): + pos = [ + (c, s) + for c in sorted(bbc, key=sortchr) + for s in sorted(bbc[c], key=(lambda z: z[0])) + ] + lx = ""Genome"" + ly = ""Read-depth ratio (RDR)"" + g = ""Sample"" + lh = ""Cluster"" + data = [ + {lx: x, ly: bbc[b[0]][b[1]][p][""RDR""], g: p, lh: clusters[b[0]][b[1]]} + for x, b in enumerate(pos) + for p in bbc[b[0]][b[1]] + ] + df = pd.DataFrame(data) + df.sort_values([lx, lh], ascending=[True, True]) + figsize = args[""figsize""] if args[""figsize""] is not None else (8, 2) + s = args[""markersize""] if args[""markersize""] > 0 else 20 + mpl.rcParams[""figure.figsize""] = (figsize[0], figsize[1]) + + with PdfPages(out) as pdf: + for sample, group in df.groupby(g): + sys.stderr.write(info(""## Plotting for {}..\n"".format(sample))) + sns.lmplot( + data=group, + x=lx, + y=ly, + hue=lh, + fit_reg=False, + height=figsize[0], + aspect=figsize[1], + markers=""|"", + scatter_kws={""s"": s}, + legend=False, + ) + addchr(pos) + coordinates(args) + plt.title(""Read-depth ratio in {}"".format(sample)) + plt.xlim(xmin=0, xmax=(len(pos) + 1)) + pdf.savefig(bbox_inches=""tight"") + plt.close() + + +def baf(bbc, args, out): + pos = [ + (c, s) + for c in sorted(bbc, key=sortchr) + for s in sorted(bbc[c], key=(lambda z: z[0])) + ] + lx = ""Genome"" + ly = ""B-allele frequency (BAF)"" + lh = ""Sample"" + data = [ + {lx: x, ly: bbc[b[0]][b[1]][p][""BAF""], lh: p} + for x, b in enumerate(pos) + for p in bbc[b[0]][b[1]] + ] + df = pd.DataFrame(data) + df.sort_values([lx, lh], ascending=[True, False]) + figsize = args[""figsize""] if args[""figsize""] is not None else (8, 2) + s = args[""markersize""] if args[""markersize""] > 0 else 20 + mpl.rcParams[""figure.figsize""] = (figsize[0], figsize[1]) + + with PdfPages(out) as pdf: + sys.stderr.write(info(""## Plotting for all samples..\n"")) + sns.lmplot( + data=df, + x=lx, + y=ly, + hue=lh, + palette=args[""cmap""], + fit_reg=False, + height=figsize[0], + aspect=figsize[1], + markers=""|"", + scatter_kws={""s"": s}, + ) + plt.ylim(ymax=0.5) + addchr(pos) + coordinates(args) + plt.xlim(xmin=0, xmax=(len(pos) + 1)) + pdf.savefig(bbox_inches=""tight"") + plt.close() + + for sample, group in df.groupby(lh): + sys.stderr.write(info(""## Plotting for {}..\n"".format(sample))) + sns.lmplot( + data=group, + x=lx, + y=ly, + fit_reg=False, + height=figsize[0], + aspect=figsize[1], + markers=""|"", + scatter_kws={""s"": s}, + ) + plt.ylim(ymax=0.5) + addchr(pos) + coordinates(args) + plt.title(""B-allele frequency in {}"".format(sample)) + plt.xlim(xmin=0, xmax=(len(pos) + 1)) + pdf.savefig(bbox_inches=""tight"") + plt.close() + + +def clubaf(bbc, clusters, args, out): + pos = [ + (c, s) + for c in sorted(bbc, key=sortchr) + for s in sorted(bbc[c], key=(lambda z: z[0])) + ] + lx = ""Genome"" + ly = ""B-allele frequency (BAF)"" + g = ""Sample"" + lh = ""Cluster"" + data = [ + {lx: x, ly: bbc[b[0]][b[1]][p][""BAF""], g: p, lh: clusters[b[0]][b[1]]} + for x, b in enumerate(pos) + for p in bbc[b[0]][b[1]] + ] + df = pd.DataFrame(data) + df.sort_values([lx, lh], ascending=[True, True]) + figsize = args[""figsize""] if args[""figsize""] is not None else (8, 2) + s = args[""markersize""] if args[""markersize""] > 0 else 20 + mpl.rcParams[""figure.figsize""] = (figsize[0], figsize[1]) + + with PdfPages(out) as pdf: + for sample, group in df.groupby(g): + sys.stderr.write(info(""## Plotting for {}..\n"".format(sample))) + sns.lmplot( + data=group, + x=lx, + y=ly, + hue=lh, + fit_reg=False, + height=figsize[0], + aspect=figsize[1], + markers=""|"", + scatter_kws={""s"": s}, + legend=False, + ) + plt.ylim(ymax=0.5) + addchr(pos) + coordinates(args) + plt.title(""B-allele frequency in {}"".format(sample)) + plt.xlim(xmin=0, xmax=(len(pos) + 1)) + pdf.savefig(bbox_inches=""tight"") + plt.close() + + +def bb(bbc, clusters, args, out): + pos = [ + (c, s) + for c in sorted(bbc, key=sortchr) + for s in sorted(bbc[c], key=(lambda z: z[0])) + ] + ly = ""RDR"" + lx = ""0.5 - BAF"" + g = ""Sample"" + data = [ + { + ly: bbc[b[0]][b[1]][p][""RDR""], + lx: 0.5 - bbc[b[0]][b[1]][p][""BAF""], + g: p, + } + for b in pos + for p in bbc[b[0]][b[1]] + ] + df = pd.DataFrame(data) + figsize = args[""figsize""] if args[""figsize""] is not None else (16, 10) + s = args[""markersize""] if args[""markersize""] > 0 else 10 + + with PdfPages(out) as pdf: + for sample, group in df.groupby(g): + sys.stderr.write(info(""## Plotting for {}..\n"".format(sample))) + rdratio = np.array(group[lx]) + baf = np.array(group[ly]) + + # Calculate the point density + xy = np.vstack([rdratio, baf]) + z = gaussian_kde(xy)(xy) + + # Sort the points by density, so that the densest points are plotted last + idx = z.argsort() + rdratio, baf, z = rdratio[idx], baf[idx], z[idx] + + fig, ax = plt.subplots(1, figsize=figsize) + cax = ax.scatter( + rdratio, baf, c=z, cmap=plt.cm.jet, norm=col.LogNorm(), s=s + ) + ax.yaxis.set_major_locator(ticker.MultipleLocator(0.1)) + ax.grid(True) + plt.colorbar(cax) + plt.title(sample) + coordinates(args) + pdf.savefig(bbox_inches=""tight"") + plt.close() + + +def cluster_bins(bbc, clusters, args, out, clust_order, pal): + pos = [ + (c, s) + for c in sorted(bbc, key=sortchr) + for s in sorted(bbc[c], key=(lambda z: z[0])) + ] + ly = ""RDR"" + lx = ""0.5 - BAF"" + g = ""Sample"" + lh = ""Cluster"" + size = { + i: float(sum(clusters[b[0]][b[1]] == i for b in pos)) + for i in set(clusters[b[0]][b[1]] for b in pos) + } + data = [ + { + ly: bbc[b[0]][b[1]][p][""RDR""], + lx: 0.5 - bbc[b[0]][b[1]][p][""BAF""], + g: p, + lh: clusters[b[0]][b[1]], + ""size"": size[clusters[b[0]][b[1]]], + } + for b in pos + for p in bbc[b[0]][b[1]] + ] + df = pd.DataFrame(data) + + # for the top clusters in clust_order (leftmost in list) that have an assigned color (not gray) in palette pal, + # get their index in pal, otherwise assign the rest of the clusters to the last color in the palette (gray) + color_index = [] + for i in df[""Cluster""]: + if clust_order.index(i) <= len(pal) - 2: + color_index.append(clust_order.index(i)) + else: + color_index.append(len(pal) - 1) + df[""Color""] = color_index + + # reverse order so the largest clusters with color are plotted last and on top + order = [i for i in range(len(pal))] + order.reverse() + pal.reverse() + figsize = args[""figsize""] if args[""figsize""] is not None else (10, 1.1) + s = args[""markersize""] if args[""markersize""] > 0 else 7 + + if args[""colwrap""] > 1: + g = sns.lmplot( + data=df, + x=lx, + y=ly, + hue=""Color"", + hue_order=order, + palette=pal, + fit_reg=False, + height=figsize[0], + aspect=figsize[1], + scatter_kws={""s"": s}, + legend=False, + col=g, + col_wrap=args[""colwrap""], + ) + else: + g = sns.lmplot( + data=df, + x=lx, + y=ly, + hue=""Color"", + hue_order=order, + palette=pal, + fit_reg=False, + height=figsize[0], + aspect=figsize[1], + scatter_kws={""s"": s}, + legend=False, + row=g, + ) + coordinates(args, g) + if args[""pdf""]: + plt.savefig(out, bbox_inches=""tight"") + else: + plt.savefig(out, bbox_inches=""tight"", dpi=args[""dpi""]) + plt.close() + + +def clus(seg, args, out): + samples = set(seg[list(seg)[0]]) + figsize = args[""figsize""] if args[""figsize""] is not None else (16, 10) + mpl.rcParams[""figure.figsize""] = (figsize[0], figsize[1]) + pal = cycle(sns.color_palette(args[""cmap""], min(20, len(set(seg))))) + col = {idx: next(pal) for idx in seg} + + with PdfPages(out) as pdf: + for p in samples: + sys.stderr.write(info(""## Plotting for {}..\n"".format(p))) + for idx in seg: + plt.scatter( + 0.5 - seg[idx][p][""BAF""], + seg[idx][p][""RDR""], + c=col[idx], + s=(seg[idx][p][""SIZE""] ** 0.5) * 20, + alpha=0.8, + ) + plt.title(""{}"".format(p)) + coordinates(args) + pdf.savefig(bbox_inches=""tight"") + plt.close() + + +def readBBC(inp): + bbc = {} + clusters = {} + samples = set() + with open(inp, ""r"") as f: + for line in f: + if len(line) > 0 and line[0] != ""#"": + parsed = line.strip().split() + chro = parsed[0] + if chro not in bbc: + bbc[chro] = {} + clusters[chro] = {} + start = int(parsed[1]) + end = int(parsed[2]) + if (start, end) not in bbc[chro]: + bbc[chro][start, end] = {} + clusters[chro][start, end] = {} + clusters[chro][start, end] = parsed[10] + sample = parsed[3] + samples.add(sample) + if sample not in bbc[chro][start, end]: + bbc[chro][start, end][sample] = {} + bbc[chro][start, end][sample][""RDR""] = float(parsed[4]) + bbc[chro][start, end][sample][""BAF""] = float(parsed[9]) + bbc[chro][start, end][sample][""SNPS""] = float(parsed[5]) + + for chro in bbc: + for s in bbc[chro]: + assert len(bbc[chro][s]) == len(samples) + + return bbc, clusters + + +def readSEG(inp): + seg = {} + samples = set() + with open(inp, ""r"") as f: + for line in f: + if len(line) > 0 and line[0] != ""#"": + parsed = line.strip().split() + idx = parsed[0] + if idx not in seg: + seg[idx] = {} + sample = parsed[1] + samples.add(sample) + if sample not in seg[idx]: + seg[idx][sample] = {} + seg[idx][sample][""SIZE""] = int(parsed[2]) + seg[idx][sample][""RDR""] = float(parsed[3]) + seg[idx][sample][""BAF""] = float(parsed[8]) + + for idx in seg: + assert len(seg[idx]) == len(samples) + + return seg + + +def join(bbc, clusters, resolution): + projbbc = {} + projclu = {} + samples = set(p for c in bbc for s in bbc[c] for p in bbc[c][s]) + for c in bbc: + bins = sorted(list(bbc[c]), key=(lambda x: x[0])) + projbbc[c] = {} + projclu[c] = {} + while bins: + tmp = bins[:resolution] + projbbc[c][tmp[0][0], tmp[-1][1]] = {} + projclu[c][tmp[0][0], tmp[-1][1]] = {} + for p in samples: + projbbc[c][tmp[0][0], tmp[-1][1]][p] = {} + projclu[c][tmp[0][0], tmp[-1][1]][p] = {} + projbbc[c][tmp[0][0], tmp[-1][1]][p][""RDR""] = sum( + bbc[c][b][p][""RDR""] for b in tmp + ) / float(len(tmp)) + projbbc[c][tmp[0][0], tmp[-1][1]][p][""BAF""] = sum( + bbc[c][b][p][""BAF""] for b in tmp + ) / float(len(tmp)) + projclu[c][tmp[0][0], tmp[-1][1]] = argmax( + dict(Counter([clusters[c][s] for s in tmp])) + ) + bins = bins[resolution:] + return projbbc, projclu + + +def select(bbc, clusters, args): + alls = set(clusters[c][s] for c in clusters for s in clusters[c]) # all cluster IDs + count = {idx: {""SIZE"": 0.0, ""CHRS"": set()} for idx in alls} + totsize = sum(1.0 for c in bbc for s in bbc[c]) + for c in bbc: + for s in bbc[c]: + count[clusters[c][s]][""SIZE""] += 1.0 + count[clusters[c][s]][""CHRS""].add(c) + + # sel(ect) clusters based on size + sel = set(alls) + if args[""st""] is not None: + sel = set( + idx for idx in sel if float(count[idx][""SIZE""] / totsize) >= args[""st""] + ) + if args[""ct""] is not None: + sel = set(idx for idx in sel if len(count[idx][""CHRS""]) >= args[""ct""]) + s = [ + ""{}:\tSIZE= {},\t# CHRS= {}"".format(idx, count[idx][""SIZE""], count[idx][""CHRS""]) + for idx in sel + ] + sys.stderr.write(info(""## Selected clusters: \n{}\n"".format(""\n"".join(s)))) + + # if too many clusters are selected, still select the largest ones based on the number of colors in palette + sel = sorted( + sel, key=(lambda x: count[x][""SIZE""]), reverse=True + ) # order selected clusters large -> small + sel = sel[ + 0 : len(sns.color_palette(args[""cmap""])) + ] # select the top ones if more selected clusters than colors + clust_order = [ + i for i in reversed(sel) + ] # reverse order for later plotting, smaller selected clusters in front + # add on the rest of the unselected clusters, but we'll know which ones to color based on the number of + # colors in the palette pal + [clust_order.append(i) if i not in sel else next for i in alls] + # configure palette; subselecting colors if there are fewer selected clusters than colors + if len(sel) <= len( + sns.color_palette(args[""cmap""]) + ): # are there more colors than selected clusters? + pal = sns.color_palette(args[""cmap""])[ + 0 : len(sel) + ] # only select colors for the selected clusters at begining of clust_order + else: + pal = sns.color_palette(args[""cmap""]) + pal.append( + ""0.75"" + ) # all non selected clusters (or additional ones beyond palette colors) get colors gray + + return clust_order, pal + + +def addchr(pos): + ymin, ymax = plt.ylim() + corners = [] + prev = 0 + val = pos[0][0] + for x, s in enumerate(pos): + if x != 0 and pos[x - 1][0] != pos[x][0]: + plt.plot((x, x), (0, ymax + 0.4), ""--b"", linewidth=0.2) + corners.append((prev, x, val)) + prev = x + val = s[0] + corners.append((prev, x, val)) + ticks = [(int(float(o[1] + o[0] + 1) / 2.0), o[2]) for o in corners] + plt.xticks([x[0] for x in ticks], [x[1] for x in ticks], rotation=45, ha=""center"") + plt.yticks(rotation=0) + + +def coordinates(args, g=None): + if g is None: + if args[""xmin""] is not None: + plt.xlim(xmin=args[""xmin""]) + if args[""xmax""] is not None: + plt.xlim(xmax=args[""xmax""]) + if args[""ymin""] is not None: + plt.ylim(ymin=args[""ymin""]) + if args[""ymax""] is not None: + plt.ylim(ymax=args[""ymax""]) + else: + g.set( + xlim=(args[""xmin""], args[""xmax""]), + ylim=(args[""ymin""], args[""ymax""]), + ) + + +def sortchr(x): + if x.endswith(""X""): + return 23 + elif x.endswith(""Y""): + return 24 + else: + return int("""".join([d for d in x if d.isdigit()])) + + +def argmax(d): + return max(d, key=(lambda x: d[x])) + + +def argmin(d): + return min(d, key=(lambda x: d[x])) + + +def isfloat(value): + try: + float(value) + return True + except ValueError: + return False + + +def error(msg): + return ""{}{}{}"".format(""\033[91m\033[1m"", msg, ""\033[0m"") + + +def warning(msg): + return ""{}{}{}"".format(""\033[93m\033[1m"", msg, ""\033[0m"") + + +def log(msg): + return ""{}{}{}"".format(""\033[95m\033[1m"", msg, ""\033[0m"") + + +def info(msg): + return ""{}{}{}"".format(""\033[96m"", msg, ""\033[0m"") + + +def debug(msg): + return ""{}{}{}"".format(""\033[92m"", msg, ""\033[0m"") + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/TotalCounting.py",".py","3698","129","import shlex +import subprocess +from multiprocessing import Process, Queue, JoinableQueue, Lock, Value + +import hatchet.utils.ProgressBar as pb +import hatchet.utils.Supporting as sp + + +def tcount(samtools, samples, chromosomes, num_workers, q, verbose=False): + # Define a Lock and a shared value for log printing through ProgressBar + err_lock = Lock() + counter = Value(""i"", 0) + progress_bar = pb.ProgressBar( + total=len(samples) * len(chromosomes), + length=40, + lock=err_lock, + counter=counter, + verbose=verbose, + ) + + # Establish communication queues + tasks = JoinableQueue() + results = Queue() + + # Enqueue jobs + jobs_count = 0 + for bam in samples: + for chro in chromosomes: + tasks.put((bam[0], bam[1], chro)) + jobs_count += 1 + + # Setting up the workers + workers = [ + TotalCounter(tasks, results, progress_bar, samtools, q, verbose) + for i in range(min(num_workers, jobs_count)) + ] + + # Add a poison pill for each worker + for i in range(len(workers)): + tasks.put(None) + + # Start the workers + for w in workers: + w.start() + + # Wait for all of the tasks to finish + tasks.join() + + # Get the results + sorted_results = {} + for i in range(jobs_count): + res = results.get() + sorted_results[res[0], res[1]] = res[2] + + # Close Queues + tasks.close() + results.close() + + # Ensure each worker terminates + for w in workers: + w.terminate() + w.join() + + return sorted_results + + +class TotalCounter(Process): + def __init__(self, task_queue, result_queue, progress_bar, samtools, q, verbose): + Process.__init__(self) + self.task_queue = task_queue + self.result_queue = result_queue + self.progress_bar = progress_bar + self.samtools = samtools + self.q = q + self.verbose = verbose + + def run(self): + while True: + next_task = self.task_queue.get() + if next_task is None: + # Poison pill means shutdown + self.task_queue.task_done() + break + + self.progress_bar.progress( + advance=False, + msg=""{} starts on {} for {}"".format( + self.name, next_task[1], next_task[2] + ), + ) + count = self.binChr( + bamfile=next_task[0], + samplename=next_task[1], + chromosome=next_task[2], + ) + self.progress_bar.progress( + advance=True, + msg=""{} ends on {} for {}"".format( + self.name, next_task[1], next_task[2] + ), + ) + self.task_queue.task_done() + self.result_queue.put(count) + return + + def binChr(self, bamfile, samplename, chromosome): + popen = subprocess.Popen + pipe = subprocess.PIPE + split = shlex.split + cmd = ""{} view {} -c -q {} {}"".format( + self.samtools, bamfile, self.q, chromosome + ) + stdout, stderr = popen( + split(cmd), stdout=pipe, stderr=pipe, universal_newlines=True + ).communicate() + if stderr != """": + self.progress_bar.progress( + advance=False, + msg='{}{}: samtools warns ""{}""on (sample={}, chromosome={}){}'.format( + sp.bcolors.WARNING, + self.name, + stderr, + samplename, + chromosome, + sp.bcolors.ENDC, + ), + ) + return samplename, chromosome, int(stdout.strip()) +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/check.py",".py","10588","304","import sys +import os +import os.path +import subprocess +import textwrap +import importlib +from contextlib import contextmanager +import tempfile +import shutil + +from hatchet import config +import hatchet.data +from hatchet.utils.check_solver import main as check_solver +from hatchet.utils.commands import commands as all_commands + + +# from https://stackoverflow.com/questions/2125702 +@contextmanager +def suppress_stdout(): + with open(os.devnull, ""w"") as devnull: + old_stdout = sys.stdout + old_stderr = sys.stderr + sys.stdout = devnull + sys.stderr = devnull + try: + yield + finally: + sys.stdout = old_stdout + sys.stderr = old_stderr + + +def _check_cmd(exe_path, exe_name, *args): + # This function should never raise Exceptions unless it's a genuine implementation bug + # Only use exe and args that return a return code of 0 + # Use exe_path as '' if you expect to be on PATH + cmd = [os.path.join(exe_path, exe_name), *args] + try: + p = subprocess.Popen( + cmd, + stdout=subprocess.DEVNULL, + stderr=subprocess.PIPE, + universal_newlines=True, + ) + p.communicate() + assert p.returncode == 0 + except Exception: + return False + else: + return True + + +# Most command-line commands can be checked using _check_cmd(, , '--version') +# Others, like below, need special handling because they have no simple invocations that return 0 +def _check_tabix(): + with tempfile.TemporaryDirectory() as tempdirname: + with importlib.resources.path(hatchet.data, ""sample.sorted.gff.gz"") as gz_path: + _temp_gz_path = os.path.join(tempdirname, ""sample.sorted.gff.gz"") + shutil.copy(gz_path, _temp_gz_path) + return _check_cmd( + config.paths.tabix, ""tabix"", ""-p"", ""gff"", _temp_gz_path, ""-f"" + ) + + +def _check_bgzip(): + with tempfile.TemporaryDirectory() as tempdirname: + with importlib.resources.path(hatchet.data, ""sample.bbc"") as file_path: + _temp_file_path = os.path.join(tempdirname, ""sample.bbc"") + shutil.copy(file_path, _temp_file_path) + return _check_cmd(config.paths.bgzip, ""bgzip"", _temp_file_path, ""-f"") + + +def _check_picard(): + picard_dir = config.paths.picard + picard_java_flags = config.phase_snps.picard_java_flags + picard_bin_path = os.path.join(picard_dir, ""picard"") + picard_jar_path = os.path.join(picard_dir, ""picard.jar"") + if shutil.which(picard_bin_path) is not None: + exe_path = f""{picard_dir}"" + exe_name = ""picard"" + args_pre = (picard_java_flags,) + elif os.path.exists(picard_jar_path): + exe_path = """" # Assume java is on PATH + exe_name = ""java"" + args_pre = ( + picard_java_flags, + ""-jar"", + os.path.join(picard_dir, ""picard.jar""), + ) + else: + return False + + with tempfile.TemporaryDirectory() as tempdirname: + with importlib.resources.path(hatchet.data, ""sample.sorted.bam"") as bam_path: + return _check_cmd( + exe_path, + exe_name, + *args_pre, + ""BuildBamIndex"", + ""--INPUT"", + bam_path, + ""--OUTPUT"", + f""{tempdirname}/sample.sorted.bam.bai"", + ) + + +def _check_python_import(which): + try: + importlib.import_module(which) + except ImportError: + return False + else: + return True + + +# => [(, , , , ..), ..] +# If the same is used more than once, the first result of its check is cached and reused later. +CHECKS = { + ""count-reads"": [ + ( + ""tabix"", + """", + ""Please install tabix executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.tabix, or its location specified using the environment variable "" + ""HATCHET_PATHS_TABIX"", + _check_tabix, + ), + ( + ""samtools"", + """", + ""Please install samtools executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.samtools, or its location specified using the environment variable "" + ""HATCHET_PATHS_SAMTOOLS"", + _check_cmd, + config.paths.samtools, + ""samtools"", + ""--version"", + ), + ( + ""mosdepth"", + """", + ""Please install mosdepth executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.mosdepth, or its location specified using the environment variable "" + ""HATCHET_PATHS_MOSDEPTH"", + _check_cmd, + config.paths.mosdepth, + ""mosdepth"", + ""--version"", + ), + ], + ""combine-counts"": [ + ( + ""bedtools"", + """", + ""Please install bedtools executable and either ensure its on your PATH"", + _check_cmd, + """", + ""bedtools"", + ""--version"", + ), + ], + ""genotype-snps"": [ + ( + ""samtools"", + """", + ""Please install samtools executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.samtools, or its location specified using the environment variable "" + ""HATCHET_PATHS_SAMTOOLS"", + _check_cmd, + config.paths.samtools, + ""samtools"", + ""--version"", + ), + ( + ""bcftools"", + """", + ""Please install bcftools executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.bcftools, or its location specified using the environment variable "" + ""HATCHET_PATHS_BCFTOOLS"", + _check_cmd, + config.paths.bcftools, + ""bcftools"", + ""--version"", + ), + ], + ""count-alleles"": [ + ( + ""samtools"", + """", + ""Please install samtools executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.samtools, or its location specified using the environment variable "" + ""HATCHET_PATHS_SAMTOOLS"", + _check_cmd, + config.paths.samtools, + ""samtools"", + ""--version"", + ), + ( + ""bcftools"", + """", + ""Please install bcftools executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.bcftools, or its location specified using the environment variable "" + ""HATCHET_PATHS_BCFTOOLS"", + _check_cmd, + config.paths.bcftools, + ""bcftools"", + ""--version"", + ), + ], + ""phase-snps"": [ + ( + ""bcftools"", + """", + ""Please install bcftools executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.samtools, or its location specified using the environment variable "" + ""HATCHET_PATHS_BCFTOOLS"", + _check_cmd, + config.paths.bcftools, + ""bcftools"", + ""--version"", + ), + ( + ""picard"", + """", + ""Please install picard and ensure that the location of the picard executable is on PATH, or"" + ""specified (either in hatchet.ini or using the environment variable HATCHET_PATHS_PICARD)."" + ""If you have picard.jar installed instead, you can alternatively specify its location"" + 'instead (as long as ""java"" is on your PATH).', + _check_picard, + ), + ( + ""shapeit"", + """", + ""Please install shapeit executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.shapeit, or its location specified using the environment variable "" + ""HATCHET_PATHS_SHAPEIT"", + _check_cmd, + config.paths.shapeit, + ""shapeit"", + ""--version"", + ), + ( + ""bgzip"", + """", + ""Please install the bgzip executable and either ensure its on your PATH, or its location specified in "" + ""hatchet.ini as config.paths.bgzip, or its location specified using the environment variable "" + ""HATCHET_PATHS_BGZIP. Note that bgzip can often be found at the same location as the tabix executable."", + _check_bgzip, + ), + ], + ""compute-cn"": [ + ( + ""solver"", + f'Your selected solver ""{config.compute_cn.solver}"" seems to be working correctly', + ""See http://compbio.cs.brown.edu/hatchet/README.html#using-a-solver"", + check_solver, + ) + ], +} + + +def main(hatchet_cmds=None): + all_ok = True + hatchet_cmds = hatchet_cmds or all_commands + print(""======================\nRunning HATCHet checks\n======================"") + + _pred_cache = {} + + for hatchet_cmd in hatchet_cmds: + if hatchet_cmd in CHECKS: + checks = CHECKS[hatchet_cmd] + print( + f""----------------------\nCommand: {hatchet_cmd}\n----------------------"" + ) + for check in checks: + cmd_name, success_msg, err_msg, func, args = ( + check[0], + check[1], + check[2], + check[3], + check[4:], + ) + with suppress_stdout(): + if cmd_name in _pred_cache: + pred = _pred_cache[cmd_name] + else: + pred = func(*args) + _pred_cache[cmd_name] = pred + if pred: + print(f"" {cmd_name} check SUCCESSFUL. {success_msg}"") + else: + msg = textwrap.fill( + err_msg, + initial_indent="" "", + subsequent_indent="" "", + ) + print(f"" {cmd_name} check FAILED.\n{msg}"") + all_ok = False + + sys.exit(0 if all_ok else 1) + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/check_solver.py",".py","2770","96","import os.path +import tempfile +from importlib.resources import path + +from hatchet import config +import hatchet.data +from hatchet.bin.HATCHet import main as hatchet_main +from hatchet.utils.Supporting import log + + +this_dir = os.path.dirname(__file__) +DATA_FOLDER = os.path.join(this_dir, ""data"") + + +def main(args=None): + log(msg=f""# The solver you are currently using is {config.compute_cn.solver}\n"") + + try: + with tempfile.TemporaryDirectory() as tempdirname: + with path(hatchet.data, ""sample.bbc"") as bbc_path: + input_files_prefix = os.path.splitext(bbc_path)[0] + # purity values are free + hatchet_main( + args=[ + ""-x"", + os.path.join(tempdirname), + ""-i"", + input_files_prefix, + ""-n2"", + ""-p"", + ""5"", + ""-v"", + ""3"", + ""-u"", + ""0.03"", + ""--mode"", + ""0"", + ""-r"", + ""6700"", + ""-j"", + ""1"", + ""-eD"", + ""6"", + ""-eT"", + ""12"", + ""-g"", + ""0.35"", + ""-l"", + ""0.6"", + ] + ) + # purity values are fixed + hatchet_main( + args=[ + ""-x"", + os.path.join(tempdirname), + ""-i"", + input_files_prefix, + ""-n2"", + ""-p"", + ""5"", + ""-v"", + ""3"", + ""-u"", + ""0.03"", + ""--mode"", + ""0"", + ""-r"", + ""6700"", + ""-j"", + ""1"", + ""-eD"", + ""6"", + ""-eT"", + ""12"", + ""-g"", + ""0.35"", + ""-l"", + ""0.6"", + ""-P"", + ""0.6 0.2 0"", + ] + ) + + except Exception: + return False + else: + log( + msg=f""# Your current solver {config.compute_cn.solver} seems to be working correctly\n"" + ) + return True + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/count_alleles.py",".py","9771","326","import sys +import os +import os.path +import shlex +import subprocess as pr +from scipy.stats import beta +import tempfile + +import hatchet.utils.ArgParsing as ap +from hatchet.utils.Supporting import log, logArgs, error, close +from hatchet.utils.multiprocessing import Worker + + +def main(args=None): + log( + msg=( + ""# Parsing the input arguments, checking the consistency of given files, and extracting required "" + ""information\n"" + ), + level=""STEP"", + ) + args = ap.parse_count_alleles_arguments(args) + logArgs(args, 80) + + log( + msg=""# Counting SNPs alleles from the matched-normal sample\n"", + level=""STEP"", + ) + snps = counting( + bcftools=args[""bcftools""], + reference=args[""reference""], + samples=[args[""normal""]], + chromosomes=args[""chromosomes""], + num_workers=args[""j""], + snplist=args[""snps""], + q=args[""q""], + Q=args[""Q""], + mincov=args[""mincov""], + dp=args[""maxcov""], + E=args[""E""], + verbose=args[""verbose""], + outdir=args[""outputSnps""], + ) + + log(msg=""# Selecting heterozygous SNPs\n"", level=""STEP"") + hetSNPs = selectHetSNPs(counts=snps, gamma=args[""gamma""], maxshift=args[""maxshift""]) + if not hetSNPs: + close(""No heterozygous SNPs found in the selected regions of the normal!\n"") + + log( + msg=""# Writing the list of selected SNPs, covered and heterozygous in the normal sample\n"", + level=""STEP"", + ) + # put lists of SNPs in uniquely named temporary dir to prevent concurrent hatchet runs from overwriting + # each others temp files + with tempfile.TemporaryDirectory(dir=args[""outputSnps""]) as tmpdirname: + hetsnpsfiles = {} + for chro in args[""chromosomes""]: + hetsnpsfiles[chro] = os.path.join(tmpdirname, ""TMP_{}.tsv"".format(chro)) + with open(hetsnpsfiles[chro], ""w"") as f: + if (args[""normal""][1], chro) in hetSNPs: + for snp in sorted(hetSNPs[args[""normal""][1], chro]): + f.write(""{}\t{}\n"".format(chro, snp)) + + log( + msg=""# Writing the allele counts of the normal sample for selected SNPs\n"", + level=""STEP"", + ) + handle = ( + open(args[""outputNormal""], ""w"") + if args[""outputNormal""] is not None + else sys.stdout + ) + for chro in args[""chromosomes""]: + if (args[""normal""][1], chro) in hetSNPs: + for snp in sorted(hetSNPs[args[""normal""][1], chro]): + count = hetSNPs[args[""normal""][1], chro][snp] + handle.write( + ""{}\t{}\t{}\t{}\t{}\n"".format( + chro, + snp, + args[""normal""][1], + count[0][1], + count[1][1], + ) + ) + if handle is not sys.stdout: + handle.close() + + log(msg=""# Counting SNPs alleles from tumour samples\n"", level=""STEP"") + rcounts = counting( + bcftools=args[""bcftools""], + reference=args[""reference""], + samples=args[""samples""], + chromosomes=args[""chromosomes""], + num_workers=args[""j""], + snplist=hetsnpsfiles, + q=args[""q""], + Q=args[""Q""], + mincov=args[""mincov""], + dp=args[""maxcov""], + E=args[""E""], + verbose=args[""verbose""], + outdir=args[""outputSnps""], + ) + if not rcounts: + close(""The selected SNPs are not covered in the tumors!\n"") + rcounts = { + c: dict(map(lambda r: (int(r[2]), dict(r[3])), rcounts[c])) for c in rcounts + } + het = lambda chro: hetSNPs[args[""normal""][1], chro] + form = lambda REF, ALT, T: ( + (REF, T[REF] if REF in T else 0), + (ALT, T[ALT] if ALT in T else 0), + ) + counts = { + c: { + o: form(het(c[1])[o][0][0], het(c[1])[o][1][0], rcounts[c][o]) + for o in rcounts[c] + } + for c in rcounts + } + + log( + msg=""# Writing the allele counts of tumor samples for selected SNPs\n"", + level=""STEP"", + ) + handle = ( + open(args[""outputTumors""], ""w"") + if args[""outputTumors""] is not None + else sys.stdout + ) + for sample in args[""samples""]: + for chro in args[""chromosomes""]: + if (sample[1], chro) in counts: + for snp in counts[sample[1], chro]: + count = counts[sample[1], chro][snp] + handle.write( + ""{}\t{}\t{}\t{}\t{}\n"".format( + chro, snp, sample[1], count[0][1], count[1][1] + ) + ) + if handle is not sys.stdout: + handle.close() + + +def selectHetSNPs(counts, gamma, maxshift): + hetSNPs = { + c: [ + (r[0], r[1], r[2], r[3][0], max(r[3][1:], key=(lambda x: x[1]))) + for r in counts[c] + if len(r[3]) >= 2 + ] + for c in counts + } + check = lambda r: isHet(r[3][1], r[4][1], gamma) and checkShift( + r[3][1], r[4][1], maxshift + ) + hetSNPs = { + c: list(filter(check, hetSNPs[c])) for c in hetSNPs if len(hetSNPs[c]) > 0 + } + return { + c: {int(r[2]): (r[3], r[4]) for r in reversed(hetSNPs[c])} + for c in hetSNPs + if len(hetSNPs[c]) > 0 + } + + +def isHet(countA, countB, gamma): + p_lower = gamma / 2.0 + p_upper = 1.0 - p_lower + [c_lower, c_upper] = beta.ppf([p_lower, p_upper], countA + 1, countB + 1) + return c_lower <= 0.5 <= c_upper + + +# def isHet(countA, countB, gamma): +# lb, ub = proportion_confint(min(countA, countB), countA+countB, alpha=gamma, method='beta') +# return lb <= 0.5 <= ub + +# def isHet(countA, countB, gamma): +# lb, ub = proportion_confint(min(countA, countB), countA+countB, alpha=gamma, method='jeffreys') +# return lb <= 0.5 <= ub + + +def checkShift(countA, countB, maxshift): + return (0.5 - (float(min(countA, countB)) / float(countA + countB))) <= maxshift + + +def counting( + bcftools, + reference, + samples, + chromosomes, + num_workers, + snplist, + q, + Q, + mincov, + dp, + E, + verbose, + outdir, +): + work = [] + for bam in samples: + for chro in chromosomes: + work.append((bam[0], bam[1], chro)) + + worker = AlleleCounter( + bcftools, + reference, + q, + Q, + mincov, + dp, + E, + snplist, + verbose, + outdir, + ) + + results = worker.run(work=work, n_instances=num_workers) + results = {(v[0][0], v[0][1]): v for v in results if v} + return results + + +class AlleleCounter(Worker): + def __init__( + self, + bcftools, + reference, + q, + Q, + mincov, + dp, + E, + snplist, + verbose, + outdir, + ): + self.bcftools = bcftools + self.reference = reference + self.q = q + self.Q = Q + self.mincov = mincov + self.dp = dp + self.E = E + self.snplist = snplist + self.verbose = verbose + self.outdir = outdir + + def work(self, bamfile, samplename, chromosome): + return self.countAlleles( + bamfile=bamfile, samplename=samplename, chromosome=chromosome + ) + + def countAlleles(self, bamfile, samplename, chromosome): + cmd_mpileup = ""{} mpileup {} -Ou -f {} --skip-indels -a INFO/AD -q {} -Q {} -d {} -T {}"".format( + self.bcftools, + bamfile, + self.reference, + self.q, + self.Q, + self.dp, + self.snplist[chromosome], + ) + cmd_query = ""{} query -f '%CHROM\\t%POS\\t%REF,%ALT\\t%AD\\n' -i 'SUM(INFO/AD)<={} & SUM(INFO/AD)>={}'"".format( + self.bcftools, self.dp, self.mincov + ) + if self.E: + cmd_mpileup += "" -E"" + errname = os.path.join( + self.outdir, ""{}_{}_bcftools.log"".format(samplename, chromosome) + ) + + with open(errname, ""w"") as err: + mpileup = pr.Popen( + shlex.split(cmd_mpileup), + stdout=pr.PIPE, + stderr=err, + universal_newlines=True, + ) + query = pr.Popen( + shlex.split(cmd_query), + stdin=mpileup.stdout, + stdout=pr.PIPE, + stderr=err, + universal_newlines=True, + ) + # Allow sp mpileup to receive a SIGPIPE if p2 exits. avoid deadlock + mpileup.stdout.close() + stdout, _ = query.communicate() + codes = map(lambda p: p.wait(), [mpileup, query]) + if any(c != 0 for c in codes): + raise ValueError( + error( + ""Allele counting failed on {} of {}, please check errors in {}!"".format( + chromosome, samplename, errname + ) + ) + ) + else: + os.remove(errname) + alleles = {""A"", ""C"", ""G"", ""T""} + mkcounts = lambda p, q: list( + map( + lambda y: (y[0], int(y[1])), + filter(lambda x: x[0] in alleles, zip(p, q)), + ) + ) + form = lambda p: ( + samplename, + p[0], + p[1], + mkcounts(p[2].split("",""), p[3].split("","")), + ) + return [ + form(line.strip().split()) + for line in stdout.strip().split(""\n"") + if line != """" + ] + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/config.py",".py","2443","78","import os +import configparser + + +class ConfigSection(object): + """""" + A thin wrapper over a ConfigParser's SectionProxy object, + that tries to infer the types of values, and makes them available as attributes + Currently int/float/str are supported. + """""" + + def __init__(self, config, section_proxy): + self.config = config + self.name = section_proxy.name + self.d = {} # key value dict where the value is typecast to int/float/str + + for k, v in section_proxy.items(): + if v in (""True"", ""False""): + self.d[k] = eval(v) + continue + + try: + v = int(v) + except ValueError: + try: + v = float(v) + except ValueError: + # We interpret a missing value as None, and a """" as the empty string + if v.startswith('""') and v.endswith('""'): + v = v[1:-1] + elif v == """": + v = None + self.d[k] = v + else: + self.d[k] = v + else: + self.d[k] = v + + def __setattr__(self, key, value): + if key in (""config"", ""name"", ""d""): + return super(ConfigSection, self).__setattr__(key, value) + else: + self.d[key] = value + + def __getattr__(self, item): + if item not in (""config"", ""name"", ""d""): + # If an environment variable exists with name _
_, use it + env_varname = ""_"".join( + [str(x).upper() for x in [self.config.name, self.name, item]] + ) + env_var = os.getenv(env_varname) + return env_var or self.d[item] + + def items(self): + return self.d.items() + + +class Config(object): + def __init__(self, name, filenames): + self.name = name + self.config = configparser.ConfigParser(inline_comment_prefixes=""#"") + self.init_from_files(filenames) + + def init_from_files(self, filenames): + self.config.read(filenames) + self._read_sections() + + def read(self, filename): + self.config.read(filename) + self._read_sections() + + def _read_sections(self): + for section in self.config.sections(): + setattr(self, section, ConfigSection(self, self.config[section])) + + def sections(self): + return self.config.sections() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/multiprocessing.py",".py","3134","113","import sys +import traceback +from multiprocessing import ( + Process, + Queue, + JoinableQueue, + Lock, + Value, + cpu_count, +) +from hatchet.utils import ProgressBar as pb + + +class TaskHandler(Process): + def __init__(self, worker, task_queue, result_queue, progress_bar): + Process.__init__(self) + self.worker = worker + self.task_queue = task_queue + self.result_queue = result_queue + self.progress_bar = progress_bar + + def run(self): + while True: + task_i_and_args = self.task_queue.get() + if task_i_and_args is None: + self.task_queue.task_done() + break + else: + task_i, args = task_i_and_args + + try: + result = self.worker.work(*args) + except Exception as e: + typ, value, tb = sys.exc_info() + result = RuntimeError(e).with_traceback(tb) + # Traceback object is not preserved across multiprocessing; Save the traceback string as an attribute + result.error = traceback.format_exception(typ, value, tb) + + if self.progress_bar is not None: + self.progress_bar.progress(advance=True) + + self.result_queue.put((task_i, result)) + self.task_queue.task_done() + + +class Worker: + def __init__(self): + pass + + def work( + self, + *args, + ): + raise NotImplementedError + + def run(self, work, n_instances=None, show_progress=True): + n_work = len(work) + if n_instances is None: + n_instances = min(cpu_count(), n_work) + else: + n_instances = min(n_instances, n_work) + + if show_progress: + progress_bar = pb.ProgressBar( + total=n_work, + length=40, + lock=Lock(), + counter=Value(""i"", 0), + verbose=True, + ) + else: + progress_bar = None + + task_queue = JoinableQueue() + for i, arg in enumerate(work): + if isinstance(arg, tuple): + task_queue.put((i, arg)) + else: + task_queue.put((i, tuple([arg]))) + + for _ in range(n_instances): + task_queue.put(None) + + result_queue = Queue() + handlers = [ + TaskHandler(self, task_queue, result_queue, progress_bar) + for _ in range(n_instances) + ] + + for h in handlers: + h.start() + + task_queue.join() + + try: + results = [None] * n_work + for work_i, result in [result_queue.get() for _ in range(n_work)]: + if isinstance(result, Exception): + error_string = """".join(getattr(result, ""error"", [])) + raise result.__class__(f""WORK {work_i} FAILED\n\n{error_string}"") + else: + results[work_i] = result + + finally: + task_queue.close() + result_queue.close() + + for h in handlers: + h.terminate() + h.join() + + return results +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/CoordinateFinding.py",".py","2085","104","from math import floor +from math import ceil + + +lhg19 = [ + -1, + 249904550, + 243199373, + 198022430, + 191535534, + 180915260, + 171115067, + 159321559, + 146440111, + 141696573, + 135534747, + 135046619, + 133851895, + 115169878, + 107349540, + 102531392, + 90354753, + 81529607, + 78081510, + 59380841, + 63025520, + 48157577, + 51304566, +] + + +def extractChr(ref): + return int("""".join([i for i in ref if i.isdigit()])) + + +def findStart(bamfile, seq, least=0): + L = 0 + R = lhg19[extractChr(seq)] + first = True + + while R - L > 1: + if first: + M = int(ceil(R * 0.01)) + else: + M = int(ceil((L + R) / 2)) + count = bamfile.count(seq, L, M) + # print ""[{}, {}] = {}"".format(L, M, count) + if count > least: + R = M + else: + L = M + first = False + + if bamfile.count(seq, L, L) > least: + return L + else: + return R + + +def findEnd(bamfile, seq, least=0): + L = 0 + R = lhg19[extractChr(seq)] + first = True + + while R - L > 1: + if first: + M = int(floor(R * 0.99)) + else: + M = int(floor((L + R) / 2)) + count = bamfile.count(seq, M, R) + # print ""[{}, {}] = {}"".format(M, R, count) + if count > least: + L = M + else: + R = M + first = False + + if bamfile.count(seq, R, R) > least: + return R + else: + return L + + +def binChr(bamfile, sample, seq, size, start=0, end=0, least=-1): + res = [] + index = start + if end == 0: + end = lhg19[extractChr(seq)] + while index < end: + border = min(end, index + size) + count = bamfile.count(seq, index, border) + if count > least: + res.append( + { + ""sample"": sample, + ""chromosome"": extractChr(seq), + ""start"": index, + ""end"": (index + size), + ""count"": count, + } + ) + index += size + return res +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/count_reads.py",".py","20917","636","import sys +import os +from multiprocessing import Pool +import subprocess as sp +import numpy as np +import pandas as pd +import gzip +import subprocess +import traceback +from importlib.resources import path +import hatchet.data + +from hatchet.utils.ArgParsing import parse_count_reads_args +from hatchet.utils.Supporting import log, logArgs, error +import hatchet.utils.TotalCounting as tc + + +def main(args=None): + log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") + args = parse_count_reads_args(args) + logArgs(args, 80) + + bams = args[""bams""] + names = args[""names""] + + tbams, tnames = zip(*sorted(zip(*(bams[1:], names[1:])), key=lambda x: x[1])) + bams = [bams[0]] + list(tbams) + names = [names[0]] + list(tnames) + + chromosomes = args[""chromosomes""] + samtools = args[""samtools""] + processes = args[""j""] + outdir = args[""outdir""] + mosdepth = args[""mosdepth""] + tabix = args[""tabix""] + readquality = args[""readquality""] + + if len(check_array_files(outdir, chromosomes)) == 0: + log( + msg=""# Found all array files, skipping to total read counting. \n"", + level=""STEP"", + ) + else: + if len(check_counts_files(outdir, chromosomes, names)) == 0: + log( + msg=""# Found all count files, skipping to forming arrays\n"", + level=""STEP"", + ) + + else: + params = zip( + np.repeat(chromosomes, len(bams)), + [outdir] * len(bams) * len(chromosomes), + [samtools] * len(bams) * len(chromosomes), + bams * len(chromosomes), + names * len(chromosomes), + [readquality] * len(bams) * len(chromosomes), + ) + + n_workers_samtools = min(processes, len(bams) * len(chromosomes)) + with Pool( + n_workers_samtools + ) as p: # divide by 2 because each worker starts 2 processes + p.map(count_chromosome_wrapper, params) + + n_workers_mosdepth = min(processes, len(bams)) + + # compute number of decompression threads to use for each call to mosdepth + if processes > len(bams): + base = min(int(processes / n_workers_mosdepth), 4) + threads_per_task = [base] * len(bams) + + if base < 4: + remainder = processes % n_workers_mosdepth + i = 0 + while remainder > 0: + threads_per_task[i] += 1 + i += 1 + remainder -= 1 + else: + threads_per_task = [1] * len(bams) + + # Note: These function calls are the only section that uses mosdepth + mosdepth_params = [ + ( + outdir, + names[i], + bams[i], + threads_per_task[i], + mosdepth, + readquality, + ) + for i in range(len(bams)) + ] + with Pool(n_workers_mosdepth) as p: + p.map(mosdepth_wrapper, mosdepth_params) + + if len(check_counts_files(outdir, chromosomes, names)) > 0: + raise ValueError(error(""Missing some counts files!"")) + + ### Aggregate count files into count arrays for adaptive binning ### + # (formerly formArray) + use_chr = args[""use_chr""] + + n_workers = min(len(chromosomes), processes) + + # Read in centromere locations table + with path(hatchet.data, f'{args[""refversion""]}.centromeres.txt') as centromeres: + centromeres = pd.read_table( + centromeres, + header=None, + names=[""CHR"", ""START"", ""END"", ""NAME"", ""gieStain""], + ) + + chr2centro = {} + for ch in centromeres.CHR.unique(): + my_df = centromeres[centromeres.CHR == ch] + assert (my_df.gieStain == ""acen"").all() + # Each centromere should consist of 2 adjacent segments + assert len(my_df == 2) + assert my_df.START.max() == my_df.END.min() + if use_chr: + if ch.startswith(""chr""): + chr2centro[ch] = my_df.START.min(), my_df.END.max() + else: + chr2centro[""chr"" + ch] = my_df.START.min(), my_df.END.max() + else: + if ch.startswith(""chr""): + chr2centro[ch[3:]] = my_df.START.min(), my_df.END.max() + else: + chr2centro[ch] = my_df.START.min(), my_df.END.max() + + for ch in chromosomes: + if ch not in chr2centro: + raise ValueError( + error( + f""Chromosome {ch} not found in centromeres file. Inspect file provided as -C argument."" + ) + ) + + # Use Tabix to index per-position coverage bed files for each sample + for name in names: + perpos_file = os.path.join(outdir, name + "".per-base.bed.gz"") + subprocess.run([tabix, ""-f"", perpos_file]) + + # form parameters for each worker + params = [ + ( + outdir, + names, + ch, + chr2centro[ch][0], + chr2centro[ch][1], + args[""baf_file""], + tabix, + ) + for ch in chromosomes + ] + + # dispatch workers + with Pool(n_workers) as p: + p.map(run_chromosome_wrapper, params) + + np.savetxt(os.path.join(outdir, ""samples.txt""), names, fmt=""%s"") + + if len(check_array_files(outdir, chromosomes)) > 0: + raise ValueError(error(""Missing some output arrays!"")) + else: + log( + msg=""# Array forming completed successfully, removing intermediate count files. \n"", + level=""STEP"", + ) + [os.remove(f) for f in expected_counts_files(outdir, chromosomes, names)] + + totals_file = os.path.join(outdir, ""total.tsv"") + if os.path.exists(totals_file): + log(msg=""# Found total reads file, exiting. \n"", level=""STEP"") + return + else: + # TODO: take -q option and pass in here + log( + msg=""# Counting total number of reads for normal and tumor samples\n"", + level=""STEP"", + ) + total_counts = tc.tcount( + samtools=samtools, + samples=[(bams[i], names[i]) for i in range(len(names))], + chromosomes=chromosomes, + num_workers=processes, + q=readquality, + ) + + try: + total = { + name: sum(total_counts[name, chromosome] for chromosome in chromosomes) + for name in names + } + except KeyError: + raise KeyError( + error( + ""Either a chromosome or a sample has not been considered in the total counting!"" + ) + ) + + log( + msg=""# Writing the total read counts for all samples in {}\n"".format( + totals_file + ), + level=""STEP"", + ) + with open(totals_file, ""w"") as f: + for name in names: + f.write(""{}\t{}\n"".format(name, total[name])) + + +def mosdepth_wrapper(params): + run_mosdepth(*params) + + +def run_mosdepth(outdir, sample_name, bam, threads, mosdepth, readquality): + try: + last_file = os.path.join(outdir, sample_name + "".per-base.bed.gz.csi"") + if os.path.exists(last_file): + log( + f""Skipping mosdepth on sample {sample_name} (output file {last_file} exists)\n"", + level=""STEP"", + ) + return + + log( + f""Starting mosdepth on sample {sample_name} with {threads} threads\n"", + level=""STEP"", + ) + sys.stderr.flush() + + md = sp.run( + [ + mosdepth, + ""-t"", + str(threads), + ""-Q"", + str(readquality), + os.path.join(outdir, sample_name), + bam, + ] + ) + md.check_returncode() + log(f""Done mosdepth on sample {sample_name}\n"", level=""STEP"") + + except Exception as e: + log(""Exception in countPos: {}\n"".format(e), level=""ERROR"") + raise e + + +def count_chromosome( + ch, outdir, samtools, bam, sample_name, readquality, compression_level=6 +): + try: + outfile = os.path.join(outdir, f""{sample_name}.{ch}.starts"") + if os.path.exists(outfile): + log( + f""Skipping sample {sample_name} chromosome {ch} (output file exists)\n"", + level=""STEP"", + ) + return + + log(f""Sample {sample_name} -- Starting chromosome {ch}\n"", level=""STEP"") + sys.stderr.flush() + + # Get start positions + st = sp.Popen( + (samtools, ""view"", ""-q"", str(readquality), bam, ch), stdout=sp.PIPE + ) + cut = sp.Popen((""cut"", ""-f"", ""4""), stdin=st.stdout, stdout=sp.PIPE) + gzip = sp.Popen( + (""gzip"", ""-{}"".format(compression_level)), + stdin=cut.stdout, + stdout=open(outfile + "".gz"", ""w""), + ) + st.wait() + cut.wait() + gzip.wait() + if st.returncode != 0: + raise ValueError( + ""samtools subprocess returned nonzero value: {}"".format(st.returncode) + ) + if cut.returncode != 0: + raise ValueError( + ""cut subprocess returned nonzero value: {}"".format(cut.returncode) + ) + + log(f""Sample {sample_name} -- Done chromosome {ch}\n"", level=""STEP"") + + except Exception as e: + log(""Exception in countPos: {}\n"".format(e), level=""ERROR"") + raise e + + +def count_chromosome_wrapper(param): + count_chromosome(*param) + + +def read_snps(baf_file, ch, all_names): + """""" + Read and validate SNP data for this patient (TSV table output from HATCHet deBAF.py). + """""" + all_names = all_names[ + 1: + ] # remove normal sample -- not looking for SNP counts from normal + + # Read in HATCHet BAF table + all_snps = pd.read_table( + baf_file, + names=[""CHR"", ""POS"", ""SAMPLE"", ""REF"", ""ALT""], + dtype={ + ""CHR"": object, + ""POS"": np.uint32, + ""SAMPLE"": object, + ""ALT"": np.uint32, + ""REF"": np.uint32, + }, + ) + + # Keep only SNPs on this chromosome + snps = all_snps[all_snps.CHR == ch].sort_values(by=[""POS"", ""SAMPLE""]) + snps = snps.reset_index(drop=True) + + if len(snps) == 0: + raise ValueError( + error( + f""Chromosome {ch} not found in SNPs file (chromosomes in file: {all_snps.CHR.unique()})"" + ) + ) + + n_samples = len(all_names) + if n_samples != len(snps.SAMPLE.unique()): + raise ValueError( + error( + f""Expected {n_samples} samples, found {len(snps.SAMPLE.unique())} samples in SNPs file."" + ) + ) + + if set(all_names) != set(snps.SAMPLE.unique()): + raise ValueError( + error( + f""Expected sample names did not match sample names in SNPs file.\n\ + Expected: {sorted(all_names)}\n Found:{sorted(snps.SAMPLE.unique())}"" + ) + ) + + # Add total counts column + snpsv = snps.copy() + snpsv[""TOTAL""] = snpsv.ALT + snpsv.REF + + # Create counts array and find SNPs that are not present in all samples + snp_counts = snpsv.pivot(index=""POS"", columns=""SAMPLE"", values=""TOTAL"") + missing_pos = snp_counts.isna().any(axis=1) + + # Remove SNPs that are absent in any sample + snp_counts = snp_counts.dropna(axis=0) + snpsv = snpsv[~snpsv.POS.isin(missing_pos[missing_pos].index)] + + # Pivot table for dataframe should match counts array and have no missing entries + check_pivot = snpsv.pivot(index=""POS"", columns=""SAMPLE"", values=""TOTAL"") + assert np.array_equal(check_pivot, snp_counts), ""SNP file reading failed"" + assert not np.any(check_pivot.isna()), ""SNP file reading failed"" + assert np.array_equal(all_names, list(snp_counts.columns)), ( + all_names, + list(snp_counts.columns), + ) # make sure that sample order is the same + + return np.array(snp_counts.index), np.array(snp_counts), snpsv + + +def form_counts_array( + starts_files, perpos_files, thresholds, chromosome, tabix, chunksize=1e5 +): + """""" + NOTE: Assumes that starts_files[i] corresponds to the same sample as perpos_files[i] + Parameters: + starts_files: list of ..starts.gz files each containing a list of start positions + perpos_files: list of .per-base.bed.gz files containing per-position coverage from mosdepth + thresholds: list of potential bin start positions (thresholds between SNPs) + chromosome: chromosome to extract read counts for + + Returns: x <2d> np.ndarray + entry [i, 2j] contains the number of reads starting in (starts[i], starts[i + 1]) in sample j + entry [i, 2j + 1] contains the number of reads covering position starts[i] in sample j + """""" + arr = np.zeros( + (thresholds.shape[0] + 1, len(starts_files) * 2) + ) # add one for the end of the chromosome + + for i in range(len(starts_files)): + # populate starts in even entries + fname = starts_files[i] + if fname.endswith("".gz""): + f = gzip.open(fname) + else: + f = open(fname) + + read_starts = [int(a) for a in gzip.open(fname, ""r"")] + end = thresholds[0] + j = 0 + for idx in range(1, len(thresholds)): + start = end + end = thresholds[idx] + + my_count = 0 + while j < len(read_starts) and read_starts[j] < end: + assert read_starts[j] >= start + my_count += 1 + j += 1 + + arr[idx - 1, i * 2] = my_count + + arr[idx - 1, i * 2] += len(read_starts) - j + f.close() + + for i in range(len(perpos_files)): + # populate threshold coverage in odd entries + fname = perpos_files[i] + + chr_sample_file = os.path.join(fname[:-3] + ""."" + chromosome) + + if not os.path.exists(chr_sample_file): + with open(chr_sample_file, ""w"") as f: + subprocess.run([tabix, fname, chromosome], stdout=f) + + with open(chr_sample_file, ""r"") as records: + idx = 0 + last_record = None + for line in records: + tokens = line.split() + if len(tokens) == 4: + start = int(tokens[1]) + end = int(tokens[2]) + nreads = int(tokens[3]) + + while idx < len(thresholds) and thresholds[idx] - 1 < end: + assert thresholds[idx] - 1 >= start + arr[idx, (2 * i) + 1] = nreads + idx += 1 + last_record = line + + if i == 0: + # identify the (effective) chromosome end as the last well-formed record + assert idx == len(thresholds) + _, _, chr_end, end_reads = last_record.split() + chr_end = int(chr_end) + end_reads = int(end_reads) + + assert chr_end > thresholds[-1] + assert len(thresholds) == len(arr) - 1 + + # add the chromosome end to thresholds + thresholds = np.concatenate([thresholds, [chr_end]]) + + # count the number of reads covering the chromosome end + arr[idx, 0] = end_reads + + if os.path.exists(chr_sample_file): + os.remove(chr_sample_file) + + return arr, thresholds + + +def get_chr_end(stem, all_names, chromosome): + starts_files = [] + for name in all_names: + starts_files.append(os.path.join(stem, name + ""."" + chromosome + "".starts.gz"")) + + last_start = 0 + for sfname in starts_files: + zcat = subprocess.Popen((""zcat"", sfname), stdout=subprocess.PIPE) + tail = subprocess.Popen( + (""tail"", ""-1""), stdin=zcat.stdout, stdout=subprocess.PIPE + ) + my_last = int(tail.stdout.read().decode(""utf-8"").strip()) + + if my_last > last_start: + last_start = my_last + + return last_start + + +def run_chromosome( + outdir, + all_names, + chromosome, + centromere_start, + centromere_end, + baf_file, + tabix, +): + """""" + Construct arrays that contain all counts needed to perform adaptive binning for a single chromosome + (across all samples). + """""" + + try: + totals_out = os.path.join(outdir, f""{chromosome}.total.gz"") + thresholds_out = os.path.join(outdir, f""{chromosome}.thresholds.gz"") + + if os.path.exists(totals_out) and os.path.exists(thresholds_out): + log( + msg=f""Output files already exist, skipping chromosome {chromosome}\n"", + level=""INFO"", + ) + return + + log(msg=f""Loading chromosome {chromosome}\n"", level=""INFO"") + # Per-position coverage bed files for each sample + perpos_files = [ + os.path.join(outdir, name + "".per-base.bed.gz"") for name in all_names + ] + + # Identify the start-positions files for this chromosome + starts_files = [] + for name in all_names: + starts_files.append( + os.path.join(outdir, name + ""."" + chromosome + "".starts.gz"") + ) + + log( + msg=f""Reading SNPs file for chromosome {chromosome}\n"", + level=""INFO"", + ) + # Load SNP positions and counts for this chromosome + + if chromosome.endswith(""X"") or chromosome.endswith(""Y""): + log( + msg=""Running on sex chromosome -- ignoring SNPs and min SNP reads\n"", + level=""INFO"", + ) + + # TODO: do this procedure only for XY + last_start = get_chr_end(outdir, all_names, chromosome) + positions = np.arange(5000, last_start, 5000) + + else: + positions, _, _ = read_snps(baf_file, chromosome, all_names) + + thresholds = np.trunc( + np.vstack([positions[:-1], positions[1:]]).mean(axis=0) + ).astype(np.uint32) + last_idx_p = np.argwhere(thresholds > centromere_start)[0][0] + first_idx_q = np.argwhere(thresholds > centromere_end)[0][0] + all_thresholds = np.concatenate( + [ + [1], + thresholds[:last_idx_p], + [centromere_start], + [centromere_end], + thresholds[first_idx_q:], + ] + ) + + log(msg=f""Loading counts for chromosome {chromosome}\n"", level=""INFO"") + # Load read count arrays from file (also adds end of chromosome as a threshold) + total_counts, complete_thresholds = form_counts_array( + starts_files, perpos_files, all_thresholds, chromosome, tabix=tabix + ) + + np.savetxt(totals_out, total_counts, fmt=""%d"") + np.savetxt(thresholds_out, complete_thresholds, fmt=""%d"") + + log(msg=f""Done chromosome {chromosome}\n"", level=""INFO"") + except Exception as e: + print(f""Error in chromosome {chromosome}:"") + print(e) + traceback.print_exc() + raise e + + +def run_chromosome_wrapper(param): + run_chromosome(*param) + + +def expected_counts_files(dcounts, chrs, all_names): + expected = [] + + for chr in chrs: + for name in all_names: + fname = os.path.join(dcounts, ""."".join([name, chr, ""starts.gz""])) + expected.append(fname) + + # mosdepth output + for name in all_names: + fname = os.path.join(dcounts, name + "".mosdepth.global.dist.txt"") + expected.append(fname) + + fname = os.path.join(dcounts, name + "".mosdepth.summary.txt"") + expected.append(fname) + + fname = os.path.join(dcounts, name + "".per-base.bed.gz"") + expected.append(fname) + + fname = os.path.join(dcounts, name + "".per-base.bed.gz.csi"") + expected.append(fname) + + return expected + + +def check_counts_files(dcounts, chrs, all_names): + return [ + a + for a in expected_counts_files(dcounts, chrs, all_names) + if not os.path.exists(a) + ] + + +def expected_arrays(darray, chrs): + expected = [] + # formArray (abin/. files)) + + fname = os.path.join(darray, ""samples.txt"") + expected.append(fname) + + for ch in chrs: + fname = os.path.join(darray, f""{ch}.total.gz"") + expected.append(fname) + + fname = os.path.join(darray, f""{ch}.thresholds.gz"") + expected.append(fname) + + return expected + + +def check_array_files(darray, chrs): + return [a for a in expected_arrays(darray, chrs) if not os.path.exists(a)] + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/ArgParsing.py",".py","85045","2623","import sys +import os.path +from os.path import isfile, isdir +import argparse +import subprocess + +from hatchet.utils.Supporting import ( + ensure, + log, + error, + which, + url_exists, + bcolors, + numericOrder, +) +from hatchet import config, __version__ + + +def parse_plot_bins_1d2d_args(args=None): + """""" + Parse command line arguments for auxiliary cluster plotting command (1D and 2D plot with matching colors and + optional labeled centers) + """""" + description = """" + parser = argparse.ArgumentParser( + prog=""hatchet plot-cn"", + description=description, + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + ""-b"", + ""--bbc"", + help=""Filename for BBC table (e.g., bbc/bulk.bbc)"", + required=True, + type=str, + ) + parser.add_argument( + ""-s"", + ""--seg"", + help=""Filename for SEG table (e.g., bbc/bulk.seg) optional but required to show cluster centers"", + required=False, + type=str, + default=config.plot_bins_1d2d.seg, + ) + parser.add_argument( + ""-O"", + ""--outdir"", + required=True, + type=str, + help=""Directory for output files"", + ) + parser.add_argument( + ""--baflim"", + required=False, + type=str, + help=( + ""Axis limits for mirrored BAF as comma-separated values, e.g., '0,0.51' (default: None -- show full "" + ""range of data)"" + ), + default=config.plot_bins_1d2d.baflim, + ) + parser.add_argument( + ""--rdrlim"", + required=False, + type=str, + help=( + ""Axis limits for read-depth ratio as comma-separated values, e.g., '0,3' (default: None -- show full "" + ""range of data)"" + ), + default=config.plot_bins_1d2d.fcnlim, + ) + parser.add_argument( + ""--centers"", + required=False, + action=""store_true"", + help=""Show cluster centers (requires SEG file provided via -s/--seg)"", + default=config.plot_bins_1d2d.centers, + ) + parser.add_argument( + ""--centromeres"", + required=False, + action=""store_true"", + help=""Mark centromere locations with grey rectangles"", + default=config.plot_bins_1d2d.centromeres, + ) + parser.add_argument( + ""-a"", + ""--alpha"", + required=False, + type=float, + help=""Opacity alpha (default 1)"", + default=config.plot_bins_1d2d.alpha, + ) + args = parser.parse_args(args) + + ensure(isfile(args.bbc), f""Input BBC file [{args.bbc}] not found."") + ensure( + (args.seg is None) or (isfile(args.seg)), + f""Input SEG file [{args.seg}] not found."", + ) + + if args.baflim is not None: + tkns = args.baflim.split("","") + try: + minbaf = float(tkns[0].strip()) + maxbaf = float(tkns[1].strip()) + except ValueError: + error( + ""--baflim must be comma-separated float or integer values."", + raise_exception=True, + ) + ensure(minbaf < maxbaf, ""Minimum BAF must be < maximum BAF."") + else: + minbaf = maxbaf = None + + if args.rdrlim is not None: + tkns = args.rdrlim.split("","") + try: + minrdr = float(tkns[0].strip()) + maxrdr = float(tkns[1].strip()) + except ValueError: + error( + ""--rdrlim must be comma-separated float or integer values."", + raise_exception=True, + ) + ensure(minrdr < maxrdr, ""Minimum RDR must be < maximum RDR."") + else: + minrdr = maxrdr = None + + return { + ""bbc"": args.bbc, + ""seg"": args.seg, + ""outdir"": args.outdir, + ""minbaf"": minbaf, + ""maxbaf"": maxbaf, + ""minrdr"": minrdr, + ""maxrdr"": maxrdr, + ""centers"": args.centers, + ""centromeres"": args.centromeres, + ""alpha"": args.alpha, + } + + +def parse_plot_cn_1d2d_args(args=None): + """""" + Parse command line arguments for auxiliary plotting command (1D and 2D plot with labeled copy states) + """""" + description = """" + parser = argparse.ArgumentParser( + prog=""hatchet plot-cn"", + description=description, + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + ""INPUT"", help=""Filename for BBC table (e.g., results/best.bbc.ucn)"" + ) + parser.add_argument( + ""-O"", + ""--outdir"", + required=True, + type=str, + help=""Directory for output files"", + ) + parser.add_argument( + ""--baflim"", + required=False, + type=str, + help=( + ""Axis limits for mirrored BAF values to show as comma-separated values, e.g., '0,0.51' (default: None "" + ""-- show full range of data)"" + ), + default=config.plot_cn_1d2d.baflim, + ) + parser.add_argument( + ""--fcnlim"", + required=False, + type=str, + help=( + ""Axis limits for fractional copy number values to show as comma-separated values, e.g., '0,3' (default: "" + ""None -- show full range of data)"" + ), + default=config.plot_cn_1d2d.fcnlim, + ) + parser.add_argument( + ""--centromeres"", + required=False, + action=""store_true"", + help=""Mark centromere locations with grey rectangles"", + default=config.plot_cn_1d2d.centromeres, + ) + parser.add_argument( + ""--bysample"", + required=False, + action=""store_true"", + help=""Write each sample to a separate file rather than combining all into 2 file"", + default=config.plot_cn_1d2d.bysample, + ) + + args = parser.parse_args(args) + + ensure(isfile(args.INPUT), f""Input file [{args.INPUT}] not found."") + + if args.baflim is not None: + tkns = args.baflim.split("","") + try: + minbaf = float(tkns[0].strip()) + maxbaf = float(tkns[1].strip()) + except ValueError: + error( + ""--baflim must be comma-separated float or integer values."", + raise_exception=True, + ) + else: + minbaf = maxbaf = None + + if args.fcnlim is not None: + tkns = args.fcnlim.split("","") + try: + minfcn = float(tkns[0].strip()) + maxfcn = float(tkns[1].strip()) + except ValueError: + error( + ""--fcnlim must be comma-separated float or integer values."", + raise_exception=True, + ) + else: + minfcn = maxfcn = None + + return { + ""input"": args.INPUT, + ""outdir"": args.outdir, + ""minbaf"": minbaf, + ""maxbaf"": maxbaf, + ""minfcn"": minfcn, + ""maxfcn"": maxfcn, + ""bysample"": args.bysample, + ""centromeres"": args.centromeres, + } + + +def parse_cluster_bins_args(args=None): + """""" + Parse command line arguments + Returns: + """""" + description = ( + ""Combine tumor bin counts, normal bin counts, and tumor allele counts to obtain the read-depth "" + ""ratio and the mean B-allel frequency (BAF) of each bin. Optionally, the normal allele counts can "" + ""be provided to add the BAF of each bin scaled by the normal BAF. The output is written on stdout."" + ) + parser = argparse.ArgumentParser( + prog=""hatchet cluster-bins"", + description=description, + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + ""BBFILE"", + help=( + ""A BB file containing a line for each bin in each sample and the corresponding values of read-depth "" + ""ratio and B-allele frequency (BAF)"" + ), + ) + parser.add_argument( + ""-o"", + ""--outsegments"", + required=False, + default=config.cluster_bins.outsegments, + type=str, + help=""Output filename for the segments computed by clustering bins (default: stdout)"", + ) + parser.add_argument( + ""-O"", + ""--outbins"", + required=False, + default=config.cluster_bins.outbins, + type=str, + help=""Output filename for a BB file adding the clusters (default: stdout)"", + ) + parser.add_argument( + ""-d"", + ""--diploidbaf"", + type=float, + required=False, + default=config.cluster_bins.diploidbaf, + help=( + ""Maximum diploid-BAF shift used to determine the largest copy-neutral cluster and to rescale all the "" + ""cluster inside this threshold accordingly (default: 0.1)"" + ), + ) + parser.add_argument( + ""--minK"", + type=int, + required=False, + default=config.cluster_bins.mink, + help=f""Minimum number of clusters to infer (default = {config.cluster_bins.mink})"", + ) + parser.add_argument( + ""--maxK"", + type=int, + required=False, + default=config.cluster_bins.maxk, + help=f""Maximum number of clusters to infer (default = {config.cluster_bins.maxk})"", + ) + parser.add_argument( + ""--exactK"", + type=int, + required=False, + default=config.cluster_bins.exactk, + help=""Skip model selection and infer exactly this many clusters (default: None)"", + ) + parser.add_argument( + ""-t"", + ""--transmat"", + type=str, + required=False, + default=config.cluster_bins.transmat, + help=""Form of transition matrix to infer: fixed, diag (1-parameter), or full (default: diag)"", + ) + parser.add_argument( + ""--tau"", + type=float, + required=False, + default=config.cluster_bins.tau, + help=f""Off-diagonal value for initializing transition matrix (default: {config.cluster_bins.tau})"", + ) + parser.add_argument( + ""-c"", + ""--covar"", + type=str, + required=False, + default=config.cluster_bins.covar, + help=""Form of covariance matrix: spherical, diag, full, or tied (default: diag)"", + ) + parser.add_argument( + ""-x"", + ""--decoding"", + type=str, + required=False, + default=config.cluster_bins.decoding, + help=""Decoding algorithm to use: map or viterbi (default: map)"", + ) + parser.add_argument( + ""-s"", + ""--selection"", + type=str, + required=False, + default=config.cluster_bins.selection, + help=""Number of HMM states selection criterion: bic or silhouette (default: bic)"", + ) + parser.add_argument( + ""-R"", + ""--restarts"", + type=int, + required=False, + default=config.cluster_bins.restarts, + help=""Number of restarts performed by the clustering to choose the best (default: 10)"", + ) + parser.add_argument( + ""-S"", + ""--subset"", + required=False, + default=config.cluster_bins.subset, + type=str, + nargs=""+"", + help=( + ""List of sample names to use as a subset of those included in binning"" + ""(default: none, run on all samples)"" + ), + ) + parser.add_argument( + ""--allow_gaps"", + action=""store_true"", + required=False, + default=config.cluster_bins.allow_gaps, + help='Set this flag to allow gaps in chromosomes (each contiguous region is considered a separate ""arm"").', + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args(args) + + ensure(isfile(args.BBFILE), ""The specified BB file does not exist!"") + ensure( + (args.diploidbaf is None) or (0.0 <= args.diploidbaf <= 0.5), + ""The specified maximum for diploid-BAF shift must be a value in [0.0, 0.5]"", + ) + + if args.exactK > 0: + log( + msg=f""WARNING: using fixed K (K={args.exactK}) will bypass model selection.\n"", + level=""WARN"", + ) + + ensure(args.minK >= 0, ""Min. number of clusters must be non-negative."") + ensure(args.maxK >= 0, ""Max. number of clusters must be non-negative."") + ensure( + args.minK <= args.maxK, + ""Min number of clusters must be smaller than max number of clusters."", + ) + + if args.maxK == args.minK: + log( + msg=f""WARNING: minK = maxK = {args.minK}, so no model selection will be performed.\n"", + level=""WARN"", + ) + + valid_covars = (""spherical"", ""diag"", ""full"", ""tied"") + ensure( + args.covar in valid_covars, + f""Invalid -c/--covar argument: {args.covar}. Valid values are {valid_covars}."", + ) + + valid_decodings = (""map"", ""viterbi"") + ensure( + args.decoding in valid_decodings, + f""Invalid -x/--decoding argument: {args.decoding}. Valid values are {valid_decodings}."", + ) + + valid_selections = (""bic"", ""silhouette"") + ensure( + args.selection in valid_selections, + f""Invalid -s/--selection argument: {args.selection}. Valid values are {valid_selections}."", + ) + + valid_transmats = (""fixed"", ""diag"", ""free"") + ensure( + args.transmat in valid_transmats, + f""Invalid -t/--transmat argument: {args.transmat}. Valid values are {valid_transmats}."", + ) + ensure(args.restarts >= 1, ""Number of restarts must be positive."") + ensure(args.tau >= 0, ""Transition parameter --tau must be non-negative."") + ensure( + args.tau >= 6e-17, + ""Transition parameter --tau must be at least 6e-17 to ensure numerical precision."", + ) + + if args.subset is not None: + import pandas as pd + + args.subset = args.subset.split() + bb = pd.read_table(args.BBFILE) + samples = bb.SAMPLE.unique() + ensure( + all([a in samples for a in args.subset]), + 'Samples indicated in ""subset"" must be present in input BB file. BB file:' + + f""{samples}, argument: {args.subset}"", + ) + + return { + ""bbfile"": args.BBFILE, + ""diploidbaf"": args.diploidbaf, + ""decoding"": args.decoding, + ""selection"": args.selection, + ""minK"": args.minK, + ""maxK"": args.maxK, + ""exactK"": args.exactK, + ""covar"": args.covar, + ""transmat"": args.transmat, + ""tau"": args.tau, + ""outsegments"": args.outsegments, + ""outbins"": args.outbins, + ""restarts"": args.restarts, + ""subset"": args.subset, + ""allow_gaps"": args.allow_gaps, + } + + +def parse_count_reads_args(args=None): + description = ( + ""Count the mapped sequencing reads in bins of fixed and given length, uniformly for a BAM file of "" + ""a normal sample and one or more BAM files of tumor samples. This program supports both data from "" + ""whole-genome sequencing (WGS) and whole-exome sequencing (WES), but the a BED file with targeted "" + ""regions is required when considering WES."" + ) + parser = argparse.ArgumentParser( + prog=""hatchet count-reads"", description=description + ) + parser.add_argument( + ""-N"", + ""--normal"", + required=True, + type=str, + help=""BAM file corresponding to matched normal sample"", + ) + parser.add_argument( + ""-T"", + ""--tumor"", + required=True, + type=str, + nargs=""+"", + help=""BAM files corresponding to samples from the same tumor"", + ) + parser.add_argument( + ""-b"", + ""--baffile"", + required=True, + type=str, + help=""1bed file containing SNP information from tumor samples (i.e., baf/bulk.1bed)"", + ) + parser.add_argument( + ""-V"", + ""--refversion"", + required=True, + type=str, + help=""Version of reference genome used in BAM files"", + ) + parser.add_argument( + ""-O"", + ""--outdir"", + required=True, + type=str, + help=""Directory for output files"", + ) + parser.add_argument( + ""-S"", + ""--samples"", + required=False, + default=config.count_reads.samples, + type=str, + nargs=""+"", + help=( + ""Sample names for each BAM, given in the same order where the normal name is first (default: inferred "" + ""from file names)"" + ), + ) + parser.add_argument( + ""-st"", + ""--samtools"", + required=False, + type=str, + default=config.paths.samtools, + help=""Path to samtools executable"", + ) + parser.add_argument( + ""-md"", + ""--mosdepth"", + required=False, + type=str, + default=config.paths.mosdepth, + help=""Path to mosdepth executable"", + ) + parser.add_argument( + ""-tx"", + ""--tabix"", + required=False, + type=str, + default=config.paths.tabix, + help=""Path to tabix executable"", + ) + parser.add_argument( + ""-j"", + ""--processes"", + required=False, + default=config.count_reads.processes, + type=int, + help=""Number of available parallel processes (default: 2)"", + ) + parser.add_argument( + ""-q"", + ""--readquality"", + required=False, + default=config.count_reads.readquality, + type=int, + help=( + ""Minimum mapping quality for an aligned read to be considered (default: "", + f""{config.count_reads.readquality})"", + ), + ) + parser.add_argument( + ""-i"", + ""--intermediates"", + required=False, + action=""store_true"", + default=config.count_reads.intermediates, + help=""Produce intermediate counts files only and do not proceed to forming arrays (default: False)"", + ) + parser.add_argument( + ""--chromosomes"", + required=False, + nargs=""*"", + help=""One or more chromosomes to process (default: blank to process all chromosomes)"", + ) + + args = parser.parse_args(args) + + # Parse BAM files, check their existence, and infer or parse the corresponding sample names + bams = [args.normal] + args.tumor + for bamfile in bams: + ensure( + isfile(bamfile), + f""The specified tumor BAM file {bamfile} does not exist"", + ) + # also make sure the bam index files are present too + for bamfile in bams: + ensure( + isfile(bamfile + "".bai"") or isfile(bamfile.replace("".bam"", "".bai"")), + f""The specified tumor BAM file {bamfile} does not have an index file (bai)"", + ) + names = args.samples + ensure( + (names is None) or (len(bams) == len(names)), + ""A sample name must be provided for each corresponding BAM: both for each normal sample and each tumor sample"", + ) + + if names is None: + names = [""normal""] + for bamfile in bams[1:]: + names.append(os.path.splitext(os.path.basename(bamfile))[0]) + + # In default mode, check the existence and compatibility of samtools and bcftools + samtools = os.path.join(args.samtools, ""samtools"") + ensure( + which(samtools) is not None, + ""samtools has not been found or is not executable."", + ) + + # Extract the names of the chromosomes and check their consistency across the given BAM files and the reference + chromosomes = extractChromosomes( + samtools, [bams[0], ""normal""], [(x, """") for x in bams[1:]] + ) + if args.chromosomes: + chromosomes = [c for c in chromosomes if c in args.chromosomes] + + # Check that chr notation is consistent across chromosomes + using_chr = [a.startswith(""chr"") for a in chromosomes] + if any(using_chr): + ensure( + all(using_chr), + ""Some chromosomes use chr notation while others do not."", + ) + use_chr = True + else: + use_chr = False + + ver = args.refversion + ensure( + ver in (""hg19"", ""hg38""), + ""Invalid reference genome version. Supported versions are hg38 and hg19."", + ) + ensure(os.path.exists(args.baffile), f""BAF file not found: {args.baffile}"") + ensure( + args.processes > 0, + ""The number of parallel processes must be greater than 0"", + ) + ensure( + os.path.exists(args.outdir), + f""Output directory <{args.outdir}> not found!"", + ) + + mosdepth = os.path.join(args.mosdepth, ""mosdepth"") + tabix = os.path.join(args.tabix, ""tabix"") + ensure( + which(mosdepth) is not None, + ( + ""The mosdepth executable was not found or is not executable. Please install mosdepth (e.g., conda install "" + ""-c bioconda mosdepth) and/or supply the path to the executable."" + ), + ) + ensure( + which(tabix) is not None, + ( + ""The tabix executable was not found or is not executable. Please install tabix (e.g., conda install -c "" + ""bioconda tabix) and/or supply the path to the executable."" + ), + ) + + return { + ""bams"": bams, + ""names"": names, + ""chromosomes"": chromosomes, + ""samtools"": samtools, + ""mosdepth"": mosdepth, + ""tabix"": tabix, + ""j"": args.processes, + ""outdir"": args.outdir, + ""use_chr"": use_chr, + ""refversion"": ver, + ""baf_file"": args.baffile, + ""readquality"": args.readquality, + } + + +def parse_combine_counts_args(args=None): + parser = argparse.ArgumentParser( + description=""Perform adaptive binning, compute RDR and BAF for each bin, and produce a BB file."" + ) + parser.add_argument( + ""-A"", + ""--array"", + type=str, + required=True, + help='Directory containing array files (output from ""count_reads"" command)', + ) + parser.add_argument( + ""-t"", + ""--totalcounts"", + required=True, + type=str, + help=( + 'Total read counts in the format ""SAMPLE\tCOUNT"" used to normalize by the different number of reads ' + ""extracted from each sample"" + ), + ) + parser.add_argument( + ""-b"", + ""--baffile"", + required=True, + type=str, + help=""1bed file containing SNP information from tumor samples (i.e., baf/bulk.1bed)"", + ) + parser.add_argument( + ""-r"", + ""--referencefasta"", + required=True, + type=str, + help=""path to the reference genome fasta file"", + ) + parser.add_argument( + ""-o"", ""--outfile"", required=True, type=str, help=""Filename for output"" + ) + parser.add_argument( + ""--msr"", + type=int, + help=f""Minimum SNP reads per bin (default {config.combine_counts.msr})"", + default=config.combine_counts.msr, + ) + parser.add_argument( + ""--mtr"", + type=int, + help=f""Minimum total reads per bin (default {config.combine_counts.mtr})"", + default=config.combine_counts.mtr, + ) + parser.add_argument( + ""-j"", + ""--processes"", + type=int, + help=f""Number of parallel processes to use (default {config.combine_counts.processes})"", + default=config.combine_counts.processes, + ) + parser.add_argument( + ""-p"", + ""--phase"", + required=False, + default=config.combine_counts.phase, + type=str, + help=""VCF file containing phasing for heterozygous germline SNPs"", + ) + parser.add_argument( + ""-s"", + ""--max_blocksize"", + required=False, + default=config.combine_counts.blocksize, + type=int, + help=f""Maximum size of phasing block (default {config.combine_counts.blocksize})"", + ) + parser.add_argument( + ""-m"", + ""--max_spb"", + required=False, + default=config.combine_counts.max_spb, + type=int, + help=f""Maximum number of SNPs per phasing block (default {config.combine_counts.max_spb})"", + ) + parser.add_argument( + ""-a"", + ""--alpha"", + required=False, + default=config.combine_counts.alpha, + type=float, + help=( + ""Significance level for phase blocking adjacent SNPs. Higher means less trust in phasing. "" + f""(default {config.combine_counts.alpha})"" + ), + ) + parser.add_argument( + ""--ss_em"", + action=""store_true"", + default=config.combine_counts.ss_em, + required=False, + help=""Use single-sample EM BAF inference (instead of multi-sample)"", + ) + parser.add_argument( + ""-z"", + ""--not_compressed"", + action=""store_true"", + default=config.combine_counts.not_compressed, + required=False, + help=""Non-compressed intermediate files"", + ) + parser.add_argument( + ""-V"", + ""--refversion"", + required=True, + type=str, + help=""Version of reference genome used in BAM files"", + ) + args = parser.parse_args(args) + + ensure(os.path.exists(args.baffile), f""BAF file not found: {args.baffile}"") + ensure( + os.path.exists(args.referencefasta), + f""Reference genome fasta file file not found: {args.referencefasta}"", + ) + if args.totalcounts is not None and not isfile(args.totalcounts): + raise ValueError( + error(""The specified file for total read counts does not exist!"") + ) + + if args.phase == ""None"": + args.phase = None + ensure( + (args.phase is None) or isfile(args.phase), + ""The specified phasing file does not exist!"", + ) + ensure(args.max_blocksize > 0, ""The max_blocksize argument must be positive."") + ensure(args.max_spb > 0, ""The max_snps_per_bin argument must be positive."") + ensure( + 0 <= args.alpha <= 1, + ""The alpha argument must be between 0 and 1, inclusive."", + ) + ensure( + os.path.exists(args.array), + f""The provided array directory does not exist: {args.array}"", + ) + + # pybedtools require 'bedtools' executable to be in PATH + ensure( + which(os.path.join(""bedtools"")) is not None, + ( + ""The bedtools executable was not found or is not executable. Please install bedtools (e.g., conda install "" + '-c bioconda bedtools). pybedtools require ""bedtools"" executable to be in PATH.' + ), + ) + namesfile = os.path.join(args.array, ""samples.txt"") + ensure( + os.path.exists(namesfile), + ""Missing file containing sample names (1 per line): {namesfile}"", + ) + names = open(namesfile).read().split() + + chromosomes = set() + for f in os.listdir(args.array): + tkns = f.split(""."") + if len(tkns) > 1 and (tkns[1] == ""thresholds"" or tkns[1] == ""total""): + chromosomes.add(tkns[0]) + chromosomes = sorted(chromosomes) + + for ch in chromosomes: + if args.not_compressed: + totals_arr = os.path.join(args.array, f""{ch}.total"") + thresholds_arr = os.path.join(args.array, f""{ch}.thresholds"") + else: + totals_arr = os.path.join(args.array, f""{ch}.total.gz"") + thresholds_arr = os.path.join(args.array, f""{ch}.thresholds.gz"") + if not os.path.exists(totals_arr): + raise ValueError(error(""Missing array file: {}"".format(totals_arr))) + if not os.path.exists(thresholds_arr): + raise ValueError(error(""Missing array file: {}"".format(thresholds_arr))) + + log(msg=f""Identified {len(chromosomes)} chromosomes.\n"", level=""INFO"") + + using_chr = [a.startswith(""chr"") for a in chromosomes] + if any(using_chr): + if not all(using_chr): + raise ValueError( + error(""Some starts files use 'chr' notation while others do not."") + ) + use_chr = True + else: + use_chr = False + + ensure(args.processes > 0, ""The number of jobs must be positive."") + ensure( + args.msr > 0, + ""The minimum number of SNP-covering reads must be positive."", + ) + ensure(args.mtr > 0, ""The minimum number of total reads must be positive."") + + ver = args.refversion + ensure( + ver in (""hg19"", ""hg38""), + ""Invalid reference genome version. Supported versions are hg38 and hg19."", + ) + + outdir = os.sep.join(args.outfile.split(os.sep)[:-1]) + ensure( + os.path.exists(outdir), + f""Directory for output file does not exist: <{outdir}>"", + ) + + return { + ""baffile"": args.baffile, + ""outfile"": args.outfile, + ""referencefasta"": args.referencefasta, + ""sample_names"": names, + ""min_snp_reads"": args.msr, + ""min_total_reads"": args.mtr, + ""use_chr"": use_chr, + ""processes"": args.processes, + ""chromosomes"": chromosomes, + ""array"": args.array, + ""totalcounts"": args.totalcounts, + ""phase"": args.phase, + ""blocksize"": args.max_blocksize, + ""max_snps_per_block"": args.max_spb, + ""test_alpha"": args.alpha, + ""multisample"": not args.ss_em, + ""ref_version"": ver, + } + + +def parse_genotype_snps_arguments(args=None): + description = ""Genotype and call SNPs in a matched-normal sample."" + parser = argparse.ArgumentParser( + prog=""hatchet genotype-snps"", description=description + ) + parser.add_argument( + ""-N"", + ""--normal"", + required=True, + type=str, + help=""BAM file corresponding to matched normal sample"", + ) + parser.add_argument( + ""-r"", + ""--reference"", + required=True, + type=str, + help=""Human reference genome of BAMs"", + ) + parser.add_argument( + ""-st"", + ""--samtools"", + required=False, + default=config.paths.samtools, + type=str, + help=( + 'Path to the directory to ""samtools"" executable, required in default mode (default: samtools is ' + ""directly called as it is in user $PATH)"" + ), + ) + parser.add_argument( + ""-bt"", + ""--bcftools"", + required=False, + default=config.paths.bcftools, + type=str, + help=( + 'Path to the directory of ""bcftools"" executable, required in default mode (default: bcftools is ' + ""directly called as it is in user $PATH)"" + ), + ) + parser.add_argument( + ""-R"", + ""--snps"", + required=False, + default=config.genotype_snps.snps, + type=str, + help=( + ""List of SNPs to consider in the normal sample (default: heterozygous SNPs are inferred from the normal "" + ""sample)"" + ), + ) + parser.add_argument( + ""-j"", + ""--processes"", + required=False, + default=config.genotype_snps.processes, + type=int, + help=""Number of available parallel processes (default: 2)"", + ) + parser.add_argument( + ""-q"", + ""--readquality"", + required=False, + default=config.genotype_snps.readquality, + type=int, + help=""Minimum mapping quality for an aligned read to be considered (default: 0)"", + ) + parser.add_argument( + ""-Q"", + ""--basequality"", + required=False, + default=config.genotype_snps.basequality, + type=int, + help=""Minimum base quality for a base to be considered (default: 11)"", + ) + parser.add_argument( + ""-c"", + ""--mincov"", + required=False, + default=config.genotype_snps.mincov, + type=int, + help=""Minimum coverage for SNPs to be considered (default: 0)"", + ) + parser.add_argument( + ""-C"", + ""--maxcov"", + required=False, + default=config.genotype_snps.maxcov, + type=int, + help=( + ""Maximum coverage for SNPs to be considered (default: 1000, suggested: twice the values of expected "" + ""average coverage to avoid aligning artefacts)"" + ), + ) + parser.add_argument( + ""-E"", + ""--newbaq"", + required=False, + action=""store_true"", + default=config.genotype_snps.newbaq, + help=""Recompute alignment of reads on the fly during SNP calling (default: false)"", + ) + parser.add_argument( + ""-o"", + ""--outputsnps"", + required=False, + default=config.genotype_snps.outputsnps, + type=str, + help=""Output folder for SNPs separated by chromosome (default: ./)"", + ) + parser.add_argument( + ""--chromosomes"", + required=False, + nargs=""*"", + help=""One or more chromosomes to process (default: blank to process all chromosomes)"", + ) + parser.add_argument( + ""-v"", + ""--verbose"", + action=""store_true"", + default=config.genotype_snps.verbose, + required=False, + help=""Use verbose log messages"", + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args(args) + + # Parse BAM files, check their existence, and infer or parse the corresponding sample names + normalbaf = args.normal + if not isfile(os.path.abspath(normalbaf)): + raise ValueError(error(""The specified normal BAM file does not exist"")) + normal = (os.path.abspath(normalbaf), ""Normal"") + + # In default mode, check the existence and compatibility of samtools and bcftools + samtools = os.path.join(args.samtools, ""samtools"") + bcftools = os.path.join(args.bcftools, ""bcftools"") + ensure( + which(samtools) is not None, + ""samtools has not been found or is not executable!"", + ) + ensure( + which(bcftools) is not None, + ""bcftools has not been found or is not executable!"", + ) + + # Check that SNP, reference, and region files exist when given in input + ensure( + isfile(args.reference), + ""The provided file for human reference genome does not exist!"", + ) + ensure( + (args.outputsnps is None) or (isdir(args.outputsnps)), + ""The folder for output SNPs does not exist!"", + ) + + if args.snps is not None and len(args.snps) < 2: + args.snps = None + if args.snps is not None and not (isfile(args.snps) or url_exists(args.snps)): + error(""The provided list of SNPs does not exist!"", raise_exception=True) + # if the input snps file is a bgzip compressed vcf file + # and associated tabix file is not located in the same directory, report error + if ( + args.snps is not None + and isfile(args.snps) + and args.snps.endswith(""gz"") + and not isfile(args.snps + "".tbi"") + ): + error( + ""The provided list of SNPs is a bgzip compressed vcf file"" + ""but the associated tabix file does not exist!"", + raise_exception=True, + ) + + # Extract the names of the chromosomes and check their consistency across the given BAM files and the reference + chromosomes = extractChromosomes(samtools, normal, [], args.reference) + if args.chromosomes: + chromosomes = [c for c in chromosomes if c in args.chromosomes] + + ensure( + args.processes > 0, + ""The number of parallel processes must be greater than 0"", + ) + ensure(args.readquality >= 0, ""The read mapping quality must be positive"") + ensure(args.basequality >= 0, ""The base quality quality must be positive"") + ensure(args.mincov >= 0, ""The minimum-coverage value must be positive"") + ensure(args.maxcov >= 0, ""The maximum-coverage value must be positive"") + + if args.verbose: + log( + msg='stderr of samtools and bcftools will be collected in the following file ""samtools.log""\n', + level=""WARN"", + ) + with open(""samtools.log"", ""w"") as f: + f.write("""") + + return { + ""normal"": normal, + ""chromosomes"": chromosomes, + ""samtools"": samtools, + ""bcftools"": bcftools, + ""snps"": args.snps, + ""reference"": args.reference, + ""j"": args.processes, + ""q"": args.readquality, + ""Q"": args.basequality, + ""E"": args.newbaq, + ""mincov"": args.mincov, + ""maxcov"": args.maxcov, + ""outputsnps"": os.path.abspath(args.outputsnps), + ""verbose"": args.verbose, + } + + +def parse_download_panel_arguments(args=None): + description = ( + ""Download and prepare files for phasing germline SNPs using a reference panel"" + ) + parser = argparse.ArgumentParser(description=description) + parser.add_argument( + ""-D"", + ""--refpaneldir"", + required=False, + type=str, + default=config.download_panel.refpaneldir, + help=""Path to Reference Panel"", + ) + parser.add_argument( + ""-R"", + ""--refpanel"", + default=config.download_panel.refpanel, + required=False, + type=str, + help=( + 'Reference Panel; specify ""1000GP_Phase3"" to automatically download and use the panel form the 1000 ' + ""genomes project"" + ), + ) + args = parser.parse_args(args) + + ensure( + args.refpaneldir is not None, + 'The command ""download_panel"" requires a path for the variable ""refpaneldir"".', + ) + + return { + ""refpanel"": args.refpanel, + ""refpaneldir"": os.path.abspath(args.refpaneldir), + } + + +def parse_phase_snps_arguments(args=None): + description = ""Phase germline SNPs using a reference panel"" + parser = argparse.ArgumentParser(description=description) + parser.add_argument( + ""-D"", + ""--refpaneldir"", + required=False, + type=str, + default=config.download_panel.refpaneldir, + help=""Path to Reference Panel"", + ) + parser.add_argument( + ""-g"", + ""--refgenome"", + required=True, + type=str, + help=""Path to Reference genome used in BAM files"", + ) + parser.add_argument( + ""-V"", + ""--refversion"", + required=True, + type=str, + help=""Version of reference genome used in BAM files"", + ) + parser.add_argument( + ""-N"", + ""--chrnotation"", + required=False, + action=""store_true"", + help='Use this flag to indicate that chromosomes are named with ""chr"" (default: no ""chr"")', + default=False, + ) + parser.add_argument( + ""-o"", + ""--outdir"", + required=False, + type=str, + help=""Output folder for phased VCFs"", + ) + parser.add_argument( + ""-L"", + ""--snps"", + required=True, + type=str, + nargs=""+"", + help=""List of SNPs in the normal sample to phase"", + ) + parser.add_argument( + ""-j"", + ""--processes"", + required=False, + default=config.genotype_snps.processes, + type=int, + help=""Number of available parallel processes (default: 2)"", + ) + parser.add_argument( + ""-si"", + ""--shapeit"", + required=False, + type=str, + default=config.paths.shapeit, + help=""Path to shapeit executable (default: look in $PATH)"", + ) + parser.add_argument( + ""-pc"", + ""--picard"", + required=False, + type=str, + default=config.paths.picard, + help=""Path to picard executable or jar (default: look in $PATH)"", + ) + parser.add_argument( + ""-bt"", + ""--bcftools"", + required=False, + default=config.paths.bcftools, + type=str, + help='Path to the directory of ""bcftools"" executable (default: look in $PATH)', + ) + parser.add_argument( + ""-bg"", + ""--bgzip"", + required=False, + default=config.paths.bgzip, + type=str, + help='Path to the directory of ""bcftools"" executable (default: look in $PATH)', + ) + args = parser.parse_args(args) + + # add safety checks for custom ref panel + # if args.refpanel != ""1000GP_Phase3"": + + bgzip = os.path.join(args.bgzip, ""bgzip"") + if which(bgzip) is None: + raise ValueError( + error( + ""The 'bgzip' executable was not found or is not executable. \ + Please install bgzip and/or supply the path to the executable."" + ) + ) + + shapeit = os.path.join(args.shapeit, ""shapeit"") + if which(shapeit) is None: + raise ValueError( + error( + ""The 'shapeit' executable was not found or is not executable. \ + Please install shapeit (e.g., conda install -c dranew shapeit) and/or supply the path to the executable."" + ) + ) + + # We may have access to a picard wrapper executable or picard.jar. Take care of both scenarios. + picard_dir = args.picard + picard_java_flags = config.phase_snps.picard_java_flags + picard_bin_path = os.path.join(picard_dir, ""picard"") + picard_jar_path = os.path.join(picard_dir, ""picard.jar"") + if which(picard_bin_path) is not None: + picard = f""{picard_bin_path} {picard_java_flags}"" + elif os.path.exists(picard_jar_path): + picard = f""java {picard_java_flags} -jar {picard_jar_path}"" + else: + error( + ( + ""Neither picard nor picard.jar were found in the given location. Please install picard"" + ""(e.g., conda install -c bioconda picard) and/or supply the path to the executable"" + "" or JAR file."" + ), + raise_exception=True, + ) + + bcftools = os.path.join(args.bcftools, ""bcftools"") + if which(bcftools) is None: + raise ValueError(error(""bcftools has not been found or is not executable!"")) + + if args.refversion not in (""hg19"", ""hg38""): + error( + 'The reference genome version of your samples is not ""hg19"" or ""hg38"".', + raise_exception=True, + ) + + rpd = args.refpaneldir + if not os.path.exists(os.path.join(rpd, ""1000GP_Phase3"", ""1000GP_Phase3.sample"")): + error( + ""Please download the 1000GP reference panel before proceeding"", + raise_exception=True, + ) + + # Check that SNP files exist when given in input + snplists = {} + for f in args.snps: + if not isfile(f): + raise ValueError( + error(""The specified SNP file {} does not exist!"".format(f)) + ) + # use keys that correspond to chromosomes names used (below) + snplists = { + os.path.basename(f).split(""."")[0].replace(""chr"", """"): f for f in args.snps + } + + # Get chromosome names from vcf file names, since they're named according to chromosome in SNPCaller + # rename chromosomes if they have chr prefix; used to locate ref panel files! + chromosomes = [ + os.path.basename(snplists[i]).replace("".vcf.gz"", """").replace(""chr"", """") + for i in snplists + ] + + return { + ""refpaneldir"": args.refpaneldir, + ""j"": args.processes, + ""chromosomes"": chromosomes, + ""snps"": snplists, + ""refvers"": args.refversion, + ""chrnot"": args.chrnotation, + ""refgenome"": args.refgenome, + ""outdir"": os.path.abspath(args.outdir), + ""shapeit"": shapeit, + ""picard"": picard, + ""bcftools"": bcftools, + ""bgzip"": bgzip, + } + + +def parse_count_alleles_arguments(args=None): + description = ( + ""Count the A/B alleles from a matched-normal BAM file and multiple tumor BAM files in specified "" + ""SNP positions or estimated heterozygous SNPs in the normal genome. This tool can be applied both "" + ""to whole-genome sequencing (WGS) data or whole-exome sequencing (WES) data, but coding regions "" + ""must be specified as a BED file in the case of WES."" + ) + parser = argparse.ArgumentParser( + prog=""hatchet count-alleles"", description=description + ) + parser.add_argument( + ""-N"", + ""--normal"", + required=True, + type=str, + help=""BAM file corresponding to matched normal sample"", + ) + parser.add_argument( + ""-T"", + ""--tumors"", + required=True, + type=str, + nargs=""+"", + help=""BAM files corresponding to samples from the same tumor"", + ) + parser.add_argument( + ""-r"", + ""--reference"", + required=True, + type=str, + help=""Human reference genome of BAMs"", + ) + parser.add_argument( + ""-L"", + ""--snps"", + required=True, + type=str, + nargs=""+"", + help=""List of SNPs to consider in the normal sample"", + ) + parser.add_argument( + ""-S"", + ""--samples"", + required=False, + default=config.count_alleles.samples, + type=str, + nargs=""+"", + help=""Sample names for each BAM (given in the same order where the normal name is first)"", + ) + parser.add_argument( + ""-st"", + ""--samtools"", + required=False, + default=config.paths.samtools, + type=str, + help=( + 'Path to the directory to ""samtools"" executable, required in default mode (default: samtools is ' + ""directly called as it is in user $PATH)"" + ), + ) + parser.add_argument( + ""-bt"", + ""--bcftools"", + required=False, + default=config.paths.bcftools, + type=str, + help=( + 'Path to the directory of ""bcftools"" executable, required in default mode (default: bcftools is ' + ""directly called as it is in user $PATH)"" + ), + ) + parser.add_argument( + ""-j"", + ""--processes"", + required=False, + default=config.count_alleles.processes, + type=int, + help=""Number of available parallel processes (default: 2)"", + ) + parser.add_argument( + ""-q"", + ""--readquality"", + required=False, + default=config.count_alleles.readquality, + type=int, + help=""Minimum mapping quality for an aligned read to be considered (default: 0)"", + ) + parser.add_argument( + ""-Q"", + ""--basequality"", + required=False, + default=config.count_alleles.basequality, + type=int, + help=""Minimum base quality for a base to be considered (default: 11)"", + ) + parser.add_argument( + ""-U"", + ""--snpquality"", + required=False, + default=config.count_alleles.snpquality, + type=int, + help=""Minimum SNP-variant quality, QUAL, for a variant to be considered (default: 11)"", + ) + parser.add_argument( + ""-g"", + ""--gamma"", + required=False, + default=config.count_alleles.gamma, + type=float, + help=""Level of confidence to determine heterozigosity of SNPs (default: 0.05)"", + ) + parser.add_argument( + ""-b"", + ""--maxshift"", + required=False, + default=config.count_alleles.maxshift, + type=float, + help=( + ""Maximum allowed absolute difference of BAF from 0.5 for selected heterozygous SNPs in the normal "" + ""sample (default: 0.5)"" + ), + ) + parser.add_argument( + ""-c"", + ""--mincov"", + required=False, + default=config.count_alleles.mincov, + type=int, + help=""Minimum coverage for SNPs to be considered (default: 0)"", + ) + parser.add_argument( + ""-C"", + ""--maxcov"", + required=False, + default=config.count_alleles.maxcov, + type=int, + help=( + ""Maximum coverage for SNPs to be considered (default: 1000, suggested: twice the values of expected "" + ""average coverage to avoid aligning artefacts)"" + ), + ) + parser.add_argument( + ""-E"", + ""--newbaq"", + required=False, + action=""store_true"", + default=config.count_alleles.newbaq, + help=""Recompute alignment of reads on the fly during SNP calling (default: false)"", + ) + parser.add_argument( + ""-O"", + ""--outputnormal"", + required=False, + default=config.count_alleles.outputnormal, + type=str, + help=""Filename of output for allele counts in the normal sample (default: standard output)"", + ) + parser.add_argument( + ""-o"", + ""--outputtumors"", + required=False, + default=config.count_alleles.outputtumors, + type=str, + help=""Output filename for allele counts in tumor samples (default: standard output)"", + ) + parser.add_argument( + ""-l"", + ""--outputsnps"", + required=False, + default=config.count_alleles.outputsnps, + type=str, + help=""Output directory for lists of selected SNPs (default: ./)"", + ) + parser.add_argument( + ""--chromosomes"", + required=False, + nargs=""*"", + help=""One or more chromosomes to process (default: blank to process all chromosomes)"", + ) + parser.add_argument( + ""-v"", + ""--verbose"", + action=""store_true"", + default=config.count_alleles.verbose, + required=False, + help=""Use verbose log messages"", + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args(args) + + # Parse BAM files, check their existence, and infer or parse the corresponding sample names + normalbaf = args.normal + if not isfile(normalbaf): + raise ValueError(error(""The specified normal BAM file does not exist"")) + tumors = args.tumors + for tumor in tumors: + if not isfile(tumor): + raise ValueError( + error(f""The specified tumor BAM file does not exist: {tumor}"") + ) + names = args.samples + ensure( + (names is None) or ((len(tumors) + 1) == len(names)), + ( + ""A sample name must be provided for each corresponding BAM: both for each normal sample and each "", + ""tumor sample"", + ), + ) + + samples = set() + if names is None: + normal = normalbaf, os.path.splitext(os.path.basename(normalbaf))[0] + for tumor in tumors: + samples.add((tumor, os.path.splitext(os.path.basename(tumor))[0])) + else: + normal = normalbaf, names[0] + for i in range(len(tumors)): + samples.add((tumors[i], names[i + 1])) + + # In default mode, check the existence and compatibility of samtools and bcftools + samtools = os.path.join(args.samtools, ""samtools"") + bcftools = os.path.join(args.bcftools, ""bcftools"") + if which(samtools) is None: + raise ValueError(error(""{}samtools has not been found or is not executable!{}"")) + elif which(bcftools) is None: + raise ValueError(error(""{}bcftools has not been found or is not executable!{}"")) + + # Check that SNP, reference, and region files exist when given in input + snplists = {} + for f in args.snps: + if not isfile(f): + raise ValueError( + error(""The specified SNP file {} does not exist!"".format(f)) + ) + snplists = {os.path.basename(f).split(""."")[0]: f for f in args.snps} + if not isfile(args.reference): + raise ValueError( + error(""The provided file for human reference genome does not exist!"") + ) + + # Extract the names of the chromosomes and check their consistency across the given BAM files and the reference + chromosomes = extractChromosomes(samtools, normal, samples, args.reference) + if args.chromosomes: + chromosomes = [c for c in chromosomes if c in args.chromosomes] + snplists = {c: snplists.get(c, []) for c in chromosomes} + + ensure( + args.processes > 0, + ""The number of parallel processes must be greater than 0"", + ) + ensure(args.readquality >= 0, ""The read mapping quality must be positive"") + ensure(args.basequality >= 0, ""The base quality quality must be positive"") + ensure(0 <= args.gamma <= 1, ""Gamma must be a floating value between 0 and 1"") + ensure( + 0 <= args.maxshift <= 0.5, + ""Max BAF shift must be a floating value between 0 and 0.5"", + ) + ensure(args.mincov >= 0, ""The minimum-coverage value must be positive"") + ensure(args.maxcov >= 0, ""The maximum-coverage value must be positive"") + ensure(args.snpquality >= 0, ""The QUAL value must be positive"") + + if args.verbose: + log( + msg='stderr of samtools and bcftools will be collected in the following file ""samtools.log""\n', + level=""WARN"", + ) + with open(""samtools.log"", ""w"") as f: + f.write("""") + + return { + ""normal"": normal, + ""samples"": samples, + ""chromosomes"": chromosomes, + ""samtools"": samtools, + ""bcftools"": bcftools, + ""snps"": snplists, + ""reference"": args.reference, + ""j"": args.processes, + ""q"": args.readquality, + ""Q"": args.basequality, + ""qual"": args.snpquality, + ""E"": args.newbaq, + ""gamma"": args.gamma, + ""maxshift"": args.maxshift, + ""mincov"": args.mincov, + ""maxcov"": args.maxcov, + ""outputNormal"": args.outputnormal, + ""outputTumors"": args.outputtumors, + ""outputSnps"": args.outputsnps, + ""verbose"": args.verbose, + } + + +def parse_count_reads_fw_arguments(args=None): + description = ( + ""Count the mapped sequencing reads in bins of fixed and given length, uniformly for a BAM file of "" + ""a normal sample and one or more BAM files of tumor samples. This program supports both data from "" + ""whole-genome sequencing (WGS) and whole-exome sequencing (WES), but the a BED file with targeted "" + ""regions is required when considering WES."" + ) + parser = argparse.ArgumentParser( + prog=""hatchet count-reads"", description=description + ) + parser.add_argument( + ""-N"", + ""--normal"", + required=True, + type=str, + help=""BAM file corresponding to matched normal sample"", + ) + parser.add_argument( + ""-T"", + ""--tumors"", + required=True, + type=str, + nargs=""+"", + help=""BAM files corresponding to samples from the same tumor"", + ) + parser.add_argument( + ""-b"", + ""--size"", + required=True, + type=str, + help='Size of the bins, specified as a full number or using the notations either ""kb"" or ""Mb""', + ) + parser.add_argument( + ""-S"", + ""--samples"", + required=False, + default=config.count_reads_fw.samples, + type=str, + nargs=""+"", + help=( + ""Sample names for each BAM, given in the same order where the normal name is first (default: inferred "" + ""from file names)"" + ), + ) + parser.add_argument( + ""-st"", + ""--samtools"", + required=False, + default=config.paths.samtools, + type=str, + help=( + 'Path to the directory to ""samtools"" executable, required in default mode (default: samtools is ' + ""directly called as it is in user $PATH)"" + ), + ) + parser.add_argument( + ""-r"", + ""--regions"", + required=False, + default=config.count_reads_fw.regions, + type=str, + help=( + 'BED file containing the a list of genomic regions to consider in the format ""CHR START END"", ' + ""REQUIRED for WES data (default: none, consider entire genome)"" + ), + ) + parser.add_argument( + ""-g"", + ""--reference"", + required=False, + default=config.paths.reference, + type=str, + help=( + ""Reference genome, note that reference must be indexed and the dictionary must exist in the same "" + ""directory with the same name and .dict extension"" + ), + ) + parser.add_argument( + ""-j"", + ""--processes"", + required=False, + default=config.count_reads_fw.processes, + type=int, + help=""Number of available parallel processes (default: 2)"", + ) + parser.add_argument( + ""-q"", + ""--readquality"", + required=False, + default=config.count_reads_fw.readquality, + type=int, + help=( + ""Minimum mapping quality for an aligned read to be considered "", + f""(default: {config.count_reads_fw.readquality})"", + ), + ) + parser.add_argument( + ""-O"", + ""--outputnormal"", + required=False, + default=config.count_reads_fw.outputnormal, + type=str, + help=""Filename of output for allele counts in the normal sample (default: standard output)"", + ) + parser.add_argument( + ""-o"", + ""--outputtumors"", + required=False, + default=config.count_reads_fw.outputtumors, + type=str, + help=""Output filename for allele counts in tumor samples (default: standard output)"", + ) + parser.add_argument( + ""-t"", + ""--outputtotal"", + required=False, + default=config.count_reads_fw.outputtotal, + type=str, + help='Output filename for total read counts in all tumor samples (default: ""total_read.counts"")', + ) + parser.add_argument( + ""-v"", + ""--verbose"", + action=""store_true"", + default=config.count_reads_fw.verbose, + required=False, + help=""Use verbose log messages"", + ) + parser.add_argument( + ""--chromosomes"", + required=False, + nargs=""*"", + help=""One or more chromosomes to process (default: blank to process all chromosomes)"", + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args(args) + + # Parse BAM files, check their existence, and infer or parse the corresponding sample names + normalbaf = args.normal + ensure(isfile(normalbaf), ""The specified normal BAM file does not exist"") + tumors = args.tumors + for tumor in tumors: + ensure( + isfile(tumor), + f""The specified tumor BAM file {tumor} does not exist"", + ) + + names = args.samples + ensure( + names is None or (len(tumors) + 1) == len(names), + ""A sample name must be provided for each corresponding BAM: both for each normal sample and each tumor sample"", + ) + + samples = set() + if names is None: + normal = (normalbaf, os.path.splitext(os.path.basename(normalbaf))[0]) + for tumor in tumors: + samples.add((tumor, os.path.splitext(os.path.basename(tumor))[0])) + else: + normal = (normalbaf, names[0]) + for i in range(len(tumors)): + samples.add((tumors[i], names[i + 1])) + + # Check the region file + ensure( + args.regions is None or isfile(args.regions), + ""The specified region file does not exist"", + ) + + # In default mode, check the existence and compatibility of samtools and bcftools + samtools = os.path.join(args.samtools, ""samtools"") + if which(samtools) is None: + raise ValueError(error(""samtools has not been found or is not executable!"")) + + # Check and parse the given size + size = 0 + try: + if args.size[-2:] == ""kb"": + size = int(args.size[:-2]) * 1000 + elif args.size[-2:] == ""Mb"": + size = int(args.size[:-2]) * 1000000 + else: + size = int(args.size) + except (IndexError, ValueError): + error( + 'Size must be a number, optionally ending with either ""kb"" or ""Mb""!', + raise_exception=True, + ) + + # Check that either region file or available reference name are available + ensure( + any((args.reference, args.regions)), + ( + ""Please either provide a BED file of regions or specify a name of an available references for inferring "" + ""maximum-chromosome lengths"", + ), + ) + ensure( + args.reference is None or isfile(args.reference), + ""The specified reference genome does not exist!"", + ) + + refdict = os.path.splitext(args.reference)[0] + "".dict"" + ensure( + args.reference is None or isfile(args.reference), + ( + ""The dictionary of the reference genome has not been found! Reference genome must be indexed and its "" + ""dictionary must exist in the same directory with same name but extension .dict"" + ), + ) + + # Extract the names of the chromosomes and check their consistency across the given BAM files and the reference + chromosomes = extractChromosomes(samtools, normal, samples) + if args.chromosomes: + chromosomes = [c for c in chromosomes if c in args.chromosomes] + + ensure( + args.processes > 0, + ""The number of parallel processes must be greater than 0"", + ) + ensure(args.readquality >= 0, ""The read mapping quality must be positive"") + + return { + ""normal"": normal, + ""samples"": samples, + ""chromosomes"": chromosomes, + ""samtools"": samtools, + ""regions"": args.regions, + ""size"": size, + ""reference"": args.reference, + ""refdict"": refdict, + ""j"": args.processes, + ""q"": args.readquality, + ""outputNormal"": args.outputnormal, + ""outputTumors"": args.outputtumors, + ""outputTotal"": args.outputtotal, + ""verbose"": args.verbose, + } + + +def parse_combine_counts_fw_args(args=None): + parser = argparse.ArgumentParser( + prog=""hatchet combine-counts"", + description=( + ""Combine tumor bin counts, normal bin counts, and tumor allele counts to obtain the read-depth "" + ""ratio and the mean B-allel frequency (BAF) of each bin. Optionally, the normal allele counts "" + ""can be provided to add the BAF of each bin scaled by the normal BAF. The output is written on "" + ""stdout."" + ), + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + ""-c"", + ""--normalbins"", + required=True, + type=str, + help='Normal bin counts in the format ""SAMPLE\tCHR\tSTART\tEND\tCOUNT""', + ) + parser.add_argument( + ""-C"", + ""--tumorbins"", + required=True, + type=str, + help='Tumor bin counts in the format ""SAMPLE\tCHR\tSTART\tEND\tCOUNT""', + ) + parser.add_argument( + ""-B"", + ""--tumorbafs"", + required=True, + type=str, + help='Tumor allele counts in the format ""SAMPLE\tCHR\tPOS\tREF-COUNT\tALT-COUNT""', + ) + parser.add_argument( + ""-p"", + ""--phase"", + required=False, + default=config.combine_counts.phase, + type=str, + help='Phasing of heterozygous germline SNPs in the format ""CHR\tPOS\t""', + ) + parser.add_argument( + ""-d"", + ""--diploidbaf"", + type=float, + required=False, + default=0.1, + help=( + ""Maximum diploid-BAF shift used to select the bins whose BAF should be normalized by the normal when "" + ""normalbafs is given (default: 0.1)"" + ), + ) + parser.add_argument( + ""-l"", + ""--blocklength"", + required=False, + default=config.combine_counts.blocksize, + type=str, + help=( + 'Size of the haplotype blocks, specified as a full number or using the notations either ""kb"" or ""Mb"" ', + ""(default: 50kb)"", + ), + ) + parser.add_argument( + ""-t"", + ""--totalcounts"", + required=False, + default=None, + type=str, + help=( + 'Total read counts in the format ""SAMPLE\tCOUNT"" used to normalize by the different number of reads ' + ""extracted from each sample (default: none)"" + ), + ) + parser.add_argument( + ""-g"", + ""--gamma"", + type=float, + required=False, + default=0.05, + help=( + ""Confidence level used to determine if a bin is copy neutral with BAF of 0.5 in the BINOMIAL_TEST mode "" + ""(default: 0.05)"" + ), + ) + parser.add_argument( + ""-e"", + ""--seed"", + type=int, + required=False, + default=0, + help=""Random seed used for the normal distributions used in the clouds (default: 0)"", + ) + parser.add_argument( + ""-v"", + ""--verbose"", + action=""store_true"", + required=False, + help=""Use verbose log messages"", + ) + parser.add_argument( + ""-r"", + ""--disablebar"", + action=""store_true"", + required=False, + help=""Disable progress bar"", + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args(args) + + ensure( + isfile(args.normalbins), + ""The specified file for normal bin counts does not exist!"", + ) + ensure( + isfile(args.tumorbins), + ""The specified file for tumor bin counts does not exist!"", + ) + ensure( + isfile(args.normalbins), + ""The specified file for normal bin counts does not exist!"", + ) + if args.phase == ""None"": # TODO - why do we need this? + args.phase = None + ensure( + (args.phase is None) or (isfile(args.phase)), + ""The specified file for phase does not exist!"", + ) + ensure( + 0.0 <= args.diploidbaf <= 0.5, + ""The specified maximum for diploid-BAF shift must be a value in [0.0, 0.5]"", + ) + ensure( + (args.totalcounts is None) or (isfile(args.totalcounts)), + ""The specified file for total read counts does not exist!"", + ) + ensure( + 0.0 <= args.gamma <= 0.1, + ""The specified gamma must be a value in [0.0, 0.1]"", + ) + ensure(args.seed >= 0, ""Seed parameter must be positive!"") + + args.blocklength = str(args.blocklength) + try: + if args.blocklength[-2:] == ""kb"": + size = int(args.blocklength[:-2]) * 1000 + elif args.blocklength[-2:] == ""Mb"": + size = int(args.blocklength[:-2]) * 1000000 + else: + size = int(args.blocklength) + except (IndexError, ValueError): + error( + 'Size must be a number, optionally ending with either ""kb"" or ""Mb""!', + raise_exception=True, + ) + + return { + ""normalbins"": args.normalbins, + ""tumorbins"": args.tumorbins, + ""tumorbafs"": args.tumorbafs, + ""phase"": args.phase, + ""block"": size, + ""diploidbaf"": args.diploidbaf, + ""totalcounts"": args.totalcounts, + ""gamma"": args.gamma, + ""seed"": args.seed, + ""verbose"": args.verbose, + ""disable"": args.disablebar, + } + + +def parse_cluster_bins_gmm_args(args=None): + parser = argparse.ArgumentParser( + prog=""hatchet cluster-bins"", + description=( + ""Combine tumor bin counts, normal bin counts, and tumor allele counts to obtain the read-depth "" + ""ratio and the mean B-allel frequency (BAF) of each bin. Optionally, the normal allele counts "" + ""can be provided to add the BAF of each bin scaled by the normal BAF. The output is written on "" + ""stdout."" + ), + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + ""BBFILE"", + help=( + ""A BB file containing a line for each bin in each sample and the corresponding values of read-depth "" + ""ratio and B-allele frequency (BAF)"" + ), + ) + parser.add_argument( + ""-o"", + ""--outsegments"", + required=False, + default=config.cluster_bins_gmm.outsegments, + type=str, + help=""Output filename for the segments computed by clustering bins (default: stdout)"", + ) + parser.add_argument( + ""-O"", + ""--outbins"", + required=False, + default=config.cluster_bins_gmm.outbins, + type=str, + help=""Output filename for a BB file adding the clusters (default: stdout)"", + ) + parser.add_argument( + ""-d"", + ""--diploidbaf"", + type=float, + required=False, + default=config.cluster_bins_gmm.diploidbaf, + help=( + ""Maximum diploid-BAF shift used to determine the largest copy-neutral cluster and to rescale all the "" + ""cluster inside this threshold accordingly (default: None, scaling is not performed)"" + ), + ) + parser.add_argument( + ""-tR"", + ""--tolerancerdr"", + type=float, + required=False, + default=config.cluster_bins_gmm.tolerancerdr, + help=( + ""Refine the clustering merging the clusters with this maximum difference in RDR values (default: None, "" + ""gurobipy required)"" + ), + ) + parser.add_argument( + ""-tB"", + ""--tolerancebaf"", + type=float, + required=False, + default=config.cluster_bins_gmm.tolerancebaf, + help=( + ""Refine the clustering merging the clusters with this maximum difference in BAF values (default: None, "", + ""gurobipy required)"", + ), + ) + parser.add_argument( + ""-u"", + ""--bootclustering"", + type=int, + required=False, + default=config.cluster_bins_gmm.bootclustering, + help=( + ""Number of points to add for bootstraping each bin to improve the clustering. Each point is generated "" + ""by drawing its values from a normal distribution centered on the values of the bin. This can help the "" + ""clustering when the input number of bins is low (default: 0)"" + ), + ) + parser.add_argument( + ""-dR"", + ""--ratiodeviation"", + type=float, + required=False, + default=config.cluster_bins_gmm.ratiodeviation, + help=""Standard deviation of the read ratios used to generate the points in the clouds (default: 0.02)"", + ) + parser.add_argument( + ""-dB"", + ""--bafdeviation"", + type=float, + required=False, + default=config.cluster_bins_gmm.bafdeviation, + help=""Standard deviation of the BAFs used to generate the points in the clouds (default: 0.02)"", + ) + parser.add_argument( + ""-e"", + ""--seed"", + type=int, + required=False, + default=config.cluster_bins_gmm.seed, + help=""Random seed used for clustering AND the normal distributions used in the clouds (default: 0)"", + ) + parser.add_argument( + ""-K"", + ""--initclusters"", + type=int, + required=False, + default=config.cluster_bins_gmm.initclusters, + help=""The maximum number of clusters to infer (default: 50)"", + ) + parser.add_argument( + ""-c"", + ""--concentration"", + type=float, + required=False, + default=config.cluster_bins_gmm.concentration, + help=( + ""Tuning parameter for clustering (concentration parameter for Dirichlet process prior). Higher favors "" + ""more clusters, lower favors fewer clusters (default 0.02 = 1/K)."" + ), + ) + parser.add_argument( + ""-R"", + ""--restarts"", + type=int, + required=False, + default=config.cluster_bins_gmm.restarts, + help=""Number of restarts performed by the clustering to choose the best (default: 10)"", + ) + parser.add_argument( + ""-v"", + ""--verbose"", + action=""store_true"", + default=config.cluster_bins_gmm.verbose, + required=False, + help=""Use verbose log messages"", + ) + parser.add_argument( + ""--disablebar"", + action=""store_true"", + default=config.cluster_bins_gmm.disablebar, + required=False, + help=""Disable progress bar"", + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args(args) + + ensure(isfile(args.BBFILE), ""The specified BB file does not exist!"") + ensure( + (args.diploidbaf is None) or (0.0 <= args.diploidbaf <= 0.5), + ""The specified maximum for diploid-BAF shift must be a value in [0.0, 0.5]"", + ) + ensure(args.tolerancerdr >= 0, ""Tolerance-RDR parameter must be positive!"") + ensure(args.tolerancebaf >= 0, ""Tolerance-BAF parameter must be positive!"") + ensure(args.bootclustering >= 0, ""Bootclustering parameter must be positive!"") + ensure(args.ratiodeviation >= 0, ""Ratio-deviation parameter must be positive!"") + ensure(args.bafdeviation >= 0, ""BAF-deviation parameter must be positive!"") + ensure(args.seed >= 0, ""Seed parameter must be positive!"") + ensure(args.initclusters >= 0, ""Init-cluster parameter must be positive!"") + ensure(args.concentration >= 0, ""Concentration parameter must be positive!"") + ensure(args.restarts >= 1, ""Number of restarts must be positive!"") + + return { + ""bbfile"": args.BBFILE, + ""cloud"": args.bootclustering, + ""diploidbaf"": args.diploidbaf, + ""rdtol"": args.tolerancerdr, + ""baftol"": args.tolerancebaf, + ""ratiodeviation"": args.ratiodeviation, + ""bafdeviation"": args.bafdeviation, + ""seed"": args.seed, + ""initclusters"": args.initclusters, + ""concentration"": args.concentration, + ""restarts"": args.restarts, + ""verbose"": args.verbose, + ""disable"": args.disablebar, + ""outsegments"": args.outsegments, + ""outbins"": args.outbins, + } + + +def parse_plot_bins_args(args=None): + parser = argparse.ArgumentParser( + prog=""hatchet plot-bins"", + description=( + ""Generate plots for read-depth ratio (RD), B-allele frequency (BAF), and clusters for genomic "", + ""bins in multiple samples using .bb, .cbb, .seg files."", + ), + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument(""INPUT"", help=""Input BBC file with RDR and BAF"") + + b, e = bcolors.BOLD, bcolors.ENDC + parser.add_argument( + ""-c"", + ""--command"", + required=False, + type=str, + default=config.plot_bins.command, + help=( + f""The command determining the plots to generate (default: all)\n\n\t{b}RD{e}: Plot the read-depth ratio "", + f""(RD) values of the genomes for each sample.\n\n\t{b}CRD{e}: Plot the read-depth ratio (CRD) values of "", + f""the genomes for each sample colored by corresponding cluster.\n\n\t{b}BAF{e}: Plot the B-allele "", + f""frequency (BAF) values of the genomes for each sample.\n\n\t{b}CBAF{e}: Plot BAF values for each "", + f""sample colored by corresponding cluster.\n\n\t{b}BB{e}: Plot jointly the values of read-depth ratio "", + f""(RD) and B-allele frequency (BAF) for each bin in all samples and their density.\n\n\t{b}CBB{e}: Plot "", + ""jointly the values of read-depth ratio (RD) and B-allele frequency (BAF) for each bin in all samples "", + f""by coloring the bins depending on their cluster.\n\n\t{b}CLUSTER{e}: Plot jointly the values of "" + f""read-depth ratio (RD) and B-allele frequency (BAF) for each cluster in all samples where the size of "", + ""the markers is proportional to the number of bins."", + ), + ) + parser.add_argument( + ""-s"", + ""--segfile"", + required=False, + type=str, + default=config.plot_bins.segfile, + help=""When the corresponding seg file is provided the clusters are also plotted (default: none)"", + ) + parser.add_argument( + ""-m"", + ""--colormap"", + required=False, + type=str, + default=config.plot_bins.colormap, + help=( + ""Colormap to use for the colors in the plots, the available colormaps are the following "" + ""{Set1, Set2, Paired, Dark2, tab10, tab20}"" + ), + ) + parser.add_argument( + ""-tC"", + ""--chrthreshold"", + required=False, + type=int, + default=config.plot_bins.chrthreshold, + help=""Only covering at least this number of chromosomes are considered (default: None)"", + ) + parser.add_argument( + ""-tS"", + ""--sizethreshold"", + required=False, + type=float, + default=config.plot_bins.sizethreshold, + help=""Only covering at least this genome proportion (default: None)"", + ) + parser.add_argument( + ""--resolution"", + required=False, + default=config.plot_bins.resolution, + type=int, + help=""Resolution of bins (default: bins are not merged)"", + ) + parser.add_argument( + ""--xmin"", + required=False, + default=config.plot_bins.xmin, + type=float, + help=""Minimum value on x-axis for supported plots (default: inferred from data)"", + ) + parser.add_argument( + ""--xmax"", + required=False, + default=config.plot_bins.xmax, + type=float, + help=""Maximum value on x-axis for supported plots (default: inferred from data)"", + ) + parser.add_argument( + ""--ymin"", + required=False, + default=config.plot_bins.ymin, + type=float, + help=""Minimum value on y-axis for supported plots (default: inferred from data)"", + ) + parser.add_argument( + ""--ymax"", + required=False, + default=config.plot_bins.ymax, + type=float, + help=""Maximum value on y-axis for supported plots (default: inferred from data)"", + ) + parser.add_argument( + ""--figsize"", + required=False, + default=config.plot_bins.figsize, + type=str, + help='Size of the plotted figures in the form ""(X-SIZE, Y-SIZE)""', + ) + parser.add_argument( + ""--markersize"", + required=False, + default=config.plot_bins.markersize, + type=int, + help=""Size of the markers (default: values inferred for each plot)"", + ) + parser.add_argument( + ""--colwrap"", + required=False, + default=config.plot_bins.colwrap, + type=int, + help=""Wrapping the plots in this number of columnes (default: 2)"", + ) + parser.add_argument( + ""--fontscale"", + required=False, + default=config.plot_bins.fontscale, + type=float, + help=""Font scale (default: 1)"", + ) + parser.add_argument( + ""-x"", + ""--rundir"", + required=False, + default=config.plot_bins.rundir, + type=str, + help=""Running dirrectory where output the results (default: current directory)"", + ) + parser.add_argument( + ""--pdf"", + action=""store_true"", + default=config.plot_bins.pdf, + required=False, + help=""Output the bb_clustered figure in PDF format (default: PNG)"", + ) + parser.add_argument( + ""--dpi"", + required=False, + default=config.plot_bins.dpi, + type=int, + help=""DPI of PNG images (default: 900)"", + ) + parser.add_argument( + ""-V"", ""--version"", action=""version"", version=f""%(prog)s {__version__}"" + ) + args = parser.parse_args(args) + + ensure(isfile(args.INPUT), ""The specified BB file does not exist!"") + ensure( + args.command is None + or args.command + in ( + ""RD"", + ""CRD"", + ""BAF"", + ""CBAF"", + ""BB"", + ""CBB"", + ""CLUSTER"", + ), + ""Unrecognized COMMAND!"", + ) + ensure( + args.segfile is None or isfile(args.segfile), + ""Specified seg-file does not exist!"", + ) + + ensure( + args.colormap + in ( + ""Set1"", + ""Set2"", + ""Set3"", + ""Paired"", + ""Accent"", + ""Dark2"", + ""tab10"", + ""tab20"", + ""husl"", + ""hls"", + ""muted"", + ""colorblind"", + ""Pastel1"", + ""Pastel2"", + ), + ""Unrecognized colormap!"", + ) + ensure( + args.resolution is None or args.resolution >= 1, + ""Resolution must be greater than 1!"", + ) + ensure( + args.chrthreshold is None or (0 <= args.chrthreshold <= 22), + ""The chromosome threshold must be a integer in [0, 22]"", + ) + ensure(args.colwrap >= 1, ""Colwrap must be grater than 1!"") + ensure(args.fontscale >= 0, ""Font scale must be positive!"") + ensure( + args.sizethreshold is None or (0 <= args.sizethreshold <= 1.0), + ""The size threshold must be a real value in [0, 1]!"", + ) + if args.figsize is not None: + try: + parsed = args.figsize.strip().split("","") + figsize = (float(parsed[0]), float(parsed[1])) + except IndexError: + error(""Wrong format of figsize!"", raise_exception=True) + else: + figsize = None + ensure( + isdir(args.rundir), + ""Running directory either does not exists or is not a directory!"", + ) + + return { + ""input"": args.INPUT, + ""command"": args.command, + ""segfile"": args.segfile, + ""ct"": args.chrthreshold, + ""st"": args.sizethreshold, + ""cmap"": args.colormap, + ""resolution"": args.resolution, + ""xmin"": args.xmin, + ""xmax"": args.xmax, + ""ymin"": args.ymin, + ""ymax"": args.ymax, + ""x"": args.rundir, + ""figsize"": figsize, + ""markersize"": args.markersize, + ""colwrap"": args.colwrap, + ""fontscale"": args.fontscale, + ""pdf"": args.pdf, + ""dpi"": args.dpi, + } + + +def extractChromosomes(samtools, normal, tumors, reference=None): + """""" + Parameters: + samtools: path to samtools executable + normal: tuple of (path to normal BAM file, string name) + tumor: list of tuples (path to BAM file, string name) + reference: path to FASTA file + """""" + + # Read the names of sequences in normal BAM file + normal_sq = getSQNames(samtools, normal[0]) + + # Extract only the names of chromosomes in standard formats + chrm = set() + no_chrm = set() + for i in range(1, 23): + if str(i) in normal_sq: + no_chrm.add(str(i)) + elif ""chr"" + str(i) in normal_sq: + chrm.add(""chr"" + str(i)) + else: + sys.stderr.write( + ( + f""WARNING: a chromosome named either {i} or a variant of CHR{i} cannot be found in the normal "", + ""BAM file\n"", + ) + ) + + for c in [""X"", ""Y""]: + if c in normal_sq: + no_chrm.add(c) + elif ""chr"" + c in normal_sq: + chrm.add(""chr"" + c) + else: + sys.stderr.write( + ( + f""WARNING: a chromosome named either {c} or a variant of CHR{c} cannot be found in the normal "", + ""BAM file\n"", + ) + ) + + if len(chrm) == 0 and len(no_chrm) == 0: + raise ValueError(""No chromosomes found in the normal BAM"") + chromosomes = chrm if len(chrm) > len(no_chrm) else no_chrm + + # Check that chromosomes with the same names are present in each tumor BAM contain + for tumor in tumors: + tumor_sq = getSQNames(samtools, tumor[0]) + if not chromosomes <= tumor_sq: + sys.stderr.write( + ""WARNING: chromosomes {} are not present in the tumor sample {}\n"".format( + chromosomes - tumor_sq, tumor + ) + ) + + # Check consistency of chromosome names with the reference + if reference is not None: + stdout, stderr = subprocess.Popen( + 'grep -e ""^>"" {}'.format(reference), + stdout=subprocess.PIPE, + shell=True, + universal_newlines=True, + ).communicate() + if stderr is not None: + raise ValueError(""Error in reading the reference: {}"".format(reference)) + else: + ref = set(c[1:].strip().split()[0] for c in stdout.strip().split(""\n"")) + ensure( + chromosomes <= ref, + ( + ""The given reference cannot be used because the chromosome names are inconsistent!\nChromosomes found "" + f""in BAF files: {chromosomes}\nChromosomes with the same name found in reference genome: {ref}"", + ), + ) + + return sorted(list(chromosomes), key=numericOrder) + + +def getSQNames(samtools, bamfile): + header, stderr = subprocess.Popen( + [samtools, ""view"", ""-H"", bamfile], + stdout=subprocess.PIPE, + shell=False, + universal_newlines=True, + ).communicate() + if stderr is not None: + raise ValueError( + ""The header of the normal-sample BAM cannot be read with samtools!"" + ) + names = set() + for line in header.strip().split(""\n""): + line = line.split() + if len(line) > 0 and line[0] == ""@SQ"": + names.add(line[1].split("":"")[1].strip()) + return names + + +def parseRegions(region_file, chromosomes): + res = {} + for chro in chromosomes: + res[chro] = [] + nofound = set() + with open(region_file, ""r"") as f: + for line in f: + split = line.strip().split() + chro = split[0] + if chro in chromosomes: + res[chro].append((int(split[1]), int(split[2]))) + else: + nofound.add(chro) + + for c in nofound: + log( + msg=( + f""The chromosome {c} present in the provided regions is non-autosome or is not present in the given "" + ""BAM files\n"" + ), + level=""WARN"", + ) + + for key in res: + ensure( + len(res[key]) != 0, + f""The regions of chromosome {key} could not be determined."", + ) + res[key].sort(key=lambda x: x[0]) + if not all( + a[0] <= a[1] <= b[0] <= b[1] for a, b in zip(res[key], res[key][1:]) + ): + error( + ( + f""The regions provided for chromosome {key} are non-disjoint or a region start is greater than "", + ""corresponding region end"", + ), + raise_exception=True, + ) + + return res +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/combine_counts_fw.py",".py","17717","521","import sys +import math +import gzip +from collections import defaultdict, deque +import numpy as np + +import hatchet.utils.ProgressBar as pb +import hatchet.utils.Supporting as sp +from hatchet.utils.ArgParsing import parse_combine_counts_fw_args + + +def main(args=None): + sp.log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") + args = parse_combine_counts_fw_args(args) + sp.logArgs(args, 80) + np.random.seed(seed=args[""seed""]) + sp.log( + msg=""# Reading and checking the bin count files for computing read-depth ratios\n"", + level=""STEP"", + ) + normalbins, tumorbins, chromosomes, normal, samples1 = readBINs( + normalbins=args[""normalbins""], tumorbins=args[""tumorbins""] + ) + sp.log( + msg=""# Reading and checking the allele count files for computing BAF\n"", + level=""STEP"", + ) + tumorbafs, chromosomes2, samples2 = readBAFs(tumor=args[""tumorbafs""]) + if samples1 != samples2: + raise ValueError( + sp.error( + ""The names of tumor samples are different in bin counts and allele counts!"" + ) + ) + else: + samples = samples1 + if args[""phase""] is not None: + sp.log( + msg=""# Reading phases of heterozygous germline SNPs\n"", + level=""STEP"", + ) + phase = readPhase(args[""phase""]) + else: + phase = None + + totalcounts = None + if args[""totalcounts""] is not None: + sp.log( + msg=""# Reading and checking the total read count files\n"", + level=""STEP"", + ) + totalcounts = readTotalCounts( + filename=args[""totalcounts""], samples=samples, normal=normal + ) + + sp.log( + msg=""# Combine the bin and allele counts to obtain BAF and RD for each bin\n"", + level=""STEP"", + ) + result = combine( + normalbins=normalbins, + tumorbins=tumorbins, + tumorbafs=tumorbafs, + diploidbaf=args[""diploidbaf""], + totalcounts=totalcounts, + chromosomes=chromosomes, + samples=samples, + normal=normal, + gamma=args[""gamma""], + verbose=args[""verbose""], + disable=args[""disable""], + phase=phase, + block=args[""block""], + ) + + sys.stdout.write(""#CHR\tSTART\tEND\tSAMPLE\tRD\t#SNPS\tCOV\tALPHA\tBETA\tBAF\n"") + nonzerobaf = lambda rk: all(sample[4] + sample[5] > 0 for sample in rk) + result = {key: result[key] for key in result if nonzerobaf(result[key])} + sexchroms = set([""X"", ""Y"", ""chrX"", ""chrY""]) + for key in sorted( + result, key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))) + ): + if key[0] in sexchroms: + # skip sex chromosomes since there's no good way to handle them in this version + continue + for sample in sorted(result[key]): + sys.stdout.write( + ""{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\n"".format( + key[0], + key[1], + key[2], + sample[0], + sample[1], + sample[2], + sample[3], + sample[4], + sample[5], + sample[6], + ) + ) + + +def combine( + normalbins, + tumorbins, + tumorbafs, + diploidbaf, + totalcounts, + chromosomes, + samples, + normal, + gamma, + verbose=False, + disable=False, + phase=None, + block=None, +): + res = {} + ctumorbafs = {c: sorted(tumorbafs[c], key=(lambda x: x[1])) for c in tumorbafs} + if not disable: + progress_bar = pb.ProgressBar(total=len(tumorbins), length=40, verbose=verbose) + for bi in sorted( + tumorbins, + key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))), + ): + if bi[0] in ctumorbafs: + # Extract counts + normal_count = normalbins[bi][1] + tumor_counts = {x[0]: x[1] for x in tumorbins[bi]} + + # Extract overlapping SNPs: option 2 + # tumorover = [x for x in ctumorbafs[bi[0]] if bi[1] <= x[1] <= bi[2]] + # ctumorbafs[bi[0]] = [x for x in ctumorbafs[bi[0]] if x not in tumorover] + + tumorover = [] + for i, x in enumerate(ctumorbafs[bi[0]]): + if bi[1] <= x[1] <= bi[2]: + tumorover.append(x) + elif x[1] > bi[2]: + ctumorbafs[bi[0]] = ctumorbafs[bi[0]][i:] + break + + # Partition the overlapping SNPs by samples + tpartition = { + sample: [x for x in tumorover if x[0] == sample] for sample in samples + } + + # Check the bin to be covered in each sample and non-zero count in normal + if ( + sum(len(tpartition[key]) != 0 for key in tpartition) == len(samples) + and normal_count != 0 + ): + # Compute ratios + ratios = { + sample: float(tumor_counts[sample]) / float(normal_count) + for sample in samples + } + + # Compute normalizing factor by total number of reads if provided + if totalcounts is not None: + totalfactor = { + sample: float(totalcounts[normal]) / float(totalcounts[sample]) + for sample in samples + } + ratios = { + sample: float(ratios[sample]) * float(totalfactor[sample]) + for sample in samples + } + + # Compute number of SNPs covering each bin and the average coverage + snps = {sample: len(tpartition[sample]) for sample in samples} + cov = { + sample: float(sum(x[2] + x[3] for x in tpartition[sample])) + / float(len(tpartition[sample])) + for sample in samples + } + + # Compute BAFs + if phase is None: + records = computeBAFs( + partition=tpartition, + diploidbaf=diploidbaf, + samples=samples, + ) + else: + records = computeBAFs( + partition=tpartition, + diploidbaf=diploidbaf, + samples=samples, + phase=phase[bi[0]], + block=block, + ) + parsed = {record[0]: record for record in records} + + res[bi] = [ + ( + parsed[sample][0], + ratios[sample], + snps[sample], + cov[sample], + parsed[sample][1], + parsed[sample][2], + parsed[sample][3], + ) + for sample in samples + ] + else: + if verbose and normal_count != 0: + sp.log( + msg=( + f'The bin ({bi[1]}, {bi[2]}) in chromosomes ""{bi[0]}"" has been discarded because there ' + ""are no covering SNPs in each tumor or normal sample\n"" + ), + level=""WARN"", + ) + elif verbose and normal_count == 0: + sp.log( + msg=( + f'The bin ({bi[1]}, {bi[2]}) in chromosomes ""{bi[0]}"" has been discarded because normal ' + ""read count is zero\n"" + ), + level=""WARN"", + ) + if not disable: + progress_bar.progress( + advance=True, + msg=""Combine bin ({}, {}) in chromosome {}"".format(bi[1], bi[2], bi[0]), + ) + return res + + +def computeBAFs(partition, samples, diploidbaf, phase=None, block=0): + if phase is None: + tpartition = partition + else: + select = lambda L, s: blocking( + list(filter(lambda o: o[1] in phase, L)), s, phase, block + ) + tpartition = {sample: select(partition[sample], sample) for sample in samples} + + alphas = { + sample: sum(int(min(x[2], x[3])) for x in tpartition[sample]) + for sample in samples + } + betas = { + sample: sum(int(max(x[2], x[3])) for x in tpartition[sample]) + for sample in samples + } + mirrorbaf = { + sample: (float(alphas[sample]) / float(alphas[sample] + betas[sample])) + if (alphas[sample] + betas[sample]) > 0 + else 0.5 + for sample in samples + } + + return [ + (sample, alphas[sample], betas[sample], mirrorbaf[sample]) for sample in samples + ] + + +def blocking(L, sample, phase, blocksize): + result = [] + if len(L) == 0: + return result + que = deque(sorted(L, key=(lambda v: v[1]))) + omap = {} + + for bk in range(min(o[1] for o in L), max(o[1] for o in L) + 1, blocksize): + block = (sample, bk, 0, 0) + while que and bk <= que[0][1] < bk + blocksize: + o = que.popleft() + if phase[o[1]] == ""0|1"": + block = (sample, bk, block[2] + o[2], block[3] + o[3]) + elif phase[o[1]] == ""1|0"": + block = (sample, bk, block[2] + o[3], block[3] + o[2]) + else: + assert False, ""Found a wrong phase value"" + omap[o] = bk + if block[2] + block[3] > 0: + result.append(block) + return result + + +def readBINs(normalbins, tumorbins): + normalBINs = {} + tumorBINs = {} + normal = set() + samples = set() + normal_chr = set() + tumor_chr = set() + + # Read normal bin counts + with open(normalbins, ""r"") as f: + for line in f: + parsed = line.strip().split()[:5] + normal_chr.add(parsed[0]) + normal.add(parsed[3]) + if (parsed[0], int(parsed[1]), int(parsed[2])) not in normalBINs: + normalBINs[parsed[0], int(parsed[1]), int(parsed[2])] = ( + parsed[3], + int(parsed[4]), + ) + else: + raise ValueError( + sp.error( + ""Found multiple lines for the same interval in the normal bin counts!"" + ) + ) + + # Check normal bin counts + if len(normal) > 1: + raise ValueError(sp.error(""Found multiple samples in normal bin counts!"")) + prev_r = -1 + prev_c = -1 + for key in sorted( + normalBINs, + key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))), + ): + l, r = int(key[1]), int(key[2]) + if l > r and prev_c == key[0]: + raise ValueError( + sp.error( + ""Found an interval with START {} greater than END {} in normal bin counts!"".format( + key[1], key[2] + ) + ) + ) + if l < prev_r and prev_c == key[0]: + raise ValueError( + sp.error( + ( + f""Found overlapping intervals one ending with {prev_r} and the next starting with {key[1]} in "" + ""normal bin counts!"" + ) + ) + ) + prev_r = r + prev_c = key[0] + + # Read tumor bin counts + with open(tumorbins, ""r"") as f: + for line in f: + parsed = line.strip().split()[:5] + tumor_chr.add(parsed[0]) + samples.add(parsed[3]) + try: + tumorBINs[parsed[0], int(parsed[1]), int(parsed[2])].add( + (parsed[3], int(parsed[4])) + ) + except KeyError: + tumorBINs[parsed[0], int(parsed[1]), int(parsed[2])] = set() + tumorBINs[parsed[0], int(parsed[1]), int(parsed[2])].add( + (parsed[3], int(parsed[4])) + ) + + # Check tumor bin counts + prev_r = -1 + prev_c = -1 + num_samples = len(samples) + for key in sorted( + tumorBINs, + key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))), + ): + l, r = int(key[1]), int(key[2]) + if len(tumorBINs[key]) != num_samples: + raise ValueError( + sp.error( + ""Found multiple lines for the same interval in the tumor bin counts!"" + ) + ) + if l > r and prev_c == key[0]: + raise ValueError( + sp.error( + ""Found an interval with START {} greater than END {} in tumor bin counts!"".format( + key[1], key[2] + ) + ) + ) + if l < prev_r and prev_c == key[0]: + raise ValueError( + sp.error( + ( + f""Found overlapping intervals one ending with {prev_r} and the next starting with {key[1]} in "" + ""tumor bin counts!"" + ) + ) + ) + prev_r = r + prev_c = key[0] + + if normal_chr != tumor_chr: + raise ValueError( + sp.error(""The chromosomes in normal and tumor bin counts are different!"") + ) + if set(normalBINs) != set(tumorBINs): + raise ValueError( + sp.error(""The bins of the normal and tumor samples are different!"") + ) + + chromosomes = sorted(list(normal_chr), key=sp.numericOrder) + + return normalBINs, tumorBINs, chromosomes, normal.pop(), samples + + +def readBAFs(tumor): + tumorBAFs = {} + tumor_chr = set() + + # Read tumor bafs + samples = set() + with open(tumor, ""r"") as f: + for line in f: + parsed = line.strip().split()[:5] + sample = parsed[2] + chromosome = parsed[0] + pos = int(parsed[1]) + ref = int(parsed[3]) + alt = int(parsed[4]) + tumor_chr.add(chromosome) + samples.add(sample) + baf = float(min(ref, alt)) / float(ref + alt) if ref + alt > 0 else 0.5 + try: + tumorBAFs[chromosome].append((sample, pos, ref, alt, baf)) + except KeyError: + tumorBAFs[chromosome] = [(sample, pos, ref, alt, baf)] + + # Check tumor bafs + for key in tumorBAFs: + tumorBAFs[key].sort(key=(lambda x: x[1])) + if len(tumorBAFs[key]) > len(set((x[0], x[1]) for x in tumorBAFs[key])): + raise ValueError( + sp.error(""A position is present multiple times in the tumor samples!"") + ) + + chromosomes = sorted(list(tumor_chr), key=sp.numericOrder) + + return tumorBAFs, chromosomes, samples + + +def readPhase(f): + phased = defaultdict(lambda: dict()) + if not f.endswith("".gz""): + raise ValueError( + ""Please make sure your phased VCF file is compressed with gzip with a .gz suffix"" + ) + with gzip.open(f, ""rt"") as i: + for l in i: + p = l.strip().split() + if len(l) > 1 and p[0][0] != ""#"": + zeroone = ""0|1"" in l + onezero = ""1|0"" in l + if zeroone or onezero: + if zeroone and onezero: + raise ValueError( + ""Found a record in phased positions which contains both phases 0|1 and 1|0!"" + ) + if p[0] in phased[p[0]]: + raise ValueError(""Found a duplicate phased position!"") + phased[p[0]][int(p[1])] = ""0|1"" if zeroone else ""1|0"" + return phased + + +def splitBAF(baf, scale): + BAF = float(baf) + BAF = min(BAF, 1.0 - BAF) + SUM = float(scale) + + roundings = [] + roundings.append((int(math.floor(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) + roundings.append((int(math.floor(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) + roundings.append((int(math.ceil(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) + roundings.append((int(math.ceil(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) + roundings = [(int(min(a, b)), int(max(a, b))) for (a, b) in roundings] + + estimations = [ + float(a) / float(a + b) if a + b > 0 else 1.0 for (a, b) in roundings + ] + diff = [abs(est - BAF) for est in estimations] + best = np.argmin(diff) + return roundings[best][0], roundings[best][1] + + +def readTotalCounts(filename, samples, normal): + normalfound = False + counts = {} + found = set() + with open(filename, ""r"") as f: + for line in f: + parsed = line.strip().split() + if parsed[0] in found: + raise ValueError( + sp.error( + ""Found multiple total read counts for the same sample {}!"".format( + parsed[0] + ) + ) + ) + if parsed[0] == normal: + normalfound = True + else: + found.add(parsed[0]) + counts[parsed[0]] = int(parsed[1]) + if samples < found: + raise ValueError( + sp.error( + ""Found total read counts for samples that are not present in the input!"" + ) + ) + elif found < samples: + raise ValueError( + sp.error(""Missing total read counts for some samples present in the input!"") + ) + elif not normalfound: + raise ValueError(sp.error(""Missing total read counts for normal sample!"")) + else: + return counts + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/count_reads_fw.py",".py","6039","204","import sys +import os.path + +import hatchet.utils.BAMBinning as bb +import hatchet.utils.TotalCounting as tc +import hatchet.utils.ArgParsing as ap +from hatchet.utils.Supporting import log, close, error + + +def main(args=None): + log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") + args = ap.parse_count_reads_fw_arguments(args) + logArgs(args, 80) + + if args[""regions""] is None: + log( + msg=""# Retrieving genomic regions to consider from maximum chromosome length\n"", + level=""STEP"", + ) + regions = knownRegions(args[""refdict""], args[""chromosomes""]) + else: + log( + msg=""# Checking the consistency of the given regions\n"", + level=""STEP"", + ) + regions = ap.parseRegions(args[""regions""], args[""chromosomes""]) + + if args[""verbose""]: + msg = ""regions: "" + for c in args[""chromosomes""]: + msg += "" {}: {}"".format(c, regions[c]) + msg += ""\n"" + log(msg=msg, level=""INFO"") + + log(msg=""# Binning and counting the normal sample\n"", level=""STEP"") + normal_bins = bb.bin( + samtools=args[""samtools""], + samples=[args[""normal""]], + chromosomes=args[""chromosomes""], + num_workers=args[""j""], + q=args[""q""], + size=args[""size""], + regions=regions, + verbose=args[""verbose""], + ) + if not normal_bins: + close(""No bins in the normal sample!\n"") + + log( + msg=""# Writing the read counts for bins of normal sample\n"", + level=""STEP"", + ) + handle = ( + open(args[""outputNormal""], ""w"") + if args[""outputNormal""] is not None + else sys.stdout + ) + for c in args[""chromosomes""]: + for samplename, chromosome, start, stop, n_reads in normal_bins[ + args[""normal""][1], c + ]: + handle.write( + ""\t"".join( + [ + str(chromosome), + str(start), + str(stop), + samplename, + str(n_reads), + ] + ) + + ""\n"" + ) + if handle is not sys.stdout: + handle.close() + + log(msg=""# Binning and counting the tumor samples\n"", level=""STEP"") + tumor_bins = bb.bin( + samtools=args[""samtools""], + samples=args[""samples""], + chromosomes=args[""chromosomes""], + num_workers=args[""j""], + q=args[""q""], + size=args[""size""], + regions=regions, + verbose=args[""verbose""], + ) + if not tumor_bins: + close(""No bins in the tumor samples!\n"") + + log( + msg=""# Writing the read counts for bins of tumor samples\n"", + level=""STEP"", + ) + handle = ( + open(args[""outputTumors""], ""w"") + if args[""outputTumors""] is not None + else sys.stdout + ) + for sample in sorted(args[""samples""]): + for c in args[""chromosomes""]: + for samplename, chromosome, start, stop, n_reads in tumor_bins[ + sample[1], c + ]: + handle.write( + ""\t"".join( + [ + str(chromosome), + str(start), + str(stop), + samplename, + str(n_reads), + ] + ) + + ""\n"" + ) + if handle is not sys.stdout: + handle.close() + + log( + msg=""# Counting total number of reads for normal and tumor samples\n"", + level=""STEP"", + ) + total_counts = tc.tcount( + samtools=args[""samtools""], + samples=({args[""normal""]} | args[""samples""]), + chromosomes=args[""chromosomes""], + num_workers=args[""j""], + q=args[""q""], + verbose=args[""verbose""], + ) + + try: + total = { + sample[1]: sum( + total_counts[sample[1], chromosome] + for chromosome in args[""chromosomes""] + ) + for sample in args[""samples""] + } + total[args[""normal""][1]] = sum( + total_counts[args[""normal""][1], chromosome] + for chromosome in args[""chromosomes""] + ) + except KeyError: + raise KeyError( + error( + ""Either a chromosome or a sample has not been considered in the total counting!"" + ) + ) + + log( + msg=""# Writing the total read counts for all samples in {}\n"".format( + args[""outputTotal""] + ), + level=""STEP"", + ) + with open(args[""outputTotal""], ""w"") as f: + f.write(""{}\t{}\n"".format(args[""normal""][1], total[args[""normal""][1]])) + for sample in sorted(args[""samples""]): + f.write(""{}\t{}\n"".format(sample[1], total[sample[1]])) + + +def knownRegions(refdict, chromosomes): + ends = {c: None for c in chromosomes} + assert os.path.isfile(refdict) + with open(refdict, ""r"") as i: + for l in i: + if ""@SQ"" in l: + assert ""SN:"" in l and ""LN:"" in l + c = l.split(""SN:"")[1].split()[0] + if c in chromosomes: + end = int(l.split(""LN:"")[1].split()[0]) + ends[c] = end + if None in ends.values(): + log( + msg=( + ""The following chromosomes have not been found in the dictionary of the reference genome: "" + ""\n\t{}"" + ).format("","".join([c for c in ends if ends[c] is None])), + level=""WARN"", + ) + + res = {} + for c in chromosomes: + if ends[c] is None: + raise ValueError( + f""Length of chromosome {c} could not be determined. Are you using the correct reference genome?"" + ) + res[c] = [(0, ends[c])] + + return res + + +def logArgs(args, width): + text = ""\n"" + for key in args: + text += ""\t{}: {}\n"".format(key, args[key]) + log(msg=text, level=""INFO"") + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/commands.py",".py","818","37","# All supported HATCHet commands +commands = ( + ""count-reads"", + ""count-reads-fw"", + ""genotype-snps"", + ""count-alleles"", + ""combine-counts"", + ""combine-counts-fw"", + ""cluster-bins"", + ""plot-bins"", + ""compute-cn"", + ""plot-cn"", + ""run"", + ""check"", + ""download-panel"", + ""phase-snps"", + ""cluster-bins-gmm"", + ""plot-cn-1d2d"", + ""plot-bins-1d2d"", +) + + +# Support for old command names as they've been used in earlier versions of HATCHet +command_aliases = { + ""binBAM"": ""count-reads-fw"", + ""SNPCaller"": ""genotype-snps"", + ""deBAF"": ""count-alleles"", + ""comBBo"": ""combine-counts-fw"", + ""cluBB"": ""cluster-bins-gmm"", + ""BBot"": ""plot-bins"", + ""solve"": ""compute-cn"", + ""BBeval"": ""plot-cn"", + ""PhasePrep"": ""download-panel"", + ""Phase"": ""phase-snps"", + ""check-solver"": ""check"", +} +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/download_panel.py",".py","5817","155","import os +import os.path +import subprocess as pr +import gzip + +import hatchet.utils.ArgParsing as ap +from hatchet.utils.Supporting import log, logArgs, error, download, checksum +from hatchet import config + + +def main(args=None): + log(msg=""# log notes\n"", level=""STEP"") + args = ap.parse_download_panel_arguments(args) + logArgs(args) + + os.makedirs(args[""refpaneldir""], exist_ok=True) + + # download reference panel, prepare files for liftover + if args[""refpanel""] == ""1000GP_Phase3"": + # download 1000GP ref panel + download( + url=config.urls.onekgp, + dirpath=args[""refpaneldir""], + sentinel_file=os.path.join(""1000GP_Phase3"", ""1000GP_Phase3.sample""), + ) + else: + error( + 'Currently, only the 1000 genome panel aligned to GRCh37 without ""chr"" prefix is supported\n', + raise_exception=True, + ) + + # download necessary liftover files; 1000GP in hg19 coordinates + # if users aligned reads to the hg38 build, we need to liftover coordinates to the reference panel (hg38 -> hg19) + # since the 1000GP panel is in hg19 coordinates, we need to download (1) hg19 genome and (2) chain files + # for liftover via picard + dwnld_refpanel_genome(path=args[""refpaneldir""]) + dwnld_chains(dirpath=args[""refpaneldir""]) + + # if users aligned reads to the same reference genome as used in the reference panel, liftover isn't required, but + # there could be different naming conventions of chromosomes, with or without the 'chr' prefix. The 1000GP reference + # panel does NOT use 'chr' prefix, so input into shapeit also should not have this + mk_rename_file(path=args[""refpaneldir""]) + + +def dwnld_chains(dirpath): + def mod_chain(infile, sample_chr, refpanel_index, sample_index): + if sample_chr: + name = infile.strip("".gz"").replace(""over"", ""chr"") + else: + name = infile.strip("".gz"").replace(""over"", ""no_chr"") + + with open(name, ""w"") as new: + with gzip.open(infile, ""rt"") as f: + for line in f: + if line.startswith(""chain""): + line = line.split() + if not config.urls.refpanel_genome_chr_notation: + line[refpanel_index] = line[refpanel_index].replace( + ""chr"", """" + ) + if not sample_chr: + line[sample_index] = line[sample_index].replace(""chr"", """") + new.write("" "".join(line) + ""\n"") + else: + new.write(line) + return name + + hg38tohg19 = download( + url=config.urls.refpanel_hg38tohg19, + dirpath=dirpath, + overwrite=False, + extract=False, + ) + hg19tohg38 = download( + url=config.urls.refpanel_hg19tohg38, + dirpath=dirpath, + overwrite=False, + extract=False, + ) + + # make all necessary chain files to convert from hg38 (w/ or w/out chr notation) to hg19 (no chr notation), + # and also to lift back over from hg19 (no chr notation) to hg38 (w/ or w/out chr notation). + + # modify chr notation of hg38ToHg19, ref panel chr in 7th field, sample chr in 2nd field + mod_chain(hg38tohg19, sample_chr=True, refpanel_index=7, sample_index=2) + mod_chain(hg38tohg19, sample_chr=False, refpanel_index=7, sample_index=2) + + # modify chr notation of hg19ToHg38, ref panel chr in 2nd field, sample chr in 7th field + mod_chain(hg19tohg38, sample_chr=True, refpanel_index=2, sample_index=7) + mod_chain(hg19tohg38, sample_chr=False, refpanel_index=2, sample_index=7) + + +def dwnld_refpanel_genome(path): + newref = os.path.join(path, ""hg19_no_chr.fa"") + if not os.path.isfile(newref): + # If the genome reference file used in other parts of HATCHet matches the one we want, use it + reference_file = config.paths.reference + if ( + os.path.isfile(reference_file) + and checksum(reference_file) == config.urls.refpanel_genome_checksum + ): + out = reference_file + else: + out = download(config.urls.refpanel_genome, dirpath=path, extract=False) + + _open, _mode = open, ""r"" + if out.endswith(""gz""): + _open, _mode = gzip.open, ""rt"" + + # change chr notation + with open(newref, ""w"") as new: + with _open(out, _mode) as f: + for line in f: + if line.startswith("">""): + new.write(line.replace(""chr"", """")) + else: + new.write(line) + + # make dict file + dict_file = newref.replace("".fa"", "".dict"") + samtools = os.path.join(config.paths.samtools, ""samtools"") + cmd = f""{samtools} dict {newref} > {dict_file}"" + errname = os.path.join(path, ""samtools.log"") + with open(errname, ""w"") as err: + run = pr.run( + cmd, + stdout=err, + stderr=err, + shell=True, + universal_newlines=True, + ) + if run.returncode != 0: + raise ValueError( + error( + f""Samtools dict creation failed, please check errors in {errname}!"" + ) + ) + else: + os.remove(errname) + return newref + + +def mk_rename_file(path): + # makes rename_chrs1.txt for removing ""chr"", rename_chrs2.txt for adding ""chr"" + names = [os.path.join(path, f""rename_chrs{i}.txt"") for i in range(1, 3)] + for i, n in enumerate(names): + with open(n, ""w"") as f: + for j in range(1, 23): + f.write(f""chr{j} {j}\n"") if i == 0 else f.write(f""{j} chr{j}\n"") + return names + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/cluster_bins_gmm.py",".py","18400","549","import sys +import math +import numpy as np +from collections import Counter + +from hatchet.utils.ArgParsing import parse_cluster_bins_gmm_args +import hatchet.utils.Supporting as sp + + +def main(args=None): + sp.log(msg=""# Parsing and checking input arguments\n"", level=""STEP"") + args = parse_cluster_bins_gmm_args(args) + sp.logArgs(args, 80) + + sp.log(msg=""# Reading the combined BB file\n"", level=""STEP"") + combo, samples = readBB(args[""bbfile""]) + + sp.log(msg=""# Format data to cluster\n"", level=""STEP"") + points, bintoidx = getPoints(data=combo, samples=samples) + + clouds = None + if args[""cloud""] > 0: + sp.log(msg=""# Bootstrap each bin for clustering\n"", level=""STEP"") + clouds = generateClouds( + points=points, + density=args[""cloud""], + seed=args[""seed""], + sdeven=args[""ratiodeviation""], + sdodd=args[""bafdeviation""], + ) + + sp.log( + msg=""# Clustering bins by RD and BAF across tumor samples\n"", + level=""STEP"", + ) + mus, sigmas, clusterAssignments, numPoints, numClusters = cluster( + points=points, + clouds=clouds, + K=args[""initclusters""], + concentration_prior=args[""concentration""], + restarts=args[""restarts""], + seed=args[""seed""], + ) + + if args[""rdtol""] > 0.0 or args[""baftol""] > 0.0: + sp.log(msg=""# Refining clustering using given tolerances\n"", level=""STEP"") + before = len(set(clusterAssignments)) + clusterAssignments, numClusters = refineClustering( + combo=combo, + assign=clusterAssignments, + assignidx=bintoidx, + samples=samples, + rdtol=args[""rdtol""], + baftol=args[""baftol""], + ) + sp.log( + msg=""The number of clusters have been reduced from {} to {} with given tolerances\n"".format( + before, numClusters + ), + level=""INFO"", + ) + + clusterAssignments = reindex(clusterAssignments) + + sp.log(msg=""# Writing BBC output with resulting clusters\n"", level=""STEP"") + if args[""outbins""] is None: + outbins = sys.stdout + else: + outbins = open(args[""outbins""], ""w"") + outbins.write( + ""#CHR\tSTART\tEND\tSAMPLE\tRD\t#SNPS\tCOV\tALPHA\tBETA\tBAF\tCLUSTER\n"" + ) + for key in sorted( + combo, key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))) + ): + for sample in sorted(combo[key]): + outbins.write( + ""{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\n"".format( + key[0], + key[1], + key[2], + sample[0], + sample[1], + sample[2], + sample[3], + sample[4], + sample[5], + sample[6], + clusterAssignments[bintoidx[key]], + ) + ) + if outbins is not sys.stdout: + outbins.close() + + sp.log(msg=""# Segmenting bins\n"", level=""STEP"") + clusters = { + cluster: set( + key for key in combo if clusterAssignments[bintoidx[key]] == cluster + ) + for cluster in set(clusterAssignments) + } + segments = segmentBins(bb=combo, clusters=clusters, samples=samples) + + if args[""diploidbaf""] is not None: + sp.log( + msg=( + ""# Determining the largest cluster as diploid or tetraploid and rescaling all the clusters inside the "" + ""threshold accordingly\n"" + ), + level=""STEP"", + ) + segments = scaleBAF( + segments=segments, samples=samples, diploidbaf=args[""diploidbaf""] + ) + + sp.log(msg=""# Writing REF output with resulting segments\n"", level=""STEP"") + if args[""outsegments""] is None: + outsegments = sys.stdout + else: + outsegments = open(args[""outsegments""], ""w"") + outsegments.write(""#ID\tSAMPLE\t#BINS\tRD\t#SNPS\tCOV\tALPHA\tBETA\tBAF\n"") + for key in sorted(segments): + for sample in sorted(segments[key]): + record = segments[key][sample] + outsegments.write( + ""{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\n"".format( + key, + sample, + record[0], + record[1], + record[2], + record[3], + record[4], + record[5], + record[6], + ) + ) + if outsegments is not sys.stdout: + outsegments.close() + + +def readBB(bbfile): + read = {} + samples = set() + with open(bbfile, ""r"") as f: + for line in f: + if line[0] != ""#"": + parsed = line.strip().split() + chromosome = parsed[0] + start = int(parsed[1]) + end = int(parsed[2]) + sample = parsed[3] + rd = float(parsed[4]) + snps = int(parsed[5]) + cov = float(parsed[6]) + alpha = int(parsed[7]) + beta = int(parsed[8]) + baf = float(parsed[9]) + + samples.add(sample) + try: + read[chromosome, start, end].append( + (sample, rd, snps, cov, alpha, beta, baf) + ) + except KeyError: + read[chromosome, start, end] = [ + (sample, rd, snps, cov, alpha, beta, baf) + ] + nonzeroab = lambda rb: all(rec[4] + rec[5] > 0 for rec in rb) + newread = {b: read[b] for b in read if nonzeroab(read[b])} + diff = len(read.keys()) - len(newread.keys()) + if diff > 0: + sp.log( + msg=""{} bins have been discarded because no covered by any SNP\n"".format( + diff + ), + level=""WARN"", + ) + return newread, samples + + +def getPoints(data, samples): + idx = 0 + points = [] + bintoidx = {} + for bi in sorted( + data, key=(lambda x: (sp.numericOrder(x[0]), int(x[1]), int(x[2]))) + ): + partition = {} + for x in data[bi]: + if x[0] in partition: + raise ValueError( + sp.error( + ""Found a bin ({}, {}) in chromosome {} defined multiple times for the same sample!"".format( + bi[1], bi[2], bi[0] + ) + ) + ) + else: + partition[x[0]] = [x[1], x[-1]] + if len(partition) != len(samples): + raise ValueError( + sp.error( + ""Found a bin ({}, {}) in chromosome {} that is not covered in all the samples!"".format( + bi[1], bi[2], bi[0] + ) + ) + ) + points.append([e for sample in samples for e in partition[sample]]) + bintoidx[bi] = idx + idx += 1 + return points, bintoidx + + +def cluster(points, clouds=None, concentration_prior=None, K=100, restarts=10, seed=0): + """""" + Clusters a set of data points lying in an arbitrary number of clusters. + Arguments: + data (list of lists of floats): list of data points to be clustered. + clouds (list or lists of floats, same second dimension as data): bootstrapped bins for clustering + sampleName (string): The name of the input sample. + concentration_prior (float): Tuning parameter for clustering, must be between 0 and 1. Used to determine + concentration of points in clusters -- higher favors more clusters, lower favors fewer clusters. + K (int): maximum number of clusters to infer + restarts (int): number of initializations to try for GMM + seed (int): random number generator seed for GMM + Returns: + mus (list of lists of floats): List of cluster means. + sigmas (list of 2D lists of floats): List of cluster covariances. + clusterAssignments (list of ints): The assignment of each interval to a cluster, where an entry + j at index i means the ith interval has been assigned to the + jth meta-interval. + numPoints (list of ints): Number of points assigned to each cluster + numClusters (int): The number of clusters. + """""" + from sklearn.mixture import BayesianGaussianMixture + from collections import Counter + + sp.log( + msg=""## Clustering with K={} and c={}...\n"".format(K, concentration_prior), + level=""INFO"", + ) + total = list(points) + if clouds is not None: + total.extend(list(clouds)) + npArray = np.array(total) + + gmm = BayesianGaussianMixture( + n_components=K, + n_init=restarts, + weight_concentration_prior=concentration_prior, + max_iter=int(1e6), + random_state=seed, + ) + targetAssignments = gmm.fit_predict(npArray) + targetAssignments = targetAssignments[: len(points)] + mus = gmm.means_ + sigmas = gmm.covariances_ + cntr = Counter(targetAssignments) + numPoints = [cntr[i] if i in cntr else 0 for i in range(K)] + numClusters = len(cntr) + + return mus, sigmas, targetAssignments, numPoints, numClusters + + +def refineClustering(combo, assign, assignidx, samples, rdtol, baftol): + assignment = {b: assign[assignidx[b]] for b in combo} + clusters = set(assignment[b] for b in assignment) + size = {c: float(sum(c == assignment[b] for b in combo)) for c in clusters} + getbaf = lambda c, p: float( + sum(e[6] for b in combo for e in combo[b] if assignment[b] == c and e[0] == p) + ) + baf = {c: {p: getbaf(c, p) / size[c] for p in samples} for c in clusters} + getrdr = lambda c, p: float( + sum(e[1] for b in combo for e in combo[b] if assignment[b] == c and e[0] == p) + ) + rdr = {c: {p: getrdr(c, p) / size[c] for p in samples} for c in clusters} + + mbaf = lambda c: {p: baf[c][p] for p in samples} + mrdr = lambda c: {p: rdr[c][p] for p in samples} + merge = { + c: {""BAF"": mbaf(c), ""RDR"": mrdr(c), ""SIZE"": size[c], ""CLUS"": {c}} + for c in clusters + } + + def mergable(m): + checkrdr = lambda f, s: False not in set( + abs(m[f][""RDR""][p] - m[s][""RDR""][p]) <= rdtol for p in samples + ) + checkbaf = lambda f, s: False not in set( + abs(m[f][""BAF""][p] - m[s][""BAF""][p]) <= baftol for p in samples + ) + check = lambda f, s: checkrdr(f, s) and checkbaf(f, s) + varrdr = lambda f, s: sum(abs(m[f][""RDR""][p] - m[s][""RDR""][p]) for p in samples) + varbaf = lambda f, s: sum(abs(m[f][""BAF""][p] - m[s][""BAF""][p]) for p in samples) + var = lambda f, s: varrdr(f, s) + varbaf(f, s) + + seq = sorted(m, key=(lambda x: m[x][""SIZE""])) + for idx, f in enumerate(seq): + opts = { + s: var(f, s) + for s in seq[idx + 1 :] + for p in samples + if s != f and check(f, s) + } + if len(opts) > 0: + first = f + break + if len(opts) > 0: + f = first + return first, sp.argmin(opts) + else: + None + + m = mergable(merge) + while m is not None: + m1 = m[0] + m2 = m[1] + tot = float(merge[m1][""SIZE""] + merge[m2][""SIZE""]) + newbaf = { + p: float( + merge[m1][""BAF""][p] * merge[m1][""SIZE""] + + merge[m2][""BAF""][p] * merge[m2][""SIZE""] + ) + / tot + for p in samples + } + newrdr = { + p: float( + merge[m1][""RDR""][p] * merge[m1][""SIZE""] + + merge[m2][""RDR""][p] * merge[m2][""SIZE""] + ) + / tot + for p in samples + } + newclu = merge[m1][""CLUS""] | merge[m2][""CLUS""] + merge = {c: merge[c] for c in merge if c != m1 and c != m2} + if len(merge) == 0: + merge = {} + merge[m1] = {""BAF"": newbaf, ""RDR"": newrdr, ""SIZE"": tot, ""CLUS"": newclu} + m = mergable(merge) + + newassign = [-1 for i in range(len(assign))] + for b in combo: + get = [c for c in merge if assign[assignidx[b]] in merge[c][""CLUS""]] + assert len(get) == 1 + newassign[assignidx[b]] = get[0] + assert -1 not in set(newassign) + + return newassign, len(merge) + + +def generateClouds(points, density, seed, sdeven=0.02, sdodd=0.02): + res = [] + resappend = res.append + for point in points: + np.random.seed(seed=seed) + for d in range(density): + normal = np.random.normal + newpoint = [ + normal(point[i], sdeven) if i % 2 == 0 else normal(point[i], sdodd) + for i in range(len(point)) + ] + resappend(newpoint) + return res + + +def segmentBins(bb, clusters, samples): + sbb = {bi: {record[0]: record[1:] for record in bb[bi]} for bi in bb} + nbins = { + cluster: {sample: len(clusters[cluster]) for sample in samples} + for cluster in clusters + } + rd = { + cluster: { + sample: float(sum(sbb[bi][sample][0] for bi in clusters[cluster])) + / float(len(clusters[cluster])) + for sample in samples + } + for cluster in clusters + } + nsnps = { + cluster: { + sample: sum(sbb[bi][sample][1] for bi in clusters[cluster]) + for sample in samples + } + for cluster in clusters + } + cov = { + cluster: { + sample: float(sum(sbb[bi][sample][2] for bi in clusters[cluster])) + / float(len(clusters[cluster])) + for sample in samples + } + for cluster in clusters + } + return minSegmentBins(sbb, nbins, rd, nsnps, cov, clusters, samples) + + +def minSegmentBins(sbb, nbins, rd, nsnps, cov, clusters, samples): + alpha = { + cluster: { + sample: sum( + min(sbb[bi][sample][3], sbb[bi][sample][4]) for bi in clusters[cluster] + ) + for sample in samples + } + for cluster in clusters + } + beta = { + cluster: { + sample: sum( + max(sbb[bi][sample][3], sbb[bi][sample][4]) for bi in clusters[cluster] + ) + for sample in samples + } + for cluster in clusters + } + mean = { + cluster: { + sample: float(alpha[cluster][sample]) + / float(alpha[cluster][sample] + beta[cluster][sample]) + for sample in samples + } + for cluster in clusters + } + return { + cluster: { + sample: ( + nbins[cluster][sample], + rd[cluster][sample], + nsnps[cluster][sample], + cov[cluster][sample], + alpha[cluster][sample], + beta[cluster][sample], + mean[cluster][sample], + ) + for sample in samples + } + for cluster in clusters + } + + +def scaleBAF(segments, samples, diploidbaf): + diploid = -1 + main = -1 + for key in segments: + if sum( + (0.5 - segments[key][sample][-1]) <= diploidbaf for sample in samples + ) == len(samples): + sample = list(samples)[0] + if main < segments[key][sample][0]: + main = segments[key][sample][0] + diploid = key + if diploid == -1: + raise ValueError( + sp.error( + ""No potential neutral cluster has been found within the given threshold {}!"".format( + diploidbaf + ) + ) + ) + scalings = {sample: segments[diploid][sample][-1] for sample in samples} + scale = ( + lambda value, scale, diploidbaf: min((float(value) / float(scale)) * 0.5, 0.5) + if (0.5 - value) <= diploidbaf and scale > 0 + else value + ) + scaledBAF = { + segment: { + sample: scale(segments[segment][sample][-1], scalings[sample], diploidbaf) + for sample in samples + } + for segment in segments + } + regulate = ( + lambda record, baf: record[:-3] + + splitBAF(baf, record[-3] + record[-2]) + + (baf,) + if record[-1] != baf + else record + ) + return { + segment: { + sample: regulate(segments[segment][sample], scaledBAF[segment][sample]) + for sample in samples + } + for segment in segments + } + + +def splitBAF(baf, scale): + BAF = float(baf) + BAF = min(BAF, 1.0 - BAF) + SUM = float(scale) + + roundings = [] + roundings.append((int(math.floor(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) + roundings.append((int(math.floor(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) + roundings.append((int(math.ceil(BAF * SUM)), int(math.floor((1.0 - BAF) * SUM)))) + roundings.append((int(math.ceil(BAF * SUM)), int(math.ceil((1.0 - BAF) * SUM)))) + roundings = [(int(min(a, b)), int(max(a, b))) for (a, b) in roundings] + + estimations = [ + float(a) / float(a + b) if a + b > 0 else 1.0 for (a, b) in roundings + ] + diff = [abs(est - BAF) for est in estimations] + best = np.argmin(diff) + return roundings[best][0], roundings[best][1] + + +def roundAlphasBetas(baf, alpha, beta): + BAF = float(baf) + BAF = min(BAF, 1.0 - BAF) + ALPHA = min(alpha, beta) + BETA = max(alpha, beta) + + roundings = [] + roundings.append((int(math.floor(ALPHA)), int(math.floor(BETA)))) + roundings.append((int(math.floor(ALPHA)), int(math.ceil(BETA)))) + roundings.append((int(math.ceil(ALPHA)), int(math.floor(BETA)))) + roundings.append((int(math.ceil(ALPHA)), int(math.ceil(BETA)))) + roundings = [(int(min(a, b)), int(max(a, b))) for (a, b) in roundings] + + estimations = [ + float(a) / float(a + b) if a + b > 0 else 1.0 for (a, b) in roundings + ] + diff = [abs(est - BAF) for est in estimations] + return roundings[np.argmin(diff)] + + +def reindex(labels): + """""" + Given a list of labels, reindex them as integers from 1 to n_labels + Also orders them in nonincreasing order of prevalence + """""" + old2new = {} + j = 1 + for i, _ in Counter(labels).most_common(): + old2new[i] = j + j += 1 + old2newf = lambda x: old2new[x] + + return [old2newf(a) for a in labels] + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/run.py",".py","13467","411","import sys +from io import StringIO +import os.path +import glob +import argparse + +from hatchet import config +from hatchet.utils.count_reads import main as count_reads +from hatchet.utils.count_reads_fw import main as count_reads_fw +from hatchet.utils.genotype_snps import main as genotype_snps +from hatchet.utils.count_alleles import main as count_alleles +from hatchet.utils.combine_counts import main as combine_counts +from hatchet.utils.combine_counts_fw import main as combine_counts_fw +from hatchet.utils.cluster_bins_gmm import main as cluster_bins_gmm +from hatchet.utils.cluster_bins import main as cluster_bins +from hatchet.utils.plot_bins import main as plot_bins +from hatchet.utils.plot_bins_1d2d import main as plot_bins_1d2d +from hatchet.bin.HATCHet import main as hatchet_main +from hatchet.utils.plot_cn import main as plot_cn +from hatchet.utils.plot_cn_1d2d import main as plot_cn_1d2d +from hatchet.utils.download_panel import main as download_panel +from hatchet.utils.phase_snps import main as phase_snps +from hatchet.utils.Supporting import log, error + + +def main(args=None): + parser = argparse.ArgumentParser( + prog=""hatchet run"", description=""Run HATCHet pipeline"" + ) + parser.add_argument(""inifile"", help="".ini file for run configuration"") + args = parser.parse_args(args) + + config.read(args.inifile) + + output = config.run.output + output = output.rstrip(""/"") + os.makedirs(output, exist_ok=True) + + try: + chromosomes = [c for c in config.run.chromosomes.split()] + except (KeyError, AttributeError): # if key is absent or is blank (None) + chromosomes = [] # process all + + extra_args = [] + try: + if config.run.processes is not None: + extra_args = [""-j"", str(config.run.processes)] + except KeyError: + pass + + # ---------------------------------------------------- + + if config.run.download_panel: + if not config.download_panel.refpaneldir: + raise ValueError( + error( + ( + 'The step ""download_panel"" requires that the variable ""refpaneldir"" indicates the directory in ' + ""which to store the reference panel."" + ) + ) + ) + + download_panel( + args=[ + ""-D"", + config.download_panel.refpaneldir, + ""-R"", + config.download_panel.refpanel, + ] + ) + + # ---------------------------------------------------- + + if config.run.genotype_snps: + snps = """" + if config.genotype_snps.snps: + snps = config.genotype_snps.snps + elif config.genotype_snps.reference_version: + snps_mapping = { + ( + ""hg19"", + True, + ): ""https://ftp.ncbi.nih.gov/snp/organisms/human_9606_b151_GRCh37p13/VCF/GATK/00-All.vcf.gz"", + ( + ""hg19"", + False, + ): ""https://ftp.ncbi.nih.gov/snp/organisms/human_9606_b151_GRCh37p13/VCF/00-All.vcf.gz"", + ( + ""hg38"", + True, + ): ""https://ftp.ncbi.nih.gov/snp/organisms/human_9606_b151_GRCh38p7/VCF/GATK/00-All.vcf.gz"", + ( + ""hg38"", + False, + ): ""https://ftp.ncbi.nih.gov/snp/organisms/human_9606_b151_GRCh38p7/VCF/00-All.vcf.gz"", + } + + if ( + config.genotype_snps.reference_version, + config.genotype_snps.chr_notation, + ) not in snps_mapping: + raise RuntimeError( + ( + ""Please specify valid values of reference_version and chr_notation. "" + f""Valid pairs include: {snps_mapping.keys()}"" + ) + ) + else: + snps = snps_mapping[ + config.genotype_snps.reference_version, + config.genotype_snps.chr_notation, + ] + + os.makedirs(f""{output}/snps"", exist_ok=True) + genotype_snps( + args=[ + ""-N"", + config.run.normal, + ""-r"", + config.run.reference, + ""-R"", + snps, + ""-o"", + f""{output}/snps/"", + ""--chromosomes"", + ] + + ( + chromosomes or [] + ) # important to keep this as a list here to allow proper argparse parsing + + extra_args + ) + + # ---------------------------------------------------- + + if config.run.phase_snps: + if len(glob.glob(f""{output}/snps/*.vcf.gz"")) == 0: + raise ValueError( + error( + ( + ""No SNP files were found for phasing. Are there any .vcf.gz files in the snps subdirectory of "" + ""the output folder? Try running genotype_snps."" + ) + ) + ) + + if not config.download_panel.refpaneldir: + raise ValueError( + error( + ( + 'The step ""phase_snps"" requires that the config variable ""download_panel.refpaneldir"" ' + ""indicates the directory where the reference panel is located."" + ) + ) + ) + + os.makedirs(f""{output}/phase"", exist_ok=True) + phase_snps( + args=[ + ""-D"", + config.download_panel.refpaneldir, + ""-g"", + config.run.reference, + ""-V"", + config.genotype_snps.reference_version, + ""-o"", + f""{output}/phase/"", + ""-L"", + ] + + glob.glob(f""{output}/snps/*.vcf.gz"") + + ([""-N""] if config.genotype_snps.chr_notation else []) + + extra_args + ) + + # ---------------------------------------------------- + if config.run.count_alleles: + os.makedirs(f""{output}/baf"", exist_ok=True) + count_alleles( + args=[""-N"", config.run.normal, ""-T""] + + config.run.bams.split() + + [""-S""] + + (""normal "" + config.run.samples).split() + + [""-r"", config.run.reference, ""-L""] + + glob.glob(f""{output}/snps/*.vcf.gz"") + + [ + ""-O"", + f""{output}/baf/normal.1bed"", + ""-o"", + f""{output}/baf/tumor.1bed"", + ""-l"", + f""{output}"", + ""--chromosomes"", + ] + + ( + chromosomes or [] + ) # important to keep this as a list here to allow proper argparse parsing + + extra_args + ) + + if config.run.fixed_width is None or not config.run.fixed_width: + # ---------------------------------------------------- + # ---------------------------------------------------- + # Variable-width/adaptive binning + + if config.run.count_reads: + os.makedirs(f""{output}/rdr"", exist_ok=True) + count_reads( + args=[""-N"", config.run.normal, ""-T""] + + config.run.bams.split() + + [""-S""] + + (""normal "" + config.run.samples).split() + + [ + ""-V"", + config.genotype_snps.reference_version, + ""-b"", + f""{output}/baf/tumor.1bed"", + ""-O"", + f""{output}/rdr"", + ""--chromosomes"", + ] + + ( + chromosomes or [] + ) # important to keep this as a list here to allow proper argparse parsing + + extra_args + ) + + # ---------------------------------------------------- + + if config.run.combine_counts: + _stdout = sys.stdout + sys.stdout = StringIO() + os.makedirs(f""{output}/bb"", exist_ok=True) + + phasefile = f""{output}/phase/phased.vcf.gz"" + args = [ + ""-A"", + f""{output}/rdr"", + ""-b"", + f""{output}/baf/tumor.1bed"", + ""-t"", + f""{output}/rdr/total.tsv"", + ""-V"", + config.genotype_snps.reference_version, + ""-o"", + f""{output}/bb/bulk.bb"", + ""-r"", + config.run.reference, + ] + extra_args + + if os.path.exists(phasefile): + log( + msg=""Found phasing file, including phasing in binning process.\n"", + level=""INFO"", + ) + args = [""-p"", f""{output}/phase/phased.vcf.gz""] + args + else: + log( + msg=f""NO PHASING FILE FOUND at {phasefile}. Not including phasing in binning process.\n"", + level=""INFO"", + ) + + combine_counts(args) + + else: + # ---------------------------------------------------- + # ---------------------------------------------------- + # Old fixed-width binning + + if config.run.count_reads: + os.makedirs(f""{output}/rdr"", exist_ok=True) + count_reads_fw( + args=[ + ""-N"", + config.run.normal, + ""-g"", + config.run.reference, + ""-T"", + ] + + config.run.bams.split() + + [""-b"", config.count_reads_fw.size, ""-S""] + + (""Normal "" + config.run.samples).split() + + [ + ""-O"", + f""{output}/rdr/normal.1bed"", + ""-o"", + f""{output}/rdr/tumor.1bed"", + ""-t"", + f""{output}/rdr/total.tsv"", + ""--chromosomes"", + ] + + ( + chromosomes or [] + ) # important to keep this as a list here to allow proper argparse parsing + + extra_args + ) + + # ---------------------------------------------------- + + if config.run.combine_counts: + _stdout = sys.stdout + sys.stdout = StringIO() + + combine_counts_fw( + args=[ + ""-c"", + f""{output}/rdr/normal.1bed"", + ""-C"", + f""{output}/rdr/tumor.1bed"", + ""-B"", + f""{output}/baf/tumor.1bed"", + ""-t"", + f""{output}/rdr/total.tsv"", + ] + ) + out = sys.stdout.getvalue() + sys.stdout.close() + sys.stdout = _stdout + + os.makedirs(f""{output}/bb"", exist_ok=True) + with open(f""{output}/bb/bulk.bb"", ""w"") as f: + f.write(out) + + if config.run.cluster_bins: + os.makedirs(f""{output}/bbc"", exist_ok=True) + + if config.run.loc_clust: + cluster_bins( + args=[ + f""{output}/bb/bulk.bb"", + ""-o"", + f""{output}/bbc/bulk.seg"", + ""-O"", + f""{output}/bbc/bulk.bbc"", + ] + ) + else: + cluster_bins_gmm( + args=[ + f""{output}/bb/bulk.bb"", + ""-o"", + f""{output}/bbc/bulk.seg"", + ""-O"", + f""{output}/bbc/bulk.bbc"", + ] + ) + + # ---------------------------------------------------- + + if config.run.plot_bins: + os.makedirs(f""{output}/plots"", exist_ok=True) + plot_bins( + args=[ + f""{output}/bbc/bulk.bbc"", + ""--rundir"", + f""{output}/plots"", + ""--ymin"", + ""0"", + ""--ymax"", + ""3"", + ] + ) + + os.makedirs(f""{output}/plots/1d2d"", exist_ok=True) + plot_bins_1d2d( + args=[ + ""-b"", + f""{output}/bbc/bulk.bbc"", + ""-s"", + f""{output}/bbc/bulk.seg"", + ""--outdir"", + f""{output}/plots/1d2d"", + ""--centers"", + ""--centromeres"", + ] + ) + + # ---------------------------------------------------- + + if config.run.compute_cn: + os.makedirs(f""{output}/results"", exist_ok=True) + hatchet_main( + args=[""-x"", f""{output}/results"", ""-i"", f""{output}/bbc/bulk""] + extra_args + ) + + # ---------------------------------------------------- + + if config.run.plot_cn: + os.makedirs(f""{output}/summary"", exist_ok=True) + plot_cn( + args=[ + f""{output}/results/best.bbc.ucn"", + ""--rundir"", + f""{output}/summary"", + ] + ) + + os.makedirs(f""{output}/summary/1d2d"", exist_ok=True) + plot_cn_1d2d( + args=[ + f""{output}/results/best.bbc.ucn"", + ""--outdir"", + f""{output}/summary/1d2d"", + ""--bysample"", + ""--centromeres"", + ] + ) + + +if __name__ == ""__main__"": + main() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/rd_gccorrect.py",".py","1859","55","import pandas as pd +import statsmodels.formula.api as smf +from pybedtools import BedTool + + +def rd_gccorrect(bb, ref_genome): + """""" + Function to correct GC bias in read depth data for each sample. + Parameters: + - bb: DataFrame containing read depth data, including columns '#CHR', 'START', 'END', 'RD', 'SAMPLE' + - ref_genome: File path to the reference genome in FASTA format + Return type: DataFrame with corrected read depth data + """""" + + bb[""CHR""] = bb[""#CHR""].str.replace(""chr"", """") + bb = bb.sort_values(by=[""CHR"", ""START""]).reset_index(drop=True) + + # add GC content + # ref_genome = '/n/fs/ragr-data/datasets/ref-genomes/GRCh38_10X/fasta/genome.fa' + bb = bb.merge( + BedTool.from_dataframe(bb[[""#CHR"", ""START"", ""END""]].drop_duplicates()) + .nucleotide_content(fi=ref_genome) + .to_dataframe(disable_auto_names=True) + .rename( + columns={ + ""#1_usercol"": ""#CHR"", + ""2_usercol"": ""START"", + ""3_usercol"": ""END"", + ""5_pct_gc"": ""GC"", + } + ) + .astype({""#CHR"": str})[[""#CHR"", ""START"", ""END"", ""GC""]] + ) + + # Correcting GC bias per sample + gccorrect = bb.groupby(""SAMPLE"").apply( + lambda D: smf.quantreg(""RD ~ GC + I(GC ** 2.0)"", data=D).fit(q=0.5) + ) + bb[""UNCORR_RD""] = bb[""RD""].copy() + bb[""GCCORR""] = bb.groupby(""SAMPLE"")[""GC""].transform( + lambda X: gccorrect[X.name].predict(X.to_frame(""GC"")).values + ) + bb[""RD""] = bb[""UNCORR_RD""] / bb[""GCCORR""].where( + (bb[""GCCORR""] > 0) & ~pd.isnull(bb[""GCCORR""]), 1 + ) + bb[""RD""] = bb[""RD""] / bb.groupby(""SAMPLE"")[""RD""].transform(lambda X: X.mean()) + print(bb.head(10)) + + bb = bb.sort_values(by=[""CHR"", ""START""]).reset_index(drop=True) + + # Drop the 'CHR' column + bb.drop(columns=[""CHR""], inplace=True) + + return bb +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/ProgressBar.py",".py","2880","92","import sys +import datetime +import hatchet.utils.Supporting as sp + + +class ProgressBar: + def __init__( + self, + total, + length, + counter=0, + verbose=False, + decimals=1, + fill=chr(9608), + lock=None, + prefix=""Progress:"", + suffix=""Complete"", + ): + self.total = total + self.length = length + self.decimals = decimals + self.fill = fill + self.prefix = prefix + self.suffix = suffix + self.lock = lock + self.counter = counter + self.verbose = verbose + + def progress(self, advance=True, msg=""""): + if self.lock is not None: + self.progressLock(advance, msg) + else: + self.progressNoLock(advance, msg) + + def progressLock(self, advance=True, msg=""""): + flush = sys.stderr.flush + write = sys.stderr.write + if advance: + with self.counter.get_lock(): + self.counter.value += 1 + percent = (""{0:."" + str(self.decimals) + ""f}"").format( + 100 * (self.counter.value / float(self.total)) + ) + filledLength = int(self.length * self.counter.value // self.total) + bar = self.fill * filledLength + ""-"" * (self.length - filledLength) + rewind = ""\x1b[2K\r"" + result = ""%s%s%s |%s| %s%s%% %s%s"" % ( + sp.bcolors.BBLUE, + self.prefix, + sp.bcolors.ENDC, + bar, + sp.bcolors.BBLUE, + percent, + self.suffix, + sp.bcolors.ENDC, + ) + msg = ""[{:%Y-%b-%d %H:%M:%S}]"".format(datetime.datetime.now()) + msg + if not self.verbose: + toprint = ( + rewind + result + "" %s[%s]%s"" % (sp.bcolors.BBLUE, msg, sp.bcolors.ENDC) + ) + else: + toprint = rewind + sp.bcolors.BBLUE + msg + sp.bcolors.ENDC + ""\n"" + result + with self.lock: + write(toprint) + flush() + if self.counter.value == self.total: + write(""\n"") + flush() + + def progressNoLock(self, advance=True, msg=""""): + flush = sys.stderr.flush + write = sys.stderr.write + if advance: + self.counter += 1 + percent = (""{0:."" + str(self.decimals) + ""f}"").format( + 100 * (self.counter / float(self.total)) + ) + filledLength = int(self.length * self.counter // self.total) + bar = self.fill * filledLength + ""-"" * (self.length - filledLength) + rewind = ""\x1b[2K\r"" + result = ""%s |%s| %s%% %s"" % (self.prefix, bar, percent, self.suffix) + if not self.verbose: + toprint = rewind + result + "" [%s]"" % (msg) + else: + toprint = rewind + msg + ""\n"" + result + write(toprint) + flush() + if self.counter == self.total: + write(""\n"") + flush() +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/solve/ilp_subset.py",".py","43036","1088","import textwrap +import math +import numpy as np +from pyomo import environ as pe +from pyomo.opt import SolverStatus, TerminationCondition + +from hatchet.utils.solve.utils import Random + + +class ILPSubset: + def __init__(self, n, cn_max, d, mu, ampdel, copy_numbers, f_a, f_b, w, purities): + # Each ILPSubset maintains its own data, so make a deep-copy of passed-in DataFrames + f_a, f_b = f_a.copy(deep=True), f_b.copy(deep=True) + + assert f_a.shape == f_b.shape + assert np.all(f_a.index == f_b.index) + assert np.all(f_a.columns == f_b.columns) + + self.m, self.k = f_a.shape + self.f_a = f_a + self.f_b = f_b + self.cluster_ids = f_a.index + self.sample_ids = f_a.columns + + self.n = n + self.cn_max = cn_max + self.d = d + self.mu = mu + self.ampdel = ampdel + self.copy_numbers = copy_numbers + self.w = w + self.purities = purities + + self.tol = 0.001 + + self.mode = ""FULL"" + + # Values we want to optimize for, as dataframes + self.cA = [[np.nan for _ in range(self.n)] for _ in range(self.m)] + self.cB = [[np.nan for _ in range(self.n)] for _ in range(self.m)] + self.u = [[np.nan for _ in range(self.k)] for _ in range(self.n)] + + # Fixed values of cA/cB/u + self._fixed_cA = [[np.nan for _ in range(n)] for _ in range(self.m)] + self._fixed_cB = [[np.nan for _ in range(n)] for _ in range(self.m)] + self._fixed_u = [[np.nan for _ in range(self.k)] for _ in range(self.n)] + + self.warmstart = False # set on hot_start() + self.model = None # initialized on create_model() + + def __copy__(self): + return ILPSubset( + n=self.n, + cn_max=self.cn_max, + d=self.d, + mu=self.mu, + ampdel=self.ampdel, + copy_numbers=self.copy_numbers, + f_a=self.f_a, + f_b=self.f_b, + w=self.w, + purities=self.purities, + ) + + def __str__(self): + # Pyomo pprint gives us too much information - too unwieldy for large models + # This method is implemented to supply the bare-minimum but useful model information. + if self.model is None: + return """" + else: + return textwrap.dedent( + f"""""" + # ------------------------------------------ + # Problem Information + # ------------------------------------------ + # Number of constraints: {self.model.nconstraints()} + # Number of variables: {self.model.nvariables()} + # ------------------------------------------ + """""" + ) + + @property + def M(self): + return math.floor(math.log2(self.cn_max)) + 1 + + @property + def base(self): + return min(2, len(self.copy_numbers)) + + @staticmethod + def symmCoeff(i): + return math.pow(i + 1, 1) + + @property + def optimized_cA(self): + if self.mode == ""UARCH"": + return self._fixed_cA + else: + return self.cA + + @property + def optimized_cB(self): + if self.mode == ""UARCH"": + return self._fixed_cB + else: + return self.cB + + @property + def optimized_u(self): + if self.mode == ""CARCH"": + return self._fixed_u + else: + return self.u + + def create_model(self, pprint=False): + m, n, k = self.m, self.n, self.k + f_a, f_b = self.f_a, self.f_b + cn_max = self.cn_max + ampdel = self.ampdel + copy_numbers = self.copy_numbers + mode_t = self.mode + d = self.d + _M = self.M + _base = self.base + purities = self.purities + + model = pe.ConcreteModel() + + fA = {} + fB = {} + yA = {} + yB = {} + adA = {} + adB = {} + + for _m in range(m): + cluster_id = f_a.index[_m] + + # upper bound for solver + ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) + + for _k in range(k): + yA[(_m, _k)] = pe.Var(bounds=(0, np.inf), domain=pe.Reals) + model.add_component(f""yA_{_m + 1}_{_k + 1}"", yA[(_m, _k)]) + yB[(_m, _k)] = pe.Var(bounds=(0, np.inf), domain=pe.Reals) + model.add_component(f""yB_{_m + 1}_{_k + 1}"", yB[(_m, _k)]) + fA[(_m, _k)] = pe.Var(bounds=(0, ub), domain=pe.Reals) + model.add_component(f""fA_{_m + 1}_{_k + 1}"", fA[(_m, _k)]) + fB[(_m, _k)] = pe.Var(bounds=(0, ub), domain=pe.Reals) + model.add_component(f""fB_{_m + 1}_{_k + 1}"", fB[(_m, _k)]) + + if mode_t in (""FULL"", ""CARCH""): + for _m in range(m): + cluster_id = f_a.index[_m] + + # upper bound for solver + ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) + + for _n in range(n): + self.cA[_m][_n] = pe.Var(bounds=(0, ub), domain=pe.Integers) + model.add_component(f""cA_{_m + 1}_{_n + 1}"", self.cA[_m][_n]) + self.cB[_m][_n] = pe.Var(bounds=(0, ub), domain=pe.Integers) + model.add_component(f""cB_{_m + 1}_{_n + 1}"", self.cB[_m][_n]) + + if ampdel: + for _m in range(m): + cluster_id = f_a.index[_m] + if cluster_id not in copy_numbers: + adA[_m] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component(f""adA_{_m + 1}"", adA[_m]) + adB[_m] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component(f""adB_{_m + 1}"", adB[_m]) + + bitcA = {} + bitcB = {} + if (mode_t == ""FULL"") or (d > 0 and mode_t == ""CARCH""): + for _b in range(_M): + for _m in range(m): + for _n in range(n): + bitcA[(_b, _m, _n)] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component( + f""bitcA_{_b + 1}_{_m + 1}_{_n + 1}"", + bitcA[(_b, _m, _n)], + ) + bitcB[(_b, _m, _n)] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component( + f""bitcB_{_b + 1}_{_m + 1}_{_n + 1}"", + bitcB[(_b, _m, _n)], + ) + + if mode_t in (""FULL"", ""UARCH""): + for _n in range(n): + for _k in range(k): + self.u[_n][_k] = pe.Var(bounds=(0, 1), domain=pe.Reals) + model.add_component(f""u_{_n + 1}_{_k + 1}"", self.u[_n][_k]) + + vA = {} + vB = {} + if mode_t == ""FULL"": + for _b in range(_M): + for _m in range(m): + for _n in range(n): + for _k in range(k): + vA[(_b, _m, _n, _k)] = pe.Var( + bounds=(0, 1), domain=pe.Reals + ) + model.add_component( + f""vA_{_b + 1}_{_m + 1}_{_n + 1}_{_k + 1}"", + vA[(_b, _m, _n, _k)], + ) + vB[(_b, _m, _n, _k)] = pe.Var( + bounds=(0, 1), domain=pe.Reals + ) + model.add_component( + f""vB_{_b + 1}_{_m + 1}_{_n + 1}_{_k + 1}"", + vB[(_b, _m, _n, _k)], + ) + + x = {} + if (mode_t in (""FULL"", ""UARCH"")) and (self.mu > 0): + for _n in range(n): + for _k in range(k): + x[(_n, _k)] = pe.Var(domain=pe.Binary) + model.add_component(f""x_{_n + 1}_{_k + 1}"", x[(_n, _k)]) + + # buildOptionalVariables + z = {} + if (mode_t in (""FULL"", ""CARCH"")) and d > 0: + for _m in range(self.m): + for _n in range(1, self.n): + for _d in range(d): + z[(_m, _n, _d)] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component( + f""z_{_m + 1}_{_n + 1}_{_d + 1}"", z[(_m, _n, _d)] + ) + + # CONSTRAINTS + model.constraints = pe.ConstraintList() + + for _m in range(m): + cluster_id = f_a.index[_m] + f_a_values = f_a.loc[cluster_id].values + f_b_values = f_b.loc[cluster_id].values + + for _k in range(k): + _yA, _yB = yA[(_m, _k)], yB[(_m, _k)] + _fA, _fB = fA[(_m, _k)], fB[(_m, _k)] + + model.constraints.add(float(f_a_values[_k]) - _fA <= _yA) + model.constraints.add(_fA - float(f_a_values[_k]) <= _yA) + model.constraints.add(float(f_b_values[_k]) - _fB <= _yB) + model.constraints.add(_fB - float(f_b_values[_k]) <= _yB) + + if mode_t == ""FULL"": + for _m in range(m): + for _k in range(k): + sum_a = 0 + for _n in range(n): + for _b in range(_M): + sum_a += vA[(_b, _m, _n, _k)] * math.pow(2, _b) + model.constraints.add( + vA[(_b, _m, _n, _k)] <= bitcA[(_b, _m, _n)] + ) + model.constraints.add( + vA[(_b, _m, _n, _k)] <= self.u[_n][_k] + ) + model.constraints.add( + vA[(_b, _m, _n, _k)] + >= bitcA[(_b, _m, _n)] + self.u[_n][_k] - 1 + ) + + model.constraints.add(fA[(_m, _k)] == sum_a) + + for _m in range(m): + for _k in range(k): + sum_b = 0 + for _n in range(n): + for _b in range(_M): + sum_b += vB[(_b, _m, _n, _k)] * math.pow(2, _b) + model.constraints.add( + vB[(_b, _m, _n, _k)] <= bitcB[(_b, _m, _n)] + ) + model.constraints.add( + vB[(_b, _m, _n, _k)] <= self.u[_n][_k] + ) + model.constraints.add( + vB[(_b, _m, _n, _k)] + >= bitcB[(_b, _m, _n)] + self.u[_n][_k] - 1 + ) + + model.constraints.add(fB[(_m, _k)] == sum_b) + + for _n in range(n): + for _k in range(k): + _sum = 0 + for _m in range(m): + for _b in range(_M): + _sum += bitcA[(_b, _m, _n)] + bitcB[(_b, _m, _n)] + model.constraints.add(_sum >= self.u[_n][_k]) + + if (mode_t == ""FULL"") or (d > 0 and mode_t == ""CARCH""): + for _m in range(m): + cluster_id = f_a.index[_m] + # upper bound for solver + ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) + + for _n in range(n): + sum_a = 0 + sum_b = 0 + for _b in range(_M): + sum_a += bitcA[(_b, _m, _n)] * math.pow(2, _b) + sum_b += bitcB[(_b, _m, _n)] * math.pow(2, _b) + + model.constraints.add(self.cA[_m][_n] == sum_a) + model.constraints.add(self.cB[_m][_n] == sum_b) + model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] <= ub) + + # this is where we fix the purities if user provides purity values for (tumor) samples + # in each sample s, clone 0 (healty & normal) should have the purity 1 - purity_s + if mode_t in (""FULL"", ""UARCH"") and purities: + for i, p in enumerate(purities): + model.constraints.add(self.u[0][i] == 1 - p) + + if mode_t == ""CARCH"": + # TODO: These loops can be collapsed once validation against C++ is complete + for _m in range(m): + for _k in range(k): + _sumA = 0 + _sumB = 0 + for _n in range(n): + if self._fixed_u[_n][_k] >= self.mu - self.tol: + _sumA += self.cA[_m][_n] * self._fixed_u[_n][_k] + _sumB += self.cB[_m][_n] * self._fixed_u[_n][_k] + model.constraints.add(fA[(_m, _k)] == _sumA) + model.constraints.add(fB[(_m, _k)] == _sumB) + + cluster_id = f_a.index[_m] + # upper bound for solver + ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) + for _n in range(n): + model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] <= ub) + + if mode_t in (""FULL"", ""CARCH""): + for _m in range(m): + model.constraints.add(self.cA[_m][0] == 1) + model.constraints.add(self.cB[_m][0] == 1) + + cluster_id = self.cluster_ids[_m] + + # if the fraction of the cluster size is larger than or equal to 0.005 in the whole dataset + # then its integer copy number cannot have (0,0) copy number + if self.w[cluster_id] / sum(self.w) >= 0.005: + for _n in range(1, n): + model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] >= 1) + + if ampdel: + for _m in range(m): + cluster_id = f_a.index[_m] + if cluster_id not in copy_numbers: + for _n in range(1, n): + model.constraints.add( + self.cA[_m][_n] + <= cn_max * adA[_m] + _base - _base * adA[_m] + ) + model.constraints.add(self.cA[_m][_n] >= _base * adA[_m]) + model.constraints.add( + self.cB[_m][_n] + <= cn_max * adB[_m] + _base - _base * adB[_m] + ) + model.constraints.add(self.cB[_m][_n] >= _base * adB[_m]) + + if mode_t == ""UARCH"": + # TODO: These loops can be collapsed once validation against C++ is complete + for _m in range(m): + for _k in range(k): + _sumA = 0 + _sumB = 0 + for _n in range(n): + _sumA += int(self._fixed_cA[_m][_n]) * self.u[_n][_k] + _sumB += int(self._fixed_cB[_m][_n]) * self.u[_n][_k] + model.constraints.add(fA[(_m, _k)] == _sumA) + model.constraints.add(fB[(_m, _k)] == _sumB) + + if mode_t in (""FULL"", ""UARCH""): + for _k in range(k): + _sum = 0 + for _n in range(n): + _sum += self.u[_n][_k] + model.constraints.add(_sum == 1) + + if (mode_t in (""FULL"", ""UARCH"")) and self.mu > 0: + for _k in range(k): + for _n in range(1, n): + model.constraints.add(x[(_n, _k)] >= self.u[_n][_k]) + model.constraints.add(self.u[_n][_k] >= self.mu * x[(_n, _k)]) + + # buildOptionalConstraints + if (mode_t in (""FULL"", ""CARCH"")) and d > 0: + for _m in range(self.m): + for _n in range(1, self.n): + _sum = 0 + for _d in range(self.d): + _sum += z[(_m, _n, _d)] + model.constraints.add(_sum == 1) + + for _m in range(self.m): + for _M in range(self.M): + for _d in range(d): + for _i in range(1, self.n - 1): + for _j in range(1, self.n): + model.constraints.add( + bitcA[(_M, _m, _i)] - bitcA[(_M, _m, _j)] + <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] + ) + model.constraints.add( + bitcA[(_M, _m, _j)] - bitcA[(_M, _m, _i)] + <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] + ) + model.constraints.add( + bitcB[(_M, _m, _i)] - bitcB[(_M, _m, _j)] + <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] + ) + model.constraints.add( + bitcB[(_M, _m, _j)] - bitcB[(_M, _m, _i)] + <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] + ) + + for _m in range(self.m): + for _d in range(d - 1): + _sum_l = _sum_l1 = 0 + for _n in range(1, self.n): + _sum_l += z[(_m, _n, _d)] * self.symmCoeff(_n) + _sum_l1 += z[(_m, _n, _d + 1)] * self.symmCoeff(_n) + model.constraints.add(_sum_l <= _sum_l1) + + if mode_t in (""FULL"", ""CARCH""): + self.build_symmetry_breaking(model) + self.fix_given_cn(model) + + if mode_t == ""FULL"": + self.hot_start() + + obj = 0 + for _m in range(m): + for _k in range(k): + cluster_id = self.cluster_ids[_m] + obj += (yA[(_m, _k)] + yB[(_m, _k)]) * self.w[cluster_id] + + model.obj = pe.Objective(expr=obj, sense=pe.minimize) + self.model = model + + if pprint: + print(str(self)) + + def build_symmetry_breaking(self, model): + for i in range(1, self.n - 1): + _sum1 = 0 + _sum2 = 0 + for _m in range(self.m): + _symCoeff = self.symmCoeff(_m) + _sum1 += self.cA[_m][i] * _symCoeff + self.cB[_m][i] * _symCoeff + _sum2 += self.cA[_m][i] * _symCoeff + self.cB[_m][i] * _symCoeff + model.constraints.add(_sum1 <= _sum2) + + def fix_given_cn(self, model): + for _m in range(self.m): + cluster_id = self.f_a.index[_m] + if cluster_id in self.copy_numbers: + _cnA, _cnB = self.copy_numbers[cluster_id] + for _n in range(1, self.n): + model.constraints.add(self.cA[_m][_n] == _cnA) + model.constraints.add(self.cB[_m][_n] == _cnB) + + def first_hot_start(self): + if self.d > 0: + targetA = np.empty((self.m, self.d)) + targetB = np.empty_like(targetA) + for _m in range(self.m): + targetA[_m, :] = np.random.choice( + self.f_a.iloc[_m].values, self.d, replace=False + ) + targetB[_m, :] = np.random.choice( + self.f_b.iloc[_m].values, self.d, replace=False + ) + targetA = targetA.round() + targetB = targetB.round() + else: + targetA = np.round(self.f_a.values) + targetB = np.round(self.f_b.values) + + hcA = np.zeros((self.m, self.n)) + hcB = np.zeros((self.m, self.n)) + + for _m in range(self.m): + cluster_id = self.f_a.index[_m] + + adA = 0 + adB = 0 + for _n in range(self.n): + if _n == 0: + hcA[_m][0] = 1 + hcB[_m][0] = 1 + else: + if cluster_id in self.copy_numbers: + hcA[_m][_n] = self.copy_numbers[cluster_id][0] + hcB[_m][_n] = self.copy_numbers[cluster_id][1] + else: + mod = min(self.n, self.k) + a = min(targetA[_m][_n % mod], self.cn_max) + b = min(targetB[_m][_n % mod], self.cn_max) + + if self.ampdel: + base = self.base + if adA == 0 and a > base: + adA = 1 + if adA == 0 and a < base: + adA = -1 + if adB == 0 and b > base: + adB = 1 + if adB == 0 and b < base: + adB = -1 + + a = max(a, base) if adA >= 0 else min(a, base) + b = max(b, base) if adB >= 0 else min(b, base) + + if a + b > self.cn_max: + a = self.cn_max - base + b = self.cn_max - a + + if a + b <= self.cn_max: + hcA[_m][_n] = a + hcB[_m][_n] = b + else: + hcA[_m][_n] = a + hcB[_m][_n] = max(self.cn_max - a, 0) + + assert hcA[_m][_n] + hcB[_m][_n] <= self.cn_max + assert hcA[_m][_n] >= 0 + assert hcB[_m][_n] >= 0 + + return hcA, hcB + + def hot_start(self, f_a=None, f_b=None): + def get_rank(hcA, hcB): + # m, n = hcA.shape + m, n = len(hcA), len(hcA[0]) + rank = np.zeros(n) + rank[0] = -1 + for _m in range(m): + for _n in range(1, n): + rank[_n] += hcA[_m][_n] * self.symmCoeff(_m) + hcB[_m][ + _n + ] * self.symmCoeff(_m) + + return rank + + if f_a is None and f_b is None: + f_a, f_b = self.first_hot_start() + rank = get_rank(f_a, f_b) + rank_indices = np.argsort(rank) + + for _m in range(self.m): + for _n in range(0, self.n): + self.cA[_m][rank_indices[_n]].value = f_a[_m][_n] + self.cB[_m][rank_indices[_n]].value = f_b[_m][_n] + self.warmstart = True + + def fix_u(self, u): + self._fixed_u[:] = u + self.mode = ""CARCH"" + # TODO: sanity checks in fixU + + def fix_c(self, cA, cB): + self._fixed_cA = cA + self._fixed_cB = cB + self.mode = ""UARCH"" + # TODO: sanity checks in fixC + + def build_random_u(self, random_seed=None): + def _calculate_size_bubbles(mu): + if mu <= 0.1: + return 10 + elif mu <= 0.15: + return 6 + elif mu <= 0.2: + return 5 + else: + return 3 + + def _build_partition_vector(n, n_parts, size_bubbles, mu=0.03): + """""" + Return fractional components of n components as an ndarray of size n + """""" + # initialize all fractions to 0 + result = np.zeros(n) + # generate n_parts random positions from all available positions + positions = np.random.choice(np.arange(n), n_parts, replace=False) + + bubbles = ( + np.sort( + np.random.choice( + np.arange(1, size_bubbles), n_parts - 1, replace=False + ) + ) + / size_bubbles + ) + _result = np.diff(bubbles, prepend=0, append=1) + + # set fractions at selected positions to successive difference between bubbles + result[positions] = _result + # for fractions that are within tol of mu, clamp them up to mu + result[(mu - self.tol <= result) & (result < mu)] = mu + + return result + + size_bubbles = _calculate_size_bubbles(self.mu) + U = np.empty((self.n, self.k)) + + with Random(random_seed): + for _k in range(self.k): + # Generate 2 random ints between [1, n] and take the max - biasing towards larger numbers + _n0 = np.random.randint(1, self.n + 1) + _n1 = np.random.randint(1, self.n + 1) + n_parts = min( + max(_n0, _n1), size_bubbles + ) # no. of clones with non-zero proportion in the mix + v = _build_partition_vector(self.n, n_parts, size_bubbles, mu=self.mu) + U[:, _k] = v + return U + + def run(self, solver_type=""gurobi"", timelimit=None, write_path=None): + if solver_type == ""gurobipy"": + solver = pe.SolverFactory(""gurobi"", solver_io=""python"") + else: + solver = pe.SolverFactory(solver_type) + + kwargs = {""report_timing"": False} + if timelimit is not None: + kwargs[""timelimit""] = int(timelimit) + if solver.warm_start_capable(): + kwargs[""warmstart""] = self.warmstart + + results = solver.solve(self.model, **kwargs) + if ( + (results.solver.status == SolverStatus.ok) + and ( + results.solver.termination_condition + in ( + TerminationCondition.optimal, + TerminationCondition.feasible, + ) + ) + or ( + results.solver.status == SolverStatus.aborted + and results.solver.termination_condition + == TerminationCondition.maxTimeLimit + ) + ): + pass + else: + return None + + if write_path is not None: + self.model.write(write_path) + + return ( + self.model.obj(), + [[int(getattr(x, ""value"", x)) for x in row] for row in self.optimized_cA], + [[int(getattr(x, ""value"", x)) for x in row] for row in self.optimized_cB], + [[getattr(x, ""value"", x) for x in row] for row in self.optimized_u], + self.cluster_ids, + self.sample_ids, + ) + + +class ILPSubsetSplit(ILPSubset): + def __init__( + self, + n, + cn_max, + d, + mu, + ampdel, + copy_numbers, + f_a, + f_b, + binsA, + binsB, + lengths, + ): + # Each ILPSubset maintains its own data, so make a deep-copy of passed-in DataFrames + f_a, f_b = f_a.copy(deep=True), f_b.copy(deep=True) + self.binsA = {k: v.copy(deep=True) for k, v in binsA.items()} + self.binsB = {k: v.copy(deep=True) for k, v in binsB.items()} + self.lengths = {k: np.copy(v) for k, v in lengths.items()} + + assert f_a.shape == f_b.shape + assert np.all(f_a.index == f_b.index) + assert np.all(f_a.columns == f_b.columns) + + self.m, self.k = f_a.shape + self.f_a = f_a + self.f_b = f_b + self.cluster_ids = f_a.index + self.sample_ids = f_a.columns + + self.n = n + self.cn_max = cn_max + self.d = d + self.mu = mu + self.ampdel = ampdel + self.copy_numbers = copy_numbers + + self.tol = 0.001 + + self.mode = ""FULL"" + + # Values we want to optimize for, as dataframes + self.cA = [[np.nan for _ in range(self.n)] for _ in range(self.m)] + self.cB = [[np.nan for _ in range(self.n)] for _ in range(self.m)] + self.u = [[np.nan for _ in range(self.k)] for _ in range(self.n)] + + # Fixed values of cA/cB/u + self._fixed_cA = [[np.nan for _ in range(n)] for _ in range(self.m)] + self._fixed_cB = [[np.nan for _ in range(n)] for _ in range(self.m)] + self._fixed_u = [[np.nan for _ in range(self.k)] for _ in range(self.n)] + + self.warmstart = False # set on hot_start() + self.model = None # initialized on create_model() + + def __copy__(self): + return ILPSubsetSplit( + n=self.n, + cn_max=self.cn_max, + d=self.d, + mu=self.mu, + ampdel=self.ampdel, + copy_numbers=self.copy_numbers, + f_a=self.f_a, + f_b=self.f_b, + binsA=self.binsA, + binsB=self.binsB, + lengths=self.lengths, + ) + + def create_model(self, pprint=False): + m, n, k = self.m, self.n, self.k + f_a = self.f_a + cn_max = self.cn_max + ampdel = self.ampdel + copy_numbers = self.copy_numbers + mode_t = self.mode + d = self.d + _M = self.M + _base = self.base + + model = pe.ConcreteModel() + + fA = {} + fB = {} + yA = {} + yB = {} + adA = {} + adB = {} + + for _m in range(m): + cluster_id = f_a.index[_m] + + # upper bound for solver + ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) + + for _k in range(k): + fA[(_m, _k)] = pe.Var(bounds=(0, ub), domain=pe.Reals) + model.add_component(f""fA_{_m + 1}_{_k + 1}"", fA[(_m, _k)]) + fB[(_m, _k)] = pe.Var(bounds=(0, ub), domain=pe.Reals) + model.add_component(f""fB_{_m + 1}_{_k + 1}"", fB[(_m, _k)]) + + # Need an objective function term for each bin for absolute vlaue + for _i in range(len(self.binsA[cluster_id])): + yA[(_m, _k, _i)] = pe.Var(bounds=(0, np.inf), domain=pe.Reals) + model.add_component( + f""yA_{_m + 1}_{_k + 1}_{_i + 1}"", yA[(_m, _k, _i)] + ) + yB[(_m, _k, _i)] = pe.Var(bounds=(0, np.inf), domain=pe.Reals) + model.add_component( + f""yB_{_m + 1}_{_k + 1}_{_i + 1}"", yB[(_m, _k, _i)] + ) + + if mode_t in (""FULL"", ""CARCH""): + for _m in range(m): + cluster_id = f_a.index[_m] + + # upper bound for solver + ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) + + for _n in range(n): + self.cA[_m][_n] = pe.Var(bounds=(0, ub), domain=pe.Integers) + model.add_component(f""cA_{_m + 1}_{_n + 1}"", self.cA[_m][_n]) + self.cB[_m][_n] = pe.Var(bounds=(0, ub), domain=pe.Integers) + model.add_component(f""cB_{_m + 1}_{_n + 1}"", self.cB[_m][_n]) + + if ampdel: + for _m in range(m): + cluster_id = f_a.index[_m] + if cluster_id not in copy_numbers: + adA[_m] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component(f""adA_{_m + 1}"", adA[_m]) + adB[_m] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component(f""adB_{_m + 1}"", adB[_m]) + + bitcA = {} + bitcB = {} + if (mode_t == ""FULL"") or (d > 0 and mode_t == ""CARCH""): + for _b in range(_M): + for _m in range(m): + for _n in range(n): + bitcA[(_b, _m, _n)] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component( + f""bitcA_{_b + 1}_{_m + 1}_{_n + 1}"", + bitcA[(_b, _m, _n)], + ) + bitcB[(_b, _m, _n)] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component( + f""bitcB_{_b + 1}_{_m + 1}_{_n + 1}"", + bitcB[(_b, _m, _n)], + ) + + if mode_t in (""FULL"", ""UARCH""): + for _n in range(n): + for _k in range(k): + self.u[_n][_k] = pe.Var(bounds=(0, 1), domain=pe.Reals) + model.add_component(f""u_{_n + 1}_{_k + 1}"", self.u[_n][_k]) + + vA = {} + vB = {} + if mode_t == ""FULL"": + for _b in range(_M): + for _m in range(m): + for _n in range(n): + for _k in range(k): + vA[(_b, _m, _n, _k)] = pe.Var( + bounds=(0, 1), domain=pe.Reals + ) + model.add_component( + f""vA_{_b + 1}_{_m + 1}_{_n + 1}_{_k + 1}"", + vA[(_b, _m, _n, _k)], + ) + vB[(_b, _m, _n, _k)] = pe.Var( + bounds=(0, 1), domain=pe.Reals + ) + model.add_component( + f""vB_{_b + 1}_{_m + 1}_{_n + 1}_{_k + 1}"", + vB[(_b, _m, _n, _k)], + ) + + x = {} + if (mode_t in (""FULL"", ""UARCH"")) and (self.mu > 0): + for _n in range(n): + for _k in range(k): + x[(_n, _k)] = pe.Var(domain=pe.Binary) + model.add_component(f""x_{_n + 1}_{_k + 1}"", x[(_n, _k)]) + + # buildOptionalVariables + z = {} + if (mode_t in (""FULL"", ""CARCH"")) and d > 0: + for _m in range(self.m): + for _n in range(1, self.n): + for _d in range(d): + z[(_m, _n, _d)] = pe.Var(bounds=(0, 1), domain=pe.Binary) + model.add_component( + f""z_{_m + 1}_{_n + 1}_{_d + 1}"", z[(_m, _n, _d)] + ) + + # CONSTRAINTS + model.constraints = pe.ConstraintList() + + for _m in range(m): + cluster_id = f_a.index[_m] + f_a_values = self.binsA[cluster_id].values + f_b_values = self.binsB[cluster_id].values + + for _k in range(k): + _fA, _fB = fA[(_m, _k)], fB[(_m, _k)] + + for _i in range(f_a_values.shape[0]): + _yA, _yB = yA[(_m, _k, _i)], yB[(_m, _k, _i)] + + # Instead of 1 term per inferred CN, use all values in bin + model.constraints.add(f_a_values[_i, _k] - _fA <= _yA) + model.constraints.add(_fA - f_a_values[_i, _k] <= _yA) + + # model.constraints.add(myA >= _yA) + model.constraints.add(f_b_values[_i, _k] - _fB <= _yB) + model.constraints.add(_fB - f_b_values[_i, _k] <= _yB) + # model.constraints.add(myB >= _yB) + + if mode_t == ""FULL"": + for _m in range(m): + for _k in range(k): + sum_a = 0 + for _n in range(n): + for _b in range(_M): + sum_a += vA[(_b, _m, _n, _k)] * math.pow(2, _b) + model.constraints.add( + vA[(_b, _m, _n, _k)] <= bitcA[(_b, _m, _n)] + ) + model.constraints.add( + vA[(_b, _m, _n, _k)] <= self.u[_n][_k] + ) + model.constraints.add( + vA[(_b, _m, _n, _k)] + >= bitcA[(_b, _m, _n)] + self.u[_n][_k] - 1 + ) + + model.constraints.add(fA[(_m, _k)] == sum_a) + + for _m in range(m): + for _k in range(k): + sum_b = 0 + for _n in range(n): + for _b in range(_M): + sum_b += vB[(_b, _m, _n, _k)] * math.pow(2, _b) + model.constraints.add( + vB[(_b, _m, _n, _k)] <= bitcB[(_b, _m, _n)] + ) + model.constraints.add( + vB[(_b, _m, _n, _k)] <= self.u[_n][_k] + ) + model.constraints.add( + vB[(_b, _m, _n, _k)] + >= bitcB[(_b, _m, _n)] + self.u[_n][_k] - 1 + ) + + model.constraints.add(fB[(_m, _k)] == sum_b) + + for _n in range(n): + for _k in range(k): + _sum = 0 + for _m in range(m): + for _b in range(_M): + _sum += bitcA[(_b, _m, _n)] + bitcB[(_b, _m, _n)] + model.constraints.add(_sum >= self.u[_n][_k]) + + if (mode_t == ""FULL"") or (d > 0 and mode_t == ""CARCH""): + for _m in range(m): + cluster_id = f_a.index[_m] + # upper bound for solver + ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) + + for _n in range(n): + sum_a = 0 + sum_b = 0 + for _b in range(_M): + sum_a += bitcA[(_b, _m, _n)] * math.pow(2, _b) + sum_b += bitcB[(_b, _m, _n)] * math.pow(2, _b) + + model.constraints.add(self.cA[_m][_n] == sum_a) + model.constraints.add(self.cB[_m][_n] == sum_b) + model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] <= ub) + + if mode_t == ""CARCH"": + # TODO: These loops can be collapsed once validation against C++ is complete + for _m in range(m): + for _k in range(k): + _sumA = 0 + _sumB = 0 + for _n in range(n): + if self._fixed_u[_n][_k] >= self.mu - self.tol: + _sumA += self.cA[_m][_n] * self._fixed_u[_n][_k] + _sumB += self.cB[_m][_n] * self._fixed_u[_n][_k] + model.constraints.add(fA[(_m, _k)] == _sumA) + model.constraints.add(fB[(_m, _k)] == _sumB) + + cluster_id = f_a.index[_m] + # upper bound for solver + ub = max(sum(copy_numbers.get(cluster_id, (0, 0))), cn_max) + for _n in range(n): + model.constraints.add(self.cA[_m][_n] + self.cB[_m][_n] <= ub) + + if mode_t in (""FULL"", ""CARCH""): + for _m in range(m): + model.constraints.add(self.cA[_m][0] == 1) + model.constraints.add(self.cB[_m][0] == 1) + + if ampdel: + for _m in range(m): + cluster_id = f_a.index[_m] + if cluster_id not in copy_numbers: + for _n in range(1, n): + model.constraints.add( + self.cA[_m][_n] + <= cn_max * adA[_m] + _base - _base * adA[_m] + ) + model.constraints.add(self.cA[_m][_n] >= _base * adA[_m]) + model.constraints.add( + self.cB[_m][_n] + <= cn_max * adB[_m] + _base - _base * adB[_m] + ) + model.constraints.add(self.cB[_m][_n] >= _base * adB[_m]) + + if mode_t == ""UARCH"": + # TODO: These loops can be collapsed once validation against C++ is complete + for _m in range(m): + for _k in range(k): + _sumA = 0 + _sumB = 0 + for _n in range(n): + _sumA += int(self._fixed_cA[_m][_n]) * self.u[_n][_k] + _sumB += int(self._fixed_cB[_m][_n]) * self.u[_n][_k] + model.constraints.add(fA[(_m, _k)] == _sumA) + model.constraints.add(fB[(_m, _k)] == _sumB) + + if mode_t in (""FULL"", ""UARCH""): + for _k in range(k): + _sum = 0 + for _n in range(n): + _sum += self.u[_n][_k] + model.constraints.add(_sum == 1) + + if (mode_t in (""FULL"", ""UARCH"")) and self.mu > 0: + for _k in range(k): + for _n in range(1, n): + model.constraints.add(x[(_n, _k)] >= self.u[_n][_k]) + model.constraints.add(self.u[_n][_k] >= self.mu * x[(_n, _k)]) + + # buildOptionalConstraints + if (mode_t in (""FULL"", ""CARCH"")) and d > 0: + for _m in range(self.m): + for _n in range(1, self.n): + _sum = 0 + for _d in range(self.d): + _sum += z[(_m, _n, _d)] + model.constraints.add(_sum == 1) + + for _m in range(self.m): + for _M in range(self.M): + for _d in range(d): + for _i in range(1, self.n - 1): + for _j in range(1, self.n): + model.constraints.add( + bitcA[(_M, _m, _i)] - bitcA[(_M, _m, _j)] + <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] + ) + model.constraints.add( + bitcA[(_M, _m, _j)] - bitcA[(_M, _m, _i)] + <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] + ) + model.constraints.add( + bitcB[(_M, _m, _i)] - bitcB[(_M, _m, _j)] + <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] + ) + model.constraints.add( + bitcB[(_M, _m, _j)] - bitcB[(_M, _m, _i)] + <= 2 - z[(_m, _i, _d)] - z[(_m, _j, _d)] + ) + + for _m in range(self.m): + for _d in range(d - 1): + _sum_l = _sum_l1 = 0 + for _n in range(1, self.n): + _sum_l += z[(_m, _n, _d)] * self.symmCoeff(_n) + _sum_l1 += z[(_m, _n, _d + 1)] * self.symmCoeff(_n) + model.constraints.add(_sum_l <= _sum_l1) + + if mode_t in (""FULL"", ""CARCH""): + self.build_symmetry_breaking(model) + self.fix_given_cn(model) + + if mode_t == ""FULL"": + self.hot_start() + + obj = 0 + for _m in range(m): + cluster_id = self.cluster_ids[_m] + n_bins = len(self.binsA[cluster_id]) + + for _k in range(k): + for _i in range(n_bins): + obj += (yA[(_m, _k, _i)] + yB[(_m, _k, _i)]) * self.lengths[ + cluster_id + ][_i] + + model.obj = pe.Objective(expr=obj, sense=pe.minimize) + self.model = model + + if pprint: + print(str(self)) +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/solve/cd.py",".py","5007","169","from copy import copy +from concurrent.futures import ProcessPoolExecutor, as_completed + +from hatchet.utils.solve.ilp_subset import ILPSubset, ILPSubsetSplit +from hatchet.utils.solve.utils import Random + + +class Worker: + def __init__(self, ilp, solver): + self.ilp = ilp + self.solver_type = solver + + def run( + self, + cA, + cB, + u, + max_iters, + max_convergence_iters, + tol=0.001, + timelimit=None, + ): + _iters = _convergence_iters = 0 + _u = u + _cA, _cB = cA, cB # first hot-start values + + while (_iters < max_iters) and (_convergence_iters < max_convergence_iters): + carch = copy(self.ilp) + carch.fix_u(_u) + carch.create_model() + carch.hot_start(_cA, _cB) + carch_results = carch.run(self.solver_type, timelimit=timelimit) + if carch_results is None: + return None + _obj_c, _cA, _cB, _, _, _ = carch_results + + uarch = copy(self.ilp) + uarch.fix_c(_cA, _cB) + uarch.create_model() + uarch_results = uarch.run(self.solver_type, timelimit=timelimit) + if uarch_results is None: + return None + _obj_u, _, _, _u, _, _ = uarch_results + + delta = abs(_obj_c - _obj_u) + if delta < tol: + _convergence_iters += 1 + else: + _convergence_iters = 0 + + _iters += 1 + + return _obj_u, _cA, _cB, _u + + +# Top-level 'work' function that can be pickled for multiprocessing +def _work(cd, u, solver_type, max_iters, max_convergence_iters, timelimit): + worker = Worker(cd.ilp, solver_type) + return worker.run( + cd.hcA, + cd.hcB, + u, + max_iters=max_iters, + max_convergence_iters=max_convergence_iters, + timelimit=timelimit, + ) + + +class CoordinateDescent: + def __init__(self, f_a, f_b, n, mu, d, cn_max, cn, w, purities, ampdel=True): + # ilp attribute used here as a convenient storage container for properties + self.ilp = ILPSubset( + n=n, + cn_max=cn_max, + d=d, + mu=mu, + ampdel=ampdel, + copy_numbers=cn, + f_a=f_a, + f_b=f_b, + w=w, + purities=purities, + ) + # Building the model here is not strictly necessary, as, during execution, + # self.carch and c.uarch will copy self.ilp and create+run those models. + # However, we do so here simply so we can print out some diagnostic information once for the user. + self.ilp.create_model(pprint=True) + self.hcA, self.hcB = self.ilp.first_hot_start() + + self.seeds = None + + def run( + self, + solver_type=""gurobi"", + max_iters=10, + max_convergence_iters=2, + n_seed=400, + j=8, + random_seed=None, + timelimit=None, + ): + with Random(random_seed): + seeds = [self.ilp.build_random_u() for _ in range(n_seed)] + + result = {} # obj. value => (cA, cB, u) mapping + to_do = [] + with ProcessPoolExecutor(max_workers=min(j, n_seed)) as executor: + for u in seeds: + future = executor.submit( + _work, + self, + u, + solver_type, + max_iters, + max_convergence_iters, + timelimit, + ) + to_do.append(future) + + for future in as_completed(to_do): + results = future.result() + if results is not None: + obj, cA, cB, u = results + result[obj] = cA, cB, u + + if not result: + raise RuntimeError(""Not a single feasible solution found!"") + + best = min(result) + return (best,) + result[best] + (self.ilp.cluster_ids, self.ilp.sample_ids) + + +class CoordinateDescentSplit(CoordinateDescent): + def __init__( + self, + f_a, + f_b, + n, + mu, + d, + cn_max, + cn, + binsA, + binsB, + lengths, + ampdel=True, + ): + # ilp attribute used here as a convenient storage container for properties + self.ilp = ILPSubsetSplit( + n=n, + cn_max=cn_max, + d=d, + mu=mu, + ampdel=ampdel, + copy_numbers=cn, + f_a=f_a, + f_b=f_b, + binsA=binsA, + binsB=binsB, + lengths=lengths, + ) + # Building the model here is not strictly necessary, as, during execution, + # self.carch and c.uarch will copy self.ilp and create+run those models. + # However, we do so here simply so we can print out some diagnostic information once for the user. + self.ilp.create_model(pprint=True) + self.hcA, self.hcB = self.ilp.first_hot_start() + + self.seeds = None +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/solve/__init__.py",".py","9369","306","import os +import numpy as np +import pandas as pd +from pyomo import environ as pe +from collections import OrderedDict + +from hatchet.utils.solve.ilp_subset import ILPSubset, ILPSubsetSplit +from hatchet.utils.solve.cd import CoordinateDescent, CoordinateDescentSplit +from hatchet.utils.solve.utils import parse_clonal, scale_rdr +from hatchet import config +import hatchet.utils.Supporting as sp + + +def solver_available(solver=None): + solver = solver or config.compute_cn.solver + if solver == ""cpp"": + return os.getenv(""GRB_LICENSE_FILE"") is not None + elif solver == ""gurobipy"": + return pe.SolverFactory(""gurobi"", solver_io=""python"").available( + exception_flag=False + ) + return pe.SolverFactory(solver).available(exception_flag=False) + + +def solve( + clonal, + bbc_file, + seg_file, + n, + solver=""gurobi"", + solve_mode=""cd"", + d=-1, + cn_max=-1, + mu=0.01, + diploid_threshold=0.1, + ampdel=True, + n_seed=400, + n_worker=8, + random_seed=None, + max_iters=None, + timelimit=None, + binwise=False, + purities=None, +): + assert solve_mode in (""ilp"", ""cd"", ""both""), ""Unrecognized solve_mode"" + assert solver_available(solver), f""Solver {solver} not available or not licensed"" + + if max_iters is None: + max_iters = 10 + + df = pd.read_csv(seg_file, sep=""\t"") + df = df.sort_values([""#ID"", ""SAMPLE""]) + + bbc = pd.read_table(bbc_file) + bbc = bbc.sort_values(by=[""#CHR"", ""START"", ""SAMPLE""]) + + # sanity-check + sample_ids = np.sort(df[""SAMPLE""].unique()) + for _cluster_id, _df in df.groupby(""#ID""): + _sample_ids = _df[""SAMPLE""].values + if not np.all(_sample_ids == sample_ids): + raise ValueError( + f""Sample IDs for cluster {_cluster_id} do not match {sample_ids}"" + ) + + rdr = df.pivot(index=""#ID"", columns=""SAMPLE"", values=""RD"") + baf = df.pivot(index=""#ID"", columns=""SAMPLE"", values=""BAF"") + + bins = {} # cluster_id => no. of bins + for cluster_id, _df in df.groupby(""#ID""): + if len(_df[""#BINS""].unique()) != 1: + raise ValueError( + f""Bin sizes for cluster {cluster_id} across tumor samples are not identical!"" + ) + bins[cluster_id] = _df.iloc[0][""#BINS""] + bins = pd.Series(bins) + + weights = 100 * bins / sum(bins) + + if clonal is None: + _candidate_cluster_ids = np.all(rdr > 0.5 - diploid_threshold, axis=1) + if not np.any(_candidate_cluster_ids): + raise RuntimeError( + f""Unable to determine cluster with diploid RDR threshold {diploid_threshold}"" + ) + dipoid_cluster_id = (_candidate_cluster_ids * weights).idxmax() + copy_numbers = {dipoid_cluster_id: (1, 1)} + else: + copy_numbers = parse_clonal(clonal) + + gamma = scale_rdr(rdr, copy_numbers) + sp.log( + msg=""Computed scaling factor gamma = \n"" + str(gamma) + ""\n"", + level=""INFO"", + ) + rdr = rdr * gamma + f_b = rdr * baf + f_a = rdr - f_b + + if not binwise: + if solve_mode == ""ilp"": + ilp = ILPSubset( + n, + cn_max, + d=d, + mu=mu, + ampdel=ampdel, + copy_numbers=copy_numbers, + f_a=f_a, + f_b=f_b, + w=weights, + purities=purities, + ) + ilp.create_model(pprint=True) + return ilp.run(solver_type=solver, timelimit=timelimit) + elif solve_mode == ""cd"": + cd = CoordinateDescent( + f_a=f_a, + f_b=f_b, + n=n, + mu=mu, + d=d, + cn_max=cn_max, + w=weights, + ampdel=ampdel, + cn=copy_numbers, + purities=purities, + ) + return cd.run( + solver_type=solver, + max_iters=max_iters, + n_seed=n_seed, + j=n_worker, + random_seed=random_seed, + timelimit=timelimit, + ) + else: + cd = CoordinateDescent( + f_a=f_a, + f_b=f_b, + n=n, + mu=mu, + d=d, + cn_max=cn_max, + w=weights, + ampdel=ampdel, + cn=copy_numbers, + purities=purities, + ) + _, cA, cB, _, _, _ = cd.run( + solver_type=solver, + max_iters=max_iters, + n_seed=n_seed, + j=n_worker, + random_seed=random_seed, + timelimit=timelimit, + ) + + ilp = ILPSubset( + n, + cn_max, + d=d, + mu=mu, + ampdel=ampdel, + copy_numbers=copy_numbers, + f_a=f_a, + f_b=f_b, + w=weights, + purities=purities, + ) + ilp.create_model() + ilp.hot_start(cA, cB) + return ilp.run(solver_type=solver, timelimit=timelimit) + + else: + bins = OrderedDict() # cluster_id => RDR for cluster + for cluster_id, _df in df.groupby(""#ID""): + if len(_df[""#BINS""].unique()) != 1: + raise ValueError( + f""Bin sizes for cluster {cluster_id} across tumor samples are not identical!"" + ) + my_bbc = bbc[bbc.CLUSTER == cluster_id] + if _df.iloc[0][""#BINS""] * len(_df) != len( + my_bbc + ): # seg file should have 1 row per sample + raise ValueError( + f""BBC and SEG files describe inconsisitent # bins for cluster {cluster_id}!"" + ) + bins[cluster_id] = my_bbc.RD + + binned_length = ( + bbc[bbc.SAMPLE == bbc.iloc[0].SAMPLE].END + - bbc[bbc.SAMPLE == bbc.iloc[0].SAMPLE].START + ).sum() + + bins_rdr = { + k: my_df.pivot(index=[""#CHR"", ""START""], columns=""SAMPLE"", values=""RD"") + for k, my_df in bbc.groupby(""CLUSTER"") + } + bins_baf = { + k: my_df.pivot(index=[""#CHR"", ""START""], columns=""SAMPLE"", values=""BAF"") + for k, my_df in bbc.groupby(""CLUSTER"") + } + bins_length = { + k: ( + ( + my_df.pivot(index=[""#CHR"", ""START""], columns=""SAMPLE"", values=""END"") + - my_df.pivot( + index=[""#CHR"", ""START""], + columns=""SAMPLE"", + values=""START"", + ) + ).values[:, 0] + * 100 + ) + / binned_length + for k, my_df in bbc.groupby(""CLUSTER"") + } + + binsA = {} + binsB = {} + for k in bins_rdr.keys(): + bins_rdr[k] = bins_rdr[k] * gamma + binsB[k] = bins_rdr[k] * bins_baf[k] + binsA[k] = bins_rdr[k] - binsB[k] + + if solve_mode == ""ilp"": + ilp = ILPSubsetSplit( + n, + cn_max, + d=d, + mu=mu, + ampdel=ampdel, + copy_numbers=copy_numbers, + f_a=f_a, + f_b=f_b, + binsA=binsA, + binsB=binsB, + lengths=bins_length, + purities=purities, + ) + ilp.create_model(pprint=True) + return ilp.run(solver_type=solver, timelimit=timelimit) + elif solve_mode == ""cd"": + cd = CoordinateDescentSplit( + f_a=f_a, + f_b=f_b, + n=n, + mu=mu, + d=d, + cn_max=cn_max, + ampdel=ampdel, + cn=copy_numbers, + binsA=binsA, + binsB=binsB, + lengths=bins_length, + ) + return cd.run( + solver_type=solver, + max_iters=max_iters, + n_seed=n_seed, + j=n_worker, + random_seed=random_seed, + timelimit=timelimit, + ) + else: + cd = CoordinateDescentSplit( + f_a=f_a, + f_b=f_b, + n=n, + mu=mu, + d=d, + cn_max=cn_max, + ampdel=ampdel, + cn=copy_numbers, + binsA=binsA, + binsB=binsB, + lengths=bins_length, + ) + _, cA, cB, _, _, _ = cd.run( + solver_type=solver, + max_iters=max_iters, + n_seed=n_seed, + j=n_worker, + random_seed=random_seed, + timelimit=timelimit, + ) + + ilp = ILPSubsetSplit( + n, + cn_max, + d=d, + mu=mu, + ampdel=ampdel, + copy_numbers=copy_numbers, + f_a=f_a, + f_b=f_b, + cn=copy_numbers, + binsA=binsA, + binsB=binsB, + lengths=bins_length, + ) + ilp.create_model() + ilp.hot_start(cA, cB) + return ilp.run(solver_type=solver, timelimit=timelimit) +","Python" +"Allele","raphael-group/hatchet","src/hatchet/utils/solve/utils.py",".py","7185","182","from collections import OrderedDict +import numpy as np +import pandas as pd + + +# A list of random states, used as a stack +random_states = [] + + +class Random: + """""" + A context manager that pushes a random seed to the stack for reproducible results, + and pops it on exit. + """""" + + def __init__(self, seed=None): + self.seed = seed + + def __enter__(self): + if self.seed is not None: + # Push current state on stack + random_states.append(np.random.get_state()) + new_state = np.random.RandomState(self.seed) + np.random.set_state(new_state.get_state()) + + def __exit__(self, *args): + if self.seed is not None: + np.random.set_state(random_states.pop()) + + +def parse_clonal(clonal): + copy_numbers = OrderedDict() # dict from cluster_id => (cn_a, cn_b) 2-tuple + clonal_parts = clonal.split("","") + n_clonal_parts = len(clonal_parts) + + for i, c in enumerate(clonal_parts): + cluster_id, cn_a, cn_b = [int(_c) for _c in c.split("":"")] + + # The first two clonal clusters (used for scaling) MUST have different total copy numbers + if i == 1: + _first_cn_a, _first_cn_b = list(copy_numbers.values())[0] + if _first_cn_a + _first_cn_b == cn_a + cn_b: + raise ValueError( + ( + ""When >= 2 clonal copy numbers are given, the first two must be different in the two segmental "" + ""clusters"" + ) + ) + + cn_total = cn_a + cn_b + if (cn_total == 2) and (n_clonal_parts > 1): + # warnings.warn('Please specify a single cluster when CN_A+CN_B=2') + # TODO: The C++ implementation generates a warning corresponding to the above + # This is suppressed by default, which is what we do here for now. + pass + if cluster_id in copy_numbers: + raise ValueError(""Already encountered cluster_id ="", str(cluster_id)) + copy_numbers[cluster_id] = cn_a, cn_b + + return copy_numbers + + +def scale_rdr(rdr, copy_numbers, purity_tol=0.05): + assert len(copy_numbers) >= 1 + if len(copy_numbers) == 1: + diploid_cluster_id = list(copy_numbers.keys())[0] + diploid_rdr = rdr.loc[diploid_cluster_id] + scale = 2 / diploid_rdr + else: + # Use the first two copy-number specifications to determine scaling factors + # Note the reversed assignment order to conform to C++ behavior - check with Simone! + cluster_id_2, cluster_id_1 = tuple(copy_numbers.keys())[:2] # TODO + rdr_1, rdr_2 = rdr.loc[cluster_id_1], rdr.loc[cluster_id_2] + cn_sum_1, cn_sum_2 = ( + sum(copy_numbers[cluster_id_1]), + sum(copy_numbers[cluster_id_2]), + ) + purity = 2 * (rdr_1 - rdr_2) / ((2 - cn_sum_2) * rdr_1 - (2 - cn_sum_1) * rdr_2) + + purity[(1 <= purity) & (purity <= 1 + purity_tol)] = 1 + purity[(-purity_tol <= purity) & (purity <= 0)] = 0 + + scale = (2 - (2 - cn_sum_1) * purity) / rdr_1 + assert np.all((0 <= purity) & (purity <= 1) & (scale >= 0)), ""scaling failed"" + + return scale + + +def segmentation( + cA, + cB, + u, + cluster_ids, + sample_ids, + bbc_file, + bbc_out_file=None, + seg_out_file=None, +): + df = pd.read_csv(bbc_file, sep=""\t"") + # Chromosomes may or may not have chr notation - force a string dtype anyway + df[""#CHR""] = df[""#CHR""].astype(str) + # TODO: The legacy C++ implementation interprets the 'coverage' column as an int + df[""COV""] = df[""COV""].astype(int) + + n_clone = len(cA[0]) + cA = pd.DataFrame(cA, index=cluster_ids, columns=range(n_clone)) + cB = pd.DataFrame(cB, index=cluster_ids, columns=range(n_clone)) + u = pd.DataFrame(u, index=range(n_clone), columns=sample_ids) + # Make (n_sample, n_clone) in shape; easier to merge later + u = u.T + + # copy-numbers represented as | strings + cN = cA.astype(str) + ""|"" + cB.astype(str) + cN.columns = [""cn_normal""] + [f""cn_clone{i}"" for i in range(1, n_clone)] + + # Merge in copy-number + proportion information to our original Dataframe + df = df.merge(cN, left_on=""CLUSTER"", right_index=True) + u.columns = [""u_normal""] + [f""u_clone{i}"" for i in range(1, n_clone)] + df = df.merge(u, left_on=""SAMPLE"", right_index=True) + + # Sorting the values by start/end position critical for merging contiguous + # segments with identical copy numbers later on + df = df.sort_values([""#CHR"", ""START"", ""END"", ""SAMPLE""]) + df = df.reset_index(drop=True) + + # last 2*n_clone columns names = [cn_normal, u_normal, cn_clone1, u_clone1, cn_clone2, ...] + extra_columns = [col for sublist in zip(cN.columns, u.columns) for col in sublist] + all_columns = df.columns.values[: -2 * n_clone].tolist() + extra_columns + + if bbc_out_file is not None: + # rearrange columns for easy comparison to legacy files + df = df[all_columns] + df.to_csv(bbc_out_file, sep=""\t"", index=False) + + if seg_out_file is not None: + # create a new column that will use to store the contiguous segment number (1-indexed) + df[""segment""] = 0 + # all column names with cnA|cnB information (normal + clones) + cN_column_names = cN.columns.tolist() + # create a new column with all cnA|cnB strings joined as a single column + df[""all_copy_numbers""] = df[cN_column_names].apply( + lambda x: "","".join(x), axis=1 + ) + + _first_sample_name = df[""SAMPLE""].iloc[0] + + # Grouping by consecutive identical values + # See https://towardsdatascience.com/pandas-dataframe-group-by-consecutive-same-values-128913875dba + group_name_to_indices = df.groupby( + ( + # Find indices where we see the first sample name AND + (df[""SAMPLE""] == _first_sample_name) + & ( + # The chromosome changed values from the previous row OR + # any of the copy-numbers changed from the previous row OR + # the START changed from the END in the previous row + (df[""#CHR""] != df[""#CHR""].shift()) + | (df[""all_copy_numbers""] != df[""all_copy_numbers""].shift()) + | (df[""START""] != df[""END""].shift()) + ) + ).cumsum(), + # cumulative sum increments whenever a True is encountered, thus creating a series of monotonically + # increasing values we can use as segment numbers + sort=False, + ).indices + # 'indices' of a Pandas GroupBy object gives us a mapping from the group 'name' + # (numbers starting from 1) -> indices in the Dataframe + + for group_name, indices in group_name_to_indices.items(): + df.loc[indices, ""segment""] = group_name + + aggregation_rules = { + ""#CHR"": ""first"", + ""START"": ""min"", + ""END"": ""max"", + ""SAMPLE"": ""first"", + } + aggregation_rules.update({c: ""first"" for c in extra_columns}) + df = df.groupby([""segment"", ""SAMPLE""]).agg(aggregation_rules) + + df.to_csv(seg_out_file, sep=""\t"", index=False) +","Python" +"Allele","raphael-group/hatchet","src/hatchet/data/__init__.py",".py","0","0","","Python" +"Allele","raphael-group/hatchet","examples/demo-WES/demo-wes.md",".md","12879","145","# Demo for WES data from a cancer patient +: ex: set ft=markdown ;:<<'```shell' # + +**NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. + +The following HATCHet's demo represents a guided example starting from WES (whole-exome sequencing) data from 2 samples of the same patient. WES data are an interesting case to consider as they are typically characterize by a larger variance, especially for RDR. For simplicity, the demo starts from a BB file `demo-wes.bb` (included in this demo at `examples/demo-WES/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. count-reads, count-alleles, and combine-counts) have already been executed by running standard configuration for WES data (bin size of 250kb through -b 250kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 30 and 400 through `-c 30 -C 400` of `count-alleles` as the average coverage is 180x). + +## Requirements and set up + +The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: + +```shell +PY=""python3"" # This is the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` +:<<'```shell' # Ignore this line +``` + +The following paths are consequently obtained to point to the required components of HATCHet + +```shell +CLUSTERBINS=""${PY} -m hatchet cluster-bins"" +PLOTBINS=""${PY} -m hatchet plot-bins"" +INFER=""${PY} -m hatchet compute-cn"" +PLOTCN=""${PY} -m hatchet plot-cn"" +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands + +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Global clustering + +The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: + +```shell +${CLUSTERBINS} demo-wes.bb -o demo-wes.seg -O demo-wes.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 +:<<'```shell' # Ignore this line +``` + +For different type of data it is essential to assess the quality of the clustering because this is performed by a Dirichlet process and it is affected by varying degrees of noise. This assesment is particularly important in the case of WES data where the variance is higher than expected, especially for RDR; in fact we often observe that the clusters are much wider in terms of RDR (x-axis) and tend to have a *disc* shape rather than the expected *oval* shape. To do this, we use `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data, and produce the cluster plot using the `CBB` command. To help we use the following options: +- `--xmin 0` and `--xmax 2` allow to zoom in and to focus the figure on the same RDR (y-axis) range for every sample. +- `-tS 0.005` asks to plot only the clusters which cover at least the `0.5%` of the genome. This is useful to clean the figure and focus on the main components. +To trace all steps, we also move the figure to `tR015-cbb.pdf`. + +```shell +${PLOTBINS} -c CBB demo-wes.bbc --ymin 0 --ymax 2 -tS 0.005 +mv bb_clustered.png tR015-cbb.png +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![Bad clustering with default values](tR015-cbb.png) + +We can easily notice that the clustering is not ideal and is clearly overfitting the data by choosing too many distinct clusters; in fact we notice the presence of many different clusters that are extremely close and have identical BAF in every sample. For example, orange/light blue/light orange clusters and purple/red clusters exhibit a very typical pattern of ""striped"" clusters which are always adjacent clusters which appear to be part of a wider cluster. A good condition to assess the quality of the clustering is to assess that every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. + +Since Dirichlet clustering is not ad-hoc for this application, it can often result in overclustering. For this reason, cluster-bins additionally provides a procedure to merge clusters which are very likely to be part of a single cluster. However this procedure requires two maximum thresholds for doing this, one is the maximum shift for RDR (`-tR 0.15`) and one is the maximum shift for BAF (`-tB 0.03`). The default values allow to work with most of the datasets, however datasets of high variance, e.g. in the case of WES data, require to tune these parameters. In our example as in most WES datasets, BAF is pretty well estimated and the clusters exhibit small variance on the y-axis, accordingly, the default value `-tB 0.03` is therefore good. Instead, RDR appears to have much higher variance; in fact, the clusters that are always adjacent span much more than 0.15 of RDR in the x-axis. Therefore, by looking at the plot, we can see that a value of `-tR 0.5` fit much better the noise of RDR in our data and we repeat the clustering with this value. + +```shell +${CLUSTERBINS} demo-wes.bb -o demo-wes.seg -O demo-wes.bbc -e 12 -tB 0.03 -tR 0.5 -d 0.08 +:<<'```shell' # Ignore this line +``` + +We assess again the clustering using `plot-bins` as before. + +```shell +${PLOTBINS} -c CBB demo-wes.bbc --ymin 0 --ymax 2 -tS 0.005 +mv bb_clustered.png cbb.png +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![Better clustering with default values](cbb.png) + +In this clustering the previously-described condition is met and all the different clusters are clearly distinct in at least one sample. + +## hatchet's step + +In the last step we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. +We apply the last step with default parameters and, for simplicity of this demo, we apply only few changes: +- As the dataset has high variance and noise (see clustering), we consider a minimum clone proportion `-u` slightly higher than the default value, i.e. `6%`. We do this because we cannot infer tumor clones with very low proportions when there is high noise and because potential clones inferred with very low proportions may simply be the result of overfitting. In fact, when using values of `-u` smaller than `6%` we obtain solutions with clone proporions identical to the minimum value of `-u`; this is the recommended criterion to determine the need of increasing the value of `-u`. Interestingly, we can observe the same overfitting sign when we consider too high values of the minimum clone proportion, for example `-u 0.1`. This happens because the value is too high to fit the given data. As such, it is always important to choose the minimum value which provides ""non-overfitting"" results, i.e. results where the clone proportions are not identical to the minimum. When this is not possible, as in very noisy datasets, we reccommend to either tune the clustering or keeping very low values of the minimum clone proportion, as HATCHet is still able to recover the main clonal composition even in the presence of mninor overfitting. +- We limit the number of clones to 6 for simplicity of this demo and because it is a reasonable value for CNAs when consider only few samples from the same patient. +- We only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. + +```shell +${INFER} -i demo-wes -n2,6 -p 100 -v 2 -u 0.06 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results: + + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 25.198649 - score: -0.0948974010472 + ## Diploid with 3 clones - OBJ: 15.247768 - score: -0.093570025792 + ## Diploid with 4 clones - OBJ: 7.79973 - score: 0.183873549872 + ## Diploid with 5 clones - OBJ: 5.42398 - score: 0.071621041522 + ## Diploid with 6 clones - OBJ: 4.16034 - score: -0.0670271645544 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 54.70041 - score: -0.258478300254 + ## Tetraploid with 3 clones - OBJ: 24.151418 - score: 0.0574235848181 + ## Tetraploid with 4 clones - OBJ: 13.46257 - score: 0.208505877387 + ## Tetraploid with 5 clones - OBJ: 10.311379 - score: 0.0136705311613 + ## Tetraploid with 6 clones - OBJ: 8.038751 - score: -0.0795999933666 + # The chosen diploid solution has 4 clones with OBJ: 7.79973 and score: 0.183873549872 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 4 clones with OBJ: 13.46257 and score: 0.208505877387 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is diploid with 4 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet predicts the presence of 4 clones in the 3 tumor samples with no WGD and, especially, predicts that each sample contains two distinct tumor clones while sharing one of this. As there are inferred tumor clones with small clone proportions, there are only 2 samples, and the objective function does not significantly decrease after the chosen number of clones, there is no need to investigate the results of HATCHet by increasing the sensitivity with lower values of `-l`. However, the user could investigate the results of HATCHet when considering a lower sensitivity to small CNAs by considering higher values of `-l`, e.g. `-l 0.6` or `-l 0.8`; this choice would be indeed motivated by the high noise of the dataset. + + +## Analyzing inferred results + +Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. As WES data have fewer point covering the genome, we slightly change the resolution of the plots by asking to obtain genomic regions merging fewer genomic bins through `-rC 10 -rG 1`. As such, we run `plot-cn` as follows + +```shell +${PLOTCN} best.bbc.ucn -rC 10 -rG 1 +exit $? +``` + +First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: + + ### SAMPLE: WESDemo2 -- PURITY: 0.7534724 -- PLOIDY: 1.84640419971 -- CLASSIFICATION: DIPLOID + ### SAMPLE: WESDemo1 -- PURITY: 0.9283579 -- PLOIDY: 1.90711595733 -- CLASSIFICATION: DIPLOID + +Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly important. + +The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). +![intratumor-clones-totalcn.pdf](totalcn.png) +Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. + +The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. +![intratumor-clones-allelecn.pdf](allelecn.png) + +The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. +![intratumor-clones-allelecn.pdf](profiles.png) +The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. +","Markdown" +"Allele","raphael-group/hatchet","examples/demo-WES/demo-wes.sh",".sh","12879","145","# Demo for WES data from a cancer patient +: ex: set ft=markdown ;:<<'```shell' # + +**NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. + +The following HATCHet's demo represents a guided example starting from WES (whole-exome sequencing) data from 2 samples of the same patient. WES data are an interesting case to consider as they are typically characterize by a larger variance, especially for RDR. For simplicity, the demo starts from a BB file `demo-wes.bb` (included in this demo at `examples/demo-WES/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. count-reads, count-alleles, and combine-counts) have already been executed by running standard configuration for WES data (bin size of 250kb through -b 250kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 30 and 400 through `-c 30 -C 400` of `count-alleles` as the average coverage is 180x). + +## Requirements and set up + +The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: + +```shell +PY=""python3"" # This is the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` +:<<'```shell' # Ignore this line +``` + +The following paths are consequently obtained to point to the required components of HATCHet + +```shell +CLUSTERBINS=""${PY} -m hatchet cluster-bins"" +PLOTBINS=""${PY} -m hatchet plot-bins"" +INFER=""${PY} -m hatchet compute-cn"" +PLOTCN=""${PY} -m hatchet plot-cn"" +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands + +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Global clustering + +The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: + +```shell +${CLUSTERBINS} demo-wes.bb -o demo-wes.seg -O demo-wes.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 +:<<'```shell' # Ignore this line +``` + +For different type of data it is essential to assess the quality of the clustering because this is performed by a Dirichlet process and it is affected by varying degrees of noise. This assesment is particularly important in the case of WES data where the variance is higher than expected, especially for RDR; in fact we often observe that the clusters are much wider in terms of RDR (x-axis) and tend to have a *disc* shape rather than the expected *oval* shape. To do this, we use `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data, and produce the cluster plot using the `CBB` command. To help we use the following options: +- `--xmin 0` and `--xmax 2` allow to zoom in and to focus the figure on the same RDR (y-axis) range for every sample. +- `-tS 0.005` asks to plot only the clusters which cover at least the `0.5%` of the genome. This is useful to clean the figure and focus on the main components. +To trace all steps, we also move the figure to `tR015-cbb.pdf`. + +```shell +${PLOTBINS} -c CBB demo-wes.bbc --ymin 0 --ymax 2 -tS 0.005 +mv bb_clustered.png tR015-cbb.png +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![Bad clustering with default values](tR015-cbb.png) + +We can easily notice that the clustering is not ideal and is clearly overfitting the data by choosing too many distinct clusters; in fact we notice the presence of many different clusters that are extremely close and have identical BAF in every sample. For example, orange/light blue/light orange clusters and purple/red clusters exhibit a very typical pattern of ""striped"" clusters which are always adjacent clusters which appear to be part of a wider cluster. A good condition to assess the quality of the clustering is to assess that every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. + +Since Dirichlet clustering is not ad-hoc for this application, it can often result in overclustering. For this reason, cluster-bins additionally provides a procedure to merge clusters which are very likely to be part of a single cluster. However this procedure requires two maximum thresholds for doing this, one is the maximum shift for RDR (`-tR 0.15`) and one is the maximum shift for BAF (`-tB 0.03`). The default values allow to work with most of the datasets, however datasets of high variance, e.g. in the case of WES data, require to tune these parameters. In our example as in most WES datasets, BAF is pretty well estimated and the clusters exhibit small variance on the y-axis, accordingly, the default value `-tB 0.03` is therefore good. Instead, RDR appears to have much higher variance; in fact, the clusters that are always adjacent span much more than 0.15 of RDR in the x-axis. Therefore, by looking at the plot, we can see that a value of `-tR 0.5` fit much better the noise of RDR in our data and we repeat the clustering with this value. + +```shell +${CLUSTERBINS} demo-wes.bb -o demo-wes.seg -O demo-wes.bbc -e 12 -tB 0.03 -tR 0.5 -d 0.08 +:<<'```shell' # Ignore this line +``` + +We assess again the clustering using `plot-bins` as before. + +```shell +${PLOTBINS} -c CBB demo-wes.bbc --ymin 0 --ymax 2 -tS 0.005 +mv bb_clustered.png cbb.png +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![Better clustering with default values](cbb.png) + +In this clustering the previously-described condition is met and all the different clusters are clearly distinct in at least one sample. + +## hatchet's step + +In the last step we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. +We apply the last step with default parameters and, for simplicity of this demo, we apply only few changes: +- As the dataset has high variance and noise (see clustering), we consider a minimum clone proportion `-u` slightly higher than the default value, i.e. `6%`. We do this because we cannot infer tumor clones with very low proportions when there is high noise and because potential clones inferred with very low proportions may simply be the result of overfitting. In fact, when using values of `-u` smaller than `6%` we obtain solutions with clone proporions identical to the minimum value of `-u`; this is the recommended criterion to determine the need of increasing the value of `-u`. Interestingly, we can observe the same overfitting sign when we consider too high values of the minimum clone proportion, for example `-u 0.1`. This happens because the value is too high to fit the given data. As such, it is always important to choose the minimum value which provides ""non-overfitting"" results, i.e. results where the clone proportions are not identical to the minimum. When this is not possible, as in very noisy datasets, we reccommend to either tune the clustering or keeping very low values of the minimum clone proportion, as HATCHet is still able to recover the main clonal composition even in the presence of mninor overfitting. +- We limit the number of clones to 6 for simplicity of this demo and because it is a reasonable value for CNAs when consider only few samples from the same patient. +- We only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. + +```shell +${INFER} -i demo-wes -n2,6 -p 100 -v 2 -u 0.06 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results: + + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 25.198649 - score: -0.0948974010472 + ## Diploid with 3 clones - OBJ: 15.247768 - score: -0.093570025792 + ## Diploid with 4 clones - OBJ: 7.79973 - score: 0.183873549872 + ## Diploid with 5 clones - OBJ: 5.42398 - score: 0.071621041522 + ## Diploid with 6 clones - OBJ: 4.16034 - score: -0.0670271645544 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 54.70041 - score: -0.258478300254 + ## Tetraploid with 3 clones - OBJ: 24.151418 - score: 0.0574235848181 + ## Tetraploid with 4 clones - OBJ: 13.46257 - score: 0.208505877387 + ## Tetraploid with 5 clones - OBJ: 10.311379 - score: 0.0136705311613 + ## Tetraploid with 6 clones - OBJ: 8.038751 - score: -0.0795999933666 + # The chosen diploid solution has 4 clones with OBJ: 7.79973 and score: 0.183873549872 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 4 clones with OBJ: 13.46257 and score: 0.208505877387 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is diploid with 4 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet predicts the presence of 4 clones in the 3 tumor samples with no WGD and, especially, predicts that each sample contains two distinct tumor clones while sharing one of this. As there are inferred tumor clones with small clone proportions, there are only 2 samples, and the objective function does not significantly decrease after the chosen number of clones, there is no need to investigate the results of HATCHet by increasing the sensitivity with lower values of `-l`. However, the user could investigate the results of HATCHet when considering a lower sensitivity to small CNAs by considering higher values of `-l`, e.g. `-l 0.6` or `-l 0.8`; this choice would be indeed motivated by the high noise of the dataset. + + +## Analyzing inferred results + +Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. As WES data have fewer point covering the genome, we slightly change the resolution of the plots by asking to obtain genomic regions merging fewer genomic bins through `-rC 10 -rG 1`. As such, we run `plot-cn` as follows + +```shell +${PLOTCN} best.bbc.ucn -rC 10 -rG 1 +exit $? +``` + +First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: + + ### SAMPLE: WESDemo2 -- PURITY: 0.7534724 -- PLOIDY: 1.84640419971 -- CLASSIFICATION: DIPLOID + ### SAMPLE: WESDemo1 -- PURITY: 0.9283579 -- PLOIDY: 1.90711595733 -- CLASSIFICATION: DIPLOID + +Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly important. + +The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). +![intratumor-clones-totalcn.pdf](totalcn.png) +Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. + +The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. +![intratumor-clones-allelecn.pdf](allelecn.png) + +The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. +![intratumor-clones-allelecn.pdf](profiles.png) +The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. +","Shell" +"Allele","raphael-group/hatchet","examples/demo-WGS-sim/demo-wgs-sim.md",".md","9051","130","# Demo for standard WGS data +: ex: set ft=markdown ;:<<'```shell' # + +**NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. + +The following HATCHet's demo represents a guided example starting from WGS (whole-genome sequencing) data from 3 simulated samples obtained from the same tumor. This represents an exemplary case of executing HATCHet on a typical dataset with standard noise. For simplicity, the demo starts from a BB file `demo-WGS-sim.bb` (included in this demo at `examples/demo-WGS-sim/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. count-reads, count-alleles, and combine-counts) have already been executed by running standard configuration for WGS data (bin size of 50kb through -b 50kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 3 and 200 through `-c 3 -C 200`). + +Specifically, the tumor is composed of 2 tumor clones (clone0 and clone1) and a normal diploid clone (normal). The clonal composition of every sample is described in the following table: + +| Name | Proportion of normal clone | Proporion of clone0 | Proportion of clone1 | +|------|----------------------------|---------------------|----------------------| +| `bulk_035clone1_06clone0_005normal` | `5%` | `60%` | `35%` | +| `bulk_055clone1_04clone0_005normal` | `5%` | `40%` | `55%` | +| `bulk_08clone1_Noneclone0_02normal` | `20%` | Not present | `80%` | + +## Requirements and set up + +The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: + +```shell +PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` +:<<'```shell' # Ignore this line +``` + +The following paths are consequently obtained to point to the required components of HATCHet + +```shell +CLUSTERBINS=""${PY} -m hatchet cluster-bins"" +PLOTBINS=""${PY} -m hatchet plot-bins"" +INFER=""${PY} -m hatchet compute-cn"" +PLOTCN=""${PY} -m hatchet plot-cn"" +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Global clustering + +The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: + +```shell +${CLUSTERBINS} demo-wgs-sim.bb -o demo-wgs-sim.seg -O demo-wgs-sim.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 +:<<'```shell' # Ignore this line +``` + +To assess the quality of the clustering we generate the cluster plot using the `CBB` command of `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data. For simplicity, we also use the following options +- `--colwrap 3` allows to have the 3 plots of the 3 samples on the same figure row +- `-tS 0.01` asks to plot only the clusters which cover at least the `1%` of the genome. This is useful to clean the figure and focus on the main components. + +```shell +${PLOTBINS} -c CBB demo-wgs-sim.bbc --colwrap 3 -tS 0.01 +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![CBB](cbb.png) + +We can easily notice that the clustering is good and not tuning is needed as every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. + +## hatchet's step + +Next we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. +We apply the last step with default parameters and, for simplicity of this demo, we consider 8 clones, which can be easily considered by HATCHet in this case, and we only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. + +```shell +${INFER} -i demo-wgs-sim -n2,8 -p 100 -v 2 -u 0.03 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results: + + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 66.884758 - score: -0.17739731674 + ## Diploid with 3 clones - OBJ: 34.954154 - score: -0.0216588755513 + ## Diploid with 4 clones - OBJ: 17.510067 - score: 0.0555719383474 + ## Diploid with 5 clones - OBJ: 9.744628 - score: 0.186776250313 + ## Diploid with 6 clones - OBJ: 7.243104 - score: 0.0839737725603 + ## Diploid with 7 clones - OBJ: 5.991972 - score: 0.0538665194051 + ## Diploid with 8 clones - OBJ: 5.27972 - score: -0.181132288335 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 81.216417 - score: -0.415141225696 + ## Tetraploid with 3 clones - OBJ: 23.135209 - score: 0.169099207187 + ## Tetraploid with 4 clones - OBJ: 15.47975 - score: 0.0653131702741 + ## Tetraploid with 5 clones - OBJ: 11.36852 - score: 0.0682096876804 + ## Tetraploid with 6 clones - OBJ: 9.124625 - score: 0.0411292123085 + ## Tetraploid with 7 clones - OBJ: 7.698914 - score: 0.0753487410723 + ## Tetraploid with 8 clones - OBJ: 7.076072 - score: -0.219100018522 + # The chosen diploid solution has 5 clones with OBJ: 9.744628 and score: 0.186776250313 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 3 clones with OBJ: 23.135209 and score: 0.169099207187 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is tetraploid with 3 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet predicts the presence of 3 clones in the 3 tumor samples and, especially, predicts that 2 samples contains two distinct tumor clones, according to the true clonal composition. + +## Analyzing inferred results + +Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows + +```shell +${PLOTCN} best.bbc.ucn +exit $? +``` + +First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: + + ### SAMPLE: bulk_08clone1_Noneclone0_02normal -- PURITY: 0.799477 -- PLOIDY: 3.07107541299 -- CLASSIFICATION: TETRAPLOID + ### SAMPLE: bulk_035clone1_06clone0_005normal -- PURITY: 0.95065 -- PLOIDY: 3.37447061915 -- CLASSIFICATION: TETRAPLOID + ### SAMPLE: bulk_055clone1_04clone0_005normal -- PURITY: 0.95048 -- PLOIDY: 3.27575289096 -- CLASSIFICATION: TETRAPLOID + +Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly interesting. + +The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). +![intratumor-clones-totalcn.pdf](totalcn.png) +Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. + +The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. +![intratumor-clones-allelecn.pdf](allelecn.png) + +The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. +![intratumor-clones-allelecn.pdf](profiles.png) +The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. +","Markdown" +"Allele","raphael-group/hatchet","examples/demo-WGS-sim/demo-wgs-sim.sh",".sh","9051","130","# Demo for standard WGS data +: ex: set ft=markdown ;:<<'```shell' # + +**NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. + +The following HATCHet's demo represents a guided example starting from WGS (whole-genome sequencing) data from 3 simulated samples obtained from the same tumor. This represents an exemplary case of executing HATCHet on a typical dataset with standard noise. For simplicity, the demo starts from a BB file `demo-WGS-sim.bb` (included in this demo at `examples/demo-WGS-sim/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. count-reads, count-alleles, and combine-counts) have already been executed by running standard configuration for WGS data (bin size of 50kb through -b 50kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 3 and 200 through `-c 3 -C 200`). + +Specifically, the tumor is composed of 2 tumor clones (clone0 and clone1) and a normal diploid clone (normal). The clonal composition of every sample is described in the following table: + +| Name | Proportion of normal clone | Proporion of clone0 | Proportion of clone1 | +|------|----------------------------|---------------------|----------------------| +| `bulk_035clone1_06clone0_005normal` | `5%` | `60%` | `35%` | +| `bulk_055clone1_04clone0_005normal` | `5%` | `40%` | `55%` | +| `bulk_08clone1_Noneclone0_02normal` | `20%` | Not present | `80%` | + +## Requirements and set up + +The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: + +```shell +PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` +:<<'```shell' # Ignore this line +``` + +The following paths are consequently obtained to point to the required components of HATCHet + +```shell +CLUSTERBINS=""${PY} -m hatchet cluster-bins"" +PLOTBINS=""${PY} -m hatchet plot-bins"" +INFER=""${PY} -m hatchet compute-cn"" +PLOTCN=""${PY} -m hatchet plot-cn"" +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Global clustering + +The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: + +```shell +${CLUSTERBINS} demo-wgs-sim.bb -o demo-wgs-sim.seg -O demo-wgs-sim.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 +:<<'```shell' # Ignore this line +``` + +To assess the quality of the clustering we generate the cluster plot using the `CBB` command of `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data. For simplicity, we also use the following options +- `--colwrap 3` allows to have the 3 plots of the 3 samples on the same figure row +- `-tS 0.01` asks to plot only the clusters which cover at least the `1%` of the genome. This is useful to clean the figure and focus on the main components. + +```shell +${PLOTBINS} -c CBB demo-wgs-sim.bbc --colwrap 3 -tS 0.01 +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![CBB](cbb.png) + +We can easily notice that the clustering is good and not tuning is needed as every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. + +## hatchet's step + +Next we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. +We apply the last step with default parameters and, for simplicity of this demo, we consider 8 clones, which can be easily considered by HATCHet in this case, and we only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. + +```shell +${INFER} -i demo-wgs-sim -n2,8 -p 100 -v 2 -u 0.03 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results: + + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 66.884758 - score: -0.17739731674 + ## Diploid with 3 clones - OBJ: 34.954154 - score: -0.0216588755513 + ## Diploid with 4 clones - OBJ: 17.510067 - score: 0.0555719383474 + ## Diploid with 5 clones - OBJ: 9.744628 - score: 0.186776250313 + ## Diploid with 6 clones - OBJ: 7.243104 - score: 0.0839737725603 + ## Diploid with 7 clones - OBJ: 5.991972 - score: 0.0538665194051 + ## Diploid with 8 clones - OBJ: 5.27972 - score: -0.181132288335 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 81.216417 - score: -0.415141225696 + ## Tetraploid with 3 clones - OBJ: 23.135209 - score: 0.169099207187 + ## Tetraploid with 4 clones - OBJ: 15.47975 - score: 0.0653131702741 + ## Tetraploid with 5 clones - OBJ: 11.36852 - score: 0.0682096876804 + ## Tetraploid with 6 clones - OBJ: 9.124625 - score: 0.0411292123085 + ## Tetraploid with 7 clones - OBJ: 7.698914 - score: 0.0753487410723 + ## Tetraploid with 8 clones - OBJ: 7.076072 - score: -0.219100018522 + # The chosen diploid solution has 5 clones with OBJ: 9.744628 and score: 0.186776250313 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 3 clones with OBJ: 23.135209 and score: 0.169099207187 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is tetraploid with 3 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet predicts the presence of 3 clones in the 3 tumor samples and, especially, predicts that 2 samples contains two distinct tumor clones, according to the true clonal composition. + +## Analyzing inferred results + +Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows + +```shell +${PLOTCN} best.bbc.ucn +exit $? +``` + +First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: + + ### SAMPLE: bulk_08clone1_Noneclone0_02normal -- PURITY: 0.799477 -- PLOIDY: 3.07107541299 -- CLASSIFICATION: TETRAPLOID + ### SAMPLE: bulk_035clone1_06clone0_005normal -- PURITY: 0.95065 -- PLOIDY: 3.37447061915 -- CLASSIFICATION: TETRAPLOID + ### SAMPLE: bulk_055clone1_04clone0_005normal -- PURITY: 0.95048 -- PLOIDY: 3.27575289096 -- CLASSIFICATION: TETRAPLOID + +Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly interesting. + +The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). +![intratumor-clones-totalcn.pdf](totalcn.png) +Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. + +The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. +![intratumor-clones-allelecn.pdf](allelecn.png) + +The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. +![intratumor-clones-allelecn.pdf](profiles.png) +The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. +","Shell" +"Allele","raphael-group/hatchet","examples/demo-complete/demo-complete.md",".md","6003","146","# Demo complete for the entire HATCHet pipeline + +: ex: set ft=markdown ;:<<'```shell' # + +The following HATCHet demo represents a guided example of the complete HATCHet pipeline starting from an exemplary dataset of tumour and matched normal +[BAM files](https://doi.org/10.5281/zenodo.4046906) publicly available. From this directory, simply run this file through BASH as a standard script to run +the complete demo. The demo can also be considered as a guided example of a complete execution and is correspondingly commented. + +## Requirements and set up + +The demo requires that HATCHet has been succesfully installed in the current python environment. +Please make sure that you can succesfully run the required dependencies `samtools`, `bcftools`, `tabix`, and `mosdepth`. +The demo includes the downloading of all the required files and will terminate in <20 minutes on machine with minimum requirements satisfied. + +We guarantee that the running directory in the same directory of the demo and we remove previous results. + +```shell +cd $( cd ""$(dirname ""$0"")"" >/dev/null 2>&1 ; pwd -P ) +rm -rf rdr/ baf/ snps/ bb/ bbc/ plots/ results/ summary/ +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Downloading of data + +The demo automatically downloads the required tumor and matched-normal BAM files in `data` folder. + +```shell +# Creating data folder +mkdir -p data + +# Downloading matched-normal BAM file +echo ""Downloading matched-normal BAM file from Zenodo, please be patient as downloading time may vary."" +curl -L 'https://zenodo.org/record/4046906/files/normal.bam?download=1' > data/normal.bam +curl -L 'https://zenodo.org/record/4046906/files/normal.bam.bai?download=1' > data/normal.bam.bai + +# Downloading BAM file of tumor sample 1 +echo ""Downloading BAM file of tumor sample 1 from Zenodo, please be patient as downloading time may vary."" +curl -L 'https://zenodo.org/record/4046906/files/bulk_03clone1_06clone0_01normal.sorted.bam?download=1' > data/bulk_03clone1_06clone0_01normal.sorted.bam +curl -L 'https://zenodo.org/record/4046906/files/bulk_03clone1_06clone0_01normal.sorted.bam.bai?download=1' > data/bulk_03clone1_06clone0_01normal.sorted.bam.bai + +# Downloading BAM file of tumor sample 2 +echo ""Downloading BAM file of tumor sample 2 from Zenodo, please be patient as downloading time may vary."" +curl -L 'https://zenodo.org/record/4046906/files/bulk_08clone1_Noneclone0_02normal.sorted.bam?download=1' > data/bulk_08clone1_Noneclone0_02normal.sorted.bam +curl -L 'https://zenodo.org/record/4046906/files/bulk_08clone1_Noneclone0_02normal.sorted.bam.bai?download=1' > data/bulk_08clone1_Noneclone0_02normal.sorted.bam.bai + +# Downloading BAM file of tumor sample 3 +echo ""Downloading BAM file of tumor sample 3 from Zenodo, please be patient as downloading time may vary."" +curl -L 'https://zenodo.org/record/4046906/files/bulk_Noneclone1_09clone0_01normal.sorted.bam?download=1' > data/bulk_Noneclone1_09clone0_01normal.sorted.bam +curl -L 'https://zenodo.org/record/4046906/files/bulk_Noneclone1_09clone0_01normal.sorted.bam.bai?download=1' > data/bulk_Noneclone1_09clone0_01normal.sorted.bam.bai +:<<'```shell' # Ignore this line +``` + +Next the corresponding reference genome is downloaded and unpacked + +```shell +echo ""Downloading human reference genome, please be patient as downloading time may vary."" +curl -L https://hgdownload.soe.ucsc.edu/goldenPath/hg19/bigZips/hg19.fa.gz | gzip -d > data/hg19.fa +samtools faidx data/hg19.fa +samtools dict data/hg19.fa > data/hg19.dict +:<<'```shell' # Ignore this line +``` + +## Configuring the HATCHet's execution + +We follow the template of the HATCHet's [script](../../doc/doc_fullpipeline.md#fullpipelineandtutorial). + +1. We specify the correct path to the reference genome and the output folder, and other required flags +```shell +echo '[run]' > hatchet.ini +echo 'genotype_snps=True' >> hatchet.ini +echo 'count_alleles=True' >> hatchet.ini +echo 'count_reads=True' >> hatchet.ini +echo 'combine_counts=True' >> hatchet.ini +echo 'cluster_bins=True' >> hatchet.ini +echo 'plot_bins=True' >> hatchet.ini +echo 'compute_cn=True' >> hatchet.ini +echo 'plot_cn=True' >> hatchet.ini +echo 'reference=data/hg19.fa' >> hatchet.ini +echo 'output=output/' >> hatchet.ini +j=$(grep -c ^processor /proc/cpuinfo) +processes=""processes=${j}"" +echo $processes >> hatchet.ini +echo 'chromosomes=""chr22""' >> hatchet.ini + +:<<'```shell' # Ignore this line +``` + +2. We specify the path to the matched-normal BAM files +```shell +echo 'normal=data/normal.bam' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +3. We specify the list of paths to the tumor BAM files and corresponding names +```shell +echo 'bams=data/bulk_03clone1_06clone0_01normal.sorted.bam data/bulk_08clone1_Noneclone0_02normal.sorted.bam data/bulk_Noneclone1_09clone0_01normal.sorted.bam' >> hatchet.ini +echo 'samples=TumorSample1 TumorSample2 TumorSample3' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +4. We specify the min/max coverage for the genotpe_snps step +```shell +echo '[genotype_snps]' >> hatchet.ini +echo 'mincov=8' >> hatchet.ini +echo 'maxcov=300' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +5. We specify the reference genome and chr notation +```shell +echo 'reference_version=hg19' >> hatchet.ini +echo 'chr_notation=True' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +6. We specify mincov/maxcov for the count_alleles step +```shell +echo '[count_alleles]' >> hatchet.ini +echo 'mincov=8' >> hatchet.ini +echo 'maxcov=300' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +7. We specify the minimum number of total and SNP-covering reads in each bin for the combine_counts step +```shell +echo '[combine_counts]' >> hatchet.ini +echo 'msr=3000' >> hatchet.ini +echo 'mtr=5000' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +## Running HATCHet + +```shell +python -m hatchet run hatchet.ini +exit $? +``` +","Markdown" +"Allele","raphael-group/hatchet","examples/demo-complete/demo-complete.sh",".sh","6003","146","# Demo complete for the entire HATCHet pipeline + +: ex: set ft=markdown ;:<<'```shell' # + +The following HATCHet demo represents a guided example of the complete HATCHet pipeline starting from an exemplary dataset of tumour and matched normal +[BAM files](https://doi.org/10.5281/zenodo.4046906) publicly available. From this directory, simply run this file through BASH as a standard script to run +the complete demo. The demo can also be considered as a guided example of a complete execution and is correspondingly commented. + +## Requirements and set up + +The demo requires that HATCHet has been succesfully installed in the current python environment. +Please make sure that you can succesfully run the required dependencies `samtools`, `bcftools`, `tabix`, and `mosdepth`. +The demo includes the downloading of all the required files and will terminate in <20 minutes on machine with minimum requirements satisfied. + +We guarantee that the running directory in the same directory of the demo and we remove previous results. + +```shell +cd $( cd ""$(dirname ""$0"")"" >/dev/null 2>&1 ; pwd -P ) +rm -rf rdr/ baf/ snps/ bb/ bbc/ plots/ results/ summary/ +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Downloading of data + +The demo automatically downloads the required tumor and matched-normal BAM files in `data` folder. + +```shell +# Creating data folder +mkdir -p data + +# Downloading matched-normal BAM file +echo ""Downloading matched-normal BAM file from Zenodo, please be patient as downloading time may vary."" +curl -L 'https://zenodo.org/record/4046906/files/normal.bam?download=1' > data/normal.bam +curl -L 'https://zenodo.org/record/4046906/files/normal.bam.bai?download=1' > data/normal.bam.bai + +# Downloading BAM file of tumor sample 1 +echo ""Downloading BAM file of tumor sample 1 from Zenodo, please be patient as downloading time may vary."" +curl -L 'https://zenodo.org/record/4046906/files/bulk_03clone1_06clone0_01normal.sorted.bam?download=1' > data/bulk_03clone1_06clone0_01normal.sorted.bam +curl -L 'https://zenodo.org/record/4046906/files/bulk_03clone1_06clone0_01normal.sorted.bam.bai?download=1' > data/bulk_03clone1_06clone0_01normal.sorted.bam.bai + +# Downloading BAM file of tumor sample 2 +echo ""Downloading BAM file of tumor sample 2 from Zenodo, please be patient as downloading time may vary."" +curl -L 'https://zenodo.org/record/4046906/files/bulk_08clone1_Noneclone0_02normal.sorted.bam?download=1' > data/bulk_08clone1_Noneclone0_02normal.sorted.bam +curl -L 'https://zenodo.org/record/4046906/files/bulk_08clone1_Noneclone0_02normal.sorted.bam.bai?download=1' > data/bulk_08clone1_Noneclone0_02normal.sorted.bam.bai + +# Downloading BAM file of tumor sample 3 +echo ""Downloading BAM file of tumor sample 3 from Zenodo, please be patient as downloading time may vary."" +curl -L 'https://zenodo.org/record/4046906/files/bulk_Noneclone1_09clone0_01normal.sorted.bam?download=1' > data/bulk_Noneclone1_09clone0_01normal.sorted.bam +curl -L 'https://zenodo.org/record/4046906/files/bulk_Noneclone1_09clone0_01normal.sorted.bam.bai?download=1' > data/bulk_Noneclone1_09clone0_01normal.sorted.bam.bai +:<<'```shell' # Ignore this line +``` + +Next the corresponding reference genome is downloaded and unpacked + +```shell +echo ""Downloading human reference genome, please be patient as downloading time may vary."" +curl -L https://hgdownload.soe.ucsc.edu/goldenPath/hg19/bigZips/hg19.fa.gz | gzip -d > data/hg19.fa +samtools faidx data/hg19.fa +samtools dict data/hg19.fa > data/hg19.dict +:<<'```shell' # Ignore this line +``` + +## Configuring the HATCHet's execution + +We follow the template of the HATCHet's [script](../../doc/doc_fullpipeline.md#fullpipelineandtutorial). + +1. We specify the correct path to the reference genome and the output folder, and other required flags +```shell +echo '[run]' > hatchet.ini +echo 'genotype_snps=True' >> hatchet.ini +echo 'count_alleles=True' >> hatchet.ini +echo 'count_reads=True' >> hatchet.ini +echo 'combine_counts=True' >> hatchet.ini +echo 'cluster_bins=True' >> hatchet.ini +echo 'plot_bins=True' >> hatchet.ini +echo 'compute_cn=True' >> hatchet.ini +echo 'plot_cn=True' >> hatchet.ini +echo 'reference=data/hg19.fa' >> hatchet.ini +echo 'output=output/' >> hatchet.ini +j=$(grep -c ^processor /proc/cpuinfo) +processes=""processes=${j}"" +echo $processes >> hatchet.ini +echo 'chromosomes=""chr22""' >> hatchet.ini + +:<<'```shell' # Ignore this line +``` + +2. We specify the path to the matched-normal BAM files +```shell +echo 'normal=data/normal.bam' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +3. We specify the list of paths to the tumor BAM files and corresponding names +```shell +echo 'bams=data/bulk_03clone1_06clone0_01normal.sorted.bam data/bulk_08clone1_Noneclone0_02normal.sorted.bam data/bulk_Noneclone1_09clone0_01normal.sorted.bam' >> hatchet.ini +echo 'samples=TumorSample1 TumorSample2 TumorSample3' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +4. We specify the min/max coverage for the genotpe_snps step +```shell +echo '[genotype_snps]' >> hatchet.ini +echo 'mincov=8' >> hatchet.ini +echo 'maxcov=300' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +5. We specify the reference genome and chr notation +```shell +echo 'reference_version=hg19' >> hatchet.ini +echo 'chr_notation=True' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +6. We specify mincov/maxcov for the count_alleles step +```shell +echo '[count_alleles]' >> hatchet.ini +echo 'mincov=8' >> hatchet.ini +echo 'maxcov=300' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +7. We specify the minimum number of total and SNP-covering reads in each bin for the combine_counts step +```shell +echo '[combine_counts]' >> hatchet.ini +echo 'msr=3000' >> hatchet.ini +echo 'mtr=5000' >> hatchet.ini +:<<'```shell' # Ignore this line +``` + +## Running HATCHet + +```shell +python -m hatchet run hatchet.ini +exit $? +``` +","Shell" +"Allele","raphael-group/hatchet","examples/demo-WGS-cancer/demo-wgs-cancer.md",".md","14175","172","# Demo for WGS data from a cancer patient +: ex: set ft=markdown ;:<<'```shell' # + +**NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. + +The following HATCHet's demo represents a guided example starting from WGS (whole-genome sequencing) data from 3 samples (A12-A, A12-C, and A12-D) of metastatic patient A12, previously published in (Gundem et al., Nature, 2015)). For simplicity, the demo starts from a BB file `demo-wgs-cancer.bb` (included in this demo at `examples/demo-WGS-cancer/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. `count-reads`, `count-alleles`, and `combine-counts`) have already been executed by running standard configuration for WGS data (bin size of 50kb through -b 50kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 3 and 200 through `-c 3 -C 200`). + +## Requirements and set up + +The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: + +```shell +PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` +:<<'```shell' # Ignore this line +``` + +The following paths are consequently obtained to point to the required components of HATCHet + +```shell +CLUSTERBINS=""${PY} -m hatchet cluster-bins"" +PLOTBINS=""${PY} -m hatchet plot-bins"" +INFER=""${PY} -m hatchet compute-cn"" +PLOTCN=""${PY} -m hatchet plot-cn"" +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Global clustering + +The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: + +```shell +${CLUSTERBINS} demo-wgs-cancer.bb -o demo-wgs-cancer.seg -O demo-wgs-cancer.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 +:<<'```shell' # Ignore this line +``` + +For different type of data it is essential to assess the quality of the clustering because this is performed by a Dirichlet process and it is affected by varying degrees of noise. To do this, we use `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data, and produce the cluster plot using the `CBB` command. To help we use the following options: +- `--xmin 0.5` and `--xmax 4` allow to zoom in and to focus the figure on the same RDR (x-axis) range for every sample. +- `--colwrap 3` allows to have the 3 plots of the 3 samples on the same figure row +- `-tS 0.005` asks to plot only the clusters which cover at least the `0.5%` of the genome. This is useful to clean the figure and focus on the main components. +To trace all steps, we also move the figure to `tR015-cbb.pdf`. + +```shell +${PLOTBINS} -c CBB demo-wgs-cancer.bbc --ymin 0.5 --ymax 4 --colwrap 3 -tS 0.005 +mv bb_clustered.png tR015-cbb.png +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![Bad clustering with default values](tR015-cbb.png) + +We can easily notice that the clustering is not ideal and is clearly overfitting the data by choosing too many distinct clusters; in fact we notice the presence of many different clusters that are extremely close and have identical BAF in every sample, e.g. light blue/dark blue/light orange/dark grey clusters or orange/purple clusters or pink/light gray clusters are always adjacent clusters which appear to be part of wider cluster. A good condition to assess the quality of the clustering is to assess that every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. + +Since Dirichlet clustering is not ad-hoc for this application, it can often result in overclustering. For this reason, cluster-bins additionally provides a procedure to merge clusters which are very likely to be part of a single cluster. However this procedure requires two maximum thresholds for doing this, one is the maximum shift for RDR (`-tR 0.15`) and one is the maximum shift for BAF (`-tB 0.03`). The default values allow to work with most of the datasets, however datasets of high variance require to tune these parameters. In our example, while the BAF of the clusters appears to be consistent with the default threshold, RDR appears to have much higher variance; in fact, the clusters that are always adjacent span much more than 0.15 of RDR in the x-axis. Therefore, by looking at the plot, we can see that a value of `-tR 0.5` fit much better the noise of RDR in our data and we repeat the clustering with this value. + +```shell +${CLUSTERBINS} demo-wgs-cancer.bb -o demo-wgs-cancer.seg -O demo-wgs-cancer.bbc -e 12 -tB 0.03 -tR 0.5 -d 0.08 +:<<'```shell' # Ignore this line +``` + +We assess again the clustering using `plot-bins` as before. + +```shell +${PLOTBINS} -c CBB demo-wgs-cancer.bbc --ymin 0.5 --ymax 4 --colwrap 3 -tS 0.008 +mv bb_clustered.png cbb.png +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![Better clustering with default values](tR05-cbb.png) + +In this clustering the previously-described condition is met and all the different clusters are clearly distinct in at least one sample. + +## hatchet's step + +In the last step we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. +We apply the last step with default parameters and, for simplicity of this demo, we apply only few changes: +- As the dataset has high variance and noise (see clustering), we consider a minimum clone proportion `-u` slightly higher than the default value, i.e. `10%`. We do this because we cannot infer tumor clones with very low proportions when there is high noise and because potential clones inferred with very low proportions may simply be the result of overfitting. In fact, when using values of `-u` smaller than `10%` we obtain solutions with clone proporions identical to the minimum value of `-u`; this is the recommended criterion to determine the need of increasing the value of `-u`. +- We limit the number of clones to 6 for simplicity of this demo and because it is a reasonable value for CNAs when consider only few samples from the same patient. +- We only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. + +```shell +${INFER} -i demo-wgs-cancer -n2,6 -p 100 -v 2 -u 0.1 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results: + + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 32.903145 - score: -0.320298393968 + ## Diploid with 3 clones - OBJ: 12.493377 - score: 0.0653576290862 + ## Diploid with 4 clones - OBJ: 7.063226 - score: 0.216430182885 + ## Diploid with 5 clones - OBJ: 5.521944 - score: 0.0291809338181 + ## Diploid with 6 clones - OBJ: 4.478124 - score: -0.11096874579 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 50.187684 - score: -0.351848788241 + ## Tetraploid with 3 clones - OBJ: 17.472903 - score: 0.0803178784888 + ## Tetraploid with 4 clones - OBJ: 10.139838 - score: 0.162808688228 + ## Tetraploid with 5 clones - OBJ: 7.535183 - score: 0.0254150864857 + ## Tetraploid with 6 clones - OBJ: 5.791102 - score: -0.0685416532021 + # The chosen diploid solution has 4 clones with OBJ: 7.063226 and score: 0.216430182885 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 4 clones with OBJ: 10.139838 and score: 0.162808688228 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is diploid with 4 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet predicts the presence of 4 clones in the 3 tumor samples and, especially, predicts that 2 samples (A12-C and A12-D) contains two distinct tumor clones. While HATCHet accurately recovers the major tumor clones distinguished by larger CNAs, HATCHet may miss small or minor CNAs, especially CNAs that are only present in a unique sample or in low proportions. Investigating the presence of unique or low proporions clones is particularly interesting in this patient because the high noise and variance make more difficult distinguishing variations in the clusters between those due to either noise or presence of different clones. To investigate the presence of minor or low-proportions clones, we re-run the `hatchet` step by increasing the sensitivity of HATCHet; we do this by decreasing the value of the limit `-l` from the default of `0.5` to `0.2`. Remember that the value that control the sensivity `-l` must be in `[0, 1]` and the default value is `0.5`; in particular, lower values incrase the sensitivty of HATCHet by exploring solutions with more clones and the presence of small CNAs, whereas higher values decrease the sensitivity. We thus re-run the `hatchet` step as follows: + +```shell +${INFER} -i demo-wgs-cancer -n2,6 -p 100 -v 2 -u 0.1 -r 12 -eD 6 -eT 12 -l 0.2 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results. + + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 32.903145 - score: -0.420298393968 + ## Diploid with 3 clones - OBJ: 12.493377 - score: -0.234642370914 + ## Diploid with 4 clones - OBJ: 7.063226 - score: -0.0182121880285 + ## Diploid with 5 clones - OBJ: 5.521944 - score: 0.0109687457895 + ## Diploid with 6 clones - OBJ: 4.478124 - score: -0.11096874579 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 50.187684 - score: -0.451848788241 + ## Tetraploid with 3 clones - OBJ: 17.472903 - score: -0.219682121511 + ## Tetraploid with 4 clones - OBJ: 10.139838 - score: -0.0568734332836 + ## Tetraploid with 5 clones - OBJ: 7.535183 - score: -0.0314583467979 + ## Tetraploid with 6 clones - OBJ: 5.791102 - score: -0.1 + # The chosen diploid solution has 5 clones with OBJ: 5.521944 and score: 0.0109687457895 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 5 clones with OBJ: 7.535183 and score: -0.0314583467979 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is diploid with 5 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet indeed finds an additional tumor clone which is unique to sample A12-D and has some small and specific CNAs which are only present in this sample. This conclude the inference and the final results containing clone and allele-specific copy numbers are available for every bin in `best.bbc.ucn` and for segments in a compact format in `best.seg.ucn`. + +## Analyzing inferred results + +Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows + +```shell +${PLOTCN} best.bbc.ucn +exit $? +``` + +First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: + + ### SAMPLE: A12-D -- PURITY: 0.820847 -- PLOIDY: 2.13676481963 -- CLASSIFICATION: DIPLOID + ### SAMPLE: A12-C -- PURITY: 0.771882 -- PLOIDY: 2.07266027371 -- CLASSIFICATION: DIPLOID + ### SAMPLE: A12-A -- PURITY: 0.779084 -- PLOIDY: 2.09771617784 -- CLASSIFICATION: DIPLOID + +Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly important. + +The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). +![intratumor-clones-totalcn.pdf](totalcn.png) +Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. + +The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. +![intratumor-clones-allelecn.pdf](allelecn.png) + +The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. +![intratumor-clones-allelecn.pdf](profiles.png) +The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. +","Markdown" +"Allele","raphael-group/hatchet","examples/demo-WGS-cancer/demo-wgs-cancer.sh",".sh","14175","172","# Demo for WGS data from a cancer patient +: ex: set ft=markdown ;:<<'```shell' # + +**NOTE**: this demo has not yet been updated for version 1.0 of HATCHet which includes variable-width binning, phasing, and locality-aware clustering. + +The following HATCHet's demo represents a guided example starting from WGS (whole-genome sequencing) data from 3 samples (A12-A, A12-C, and A12-D) of metastatic patient A12, previously published in (Gundem et al., Nature, 2015)). For simplicity, the demo starts from a BB file `demo-wgs-cancer.bb` (included in this demo at `examples/demo-WGS-cancer/`) which contains the RDR and BAF of every genomic bin and, therefore, we assume that the preliminary steps (i.e. `count-reads`, `count-alleles`, and `combine-counts`) have already been executed by running standard configuration for WGS data (bin size of 50kb through -b 50kb of count-reads, and the allele counts for germline heterozygous SNPs have been selected between 3 and 200 through `-c 3 -C 200`). + +## Requirements and set up + +The demo requires that HATCHet has been successfully compiled and all the dependencies are available and functional. As such, the demo requires the user to properly set up the following paths: + +```shell +PY=""python3"" # This id the full path to the version of PYTHON3 which contains the required `hatchet` module. When this corresponds to the standard version, the user can keep the given value of `python3` +:<<'```shell' # Ignore this line +``` + +The following paths are consequently obtained to point to the required components of HATCHet + +```shell +CLUSTERBINS=""${PY} -m hatchet cluster-bins"" +PLOTBINS=""${PY} -m hatchet plot-bins"" +INFER=""${PY} -m hatchet compute-cn"" +PLOTCN=""${PY} -m hatchet plot-cn"" +:<<'```shell' # Ignore this line +``` + +We also ask the demo to terminate in case of errors and to print a trace of the execution by the following commands +```shell +set -e +set -o xtrace +PS4='[\t]' +:<<'```shell' # Ignore this line +``` + +## Global clustering + +The first main step of the demo performs the global clustering of HATCHet where genomic bins which have the same copy-number state in every tumor clone are clustered correspondingly. To do this, we use `cluster-bins`, i.e. the HATCHet's component designed for this purpose. At first, we attempt to run the clustering using the default values of the parameters as follows: + +```shell +${CLUSTERBINS} demo-wgs-cancer.bb -o demo-wgs-cancer.seg -O demo-wgs-cancer.bbc -e 12 -tB 0.03 -tR 0.15 -d 0.08 +:<<'```shell' # Ignore this line +``` + +For different type of data it is essential to assess the quality of the clustering because this is performed by a Dirichlet process and it is affected by varying degrees of noise. To do this, we use `plot-bins`, i.e. the HATCHet's component designed for the analysis of the data, and produce the cluster plot using the `CBB` command. To help we use the following options: +- `--xmin 0.5` and `--xmax 4` allow to zoom in and to focus the figure on the same RDR (x-axis) range for every sample. +- `--colwrap 3` allows to have the 3 plots of the 3 samples on the same figure row +- `-tS 0.005` asks to plot only the clusters which cover at least the `0.5%` of the genome. This is useful to clean the figure and focus on the main components. +To trace all steps, we also move the figure to `tR015-cbb.pdf`. + +```shell +${PLOTBINS} -c CBB demo-wgs-cancer.bbc --ymin 0.5 --ymax 4 --colwrap 3 -tS 0.005 +mv bb_clustered.png tR015-cbb.png +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![Bad clustering with default values](tR015-cbb.png) + +We can easily notice that the clustering is not ideal and is clearly overfitting the data by choosing too many distinct clusters; in fact we notice the presence of many different clusters that are extremely close and have identical BAF in every sample, e.g. light blue/dark blue/light orange/dark grey clusters or orange/purple clusters or pink/light gray clusters are always adjacent clusters which appear to be part of wider cluster. A good condition to assess the quality of the clustering is to assess that every pair of clusters is clearly distinct in one of the two dimensions (RDR and BAF) in **at least one** sample. + +Since Dirichlet clustering is not ad-hoc for this application, it can often result in overclustering. For this reason, cluster-bins additionally provides a procedure to merge clusters which are very likely to be part of a single cluster. However this procedure requires two maximum thresholds for doing this, one is the maximum shift for RDR (`-tR 0.15`) and one is the maximum shift for BAF (`-tB 0.03`). The default values allow to work with most of the datasets, however datasets of high variance require to tune these parameters. In our example, while the BAF of the clusters appears to be consistent with the default threshold, RDR appears to have much higher variance; in fact, the clusters that are always adjacent span much more than 0.15 of RDR in the x-axis. Therefore, by looking at the plot, we can see that a value of `-tR 0.5` fit much better the noise of RDR in our data and we repeat the clustering with this value. + +```shell +${CLUSTERBINS} demo-wgs-cancer.bb -o demo-wgs-cancer.seg -O demo-wgs-cancer.bbc -e 12 -tB 0.03 -tR 0.5 -d 0.08 +:<<'```shell' # Ignore this line +``` + +We assess again the clustering using `plot-bins` as before. + +```shell +${PLOTBINS} -c CBB demo-wgs-cancer.bbc --ymin 0.5 --ymax 4 --colwrap 3 -tS 0.008 +mv bb_clustered.png cbb.png +:<<'```shell' # Ignore this line +``` + +We thus obtain the following clustering: + +![Better clustering with default values](tR05-cbb.png) + +In this clustering the previously-described condition is met and all the different clusters are clearly distinct in at least one sample. + +## hatchet's step + +In the last step we apply `hatchet`, i.e. the component of HATCHet which estimates fractional copy numbers, infers allele-and-clone specific copy numbers, and jointly predicts the number of clones (including the normal clone) and the presence of a WGD. +We apply the last step with default parameters and, for simplicity of this demo, we apply only few changes: +- As the dataset has high variance and noise (see clustering), we consider a minimum clone proportion `-u` slightly higher than the default value, i.e. `10%`. We do this because we cannot infer tumor clones with very low proportions when there is high noise and because potential clones inferred with very low proportions may simply be the result of overfitting. In fact, when using values of `-u` smaller than `10%` we obtain solutions with clone proporions identical to the minimum value of `-u`; this is the recommended criterion to determine the need of increasing the value of `-u`. +- We limit the number of clones to 6 for simplicity of this demo and because it is a reasonable value for CNAs when consider only few samples from the same patient. +- We only consider 100 restarts for the coordinate-descent method; these are the number of attempts to find the best solution. This number is sufficient in this small example but we reccommend to use at least 400 restarts in standard runs. + +```shell +${INFER} -i demo-wgs-cancer -n2,6 -p 100 -v 2 -u 0.1 -r 12 -eD 6 -eT 12 -l 0.5 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results: + + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 32.903145 - score: -0.320298393968 + ## Diploid with 3 clones - OBJ: 12.493377 - score: 0.0653576290862 + ## Diploid with 4 clones - OBJ: 7.063226 - score: 0.216430182885 + ## Diploid with 5 clones - OBJ: 5.521944 - score: 0.0291809338181 + ## Diploid with 6 clones - OBJ: 4.478124 - score: -0.11096874579 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 50.187684 - score: -0.351848788241 + ## Tetraploid with 3 clones - OBJ: 17.472903 - score: 0.0803178784888 + ## Tetraploid with 4 clones - OBJ: 10.139838 - score: 0.162808688228 + ## Tetraploid with 5 clones - OBJ: 7.535183 - score: 0.0254150864857 + ## Tetraploid with 6 clones - OBJ: 5.791102 - score: -0.0685416532021 + # The chosen diploid solution has 4 clones with OBJ: 7.063226 and score: 0.216430182885 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 4 clones with OBJ: 10.139838 and score: 0.162808688228 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is diploid with 4 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet predicts the presence of 4 clones in the 3 tumor samples and, especially, predicts that 2 samples (A12-C and A12-D) contains two distinct tumor clones. While HATCHet accurately recovers the major tumor clones distinguished by larger CNAs, HATCHet may miss small or minor CNAs, especially CNAs that are only present in a unique sample or in low proportions. Investigating the presence of unique or low proporions clones is particularly interesting in this patient because the high noise and variance make more difficult distinguishing variations in the clusters between those due to either noise or presence of different clones. To investigate the presence of minor or low-proportions clones, we re-run the `hatchet` step by increasing the sensitivity of HATCHet; we do this by decreasing the value of the limit `-l` from the default of `0.5` to `0.2`. Remember that the value that control the sensivity `-l` must be in `[0, 1]` and the default value is `0.5`; in particular, lower values incrase the sensitivty of HATCHet by exploring solutions with more clones and the presence of small CNAs, whereas higher values decrease the sensitivity. We thus re-run the `hatchet` step as follows: + +```shell +${INFER} -i demo-wgs-cancer -n2,6 -p 100 -v 2 -u 0.1 -r 12 -eD 6 -eT 12 -l 0.2 |& tee hatchet.log +:<<'```shell' # Ignore this line +``` + +We obtain the following summary of results. + + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 32.903145 - score: -0.420298393968 + ## Diploid with 3 clones - OBJ: 12.493377 - score: -0.234642370914 + ## Diploid with 4 clones - OBJ: 7.063226 - score: -0.0182121880285 + ## Diploid with 5 clones - OBJ: 5.521944 - score: 0.0109687457895 + ## Diploid with 6 clones - OBJ: 4.478124 - score: -0.11096874579 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 50.187684 - score: -0.451848788241 + ## Tetraploid with 3 clones - OBJ: 17.472903 - score: -0.219682121511 + ## Tetraploid with 4 clones - OBJ: 10.139838 - score: -0.0568734332836 + ## Tetraploid with 5 clones - OBJ: 7.535183 - score: -0.0314583467979 + ## Tetraploid with 6 clones - OBJ: 5.791102 - score: -0.1 + # The chosen diploid solution has 5 clones with OBJ: 5.521944 and score: 0.0109687457895 + ## The related-diploid resulting files are copied to ./chosen.diploid.bbc.ucn and ./chosen.diploid.seg.ucn + # The chosen tetraploid solution has 5 clones with OBJ: 7.535183 and score: -0.0314583467979 + ## The related-tetraploid resulting files are copied to ./chosen.tetraploid.bbc.ucn and ./chosen.tetraploid.seg.ucn + # The chosen solution is diploid with 5 clones and is written in ./best.bbc.ucn and ./best.seg.ucn + +HATCHet indeed finds an additional tumor clone which is unique to sample A12-D and has some small and specific CNAs which are only present in this sample. This conclude the inference and the final results containing clone and allele-specific copy numbers are available for every bin in `best.bbc.ucn` and for segments in a compact format in `best.seg.ucn`. + +## Analyzing inferred results + +Finally, we obtain useful plots to summarize and analyze the inferred results by using `plot-cn`, which is the last component of HATCHet. We run `plot-cn` as follows + +```shell +${PLOTCN} best.bbc.ucn +exit $? +``` + +First, `plot-cn` summarizes the values of tumor purity and tumor ploidy for every sample of the patient as follows: + + ### SAMPLE: A12-D -- PURITY: 0.820847 -- PLOIDY: 2.13676481963 -- CLASSIFICATION: DIPLOID + ### SAMPLE: A12-C -- PURITY: 0.771882 -- PLOIDY: 2.07266027371 -- CLASSIFICATION: DIPLOID + ### SAMPLE: A12-A -- PURITY: 0.779084 -- PLOIDY: 2.09771617784 -- CLASSIFICATION: DIPLOID + +Next, `plot-cn` produces some informative plots to evaluate the inferred results. Among all the plots, 3 of those are particularly important. + +The first `intratumor-clones-totalcn.pdf` represents the total-copy numbers for all tumor clones in fixed-size regions (obtained by merging neighboring genomic bins). +![intratumor-clones-totalcn.pdf](totalcn.png) +Every tumor clone is identified by a color and a dot is drawn for every genomic region (which are partitioned) for the corresponding total copy number. + +The second `intratumor-clones-allelecn.pdf` similarly represents the allele-specific copy numbers (split between the bottom and top regions of the figure) as the plot above. +![intratumor-clones-allelecn.pdf](allelecn.png) + +The third `intratumor-profiles.pdf` represents both the clone proportions and the total copy numbers of every clone in genomic regions. +![intratumor-clones-allelecn.pdf](profiles.png) +The main heatmap in the right side of the figure represent the total copy number of every clone (i.e. a row) for every genomic region (which are partition into chromosomes as described at the top of the heatmap) such that grey color indicate regions with base copy number not affected by CNAs (but they can be affected by a WGD when this occurrs), blue colors indicates deletions, and red colors indicate amplifications; in general, the stronger the color the smaller/higher the corresponding aberration. The smaller heatmap in the left side describes the clone proportion of each clone in each sample such that the lightest color correspond to absence while darker colors indicate higher clone proportions. Last, in the left-most part there is a dendogram which hierarchically clusters the tumor clones based on similiraity. +","Shell" +"Allele","raphael-group/hatchet","docs/buildDocs.sh",".sh","1230","47","#!/bin/bash + +# Adapted from: +# https://tech.michaelaltfield.net/2020/07/18/sphinx-rtd-github-pages-1/ + +set -x +pwd +ls -lah +export SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct) + +####################### +# Update GitHub Pages # +####################### + +git config --global user.name ""${GITHUB_ACTOR}"" +git config --global user.email ""${GITHUB_ACTOR}@users.noreply.github.com"" + +docroot=`mktemp -d` +rsync -av ""docs/build/html/"" ""${docroot}/"" + +pushd ""${docroot}"" + +# don't bother maintaining history; just generate fresh +git init +git remote add deploy ""https://token:${GITHUB_TOKEN}@github.com/${GITHUB_REPOSITORY}.git"" +git checkout -b gh-pages + +# Add README +cat > README.md <= 4.8.1, or Clang). +As long as you have a recent version of GCC or Clang installed, `setuptools` should automatically be able to download a +recent version of `cmake` and compile the Hatchet code into a working package. + +The installation process can be broken down into the following steps: + +1. **Get [Gurobi](http://www.gurobi.com/)** (v9.0.2) + + The coordinate-method applied by HATCHet is based on several integer linear programming (ILP) formulations. Gurobi is a commercial ILP solver with two licensing options: (1) a single-host license where the license is tied to a single computer and (2) a network license for use in a compute cluster (using a license server in the cluster). Both options are freely and [easily available](http://www.gurobi.com/academia/academia-center) for users in academia. +[Download](https://www.gurobi.com/downloads/gurobi-optimizer-eula) Gurobi for your specific platform. + + +2. **Set GUROBI_HOME environment variable** + ```shell + $ export GUROBI_HOME=/path/to/gurobi902 + ``` + Set `GUROBI_HOME` to where you download Gurobi. Here `XXX` is the 3-digit version of gurobi. + + +3. **Build Gurobi** + ```shell + $ cd ""${GUROBI_HOME}"" + $ cd linux64/src/build/ + $ make + $ cp libgurobi_c++.a ../../lib + ``` + Substitute `mac64` for `linux64` if using the Mac OSX platform. + + +4. **Create a new venv/conda environment for Hatchet** + + `Hatchet` is a Python 3 package. Unless you want to compile/install it in your default Python 3 environment, you will +want to create either a new Conda environment for Python 3 and activate it: + ``` + conda create --name hatchet python=3.8 + conda activate hatchet + ``` + or use `virtualenv` through `pip`: + ``` + python3 -m pip virtualenv env + source env/bin/activate + ``` + + +5. **Install basic packages** + + It is **highly recommended** that you upgrade your `pip` and `setuptools` versions to the latest, using: + ```shell + pip install -U pip + pip install -U setuptools + ``` + + +6. **Build and install HATCHet** + + Execute the following commands from the root of HATCHet's repository. + ```shell + $ pip install . + ``` + + **NOTE**: If you experience a failure of compilation with an error message like: + ``` + _undefined reference to symbol 'pthread_create@@GLIBC_2.2.5'_. + ``` + + you may need to set `CXXFLAGS` to `-pthread` before invoking the command: + ```shell + $ CXXFLAGS=-pthread pip install . + ``` + + When the compilation process fails or when the environment has special requirements, you may have to manually specify the required paths to Gurobi by following the [detailed intructions](doc_compilation.md). + + +7. **Install required utilities** + + For reading BAM files, read counting, allele counting, and SNP calling, you need to install [SAMtools, BCFtools, and tabix](http://www.htslib.org/doc/) as well as [mosdepth](https://github.com/brentp/mosdepth). + If you want to perform reference-based phasing, you must also install [shapeit](https://mathgen.stats.ox.ac.uk/genetics_software/shapeit/shapeit.html), [picard](https://broadinstitute.github.io/picard/), and [bgzip](http://www.htslib.org/doc/). The easiest way to install these is via `conda`, as all are available from the `bioconda` channel (except `shapeit` which is available from channel `dranew`). + + +#### Compiling HATCHet *without* the built-in Gurobi optimizer + + +If you wish to use an alternate ILP optimizer, then you do not need a C++ compiler. + +In this case, set the `HATCHET_BUILD_NOEXT` environment variable to `1` (using `export HATCHET_BUILD_NOEXT=1`), +set the environment variable `HATCHET_COMPUTE_CN_SOLVER` to a Pyomo-supported solver (see the +[Using a different Pyomo-supported solver](README.html#usingasolver_other) section of the README for more details) +and proceed directly to step (4) above. +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_phase_snps.md",".md","3978","46","# phase-snps + +**Note:** To run this step, you must first run [*download-panel*](doc_download_panel.html) to download the reference-based phasing panel, and specify its location via the argument `-D, --refpaneldir`. The `download-panel` command only needs to be run once per system. + +This step of HATCHet phases genotypes found in VCF files. It automatically takes care of differences in coordinates if the user has aligned their reads to a version of the reference genome (e.g. hg38) that is different from the version used in the reference panel (e.g. hg19 for the 1000 genomes project), using the liftover utility within Picard. Once genotypes are lifted over and phased, we again perform one last liftover to the coordinates of the genome used for alignment. Liftover is skipped if the version of the reference genome used for alignments corresponds to the same version used in the reference panel. Lastly, in order to account for differences in naming conventions for chromosomes, with or without the ""chr"" prefix, we also add or remove these prefixes so that chromosome names correspond to those used in the reference panel (without ""chr"" for the 1000 genomes project hg19 panel). + +## Input + +`phase-snps` takes one or more VCF files containing heterozygous SNP positions as input, specified using `-L, --snps`. These are typically produced by [`genotype_snps`](doc_genotype_snps.md). + +The following parameters are required to specify and describe the input data: + +| Name | Description | Usage | +|------|-------------|-------| +| `-L`, `--snps` | A list of VCF files to phase, one per chromosome | Specify a list using a path along with a wildcard, e.g. /path/to/snps/*.vcf.gz | +| `-D`, `--refpaneldir` | Path to the Reference Panel | This is the location where the 1000 genome project reference panel will be downloaded | +| `-g`, `--refgenome` | Path to the reference genome used to align reads | Path should include the filename | +| `-V`, `--refversion` | Version of reference genome used to align reads | Specify the human reference genome used for aligning reads; hg19 or hg38 | +| `-N`, `--chrnotation` | Chromosome names contain ""chr"" (e.g., ""chr1"" instead of ""1"") | Set this flag if and only if your BAM files/reference genome include ""chr"" in chromosome names | +| `-o`, `--outdir` | Output folder for phased VCFs | Specify a path or relative path | + +## Output + +The following files will be placed in the directory indicated by `-o, --outdir`: + +| Name | Description | +|------|-------------| +| phased.vcf.gz | VCF file containing phased genotypes for all chromosomes | +| phased.log | Table showing how many SNPs were present before and after phasing; SNPs may be lost in the process due to various reasons, e.g. they were not present in the reference panel so there is no information to phase them | +| *_alignments.log | Log files from the shapeit phasing program, one per chromosome | + +## Main Parameters + +If HATCHet is installed via `conda`, the dependencies (`shapeit`, `picard`, `bcftools`, and `bgzip`) should be installed automatically and available on the PATH. +You can verify that these dependencies are available by running [the check command](doc_check.md), i.e., `hatchet check`. + + If HATCHet is installed from source, you may need to install them youself (i.e., via `conda` or from source) and/or specify their locations using the following arguments: + +| Name | Description | Usage | +|------|-------------|-------| +| `-j`, `--processes` | Number of parallel jobs | Parallel jobs independently phase VCF files, which are split up by chromosome | +| `-si`, `--shapeit` | Path to the `shapeit` executable | `shapeit` is required to run this command | +| `-pc`, `--picard` | Path to the `picard` executable or JAR file | `picard` is required to run this command | +| `-bt`, `--bcftools` | Path to the `bcftools` executable | `bcftools` is required to run this command | +| `-bg`, `--bgzip` | Path to the `bgzip` executable | `bgzip` is required to run this command | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/recommendation_runtime.md",".md","637","8","# Improve running time + +This section includes a collection of several tips for improving the overall running time. + +## 1. SNP calling from known database + +HATCHet allows to provide to count-alleles a list of known germline SNPs. This allows to significantly improve the performance. However, running count-alleles without this list (as by default behaviour) results in count-alleles calling germline SNPs along the whole genome and identifying more SNPs (especially including private and rare germline SNPs), which could result in a higher total number of SNPs improving quality of BAF estimations. The user can consider this trade-off. +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_plot_bins_1d2d.md",".md","3194","55","# plot-bins-1d2d + +This step produces alternate plots that show bins in terms of their computed read-depth ratios (RDR), B-allele frequencies (BAF), and cluster assignments. +These plots show bins colored by cluster, where the color is consistent between the ""2D"" (RDR x BAF) view and the ""1D"" (genomic location x RDR/BAF) view. +These plots should be used to review the clustering and tune clustering parameters. + +When `plot_bins = True` is indicated in `hatchet.ini`, both this command and the command [plot-bins](doc_plot_bins.md) will be run. + +---------------------- + +## Input + +plot-bins considers two different inputs which are tab-separated files, one is mandatory and the other is optional (required to show cluster centers): + +1. A file of clustered genomic bins, specified with the flag `-b, --bbc` and with the following fields. + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `RD` | RDR of the bin in `SAMPLE` | +| `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | +| `COV` | Average coverage in the bin in `SAMPLE` | +| `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | +| `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | +| `BAF` | BAF of the bin in `SAMPLE` | +| `CLUSTER` | The name of the corresponding cluster of the bin in `SAMPLE` | + +2. A file of clusters, which is required only by commands and it is specified through the flag `-s`, `--segfile`. The file has the following fields. + +| Field | Description | +|-------|-------------| +| `ID` | The name of a cluster | +| `SAMPLE` | The name of a sample | +| `#BINS` | The number of bins included in `ID` | +| `RD` | The RDR of the cluster `ID` in `SAMPLE` | +| `#SNPS` | The total number of SNPs in the cluster `ID` | +| `COV` | The average coverage in the cluster `ID` | +| `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | +| `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | +| `BAF` | The BAF of the cluster `ID` in `SAMPLE` | + +## Parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-O`, `--outdir` | Output directory | Directory in which output plots will be stored | """" (current directory) | +| `--baflim` | Axis limits for mirrored BAF | Specify limits as comma-separated values, e.g., '0,0.51' | None (determined by extremes of data) | +| `--rdrlim` | Axis limits for read-depth ratio | Specify limits as comma-separated values, e.g., '0,3' | None (determined by extremes of data) | +| `--centers` | Show cluster centers | Requires SEG file provided via `-s, --seg`. Enable by including this flag. | False | +| `--centromeres` | Mark centromere locations with grey rectangles | Enable by including this flag. | False | +| `-a, --alpha` | Opacity value for scatterplots | Valid values are (0, 1]. Smaller values make points more transparent. | 1 | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/recommendation_inference.md",".md","18276","127","# Analyze HATCHet's inference + +The main component of HATCHet ([compute-cn](doc_compute_cn.md) step) performs three major tasks: (1) explicit estimation of fractional copy numbers, (2) inference of allele and clone-specific copy numbers, and (3) joint prediction of number of clones and whole-genome duplication. In the following, we guide the user in the interpration of HATCHet's inference, we explain how to perform quality control to guarantee the best-quality results, and we describe how the user can control and tune some of the parameters to obtain the best-fitting results. In fact, it is important to assess the quality of the results from each of these steps to guarantee the best-quality results, especially when considering datasets with high noise or special features. + +1. [Estimation of fractional copy numbers](#estimation) +2. [Inference of allele and clone-specific copy numbers](#inference) +3. [Joint selection of number of clones and whole-genome duplication](#joint) +4. [Quality control and suspicious cases](#quality) + +## 1. Estimation of fractional copy numbers + + +HATCHet estimates the fractional copy numbers for all segments by identifying 1 or 2 tumor clonal clusters (i.e, a cluster which have the same CNA in all tumor clones). First, HATCHet selects only some of the clusters as potential clonal clusters and, next, it aims to find consistent combinations of clonal clusters. + +#### Selecting potential clonal clusters + +HATCHet selects potential clonal clusters as sufficiently large clusters; the list of the selected clusters is reported in the LOG of the `HATCHet` step starting with line `# Selected clusters`. This list reports the cluster size and the corresponding pairs of values (RDR, BAF) in each sample (alphabetically sorted) and, therefore, can be easily used to map these clusters to the `bb_clustered.pdf` figure generated by the command `CBB` of `plot-bins` or the `plot-bins-1d2d` command. For example, we have the following: + + # Selected clusters: 11, 10, 12, 15, 21, 22, 23 + ## Features of selected clusters: + ## 11: SIZE= 169350000.0 #CHRS= 6 (RDR, BAF)= (0.98300155842, 0.0717476641159)-(0.70901452517, 0.0218274427111)-(0.793836783391, 0.0201025034921) + ## 10: SIZE= 31250000.0 #CHRS= 2 (RDR, BAF)= (1.26230102783, 0.5)-(0.993581127953, 0.39042851007)-(1.08735153846, 0.411521706019) + ## 12: SIZE= 187400000.0 #CHRS= 8 (RDR, BAF)= (1.54296926478, 0.399215013858)-(1.28029494725, 0.494771052557)-(1.38353348068, 0.415539785049) + ## 15: SIZE= 57450000.0 #CHRS= 2 (RDR, BAF)= (0.70122709154, 0.406572560257)-(0.96296886062, 0.419918229626)-(0.869811018537, 0.415889001548) + ## 21: SIZE= 73000000.0 #CHRS= 1 (RDR, BAF)= (0.982893169988, 0.350795164506)-(0.88867098782, 0.410185588799)-(0.917182445956, 0.415596024012) + ## 22: SIZE= 71600000.0 #CHRS= 1 (RDR, BAF)= (0.982359985531, 0.350709236531)-(1.2496122809, 0.497653731887)-(1.16543827292, 0.496215824202) + ## 23: SIZE= 106150000.0 #CHRS= 10 (RDR, BAF)= (0.701788866503, 0.100467817792)-(0.602518459603, 0.0254102909342)-(0.621971921092, 0.0253841073015) + +The size of the clusters that are considered is defined by the parameter `-ts` which defines the minimum fraction of the genome that needs to be covered by a potential clonal cluster. To deal with special or noisy datasets, the user can either decrease the value of this threshold (e.g. `-ts 0.001`, 0.1% fraction of the genome) to include clusters which have been erroneously excluded or increase the value of this threshold (e.g. `-ts 0.03`, 3% fraction of the genome) to exclude noisy clusters. Including all the most significant clusters is crucial to guarantee a correct identification of the clonal clusters and their copy numbers. For example, assume to have the following clusters: + + ## 0: SIZE= 498 #CHRS= 22 (RDR, BAF)= (1.0, 0.5) + ## 1: SIZE= 497 #CHRS= 22 (RDR, BAF)= (0.7, 0.25) + ## 2: SIZE= 5 #CHRS= 10 (RDR, BAF)= (1.0, 0.00) + +When using the default value of `-ts 0.008`, the cluster `2` will be excluded as it is covering a fraction of the genome smaller than the given threshold; as a consequence, the other cluster `1` appears to be the one with maximum shift of BAF and, therefore, with a copy-number state equal for example to (2, 0) (i.e. a loss-of-heterozygosity, LOH). However, assuming `2` is not due to noise but is providing true information, `2` should be the one with maximum shift of BAF and with a state (2, 0) corresponding to a LOH. Therefore, the user should identify the absence of cluster `2` by using the `bb_clustered.pdf` figure generated by command CBB of `plot-bins` and use a lower threshold `-ts 0.005` to include it. + +#### Identifying combinations of clonal clusters + +HATCHet chooses the largest combination of consistent clonal clusters to obtain the needed clonal cluster and to estimate the fractional copy numbers, when assuming the occurrence of a WGD. The combinations considered by HATCHet are reported in the LOG of the `HATCHet` step, after the inferences with the absence of a WGD (`# Running diploid`) and starting with line `# Finding clonal clusters and their copy numbers`. Each combination (also called pattern) is reported by first specifying the total size of the involved clusters and next the copy number state of each cluster. For example, we have the following: + + # Finding clonal clusters and their copy numbers + ## Found pattern of size 1080892751.0: {'8': (2, 1), '28': (3, 2), '50': (2, 2), '29': (4, 2), '23': (2, 0)} + ## Found pattern of size 906528933.0: {'60': (2, 1), '12': (3, 2), '50': (2, 2)} + ## Found pattern of size 712147541.0: {'11': (2, 0), '50': (2, 2)} + ## Found pattern of size 835497541.0: {'23': (2, 0), '28': (3, 2), '50': (2, 2), '29': (4, 2), '21': (2, 1)} + ## Found pattern of size 886592751.0: {'8': (2, 0), '28': (4, 2), '50': (2, 2)} + ## Chosen pattern of size 1080892751.0: {'8': (2, 1), '28': (3, 2), '50': (2, 2), '29': (4, 2), '23': (2, 0)} + +There are two parameters which control the identification of these patterns, which are `-tR`, i.e. RDR threshold, and `-tB`, i.e. BAF threshold. These thresholds are considered as the maximum allowed errors when estimating the clonal clusters. As such, the user can either decrease the thresholds (e.g. `-ts 0.03` and `-ts 0.02`) to consider more stringent constraints especially in low-noise datasets where subclonality can be accurately identified, or increase the thresholds (e.g. `-ts 0.15` and `-ts 0.05`) to accomodate the higher noise in certain datasets. The user can use the `bb_clustered.pdf` figure produced by the command `CBB` of `plot-bins` to assess the identified clonal cluster. For example, in the following case + + ## 0: SIZE= 498 #CHRS= 22 (RDR, BAF)= (1.0, 0.5) + ## 1: SIZE= 497 #CHRS= 22 (RDR, BAF)= (0.7, 0.25) + ## 2: SIZE= 5 #CHRS= 10 (RDR, BAF)= (1.0, 0.00) + +The users can easily see that the following pattern would be suspicious and wrong: + + ## Chosen pattern of size 995: {`0` : (2, 2), `1` : (2, 0)} + +because in the `bb_clustered.pdf` figure there is another clear cluster `2` which have a significantly higher shift in the BAF and, therefore, `1` cannot have a state `(2, 0)` which would correspond to the highest shift of BAF. + +## 2. Inference of allele and clone-specific copy numbers + + +HATCHet infers allele and clone-specific copy numbers by first assuming the absence of a WGD (`# Running diploid`) and, next, by assuming the presence of a WGD (`# Running tetraploid`). In each of the two cases, HATCHet considers an increasing number of clones (including the normal diploid clone). Typically, the interval starts from 2 (i.e. 1 tumor clone) up to 6-8 clones which is the typical maximum number of clones in terms of CNAs; however, the user can consider larger numbers, especially when suspecting the presence of more clones, by controlling the parameter `-n`, e.g. typical intervals are `-n 2,6`, `-n 2,8`, `-n 2,10`, `-n 2,12`, ... + +#### Maximum copy numbers and minimum clone proportion + +For each assumpotion and number of clones, HATCHet infers allele and clone-specific copy-numbers by using two main parameters, the *maximum copy numbers (`-eD` and `-eT`)* and the *minimum clone proportion (`-u`)*. These parameters are very important to constrain the solution space depending on the needs of the user, in particular the minimum clone proportion `-u` is particularly important to deal with noisy datasets and we reccomend the user to follow the criterion described here below: +- **Maximum copy numbers (`-eD` and `-eT`)**: these values define the maximum value of the total copy number when assuming the absence of a WGD (`-eD`) and the presence of a WGD (`-eT`). By default the value of these parameters is `0` meaning that these values are inferred from the estimated fractional copy numbers. However, we recommend the user to try to use common values, especially in the first attempts, (e.g. 5, 6, 8 for `-eD` and 8, 10, 12 for `eT`) to constraint the searching space and avoid that noisy clusters introduce outlying values. +- **Minimum clone proportion `-u`**: this value defines the minimum clone proportion for the inferred tumor clones. Default values are pretty small, e.g. 0.03 or 0.05, and allow to infer tumor clones present in small proportions. However, the power of the inference and the capability of inferring tumor clones with small proportions strongly depend on the noise of the data. As such, especially for noisy and special datasets it is very important that the user considers higher values when possible, e.g. 0.1-0.15. We reccomend to consider the following criterion to avoid overfitting and find the best fitting value for `-u`: **start from very small minimum clone proprtions and increase the value whenever the inferred solutions contain clones with clone proportions equal to this threshold**. + +## 3. Joint selection of number of clones and whole-genome duplication + + +For each number of clones N, the related copy numbers are computed by HATCHet and placed in two output files: +- A `BBC-UCN` file which adds to the input `BBC` file the copy-number state and proportion inferred for each clone (the normal clone is always the first). The file is named `results.diploid.nN.bbc.ucn.tsv` or `results.tetraploid.nN.bbc.ucn.tsv` for the solutions obtained when considering the absence or presence of a WGD, respectively. +- A `SEG-UCN` file which combines neighboring bins with the same copy-number states into segments and for each segment it reports the copy-number state and proportion of each clone. The file is named `results.diploid.nN.seg.ucn.tsv` or `results.tetraploid.nN.seg.ucn.tsv` for the solutions obtained when considering the absence or presence of a WGD, respectively. + +HATCHet selects the best solution under each of the two assumptions through a model selection criterion; as such, it copies the best diploid solutions to the files `chosen.diploid.bbc.ucn` and `chosen.diploid.seg.ucn`, and the best tetraploid solution to the two files `chosen.tetraploid.bbc.ucn` and `chosen.tetraploid.seg.ucn`. Each choice is based on the value of an elbow function (called `score`) computed for each number of clones. This value approximates the second derivative of the factorization objective function (called `OBJ`) and the choice is based on the maximum score; as such **the best number of clones is chosen as the number which significantly improves the objective function with respect to lower number of clones but no significant subsequent improvements are observed with increasing number of clones**. All these values are summarized in the LOG of the HATCHet step by firts summarizing the values for diploid solutions and next those of tetraploid solutions, e.g. + + ## Scores approximating second derivative for diploid results + ## Diploid with 2 clones - OBJ: 66.804147 - score: -0.176997273837 + ## Diploid with 3 clones - OBJ: 34.938751 - score: -0.020688175766 + ## Diploid with 4 clones - OBJ: 17.550243 - score: 0.0543991087813 + ## Diploid with 5 clones - OBJ: 9.77046 - score: 0.203750740655 + ## Diploid with 6 clones - OBJ: 7.430087 - score: 0.0541415395045 + ## Diploid with 7 clones - OBJ: 6.052593 - score: 0.0380373822927 + ## Diploid with 8 clones - OBJ: 5.160703 - score: -0.152643321631 + ## Scores approximating second derivative for tetraploid results + ## Tetraploid with 2 clones - OBJ: 81.064423 - score: -0.414934454045 + ## Tetraploid with 3 clones - OBJ: 23.108674 - score: 0.172765083795 + ## Tetraploid with 4 clones - OBJ: 15.546709 - score: 0.103011062784 + ## Tetraploid with 5 clones - OBJ: 12.060766 - score: 0.023008690139 + ## Tetraploid with 6 clones - OBJ: 9.633957 - score: 0.0339979959232 + ## Tetraploid with 7 clones - OBJ: 8.022994 - score: 0.104757566866 + ## Tetraploid with 8 clones - OBJ: 7.521881 - score: -0.237540399507 + +The user should analyze the scores as HATCHet provides the following two parameters (controlling different hypotheses) to investigate alternative solutions with also high scores: +- **Sensitivity to small CNAs `-l`**: this parameter controls the sensitivity of HATCHet to small CNAs, whose typical values are 0.5-0.6. The user should decrease this value, e.g. 0.2-0.3, to investigate solutions with more clones and smaller CNAs, while it should increase the value, e.g. 1.0-1.5, to give more confidence to large CNAs and less to small CNAs. +- **Confidence in a single tumor clone `-g`**: this parameter controls the confidence in the presence of a single tumor clone, whose typical values are 0.2-0.3. The user should increase the value to increase the confidence, e.g. 0.4-0.5, in the presence of a single tumor clone, while lower values, e.g. 0.0-0.1, decrease the confidenze and favor the presence of more clones. The value should be increase especially in 2 cases: (1) when the score of 2 clones is particularly high with or without a WGD (e.g. a value close to 0.0), and especially (2) when the score of 2 clones is significantly higher with a WGD than the score of 2 clones without a WGD; the latter may indeed indicate the presence of a single tetraploid clone. + +The final best solution, according to prediction of the presence or absence of a WGD, is made based on a trade-off between the number of clones and WGD; more specifically, the diploid solution is chosen when it has the same or lower number of clones than the tetraploid solution, otherwise the tetraploid solution is chosen. + +## 4. Quality control and suspicious cases + + +It is very important that the user verifies the results in different steps to guarantee the best-quality results, more specifically: +- User can assess the validity of the chosen clonal cluster using the `bb_clustered.pdf` figure produced by the command `CBB` of `plot-bins` and comparing the list of selected potential clonal clusters. +- User can assess the inferred copy numbers by analyzing the inferred maximum values and the inferred clone proportions which define the tumor clonal composition. +- User can assess the joint inference of number of clones and WGD by analyzing the values of the objective function and the related scores. + +There are some typical suspicious and warning cases that the user can identify from the analysis of the LOG of the `HATCHet` step: +- Many diploid solutions have high scores. +- Objective function of tetraploid solutions (i.e. with WGD) does not almost decrease/vary when increasing the number of clones. Even if this can occur because a single tetraploid tumor clone is present, this typically occurrs when the heuristic of HATCHet failed to identify a correct clonal cluster. This case is even more suspicious when the chosen number of diploid clones is much higher or when the objective function of tetraploid solutions is hugely higher that those of diploid solutions. +- Inferred clone proportions are identical to the minimum clone proportion `-u` and tumor clones are present in all samples with very small proportions. Also, higher maximum copy numbers are needed when these result in much lower objective functions. +- Huge difference between the number of clones inferred with and without a WGD, especially when the chosen diploid solution has a much lower number of clones than the chosen tetraploid solution. +- Objective function that keeps decreasing significantly and objective function with very small values. +- Score of 2 clones with a WGD is much higher then score of 2 clones without a WGD. This typically requires to increase the single-clone confidence of HATCHet `-g` to investigate the presence of a single tumor clone. + +The user can consider the following parameters to investigate alternative solutions and better fitting: +- Sensitivity `-l` controls how much the variance of data and clusters influence the choice of the number of clones. The user should **increase the sensitivity (by decreasing the value of `-l` to 0.4, or 0.45, 0.5, or 0.3) when having high-purity or low variance samples** to better investigate multiple solutions, especially when there are multiple solutions with higher scores (and especially when there are many diploid solutions with high scores) and when considering small CNAs. Conversely, the user should **decrease the sensitivity (by increasing -l to 0.6, 0.8, 1.0)** when considering low-purity or high-variance samples. +- Minimum clone proportion `-u`, we suggest to increase this value whenever obtaing solutions with clone proportions idetical to `-u` or clones present in all samples with very small proportions. +- Maximum copy numbers, both standard values and those inferred from fractional copy numbers (by providing `-eD 0 -eT 0`) should be investigated. +- `-g` controls the confidence in the presence of a single tumor clone. +- Higher values of `-tR` and `-tR` allow to increase the thresholds for the inferred clonal clusters in case of high noise in the data, while lower values allow to decrease error in case of low noise data. +- `-ts` determines a thresholds for the clusters to consider as potential clonal clusters, higher values allow to improve accuracy while lower values include more information especially when small CNAs are present. +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_count_alleles.md",".md","5587","64","# count-alleles + +Given one or more BAM files and lists of heterozygous SNP positions, this step of HATCHet counts the number of reads covering both the alleles of each identified heterozgyous SNP in every tumor sample. + +## Input + +count-alleles takes in input sorted and indexed BAM files for multiple tumor samples from the same patient, a sorted and index BAM file from a matched-normal sample, and a indexed human reference genome. + +| Name | Description | Usage | +|------|-------------|-------| +| `-T`, `--tumors` | A white-space separated list of sorted-indexed BAM files | The tumor samples from the same patient that are jointly analyzed by HATCHet | +| `-N`, `--normal` | A sorted-indexed BAM file | The matched normal sample for the same patient | +| `-L`, `--snps` | VCF files | One or more files listing heterozygous SNP positions | +| `-r`, `--reference` | A FASTA file | The human reference genome used for germline variant calling | + +## Output + +count-alleles produces three tab-separated files: the first contains the read counts for every genomic bin in every tumor sample, the second contains the read counts for every genomic bin the matched-normal sample, and the third contains a list of the genomic positions that have been identified as germline heterozygous SNPs in the matched-normal sample. + +| Name | Description | Format | +|------|-------------|--------| +| `-O`, `--outputnormal` | The output file for the read counts from matched-normal sample | `#SAMPLE CHR POS REF_COUNT ALT_COUNT` | +| `-o`, `--outputtumors` | The output file for the read counts from the tumor samples | `#SAMPLE CHR POS REF_COUNT ALT_COUNT` | +| `-l`, `--outputsnps` | the output directory for the list of identified heterozygous germline SNPs | `#CHR POS` | + +The format fields are described in the following. + +| Field | Description | +|-------|-------------| +| `SAMPLE` | Name of a sample | +| `CHR` | Name of the chromosome | +| `POS` | Genomic position in `CHR` | +| `REF_COUNT` | Number of reads harboring reference allele in `POS` | +| `ALT_COUNT` | Number of reads harboring alternate allele in `POS` | + +## Main parameters + +count-alleles has some main parameters; the main values of these parameters allow to deal with most of datasets, but their values can be changed or tuned to accommodate the features of special datasets. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-S`, `--samples` | White-space separater list of a names | The first name is used for the matched-normal sample, while the others are for the tumor samples and they match the same order of the corresponding BAM files | File names are used | +| `-st`, `--samtools` | Path to `bin` directory of SAMtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | +| `-bt`, `--bcftools` | Path to `bin` directory of BCFtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | +| `-c`, `--mincov` | Minimum coverage | Minimum number of reads that have to cover a variant to be called, the value can be increased when considering a dataset with high depth (>60x) | 8 | +| `-C`, `--maxcov` | Maximum coverage | Maximum number of reads that have to cover a variant to be called, the typically suggested value should be twice higher than expected coverage to avoid sequencing and mapping artifacts | 300 | +| `-j`, `--processes` | Number of parallele jobs | Parallel jobs are used to consider the chromosomes in different samples on parallel. The higher the number the better the running time | 22 | + + +## Optional parameters + +count-alleles has some optional parameters; changes in the default values of these parameters are not expected to have a significant impact but they can be tuned to better fit the given data. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-v`, `--verbose` | Verbose logging flag | When enabled, count-alleles outputs a verbose log of the executiong | Not used | +| `-g`, `--gamma` | Level of confidence for selecting germline heterozygous SNPs | This value is the level of confidence used for the binomial model used to assess whether a called SNPs is in fact germline heterozygous | 0.05 | +| `-q`, `--readquality` | Threshold for phred-score quality of sequencing reads | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of sequencing reads | 20 | +| `-Q`, `--basequality` | Threshold for phred-score quality of sequenced nucleotide bases | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of sequenced nucleotide bases | 20 | +| `-U`, `--snpquality` | Threshold for phred-score quality of called variants | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of called variants | 20 | +| `-L`, `--snps` | Path to file of SNPs in the format `#CHR POS` | When provided, only the included genomic positions will be considered for calling germline SNPs. Using well-known lists (e.g. dbSNP) help to significantly speed up this step | Not used, SNPs are called across all genome | +| `-E`,`--newbaq` | Flag to enable `newbaq` veafute of SAMtools | When selected, the user asks SAMtools to recompute alignment of reads on the fly during SNP calling | Not used | +| `-b`, `--maxshift` | Maximum BAF difference from 0.5 | When used, only SNPs with an absolute difference between the BAF and 0.5 below the maximum are selected | Not used | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_count_reads_fw.md",".md","1966","31","# count-reads-fw + +NOTE: This function (formerly called `comBBo`) uses the legacy fixed-width binning described in the HATCHet paper. We recommend using [`count-reads`](doc_count_reads.md) and [`combine-counts`](doc_combine-counts.md) which apply an adaptive binning scheme to ensure that each genomic bin has comparable BAF signal. + +This step of HATCHet splits the human reference genome into fixed-width bins (i.e., small genomic regions), and computes the number of sequencing reads aligned to each bin from every given tumor samples and from the matched normal sample. + +## Input + +count-reads-fw takes in input sorted and indexed BAM files for multiple tumor samples from the same patient, a sorted and index BAM file from a matched-normal sample, and a indexed human reference genome. + +| Name | Description | Usage | +|------|-------------|-------| +| `-T`, `--tumors` | A white-space separated list of sorted-indexed BAM files for tumor samples | The tumor samples from the same patient that are jointly analyzed by HATCHet | +| `-N`, `--normal` | A sorted-indexed BAM file for matched-normal sample | The matched normal sample for the same patient | +| `-r`, `--reference` | A FASTA file | The human reference genome used for germline variant calling | + +## Output + +count-reads-fw produces three tab-separated files: the first contains the read counts for every genomic bin in every tumor sample (raw counts not normalized), the second contains the read counts for every genomic bin the matched-normal sample (raw counts not normalized), and the third contains a list of the genomic positions that have been identified as germline heterozygous SNPs in the matched-normal sample. + +| Name | Description | +|------|-------------| +| `-O`, `--outputnormal` | The output file for the read counts from matched-normal sample | +| `-o`, `--outputtumors` | The output file for the read counts from the tumor samples | + +## Main parameters + +count-reads-fw + +## Optional parameters +","Markdown" +"Allele","raphael-group/hatchet","docs/source/recommendation_datatype.md",".md","4090","16","# Analyze different type of data + +The default values in the complete pipeline of HATCHet are typically used for analyzing whole-genome sequencing (WGS) data. However, when considering different type of data, as those from whole-exome sequencing (WES) data, users should adjust some of the parameters due to the different features of this kind of data. More specifically, there are 4 main points to consider when analyzing WES data: + + - *Bin sizes*. One can use the plots from [plot-bins](https://github.com/raphael-group/hatchet/blob/master/doc/doc_plot_bins.html) to test different parameters (`--mtr` and `--msr` for variable-width, bin size for fixed width) and inspect the amount of variance and/or the separation between apparent clusters. + * **Variable-width** Having a sufficient number of germline SNPs is needed to have good estimations with low variances for RDR and, especially, for the B-allele frequency (BAF) of each bin. Variable-width binning attempts to account for this by adjusting bin widths to ensure enough total and SNP-covering reads in each bin. You can tune the average bin width using the `--msr` (min. SNP-covering reads, default 5000) and `--mtr` (min. total reads, default 5000) parameters to `combine-counts`. Generally, `--msr` is more important because a bin with enough SNP-covering reads to get a good BAF estimate will almost certainly have enough total reads to get a good RDR estimate. Increasing these parameters produces larger bins (on average) with lower variance, while decreasing these values produces smaller bins (on average) with higher variance. + * **Fixed-width (legacy)** While a size of 50kb is standard for CNA analysis when considering whole-genome sequencing (WGS) data, data from whole-exome sequencing (WES) generally require to use large bin sizes in order to guarantee that each bin contains a sufficient number of heterozygous germline SNPs. As such, more appropriate bin sizes to consider may be 200kb or 250k when analyzing WES data; even larger bin sizes, e.g. `500kb`, may be needed for noisy WES data. + + - *Read-count thresholds*. As suggested in the GATK best practices, `count-alleles` requires two parameters -c (the minimum coverage for SNPs) and -C (the maximum coverage for SNPs) to reliably call SNPs and exclude those in regions with artifacts. GATK suggests to consider a value of -C that is at least twice larger than the average coverage and -c should be large enough to exclude non-sequenced regions. For example, `-c 6` and `-C 300` are values previously used for WGS data whose coverage is typically between 30x and 90x. However, WES data are generally characterized by a much larger average coverage and thus require larger values, e.g. `-c 20` and `-C 600`. These values are also very usefule to discard off-target regions. In any case, the user should ideally pick values according to the considered data. + + - *Bootstrapping for clustering*. (legacy `cluster-bins-gmm` only) Occasionally, WES may have very few points and much less data points than WGS. Only in these special cases with very few data points, the global clustering of cluster-bins-gmm may generally benefit from the integrated bootstrapping approach. This approach allow to generate a certain number of synthetic bins from the real ones to increase the power of the clustering. For example, the following cluster-bins-gmm parameters `-u 20 -dR 0.002 -dB 0.002` allow to activate the bootstraping which introduces 20 synthetic bins for each real bin with low variances. + + - *Bias in balanced BAF.* Depending on the data type (WGS vs. WES) and the sequencing coverage, the argument `-d, --diploidbaf` in `cluster-bins`/`cluster-bins-gmm` may need to be adjusted to match the observed BAF bias. This threshold should be set so that the centroids of cluster(s) with BAF closest to 0.5 are included in the range [0.5 - `d`, 0.5] and other clusters with apparently different BAF are excluded. + + - *Genomic regions*. Provide a BED file defining the sequenced genomic regions when this is available. This helps to speed up the process. +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_cluster_bins.md",".md","5071","71","# cluster-bins + +This step globally clusters genomic bins along the entire genome and jointly across tumor samples. +`cluster-bins` clusters bins while also taking into account their locations on the genome to preferentially form clusters that correspond to contiguous genomic segments on chromosome arms. +The input/output files for `cluster-bins` are exactly the same as those for `cluster-bins-gmm`. + +## Input + +`cluster-bins` takes in input a tab-separated file with the following fields. + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `RD` | RDR of the bin in `SAMPLE` | +| `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | +| `COV` | Average coverage in the bin in `SAMPLE` | +| `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | +| `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | +| `BAF` | BAF of the bin in `SAMPLE` | + +The fields `#SNPS`, `COV`, `ALPHA`, and `BETA` are currently deprecated and their values are ignored. + +## Output + +`cluster-bins` produces two tab-separated files: + +1. A file of clustered genomic bins, specified by the flag `-O`, `--outbins`. The tab separated file has the same fields as the input plus a last field `CLUSTER` which specifies the name of the corresponding cluster. + +2. A file of clustered genomic bins, specified by the flag `-o`, `--outsegments`. The tab separated file has the following fields. + +| Field | Description | +|-------|-------------| +| `ID` | The name of a cluster | +| `SAMPLE` | The name of a sample | +| `#BINS` | The number of bins included in `ID` | +| `RD` | The RDR of the cluster `ID` in `SAMPLE` | +| `#SNPS` | The total number of SNPs in the cluster `ID` | +| `COV` | The average coverage in the cluster `ID` | +| `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | +| `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | +| `BAF` | The BAF of the cluster `ID` in `SAMPLE` | + + +## Main parameters + +1. `cluster-bins` has a parameter `-d`, `--diploidbaf` that specifies the maximum expected shift from 0.5 the BAF of a balanced cluster (i.e., diploid with copy-number state (1, 1) or tetraploid with copy-number state (2, 2)). This threshold is used to correct bias in the BAF of these balanced clusters. +The default value of this parameter (0.1) is often sufficient, but the most appropriate value will vary depending on noise and coverage. In general, this value should be set to include only those clusters that are closest to 0.5 -- for example, if some clusters have centroids near 0.47 and others have centroids near 0.42, this parameter should be set to 0.035 or 0.04. +To determine the best setting for this value, please check the plots produced by `plot-bins` and the centroid values described `bbc/bulk.seg` (output from this command). + +2. By default, `cluster-bins` takes as input a minimum number of clusters (`--minK`, default `2`) and maximum number of clusters (`--maxK`, default `30`), and chooses the number `K` of clusters in this closed interval that maximizes the silhoutette score. Users can also specify an exact number of clusters (`--exactK`) to infer, which skips the model selection step. + +3. Other options are available to change aspects of the Gaussian Hidden Markov model (GHMM) that is used by `cluster-bins`: + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `--tau` | Off-diagonal value for initializing transition matrix | must be `<= 1/(K-1)` | `1e-6` | +| `-t`, `--transmat` | Type of transition matrix to infer | `fixed` (to off-diagonal = tau), `diag` (all diagonal elements are equal, all off-diagonal elements are equal) or `full` (freely varying) | `diag` | +| `-c`, `--covar` | Type of covariance matrix to infer | options described in [hmmlearn documentation](https://hmmlearn.readthedocs.io/en/latest/api.html#hmmlearn.hmm.GaussianHMM) | `diag` | +| `-x`, `--decoding` | Decoding algorithm to use to infer final estimates of states | `map` for MAP inference, `viterbi` for Viterbi algorithm | `map` | + +Particularly, `tau` controls the balance between global information (RDR and BAf across samples) and local information (assigning adjacent bins to the same cluster): smaller values of `tau` put more weight on *local* information, and larger values of `tau` put more weight on *global* information. It may be appropriate to reduce `tau` by several orders of magnitude for noisier or lower-coverage datasets. + +## Optional parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-R`, `--restarts` | Number of restarts (initializations) | For each K, the HMM is initialized randomly this many times and the solution with the highest log-likelihood is kept | 10 | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_check.md",".md","1124","24","# check + +This command of HATCHet verifies that dependencies that are unique to specific parts of HATCHet are correctly installed. The relevant commands with dependencies are `count-reads`, `phase-snps`, and `compute-cn`. + +All checks can be run simultaneously via `hatchet check`, or an individual command can be checked via, e.g., `hatchet check compute-cn`. + +The check for `compute-cn` runs the step on a set of small data files (.bbc/.seg) pre-packaged with HATCHet, and is a quick way to verify if your solver is working correctly. +If you are unable to run this command, it likely indicates a licensing issue with default (Gurobi) solver. To use alternative solvers, see the +[Using a different Pyomo-supported solver](README.html#usingasolver_other) section of the README for more details. + +## Input + +This command takes no inputs. + +## Output + +This command produces debugging output from the solver as well as other dependency checks. For `compute-cn`, look for the message towards the end of the output: + +``` +# Your current solver ... seems to be working correctly +``` + +to verify if your selected solver works correctly. +","Markdown" +"Allele","raphael-group/hatchet","docs/source/recommendation_clustering.md",".md","3523","31","# Analyze global clustering + +The global clustering performed along the genome and jointly across samples is a crucial feature of HATCHet and the quality of the final results is strongly affected by the quality of the clustering. This global clustering is performed by HATCHet's component `cluster-bins`, whose default values are suitable for many datasets. However, for ideal results on specific datasets these parameters may need to be modified. + +The module `cluster-bins` incorporates genomic position to improve clustering using a Gaussian hidden Markov model (GHMM), as opposed to the position-agnostic Gaussian mixture model (GMM) used in `cluster-bins-gmm` and described in the original HATCHet publication. This page describes how to tune the parameters of `cluster-bins` -- for recommendations on `cluster-bins-gmm`, see [this page](recommendation_old_clustering.md) instead. + +The user should validate the results of the clustering, especially in noisy or suspicious cases, through the cluster figures produced by [plot-bins](doc_plot_bins.html) and [plot-bins-1d2d](doc_plot_bins_1d2d.html). More specifically, we suggest the following criteria to evaluate the clustering: + +1. Every pair of clusters should be clearly distinct in terms of RDR or BAF in at least one sample, and +2. Each cluster should contain regions with similar values of RDR and BAF in all samples + + +`cluster-bins` offers several parameters that can be used to tune the clustering. +## Number of clusters +By default, `cluster-bins` tries several possible values for the number `K` of clusters and selects the one that maximizes the silhouette score. In practice, this tends to *underestimate* the number of clusters that are visually apparent. This can be modified by + +1. Setting the parameters `--minK` and `--maxK` which specify the minimum and maximum number of clusters to consider, or +2. Setting the parameter `--exactK` to fix the number of clusters to a given value. + +## Model parameters +Some parameters of the model can be tuned to change the clustering. The most useful one is the value `--tau`, which corresponds to the probability of transitioning between different copy-number states (i.e., the initial value for off-diagonal entries in the transition matrix). In practice, `tau` controls the balance between global information (RDR and BAf across samples) and local information (assigning adjacent bins to the same cluster): smaller values of `tau` put more weight on *local* information, and larger values of `tau` put more weight on *global* information. + It may be appropriate to reduce `tau` by several orders of magnitude for noisier or lower-coverage datasets, as in this case the global RDR/BAF values are less reliable. + + Other parameters (below) are available to change the structure of the model, although in practice I have not found them particularly helpful in tuning the clustering. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-t`, `--transmat` | Type of transition matrix to infer | `fixed` (to off-diagonal = tau), `diag` (all diagonal elements are equal, all off-diagonal elements are equal) or `full` (freely varying) | `diag` | +| `-c`, `--covar` | Type of covariance matrix to infer | options described in [hmmlearn documentation](https://hmmlearn.readthedocs.io/en/latest/api.html#hmmlearn.hmm.GaussianHMM) | `diag` | +| `-x`, `--decoding` | Decoding algorithm to use to infer final estimates of states | `map` for MAP inference, `viterbi` for Viterbi algorithm | `map` | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/recommendation_old_clustering.md",".md","4769","27","# Analyze global clustering + +**Note**: this page describes recommendations for tuning the older clustering module `cluster-bins-gmm`. We recommend using the locality-aware clustering module [`cluster-bins`](doc_cluster_bins.md) instead. + +The global clustering performed along the genome and jointly across samples is a crucial feature of HATCHet and the quality of the final results is affected by the quality of the clustering. In particular, the global clustering is performed by HATCHet's component `cluster-bins-gmm`, whose default values for the main parameters allow to deal with most of the datasets. However, noisy or special datasets need tuning of these parameters, especially because the current version of `cluster-bins-gmm` uses [scikit-learn](https://scikit-learn.org/stable/modules/generated/sklearn.mixture.BayesianGaussianMixture.html), an external implementation of a GMM with a Dirichlet process prior which is not specifically designed for sequencing data. Therefore, the user needs to validate the results and improve it to obtain best-quality results, especially when considering noisy and special datasets. + +The user should validate the results of the clustering, especially in noisy or suspicious cases, through the cluster figure produced by the [command CBB of plot-bins](doc_plot_bins.md) and as explained in the available [demos](https://github.com/raphael-group/hatchet#demos). More specifically, we suggest to consider the following criterion to validate the clustering: **Every pair of clusters needs to be clearly distinct in terms of RDR or BAF in at least one sample and each cluster only contains regions with similar values of RDR and BAF in all samples**. + +`cluster-bins-gmm` offers two sets of parameters that the user can tune to improve the result of the clustering: (1) `cluster-bins-gmm`-specific and (2) sklearn-specific parameters. + +### `cluster-bins-gmm`-specific parameters + +`cluster-bins-gmm` provides two specific parameters that can be used to improve the results of the global clustering: +- `-tR` threshold defines a RDR tolerance (default value is `-tR 0.15`) +- `-tB` threshold defines a BAF tolerance (default value is `-tB 0.04`) + +These tolerances are used to merge any pair of clusters which have differences in terms of RDR and BAF always lower than the given thresholds across all samples. Intuitively these two thresolds are used to draw a rectangle (with `tR` width and `tB` height in every RDR-BAF plots) around every cluster in every sample. If two clusters are in the same rectangle in every sample, they are merged. As such, the user can estimate the RDR and BAF as the values of the thresholds by using the heat figure produced by the [command BB of plot-bins](doc_plot_bins.md). In particular, higher values allow to merge more clusters, avoid overfitting, and accomodate higher noise and variances, while smaller values allow to avoid overclustering. For example, clusters which have a disc/long shape, i.e. high variance of RDR as in the [cancer WGS demo](https://github.com/raphael-group/hatchet/blob/master/examples/demo-WGS-cancer/demo-wgs-cancer.sh) or [WES demo](https://github.com/raphael-group/hatchet/blob/master/examples/demo-WES/demo-wes.sh), will require a higher value of `tR`, e.g. `-tR 0.3` or `-tR 0.4`. + +### `sklearn`-specific parameters + +`cluster-bins-gmm` additionally provide 3 parameters which allow to directly control the clustering computed by the scikit-learn Gaussian Mixture Model: +- `-R`: number of restarts (default is `-R 10`) which controls the number of restarts allows the method to escape local optima. While a lower number of restarts improves the running time of `cluster-bins-gmm` process, a higher number allows it to consider more solutions and choose a better clustering. +- `-K`: this value provides the maximum possible number of clusters (default is `-K 50`). Scikit-learn tends to infer close to this maximum number `K` of clusters, so if you have relatively simple data with few apparent clusters you may want to lower `K`. +- `-c`: this value (default `1`) determines the model's relative confidence in many even clusters (large `c`) vs. an uneven distribution of points into clusters, potentially with fewer than `K` components (small `c`). For experts, this is the concentration parameter for the Dirichlet process prior. Reducing this value by many orders of magnitude (e.g., `-c 0.001` or `-c 0.00001`) may enable scikit-learn to infer fewer than `K` clusters. + +Note that that these clustering parameters determine the clustering *before* the merging heuristic described above is applied; if you are unsure which set of parameters to tune, consider turning off the merging heuristic (i.e., setting `-tR 0 -tB 0`) to inspect the clustering without merging. +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_combine_counts.md",".md","5918","81","# combine-counts + +This step constructs variable-length bins that ensure that each bin has at least some number (`--msr`) of SNP-covering reads and at least some number (`--mtr`) of total reads per bin. Then, it combines the read counts and the allele counts for the identified germline SNPs to compute the read-depth ratio (RDR) and B-allele frequency (BAF) of every genomic bin. + +## Input + +`combine-counts` takes in input the output from `count-reads` (i.e., two gzipped files `ch.total.gz` and `ch.thresholds.gz` for each chromosome `ch`, ). Use the `-A, --array` argument to specify a directory containing these input files. + +It also requires (specified by the flag `-b`, `--baffile`) a tab-separated file specifying the allele counts for heterzygous germline SNPs from all tumor samples. The tab separated file would typically be produced by the `count-alleles` command and has the following fields: + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `POS` | Genomic position corresponding to a heterozygous germline in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `REF_COUNT` | Count of reads covering `POS` with reference allele | +| `ALT_COUNT` | Count of reads covering `POS` with alternate allele | + +Finally, `combine-counts` requires a TSV file (`-t, --totalcounts`) specifying the total number of reads aligned in each sample (also typically produced by `count-reads`). + +In summary, **the following arguments are required to specify input**: + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-A`, `--array` | Directory containing intermediate files | Typically populated by `count-reads`. For each chromosome `ch`, this directory should contain files `ch.total.gz` and `ch.thresholds.gz` (as well as `samples.txt` indicating sample names) | | +| `-b, --baffile` | Tab-separated file with allele counts | Typically produced by `count-alleles`. See description above. | | +| `-t, --totalcounts` | Tab-separated file with total aligned reads for each sample | Typically produced by `count-reads`. | | +| `-V, --refversion` | Reference genome version | Either ""hg19"" or ""hg38"". This argument is used to select which centromere locations to use. | + + +## Output + +combine-counts produces a tab-separated file (`-o, --outfile`) with the following fields. + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `RD` | RDR of the bin in `SAMPLE` (corrected by the total reads in `SAMPLE` vs. the total reads in the matched normal sample) | +| `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | +| `COV` | Average coverage in the bin in `SAMPLE` | +| `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | +| `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | +| `BAF` | BAF of the bin in `SAMPLE` | +| `TOTAL_READS` | Total number of reads in the bin in `SAMPLE` | +| `NORMAL_READS` | Total number of reads in the bin in the matched normal sample | +| `CORRECTED_READS` | Total number of reads in the bin in `SAMPLE`, corrected by the total reads in `SAMPLE` vs. the total reads in matched normal. | + +Currently, it produces one such file that excludes sex chromosomes (for use in HATCHet), and one that includes sex chromosomes (for future use). + +## Main parameters + +combine-counts has some main parameters; the main values of these parameters allow to deal with most of datasets, but their values can be changed or tuned to accommodate the features of special datasets. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `--msr` | Minimum SNP-covering reads for each bin | Each bin constructed by this command must have at least this many reads covering heterozygous SNPs in each sample | 5000 | +| `--mtr` | Minimum total reads for each bin | Each bin constructed by this command must have at least this many total reads in each sample | 5000 | + +## Phasing parameters +A phased VCF file must be given via argument `-p, --phase` to apply reference-based phasing. The remaining parameters control the degree to which the phasing information is used. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-p`, `--phase` | vcf.gz with phasing for all het. SNPs | File containing phasing data for germline SNPs, typically `phased.vcf.gz` if using the HATCHet pipeline. | None (no phasing is performed) | +| `-s`, `--blocksize` | Maximum phasing block size | Maximum distance (in bp) between a pair of SNPs included in the same phasing block (ignored if `-p, --phase` is not used) | 25000 | +| `-m`, `--max_spb` | Maximum number of SNPs per phased block | No more than this many SNPs can be included in the same phasing block (included to minimize phasing errors in high-LD regions) | 10 | +| `-a`, `--alpha` | Significance threshold to allow adjacent SNPs to be merged | If adjacent SNPs have significantly different BAFs (at this significance level) after taking the phasing into account, they are not merged a priori. Higher means less trust in phasing. | 0.1 | + +## Other optional parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-j`, `--processes` | Number of parallel processes to use (default 1) | | 1 | +| `-z, --not_compressed` | Indicates that intermediate files are not compressed | For compatibility with legacy versions of previous step -- set this flag if your `.total` and `.thresholds` files are plaintext rather than gzipped. | | + +## Example usage +`hatchet combine-counts -b baf/bulk.1bed -o abin/bulk.bb -j 24 -V hg19 -A array -t array/total.tsv -V hg19` +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_fullpipeline.md",".md","10371","87","## Full pipeline and tutorial + + +We provide example [BASH scripts](script/README.md) that implement the entire pipeline of HATCHet. +This script and its usage are described in detailed in a guided [tutorial](doc_runhatchet.md). +The user can simply use the script for every execution of HATCHet on different data by copying the script inside the running directory and changing the corresponding paths of the required data and dependencies at the beginning of the script, as described in the guided [tutorial](doc_runhatchet.md). + +## Demos + + +Each demo is an example and guided execution of HATCHet on a dataset included in the corresponding demo's folder of this +repository (inside `examples`). The demos are meant to illustrate how the user should apply HATCHet on different +datasets characterized by different features, noise, and kind of data. In fact, the default parameters of HATCHet allow +to successfully analyze most of the datasets but some of these may be characterized by special features or +higher-than-expected variance of the data. Understanding the functioning of HATCHet, assessing the quality of the +results, and tuning the few parameters needed to fit the unique features of the considered data thus become crucial to +guarantee to always obtain the best-quality results. These are the goals of these demos. + +More specifically, each demo is simultaneously a guided description of the entire example and a BASH script, which can +be directly executed to run the complete demo after setting the few required paths at the beginning of the file. As +such, the user can both read the guided description as a web page and run the same script to execute the demo. At this +time the following demos are available (more demos will be added in the near future): + +| Demo | Description | +|------|-------------| +| [demo-complete](examples/demo-complete/demo-complete.html) | A demo of the complete HATCHet pipeline starting from an example dataset of tumour and matched normal BAM files | +| [demo-wgs-sim](examples/demo-WGS-sim/demo-wgs-sim.html) | A demo on a typical WGS (whole-genome sequencing) multi-sample dataset with standard noise and variance of the data | +| [demo-wgs-cancer](examples/demo-WGS-cancer/demo-wgs-cancer.html) | A demo on a cancer WGS (whole-genome sequencing) multi-sample dataset with high noise and variance of the data | +| [demo-wes](examples/demo-WES/demo-wes.html) | A demo on a cancer WES (whole-exome sequencing) multi-sample dataset, which is typycally characterized by very high variance of RDR | + +## Custom pipelines + + +The repository includes custom pipelines which have been designed to adapt the complete pipeline of HATCHet to special +conditions or to integrate the processed data produced by other pipelines. Each custom pipeline is a variation of the +main HATCHet's pipeline, we thus recommend the user to always first carefully understand the main +[BASH script](script/README.md) through the corresponding guided [tutorial](doc_runhatchet.md) and to carefully +understand the provided [demos](#demos) to properly apply HATCHet for best-quality results. Each custom pipeline also +includes a specific demo which represent a guided and executable example on example data. + +| Name | Description | Script | Demo | Variations | +|------|-------------|--------|------|------------| +| GATK4-CNV | Custom pipeline for segmented files from GATK4 CNV pipeline | [custom-gatk4-cnv.sh](custom-gatk4-cnv.sh) | [demo-gatk4-cnv.sh](custom/GATK4-CNV/demo-gatk4-cnv.html) | This custom pipeline takes the input the segmented files which already contain the estimated RDR and BAF. As such, the first pre-processing steps of HATCHet (`count-reads`, `count-alleles`, and `combine-counts`) are not needed; for this reason, the following depdencies SAMtools and BCFtools and the following required data, human reference genome, matched-normal sample, and BAM files, are not needed in this case. | + +## Detailed steps + + +The full pipeline of HATCHet is composed of 9 sequential steps (and an additional dependency-checking command), starting from the required input data. +The description of each step also includes the details of the corresponding input/output that are especially useful when +one wants to replace or change some of the steps in the pipeline while guaranteeing the correct functioning of HATCHet. +Each step `` of HATCHet can be run with the following command within a HATCHet conda environment: +```shell +hatchet +``` + +**Note**: This version of HATCHet uses variable-width bins to ensure that each bin has comparable B-allele frequency (BAF) signal from heterogeneous germline SNPs and to account for sequencing coverage. To run the older versions of HATCHet with fixed-width bins, use [*count-reads-fw*](doc_count_reads_fw.html) (formerly binBAM) instead of *count-reads* and [*combine-counts-fw*](doc_combine_counts_fw.html) (formerly comBBo) instead of *combine-counts*. If you are using the `run` command, set `fixed_width = True` under the `[run]` header in your `.ini` file. + +Additionally, this version of HATCHet uses a new locality-aware clustering module that incorporates local information along the genome. This replaces the previous GMM-based clustering (command named cluBB). Users can still use GMM-based clustering if they wish by setting `loc-clust` to `False` under the `[run]` header in `hatchet.ini`, or by running [*cluster-bins-gmm*](doc_cluster_bins_gmm.md) directly. + + +*Older versions of HATCHet used different names for these steps. The `Old Name` column lists those names.* + +| Order | Step | Old Name | Description | +|-------|------|----------|-------------| +| (1) | [*genotype-snps*](doc_genotype_snps.html) | deBAF | This step calls heterozygous germline SNPs from the matched-normal sample. | +| (2) | [*count-alleles*](doc_count_alleles.html) | deBAF | This step counts the number of reads covering both the alleles of each identified heterozgyous SNP in every tumor sample. | +| (3) | [*count-reads*](doc_count_reads.html) | N/A | This step splits the human reference genome into very small regions (representing candidate bins) according to germline SNP positions, and counts the number of total reads aligned to each region in each of the tumor samples and in the matched normal sample. | +| (4) | [*phase-snps*](doc_phase_snps.html) | N/A | This **optional** step uses reference-based phasing to group together germline SNPs that are likely on the same haplotype. This improves the quality of BAF estimates for balanced regions of the genome. | +| (5) | [*combine-counts*](doc_combine_counts.html) | N/A | This step constructs genomic bins with variable sizes, and combines the read counts and the allele counts for the identified germline SNPs to compute the read-depth ratio (RDR) and B-allele frequency (BAF) of every genomic bin. | +| (6) | [*cluster-bins*](doc_cluster_bins.html) | N/A | This step globally clusters genomic bins along the entire genome and jointly across tumor samples while incorporating local information. | +| (7) | [*plot-bins*](doc_plot_bins.html) | BBot | This **optional** step produces informative plots concerning the computed RDRs, BAFs, and clusters. The information produced by this step are important to validate the compute clusters of genomic regions. When this step is enabled in the `.ini` file, [plot-bins-1d2d](doc_plot_bins_1d2d.html) is run as well to generate additional plots. | +| (8) | [*compute-cn*](doc_compute_cn.html) | hatchet | This step computes allele-specific fractional copy numbers, solves a constrained distance-based simultaneous factorization to compute allele and clone-specific copy numbers and clone proportions, and deploys a model-selection criterion select the number of clone by explicitly considering the trade-off between subclonal copy-number aberrations and whole-genome duplication. | +| (9) | [*plot-cn*](doc_plot_cn.html) | BBeval | This **optional** step analyzes the inferred copy-number states and clone proportions and produces informative plots jointly considering all samples from the same patient. In addition, this step can also combine results obtained for different patients and perform integrative analysis. When this step is enabled in the `.ini` file, [plot-cn-1d2d](doc_plot_cn_1d2d.html) is run as well to generate additional plots. | +| (10) | [*check*](doc_check.html) | check-solver | This **optional** step is a quick way to verify if your solver and other 3rd party dependencies are working correctly. It checks for the presence of several dependencies and tests `compute_cn` on a set of small data files pre-packaged. | + +## Recommendations and quality control + + +All the components of HATCHet's pipeline use some basic parameters that allow to deal with data characterized by different features. The default values of these parameters allow one to succesfully apply HATCHet on most datasets. However, special or noisy datasets may require to tune some parameters. The user can deal with these cases by following the recommendations reported here, reading the descriptions of the various steps, and using the informative plots to verify the results. In the following guides and recommentations, we guide the user in the interpration of HATCHet's inference, we explain how to perform quality control to guarantee the best-quality results, and we describe how the user can control and tune some of the parameters to obtain the best-fitting results. We thus split the recommendations into distinct topics with dedicated descriptions. + +| Recommendation | Description | +|----------------|-------------| +| [Analyze HATCHet inference](recommendation_inference.html) | Interpret HATCHet's inference, quality and error control, and investigate alternative solutions. | +| [Analyze global clustering](recommendation_clustering.html) | Interprent global clustering, quality and error control, and parameter tuning | +| [Analyze different type of data](recommendation_datatype.html) | Tuning parameters to better analyzing different type of data as those from WES | +| [Improve running time](recommendation_runtime.html)| Tips for improving running time of the whole pipeline | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_count_reads.md",".md","3819","47","# count-reads + +This step of HATCHet uses the locations of heterozygous SNPs (called by `count-alleles`) to identify candidate bin thresholds between SNPs. Then, it counts the total number of reads in each sample between each set of candidate thresholds for use in constructing variable-length bins. + +## Input + +`count-reads` takes in input sorted and indexed BAM files for multiple tumor samples from the same patient, a sorted and index BAM file from a matched-normal sample, an indexed human reference genome, and a 1bed file containing SNP information for this individual (output from `count-alleles` command, normally `baf/bulk.1bed`). + +| Name | Description | Usage | +|------|-------------|-------| +| `-T`, `--tumors` | A white-space separated list of sorted-indexed BAM files for tumor samples | The tumor samples from the same patient that are jointly analyzed by HATCHet | +| `-N`, `--normal` | A sorted-indexed BAM file for matched-normal sample | The matched normal sample for the same patient | +| `-b`, `--baffile` | A 1bed file containing locations of heterozygous germline SNPs | Typically, a user would run `count-alleles` to obtain this file. | +| `-V`, `--refversion` | Reference genome version (hg19 or hg38 supported) | | + +## Output + +`count-reads` writes all output files to a given output directory. For each chromosome `chr`, count-reads produces two gzipped files needed to construct adaptive bins: `chr.threhsolds.gz` and `chr.total.gz`. `count-reads` also produces a tab-separated file `total.tsv` containing the total number of reads in each sample, and a text file `samples.txt` containing the list of sample names. + +| Name | Description | +|------|-------------| +| `-O`, `--outdir` | Output directory | Directory in which output will be written to (must already exist before running `count-reads`) + +## Main parameters + +| Name | Description | Usage | +|------|-------------|-------| +| `-V`, `--refversion` | Reference genome version (""hg19"" or ""hg38"" supported) | | + + +## Optional parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-S`, `--samples` | White-space separater list of a names | The first name is used for the matched-normal sample, while the others are for the tumor samples and they match the same order of the corresponding BAM files | File names are used | +| `-j`, `--processes` | Number of parallel jobs | Parallel jobs are used to consider the chromosomed in different samples in parallel. The higher the number the better the running time (up to 22 * n_samples) | 22 | +| `-st`, `--samtools` | Path to `bin` directory of SAMtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | +| `-md`, `--mosdepth` | Path to the `mosdepth` executable | The path to this executable needs to be specified when it is not included in `$PATH` | None (expected on `PATH`) | +| `-tx`, `--tabix` | Path to the `tabix` executable | The path to this executable needs to be specified when it is not included in `$PATH` | None (expected on `PATH`) | +| `-q`, `--readquality` | Minimum mapping quality (MAPQ) for a read to be counted | Values range from 0 to 41, see alignment documentation for details | 11 | +| `-i`, `--intermediates` | Keep intermediate files | Retain intermediate files (read starts and per-position coverage) that are used to compute arrays for binning | False (these files are deleted, subsequent arrays are retained instead) | +## Example usage + +Given samtools, mosdepth, and tabix are on the PATH, the referenced files are in the current directory, and the intended output directory `array` is present: + +`hatchet count-reads -T first_sample.bam second_sample.bam -N normal_sample.bam -S normal tumor1 tumor2 -V hg19 -j 24 -O array -b baf/bulk.1bed` +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_plot_bins.md",".md","8217","124","# plot-bins + +This step produces informative plots concerning the computed RDRs, BAFs, and clusters. +The information produced by this step are important to validate the compute clusters of genomic regions and help to tune the parameters for better deal with special datasets. +plot-bins produces different plots which need to be specified by different commands and require different input. + +When `plot_bins = True` is indicated in `hatchet.ini`, the command [`plot-bins-1d2d`](doc_plot_bins_1d2d.md) will also be run. This command produces alternate plots in which bins are colored by cluster and colors match across samples between the 2D cluster view and 1D genomic view. + +## Input + +plot-bins considers two different inputs which are tab-separated files, one is mandatory and the other is only required for certain command: + +1. A file of clustered genomic bins, specified without any flag and with the following fields. + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `RD` | RDR of the bin in `SAMPLE` | +| `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | +| `COV` | Average coverage in the bin in `SAMPLE` | +| `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | +| `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | +| `BAF` | BAF of the bin in `SAMPLE` | +| `CLUSTER` | The name of the corresponding cluster of the bin in `SAMPLE` | + +2. A file of clusters, which is required only by commands and it is specified through the flag `-s`, `--segfile`. The file has the following fields. + +| Field | Description | +|-------|-------------| +| `ID` | The name of a cluster | +| `SAMPLE` | The name of a sample | +| `#BINS` | The number of bins included in `ID` | +| `RD` | The RDR of the cluster `ID` in `SAMPLE` | +| `#SNPS` | The total number of SNPs in the cluster `ID` | +| `COV` | The average coverage in the cluster `ID` | +| `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | +| `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | +| `BAF` | The BAF of the cluster `ID` in `SAMPLE` | + +## Commands + +A command must be specified using the flag `-c`, `--command` and every command is described in the following together with an example of the corresponding plot. + +### RD + +The command generates a scatter plot describing the RDR of every genomic bin in the different samples. For every genomic bin sorted by chromosome and by genomic positions, a point is plotted with the correspondig value of RDR and colored by a color identifying the corresponding sample. + + python -m hatchet plot-bins A12.bbc -c RD -m Set1 --figsize 9,2.5 --markersize 1 --ymax 8 --ymin 0 + +![](example_rd.png ""Example of RDR plot from the output of RD command"") + +*** + +### BAF + +The command generates a scatter plot describing the BAF of every genomic bin in the different samples. For every genomic bin sorted by chromosome and by genomic positions, a point is plotted with the correspondig value of RDR and colored by a color identifying the corresponding sample. + + python -m hatchet plot-bins A12.bbc -c BAF -m Set1 --figsize 9,2.5 --markersize 1 --ymax 8 --ymin 0 + +![](example_baf.png ""Example of RDR plot from the output of RD command"") + +*** + +### BB + +The command generates a series of 2d-scatter plots where x-axis corresponds to the mirrored BAF and the y-axis corresponds to RDR. More specifically, a plot is generated for every sample and every point is drawn according to the corresponding values of RDR and BAF. The points are colored according to their density from blue (low density) to dark red (high density). + + python -m hatchet plot-bins A12.bbc -c BB --figsize 8,6 --markersize 1 --xmax 3.5 --xmin 0.5 + + +*** + +### CBB + +The command generates a series of 2d-scatter plots where x-axis corresponds to the mirrored BAF and the y-axis corresponds to RDR. More specifically, a plot is generated for every sample and every point is drawn according to the corresponding values of RDR and BAF. The points are colored according to the clusters computed by HATCHet. Remember that a cluster contains all the genomic regions that have the same copy-number state in every clone. + + python -m hatchet plot-bins A12.bbc -c CBB --figsize 4,1.1 -m tab20 --markersize 1 --xmax 3.5 --xmin 0.5 --colwrap 3 -tS 0.005 + + + +*** + +### CRDR + +The command generates a series of 2d-scatter plots where x-axis corresponds to the RDR and to bins sorted by chromosome and positions. More specifically, a plot is generated for every sample and every point is drawn according to the corresponding values of RDR. The points are colored according to the clusters computed by HATCHet. Remember that a cluster contains all the genomic regions that have the same copy-number state in every clone. + + python -m hatchet plot-bins A12.bbc -c CRD -m tab20 --figsize 9,2.5 --markersize 1 --ymax 8 --ymin 0 + +![](example_crdr.png ""Example of cluster plot from the output of CRDR command"") + +*** + +### CBAF + +The command generates a series of 2d-scatter plots where x-axis corresponds to the BAF and to bins sorted by chromosome and positions. More specifically, a plot is generated for every sample and every point is drawn according to the corresponding values of BAF. The points are colored according to the clusters computed by HATCHet. Remember that a cluster contains all the genomic regions that have the same copy-number state in every clone. + + python -m hatchet plot-bins A12.bbc -c CBAF -m tab20 --figsize 9,2.5 --markersize 1 --ymax 8 --ymin 0 + +![](example_cbaf.png ""Example of cluster plot from the output of CBAF command"") + +*** + +### Parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-tC`, `--chrthreshold` | Threshold of chromosomes | A threshold can be specified to select to plot only genomic regions belonging to clusters that cover at least the specified number of chomosomes | 0, no threshold | +| `-tS`, `--sizethreshold` | Threshold of size | A threshold can be specified to select to plot only genomic regions belonging to clusters that cover at least the specified fraction of the genome | 0, no threshold | +| `--xmin` | Minimum x-value of plot | The value can be specified to fix the minimum value of x-axis of the plot | None | +| `--xmax` | Maximum x-value of plot | The value can be specified to fix the maximum value of x-axis of the plot | None | +| `--ymin` | Minimum y-value of plot | The value can be specified to fix the minimum value of y-axis of the plot | None | +| `--ymax` | Maximum y-value of plot | The value can be specified to fix the maximum value of y-axis of the plot | None | +| `--figsize` | Figure size in the format ""(X, Y)"" | The parameter is used to change the figure size. The meaning and scale of X and Y depend on the different plot so one needs to try different values. | Automatic values | +| `--markersize` | Size of the markers | The value is used to scale the size of the point markers | Automatic value | +| `-m`, `--colormap` | Name of the colormap to use | The following colormaps are available: {Set1, Set2, Paired, Dark2, tab10, and tab20} | tab20 | +| `--resolution` | Number of bins to merge | This feature allows plot-bins to merge multiple bins into segments whose copy numbers will be chosen by majority. This features allows to change the resolution of the plot. | 0, bins are not merged | +| `--colwrap` | Number of plots per each column | This value determines the maximum number of plots for multiple samples to print on the same row | 2 | +| `--fontscale` | Scale for font size | The value is used to scale the font size | 1 | +| `-s`, `--segfile` | Path to cluter file | The cluster file, containing estimated values of RDR and BAF for each cluster in every sample is only required by `CLUSTER` command | None | +| `-x`, `--rundir` | Path to running directory | The running directory where output the results | Current directory | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_compute_cn.md",".md","12986","143","# compute-cn + +This step infers allele-specific copy numbers for each tumor clone as well as the mixture proportions of the tumor clones in each sample. It consists of the following components: + +1. Compute allele-specific fractional copy numbers. +2. Solve a constrained distance-based simultaneous factorization to compute allele and clone-specific copy numbers and clone proportions. +3. Deploy a model-selection criterion to select the number of clones by explicitly considering the trade-off between subclonal copy-number aberrations and whole-genome duplication. + +The step offers some parameters to control each of these features. + +## Input + +This step requires in input two tab-separated files that must have the same prefix `${PRE}` and the only difference is the extension: + +1. The name of the first file must be `${PRE}.bbc` and is a tab-separated file describing the RDR and BAF of clustered genomic bins with the following fields + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `RD` | RDR of the bin in `SAMPLE` | +| `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | +| `COV` | Average coverage in the bin in `SAMPLE` | +| `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | +| `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | +| `BAF` | BAF of the bin in `SAMPLE` | +| `CLUSTER` | The name of a cluster | + +2. The name of the second file must be `${PRE}.seg` and is a tab-separated file describing the RDR and BAF of clusters of genomic regions with the following fields + +| Field | Description | +|-------|-------------| +| `ID` | The name of a cluster | +| `SAMPLE` | The name of a sample | +| `#BINS` | The number of bins included in `ID` | +| `RD` | The RDR of the cluster `ID` in `SAMPLE` | +| `#SNPS` | The total number of SNPs in the cluster `ID` | +| `COV` | The average coverage in the cluster `ID` | +| `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | +| `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | +| `BAF` | The BAF of the cluster `ID` in `SAMPLE` | + +## Output + +This step produces 2 files, a BBC result file and a SEG result file, for every considered number of clones and for both the assumption of the presence and absence of a WGD. +For every considered number of clones `${N}` and assuming `${P}` is either equal to `diploid` or `tetraploid`, the steps generates a pair of files as follows: + +1. The first BBC file has the following name `results.${P}.n${N}.bbc.ucn.tsv` and is a copy of the BBC input file with `2 (${N} + 1)` additional fields according to the following: + +| Field | Description | +|-------|-------------| +| ... | ... | +| `cn_normal` | The copy number state of the normal diploid clone equal to 1|1 | +| `u_normal` | The normal admixture of the normal diploid cells in the corresponding sample | +| `cn_clone${n}` | The copy number state of the `${n}` tumor clone in the format A|B where `A` and `B` are the two allele-specific copy numbers of the corresponding genomic bin | +| `u_clone${n}` | The clone proportion of the `${n}` tumor clone in the corresponding sample | + +2. The second SEG file has the following name `results.${P}.n${N}.seg.ucn.tsv` and is a file of genomic segments with the following fields: + +| Field | Description | +|-------|-------------| +| `CHR` | The name of a chromosome | +| `START` | The genomic position that starts the corresponding genomic segment | +| `END` | The genomic position that ends the corresponding genomic segment | +| `SAMPLE` | The name of a sample | +| `cn_normal` | The copy number state of the normal diploid clone equal to 1|1 | +| `u_normal` | The normal admixture of the normal diploid cells in the corresponding sample | +| `cn_clone${n}` | The copy number state of the `${n}` tumor clone in the format A|B where `A` and `B` are the two allele-specific copy numbers of the corresponding genomic bin | +| `u_clone${n}` | The clone proportion of the `${n}` tumor clone in the corresponding sample | + +In addition, the two files for the best solution assuming both the absence or presence of a WGD are copied in the files `chosen.diploid.bbc.ucn`, `chosen.diploid.seg.ucn` and `chosen.tetraploid.bbc.ucn`, `chosen.tetraploid.seg.ucn`, respectively. +Last, hatchet copies the best solution according to the prediction of WGD in the two files `best.bbc.ucn` and `best.seg.ucn`. + +## Fractional copy numbers + +The first feature of hatchet is the explicit estimation of allele-specific fractional copy numbers. +hatchet performs this estimation based on rigorous criterion stating that allele-specific fractional copy numbers can be obtained from RDR and BAF of clusters of genomic regions. +More specifically, the criterion states that: +- when there is no WGD, the identification of the diploid cluster with copy-number state (1, 1) is sufficient +- when there is a WGD, the identification of the tetraploid cluster with copy-number state (2, 2) and of a second clonal cluster with a copy-number state (A, B) in all tumor clones are sufficient. + +As such, hatchet identifies a heuristic to identifies the required clusters and copy-number states. +This heuristic can be controlled by the following parameters: + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-c`, `--clonal` | The required clusters and corresponding copy number states | User can directly specifies the required clusters and the corresponding copy number states to compute the allele-specific fractional copy number states. These must be speficied in the format `IDX-1:A-1:B-1, ..., IDX-M:A-M:B-M` where `IDX-S` is the name of cluster `S` and `(A-S, B-S)` is the corresponding copy-number state. Moreover, user can specify addittional clusters and copy numbers beyond the required ones. The copy-numbers for these clusters will be fixed during the computation. This can be an usefule feature for especially noisy datasets. | None | +| `-ts`, `--minsize` | Threshold for size of clusters | The minimum size of the clusters to consider for the heuristic that identifies clonal clusters. The non-selected clusters will not be considered as potential tumor-clonal clusters. The threshold must be expressed as a fraction of the entire genome. | 0.02, e.g. `2%` of genome | +| `-tc`, `--minchrs` | Threshold for number of chromosomes | The minimum number of chromosomes covered by the clusters to consider for the heuristic that identifies clonal clusters. The non-selected clusters will not be considered as potential tumor-clonal clusters. | 1 | +| `-td`, `--maxneutralshift` | Maximum BAF shift allowed for diploid cluster | The maximum expected shift from 0.5 for BAF for a diploid or tetraploid cluster (i.e. with copy-number states (1, 1) or (2, 2)). This threshold is used for two goals to identify the diploid or tetraploid cluster. | 0.1 | +| `-tR`, `--toleranceRDR` | Maximum RDR tolerance | The maximum RDR tolerance used by the heuristic when estimating the position of all clonal clusters | 0.04 | +| `-tB`, `--toleranceBAF` | Maximum BAF tolerance | The maximum BAF tolerance used by the heuristic when estimating the position of all clonal clusters | 0.03 | +| `--merge` | Activate merging of clusters | When activated, the heuristic will merge together clusters that appear to have the same values of RDR and BAF, according to the values below. This procedure can help the heuristic by refining the clustering and merging clusters that are likely to have the same copy-number states and unlikely to be clonal. | False, not used | +| `-mR`, `--mergeRDR` | RDR merging threhsold | The maximum difference in RDR considered by the merging procedure | 0 | +| `-mB`, `--mergeBAF` | BAF merging threhsold | The maximum difference in BAF considered by the merging procedure | 0 | + +## Simultaneous factorization + +The second feature corresponds to the simultaneous factorization of allele-specific copt numbers and clone proportions. +hatchet solves a constrained and distance-based variant of the factorization that can be controlled by the following parameters. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-n`, `--clones` | Interval for number of clones | User can specify the minimum and maximum number of clones to consider | `""2,8""` | +| `-eD`, `--diploidcmax` | Maximum copy number with no WGD | The value of maximum copy number that is considered when assuming no WGD. When `0`-value is specified the maximum copy number is directly inferred from the data by rounding the maximum fractional copy number | 8 | +| `-eT`, `--tetraploidcmax` | Maximum copy number with a WGD | The value of maximum copy number that is considered when assuming there is a WGD. When `0`-value is specified the maximum copy number is directly inferred from the data by rounding the maximum fractional copy number | 8 | +| `-u`, `--minprop` | Minimum clone proportion | In every sample, each clone either is non present (clone proportion equal to 0.0) or has a clone proportion higher than this threshold | 0.03 | +| `-f`, `--noampdel` | Activate clone evolutionary contraints | User can decide whether to enable or not constrained about the evolution of tumor clones. These constrained force each allele to be either amplified or deleted across all tumor clones | Activated | +| `-d`, `--cnstates` | Maximum number of distinct copy-number states per cluster | When enabled, the maximum number of distinct copy-number states per cluster is fixed. This option is deprecated | Not used | + +HATCHet implements two methods to solve the constrained and distance-based simultaneous factorization: (1) a integer-linear programming (ILP) and (2) a coordinate-descent method (CD). +These methods can be combined in 3 different modes: +- (0) CD + ILP: the solution found by CD is used to start the ILP. As such, ILP attempts to improve the solution found by CD. +- (1) ILP only +- (2) CD only + +The mode can be specified through the flag `--mode` whose default is mode 2. +In addition, the solving methods can be controlled by the following parameters. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-j`, `--jobs` | Number of parallel jobs | Every job will run on parallel a different seed of the CD algorithm and all the jobs can be used for solving the ILP | Number of available processes on machine | +| `-p`, `--seeds` | Number of CD seeds | Number of random restarts executed by the CD algorithm. In general, the higher the number of restarts, the better the result | 400 | +| `-r`, `--randomseed` | Seed for random generator | Every execution started from the same seed have a deterministic behaviour and can be exactly replicated | None, random seed | +| `-s`, `--timelimit` | Time limit | The time limit, expressed in seconds, is imposed to every step of the CD algorithm or to the whole ILP | None | +| `-m`, `--timelimit` | Memory limit | The memory limit, expressed in megabytes, is imposed to every step of the CD algorithm or to the whole ILP. The execution will not be interrupted when reaching the threshold but disk is used | None | +| `--maxiterations` | Maximum number of iteration per seed | This number is imposed as the maximum number of iterations executed for every restart of the CD algorithm | 40 | +| `--diploid` | Assume no WGD | When enabled, HATCHet assumes the absence of a WGD | Not used | +| `--tetraloid` | Assume a WGD | When enabled, HATCHet assumes the occurrence of a WGD | Not used | + +## Model selection + +This steps have two main parameters to control the model-selection criterion: + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-l`, `--limitinc` | Sensitivity level | The sensitivity level is used to control the confidence in evaluating the presence of tumor clones characterized by small CNAs. By decreasing the value of the sensitivity, HATCHet is more sensible to the presence of small CNAs and small clusters or with small shifts in RDR/BAF are more likely considered as the signal of an additional tumor clone. The possible values of this parameter are between 1.0 and 0.0 and specifically corresponds to an upper bound for the left relative improvement of the objective function. | None, reasonable values to use can be 0.6, 0.5, 0.4, 0.3, 0.2, ... according to the values of the objective function. | +| `-g`, `--ghostprop` | Confidence in the presence of a single tumor clone | This value expresses the confidence of HATCHet when evaluating the presence of a single tumor clone. The higher the value the more likely the presence of a single clone is considered | 0.2 | + +## Additional parameters +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_combine_counts_fw.md",".md","5234","76","# combine-counts-fw + +NOTE: This function (formerly called `comBBo`) uses the legacy fixed-width binning described in the HATCHet paper. We recommend using [`count-reads`](doc_count_reads.md) and [`combine-counts`](doc_combine-counts.md) which apply an adaptive binning scheme to ensure that each genomic bin has comparable BAF signal. + +This step combines the read counts and the allele counts for the identified germline SNPs to compute the read-depth ratio (RDR) and B-allele frequency (BAF) of every genomic bin. + +## Input + +combine-counts-fw takes in input three tab-separate files: + +1. A file of read counts for genomic bins obtained from the matched-normal sample, specified by the flag `-c`, `--normalbins`. The tab separated file has the following fields. + +| Field | Description | +|-------|-------------| +| `SAMPLE` | Name of the matched-normal sample | +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `COUNT` | Count of sequencing reads in the corresponding bin | + +2. A file of read counts for genomic bins obtained from all the tumor samples, specified by the flag `-C`, `--tumorbins`. The tab separated file has the following fields. + +| Field | Description | +|-------|-------------| +| `SAMPLE` | Name of a tumor sample | +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `COUNT` | Count of sequencing reads in the corresponding bin | + +3. A file of allele counts for heterozygous germline SNPs obtained from all the tumor samples, specified by the flag `-B`, `--tumorbafs`. The tab separated file has the following fields. + +| Field | Description | +|-------|-------------| +| `SAMPLE` | Name of a tumor sample | +| `CHR` | Name of a chromosome | +| `POS` | Genomic position corresponding to a heterozygous germline in `CHR` | +| `REF_COUNT` | Count of reads covering `POS` with reference allele | +| `ALT_COUNT` | Count of reads covering `POS` with alternate allele | + +## Output + +combine-counts-fw produces a tab-separated file with the following fields. + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `RD` | RDR of the bin in `SAMPLE` | +| `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | +| `COV` | Average coverage in the bin in `SAMPLE` | +| `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | +| `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | +| `BAF` | BAF of the bin in `SAMPLE` | + +## Main parameters + +combine-counts has some main parameters; the main values of these parameters allow to deal with most of datasets, but their values can be changed or tuned to accommodate the features of special datasets. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-d`, `--diploidbaf` | Maximum expected shift from 0.5 for BAF of diploid or tetraploid clusters | The maximum shift is used to identify all the potential clusters with base states (1, 1) or (2, 2). The value depends on the variance in the data (related to noise and coverage); generally, higher variance requires a higher shift. Information provided by plot-bins can help to decide this value in special datasets. | 0.08 (other typically suggested values are 0.1-0.11 for higher variance and 0.06 for low variance) | + +## Optional parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-v`, `--verbose` | Verbose logging flag | When enabled, combine-counts outputs a verbose log of the executiong | Not used | +| `-r`, `--disablebar` | Disabling progress-bar flag | When enabled, the output progress bar is disabled | Not used | +| `-b`, `--normalbafs` | File of allele counts for SNPs in matched-normal sample | When provided, combine-counts attempts to correct the estimated BAF using the variance in matched-normal sample. | Not used (deprecated) | +| `-d`, `--diploidbaf` | Maximum expected shift from 0.5 for BAF of diploid or tetraploid clusters | The maximum shift is used to identify potential potential bins with base states (1, 1) or (2, 2) whose BAF needs to be corrected. The value depends on the variance in the data (related to noise and coverage); generally, higher variance requires a higher shift. Information provided by plot-bins can help to decide this value in special datasets. | 0.08 (other typically suggested values are 0.1-0.11 for higher variance and 0.06 for low variance) | +| `-t`, `--totalcounts` | File of total read counts | When provided, the total read counts are used to normalize the read counts from the corresponding sample | Not used (deprecated) | +| `-m`, `--mode` | Mode used to estimate BAFs | Different modes are provided to combine to combine the allele counts of SNPs | The counts from the allele with minor count are combined (deprecated) | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_cluster_bins_gmm.md",".md","6933","86","# cluster-bins-gmm + +This step globally clusters genomic bins along the entire genome and jointly across tumor samples, and estimate the corresponding values of RDR and BAF for every cluster in every sample. +cluster-bins-gmm uses a non-parametric Gaussian mixture model (GMM) (scikit-learn implementation) for clustering; the main parameters can be tuned for dealing with special datasets, especially those with high variance or low tumor purity (see [Main Parameters](#main-parameters) below). + +## Input + +cluster-bins-gmm takes in input a tab-separated file with the following fields. + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `RD` | RDR of the bin in `SAMPLE` | +| `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | +| `COV` | Average coverage in the bin in `SAMPLE` | +| `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | +| `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | +| `BAF` | BAF of the bin in `SAMPLE` | + +The fields `#SNPS`, `COV`, `ALPHA`, and `BETA` are currently deprecated and their values are ignored. + +## Output + +cluster-bins-gmm produces two tab-separated files: + +1. A file of clustered genomic bins, specified by the flag `-O`, `--outbins`. The tab separated file has the same fields as the input plus a last field `CLUSTER` which specifies the name of the corresponding cluster. + +2. A file of clustered genomic bins, specified by the flag `-o`, `--outsegments`. The tab separated file has the following fields. + +| Field | Description | +|-------|-------------| +| `ID` | The name of a cluster | +| `SAMPLE` | The name of a sample | +| `#BINS` | The number of bins included in `ID` | +| `RD` | The RDR of the cluster `ID` in `SAMPLE` | +| `#SNPS` | The total number of SNPs in the cluster `ID` | +| `COV` | The average coverage in the cluster `ID` | +| `ALPHA` | The alpha parameter of the binomial model for the BAF of the cluster `ID` | +| `BETA` | The beta parameter of the binomial model for the BAF of the cluster `ID` | +| `BAF` | The BAF of the cluster `ID` in `SAMPLE` | + + +## Main parameters + +cluster-bins-gmm has 4 main features with some main parameters that allow to improve the clustering. + +1. cluster-bins-gmm has a parameter `-d`, `--diploidbaf` that specifies the maximum expected shift from 0.5 for BAF for a diploid or tetraploid cluster (i.e. with copy-number states (1, 1) or (2, 2)). This threshold is used for two goals: (1) To identify the diploid or tetraploid cluster which is used to correct the estimated BAF of potentially biased clusters. (2) To identify potentially biased clusters. +The default value of this parameter (0.1) is typically sufficient for most of the datasets, but its value can be changed or tuned to accommodate the features of special datasets. +In particular, the value of this threshold depends on the variance in the data (related to noise and coverage); generally, higher variance requires a higher shift. +Information provided by plot-bins can be crucial to decide whether one needs to change this value in special datasets. + +2. cluster-bins-gmm has some main parameters to control the clustering; the default values for most of these parameters allow to deal with most of datasets, but their values can be changed or tuned to accommodate the features of special datasets. +plot-bins provides informative plots that can be used to assess the quality of the clustering and evaluate the need of changing some parameters for special datasets. +If your clusters do not appear to be cohesive, try lowering the maximum number of clusters (`-K`) which will force cluster-bins-gmm to infer fewer clusters. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-K`, `--initclusters` | Maximum number of clusters | The parameter specifies the maximum number of clusters to infer, i.e., the maximum number of GMM components | 50 | +| `-c`, `--concentration` | Concentration parameter for clustering | This parameter determines how much confidence the GMM has in different types of clusterings. Higher values (e.g., 10 or 100) favor fewer clusters, and smaller values (e.g., 0.01 or 0.001) favor more clusters. For experts, this is the alpha parameter for the Dirichlet process prior. | 1/K | + +3. cluster-bins-gmm offers a bootstraping approach that allows a succesfull clustering even when there is a limited number genomic bins that are considred. The bootstraping approach generates sinthetic (i.e. used only for clustering) bins based on the data of the given bins. The bootstraping is controlled by the following parameters. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-u`, `--bootclustering` | Number of sinthetic bins to generate | Sinthetic bins can be generated based on the RDR and BAF of given bins and are added only to the clustering to improve it when the total number of bins is low (e.g. when considering data from WES) | 0, not used | +| `-dR`,`--ratiodeviation` | Standard deviation for generate RDR of sinthetic bins | The parameter affects the variance of the generated data, this value can be estimated from given bins and plot-bins generates informative plots to do this | 0.02 | +| `-dB`,`--bafdeviation` | Standard deviation for generate BAF of sinthetic bins | The parameter affects the variance of the generated data, this value can be estimated from given bins and plot-bins generates informative plots to do this | 0.02 | +| `-s`, `--seed` | Random seed | The value is used to seed the random generation of RDR and BAF of synthetic bins | 0 | + +4. cluster-bins-gmm offers a basic iterative process to merge clusters according to given tolerances. This feature can be used to refine the results of the GMM clustering and merge distinct clusters that are not sufficiently distinguished. This process can be controlled by the following parameters. + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-tR`, `--tolerancerdr` | Tolerance for RDR | The value is used to determine when two clusters should be merged in terms of RDR | 0.0, merging is not performed | +| `-tB`, `--tolerancebaf` | Tolerance for BAF | The value is used to determine when two clusters should be merged in terms of BAF | 0.0, merging is not performed | + +## Optional parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-v`, `--verbose` | Verbose logging flag | When enabled, combine-counts outputs a verbose log of the executiong | Not used | +| `-r`, `--disablebar` | Disabling progress-bar flag | When enabled, the output progress bar is disabled | Not used | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_plot_cn.md",".md","9226","143","# plot-cn + +This step analyzes the inferred copy-number states and clone proportions and produces informative plots jointly considering all samples from the same patient. In addition, this step can also combine results obtained for different patients and perform integrative analysis. +plot-cn produces several informative plots concerning the copy-number states and proportions for the inferred clones from multiple tumor samples of a patient. +In additionl, plot-cn can also produce some informative plots to compare the solutions obtained on different patients. + +When `plot_cn = True` is indicated in `hatchet.ini`, the command [`plot-cn-1d2d`](plot_cn_1d2d.md) will also be run. This command produces alternate plots in which bins are colored by cluster and colors match across samples between the 2D cluster view and 1D genomic view. In addition, these plots show the expected positions of the assigned copy-number states as labeled points in the 2D plots and black bars in the 1D plots. + +## Input + +plot-cn considers in input one or more tab-separated files. Each of these files contains the inferred copy-number states and clone proportions for clustered genomic bins and has the following format: + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `RD` | RDR of the bin in `SAMPLE` | +| `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | +| `COV` | Average coverage in the bin in `SAMPLE` | +| `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | +| `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | +| `BAF` | BAF of the bin in `SAMPLE` | +| `CLUSTER` | The name of the corresponding cluster of the bin in `SAMPLE` | +| `cn_normal` | The copy number state of the normal diploid clone equal to 1|1 | +| `u_normal` | The normal admixture of the normal diploid cells in the corresponding sample | +| `cn_clone${n}` | The copy number state of the `${n}` tumor clone in the format A|B where `A` and `B` are the two allele-specific copy numbers of the corresponding genomic bin | +| `u_clone${n}` | The clone proportion of the `${n}` tumor clone in the corresponding sample | + +When a single file is speicified, the input is given directly and plot-cn runs in single-patient mode. +When multiple files are speicified, the files are given in a white-space separated list of filenames between ""..."" and plot-cn runs in multi-patient mode. + +## Parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-x`, `--rundir` | Outpud directory | Directory where the output files are generated | Current directory | +| `-n`, `--patientnames` | Names of the patients | White-space separated list of patient names is used when running in multi-patient mode | Inferred from file names | +| `-u`, `--minu` | Minimum CNA proportion | A minimum CNA proportion that is used as a minimum threshold to exclude CNA present in lower proportions from the plot | 0.2 | +| `-e`, `--threshold` | Tumor ploidy threshold for WGD/no WGD | This is the value of tumor ploidy which is used to determine either the absence or presence of a WGD which determine the basic copy number equal to either 2 or 4 | 3.0 | +| `-b`, `--baseCN` | Base copy number | Force base copy number to be equal to this value for determining the grey colors on plots | None, inferred tumor ploidy | +| `-sC`, `--figsizeclones` | Size of tumor-clone plots | The size should be given in the format `(X-SIZE, Y-SIZE)` | `(12, 3)` | +| `-sP`, `--figsizecn` | Size of copy-number plots | The size should be given in the format `(X-SIZE, Y-SIZE)` | `(16, 4)` | +| `-sG`, `--figsizegrid` | Size of grid plots | The size should be given in the format `(X-SIZE, Y-SIZE)` | `(20, 10)` | +| `-rC`, `--resolutionclones` | Resolution for tumor-clone plots | Number of bins that are merged together when plotting tumor-clone profiles | 100 | +| `-rP`, `--resolutioncn` | Resolution for copy-number plots | Number of bins that are merged together when plotting copy-number profiles | 500 | +| `-rG`, `--resolutiongrid` | Resolution for grid plots | Number of bins that are merged together for grid plots | 100 | +| `--ymax` | Maximum value in y-axis | Fix the maximum y-axis value | Automatically inferred | +| `--ymin` | Minimum value in y-axis | Fix the minimum y-axis value | Automatically inferred | +| `--clonepalette` | Name of color palette | Color palette to use for coloring tumor clones among the ones available, including `Set1, Set2, Set3, Paired` | `Set1` | +| `--linkage` | Linkage method | The linkage method to use for the clustering of the rows in grdin and tumor-clone plots, including \{single, complete, average, weighted, centroid, median, ward\} from SciPy | single | + +## Single-patient (intra-tumor) + +In the following, we report an example of all the plots produced in single-patient mode obtained by running the following command: + + python plot_cn.py A12.bbc.ucn -sG ""(16,4)"" + +*** + +### Total copy numbers of tumor clones + +The total copy number for every genomic region, sorted across chromosomes, with a color identifiying each tumor clone. +When the total copy numbers of different clones overlap the same value, the corresponding bars are slightly shifted. + +![](intratumor-clones-totalcn.png ""intratumor-clones-totalcn"") + +*** + +### Allele-specific copy numbers of tumor clones + +The allele-specific copy number for every genomic region, sorted across chromosomes, with a color identifiying each tumor clone. +The A-allele is represented in the top part and the B-allele in the bottom part (the negative sign should be ignored). +When the allele-specific copy numbers of different clones overlap the same value, the corresponding bars are slightly shifted. + +![](intratumor-clones-allelecn.png ""intratumor-clones-allelecn"") + +*** + +### Proportions of total copy numbers per sample + +For each sample, the proportions across the different total copy numbers are represented for every genomic region. + +![](intratumor-copynumber-totalcn-0.png ""intratumor-copynumber-totalcn-0"") +![](intratumor-copynumber-totalcn-1.png ""intratumor-copynumber-totalcn-1"") +![](intratumor-copynumber-totalcn-2.png ""intratumor-copynumber-totalcn-2"") + +*** + +### Proportions of allele-specific copy numbers per sample + +For each sample, the proportions across the different allele-specific copy numbers are represented for every genomic region. +The proportions of A-specific copy numbers are represented in the top part of the plot with positive values, while the proportions of B-specific copy numbers are represented in the bottom part of the plot with negative values. + +![](intratumor-copynumber-allelecn-0.png ""intratumor-copynumber-allelecn-0"") +![](intratumor-copynumber-allelecn-1.png ""intratumor-copynumber-allelecn-1"") +![](intratumor-copynumber-allelecn-2.png ""intratumor-copynumber-allelecn-2"") + +*** + +### Copy-number profiles of tumor clones + +Every row of the main grid corresponds to a tumor clone and the total copy number for each genomic region is represented, such that the regions are sorted across the crhomosomes represented on the top as alternating gray boxes. +A heatmap in the left side of the figure represents the clone proprtions across every sample (columns). +Also, on the left-most side of the figure a dendogram represents a clustering of the tumor clones. + +![](intratumor-profiles.png ""intratumor-profiles"") + +*** + +### Reduced copy-number profiles of tumor clones + +Every row of the main grid corresponds to a tumor clone and the corredponsing reduced total copy number for each genomic region is represented, such that the regions are sorted across the crhomosomes represented on the top as alternating gray boxes. +More specifically, a region is classified as: +- 0 when the total copy number is equal to the base +- -1 when it corresponds to a deletion (total copy number lower than base) +- 1 when it corresponds to an amplification (total copy number higher than base). + +A heatmap in the left side of the figure represents the clone proprtions across every sample (columns). +Also, on the left-most side of the figure a dendogram represents a clustering of the tumor clones. + +![](intratumor-profilesreduced.png ""intratumor-profilesreduced"") + +*** + +### Mixture profiles of tumor samples + +Every row of the main grid corresponds to a tumor sample and the corredponsing reduced-fractional copy number for each genomic region is represented, such that the regions are sorted across the crhomosomes represented on the top as alternating gray boxes. +More specifically, the fractional copy number are computed from the mixed profiles. +A heatmap in the left side of the figure represents the clone proprtions across every sample (columns). +Also, on the left-most side of the figure a dendogram represents a clustering of the tumor samples. + +![](intratumor-mixtures.png ""intratumor-mixtures"") + +*** + +### Subclonality + +This plot is not currently functioning properly. + +*** +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_genotype_snps.md",".md","3310","43","# genotype-snps + +Given the normal BAM file, this step of HATCHet identifies heterozygous germline SNP positions. The user can restrict candidate positions to a given list (e.g., dbSNP) using the `-R, --snps` argument. + +## Input + +genotype-snps takes in input a sorted and index BAM file from a matched-normal sample and an indexed human reference genome (preferrably the same version as was used for alignment). + +| Name | Description | Usage | +|------|-------------|-------| +| `-N`, `--normal` | A sorted-indexed BAM file | The matched normal sample | +| `-r`, `--reference` | A FASTA file | The human reference genome used for germline variant calling | + +## Output + +genotype-snps produces a tab-separated VCF file for each chromosome which contains a list of the genomic positions that have been identified as germline heterozygous SNPs in the matched-normal sample. + +| Name | Description | Format | +|------|-------------|--------| +| `-l`, `--outputsnps` | the output file for the list of identified heterozygous germline SNPs | `#CHR POS` | + +## Main parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-R`, `--snps` | VCF files | Optional list of candidate SNP positions to consider | None* | +| `-st`, `--samtools` | Path to `bin` directory of SAMtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | +| `-bt`, `--bcftools` | Path to `bin` directory of BCFtools | The path to this direcoty needs to be specified when it is not included in `$PATH` | Path is expected in the enviroment variable `$PATH` | +| `-c`, `--mincov` | Minimum coverage | Minimum number of reads that have to cover a variant to be called, the value can be increased when considering a dataset with high depth (>60x) | 0 | +| `-C`, `--maxcov` | Maximum coverage | Maximum number of reads that have to cover a variant to be called, the typically suggested value should be twice higher than expected coverage to avoid sequencing and mapping artifacts | 1000 | +| `-j`, `--processes` | Number of parallel jobs | Parallel jobs are used to consider the chromosomes in different samples on parallel. The higher the number the better the running time | 2 | + +*When run as a standalone module, the no SNP list is used by default. When run as part of `hatchet run` and no `--snps` argument is supplied, the correct version of dbSNP is automatically downloaded and used to call SNPs. + +## Optional parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-v`, `--verbose` | Verbose logging flag | When enabled, count-alleles outputs a verbose log of the executiong | Not used | +| `-q`, `--readquality` | Threshold for phred-score quality of sequencing reads | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of sequencing reads | 0 | +| `-Q`, `--basequality` | Threshold for phred-score quality of sequenced nucleotide bases | The value can be either decreased (e.g. 10) or increased (e.g. 30) to adjust the filtering of sequenced nucleotide bases | 11 | +| `-E`,`--newbaq` | Flag to enable `newbaq` veafute of SAMtools | When selected, the user asks SAMtools to recompute alignment of reads on the fly during SNP calling | Not used | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_compilation.md",".md","1697","34","# Detailed compilation + +To perform the compilation, execute the following commands from the root of HATCHet's repository. + +```shell +$ mkdir build +$ cd build/ +$ ccmake .. +$ make +``` + +HATCHet's compilation process attempts to automatically find the following Gurobi's paths. + +| Name | Path | Comment | +|------|------|---------| +| `GUROBI_CPP_LIB` | `/to/gurobiXXX/YY/lib/libgurobi_c++.a` |
  • `/to/gurobi` is the path to Gurobi's home, typically `/opt/gurobiXXX` for linux and `/Library/gurobiXXX` for mac
  • `XXX` is the Gurobi full version, e.g. 702 or 751
  • `YY` depends on os, typically `linux64` for linux or `mac64` for mac
| +| `GUROBI_INCLUDE_DIR` | `/to/gurobiXXX/YY/include` |
  • `/to/gurobi` is the path to Gurobi's home
  • `XXX` is the Gurobi full version
  • `YY` depends on os
| +| `GUROBI_LIB` | `/to/gurobiXXX/YY/lib/libgurobiZZ.QQ` |
  • `/to/gurobiXXX` is the path to Gurobi's home
  • `XXX` is the Gurobi full version
  • `YY` depends on os
  • `ZZ` are typically the first 2 numbers of `XXX`
  • `QQ` is typically `so` but becomes `dylib` for MAC version since version 8.10
| + +If the automatic compilation fails to find the Gurobi's paths, these need to be specified directly. First, user needs to verify the existence of each of these 3 files. Next, user can specify these paths directly by either using + +```shell +$ ccmake .. +``` + +or by directly running `CMake` with proper flags as following + +```shell +$ cmake .. \ + -DGUROBI_CPP_LIB=/to/gurobiXXX/YY/lib/libgurobi_c++.a \ + -DGUROBI_INCLUDE_DIR=/to/gurobiXXX/YY/include \ + -DGUROBI_LIB=/to/gurobiXXX/YY/lib/libgurobiZZ.QQ +``` +","Markdown" +"Allele","raphael-group/hatchet","docs/source/conf.py",".py","3429","112","#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +# +# BSS documentation build configuration file, created by +# sphinx-quickstart on Tue May 1 10:26:43 2018. +# +# This file is execfile()d with the current directory set to its +# containing dir. +# +# Note that not all possible configuration values are present in this +# autogenerated file. +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +import os +import sys +import sphinx_rtd_theme + +sys.path.insert(0, os.path.abspath(""../src"")) +import hatchet # noqa: E402 + +# -- General configuration ------------------------------------------------ + +# If your documentation needs a minimal Sphinx version, state it here. +# +# needs_sphinx = '1.0' + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + ""sphinx.ext.autodoc"", + ""sphinx.ext.mathjax"", + ""sphinxcontrib.bibtex"", + ""numpydoc"", + ""recommonmark"", + ""sphinx_markdown_tables"", +] + +# Add any paths that contain templates here, relative to this directory. +templates_path = [""_templates""] + +# The suffix(es) of source filenames. +# You can specify multiple suffix as a list of string: +# +# source_suffix = ['.rst', '.md'] +# source_suffix = '.rst' + +# Extra file to copy over to the build directory +html_extra_path = [ + ""../../script/hatchet.ini"", + ""../../custom/GATK4-CNV/sample1.GATK4.CNV.seg"", + ""../../custom/GATK4-CNV/sample2.GATK4.CNV.seg"", + ""../../custom/GATK4-CNV/custom-gatk4-cnv.sh"", +] + +# The master toctree document. +master_doc = ""index"" + +# General information about the project. +project = ""HATCHet"" +copyright = ""2021, Princeton University"" +author = ""Simone Zaccaria"" + +# The version info for the project you're documenting, acts as replacement for +# |version| and |release|, also used in various other places throughout the +# built documents. +# +# The short X.Y version. +version = hatchet.__version__ +# The full version, including alpha/beta/rc tags. +release = version + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set ""language"" from the command line for these cases. +language = None + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This patterns also effect to html_static_path and html_extra_path +exclude_patterns = [] + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = ""sphinx"" + +# If true, `todo` and `todoList` produce output, else they produce nothing. +todo_include_todos = False + + +# -- Options for HTML output ---------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = ""sphinx_rtd_theme"" +html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] + +# -- Options for HTMLHelp output ------------------------------------------ + +# Output file base name for HTML help builder. +htmlhelp_basename = ""hatchet"" + +autoclass_content = ""both"" +","Python" +"Allele","raphael-group/hatchet","docs/source/doc_runhatchet.md",".md","13663","196","# Tutorial + +This tutorial illustrates how to use the complete pipeline through the `hatchet run` command, along with the configuration [hatchet.ini](hatchet.ini) file that stores all the variables the user needs to specify. + +The tutorial is subdivided into some subsections and each of these describes sequential parts of the full pipeline: +1. [Preliminaries](#preliminaries) +2. [genotype-snps](#genotype-snps) +3. [count-alleles](#count-alleles) +4. [count-reads](#count-reads) +5. [combine-counts](#combine-counts) +6. [cluster-bins](#cluster-bins) +7. [plot-bins](#plot-bins) +8. [compute-cn](#compute-cn) +9. [plot-cn](#plot-cn) + +We suggest you make a copy of the configuration file, place it into the designated running directory, and follow the tutorial. + +## Preliminaries + + +The following variables, specified in [hatchet.ini](hatchet.ini), should be changed according to the user's data: + +```shell +# Path to reference genome - make sure you have also generated the reference dictionary as /path/to/reference.dict +reference = ""/path/to/reference.fa"" +normal = ""/path/to/normal.bam"" +# Space-delimited list of tumor BAM locations +bams = ""/path/to/tumor1.bam /path/to/tumor2.bam"" +# Space-delimited list of tumor names +samples = ""Primary Met"" + +``` + +Each of these are explained further below. + +*** + +```shell +reference = ""/path/to/reference.fa"" +reference_version = """" +chr_notation = True +``` + +First, you need to specify the full path to the human reference genome with the variable `reference`, along with the specific version of this reference with the `reference_version` variable, which may be ""hg19"" or ""hg38"". This reference version is used to select a list of known germline SNPs to genotype samples. Lastly, the `chr_notation` must be set to true/false depending on whether or not the chromosomes in your reference are prefixed with ""chr"". + +*** + +```shell +normal = ""/path/to/normal.bam"" +bams = ""/path/to/tumor1.bam /path/to/tumor2.bam"" +samples = ""Primary Met"" +``` + +Next, you need to specify the full paths to the required input data: +1. `normal` is the full path to the BAM file of matched-normal samples +2. `bams` is a white-space separated list of the BAM files for the multiple tumor samples from the considered patient. + +The variable `samples` is also a white-space separated list of tumor sample names (specified in the same order as the BAM files in `bams`), and these names are used in the plots produced by HATCHet. + +*** + +```shell +mincov = 8 +maxcov = 300 +``` + +Both `mincov` and `maxcov` specify the minimum and maximum sequencing depth for considering germline snps. For samples that have undergone whole-genome sequencing with depths >30X, values around 8 and 300 should be reasonable for the minimum and maximum, respectively. For samples in which only the exome was sequenced to ~100X, then values around 20 and 1000 should be fine for the minimum and maximum, respectively. + +*** + +## genotype-snps + + +```shell +python3 -m hatchet genotype-snps -N ${NORMAL} -r ${REF} -j ${J} -c ${MINREADS} -C ${MAXREADS} \ + -R ${LIST} -o ${SNP} |& tee ${BAF}bafs.log +``` + +genotype-snps genotypes germline SNPs from the matched-normal sample `${NORMAL}`, using positions of known germline variation specified by the file in `${LIST}`. If this parameter is omitted, heterozygous SNPs are inferred from the normal sample. As mentioned above, SNPs are only considered for downstream analysis if they have a minimum and maximum sequencing depth of `${MINREADS}` and `${MAXREADs}`, respectively. + +GATK best practices suggest that the maximum should be at least twice the expected average coverage to avoid mapping artifacts. +Observe that WES generally requires higher thresholds (e.g. 100 and 3000). +Also, an increasing in the minimum threshold allow to improve the quality of the estimated BAF (computed in the next step), while a decreasing it allows us to consider more SNPs. + +## [count-alleles](doc_count_alleles.html) + + +```shell +python3 -m hatchet count-alleles -N ${NORMAL} -T ${BAMS} -S ${ALLNAMES} -r ${REF} \ + -j ${J} -c ${MINREADS} -C ${MAXREADS} -L ${SNP}*.vcf.gz \ + -O ${BAF}normal.1bed -o ${BAF}tumor.1bed |& tee ${BAF}bafs.log +``` + +count-alleles uses these germline SNPs from genotype-snps (specified in the list `${SNP}*.vcf.gz`) and computes the corresponding allele counts from all tumor samples `${BAMS}`. +As for all steps in this pipeline, the same reference genome used for the BAM files has to be specified by `${REF}`. +Minimum and maximum thresholds for the read counts of germline SNPs are again specified with `${MINREADS}` and `${MAXREADS}`. + +Several simple parameters are also specified including: number of parallel threads, output filenames, and the log filename of this step. + + +## [count-reads](doc_count_reads.html) + + +```shell +python3 -m hatchet count-reads -N ${NORMAL} -T ${BAMS} -S ${ALLNAMES} -b ${BAF}tumor.1bed \ + -j ${J} -O ${RDR}normal.1bed -O {RDR} -V {REF_VERSION} |& tee ${RDR}bins.log +``` + +`count-reads` identifies candidate bin thresholds using the SNPs identified by `count_alleles` (in `${BAF}tumor.1bed `), and counts the number of reads in each tumor sample `${BAMS}` as well as in the normal sample `{$NORMAL}` that fall within each interval as well as the number of reads overlapping each threshold. It uses the centromere locations corresponding the the reference genome version `${REF_VERSION}` (hg19 or hg38) to avoid constructing bins that overlap centromeres. This step produces a gzip-compressed file for each chromosome and each sample in the `${RDR}` directory, as well as an ordered list `${RDR}samples.txt` of sample labels. It also counts the total reads in each of the BAM files and writes it to `${RDR}total.tsv`. +Other simple parameters are also specified including number of parallel threads, output filenames, and the log filename of this step. + + +## [combine-counts](doc_combine_counts.html) + + +```shell +python3 -m hatchet combine-counts -A ${RDR} -t ${RDR}total.tsv -b {BAF}tumor.1bed -o #{BB}bulk.bb \ + --msr ${msr} --mtr ${mtr} -j ${J} \ + -p ${PHASE} -s ${max_blocksize} -m {max_spb} -a {alpha} # optional phasing args +``` + +combine-counts constructs genomic bins such that in all samples, each bin has at least `${msr}` SNP-covering reads and at least `${mtr}` total reads. Bins will not have the same width, but using this rule each bin will have comparable RDR and BAF signals for the following clustering steps. The BAF for each bin and the relative phase of all SNPs in the bin are inferred via EM, and the RDR for each bin is computed fom the read count files in the `${RDR}` folder. After this computation, RDR values are normalized using the total reads in each sample (from `${RDR}total.tsv`). As with other HATCHet commands, `-j ${J}` controls the number of parallel processes. + +See the [script](script/README.md) directory for a guide on how to run HATCHet with phasing. If a phased VCF file is supplied via `-p, --phase ${PHASE}` (e.g., `-p phase/phased.vcf.gz`), SNPs are merged into blocks before BAF inference. Each block contains at most `${max_spb}` such that no two SNPs in the same block are further apart than `${max_blocksize}`, and such that no two adjacent SNPs have significantly different marginal BAF estimates (at significance level `${alpha}` -- higher `${alpha}` corresponds to less trust in the phasing results). Then, blocks are passed to the EM which determines the relative phase of each block. + +## [cluster-bins](doc_cluster_bins.html) + + +```shell +python3 -m hatchet cluster-bins ${BB}bulk.bb -o ${BBC}bulk.seg -O ${BBC}bulk.bbc \ + -minK 5 -maxK 10 -tau 0.0001 -d 0.08 +``` + +cluster-bins globally clusters genomic bins based on RDR and BAF (specified in a BB file `${BB}bulk.bb`) jointly along the genome and across all tumor samples. This *locality-aware* clustering takes into account the contiguity of bins along the genome to inform the clustering. + +The main parameters are as follows: +- The maximum expected BAF shift `-d` for a balanced cluster, here set to `0.08`. This parameter should be as small as possible while still including the clusters with the closest BAF to 0.5. +- Parameters `minK` and `maxK` which specify the minimum and maximum (respectively) of clusters to consider. Alternatively, one can specify `exactK` to fix the number of clusters at a given value. +- Parameter `tau` which controls the trade-off between local and global information: lower `tau` puts more weight on *local* information (i.e., adjacent bins on each chromosome arm) while higher `tau` puts more weight on *global* information (i.e., RDR and BAF values). + +The plots from `plot-bins` are helpful to evaluate clusterings and tune parameters. + +Other parameters are used to specify the output files containing the cluster information (`${BBC}bulk.seg`) and the clustered genomic bins (`${BBC}bulk.bbc`). + +## [plot-bins](doc_plot_bins.html) + + +```shell +cd ${PLO} +python3 -m hatchet plot-bins -c RD --figsize 6,3 ../${BBC}bulk.bbc +python3 -m hatchet plot-bins -c CRD --figsize 6,3 ../${BBC}bulk.bbc +python3 -m hatchet plot-bins -c BAF --figsize 6,3 ../${BBC}bulk.bbc +python3 -m hatchet plot-bins -c BB ../${BBC}bulk.bbc +python3 -m hatchet plot-bins -c CBB ../${BBC}bulk.bbc -tS 0.01 +``` + +plot-bins produces informative plots which are described [here](doc_plot_bins.md). +Many of these plots can be very useful to assess the performance of the various steps of HATCHet, especially in the case of noisy datasets. + +## [compute-cn](doc_compute_cn.html) + + +```shell +cd ../${RES} +python3 -m hatchet compute-cn -i ../${BBC}bulk -n2,6 -p 400 -u 0.03 \ + -r ${RANDOM} -j ${J} -eD 6 -eT 12 -g 0.35 \ + -l 0.6 &> >(tee >(grep -v Progress > hatchet.log)) +``` + +compute-cn computes the fractional copy numbers, factorizes these into allele and clone-specific copy numbers and clone proportions, and applies a model-selection step to jointly infer the number of clones and predict a whole-genome duplication (WGD). +This step requires the common prefix `${BBC}bulk` of the cluster and clustered bins files. +Some basic parameter include: +- the interval `2,6` specifying the minimum and maximum number of clones which can be increased as much as wanted. User can start to use this interval and increasing if the number of clones appear to be higher or close to the maximum. +- the number of restarts `400` for the coordinate-descent method. This value is typically enough to obtain a good solution close to the optimum, however an increase in this value allows to improve the search of a solution. This can be useful when observing a number of clusters significantly higher than usual. +- Random initializing seed with `${RANDOM}`. +- Number of parallel threads `${J}` + +There are also some important parameters which need to be tuned for special or noisy datasets. +The details of these parameters are the following: +- Maximum copy number without a WGD `-eD` and with a WGD `-eT`. The specified values are typically enough to obtain the copy numbers of large CNAs. While higher values increase the number of reasonable solutions, the values can be increased to investigate the presence of large genomic regions with higher copy numbers. In particular, when the value `0` is specified, then the maximum copy numbers are automatically chosen from the fractional copynumbers. +- Minimum clone proportion `-u`. The value depends on the power to identify tumor clones present in samples at low tumor proportions. The default value is reasonable for most of the datasets, but datasets with high noise may need higher values to avoid overfitting. We thus suggest, especially in these special cases, to repeat the hatchet step by considering increasing values of this parameter up to a maximum or until clone proportions are different from this threshold. +- Two parameters are used to control the elbow method during model selection to choose the best solution. The user should repeat this step with different values of these parameters, especially when one wants to investigate the presence of a single tumor clone or the presence of more tumor clones with small different CNAs and small clone proportions. These two parameters are the following: + - Confidence in the presence of a single tumor clone `g`. This value determines the confidence in having a single tumor clone in several of the given samples. The user can investigate the hypothesis that a single tumor clone is present by increasing the confidence, e.g. using values of `0.4, 0.5, ...`. Vice versa, the confidence is lowered by decreasing these values. For example, one can do that to investigate the presence of tumor clones with small CNAs or small proportions. + - Sensitivity `l`. This value determines the sensitivity of the method. Lower values correspond to higher sensitivities which allow to consider solutions with a higher number of clones. The user can decrease this value for investigating the presence of more tumor clones, especially tumor clones with small different CNAs or present in small proportions. + +## [plot-cn](doc_plot_cn.html) + + +```shell +cd ../${SUM} +python3 -m hatchet plot-cn ../${RES}/best.bbc.ucn +``` + +plot-cn produces informative and summary plots for the inferred results. +Examples and details of these plots are reported [here](doc_plot_cn.md). +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_download_panel.md",".md","2287","31","# download-panel + +This step of HATCHet downloads the 1000 genomes reference panel to phase germline mutations. It also downloads and creates other files necessary for phasing when the user has aligned their reads to a version of the human reference genome that is not the same as the version used in the 1000 genomes project (which was hg19, with no 'chr' prefix preceding chromosome names). + +**Note:** This step requires access to the internet in order to download files. This step only needs to be run once per system. + +## Input + +`download-panel` takes no input files and the following options: + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-D`, `--refpaneldir` | Path to the Reference Panel | This is the location where the 1000 genome project reference panel will be downloaded | None +| `-R`, `--refpanel` | Reference Panel to use; only 1000 genomes project currently supported | specify ""1000GP_Phase3"" to automatically download and use the panel from the 1000 genomes project | ""1000GP_Phase3"" + +## Output + +download-panel populates the directory `-D, --refpaneldir` with several files for phasing germline SNPs, and for performing liftover in situations when the reference genome used to align sequencing reads is different from the reference genome version used in the reference panel. + +| Name | Description | +|------|-------------| +| 1000GP_Phase3 | Directory containing reference panel of haplotypes for phasing mutations, in HAP/LEGEND/SAMPLE format | +| hg19_no_chr.fa | hg19 reference genome, chromosomes named without ""chr"" prefix | +| hg19_no_chr.dict | Sequence dictionary for the hg19 reference genome | +| hg38ToHg19.chr.chain | Chain file for liftover, going from hg38 to hg19 coordinates | +| hg38ToHg19.no_chr.chain | Chain file for liftover, going from hg38 to hg19 coordinates, where hg38 chromosomes are named without ""chr"" prefix | +| hg19ToHg38.chr.chain | Chain file for liftover, going from hg19 to hg38 | +| hg19ToHg38.no_chr.chain | Chain file for liftover, going form hg19 to hg38, where hg38 chromosomes are named without ""chr"" prefix | +| rename_chrs1.txt | File for renaming chromosomes with bcftools, removing the ""chr"" prefix | +| rename_chrs2.txt | File for renaming chromosomes with bcftools, adding the ""chr"" prefix | +","Markdown" +"Allele","raphael-group/hatchet","docs/source/doc_plot_cn_1d2d.md",".md","3386","42","# plot-cn-1d2d + +This step produces alternate plots that show bins in terms of their computed read-depth ratios (RDR), B-allele frequencies (BAF), and assigned copy-number states. +These plots show bins colored by cluster, where the color is consistent between the ""2D"" (RDR x BAF) view and the ""1D"" (genomic location x RDR/BAF) view. +Additionally, the labeled points in the 2D plots and the black bars in the 1D plots show the *expected* positions of the assigned copy-number states (determined by the mixture proportions and fractional copy number scaling). These indicators can be used to evaluate the consistency of the HATCHet solution. + +When `plot_cn = True` is indicated in `hatchet.ini`, both this command and the command [plot-cn](doc_plot_cn.md) will be run. + +These plots should be used to review the results of the copy-number assignment step [compute_cn](doc_compute_cn.md) and tune its parameters. They are most useful when there are few samples - when there are many samples, the visualizations from `plot-cn` may be more interpretable. + +## Input + +plot-bins requires a single tab-separated file as input. This file (e.g., `best.bbc.ucn`, `results.diploid.n3.bbc.ucn.tsv`, ...) is typically produced by [compute_cn](doc_compute_cn.md) and contains the following fields: + +| Field | Description | +|-------|-------------| +| `CHR` | Name of a chromosome | +| `START` | Starting genomic position of a genomic bin in `CHR` | +| `END` | Ending genomic position of a genomic bin in `CHR` | +| `SAMPLE` | Name of a tumor sample | +| `RD` | RDR of the bin in `SAMPLE` | +| `#SNPS` | Number of SNPs present in the bin in `SAMPLE` | +| `COV` | Average coverage in the bin in `SAMPLE` | +| `ALPHA` | Alpha parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from A allele | +| `BETA` | Beta parameter related to the binomial model of BAF for the bin in `SAMPLE`, typically total number of reads from B allele | +| `BAF` | BAF of the bin in `SAMPLE` | +| `CLUSTER` | The name of the corresponding cluster of the bin in `SAMPLE` | +| `cn_normal` | The copy number state of the normal diploid clone equal to 1|1 | +| `u_normal` | The normal admixture of the normal diploid cells in the corresponding sample | +| `cn_clone${n}` | The copy number state of the `${n}` tumor clone in the format A|B where `A` and `B` are the two allele-specific copy numbers of the corresponding genomic bin | +| `u_clone${n}` | The clone proportion of the `${n}` tumor clone in the corresponding sample | + +## Parameters + +| Name | Description | Usage | Default | +|------|-------------|-------|---------| +| `-O`, `--outdir` | Output directory | Directory in which output plots will be stored | """" (current directory) | +| `--baflim` | Axis limits for mirrored BAF | Specify limits as comma-separated values, e.g., '0,0.51' | None (determined by extremes of data) | +| `--fcnlim` | Axis limits for fractional copy numbers | Specify limits as comma-separated values, e.g., '0,3' | None (determined by extremes of data) | +| `--centromeres` | Mark centromere locations with grey rectangles | Enable by including this flag with no argument. | False | +| `--bysample` | Split plots into distinct sample-specific files (instead of grouping all 1D plots together and all 2D plots together) | Enable by including this flag with no argument. | False | +","Markdown" +"Allele","raphael-group/hatchet","tests/test_steps.py",".py","8580","330","import sys +from io import StringIO +import pytest +import os +import glob +import gzip +import hashlib +from mock import patch +import shutil +import pickle +import pandas as pd +from pandas.testing import assert_frame_equal + +from hatchet import config +from hatchet.utils import ArgParsing +from hatchet.utils.count_reads_fw import main as count_reads +from hatchet.utils.genotype_snps import main as genotype_snps +from hatchet.utils.count_alleles import counting +from hatchet.utils.combine_counts_fw import main as combine_counts +from hatchet.utils.cluster_bins_gmm import main as cluster_bins_gmm +from hatchet.utils.plot_bins import main as plot_bins +from hatchet.bin.HATCHet import main as main +from hatchet.utils.plot_cn import main as plot_cn +from hatchet.utils.solve import solver_available + +this_dir = os.path.dirname(__file__) + + +@pytest.fixture(scope=""module"") +def bams(): + bam_directory = config.tests.bam_directory + normal_bam = os.path.join(bam_directory, ""normal.bam"") + if not os.path.exists(normal_bam): + pytest.skip( + ""File not found: {}"".format(os.path.join(bam_directory, ""normal.bam"")) + ) + tumor_bams = sorted( + [ + f + for f in glob.glob(bam_directory + ""/*.bam"") + if os.path.basename(f) != ""normal.bam"" + ] + ) + if not tumor_bams: + pytest.skip(""No tumor bams found in {}"".format(bam_directory)) + + return normal_bam, tumor_bams + + +@pytest.fixture(scope=""module"") +def normal_snps(): + with open(f""{this_dir}/data/fw/snps/normal_snps.pik"", ""rb"") as f: + return pickle.load(f) + + +@pytest.fixture(scope=""module"") +def output_folder(): + out = os.path.join(this_dir, ""out"") + shutil.rmtree(out, ignore_errors=True) + for sub_folder in ( + ""bin"", + ""snps"", + ""baf"", + ""bb"", + ""bbc"", + ""plots"", + ""results"", + ""evaluation"", + ""analysis"", + ): + os.makedirs(os.path.join(out, sub_folder)) + return out + + +@pytest.mark.skipif(not config.paths.reference, reason=""paths.reference not set"") +@patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) +@patch( + ""hatchet.utils.count_reads_fw.knownRegions"", + return_value={""chr22"": [(30256931, 32622323)]}, +) +def test_count_reads(_mock0, _mock1, bams, output_folder): + normal_bam, tumor_bams = bams + + count_reads( + args=[""-N"", normal_bam, ""-T""] + + tumor_bams + + [ + ""-b"", + ""50kb"", + ""-st"", + config.paths.samtools, + ""-S"", + ""Normal"", + ""Tumor1"", + ""Tumor2"", + ""Tumor3"", + ""-g"", + config.paths.reference, + ""-j"", + ""12"", + ""-q"", + ""11"", + ""-O"", + os.path.join(output_folder, ""bin/normal.1bed""), + ""-o"", + os.path.join(output_folder, ""bin/bulk.1bed""), + ""-v"", + ] + ) + + df1 = pd.read_csv(f""{output_folder}/bin/normal.1bed"", sep=""\t"") + df2 = pd.read_csv(f""{this_dir}/data/fw/bin/normal.1bed"", sep=""\t"") + assert_frame_equal(df1, df2) + + df1 = pd.read_csv(f""{output_folder}/bin/bulk.1bed"", sep=""\t"") + df2 = pd.read_csv(f""{this_dir}/data/fw/bin/bulk.1bed"", sep=""\t"") + assert_frame_equal(df1, df2) + + +@pytest.mark.skipif(not config.paths.reference, reason=""paths.reference not set"") +@patch( + ""hatchet.utils.ArgParsing.extractChromosomes"", + return_value=[""chr22:30256931-32622323""], +) +def test_genotype_snps(_mock1, bams, output_folder): + normal_bam, _ = bams + + genotype_snps( + args=[ + ""-N"", + normal_bam, + ""-r"", + config.paths.reference, + ""-c"", + ""0"", # min reads + ""-C"", + ""300"", # max reads + ""-o"", + f""{output_folder}/snps"", + ""-st"", + config.paths.samtools, + ""-bt"", + config.paths.bcftools, + ""-j"", + ""12"", + ] + ) + + with gzip.open(f""{output_folder}/snps/chr22:30256931-32622323.vcf.gz"", ""rb"") as f: + # ignore commented lines since these may have timestamps and software version numbers etc. + lines = ""\n"".join( + [ + line + for line in f.read().decode(""utf8"").split(""\n"") + if not line.startswith(""#"") + ] + ) + assert ( + hashlib.md5(lines.encode(""utf8"")).hexdigest() + == ""3d81c51d21c22334ce1fc069cb005328"" + ) + + +@patch( + ""hatchet.utils.ArgParsing.extractChromosomes"", + return_value=[""chr22:30256931-32622323""], +) +def test_count_alleles_normal_snps(_mock1, bams, normal_snps, output_folder): + normal_bam, tumor_bams = bams + + args = ( + [""-N"", normal_bam, ""-T""] + + tumor_bams + + [ + ""-S"", + ""Normal"", + ""Tumor1"", + ""Tumor2"", + ""Tumor3"", + ""-r"", + config.paths.reference, + ""-j"", + ""12"", + ""-q"", + ""3"", + ""-Q"", + ""3"", + ""-U"", + ""3"", + ""-c"", + ""8"", + ""-C"", + ""300"", + ""-O"", + f""{output_folder}/baf/normal.1bed"", + ""-o"", + f""{output_folder}/baf/bulk.1bed"", + ""-L"", + f""{this_dir}/data/fw/snps/chr22:30256931-32622323.vcf.gz"", + ] + ) + + args = ArgParsing.parse_count_alleles_arguments(args) + + snps = counting( + bcftools=args[""bcftools""], + reference=args[""reference""], + samples=[args[""normal""]], + chromosomes=args[""chromosomes""], + num_workers=args[""j""], + snplist=args[""snps""], + q=args[""q""], + Q=args[""Q""], + mincov=args[""mincov""], + dp=args[""maxcov""], + E=args[""E""], + verbose=False, + outdir=args[""outputSnps""], + ) + + assert snps == normal_snps + + +def test_combine_counts(output_folder): + _stdout = sys.stdout + sys.stdout = StringIO() + + combine_counts( + args=[ + ""-c"", + f""{this_dir}/data/fw/bin/normal.1bed"", + ""-C"", + f""{this_dir}/data/fw/bin/bulk.1bed"", + ""-B"", + f""{this_dir}/data/fw/baf/bulk.1bed"", + ""-e"", + ""12"", + ] + ) + + out = sys.stdout.getvalue() + sys.stdout.close() + sys.stdout = _stdout + + with open(f""{this_dir}/data/fw/bb/bulk.bb"", ""r"") as f: + assert out == f.read() + + +def test_cluster_bins_gmm(output_folder): + cluster_bins_gmm( + args=[ + f""{this_dir}/data/fw/bb/bulk.bb"", + ""-o"", + f""{output_folder}/bbc/bulk.seg"", + ""-O"", + f""{output_folder}/bbc/bulk.bbc"", + ""-e"", + ""22171"", # random seed + ""-tB"", + ""0.04"", + ""-tR"", + ""0.15"", + ""-d"", + ""0.4"", + ""-K"", + ""20"", + ] + ) + + df1 = pd.read_csv(f""{output_folder}/bbc/bulk.seg"", sep=""\t"") + df2 = pd.read_csv(f""{this_dir}/data/fw/bbc/bulk.seg"", sep=""\t"") + assert_frame_equal(df1, df2) + + +def test_plot_bins(output_folder): + # We simply check if we're able to run plot_bins without exceptions + plot_bins( + args=[ + os.path.join(f""{this_dir}/data/fw/bbc/bulk.bbc""), + ""--rundir"", + os.path.join(output_folder, ""plots""), + ] + ) + + +def test_compute_cn(output_folder): + if solver_available(): + main( + args=[ + ""-x"", + f""{output_folder}/results"", + ""-i"", + f""{this_dir}/data/fw/bbc/bulk"", + ""-n2"", + ""-p"", + ""100"", + ""-v"", + ""3"", + ""-u"", + ""0.03"", + ""-r"", + ""6700"", # random seed + ""-j"", + ""8"", + ""-eD"", + ""6"", + ""-eT"", + ""12"", + ""-g"", + ""0.35"", + ""-l"", + ""0.6"", + ] + ) + + df1 = pd.read_csv(f""{output_folder}/results/best.bbc.ucn"", sep=""\t"") + df2 = pd.read_csv(f""{this_dir}/data/fw/results/best.bbc.ucn"", sep=""\t"") + assert_frame_equal(df1, df2) + + +def test_plot_cn(output_folder): + # We simply check if we're able to run plot_cn without exceptions + plot_cn( + args=[ + f""{this_dir}/data/fw/results/best.bbc.ucn"", + ""--rundir"", + f""{output_folder}/evaluation"", + ] + ) +","Python" +"Allele","raphael-group/hatchet","tests/test_steps_vw.py",".py","6665","217","import os +import glob +from mock import patch +import shutil +import pandas as pd +from pandas.testing import assert_frame_equal +from numpy.testing import assert_array_equal +import numpy as np +import pytest + +from hatchet import config +from hatchet.utils.count_reads import main as count_reads +from hatchet.utils.cluster_bins import main as cluster_bins +from hatchet.utils.combine_counts import main as combine_counts + +this_dir = os.path.dirname(__file__) + + +@pytest.fixture(scope=""module"") +def bams(): + bam_directory = config.tests.bam_directory + normal_bam = os.path.join(bam_directory, ""normal.bam"") + if not os.path.exists(normal_bam): + pytest.skip(""File not found: {}/{}"".format(bam_directory, normal_bam)) + tumor_bams = sorted( + [ + f + for f in glob.glob(bam_directory + ""/*.bam"") + if os.path.basename(f) != ""normal.bam"" + ] + ) + if not tumor_bams: + pytest.skip(""No tumor bams found in {}"".format(bam_directory)) + + return normal_bam, tumor_bams + + +@pytest.fixture(scope=""module"") +def output_folder(): + out = os.path.join(this_dir, ""out"", ""vw"") + shutil.rmtree(out, ignore_errors=True) + for sub_folder in [""rdr"", ""bb"", ""bbc""]: + os.makedirs(os.path.join(out, sub_folder)) + return out + + +@patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) +def test_count_reads(_, bams, output_folder): + normal_bam, tumor_bams = bams + + count_reads( + args=[""-N"", normal_bam, ""-T""] + + tumor_bams + + [ + ""-st"", + config.paths.samtools, + ""-S"", + ""Normal"", + ""Tumor1"", + ""Tumor2"", + ""Tumor3"", + ""-j"", + ""1"", + ""-b"", + os.path.join(this_dir, ""data"", ""vw"", ""baf"", ""bulk.1bed""), + ""-O"", + os.path.join(output_folder, ""rdr""), + ""-V"", + ""hg19"", + ] + ) + + arr1 = np.loadtxt(os.path.join(output_folder, ""rdr"", ""chr22.thresholds.gz"")) + arr2 = np.loadtxt(os.path.join(output_folder, ""rdr"", ""chr22.total.gz"")) + arr3 = [l for l in open(os.path.join(output_folder, ""rdr"", ""samples.txt""), ""r"")] + arr4 = pd.read_table(os.path.join(output_folder, ""rdr"", ""total.tsv"")) + + truth1 = np.loadtxt( + os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""chr22.thresholds.gz"") + ) + truth2 = np.loadtxt(os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""chr22.total.gz"")) + truth3 = [ + l for l in open(os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""samples.txt""), ""r"") + ] + truth4 = pd.read_table(os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""total.tsv"")) + + assert_array_equal(arr1, truth1) + assert_array_equal(arr2, truth2) + assert len(arr3) == len(truth3) and all( + [arr3[i] == truth3[i] for i in range(len(truth3))] + ) + assert_frame_equal(arr4, truth4) + + +@pytest.mark.skipif(not config.paths.reference, reason=""paths.reference not set"") +@patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) +def test_combine_counts(_, output_folder): + # Test without phasing + combine_counts( + args=[ + ""-A"", + os.path.join(this_dir, ""data"", ""vw"", ""rdr""), + ""-t"", + os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""total.tsv""), + ""-j"", + ""1"", + ""-b"", + os.path.join(this_dir, ""data"", ""vw"", ""baf"", ""bulk.1bed""), + ""-o"", + os.path.join(output_folder, ""bb"", ""bulk_nophase.bb""), + ""-r"", + config.paths.reference, + ""-V"", + ""hg19"", + ] + ) + df1 = pd.read_csv(os.path.join(output_folder, ""bb"", ""bulk_nophase.bb""), sep=""\t"") + df2 = pd.read_csv( + os.path.join(this_dir, ""data"", ""vw"", ""bb"", ""bulk_nophase.bb""), sep=""\t"" + ) + assert_frame_equal(df1, df2) + + +@pytest.mark.skipif(not config.paths.reference, reason=""paths.reference not set"") +@patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) +def test_combine_counts_phasing(_, output_folder): + # Test with phasing + combine_counts( + args=[ + ""-A"", + os.path.join(this_dir, ""data"", ""vw"", ""rdr""), + ""-t"", + os.path.join(this_dir, ""data"", ""vw"", ""rdr"", ""total.tsv""), + ""-j"", + ""1"", + ""-b"", + os.path.join(this_dir, ""data"", ""vw"", ""baf"", ""bulk.1bed""), + ""-o"", + os.path.join(output_folder, ""bb"", ""bulk_yesphase.bb""), + ""-V"", + ""hg19"", + ""-r"", + config.paths.reference, + ""-p"", + os.path.join(this_dir, ""data"", ""vw"", ""phase"", ""phased.vcf.gz""), + ] + ) + + df3 = pd.read_csv(os.path.join(output_folder, ""bb"", ""bulk_yesphase.bb""), sep=""\t"") + df4 = pd.read_csv( + os.path.join(this_dir, ""data"", ""vw"", ""bb"", ""bulk_yesphase.bb""), + sep=""\t"", + ) + assert_frame_equal(df3, df4) + + +def test_cluster_bins(output_folder): + cluster_bins( + args=[ + f""{this_dir}/data/fw/bb/bulk.bb"", + ""-o"", + f""{output_folder}/bbc/bulk.seg"", + ""-O"", + f""{output_folder}/bbc/bulk.bbc"", + ""--transmat"", + ""diag"", + ""--covar"", + ""diag"", + ""--minK"", + ""2"", + ""--maxK"", + ""10"", + ] + ) + + seg1 = pd.read_csv(os.path.join(output_folder, ""bbc"", ""bulk.seg""), sep=""\t"") + bbc1 = pd.read_csv(os.path.join(output_folder, ""bbc"", ""bulk.bbc""), sep=""\t"") + + seg2 = pd.read_csv( + os.path.join(this_dir, ""data"", ""vw"", ""bbc"", ""bulk.seg""), sep=""\t"" + ) + bbc2 = pd.read_csv( + os.path.join(this_dir, ""data"", ""vw"", ""bbc"", ""bulk.bbc""), sep=""\t"" + ) + assert_frame_equal(seg1, seg2) + assert_frame_equal(bbc1, bbc2) + + +def test_cluster_bins_singleton(output_folder): + cluster_bins( + args=[ + f""{this_dir}/data/fw/bb/bulk.bb"", + ""-o"", + f""{output_folder}/bbc/bulk_onecl.seg"", + ""-O"", + f""{output_folder}/bbc/bulk_onecl.bbc"", + ""--transmat"", + ""diag"", + ""--covar"", + ""diag"", + ""--exactK"", + ""1"", + ] + ) + + seg1 = pd.read_csv(os.path.join(output_folder, ""bbc"", ""bulk_onecl.seg""), sep=""\t"") + bbc1 = pd.read_csv(os.path.join(output_folder, ""bbc"", ""bulk_onecl.bbc""), sep=""\t"") + + seg2 = pd.read_csv( + os.path.join(this_dir, ""data"", ""vw"", ""bbc"", ""bulk_onecl.seg""), sep=""\t"" + ) + bbc2 = pd.read_csv( + os.path.join(this_dir, ""data"", ""vw"", ""bbc"", ""bulk_onecl.bbc""), sep=""\t"" + ) + assert_frame_equal(seg1, seg2) + assert_frame_equal(bbc1, bbc2) +","Python" +"Allele","raphael-group/hatchet","tests/test_config.py",".py","104","6","from hatchet import config + + +def test_config_reference(): + assert config.paths.reference is not None +","Python" +"Allele","raphael-group/hatchet","tests/test_phase.py",".py","1341","55","import pytest +import os +from mock import patch +import shutil +import pandas as pd +from pandas.testing import assert_frame_equal + +import hatchet # noqa: F401 +from hatchet import config +from hatchet.utils.phase_snps import main as phase_snps +from hatchet.utils.download_panel import main as download_panel + +this_dir = os.path.dirname(__file__) + + +@pytest.fixture(scope=""module"") +def output_folder(): + out = os.path.join(this_dir, ""out"", ""vw"", ""phase"") + shutil.rmtree(out, ignore_errors=True) + os.makedirs(out, exist_ok=True) + return out + + +@patch(""hatchet.utils.ArgParsing.extractChromosomes"", return_value=[""chr22""]) +def test_script(_, output_folder): + download_panel( + args=[ + ""-R"", + ""1000GP_Phase3"", + ] + ) + + phase_snps( + args=[ + ""-g"", + config.paths.reference, + ""-V"", + ""hg19"", + ""-N"", + ""-o"", + os.path.join(output_folder, ""phase""), + ""-L"", + os.path.join(this_dir, ""data"", ""vw"", ""snps"", ""chr22.vcf.gz""), + ] + ) + + df1 = pd.read_table( + os.path.join(output_folder, ""phase"", ""phased.vcf.gz""), comment=""#"" + ) + df2 = pd.read_table( + os.path.join(this_dir, ""data"", ""vw"", ""phase"", ""phased.vcf.gz""), + comment=""#"", + ) + assert_frame_equal(df1, df2) +","Python" +"Allele","raphael-group/hatchet","tests/test_solver.py",".py","5229","222","import os +import subprocess +import pytest +import pandas as pd +from pandas.testing import assert_frame_equal + +import hatchet +from hatchet.bin.HATCHet import main as main +from hatchet import config +from hatchet.utils.solve import solver_available + +this_dir = os.path.dirname(__file__) +DATA_FOLDER = os.path.join(this_dir, ""data"", ""fw"") +SOLVE = os.path.join(os.path.dirname(hatchet.__file__), ""solve"") + + +@pytest.fixture(scope=""module"") +def output_folder(): + out = os.path.join(this_dir, ""out"", ""solver"") + os.makedirs(out, exist_ok=True) + return out + + +@pytest.mark.skipif( + os.getenv(""GRB_LICENSE_FILE"") is None, reason=""No license for Gurobi found"" +) +def test_solve_binary(): + cmd = [SOLVE, os.path.join(DATA_FOLDER, ""bulk"")] + # -M 1 for ILP solve mode + cmd.extend( + [_x for _x in ""-f -e 6 -p 400 -u 0.03 -r 6700 -M 1 -v 2 -c 5:1:1 -n 2"".split()] + ) + + print("" "".join(cmd)) + + p = subprocess.Popen( + cmd, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + universal_newlines=True, + ) + p.communicate() + assert p.returncode == 0 + + +@pytest.mark.skipif( + os.getenv(""GRB_LICENSE_FILE"") is None, reason=""No license for Gurobi found"" +) +def test_solve_command_cpp(output_folder): + old_value = config.compute_cn.solver + config.compute_cn.solver = ""cpp"" + + main( + args=[ + ""-x"", + os.path.join(output_folder), + ""-i"", + os.path.join(this_dir, ""data/fw/bulk""), + ""-n2"", + ""-p"", + ""400"", + ""-v"", + ""3"", + ""-u"", + ""0.03"", + ""--mode"", + ""1"", + ""-r"", + ""6700"", + ""-j"", + ""8"", + ""-eD"", + ""6"", + ""-eT"", + ""12"", + ""-g"", + ""0.35"", + ""-l"", + ""0.6"", + ] + ) + + df1 = pd.read_csv(os.path.join(output_folder, ""best.bbc.ucn""), sep=""\t"") + df2 = pd.read_csv(os.path.join(this_dir, ""data"", ""fw"", ""best.bbc.ucn""), sep=""\t"") + assert_frame_equal(df1, df2) + + config.compute_cn.solver = old_value + + +@pytest.mark.skipif( + not solver_available(""gurobipy""), + reason=""gurobipy solver not available for pyomo"", +) +def test_solve_command_gurobipy(output_folder): + old_value = config.compute_cn.solver + config.compute_cn.solver = ""gurobipy"" + + main( + args=[ + ""-x"", + os.path.join(output_folder), + ""-i"", + os.path.join(this_dir, ""data/fw/bulk""), + ""-n2"", + ""-p"", + ""400"", + ""-v"", + ""3"", + ""-u"", + ""0.03"", + ""--mode"", + ""1"", + ""-r"", + ""6700"", + ""-j"", + ""8"", + ""-eD"", + ""6"", + ""-eT"", + ""12"", + ""-g"", + ""0.35"", + ""-l"", + ""0.6"", + ] + ) + + df1 = pd.read_csv(os.path.join(output_folder, ""best.bbc.ucn""), sep=""\t"") + df2 = pd.read_csv(os.path.join(this_dir, ""data"", ""fw"", ""best.bbc.ucn""), sep=""\t"") + assert_frame_equal(df1, df2) + + config.compute_cn.solver = old_value + + +@pytest.mark.skipif( + not solver_available(""gurobi""), + reason=""gurobi solver not available for pyomo"", +) +def test_solve_command_gurobi(output_folder): + old_value = config.compute_cn.solver + config.compute_cn.solver = ""gurobi"" + + main( + args=[ + ""-x"", + os.path.join(output_folder), + ""-i"", + os.path.join(this_dir, ""data/fw/bulk""), + ""-n2"", + ""-p"", + ""400"", + ""-v"", + ""3"", + ""-u"", + ""0.03"", + ""--mode"", + ""1"", + ""-r"", + ""6700"", + ""-j"", + ""8"", + ""-eD"", + ""6"", + ""-eT"", + ""12"", + ""-g"", + ""0.35"", + ""-l"", + ""0.6"", + ] + ) + + df1 = pd.read_csv(os.path.join(output_folder, ""best.bbc.ucn""), sep=""\t"") + df2 = pd.read_csv(os.path.join(this_dir, ""data"", ""fw"", ""best.bbc.ucn""), sep=""\t"") + assert_frame_equal(df1, df2) + + config.compute_cn.solver = old_value + + +@pytest.mark.skipif( + not solver_available(""cbc""), reason=""cbc solver not available for pyomo"" +) +def test_solve_command_cbc(output_folder): + old_value = config.compute_cn.solver + config.compute_cn.solver = ""cbc"" + + main( + args=[ + ""-x"", + os.path.join(output_folder), + ""-i"", + os.path.join(this_dir, ""data/fw/bulk""), + ""-n2"", + ""-p"", + ""400"", + ""-v"", + ""3"", + ""-u"", + ""0.03"", + ""--mode"", + ""1"", + ""-r"", + ""6700"", + ""-j"", + ""8"", + ""-eD"", + ""6"", + ""-eT"", + ""12"", + ""-g"", + ""0.35"", + ""-l"", + ""0.6"", + ] + ) + + df1 = pd.read_csv(os.path.join(output_folder, ""best.bbc.ucn""), sep=""\t"") + df2 = pd.read_csv(os.path.join(this_dir, ""data"", ""fw"", ""best.bbc.ucn""), sep=""\t"") + assert_frame_equal(df1, df2) + + config.compute_cn.solver = old_value +","Python" +"Allele","ZhaotongL/MVMR-cML","LICENSE.md",".md","1071","22","# MIT License + +Copyright (c) 2023 Zhaotong Lin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the ""Software""), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +","Markdown" +"Allele","ZhaotongL/MVMR-cML","src/RcppExports.cpp",".cpp","3675","64","// Generated by using Rcpp::compileAttributes() -> do not edit by hand +// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#include +#include + +using namespace Rcpp; + +#ifdef RCPP_USE_GLOBAL_ROSTREAM +Rcpp::Rostream& Rcpp::Rcout = Rcpp::Rcpp_cout_get(); +Rcpp::Rostream& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get(); +#endif + +// MVmr_cML +Rcpp::List MVmr_cML(const arma::mat& b_exp, const arma::mat& b_out, const arma::mat& se_bx, const Rcpp::List& Sig_inv_l, const unsigned int n, Rcpp::NumericVector K_vec, const unsigned int random_start, const unsigned int maxit, const double thres); +RcppExport SEXP _MVMRcML_MVmr_cML(SEXP b_expSEXP, SEXP b_outSEXP, SEXP se_bxSEXP, SEXP Sig_inv_lSEXP, SEXP nSEXP, SEXP K_vecSEXP, SEXP random_startSEXP, SEXP maxitSEXP, SEXP thresSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type b_exp(b_expSEXP); + Rcpp::traits::input_parameter< const arma::mat& >::type b_out(b_outSEXP); + Rcpp::traits::input_parameter< const arma::mat& >::type se_bx(se_bxSEXP); + Rcpp::traits::input_parameter< const Rcpp::List& >::type Sig_inv_l(Sig_inv_lSEXP); + Rcpp::traits::input_parameter< const unsigned int >::type n(nSEXP); + Rcpp::traits::input_parameter< Rcpp::NumericVector >::type K_vec(K_vecSEXP); + Rcpp::traits::input_parameter< const unsigned int >::type random_start(random_startSEXP); + Rcpp::traits::input_parameter< const unsigned int >::type maxit(maxitSEXP); + Rcpp::traits::input_parameter< const double >::type thres(thresSEXP); + rcpp_result_gen = Rcpp::wrap(MVmr_cML(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, maxit, thres)); + return rcpp_result_gen; +END_RCPP +} +// MVmr_cML_DP +Rcpp::List MVmr_cML_DP(const arma::mat& b_exp, const arma::mat& b_out, const arma::mat& se_bx, const Rcpp::List& Sig_inv_l, const unsigned int n, Rcpp::NumericVector K_vec, const unsigned int random_start, const unsigned int num_pert, const unsigned int maxit, const double thres); +RcppExport SEXP _MVMRcML_MVmr_cML_DP(SEXP b_expSEXP, SEXP b_outSEXP, SEXP se_bxSEXP, SEXP Sig_inv_lSEXP, SEXP nSEXP, SEXP K_vecSEXP, SEXP random_startSEXP, SEXP num_pertSEXP, SEXP maxitSEXP, SEXP thresSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type b_exp(b_expSEXP); + Rcpp::traits::input_parameter< const arma::mat& >::type b_out(b_outSEXP); + Rcpp::traits::input_parameter< const arma::mat& >::type se_bx(se_bxSEXP); + Rcpp::traits::input_parameter< const Rcpp::List& >::type Sig_inv_l(Sig_inv_lSEXP); + Rcpp::traits::input_parameter< const unsigned int >::type n(nSEXP); + Rcpp::traits::input_parameter< Rcpp::NumericVector >::type K_vec(K_vecSEXP); + Rcpp::traits::input_parameter< const unsigned int >::type random_start(random_startSEXP); + Rcpp::traits::input_parameter< const unsigned int >::type num_pert(num_pertSEXP); + Rcpp::traits::input_parameter< const unsigned int >::type maxit(maxitSEXP); + Rcpp::traits::input_parameter< const double >::type thres(thresSEXP); + rcpp_result_gen = Rcpp::wrap(MVmr_cML_DP(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, num_pert, maxit, thres)); + return rcpp_result_gen; +END_RCPP +} + +static const R_CallMethodDef CallEntries[] = { + {""_MVMRcML_MVmr_cML"", (DL_FUNC) &_MVMRcML_MVmr_cML, 9}, + {""_MVMRcML_MVmr_cML_DP"", (DL_FUNC) &_MVMRcML_MVmr_cML_DP, 10}, + {NULL, NULL, 0} +}; + +RcppExport void R_init_MVMRcML(DllInfo *dll) { + R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); + R_useDynamicSymbols(dll, FALSE); +} +","C++" +"Allele","ZhaotongL/MVMR-cML","src/mvmr.cpp",".cpp","14380","374","#include +// [[Rcpp::depends(RcppArmadillo)]] +// [[Rcpp::plugins(openmp)]] +using namespace Rcpp; +using namespace arma; + +double l_i_c(const arma::vec& b_exp_i, + const arma::vec& b_out_i, + const arma::mat& Sig_inv_i, + const arma::vec& b_t_i, + const arma::vec& theta_t, + const arma::vec& r_vec_t_i) +{ + arma::vec beta = arma::join_vert(b_exp_i, b_out_i); + arma::vec bvec = arma::join_vert(b_t_i, dot(theta_t, b_t_i) + r_vec_t_i); + double l = - 1.0/2.0 * arma::as_scalar((beta-bvec).t() * Sig_inv_i * (beta-bvec)); + return l; +} + +double loglik_c(const arma::mat& b_exp, const arma::mat& b_out, + const Rcpp::List& Sig_inv_l, + const arma::mat& b_t, + const arma::vec& theta_t, + const arma::vec& r_vec_t){ + int p = b_exp.n_rows; + arma::vec l_i_vec(p); + for(unsigned int i=0; i < p; ++i){ + l_i_vec(i) = l_i_c(b_exp.row(i).t(),b_out.row(i), Sig_inv_l[i],b_t.row(i).t(),theta_t,r_vec_t.row(i)); + } + double l = sum(l_i_vec); + return l; +} + +Rcpp::List WK_func(const Rcpp::List& Sig_inv_l) + { + const int p = Sig_inv_l.length(), L = as(Sig_inv_l[0]).n_rows; + arma::mat WK1mat(p,L); + arma::vec WK1vec(p); + for(unsigned int i = 0; i < p; i++){ + WK1mat.row(i) = as(Sig_inv_l[i]).row(L-1); + WK1vec(i) = as(Sig_inv_l[i])(L-1,L-1); + } + return Rcpp::List::create(Rcpp::Named(""WK1vec"") = WK1vec, + Rcpp::Named(""WK1mat"") = WK1mat); +} + +arma::mat mvrnormArma(int n, arma::vec mu, arma::mat sigma) { + int ncols = sigma.n_cols; + arma::mat Y = arma::randn(n, ncols); + return arma::repmat(mu, 1, n).t() + Y * arma::chol(sigma); +} + +Rcpp::List MVcML_estimate_c(const arma::mat& b_exp, const arma::mat& b_out, + const Rcpp::List& Sig_inv_l, + const arma::vec& WK1vec, + const arma::mat& WK1mat, + const unsigned int K, + const arma::vec& initial_theta, + const arma::mat& initial_mu, + const unsigned int maxit = 100, + const double thres = 1e-4) +{ + + // initialize + const int p = b_exp.n_rows, k = b_exp.n_cols; + arma::vec theta = initial_theta, theta_old = theta -1; + arma::mat mu_vec = initial_mu; + arma::vec v_importance(p), v_bg(p), beta_star_i, B; + arma::mat r_t(p,1); + arma::mat A, temp, beta_star; + unsigned int ite_ind; + // + for (ite_ind = 0; ite_ind < maxit && sum(abs(theta - theta_old)) > thres; ++ite_ind){ + theta_old = theta; + + if (K > 0) { + A = arma::eye(p,p); + A.diag() = 1 / WK1vec; + beta_star = arma::join_horiz(b_exp-mu_vec,b_out-(mu_vec * theta)); + temp = WK1mat * beta_star.t(); + B = temp.diag(); + r_t = A * B; + for(unsigned int i = 0; i < p; ++i){ + double l_r = l_i_c(b_exp.row(i).t(), b_out.row(i), Sig_inv_l[i], mu_vec.row(i).t(), theta, r_t.row(i)); + double l_r0 = l_i_c(b_exp.row(i).t(), b_out.row(i), Sig_inv_l[i], mu_vec.row(i).t(), theta, zeros(1,1)); + v_importance(i) = l_r-l_r0; + } + + arma::uvec nonzero_bg_ind = sort_index(v_importance, ""descend""); + v_bg = arma::zeros(p); + v_bg(nonzero_bg_ind.head(K)) = r_t(nonzero_bg_ind.head(K)); + } + else{ + v_bg = arma::zeros(p); + } + arma::mat theta_cp = theta * theta.t(); + for(unsigned int i = 0; i < p; ++i){ + beta_star_i = arma::join_vert(b_exp.row(i).t(), b_out.row(i) - v_bg.row(i)); + arma::mat W_i = Sig_inv_l[i]; + B = W_i.rows(0, k-1) * beta_star_i + + arma::as_scalar(W_i.row(k) * beta_star_i) * theta; + A = W_i(span(0,k-1), span(0,k-1)) + arma::as_scalar(W_i(k,k)) * theta_cp + + W_i(span(0,k-1),k) * theta.t() + theta * W_i(k,span(0,k-1)); + + mu_vec.row(i) = solve(A,B).t(); + } + + A = zeros(k,k); + B = zeros(k); + for(unsigned int i = 0; i < p; ++i){ + arma::mat W_i = Sig_inv_l[i]; + A = A + arma::as_scalar(W_i(k,k)) * mu_vec.row(i).t() * mu_vec.row(i); + beta_star_i = arma::join_vert(b_exp.row(i).t()-mu_vec.row(i).t(),b_out.row(i)-v_bg.row(i)); + B = B + arma::as_scalar(W_i.row(k) * beta_star_i) * mu_vec.row(i).t(); + } + + theta = solve(A,B); + + } + bool Conv = (ite_ind >= maxit); + double Neg_l = -loglik_c(b_exp,b_out,Sig_inv_l,mu_vec, + theta,v_bg); + + return Rcpp::List::create(Rcpp::Named(""theta"") = theta, + Rcpp::Named(""b_vec"") = mu_vec, + Rcpp::Named(""r_vec"") = v_bg, + Rcpp::Named(""l"") = Neg_l, + Rcpp::Named(""Converge"") = Conv); +} + +Rcpp::List MVcML_estimate_random_c(const arma::mat& b_exp, const arma::mat& b_out, + const arma::mat& se_bx, + const Rcpp::List& Sig_inv_l, + const arma::vec& WK1vec, + const arma::mat& WK1mat, + const unsigned int K, + const unsigned int n, + const unsigned int random_start = 1, + const unsigned int maxit = 100, + const double thres = 1e-4) +{ +// min_theta_range = min(b_out/b_exp) +// max_theta_range = max(b_out/b_exp) +// initialize + const int p = b_exp.n_rows, k = b_exp.n_cols; + arma::mat theta_v_RandomCandidate(k,random_start), invalid_RandomCandidate(p,random_start); + arma::vec l_v_RandomCandidate(random_start), Conv_v_RandomCandidate(random_start); + arma::vec initial_theta(k); + arma::mat initial_mu(p,k); + for(unsigned int random_ind = 0; random_ind < random_start; ++random_ind) + { + if(random_ind == 0) + { + initial_theta = zeros(k); + // initial_mu = zeros(p,k); + initial_mu = b_exp; + } else { + initial_theta = runif(k, -0.5, 0.5); // TO-DO: option to change initial value for theta + arma::mat b_rand; + b_rand = Rcpp::rnorm(p*k,0.0,1.0); + b_rand.reshape(size(b_exp)); + initial_mu = b_exp + b_rand % se_bx; + // initial_mu = zeros(p,k); + } + + Rcpp::List MLE_result = MVcML_estimate_c(b_exp,b_out, + Sig_inv_l,WK1vec,WK1mat, + K,initial_theta, + initial_mu, + maxit, + thres); + + double Neg_l = -loglik_c(b_exp,b_out,Sig_inv_l,MLE_result[""b_vec""], + MLE_result[""theta""],MLE_result[""r_vec""]); + + theta_v_RandomCandidate.col(random_ind) = as(MLE_result[""theta""]); + l_v_RandomCandidate(random_ind) = Neg_l; + Conv_v_RandomCandidate(random_ind) = as(MLE_result[""Converge""]); + invalid_RandomCandidate.col(random_ind) = as(MLE_result[""r_vec""]); + + } + uvec q1 = find(Conv_v_RandomCandidate == 0); + if (q1.n_elem == 0){ + return Rcpp::List::create(Rcpp::Named(""Converge"") = 1); + } + int min_neg_l = l_v_RandomCandidate(q1).eval().index_min(); + + arma::vec theta_est = theta_v_RandomCandidate.cols(q1).eval().col(min_neg_l); + double l_est = (l_v_RandomCandidate(q1).eval())(min_neg_l); + arma::vec r_est = invalid_RandomCandidate.cols(q1).eval().col(min_neg_l); + return Rcpp::List::create(Rcpp::Named(""theta"") = theta_est, + Rcpp::Named(""l"") = l_est, + Rcpp::Named(""r_vec"") = r_est, + Rcpp::Named(""Converge"") = 0); +} + +//' MVMRcML method with BIC selection +//' +//' This is the main function of MVMR-cML. +//' +//' @param b_exp A m*L matrix of SNP effects on the exposure variable. +//' @param b_out A m*1 matrix of SNP effects on the outcome variable. +//' @param se_bx A m*L matrix of standard errors of \code{b_exp}. +//' @param Sig_inv_l A list of the inverse of m covariance matrices, generated by \code{invcov_mvmr()}. +//' @param n The smallest sample size of the L+1 GWAS dataset. +//' @param K_vec Sets of candidate K's, the constraint parameter representing number of invalid IVs. +//' @param random_start Number of random start points, default is 1. +//' @param maxit Maximum number of iterations for each optimization, default is 100. +//' @param thres Threshold for convergence criterion. +//' +//' @import Rcpp +//' @import RcppArmadillo +//' @return A list +//' \describe{ +//' \item{BIC_theta}{Estimated causal effect from MVMR-cML-BIC} +//' \item{BIC_invalid}{Invalid IVs selected by MVMR-cML-BIC} +//' \item{K_vec}{K_vec to be searched from} +//' \item{Converge}{0 if converge; 1 otherwise} +//' \item{BIC_vec}{BIC vector corresponding to K_vec} +//' } +//' +//' @export +// [[Rcpp::export]] +Rcpp::List MVmr_cML(const arma::mat& b_exp, const arma::mat& b_out, + const arma::mat& se_bx, + const Rcpp::List& Sig_inv_l, + const unsigned int n, + Rcpp::NumericVector K_vec = Rcpp::NumericVector::create(), + const unsigned int random_start = 1, + const unsigned int maxit = 100, + const double thres = 1e-4) +{ + //initialize + const int p = b_exp.n_rows, L = b_exp.n_cols; + arma::vec K_vec1; + if(K_vec.size() == 0){ + K_vec1 = linspace(0, p - L - 1, p - L); + }else{ + K_vec1 = as(K_vec); + } + arma::vec WK1vec = as(WK_func(Sig_inv_l)[""WK1vec""]); + arma::mat WK1mat = as(WK_func(Sig_inv_l)[""WK1mat""]); + + const int K_vec_len = K_vec1.n_elem; + arma::mat rand_theta(L,K_vec_len), invalid_mat(p,K_vec_len); + arma::vec rand_l(K_vec_len), Conv_l(K_vec_len), BIC_vec; + for(unsigned int i=0; i < K_vec_len; ++i) + { + int K_value = K_vec1(i); + Rcpp::List rand_res = MVcML_estimate_random_c(b_exp,b_out,se_bx,Sig_inv_l, + WK1vec, WK1mat, + K_value, n, + random_start, maxit,thres); + if(as(rand_res[""Converge""]) == 1){ + Conv_l(i) = 1; + continue; + } + rand_theta.col(i) = as(rand_res[""theta""]); + rand_l(i)= rand_res[""l""]; + Conv_l(i) = 0; + invalid_mat.col(i) = as(rand_res[""r_vec""]); + } + uvec q1 = find(Conv_l == 0); + if(q1.n_elem==0){ + return Rcpp::List::create(Rcpp::Named(""Converge"") = 1); + } + BIC_vec = log(n) * K_vec1(q1) + 2 * rand_l(q1); + +// cML-BIC + unsigned int min_ind = BIC_vec.index_min(); + uvec BIC_invalid = arma::find(invalid_mat.cols(q1).eval().col(min_ind)); + + arma::vec BIC_theta = rand_theta.cols(q1).eval().col(min_ind); + + Rcpp::List res; + res[""BIC_theta""] = BIC_theta; + res[""BIC_invalid""] = BIC_invalid + 1; + res[""l_vec""] = rand_l; + res[""K_vec""] = K_vec1; + res[""theta_vec""] = rand_theta; + res[""Conv_vec""] = Conv_l; + res[""Converge""] = 0; + res[""BIC_vec""] = BIC_vec; + + return res; + +} + +//' MVMRcML method with Data Perturbation +//' +//' This is the main function of MVMR-cML. +//' +//' @param b_exp A m*L matrix of SNP effects on the exposure variable. +//' @param b_out A m*1 matrix of SNP effects on the outcome variable. +//' @param se_bx A m*L matrix of standard errors of \code{b_exp}. +//' @param Sig_inv_l A list of the inverse of m covariance matrices, generated by \code{invcov_mvmr()}. +//' @param n The smallest sample size of the L+1 GWAS dataset. +//' @param K_vec Sets of candidate K's, the constraint parameter representing number of invalid IVs. +//' @param random_start Number of random start points, default is 1. +//' @param num_pert Number of perturbation, default is 100. +//' @param maxit Maximum number of iterations for each optimization, default is 100. +//' @param thres Threshold for convergence criterion. +//' +//' @import Rcpp +//' @import RcppArmadillo +//' @return A list +//' \describe{ +//' \item{BIC_theta}{Estimated causal effect from MVMR-cML-BIC} +//' \item{BIC_invalid}{Invalid IVs selected by MVMR-cML-BIC} +//' \item{BIC_DP_theta}{Estimated causal effect from MVMR-cML-DP } +//' \item{BIC_DP_se}{Estimate standard error for \code{BIC_DP_theta}} +//' \item{eff_DP_B}{Data perturbation with successful convergence} +//' } +//' +//' @export +// [[Rcpp::export]] +Rcpp::List MVmr_cML_DP(const arma::mat& b_exp, const arma::mat& b_out, + const arma::mat& se_bx, + const Rcpp::List& Sig_inv_l, + const unsigned int n, + Rcpp::NumericVector K_vec = Rcpp::NumericVector::create(), + const unsigned int random_start = 1, + const unsigned int num_pert = 100, + const unsigned int maxit = 100, + const double thres = 1e-4) +{ + //initialize + const int p = b_exp.n_rows, L = b_exp.n_cols; + arma::vec K_vec1; + arma::mat theta_v(L,num_pert); + Rcpp::List cML_res = MVmr_cML(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, maxit, thres); + arma::mat b_exp_new(size(b_exp)), b_out_new(size(b_out)); + arma::vec theta_b, Conv_v(num_pert); + for(unsigned int pt_ind = 0; pt_ind < num_pert; ++pt_ind) + { + for(unsigned int i = 0; i < p; ++i) + { + arma::mat sig = arma::inv(as(Sig_inv_l[i])); + arma::mat epis = mvrnormArma(1, zeros(L+1), sig); + b_exp_new.row(i) = b_exp.row(i) + epis.head_cols(L); + b_out_new.row(i) = b_out.row(i) + epis.col(L); + } + Rcpp::List cML_res_b = MVmr_cML(b_exp_new, b_out_new, se_bx, Sig_inv_l, n, K_vec, random_start, maxit, thres); + if(as(cML_res_b[""Converge""])==1){ + Conv_v(pt_ind) = 1; + continue; + } + theta_b = as(cML_res_b[""BIC_theta""]); + theta_v.col(pt_ind) = theta_b; + Conv_v(pt_ind) = 0; + } + uvec q1 = find(Conv_v == 0); + // cML-BIC-DP + arma::vec BIC_DP_theta = mean(theta_v.cols(q1).eval(), 1); + arma::vec BIC_DP_se = stddev(theta_v.cols(q1).eval(), 0, 1); + + Rcpp::List res; + res[""BIC_theta""] = cML_res[""BIC_theta""]; + res[""BIC_invalid""] = cML_res[""BIC_invalid""]; + res[""BIC_DP_theta""] = BIC_DP_theta; + res[""BIC_DP_se""] = BIC_DP_se; + res[""eff_DP_B""] = q1.n_elem; + return res; + +} + + +// You can include R code blocks in C++ files processed with sourceCpp +// (useful for testing and development). The R code will be automatically +// run after the compilation. + + + +","C++" +"Allele","ZhaotongL/MVMR-cML","R/MVMRcML.R",".R","2671","75","#' Profile likelihood of valid IVs +#' +#' calculate the profile likelihood of valid IVs up to a constant +#' +#' @keywords internal +#' +pl <- function(x,b_exp_v,b_out_v,Sig_inv_v){ + k = ncol(b_exp_v) + m_valid = length(b_out_v) + pll = 0 + for(i in 1:m_valid){ + W = Sig_inv_v[[i]] + b_exp_i = b_exp_v[i,] + b_out_i = b_out_v[i] + beta = c(b_exp_i,b_out_i) + B = W[-(k+1),] %*% beta + c(W[(k+1),] %*% beta) * x + A = W[-(k+1),-(k+1)] + W[-(k+1),k+1] %*% t(x) + x %*% t(W[k+1,-(k+1)]) + W[k+1,k+1] * x %*% t(x) + bhat_xi = solve(A) %*% B + b_i = c(bhat_xi,t(bhat_xi) %*% x) + pll = pll -1/2 * t(b_i) %*% W %*% b_i + t(beta) %*% W %*% b_i + } + return(-pll) +} + +#' Generate the list of inverse of covariance matrices used in \code{MVMR-cML-DP} +#' +#' @param se_bx A m*L matrix of standard errors of SNP-exposure association +#' @param se_by A vector of standard errors of SNP-outcome association +#' @param rho_mat A (L+1)\eqn{\times}(L+1) correlation matrix among the L exposures and the outcome, note that the upper-left L\eqn{\times}L submatrix corresponding to the L exposures. +#' @return A list of inverse of covariance matrices with respect to each genetic variant, retaining the ordering in \code{se_bx} +#' +#' @export +#' +invcov_mvmr <- function(se_bx, se_by, rho_mat){ + Sig_l = Sig_inv_l = list() + m = nrow(se_bx) + for(i in 1:m){ + Sig = rho_mat*crossprod(t(c(se_bx[i,],se_by[i]))) + Sig_l[[i]] = Sig + Sig_inv_l[[i]] = solve(Sig) + } + return(Sig_inv_l) +} + +#' Standard error estimate for MVMR-cML-BIC +#' +#' This is based on the profile likelihood of the set of valid IVs, which is not robust to uncertainty in model selection. +#' +#' @param b_exp A matrix of SNP effects on the exposure variable. +#' @param b_out A vector of SNP effects on the outcome variable. +#' @param Sig_inv_l A list of inverse of covariance matrix. +#' @param theta A vector of final estimates of causal effect of each exposure by MVMR-cML-BIC obtained from \code{MVmr_cML_DP}. +#' @param zero_ind A vector of the index of valid IVs. +#' @param r_vec A vector of estimated horizontal pleiotropic effects. +#' +#' +#' @import numDeriv +#' @return A vector +#' +#' @export +#' +MVcML_SdTheta <- function(b_exp,b_out,Sig_inv_l,theta,zero_ind,r_vec=NULL){ + if(!is.null(r_vec)){ + zero_ind = which(r_vec==0) + } + H = hessian(pl,x=theta,b_exp_v = b_exp[zero_ind,,drop=FALSE], b_out_v=b_out[zero_ind],Sig_inv_v =Sig_inv_l[zero_ind]) + se_theta = sqrt(diag(solve(H))) + # ores = optim(theta,pl,method = 'BFGS',b_exp_v=b_exp[zero_ind,],b_out_v=b_out[zero_ind],Sig_inv_v= Sig_inv_l[zero_ind], + # hessian = TRUE) + # sqrt(diag(solve(ores$hessian))) + return(se_theta) +} + + +","R" +"Allele","ZhaotongL/MVMR-cML","R/RcppExports.R",".R","3033","65","# Generated by using Rcpp::compileAttributes() -> do not edit by hand +# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#' MVMRcML method with BIC selection +#' +#' This is the main function of MVMR-cML. +#' +#' @param b_exp A m*L matrix of SNP effects on the exposure variable. +#' @param b_out A m*1 matrix of SNP effects on the outcome variable. +#' @param se_bx A m*L matrix of standard errors of \code{b_exp}. +#' @param Sig_inv_l A list of the inverse of m covariance matrices, generated by \code{invcov_mvmr()}. +#' @param n The smallest sample size of the L+1 GWAS dataset. +#' @param K_vec Sets of candidate K's, the constraint parameter representing number of invalid IVs. +#' @param random_start Number of random start points, default is 1. +#' @param maxit Maximum number of iterations for each optimization, default is 100. +#' @param thres Threshold for convergence criterion. +#' +#' @import Rcpp +#' @import RcppArmadillo +#' @return A list +#' \describe{ +#' \item{BIC_theta}{Estimated causal effect from MVMR-cML-BIC} +#' \item{BIC_invalid}{Invalid IVs selected by MVMR-cML-BIC} +#' \item{K_vec}{K_vec to be searched from} +#' \item{Converge}{0 if converge; 1 otherwise} +#' \item{BIC_vec}{BIC vector corresponding to K_vec} +#' } +#' +#' @export +MVmr_cML <- function(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec = as.numeric( c()), random_start = 1L, maxit = 100L, thres = 1e-4) { + .Call('_MVMRcML_MVmr_cML', PACKAGE = 'MVMRcML', b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, maxit, thres) +} + +#' MVMRcML method with Data Perturbation +#' +#' This is the main function of MVMR-cML. +#' +#' @param b_exp A m*L matrix of SNP effects on the exposure variable. +#' @param b_out A m*1 matrix of SNP effects on the outcome variable. +#' @param se_bx A m*L matrix of standard errors of \code{b_exp}. +#' @param Sig_inv_l A list of the inverse of m covariance matrices, generated by \code{invcov_mvmr()}. +#' @param n The smallest sample size of the L+1 GWAS dataset. +#' @param K_vec Sets of candidate K's, the constraint parameter representing number of invalid IVs. +#' @param random_start Number of random start points, default is 1. +#' @param num_pert Number of perturbation, default is 100. +#' @param maxit Maximum number of iterations for each optimization, default is 100. +#' @param thres Threshold for convergence criterion. +#' +#' @import Rcpp +#' @import RcppArmadillo +#' @return A list +#' \describe{ +#' \item{BIC_theta}{Estimated causal effect from MVMR-cML-BIC} +#' \item{BIC_invalid}{Invalid IVs selected by MVMR-cML-BIC} +#' \item{BIC_DP_theta}{Estimated causal effect from MVMR-cML-DP } +#' \item{BIC_DP_se}{Estimate standard error for \code{BIC_DP_theta}} +#' \item{eff_DP_B}{Data perturbation with successful convergence} +#' } +#' +#' @export +MVmr_cML_DP <- function(b_exp, b_out, se_bx, Sig_inv_l, n, K_vec = as.numeric( c()), random_start = 1L, num_pert = 100L, maxit = 100L, thres = 1e-4) { + .Call('_MVMRcML_MVmr_cML_DP', PACKAGE = 'MVMRcML', b_exp, b_out, se_bx, Sig_inv_l, n, K_vec, random_start, num_pert, maxit, thres) +} + +","R" +"Allele","Sendrowski/fastDFE","CITATION.md",".md","443","14","```bibtex +@article{fastdfe, + author = {Sendrowski, Janek and Bataillon, Thomas}, + title = {fastDFE: fast and flexible inference of the distribution of fitness effects}, + journal = {Molecular Biology and Evolution}, + publisher = {Oxford University Press}, + pages = {msae070}, + year = {2024}, + month = {04}, + issn = {1537-1719}, + doi = {10.1093/molbev/msae070}, + url = {https://doi.org/10.1093/molbev/msae070} +} +```","Markdown" +"Allele","Sendrowski/fastDFE","testing/test_optimization.py",".py","19052","574","import logging +from typing import Literal, List + +import matplotlib.pyplot as plt +import numpy as np +from numpy import testing + +from fastdfe.optimization import pack_params, unpack_params, flatten_dict, unflatten_dict, filter_dict, Optimization, \ + merge_dicts, correct_values, to_symlog, from_symlog, scale_bound, scale_value, unscale_value, unscale_bound, \ + check_bounds, perturb_value, collapse_fixed_to_mean, collapse_fixed +from testing import TestCase + + +class OptimizationTestCase(TestCase): + """""" + Test the Optimization class. + """""" + + def test_pack_unpack_restores_dict(self): + """""" + Check whether the parameters can be restored from packed format. + """""" + params = { + 'all': {'S_d': -400.0, 'b': 0.4, 'p_b': 0.02, 'S_b': 4.0, 'eps': 0.05}, + 'sub': {'S_d': -399.0, 'b': 0.39, 'p_b': 0.12, 'S_b': 4.1, 'eps': 0.02}, + } + + restored = unpack_params(pack_params(params), params) + + self.assertDictEqual(params, restored) + + def test_flatten_dict(self): + """""" + Test that flatten_dict works as expected. + """""" + d = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}} + expected = {'a': 1, 'b.c': 2, 'b.d.e': 3} + assert flatten_dict(d) == expected + + d = {'a': {'b': {'c': 1}}} + expected = {'a.b.c': 1} + assert flatten_dict(d) == expected + + def test_unflatten_dict(self): + """""" + Test that unflatten_dict works as expected. + """""" + d = {'a': 1, 'b.c': 2, 'b.d.e': 3} + expected = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}} + assert unflatten_dict(d) == expected + + d = {'a.b.c': 1} + expected = {'a': {'b': {'c': 1}}} + assert unflatten_dict(d) == expected + + def test_flatten_unflatten_dict(self): + """""" + Test that flatten_dict and unflatten_dict are inverse operations. + """""" + d = {'a': 1, 'b': {'c': 2, 'd': {'e': 3}}} + expected = d + flattened = flatten_dict(d) + unflattened = unflatten_dict(flattened) + assert unflattened == expected + + def test_filter_dict(self): + """""" + Test that filter_dict works as expected. + """""" + d = {'a': 1, 'b': {'c': 2, 'd': {'e': 3, 'f': {'g': 4}}}, 'c': {'g': 1, 'b': 2}} + keys = ['a', 'c'] + expected = {'a': 1, 'b': {'c': 2}} + assert filter_dict(d, keys) == expected + + def test_sample_x0_nested_dict(self): + """""" + Test that sample_x0 works as expected when the initial parameters are a nested dict. + """""" + x0 = {'a': 1, 'b': {'c': 2, 'd': 4}} + + o = Optimization( + bounds={'a': (2, 2), 'b': (0, 0), 'c': (-1, -1), 'd': (4, 4)}, + scales={'a': 'lin', 'b': 'lin', 'c': 'lin', 'd': 'lin'}, + param_names=['a', 'b', 'c', 'd'] + ) + + sample = o.sample_x0(x0) + expected = {'a': 2.0, 'b': {'c': -1.0, 'd': 4.0}} + + assert sample == expected + + def test_merge_dicts(self): + """""" + Test that merge_dicts works as expected. + """""" + dict1 = {'a': 1, 'b': {'c': 2, 'd': 3}} + dict2 = {'b': {'d': 4, 'e': 5}, 'f': 6} + expected_result = {'a': 1, 'b': {'c': 2, 'd': 4, 'e': 5}, 'f': 6} + + assert merge_dicts(dict1, dict2) == expected_result + + dict3 = {'a': {'b': 1, 'c': {'d': 2, 'e': {'f': 3}}}} + dict4 = {'a': {'b': 4, 'c': {'d': 5, 'e': {'g': 6}}}} + expected_result2 = {'a': {'b': 4, 'c': {'d': 5, 'e': {'f': 3, 'g': 6}}}} + + assert merge_dicts(dict3, dict4) == expected_result2 + + dict5 = {'a': 1, 'b': {'c': 2}} + dict6 = {'b': {'c': 3}, 'd': 4} + expected_result3 = {'a': 1, 'b': {'c': 3}, 'd': 4} + + assert merge_dicts(dict5, dict6) == expected_result3 + + dict7 = {'a': 1} + dict8 = {'b': 2} + expected_result4 = {'a': 1, 'b': 2} + + assert merge_dicts(dict7, dict8) == expected_result4 + + def test_positive_bounds(self): + """""" + Test that ValueError is raised when bounds are positive. + """""" + bounds = (1, 10) + scale = 'lin' + for _ in range(100): + sample = Optimization.sample_value(bounds, scale) + self.assertGreaterEqual(sample, bounds[0]) + self.assertLessEqual(sample, bounds[1]) + + def test_negative_bounds(self): + """""" + Test that ValueError is raised when bounds are negative. + """""" + bounds = (-10, -1) + scale = 'lin' + for _ in range(100): + sample = Optimization.sample_value(bounds, scale) + self.assertGreaterEqual(sample, bounds[0]) + self.assertLessEqual(sample, bounds[1]) + + def test_mixed_bounds(self): + """""" + Test that ValueError is raised when bounds are mixed. + """""" + bounds = (-5, 5) + scale = 'lin' + for _ in range(100): + sample = Optimization.sample_value(bounds, scale) + self.assertGreaterEqual(sample, bounds[0]) + self.assertLessEqual(sample, bounds[1]) + + def test_positive_bounds_log_scale(self): + """""" + Test that ValueError is raised when bounds are positive and scale is log. + """""" + bounds = (1, 10) + scale = 'log' + for _ in range(100): + sample = Optimization.sample_value(bounds, scale) + self.assertGreaterEqual(sample, bounds[0]) + self.assertLessEqual(sample, bounds[1]) + + def test_negative_bounds_log_scale(self): + """""" + Test that ValueError is raised when bounds are negative and scale is log. + """""" + bounds = (-10, -1) + scale = 'log' + for _ in range(100): + sample = Optimization.sample_value(bounds, scale) + self.assertGreaterEqual(sample, bounds[0]) + self.assertLessEqual(sample, bounds[1]) + + def test_mixed_bounds_log_scale(self): + """""" + Test that ValueError is raised when bounds are mixed and scale is log. + """""" + bounds = (-5, 5) + scale = 'log' + with self.assertRaises(ValueError): + Optimization.sample_value(bounds, scale) + + def test_correct_values_no_changes(self): + """""" + Test that values are not changed when they are within bounds. + """""" + params = {""a.a"": 2, ""a.b"": 5, ""a.c"": 10} + bounds = {""a"": (1, 3), ""b"": (4, 6), ""c"": (8, 12)} + scales = {""a"": ""lin"", ""b"": ""lin"", ""c"": ""lin""} + + expected = params.copy() + actual = correct_values(params, bounds, scales) + self.assertEqual(expected, actual) + + def test_correct_values_corrections(self): + """""" + Test that values are corrected when they are out of bounds. + """""" + params = {""a.a"": 0, ""a.b"": 7, ""a.c"": 20} + bounds = {""a"": (1, 3), ""b"": (4, 6), ""c"": (8, 12)} + scales = {""a"": ""lin"", ""b"": ""lin"", ""c"": ""lin""} + + expected = {""a.a"": 1, ""a.b"": 6, ""a.c"": 12} + actual = correct_values(params, bounds, scales) + self.assertEqual(expected, actual) + + def test_correct_values_threshold_warning(self): + """""" + Test that a warning is raised when the threshold is exceeded. + """""" + params = {""a.a"": 0, ""a.b"": 7, ""a.c"": 20} + bounds = {""a"": (1, 3), ""b"": (4, 6), ""c"": (8, 12)} + scales = {""a"": ""lin"", ""b"": ""lin"", ""c"": ""lin""} + + with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): + correct_values(params, bounds, scales, warn=True, threshold=0.05) + + def test_symlog_scale(self): + """""" + Test the symlog scale. + """""" + testing.assert_almost_equal(4, from_symlog(to_symlog(4))) + testing.assert_almost_equal(-4, from_symlog(to_symlog(-4))) + + y = np.array([to_symlog(x) for x in range(-100, 100)]) + + # check that the sequence is strictly increasing + self.assert_strictly_increasing(y) + + # plot the sequence + plt.plot(y) + plt.show() + + def assert_strictly_increasing(self, y: np.ndarray): + """""" + Check that the sequence is strictly increasing. + + :raises AssertionError: if the sequence is not strictly increasing + """""" + if not np.all(np.diff(y) > 0): + raise AssertionError(""The sequence is not strictly increasing."") + + def test_convert_bound(self): + """""" + Test the conversion of bounds to the various scales. + """""" + testing.assert_almost_equal( + scale_bound((-10, 10), 'lin'), + (-10, 10) + ) + + testing.assert_almost_equal( + scale_bound((0.1, 10), 'log'), + (-1, 1) + ) + + symlog_bounds = (-2.0043213737826426, 2.0043213737826426) + bounds = (0.1, 10) + testing.assert_almost_equal( + scale_bound(bounds, 'symlog'), + symlog_bounds + ) + + x = np.linspace(*symlog_bounds, 100) + y = np.array([from_symlog(i, linthresh=bounds[0]) for i in x]) + + # check that the sequence is strictly increasing + self.assert_strictly_increasing(y) + + plt.plot(x, y) + plt.show() + + def test_scale_value_inverse(self): + """""" + Make sure that scaling and then unscaling a value returns the original value. + """""" + # Test parameters + test_values = np.array([-1e4, -1e2, -1e0, 1e0, 1e2, 1e4]) + + # only used to define linthresh + bounds = np.array([ + (-1e5, -1e-5), + (-1e3, -1e-3), + (-1e1, -1e-1), + (1e-1, 1e1), + (1e-3, 1e3), + (1e-5, 1e5) + ]) + + scales: List[Literal['lin', 'log', 'symlog']] = ['lin', 'log', 'symlog'] + tolerance = 1e-10 + + for scale in scales: + for value, bound in zip(test_values, bounds): + + if scale == 'symlog' and bound[1] < 0: + # doesn't work for negative bounds + continue + + # Scale and then unscale the value + scaled_value = scale_value(value, bound, scale) + unscaled_value = unscale_value(scaled_value, bound, scale) + + # Check if the original value and unscaled_value are close within the tolerance + assert np.isclose(value, unscaled_value, atol=tolerance, rtol=0) + + def test_scale_bounds_inverse(self): + """""" + Make sure that scaling and then unscaling bounds returns the original bounds. + """""" + # Test parameters + test_bounds = [(1e-5, 1e6), (1e-1, 1e4), (1e-3, 1e1)] + scales: List[Literal['lin', 'log', 'symlog']] = ['lin', 'log', 'symlog'] + + for scale in scales: + for bounds in test_bounds: + # Scale and then unscale the bounds + scaled_bounds = scale_bound(bounds, scale) + unscaled_bounds = unscale_bound(scaled_bounds, scale, linthresh=bounds[0]) + + # Check if the original bounds and unscaled_bounds are close within the tolerance + assert np.allclose(bounds, unscaled_bounds, atol=1e-7, rtol=0) + + def test_scale_bounds_raises_error(self): + """""" + Test that scale_bounds raises an error when the bounds or the scale are not valid. + """""" + with self.assertRaises(ValueError): + scale_bound((-1, 1), 'log') + + with self.assertRaises(ValueError): + scale_bound((0, 1), 'log') + + with self.assertRaises(ValueError): + scale_bound((-1, 1), 'symlog') + + with self.assertRaises(ValueError): + scale_bound((1, 2), 'foo') + + def test_plot_scaled_values(self): + """""" + Test plotting the scaled values within the untransformed bounds for the different scales. + """""" + bounds = dict( + lin=(-10, 10), + log=(0.1, 10), + symlog=(0.001, 10) + ) + + fig, axes = plt.subplots(1, 3, figsize=(15, 5)) + + scale: Literal['lin', 'log', 'symlog'] + for i, scale in enumerate(['lin', 'log', 'symlog']): + bounds_scaled = scale_bound(bounds[scale], scale) + x_scaled = [unscale_value(x, bounds=bounds[scale], scale=scale) for x in np.linspace(*bounds_scaled, 100)] + y_scaled = np.array([scale_value(x, bounds=bounds[scale], scale=scale) for x in x_scaled]) + + x_unscaled = np.linspace(*unscale_bound(bounds_scaled, scale=scale, linthresh=bounds[scale][0]), 100) + y_unscaled = np.array([unscale_value(i, bounds=bounds[scale], scale=scale) for i in y_scaled]) + axes[i].plot(x_unscaled, y_unscaled, label=scale) + axes[i].set_title(scale) + + plt.show() + + def test_sample_value_symlog_scale(self): + """""" + Sample a value from the symlog scale. + """""" + y = [Optimization.sample_value(scale='symlog', bounds=(0.1, 10)) for _ in range(10000)] + + plt.hist(y, bins=50) + plt.show() + + # check that we both have positive and negative values + assert np.any(np.array(y) > 0) and np.any(np.array(y) < 0) + + def test_check_bounds_linear(self): + """""" + Test that check_bounds works as expected for linear scale. + """""" + bounds = dict( + param1=(1, 10), + param2=(1, 10), + param3=(-10, -1), + param4=(-10, -1), + param5=(-10, -1), + ) + + params = dict( + param1=1.1, + param2=1.005, + param3=-9.9, + param4=-9.995, + param5=11, + ) + + fixed_params = {} + percentile = 1 + + lower, upper = check_bounds(bounds, params, fixed_params, percentile, scale='lin') + + self.assertEqual(['param2', 'param4'], list(lower.keys())) + self.assertEqual(['param5'], list(upper.keys())) + + def test_check_bounds_log(self): + """""" + Test that check_bounds works as expected for log scale. + """""" + bounds = dict( + param1=(1, 10), + param2=(1, 10), + param3=(-10, -1), + param4=(-10, -1), + param5=(-1, 1), + param6=(-1, 1), + param7=(-1, 1), + param8=(-1, 1), + ) + + params = dict( + param1=1.1, + param2=1.005, + param3=-9.9, + param4=-9.995, + param5=0, + param6=0.99, + param7=-0.99, + param8=0.1, + ) + + fixed_params = {} + percentile = 1 + + lower, upper = check_bounds(bounds, params, fixed_params, percentile, scale='log') + + self.assertEqual(['param2'], list(lower.keys())) + + # param7 doesn't work for log scale + self.assertEqual(['param6', 'param8'], list(upper.keys())) + + def test_perturb_value(self): + """""" + Test the perturb_value function. + """""" + rng = np.random.default_rng(seed=42) + + bounds = (1, 10) + value = 5 + + perturbed_values = [perturb_value(value, bounds, rng) for _ in range(100)] + + self.assertGreaterEqual(np.std(perturbed_values), 0.3) + + def test_perturb_value_near_bounds(self): + """""" + Test the perturb_value function when the value is near the bounds. + """""" + rng = np.random.default_rng(seed=42) + + bounds = (1, 10) + value_low = 1.1 + value_high = 9.9 + + perturbed_values_low = np.array([perturb_value(value_low, bounds, rng) for _ in range(100)]) + perturbed_values_high = np.array([perturb_value(value_high, bounds, rng) for _ in range(100)]) + + self.assertGreaterEqual(np.std(perturbed_values_low), 0.03) + self.assertGreaterEqual(np.std(perturbed_values_high), 0.3) + + # make sure that perturbed values are within bounds + self.assertTrue(np.all((perturbed_values_low >= bounds[0]) & (perturbed_values_low <= bounds[1]))) + self.assertTrue(np.all((perturbed_values_high >= bounds[0]) & (perturbed_values_high <= bounds[1]))) + + def test_perturb_params(self): + """""" + Test the perturb_params function. + """""" + rng = np.random.default_rng(seed=42) + + bounds = { + 'param1': (1, 10), + 'param2': (1, 10), + 'param3': (-10, -1), + } + + params = { + 'param1': 5, + 'param2': 9, + 'param3': -5, + } + + for i in range(10): + + perturbed_params = flatten_dict(Optimization.perturb_params(params, bounds, rng)) + + for key in params.keys(): + self.assertNotEqual(params[key], perturbed_params[key]) + self.assertGreaterEqual(perturbed_params[key], bounds[key][0]) + self.assertLessEqual(perturbed_params[key], bounds[key][1]) + + def test_collapse_fixed_to_mean(self): + """""" + Test the collapse_fixed_to_mean function. + """""" + self.assertDictEqual( + collapse_fixed_to_mean( + { + 'pendula': {'eps': 0, 'h': 0.6, 'p_b': 0, 'S_b': 1}, + 'pubescens': {'eps': 0, 'h': 0.5, 'p_b': 0, 'S_b': 1} + }, + types=['pendula', 'pubescens'] + ), + {'all': {'eps': 0, 'h': 0.55, 'p_b': 0, 'S_b': 1}} + ) + + self.assertDictEqual( + collapse_fixed_to_mean( + { + 'all': {'b': 1}, + 'pendula': {'eps': 0, 'h': 0.6, 'p_b': 0, 'S_b': 1}, + 'pubescens': {'eps': 0, 'h': 0.5, 'p_b': 0, 'S_b': 1} + }, + types=['pendula', 'pubescens'] + ), + {'all': {'eps': 0, 'h': 0.55, 'p_b': 0, 'S_b': 1, 'b': 1}} + ) + + def test_collapse_fixed(self): + """""" + Test the collapse_fixed function. + """""" + self.assertDictEqual( + collapse_fixed(dict( + all=dict(h=0.5), + pendula=dict(S_b=0.5, p_b=0, S_d=-100), + pubescens=dict(S_b=0.5, p_b=0.1, b=0.3)), + types=['pendula', 'pubescens'] + ), + dict(all=dict(h=0.5, S_b=0.5), pendula=dict(S_d=-100, p_b=0), pubescens=dict(b=0.3, p_b=0.1)) + ) + + self.assertDictEqual( + collapse_fixed(dict( + all=dict(h=0.5, S_b=0.5), + pendula=dict(p_b=0, S_d=-100), + pubescens=dict(p_b=0.1, b=0.3), + foo=dict(bar=1)), + types=['pendula', 'pubescens'] + ), + dict( + all=dict(h=0.5, S_b=0.5), + pendula=dict(S_d=-100, p_b=0), + pubescens=dict(b=0.3, p_b=0.1), + foo=dict(bar=1) + ) + ) + + self.assertDictEqual( + collapse_fixed(dict( + all=dict(h=0.5, S_b=0.5), + pendula=dict(p_b=0, S_d=-100), + pubescens=dict(p_b=0.1, b=0.3), + foo=dict(bar=1)), + types=[] + ), + dict( + all=dict(h=0.5, S_b=0.5), + pendula=dict(p_b=0, S_d=-100), + pubescens=dict(p_b=0.1, b=0.3), + foo=dict(bar=1), + ) + ) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_filtration.py",".py","19072","462","from functools import cached_property +from typing import List +from unittest.mock import Mock + +import numpy as np + +import fastdfe as fd +from fastdfe.io_handlers import count_sites +from testing import TestCase + + +class FiltrationTestCase(TestCase): + """""" + Test the filterer and filtration classes. + """""" + + @staticmethod + def test_filter_snp_filtration(): + """""" + Test the SNP filtration. + """""" + f = fd.Filterer( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + output='scratch/test_filter_snp_filtration.vcf', + filtrations=[fd.SNPFiltration()], + ) + + f.filter() + + # assert no sites were filtered + assert f.n_filtered == 2 + + # assert number of sites is the same + assert count_sites(f.vcf) == count_sites(f.output) + f.n_filtered + + def test_snp_filtration_use_sample_mask_from_parser_if_specified(self): + """""" + Make sure the SNP filtration uses the sample mask from the parser. + """""" + f = fd.SNPFiltration( + use_parser=True, + ) + + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + filtrations=[f], + n=10, + include_samples=['ASP01', 'ASP02', 'ASP03'], + ) + + p._setup() + + self.assertEqual(3, sum(p._samples_mask)) + + np.testing.assert_array_equal(f._samples_mask, p._samples_mask) + + def test_snp_filtration_dont_use_sample_mask_from_parser_if_specified(self): + """""" + Make sure the SNP filtration doesn't use the sample mask from the parser. + """""" + f = fd.SNPFiltration( + use_parser=False, + ) + + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + filtrations=[f], + n=10, + include_samples=['ASP01', 'ASP02', 'ASP03'], + ) + + p._setup() + + self.assertEqual(3, sum(p._samples_mask)) + + self.assertEqual(None, f._samples_mask) + + def test_snp_filtration_include(self): + """""" + Make sure the SNP filtration uses the sample mask from the parser. + """""" + f = fd.SNPFiltration( + include_samples=['ASP01', 'ASP02', 'ASP03'] + ) + + filterer = fd.Filterer( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + output='scratch/test_snp_filtration_include.vcf', + filtrations=[f], + ) + + filterer._setup() + + self.assertEqual(3, sum(f._samples_mask)) + self.assertEqual(377, len(f._samples_mask)) + + @staticmethod + def test_filter_no_poly_allelic_filtration(): + """""" + Test the no poly-allelic filtration. + """""" + f = fd.Filterer( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + output='scratch/test_filter_no_poly_allelic_filtration.vcf', + filtrations=[fd.PolyAllelicFiltration()], + ) + + f.filter() + + # assert no sites were filtered + assert f.n_filtered == 0 + + # assert number of sites is the same + assert count_sites(f.vcf) == count_sites(f.output) + + @staticmethod + def test_annotator_load_vcf_from_url(): + """""" + Test the annotator loading a VCF from a URL. + """""" + f = fd.Filterer( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + output='scratch/test_annotator_load_vcf_from_url.vcf', + filtrations=[fd.PolyAllelicFiltration()] + ) + + f.filter() + + # assert number of sites is the same + assert f.n_sites == 10000 + assert f.n_filtered == 0 + + @staticmethod + def test_deviant_outgroup_filtration(): + """""" + Test the annotator loading a VCF from a URL. + """""" + f = fd.Filterer( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_deviant_outgroup_filtration.vcf', + filtrations=[fd.DeviantOutgroupFiltration(outgroups=[""ERR2103730"", ""ERR2103731""])] + ) + + f.filter() + + # assert number of sites is the same + assert f.n_sites == 10000 + assert f.n_filtered == 510 + + @staticmethod + def test_deviant_outgroup_filtration_single_site(): + """""" + Test the annotator loading a VCF from a URL. + """""" + from cyvcf2 import Variant + + mock_variant = Mock(spec=Variant) + + # test case 1: variant is not an SNP + mock_variant.is_snp = False + filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1']) + filter_obj.samples = np.array(['ingroup1', 'outgroup1']) + filter_obj._create_masks() + assert filter_obj.filter_site(mock_variant) # expect True as the variant is not SNP + + # test case 2: variant is an SNP, strict mode is enabled and no outgroup sample is present + mock_variant.is_snp = True + filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1'], strict_mode=True) + filter_obj.samples = np.array(['ingroup1', 'outgroup1']) + filter_obj._create_masks() + mock_variant.gt_bases = np.array(['A/A', './.']) + assert not filter_obj.filter_site(mock_variant) # expect False as no outgroup sample is present + + # test case 3: variant is an SNP, strict mode is disabled and no outgroup sample is present + filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1'], strict_mode=False) + filter_obj.samples = np.array(['ingroup1', 'outgroup1']) + filter_obj._create_masks() + mock_variant.gt_bases = np.array(['A/A', './.']) + assert filter_obj.filter_site(mock_variant) # # expect True as strict mode off and no outgroup sample present + + # test case 4: variant is an SNP and outgroup base is different from ingroup base + filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1']) + filter_obj.samples = np.array(['ingroup1', 'outgroup1']) + filter_obj._create_masks() + mock_variant.gt_bases = np.array(['A/A', 'T/T']) + assert not filter_obj.filter_site(mock_variant) # expect False as outgroup base is different from ingroup base + + # test case 5: variant is an SNP and outgroup base is same as ingroup base + filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1'], ingroups=['ingroup1']) + filter_obj.samples = np.array(['ingroup1', 'outgroup1']) + filter_obj._create_masks() + mock_variant.gt_bases = np.array(['A/A', 'A/A']) + assert filter_obj.filter_site(mock_variant) # expect True as outgroup base is same as ingroup base + + # test case 6: multiple ingroups and outgroups with matching major bases + mock_variant = Mock(spec=Variant) + mock_variant.is_snp = True + filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1', 'outgroup2'], + ingroups=['ingroup1', 'ingroup2']) + filter_obj.samples = np.array(['ingroup1', 'ingroup2', 'outgroup1', 'outgroup2']) + filter_obj._create_masks() + mock_variant.gt_bases = np.array(['A/A', 'A/T', 'A/A', 'A/G']) + assert filter_obj.filter_site(mock_variant) # expect True as major base 'A' is common in ingroup and outgroup + + # test case 7: multiple ingroups and outgroups with differing major bases + mock_variant = Mock(spec=Variant) + mock_variant.is_snp = True + filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1', 'outgroup2'], + ingroups=['ingroup1', 'ingroup2']) + filter_obj.samples = np.array(['ingroup1', 'ingroup2', 'outgroup1', 'outgroup2']) + filter_obj._create_masks() + mock_variant.gt_bases = np.array(['A/A', 'A/T', 'T/T', 'T/G']) + assert not filter_obj.filter_site(mock_variant) # expect False as major base 'A' in ingroup and 'T' in outgroup + + # test case 8: make sure we retain mono-allelic sites if retain_monomorphic is True + mock_variant = Mock(spec=Variant) + mock_variant.is_snp = False + filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1', 'outgroup2'], + ingroups=['ingroup1', 'ingroup2'], retain_monomorphic=True) + filter_obj.samples = np.array(['ingroup1', 'ingroup2', 'outgroup1', 'outgroup2']) + filter_obj._create_masks() + mock_variant.gt_bases = np.array(['A/A', 'A/A', 'T/T', 'T/T']) + assert filter_obj.filter_site(mock_variant) # expect True as major base 'A' in ingroup and 'T' in outgroup + + # test case 9: make sure we don't retain mono-allelic sites if retain_monomorphic is False + mock_variant = Mock(spec=Variant) + mock_variant.is_snp = False + filter_obj = fd.DeviantOutgroupFiltration(outgroups=['outgroup1', 'outgroup2'], + ingroups=['ingroup1', 'ingroup2'], retain_monomorphic=False) + filter_obj.samples = np.array(['ingroup1', 'ingroup2', 'outgroup1', 'outgroup2']) + filter_obj._create_masks() + mock_variant.gt_bases = np.array(['A/A', 'A/A', 'T/T', 'T/T']) + assert not filter_obj.filter_site(mock_variant) # expect False as major base 'A' in ingroup and 'T' in outgroup + + @staticmethod + def test_existing_outgroup_filtration_single_site_1_missing(): + """""" + Test the existing outgroup filtration. + """""" + from cyvcf2 import Variant + + # test case 1: variants has one fully defined outgroup sample + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1']) + filter_obj.samples = np.array(['ingroup1', 'outgroup1']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['A/A', 'T/T']) + assert filter_obj.filter_site(mock_variant) + + # test case 2: variants has one missing outgroup sample + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1']) + filter_obj.samples = np.array(['ingroup1', 'outgroup1']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['A/A', './.']) + assert not filter_obj.filter_site(mock_variant) + + # test case 3: variants has one fully defined outgroup sample and one missing outgroup sample + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2']) + filter_obj.samples = np.array(['outgroup1', 'ingroup1', 'outgroup2']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['./.', 'A/A', 'T/T']) + assert not filter_obj.filter_site(mock_variant) + + # test case 4: variants has one outgroup sample with one missing allele + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1']) + filter_obj.samples = np.array(['ingroup1', 'outgroup1']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['A/A', 'T/.']) + assert filter_obj.filter_site(mock_variant) + + # test case 5: variants has three outgroup samples with one missing allele each + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2', 'outgroup3']) + filter_obj.samples = np.array(['ingroup1', 'outgroup1', 'outgroup2', 'outgroup3']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['A/A', 'T/.', 'T/.', 'T/.']) + assert filter_obj.filter_site(mock_variant) + + @staticmethod + def test_existing_outgroup_filtration_with_varied_n_missing(): + """""" + Test the existing outgroup filtration with shuffled masks, extra unused samples, and ingroups. + """""" + from cyvcf2 import Variant + + # test case 6: n=2, one missing outgroup, extra unused sample -> should pass + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup2', 'outgroup3'], n_missing=2) + filter_obj.samples = np.array(['unused1', 'ingroup1', 'outgroup2', 'outgroup3', 'unused2']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['A/A', 'C/C', './.', 'T/T', 'G/G']) + assert filter_obj.filter_site(mock_variant) + + # test case 7: n=2, exactly two outgroups missing, shuffled sample order -> should fail + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup3', 'outgroup1'], n_missing=2) + filter_obj.samples = np.array(['ingroup1', 'outgroup3', 'unused1', 'outgroup1', 'unused2']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['A/A', './.', 'G/G', './.', 'T/T']) + assert not filter_obj.filter_site(mock_variant) + + # test case 8: n=3, two missing outgroups, extra ingroup sample -> should pass + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2', 'outgroup3'], n_missing=3) + filter_obj.samples = np.array(['ingroup1', 'outgroup1', 'ingroup2', 'outgroup2', 'outgroup3']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['A/A', './.', 'C/C', './.', 'T/T']) + assert filter_obj.filter_site(mock_variant) + + # test case 9: n=3, exactly three outgroups missing -> should fail + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2', 'outgroup3'], n_missing=3) + filter_obj.samples = np.array(['outgroup1', 'ingroup1', 'outgroup2', 'outgroup3', 'unused1']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['./.', 'A/A', './.', './.', 'G/G']) + assert not filter_obj.filter_site(mock_variant) + + # test case 10: n=3, mixed missing and defined outgroups, with unused samples -> should pass + mock_variant = Mock(spec=Variant) + filter_obj = fd.ExistingOutgroupFiltration(outgroups=['outgroup1', 'outgroup2', 'outgroup3'], n_missing=3) + filter_obj.samples = np.array(['unused1', 'outgroup1', 'ingroup1', 'outgroup2', 'unused2', 'outgroup3']) + filter_obj._create_mask() + mock_variant.gt_bases = np.array(['G/G', './.', 'A/A', 'T/T', 'C/C', './.']) + assert filter_obj.filter_site(mock_variant) + + @staticmethod + def test_snp_filtration(): + """""" + Test the SNP filtration. + """""" + f = fd.SNPFiltration() + + assert not f.filter_site(variant=Mock(is_snp=False)) + assert f.filter_site(variant=Mock(is_snp=True)) + + @staticmethod + def test_snv_filtration(): + """""" + Test the SNV filtration. + """""" + f = fd.SNVFiltration() + + assert not f.filter_site(variant=Mock(REF='AG', ALT=['A', 'G'])) + assert f.filter_site(variant=Mock(REF='A', ALT=['G'])) + assert f.filter_site(variant=Mock(REF='A', ALT=['G', 'C'])) + assert not f.filter_site(variant=Mock(REF='A', ALT=['GA'])) + assert f.filter_site(variant=Mock(REF='A', ALT=['G', 'C', 'T'])) + + @staticmethod + def test_no_poly_allelic_filtration(): + """""" + Test the no poly-allelic filtration. + """""" + f = fd.PolyAllelicFiltration() + + assert not f.filter_site(variant=Mock(ALT=['T', 'G'])) + assert not f.filter_site(variant=Mock(ALT=['T', 'G', 'C'])) + assert f.filter_site(variant=Mock(ALT=['T'])) + assert f.filter_site(variant=Mock(ALT=[])) + + def test_coding_sequence_filtration_raises_error_if_no_fasta_given(self): + """""" + Test the coding sequence filtration. + """""" + with self.assertRaises(ValueError) as error: + f = fd.Filterer( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + output='scratch/test_coding_sequence_filtration.vcf', + filtrations=[fd.CodingSequenceFiltration()], + ) + + f.filter() + + print(error) + + @staticmethod + def test_coding_sequence_filtration(): + """""" + Test the coding sequence filtration. + """""" + f = fd.Filterer( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + output='scratch/test_coding_sequence_filtration.vcf', + gff=""resources/genome/betula/genome.gff"", + filtrations=[fd.CodingSequenceFiltration()], + ) + + f.filter() + + # assert no sites were filtered + assert f.n_filtered == 6434 + + # assert number of sites is the same + assert count_sites(f.vcf) - f.n_filtered == count_sites(f.output) + + @staticmethod + def test_existing_outgroup_filtration(): + """""" + Test the existing outgroup filtration. + """""" + f = fd.Filterer( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_existing_outgroup_filtration.vcf', + filtrations=[fd.ExistingOutgroupFiltration(outgroups=[""ERR2103730"", ""ERR2103731""])] + ) + + f.filter() + + # assert number of sites is the same + assert f.n_sites == 10000 + assert f.n_filtered == 3638 + + @staticmethod + def test_biased_gc_conversion_filtration(): + """""" + Test the SNV filtration. + """""" + f = fd.BiasedGCConversionFiltration() + + class VariantMock: + """""" + Mock the variant class. + """""" + + def __init__(self, REF: str, ALT: List[str]): + self.REF = REF + self.ALT = ALT + + @cached_property + def is_snp(self): + """""" + + :return: + """""" + return len(self.ALT) == 0 or self.REF != self.ALT[0] + + assert f.filter_site(variant=VariantMock(REF='A', ALT=['A'])) + assert f.filter_site(variant=VariantMock(REF='T', ALT=['T'])) + assert f.filter_site(variant=VariantMock(REF='T', ALT=[])) + + assert not f.filter_site(variant=VariantMock(REF='A', ALT=['G'])) + assert not f.filter_site(variant=VariantMock(REF='G', ALT=['A'])) + assert not f.filter_site(variant=VariantMock(REF='C', ALT=['T'])) + assert not f.filter_site(variant=VariantMock(REF='T', ALT=['G'])) + + assert f.filter_site(variant=VariantMock(REF='C', ALT=['G'])) + assert f.filter_site(variant=VariantMock(REF='G', ALT=['C'])) + assert f.filter_site(variant=VariantMock(REF='A', ALT=['T'])) + assert f.filter_site(variant=VariantMock(REF='T', ALT=['A'])) + + def test_contig_filtration(self): + """""" + Test the contig filtration. + """""" + f = fd.ContigFiltration(contigs=['chr1']) + + self.assertTrue(f.filter_site(variant=Mock(CHROM='chr1'))) + self.assertFalse(f.filter_site(variant=Mock(CHROM='chr2'))) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_joint_inference.py",".py","30621","866","import matplotlib.pyplot as plt +import numpy as np +import pytest +from pandas._testing import assert_frame_equal + +import fastdfe as fd +from fastdfe import JointInference, Config, SharedParams, Covariate, Spectra +from fastdfe.optimization import flatten_dict +from testing.test_base_inference import InferenceTestCase + + +class JointInferenceTestCase(InferenceTestCase): + """""" + Test the JointInference class. + """""" + config_file = ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" + + maxDiff = None + + def test_run_and_restore_from_file(self): + """""" + Test that joint inference can be restored from file. + """""" + inference = JointInference.from_config_file( + ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" + ) + + inference.run() + + out = ""scratch/test_restore_from_file.json"" + + inference.to_file(out) + + inference2 = JointInference.from_file(out) + + self.assertEqualObjects(inference, inference2) + + def test_recreate_from_config(self): + """""" + Test whether inference can be recreated from config. + """""" + inf = JointInference.from_config_file(self.config_file) + + inf2 = JointInference.from_config(inf.create_config()) + + self.assertEqualObjects(inf, inf2, ignore_keys=['fixed_params']) + + def test_perform_lrt_shared(self): + """""" + Test that the perform_lrt_shared method works. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/shared_example_2/serialized.json"" + ) + + # inference.evaluate_likelihood(inference.params_mle) + + # inference.marginal_inferences['example_1'].evaluate_likelihood( + # dict(all=inference.params_mle['example_1'])) + + assert inference.perform_lrt_shared() < 1 + + np.testing.assert_array_equal(inference.get_shared_param_names(), ['S_d']) + + def test_perform_lrt_covariates_no_covariates_raises_error(self): + """""" + Test that the perform_lrt_covariates method works. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/shared_example_1/serialized.json"" + ) + + with pytest.raises(ValueError): + inference.perform_lrt_covariates() + + @pytest.mark.slow + def test_perform_lrt_covariates(self): + """""" + Test that the perform_lrt_covariates method works. + """""" + inf = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" + ) + + inf.n_bootstraps = 2 + + assert inf.perform_lrt_covariates() < 1 + + def test_no_shared_params(self): + """""" + Test that the perform_lrt_covariates method works. + """""" + # create inference object + inf = JointInference( + sfs_neut=Spectra(dict( + pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] + )), + sfs_sel=Spectra(dict( + pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] + )), + fixed_params=dict(all=dict(h=0.5)), + do_bootstrap=False, + parallelize=False, + n_bootstraps=2, + n_runs=1 + ) + + inf.run() + inf.plot_discretized() + + self.assertEqual(inf.get_shared_param_names(), []) + + def test_perform_lrt_covariates_two_samples(self): + """""" + Test that the perform_lrt_covariates method works. + """""" + # create inference object + inf = JointInference( + sfs_neut=Spectra(dict( + pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] + )), + sfs_sel=Spectra(dict( + pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] + )), + fixed_params=dict(all=dict(eps=0, p_b=0, S_b=1, h=0.5)), + do_bootstrap=True, + n_bootstraps=2, + n_runs=1, + covariates=[Covariate(param='S_d', values=dict(pendula=0.3, pubescens=0.6))] + ) + + assert inf.perform_lrt_covariates() < 1 + + def test_plot_inferred_parameters_boxplot(self): + """""" + Test that the plot_inferred_parameters_boxplot method works. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/shared_example_2/serialized.json"" + ) + + inference.bootstrap(6) + + inference.plot_inferred_parameters_boxplot() + + def test_plot_inferred_parameters(self): + """""" + Test that the plot_inferred_parameters_boxplot method works. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/shared_example_2/serialized.json"" + ) + + inference.bootstrap(2) + + inference.plot_inferred_parameters() + + def test_plot_all_without_bootstraps(self): + """""" + Test that the plot_all method works. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" + ) + + inference.plot_all() + + def test_plot_all_with_bootstraps(self): + """""" + Test that the plot_all method works. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" + ) + + inference.bootstrap(2) + + inference.plot_all() + + @staticmethod + def test_plot_covariate(): + """""" + Test the plot_covariate method. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" + ) + + inference.plot_covariate() + + pass + + @staticmethod + def test_plot_not_showing_types(): + """""" + Test the plot_covariate method. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" + ) + + inference.plot_covariate(show_types=False) + + pass + + @staticmethod + def test_plot_covariate_bootstrap(): + """""" + Test the plot_covariate method. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" + ) + + inference.bootstrap(2) + + inference.plot_covariate() + + pass + + @staticmethod + def test_plot_discretized_without_showing_marginals(): + """""" + Test the plot_discretized method + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/covariates_Sd_example_1/serialized.json"" + ) + + inference.plot_discretized(show_marginals=False) + + pass + + def test_evaluate_likelihood_same_as_mle_results(self): + """""" + Check that evaluating the loss function at the MLE results + yields the same likelihood as the one reported. + """""" + # rerun inference to make sure we don't have platform-specific differences + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/shared_example_1/serialized.json"" + ) + + # make sure joint likelihood is almost the same + self.assertAlmostEqual(inference.evaluate_likelihood(inference.params_mle), inference.likelihood) + + for t in inference.types: + # make sure marginal likelihoods are the same + self.assertAlmostEqual(inference.marginal_inferences[t].evaluate_likelihood( + dict(all=inference.marginal_inferences[t].params_mle)), inference.marginal_inferences[t].likelihood) + + # make sure joint likelihoods are not the same as when evaluated individually + assert inference.joint_inferences[t].evaluate_likelihood( + dict(all=inference.joint_inferences[t].params_mle)) != inference.joint_inferences[t].likelihood + + # make sure all joint likelihoods coincide with likelihood of joint inference + assert inference.joint_inferences[t].likelihood == inference.likelihood + + def test_fixed_parameters(self): + """""" + Test whether fixed parameters are correctly set. + """""" + config = Config.from_file( + ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" + ) + + # define fixed parameters + config.data['fixed_params'] = dict( + all=dict(eps=0.123, h=0.5), + example_1=dict(b=1.234), + example_2=dict(b=1.132), + pendula=dict(S_b=10.1) + ) + + # define fixed parameters + config.data['shared_params'] = [ + SharedParams(types='all', params=['S_d', 'p_b']) + ] + + inf = JointInference.from_config(config) + + inf.run() + + params_mle = inf.params_mle + + fixed = { + 'all': {'eps': 0.123, 'h': 0.5}, + 'example_1': {'eps': 0.123, 'h': 0.5, 'b': 1.234}, + 'example_2': {'eps': 0.123, 'h': 0.5, 'b': 1.132}, + 'example_3': {'eps': 0.123, 'h': 0.5}, + 'pendula': {'eps': 0.123, 'h': 0.5, 'S_b': 10.1}, + 'pubescens': {'eps': 0.123, 'h': 0.5}, + } + + assert inf.marginal_inferences['all'].optimization.fixed_params == flatten_dict(dict(all=fixed['all'])) + + # check that eps is fixed for all types + for t in inf.types: + assert inf.marginal_inferences[t].optimization.fixed_params == flatten_dict(dict(all=fixed[t])) + assert inf.joint_inferences[t].optimization.fixed_params == flatten_dict(dict(all=fixed[t])) + assert params_mle[t]['eps'] == config.data['fixed_params']['all']['eps'] + + # check that b is fixed for example_1 and example_2, but not for the others + assert params_mle['example_1']['b'] == config.data['fixed_params']['example_1']['b'] + assert params_mle['example_2']['b'] == config.data['fixed_params']['example_2']['b'] + assert params_mle['example_3']['b'] != config.data['x0']['all']['b'] + assert params_mle['example_3']['b'] != config.data['fixed_params']['example_1']['b'] + assert params_mle['example_3']['b'] != config.data['fixed_params']['example_2']['b'] + assert params_mle['pendula']['b'] != config.data['x0']['all']['b'] + assert params_mle['pubescens']['b'] != config.data['x0']['all']['b'] + + # check that S_b is fixed for pendula, but not for the others + self.assertAlmostEqual(params_mle['pendula']['S_b'], config.data['fixed_params']['pendula']['S_b']) + assert params_mle['pubescens']['S_b'] != config.data['x0']['all']['S_b'] + + def test_shared_same_parameter_twice_among_different_types(self): + """""" + Test sharing a parameter twice among different types. + """""" + config = Config.from_file( + ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" + ) + + config.update( + fixed_params={'all': dict(S_b=1, eps=0, p_b=0, h=0.5)}, + shared_params=[ + SharedParams(types=['example_1', 'example_2'], params=['b']), + SharedParams(types=['pendula', 'pubescens'], params=['b']) + ], + n_bootstraps=2, + do_bootstraps=True, + n_runs=1 + ) + + inf = JointInference.from_config(config) + + inf.run() + + # check that b is shared between example_1 and example_2 + assert inf.params_mle['example_1']['b'] == inf.params_mle['example_2']['b'] + + # check that b is shared between pendula and pubescens + assert inf.params_mle['pendula']['b'] == inf.params_mle['pubescens']['b'] + + # check that b is not shared between example_1 and pendula + assert inf.params_mle['example_1']['b'] != inf.params_mle['pendula']['b'] + + def test_fixed_parameters_cannot_be_shared(self): + """""" + Test that trying to shared fixed parameters raises an error. + """""" + config = Config.from_file( + ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" + ) + + # define fixed parameters + config.data['fixed_params'] = dict( + example_1=dict(b=1.234), + ) + + # define fixed parameters + config.data['shared_params'] = [ + SharedParams(types=['example_1'], params=['S_d', 'p_b', 'b']) + ] + + with pytest.raises(ValueError): + JointInference.from_config(config) + + @pytest.mark.slow + def test_compare_nested_models(self): + """""" + Test nested model comparison. + """""" + inf = JointInference.from_config_file( + ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" + ) + + P, inferences = inf.compare_nested_models() + + assert inferences['full.anc'].get_n_optimized() == 18 + assert inferences['full.anc'].marginal_inferences['all'].get_n_optimized() == 5 + + assert inferences['full.no_anc'].get_n_optimized() == 13 + assert inferences['full.no_anc'].marginal_inferences['all'].get_n_optimized() == 4 + + assert inferences['dele.anc'].get_n_optimized() == 8 + assert inferences['dele.anc'].marginal_inferences['all'].get_n_optimized() == 3 + + assert inferences['dele.no_anc'].get_n_optimized() == 3 + assert inferences['dele.no_anc'].marginal_inferences['all'].get_n_optimized() == 2 + + def test_get_n_optimized(self): + """""" + Test get number of parameters to be optimized. + """""" + inf = JointInference.from_config_file( + ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" + ) + + assert inf.get_n_optimized() == 11 + + inf = JointInference.from_config_file( + ""resources/configs/shared/covariates_Sd_example_1/config.yaml"" + ) + + assert inf.get_n_optimized() == 18 + + inf = JointInference.from_config_file( + ""resources/configs/shared/covariates_dummy_example_1/config.yaml"" + ) + + assert inf.get_n_optimized() == 19 + + def test_non_existing_shared_param_raises_error(self): + """""" + Test that trying to share a non-existing parameter raises an error. + """""" + config = Config.from_file( + ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" + ) + + # define shared parameters + config.data['shared_params'] = [ + SharedParams(types=['example_1'], params=['b', 'foo', 'bar']) + ] + + with pytest.raises(ValueError): + JointInference.from_config(config) + + def test_non_existing_covariate_raises_error(self): + """""" + Test that trying to share a non-existing parameter raises an error. + """""" + config = Config.from_file( + ""testing/cache/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml"" + ) + + types = ['pendula', 'pubescens', 'example_1', 'example_2', 'example_3'] + + # define shared parameters + config.data['covariates'] = [ + Covariate(values={t: 1 for t in types}, param='foo') + ] + + with pytest.raises(ValueError): + JointInference.from_config(config) + + def test_covariate_random_covariates(self): + """""" + Check that random covariates are not significant. + """""" + # parse SFS + spectra = Spectra.from_file(""resources/SFS/betula/pendula/degeneracy_ref_base_tutorial.csv"") + + # create inference object + inf = JointInference( + sfs_neut=spectra[['neutral.*']].merge_groups(1), + sfs_sel=spectra[['selected.*']].merge_groups(1), + covariates=[Covariate(param='S_d', values=dict(A=1, C=2, T=3, G=4))], + fixed_params={'all': dict(S_b=1, eps=0, h=0.5)}, + parallelize=True, + do_bootstrap=True, + n_bootstraps=2 + ) + + # run inference + inf.run() + + inf_no_cov = inf.run_joint_without_covariates() + + p = inf.perform_lrt_covariates() + + inf.plot_inferred_parameters() + + # the test should be non-significant as we chose random covariates + assert p > 0.05 + + @pytest.mark.slow + def test_covariates_strong_correlation(self): + """""" + Check that strong correlation between covariates is detected as significant. + """""" + # parse SFS + spectra = Spectra.from_file(""resources/SFS/betula/pendula/degeneracy_ref_base_tutorial.csv"") + + # create inference object + inf = JointInference( + sfs_neut=spectra[['neutral.*']].merge_groups(1), + sfs_sel=spectra[['selected.*']].merge_groups(1), + covariates=[Covariate(param='S_d', values=dict(A=-100000, C=-2045, T=-60504, G=-5024))], + fixed_params={'all': dict(S_b=1, eps=0, p_b=0, h=0.5)}, + parallelize=True, + do_bootstrap=True, + n_bootstraps=100, + n_runs=20 + ) + + # run inference + inf.run() + + inf_no_cov = inf.run_joint_without_covariates() + + p = inf.perform_lrt_covariates() + + inf.plot_inferred_parameters() + + # we expect 'c0' to be close to 1 + # self.assertAlmostEqual(inf.params_mle['T']['c0'], 1, places=2) + + # the test should be more or less significant as we chose good covariates + assert p < 0.15 + + def test_covariates_plot_inferred_parameters(self): + """""" + Check that covariates are plotted correctly. + """""" + # parse SFS + spectra = Spectra.from_file(""resources/SFS/betula/pendula/degeneracy_ref_base_tutorial.csv"") + + # create inference object + inf = JointInference( + sfs_neut=spectra[['neutral.*']].merge_groups(1), + sfs_sel=spectra[['selected.*']].merge_groups(1), + covariates=[Covariate(param='S_d', values=dict(A=-100000, C=-2045, T=-60504, G=-5024))], + fixed_params={'all': dict(S_b=1, eps=0, p_b=0, h=0.5)}, + parallelize=True, + do_bootstrap=True, + n_runs=10, + n_bootstraps=2 + ) + + inf.plot_inferred_parameters() + + def test_get_discretized_errors_with_bootstraps(self): + """""" + Get the discretized DFE errors. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/shared_example_2/serialized.json"" + ) + + inference.bootstrap(2) + + res = inference.get_discretized() + + def test_get_discretized_errors_no_bootstraps(self): + """""" + Get the discretized DFE errors. + """""" + inference = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/shared_example_1/serialized.json"" + ) + + values, errors = inference.get_discretized() + + # check that all errors are None + for err in errors.values(): + assert err is None + + def test_joint_inference_with_folded_spectra(self): + """""" + Test that joint inference works with folded spectra. + """""" + # neutral SFS for two types + sfs_neut = Spectra(dict( + pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] + )).fold() + + # selected SFS for two types + sfs_sel = Spectra(dict( + pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] + )).fold() + + # create inference object + inf = JointInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + shared_params=[SharedParams(types=[""pendula"", ""pubescens""], params=[""eps"", ""S_d""])], + fixed_params={'all': dict(h=0.5)}, + do_bootstrap=True, + n_bootstraps=2 + ) + + # run inference + inf.run() + + # assert that all inferences are folded + assert inf.folded + assert np.array([v.folded for v in inf.get_inferences().values()]).all() + + inf.plot_discretized() + inf.plot_sfs_comparison() + + def test_joint_inference_types_with_dots_throws_error(self): + """""" + Test that joint inference with types containing dots throws an error. + """""" + # neutral SFS for two types + sfs_neut = Spectra({ + 'pendula.foo': [177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + 'pubescens.bar.foo': [172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] + }) + + # selected SFS for two types + sfs_sel = Spectra({ + 'pendula.foo': [797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + 'pubescens.bar.foo': [791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] + }) + + # create inference object + with pytest.raises(ValueError): + JointInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + fixed_params={'all': dict(eps=0, h=0.5)}, + shared_params=[SharedParams(types=[""pendula.foo"", ""pubescens.bar.foo""], params=[""S_d"", ""S_b"", ""p_b""])], + do_bootstrap=True + ) + + def test_spectra_with_disparate_types_throws_error(self): + """""" + Test that joint inference with types containing dots throws an error. + """""" + # neutral SFS for two types + sfs_neut = Spectra({ + 'pendula': [177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + 'pubescens': [172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] + }) + + # selected SFS for two types + sfs_sel = Spectra({ + 'pendula': [797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + 'pubescens.bar.foo': [791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] + }) + + # create inference object + with pytest.raises(ValueError): + JointInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + fixed_params={'all': dict(eps=0, h=0.5)}, + shared_params=[SharedParams(types=[""pendula"", ""pubescens.bar.foo""], params=[""S_d"", ""S_b"", ""p_b""])], + do_bootstrap=True + ) + + @staticmethod + @pytest.mark.slow + def test_manuscript_example(): + """""" + Test the example in the manuscript. + + Note the warning on a large residual for the joint inference is not + unusual as the fit to each component SFS naturally is worse when sharing parameters. + """""" + config = fd.Config.from_file(""resources/configs/arabidopsis/covariates_example.yaml"") + + inf = fd.JointInference.from_config(config) + + inf.run() + + # get p-value for covariate significance + p = inf.perform_lrt_covariates() + + _, axs = plt.subplots(1, 2, figsize=(10.5, 3.5)) + p_str = f""p = {p:.1e}"" if p >= 1e-100 else ""p < 1e-100"" + + inf.plot_covariate(ax=axs[0], xlabel='RSA', show=False) + inf.plot_discretized( + title=f""DFE comparison, "" + p_str, ax=axs[1], + show_marginals=False, show=True + ) + + pass + + @pytest.mark.skip(""Only works with variable h"") + def test_alternative_optimizer(self): + """""" + Test for alternative optimizer. + """""" + config = fd.Config.from_file( + ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" + ).update( + do_bootstrap=True, + n_bootstraps=1, + method_mle='Powell' + ) + + inf = fd.JointInference.from_config(config) + inf.run() + + self.assertTrue(hasattr(inf.result, 'direc')) + self.assertTrue(hasattr(inf.bootstrap_results[0], 'direc')) + + self.assertTrue(hasattr(inf.marginal_inferences['all'].result, 'direc')) + self.assertTrue(hasattr(inf.marginal_inferences['example_1'].bootstrap_results[0], 'direc')) + + def test_raise_error_n_above_400(self): + """""" + Test whether an error is raised when sample size is above 400. + """""" + with self.assertRaises(ValueError) as context: + fd.JointInference( + sfs_neut=fd.Spectrum.standard_kingman(401, n_monomorphic=10000).to_spectra(), + sfs_sel=fd.Spectrum.standard_kingman(401, n_monomorphic=10000).to_spectra() + ) + + print(context.exception) + + def test_bootstrap_n_retries(self): + """""" + Test whether bootstrapping with retries works as expected. + """""" + config = fd.Config.from_file( + ""resources/configs/shared/covariates_Sd_fixed_params/config.yaml"" + ).update( + n_bootstrap_retries=3, + parallelize=True, + n_bootstraps=3, + do_bootstrap=True + ) + inf = fd.JointInference.from_config(config) + inf.run() + + for inf in list(inf.marginal_inferences.values()) + [inf]: + self.assertEqual(3, len(inf.bootstraps.likelihoods_runs.iloc[0])) + self.assertEqual(3, len(inf.bootstraps.x0_runs.iloc[0])) + self.assertGreater(inf.bootstraps.likelihoods_std.mean(), 0) + + def test_get_alpha(self): + """""" + Test get_alpha method. + """""" + inf = JointInference.from_file( + ""testing/cache/fastdfe/templates/shared/shared_example_1/serialized.json"" + ) + + alpha = inf.get_alpha() + + # assert keys are present + for t in inf.types: + assert t in alpha + + def test_seeded_inference_is_deterministic_non_parallelized(self): + """""" + Check that inference is deterministic when seeded and not parallelized. + """""" + config = fd.Config.from_file(self.config_file) + + config.update( + seed=0, + do_bootstrap=True, + parallelize=False, + n_bootstraps=2 + ) + + inf = fd.JointInference.from_config(config) + inf.run() + + inf2 = fd.JointInference.from_config(config) + inf2.run() + + self.assertEqual(inf.params_mle, inf2.params_mle) + assert_frame_equal(inf.bootstraps, inf2.bootstraps) + + def test_seeded_inference_is_deterministic_parallelized(self): + """""" + Check that seeded inference is deterministic when parallelized. + """""" + config = fd.Config.from_file(self.config_file) + + config.update( + seed=0, + do_bootstrap=True, + parallelize=True, + n_bootstraps=2 + ) + + inference = fd.JointInference.from_config(config) + inference.run() + + inference2 = fd.JointInference.from_config(config) + inference2.run() + + self.assertEqual(inference.params_mle, inference2.params_mle) + assert_frame_equal(inference.bootstraps, inference2.bootstraps) + + def test_joint_different_fixed_h(self): + """""" + Test joint inference with different fixed h values. + """""" + inf = JointInference( + sfs_neut=Spectra(dict( + pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + pendula2=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + )), + sfs_sel=Spectra(dict( + pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + pendula2=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + )), + fixed_params=dict(all=dict(eps=0, S_b=1, p_b=0), pendula=dict(h=0.2), pendula2=dict(h=0.8)), + shared_params=[SharedParams(types='all', params=['b'])], + intervals_del=(-1.0e+8, -1.0e-5, 100), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_h=(0, 1, 11), + do_bootstrap=False, + parallelize=True, + n_runs=10 + ) + + inf.run() + + # make sure that h values are correctly held fixed + self.assertEqual(0.2, inf.params_mle['pendula']['h']) + self.assertEqual(0.8, inf.params_mle['pendula2']['h']) + + self.assertEqual(0.2, inf.joint_inferences['pendula'].params_mle['h']) + self.assertEqual(0.8, inf.joint_inferences['pendula2'].params_mle['h']) + + self.assertEqual(0.2, inf.marginal_inferences['pendula'].params_mle['h']) + self.assertEqual(0.8, inf.marginal_inferences['pendula2'].params_mle['h']) + + inf.plot_discretized() + + # make sure that the DFE for h=0.2 is shifted towards more deleterious mutations for both marginals and joints + discretized = inf.get_discretized()[0] + self.assertGreater(discretized[""marginal.pendula""][0], discretized[""marginal.pendula2""][0]) + self.assertGreater(discretized[""joint.pendula""][0], discretized[""joint.pendula2""][0]) + + def test_joint_optimized_different_h(self): + """""" + Test joint inference with different optimized h values. + """""" + inf = JointInference( + sfs_neut=Spectra(dict( + pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] + )), + sfs_sel=Spectra(dict( + pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] + )), + fixed_params=dict(all=dict(eps=0, S_b=1, p_b=0)), + shared_params=[SharedParams(types='all', params=['b', 'S_d'])], + intervals_del=(-1.0e+8, -1.0e-5, 100), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_h=(0, 1, 11), + do_bootstrap=False, + parallelize=True, + n_runs=10 + ) + + inf.run() + + self.assertNotEqual(inf.params_mle['pendula']['h'], inf.params_mle['pubescens']['h']) + self.assertNotEqual( + inf.joint_inferences['pendula'].params_mle['h'], + inf.joint_inferences['pubescens'].params_mle['h'] + ) + +","Python" +"Allele","Sendrowski/fastDFE","testing/test_parser.py",".py","43725","1335","import logging + +import dadi +import fastdfe as fd +import numpy as np +import pandas as pd +import pytest +from fastdfe.io_handlers import get_called_bases +from unittest.mock import Mock +from testing import TestCase + + +class ParserTestCase(TestCase): + """""" + Test parser. + """""" + + @staticmethod + def test_parse_sfs_compare_subsample_modes(): + """""" + Compare the sfs for probabilistic vs random subsampling. + """""" + for n in [19, 20]: + p1 = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + n=n, + stratifications=[], + subsample_mode='probabilistic', + max_sites=10000 + ) + + sfs = p1.parse().all + + p2 = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + n=n, + stratifications=[], + subsample_mode='random', + max_sites=10000, + seed=2 + ) + + sfs2 = p2.parse().all + + fd.Spectra.from_spectra(dict( + probabilistic=sfs, + random=sfs2 + )).plot() + + diff_rel = np.abs(sfs.data - sfs2.data) / sfs2.data + + assert sfs.data.min() > 0 + assert sfs2.data.min() > 0 + assert diff_rel.mean() < 0.2 + + @staticmethod + def test_parse_sfs_compare_probabilistic_with_dadi(): + """""" + Compare the parsed sfs with results from dadi. + """""" + p1 = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + n=20, + stratifications=[], + subsample_mode='probabilistic' + ) + + sfs = p1.parse().all + + data_dict = dadi.Misc.make_data_dict_vcf( + 'resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + 'resources/genome/betula/pops_dadi.txt' + ) + + sfs2 = dadi.Spectrum.from_data_dict(data_dict, ['pop0'], [20], polarized=True) + + assert np.abs(sfs.data.sum() - sfs2.data.sum()) < 1e-08 + + diff_rel = np.abs(sfs.data - sfs2.data) / sfs2.data + + # used to be 1e-12 but dadi was updated + assert diff_rel.max() < 1e-3 + + @staticmethod + @pytest.mark.slow + def test_compare_sfs_with_dadi_full_set(): + """""" + Compare the sfs from dadi with the one from the data. + """""" + p = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.vcf.gz', + n=20, + stratifications=[], + seed=2 + ) + + sfs = p.parse().all + + data_dict = dadi.Misc.make_data_dict_vcf( + 'resources/genome/betula/biallelic.polarized.vcf.gz', + 'resources/genome/betula/pops_dadi.txt' + ) + + sfs_dadi = dadi.Spectrum.from_data_dict(data_dict, ['pop0'], [20], polarized=True) + + diff_rel = np.abs(sfs.to_numpy() - sfs_dadi.data) / sfs_dadi.data + + s = fd.Spectra(dict( + native=sfs.to_numpy(), + dadi=sfs_dadi.data + )) + + s.plot() + + # rather similar given number of sites and subsamples + assert diff_rel[sfs_dadi.data != 0].max() < 0.1 + + @staticmethod + def test_degeneracy_stratification(): + """""" + Test the degeneracy stratification. + """""" + p = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + n=20, + stratifications=[fd.DegeneracyStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + # assert total number of sites + assert sfs.all.data.sum() == 10000 - p.n_skipped + + # assert that all types are a subset of the stratification + assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) + + @staticmethod + def test_contig_stratification_dataset(): + """""" + Test the degeneracy stratification. + """""" + p = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + n=20, + stratifications=[fd.ContigStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + # assert total number of sites + assert np.round(sfs.all.data.sum()) == 10000 - p.n_skipped + + # assert that all types are a subset of the stratification + assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) + + def test_contig_stratification(self): + """""" + Test the contig stratification. + """""" + s = fd.ContigStratification(['contig1', 'contig2']) + + self.assertEqual(s.get_types(), ['contig1', 'contig2']) + self.assertNotEqual(s.get_types(), ['contig1', 'contig3']) + self.assertEqual(s.get_type(Mock(CHROM='contig1')), 'contig1') + self.assertNotEqual(s.get_type(Mock(CHROM='contig1')), 'contig2') + + def test_random_stratification(self): + """""" + Test the RandomStratification class. + """""" + # Test with 3 bins and fixed seed + s = fd.RandomStratification(n_bins=3, seed=42) + + # Ensure all bin types are generated correctly + self.assertEqual(s.get_types(), ['bin0', 'bin1', 'bin2']) + + # Ensure random assignment produces valid bins + mock_variant = Mock() + bin = s.get_type(mock_variant) + self.assertIn(bin, ['bin0', 'bin1', 'bin2']) + + # Test reproducibility: two instances with the same seed should match + s2 = fd.RandomStratification(n_bins=3, seed=42) + self.assertEqual(bin, s2.get_type(mock_variant)) + + # Test with only 1 bin (should always return ""bin1"") + s_single_bin = fd.RandomStratification(n_bins=1, seed=42) + self.assertEqual(s_single_bin.get_type(mock_variant), 'bin0') + + # Test invalid num_bins (should raise ValueError) + with self.assertRaises(ValueError): + fd.RandomStratification(n_bins=0) + + @staticmethod + def test_chunked_stratification(): + """""" + Test the degeneracy stratification. + """""" + n_chunks = 7 + s = fd.ChunkedStratification(n_chunks=n_chunks) + + p = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + n=20, + stratifications=[s] + ) + + sfs = p.parse() + + sfs.plot() + + # assert total number of sites + assert np.round(sfs.all.data.sum()) == 10000 - p.n_skipped + + assert s.n_valid == 10000 - p.n_skipped + + assert len(sfs.types) == n_chunks + + # assert that all types are a subset of the stratification + assert set(sfs.types).issubset(set(s.get_types())) + + @pytest.mark.slow + def test_vep_stratification(self): + """""" + Test the VEP for human chr21. + """""" + p = fd.Parser( + vcf='snakemake/results/vcf/sapiens/chr21.vep.vcf.gz', + n=20, + stratifications=[fd.VEPStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + # assert that all types are a subset of the stratification + assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) + + def test_vep_stratification_subset(self): + """""" + Test the synonymy stratification for a small subset of Betula spp. + """""" + p = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + n=20, + max_sites=1000, + stratifications=[fd.VEPStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + # assert that we have all types + self.assertEqual(set(sfs.types), set(p.stratifications[0].get_types())) + + @pytest.mark.slow + def test_snpeff_stratification(self): + """""" + Test the synonymy stratification against SNPEFF for human chr21. + """""" + p = fd.Parser( + vcf='snakemake/results/vcf/sapiens/chr21.snpeff.vcf.gz', + n=20, + stratifications=[fd.SnpEffStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + # assert that all types are a subset of the stratification + assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) + + @staticmethod + def test_base_transition_stratification(): + """""" + Test the base transition stratification. + """""" + p = fd.Parser( + vcf='resources/genome/betula/all.polarized.subset.10000.vcf.gz', + n=20, + stratifications=[fd.BaseTransitionStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + # assert total number of sites + assert sfs.all.data.sum() == 10000 - p.n_skipped + + # assert that all types are a subset of the stratification + assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) + + @staticmethod + def test_transition_transversion_stratification(): + """""" + Test the transition transversion stratification. + """""" + p = fd.Parser( + vcf='resources/genome/betula/all.polarized.subset.10000.vcf.gz', + n=20, + stratifications=[fd.TransitionTransversionStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + # assert total number of sites + assert np.round(sfs.all.data.sum()) == 10000 - p.n_skipped + + # assert that all types are a subset of the stratification + assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) + + @staticmethod + def test_base_context_stratification(): + """""" + Test the base context stratification. + """""" + p = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + n=20, + stratifications=[fd.BaseContextStratification(fasta='resources/genome/betula/genome.subset.20.fasta')] + ) + + sfs = p.parse() + + sfs.plot() + + # assert total number of sites + assert sfs.all.data.sum() == 10000 - p.n_skipped + + # assert that all types are a subset of the stratification + assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) + + @staticmethod + def test_reference_base_stratification(): + """""" + Test the reference base stratification. + """""" + p = fd.Parser( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + n=20, + stratifications=[fd.AncestralBaseStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + # assert total number of sites + assert np.round(sfs.all.data.sum()) == 10000 - p.n_skipped + + # assert that all types are a subset of the stratification + assert set(sfs.types).issubset(set(p.stratifications[0].get_types())) + + def test_parse_vcf_chr21_test(self): + """""" + Parse human chr21 test VCF file. + """""" + p = fd.Parser( + vcf=""resources/genome/sapiens/chr21_test.vcf.gz"", + gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", + fasta=""http://hgdownload.soe.ucsc.edu/goldenPath/hg38/chromosomes/chr21.fa.gz"", + n=20, + annotations=[ + fd.DegeneracyAnnotation(), + fd.MaximumParsimonyAncestralAnnotation() + ], + filtrations=[ + fd.CodingSequenceFiltration() + ], + stratifications=[fd.DegeneracyStratification()], + max_sites=100000 + ) + + sfs = p.parse() + + self.assertEqual(np.round(sfs.all.data.sum()), 6) + + def test_parse_betula_vcf_biallelic_infer_monomorphic_subset(self): + """""" + Parse a subset of the VCF file of Betula spp. + """""" + + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + target_site_counter=fd.TargetSiteCounter( + n_samples=1000000, + n_target_sites=100000 + ), + n=20, + max_sites=10000, + annotations=[ + fd.DegeneracyAnnotation(), + fd.MaximumParsimonyAncestralAnnotation() + ], + filtrations=[ + fd.CodingSequenceFiltration() + ], + stratifications=[fd.DegeneracyStratification()] + ) + + sfs = p.parse() + + self.assertEqual(sfs.n_sites.sum(), 100000) + + # assert fixed number of target sites + # self.assertAlmostEqual(sfs['neutral'].n_sites, 18897.233850, places=5) + # self.assertAlmostEqual(sfs['selected'].n_sites, 81102.766149, places=5) + + def test_filter_out_all_raises_warning(self): + """""" + Test that filtering out all sites logs a warning. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + n=20, + filtrations=[fd.AllFiltration()] + ) + + with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): + p.parse() + + @staticmethod + def test_parser_no_stratifications(): + """""" + Test that filtering out all sites logs a warning. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + n=20, + stratifications=[] + ) + + sfs = p.parse() + + assert 'all' in sfs.types + + @staticmethod + def test_parse_betula_vcf(): + """""" + Parse the VCF file of Betula spp. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/all.polarized.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + n=20, + annotations=[ + fd.DegeneracyAnnotation(), + fd.MaximumParsimonyAncestralAnnotation() + ], + filtrations=[ + fd.CodingSequenceFiltration() + ], + stratifications=[fd.DegeneracyStratification()] + ) + + sfs = p.parse() + + pass + + def test_parse_betula_vcf_degeneracy_vs_synonymy(self): + """""" + Parse the VCF file of Betula spp. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/all.polarized.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + n=20, + annotations=[ + fd.DegeneracyAnnotation(), + fd.SynonymyAnnotation() + ], + filtrations=[ + fd.CodingSequenceFiltration() + ], + stratifications=[ + fd.DegeneracyStratification(), + fd.SynonymyStratification() + ] + ) + + sfs = p.parse() + + # make sure we only have equivalent types + self.assertEqual(set(sfs.data.columns), {'neutral.neutral', 'selected.selected'}) + + @pytest.mark.slow + def test_parse_betula_complete_vcf_biallelic_synonymy(self): + """""" + Parse the VCF file of Betula spp. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.vcf.gz"", + fasta=""resources/genome/betula/genome.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + n=10, + annotations=[ + fd.SynonymyAnnotation() + ], + filtrations=[ + fd.CodingSequenceFiltration() + ], + stratifications=[fd.SynonymyStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + @pytest.mark.slow + def test_parse_betula_complete_from_remote(self): + """""" + Parse the VCF file of Betula spp. using remote files. + """""" + parsers = [] + spectra = [] + + for outgroups in [[""ERR2103730""], [""ERR2103730"", ""ERR2103731""]]: + p = fd.Parser( + vcf=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" + ""genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true"", + fasta=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" + ""genome/betula/genome.subset.1000.fasta.gz?raw=true"", + gff=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" + ""genome/betula/genome.gff.gz?raw=true"", + n=10, + subsample_mode='random', + annotations=[ + fd.DegeneracyAnnotation(), + fd.MaximumLikelihoodAncestralAnnotation( + n_ingroups=10, + outgroups=outgroups, + subsample_mode='random' + ) + ], + filtrations=[ + fd.CodingSequenceFiltration(), + fd.ExistingOutgroupFiltration(outgroups=outgroups) + ], + stratifications=[fd.DegeneracyStratification()], + max_sites=10000 + ) + + sfs = p.parse() + + sfs.plot() + + parsers.append(p) + spectra.append(sfs) + + # noinspection all + # using two outgroups produces bad results as the two outgroups are too close to each other + site_info = dict( + one_outgroup=pd.DataFrame(parsers[0].annotations[1].get_inferred_site_info()), + two_outgroups=pd.DataFrame(parsers[1].annotations[1].get_inferred_site_info()) + ) + + pass + + @pytest.mark.slow + def test_parse_betula_compare_monomorphic_vcf_with_inferred_monomorphic_betula(self): + """""" + Parse the VCF file of Betula spp. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/all.polarized.vcf.gz"", + fasta=""resources/genome/betula/genome.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + target_site_counter=None, + # max_sites=100000, + n=20, + annotations=[fd.DegeneracyAnnotation()], + filtrations=[fd.CodingSequenceFiltration()], + stratifications=[fd.DegeneracyStratification()] + ) + + sfs = p.parse() + + p2 = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.vcf.gz"", + fasta=""resources/genome/betula/genome.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + target_site_counter=fd.TargetSiteCounter( + n_samples=100000, + n_target_sites=sfs.n_sites.sum() + ), + # max_sites=100000, + n=20, + annotations=[fd.DegeneracyAnnotation()], + filtrations=[fd.CodingSequenceFiltration()], + stratifications=[fd.DegeneracyStratification()] + ) + + sfs2 = p2.parse() + + infs = [] + for spectra in [sfs, sfs2]: + inf = fd.BaseInference( + sfs_neut=spectra['neutral'], + sfs_sel=spectra['selected'], + do_bootstrap=True, + model=fd.DiscreteFractionalParametrization(), + ) + + inf.run() + + infs.append(inf) + + # the ratio of neutral to selected sites should be the same + # but is about 0.225 for monomorphic VCF and 0.29 for inferred monomorphic sites + fd.Inference.plot_discretized(infs, labels=['monomorphic', 'inferred']) + + pass + + @pytest.mark.slow + def test_parse_betula_compare_monomorphic_vcf_with_inferred_monomorphic_betula_same_vcf(self): + """""" + Parse the VCF file of Betula spp. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/all.polarized.vcf.gz"", + fasta=""resources/genome/betula/genome.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + target_site_counter=None, + max_sites=100000, + n=20, + annotations=[fd.DegeneracyAnnotation()], + filtrations=[fd.CodingSequenceFiltration()], + stratifications=[fd.DegeneracyStratification()] + ) + + sfs = p.parse() + + p2 = fd.Parser( + vcf=""resources/genome/betula/all.polarized.vcf.gz"", + fasta=""resources/genome/betula/genome.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + target_site_counter=fd.TargetSiteCounter( + n_samples=1000000, + n_target_sites=sfs.n_sites.sum() + ), + max_sites=100000, + n=20, + annotations=[fd.DegeneracyAnnotation()], + filtrations=[fd.SNPFiltration(), fd.CodingSequenceFiltration()], + stratifications=[fd.DegeneracyStratification()] + ) + + sfs2 = p2.parse() + + infs = [] + for spectra in [sfs, sfs2]: + inf = fd.BaseInference( + sfs_neut=spectra['neutral'], + sfs_sel=spectra['selected'], + do_bootstrap=True, + model=fd.DiscreteFractionalParametrization(), + parallelize=True + ) + + inf.run() + + infs.append(inf) + + fd.Inference.plot_discretized(infs, labels=['monomorphic', 'inferred']) + + # calculate ratio of neutral to selected sites + r1 = sfs['neutral'].data[0] / sfs['selected'].data[0] + r2 = sfs2['neutral'].data[0] / sfs2['selected'].data[0] + + # make sure that the ratio is similar + self.assertTrue(abs(r1 - r2) < 0.01) + + pass + + @pytest.mark.slow + def test_parse_betula_complete_vcf_including_monomorphic(self): + """""" + Parse the VCF file of Betula spp. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/all.polarized.vcf.gz"", + fasta=""resources/genome/betula/genome.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + n=20, + annotations=[ + fd.DegeneracyAnnotation() + ], + filtrations=[ + fd.CodingSequenceFiltration() + ], + stratifications=[fd.DegeneracyStratification()] + ) + + sfs = p.parse() + + sfs.plot() + + pass + + @staticmethod + @pytest.mark.slow + def test_parse_human_chr21_from_online_resources(): + """""" + Parse the VCF for human chr21 file using remote files. + """""" + # parse selected and neutral SFS from human chromosome 1 + p = fd.Parser( + vcf=""https://ngs.sanger.ac.uk/production/hgdp/hgdp_wgs.20190516/"" + ""hgdp_wgs.20190516.full.chr21.vcf.gz"", + fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" + ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", + gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", + aliases=dict(chr21=['21']), + n=8, + target_site_counter=fd.TargetSiteCounter( + n_samples=1000000, + n_target_sites=fd.Annotation.count_target_sites( + ""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"" + )['21'] + ), + annotations=[ + fd.DegeneracyAnnotation() + ], + filtrations=[ + fd.SNPFiltration(), + fd.CodingSequenceFiltration() + ], + stratifications=[fd.DegeneracyStratification()], + info_ancestral='AA_ensembl', + skip_non_polarized=True + ) + + sfs = p.parse() + + sfs.plot() + + pass + + def test_target_site_counter_no_fasta(self): + """""" + Make sure an error is raised when not FASTA file is specified + """""" + p = fd.Parser( + n=10, + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + target_site_counter=fd.TargetSiteCounter( + n_target_sites=40000 + ), + max_sites=10 + ) + + with self.assertRaises(ValueError): + p.parse() + + pass + + def test_target_site_counter_betula(self): + """""" + Test whether the monomorphic site counter works on the Betula data. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + max_sites=10000, + n=10, + target_site_counter=fd.TargetSiteCounter( + n_target_sites=40000, + n_samples=10000 + ), + annotations=[ + fd.DegeneracyAnnotation() + ], + stratifications=[fd.DegeneracyStratification()] + ) + + # set log level to DEBUG + p.target_site_counter._logger.setLevel(logging.DEBUG) + + sfs = p.parse() + + # make sure that the sum of the target sites is correct + self.assertEqual(sfs.n_sites.sum(), p.target_site_counter.n_target_sites) + + # assert that 3 contigs were parsed + self.assertEqual(3, len(p._contig_bounds)) + + def test_target_site_counter_update_target_sites_target_sites_lower_than_polymorphic_raises_warning(self): + """""" + Test updating the target sites for different spectra. + """""" + c = fd.TargetSiteCounter( + n_target_sites=1000, + n_samples=10000 + ) + + # assign a polymorphic SFS to the target site counter + c._sfs_polymorphic = fd.Spectra(dict( + neutral=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + selected=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + )) + + with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe.TargetSiteCounter')) as warning: + c._update_target_sites(fd.Spectra(dict( + # an SFS, decreasing sequence + neutral=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + selected=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794] + ))) + + print(warning[1][0]) + + def test_target_site_counter_update_target_sites_target_sites_no_monomorphic_raises_warning(self): + """""" + Test updating the target sites for different spectra. + """""" + c = fd.TargetSiteCounter( + n_target_sites=100000, + n_samples=10000 + ) + + # assign a polymorphic SFS to the target site counter + c._sfs_polymorphic = fd.Spectra(dict( + neutral=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + selected=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + )) + + with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe.TargetSiteCounter')) as warning: + c._update_target_sites(fd.Spectra(dict( + # an SFS, decreasing sequence + neutral=[0, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + selected=[0, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794] + ))) + + print(warning[1][0]) + + def test_target_site_counter_update_target_sites_sum_coincides_with_given_target_sites(self): + """""" + Test updating the target sites for different spectra. + """""" + c = fd.TargetSiteCounter( + n_target_sites=100000, + n_samples=10000 + ) + + # assign a polymorphic SFS to the target site counter + c._sfs_polymorphic = fd.Spectra(dict( + neutral=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + selected=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + )) + + sfs1 = fd.Spectra(dict( + neutral=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + selected=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794] + )) + + sfs2 = c._update_target_sites(sfs1) + + # make sure that the sum of the target sites is the same + self.assertEqual(sfs2.n_sites.sum(), 100000) + + # make sure ratio of neutral to selected is the same + self.assertEqual( + sfs1.data.loc[0, 'neutral'] / sfs1.data.loc[0, 'selected'], + sfs2.data.loc[0, 'neutral'] / sfs2.data.loc[0, 'selected'] + ) + + def test_target_site_counter_update_target_sites_more_entries_sum_coincides_with_given_target_sites(self): + """""" + Test updating the target sites for different spectra. + """""" + c = fd.TargetSiteCounter( + n_target_sites=100000, + n_samples=10000 + ) + + # assign a polymorphic SFS to the target site counter + c._sfs_polymorphic = fd.Spectra({ + 'type1.neutral': [0, 0, 0, 0, 0, 0], + 'type1.selected': [0, 0, 0, 0, 0, 0], + 'type2.neutral': [0, 0, 0, 0, 0, 0], + 'type2.selected': [0, 0, 0, 0, 0, 0] + }) + + sfs1 = fd.Spectra({ + 'type1.neutral': [177130, 997, 441, 228, 156, 117], + 'type1.selected': [797939, 1329, 499, 265, 162, 104], + 'type2.neutral': [144430, 114, 83, 105, 109, 652], + 'type2.selected': [797939, 117, 90, 94, 119, 794] + }) + + sfs2 = c._update_target_sites(sfs1) + + # make sure that the sum of the target sites is the same + self.assertEqual(sfs2.n_sites.sum(), 100000) + + @pytest.mark.slow + def test_betula_biallelic_dfe_for_different_n_target_sites(self): + """""" + Test the DFE estimation for different numbers of target sites. + """""" + n_target_sites = [1000, 10000, 100000, 1000000, 10000000] + + parsers = [] # parsers + spectra = fd.Spectra({}) # spectra + inferences = [] # inferences + + for i, n in enumerate(n_target_sites): + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + max_sites=10000, + n=10, + target_site_counter=fd.TargetSiteCounter( + n_target_sites=n, + n_samples=100000 + ), + annotations=[ + fd.DegeneracyAnnotation() + ], + stratifications=[fd.DegeneracyStratification()], + filtrations=[fd.SNPFiltration()] + ) + + sfs = p.parse() + + inf = fd.BaseInference( + sfs_neut=sfs['neutral'], + sfs_sel=sfs['selected'], + do_bootstrap=True, + model=fd.DiscreteFractionalParametrization() + ) + + inf.run() + + parsers.append(p) + inferences.append(inf) + + spectra += sfs.prefix(str(n)) + + spectra.plot() + + # very similar results for all n_target_sites + fd.Inference.plot_discretized(inferences, labels=list(map(str, n_target_sites))) + + self.assertTrue((np.array([inf.bootstraps.mean() for inf in inferences]).var(axis=0) < 1e-1).all()) + + pass + + @pytest.mark.slow + def test_betula_compare_dfe_across_different_samples_sizes_n(self): + """""" + Test the DFE estimation for different sample sizes. + """""" + sample_sizes = [5, 10, 15, 20, 25, 30] + + parsers = [] # parsers + spectra = fd.Spectra({}) # spectra + inferences = [] # inferences + + for i, n in enumerate(sample_sizes): + p = fd.Parser( + vcf=""resources/genome/betula/all.polarized.vcf.gz"", + fasta=""resources/genome/betula/genome.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + # max_sites=1000000, + n=n, + annotations=[ + fd.DegeneracyAnnotation() + ], + stratifications=[fd.DegeneracyStratification()] + ) + + sfs = p.parse() + + inf = fd.BaseInference( + sfs_neut=sfs['neutral'], + sfs_sel=sfs['selected'], + do_bootstrap=True, + model=fd.DiscreteFractionalParametrization() + ) + + inf.run() + + parsers.append(p) + inferences.append(inf) + + spectra += sfs.prefix(str(n)) + + spectra.plot(use_subplots=True) + + fd.Inference.plot_discretized(inferences, labels=[f""n={n}"" for n in sample_sizes]) + fd.Inference.plot_inferred_parameters(inferences, labels=[f""n={n}"" for n in sample_sizes], scale='lin') + + @pytest.mark.skip(reason=""takes too long"") + def test_human_chr1_compare_dfe_across_different_samples_sizes_n(self): + """""" + Test the DFE estimation for different sample sizes. + """""" + sample_sizes = [5, 10, 15, 20, 25, 30] + + parsers = [] # parsers + spectra = fd.Spectra({}) # spectra + inferences = [] # inferences + + for i, n in enumerate(sample_sizes): + p = fd.Parser( + vcf=""https://ngs.sanger.ac.uk/production/hgdp/hgdp_wgs.20190516/"" + ""hgdp_wgs.20190516.full.chr1.vcf.gz"", + fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" + ""dna/Homo_sapiens.GRCh38.dna.chromosome.1.fa.gz"", + gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.1.gff3.gz"", + aliases=dict(chr1=['1']), + n=n, + target_site_counter=fd.TargetSiteCounter( + n_samples=100000, + n_target_sites=fd.Annotation.count_target_sites( + file=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.1.gff3.gz"" + )['1'] + ), + annotations=[ + fd.DegeneracyAnnotation() + ], + filtrations=[ + fd.CodingSequenceFiltration(), + fd.SNPFiltration() + ], + stratifications=[fd.DegeneracyStratification()], + info_ancestral='AA_ensembl' + ) + + sfs = p.parse() + + inf = fd.BaseInference( + sfs_neut=sfs['neutral'], + sfs_sel=sfs['selected'], + do_bootstrap=True, + model=fd.DiscreteFractionalParametrization() + ) + + inf.run() + + parsers.append(p) + inferences.append(inf) + + spectra += sfs.prefix(str(n)) + + spectra.plot(use_subplots=True) + + fd.Inference.plot_discretized(inferences, labels=[f""n={n}"" for n in sample_sizes]) + fd.Inference.plot_inferred_parameters(inferences, labels=[f""n={n}"" for n in sample_sizes], scale='lin') + + pass + + def test_parser_betula_include_samples(self): + """""" + Test that the parser includes only the samples that are given in the include_samples parameter. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + n=20, + include_samples=['ASP01', 'ASP02', 'ASP03'] + ) + + p._setup() + + self.assertEqual(np.sum(p._samples_mask), 3) + + def test_parser_betula_include_all_samples(self): + """""" + Test that the parser includes all samples if the include_samples parameter is not given. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + n=20 + ) + + p._setup() + + self.assertEqual(np.sum(p._samples_mask), 377) + + def test_parser_betula_exclude_two_samples(self): + """""" + Test that the parser excludes the samples that are given in the exclude_samples parameter. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + n=20, + exclude_samples=['ASP01', 'ASP02'] + ) + + p._setup() + + self.assertEqual(np.sum(p._samples_mask), 375) + + def test_parser_betula_include_exclude(self): + """""" + Test that both include and exclude samples work together. + """""" + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + n=20, + include_samples=['ASP01', 'ASP02', 'ASP03'], + exclude_samples=['ASP02'] + ) + + p._setup() + + self.assertEqual(np.sum(p._samples_mask), 2) + + @staticmethod + def test_get_called_genotypes(): + """""" + Test the get_called_genotypes function. + """""" + result = get_called_bases([""A|T"", ""C/T"", "".|G""]) + + expected = np.array(['A', 'T', 'C', 'T', 'G']) + + np.testing.assert_array_equal(result, expected) + + @staticmethod + @pytest.mark.slow + def test_manuscript_example(): + """""" + Test the example from the manuscript. + """""" + basepath = (""https://github.com/Sendrowski/fastDFE/"" + ""blob/master/resources/genome/betula/"") + + # instantiate parser + p = fd.Parser( + n=8, # SFS sample size + vcf=(basepath + ""biallelic.with_outgroups."" + ""subset.50000.vcf.gz?raw=true""), + fasta=basepath + ""genome.subset.1000.fasta.gz?raw=true"", + gff=basepath + ""genome.gff.gz?raw=true"", + target_site_counter=fd.TargetSiteCounter( + n_target_sites=350000 # total number of target sites + ), + annotations=[ + fd.DegeneracyAnnotation(), # determine degeneracy + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""] # use one outgroup + ) + ], + stratifications=[fd.DegeneracyStratification()] + ) + + # obtain SFS + spectra: fd.Spectra = p.parse() + + spectra.plot() + + def test_count_target_sites_remove_overlaps(self): + """""" + Test the count_target_sites function with removing overlaps. + """""" + sites_overlaps = fd.Annotation.count_target_sites('resources/genome/betula/genome.gff.gz', remove_overlaps=True) + sites = fd.Annotation.count_target_sites('resources/genome/betula/genome.gff.gz', remove_overlaps=False) + + for config in sites.keys(): + self.assertLessEqual(sites_overlaps[config], sites[config]) + + def test_invalid_subsample_model_raises_value_error(self): + """""" + Test that an invalid subsample model raises a ValueError. + """""" + with self.assertRaises(ValueError): + fd.Parser( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + n=20, + subsample_mode='invalid' + ) + + def test_probabilistic_polarization_no_aa_prob_tags_same_result_random_subsampling(self): + """""" + Make sure that probabilistic polarization without AA probability tags yields the same result as without. + The used VCF files don't contain AA probability tags. + """""" + for n in [9, 10]: + p1 = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + polarize_probabilistically=True, + subsample_mode='random', + max_sites=1000, + n=n + ) + + sfs_prob = p1.parse() + + p2 = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + polarize_probabilistically=False, + subsample_mode='random', + max_sites=1000, + n=n + ) + + sfs_fixed = p2.parse() + + spectra = fd.Spectra(dict( + prob=sfs_prob.all, + fixed=sfs_fixed.all + )) + + spectra.plot() + + self.assertGreater(sfs_prob.all.data.sum(), 0) + + np.testing.assert_array_equal(sfs_prob.all.data, sfs_fixed.all.data) + + def test_probabilistic_polarization_no_aa_prob_tags_same_result_probabilistic_subsampling(self): + """""" + Make sure that probabilistic polarization without AA probability tags yields the same result as without. + The used VCF files don't contain AA probability tags. + """""" + for n in [9, 10]: + p1 = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + polarize_probabilistically=True, + subsample_mode='probabilistic', + max_sites=100, + n=n + ) + + sfs_prob = p1.parse() + + p2 = fd.Parser( + vcf=""resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz"", + polarize_probabilistically=False, + subsample_mode='probabilistic', + max_sites=100, + n=n + ) + + sfs_fixed = p2.parse() + + spectra = fd.Spectra(dict( + prob=sfs_prob.all, + fixed=sfs_fixed.all + )) + + spectra.plot() + + self.assertGreater(sfs_prob.all.data.sum(), 0) + + np.testing.assert_array_equal(sfs_prob.all.data, sfs_fixed.all.data) + + def test_compare_probabilistic_polarization_vs_fixed_random_subsampling(self): + """""" + Compare probabilistic polarization with fixed polarization. + """""" + for n in [19, 20]: + p1 = fd.Parser( + vcf=""resources/genome/sapiens/hgdp.anc.deg.vcf.gz"", + polarize_probabilistically=True, + subsample_mode='random', + max_sites=10000, + n=n + ) + + sfs_prob = p1.parse() + + p2 = fd.Parser( + vcf=""resources/genome/sapiens/hgdp.anc.deg.vcf.gz"", + polarize_probabilistically=False, + subsample_mode='random', + max_sites=10000, + n=n + ) + + sfs_fixed = p2.parse() + + spectra = fd.Spectra(dict( + prob=sfs_prob.all, + fixed=sfs_fixed.all + )) + + spectra.plot() + + # mean relative difference much lower than threshold for most bins + self.assertLess(np.abs((sfs_prob.all.data - sfs_fixed.all.data) / sfs_fixed.all.data).mean(), 0.3) + + def test_compare_probabilistic_polarization_vs_fixed_probabilistic_subsampling(self): + """""" + Compare probabilistic polarization with fixed polarization. + """""" + for n in [19, 20]: + p1 = fd.Parser( + vcf=""resources/genome/sapiens/hgdp.anc.deg.vcf.gz"", + polarize_probabilistically=True, + max_sites=10000, + n=n + ) + + sfs_prob = p1.parse() + + p2 = fd.Parser( + vcf=""resources/genome/sapiens/hgdp.anc.deg.vcf.gz"", + polarize_probabilistically=False, + max_sites=10000, + n=n + ) + + sfs_fixed = p2.parse() + + spectra = fd.Spectra(dict( + prob=sfs_prob.all, + fixed=sfs_fixed.all + )) + + spectra.plot() + + # mean relative difference much lower than threshold for most bins + self.assertLess(np.abs((sfs_prob.all.data - sfs_fixed.all.data) / sfs_fixed.all.data).mean(), 0.12) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_annotation.py",".py","127238","3439","import itertools +import logging +import os +import tempfile +from collections import defaultdict +from hashlib import md5 +from typing import Literal, cast, Tuple +from unittest.mock import MagicMock, PropertyMock, patch, Mock + +import numpy as np +import pandas as pd +import pytest +from matplotlib import pyplot as plt +from matplotlib.collections import PathCollection +from numpy import testing +from pandas.testing import assert_frame_equal + +import fastdfe as fd +from fastdfe.annotation import _ESTSFSAncestralAnnotation, base_indices, SiteConfig, SiteInfo +from fastdfe.io_handlers import count_sites, GFFHandler, get_called_bases, DummyVariant +from testing import TestCase + + +class AnnotationTestCase(TestCase): + """""" + Test the annotators. + """""" + + @staticmethod + def test_maximum_parsimony_annotation_annotate_site(): + """""" + Test the maximum parsimony annotation for a single site. + """""" + # test data + cases = [ + dict( + ingroups=[""sample1"", ""sample2""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""A/A"", ""A/G"", ""G/G""]), + expected=""A"" + ), + dict( + ingroups=[""sample1"", ""sample2""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""./."", ""C/C"", ""C/C""]), + expected=""C"" + ), + dict( + ingroups=[""sample1"", ""sample2""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""T/T"", ""./."", ""./.""]), + expected=""T"" + ), + dict( + ingroups=[""sample1"", ""sample2""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""./."", ""./."", ""./.""]), + expected=""."" + ) + ] + + # mock Annotator + mock_annotator = MagicMock() + type(mock_annotator).info_ancestral = PropertyMock(return_value=""AA"") + + for test_case in cases: + annotation = fd.MaximumParsimonyAncestralAnnotation(samples=test_case[""ingroups""]) + annotation._handler = mock_annotator + + # mock the VCF reader with samples + mock_reader = MagicMock() + mock_reader.samples = test_case[""samples""] + annotation.reader = mock_reader + + # create ingroup mask + annotation.samples_mask = np.isin(annotation.reader.samples, annotation.samples) + + # mock variant with a dictionary for INFO + mock_variant = MagicMock() + mock_variant.gt_bases = test_case[""gt_bases""] + mock_variant.INFO = {} + + # run the method + annotation.annotate_site(mock_variant) + + # check if the result matches the expectation + assert mock_variant.INFO[annotation._handler.info_ancestral] == test_case[""expected""] + + def test_maximum_parsimony_annotation_get_ancestral(self): + """""" + Test the _get_ancestral method. + """""" + from cyvcf2 import Variant + + ann = fd.MaximumParsimonyAncestralAnnotation + + # check that reference is used for dummy variants + self.assertEqual('A', ann._get_ancestral(DummyVariant(ref='A', pos=1, chrom=""1""), mask=np.array([]))) + + # check that only allele is used for monomorphic sites + variant = Mock(spec=Variant) + variant.is_snp = False + variant.REF = 'A' + variant.gt_bases = np.array(['G/G', 'A/A']) + self.assertEqual('G', ann._get_ancestral(variant, mask=np.array([True, False]))) + + # check that only allele is used for non-SNPs only if it is a valid base + variant = Mock(spec=Variant) + variant.is_snp = False + variant.REF = 'A' + variant.gt_bases = np.array(['GAT/GAT', 'A/A']) + self.assertEqual('.', ann._get_ancestral(variant, mask=np.array([True, False]))) + + # check that only allele is used for non-SNPs only if reference is a valid base + variant = Mock(spec=Variant) + variant.is_snp = False + variant.REF = 'GAT' + variant.gt_bases = np.array(['A/A', 'A/A']) + self.assertEqual('.', ann._get_ancestral(variant, mask=np.array([True, False]))) + + # make sure we can pass site without any ingroup calls + variant = Mock(spec=Variant) + variant.is_snp = False + variant.gt_bases = np.array(['./.', './.']) + self.assertEqual('.', ann._get_ancestral(variant, mask=np.array([False, True]))) + + # check that the major allele is used for biallelic sites + variant = Mock(spec=Variant) + variant.is_snp = True + variant.gt_bases = np.array(['A/A', 'G/G', 'G/G']) + self.assertEqual('G', ann._get_ancestral(variant, mask=np.array([True, True, True]))) + + def test_maximum_parsimony_annotation_betula(self): + """""" + Test the maximum parsimony annotator with the betula dataset. + """""" + ann = fd.Annotator( + vcf='resources/genome/betula/biallelic.polarized.subset.10000.vcf.gz', + output='scratch/test_maximum_parsimony_annotation.vcf', + annotations=[fd.MaximumParsimonyAncestralAnnotation()], + max_sites=10000 + ) + + ann.annotate() + + fd.Parser(ann.output, n=20, info_ancestral='BB').parse().plot() + + # assert number of sites is the same + self.assertEqual(10000, count_sites(ann.output)) + + @staticmethod + def test_degeneracy_annotation_human_test_genome(): + """""" + Test the degeneracy annotator on a small human genome. + """""" + deg = fd.DegeneracyAnnotation() + + vcf = ""resources/genome/sapiens/chr21_test.vcf.gz"" + + ann = fd.Annotator( + vcf=vcf, + output='scratch/test_degeneracy_annotation_human_test_genome.vcf', + fasta=""http://hgdownload.soe.ucsc.edu/goldenPath/hg38/chromosomes/chr21.fa.gz"", + gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", + annotations=[deg], + ) + + ann.annotate() + + # assert number of sites is the same + assert count_sites(vcf) == count_sites(ann.output) + + # assert number of annotated sites and total number of sites + assert deg.n_annotated == 7 + assert ann.n_sites == 1517 + + @staticmethod + def test_degeneracy_annotation_human_test_genome_uncached(): + """""" + Test the degeneracy annotator on a small human genome. + """""" + deg = fd.DegeneracyAnnotation() + + vcf = ""resources/genome/sapiens/chr21_test.vcf.gz"" + + ann = fd.Annotator( + vcf=vcf, + output='scratch/test_degeneracy_annotation_human_test_genome.vcf', + fasta=""http://hgdownload.soe.ucsc.edu/goldenPath/hg38/chromosomes/chr21.fa.gz"", + gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", + annotations=[deg], + cache=False + ) + + ann.annotate() + + # assert number of sites is the same + assert count_sites(vcf) == count_sites(ann.output) + + # assert number of annotated sites and total number of sites + assert deg.n_annotated == 7 + assert ann.n_sites == 1517 + + @staticmethod + def test_degeneracy_annotation_human_test_genome_remote_fasta_gzipped(): + """""" + Test the degeneracy annotator on a small human genome with a remote gzipped fasta file. + """""" + deg = fd.DegeneracyAnnotation() + + vcf = ""resources/genome/sapiens/chr21_test.vcf.gz"" + + ann = fd.Annotator( + vcf=vcf, + output='scratch/test_degeneracy_annotation_human_test_genome_remote_fasta_gzipped.vcf', + fasta=""http://hgdownload.soe.ucsc.edu/goldenPath/hg38/chromosomes/chr21.fa.gz"", + gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", + annotations=[deg], + ) + + ann.annotate() + + # assert number of annotated sites and total number of sites + assert deg.n_annotated == 7 + assert ann.n_sites == 1517 + + @staticmethod + def test_degeneracy_annotation_betula_subset(): + """""" + Test the degeneracy annotator. + """""" + vcf = ""resources/genome/betula/all.subset.100000.vcf.gz"" + + ann = fd.Annotator( + vcf=vcf, + output='scratch/test_degeneracy_annotation_betula_subset.vcf', + fasta=""resources/genome/betula/genome.subset.20.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + annotations=[ + fd.DegeneracyAnnotation() + ], + ) + + ann.annotate() + + # assert number of sites is the same + assert count_sites(vcf) == count_sites(ann.output) + + @staticmethod + def test_annotator_load_vcf_from_url(): + """""" + Test the annotator loading a VCF from a URL. + """""" + ann = fd.Annotator( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + output='scratch/test_annotator_load_vcf_from_url.vcf', + annotations=[ + fd.DegeneracyAnnotation() + ], + ) + + ann.annotate() + + # assert number of sites is the same + assert ann.n_sites == 10000 + assert count_sites(ann.output) == 10000 + + @staticmethod + def test_compare_synonymy_annotation_with_vep_betula(): + """""" + Compare the synonymy annotation with VEP for the betula dataset. + """""" + syn = fd.SynonymyAnnotation() + + ann = fd.Annotator( + vcf=""resources/genome/betula/biallelic.subset.10000.vcf.gz"", + output='scratch/test_compare_synonymy_annotation_with_vep_betula.vcf', + fasta=""resources/genome/betula/genome.subset.20.fasta"", + gff=""resources/genome/betula/genome.gff.gz"", + annotations=[syn], + ) + + ann.annotate() + + assert syn.n_vep_comparisons == 3566 + assert len(syn.vep_mismatches) == 0 + + @pytest.mark.slow + def test_compare_synonymy_annotation_with_vep_human_chr21(self): + """""" + Compare the synonymy annotation with VEP for human chromosome 21. + """""" + syn = fd.SynonymyAnnotation() + + ann = fd.Annotator( + vcf=""snakemake/results/vcf/sapiens/chr21.vep.vcf.gz"", + output=""scratch/test_compare_synonymy_annotation_with_vep_human_chr21.vcf"", + fasta=""resources/genome/sapiens/chr21.fasta"", + gff=""resources/genome/sapiens/chr21.sorted.gff3"", + aliases=dict(chr21=['21']), + annotations=[syn] + ) + + ann.annotate() + + assert syn.n_vep_comparisons == 9804 + assert len(syn.vep_mismatches) == 42 + + @pytest.mark.slow + def test_compare_synonymy_annotation_with_snpeff_human_chr21(self): + """""" + Compare the synonymy annotation with snpEff for human chromosome 21. + """""" + syn = fd.SynonymyAnnotation() + + ann = fd.Annotator( + vcf=""snakemake/results/vcf/sapiens/chr21.snpeff.vcf.gz"", + output=""scratch/test_compare_synonymy_annotation_with_snpeff_human_chr21.vcf"", + fasta=""resources/genome/sapiens/chr21.fasta"", + gff=""resources/genome/sapiens/hg38.sorted.gtf.gz"", + aliases=dict(chr21=['21']), + annotations=[syn] + ) + + ann.annotate() + + assert syn.n_snpeff_comparisons == 11240 + assert len(syn.snpeff_mismatches) == 233 + + @pytest.mark.slow + def test_compare_synonymy_annotation_with_vep_hgdp_chr21(self): + """""" + Compare the synonymy annotation with VEP for HGDP chromosome 21. + """""" + syn = fd.SynonymyAnnotation() + + ann = fd.Annotator( + vcf=""snakemake/results/vcf/hgdp/21/opts.vep.vcf.gz"", + output=""scratch/test_compare_synonymy_annotation_with_vep_hgdp_chr21.vcf"", + fasta=""snakemake/results/fasta/hgdp/21.fasta.gz"", + gff=""snakemake/results/gff/hgdp/21.gff3.gz"", + aliases=dict(chr21=['21']), + annotations=[syn] + ) + + ann.annotate() + + assert syn.n_vep_comparisons == 6010 + assert len(syn.vep_mismatches) == 40 + + def test_get_degeneracy(self): + """""" + Test the get_degeneracy function. + """""" + # List of test cases. Each case is a tuple (codon, pos, expected_degeneracy). + test_cases = [ + ('ATG', 0, 0), # Codon for Methionine (Start), non-degenerate + ('ATG', 1, 0), # Codon for Methionine (Start), non-degenerate + ('ATG', 2, 0), # Codon for Methionine (Start), non-degenerate + ('TGG', 0, 0), # Codon for Tryptophan, non-degenerate + ('TGG', 1, 0), # Codon for Tryptophan, non-degenerate + ('TGG', 2, 0), # Codon for Tryptophan, non-degenerate + ('GCT', 0, 0), # Codon for Alanine, non-degenerate + ('GCT', 1, 0), # Codon for Alanine, non-degenerate + ('GCT', 2, 4), # Codon for Alanine, 4-fold degenerate + ('CGT', 0, 0), # Codon for Arginine, non-degenerate + ('CGT', 1, 0), # Codon for Arginine, non-degenerate + ('CGT', 2, 4), # Codon for Arginine, 4-fold degenerate + ('ACT', 0, 0), # Codon for Threonine, non-degenerate + ('ACT', 1, 0), # Codon for Threonine, non-degenerate + ('ACT', 2, 4), # Codon for Threonine, 4-fold degenerate + ('GAT', 0, 0), # Codon for Aspartic Acid, non-degenerate + ('GAT', 1, 0), # Codon for Aspartic Acid, non-degenerate + ('GAT', 2, 2), # Codon for Aspartic Acid, 4-fold degenerate + ] + + for codon, pos, expected in test_cases: + degeneracy = fd.DegeneracyAnnotation._get_degeneracy(codon, pos) + self.assertEqual(degeneracy, expected) + + def test_is_synonymous(self): + # List of test cases. Each case is a tuple (codon1, codon2, expected_result). + test_cases = [ + ('ATG', 'ATG', True), # Same codons are always synonymous + ('GCT', 'GCC', True), # Both code for Alanine + ('GCT', 'GTT', False), # GCT codes for Alanine, GTT codes for Valine + ('TAA', 'TAG', True), # Both are stop codons + ('TAA', 'ATG', False), # TAA is a stop codon, ATG codes for Methionine + ('CGT', 'CGG', True), # Both code for Arginine + ('GAT', 'GAC', True), # Both code for Aspartic Acid + ('TTT', 'TTC', True), # Both code for Phenylalanine + ('AAA', 'AAG', True), # Both code for Lysine + ('CAA', 'CAG', True), # Both code for Glutamine + ('AAT', 'AAC', True), # Both code for Asparagine + ('GAA', 'GAG', True), # Both code for Glutamic Acid + ('AGA', 'AGG', True), # Both code for Arginine + ('CTT', 'CTC', True), # Both code for Leucine + ('TAT', 'TAC', True), # Both code for Tyrosine + ('CGT', 'AGT', False), # CGT codes for Arginine, AGT codes for Serine + ('GGT', 'GCT', False), # GGT codes for Glycine, GCT codes for Alanine + ('GAT', 'GGT', False), # GAT codes for Aspartic Acid, GGT codes for Glycine + ('AAA', 'AGA', False), # AAA codes for Lysine, AGA codes for Arginine + ('CAA', 'GAA', False), # CAA codes for Glutamine, GAA codes for Glutamic Acid + ('AAT', 'ACT', False), # AAT codes for Asparagine, ACT codes for Threonine + ('GAA', 'GGA', False), # GAA codes for Glutamic Acid, GGA codes for Glycine + ('AGA', 'ACA', False), # AGA codes for Arginine, ACA codes for Threonine + ('CTT', 'CCT', False), # CTT codes for Leucine, CCT codes for Proline + ('TAT', 'TGT', False), # TAT codes for Tyrosine, TGT codes for Cysteine + ] + + for codon1, codon2, expected in test_cases: + with self.subTest(codon1=codon1, codon2=codon2): + synonymy = fd.SynonymyAnnotation.is_synonymous(codon1, codon2) + self.assertEqual(synonymy, expected) + + @staticmethod + def test_count_target_sites(): + """""" + Test the count_target_sites function. + """""" + # Define a mock dataframe to be returned by _load_cds + mock_df = pd.DataFrame({ + 'seqid': ['chr1', 'chr1', 'chr2', 'chr2', 'chr2'], + 'start': [1, 100, 1, 100, 200], + 'end': [10, 200, 50, 150, 250] + }) + + # We'll patch the _load_cds function to return our mock dataframe + with patch.object(GFFHandler, ""_load_cds"", return_value=mock_df): + result = GFFHandler(""mock_file.gff"")._count_target_sites() + + # Our expected result is the sum of the differences between end and start for each 'seqid' + expected_result = { + 'chr1': (200 - 100 + 1) + (10 - 1 + 1), + 'chr2': (50 - 1 + 1) + (150 - 100 + 1) + (250 - 200 + 1) + } + + assert result == expected_result + + def test_count_target_sites_betula_gff_all_contigs(self): + """""" + Test the count_target_sites function on the Betula gff file. + """""" + gff = ""resources/genome/betula/genome.gff.gz"" + + target_sites = fd.Annotation.count_target_sites(gff) + + self.assertEqual(3273, len(target_sites)) + self.assertEqual(337816, target_sites['Contig0']) + + def test_count_target_sites_betula_gff_some_contigs(self): + """""" + Test the count_target_sites function on the Betula gff file. + """""" + gff = ""resources/genome/betula/genome.gff.gz"" + + target_sites = fd.Annotation.count_target_sites(gff, contigs=['Contig0', 'Contig10']) + + self.assertEqual(2, len(target_sites)) + self.assertEqual(337816, target_sites['Contig0']) + self.assertEqual(4992, target_sites['Contig10']) + + def test_aliases_empty_dict(self): + """""" + Test aliases when no aliases are given. + """""" + contig_aliases = {} + expected_mappings = {} + expected_aliases_expanded = {} + + mappings, aliases_expanded = fd.FileHandler._expand_aliases(contig_aliases) + + self.assertEqual(mappings, expected_mappings) + self.assertEqual(aliases_expanded, expected_aliases_expanded) + + def test_aliases_single_contig(self): + """""" + Test aliases when a single contig is given. + """""" + contig_aliases = {'chr1': ['1']} + expected_mappings = {'chr1': 'chr1', '1': 'chr1'} + expected_aliases_expanded = {'chr1': ['1', 'chr1']} + + mappings, aliases_expanded = fd.FileHandler._expand_aliases(contig_aliases) + + self.assertEqual(mappings, expected_mappings) + self.assertEqual(aliases_expanded, expected_aliases_expanded) + + def test_aliases_multiple_contigs(self): + """""" + Test aliases when multiple contigs are given. + """""" + contig_aliases = {'chr1': ['1'], 'chr2': ['2']} + expected_mappings = {'chr1': 'chr1', '1': 'chr1', 'chr2': 'chr2', '2': 'chr2'} + expected_aliases_expanded = {'chr1': ['1', 'chr1'], 'chr2': ['2', 'chr2']} + + mappings, aliases_expanded = fd.FileHandler._expand_aliases(contig_aliases) + + self.assertEqual(mappings, expected_mappings) + self.assertEqual(aliases_expanded, expected_aliases_expanded) + + def test_aliases_multiple_aliases(self): + """""" + Test aliases when multiple aliases are given for a single contig. + """""" + contig_aliases = {'chr1': ['1', 'one']} + expected_mappings = {'chr1': 'chr1', '1': 'chr1', 'one': 'chr1'} + expected_aliases_expanded = {'chr1': ['1', 'one', 'chr1']} + + mappings, aliases_expanded = fd.FileHandler._expand_aliases(contig_aliases) + + self.assertEqual(mappings, expected_mappings) + self.assertEqual(aliases_expanded, expected_aliases_expanded) + + def test_degeneracy_annotation_get_degeneracy_table(self): + """""" + Test the get_degeneracy_table method. + """""" + t = fd.DegeneracyAnnotation._get_degeneracy_table() + + self.assertEqual(64, len(t)) + self.assertEqual(t['AAA'], '002') + self.assertEqual(t['GCT'], '004') + + +class MaximumLikelihoodAncestralAnnotationTestCase(TestCase): + """""" + Test the MaximumLikelihoodAncestralAnnotation class. + """""" + + @staticmethod + def compare_with_est_sfs( + anc: fd.MaximumLikelihoodAncestralAnnotation, + cache: str = None + ) -> Tuple[_ESTSFSAncestralAnnotation, pd.DataFrame]: + """""" + Compare the results of the MaximumLikelihoodAncestralAnnotation class with the results of EST-SFS. + + :param anc: An instance of the MaximumLikelihoodAncestralAnnotation class. + :param cache: The cache file to use for the EST-SFS results if any. + """""" + if cache is not None and os.path.exists(cache): + est_sfs = _ESTSFSAncestralAnnotation.from_file(cache) + + fd.logger.info(f""Loading EST-SFS results from cache: {cache}"") + else: + + est_sfs = _ESTSFSAncestralAnnotation(anc) + + if anc.prior is None: + binary = ""resources/EST-SFS/cmake-build-debug/EST_SFS_no_prior"" + else: + binary = ""resources/EST-SFS/cmake-build-debug/EST_SFS_with_prior"" + + est_sfs.infer(binary=binary) + + if cache is not None: + est_sfs.to_file(cache) + + fd.logger.info(f""Caching EST-SFS results to: {cache}"") + + # get site information + site_info = pd.DataFrame([s.__dict__ for s in anc.get_inferred_site_info()]) + + # prefix columns + site_info.columns = ['native.' + col for col in site_info.columns] + + # add EST-SFS results to site information + site_info['est_sfs.config'] = est_sfs.probs.config.to_list() + site_info['est_sfs.p_major_ancestral'] = est_sfs.probs.prob.to_list() + + return est_sfs, site_info + + def test_negative_lower_bounds_raises_value_error(self): + """""" + Test that a ValueError is raised when the lower bound of a parameter is negative. + """""" + with self.assertRaises(ValueError): + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_runs=3, + n_ingroups=5, + model=fd.JCSubstitutionModel(bounds=dict(k=(-1, 1))) + ) + + def test_get_p_tree_one_outgroup(self): + """""" + Test the get_p_tree function with one outgroup. + """""" + params = dict( + k=2, + K0=0.5 + ) + + model = fd.K2SubstitutionModel() + + for base, outgroup_base in itertools.product(range(4), range(4)): + p = fd.MaximumLikelihoodAncestralAnnotation.get_p_tree( + base=base, + n_outgroups=1, + internal_nodes=[], + outgroup_bases=[outgroup_base], + model=model, + params=dict( + k=2, + K0=0.5 + ) + ) + + p_expected = model._get_prob( + b1=base, + b2=outgroup_base, + i=0, + params=params + ) + + self.assertEqual(p, p_expected) + + def test_get_p_tree_two_outgroups(self): + """""" + Test the get_p_tree function with two outgroups. + """""" + params = dict( + k=2, + K0=0.5, + K1=0.25, + K2=0.125 + ) + + model = fd.K2SubstitutionModel() + + for base, outgroup_base1, outgroup_base2, internal_node in itertools.product(range(4), repeat=4): + p = fd.MaximumLikelihoodAncestralAnnotation.get_p_tree( + base=base, + n_outgroups=2, + internal_nodes=[internal_node], + outgroup_bases=[outgroup_base1, outgroup_base2], + params=params, + model=model + ) + + p_expected = (model._get_prob(base, internal_node, 0, params) * + model._get_prob(internal_node, outgroup_base1, 1, params) * + model._get_prob(internal_node, outgroup_base2, 2, params)) + + self.assertEqual(p, p_expected) + + def test_get_p_site_three_outgroups(self): + """""" + Test the get_p_site function with three outgroups. + """""" + params = dict( + k=2, + K0=0.5, + K1=0.25, + K2=0.125, + K3=0.0625, + K4=0.03125 + ) + + model = fd.K2SubstitutionModel() + + for base, out1, out2, out3, int_node1, int_node2 in itertools.product(range(4), repeat=6): + p = fd.MaximumLikelihoodAncestralAnnotation.get_p_tree( + base=base, + n_outgroups=3, + internal_nodes=[int_node1, int_node2], + outgroup_bases=[out1, out2, out3], + model=model, + params=dict( + k=2, + K0=0.5, + K1=0.25, + K2=0.125, + K3=0.0625, + K4=0.03125 + ) + ) + + p_expected = (model._get_prob(base, int_node1, 0, params) * + model._get_prob(int_node1, out1, 1, params) * + model._get_prob(int_node1, int_node2, 2, params) * + model._get_prob(int_node2, out2, 3, params) * + model._get_prob(int_node2, out3, 4, params)) + + self.assertEqual(p, p_expected) + + def test_fixed_params_different_branch_rates(self): + """""" + Test the MaximumLikelihoodAncestralAnnotation class with fixed parameters and different branch rates. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + n_runs=10, + parallelize=False, + model=fd.K2SubstitutionModel(fixed_params=dict(k=2, K0=0.5, K2=0.125)) + ) + + anc.infer() + + self.assertEqual(anc.params_mle['k'], 2) + self.assertEqual(anc.params_mle['K0'], 0.5) + self.assertEqual(anc.params_mle['K2'], 0.125) + self.assertNotEqual(anc.params_mle['K1'], 0.5) + self.assertNotEqual(anc.params_mle['K3'], 0.125) + + def test_fixed_params_same_branch_rates(self): + """""" + Test the MaximumLikelihoodAncestralAnnotation class with fixed parameters and same branch rates. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + n_runs=10, + parallelize=True, + model=fd.K2SubstitutionModel(fixed_params=dict(k=2, K=0.5), pool_branch_rates=True) + ) + + anc.infer() + + self.assertEqual(anc.params_mle['k'], 2) + self.assertEqual(anc.params_mle['K'], 0.5) + + @staticmethod + def test_expected_ancestral_alleles_fixed_branch_rate_inferred_site_info_kingman_prior(): + """""" + Test the expected ancestral alleles with fixed branch rates and inferred site information. + """""" + configs = [ + dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['A', '.', '.'], ancestral_expected='A'), + dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['G', '.', '.'], ancestral_expected='G'), + dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=['.', '.', '.'], ancestral_expected='C'), + dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['A', 'T', '.'], ancestral_expected='A'), + dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'A', '.'], ancestral_expected='A'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['T', 'C', 'C'], ancestral_expected='T'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['G', '.', '.'], ancestral_expected='T'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', '.'], ancestral_expected='T'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['T', 'C', 'C'], ancestral_expected='T'), + dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['A', 'C', 'T'], ancestral_expected='G'), + dict(n_major=15, major_base=None, minor_base=None, outgroup_bases=['A', 'C', 'T'], ancestral_expected='.'), + dict(n_major=15, major_base=None, minor_base=None, outgroup_bases=['.', '.', '.'], ancestral_expected='.'), + + # this is counterintuitive, but we can only consider bases that are present in the ingroup + dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T', '.'], ancestral_expected='A'), + dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T', 'T'], ancestral_expected='A'), + + # this works because 'T' is present in the ingroup + dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), + dict(n_major=20, major_base='A', minor_base='T', outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), + + # this again doesn't work because 'T' is not present in the ingroup + dict(n_major=15, major_base='A', minor_base='G', outgroup_bases=['T', 'T', 'T'], ancestral_expected='A'), + ] + + anc = fd.MaximumLikelihoodAncestralAnnotation.from_data( + n_major=[c['n_major'] for c in configs], + major_base=[c['major_base'] for c in configs], + minor_base=[c['minor_base'] for c in configs], + outgroup_bases=[c['outgroup_bases'] for c in configs], + n_ingroups=20, + prior=fd.KingmanPolarizationPrior(allow_divergence=True), + model=fd.JCSubstitutionModel(pool_branch_rates=True, fixed_params=dict(K=0.1)), + parallelize=False + ) + + anc.infer() + + summary = pd.DataFrame([s.__dict__ for s in anc.get_inferred_site_info()]) + + summary['expected'] = [c['ancestral_expected'] for c in configs] + + testing.assert_array_equal(summary.major_ancestral.values, summary.expected.values) + + def test_raises_error_when_zero_outgroups_given(self): + """""" + Test that an error is raised when zero outgroups are given. + """""" + with self.assertRaises(ValueError): + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[], + n_ingroups=10 + ) + + def test_outgroup_not_found_raises_error(self): + """""" + Test that an error is raised when an outgroup is not found. + """""" + with self.assertRaises(ValueError) as context: + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""blabla""], + n_ingroups=10 + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_outgroup_not_found_raises_error.vcf', + annotations=[anc], + max_sites=10 + ) + + ann.annotate() + + # Print the caught error message + print(""Caught error: "" + str(context.exception)) + + def test_more_ingroups_than_ingroup_samples_raises_warning(self): + """""" + Test that a warning is raised when more ingroups are specified than ingroup samples are present. + """""" + with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): + anc = fd.MaximumLikelihoodAncestralAnnotation( + ingroups=[""ASP04"", ""ASP05""], + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=5 + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_fewer_ingroups_than_ingroup_samples_raises_warning.vcf', + annotations=[anc], + max_sites=10 + ) + + ann.annotate() + + @staticmethod + def test_explicitly_specified_present_samples_raises_no_error(): + """""" + Test that an error is raised when an outgroup is not found. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + ingroups=[""ASP04"", ""ASP05""], + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=2 + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_explicitly_specified_present_samples_raises_no_error.vcf', + annotations=[anc], + max_sites=10 + ) + + ann.annotate() + + def test_exclude_ingroups_no_implicit_ingroups(self): + """""" + Test that the exclude parameter works. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + exclude=[""ASP04"", ""ASP05"", ""ASP06""], + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=2, + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_explicitly_specified_present_samples_raises_no_error.vcf', + annotations=[anc], + max_sites=10 + ) + + ann.annotate() + + self.assertEqual(anc._ingroup_mask.sum(), 374) + + def test_exclude_ingroups_no_explicit_ingroups(self): + """""" + Test that the exclude parameter works. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + ingroups=[""ASP01"", ""ASP02"", ""ASP03"", ""ASP04"", ""ASP05"", ""ASP06""], + exclude=[""ASP04"", ""ASP05"", ""ASP06""], + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=2, + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_explicitly_specified_present_samples_raises_no_error.vcf', + annotations=[anc], + max_sites=10 + ) + + ann.annotate() + + self.assertEqual(anc._ingroup_mask.sum(), 3) + + def test_get_likelihood_outgroup_ancestral_allele_annotation(self): + """""" + Test the get_likelihood function. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=10, + prior=None + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_get_likelihood_outgroup_ancestral_allele_annotation.vcf', + annotations=[anc], + max_sites=10000 + ) + + ann.annotate() + + self.assertEqual(anc.evaluate_likelihood(anc.params_mle), anc.likelihood) + + @pytest.mark.slow + def test_run_inference_full_betula_dataset(self): + """""" + Test the get_likelihood function. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=10, + prior=None, + model=fd.K2SubstitutionModel(), + parallelize=True + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/biallelic.with_outgroups.vcf.gz"", + output='scratch/test_get_likelihood_full_betula_dataset.vcf', + annotations=[anc], + max_sites=100000 + ) + + ann.annotate() + + anc.to_est_sfs(""resources/EST-SFS/test-betula-biallelic-100000.txt"") + + self.assertEqual(anc.evaluate_likelihood(anc.params_mle), anc.likelihood) + + @staticmethod + def test_from_est_sfs_est_sfs_sample_dataset(): + """""" + Test the from_est_sfs function with the est-sfs sample dataset. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + model=fd.JCSubstitutionModel(), + n_runs=10, + prior=fd.AdaptivePolarizationPrior(), + parallelize=True + ) + + # evaluate a ML estimates of EST-SFS + ll = anc.evaluate_likelihood(dict( + K0=0.000000, + K1=0.061141, + K2=0.000000, + K3=0.019841, + K4=0.019863 + )) + + pass + + def test_from_est_sfs_input_valid_probs(self): + """""" + Test that the probabilities are between 0 and 1 when using a prior. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + model=fd.JCSubstitutionModel(pool_branch_rates=True), + n_runs=10, + prior=fd.KingmanPolarizationPrior(), + parallelize=False + ) + + anc.infer() + + self.assertTrue(anc.configs.p_major_ancestral.between(0, 1).all()) + + @staticmethod + def test_from_est_sfs_varied_chunk_sizes(): + """""" + Test that the chunked and non-chunked versions of the from_est_sfs function return the same + results across multiple chunk sizes. + """""" + test_sizes = [1, 2, 5, 11, 30] + reference_chunk_size = 100 + + # Create a DataFrame using the reference_chunk_size + anc_reference = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + chunk_size=reference_chunk_size + ) + + df_reference = anc_reference.configs.sort_values( + by=['n_major', 'major_base', 'minor_base', 'outgroup_bases'] + ).reset_index(drop=True).sort_index(axis=1) + + for chunk_size in test_sizes: + anc_test = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + chunk_size=chunk_size + ) + + df_test = anc_test.configs.sort_values( + by=['n_major', 'major_base', 'minor_base', 'outgroup_bases'] + ).reset_index(drop=True).sort_index(axis=1) + + assert_frame_equal(df_reference, df_test, check_dtype=False) + + def test_to_est_sfs_test_data_no_poly_allelic(self): + """""" + Test the to_est_sfs function. + """""" + file_in = ""resources/EST-SFS/test-data-no-poly-allelic.txt"" + file_out = ""scratch/test_to_est_sfs.txt"" + + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=file_in, + model=fd.JCSubstitutionModel(pool_branch_rates=True), + n_runs=10, + prior=fd.AdaptivePolarizationPrior(), + parallelize=False + ) + + anc.to_est_sfs(file_out) + + # compare files + with open(file_in, 'r') as f1, open(file_out, 'r') as f2: + for line1, line2 in zip(f1, f2): + self.assertEqual(line1.strip(), line2.strip()) + + def test_to_est_sfs_betula_biallelic(self): + """""" + Test the to_est_sfs function. + """""" + file_in = ""resources/EST-SFS/test-betula-biallelic-10000.txt"" + file_out = ""scratch/test_to_est_sfs_betula_biallelic_10000.txt"" + + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=file_in, + model=fd.JCSubstitutionModel(pool_branch_rates=True), + n_runs=10, + prior=fd.AdaptivePolarizationPrior(), + parallelize=False + ) + + anc.to_est_sfs(file_out) + + # compare files + with open(file_in, 'r') as f1, open(file_out, 'r') as f2: + for i, (line1, line2) in enumerate(zip(f1, f2)): + self.assertEqual(line1.strip(), line2.strip()) + + def test_parallelize_unequal_likelihoods(self): + """""" + Test that the parallelize function works correctly when the likelihoods are not equal. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + n_runs=10, + parallelize=True + ) + + anc.infer() + + self.assertFalse(np.all(anc.likelihoods[0] == anc.likelihoods)) + + def test_get_observed_transition_transversion_ratio(self): + """""" + Test that the get_observed_transition_transversion_ratio function works as expected. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + n_runs=10, + parallelize=True + ) + + r = anc.get_observed_transition_transversion_ratio() + + self.assertEqual(r, 8 / 3) + + def test_K2_model_not_fix_transition_transversion_ratio(self): + """""" + Test that not fixing the transition transversion ratio in the K2 model works as expected. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + n_runs=10, + parallelize=True, + model=fd.K2SubstitutionModel(fix_transition_transversion_ratio=False) + ) + + self.assertTrue('k' not in anc.model.fixed_params) + + def test_K2_model_fix_transition_transversion_ratio(self): + """""" + Test that fixing the transition transversion ratio in the K2 model works as expected. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data.txt"", + n_runs=10, + parallelize=True, + model=fd.K2SubstitutionModel(fix_transition_transversion_ratio=True) + ) + + self.assertEqual(anc.model.fixed_params['k'], anc.get_observed_transition_transversion_ratio()) + + def test_from_data_chunked(self): + """""" + Test that the from_data function produces the expected results. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_data( + n_major=[13, 15, 17, 11], + major_base=['A', 'C', 'G', 'T'], + minor_base=['C', 'G', 'T', 'A'], + outgroup_bases=[['A', 'C'], ['G', 'G'], ['G', 'G'], ['A', 'A']], + n_ingroups=20 + ) + + cols = ['n_major', 'major_base', 'minor_base', 'outgroup_bases', 'sites', 'multiplicity'] + + self.assertDictEqual(anc.configs[cols].to_dict(), { + 'major_base': {0: 0, 1: 1, 2: 2, 3: 3}, + 'minor_base': {0: 1, 1: 2, 2: 3, 3: 0}, + 'outgroup_bases': {0: (0, 1), 1: (2, 2), 2: (2, 2), 3: (0, 0)}, + 'n_major': {0: 13, 1: 15, 2: 17, 3: 11}, + 'sites': {0: [0], 1: [1], 2: [2], 3: [3]}, + 'multiplicity': {0: 1, 1: 1, 2: 1, 3: 1}, + }) + + def test_upper_bounds_larger_than_lower_bounds_raises_value_error(self): + """""" + Test that a ValueError is raised when the lower bound of a parameter is negative. + """""" + with self.assertRaises(ValueError) as context: + fd.JCSubstitutionModel(bounds=dict(K=(10, 9))) + + # Print the caught error message + print(""Caught error: "" + str(context.exception)) + + def test_zero_lower_bound_raises_value_error(self): + """""" + Test that a ValueError is raised when the lower bound of a parameter is zero. + """""" + with self.assertRaises(ValueError) as context: + fd.JCSubstitutionModel(bounds=dict(K=(0, 9))) + + # Print the caught error message + print(""Caught error: "" + str(context.exception)) + + @pytest.mark.slow + def test_papio_thorough_two_outgroups(self): + """""" + Test the MLEAncestralAlleleAnnotation class on the Papio vcf file. + """""" + samples = pd.read_csv(""resources/genome/papio/metadata.csv"") + + anc = fd.MaximumLikelihoodAncestralAnnotation( + ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + outgroups=[ + samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') + ], + n_runs=10, + n_ingroups=10, + parallelize=True, + prior=fd.KingmanPolarizationPrior(), + confidence_threshold=0, + max_sites=10000 + ) + + ann = fd.Annotator( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + output='scratch/test_papio_thorough_two_outgroups.vcf', + annotations=[anc], + max_sites=10000 + ) + + ann.annotate() + + self.assertTrue(anc.is_monotonic()) + + pass + + @pytest.mark.slow + def test_papio_thorough_three_outgroups(self): + """""" + Test the MLEAncestralAlleleAnnotation class on the Papio vcf file. + """""" + samples = pd.read_csv(""resources/genome/papio/metadata.csv"") + + anc = fd.MaximumLikelihoodAncestralAnnotation( + ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + outgroups=[ + samples[samples.C_origin == 'Anubis, Ethiopia'].iloc[0].PGDP_ID, + samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') + ], + n_runs=10, + n_ingroups=10, + parallelize=True, + prior=fd.KingmanPolarizationPrior(), + confidence_threshold=0, + max_sites=10000, + subsample_mode='random' + ) + + ann = fd.Annotator( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + output='scratch/test_papio_thorough_three_outgroups.vcf', + annotations=[anc], + max_sites=10000 + ) + + # mismatches mostly occur where we are not very confident in the ancestral allele + ann.annotate() + + anc2, site_info = self.compare_with_est_sfs( + anc=anc, + cache=""testing/cache/est-sfs/test_papio_thorough_three_outgroups.json"" + ) + + diff_params = np.array(list(anc2.params_mle.values())) / np.array(list(anc.params_mle.values())) + + # mle estimates are very similar + self.assertTrue(np.all(((0.6 < diff_params) & (diff_params < 1.5)) | (diff_params == 0))) + + self.assertTrue(anc.is_monotonic()) + + pass + + @pytest.mark.slow + def test_papio_thorough_three_outgroups_adaptive_prior(self): + """""" + Test the MLEAncestralAlleleAnnotation class on the Papio vcf file. + """""" + samples = pd.read_csv(""resources/genome/papio/metadata.csv"") + + anc = fd.MaximumLikelihoodAncestralAnnotation( + ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + outgroups=[ + samples[samples.C_origin == 'Anubis, Ethiopia'].iloc[0].PGDP_ID, + samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') + ], + n_runs=10, + n_ingroups=10, + parallelize=True, + prior=fd.AdaptivePolarizationPrior(), + confidence_threshold=0, + max_sites=10000 + ) + + ann = fd.Annotator( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + output='scratch/test_papio_thorough_three_outgroups.vcf', + annotations=[anc], + max_sites=10000 + ) + + # mismatches mostly occur where we are not very confident in the ancestral allele + ann.annotate() + + self.assertTrue(anc.is_monotonic()) + + pass + + @pytest.mark.skip(""Too slow"") + def test_papio_thorough_four_outgroups(self): + """""" + Test the MLEAncestralAlleleAnnotation class on the Papio vcf file. + """""" + samples = pd.read_csv(""resources/genome/papio/metadata.csv"") + + anc = fd.MaximumLikelihoodAncestralAnnotation( + ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + outgroups=[ + samples[samples.C_origin == 'Anubis, Ethiopia'].iloc[0].PGDP_ID, + samples[samples.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') + ], + n_runs=10, + n_ingroups=10, + parallelize=True, + prior=fd.KingmanPolarizationPrior(), + confidence_threshold=0, + max_sites=10000 + ) + + ann = fd.Annotator( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + output='scratch/test_papio_thorough_four_outgroups.vcf', + annotations=[anc], + max_sites=10000 + ) + + # mismatches mostly occur where we are not very confident in the ancestral allele + ann.annotate() + + self.assertTrue(anc.is_monotonic()) + + pass + + @pytest.mark.slow + def test_betula_thorough_two_outgroups(self): + """""" + Test the MLEAncestralAlleleAnnotation class on the betula vcf file. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_runs=50, + n_ingroups=10, + parallelize=True, + prior=fd.KingmanPolarizationPrior() + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.vcf.gz"", + output='scratch/test_betula_thorough.vcf', + annotations=[anc], + max_sites=100000 + ) + + ann.annotate() + + anc.evaluate_likelihood(anc.params_mle) + + anc.plot_likelihoods() + + # the two outgroup have a very similar divergence from the ingroup + # self.assertTrue(anc._is_monotonic()) + + pass + + @pytest.mark.slow + def test_betula_thorough_one_outgroup(self): + """""" + Test the MLEAncestralAlleleAnnotation class on the betula vcf file. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + n_runs=50, + n_ingroups=10, + parallelize=True, + prior=fd.KingmanPolarizationPrior() + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.vcf.gz"", + output='scratch/test_betula_thorough.vcf', + annotations=[anc], + max_sites=100000 + ) + + ann.annotate() + + anc.evaluate_likelihood(anc.params_mle) + + anc.plot_likelihoods() + + self.assertTrue(anc.is_monotonic()) + + pass + + @staticmethod + def test_betula_K2_model(): + """""" + Test the MLEAncestralAlleleAnnotation class on the betula vcf file. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_runs=10, + n_ingroups=5, + model=fd.K2SubstitutionModel(), + prior=fd.KingmanPolarizationPrior() + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_betula_use_prior_K2_model.vcf', + annotations=[anc], + max_sites=1000 + ) + + ann.annotate() + + pass + + @staticmethod + def test_betula_JC_model(): + """""" + Test the MLEAncestralAlleleAnnotation class on the betula vcf file. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_runs=3, + n_ingroups=5, + model=fd.JCSubstitutionModel(), + prior=fd.KingmanPolarizationPrior() + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_betula_use_prior_JC_model.vcf', + annotations=[anc], + max_sites=1000 + ) + + ann.annotate() + + pass + + @staticmethod + def test_betula_no_prior(): + """""" + Test the MLEAncestralAlleleAnnotation class on the betula vcf file. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_runs=3, + n_ingroups=5, + prior=None + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_betula_not_use_prior.vcf', + annotations=[anc], + max_sites=1000 + ) + + ann.annotate() + + anc.plot_likelihoods() + + @staticmethod + def test_adhoc_ancestral_annotation_random_subsampling_betula(): + """""" + Test the AdhocAncestralAnnotation class on the betula vcf file. + """""" + anc = fd.annotation.AdHocAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=5, + subsample_mode='random' + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_betula_not_use_prior.vcf', + annotations=[anc], + max_sites=1000 + ) + + ann.annotate() + + @staticmethod + def test_adhoc_ancestral_annotation_probabilistic_subsampling_betula(): + """""" + Test the AdhocAncestralAnnotation class on the betula vcf file. + """""" + anc = fd.annotation.AdHocAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=5, + subsample_mode='probabilistic' + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_betula_not_use_prior.vcf', + annotations=[anc], + max_sites=1000 + ) + + ann.annotate() + + @staticmethod + def test_n_target_sites_without_fasta_raises_error(): + """""" + Test that an error is raised when the number of target sites is specified without a fasta file specified. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_runs=3, + n_ingroups=5, + prior=None, + n_target_sites=1000000 + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_betula_not_use_prior.vcf', + annotations=[anc], + max_sites=1000 + ) + + with pytest.raises(ValueError) as context: + ann.annotate() + + # Print the caught error message + print(context) + + @staticmethod + def test_n_target_sites_lower_than_n_biallelic_raises_error(): + """""" + Test that an error is raised when the number of target sites is lower than the number of + biallelic sites. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_runs=3, + n_ingroups=5, + prior=None, + n_target_sites=10 + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + output='scratch/test_betula_not_use_prior.vcf', + annotations=[anc], + max_sites=1000 + ) + + with pytest.raises(ValueError) as context: + ann.annotate() + + # Print the caught error message + print(context) + + def test_n_target_sites_copied_from_target_site_counter_if_specified(self): + """""" + Test that the n_target_sites parameter is copied from the target_site_counter if it is + specified. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_runs=3, + n_ingroups=5, + prior=None, + n_target_sites=100 + ) + + p = fd.Parser( + n=10, + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + annotations=[anc], + max_sites=10, + target_site_counter=fd.TargetSiteCounter( + n_target_sites=100, + n_samples=1000 + ) + ) + + p.parse() + + self.assertEqual(anc.n_target_sites, p.target_site_counter.n_target_sites) + + @staticmethod + def test_n_target_sites(): + """""" + Test the n_target_sites parameter. + """""" + max_sites = 1000 + + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + n_runs=3, + n_ingroups=5, + prior=None, + n_target_sites=10000 + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + output='scratch/test_betula_not_use_prior.vcf', + annotations=[anc], + max_sites=max_sites, + fasta=""resources/genome/betula/genome.subset.20.fasta"" + ) + + ann.annotate() + + @staticmethod + def test_priors_betula_dataset(): + """""" + Test the EST-SFS wrapper. + """""" + annotations = [] + priors = [fd.KingmanPolarizationPrior(), fd.AdaptivePolarizationPrior()] + + fig, ax = plt.subplots(1) + + for i, prior in enumerate(priors): + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-betula-biallelic-10000.txt"", + model=fd.K2SubstitutionModel(), + n_runs=10, + prior=prior, + parallelize=True + ) + + anc.infer() + + # touch p_polarization to make sure it is calculated + _ = anc.p_polarization + + anc.prior.plot(ax=ax, show=False) + + annotations.append(anc) + + # set legend labels + ax.legend([p.__class__.__name__ for p in priors]) + + # set alpha + for child in ax.get_children(): + if isinstance(child, PathCollection): + child.set_alpha(0.5) + + plt.show() + + pass + + @staticmethod + @pytest.mark.slow + def test_compute_priors_from_betula_vcf_odd_even_number_of_ingroups(): + """""" + Test the EST-SFS wrapper. + """""" + annotators = [] + priors = [fd.KingmanPolarizationPrior(), fd.AdaptivePolarizationPrior()] + n_ingroups = [10, 11] + + fig, ax = plt.subplots(4, figsize=(10, 10)) + + for i, (prior, n_ingroup) in enumerate(itertools.product(priors, n_ingroups)): + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=n_ingroup, + prior=prior + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/all.with_outgroups.vcf.gz"", + output='scratch/test_fewer_ingroups_than_ingroup_samples_raises_error_{i}.vcf', + max_sites=100000, + annotations=[anc] + ) + + ann.annotate() + + anc.prior.plot(ax=ax[i], show=False) + + # set title + ax[i].set_title(f""n_ingroups = {n_ingroup}, prior = {prior.__class__.__name__}"") + + annotators.append(anc) + + plt.show() + + pass + + def test_compare_with_est_sfs_betula(self): + """""" + Compare MLE params and site probabilities with EST-SFS using the betula dataset. + """""" + cases = [ + dict( + prior=None, + model=fd.JCSubstitutionModel(), + tol_params=0.1, + tol_sites=0.04, + outgroups=[""ERR2103730""], + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" + ), + dict( + prior=None, + model=fd.JCSubstitutionModel(), + tol_params=1.3, + tol_sites=0.04, + outgroups=[""ERR2103730"", ""ERR2103731""], + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" + ), + dict( + prior=None, + model=fd.JCSubstitutionModel(), + tol_params=0.8, + tol_sites=0.04, + outgroups=[""ERR2103730"", ""ERR2103731""], + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"" + ), + dict( + prior=None, + model=fd.K2SubstitutionModel(), + tol_params=0.8, + tol_sites=0.04, + outgroups=[""ERR2103730"", ""ERR2103731""], + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"" + ), + dict( + prior=None, + model=fd.JCSubstitutionModel(), + tol_params=0.1, + tol_sites=0.04, + outgroups=[""ERR2103730""], + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"" + ), + dict( + prior=None, + model=fd.K2SubstitutionModel(), + tol_params=0.3, + tol_sites=0.04, + outgroups=[""ERR2103730""], + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"" + ) + ] + + annotators = [] + diffs_params = [] + diffs_sites = [] + n_ingroups = 11 + + # run inference + for i, case in enumerate(cases): + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=case['outgroups'], + n_ingroups=n_ingroups, + prior=case['prior'], + model=case['model'], + subsample_mode='random' + ) + + ann = fd.Annotator( + vcf=case['vcf'], + output='scratch/dummy.vcf', + annotations=[anc] + ) + + # set up to infer branch rates + ann._setup() + + hash_str = md5(str(case | {'model': case['model'].__class__.__name__}).encode()).hexdigest()[:8] + + anc2, site_info = self.compare_with_est_sfs( + anc=anc, + cache=f'testing/cache/est-sfs/test_betula_{hash_str}.json' + ) + + params_mle = np.array([[anc.params_mle[k], anc2.params_mle[k]] for k in anc.params_mle]) + + diff_params = np.abs(params_mle[:, 0] - params_mle[:, 1]) / params_mle[:, 1] + + # exclude sites where the major is fixed in the ingroup subsample + site_info = site_info[site_info['native.n_major'] != n_ingroups] + + diff_sites = np.abs(site_info['native.p_major_ancestral'] - site_info['est_sfs.p_major_ancestral']) + + annotators.append(ann) + diffs_params.append(diff_params) + diffs_sites.append(diff_sites) + + diffs_params_max = [d.max() for d in diffs_params] + diffs_params_tol = [case['tol_params'] for case in cases] + + diffs_sites_mean = [d.mean() for d in diffs_sites] + diffs_sites_tol = [case['tol_sites'] for case in cases] + + self.assertTrue((diffs_params_max < diffs_params_tol).all()) + self.assertTrue((diffs_sites_mean < diffs_sites_tol).all()) + + pass + + def test_compare_with_est_sfs_test_set(self): + """""" + Compare MLE params and site probabilities with EST-SFS using the EST-SFS test dataset. + """""" + for model in [fd.JCSubstitutionModel(), fd.K2SubstitutionModel()]: + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-data-no-poly-allelic.txt"", + model=model, + n_runs=10, + prior=None, + parallelize=True + ) + + anc.infer() + + est_sfs, site_info = self.compare_with_est_sfs( + anc=anc, + cache=f'testing/cache/est-sfs/test-data-no-poly-allelic-{model.__class__.__name__}.json' + ) + + params_native = anc.params_mle + params_wrapper = est_sfs.params_mle + + likelihoods_native = anc.likelihoods + likelihoods_wrapper = est_sfs.likelihoods + + testing.assert_almost_equal( + list(params_native.values()), + list(params_wrapper.values()), + decimal=3 + ) + + testing.assert_almost_equal( + site_info['native.p_major_ancestral'].values, + site_info['est_sfs.p_major_ancestral'].values, + decimal=5 + ) + + pass + + @staticmethod + def test_get_outgroup_bases(): + """""" + Test the _get_outgroup_bases function. + """""" + genotypes = np.array([""A|T"", ""./T"", ""C|G"", "".|."", ""T/T"", ""A|."", ""N|G"", ""A|N""]) + n_outgroups = 8 + + result = fd.MaximumLikelihoodAncestralAnnotation._get_outgroup_bases(genotypes, n_outgroups) + np.testing.assert_array_equal(result, np.array(['A', 'T', 'C', '.', 'T', 'A', 'G', 'A'])) + + def test_get_base_index(self): + """""" + Test the get_base_index function. + """""" + bases = np.array(['A', 'C', 'G', 'T', 'N']) + expected = np.array([0, 1, 2, 3, -1]) + + result = fd.MaximumLikelihoodAncestralAnnotation.get_base_index(bases) + + np.testing.assert_array_equal(result, expected) + + for base in bases: + self.assertEqual( + fd.MaximumLikelihoodAncestralAnnotation.get_base_index(base), + ['A', 'C', 'G', 'T'].index(base) if base in ['A', 'C', 'G', 'T'] else -1 + ) + + def test_get_base_string(self): + """""" + Test the get_base_string function. + """""" + bases = np.array([0, 1, 2, 3, -1]) + expected = np.array(['A', 'C', 'G', 'T', '.']) + + result = fd.MaximumLikelihoodAncestralAnnotation.get_base_string(bases) + + np.testing.assert_array_equal(result, expected) + + for base in bases: + self.assertEqual( + fd.MaximumLikelihoodAncestralAnnotation.get_base_string(base), + ['A', 'C', 'G', 'T', '.'][base] + ) + + def test_ad_hoc_annotation(self): + """""" + Test the ad hoc annotation. + """""" + configs = [ + dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['A'], ancestral_expected='A'), + dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['G'], ancestral_expected='G'), + dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=[], ancestral_expected='C'), + dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['A', 'T'], ancestral_expected='A'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['T', 'C', 'C'], ancestral_expected='C'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['G'], ancestral_expected='T'), + dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['A', 'C', 'T'], ancestral_expected='G'), + dict(n_major=15, major_base=None, minor_base=None, outgroup_bases=['A', 'C', 'T'], ancestral_expected='A'), + dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), + dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T'], ancestral_expected='T'), + dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), + dict(n_major=15, major_base='A', minor_base='G', outgroup_bases=['T', 'T', 'T'], ancestral_expected='T'), + ] + + for i, config in enumerate(configs): + site_config = fd.annotation.SiteConfig( + n_major=config['n_major'], + major_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['major_base']), + minor_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['minor_base']), + outgroup_bases=fd.MaximumLikelihoodAncestralAnnotation.get_base_index( + np.array(config['outgroup_bases']) + ) + ) + + site_info = fd.annotation.AdHocAncestralAnnotation._get_site_info(site_config) + + self.assertEqual(site_info['ancestral_base'], config['ancestral_expected']) + + def test_p_config(self): + """""" + Test the p_config function. + """""" + configs = [ + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T'], p_larger='equal'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['.', '.'], p_larger='equal'), + dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['A'], p_larger='major'), + dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['G'], p_larger='major'), + dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=[], p_larger='equal'), + dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['A', 'T'], p_larger='major'), + dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'A'], p_larger='equal'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['T', 'C', 'C'], p_larger='major'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'C'], p_larger='minor'), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['G'], p_larger='equal'), + dict(n_major=15, major_base='G', minor_base=None, outgroup_bases=['A', 'C', 'T'], p_larger='major'), + dict(n_major=15, major_base=None, minor_base=None, outgroup_bases=['A', 'C', 'T'], p_larger='equal'), + dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T', 'T'], p_larger='major'), + dict(n_major=15, major_base='A', minor_base=None, outgroup_bases=['T', 'T'], p_larger='major'), + dict(n_major=15, major_base='A', minor_base='T', outgroup_bases=['T', 'T', 'T'], p_larger='minor'), + dict(n_major=15, major_base='A', minor_base='G', outgroup_bases=['T', 'T', 'T'], p_larger='equal'), + dict(n_major=15, major_base='G', minor_base='C', outgroup_bases=['.', 'C'], p_larger='minor'), + ] + + for i, config in enumerate(configs): + probs = {} + + for name, focal_base in zip(['major', 'minor'], + [fd.annotation.BaseType.MAJOR, fd.annotation.BaseType.MINOR]): + probs[name] = fd.MaximumLikelihoodAncestralAnnotation.get_p_config( + config=fd.annotation.SiteConfig( + n_major=config['n_major'], + major_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['major_base']), + minor_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['minor_base']), + outgroup_bases=fd.MaximumLikelihoodAncestralAnnotation.get_base_index( + np.array(config['outgroup_bases']) + ) + ), + base_type=focal_base, + params=dict(K=0.2), + model=fd.JCSubstitutionModel(pool_branch_rates=True) + ) + + if config['p_larger'] == 'major': + self.assertGreater(probs['major'], probs['minor']) + elif config['p_larger'] == 'minor': + self.assertLess(probs['major'], probs['minor']) + elif config['p_larger'] == 'equal': + self.assertAlmostEqual(probs['major'], probs['minor'], places=10) + + pass + + @staticmethod + def test_ancestral_first_inner_node(): + """""" + Test the p_config function. + """""" + configs = pd.DataFrame([ + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'C'], expected=['C']), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'T'], expected=['C']), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T', 'T', 'T', 'T'], expected=['C']), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['C', 'T'], expected=['C', 'T']), + dict(n_major=15, major_base='T', minor_base='C', outgroup_bases=['.', '.'], expected=['C', 'T']), + dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['A', '.'], expected=['A']), + dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=['A', '.'], expected=['A']), + dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['.', 'A'], expected=['A']), + dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=['.', 'A'], expected=['A']), + dict(n_major=15, major_base='C', minor_base='A', outgroup_bases=['C', 'A'], expected=['A', 'C']), + dict(n_major=15, major_base='A', minor_base='C', outgroup_bases=['C', 'A'], expected=['A', 'C']), + dict(n_major=19, major_base='C', minor_base='A', outgroup_bases=['.', 'A'], expected=['A']), + ]) + + for i, config in configs.iterrows(): + site = SiteConfig( + n_major=config['n_major'], + major_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['major_base']), + minor_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['minor_base']), + outgroup_bases=fd.MaximumLikelihoodAncestralAnnotation.get_base_index( + np.array(config['outgroup_bases']) + ) + ) + + anc = fd.MaximumLikelihoodAncestralAnnotation.from_data( + n_major=[site.n_major], + major_base=[site.major_base], + minor_base=[site.minor_base], + outgroup_bases=[[0 for _ in site.outgroup_bases]], + n_ingroups=20, + prior=fd.KingmanPolarizationPrior(), + model=fd.JCSubstitutionModel(pool_branch_rates=True, fixed_params=dict(K=0.2)), + pass_indices=True + ) + + # dummy inference, all parameters are fixed + anc.infer() + + site_info = anc._get_site_info([site]) + + probs = np.array(list(site_info.p_bases_first_node.values())) + is_max = np.where(np.isclose(probs, np.max(probs)))[0] + + max_bases = np.array(list(site_info.p_bases_first_node.keys()))[is_max] + + np.testing.assert_array_equal(sorted(max_bases), sorted(config['expected'])) + + pass + + def test_infer_variants_without_setup_raises_runtime_error(self): + """""" + Test that an error is raised when the infer function is called without setup. + """""" + with self.assertRaises(RuntimeError): + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=10, + prior=None + ) + + anc.infer() + + def test_parse_variant(self): + """""" + Test that the annotation parses a mocked variant correctly. + """""" + from cyvcf2 import Variant + + # create a mocked annotation + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730"", ""ERR2103731""], + ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], + n_ingroups=8, + prior=None, + subsample_mode='random' + ) + + # create a mocked variant + variant = Mock(spec=Variant) + variant.REF = ""A"" + variant.ALT = [""T""] + variant.is_snp = True + anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730"", ""ERR2103731""]) + variant.gt_bases = np.array([""A|A"", ""T|T"", ""A|T"", ""T|T"", ""T|T"", ""T|T""]) + + # parse the mocked variant + site = anc._parse_variant(variant)[0] + + self.assertEqual(site.n_major, 5) + self.assertEqual(site.major_base, base_indices['T']) + self.assertEqual(site.minor_base, base_indices['A']) + + def test_parse_variant_minor_allele_zero_frequency_but_contained_in_ingroup(self): + """""" + Test that the annotation parses a mocked variant correctly when the minor allele has zero frequency but is + contained in the ingroup. + """""" + from cyvcf2 import Variant + + # create a mocked annotation + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], + n_ingroups=4, + prior=None, + subsample_mode='random' + ) + + # create a mocked variant + variant = Mock(spec=Variant) + variant.REF = ""A"" + variant.ALT = [""T""] + variant.is_snp = True + anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730""]) + variant.gt_bases = np.array([""A|T"", ""T|T"", ""T|T"", ""T|T"", ""T|A""]) + + # parse the mocked variant + site = anc._parse_variant(variant)[0] + + self.assertEqual(site.n_major, 4) + self.assertEqual(site.major_base, base_indices['T']) + self.assertEqual(site.minor_base, base_indices['A']) + + def test_parse_variant_minor_allele_zero_frequency_but_contained_in_outgroup(self): + """""" + Test that the annotation parses a mocked variant correctly when the minor allele has zero frequency but is + contained in the outgroup only. + """""" + from cyvcf2 import Variant + + # create a mocked annotation + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], + n_ingroups=4, + prior=None, + subsample_mode='random' + ) + + # create a mocked variant + variant = Mock(spec=Variant) + variant.REF = ""A"" + variant.ALT = [""T""] + variant.is_snp = True + anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730""]) + variant.gt_bases = np.array([""T|T"", ""T|T"", ""T|T"", ""T|T"", ""T|A""]) + + # parse the mocked variant + site = anc._parse_variant(variant)[0] + + self.assertEqual(site.n_major, 4) + self.assertEqual(site.major_base, base_indices['T']) + self.assertEqual(site.minor_base, base_indices['A']) + + def test_parse_variant_too_few_ingroups_error(self): + """""" + Test that an error is raised when the number of ingroups is less than the number of samples. + """""" + from cyvcf2 import Variant + + # create a mocked annotation + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + ingroups=[""ASP04"", ""ASP05"", ""ASP06""], + n_ingroups=8, + prior=None, + subsample_mode='random' + ) + + # create a mocked variant + variant = Mock(spec=Variant) + variant.REF = ""A"" + variant.ALT = [""T""] + variant.is_snp = True + anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ERR2103730""]) + variant.gt_bases = np.array([""T|T"", ""T|A"", ""T|T"", ""T|A""]) + + with self.assertRaises(fd.annotation._TooFewIngroupsSiteError): + anc._parse_variant(variant) + + def test_parse_variant_poly_allelic_error(self): + """""" + Test that an error is raised when the variant is poly-allelic. + """""" + from cyvcf2 import Variant + + # create a mocked annotation + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], + n_ingroups=8, + prior=None, + subsample_mode='random' + ) + + # create a mocked variant + variant = Mock(spec=Variant) + variant.REF = ""A"" + variant.ALT = [""T"", ""C""] + variant.is_snp = True + anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730""]) + variant.gt_bases = np.array([""T|T"", ""T|A"", ""T|T"", ""T|A"", ""T|C""]) + + with self.assertRaises(fd.annotation._PolyAllelicSiteError): + anc._parse_variant(variant) + + def test_parse_variance_probabilistic_subsampling(self): + """""" + Test the parse_variance function with probabilistic subsampling. + """""" + from cyvcf2 import Variant + + # create a mocked annotation + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + ingroups=[""ASP04"", ""ASP05"", ""ASP06"", ""ASP07""], + n_ingroups=5, + prior=None, + subsample_mode='probabilistic' + ) + + # create a mocked variant + variant = Mock(spec=Variant) + variant.REF = ""A"" + variant.ALT = [""T""] + variant.is_snp = True + anc._prepare_masks([""ASP04"", ""ASP05"", ""ASP06"", ""ASP07"", ""ERR2103730""]) + variant.gt_bases = np.array([""T|T"", ""T|A"", ""T|T"", ""T|A"", ""T|T""]) + + # parse the mocked variant + sites = anc._parse_variant(variant) + + self.assertAlmostEqual(1, sum([site.multiplicity for site in sites])) + self.assertEqual({s.n_major for s in sites}, {3, 4, 5}) + + @staticmethod + def test_plot_tree_no_outgroup(): + """""" + Test the plot_tree function. + """""" + SiteInfo( + n_major=15, + major_base='T', + minor_base='C', + outgroup_bases=[], + rate_params=dict() + ).plot_tree() + + @staticmethod + def test_plot_tree_one_outgroup(): + """""" + Test the plot_tree function. + """""" + SiteInfo( + n_major=15, + major_base='T', + minor_base='C', + outgroup_bases=['C'], + rate_params=dict(K0=0.05, K1=0.3) + ).plot_tree() + + @staticmethod + def test_plot_tree_two_outgroups(): + """""" + Test the plot_tree function. + """""" + SiteInfo( + n_major=15, + major_base='T', + minor_base='C', + outgroup_bases=['C', 'T'], + rate_params=dict(K0=0.05, K1=0.3, K2=0.1) + ).plot_tree() + + @staticmethod + def test_plot_tree_three_outgroups(): + """""" + Test the plot_tree function. + """""" + SiteInfo( + n_major=15, + major_base='T', + minor_base='C', + outgroup_bases=['C', 'T', 'C'], + rate_params=dict(K0=0.05, K1=0.3, K2=0.1, K3=0.4, K4=0.2) + ).plot_tree() + + @staticmethod + def test_plot_tree_three_outgroups_pooled_rate_params(): + """""" + Test the plot_tree function. + """""" + SiteInfo( + n_major=15, + major_base='T', + minor_base='C', + outgroup_bases=['C', 'T', 'C'], + rate_params=dict(K=0.05) + ).plot_tree() + + def test_maximum_likelihood_annotation_annotate_site(self): + """""" + Test the maximum parsimony annotation for a single site. + """""" + # test cases + cases = [ + # minor allele 'G' but supported by outgroup + dict( + ingroups=[""sample1"", ""sample2""], + outgroups=[""sample3""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""A/A"", ""A/G"", ""G/G""]), + expected=""G"", + confidence_threshold=0, + n_ingroups=4, + prior=None + ), + # minor allele 'G', supported by outgroup, but not with enough confidence + dict( + ingroups=[""sample1"", ""sample2""], + outgroups=[""sample3""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""A/A"", ""A/G"", ""G/G""]), + expected=""."", + confidence_threshold=1, + n_ingroups=4, + prior=None + ), + # minor allele 'G', supported by outgroup, but not enough ingroup samples + dict( + ingroups=[""sample1"", ""sample2""], + outgroups=[""sample3""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""A/A"", ""A/G"", ""G/G""]), + expected=""."", + confidence_threshold=0, + n_ingroups=5, + prior=None + ), + # monomorphic site with outgroup information + dict( + ingroups=[""sample1"", ""sample2""], + outgroups=[""sample3""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""./."", ""C/C"", ""C/C""]), + expected=""C"", + n_ingroups=2, + confidence_threshold=0, + prior=None + ), + # monomorphic site with no outgroup information + dict( + ingroups=[""sample1"", ""sample2""], + outgroups=[""sample3""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""T/T"", ""./."", ""./.""]), + expected=""T"", + n_ingroups=2, + confidence_threshold=0, + prior=None + ), + # site without any calls + dict( + ingroups=[""sample1"", ""sample2""], + outgroups=[""sample3""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""./."", ""./."", ""./.""]), + expected=""."", + n_ingroups=2, + confidence_threshold=0, + prior=None + ), + # poly-allelic site + dict( + ingroups=[""sample1"", ""sample2""], + outgroups=[""sample3""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""A/A"", ""./."", ""G/T""]), + expected=""."", + n_ingroups=2, + confidence_threshold=0, + prior=None + ), + # poly-allelic site + dict( + ingroups=[""sample1"", ""sample2""], + outgroups=[""sample3""], + samples=[""sample1"", ""sample2"", ""sample3""], + gt_bases=np.array([""A/T"", ""G/."", ""T/T""]), + expected=""."", + n_ingroups=3, + confidence_threshold=0, + prior=None + ), + ] + + # mock Annotator + mock_annotator = MagicMock() + type(mock_annotator).info_ancestral = PropertyMock(return_value=""AA"") + + for i, test_case in enumerate(cases): + # create with dummy input and just fix branch rates + ann = fd.MaximumLikelihoodAncestralAnnotation.from_data( + n_major=[0], + major_base=['A'], + minor_base=['T'], + outgroup_bases=[['A']], + n_ingroups=test_case[""n_ingroups""], + model=fd.JCSubstitutionModel(pool_branch_rates=True, fixed_params=dict(K=0.1)), + prior=test_case[""prior""], + confidence_threshold=test_case[""confidence_threshold""] + ) + + ann.outgroups = test_case[""outgroups""] + ann.ingroups = test_case[""ingroups""] + ann._handler = mock_annotator + + # prepare masks + ann._prepare_masks(test_case[""samples""]) + + # infer branch rates (which has no effect) + ann.infer() + + # mock variant with a dictionary for INFO + variant = MagicMock() + variant.gt_bases = test_case[""gt_bases""] + variant.INFO = {} + variant.is_snp = len(set(get_called_bases(variant.gt_bases))) > 1 + variant.REF = 'A' # doesn't matter what the reference is, but it needs to be a valid base + + # run the method + ann.annotate_site(variant) + + # check if the result matches the expectation + self.assertEqual(variant.INFO[ann._handler.info_ancestral], test_case[""expected""]) + + def test_is_confident(self): + """""" + Test the is_confident method. + """""" + self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0, 0.1)) + self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0, 0.5)) + self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0, 0.9)) + + self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(1, 0.1)) + self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(1, 0.5)) + self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(1, 0.9)) + + self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.1)) + self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.2)) + self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.3)) + self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.5)) + self.assertEqual(False, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.7)) + self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.8)) + self.assertEqual(True, fd.MaximumLikelihoodAncestralAnnotation._is_confident(0.5, 0.9)) + + @staticmethod + def test_get_outgroup_divergence_one_outgroup(): + """""" + Test the get_outgroup_divergence method with one outgroup. + """""" + # create a mocked annotation + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""outgroup1""], + ingroups=[""ingroup1"", ""ingroup2"", ""ingroup3"", ""ingroup4""], + n_ingroups=8, + prior=None + ) + + anc.params_mle = { + 'K0': 0.05 + } + + testing.assert_array_equal([0.05], anc.get_outgroup_divergence()) + + @staticmethod + def test_get_outgroup_divergence_two_outgroups(): + """""" + Test the get_outgroup_divergence method with two outgroups. + """""" + # create a mocked annotation + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""outgroup1"", ""outgroup2""], + ingroups=[""ingroup1"", ""ingroup2"", ""ingroup3"", ""ingroup4""], + n_ingroups=8, + prior=None + ) + + anc.params_mle = { + 'K0': 0.05, + 'K1': 0.1, + 'K2': 0.2 + } + + testing.assert_array_almost_equal([0.15, 0.25], anc.get_outgroup_divergence()) + + @staticmethod + def test_get_outgroup_divergence_three_outgroups(): + """""" + Test the get_outgroup_divergence method with three outgroups. + """""" + # create a mocked annotation + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""outgroup1"", ""outgroup2"", ""outgroup3""], + ingroups=[""ingroup1"", ""ingroup2"", ""ingroup3"", ""ingroup4""], + n_ingroups=8, + prior=None + ) + + anc.params_mle = { + 'K0': 0.05, + 'K1': 0.1, + 'K2': 0.13, + 'K3': 0.3, + 'K4': 0.4 + } + + testing.assert_array_almost_equal([0.15, 0.48, 0.58], anc.get_outgroup_divergence()) + + @staticmethod + @pytest.mark.slow + def test_betula_different_confidence_thresholds(): + """""" + Test the SFS for different ancestral allele annotation confidence thresholds. + """""" + spectra = {} + + for threshold in [0, 0.5, 0.9]: + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + n=10, + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_ingroups=20, + confidence_threshold=threshold, + ) + ] + ) + + sfs = p.parse() + + spectra[str(threshold)] = sfs.all + + # we have fewer derived alleles for higher confidence thresholds + fd.Spectra.from_spectra(spectra).plot() + + pass + + @pytest.mark.slow + def test_papio_sfs_for_different_number_of_outgroups(self): + """""" + Test the SFS for different numbers of outgroups. + """""" + spectra, parsers = {}, {} + + samples = pd.read_csv(""resources/genome/papio/metadata.csv"") + + outgroups = [ + # samples[samples.C_origin == 'Anubis, Ethiopia'].iloc[0].PGDP_ID, + samples[samples.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') + ] + + for n_outgroups in [1, 2, 3]: + p = fd.Parser( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + n=8, + max_sites=10000, + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation( + ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + outgroups=outgroups[-n_outgroups:], + n_runs=10, + n_ingroups=10, + parallelize=True, + prior=fd.KingmanPolarizationPrior(), + confidence_threshold=0 + ) + ] + ) + + sfs = p.parse() + + spectra[f""{n_outgroups}_outgroups""] = sfs.all + parsers[f""{n_outgroups}_outgroups""] = p + + s = fd.Spectra.from_spectra(spectra) + s.plot() + + # make sure total number of sites is the same + np.testing.assert_almost_equal(s.n_sites, [s.n_sites[0]] * 3) + + # The number of polymorphic sites is very similar as it should + # If only one outgroup is used, there is a slight over-representation of high-frequency derived alleles + pass + + @pytest.mark.slow + def test_papio_sfs_for_different_subsample_size(self): + """""" + Test the SFS for different subsample sizes. + """""" + spectra, parsers = {}, {} + + samples = pd.read_csv(""resources/genome/papio/metadata.csv"") + + for n_ingroups in [5, 10, 20, 40]: + p = fd.Parser( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + n=8, + max_sites=10000, + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation( + ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + outgroups=[ + samples[samples.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') + ], + n_runs=10, + n_ingroups=n_ingroups, + parallelize=True, + prior=fd.KingmanPolarizationPrior(), + confidence_threshold=0, + ) + ] + ) + + sfs = p.parse() + + spectra[f""{n_ingroups}_ingroups""] = sfs.all + parsers[f""{n_ingroups}_ingroups""] = p + + # looks rather similar really + fd.Spectra.from_spectra(spectra).plot() + + pass + + @pytest.mark.slow + def test_papio_sfs_for_different_priors(self): + """""" + Test the SFS for different priors. + """""" + spectra, parsers = {}, {} + + samples = pd.read_csv(""resources/genome/papio/metadata.csv"") + + priors = { + 'none': None, + 'Kingman': fd.KingmanPolarizationPrior(), + 'Adaptive': fd.AdaptivePolarizationPrior(), + } + + for name, prior in priors.items(): + p = fd.Parser( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + n=8, + max_sites=10000, + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation( + ingroups=list(samples[samples.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + outgroups=[ + samples[samples.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), + samples[samples.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), + # samples[samples.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') + ], + n_runs=10, + n_ingroups=20, + parallelize=True, + prior=prior, + confidence_threshold=0, + ) + ] + ) + + sfs = p.parse() + + spectra[name] = sfs.all + parsers[name] = p + + # slightly more high-frequency derived alleles without prior, which is expected + fd.Spectra.from_spectra(spectra).plot() + + pass + + def test_add_monomorphic_site_counts(self): + """""" + Test the add_monomorphic_site_counts method. + """""" + vcfs = [ + 'resources/genome/betula/biallelic.with_outgroups.subset.50000.vcf.gz', + 'resources/genome/betula/all.with_outgroups.subset.200000.vcf.gz', + ] + + n_sites_vcf = 100 + + bases = dict(A=123, C=654, G=87, T=98) + + n_sites_total = n_sites_vcf + sum(bases.values()) + + for vcf in vcfs: + a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( + file=vcf, + outgroups=[""ERR2103730"", ""ERR2103731""], + n_ingroups=20, + confidence_threshold=0, + prior=fd.KingmanPolarizationPrior(), + max_sites=n_sites_vcf + ) + + configs = a._add_monomorphic_sites(bases) + + self.assertEqual(n_sites_vcf, a.configs.multiplicity.sum()) + self.assertEqual(n_sites_vcf, a.n_sites) + + self.assertEqual(n_sites_total, int(configs.multiplicity.sum())) + # self.assertEqual(n_sites_total, len(configs.sites.sum())) + # self.assertEqual(n_sites_total, len(np.unique(configs.sites.sum()))) + + pass + + @pytest.mark.slow + def test_betula_est_sfs_biallelic_vs_monomorphic_compare_rates(self): + """""" + Test the SFS for dataset including monomorphic sites vs. dataset without monomorphic sites using EST-SFS. + """""" + anc, anc2 = {}, {} + + vcfs = { + 'biallelic': ""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + 'all': ""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" + } + + for key, vcf in vcfs.items(): + a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( + file=vcf, + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_ingroups=20, + confidence_threshold=0, + prior=fd.KingmanPolarizationPrior() + ) + + a.infer() + + a2 = fd.annotation._ESTSFSAncestralAnnotation(a) + + a2.infer(binary=""resources/EST-SFS/cmake-build-debug/EST_SFS_with_prior"") + + anc[key] = a + anc2[key] = a2 + + # we have markedly different rates when including monomorphic sites, also for kappa + pass + + @pytest.mark.slow + def test_betula_same_estimates_when_sampling_monomorphic_sites_from_fasta(self): + """""" + Test that we get the same estimates when sampling monomorphic sites from a fasta file instead of a VCF. + """""" + configs = [ + dict( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730""], + tolerance=0.15 + ), + dict( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730"", ""ERR2103731""], + tolerance=0.12 + ) + ] + + for config in configs: + p1 = fd.Parser( + n=10, + vcf=config['vcf'], + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=config['outgroups'], + n_ingroups=20, + ) + ] + ) + + sfs = p1.parse() + + f = fd.Filterer( + vcf=config['vcf'], + output=tempfile.NamedTemporaryFile(delete=False, suffix='.vcf').name, + filtrations=[fd.SNPFiltration()] + ) + + f.filter() + + p2 = fd.Parser( + n=10, + fasta=""resources/genome/betula/genome.subset.20.fasta"", + vcf=f.output, + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=config['outgroups'], + n_ingroups=20, + n_target_sites=int(sfs.all.n_sites), + ) + ] + ) + + p2.parse() + + # noinspection all + params_mle = np.concatenate([ + [list(p1.annotations[0].params_mle.values())], + [list(p2.annotations[0].params_mle.values())] + ]) + + # we have markedly different rates when including monomorphic sites + max_rel_diff = np.max(np.abs(np.diff(params_mle, axis=0) / params_mle[:-1, :])) + + self.assertGreater(config['tolerance'], max_rel_diff) + + @pytest.mark.slow + def test_sfs_for_different_datasets(self): + """""" + Compare the SFS for different datasets. + """""" + max_sites = 10000 + spectra, parsers = {}, {} + + # determine using n = 10 from betula dataset + target_site_multiplier = 7.23 + + papio = pd.read_csv(""resources/genome/papio/metadata.csv"") + + datasets = dict( + anubis_one_outgroup=dict( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + fasta=""resources/genome/papio/Papio_anubis.fasta"", + outgroups=[ + papio[papio.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', '') + ], + ingroups=list(papio[papio.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + prior=fd.KingmanPolarizationPrior(), + n_target_sites=100000, + aliases=dict(chr1=['CM001491.2']) + ), + anubis_one_distant_outgroup=dict( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + fasta=""resources/genome/papio/Papio_anubis.fasta"", + outgroups=[ + papio[papio.Species == 'gelada'].iloc[0].PGDP_ID.replace('Sci_', '') + ], + ingroups=list(papio[papio.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + prior=fd.KingmanPolarizationPrior(), + n_target_sites=max_sites * target_site_multiplier, + aliases=dict(chr1=['CM001491.2']) + ), + anubis_two_outgroups=dict( + vcf=""resources/genome/papio/output.filtered.snps.chr1.removed.AB.pass.vep.vcf.gz"", + fasta=""resources/genome/papio/Papio_anubis.fasta"", + outgroups=[ + papio[papio.Species == 'hamadryas'].iloc[0].PGDP_ID.replace('Sci_', ''), + papio[papio.Species == 'kindae'].iloc[0].PGDP_ID.replace('Sci_', ''), + ], + ingroups=list(papio[papio.C_origin == 'Anubis, Tanzania']['PGDP_ID']), + prior=fd.KingmanPolarizationPrior(), + n_target_sites=max_sites * target_site_multiplier, + aliases=dict(chr1=['CM001491.2']) + ), + pendula_one_outgroup=dict( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730""], + ingroups=pd.read_csv(""resources/genome/betula/sample_sets/pendula.args"", header=None)[0].tolist(), + prior=fd.KingmanPolarizationPrior() + ), + pendula_one_outgroup_biallelic=dict( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + outgroups=[""ERR2103730""], + ingroups=pd.read_csv(""resources/genome/betula/sample_sets/pendula.args"", header=None)[0].tolist(), + prior=fd.KingmanPolarizationPrior(), + n_target_sites=max_sites * target_site_multiplier + ), + pubescens_one_outgroup=dict( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730""], + ingroups=pd.read_csv(""resources/genome/betula/sample_sets/pubescens.args"", header=None)[0].tolist(), + prior=fd.KingmanPolarizationPrior() + ), + betula_one_outgroup=dict( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + prior=fd.KingmanPolarizationPrior() + ), + betula_two_outgroups=dict( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730"", ""ERR2103731""], + exclude=[], + prior=fd.KingmanPolarizationPrior() + ), + betula_one_outgroup_no_prior=dict( + vcf=""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + prior=None + ), + ) + + for dataset, config in datasets.items(): + p = fd.Parser( + vcf=config['vcf'], + fasta=config['fasta'] if 'fasta' in config else None, + aliases=config['aliases'] if 'aliases' in config else {}, + n=10, + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=config['outgroups'], + ingroups=config['ingroups'] if 'ingroups' in config else None, + exclude=config['exclude'] if 'exclude' in config else [], + n_ingroups=20, + prior=config['prior'], + n_target_sites=config['n_target_sites'] if 'n_target_sites' in config else None, + ) + ] + ) + + sfs = p.parse() + + spectra[dataset] = sfs.all + parsers[dataset] = p + + s = fd.Spectra.from_spectra(spectra) + + # normalize by number of singletons + s.data /= s.data.iloc[1] + + s.plot() + + pass + + def test_compare_p_major_ancestral_high_vs_log_branch_rates(self): + """""" + Compare the p_major_ancestral for high vs. log branch rates. + """""" + configs = dict( + default=dict(n_major=19, major_base='T', minor_base='C', outgroup_bases=['C']), + ) + + params = dict( + low=dict(k=1, K0=0.03), + high=dict(k=1, K0=0.3), + ) + + site_info = defaultdict(dict) + + for config_name, config in configs.items(): + + for param_name, param in params.items(): + site = SiteConfig( + n_major=config['n_major'], + major_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['major_base']), + minor_base=fd.MaximumLikelihoodAncestralAnnotation.get_base_index(config['minor_base']), + outgroup_bases=fd.MaximumLikelihoodAncestralAnnotation.get_base_index( + np.array(config['outgroup_bases']) + ) + ) + + anc = fd.MaximumLikelihoodAncestralAnnotation.from_data( + n_major=[site.n_major], + major_base=[site.major_base], + minor_base=[site.minor_base], + outgroup_bases=[[0 for _ in site.outgroup_bases]], + n_ingroups=20, + prior=fd.KingmanPolarizationPrior(), + model=fd.JCSubstitutionModel(fixed_params=param), + pass_indices=True + ) + + # dummy inference, all parameters are fixed + anc.infer() + + site_info[(config_name, param_name)] = anc._get_site_info([site]).__dict__ + + site_info = pd.DataFrame.from_dict(site_info) + + self.assertLess( + site_info.loc['p_major_ancestral', ('default', 'low')], + site_info.loc['p_major_ancestral', ('default', 'high')] + ) + + self.assertGreater(np.diff(site_info.loc['p_major_ancestral'])[0], 0.5) + + def test_compare_random_vs_probabilistic_subsampling(self): + """""" + Compare MLE params and ancestral allele probabilities with random vs. probabilistic subsampling. + """""" + from cyvcf2 import VCF + + parsers, spectra = {}, {} + modes = ['probabilistic', 'random'] + + for mode in modes: + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + n=10, + max_sites=1000, + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_ingroups=20, + subsample_mode=cast(Literal['random', 'probabilistic'], mode) + ) + ] + ) + + self.assertEqual(p.annotations[0].subsample_mode, mode) + + sfs = p.parse() + + parsers[str(mode)] = p + spectra[str(mode)] = sfs.all + + fd.Spectra.from_spectra(spectra).plot() + + params_mle = np.array([list(parsers[mode].annotations[0].params_mle.values()) for mode in modes]) + + diff_rel = np.abs(np.diff(params_mle, axis=0) / params_mle[0]) + + self.assertLess(diff_rel.max(), 0.03) + + annotations = [parsers[mode].annotations[0] for mode in modes] + + vcf = VCF(""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"") + + mismatches = 0 + for i in range(600): + site = next(vcf) + + # get the site info for both annotations + site_info = [ann._get_site_info(ann._parse_variant(site)) for ann in annotations] + + # make sure the major and minor allele probabilities are the same + # This is because they're independent of the actual allele frequency + # given the major allele is the same + if site_info[0].major_base == site_info[1].major_base: + self.assertLess(np.abs(site_info[0].p_minor - site_info[1].p_minor), 0.01) + self.assertLess(np.abs(site_info[0].p_major - site_info[1].p_major), 0.01) + + # this is not true for all sites, but it is for the first 600 + self.assertLess(np.abs(site_info[0].p_major_ancestral - site_info[1].p_major_ancestral), 0.3) + else: + mismatches += 1 + + self.assertLess(mismatches, 6) + + @staticmethod + def test_plot_configs(): + """""" + Compare random vs. probabilistic subsampling. + """""" + + a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( + file=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + max_sites=1000, + n_ingroups=20, + subsample_mode='probabilistic', + ) + + a.get_folded_spectra(groups=[]).plot() + a.get_folded_spectra(groups=['major_base']).plot() + a.get_folded_spectra(groups=['major_base', 'minor_base']).plot() + a.get_folded_spectra(groups=['major_base', 'minor_base', 'outgroup_bases']).plot() + + def test_compare_folded_sfs_random_vs_probabilistic_subsampling(self): + """""" + Compare folded SFS random vs. probabilistic subsampling. + """""" + spectra = {} + for mode in ['probabilistic', 'random']: + a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( + file=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + max_sites=2000, + n_ingroups=10, + subsample_mode=cast(Literal['random', 'probabilistic'], mode) + ) + + spectra[mode] = a.get_folded_spectra(groups=[]).all + + fd.Spectra.from_spectra(spectra).plot() + + diff = ((spectra['random'].data - spectra['probabilistic'].data) / + (spectra['random'].data + spectra['probabilistic'].data)) + + # less for larger number of sites + self.assertLess(np.abs(diff[~np.isnan(diff)]).max(), 0.25) + + @staticmethod + def test_get_folded_spectra_random_vs_probabilistic_subsampling(): + """""" + Test the get_folded_spectra method for random vs. probabilistic subsampling and different groups. + """""" + for mode in ['probabilistic', 'random']: + a = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_ingroups=20, + subsample_mode=cast(Literal['random', 'probabilistic'], mode), + ) + + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + n=10, + max_sites=1000, + annotations=[a] + ) + + sfs = p.parse() + + a.get_folded_spectra(groups=[]).plot() + a.get_folded_spectra(groups=['major_base']).plot(use_subplots=True) + a.get_folded_spectra(groups=['major_base', 'minor_base']).plot(use_subplots=True) + + def test_subsample_site_convergence(self): + """""" + Test that random subsampling of sites converges to the probabilistic results. + """""" + genotypes = np.array(['A'] * 20 + ['T'] * 25) + rng = np.random.default_rng() + + for n in [10, 11]: + + random = np.zeros((3, 100000), dtype=object) + for i in range(random.shape[1]): + random[:, i] = np.array(fd.MaximumLikelihoodAncestralAnnotation._subsample_site( + mode='random', + n=n, + samples=genotypes, + rng=rng + ))[:, 0] + + probabilistic = np.array(fd.MaximumLikelihoodAncestralAnnotation._subsample_site( + mode='probabilistic', + n=n, + samples=genotypes, + rng=rng + )) + + df = pd.DataFrame( + random.T, + columns=['major_base', 'n_major', 'multiplicity'] + ) + + # change dtypes + df = df.astype({'n_major': int, 'multiplicity': int, 'major_base': str}) + + # take T always to be major allele + if n % 2 == 0: + df.loc[(df['major_base'] == 'A') & (df['n_major'] == n // 2), 'major_base'] = 'T' + + grouped = df.groupby(['major_base', 'n_major']).aggregate(sum) + + random_binned = np.zeros((3, n + 1), dtype=object) + for i, prob in enumerate(probabilistic.T): + + index = (prob[0], int(prob[1])) + p = 0 + if index in grouped.index: + p = grouped.loc[index].multiplicity / random.shape[1] + + random_binned[:, i] = list(index) + [p] + + diff = np.abs(random_binned[2].astype(float) - probabilistic[2].astype(float)) + + self.assertLess(diff.max(), 0.01) + + @staticmethod + def test_subsample_monomorphic_site_probabilistically(): + """""" + Test that probabilistic subsampling of monomorphic sites works. + """""" + genotypes = np.array(['A'] * 20) + + results = [] + for mode in ['probabilistic', 'random']: + results.append(np.array(fd.MaximumLikelihoodAncestralAnnotation._subsample_site( + mode=mode, + n=10, + samples=genotypes, + rng=np.random.default_rng() + ))) + + np.testing.assert_array_equal(results[0], results[1]) + + @staticmethod + def test_fixed_result(): + """""" + Test the maximum likelihood ancestral annotation for a fixed result. + """""" + max_sites = 1000 + + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_runs=10, + n_ingroups=20, + model=fd.K2SubstitutionModel(), + prior=fd.KingmanPolarizationPrior(), + n_target_sites=7 * max_sites + ) + + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + n=10, + max_sites=max_sites, + annotations=[anc] + ) + + sfs = p.parse() + + sfs.plot() + + np.testing.assert_almost_equal( + [860.7, 81.3, 21.4, 10.9, 6.5, 3.8, 2.5, 2.3, 2.8, 3.5, 3.3], + sfs.all.data, + decimal=1 + ) + + @staticmethod + @pytest.mark.skip('For profiling only') + def test_profiling(): + """""" + Profile the maximum likelihood ancestral annotation. + """""" + max_sites = 1000 + + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_runs=10, + n_ingroups=10, + model=fd.K2SubstitutionModel(), + prior=fd.KingmanPolarizationPrior(), + n_target_sites=7 * max_sites + ) + + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + n=10, + max_sites=max_sites, + annotations=[anc] + ) + + sfs = p.parse() + + def test_raises_warning_on_few_monomorphic_sites(self): + """""" + Test that a warning is raised when there are few monomorphic sites. + """""" + max_sites = 1000 + + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_runs=10, + n_ingroups=10, + model=fd.K2SubstitutionModel(), + prior=fd.KingmanPolarizationPrior() + ) + + p = fd.Parser( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + n=10, + max_sites=max_sites, + annotations=[anc] + ) + + # this should log a warning + with self.assertLogs(level='WARNING', logger=anc._logger): + p.parse() + + @staticmethod + def test_compare_priors_random_vs_probabilistic_subsampling(): + """""" + Compare priors with random vs. probabilistic subsampling. + """""" + for prior in [fd.AdaptivePolarizationPrior(), fd.KingmanPolarizationPrior()]: + for mode in ['probabilistic', 'random']: + a = fd.MaximumLikelihoodAncestralAnnotation._from_vcf( + file=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + max_sites=1000, + n_ingroups=20, + subsample_mode=cast(Literal['random', 'probabilistic'], mode), + prior=prior + ) + + a.infer() + + # much more stable with probabilistic subsampling + a.prior.plot(title=f""{prior.__class__.__name__} - {mode}"") + + @pytest.mark.slow + def test_compare_parsed_sfs_random_vs_probabilistic_subsampling_thorough(self): + """""" + Compare parsed SFS of random vs. probabilistic subsampling. + """""" + max_sites = 10000 + spectra, parsers = {}, {} + + for mode in ['probabilistic', 'random']: + a = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + max_sites=max_sites, + n_ingroups=20, + n_target_sites=7 * max_sites, + subsample_mode=cast(Literal['random', 'probabilistic'], mode) + ) + + parsers[mode] = fd.Parser( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + fasta=""resources/genome/betula/genome.subset.20.fasta"", + n=20, + max_sites=max_sites, + annotations=[a] + ) + + spectra[mode] = parsers[mode].parse().all + + fd.Spectra.from_spectra(spectra).plot() + + diff_rel_sfs = np.abs(np.diff([s.data for s in spectra.values()], axis=0)[0] / spectra['random'].data) + + self.assertLess(diff_rel_sfs[:-1].max(), 0.15) + + params_mle = np.array([list(p.annotations[0].params_mle.values()) for p in parsers.values()]) + + diff_ref_params = np.abs(params_mle[0] - params_mle[1]) / params_mle[0] + + self.assertLess(diff_ref_params.max(), 0.01) + + def test_serialization_from_est_sfs(self): + """""" + Test serializing and deserializing an annotation using from_est_sfs. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation.from_est_sfs( + file=""resources/EST-SFS/test-betula-biallelic-10000.txt"", + n_runs=1 + ) + + anc.infer() + + anc.to_file(""scratch/test_serialization_from_est_sfs.json"") + + anc2 = fd.MaximumLikelihoodAncestralAnnotation.from_file(""scratch/test_serialization_from_est_sfs.json"") + + self.assertEqual(anc.params_mle, anc2.params_mle) + + def test_serialization_with_annotator(self): + """""" + Test serializing and deserializing an annotation using the Annotator. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_ingroups=20, + prior=fd.KingmanPolarizationPrior(), + n_runs=1 + ) + + a = fd.Annotator( + vcf=""resources/genome/betula/biallelic.with_outgroups.subset.10000.vcf.gz"", + output=""scratch/test_serialization_with_annotator.vcf"", + annotations=[anc], + max_sites=100 + ) + + a.annotate() + + anc.to_file(""scratch/test_serialization_with_annotator.json"") + anc2 = fd.MaximumLikelihoodAncestralAnnotation.from_file(""scratch/test_serialization_with_annotator.json"") + + self.assertEqual(anc.params_mle, anc2.params_mle) + + def test_default_prior_kingman(self): + """""" + Test the default prior is the Kingman polarization prior. + """""" + a = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_ingroups=20 + ) + + self.assertIsInstance(a.prior, fd.KingmanPolarizationPrior) + + def test_pass_none_as_prior_means_no_prior(self): + """""" + Test that passing None as prior means no prior. + """""" + a = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + exclude=[""ERR2103731""], + n_ingroups=20, + prior=None + ) + + self.assertIsNone(a.prior) + + def test_betula_validate_prob_aa_field(self): + """""" + Test the MLEAncestralAlleleAnnotation class on the betula vcf file. + """""" + anc = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + n_runs=1, + n_ingroups=5, + max_sites=100, + n_target_sites=100000, + model=fd.JCSubstitutionModel() + ) + + ann = fd.Annotator( + vcf=""resources/genome/betula/biallelic.with_outgroups.vcf.gz"", + fasta=""resources/genome/betula/genome.fasta"", + output='scratch/test_betula_validate_prob_aa_field.vcf', + annotations=[anc], + max_sites=100 + ) + + _annotate_site = anc.annotate_site + probs = [] + + def annotate_site(variant): + _annotate_site(variant) + probs.append(variant.INFO['AA_prob']) + return variant + + anc.annotate_site = annotate_site + + ann.annotate() + + # make sure all probabilities are greater than 0.5 + self.assertGreater(min(probs), 0.5) + + def test_n_samples_target_sites_argument(self): + """""" + Test that the n_samples_target_sites is properly extrapolated to n_target_sites + """""" + n_target_sites = 100000 + max_sites = 100 + + anc, ann = {}, {} + for n_samples in [10 ** 3, 10 ** 4, 10 ** 5, 10 ** 6]: + anc[n_samples] = fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + n_runs=1, + n_ingroups=5, + max_sites=max_sites, + n_target_sites=n_target_sites, + n_samples_target_sites=n_samples, + model=fd.JCSubstitutionModel(), + adjust_target_sites=False + ) + + ann[n_samples] = fd.Annotator( + vcf=""resources/genome/betula/biallelic.with_outgroups.vcf.gz"", + fasta=""resources/genome/betula/genome.fasta"", + output='scratch/test_n_samples_target_sites_argument.vcf', + annotations=[anc[n_samples]], + max_sites=max_sites + ) + + ann[n_samples].annotate() + + self.assertEqual(anc[n_samples].n_sites, n_target_sites) + + counts = np.array([list(v._monomorphic_samples.values()) for k, v in anc.items()]) / n_target_sites + + self.assertLessEqual(np.max(np.var(counts, axis=0)), 1e-4) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_covariates.py",".py","1165","42","from typing import Dict + +from fastdfe.optimization import Covariate +from testing import TestCase + + +class CovariateTestCase(TestCase): + """""" + Test the Covariate class. + """""" + + def custom_apply_callback(self, covariate: float, type: str, params: Dict[str, float]) -> Dict[str, float]: + """""" + + :param covariate: + :param type: + :param params: + :return: + """""" + modified = params.copy() + if ""a"" in params: + modified[""a""] *= covariate * 2 + return modified + + def test_default_callbacks(self): + covariate = Covariate(param=""a"", values={""all"": 2}) + params = {""a"": 1, ""b"": 3} + + modified_params = covariate.apply(covariate=2, type=""all"", params=params) + self.assertEqual(modified_params, {""a"": 5, ""b"": 3}) + + def test_custom_callbacks(self): + covariate = Covariate( + param=""a"", + values={""all"": 2}, + callback=self.custom_apply_callback + ) + params = {""a"": 1, ""b"": 3} + + modified_params = covariate.apply(covariate=2, type=""all"", params=params) + self.assertEqual(modified_params, {""a"": 4, ""b"": 3}) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_parametrization.py",".py","16088","542","import numpy as np +from matplotlib import pyplot as plt + +import fastdfe as fd +from fastdfe import GammaExpParametrization, BaseInference, Config +from fastdfe.visualization import Visualization +from fastdfe.discretization import Discretization +from fastdfe.parametrization import DiscreteParametrization, GammaDiscreteParametrization, \ + DisplacedGammaParametrization, DiscreteFractionalParametrization +from testing import TestCase + + +class ParametrizationTestCase(TestCase): + """""" + Test the parametrization classes. + """""" + n = 20 + + config_file = ""testing/cache/configs/pendula_C_full_anc/config.yaml"" + + def test_compare_exact_vs_empirical_cdf_gamma_exp(self): + """""" + Compare exact vs empirical CDF for GammaExpParametrization. + """""" + p = GammaExpParametrization() + params = GammaExpParametrization.x0 + d = Discretization( + n=self.n, + intervals_ben=(1e-15, 100, 1000), + intervals_del=(-100000, -1e-15, 1000) + ) + + d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) + d2 = p.get_cdf(**params)(d.s) + + plt.plot(d.s, d1, alpha=0.5, label='empirical CDF') + plt.plot(d.s, d2, alpha=0.5, label='exact CDF') + + plt.legend() + plt.show() + + plt.title('GammaExpParametrization') + + diff = np.max(np.abs(d1 - d2)) + + assert diff < 0.005 + + def test_compare_exact_vs_empirical_cdf_gamma_exp_low_shape(self): + """""" + Compare exact vs empirical CDF for GammaExpParametrization for low shape parameter. + """""" + p = GammaExpParametrization() + d = Discretization( + n=self.n, + intervals_ben=(1e-15, 100, 1000), + intervals_del=(-100000, -1e-15, 1000) + ) + + params = { + 'S_d': -37572.964129977896, + 'b': 3.8866779746119997, + 'p_b': 0.19204516636691807, + 'S_b': 0.0001 + } + + d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) + d2 = p.get_cdf(**params)(d.s) + + plt.plot(d.s, d1, alpha=0.5, label='empirical CDF') + plt.plot(d.s, d2, alpha=0.5, label='exact CDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + diff = np.max(np.abs(d1 - d2)) + + assert diff < 0.009 + + def test_compare_pdf_vs_discretized_cdf_gamma_exp(self): + """""" + Compare PDF vs discretized CDF for GammaExpParametrization. + """""" + p = GammaExpParametrization() + d = Discretization( + n=self.n, + intervals_ben=(1e-15, 100, 1000), + intervals_del=(-100000, -1e-15, 1000) + ) + + params = { + 'S_d': -37572.964129977896, + 'b': 3.8866779746119997, + 'p_b': 0.19204516636691807, + 'S_b': 0.0001 + } + + d1 = p.get_pdf(**params)(d.s) * d.interval_sizes + d2 = p._discretize(params, d.bins) + + plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') + plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + diff = np.max(np.abs(d1 - d2)) + + assert diff < 1e-4 + + def test_compare_exact_vs_empirical_cdf_discretized_parametrization(self): + """""" + Compare exact vs empirical CDF for DiscreteParametrization + """""" + p = DiscreteParametrization() + + d = Discretization( + n=self.n, + intervals_ben=(1e-2, 1000, 1000), + intervals_del=(-1000000, -1e-2, 1000) + ) + + """""" + d.bins = p.intervals[1:-1] + d.s, d.interval_sizes = get_midpoints_and_spacing(d.bins) + d.n_intervals = len(d.interval_sizes) + """""" + + params = {'S1': 0.25, 'S2': 0.35, 'S3': 0.2, 'S4': 0.1, 'S5': 0.05, 'S6': 0.05} + + d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) + d2 = p.get_cdf(**params)(d.s) + + plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='empirical CDF') + plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='exact CDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + assert np.max(np.abs(d1 - d2)) < 0.005 + + def test_compare_pdf_vs_discretized_cdf_discretized_parametrization(self): + """""" + Compare PDF vs discretized CDF for DiscreteParametrization. + """""" + p = DiscreteParametrization() + + d = Discretization( + n=self.n, + intervals_ben=(1e-2, 1000, 1000), + intervals_del=(-1000000, -1e-2, 1000) + ) + + """""" + d.bins = p.intervals[1:-1] + d.s, d.interval_sizes = get_midpoints_and_spacing(d.bins) + d.n_intervals = len(d.interval_sizes) + """""" + + params = {'S1': 0.25, 'S2': 0.35, 'S3': 0.2, 'S4': 0.1, 'S5': 0.05, 'S6': 0.05} + + d1 = p.get_pdf(**params)(d.s) + d2 = p._discretize(params, d.bins) / d.interval_sizes + + plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') + plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + assert np.max(np.abs(d1 - d2)[d.s != 0]) < 1e-12 + + def test_compare_exact_vs_empirical_cdf_discretized_fractional_parametrization(self): + """""" + Compare exact vs empirical CDF for DiscreteParametrization + """""" + p = DiscreteFractionalParametrization() + + d = Discretization( + n=self.n, + intervals_ben=(1e-2, 1000, 1000), + intervals_del=(-1000000, -1e-2, 1000) + ) + + params = {'S1': 0.5, 'S2': 0.5, 'S3': 0.5, 'S4': 0.9, 'S5': 0.3} + + d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) + d2 = p.get_cdf(**params)(d.s) + + plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='empirical CDF') + plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='exact CDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + assert np.max(np.abs(d1 - d2)) < 0.005 + + def test_compare_pdf_vs_discretized_cdf_discretized_fractional_parametrization(self): + """""" + Compare PDF vs discretized CDF for DiscreteParametrization. + """""" + p = DiscreteFractionalParametrization() + + d = Discretization( + n=self.n, + intervals_ben=(1e-2, 1000, 1000), + intervals_del=(-1000000, -1e-2, 1000) + ) + + params = {'S1': 0.5, 'S2': 0.5, 'S3': 0.5, 'S4': 0.9, 'S5': 0.3} + + d1 = p.get_pdf(**params)(d.s) + d2 = p._discretize(params, d.bins) / d.interval_sizes + + plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') + plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + assert np.max(np.abs(d1 - d2)[d.s != 0]) < 1e-12 + + def test_compare_exact_vs_empirical_cdf_gamma_discrete(self): + """""" + Compare exact vs empirical CDF for GammaDiscreteParametrization. + """""" + p = GammaDiscreteParametrization() + params = GammaDiscreteParametrization.x0 + d = Discretization( + n=self.n, + intervals_ben=(1e-15, 100, 1000), + intervals_del=(-100000, -1e-15, 1000) + ) + + d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) + d2 = p.get_cdf(**params)(d.s) + + plt.plot(d.s, d1, alpha=0.5, label='empirical CDF') + plt.plot(d.s, d2, alpha=0.5, label='exact CDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + diff = np.max(np.abs(d1 - d2)) + + assert diff < 0.05 + + def test_compare_pdf_vs_discretized_cdf_gamma_discrete(self): + """""" + Compare PDF vs discretized CDF for GammaDiscreteParametrization. + """""" + p = GammaDiscreteParametrization() + d = Discretization( + n=self.n, + intervals_ben=(1e-15, 100, 1000), + intervals_del=(-100000, -1e-15, 1000) + ) + + params = GammaDiscreteParametrization.x0 + + d1 = p.get_pdf(**params)(d.s) * d.interval_sizes + d2 = p._discretize(params, d.bins) + + plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') + plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + diff = np.max(np.abs(d1 - d2)) + + # discrete CDF produces a large point mass + assert diff < 0.001 + + def test_compare_exact_vs_empirical_cdf_displaced_gamma(self): + """""" + Compare exact vs empirical CDF for DisplacedGammaParametrization. + """""" + p = DisplacedGammaParametrization() + params = DisplacedGammaParametrization.x0 + d = Discretization( + n=self.n, + intervals_ben=(1e-15, 100, 1000), + intervals_del=(-100000, -1e-15, 1000) + ) + + d1 = np.cumsum(p.get_pdf(**params)(d.s) * d.interval_sizes) + d2 = p.get_cdf(**params)(d.s) + + plt.plot(d.s, d1, alpha=0.5, label='empirical CDF') + plt.plot(d.s, d2, alpha=0.5, label='exact CDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + diff = np.max(np.abs(d1 - d2)) + + assert diff < 0.05 + + def test_compare_pdf_vs_discretized_cdf_displaced_gamma(self): + """""" + Compare PDF vs discretized CDF for DisplacedGammaParametrization. + """""" + p = DisplacedGammaParametrization() + d = Discretization( + n=self.n, + intervals_ben=(1e-15, 100, 1000), + intervals_del=(-100000, -1e-15, 1000) + ) + + params = DisplacedGammaParametrization.x0 + + d1 = p.get_pdf(**params)(d.s) * d.interval_sizes + d2 = p._discretize(params, d.bins) + + plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='exact PDF') + plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='empirical PDF') + + plt.title(p.__class__.__name__) + plt.legend() + plt.show() + + diff = np.max(np.abs(d1 - d2)) + + # discrete CDF produces a large point mass + assert diff < 2e-4 + + def test_run_inference_discrete_parametrization(self): + """""" + Test that inference runs without error for DiscreteParametrization. + """""" + config = Config.from_file(self.config_file) + + config.update( + model=DiscreteParametrization(), + do_bootstrap=True, + parallelize=False + ) + + inf = BaseInference.from_config(config) + + inf.run() + + inf.plot_continuous() + inf.plot_discretized() + + def test_run_inference_discrete_fractional_parametrization(self): + """""" + Test that inference runs without error for DiscreteParametrization. + """""" + config = Config.from_file(self.config_file) + + config.update( + model=DiscreteFractionalParametrization(), + do_bootstrap=True, + parallelize=False + ) + + inf = BaseInference.from_config(config) + + inf.run() + + inf.plot_continuous() + inf.plot_discretized() + + def test_run_inference_gamma_exp_parametrization(self): + """""" + Test that inference runs without error for GammaExpParametrization. + """""" + config = Config.from_file(self.config_file) + + config.update( + model=GammaExpParametrization(), + do_bootstrap=True, + parallelize=False + ) + + inf = BaseInference.from_config(config) + + inf.run() + + inf.plot_continuous() + inf.plot_discretized() + + def test_run_inference_gamma_discrete_parametrization(self): + """""" + Test that inference runs without error for GammaDiscreteParametrization. + """""" + config = Config.from_file(self.config_file) + + config.update( + model=GammaDiscreteParametrization(), + do_bootstrap=True, + parallelize=False + ) + + inf = BaseInference.from_config(config) + + inf.run() + + inf.plot_continuous() + inf.plot_discretized() + + def test_run_inference_displaced_gamma_parametrization(self): + """""" + Test that inference runs without error for DisplacedGammaParametrization. + """""" + config = Config.from_file(self.config_file) + + config.update( + model=DisplacedGammaParametrization(), + do_bootstrap=True, + parallelize=False + ) + + inf = BaseInference.from_config(config) + + inf.run() + + inf.plot_continuous() + inf.plot_discretized() + + def test_plot_pdf(self): + """""" + Test that plotting the PDF works. + """""" + model = GammaExpParametrization() + + Visualization.plot_pdf(model, model.x0, s=np.linspace(-100, 100, 1000)) + + def test_plot_cdf(self): + """""" + Test that plotting the CDF works. + """""" + model = GammaExpParametrization() + + Visualization.plot_cdf(model, model.x0, s=np.linspace(-100, 100, 1000)) + + def test_to_nominal_to_fractional_are_inverse_functions(self): + """""" + Test that to_nominal and to_fractional are inverse functions. + """""" + params = {'S1': 0.5, 'S2': 0.5, 'S3': 0.5, 'S4': 0.9, 'S5': 0.3} + p = DiscreteFractionalParametrization() + + observed = p.to_fractional(p.to_nominal(params)) + observed.pop('S6') + + assert observed == params + + def test_plot_parametrization(self): + """""" + Test that plotting the parametrization works. + """""" + GammaExpParametrization().plot( + params=GammaExpParametrization.x0 + ) + + def test_deleterious_submodel_discrete_parametrization(self): + """""" + Test that deleterious submodel works for DiscreteParametrization. + """""" + for inv in [ + np.array([-100000, -100, -10, -1, 0, 1, 1000]), + np.array([-100000, -1, 0, 1, 10, 1000]) + ]: + p = DiscreteFractionalParametrization(intervals=inv) + + y = p.get_pdf( + **(p.x0 | p.submodels['dele']) + )(np.linspace(0.00001, 1000, 100)) + + self.assertEqual(np.sum(y), 0) + + y = p.get_pdf( + **(p.x0) + )(np.linspace(0.00001, 1000, 100)) + + self.assertGreater(np.sum(y), 0) + + def test_dfe_cdf_pdf(self): + """""" + Test that DFE CDF works for all parametrizations. + """""" + p = GammaExpParametrization() + dfe = p.freeze(p.x0) + + s = np.linspace(*p.bounds['S_d'], 1000) + + y1 = p.get_cdf(**p.x0)(s) + y2 = dfe.cdf(s) + + np.testing.assert_array_equal(y1, y2) + + y1 = p.get_pdf(**p.x0)(s) + y2 = dfe.pdf(s) + + np.testing.assert_array_equal(y1, y2) + + def test_custom_bounds(self): + """""" + Test that custom bounds work as expected. + """""" + self.assertDictEqual( + GammaExpParametrization(bounds=dict(p_b=(0.1, 0.9))).bounds, + GammaExpParametrization.bounds | dict(p_b=(0.1, 0.9)) + ) + + # make sure original class variable is not modified + self.assertTupleEqual( + GammaExpParametrization.bounds['p_b'], + (0.0, 0.5) + ) + + self.assertTupleEqual( + DiscreteParametrization(bounds=dict(S1=(0.1, 0.9))).bounds['S1'], + (0.1, 0.9) + ) + + self.assertTupleEqual( + DiscreteParametrization().bounds['S1'], + (0.0, 1.0) + ) + + def test_dfe_serialization(self): + """""" + Test that DFE serialization works for all parametrizations. + """""" + dfe = GammaExpParametrization().freeze(GammaExpParametrization.x0) + dfe.to_file(""scratch/gamma_exp_dfe.json"") + dfe2 = fd.DFE.from_file(""scratch/gamma_exp_dfe.json"") + + self.assertDictEqual(dfe.params, dfe2.params) +","Python" +"Allele","Sendrowski/fastDFE","testing/__init__.py",".py","1891","75",""""""" +Initialization for the testing module. +"""""" +import logging +import os +import sys +from pathlib import Path +from unittest import TestCase as BaseTestCase + +import matplotlib +import numpy as np +import pytest +from matplotlib import pyplot as plt + + +def prioritize_installed_packages(): + """""" + This function prioritizes installed packages over local packages. + """""" + # Get the current working directory + cwd = str(Path().resolve()) + + # Check if the current working directory is in sys.path + if cwd in sys.path: + # Remove the current working directory from sys.path + sys.path = [p for p in sys.path if p != cwd] + # Append the current working directory to the end of sys.path + sys.path.append(cwd) + + +# run before importing fastdfe +prioritize_installed_packages() + +import fastdfe + +logger = logging.getLogger('fastdfe') + +logger.info(sys.version) +logger.info(f""Running tests for {fastdfe.__file__}"") +logger.info(f""fastdfe version: {fastdfe.__version__}"") + +# only show plots when running in PyCharm +if 'PYCHARM_HOSTED' not in os.environ: + matplotlib.use('Agg') + #fastdfe.Settings.disable_pbar = True + #logger.setLevel(logging.WARNING) +else: + logger.setLevel(logging.INFO) + +# check for PARALLELIZE environment variable +if 'PARALLELIZE' in os.environ and os.environ['PARALLELIZE'].lower() == 'false': + fastdfe.Settings.parallelize = False + logger.info(""Parallelization disabled."") + +# create scratch directory if it doesn't exist +if not os.path.exists('scratch'): + os.makedirs('scratch') + + +class TestCase(BaseTestCase): + @pytest.fixture(autouse=True) + def cleanup(self): + """""" + + """""" + yield + plt.close('all') + + @staticmethod + def rel_diff(a, b, eps=1e-12): + """""" + Compute the relative difference between a and b. + """""" + return np.abs(a - b) / (np.abs(a) + np.abs(b) + eps) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_simulation.py",".py","16397","466",""""""" +Test the Simulation class. +"""""" +import re +from itertools import product + +import numpy as np +import pytest +from matplotlib import pyplot as plt + +import fastdfe as fd +from testing import TestCase + + +def expand(template, **wildcards): + """""" + Generate combinations of strings with placeholders. + """""" + keys, values = zip(*wildcards.items()) + combinations = product(*values) + + return [template.format(**dict(zip(keys, combo))) for combo in combinations] + + +class SLiMTestCase(TestCase): + """""" + Test results against cached SLiM results. + """""" + + # configs for testing against cached slim results + configs_slim = expand( # deleterious DFE + ""testing/cache/slim/n_replicate=1/n_chunks={n_chunks}/g=1e4/L={L}/mu={mu}/r=1e-7/N=1e3/s_b={s_b}/b={b}/s_d={s_d}/p_b={p_b}/n={n}/{folded}/sfs.csv"", + n_chunks=[100], + L=[""1e7""], + mu=[""1e-8""], + s_b=[""1e-9""], + b=[3, 1, 0.3], + s_d=[""3e-3"", ""3e-2"", ""3e-1""], + p_b=[0], + folded=[""folded"", ""unfolded""], + n=[20, 100] + ) + expand( # full DFE + ""testing/cache/slim/n_replicate=1/n_chunks={n_chunks}/g=1e4/L={L}/mu={mu}/r=1e-7/N=1e3/s_b={s_b}/b={b}/s_d={s_d}/p_b={p_b}/n={n}/{folded}/sfs.csv"", + n_chunks=[40], + L=[""1e7""], + mu=[""1e-8""], + s_b=[""1e-4"", ""1e-3""], + b=[0.4], + s_d=[""1e-1"", ""1e0""], + p_b=[0.01, 0.05], + folded=[""folded"", ""unfolded""], + n=[20, 100] + ) + expand( + ""testing/cache/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/{params}/n={n}/dominance_{h}/unfolded/sfs.csv"", + h=np.round(np.linspace(0.1, 1, 10), 1), + params=[ + ""s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00"", + ""s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00"", + ""s_b=1e-2/b=0.1/s_d=3e-1/p_b=0.01"", + ""s_b=1e-3/b=0.3/s_d=3e-2/p_b=0.05"" + ], + n=[20, 100] + ) + expand( + ""testing/cache/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-6/N=1e3/{params}/n={n}/dominance_0.0/unfolded/sfs.csv"", + params=[ + ""s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00"", + ""s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00"", + ""s_b=1e-2/b=0.1/s_d=3e-1/p_b=0.01"", + ""s_b=1e-3/b=0.3/s_d=3e-2/p_b=0.05"" + ], + n=[20, 100] + ) + expand( + ""testing/cache/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-6/N=1e3/{params}/n={n}/dominance_function_{k}/unfolded/sfs.csv"", + k=[0.1, 1, 10, 100], + params=[ + ""s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00"", + ""s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00"", + ""s_b=1e-2/b=0.1/s_d=3e-1/p_b=0.01"", + ""s_b=1e-3/b=0.3/s_d=3e-2/p_b=0.05"" + ], + n=[20] + ) + + def test_compare_against_slim(self): + """""" + Test parameters of inferred DFE against ground-truth from SLiM simulations. + """""" + cached = {} + + for file_path in self.configs_slim: + spectra = fd.Spectra.from_file(file_path) + + params = {} + for p in ['s_b', 's_d', 'b', 'p_b', 'mu', 'n']: + # match parameter values + match = re.search(rf""\b{p}=([\d.e+-]+)"", file_path) + if match: + params[p] = float(match.group(1)) + + if match := re.search(r""dominance_([\d.]+)"", file_path): + params['h'] = float(match.group(1)) + + Ne = spectra['neutral'].theta / (4 * params['mu']) + params['S_b'] = 4 * Ne * params['s_b'] + params['S_d'] = -4 * Ne * params['s_d'] + + model = fd.GammaExpParametrization() + model.bounds['S_b'] = (1e-10, 100) + + sim = fd.Simulation( + params=params, + sfs_neut=spectra['neutral'], + model=model, + intervals_del=(-1.0e+8, -1.0e-5, 100), + intervals_ben=(1.0e-5, 1.0e4, 100) + ) + + # cache discretization + if sim.discretization in cached: + sim.discretization = cached[sim.discretization] + else: + cached[sim.discretization] = sim.discretization + + sfs_sel = sim.run() + comp = fd.Spectra(dict(slim=spectra['selected'], fastdfe=sfs_sel)) + + diff_rel = (comp['slim'].data[:-1] - comp['fastdfe'].data[:-1]) / comp['slim'].data[:-1] + + # exclude bins with few counts due to large variance + diff_rel[comp['slim'].data[:-1] < 20] = 0 + + # compute root mean squared error + diff = np.sqrt((diff_rel ** 2).mean()) + tol = 0.16 # 0.125 with default discretization bins + + if diff < tol: + fd.logger.info(f""{diff:.3f} < {tol} for {params}"") + else: + fd.logger.fatal(f""{diff:.3f} >= {tol} for {params}"") + + self.assertLess(diff, tol) + + +class SimulationTestCase(TestCase): + """""" + Test the Simulation class. + """""" + + def test_get_neutral_sfs(self): + """""" + Test the get_neutral_sfs method. + """""" + theta = 1e-4 + n_sites = 1e8 + n = 10 + sfs = fd.Simulation.get_neutral_sfs(theta=theta, n_sites=n_sites, n=n) + + self.assertAlmostEqual(sfs.n_sites, n_sites) + self.assertAlmostEqual(sfs.n, n) + self.assertAlmostEqual(sfs.theta, theta) + + np.testing.assert_array_almost_equal(sfs.data[1:-1], [theta * n_sites / i for i in range(1, 10)]) + + self.assertAlmostEqual(sfs.data[0], n_sites - sum(sfs.data[1:])) + self.assertAlmostEqual(sfs.data[-1], 0) + + def test_get_neutral_sfs_with_demography(self): + """""" + Test the get_neutral_sfs method with demography. + """""" + theta = 1e-4 + n_sites = 1e8 + n = 10 + r = [0.98, 1.21, 0.87, 1.43, 0.92, 1.32, 0.99, 1.12, 0.95] + sfs = fd.Simulation.get_neutral_sfs(theta=theta, n_sites=n_sites, n=n, r=r) + + self.assertAlmostEqual(sfs.n_sites, n_sites) + self.assertAlmostEqual(sfs.n, n) + + # nuisance parameters affect mutation rate + self.assertAlmostEqual(sfs.theta, theta, delta=1e-5) + + np.testing.assert_array_almost_equal(sfs.data[1:-1], [theta * n_sites / i * r[i - 1] for i in range(1, 10)]) + + self.assertAlmostEqual(sfs.data[0], n_sites - sum(sfs.data[1:])) + self.assertAlmostEqual(sfs.data[-1], 0) + + def test_get_neutral_sfs_wrong_length_r(self): + """""" + Test the get_neutral_sfs method with wrong length r. + """""" + theta = 1e-4 + n_sites = 1e8 + n = 10 + r = [1] * 10 + + with self.assertRaises(ValueError) as e: + fd.Simulation.get_neutral_sfs(theta=theta, n_sites=n_sites, n=n, r=r) + + print(e.exception) + + def test_recover_result_full_dfe_no_demography(self): + """""" + Test that the simulated result can be recovered by inference. + """""" + # very deleterious DFEs were difficult to recover + sim = fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), + params=dict(S_d=-300, b=1, p_b=0.05, S_b=0.1) + ) + + sfs_sel = sim.run() + + inf = fd.BaseInference( + sfs_sel=sfs_sel, + sfs_neut=sim.sfs_neut, + discretization=sim.discretization, + fixed_params=dict(all=dict(eps=0, h=0.5)), + do_bootstrap=True, + n_bootstraps=100, + parallelize=True + ) + + inf.run() + + self.assertAlmostEqual(sim.n_sites, inf.sfs_sel.n_sites, delta=1e-6) + self.assertAlmostEqual(sim.n_sites, inf.sfs_neut.n_sites) + + self.assertAlmostEqual(sim.theta, inf.sfs_neut.theta) + + for key in sim.params: + self.assertAlmostEqual(inf.params_mle[key], sim.params[key], delta=np.abs(sim.params[key]) / 500) + + mean = inf.bootstraps.select_dtypes(""number"").mean() + + self.assertAlmostEqual(mean['S_d'], sim.params['S_d'], delta=np.abs(sim.params['S_d']) / 10) + self.assertAlmostEqual(mean['b'], sim.params['b'], delta=np.abs(sim.params['b']) / 10) + self.assertAlmostEqual(mean['p_b'], sim.params['p_b'], delta=np.abs(sim.params['p_b']) / 8) + self.assertAlmostEqual(mean['S_b'], sim.params['S_b'], delta=np.abs(sim.params['S_b']) * 3) + + self.assertAlmostEqual(mean['eps'], 0, delta=1e-3) + + def test_recover_result_full_dfe_with_demography(self): + """""" + Test that the simulated result can be recovered by inference. + """""" + sim = fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs( + n=20, + n_sites=1e8, + theta=1e-4, + r=[0.98, 1.21, 0.87, 1.43, 0.92, 1.32, 0.99, + 1.12, 0.95, 1.21, 0.87, 1.43, 0.92, + 0.99, 1.12, 0.95, 1.21, 0.87, 1.43] + ), + params=dict(S_d=-300, b=1, p_b=0.05, S_b=0.1) + ) + + sfs_sel = sim.run() + + inf = fd.BaseInference( + sfs_sel=sfs_sel, + sfs_neut=sim.sfs_neut, + discretization=sim.discretization, + fixed_params=dict(all=dict(eps=0, h=0.5)), + do_bootstrap=True, + n_bootstraps=100, + parallelize=True + ) + + inf.run() + + self.assertAlmostEqual(sim.n_sites, inf.sfs_sel.n_sites, delta=1e-6) + self.assertAlmostEqual(sim.n_sites, inf.sfs_neut.n_sites) + + self.assertAlmostEqual(sim.theta, inf.sfs_neut.theta) + + for key in sim.params: + self.assertAlmostEqual(inf.params_mle[key], sim.params[key], delta=np.abs(sim.params[key]) / 100) + + mean = inf.bootstraps.select_dtypes(""number"").mean() + + self.assertAlmostEqual(mean['S_d'], sim.params['S_d'], delta=np.abs(sim.params['S_d']) / 8) + self.assertAlmostEqual(mean['b'], sim.params['b'], delta=np.abs(sim.params['b']) / 10) + self.assertAlmostEqual(mean['p_b'], sim.params['p_b'], delta=np.abs(sim.params['p_b']) / 5) + self.assertAlmostEqual(mean['S_b'], sim.params['S_b'], delta=np.abs(sim.params['S_b']) * 3) + + self.assertAlmostEqual(inf.bootstraps['eps'].mean(), 0, delta=1e-3) + + def test_recover_result_deleterious_dfe_no_demography(self): + """""" + Test that the simulated result can be recovered by inference. + """""" + sim = fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), + params=dict(S_d=-300, b=1, p_b=0, S_b=0.1) + ) + + sfs_sel = sim.run() + + inf = fd.BaseInference( + sfs_sel=sfs_sel, + sfs_neut=sim.sfs_neut, + discretization=sim.discretization, + fixed_params=dict(all=dict(p_b=0, S_b=0.1, h=0.5, eps=0)), + do_bootstrap=True, + n_bootstraps=100, + parallelize=True + ) + + inf.run() + + self.assertAlmostEqual(sim.n_sites, inf.sfs_sel.n_sites) + self.assertAlmostEqual(sim.n_sites, inf.sfs_neut.n_sites) + + self.assertAlmostEqual(sim.theta, inf.sfs_neut.theta) + + for key in sim.params: + self.assertAlmostEqual(inf.params_mle[key], sim.params[key], delta=np.abs(sim.params[key]) / 1000) + + self.assertAlmostEqual(inf.bootstraps['S_d'].mean(), sim.params['S_d'], delta=10) + self.assertAlmostEqual(inf.bootstraps['b'].mean(), sim.params['b'], delta=0.1) + self.assertAlmostEqual(inf.bootstraps['eps'].mean(), 0, delta=1e-3) + + self.assertAlmostEqual(inf.bootstraps['p_b'].mean(), 0) + self.assertAlmostEqual(inf.bootstraps['S_b'].mean(), 0.1) + + def test_usage_example_simulation_class(self): + """""" + Test the usage example of the Simulation class. + """""" + import fastdfe as fd + + # create simulation object by specifying neutral SFS and DFE + sim = fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), + params=dict(S_d=-300, b=0.3, p_b=0.1, S_b=0.1), + model=fd.GammaExpParametrization() + ) + + # perform the simulation + sfs_sel = sim.run() + + # plot SFS + sfs_sel.plot() + + def test_parameter_out_of_bounds(self): + """""" + Test that the simulation of a neutral DFE with the Wright-Fisher model is correct. + """""" + with self.assertRaises(ValueError) as e: + fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=10, n_sites=1e8, theta=1e-4), + params=dict(S_d=0, b=1, p_b=0, S_b=1), + ) + + print(e.exception) + + def test_wright_fisher_simulation_sample_cdf(self): + """""" + Test that the sample_cdf method of the Wright-Fisher model is correct. + """""" + sim = fd.simulation.WrightFisherSimulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), + params=dict(S_d=-300, b=10, p_b=0.1, S_b=50), + ) + + samples = sim._sample_cdf(n=1000) + + ax = plt.gca() + ax.hist(samples, bins=100, density=True, alpha=0.5) + x = np.linspace(-1000, 300, 1000) + ax.plot(x, sim.model.get_pdf(**sim.params)(x), color='red') + ax.set_xlim(-1000, 300) + plt.show() + + self.assertAlmostEqual(samples.mean(), -300 * 0.9 + 50 * 0.1, delta=10) + + def test_simulation_wright_fisher_usage_example(self): + """""" + Test the usage example of the WrightFisherSimulation class. + """""" + # create simulation object by specifying neutral SFS and DFE + sim = fd.simulation.WrightFisherSimulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=int(1e7), theta=1e-4), + params=dict(S_d=-300, b=0.3, p_b=0.1, S_b=0.1), + model=fd.GammaExpParametrization(), + pop_size=100, + n_generations=500 + ) + + # perform the simulation + sfs_sel = sim.run() + + # plot SFS + sfs_sel.plot() + + @pytest.mark.skip(reason=""takes too long for reasonable values"") + def test_simulation_against_wright_fisher_neutral(self): + """""" + Test that the simulation of a neutral DFE with the Wright-Fisher model is correct. + """""" + sim = fd.simulation.WrightFisherSimulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=10, n_sites=1e8, theta=1e-6), + params=dict(S_d=-1e-100, b=1, p_b=0, S_b=1), + n_generations=1000, + pop_size=100 + ) + + sfs_sel = sim.run() + + sfs_sel.plot() + + self.assertAlmostEqual(sfs_sel.n_sites, sim.sfs_neut.n_sites) + self.assertAlmostEqual(sfs_sel.n, sim.sfs_neut.n) + self.assertAlmostEqual(sfs_sel.theta, sim.sfs_neut.theta) + + fd.Spectra(dict(neutral=sim.sfs_neut, selected=sfs_sel)).plot() + + np.testing.assert_array_almost_equal(sfs_sel.data, sim.sfs_neut.data) + + @pytest.mark.skip(reason=""takes too long for reasonable values"") + def test_simulation_against_wright_fisher_deleterious(self): + """""" + Test that the simulation of a neutral DFE with the Wright-Fisher model is correct. + """""" + fd.logger.setLevel('DEBUG') + + sim = fd.simulation.WrightFisherSimulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=10, n_sites=1e8, theta=1e-6), + params=dict(S_d=-100, b=1, p_b=0, S_b=1), + n_generations=100, + pop_size=100 + ) + + sfs_sel = sim.run() + + sfs_sel.plot() + + def test_get_alpha(self): + """""" + Test the get_alpha method. + """""" + alphas = [] + for h in np.linspace(0, 1, 11): + sim = fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), + params=dict(S_d=-300, b=0.3, p_b=0.05, S_b=0.1, h=h) + ) + + alphas.append(sim.get_alpha()) + + # make sure order is ascending + self.assertTrue(np.all(np.diff(alphas) >= 0)) + + self.assertEqual(fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), + params=dict(S_d=-300, b=0.3, p_b=0, S_b=0.1, h=h) + ).get_alpha(), 0) + + self.assertAlmostEqual(fd.Simulation( + model=fd.GammaExpParametrization(bounds=dict(p_b=(0, 1))), + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), + params=dict(S_d=-300, b=0.3, p_b=1, S_b=0.1, h=h) + ).get_alpha(), 1, delta=1e-3) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_bootstrap.py",".py","3876","127","import numpy as np +from scipy import stats + +from fastdfe.bootstrap import Bootstrap +from testing import TestCase + + +class BootstrapTestCase(TestCase): + """""" + Test the Bootstrap class. + """""" + + def test_ci_percentile(self): + x = np.arange(100) + + cis = Bootstrap.get_ci_percentile(x, 0.05) + + assert cis == (5, 95) + + def test_ci_bca(self): + x = np.arange(100) + + cis = Bootstrap.get_ci_bca(x, 50, 0.05) + + assert cis == (5, 95) + + @staticmethod + def get_cis(ci_level, values): + """""" + + :param ci_level: + :param values: + :return: + """""" + # calculate the sample mean and standard error + sample_mean = np.mean(values) + standard_error = np.std(values) + + # determine the z-score for the chosen confidence level + z_score = stats.norm.ppf(1 - ci_level) + + # calculate the margin of error + margin_of_error = z_score * standard_error + + # calculate the confidence interval + lower_bound = sample_mean - margin_of_error + upper_bound = sample_mean + margin_of_error + + return lower_bound, upper_bound + + def compare_cis(self, values): + """""" + + :param values: + """""" + # set the confidence level + ci_level = 0.05 + + # create synthetic data + original = np.mean(values) + + lower_bound, upper_bound = self.get_cis(ci_level, values) + + # calculate errors and confidence intervals using the get_errors function + _, errors_perc, cis_perc = Bootstrap.get_errors([original], np.array([values]).T, ci_level, 'percentile') + _, errors_bca, cis_bca = Bootstrap.get_errors([original], np.array([values]).T, ci_level, 'bca') + + assert np.abs(lower_bound - cis_perc[0][0]) / lower_bound < 0.005 + assert np.abs(upper_bound - cis_perc[1][0]) / upper_bound < 0.005 + + assert np.abs(lower_bound - cis_bca[0][0]) / lower_bound < 0.005 + assert np.abs(upper_bound - cis_bca[1][0]) / upper_bound < 0.005 + + def test_get_errors_percentile_positive(self): + """""" + Test the get_errors function for positive values. + """""" + np.random.seed(42) + self.compare_cis(np.random.normal(5, 2, size=100000)) + + def test_get_errors_percentile_negative(self): + """""" + Test the get_errors function for negative values. + """""" + np.random.seed(42) + self.compare_cis(-np.random.normal(5, 2, size=100000)) + + def test_get_errors_percentile_positive_and_negative(self): + """""" + Test the get_errors function for positive and negative values. + """""" + np.random.seed(42) + self.compare_cis(np.random.normal(0, 2, size=100000)) + + def test_get_bounds_from_quantile_is_nan_return_nones(self): + """""" + Test get_bounds_from_quantile when data is nan. + """""" + bounds = Bootstrap.get_bounds_from_quantile([2, 2, 2], np.nan, np.nan, 3) + + self.assertEqual(tuple(bounds), (None, None)) + + def test_get_ci_percentile_invalid_a_raises_value_error(self): + """""" + Test get_ci_percentile when a is invalid. + """""" + with self.assertRaises(ValueError): + Bootstrap.get_ci_percentile([1, 2, 3], 1.1) + + with self.assertRaises(ValueError): + Bootstrap.get_ci_percentile([1, 2, 3], -0.1) + + def test_get_errors_invalid_bootstrap_type_raises_not_implemented_error(self): + """""" + Test get_errors when bootstrap_type is invalid. + """""" + with self.assertRaises(NotImplementedError): + Bootstrap.get_errors([1, 2, 3], np.array([[1, 2, 3]]), bootstrap_type='invalid') + + def test_get_ci_bca_no_data_return_zeros(self): + """""" + Test get_ci_bca when bootstraps is empty. + """""" + bounds = Bootstrap.get_ci_bca([], 1, 0.05) + + self.assertEqual(bounds, [0, 0]) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_base_inference.py",".py","49322","1400","import copy +import logging +import resource +import time +from abc import ABC +from unittest import mock + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import pytest +from numpy.random._generator import Generator +from pandas.testing import assert_frame_equal +from scipy.optimize import OptimizeResult + +import fastdfe as fd +from fastdfe.discretization import Discretization +from fastdfe.polydfe import PolyDFE +from testing import TestCase + + +class InferenceTestCase(TestCase, ABC): + """""" + Test inference. + """""" + + def assertEqualObjects(self, obj1: object, obj2: object, ignore_keys=[]): + """""" + Compare objects, recursively comparing their attributes. + + :param obj1: First object + :param obj2: Second object + :param ignore_keys: Keys to ignore + """""" + ignore_keys += ['_logger'] + + if not hasattr(obj1, '__dict__'): + self.assertEqual(obj1, obj2) + else: + + d1 = obj1.__dict__ + d2 = obj2.__dict__ + + for (key1, value1), (key2, value2) in zip(d1.items(), d2.items()): + if key1 in ignore_keys: + pass + + elif isinstance(value1, OptimizeResult): + pass + + elif isinstance(value1, dict): + self.assertEqual(value1.keys(), value2.keys()) + + for k in value1.keys(): + self.assertEqualObjects(value1[k], value2[k], ignore_keys=ignore_keys) + + elif isinstance(value1, (int, float, str, bool, tuple, list, type(None), np.bool_)): + self.assertEqual(value1, value2) + + elif isinstance(value1, np.ndarray): + np.testing.assert_equal(value1, value2) + + elif isinstance(value1, pd.DataFrame): + pd.testing.assert_frame_equal(value1.reset_index(drop=True), value2.reset_index(drop=True)) + + elif isinstance(value1, Generator): + pass + + elif isinstance(value1, fd.Spectrum): + np.testing.assert_equal(value1.to_list(), value2.to_list()) + + elif isinstance(value1, object): + self.assertEqualObjects(value1, value2, ignore_keys=ignore_keys) + + else: + raise AssertionError('Some objects were not compared.') + + +class PolyDFETestCase(InferenceTestCase): + """""" + Test results against cached PolyDFE results. + """""" + + # configs for testing against cached polydfe results + configs_polydfe = [ + 'pendula_C_full_bootstrapped_100', + 'pendula_C_full_anc_bootstrapped_100', + 'pendula_C_deleterious_bootstrapped_100', + 'pendula_C_deleterious_anc_bootstrapped_100', + 'pubescens_C_full_bootstrapped_100', + 'pubescens_C_full_anc_bootstrapped_100', + 'pubescens_C_deleterious_bootstrapped_100', + 'pubescens_C_deleterious_anc_bootstrapped_100', + 'example_1_C_full_bootstrapped_100', + 'example_1_C_full_anc_bootstrapped_100', + # 'example_1_C_deleterious_bootstrapped_100' # polydfe does not finish in this case + 'example_1_C_deleterious_anc_bootstrapped_100', + 'example_2_C_full_bootstrapped_100', + 'example_2_C_full_anc_bootstrapped_100', + 'example_2_C_deleterious_bootstrapped_100', + 'example_2_C_deleterious_anc_bootstrapped_100', + 'example_3_C_full_bootstrapped_100', + 'example_3_C_full_anc_bootstrapped_100', + 'example_3_C_deleterious_bootstrapped_100', + 'example_3_C_deleterious_anc_bootstrapped_100' + ] + + def compare_with_polydfe(self, config: str): + """""" + Test whether the results are similar to those of PolyDFE. + """""" + conf = fd.Config.from_file(f""testing/cache/configs/{config}/config.yaml"") + conf.data['fixed_params']['all']['h'] = 0.5 + inf_polydfe = PolyDFE.from_file(f""testing/cache/polydfe/{config}/serialized.json"") + + inf_fastdfe = fd.BaseInference.from_config(conf) + inf_fastdfe.run() + + # compare discretized DFE + dfe_fastdfe = inf_fastdfe.get_discretized() + dfe_polydfe = inf_polydfe.get_discretized() + + ci_fastdfe = np.array([dfe_fastdfe[0] - dfe_fastdfe[1][0], dfe_fastdfe[0] + dfe_fastdfe[1][1]]) + ci_polydfe = np.array([dfe_polydfe[0] - dfe_polydfe[1][0], dfe_polydfe[0] + dfe_polydfe[1][1]]) + + plt.clf() + _, axs = plt.subplots(1, 2, figsize=(10, 4)) + inf_fastdfe.plot_discretized(ax=axs[0], show=False, title='fastdfe') + inf_polydfe.plot_discretized(ax=axs[1], show=True, title='polydfe') + + # assert that the confidence intervals almost overlap + assert np.all(ci_fastdfe[0] <= ci_polydfe[1] + 0.05) + assert np.all(ci_polydfe[0] <= ci_fastdfe[1] + 0.05) + + @staticmethod + def generate_compare_with_polydfe(config: str) -> callable: + """""" + Generate test for comparing with PolyDFE. + """""" + + def compare_with_polydfe(self): + """""" + Compare with PolyDFE. + + :param self: Self + """""" + self.compare_with_polydfe(config) + + return compare_with_polydfe + + # dynamically generate tests + for config in configs_polydfe: + locals()[f'test_compare_with_polydfe_{config}'] = generate_compare_with_polydfe(config) + + +class BaseInferenceTestCase(InferenceTestCase): + """""" + Test BaseInference. + """""" + config_file = ""testing/cache/configs/pendula_C_full_anc/config.yaml"" + serialized = ""testing/cache/fastdfe/pendula_C_full_anc/serialized.json"" + + def test_run_inference_from_config_parallelized(self): + """""" + Run inference from config file. + """""" + config = fd.Config.from_file(self.config_file) + config.update(parallelize=True) + + inf = fd.BaseInference.from_config(config) + inf.run() + + # make sure the likelihood is the maximum of the runs + self.assertEqual(inf.likelihood, inf.runs.likelihood.max()) + + def test_run_inference_from_config_not_parallelized(self): + """""" + Run inference from config file. + """""" + config = fd.Config.from_file(self.config_file) + config.update(parallelize=False) + + inf = fd.BaseInference.from_config(config) + inf.run() + + # make sure the likelihood is the maximum of the runs + self.assertEqual(inf.likelihood, inf.runs.likelihood.max()) + + def test_seeded_inference_is_deterministic_non_parallelized(self): + """""" + Check that inference is deterministic when seeded and not parallelized. + """""" + config = fd.Config.from_file(self.config_file) + + config.update( + seed=0, + do_bootstrap=True, + parallelize=False, + n_bootstraps=2 + ) + + inf = fd.BaseInference.from_config(config) + inf.run() + + inf2 = fd.BaseInference.from_config(config) + inf2.run() + + self.assertEqual(inf.params_mle, inf2.params_mle) + assert_frame_equal(inf.bootstraps, inf2.bootstraps) + + def test_seeded_inference_is_deterministic_parallelized(self): + """""" + Check that seeded inference is deterministic when parallelized. + """""" + config = fd.Config.from_file(self.config_file) + + config.update( + seed=0, + do_bootstrap=True, + parallelize=True, + n_bootstraps=2 + ) + + inference = fd.BaseInference.from_config(config) + inference.run() + + inference2 = fd.BaseInference.from_config(config) + inference2.run() + + self.assertEqual(inference.params_mle, inference2.params_mle) + assert_frame_equal(inference.bootstraps, inference2.bootstraps) + + def test_compare_inference_with_log_scales_vs_lin_scales(self): + """""" + Compare inference with log scales vs linear scales. + """""" + config = fd.Config.from_file(self.config_file) + + model = fd.GammaExpParametrization() + model.scales = dict( + S_d='log', + b='log', + p_b='lin', + S_b='log' + ) + + config.update( + model=model, + do_bootstrap=True + ) + + inference_log = fd.BaseInference.from_config(config) + inference_log.run() + + model = copy.copy(model) + model.scales = dict( + S_d='lin', + b='lin', + p_b='lin', + S_b='lin' + ) + + config.update(model=model) + inference_lin = fd.BaseInference.from_config(config) + inference_lin.run() + + fig, axs = plt.subplots(1, 2, figsize=(10, 5)) + inference_lin.plot_discretized(ax=axs[0], show=False) + inference_log.plot_discretized(ax=axs[1], show=False) + + axs[0].set_title('Linear scales') + axs[1].set_title('Log scales') + + plt.tight_layout() + plt.show() + + # get confidence intervals + cis_lin = inference_lin.get_stats_discretized()[2] + cis_log = inference_log.get_stats_discretized()[2] + + # assert that the confidence intervals overlap + assert np.all(cis_lin[0] < cis_log[1]) + assert np.all(cis_log[0] < cis_lin[1]) + + # likelihood on log scales should be better + assert inference_log.likelihood > inference_lin.likelihood + assert inference_log.bootstraps.likelihood.mean() > inference_lin.bootstraps.likelihood.mean() + + # standard deviation of bootstrapped likelihoods should be lower on log scales + assert inference_log.bootstraps.likelihoods_std.mean() * 2 < inference_lin.bootstraps.likelihoods_std.mean() + + def test_compare_inference_with_log_scales_vs_lin_scales_tutorial(self): + """""" + Compare inference with log scales vs linear scales. + """""" + model = fd.GammaExpParametrization() + model.scales = dict( + S_d='log', + b='log', + p_b='lin', + S_b='log' + ) + + inference_log = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + fixed_params=dict(all=dict(h=0.5)), + model=model, + do_bootstrap=True, + n_runs=10 + ) + inference_log.run() + + model = fd.GammaExpParametrization() + model.scales = dict( + S_d='lin', + b='lin', + p_b='lin', + S_b='lin' + ) + + inference_lin = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + fixed_params=dict(all=dict(h=0.5)), + model=model, + do_bootstrap=True, + n_runs=10 + ) + inference_lin.run() + + fig, axs = plt.subplots(1, 2, figsize=(10, 5)) + inference_lin.plot_discretized(ax=axs[0], show=False) + inference_log.plot_discretized(ax=axs[1], show=False) + + axs[0].set_title('Linear scales') + axs[1].set_title('Log scales') + + plt.tight_layout() + plt.show() + + # get confidence intervals + cis_lin = inference_lin.get_stats_discretized()[1] + cis_log = inference_log.get_stats_discretized()[1] + + # assert that the confidence intervals overlap + # assert np.all(cis_lin[0] < cis_log[1]) + # assert np.all(cis_log[0] < cis_lin[1]) + + # likelihood on log scales should be better + assert inference_log.likelihood > inference_lin.likelihood + + # standard deviation of bootstrapped likelihoods should be lower on log scales + assert inference_log.bootstraps.likelihoods_std.mean() * 100 < inference_lin.bootstraps.likelihoods_std.mean() + + def test_restore_serialized_inference(self): + """""" + Check whether Inference can properly be serialized and restored. + """""" + inference = fd.BaseInference.from_config_file(self.config_file) + inference.run() + + serialized = 'scratch/test_serialize_inference.json' + inference.to_file(serialized) + inference_restored = fd.BaseInference.from_file(serialized) + + # self.assertEqual(inference.to_json(), inference_restored.to_json()) + self.assertEqualObjects(inference, inference_restored) + + def test_inference_run_bootstrap(self): + """""" + Run bootstrap on inference. + """""" + # unserialize + inference = fd.BaseInference.from_file(self.serialized) + + # make sure the likelihoods of the different runs are cached + self.assertEqual(len(inference.likelihoods), inference.n_runs) + + self.assertIsNone(inference.bootstraps) + + inference.bootstrap(2, parallelize=False) + + self.assertIsNotNone(inference.bootstraps) + + # make sure the likelihoods of the different runs are not overwritten + self.assertEqual(len(inference.likelihoods), inference.n_runs) + + def test_evaluate_likelihood_same_as_mle_results(self): + """""" + Check that evaluating the loss function at the MLE result + yields the same likelihood as the one reported. + """""" + # unserialize + inference = fd.BaseInference.from_file(self.serialized) + + self.assertAlmostEqual(inference.evaluate_likelihood(dict(all=inference.params_mle)), inference.likelihood) + + def test_visualize_inference_without_bootstraps(self): + """""" + Plot everything possible. + """""" + config = fd.Config.from_file(self.config_file) + + config.update( + do_bootstrap=False + ) + + inference = fd.BaseInference.from_config(config) + + inference.plot_all() + inference.plot_bucket_sizes() + + def test_visualize_inference_with_bootstraps(self): + """""" + Plot everything possible. + """""" + config = fd.Config.from_file(self.config_file) + + config.update( + do_bootstrap=True + ) + + inference = fd.BaseInference.from_config(config) + + inference.plot_all() + inference.plot_bucket_sizes() + + def test_plot_likelihoods(self): + """""" + Plot likelihoods. + """""" + # unserialize + inference = fd.BaseInference.from_file(self.serialized) + + inference.plot_likelihoods() + + def test_plot_interval_density(self): + """""" + Plot likelihoods. + """""" + # unserialize + inference = fd.BaseInference.from_file(self.serialized) + + inference.plot_interval_density() + + def test_plot_inferred_parameters(self): + """""" + Plot inferred parameters. + """""" + # unserialize + inference = fd.BaseInference.from_file(self.serialized) + + inference.plot_inferred_parameters() + + def test_plot_inferred_parameters_boxplot(self): + """""" + Plot inferred parameters. + """""" + # unserialize + inference = fd.BaseInference.from_file(self.serialized) + + inference.bootstrap(6) + + inference.plot_inferred_parameters_boxplot() + + def test_plot_observed_sfs(self): + """""" + Plot likelihoods. + """""" + # unserialize + inference = fd.BaseInference.from_file(self.serialized) + + inference.plot_observed_sfs() + + def test_plot_provide_axes(self): + """""" + Plot likelihoods. + """""" + # unserialize + inference = fd.BaseInference.from_file(self.serialized) + + _, axs = plt.subplots(ncols=2) + + inference.plot_interval_density(show=False, ax=axs[0]) + inference.plot_interval_density(ax=axs[1]) + + def test_visualize_inference_bootstrap(self): + """""" + Plot everything possible. + """""" + # unserialize + inference = fd.BaseInference.from_file(self.serialized) + + # bootstrap + inference.bootstrap(2) + + inference.plot_all() + + def test_perform_bootstrap_without_running(self): + """""" + Perform bootstrap before having run the main inference. + """""" + # unserialize + inference = fd.BaseInference.from_config_file(self.config_file) + + # bootstrap + inference.bootstrap(2) + + def test_compare_nested_with_bootstrap(self): + """""" + Compare nested likelihoods. + """""" + # unserialize + inference = fd.BaseInference.from_config_file(self.config_file) + + inference.compare_nested_models() + + inference.plot_nested_models() + inference.plot_nested_models(remove_empty=True) + inference.plot_nested_models(transpose=True) + + def test_compare_nested_different_parametrizations_raises_error(self): + """""" + Make sure that comparing nested likelihoods with different parametrizations raises an error. + """""" + config1 = fd.Config.from_file(self.config_file) + config1.update(model=fd.GammaExpParametrization()) + inf1 = fd.BaseInference.from_config(config1) + + config2 = fd.Config.from_file(self.config_file) + config2.update(model=fd.DiscreteParametrization()) + inf2 = fd.BaseInference.from_config(config2) + + with self.assertRaises(ValueError): + inf1.compare_nested(inf2) + + def test_compare_nested_different_fixed_params_raises_error(self): + """""" + Make sure that comparing nested likelihoods with different fixed parameters raises an error. + """""" + config1 = fd.Config.from_file(self.config_file) + config1.update(fixed_params=dict(all=dict(S_b=1, p_b=0))) + inf1 = fd.BaseInference.from_config(config1) + + config2 = fd.Config.from_file(self.config_file) + config2.update(fixed_params=dict(all=dict(S_b=1, eps=0))) + inf2 = fd.BaseInference.from_config(config2) + + with self.assertRaises(ValueError): + inf1.compare_nested(inf2) + + def test_compare_nested_valid_comparison_1df(self): + """""" + Make sure that comparing nested models with the same parametrization works as expected. + """""" + config1 = fd.Config.from_file(self.config_file) + config1.update(fixed_params=dict(all=dict(S_b=1, p_b=0, h=0.5)), do_bootstrap=False) + inf1 = fd.BaseInference.from_config(config1) + inf1.run() + + config2 = fd.Config.from_file(self.config_file) + config2.update(fixed_params=dict(all=dict(S_b=1, h=0.5)), do_bootstrap=False) + inf2 = fd.BaseInference.from_config(config2) + inf2.run() + + assert 0 < inf1.compare_nested(inf2) < 1 + + def test_compare_nested_valid_automatic_run(self): + """""" + Make sure that comparing nested models with the same parametrization works as expected. + """""" + config1 = fd.Config.from_file(self.config_file) + config1.update(fixed_params=dict(all=dict(S_b=1, p_b=0, h=0.5)), do_bootstrap=False) + inf1 = fd.BaseInference.from_config(config1) + + config2 = fd.Config.from_file(self.config_file) + config2.update(fixed_params=dict(all=dict(S_b=1, h=0.5)), do_bootstrap=False) + inf2 = fd.BaseInference.from_config(config2) + + assert 0 < inf1.compare_nested(inf2) < 1 + + def test_lrt_components(self): + """""" + Check whether the weights and degrees of freedom of the components are computed correctly. + """""" + inf = fd.BaseInference.from_config_file(self.config_file) + + # test weights + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=1, m=0)[0], [1]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=1, m=1)[0], [0.5, 0.5]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=1)[0], [0.5, 0.5]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=2)[0], [0.25, 0.5, 0.25]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=0)[0], [1]) + np.testing.assert_array_equal( + inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=3)[0], [0.125, 0.375, 0.375, 0.125] + ) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=2)[0], [0.25, 0.5, 0.25]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=0)[0], [1]) + + # test degrees of freedom of components + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=1, m=0)[2], [1]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=1, m=1)[2], [0, 1]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=1)[2], [1, 2]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=2)[2], [0, 1, 2]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=2, m=0)[2], [2]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=3)[2], [0, 1, 2, 3]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=2)[2], [1, 2, 3]) + np.testing.assert_array_equal(inf._lrt_components(ll_simple=50, ll_complex=51, df=3, m=0)[2], [3]) + + def test_is_nested(self): + """""" + Check whether the is_nested method works as expected. + """""" + config1 = fd.Config.from_file(self.config_file).update(fixed_params={}) + config2 = copy.deepcopy(config1).update(fixed_params={}, model=fd.DiscreteParametrization()) + config3 = copy.deepcopy(config1).update(fixed_params=dict(all=dict(eps=0))) + config4 = copy.deepcopy(config1).update(fixed_params=dict(all=dict(eps=0, S_b=1))) + config5 = copy.deepcopy(config1).update(fixed_params=dict(all=dict(eps=0)), + model=fd.DiscreteParametrization()) + + def is_nested(simple: fd.Config, complex: fd.Config) -> bool: + return fd.BaseInference.from_config(simple)._is_nested(fd.BaseInference.from_config(complex)) + + self.assertFalse(is_nested(simple=config1, complex=config2)) + self.assertFalse(is_nested(simple=config2, complex=config1)) + self.assertFalse(is_nested(simple=config1, complex=config1)) + self.assertFalse(is_nested(simple=config1, complex=config3)) + self.assertTrue(is_nested(simple=config3, complex=config1)) + self.assertTrue(is_nested(simple=config4, complex=config1)) + self.assertTrue(is_nested(simple=config4, complex=config3)) + self.assertFalse(is_nested(simple=config3, complex=config4)) + self.assertFalse(is_nested(simple=config3, complex=config5)) + self.assertFalse(is_nested(simple=config5, complex=config1)) + + def test_plot_nested_model_comparison_without_running(self): + """""" + Perform nested model comparison before having run the main inference. + We just make sure this triggers a run. + """""" + # unserialize + inference = fd.BaseInference.from_config_file(self.config_file) + + inference.plot_nested_models() + + def test_plot_nested_model_comparison_different_parametrizations(self): + """""" + Perform nested model comparison before having run the main inference. + We just make sure this triggers a run. + """""" + parametrizations = [ + fd.GammaExpParametrization(), + fd.DisplacedGammaParametrization(), + fd.DiscreteParametrization(), + fd.DiscreteFractionalParametrization(), + fd.GammaDiscreteParametrization() + ] + + for p in parametrizations: + config = fd.Config.from_file(self.config_file).update( + model=p, + do_bootstrap=True, + n_bootstraps=2, + n_runs=1, + fixed_params=dict(all=dict(h=0.5)) + ) + + # unserialize + inference = fd.BaseInference.from_config(config) + + inference.plot_nested_models(title=p.__class__.__name__) + + def test_recreate_from_config(self): + """""" + Test whether inference can be recreated from config. + """""" + inf = fd.BaseInference.from_config_file(self.config_file) + + inf2 = fd.BaseInference.from_config(inf.create_config()) + + self.assertEqualObjects(inf, inf2) + + def test_cached_result(self): + """""" + Test inference against cached result. + """""" + inf = fd.BaseInference.from_file(self.serialized) + inf2 = fd.BaseInference.from_config(inf.create_config()) + + inf2.run() + + inf_params_mle = np.array(list((inf.params_mle | {'h': 0.5}).values())) + inf2_params_mle = np.array(list(inf2.params_mle.values())) + + diff = np.abs(inf_params_mle - inf2_params_mle) / (inf_params_mle + 1e-10) + + # compare MLE parameters + self.assertLess(diff.max(), 1e-3) + + def test_run_if_necessary_wrapper_triggers_run(self): + """""" + Test whether the run_if_necessary wrapper triggers a run if the inference has not been run yet. + """""" + inference = fd.BaseInference.from_config_file(self.config_file) + + with mock.patch.object(fd.BaseInference, 'run', side_effect=Exception()) as mock_run: + try: + inference.plot_inferred_parameters(show=False) + except Exception: + pass + + mock_run.assert_called_once() + + def test_run_if_necessary_wrapper_not_triggers_run(self): + """""" + Test whether the run_if_necessary wrapper does not trigger a run if the inference has already been run. + """""" + inference = fd.BaseInference.from_file(self.serialized) + + with mock.patch.object(fd.BaseInference, 'run') as mock_run: + inference.plot_inferred_parameters(show=False) + mock_run.assert_not_called() + + def test_run_with_sfs_neut_zero_entry(self): + """""" + Test whether inference can be run with a neutral SFS that has a zero entry. + """""" + config = fd.Config.from_file(self.config_file) + + # set neutral SFS entry to zero + sfs = config.data['sfs_neut']['all'].to_list() + sfs[3] = 0 + sfs = fd.Spectrum(sfs) + config.data['sfs_neut'] = fd.Spectra.from_spectrum(sfs) + + inference = fd.BaseInference.from_config(config) + + inference.run() + + # here both the nuisance parameters and epsilon cause the high number of high-frequency variants + inference.plot_sfs_comparison() + + inference.plot_discretized() + + def test_run_with_sfs_sel_zero_entry(self): + """""" + Test whether inference can be run with a selected SFS that has a zero entry. + """""" + config = fd.Config.from_file(self.config_file) + + # set selected SFS entry to zero + sfs = config.data['sfs_sel']['all'].to_list() + sfs[3] = 0 + sfs = fd.Spectrum(sfs) + config.data['sfs_sel'] = fd.Spectra.from_spectrum(sfs) + + inference = fd.BaseInference.from_config(config) + + inference.run() + + # this looks as expected, i.e. we reduce the overall distance between the modelled and observed SFS + inference.plot_sfs_comparison() + + inference.plot_discretized() + + def test_run_with_both_sfs_zero_entry(self): + """""" + Test whether inference can be run with both SFS that have a zero entry. + """""" + config = fd.Config.from_file(self.config_file) + + # set neutral SFS entry to zero + sfs = config.data['sfs_neut']['all'].to_list() + sfs[3] = 0 + sfs = fd.Spectrum(sfs) + config.data['sfs_neut'] = fd.Spectra.from_spectrum(sfs) + + # set selected SFS entry to zero + sfs = config.data['sfs_sel']['all'].to_list() + sfs[3] = 0 + sfs = fd.Spectrum(sfs) + config.data['sfs_sel'] = fd.Spectra.from_spectrum(sfs) + + inference = fd.BaseInference.from_config(config) + + inference.run() + + # the nuisance parameters cause the zero entry in the modelled SFS + inference.plot_sfs_comparison() + + inference.plot_discretized() + + def test_fixed_parameters(self): + """""" + Test whether fixed parameters are correctly set. + """""" + config = fd.Config.from_file(self.config_file) + + config.data['fixed_params'] = dict(all=dict(b=1.123, eps=0.123, h=0.5)) + + inference = fd.BaseInference.from_config(config) + + inference.run() + + assert inference.params_mle['b'] == config.data['fixed_params']['all']['b'] + assert inference.params_mle['eps'] == config.data['fixed_params']['all']['eps'] + assert inference.params_mle['S_b'] != config.data['x0']['all']['S_b'] + assert inference.params_mle['S_d'] != config.data['x0']['all']['S_d'] + assert inference.params_mle['p_b'] != config.data['x0']['all']['p_b'] + + def test_get_n_optimized(self): + """""" + Test get number of parameters to be optimized + """""" + config = fd.Config.from_file(self.config_file) + + assert fd.BaseInference.from_config(config).get_n_optimized() == 5 + + config.data['fixed_params'] = dict(all=dict(S_b=1, p_b=0, h=0.5)) + + assert fd.BaseInference.from_config(config).get_n_optimized() == 3 + + def test_non_existing_fixed_param_raises_error(self): + """""" + Test that a non-existing fixed parameter raises an error. + """""" + config = fd.Config.from_file(self.config_file) + + config.data['fixed_params'] = dict(all=dict(S_b=1, p_b=0, foo=1)) + + with self.assertRaises(ValueError): + fd.BaseInference.from_config(config) + + def test_get_discretized_errors_with_bootstraps(self): + """""" + Get the discretized DFE errors. + """""" + inference = fd.BaseInference.from_file(self.serialized) + + inference.bootstrap() + + res = inference.get_discretized() + + def test_get_discretized_errors_no_bootstraps(self): + """""" + Get the discretized DFE errors. + """""" + inference = fd.BaseInference.from_file(self.serialized) + + values, errors = inference.get_discretized() + + assert errors is None + + def test_spectrum_with_zero_monomorphic_counts_throws_error(self): + """""" + Test whether a spectrum with zero monomorphic counts throws an error. + """""" + sfs_neut = fd.Spectrum([0, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) + sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) + + with self.assertRaises(ValueError): + fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + ) + + def test_spectrum_with_few_monomorphic_counts_raises_warning(self): + """""" + Test whether a spectrum with zero monomorphic counts throws an error. + """""" + sfs_neut = fd.Spectrum([1000, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) + sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) + + with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): + fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + ) + + @staticmethod + def test_adjust_polarization(): + """""" + Test whether polarization is adjusted correctly. + """""" + counts_list = [np.array([1, 2, 3, 4, 5]), np.array([2, 3, 5, 7, 11])] + eps_list = [0, 0.1, 0.5, 1] + + expected_counts_list = [ + [ + np.array([1, 2, 3, 4, 5]), + np.array([1.4, 2.2, 3.0, 3.8, 4.6]), + np.array([3.0, 3.0, 3.0, 3.0, 3.0]), + np.array([5, 4, 3, 2, 1]) + ], + [ + np.array([2, 3, 5, 7, 11]), + np.array([2.9, 3.4, 5, 6.6, 10.1]), + np.array([6.5, 5.0, 5.0, 5.0, 6.5]), + np.array([11, 7, 5, 3, 2]) + ] + ] + + for i, counts in enumerate(counts_list): + for j, eps in enumerate(eps_list): + adjusted_counts = fd.BaseInference._adjust_polarization(counts, eps) + assert np.isclose(np.sum(counts), np.sum(adjusted_counts)) + assert np.allclose(adjusted_counts, expected_counts_list[i][j]) + + def test_estimating_full_dfe_with_folded_sfs_raises_warning(self): + """""" + Test whether estimating the full DFE with a folded SFS raises a warning. + """""" + sfs_neut = fd.Spectrum([1, 1, 0, 0]) + sfs_sel = fd.Spectrum([1, 1, 0, 0]) + + with self.assertLogs(level=""WARNING"", logger=logging.getLogger('fastdfe')): + fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + ) + + @staticmethod + def test_folded_inference_even_sample_size(): + """""" + Test folded inference with even sample size. + """""" + sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]).fold() + sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]).fold() + + inf = fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + fixed_params=dict(all=dict(S_b=1, p_b=0, h=0.5)), + do_bootstrap=False, + ) + + inf.plot_discretized() + + @staticmethod + def test_folded_inference_odd_sample_size(): + """""" + Test folded inference with odd sample size. + """""" + sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 652]).fold() + sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 794]).fold() + + inf = fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + fixed_params=dict(all=dict(S_b=1, p_b=0, h=0.5)), + do_bootstrap=False, + ) + + inf.plot_discretized() + + pass + + def test_sample_data_fixed_result(self): + """""" + Test against fixed result. + """""" + sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) + sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) + + inf = fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + fixed_params=dict(all=dict(h=0.5)), + do_bootstrap=False, + ) + + inf.run() + + expected = { + 'S_d': -9868.141535, + 'b': 0.150810, + 'eps': 0.006854, + 'p_b': 0.0 + } + + self.assertAlmostEqual(inf.params_mle['S_d'], expected['S_d'], delta=2) + self.assertAlmostEqual(inf.params_mle['b'], expected['b'], delta=1e-2) + self.assertAlmostEqual(inf.params_mle['eps'], expected['eps'], delta=1e-3) + self.assertAlmostEqual(inf.params_mle['p_b'], expected['p_b'], delta=1e-4) + + def test_base_inference_l2_loss_type(self): + """""" + Test whether the L2 loss type is correctly set. + """""" + sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) + sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) + + inf = fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + fixed_params=dict(all=dict(h=0.5)), + loss_type='L2', + do_bootstrap=True, + n_bootstraps=5 + ) + + inf.run() + + @staticmethod + def test_few_polymorphic_sites_raises_no_error(): + """""" + Test whether a spectrum with few polymorphic sites raises no error. + """""" + inf = fd.BaseInference( + sfs_neut=fd.Spectrum([1243, 0, 0, 1, 0, 0, 0]), + sfs_sel=fd.Spectrum([12421, 0, 0, 0, 0, 1, 0]), + do_bootstrap=False, + ) + + # There are sometimes problems with the optimization for spectra like these, + # but this should be nothing to worry about + inf.run() + + inf.plot_discretized() + + pass + + def test_no_polymorphic_sites_raises_error(self): + """""" + Test whether a spectrum with zero monomorphic counts throws an error. + """""" + with self.assertRaises(ValueError) as context: + fd.BaseInference( + sfs_neut=fd.Spectrum([1243, 0, 0, 0, 0, 0, 0]), + sfs_sel=fd.Spectrum([12421, 0, 0, 0, 0, 0, 0]), + ) + + print(context.exception) + + def test_different_sfs_sample_sizes_raises_error(self): + """""" + Test whether a spectrum with zero monomorphic counts throws an error. + """""" + with self.assertRaises(ValueError) as context: + fd.BaseInference( + sfs_neut=fd.Spectrum([1000, 4, 2, 1]), + sfs_sel=fd.Spectrum([1000, 4, 2, 1, 0]) + ) + + print(context.exception) + + @staticmethod + def test_spectra_with_fractional_counts(): + """""" + Test whether a spectrum with fractional counts works as expected. + """""" + sfs_neut = fd.Spectrum([177130.4, 997.3, 441.2, 228.1, 156.45, 117.2, 114.9, 83.12, 105.453, 109.1, 652.05]) + sfs_sel = fd.Spectrum([797939.4, 1329.3, 499.2, 265.1, 162.12, 104.2, 117.9, 90.12, 94.453, 119.1, 794.05]) + + inf_float = fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + fixed_params=dict(all=dict(h=0.5)), + do_bootstrap=False, + ) + + inf_float.run() + + inf_int = fd.BaseInference( + sfs_neut=fd.Spectrum(sfs_neut.data.astype(int)), + sfs_sel=fd.Spectrum(sfs_sel.data.astype(int)), + fixed_params=dict(all=dict(h=0.5)), + do_bootstrap=False, + ) + + inf_int.run() + + fd.Inference.plot_discretized([inf_float, inf_int], labels=['float', 'int']) + + assert np.abs((inf_float.params_mle['S_d'] - inf_int.params_mle['S_d']) / inf_float.params_mle['S_d']) < 1e-2 + assert np.abs((inf_float.params_mle['b'] - inf_int.params_mle['b']) / inf_float.params_mle['b']) < 1e-2 + + @staticmethod + def test_manuscript_example(): + """""" + Test the example from the manuscript. + """""" + # create inference object + inf = fd.BaseInference( + sfs_neut=fd.Spectrum([66200, 410, 120, 60, 42, 43, 52, 65, 0]), + sfs_sel=fd.Spectrum([281937, 600, 180, 87, 51, 43, 49, 61, 0]), + model=fd.GammaExpParametrization(), # the model to use + n_runs=10, # number of optimization runs + n_bootstraps=100, # number of bootstrap replicates + do_bootstrap=True + ) + + # create subplots + axs = plt.subplots(2, 2, figsize=(11, 7))[1].flatten() + + # plot results + types = ['neutral', 'selected'] + inf.plot_sfs_comparison(ax=axs[0], show=False, sfs_types=types) + inf.plot_sfs_comparison(ax=axs[1], show=False, colors=['C1', 'C5']) + inf.plot_inferred_parameters(ax=axs[2], show=False) + inf.plot_discretized(ax=axs[3], show=True) + + def test_infer_no_selection(self): + """""" + Test whether we infer a mostly neutral DFE when there is no selection. + """""" + sfs = fd.Spectrum.standard_kingman(10, n_monomorphic=100) + + # use different scalings which should not affect the result + for m in [1, 10, 0.1, sfs]: + inf = fd.BaseInference( + sfs_neut=sfs * m, + sfs_sel=sfs * m, + fixed_params=dict(all=dict(h=0.5)), + do_bootstrap=False, + seed=42, + model=fd.DiscreteFractionalParametrization( + intervals=np.array([-100000, -0.1, 0.1, 10000]) + ) + ) + + inf.run() + + # check that DFE is very neutral + self.assertAlmostEqual(1, inf.get_discretized(intervals=np.array([-100000, -0.1, 0.1, 10000]))[0][1]) + + def test_infer_strongly_beneficial_selection_target_sites(self): + """""" + Test whether we infer a strongly beneficial DFE when there is strong selection. + """""" + # use different mutational target sizes + inf = fd.BaseInference( + sfs_neut=fd.Spectrum.standard_kingman(10, n_monomorphic=100), + sfs_sel=fd.Spectrum.standard_kingman(10, n_monomorphic=10), + fixed_params=dict(all=dict(h=0.5)), + do_bootstrap=False, + seed=42 + ) + + inf.run() + + # check that DFE is very weakly beneficial + self.assertGreaterEqual(inf.get_discretized()[0][-1], 0.4) + + def test_infer_strongly_deleterious_selection_target_sites(self): + """""" + Test whether we infer a strongly deleterious DFE when there is strong selection. + """""" + # use different mutational target sizes + inf = fd.BaseInference( + sfs_neut=fd.Spectrum.standard_kingman(10, n_monomorphic=100), + sfs_sel=fd.Spectrum.standard_kingman(10, n_monomorphic=1000), + fixed_params=dict(all=dict(h=0.5)), + do_bootstrap=False, + seed=42 + ) + + inf.run() + + # check that DFE is very strongly deleterious + self.assertGreaterEqual(inf.get_discretized()[0][0], 0.8) + + def test_infer_deleterious_selection_sfs_shape(self): + """""" + Test whether we infer a deleterious DFE when there is selection. + """""" + n = 10 + + sfs_neut = fd.Spectrum.standard_kingman(n, n_monomorphic=100) + sfs_sel = fd.Spectrum.from_polymorphic( + Discretization(n=n).get_counts_semidominant_regularized(-10 * np.ones(n - 1), np.arange(1, n)) + ) + sfs_sel.data[0] = 100 + + # use different mutational target sizes + inf = fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + fixed_params=dict(all=dict(h=0.5)), + do_bootstrap=False, + seed=42 + ) + + inf.run() + + # check that DFE is very deleterious + self.assertAlmostEqual(1, inf.get_discretized(np.array([-np.inf, -1, np.inf]))[0][0]) + + def test_alternative_optimizer(self): + """""" + Test whether using an alternative optimizer works as expected. + """""" + config = fd.Config.from_file(self.config_file) + + inf_default = fd.BaseInference.from_config(config) + inf_default.run() + + inf_alt = fd.BaseInference.from_config(config.update(method_mle='TNC')) + inf_alt.run() + + def test_raise_error_n_above_400(self): + """""" + Test whether an error is raised when sample size is above 400. + """""" + with self.assertRaises(ValueError) as context: + fd.BaseInference( + sfs_neut=fd.Spectrum.standard_kingman(401, n_monomorphic=10000), + sfs_sel=fd.Spectrum.standard_kingman(401, n_monomorphic=10000) + ) + + print(context.exception) + + def test_bootstrap_n_retries(self): + """""" + Test whether bootstrapping with retries works as expected. + """""" + config = fd.Config.from_file(self.config_file).update( + n_bootstrap_retries=3, + parallelize=True, + n_bootstraps=3, + do_bootstrap=True + ) + inf = fd.BaseInference.from_config(config) + inf.run() + + self.assertEqual(3, len(inf.bootstraps.likelihoods_runs.iloc[0])) + self.assertEqual(3, len(inf.bootstraps.x0_runs.iloc[0])) + self.assertGreater(inf.bootstraps.likelihoods_std.mean(), 0) + + # make sure that the best likelihood per bootstrap is equal to the maximum over runs + self.assertTrue(np.all(inf.bootstraps.likelihoods_runs.apply(max) == inf.bootstraps.likelihood)) + + def test_infer_dfe_with_fixed_h_low_memory_consumption(self): + """""" + Make sure memory consumption is low for default settings. + """""" + for h in [0, 0.5, 1]: + inf = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + fixed_params={'all': {'h': h, 'S_b': 1, 'p_b': 0, 'eps': 0}}, + parallelize=True, + do_bootstrap=True, + n_bootstraps=10, + n_runs=10 + ) + + inf.run() + + mem_gb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024 ** 3 + + self.assertLess(mem_gb, 1) + + self.assertEqual(inf.params_mle['h'], h) + + def test_infer_h(self): + """""" + Test inference of h parameter. + """""" + inf = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1.0e+8, -1.0e-5, 100), + intervals_h=(0, 1, 11), + fixed_params={'all': {'S_b': 1, 'p_b': 0, 'eps': 0}}, + parallelize=False, + do_bootstrap=True, + n_bootstraps=50, + n_runs=10 + ) + inf.run() + inf.plot_discretized() + + mem_gb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024 ** 3 + + self.assertLess(mem_gb, 1) + + self.assertGreater(inf.bootstraps.h.std(), 0) + + def test_infer_h_custom_callback(self): + """""" + Test inference of h parameter. + """""" + inf = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1.0e+8, -1.0e-5, 100), + h_callback=lambda h, S: 0.4 * np.exp(-h * abs(S)), + intervals_h=(0, 1, 11), + fixed_params={'all': {'S_b': 1, 'p_b': 0, 'eps': 0}}, + bounds={ + 'S_d': (-100000.0, -0.01), + 'b': (0.01, 10), + 'p_b': (0, 0.5), + 'S_b': (0.0001, 100), + 'eps': (0, 0.15), + 'h': (0, 100) + }, + parallelize=False, + do_bootstrap=True, + n_bootstraps=50, + n_runs=10 + ) + inf.run() + inf.plot_discretized() + + pass + + def test_compare_nested_h_parameter(self): + """""" + Test nested model comparison when h is optimized in one model and fixed in the other. + """""" + inf1 = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1.0e+8, -1.0e-5, 100), + intervals_h=(0, 1, 11), + fixed_params={'all': {'S_b': 1, 'p_b': 0, 'eps': 0}}, + parallelize=True, + do_bootstrap=True, + n_runs=5, + n_bootstraps=20 + ) + + inf1.run() + + inf2 = fd.BaseInference.from_config( + inf1.create_config().update( + fixed_params={'all': {'S_b': 1, 'p_b': 0, 'eps': 0, 'h': 0.5}} + ) + ) + inf2.run() + + p = inf2.compare_nested(inf1) + + self.assertTrue(0 < p < 1) + + def test_get_dfe_and_plot(self): + """""" + Test get DFE method. + """""" + inf = fd.BaseInference.from_file(self.serialized) + + inf.get_dfe().plot() + + inf.bootstrap(parallelize=False, n_samples=10) + + inf.get_dfe().plot() + + inf.get_dfe().get_bootstrap_dfes()[1].plot() + + @pytest.mark.skip(reason=""Not a real test."") + def test_runtime_sequential_vs_parallel(self): + """""" + Test whether parallelization speeds up inference. + This doesn't seem to be true currently on osx-arm64 at least. + """""" + inf_seq = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + parallelize=False, + do_bootstrap=True + ) + + start_time = time.time() + inf_seq.run() + seq_time = time.time() - start_time + + inf_par = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + parallelize=True, + do_bootstrap=True + ) + + start_time = time.time() + inf_par.run() + par_time = time.time() - start_time + + self.assertLess(par_time, seq_time) + + def test_serialize_inference_result(self): + """""" + Test whether inference results can be serialized and unserialized correctly. + """""" + inf = fd.BaseInference.from_file(self.serialized) + + # serialize + result = inf.get_summary() + + result.to_file(""scratch/inference_result.json"") + + # unserialize + result2 = fd.InferenceResult.from_file(""scratch/inference_result.json"") + + self.assertEqualObjects(result, result2) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_discretization.py",".py","19168","604","from unittest.mock import patch + +import numpy as np +import pytest +from matplotlib import pyplot as plt +from scipy.special import hyp1f1 +from tqdm import tqdm + +import fastdfe as fd +from fastdfe import GammaExpParametrization +from fastdfe.discretization import Discretization +from testing import TestCase + + +class DiscretizationTestCase(TestCase): + """""" + Test the Discretization class. + """""" + n = 20 + + @staticmethod + def diff(a, b): + """""" + Difference. + """""" + return a - b + + def diff_rel(self, a, b): + """""" + Relative difference. + """""" + return self.diff(a, b) / a + + def diff_max_abs(self, a, b): + """""" + Maximum absolute difference. + """""" + return np.max(np.abs(self.diff(a, b))) + + def diff_rel_max_abs(self, a, b): + """""" + Maximum absolute relative difference. + """""" + return np.max(np.abs(self.diff_rel(a, b))) + + def test_dfe_to_sfs_linearization_midpoint_vs_quad(self): + """""" + Check for discrepancies between the linearized DFE to SFS + transformation using midpoint integration vs scipy's quad. + """""" + opts = dict( + n=self.n, + h=0.5, + intervals_ben=(1.0e-5, 100, 100), + intervals_del=(-10000, -1.0e-5, 100) + ) + + d_midpoint = Discretization(**opts, integration_mode='midpoint') + d_quad = Discretization(**opts, integration_mode='quad') + + P_quad = d_midpoint.get_counts(h=0.5) + P_lin = d_quad.get_counts(h=0.5) + + # P_diff_rel = self.diff_rel(P_quad, P_lin) + diff = self.diff_rel_max_abs(P_quad, P_lin) + + # this is rather large but is due to points near 0 + # for which we have rather small values (on the order of 1e-17) + assert diff < 1 + + model = GammaExpParametrization() + params = GammaExpParametrization.x0 | {'h': 0.5} + + sfs_quad = d_quad.model_selection_sfs(model, params) + sfs_mid = d_midpoint.model_selection_sfs(model, params) + + diff = self.diff_rel_max_abs(sfs_quad, sfs_mid) + + assert diff < 5e-3 + + def test_sfs_counts_linearized_vs_quad(self): + """""" + Compare precomputed linearization using scipy's quad with ad hoc integration. + """""" + model = GammaExpParametrization() + params = GammaExpParametrization.x0 | {'h': 0.5} + + opts = dict( + n=self.n, + integration_mode='quad', + intervals_ben=(1.0e-5, 100, 100), + intervals_del=(-5000, -1.0e-5, 100) + ) + + sfs_adhoc = Discretization(**opts, linearized=False).model_selection_sfs(model, params) + sfs_cached = Discretization(**opts, linearized=True).model_selection_sfs(model, params) + + diff = np.max(np.abs((sfs_cached - sfs_adhoc) / sfs_cached)) + + assert diff < 4e-3 + + @pytest.mark.skip(reason=""np.float128 not available on osx-arm64"") + def test_compare_H_with_regularized(self): + """""" + Compare H with its regularized equivalent that + use the limit as S -> 0 for small S. + Note, behaviour similar for other values of x. + """""" + s = np.logspace(np.log10(1e-20), np.log10(1e-10), 10000) + fig, axs = plt.subplots(nrows=2) + fig.tight_layout(pad=4) + + for ax in axs: + ax.plot(np.abs(s), Discretization.get_counts_high_precision(0.95, s), label='H(s)') + ax.plot(np.abs(s), Discretization.get_counts_high_precision_regularized(0.95, s), label='$H_{reg}(s)$') + + s = -s + + ax.set_xlabel('S' if s[0] > 0 else '-S') + ax.set_ylabel('H') + ax.set_xscale('log') + ax.set_title('sojourn times') + + plt.legend() + plt.show() + + def test_allele_counts_large_negative_S(self): + """""" + Plot divergence vs S. + """""" + d = Discretization( + n=self.n, + linearized=True + ) + + S = np.linspace(-100, -10000, 100) + k = np.arange(1, self.n) + I = np.ones((S.shape[0], k.shape[0])) + c1 = d.get_counts_semidominant_unregularized(S[:, None] * I, k[None, :] * I) + c2 = d.get_counts_semidominant_large_negative_S(S[:, None] * I, k[None, :] * I) + + diff = self.diff_rel_max_abs(c1, c2) + + assert diff < 1e-15 + + def test_hyp1f1_mpmath_vs_scipy(self): + """""" + Compare mpmath and scipy's implementation of the confluent hypergeometric function. + """""" + s = np.linspace(-500, 500, 1000) + k = np.arange(1, self.n) + I = np.ones((s.shape[0], k.shape[0])) + + S = s[:, None] * I + K = k[None, :] * I + + y_scipy = hyp1f1(K, self.n, S) + y_mpmath = Discretization.hyp1f1(K, self.n, S) + + assert self.diff_rel_max_abs(y_scipy, y_mpmath) < 1e-11 + + def test_allele_counts_large_positive_S(self): + """""" + Plot divergence vs S. + """""" + d = Discretization( + n=self.n, + linearized=True + ) + + S = np.linspace(900000, 1000000, 100) + k = np.arange(1, self.n) + I = np.ones((S.shape[0], k.shape[0])) + c1 = d.get_counts_semidominant_unregularized(S[:, None] * I, k[None, :] * I) + c2 = d.get_counts_semidominant_large_positive_S(S[:, None] * I, k[None, :] * I) + + diff = self.diff_rel_max_abs(c1, c2) + + # still relatively large, but we can now evaluate large S + # using mpmath + assert diff < 1e-4 + + def test_plot_allele_count_regularized(self): + """""" + Plot allele count for different values of k. + """""" + d = Discretization( + n=self.n, + intervals_ben=(1.0e-15, 100, 1000), + intervals_del=(-1000000, -1.0e-15, 1000) + ) + + fig, (ax1, ax2) = plt.subplots(nrows=2) + fig.tight_layout(pad=4) + + for k in range(1, self.n): + ax2.plot(np.arange(d.s[d.s != 0].shape[0]), + d.get_counts_semidominant_unregularized(d.s[d.s != 0], k * np.ones_like(d.s[d.s != 0])), + label=f""k = {k}"") + ax1.set_title('default') + + for k in range(1, self.n): + ax1.plot(np.arange(d.s.shape[0]), d.get_counts_semidominant_regularized(d.s, k * np.ones_like(d.s)), + label=f""k = {k}"") + ax1.set_title('regularized') + + plt.legend(prop=dict(size=5)) + plt.show() + + def test_plot_H_fixed_with_regularized_negative(self): + """""" + Plot H_fixed with and without regularization for negative values of S. + """""" + + d = Discretization( + n=self.n, + intervals_ben=(1.0e-15, 100, 0), + intervals_del=(-1000000, -1.0e-15, 1000) + ) + + plt.plot(np.arange(len(d.s)), d.get_counts_fixed_semidominant_regularized(d.s), alpha=0.5, label='regularized') + plt.plot(np.arange(len(d.s)), d.get_counts_fixed_semidominant(d.s), alpha=0.5, label='normal') + + plt.legend() + plt.show() + + def test_plot_H_fixed_with_regularized_positive(self): + """""" + Plot H_fixed with and without regularization for positive values of S. + """""" + + d = Discretization( + n=self.n, + intervals_ben=(1.0e-15, 1, 1000), + intervals_del=(-1000000, -1.0e-15, 0) + ) + + plt.plot(np.arange(len(d.s)), d.get_counts_fixed_semidominant_regularized(d.s), alpha=0.5, + label='positive regularized') + plt.plot(np.arange(len(d.s)), d.get_counts_fixed_semidominant(d.s), alpha=0.5, label='positive normal') + + plt.legend() + plt.show() + + def test_compare_with_semidominant(self): + """""" + Compare regularized allele counts with those obtained + from H_h for semi-dominant case (h = 0.5). + """""" + m = 5 + diff = np.zeros((3, m, 201)) + for i, n in enumerate([6, 20, 100]): + d = Discretization( + n=n, + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1.0e+8, -1.0e-5, 100) + ) + + for j, k in tqdm(enumerate(np.linspace(1, n - 1, m).astype(int)), total=m): + ys1 = d._get_counts_dominant(n=d.n, k=k, S=d.s, h=0.5) + ys2 = d.get_counts_semidominant_regularized(k=np.full_like(d.s, k), S=d.s) + + diff[i, j] = (np.abs(ys1 - ys2) / (ys2 + 1e-10)) + + diff_max = np.max(diff, axis=(1, 2)) + diff_mean = np.mean(diff, axis=(1, 2)) + self.assertLess(diff.mean(), 0.004) + self.assertTrue((diff_max < np.array([0.02, 0.06, 0.3])).all()) + pass + + def test_cache_fixed_h_not_semidominant(self): + """""" + Make sure that caching of dominance-specific allele counts invokes the correct methods. + """""" + d = Discretization( + n=10, + h=0.2, + intervals_ben=(1e-5, 1e4, 100), + intervals_del=(-1e8, -1e-5, 100), + intervals_h=(0.0, 1.0, 5), + parallelize=False + ) + + with patch.object(d, ""get_counts_dominant"", wraps=d.get_counts_dominant) as spy: + d.precompute() + spy.assert_called() + + def test_cache_fixed_h_semidominant(self): + """""" + Make sure that caching of semidominant allele counts invokes the correct methods. + """""" + d = Discretization( + n=10, + h=0.5, + intervals_ben=(1e-5, 1e4, 100), + intervals_del=(-1e8, -1e-5, 100), + intervals_h=(0.0, 1.0, 5), + parallelize=False + ) + + with patch.object(d, ""get_counts_semidominant"", wraps=d.get_counts_semidominant) as spy: + d.precompute() + spy.assert_called() + + def test_cache_dominance(self): + """""" + Test caching of dominance-specific allele counts. + """""" + d = Discretization( + n=10, + h=None, + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1.0e+8, -1.0e-5, 100), + intervals_h=(0.0, 1.0, 5) + ) + + d.precompute() + + np.testing.assert_array_equal(d.grid_h, [0.0, 0.25, 0.5, 0.75, 1.0]) + + T = d.get_counts_semidominant() + T2 = d.get_counts(h=0.5) + T3 = d.get_counts(h=0.5 - 1e-5) + T4 = d.get_counts(h=0.5 + 1e-5) + + diff = (np.abs(T2 - T) / (T + 1e-10)) + diff_max = np.max(diff) + diff_mean = np.mean(diff) + + self.assertLess(diff_max, 0.03) + self.assertLess(diff_mean, 1e-3) + self.assertLess((np.abs(T2 - T3) / (T2 + 1e-10)).max(), 0.01) + self.assertLess((np.abs(T2 - T4) / (T2 + 1e-10)).max(), 0.01) + + def test_plot_over_h(self): + """""" + Plot allele counts over h for different h callbacks. + """""" + for callback in [lambda k, S: np.full_like(S, k), lambda k, S: np.full_like(S, np.sqrt(k))]: + d = Discretization( + n=10, + h=None, + h_callback=callback, + intervals_ben=(1, 1000, 5), + intervals_del=(-1.0e+8, -1, 5), + intervals_h=(0, 1, 10) + ) + + hs = np.linspace(0, 1, 101) + counts = np.array([d.get_counts(h=h) for h in hs]).transpose(1, 2, 0) + + fig, ax = plt.subplots( + nrows=d.n // 3, + ncols=3, + figsize=(14, 10) + ) + ax = ax.flatten() + + for k in range(d.n - 1): + for j in range(d.s.shape[0]): + ax[k].plot(hs, counts[k, j], alpha=0.7, label=f""S={d.s[j]:.2f}"", linewidth=2) + ax[k].set_ylabel(""SFS count"") + ax[k].set_xlabel(""h"") + ax[k].set_yscale(""log"") + ax[k].set_title(f""k={k + 1}"") + + ax[0].legend(prop=dict(size=8)) + fig.tight_layout() + plt.show() + + def test_default_h_callback(self): + """""" + Make sure default results in single fixed h of 0.5. + """""" + d = Discretization( + n=10, + h_callback=lambda k, S: np.full_like(S, k), + h=0.5, + intervals_h=(0.0, 1.0, 6), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1e8, -1.0e-5, 100) + ) + + self.assertEqual(d.grid_h, None) + + def test_custom_h_fixed_callback_fixed_h(self): + """""" + Make sure passing fixed h callback and fixed h results in correct grid. + """""" + d = Discretization( + n=10, + h=0.5, + h_callback=lambda k, S: np.full_like(S, k - 0.1), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1e8, -1.0e-5, 100) + ) + + self.assertEqual(d.grid_h, None) + + def test_custom_h_fixed_callback_variable_h(self): + """""" + Make sure fixed h callback with variable h results in default grid. + """""" + d = Discretization( + n=10, + h=None, + h_callback=lambda k, S: np.full_like(S, k - 0.1), + intervals_h=(0.0, 1.0, 6), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1e8, -1.0e-5, 100), + ) + + np.testing.assert_array_equal(d.grid_h, np.linspace(*d.intervals_h)) + + # test interpolation + counts1 = d.get_counts(h=0.5) + counts2 = d.get_counts(h=0.6) + np.testing.assert_array_almost_equal((counts1 + counts2) / 2, d.get_counts(h=0.55)) + + def test_custom_h_variable_callback_fixed_h(self): + """""" + Make sure variable h callback with fixed h results in correct grid and interpolation. + """""" + d = Discretization( + n=10, + h=0.5, + h_callback=lambda k, S: 0.4 * np.exp(-k * abs(S)), + intervals_h=(0.0, 1.0, 6), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1e8, -1.0e-5, 100) + ) + + self.assertEqual(d.grid_h, None) + + def test_interpolation_weights_variable_h_fixed_callback(self): + """""" + Make sure variable h callback with fixed h results in correct grid and interpolation. + """""" + d = Discretization( + n=10, + h=None, + h_callback=lambda k, S: 0.4 * np.exp(-k * abs(S)), + intervals_h=(0.0, 1.0, 6), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1e8, -1.0e-5, 100) + ) + + np.testing.assert_array_equal(d.grid_h, np.linspace(*d.intervals_h)) + + i, w = d.get_interpolation_weights(h=0.5) + hs = d.map_h(0.5, d.s) + np.testing.assert_array_almost_equal(i + w, hs * 5 + 1) + x = np.arange(len(d.s)) + + plt.plot(x, i + w, label='index + weight') + plt.plot(x, w, label='weights') + plt.plot(x, i, label='indices') + plt.plot(x, hs, label='h callback') + plt.title(""Interpolation indices + weights over S"") + plt.xlabel(""S"") + plt.ylabel(""Index + weight"") + plt.legend() + plt.show() + + pass + + def test_plot_custom_h_callback(self): + """""" + Plot allele counts over h for a custom h callback. + """""" + h = lambda k, S: 0.4 * np.exp(-k * abs(S)) + + plt_s = np.logspace(-5, 2, 100) + plt_k = [0.1, 1, 10, 100] + plt.figure(figsize=(10, 6)) + for k in plt_k: + hs = h(k, plt_s) + plt.plot(plt_s, hs, label=f'k={k}') + plt.xscale('log') + plt.xlabel('S') + plt.ylabel('h') + plt.title('Custom h callback over S for different k') + plt.legend() + plt.show() + + def test_fixed_h_vs_interpolated_h(self): + """""" + Compare allele counts obtained using fixed h(S) vs interpolated h. + """""" + k = 1 + + d1 = Discretization( + n=10, + h=0.5, + h_callback=lambda k, S: 0.4 * np.exp(-k * abs(S)), + intervals_h=(0.0, 1.0, 6), + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1e8, -1.0e-5, 100) + ) + + c1 = d1.get_counts(0.5) + + d2 = Discretization( + n=10, + h=None, + h_callback=d1.h_callback, + intervals_h=d1.intervals_h, + intervals_ben=d1.intervals_ben, + intervals_del=d1.intervals_del + ) + + c2 = d2.get_counts(0.5) + + diff = self.diff_rel_max_abs(c1, c2) + self.assertLess(diff, 0.03) + + def test_compare_fixed_counts_with_semidominant(self): + """""" + Compare Discretization.get_counts_fixed_dominant and Discretization.get_counts_fixed_regularized. + """""" + d = Discretization( + n=10, + h=None, + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1e8, -1.0e-5, 100) + ) + + y1 = fd.discretization.Discretization.get_counts_fixed_dominant(d.s, 0.5) + y2 = fd.discretization.Discretization.get_counts_fixed_semidominant_regularized(d.s) + + diff = np.abs(y1 - y2) / (y2 + 1e-10) + self.assertLess(diff.max(), 0.001) + + def test_fixed_counts_varying_h(self): + """""" + Test Discretization.get_counts_fixed_dominant with varying h. + """""" + d = Discretization( + n=10, + h=None, + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1e8, -1.0e-5, 100), + ) + + rng = np.random.default_rng(0) + hs = rng.uniform(0, 1, size=d.s.shape[0]) + + y_var = fd.discretization.Discretization.get_counts_fixed_dominant(d.s, hs) + + # reference: two fixed extremes + y_h0 = fd.discretization.Discretization.get_counts_fixed_dominant(d.s, 0.0) + y_h1 = fd.discretization.Discretization.get_counts_fixed_dominant(d.s, 1.0) + + # bounds: per-s dominance interpolation + assert np.all(y_var >= np.minimum(y_h0, y_h1)) + assert np.all(y_var <= np.maximum(y_h0, y_h1)) + + x = np.arange(d.s.shape[0]) + + plt.plot(x, y_h0, label=""h=0"", alpha=0.7) + plt.plot(x, y_h1, label=""h=1"", alpha=0.7) + plt.scatter(x, y_var, c=hs, cmap=""viridis"", s=10, label=""varying h"") + + plt.yscale(""log"") + plt.colorbar(label=""h"") + plt.ylim(1e-4, 1e5) + plt.legend() + plt.show() + + + def test_plot_counts_fixed(self): + """""" + Plot allele counts for fixed h. + """""" + d = Discretization( + n=10, + h=None, + intervals_ben=(1.0e-5, 1.0e4, 100), + intervals_del=(-1e8, -1.0e-5, 100), + ) + + hs = np.round(np.linspace(0, 1, 6), 2) + + # cache all results at once + counts = { + h: fd.discretization.Discretization.get_counts_fixed_dominant(d.s, h) + for h in hs + } + + # make sure counts are larger for larger h on beneficial side and vice versa + Y = np.stack([counts[h] for h in hs], axis=0) + assert np.all(np.diff(Y[:, d.s > 0], axis=0) >= 0) + assert np.all(np.diff(Y[:, d.s < 0], axis=0) <= 0) + + # plotting + x = np.arange(len(d.s)) + for h, y in counts.items(): + plt.plot(x, y, label=f""h={h}"") + + plt.legend() + plt.yscale(""log"") + plt.ylim(1e-4, 1e5) + plt.show() +","Python" +"Allele","Sendrowski/fastDFE","testing/test_spectra.py",".py","27578","828","import dadi +import numpy as np +import pandas as pd +from numpy import testing + +from fastdfe import spectrum, Spectra, Spectrum +from testing import TestCase + + +class SpectraTestCase(TestCase): + """""" + Test the Spectrum and Spectra classes. + """""" + n = 20 + + @staticmethod + def test_multiply_by_scalar(): + """""" + Test that multiplying a spectra by a scalar works as expected. + """""" + s = Spectra(dict( + all=np.arange(20), + sub=np.arange(3, 23) + )) * 4 + + testing.assert_array_equal(np.arange(20) * 4, s[['all']].to_list()[0]) + testing.assert_array_equal(np.arange(3, 23) * 4, s[['sub']].to_list()[0]) + + @staticmethod + def test_restore_from_list(): + """""" + Test that restoring a spectra from a list works as expected. + """""" + s = Spectra(dict( + all=np.arange(20), + sub=np.arange(3, 23) + )) * 4 + + s2 = s.from_list(s.to_list(), s.types) + + testing.assert_array_equal(s.to_numpy(), s2.to_numpy()) + + @staticmethod + def test_multiply_by_list(): + """""" + Test that multiplying a spectra by a list works as expected. + """""" + s = Spectra(dict( + all=np.arange(20), + sub=np.arange(3, 23) + )) * [2, 4] + + testing.assert_array_equal(np.arange(20) * 2, s[['all']].to_list()[0]) + testing.assert_array_equal(np.arange(3, 23) * 4, s[['sub']].to_list()[0]) + + def test_kingman_sfs(self): + """""" + Test that the kingman sfs is as expected. + """""" + np.testing.assert_array_equal( + Spectrum.standard_kingman(10, n_monomorphic=100).data, + [100, 1, 0.5, 1 / 3, 1 / 4, 1 / 5, 1 / 6, 1 / 7, 1 / 8, 1 / 9, 0] + ) + + def test_create_from_spectrum_dict(self): + """""" + Test that creating a spectra from a dict of spectra works as expected. + """""" + s = Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n) * 4, + sub=spectrum.standard_kingman(self.n) * 2 + )) + + testing.assert_array_equal((spectrum.standard_kingman(self.n) * 4).to_list(), s['all'].to_list()) + testing.assert_array_equal((spectrum.standard_kingman(self.n) * 2).to_list(), s['sub'].to_list()) + + def test_create_from_spectrum(self): + """""" + Test that creating a spectra from a single spectrum works as expected. + """""" + s = Spectra.from_spectrum(spectrum.standard_kingman(self.n)) + + testing.assert_array_equal(spectrum.standard_kingman(self.n).to_list(), s['all'].to_list()) + testing.assert_equal(self.n, s.n) + testing.assert_equal(1, s.k) + + def test_create_from_array_pass_targets_div(self): + """""" + Test that creating a spectra from an array works as expected. + """""" + data = spectrum.standard_kingman(self.n) + data.data[-1] = 6543 + s = Spectra.from_list([data.to_list()], types=['all']) + + testing.assert_array_equal(data.data, s['all'].data) + testing.assert_equal(s.n, self.n) + testing.assert_equal(1, s.k) + + def test_create_from_dataframe(self): + """""" + Test that creating a spectra from a dataframe works as expected. + """""" + df = pd.DataFrame(dict( + all=(spectrum.standard_kingman(self.n) * 4).to_list(), + sub=(spectrum.standard_kingman(self.n) * 2).to_list() + )) + + s = Spectra.from_dataframe(df) + + pd.testing.assert_frame_equal(df, s.data) + + def test_spectra_restore_from_file(self): + """""" + Test that restoring a spectra from a file works as expected. + """""" + s = Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n) * 4, + sub=spectrum.standard_kingman(self.n) * 2 + )) + + out = ""scratch/test_spectra_restore_from_file.csv"" + s.to_file(out) + s2 = s.from_file(out) + + pd.testing.assert_frame_equal(s.data, s2.data) + + def test_spectrum_restore_from_file(self): + """""" + Test that restoring a spectrum from a file works as expected. + """""" + s = spectrum.standard_kingman(self.n) + + out = ""scratch/test_spectrum_restore_from_file.csv"" + s.to_file(out) + s2 = Spectrum.from_file(out) + + testing.assert_array_almost_equal(s.data, s2.data, decimal=15) + + def test_restore_from_dict(self): + """""" + Test that restoring a spectra from a dict works as expected. + """""" + s = Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n) * 4, + sub=spectrum.standard_kingman(self.n) * 2 + )) + + s2 = s.from_dict(s.to_dict()) + + pd.testing.assert_frame_equal(s.data, s2.data) + + def test_normalize(self): + """""" + Test that normalizing a spectra works as expected. + """""" + s = Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n), + sub=spectrum.standard_kingman(self.n) + )) * [2, 4] + + s = s.normalize() + + testing.assert_almost_equal(1, np.sum(s['all'].to_list()[:-1])) + testing.assert_almost_equal(1, np.sum(s['sub'].to_list()[:-1])) + + def test_properties(self): + """""" + Test that the properties of a spectra work as expected. + """""" + s = Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n), + sub=spectrum.standard_kingman(self.n) + )) * [2, 4] + + testing.assert_equal(2, s.k) + testing.assert_equal(self.n, s.n) + testing.assert_array_equal(['all', 'sub'], s.types) + + def test_from_polydfe(self): + """""" + Test that the from_polydfe method works as expected. + """""" + data = np.arange(self.n) * 10 + n_sites = 100000000 + n_div = 12345 + + s = Spectrum.from_polydfe(data, n_sites=n_sites, n_div=n_div) + + testing.assert_equal(s.to_list()[0], n_sites - np.sum(data) - n_div) + testing.assert_equal(s.n_monomorphic, n_sites - np.sum(data)) + testing.assert_equal(s.n_polymorphic, np.sum(data)) + testing.assert_equal(s.n_div, n_div) + testing.assert_equal(s.n_sites, n_sites) + + @staticmethod + def test_site_wise_wattersons_estimator_spectrum(): + """""" + Test that the wattersons_estimator method works as expected. + """""" + data = [3434, 6346, 234, 4342, 55, 525, 24, 56, 2, 42, 4] + testing.assert_equal(Spectrum(data).theta, dadi.Spectrum(data).Watterson_theta() / sum(data)) + + @staticmethod + def test_wattersons_estimator_spectrum(): + """""" + Test that the wattersons_estimator method works as expected. + """""" + data = [3434, 6346, 234, 4342, 55, 525, 24, 56, 2, 42, 4] + testing.assert_equal(Spectrum(data).Theta, dadi.Spectrum(data).Watterson_theta()) + + @staticmethod + def test_site_wise_wattersons_estimator_spectra(): + """""" + Test that the wattersons_estimator method works as expected. + """""" + data = { + 'all': [3434, 6346, 234, 4342, 55, 525, 24, 56, 2, 42, 4], + 'sub': [1234, 2345, 234, 1234, 55, 525, 24, 56, 2, 42, 4] + } + s = Spectra.from_dict(data) + + testing.assert_equal(s.theta.to_list(), [ + dadi.Spectrum(data['all']).Watterson_theta() / sum(data['all']), + dadi.Spectrum(data['sub']).Watterson_theta() / sum(data['sub']) + ]) + + @staticmethod + def test_wattersons_estimator_spectra(): + """""" + Test that the wattersons_estimator method works as expected. + """""" + data = { + 'all': [3434, 6346, 234, 4342, 55, 525, 24, 56, 2, 42, 4], + 'sub': [1234, 2345, 234, 1234, 55, 525, 24, 56, 2, 42, 4] + } + s = Spectra.from_dict(data) + + testing.assert_equal(s.Theta.to_list(), [ + dadi.Spectrum(data['all']).Watterson_theta(), + dadi.Spectrum(data['sub']).Watterson_theta() + ]) + + def test_plot_spectrum(self): + """""" + Test that the plot_spectrum method works as expected. + """""" + (spectrum.standard_kingman(self.n) * 4).plot() + + def test_plot_spectrum_log_scale(self): + """""" + Test that the plot_spectrum method works as expected when using a log scale. + """""" + (spectrum.standard_kingman(self.n) * 4).plot(log_scale=True) + + def test_plot_spectra(self): + """""" + Test that the plot_spectra method works as expected. + """""" + Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n) * 4, + sub=spectrum.standard_kingman(self.n) * 2 + )).plot() + + def test_plot_spectra_log_scale(self): + """""" + Test that the plot_spectra method works as expected when using a log scale. + """""" + Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n) * 4, + sub=spectrum.standard_kingman(self.n) * 2 + )).plot(log_scale=True) + + def test_plot_spectra_use_subplots(self): + """""" + Test that the plot_spectra method works as expected. + """""" + Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n) * 4, + sub=spectrum.standard_kingman(self.n) * 2 + )).plot(use_subplots=True) + + def test_plot_spectra_use_subplots_log_scale(self): + """""" + Test that the plot_spectra method works as expected when using a log scale. + """""" + Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n) * 4, + sub=spectrum.standard_kingman(self.n) * 2 + )).plot(use_subplots=True, log_scale=True) + + def test_select_wildcard(self): + """""" + Test that the select method works as expected. + """""" + s = Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n), + all2=spectrum.standard_kingman(self.n), + sub=spectrum.standard_kingman(self.n) + )) + + assert len(s['all.*']) == 2 + assert isinstance(s['sub.*'], Spectrum) + assert isinstance(s[['sub.*']], Spectra) + + def test_select_no_regex(self): + """""" + Test that the select method works as expected when not using regex. + """""" + s = Spectra.from_spectra(dict( + all=spectrum.standard_kingman(self.n), + all2=spectrum.standard_kingman(self.n), + sub=spectrum.standard_kingman(self.n) + )) + + assert isinstance(s.__getitem__('all', use_regex=False), Spectrum) + assert isinstance(s.__getitem__(['sub', 'all'], use_regex=False), Spectra) + assert len(s.__getitem__(['sub', 'all'], use_regex=False)) == 2 + assert isinstance(s.__getitem__(['sub'], use_regex=False), Spectra) + assert len(s.__getitem__(['sub'], use_regex=False)) == 1 + + @staticmethod + def test_merge_level(): + """""" + Test that the merge_level method works as expected. + """""" + s = Spectra.from_spectra({ + 'bla.foo.bar': Spectrum([1000, 3, 4, 1]), + 'test1.te.x': Spectrum([100, 4, 7, 6]), + 'test2.te.x': Spectrum([55, 2, 1, 7]), + }).merge_groups([1, 2]) + + expected = Spectra.from_spectra({ + 'foo.bar': Spectrum([1000, 3, 4, 1]), + 'te.x': Spectrum([155, 6, 8, 13]), + }) + + pd.testing.assert_frame_equal(s.data, expected.data) + + @staticmethod + def test_add_spectra(): + """""" + Test that the add_spectra method works as expected. + """""" + s = Spectra.from_spectra({ + 'bla.foo.bar': Spectrum([1000, 3, 4, 1]), + 'test1.te.x': Spectrum([100, 4, 7, 6]), + 'test2.foo.x': Spectrum([55, 2, 1, 7]), + }) + Spectra.from_spectra({ + 'bla.foo.bar': Spectrum([543, 7, 1, 2]), + 'test1.te.x': Spectrum([200, 4, 10, 6]), + 'test2.test2.x': Spectrum([55, 2, 1, 7]), + }) + + expected = Spectra.from_spectra({ + 'bla.foo.bar': Spectrum([1543, 10, 5, 3]), + 'test1.te.x': Spectrum([300, 8, 17, 12]), + 'test2.foo.x': Spectrum([55, 2, 1, 7]), + 'test2.test2.x': Spectrum([55, 2, 1, 7]), + }) + + pd.testing.assert_frame_equal(s.data, expected.data) + + @staticmethod + def test_rename_spectra(): + """""" + Test that the rename_spectra method works as expected. + """""" + # create spectra with two subtypes and two types + spectra = Spectra.from_spectra({ + ""subtype1.type1"": Spectrum.standard_kingman(10) * 1, + ""subtype1.type2"": Spectrum.standard_kingman(10) * 2, + ""subtype2.type1"": Spectrum.standard_kingman(10) * 3, + }) + + spectra = spectra.prefix(""subsub"") + + assert spectra.types == [""subsub.subtype1.type1"", ""subsub.subtype1.type2"", ""subsub.subtype2.type1""] + + @staticmethod + def test_fold_spectrum(): + """""" + Test that the folding of spectra works as expected + """""" + spectra = [ + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + [1, 2, 3, 4, 5, 6, 7, 8, 9], + [2, 1, 4, 4, 325, 5, 213, 515] + ] + + for s in spectra: + np.testing.assert_array_equal(Spectrum(s).fold().data, dadi.Spectrum(s).fold().data) + + def test_spectrum_is_folded(self): + """""" + Test that the is_folded property works as expected + """""" + data = [ + dict(s=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], folded=False), + dict(s=[1, 1, 0, 0], folded=True), + dict(s=[1, 1, 5, 0, 0], folded=True), + dict(s=[0, 0, 0, 0, 1], folded=False), + ] + + for d in data: + self.assertEqual(Spectrum(d['s']).is_folded(), d['folded']) + + @staticmethod + def test_folding_folded_spectrum_has_no_effect(): + """""" + Test that folding a folded spectrum has no effect + """""" + data = [ + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + [1, 1, 0, 0], + [1, 1, 5, 0, 0], + [0, 0, 0, 0, 1], + ] + + for s in data: + np.testing.assert_array_equal(Spectrum(s).fold().fold().data, Spectrum(s).fold().data) + + @staticmethod + def test_fold_spectra(): + """""" + Test that the folding of spectra works as expected + """""" + s = Spectra.from_spectra(dict( + type1=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), + type2=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]) + )) + + s_folded = s.fold() + + for t in s.types: + np.testing.assert_array_equal(s[t].fold().data, s_folded[t].data) + + assert not np.array(list(s.is_folded().values())).all() + assert np.array(list(s_folded.is_folded().values())).all() + + @staticmethod + def test_has_dots(): + """""" + Test that the has_dots() method works as expected + """""" + assert Spectra.from_spectra(dict( + type1=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), + type2=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]) + )).has_dots() is False + + assert Spectra.from_spectra({ + 'test.foo': Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) + }).has_dots() is True + + @staticmethod + def test_replace_dots(): + """""" + Test that the replace_dots() method works as expected + """""" + s = Spectra.from_spectra({ + 'test.foo': Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) + }).replace_dots() + + assert s.has_dots() is False + assert s.types == ['test_foo'] + + @staticmethod + def test_drop_empty(): + """""" + Test that the drop_empty() method works as expected + """""" + assert Spectra.from_spectra(dict( + type1=Spectrum([1, 0, 0, 0, 0, 0, 0, 0, 0, 10]), + type2=Spectrum([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), + type3=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]), + )).drop_empty().types == ['type1', 'type3'] + + @staticmethod + def test_drop_zero_entries(): + """""" + Test that the drop_zero_entries() method works as expected + """""" + assert Spectra.from_spectra(dict( + type1=Spectrum([1, 0, 0, 0, 0, 0, 0, 0, 0, 10]), + type2=Spectrum([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), + type3=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]), + type4=Spectrum([1, 2, 0, 4, 5, 6, 7, 8, 9, 65]), + )).drop_zero_entries().types == ['type3'] + + @staticmethod + def test_drop_sparse(): + """""" + Test that the drop_zero_entries() method works as expected + """""" + spectra = Spectra.from_spectra(dict( + type1=Spectrum([1, 0, 0, 0, 0, 0, 0, 0, 0, 10]), + type2=Spectrum([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), + type3=Spectrum([1, 2, 3, 4, 5, 6, 7, 8, 9, 65]), + type4=Spectrum([1, 2, 0, 4, 5, 6, 7, 8, 9, 65]), + )) + + assert spectra.drop_sparse(n_polymorphic=0).types == ['type3', 'type4'] + assert spectra.drop_sparse(n_polymorphic=1).types == ['type3', 'type4'] + assert spectra.drop_sparse(n_polymorphic=40).types == ['type3', 'type4'] + assert spectra.drop_sparse(n_polymorphic=41).types == ['type3'] + assert spectra.drop_sparse(n_polymorphic=44).types == [] + + @staticmethod + def test_add_spectrum(): + """""" + Test whether two spectrum objects can be added. + """""" + testing.assert_array_equal((Spectrum([1, 2, 3]) + Spectrum([3, 4, 5])).data, Spectrum([4, 6, 8]).data) + + @staticmethod + def test_subtract_spectrum(): + """""" + Test whether two spectrum objects can be subtracted. + """""" + testing.assert_array_equal((Spectrum([3, 4, 5]) - Spectrum([1, 2, 3])).data, [2, 2, 2]) + + @staticmethod + def test_normalize_spectrum(): + """""" + Test whether two spectrum objects can be normalized. + """""" + testing.assert_array_equal(Spectrum([10, 1, 2, 3, 10]).normalize().data, [10, 1 / 6, 1 / 3, 1 / 2, 10]) + + @staticmethod + def test_spectra_n_monomorphic(): + """""" + Test whether the n_monomorphic property works as expected. + """""" + spectra = Spectra.from_spectra(dict( + type1=Spectrum([1, 0, 0, 0, 0, 0, 0, 0, 0, 10]), + type2=Spectrum([1, 2, 0, 4, 5, 6, 7, 8, 9, 65]), + )) + + assert np.all(spectra.n_monomorphic == pd.Series(dict(type1=11, type2=66))) + + def test_reorder_levels(self): + """""" + Test whether the reorder_levels method works as expected. + """""" + spectra = Spectra({ + ""type1.subtype1.subsubtype1"": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + ""type1.subtype1.subsubtype2"": [1, 4, 12, 4, 5, 6, 7, 8, 9, 10], + ""type1.subtype2.subsubtype1"": [1, 7, 7, 4, 5, 6, 7, 8, 9, 10], + ""type1.subtype2.subsubtype2"": [1, 8, 3, 4, 5, 6, 7, 8, 9, 10], + ""type2.subtype1.subsubtype1"": [1, 0, 1, 4, 5, 6, 7, 8, 9, 10], + ""type2.subtype1.subsubtype2"": [1, 6, 3, 4, 5, 6, 7, 8, 9, 10], + }) + + spectra2 = spectra.reorder_levels([1, 0, 2]) + + self.assertEqual(spectra2.types, [ + ""subtype1.type1.subsubtype1"", + ""subtype1.type1.subsubtype2"", + ""subtype2.type1.subsubtype1"", + ""subtype2.type1.subsubtype2"", + ""subtype1.type2.subsubtype1"", + ""subtype1.type2.subsubtype2"", + ]) + + testing.assert_array_equal(spectra2.to_list(), spectra.reorder_levels([1, 0, 2]).to_list()) + + testing.assert_array_equal( + list(spectra2[""subtype1.type1.subsubtype1""]), + list(spectra[""type1.subtype1.subsubtype1""]) + ) + + def test_subsample_spectrum_random(self): + """""" + Test whether the subsample method works as expected. + """""" + kingman = Spectrum.standard_kingman(30) * 10000 + + sub = kingman.subsample(10, mode='random') + + s = Spectra.from_spectra(dict( + actual=Spectrum.standard_kingman(10) * 10000, + subsampled=sub + )) + + s.plot() + + self.assertEqual(10, sub.n) + + diff_rel = np.abs(s['actual'].polymorphic - s['subsampled'].polymorphic) / s['actual'].polymorphic + + self.assertTrue(np.all(diff_rel < 0.1)) + + def test_subsample_folded_spectrum(self): + """""" + Test whether the subsample method works as expected. + """""" + kingman = (Spectrum.standard_kingman(30) * 10000).fold() + + sub = kingman.subsample(10, mode='probabilistic') + + truth = (Spectrum.standard_kingman(10) * 10000).fold() + + self.assertTrue(np.all(np.abs(truth.data[1:] - sub.data[1:]) < 1e-12)) + + def test_subsample_spectrum_probabilistic_vs_random_folded(self): + """""" + Test random vs probabilistic subsampling. + """""" + kingman = (Spectrum.standard_kingman(30) * 10000).fold() + + sub_random = kingman.subsample(10, mode='random') + sub_probabilistic = kingman.subsample(10, mode='probabilistic') + + s = Spectra.from_spectra(dict( + actual=(Spectrum.standard_kingman(10) * 10000).fold(), + random=sub_random, + probabilistic=sub_probabilistic + )) + + s.plot() + + diff_rel = np.abs(s['actual'].polymorphic - s['probabilistic'].polymorphic) / s['probabilistic'].polymorphic + + self.assertTrue(np.all(diff_rel[:5] < 1e-15)) + + def test_subsample_spectrum_probabilistic_vs_random_unfolded(self): + """""" + Test random vs probabilistic subsampling. + """""" + kingman = Spectrum.standard_kingman(30) * 10000 + + sub_random = kingman.subsample(10, mode='random') + sub_probabilistic = kingman.subsample(10, mode='probabilistic') + + s = Spectra.from_spectra(dict( + actual=Spectrum.standard_kingman(10) * 10000, + random=sub_random, + probabilistic=sub_probabilistic + )) + + s.plot() + + diff_rel = np.abs(s['actual'].polymorphic - s['probabilistic'].polymorphic) / s['probabilistic'].polymorphic + + self.assertTrue(np.all(diff_rel < 1e-15)) + + def test_larger_subsample_size_raises_value_error(self): + """""" + Test whether the subsample method raises a ValueError when the requested subsample size is larger than the + original sample size. + """""" + self.assertRaises(ValueError, Spectrum.standard_kingman(30).subsample, 40) + + @staticmethod + def test_subsample_spectra(): + """""" + Test whether the subsample method works as expected. + """""" + spectra = Spectra({ + ""type1.subtype1.subsubtype1"": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + ""type1.subtype1.subsubtype2"": [1, 4, 12, 4, 5, 6, 7, 8, 9, 10], + }) + + spectra.subsample(7, mode='random').plot() + + # make sure n_sites is the same + testing.assert_array_equal(spectra.subsample(7).n_sites, spectra.n_sites) + + def test_has_divergence(self): + """""" + Test whether the has_divergence method works as expected. + """""" + s1 = Spectrum([1, 2, 3, 0]) + s2 = Spectrum([1, 2, 3, 4]) + + self.assertFalse(s1.has_div) + self.assertTrue(s2.has_div) + + self.assertTrue(Spectra.from_spectra({ + ""type1"": s1, + ""type2"": s2 + }).has_div.any()) + + self.assertFalse(Spectra.from_spectra({ + ""type1"": s1, + ""type2"": s1 + }).has_div.all()) + + @staticmethod + def test_copy_spectrum(): + """""" + Test whether the copy method works as expected. + """""" + s = Spectrum([1, 2, 3, 4, 5]) + + s2 = s.copy() + + testing.assert_array_equal(s.data, s2.data) + + @staticmethod + def test_spectrum_power(): + """""" + Test whether the power method works as expected. + """""" + s = Spectrum([1, 2, 3, 4, 5]) + + testing.assert_array_equal((s ** 2).data, [1, 4, 9, 16, 25]) + + @staticmethod + def test_spectrum_divide(): + """""" + Test whether the divide method works as expected. + """""" + s = Spectrum([1, 2, 3, 4, 5]) + + testing.assert_array_equal((s / 2).data, [0.5, 1, 1.5, 2, 2.5]) + + @staticmethod + def test_spectrum_floor_divide(): + """""" + Test whether the floor divide method works as expected. + """""" + s = Spectrum([1, 2, 3, 4, 5]) + + testing.assert_array_equal((s // 2).data, [0, 1, 1, 2, 2]) + + @staticmethod + def test_spectra_to_dataframe(): + """""" + Test whether the to_dataframe method works as expected. + """""" + s = Spectra.from_spectra(dict( + all=spectrum.standard_kingman(10), + sub=spectrum.standard_kingman(10) * 2 + )) + + df = s.to_dataframe() + + pd.testing.assert_frame_equal(df, s.data) + + def test_spectra_floor_divide(self): + """""" + Test whether the floor divide method works as expected. + """""" + s = Spectra.from_spectra(dict( + all=spectrum.standard_kingman(10), + sub=spectrum.standard_kingman(10) * 2 + )) + + s2 = s // 2 + + testing.assert_array_equal(s2['all'].data, s['all'].data // 2) + testing.assert_array_equal(s2['sub'].data, s['sub'].data // 2) + + def test_misidentify_value_error(self): + """""" + Test whether the misidentify method raises a ValueError when the rate is not between 0 and 1. + """""" + sfs = Spectrum([0, 1, 2]) + + with self.assertRaises(ValueError): + sfs.misidentify(-0.1) + + with self.assertRaises(ValueError): + sfs.misidentify(1.5) + + def test_misidentify_expected_sfs_even_n(self): + """""" + Test whether the misidentify method works as expected for even n. + """""" + sfs = Spectrum([177595, 922, 363, 210, 164, 162, 712]) + + np.testing.assert_array_equal( + sfs.misidentify(0.1).data, + [177595, 922 * 0.9 + 162 * 0.1, 363 * 0.9 + 164 * 0.1, 210, + 164 * 0.9 + 363 * 0.1, 162 * 0.9 + 922 * 0.1, 712] + ) + + def test_misidentify_expected_sfs_odd_n(self): + """""" + Test whether the misidentify method works as expected for odd n. + """""" + sfs = Spectrum([177749, 889, 347, 214, 189, 739]) + + np.testing.assert_array_equal( + sfs.misidentify(0.1).data, + [177749, 889 * 0.9 + 189 * 0.1, 347 * 0.9 + 214 * 0.1, + 214 * 0.9 + 347 * 0.1, 189 * 0.9 + 889 * 0.1, 739] + ) + + def test_misidentify_epislon_0(self): + """""" + Test whether the misidentify method works as expected for epsilon = 0. + """""" + sfs = Spectrum([177595, 922, 363, 210, 164, 162, 712]) + + np.testing.assert_array_equal( + sfs.misidentify(0).data, + sfs.data + ) + + def test_misidentify_epislon_1(self): + """""" + Test whether the misidentify method works as expected for epsilon = 1. + """""" + sfs = Spectrum([177595, 922, 363, 210, 164, 162, 712]) + + np.testing.assert_array_equal( + sfs.misidentify(1).data, + [sfs.data[0]] + sfs.data[1:sfs.n][::-1].tolist() + [sfs.data[-1]] + ) + + def test_resample_spectrum(self): + """""" + Test whether the Poisson resample method works as expected. + """""" + sfs = Spectrum.standard_kingman(10, n_monomorphic=3 * 10 ** 6) * 1000 + + resampled = np.array([sfs.resample().data for _ in range(1000)]) + mean = resampled.mean(axis=0) + var = resampled.var(axis=0) + + self.assertLess(self.rel_diff(sfs.data, mean).max(), 5e-3) + + rel_var_diff = np.abs(var - mean) / mean + + self.assertLess(rel_var_diff[1:-1].max(), 0.2) + +","Python" +"Allele","Sendrowski/fastDFE","testing/test_config.py",".py","5977","167","import numpy as np +from numpy import testing + +from fastdfe import Config, BaseInference, SharedParams +from fastdfe.optimization import Covariate +from testing import TestCase + + +class ConfigTestCase(TestCase): + """""" + Test the Config class. + """""" + maxDiff = None + + config_file = ""testing/cache/configs/pendula_C_full_anc/config.yaml"" + init_file = ""resources/polydfe/init/C.full_anc_init"" + spectra_file = ""resources/polydfe/pendula/spectra/sfs.txt"" + + def assert_config_equal(self, observed: Config, expected: Config, exclude: list = []): + """""" + Assert that the two given configs are equal. + + :param observed: Observed config + :param expected: Expected config + :param exclude: Keys to exclude from comparison + """""" + d1 = dict((k, v) for k, v in observed.data.items() if k not in exclude) + d2 = dict((k, v) for k, v in expected.data.items() if k not in exclude) + + self.assertDictEqual(d1, d2) + + def test_parse_restore_polydfe_sfs_config(self): + """""" + Test whether the sfs config can be properly restored from file. + """""" + out_file = ""scratch/parse_restore_polydfe_sfs_config.txt"" + + # create config from sfs file + config = Config(polydfe_spectra_config=self.spectra_file) + + # recreate sfs config file + config.create_polydfe_sfs_config(out_file) + + # compare both files + # there were some rounding errors causing the last character to be different + testing.assert_equal(open(out_file).read()[:-1], open(out_file).read()[:-1]) + + def test_parse_restore_polydfe_init_file(self): + """""" + Check whether the init file can properly be stored from file. + Note that the init file will be different from the original + polyDFE init file as not all information is stored. + """""" + out_file = ""scratch/parse_restore_polydfe_init_file.txt"" + + # parse and recreate init file + config = Config(polydfe_init_file=self.init_file) + config.create_polydfe_init_file(out_file, 20) + + # create config from newly created init file + config2 = Config(polydfe_init_file=out_file) + + self.assert_config_equal(config, config2) + + def test_restore_config_from_file(self): + """""" + Check whether the config can be properly restored from file. + """""" + # load config from sfs and init file + config = Config( + polydfe_spectra_config=self.spectra_file, + polydfe_init_file=self.init_file + ) + + file = 'scratch/restore_config_from_file1.json' + file2 = 'scratch/restore_config_from_file2.json' + + # save config and restore from file + config.to_file(file) + config2 = config.from_file(file) + config2.to_file(file2) + + # compare original and restored config + testing.assert_equal(open(file).read(), open(file2).read()) + + # compare original json representation and restored json representation + testing.assert_equal(config.to_json(), Config.from_json(config.to_json()).to_json()) + + # compare original json representation and restored json representation + testing.assert_equal(config.to_yaml(), Config.from_yaml(config.to_yaml()).to_yaml()) + + def test_recreate_config_from_inference(self): + """""" + Load config from file, create inference object and recreate config from inference object. + """""" + config = Config.from_file(self.config_file) + + config2 = BaseInference.from_config(config).create_config() + + # 'bounds' and 'opts_mle' will be different + # because of the default specific to Inference. + self.assert_config_equal(config, config2, ['bounds', 'scales', 'opts_mle', 'sfs_neut', 'sfs_sel', 'x0']) + + def test_restore_shared_params(self): + """""" + Test whether shared params can be properly restored from file. + """""" + config = Config(shared_params=[ + SharedParams(params=['p_b', 'S_b'], types=['pendula', 'pubescens']), + SharedParams(params=['eps'], types=['example_1', 'example_2', 'pubescens']), + SharedParams(params=['b', 'S_d'], types=['example_1', 'example_2', 'example_3']) + ]) + + out = ""scratch/test_restore_shared_params.yaml"" + config.to_file(out) + + config2 = Config.from_file(out) + + self.assert_config_equal(config, config2) + + def test_restore_covariates(self): + """""" + Test whether covariates can be properly restored from file. + """""" + config = Config(covariates=[ + Covariate(param='S_d', values=dict(t1=1, t2=2)), + Covariate(param='xx', values=dict(bar=34)) + ]) + + out = ""scratch/test_restore_shared_params.yaml"" + config.to_file(out) + + config2 = Config.from_file(out) + + self.assert_config_equal(config, config2) + + @staticmethod + def test_download_config(): + """""" + Test whether the config can be properly downloaded from a URL. + """""" + config = Config.from_file( + ""https://github.com/Sendrowski/fastDFE/blob/master/"" + ""resources/configs/shared/pendula_tutorial/config.yaml?raw=true"" + ) + + np.testing.assert_equal( + config.data['sfs_neut'].data['all'].to_numpy(), + np.array([173705, 3294, 1115, 534, 326, 239, 225, 214, 231, 176, 73]) + ) + + @staticmethod + def test_download_config_no_cache(): + """""" + Test whether the config can be properly downloaded from a URL without caching. + """""" + config = Config.from_file( + ""https://github.com/Sendrowski/fastDFE/blob/master/"" + ""resources/configs/shared/pendula_tutorial/config.yaml?raw=true"", + cache=False + ) + + np.testing.assert_equal( + config.data['sfs_neut'].data['all'].to_numpy(), + np.array([173705, 3294, 1115, 534, 326, 239, 225, 214, 231, 176, 73]) + ) +","Python" +"Allele","Sendrowski/fastDFE","testing/test_polydfe_wrapper.py",".py","2210","78","import os + +import pytest + +from fastdfe.polydfe import PolyDFEResult, PolyDFE +from testing import TestCase + + +class PolyDFEWrapperTestCase(TestCase): + """""" + Test polyDFE wrapper. + """""" + + polydfe_bin = 'resources/polydfe/bin/polyDFE-2.0-macOS-64-bit' + postprocessing_source = 'resources/polydfe/postprocessing/script.R' + + config = ""testing/cache/configs/pendula_C_full_anc/config.yaml"" + serialized = ""testing/cache/polydfe/pendula_C_full_anc/serialized.json"" + + def test_run_polydfe_from_config(self): + """""" + Run polyDFE from config. + """""" + # run polyDFE + polydfe = PolyDFE.from_config_file(self.config) + polydfe.run( + output_file=f""scratch/test_run_polydfe_from_config.txt"", + binary=self.polydfe_bin, + postprocessing_source=self.postprocessing_source + ) + + polydfe.to_file(""scratch/test_run_polydfe_from_config.json"") + + def test_restore_serialized_wrapper(self): + """""" + Serialize polyDFE wrapper and restore. + """""" + # run polyDFE + polydfe = PolyDFE.from_config_file(self.config) + + polydfe.run( + output_file=""scratch/test_restore_serialized_wrapper.json"", + binary=self.polydfe_bin, + postprocessing_source=self.postprocessing_source + ) + + # serialize and restore from JSON + polydfe_restored = polydfe.from_json(polydfe.to_json()) + + # compare JSON representation + self.assertEqual(polydfe.to_json(), polydfe_restored.to_json()) + + @pytest.mark.slow + def test_run_bootstrap_sample(self): + """""" + Serialize polyDFE wrapper and restore. + """""" + # run polyDFE + polydfe = PolyDFE.from_file(self.serialized) + + config = polydfe.create_bootstrap() + + bootstrap = PolyDFE(config) + + bootstrap.run( + output_file=""scratch/test_run_bootstrap_sample.json"", + binary=self.polydfe_bin, + postprocessing_source=self.postprocessing_source + ) + + def test_visualize_inference(self): + """""" + Plot everything possible. + """""" + polydfe = PolyDFE.from_file(self.serialized) + + polydfe.plot_all() +","Python" +"Allele","Sendrowski/fastDFE","testing/conftest.py",".py","44","1","collect_ignore = [""test_polydfe_wrapper.py""]","Python" +"Allele","Sendrowski/fastDFE","testing/test_likelihood.py",".py","1874","51","import numpy as np +from scipy.special import factorial + +from fastdfe.likelihood import Likelihood +from testing import TestCase + + +class LikelihoodTestCase(TestCase): + """""" + Test the Likelihood class. + """""" + + def test_stirling_approximation(self): + """""" + Compare Stirling approximation of the factorial with its expected value. + Note that we can only do this for moderately low exponents due to overflow. + """""" + x = np.arange(100, 150) + + expected = np.log(factorial(x)) + observed = Likelihood.log_factorial_stirling(x) + + self.assertTrue(np.linalg.norm(expected - observed, ord=1) > 1e-05) + + def test_log_poisson(self): + """""" + Test the log poisson function. + """""" + comparisons = [ + dict(mu=1, k=1, places=50), + dict(mu=1, k=2, places=50), + dict(mu=11, k=32, places=12), # Likelihood.poisson becomes imprecise + dict(mu=0, k=0, places=45), # yields log likelihood very close to zero for approximation + dict(mu=0, k=1, places=50), # yields very low log likelihood + dict(mu=1, k=0, places=50), # yields log likelihood of -1 + ] + + for comp in comparisons: + expected = np.log(Likelihood.poisson(mu=np.array([comp['mu']]), k=np.array([comp['k']])))[0] + observed = Likelihood.log_poisson(mu=np.array([comp['mu']]), k=np.array([comp['k']]))[0] + self.assertAlmostEqual(expected, observed, places=comp['places']) + + def test_log_poisson_zero_entries(self): + """""" + Make sure the log poisson function does not return inf or nan values. + """""" + res = Likelihood.log_poisson(mu=np.array([1, 0, 0]), k=np.array([0, 1, 0])) + + # check that there are no inf or nan values + assert ((res == np.inf) | (np.isnan(res)) | (res == -np.inf)).sum() == 0 +","Python" +"Allele","Sendrowski/fastDFE","R/fastdfe.R",".R","19263","557","if (getRversion() >= ""2.15.1"") utils::globalVariables(c("".data"")) + +# vector of required packages +required_packages <- c(""reticulate"", ""ggplot2"", ""cowplot"", ""pheatmap"", ""RColorBrewer"", ""scales"") + +# install required R packages +for(package in required_packages){ + if(!package %in% installed.packages()[,""Package""]){ + install.packages(package) + } +} + +#' Check if the `fastdfe` Python module is installed +#' +#' This function uses the reticulate package to verify if the `fastdfe` Python +#' module is currently installed. +#' +#' @return Logical `TRUE` if the `fastdfe` Python module is installed, otherwise `FALSE`. +#' +#' @examples +#' \dontrun{ +#' is_installed() # Returns TRUE or FALSE based on the installation status of fastdfe +#' } +#' +#' @export +fastdfe_is_installed <- function() { + + # Check if fastdfe is installed + installed <- reticulate::py_module_available(""fastdfe"") + + return(installed) +} + + +#' Install the `fastdfe` Python module +#' +#' This function checks if the `fastdfe` Python module is available. +#' If not, or if the `force` argument is TRUE, it installs it via pip. +#' If the `silent` argument is set to TRUE, the function will not output a +#' message when the module is already installed. +#' +#' @param version A character string specifying the version of the `fastdfe` module +#' to install. Default is `NULL` which will install the latest version. +#' @param force Logical, if `TRUE` it will force the reinstallation of the `fastdfe` module +#' even if it's already available. Default is `FALSE`. +#' @param silent Logical, if `TRUE` it will suppress the message about `fastdfe` being +#' already installed. Default is `FALSE`. +#' +#' @return Invisible `NULL`. +#' +#' @examples +#' \dontrun{ +#' install_fastdfe() # Installs the latest version of fastdfe +#' install_fastdfe(""1.2.1"") # Installs version 1.2.1 of fastdfe +#' install_fastdfe(force = TRUE) # Reinstalls the fastdfe module +#' } +#' +#' @export +install_fastdfe <- function(version = NULL, force = FALSE, silent = FALSE, python_version = '3.11') { + + # Create the package string with the version if specified + package_name <- ""fastdfe"" + if (!is.null(version)) { + package_name <- paste0(package_name, ""=="", version) + } + + # Check if fastdfe is installed or if force is TRUE + if (force || !fastdfe_is_installed()) { + reticulate::py_install( + package_name, + method = ""conda"", + pip = TRUE, + python_version = python_version, + version = version, + ignore_installed = TRUE + ) + } else { + if (!silent) { + message(""The 'fastdfe' Python module is already installed."") + } + } + + invisible(NULL) +} + +#' Load the fastdfe library and associated visualization functions +#' +#' This function imports the Python package 'fastdfe' using the reticulate package +#' and then configures it to work seamlessly with R, overriding some of the default +#' visualization functions with custom R-based ones. This function also ensures +#' that required R libraries are loaded for visualization. +#' +#' @param install A logical. If TRUE, the function will attempt to run install_fastdfe(). +#' +#' @return A reference to the 'fastdfe' Python library loaded through reticulate. +#' This reference can be used to access 'fastdfe' functionalities. +#' +#' @examples +#' \dontrun{ +#' load_fastdfe(install = TRUE) +#' # now you can use fastdfe functionalities as per its API +#' } +#' +#' @seealso \link[reticulate]{import} for importing Python modules in R. +#' +#' @importFrom grDevices colorRampPalette dev.off pdf +#' @export +load_fastdfe <- function(install = FALSE) { + + # install if install flag is true + if (install) { + install_fastdfe(silent = TRUE) + } + + # configure plot + options(repr.plot.width = 4.6, repr.plot.height = 3.2) + + fd <- reticulate::import(""fastdfe"") + + # override python visualization functions + viz <- fd$visualization$Visualization + + # + # Plot discretized DFEs using a bar plot + # + # @param values List or numeric vector. Array of values of + # size `length(intervals) - 1`, containing the + # discretized DFE for each type. + # @param errors List or numeric vector. Array of errors of + # size `length(intervals) - 1`, containing the + # discretized DFE for each type. Default is `NULL`. + # @param labels List or character vector. Labels for the different types + # of DFEs. Default is `NULL`. + # @param file Character. File path to save plot to. Default is `NULL`. + # @param show Logical. Whether to show plot. Default is `TRUE`. + # @param intervals Numeric vector. Array of interval boundaries yielding + # `length(intervals) - 1` bars. Default + # is `c(-Inf, -100, -10, -1, 0, 1, Inf)`. + # @param title Character. Title of the plot. Default is 'discretized DFE'. + # @param interval_labels List of character. Labels for the intervals, + # which are the same for all types. Default is `NULL`. + # @param ... Additional arguments which are ignored + # + # @return A ggplot object. + viz$plot_discretized <- function( + values, + errors = NULL, + labels = NULL, + file = NULL, + show = TRUE, + intervals = c(-Inf, -100, -10, -1, 0, 1, Inf), + title = 'discretized DFE', + interval_labels = NULL, + ... + ) { + # number of intervals and DFEs + n_intervals <- length(intervals) - 1 + n_dfes <- length(values) + + # create data frame with x and y values + df <- data.frame(x = rep(1:n_intervals, n_dfes), + y = unlist(values)) + + # if labels provided, add as factor to data frame + if (is.null(labels)) { + labels <- as.character(1:n_dfes) + } + + df$group <- factor( + rep(labels, each = n_intervals), + levels = labels + ) + + # if errors provided, calculate ymin and ymax + if (!is.null(errors)) { + has_err <- vapply(errors, function(e) !is.null(e), logical(1)) + + if (any(has_err)) { + df$ymin <- unlist(lapply(seq_len(n_dfes), function(i) + if (has_err[i]) values[[i]] - errors[[i]][1, ] else rep(NA_real_, n_intervals) + )) + df$ymax <- unlist(lapply(seq_len(n_dfes), function(i) + if (has_err[i]) values[[i]] + errors[[i]][2, ] else rep(NA_real_, n_intervals) + )) + } + } + + # create labels for x-axis + if (is.null(interval_labels)) { + xlabels <- c() + for (i in 2:length(intervals)) { + xlabels <- c(xlabels, viz$interval_to_string(intervals[i - 1], + intervals[i])) + } + } else { + xlabels <- interval_labels + } + + # base plot with bars + p <- ggplot2::ggplot(df, ggplot2::aes(x = factor(.data$x), y = .data$y)) + + ggplot2::geom_bar(stat = ""identity"", position = ggplot2::position_dodge(), + show.legend = n_dfes > 1) + + ggplot2::scale_x_discrete(labels = xlabels, expand = ggplot2::expansion(mult = c(0, 0))) + + ggplot2::scale_y_continuous(expand = ggplot2::expansion(mult = c(0, 0.05))) + + ggplot2::labs(x = ""S"", y = ""fraction"", title = title) + + ggplot2::theme_bw() + + ggplot2::theme(panel.grid.major = ggplot2::element_blank(), + panel.grid.minor = ggplot2::element_blank()) + + # add group aesthetic if 'group' column present + if ('group' %in% colnames(df)) p <- p + ggplot2::aes(fill = .data$group) + + # add error bars if 'ymin' and 'ymax' columns present + if (all(c('ymin', 'ymax') %in% colnames(df))) { + p <- p + ggplot2::geom_errorbar(ggplot2::aes(ymin = .data$ymin, ymax = .data$ymax), + width = 0.2, + position = ggplot2::position_dodge(0.9)) + } + + # add legend on the right if labels were provided + if (!is.null(labels)) p <- p + ggplot2::theme(legend.position = ""right"") + + # display plot if 'show' is TRUE + if (show) print(p) + + # save plot to file if 'file' is provided + if (!is.null(file)) ggplot2::ggsave(file, plot = p) + + return(p) + } + + + # Visualize the inferred parameters and their confidence intervals + # using a bar plot. Note that there problems with parameters that span 0 (which is usually not the case). + # + # @param values List of numeric vectors. Dictionary of parameter values with the parameter in the same order as `labels`. + # @param labels List or character vector. Unique labels for the DFEs. + # @param param_names List or character vector. Labels for the parameters. + # @param errors List of numeric vectors. Dictionary of errors with the parameter in the same order as `labels`. + # @param file Character. File path to save plot to. Default is `NULL`. + # @param show Logical. Whether to show plot. Default is `TRUE`. + # @param title Character. Title of the plot. Default is 'parameter estimates'. + # @param legend Logical. Whether to show the legend. Default is `TRUE`. + # @param scale Character. Whether to use a linear or log scale. Default is 'log'. + # @param ... Additional arguments which are ignored + # + # @return A ggplot object. + viz$plot_inferred_parameters <- function( + values, + labels, + param_names, + errors = NULL, + file = NULL, + show = TRUE, + title = 'parameter estimates', + legend = TRUE, + scale = 'log', + ... + ) { + # number of types and parameters + n_types <- length(values) + n_params <- length(param_names) + + # create data frame with x, y values and track the negative values + negative_flags <- unlist(lapply(values, function(x) sapply(x, function(y) ifelse(y < 0, TRUE, FALSE)))) + df <- data.frame(x = rep(1:n_params, n_types), + y = unlist(lapply(values, function(x) sapply(x, abs)))) + + # Adjust the parameter names based on negative flags + updated_param_names <- param_names + for (i in 1:length(negative_flags)) { + if (negative_flags[i]) { + idx <- (i - 1) %% n_params + 1 + updated_param_names[idx] <- paste0(""-"", param_names[idx]) + } + } + + # if labels provided, add as factor to data frame + if (is.null(labels)) { + labels <- as.character(1:n_types) # create numeric labels if labels are NULL + } + df$group <- as.factor(rep(unlist(labels), each = n_params)) + + # if errors provided, add as y-error bars to data frame + if (!is.null(errors) && !is.null(errors[[1]])) { + df$ymin <- unlist(lapply(1:n_types, function(i) abs(values[[i]]) - errors[[i]][1, ])) + df$ymax <- unlist(lapply(1:n_types, function(i) abs(values[[i]]) + errors[[i]][2, ])) + } + + # base plot with bars + p <- ggplot2::ggplot(df, ggplot2::aes(x = factor(.data$x), y = .data$y)) + + ggplot2::geom_bar(stat = ""identity"", position = ggplot2::position_dodge(), + show.legend = n_types > 1) + + ggplot2::scale_x_discrete(labels = updated_param_names, expand = ggplot2::expansion(mult = c(0, 0))) + + ggplot2::labs(x = ""Parameters"", y = ""Values"", title = title) + + ggplot2::theme_bw() + + ggplot2::theme(panel.grid.major = ggplot2::element_blank(), + panel.grid.minor = ggplot2::element_blank()) + + # add group aesthetic if 'group' column present + if ('group' %in% colnames(df)) p <- p + ggplot2::aes(fill = .data$group) + + # add error bars if 'ymin' and 'ymax' columns present + if (all(c('ymin', 'ymax') %in% colnames(df))) { + p <- p + ggplot2::geom_errorbar(ggplot2::aes(ymin = .data$ymin, ymax = .data$ymax), + width = 0.2, + position = ggplot2::position_dodge(0.9)) + } + + # add legend on the right if labels were provided + if (legend) p <- p + ggplot2::theme(legend.position = ""right"") + + if (scale == ""log"") { + p <- p + ggplot2::scale_y_continuous( + trans = ""log10"", + expand = ggplot2::expansion(mult = c(0, 0.05)) + ) + } else { + p <- p + ggplot2::scale_y_continuous( + expand = ggplot2::expansion(mult = c(0, 0.05)) + ) + } + + # display plot if 'show' is TRUE + if (show) suppressWarnings(print(p)) + + # save plot to file if 'file' is provided + if (!is.null(file)) ggplot2::ggsave(file, plot = p) + + return(p) + } + + + # Create a scatter plot. + # + # @param values List or matrix. Values to plot. + # @param file Character. File path to save plot to. Default is NULL. + # @param show Logical. Whether to show plot. Default is TRUE. + # @param title Character. Title of plot. + # @param scale Character. Scale of y-axis. One of 'lin', 'log'. Default is 'lin'. + # + # @return A ggplot object. + viz$plot_scatter <- function( + values, + file = NULL, + show = TRUE, + title = NULL, + scale = 'lin', + ... + ) { + # Create data frame + data <- data.frame(x = seq_along(values), y = unlist(values)) + + # Create plot + p <- ggplot2::ggplot(data, ggplot2::aes(x = .data$x, y = .data$y)) + + ggplot2::geom_point() + + ggplot2::labs(title = title, y = 'lnl') + + # Set y scale + if (scale == 'log') { + p <- p + ggplot2::scale_y_continuous(trans = 'log10') + } + + # Display plot if 'show' is TRUE + if (show) print(p) + + # Save plot to file if 'file' is provided + if (!is.null(file)) ggplot2::ggsave(file, plot = p) + + return(p) + } + + + # Plot the given 1D spectra + # + # @param spectra List of lists of spectra or a 2D array in which each row + # is a spectrum in the same order as labels + # @param labels Character vector. Labels for each spectrum + # @param log_scale Logical. Whether to use logarithmic y-scale + # @param use_subplots Logical. Whether to use subplots + # @param show_monomorphic Logical. Whether to show monomorphic site counts + # @param title Character. Title of plot + # @param n_ticks Numeric. Number of x-ticks to use + # @param file Character. File to save plot to + # @param show Logical. Whether to show the plot + # + # @return ggplot object + viz$plot_spectra <- function( + spectra, + labels = character(0), + log_scale = FALSE, + use_subplots = FALSE, + show_monomorphic = FALSE, + title = NULL, + file = NULL, + show = TRUE, + ... + ) { + + if (length(spectra) == 0) { + warning('No spectra to plot.') + return(NULL) + } + + if (use_subplots) { + # Creating a grid of plots + plot_list <- lapply(1:length(spectra), function(i) { + viz$plot_spectra( + spectra = list(spectra[[i]]), + labels = if (length(labels)) labels[i] else character(0), + log_scale = log_scale, + show_monomorphic = show_monomorphic, + show = FALSE + ) + + ggplot2::labs(title = if (length(labels) >= i) labels[i] else '') + }) + + plot_grid <- cowplot::plot_grid(plotlist = plot_list) + + if (show) print(plot_grid) + if (!is.null(file)) ggplot2::ggsave(file, plot = plot_grid) + + return(plot_grid) + } + + if (length(labels) == 0) { + labels <- as.character(1:length(spectra)) + } + + df <- data.frame() + for (i in seq_along(spectra)) { + indices <- if (show_monomorphic) seq_along(spectra[[i]]) else seq_along(spectra[[i]])[-c(1, length(spectra[[i]]))] + heights <- if (show_monomorphic) unlist(spectra[[i]]) else unlist(spectra[[i]][-c(1, length(spectra[[i]]))]) + df_temp <- data.frame(indices = indices, + heights = heights, + group = rep(labels[i], length(indices))) + df <- rbind(df, df_temp) + } + + # Create a ggplot object + p <- ggplot2::ggplot(df, ggplot2::aes(x = indices, y = heights, fill = .data$group)) + + ggplot2::geom_bar(stat = ""identity"", position = ""dodge"", + width = 0.7, show.legend = length(spectra) > 1) + + ggplot2::labs(x = ""frequency"", y = """", title = title) + + ggplot2::theme_bw() + + ggplot2::theme(panel.grid.major = ggplot2::element_blank(), + panel.grid.minor = ggplot2::element_blank()) + + ggplot2::scale_y_continuous(expand = ggplot2::expansion(mult = c(0, .1))) + + if (log_scale) { + p <- p + ggplot2::scale_y_log10() + } + + # Adjust x-axis labels based on show_monomorphic + if (show_monomorphic) { + p <- p + ggplot2::scale_x_continuous(breaks = 0:(length(spectra[[1]]) + 1), + labels = 0:(length(spectra[[1]]) + 1) - 1, + expand = c(0, 0)) + } else { + p <- p + ggplot2::scale_x_continuous(breaks = 1:length(spectra[[1]]), + labels = 1:length(spectra[[1]]) - 1, + expand = c(0, 0)) + } + + # Display or save the plot + if (show) print(p) + if (!is.null(file)) ggplot2::ggsave(file, plot = p) + + return(p) + } + + + # Plot p-values of nested likelihoods. + # + # @param P Matrix of p-values + # @param labels_x Labels for x-axis + # @param labels_y Labels for y-axis + # @param file File to save plot to + # @param show Whether to show plot + # @param cmap Colormap to use + # @param title Title of plot + # @param vmin Minimum value for colorbar + # @param vmax Maximum value for colorbar + # + # @return NULL + viz$plot_nested_models <- function( + P, + labels_x, + labels_y, + file = NULL, + show = TRUE, + cmap = NULL, + title = NULL, + vmin = 1e-10, + vmax = 1, + ... + ) { + # Format number to be displayed. + format_number <- function(x) { + if (is.null(x) || is.na(x) || x == 0) { + return(0) + } + + if (x < 0.0001) { + return(format(x, scientific = TRUE)) + } + + return(round(x, 4)) + } + + # Convert list to matrix and replace NULLs with NAs + P <- sapply(P, function(x) ifelse(is.null(x), NA, x)) + P_mat <- matrix(P, nrow = sqrt(length(P)), ncol = sqrt(length(P)), byrow = TRUE) + + # Determine values to display + annotation <- apply(P_mat, c(1, 2), function(x) as.character(format_number(x))) + annotation[is.na(P_mat)] <- '-' + + # Change NAs to 1 to get a nicer color + P_mat[is.na(P_mat)] <- NA + + # Keep within color bar bounds + P_mat[P_mat < vmin] <- vmin + P_mat[P_mat > vmax] <- vmax + + # Default color map + if (is.null(cmap)) { + cmap <- rev(colorRampPalette(RColorBrewer::brewer.pal(9, ""YlOrRd""))(100)) + } + + # Plot heatmap + p = pheatmap::pheatmap(mat = P_mat, color = cmap, + cluster_rows = FALSE, cluster_cols = FALSE, + display_numbers = TRUE, legend = TRUE, + breaks = seq(vmin, 0.1, length.out = 101), + labels_row = gsub(""_"", "" "", labels_y), + labels_col = gsub(""_"", "" "", labels_x), + angle_col = 45, + cellheight = 40, + cellwidth = 40, + main = title + ) + + if (!is.null(file)) { + pdf(file) + print(p) + dev.off() + } + + if (!show) { + dev.off() + } + } + + return(fd) +} +","R" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_maximum_likelihood_ancestral_annotation.py",".py","419","18","# example for ancestral allele annotation +import fastdfe as fd + +ann = fd.Annotator( + vcf=""https://github.com/Sendrowski/fastDFE/"" + ""blob/dev/resources/genome/betula/all."" + ""with_outgroups.subset.10000.vcf.gz?raw=true"", + annotations=[fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + n_ingroups=15 + )], + output=""genome.polarized.vcf.gz"" +) + +ann.annotate() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/convert_plink.py",".py","351","17",""""""" +Convert VCF file to plink format. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +from snakemake.shell import shell + +vcf = snakemake.input[0] +out = snakemake.output[0] +prefix = out[:out.rfind(""."")] + +# create bed, bim and fam files +shell(f""plink --vcf {vcf} --out {prefix} --allow-extra-chr"") +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/fold_sfs.py",".py","487","24",""""""" +Fold SFS +"""""" + + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + file = snakemake.input[0] + out = snakemake.output[0] +except NameError: + # testing + testing = True + file = ""results/sfs/hg38/chr/chr22.degeneracy/ingroup_pan_troglodytes/outgroups_ref_gorilla_gorilla_gorilla.ref_pongo_abelii/sfs.11.csv"" + out = f""scratch/folded_sfs.csv"" + +import fastdfe as fd + +fd.Spectra.from_file(file).fold().to_file(out) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_allele_counts.py",".py","1632","70",""""""" +Visualize the expected allele counts. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-06"" + +import numpy as np +from matplotlib import pyplot as plt + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + n = snakemake.params.n + out = snakemake.output[0] +except ModuleNotFoundError: + # testing + testing = True + n = 7 + out = ""scratch/allele_counts.png"" + +from fastdfe.discretization import Discretization + +d = Discretization( + n=n, + intervals_ben=(1e-15, 1000, 1000), + intervals_del=(-1000000, -1e-15, 1000) +) + +fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, figsize=(6, 6)) +fig.tight_layout(pad=4) + +ones = np.ones(d.n_intervals - 1) + +for i in range(1, n): + ax1.plot(np.arange(d.n_intervals - 1), d.get_counts_semidominant_unregularized(d.s[d.s != 0], i * ones), label=f""i={i}"") + ax2.plot(np.arange(d.n_intervals - 1), d.get_counts_semidominant_regularized(d.s[d.s != 0], i * ones), + label=f""i={i}"") + +ax1.set_title('allele counts') +ax2.set_title('regularized allele counts') + +for ax in (ax1, ax2): + ax.set_xlabel('$S$') + ax.set_ylabel('$P_{sel}(i, S)$') + + xticks = plt.gca().get_xticks() + labels = [""{:.0e}"".format(d.s[int(l)]) if 0 <= int(l) < d.n_intervals else None for l in xticks] + ax.set_xticklabels(labels) + + ax.legend(ncol=2, prop=dict(size=10)) + + ax.margins(x=0) + + ax.set_xlim(left=0, right=d.n_intervals - 1) + +plt.savefig(out, dpi=400, bbox_inches='tight', pad_inches=0) + +if testing: + plt.show() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/derive_ancestral_alleles.py",".py","483","21",""""""" +Derive the ancestral alleles using EST-SFS. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +from snakemake.shell import shell + +data = snakemake.input.data +seed = snakemake.input.seed +config = snakemake.input.config +bin = snakemake.input.bin +out_sfs = snakemake.output.sfs +out_probs = snakemake.output.probs +tmp_dir = snakemake.resources.tmpdir + +# execute command +shell(f""{bin} {config} {data} {seed} {out_sfs} {out_probs}"") +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_dfe_comparison.py",".py","753","34",""""""" +Visualize DFE inference results. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-02"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + inputs = snakemake.input + out_dfe_discretized = snakemake.output[0] +except NameError: + # testing + testing = True + inputs = [ + ""results/fastdfe/pendula_C_full_bootstrapped_100/serialized.json"", + ""results/fastdfe/pubescens_C_full_bootstrapped_100/serialized.json"" + ] + out = ""scratch/comp.png"" + +import fastdfe as fd + +inferences = [fd.BaseInference.from_file(input) for input in inputs] + +fd.Inference.plot_discretized(inferences, labels=['pendula', 'pubescens']) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/create_config_covariates_arabidopsis.py",".py","2268","99",""""""" +Create config file for joint inference of Arabidopsis thaliana. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-06-06"" + +import pandas as pd + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + sfs_file = snakemake.input[0] + col = snakemake.params.col + n_bins = snakemake.params.n_bins + subsample_size = snakemake.params.subsample_size + param = snakemake.params.param + out = snakemake.output[0] +except NameError: + # testing + testing = True + sfs_file = ""results/sfs_covariates/arabidopsis.csv"" + col = 'mean.rsa' + n_bins = 15 + subsample_size = 20 + param = 'S_d' + out = ""scratch/sfs_arabidopsis.yaml"" + +import fastdfe as fd + +# read SFS stratified by gene +genes = pd.read_csv(sfs_file, sep=""\t"") + +genes['count'] = 1 + +# create bins +genes['group'] = pd.qcut( + x=genes[col], + q=n_bins, + labels=[f""bin_{i}"" for i in range(n_bins)], +) + +# group by bins +grouped = genes.groupby('group', observed=True) + +# extract SFS +cols_neut = ['Lps'] + [f'sfsS{i}' for i in range(1, 105)] + ['Ds'] +cols_sel = ['Lpn'] + [f'sfsN{i}' for i in range(1, 105)] + ['Dn'] + +# create spectra objects +sfs_neut = fd.Spectra.from_dict( + {k: r.values for k, r in grouped.sum()[cols_neut].iterrows()} +) + +sfs_sel = fd.Spectra.from_dict( + {k: r.values for k, r in grouped.sum()[cols_sel].iterrows()} +) + +# determine average value of covariate in each bin +cov = grouped[col].mean() + +# shuffle covariate values for testing +# cov = dict(zip(cov.index, np.random.permutation(cov.values))) + +# create covariate object +covariates = fd.Covariate( + param=param, + values=dict((t, cov[t]) for t in sfs_neut.types) +) + +# create config object +config = fd.Config( + sfs_neut=sfs_neut.subsample(subsample_size), + sfs_sel=sfs_sel.subsample(subsample_size), + shared_params=[fd.SharedParams(params='all', types='all')], + covariates=[covariates], + n_runs=20, + n_bootstraps=100, + do_bootstrap=True, + parallelize=True +) + +# plot SFS +if testing: + (config.data['sfs_neut'].prefix('neutral') + config.data['sfs_sel'].prefix('selected')).plot( + show=testing, + use_subplots=True + ) + +# save config +config.to_file(out) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/compare_inferred_observed_monomorphic.R",".R","1621","61","library(fastdfe) + +fd <- load_fastdfe() + +# url for fastdfe repo +url = ""https://github.com/Sendrowski/fastDFE/blob/dev/resources/genome/betula/"" + +# create parser where we consider monomorphic sites +p <- fd$Parser( + vcf = paste0(url, ""all.with_outgroups.subset.200000.vcf.gz?raw=true""), + fasta = paste0(url, ""genome.subset.1000.fasta.gz?raw=true""), + gff = paste0(url, ""genome.gff.gz?raw=true""), + target_site_counter = NULL, + n = 10, + annotations = c(fd$DegeneracyAnnotation()), + filtrations = c(fd$CodingSequenceFiltration()), + stratifications = c(fd$DegeneracyStratification()) +) + +sfs <- p$parse() + +sfs$plot(title = ""observed"") + +# create parser where we infer monomrphic sites +p2 = fd$Parser( + vcf = paste0(url, ""all.with_outgroups.subset.200000.vcf.gz?raw=true""), + fasta = paste0(url, ""genome.subset.1000.fasta.gz?raw=true""), + gff = paste0(url, ""genome.gff.gz?raw=true""), + target_site_counter = fd$TargetSiteCounter( + n_samples = 1000000, + n_target_sites = sum(sfs$n_sites) + ), + n = 10, + annotations = c(fd$DegeneracyAnnotation()), + filtrations = c(fd$CodingSequenceFiltration()), + stratifications = c(fd$DegeneracyStratification()) +) + +sfs2 <- p2$parse() + +sfs$plot(title = ""inferred"") + +infs <- list() +spectra <- list(sfs, sfs2) + +for (i in seq_along(spectra)) { + inf <- fd$BaseInference( + sfs_neut = spectra[[i]]$select('neutral'), + sfs_sel = spectra[[i]]$select('selected'), + do_bootstrap = TRUE, + model = fd$DiscreteFractionalParametrization(), + ) + + inf$run() + + infs[[i]] <- inf +} + +# plot inferred DFEs +fd$Inference$plot_discretized(infs, labels = c('monomorphic', 'inferred')) +","R" +"Allele","Sendrowski/fastDFE","snakemake/scripts/prepare_input_est_sfs.py",".py","4441","137",""""""" +Prepare the input for est-sfs. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +import os +from typing import Dict + +import numpy as np +import pandas as pd +from cyvcf2 import VCF +from tqdm import tqdm + +try: + vcf_file = snakemake.input.vcf + ingroups_file = snakemake.input.ingroups + outgroups_file = snakemake.input.outgroups + out_data = snakemake.output.data + n_outgroups = snakemake.config['n_outgroup'] + n_max_subsamples = snakemake.config['n_samples'] + seed = snakemake.config.get('seed', 0) +except NameError: + # testing + vcf_file = ""../resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" + ingroups_file = ""../resources/genome/betula/sample_sets/birch.args"" + outgroups_file = ""../resources/genome/betula/sample_sets/outgroups.args"" + out_data = ""scratch/est-sfs.data.txt"" + n_outgroups = 2 + n_max_subsamples = 50 + seed = 0 + +rng = np.random.default_rng(seed=seed) + + +def subsample(bases: np.ndarray, size: int) -> np.ndarray: + """""" + Subsample a set of bases. + + :param bases: A list of bases. + :param size: The size of the subsample. + :return: A subsample of the bases. + """""" + # return an empty array when there are no haplotypes + # this can happen for an uncalled outgroup site + if len(bases) == 0: + return np.array([]) + + # sample with replacement if the number of haplotypes is less than the subsample size + if len(bases) < size: + return np.array(bases)[rng.choice(len(bases), size=size, replace=True)] + + return np.array(bases)[rng.choice(len(bases), size=size, replace=False)] + + +def count(bases: np.ndarray) -> Dict[str, int]: + """""" + Count the number of bases in a list of haplotypes. + + :param bases: Array of bases. + :return: A dictionary of base counts. + """""" + counts = {'A': 0, 'C': 0, 'G': 0, 'T': 0} + + for key, value in zip(*np.unique(bases, return_counts=True)): + counts[key] = value + + return counts + + +def base_dict_to_string(d: Dict[str, int]) -> str: + """""" + Convert a dictionary of bases to a string. + + :param d: A dictionary of base counts. + :return: A string of base counts. + """""" + return ','.join(map(str, [d['A'], d['C'], d['G'], d['T']])) + + +def get_called_bases(calls: np.ndarray) -> np.ndarray: + """""" + Get the called bases from a list of calls. + + :param calls: Array of calls. + :return: Array of called bases. + """""" + return np.array([b for b in '/'.join(calls).replace('|', '/') if b in 'ACGT']) + + +# load ingroup and outgroup samples +ingroups = pd.read_csv(ingroups_file, header=None, index_col=False)[0].tolist() +outgroups = pd.read_csv(outgroups_file, header=None, index_col=False)[0].tolist() + +# number of subsamples to sample from haplotypes +n_subsamples = min(n_max_subsamples, len(ingroups)) + +# write to data file +with open(out_data, 'w') as f: + # create reader + vcf_reader = VCF(vcf_file) + + # raise error if outgroup samples are not in VCF + if not set(outgroups).issubset(set(vcf_reader.samples)): + raise ValueError(""Outgroup samples not in VCF."") + + # get indices of ingroup and outgroup samples + ingroup_mask = [sample in ingroups for sample in vcf_reader.samples] + outgroup_mask = [sample in outgroups for sample in vcf_reader.samples] + + for variant in tqdm(vcf_reader): + + # Only do inference for bi-allelic SNPs. + if variant.is_snp: + + # get base counts for outgroup samples + outgroup_counts = get_called_bases(variant.gt_bases[outgroup_mask]) + + # Only do inference for bi-allelic SNPs for which + # at least ``n_outgroups`` outgroup samples are called + if len(variant.ALT) == 1 and len(outgroup_counts) >= n_outgroups: + + # get base counts for ingroup samples + ingroup_counts = count(subsample(get_called_bases(variant.gt_bases[ingroup_mask]), n_subsamples)) + + # subsample outgroup samples + outgroup_subsamples = subsample(outgroup_counts, n_outgroups) + + # create a base count dictionary for each haplotype + outgroup_dicts = [dict(A=0, C=0, G=0, T=0) for _ in range(n_outgroups)] + for i, sub in enumerate(outgroup_subsamples): + outgroup_dicts[i][sub] = 1 + + f.write(' '.join([base_dict_to_string(r) for r in [ingroup_counts] + outgroup_dicts]) + os.linesep) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/compare_dist_dominance.py",".py","2611","99",""""""" +Compare distance including dominance with distance excluding dominance +"""""" +from math import pi +from typing import Callable + +import numpy as np +import scipy.special as sp +from matplotlib import pyplot as plt + +from fastdfe.discretization import Discretization + + +def integral(S, h, x): + """""" + Indefinite integral of the function + """""" + erf = sp.erfi if S > 0 else sp.erf + + return ( + np.sqrt(pi) * np.exp(np.float128(h ** 2 * S / (1 - 2 * h))) / + (2 * np.sqrt(4 * h - 2) * np.sqrt(np.abs(S) / 2)) * + erf(np.sqrt(np.abs(S) / 2) * (h * (2 * x - 1) - x) / np.sqrt(h - 0.5)) + ) + + +def f(x, S, h): + """""" + Allele frequency distribution for scaled selection coefficient S and dominance h + """""" + return ( + np.exp(np.float128(2 * S * h * x + S * (1 - 2 * h) * x ** 2)) / + (x * (1 - x)) * + (integral(S, h, 1) - integral(S, h, x)) / + (integral(S, h, 1) - integral(S, h, 0)) + ) + + +comp = {} +for (x, S) in [(0.1, 1)]: + comp[(x, S)] = (f(x=x, S=S, h=0.6), Discretization.get_counts_high_precision_regularized(x=x, S=S)) + + +def plot_surface(ax: plt.Axes, func: Callable, title: str): + """""" + Plot the surface plot of the function + + :param ax: The axis object to plot on + :param func: The function to plot + :param title: Title for the subplot + """""" + # Parameters + x_vals = np.linspace(0.01, 0.99, 100) # allele frequencies + S_vals = np.linspace(-100, 100, 100) # selection coefficients + + # Compute the function values + X, S = np.meshgrid(x_vals, S_vals) + Z = np.array([func(x, s) for x, s in zip(np.ravel(X), np.ravel(S))]) + Z = Z.reshape(X.shape) + + # Surface plot + surf = ax.plot_surface(X, S, Z, cmap='viridis', edgecolor='none') + ax.set_xlabel('x') + ax.set_ylabel('S') + ax.set_zlabel('f') + ax.set_title(title) + + # Color bar for surface plot + fig.colorbar(surf, ax=ax, shrink=0.5, aspect=5) + + +# Create a figure with two subplots +fig = plt.figure(figsize=(14, 7)) + +# First subplot for f(x, S, h=0.6) +ax1 = fig.add_subplot(121, projection='3d') +plot_surface(ax1, lambda x, S: f(x, S, h=0.6), title=""f(x, S, h=0.6)"") + +# Second subplot for discretization.H_regularized +ax2 = fig.add_subplot(122, projection='3d') +plot_surface(ax2, Discretization.get_counts_high_precision_regularized, title=""discretization.H_regularized"") + +plt.tight_layout() +plt.show() + +S = 20 +q = np.linspace(0.01, 0.99, 100) +h_vals = np.array([0.1, 0.6, 1, 1.3]) + +for h in h_vals: + plt.plot(q, f(q, S, h), label=f""h={h}"") + +plt.legend() +plt.xlabel(""q"") +plt.ylabel(""f(q)"") +plt.show() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_filterer.py",".py","555","16","import fastdfe as fd + +# only keep variants in coding sequences +f = fd.Filterer( + vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" + ""1000_genomes_project/release/20181203_biallelic_SNV/"" + ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", + gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", + output='scratch/sapiens.chr21.coding.vcf', + filtrations=[fd.CodingSequenceFiltration()], + aliases=dict(chr21=['21']), +) + +f.filter() +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_joint_inference.py",".py","1209","41",""""""" +Visualize a DFE inference. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + testing = False + serialized = snakemake.input[0] + out_dfe = snakemake.output.get('dfe', None) + out_spectra = snakemake.output.get('spectra', None) + out_params = snakemake.output.get('params', None) +except NameError: + # testing + testing = True + # config_file = 'results/configs/example_1_C_full_anc/config.yaml' + # config_file = 'results/configs/example_1_C_deleterious_anc_bootstrapped_100/config.yaml' + # config_file = 'results/configs/pendula_C_full_anc_bootstrapped_100/config.yaml' + serialized = 'results/fastdfe/hominidae/cov/S_d.serialized.json' + out_dfe = ""scratch/dfe.png"" + out_spectra = ""scratch/spectra.png"" + out_params = ""scratch/params.png"" + +from fastdfe import JointInference + +# create from config +inf = JointInference.from_file(serialized) + +# plot results +inf.plot_inferred_parameters(file=out_params, show=testing) +inf.plot_sfs_comparison(file=out_spectra, show=testing) +inf.plot_discretized(file=out_dfe, show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/compute_sfs_slim.py",".py","3282","128",""""""" +Compute the site frequency spectrum (SFS) for selected and neutral sites in a tree sequence. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2024-02-26"" + +import random + +import matplotlib.pyplot as plt +import msprime as ms +import numpy as np +import pandas as pd +import tskit +from scipy.stats import hypergeom +from tqdm import tqdm + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + file_in = snakemake.input[0] + n = snakemake.params.n + mu = snakemake.params.mu + L = snakemake.params.L + N = snakemake.params.N + out = snakemake.output.sfs + out_ds_continuous = snakemake.output.ds_continuous + out_ds_discretized = snakemake.output.ds_discretized +except NameError: + # testing + testing = True + file_in = ""results/slim/n_replicate=1/g=10000/L=10000000000/mu=1e-09/r=1e-09/N=1000/s_b=0.05/b=1/s_d=0.1/p_b=0.2/sequence.trees"" + n = 10 + mu = 1e-9 + L = 10000000000 + N = 1000 + out = ""scratch/slim_sfs.csv"" + out_ds_continuous = ""scratch/slim_dfe.png"" + out_ds_discretized = ""scratch/slim_discretized.png"" + +# load the tree sequence +ts = tskit.load(file_in) + +j = 0 +sfs_sel = np.zeros(n + 1) +n_repeat_sel = 0 +# selection coefficients +s = np.zeros(ts.num_mutations) + +for i, var in tqdm(enumerate(ts.variants()), desc='Computing selected SFS'): + for mut in var.site.mutations: + s[j] = mut.metadata['mutation_list'][0]['selection_coeff'] + j += 1 + + n_repeat_sel += int(len(var.site.mutations) > 1) + + # add hypergeometric counts + sfs_sel += hypergeom.pmf(k=range(n + 1), M=ts.sample_size, n=np.sum(var.genotypes > 0), N=n) + +print(f""Repeat mutations (selected): {n_repeat_sel}"") + +# add monomorphic sites +sfs_sel[0] = L - sfs_sel.sum() + +# simulate neutral mutations +ts = ms.sim_mutations(ts, rate=mu, keep=False) + +sfs_neut = np.zeros(n + 1) +n_repeat_neut = 0 + +for var in tqdm(ts.variants(), desc='Computing neutral SFS'): + n_repeat_neut += int(len(var.site.mutations) > 1) + sfs_neut += hypergeom.pmf(k=range(n + 1), M=ts.sample_size, n=np.sum(var.genotypes > 0), N=n) + +print(f""Repeat mutations (neutral): {n_repeat_neut}"") + +# add monomorphic sites +sfs_neut[0] = L - sfs_neut.sum() + +# save as csv using pandas +spectra = pd.DataFrame(dict(neutral=sfs_neut, selected=sfs_sel)) + +spectra.to_csv(out, index=False) + +# determine Ne from sfs_neut using Watterson's estimator +theta = sum(sfs_neut[1:-1]) / np.sum(1 / np.arange(1, n)) / sum(sfs_neut) +# theta = 4 * Ne * mu -> Ne = theta / (4 * mu) +Ne = theta / (4 * mu) + +S = 4 * Ne * s + +# plot histogram of selection coefficients +plt.hist(S, bins=400, density=True) + +# set upper and lower bounds to 1 and 99th percentiles +plt.xlim(np.percentile(S, 1), np.percentile(S, 99)) +plt.xlabel('S') +plt.title(f'Observed S, $N_e$ = {Ne:.2f}') +plt.margins(x=0) + +plt.savefig(out_ds_continuous) + +if testing: + plt.show() + +plt.clf() + +# bin the selection coefficients +values, _ = np.histogram(S, bins=[-np.inf, -100, -10, -1, 0, 1, np.inf]) +values = values / np.sum(values) + +plt.bar(['<-100', '-100:-10', '-10:-1', '-1:0', '0:1', '>1'], values) +plt.xlabel('S') +plt.title(f'Observed S, $N_e$ = {Ne:.2f}') +plt.margins(x=0) + +plt.savefig(out_ds_discretized) + +if testing: + plt.show() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/compare_dfe_sample_sizes.py",".py","4467","149","import sys + +# necessary to import fastdfe locally +sys.path.append('.') + +import numpy as np +from matplotlib import pyplot as plt +import fastdfe as fd + +try: + testing = False + n_dfes = 6 + n_runs = 10 + n_bootstraps = 100 + n_bootstrap_retries = 2 + n_fixed = 20 + intervals_del = (-1.0e+8, -1.0e-5, 1000) + intervals_ben = (1.0e-5, 1.0e4, 1000) + out = snakemake.output[0] +except NameError: + # testing + testing = True + n_dfes = 2 + n_runs = 1 + n_bootstraps = 4 + n_bootstrap_retries = 1 + n_fixed = 20 + intervals_del = (-1.0e+8, -1.0e-5, 100) + intervals_ben = (1.0e-5, 1.0e4, 100) + out = ""scratch/compare_dfe_accuracy.png"" + +fig, ax = plt.subplots(2, 2, figsize=(10.5, 6)) + +plt.rcParams['xtick.labelsize'] = 9 +plt.rcParams[""axes.prop_cycle""] = plt.cycler(color=plt.cm.viridis(np.linspace(0.15, 1, n_dfes + 1))) + +params = [dict(S_d=-300, b=0.3, p_b=0, S_b=1), dict(S_d=-300, b=0.3, p_b=0.05, S_b=1)] + + +def sci(x): + base, exp = f""{x:e}"".split(""e"") + return f""{int(np.round(float(base)))}e{int(exp)}"" + + +for i, param in enumerate(params): + + dfes = {} + spectra = {} + + for n in np.logspace(np.log10(6), np.log10(100), n_dfes).astype(int): + sim = fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=n, n_sites=1e7, theta=1e-5), + intervals_ben=intervals_ben, + intervals_del=intervals_del, + params=param, + model=fd.GammaExpParametrization() + ) + + sim.run() + + s = sim.get_spectra() + s.data *= 10000 / s.n_polymorphic + + inf = fd.BaseInference( + sfs_neut=s['neutral'], + sfs_sel=s['selected'], + intervals_ben=intervals_ben, + intervals_del=intervals_del, + fixed_params=dict(all=dict(h=0.5, eps=0) | (dict(p_b=0, S_b=1) if param['p_b'] == 0 else {})), + n_runs=n_runs, + n_bootstraps=n_bootstraps, + n_bootstrap_retries=n_bootstrap_retries + ) + + inf.run() + + spectra[n] = inf.get_spectra()[['neutral', 'selected']] + dfes[n] = inf.get_dfe() + + param_str = ', '.join([f'{k}={v}' for k, v in param.items() if k in ['S_d', 'b', 'p_b', 'S_b']]) + fd.DFE.plot_many( + [sim.dfe] + list(dfes.values()), + labels=np.arange(len(dfes) + 1).astype(str), + point_estimate='mean', + # intervals=[-np.inf, -100, -10, -1, 1, np.inf], + ax=ax[i, 0], + title=f""SFS sample sizes $({param_str})$"", + show=False + ) + + labels = ([""true DFE""] + + [f""n={n},{'':<{3 - int(np.log10(n))}}#SNP={sci(spectra[n].all.n_polymorphic)}"" for n in dfes.keys()]) + ax[i, 0].legend(ax[i, 0].get_legend_handles_labels()[0], labels, prop={""family"": ""monospace"", ""size"": 8}) + + dfes = {} + spectra = {} + + for n_snps in np.logspace(3, 6, n_dfes) * 1.5: + sim = fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=n_fixed, n_sites=1e7, theta=1e-5), + intervals_ben=intervals_ben, + intervals_del=intervals_del, + params=param, + model=fd.GammaExpParametrization() + ) + + sim.run() + + s = sim.get_spectra() + s.data *= n_snps / s.n_polymorphic + + inf = fd.BaseInference( + sfs_neut=s['neutral'], + sfs_sel=s['selected'], + intervals_ben=intervals_ben, + intervals_del=intervals_del, + fixed_params=dict(all=dict(h=0.5, eps=0) | (dict(p_b=0, S_b=1) if param['p_b'] == 0 else {})), + n_runs=n_runs, + n_bootstraps=n_bootstraps, + n_bootstrap_retries=n_bootstrap_retries + ) + + inf.run() + + spectra[n_snps] = inf.get_spectra()[['neutral', 'selected']] + dfes[n_snps] = inf.get_dfe() + + param_str = ', '.join([f'{k}={v}' for k, v in param.items() if k in ['S_d', 'b', 'p_b', 'S_b']]) + fd.DFE.plot_many( + [sim.dfe] + list(dfes.values()), + labels=np.arange(len(dfes) + 1).astype(str), + point_estimate='mean', + # intervals=[-np.inf, -100, -10, -1, 1, np.inf], + ax=ax[i, 1], + title=f""Number of SNPs $({param_str})$"", + show=False + ) + + labels = [""true DFE""] + [f""n={n_fixed}, #SNP={sci(spectra[theta].all.n_polymorphic)}"" for theta in dfes.keys()] + ax[i, 1].legend(ax[i, 1].get_legend_handles_labels()[0], labels, prop={""family"": ""monospace"", ""size"": 8}) + +plt.tight_layout() +fig.savefig(out, dpi=200) + +if testing: + plt.show() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/create_config_covariates_hominidae.py",".py","1887","70",""""""" +Check for covariates in the great ape dataset. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-31"" + +import pandas as pd + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + testing = False + types = snakemake.params.types + param = snakemake.params.param + sfs_neutral = snakemake.input.neutral + sfs_selected = snakemake.input.selected + out = snakemake.output[0] +except NameError: + # testing + testing = True + types = [ + 'bonobo', + 'bornean_orang', + 'central_chimp', + 'eastern_chimp', + 'human', + 'NC_chimp', + 'sumatran_orang', + 'western_chimp', + 'western_lowland_gorilla' + ] + param = 'S_d' + sfs_neutral = [f'../resources/SFS/hominidae/uSFS/{t}_4fold_all_sfs.txt' for t in types] + sfs_selected = [f'../resources/SFS/hominidae/uSFS/{t}_0fold_all_sfs.txt' for t in types] + out = ""scratch/joint_inference.yaml"" + +from fastdfe import Config, Spectra, Spectrum, Covariate, SharedParams + + +def get_sfs(file: str) -> Spectrum: + """""" + Get SFS from file. + + :param file: The file to read the SFS from. + :return: The SFS. + """""" + return Spectrum(pd.read_csv(file, header=None).iloc[0].tolist()) + + +config = Config( + sfs_neut=Spectra.from_spectra(dict((t, get_sfs(sfs_neutral[i])) for i, t in enumerate(types))), + sfs_sel=Spectra.from_spectra(dict((t, get_sfs(sfs_selected[i])) for i, t in enumerate(types))), + do_bootstrap=True, + n_bootstraps=100, + n_runs=100, + parallelize=True, + # fixed_params=dict(all=dict(eps=0, p_b=0, S_b=1)), + shared_params=[SharedParams(params='all', types='all')], + covariates=[Covariate( + param=param, + values=dict((t, get_sfs(sfs_neutral[i]).theta / (4 * 1e-9)) for i, t in enumerate(types)) + )], +) + +config.to_file(out) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/parse_output_polydfe.py",".py","774","33",""""""" +Parse polyDFE output. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-06"" + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input = snakemake.input[0] + postprocessing_source = '../resources/polydfe/postprocessing/script.R' + out = snakemake.output[0] +except NameError: + # testing + testing = True + input = 'scratch/polydfe_out.txt' + postprocessing_source = '../resources/polydfe/postprocessing/script.R' + out = 'scratch/polydfe_out.json' + +import json +from fastdfe.polydfe import PolyDFE + +with open(out, 'w') as fh: + json.dump(PolyDFE.parse_output(input, postprocessing_source), fh, indent=4) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/parse_vcf_hgdp.py",".py","2021","84",""""""" +Parse SFS from HGDP VCF. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-25"" + +import numpy as np + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + testing = False + chr = snakemake.params.chr + vcf_file = snakemake.input.vcf + fasta = snakemake.input.fasta + gff = snakemake.input.gff + samples_file = snakemake.input.samples + out_csv = snakemake.output.csv + out_png = snakemake.output.png + aliases = snakemake.params.aliases + max_sites = snakemake.params.get('max_sites', np.inf) + n_samples = snakemake.params.get('n_samples', 1000000) + n = snakemake.params.get('n', 20) +except NameError: + # testing + testing = True + chr = ""9"" + vcf_file = f""results/vcf/hgdp/{chr}/opts.vcf.gz"" + fasta = f""results/fasta/hgdp/{chr}.fasta.gz"" + gff = f""results/gff/hgdp/{chr}.corrected.gff3.gz"" + samples_file = ""results/sample_lists/hgdp/all.args"" + out_csv = ""scratch/parse_csv_hgdp.spectra.csv"" + out_png = ""scratch/parse_csv_hgdp.spectra.png"" + aliases = {f""chr{chr}"": [chr]} + max_sites = 10000 + n_samples = 10000 + n = 20 + +import pandas as pd + +import fastdfe as fd + +samples = pd.read_csv(samples_file).iloc[:, 0].tolist() + +# setup parser +p = fd.Parser( + vcf=vcf_file, + fasta=fasta, + gff=gff, + aliases=aliases, + max_sites=max_sites, + target_site_counter=fd.TargetSiteCounter( + n_samples=n_samples, + n_target_sites=fd.Annotation.count_target_sites( + file=gff + )[chr] + ), + n=n, + annotations=[fd.DegeneracyAnnotation()], + filtrations=[ + fd.CodingSequenceFiltration(), + fd.SNVFiltration(), + fd.PolyAllelicFiltration() + ], + stratifications=[fd.DegeneracyStratification()], + include_samples=samples, + info_ancestral='AA_ensembl' +) + +# parse spectra +spectra = p.parse() + +# save to file +spectra.to_file(out_csv) + +# plot data and save to file +spectra.plot(show=testing, file=out_png) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_base_inference.py",".py","2328","75",""""""" +Visualize DFE inference results. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-02"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input = snakemake.input[0] + out_dfe_discretized = snakemake.output.get('dfe_discretized', None) + out_dfe_continuous = snakemake.output.get('dfe_continuous', None) + out_sfs_comparison = snakemake.output.get('sfs_comparison', None) + sfs_comparison_detailed = snakemake.output.get('sfs_comparison_detailed', None) + out_sfs_input = snakemake.output.get('sfs_input', None) + out_mle_params = snakemake.output.get('mle_params', None) + out_bucket_sizes = snakemake.output.get('bucket_sizes', None) +except NameError: + # testing + testing = True + input = ""results/fastdfe/example_3_C_full_anc_bootstrapped_100/serialized.json"" + out_dfe_discretized = ""scratch/dfe_discretized.png"" + out_dfe_continuous = ""scratch/dfe_continuous.png"" + out_sfs_comparison = ""scratch/sfs_comparison.png"" + sfs_comparison_detailed = ""scratch/sfs_comparison_detailed.png"" + out_sfs_input = ""scratch/sfs_input.png"" + out_mle_params = ""scratch/mle_params.png"" + out_bucket_sizes = ""scratch/bucket_sizes.png"" + +import fastdfe as fd + +inf = fd.BaseInference.from_file(input) + +if out_dfe_continuous is not None: + inf.plot_continuous(file=out_dfe_continuous, show=testing) + +if out_dfe_discretized is not None: + inf.plot_discretized(file=out_dfe_discretized, show=testing) + +if out_mle_params is not None: + inf.plot_inferred_parameters(file=out_mle_params, show=testing) + +if out_sfs_comparison is not None: + inf.plot_sfs_comparison( + file=out_sfs_comparison, + show=testing, + title=f""SFS comparison, L1 norm:{inf.get_residual(1) / inf.sfs_sel.n_polymorphic:.2f}"" + ) + +if sfs_comparison_detailed is not None: + inf.plot_sfs_comparison( + sfs_types=[""neutral"", ""selected"", ""modelled""], + file=sfs_comparison_detailed, + show=testing, + title='' + ) + +if out_sfs_input is not None: + inf.plot_sfs_comparison( + sfs_types=[""neutral"", ""selected""], + file=out_sfs_input, + show=testing + ) + +if out_bucket_sizes is not None: + inf.plot_bucket_sizes(file=out_bucket_sizes, show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_spectra.py",".py","582","33",""""""" +Plot spectra. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-30"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + file = snakemake.input[0] + out = snakemake.output[0] +except NameError: + # testing + testing = True + file = ""results/sfs/pendula/all.csv"" + out = ""scratch/spectra.png"" + +from fastdfe import Spectra + +s = Spectra.from_file(file) + +s = s.merge_groups([0]) + +s.plot(show=testing, file=out, show_monomorphic=False, use_subplots=False) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_parser_homo.py",".py","1039","35","import fastdfe as fd + +# parse selected and neutral SFS from human chromosome 1 +p = fd.Parser( + vcf=""https://ngs.sanger.ac.uk/production/hgdp/hgdp_wgs.20190516/"" + ""hgdp_wgs.20190516.full.chr21.vcf.gz"", + fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" + ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", + gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", + aliases=dict(chr21=['21']), + n=10, + target_site_counter=fd.TargetSiteCounter( + n_samples=1000000, + n_target_sites=fd.Annotation.count_target_sites( + ""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"" + )['21'] + ), + annotations=[ + fd.DegeneracyAnnotation() + ], + filtrations=[ + fd.CodingSequenceFiltration() + ], + stratifications=[fd.DegeneracyStratification()], + info_ancestral='AA_ensembl' +) + +sfs = p.parse() + +sfs.plot() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/install_est_sfs.py",".py","1014","43",""""""" +Set up est-sfs by downloading it from Sourceforge and compiling it. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +from snakemake.shell import shell + +try: + out = snakemake.output[0] + tmp_dir = snakemake.resources.tmpdir + max_sites = snakemake.config['max_sites'] +except NameError: + # testing + out = ""scratch/est-sfs"" + tmp_dir = ""/tmp"" + max_sites = 100000 + +version = ""2.04"" + +# set up est-sfs +# Note: the compilation only works on Linux +shell(f"""""" + set -x + work_dir=$(readlink -f .) + cd {tmp_dir} + + wget https://sourceforge.net/projects/est-usfs/files/est-sfs-release-{version}.tar.gz/download -O est-sfs.tar.gz + + rm -rf est-sfs + mkdir est-sfs + tar -xvf est-sfs.tar.gz -C est-sfs --strip-components 1 + + cd est-sfs + sed -i 's/#define max_config 1000000/#define max_config {max_sites}/g' est-sfs.c + export C_INCLUDE_PATH=$CONDA_PREFIX/include + make + + mv est-sfs ""$work_dir/{out}"" +"""""") +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_presentation_base_inference.py",".py","846","38",""""""" +Base inference example for presentation +"""""" +import numpy as np + +import fastdfe as fd + +inf = fd.BaseInference( + sfs_neut=fd.Spectrum( + [66200, 410, 120, 60, 42, 43, 52, 65, 0] + ), + sfs_sel=fd.Spectrum( + [281937, 600, 180, 87, 51, 43, 49, 61, 0] + ), + model=fd.GammaExpParametrization(), + n_runs=10, + n_bootstraps=100, + do_bootstrap=True +) + +inf.run() + +import matplotlib.pyplot as plt + +# create subplots +axs = plt.subplots(3, 1, figsize=(3.5, 6))[1].flatten() + +# plot results +types = ['neutral', 'selected'] +inf.plot_sfs_comparison(ax=axs[0], show=False, sfs_types=types) +inf.plot_sfs_comparison(ax=axs[1], show=False, colors=['C1', 'C5']) +inf.plot_discretized(ax=axs[2], show=False, intervals=[-np.inf, -100, -1, 0, np.inf]) + +plt.savefig('scratch/base_inference_presentation.png', dpi=400) + +plt.show() + +pass","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_degeneracy.py",".py","944","43",""""""" +Annotate degeneracy of variants in a VCF file. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-12"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + vcf_file = snakemake.input.vcf + fasta = snakemake.input.ref + gff = snakemake.input.gff + out = snakemake.output[0] +except ModuleNotFoundError: + # testing + testing = True + vcf_file = ""resources/genome/betula/all.polarized.subset.200000.vcf.gz"" + fasta = ""resources/genome/betula/genome.fasta"" + gff = ""resources/genome/betula/genome.gff.gz"" + out = 'resources/genome/betula/all.polarized.deg.subset.200000.vcf.gz' + +import fastdfe as fd + +fd.logger.setLevel('DEBUG') + +# initialize annotator +ann = fd.Annotator( + vcf=vcf_file, + output=out, + fasta=fasta, + gff=gff, + annotations=[fd.DegeneracyAnnotation()], +) + +# run annotator +ann.annotate() +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/run_gatk.py",".py","502","25",""""""" +Run the GATK. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +from snakemake.shell import shell +from snakemake_wrapper_utils.java import get_java_opts + +java_opts = get_java_opts(snakemake) +flags = snakemake.params.flags +command = snakemake.params.command + +cmd = f""gatk --java-options '{java_opts}' {command}"" + +if '-O' not in flags: + flags['-O'] = snakemake.output[0] + +for flag, val in flags.items(): + cmd += f"" {flag} {val}"" + +shell(cmd) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_covariates_cached.py",".py","460","17","import fastdfe as fd +import matplotlib.pyplot as plt + +# example for joint inference with covariates +inf = fd.JointInference.from_file(""scratch/example_manuscript_covariates.json"") + +_, axs = plt.subplots(1, 2, figsize=(10.5, 4)) + +inf.plot_covariate(ax=axs[0], xlabel='RSA', show=False) +inf.plot_discretized( + ax=axs[1], show_marginals=False, + kwargs_legend=dict(prop=dict(size=9)), + show=True +) + +# plt.savefig(""scratch/joint_inference_covariates.png"") +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_parser.py",".py","833","31","import fastdfe as fd + +basepath = (""https://github.com/Sendrowski/fastDFE/"" + ""blob/dev/resources/genome/betula/"") + +# instantiate parser +p = fd.Parser( + n=8, # SFS sample size + vcf=(basepath + ""biallelic.with_outgroups."" + ""subset.50000.vcf.gz?raw=true""), + fasta=basepath + ""genome.subset.1000.fasta.gz?raw=true"", + gff=basepath + ""genome.gff.gz?raw=true"", + target_site_counter=fd.TargetSiteCounter( + n_target_sites=350000 # total number of target sites + ), + annotations=[ + fd.DegeneracyAnnotation(), # determine degeneracy + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""] # use one outgroup + ) + ], + stratifications=[fd.DegeneracyStratification()] +) + +# obtain SFS +spectra: fd.Spectra = p.parse() + +spectra.plot() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_covariates.py",".py","815","31","import matplotlib.pyplot as plt + +import fastdfe as fd + +# example for joint inference with covariates +inf = fd.JointInference.from_config_file( + ""https://github.com/Sendrowski/fastDFE/"" + ""blob/dev/resources/configs/arabidopsis/"" + ""covariates_example.yaml?raw=true"" +) + +inf.run() + +# get p-value for covariate significance +p = inf.perform_lrt_covariates() +p_str = f""p = {p:.1e}"" if p >= 1e-100 else ""p < 1e-100"" + +# plot results +_, axs = plt.subplots(1, 2, figsize=(10.5, 3.5)) + +inf.plot_covariate(ax=axs[0], xlabel='RSA', show=False) +inf.plot_discretized( + title=f""DFE comparison, "" + p_str, ax=axs[1], + show_marginals=False, show=False +) + +plt.savefig('../reports/manuscript/figures/joint_inference_covariates.high_resolution.jpg', dpi=1200) +# plt.savefig(""scratch/joint_inference_covariates.png"") + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe.py",".py","1628","55",""""""" +Infer the DFE from the SFS using fastDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + config_file = snakemake.input[0] + out_summary = snakemake.output.summary + out_serialized = snakemake.output.serialized + out_dfe = snakemake.output.get('dfe', None) + out_spectra = snakemake.output.get('spectra', None) + out_params = snakemake.output.get('params', None) +except NameError: + # testing + testing = True + # config_file = 'results/configs/example_1_C_full_anc/config.yaml' + # config_file = 'results/configs/example_1_C_deleterious_anc_bootstrapped_100/config.yaml' + # config_file = 'results/configs/pendula_C_full_anc_bootstrapped_100/config.yaml' + config_file = 'results/configs/pendula_C_full_anc_bootstrapped_sequential_100/config.yaml' + out_summary = ""scratch/summary.json"" + out_serialized = ""scratch/serialized.json"" + out_dfe = ""scratch/dfe.png"" + out_spectra = ""scratch/spectra.png"" + out_params = ""scratch/params.png"" + +from fastdfe import BaseInference + +# create from config +inference = BaseInference.from_config_file(config_file) + +# perform inference +inference.run() + +# save object in serialized form +inference.to_file(out_serialized) + +# save summary +inference.get_summary().to_file(out_summary) + +# plot results +inference.plot_inferred_parameters(file=out_params, show=testing) +inference.plot_sfs_comparison(file=out_spectra, show=testing) +inference.plot_discretized(file=out_dfe, show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/parse_vcf.py",".py","1329","62",""""""" +Parse a VCF file. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-29-03"" + +import numpy as np + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + vcf_file = snakemake.input.vcf + fasta = snakemake.input.ref + n = snakemake.params.n + max_sites = snakemake.params.get('max_sites', np.inf) + stratifications = snakemake.params.get('stratifications', ['DegeneracyStratification']) + out = snakemake.output[0] +except NameError: + + # testing + testing = True + vcf_file = 'results/vcf/betula/vcf/all.vcf.gz' + fasta = '../resources/genome/betula/genome.fasta' + n = 20 + max_sites = np.inf + stratifications = [ + 'DegeneracyStratification', + 'AncestralBaseStratification' + ] + out = ""scratch/sfs_parsed.csv"" + +import fastdfe as fd + +# instantiate stratifications +for i, s in enumerate(stratifications): + if s == 'BaseContextStratification': + stratifications[i] = fd.BaseContextStratification(fasta=fasta) + else: + stratifications[i] = getattr(fastdfe.parser, s)() + +# instantiate parser +p = fd.Parser( + n=n, + vcf=vcf_file, + max_sites=max_sites, + stratifications=stratifications +) + +# parse SFS +sfs = p.parse() + +# save to file +sfs.to_file(out) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_polydfe_hgdp.py",".py","2026","76",""""""" +Infer the DFE from the SFS for the HGDP dataset using polyDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-29"" + +import os + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + execute = shell + testing = False + config_file = snakemake.input.config + spectra_file = snakemake.input.spectra + bin = snakemake.params.get('bin', 'resources/polydfe/bin/polyDFE-2.0-macOS-64-bit') + out_summary = snakemake.output.summary + out_serialized = snakemake.output.serialized + out_polydfe = snakemake.output.polydfe + out_dfe = snakemake.output.dfe + out_spectra = snakemake.output.spectra + out_params = snakemake.output.params +except ModuleNotFoundError: + # testing + testing = True + execute = None + config_file = '../resources/configs/HGDP/polydfe.yaml' + spectra_file = ""results/spectra/hgdp/1/opts.n.10/all.csv"" + bin = '../resources/polydfe/bin/polyDFE-2.0-macOS-64-bit' + out_summary = ""scratch/summary.json"" + out_serialized = ""scratch/serialized.json"" + out_polydfe = ""scratch/polydfe.txt"" + out_dfe = ""scratch/dfe.png"" + out_spectra = ""scratch/spectra.png"" + out_params = ""scratch/params.png"" + +from fastdfe import Config, Spectra +from fastdfe.polydfe import PolyDFE + +# load config from file +config = Config.from_file(config_file) + +# load spectra from file +spectra = Spectra.from_file(spectra_file) + +# update config with spectra +config.update( + sfs_neut=spectra['neutral'], + sfs_sel=spectra['selected'], + do_bootstrap=False +) + +# create from config +inference = PolyDFE.from_config(config) + +# perform inference +summary = inference.run(out_polydfe, binary=bin, wd=os.getcwd(), execute=execute) + +# save object in serialized form +inference.to_file(out_serialized) + +# save summary +summary.to_file(out_summary) + +inference.plot_inferred_parameters(file=out_params, show=testing) +inference.plot_discretized(file=out_dfe, show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_pendula_complex.py",".py","919","35","import fastdfe as fd + +basepath = (""https://github.com/Sendrowski/fastDFE/"" + ""blob/dev/resources/genome/betula/"") + +# instantiate parser +p = fd.Parser( + n=10, + vcf=""../resources/genome/betula/all.vcf.gz"", + stratifications=[fd.DegeneracyStratification(), fd.AncestralBaseStratification()] +) + +# parse SFS +spectra: fd.Spectra = p.parse() + +# create inference object +inf = fd.JointInference( + # select neutral and selected spectra from stratified spectra + sfs_neut=spectra['neutral.*'].merge_groups(1), + sfs_sel=spectra['selected.*'].merge_groups(1), + # fix ancestral misidentification rate to 0 + fixed_params=dict(all=dict(eps=0)), + # share S_b and p_b across types + shared_params=[fd.SharedParams(params=['p_b', 'S_b'], types='all')], + do_bootstrap=True +) + +# run inference +inf.run() + +# plot discretized DFE +inf.plot_discretized(show=False, kwargs_legend=dict(framealpha=0)) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/merge_bootstraps_polydfe.py",".py","985","39",""""""" +Merge bootstraps and original inference result. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-10"" + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + file_original = snakemake.input.original + files_bootstrap = snakemake.input.bootstraps + out = snakemake.output[0] +except ModuleNotFoundError: + # testing + testing = True + file_original = 'results/polydfe/pendula_C_deleterious_bootstrapped_100/serialized.json' + files_bootstrap = [f'results/polydfe/pendula_C_full_anc/bootstraps/{i}/serialized.json' for i in range(100)] + out = 'scratch/polydfe_bs.json' + +from fastdfe.polydfe import PolyDFE + +# load from file +original = PolyDFE.from_file(file_original) +bootstraps = [PolyDFE.from_file(f) for f in files_bootstrap] + +# add bootstraps +original.add_bootstraps(bootstraps) + +# save to file +original.to_file(out) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_joint_inference.py",".py","518","22","import fastdfe as fd + +spectra = fd.Spectra.from_file( + ""https://github.com/Sendrowski/fastDFE/blob/dev/"" + ""resources/SFS/betula/spectra.20.csv?raw=true"" +) + +inf = fd.JointInference( + sfs_neut=spectra['neutral.*'].merge_groups(1), + sfs_sel=spectra['selected.*'].merge_groups(1), + do_bootstrap=True, + model=fd.DiscreteFractionalParametrization(), + shared_params=[fd.SharedParams(params=['S1', 'S2'], types='all')] +) + +inf.run() + +inf.plot_discretized() +#inf.plot_inferred_parameters(scale='lin') + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/benchmark_fastdfe_import.py",".py","203","14",""""""" +Benchmark the import of fastdfe +"""""" + +import time + +start = time.time() +# noinspection PyUnresolvedReferences +import fastdfe + +end = time.time() + +print(f""fastdfe imported in {end - start:.2f} seconds"") +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_polydfe_inference.py",".py","912","35",""""""" +Visualize polyDFE inference results. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-11"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input = snakemake.input[0] + out_dfe_discretized = snakemake.output.dfe_discretized + out_mle_params = snakemake.output.mle_params +except NameError: + # testing + testing = True + # input = ""scripts/polydfe/pendula_C_full_anc/serialized.json"" + input = ""results/fastdfe/pendula_C_full_bootstrapped_100/serialized.json"" + out_dfe_discretized = ""scratch/dfe_discretized.png"" + out_mle_params = ""scratch/mle_params.png"" + +from fastdfe.polydfe import PolyDFE + +inference = PolyDFE.from_file(input) + +inference.plot_inferred_parameters(file=out_mle_params, show=testing) +inference.plot_discretized(file=out_dfe_discretized, show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_shared_dfe_inference.py",".py","1337","44",""""""" +Visualize DFE inference results. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-02"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input = snakemake.input[0] + out_dfe_discretized = snakemake.output.dfe_discretized + out_dfe_log = snakemake.output.dfe_log + out_sfs_comparison = snakemake.output.sfs_comparison + out_mle_params = snakemake.output.mle_params + out_bucket_sizes = snakemake.output.bucket_sizes +except NameError: + # testing + testing = True + input = ""scratch/serialized_shared.json"" + out_dfe_discretized = ""scratch/dfe_discretized.png"" + out_dfe_log = ""scratch/dfe_log.png"" + out_sfs_comparison = ""scratch/sfs_comparison.png"" + out_mle_params = ""scratch/mle_params.png"" + out_bucket_sizes = ""scratch/bucket_sizes.png"" + +import fastdfe as fd + +inference = fd.BaseInference.from_file(input) + +inference.plot_inferred_parameters(file=out_mle_params, show=testing) +inference.plot_bucket_sizes(file=out_bucket_sizes, show=testing) +inference.plot_sfs_comparison(file=out_sfs_comparison, show=testing) +inference.plot_continuous(file=out_dfe_log, show=testing) +inference.plot_discretized(file=out_dfe_discretized, show=testing) +inference.plot_interval_density(show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/combine_spectra.py",".py","858","42",""""""" +Create spectra objects. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2022-30-03"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + files = snakemake.input + names = snakemake.params.names + out = snakemake.output[0] +except NameError: + # testing + testing = True + files = [ + 'resources/polydfe/pendula/spectra/sfs.txt', + 'resources/polydfe/pubescens/spectra/sfs.txt' + ] + names = [ + 'pendula', + 'pubescens' + ] + out = ""scratch/spectra.csv"" + +import fastdfe as fd + +spectra = fd.Spectra({}) +for name, file in zip(names, files): + s = fd.spectrum.parse_polydfe_sfs_config(file) + + spectra['sfs_neut.' + name] = s['sfs_neut'] + spectra['sfs_sel.' + name] = s['sfs_sel'] + +spectra.to_file(out) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/recode_ancestral_alleles_vcf.py",".py","5615","174",""""""" +Annotate the VCF with ancestral allele information. +An AA info tag is added in addition to further information. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +import logging +import numpy as np +import sys +from collections import Counter +from tqdm import tqdm + +import pandas as pd +from cyvcf2 import VCF, Writer + +try: + vcf_file = snakemake.input.vcf + probs = snakemake.input.probs + data = snakemake.input.data + ingroups_file = snakemake.input.ingroups + outgroups_file = snakemake.input.outgroups + n_outgroups = snakemake.config['n_outgroup'] + log = snakemake.log[0] + out = snakemake.output.vcf + log_level = snakemake.config.get('log_level', 20) +except NameError: + # testing + vcf_file = ""../resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" + probs = ""results/est-sfs/.probs.txt"" + data = ""results/est-sfs/.data.txt"" + ingroups_file = ""../resources/genome/betula/sample_sets/birch.args"" + outgroups_file = ""../resources/genome/betula/sample_sets/outgroups.args"" + n_outgroups = 2 + log = ""scratch/est-sfs.log"" + out = ""scratch/1.polarized.vcf"" + log_level = logging.INFO + +# configure logger +logger = logging.getLogger() +logger.setLevel(logging.DEBUG) + +# add file handler +logger.addHandler(logging.FileHandler(log)) + +# add stream handler +stream_handler = logging.StreamHandler(sys.stdout) +stream_handler.setLevel(log_level) +logger.addHandler(stream_handler) + + +def get_called_bases(calls: np.ndarray) -> np.ndarray: + """""" + Get the called bases from a list of calls. + + :param calls: Array of calls. + :return: Array of called bases. + """""" + return np.array([b for b in '/'.join(calls).replace('|', '/') if b in 'ACGT']) + + +# load ingroup and outgroup samples +ingroups = pd.read_csv(ingroups_file, header=None, index_col=False)[0].tolist() +outgroups = pd.read_csv(outgroups_file, header=None, index_col=False)[0].tolist() + +vcf_reader = VCF(vcf_file) + +# Add AA info field to the header +vcf_reader.add_info_to_header({ + 'ID': 'AA', + 'Number': '.', + 'Type': 'Character', + 'Description': 'Ancestral Allele'} +) + +vcf_reader.add_info_to_header({ + 'ID': 'EST_SFS_output', + 'Number': '.', + 'Type': 'String', + 'Description': 'EST-SFS probabilities'} +) + +vcf_reader.add_info_to_header({ + 'ID': 'EST_SFS_input', + 'Number': '.', + 'Type': 'String', + 'Description': 'EST-SFS input'} +) + +probs_reader = open(probs, 'r') +data_reader = open(data, 'r') +writer = Writer(out, vcf_reader) + +# get indices of ingroup and outgroup samples +ingroup_mask = [sample in ingroups for sample in vcf_reader.samples] +outgroup_mask = [sample in outgroups for sample in vcf_reader.samples] + +# write to data file +for variant in tqdm(vcf_reader): + + # initialize info fields + variant.INFO['AA'] = '.' + variant.INFO['EST_SFS_output'] = '.' + variant.INFO['EST_SFS_input'] = '.' + + if not variant.is_snp: + # simply assign the ancestral allele to be the reference allele + variant.INFO['AA'] = variant.REF + else: + + # get base counts for outgroup samples + outgroup_counts = get_called_bases(variant.gt_bases[outgroup_mask]) + + # Only do inference for bi-allelic SNPs for which + # at least ``n_outgroups`` outgroup samples are called + if len(variant.ALT) == 1 and len(outgroup_counts) >= n_outgroups: + + line = probs_reader.readline() + + # get probability of major allele + prob_major_allele = float(line.split(' ')[2]) + + # restrict haplotypes to the non-outgroup birch samples + bases = get_called_bases(variant.gt_bases[ingroup_mask]) + + major_allele = '.' + ancestral_allele = '.' + + if len(bases) > 0: + # determine major allele + major_allele = Counter(bases).most_common()[0][0] + + # take the major allele to be the ancestral allele + # if its probability is greater than equal 0.5 + if prob_major_allele >= 0.5: + ancestral_allele = major_allele + else: + # there are exactly two alleles + ancestral_allele = variant.ALT[0] + + # add ancestral allele annotation to record + variant.INFO['AA'] = ancestral_allele + + # read est-sfs input data + est_input = data_reader.readline().replace('\n', '').replace(' ', '|').replace(',', ':') + est_output = line.replace('\n', '').replace(' ', '|') + + # add additional information from est-sfs + variant.INFO['EST_SFS_output'] = est_output + variant.INFO['EST_SFS_input'] = est_input + + # only log if major allele, ancestral allele and reference allele are not the same + if not (major_allele == ancestral_allele == variant.REF): + logger.debug(dict( + site=f""{variant.CHROM}:{variant.POS}"", + ancestral_allele=ancestral_allele, + major_allele=major_allele, + reference=variant.REF, + prob_major_allele=prob_major_allele, + est_sfs_input=est_input, + est_sfs_output=est_output + )) + + writer.write_record(variant) + +# raise error if there are lines left from the EST-SFS output +if next(probs_reader, None) is not None: + raise AssertionError(""There are more lines in the EST-SFS output than there are variants in the VCF file."") + +# raise error if there are lines left from the EST-SFS input +probs_reader.close() +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_annotator.py",".py","656","17","import fastdfe as fd + +ann = fd.Annotator( + vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" + ""1000_genomes_project/release/20181203_biallelic_SNV/"" + ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", + fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" + ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", + gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", + output='scratch/sapiens.chr21.degeneracy.vcf.gz', + annotations=[fd.DegeneracyAnnotation()], + aliases=dict(chr21=['21']), +) + +ann.annotate() +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/derive_sample_list.py",".py","635","25",""""""" +Derive a with sample names separated by new lines. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +import pandas as pd + +try: + samples_file = snakemake.input[0] + name_col = snakemake.params.get('name_col', 'name') + sep = snakemake.params.get('sep', '\t') + out = snakemake.output[0] +except NameError: + samples_file = ""results/sample_sets/hgdp/Maya.csv"" + sep = snakemake.params.get('sep', '\t') + name_col = 'sample' + out = ""scratch/all.args"" + +samples = pd.read_csv(samples_file, sep=sep) + +samples[name_col].to_csv(out, header=False, index=False, sep=sep) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_manuscript_base_inference.py",".py","912","32","import fastdfe as fd + +# create inference object +inf = fd.BaseInference( + sfs_neut=fd.Spectrum([66200, 410, 120, 60, 42, 43, 52, 65, 0]), + sfs_sel=fd.Spectrum([281937, 600, 180, 87, 51, 43, 49, 61, 0]), + model=fd.GammaExpParametrization(), # the model to use + n_runs=10, # number of optimization runs + n_bootstraps=100, # number of bootstrap replicates + do_bootstrap=True +) + +# run inference +inf.run() + +import matplotlib.pyplot as plt + +# create subplots +axs = plt.subplots(2, 2, figsize=(11, 7))[1].flatten() + +# plot results +types = ['neutral', 'selected'] +inf.plot_sfs_comparison(ax=axs[0], show=False, sfs_types=types) +inf.plot_sfs_comparison(ax=axs[1], show=False, colors=['C1', 'C5']) +inf.plot_inferred_parameters(ax=axs[2], show=False) +inf.plot_discretized(ax=axs[3], show=False) + +plt.savefig('../reports/manuscript/figures/base_inference.high_resolution.jpg', dpi=1200) + +plt.show() + +pass","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/merge_spectra.py",".py","697","39",""""""" +Merge several spectra. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-30"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('.') + + testing = False + spectra_files = snakemake.input + out = snakemake.output[0] +except NameError: + # testing + testing = True + spectra_files = [ + ""results/sfs/pendula/16.csv"", + ""results/sfs/pendula/15.csv"", + ""results/sfs/pendula/14.csv"" + ] + out = ""scratch/out.txt"" + +import numpy as np + +from fastdfe import Spectra + +s = Spectra.from_file(spectra_files[0]) +for f in spectra_files[1:]: + s += Spectra.from_file(f) + +s.to_file(out) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/modify_config.py",".py","793","40",""""""" +Modify an existing config file. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-13"" + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + config_file = snakemake.input[0] + opts = snakemake.params.get('opts', {}) + out = snakemake.output[0] +except NameError: + # testing + testing = True + config_file = 'results/configs/pendula_C_full_anc/config.yaml' + opts = dict( + do_bootstrap=True + ) + out = 'scratch/config_modified.yaml' + +import fastdfe as fd + +# create config object +config = fd.Config.from_file(config_file) + +# merge config with new options +config.data |= opts + +# save config to file +config.to_file(out) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_tool_comparison.py",".py","1403","48",""""""" +Visualize DFE inference results. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-02"" + +import numpy as np +from matplotlib import pyplot as plt + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input_fastdfe = snakemake.input.fastdfe + input_polydfe = snakemake.input.polydfe + out_discretized = snakemake.output.discretized + out_params = snakemake.output.inferred_params +except NameError: + # testing + testing = True + input_fastdfe = ""results/fastdfe/pubescens_C_full_bootstrapped_100/serialized.json"" + input_polydfe = ""results/polydfe/pubescens_C_full_bootstrapped_100/serialized.json"" + out_discretized = ""scratch/comp_discretized.png"" + out_params = ""scratch/comp_inferred_params.png"" + +from fastdfe import BaseInference, Inference +from fastdfe.polydfe import PolyDFE + +inferences = [BaseInference.from_file(input_fastdfe), PolyDFE.from_file(input_polydfe)] + +Inference.plot_discretized(inferences, labels=['fastDFE', 'polyDFE'], show=testing, file=out_discretized, title='') +Inference.plot_inferred_parameters(inferences, labels=['fastDFE', 'polyDFE'], show=False, file=None, title='') + +# use symlog scale for the inferred parameters +plt.gca().set_yscale('symlog', linthresh=0.1) + +plt.savefig(out_params, bbox_inches='tight') + +if testing: + plt.show() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/infer_shared_dfe.py",".py","1687","70",""""""" +Perform joint inference. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-19"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + testing = False + config_file = snakemake.input[0] + out_summary = snakemake.output.summary + out_serialized = snakemake.output.serialized +except NameError: + # testing + testing = True + # config_file = 'resources/configs/shared/covariates_dummy_example_1/config.yaml' + # config_file = 'results/configs/pendula.pubescens.example_1.example_2.example_3_C_full_anc/config.yaml' + config_file = '../resources/configs/shared/pendula_betula_tutorial/config.yaml' + out_summary = ""scratch/summary.json"" + out_serialized = ""scratch/serialized_shared.json"" + +import logging + +from fastdfe import Config, JointInference + +# set log level to debug +logging.getLogger('fastdfe').setLevel(logging.INFO) + +# load config from file +config = Config.from_file(config_file) + +# update config +""""""config.update( + model=DiscreteParametrization(), + fixed_params={}, + shared_params=[SharedParams(types='all', params=['S2'])], + covariates=[], + parallelize=False, + n_runs=1 +)"""""" + +# create from config +inference = JointInference.from_config(config) + +# perform inference +inference.run() + +# bootstrap +# inference.bootstrap(10) + +# save object in serialized form +inference.to_file(out_serialized) + +# save summary +inference.get_summary().to_file(out_summary) + +if testing: + inference.plot_discretized() + inference.plot_continuous() + inference.plot_inferred_parameters() + inference.perform_lrt_covariates() + inference.perform_lrt_shared() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_nested_model_comparison_hominidae.py",".py","770","34",""""""" +Plot nested model comparison for the hominidae dataset. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-31"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + testing = False + config = snakemake.params.config + out = snakemake.output[0] +except NameError: + # testing + testing = True + config = ""results/fastdfe/hominidae/cov/eps.yaml"" + out = ""scratch/joint_inference.yaml"" + +import fastdfe as fd +import matplotlib.pyplot as plt + +inf = fd.JointInference.from_config_file(config) + +fig, axs = plt.subplots(len(inf.types), figsize=(10, 10)) + +for i, t in enumerate(inf.types): + inf.marginal_inferences[t].plot_nested_models(ax=axs[i], show=False) + +plt.show() +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/check_stratified_spectra.py",".py","954","35",""""""" +Testing the inference results against the results of polyDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-31"" + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input_fastdfe = snakemake.input.fastdfe + input_polydfe = snakemake.input.polydfe +except ModuleNotFoundError: + # testing + testing = True + spectra_files = [ + 'results/sfs/pendula/DegeneracyStratification/all.csv', + 'results/sfs/pendula/DegeneracyStratification.BaseContextStratification/all.csv', + 'results/sfs/pendula/DegeneracyStratification.BaseTransitionStratification/all.csv', + 'results/sfs/pendula/DegeneracyStratification.BaseContextStratification.BaseTransitionStratification/all.csv' + ] + +from fastdfe import Spectra + +spectra = [Spectra.from_file(s) for s in spectra_files] + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/create_seed_file_est_sfs.py",".py","281","17",""""""" +Create a seed file for est-sfs. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +try: + out = snakemake.output[0] +except NameError: + # testing + out = ""scratch/seed.txt"" + +# create seed file +open(out, 'w').write('0') +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/combine_plots.py",".py","3897","153",""""""" +Combine a bunch of images in a single plot. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2022-30-03"" + +import itertools +import re +from typing import List + +import matplotlib.image as mpimg +import matplotlib.pyplot as plt +import numpy as np + +try: + testing = False + files = snakemake.input + n_cols = snakemake.params.get('n_cols', None) + n_rows = snakemake.params.get('n_rows', None) + titles = snakemake.params.get('titles', None) + title_size_rel = snakemake.params.get('title_size_rel', 20) + title_xoffset = snakemake.params.get('title_xoffset', None) + pad = snakemake.params.get('pad', 0.1) + figsize = snakemake.params.get('figsize', None) + dpi = snakemake.params.get('dpi', 1000) + out = snakemake.output[0] +except NameError: + # testing + testing = True + files = [ + ""scratch/combined.png"", + ""scratch/combined.png"", + ""scratch/combined.png"", + ""scratch/combined.png"", + ] + n_cols = None + n_rows = None + titles = None + title_size_rel = 20 + title_xoffset = None + pad = 0.1 + figsize = None + dpi = 1000 + out = ""scratch/combined2.png"" + + +def get_index_common_start(strs: List[str]): + """""" + Return first position where given strings differ. + + :param strs: List of strings + :return: Index + """""" + n = min(len(f) for f in strs) + for i in range(n): + if not all([strs[0][i] == strs[j][i] for j in range(1, len(strs))]): + return i + + return n + + +def determine_names_dep(files: List[str]) -> List[str]: + """""" + Determine names by removing common start and end substrings. + + :return: List of names + """""" + i = get_index_common_start(files) + j = get_index_common_start([f[::-1] for f in files]) + return [s[i:-j] for s in files] + + +def determine_names(out: str) -> List[str]: + """""" + Determine names from output file path. + + :param out: Output file path + :return: List of names + """""" + matches = re.finditer(""\[(.*?)\]"", out) + + elements = [match.groups()[0].split(',') for match in matches] + prod = itertools.product(*elements) + + return [','.join(p) for p in prod] + + +if titles is None: + titles = determine_names(out) + + # infer names from input file names if names + # inferred from output file name are too long + if len(titles[0]) > 30: + titles = determine_names_dep(files) + + if len(titles) != len(files): + titles = [''] * len(files) + +# determine number of rows and columns if not specified +n_files = len(files) + +if n_cols is None and n_rows is not None: + # infer number of columns from number of rows + n_cols = int(np.ceil(n_files / n_rows)) + +if n_rows is None and n_cols is not None: + # infer number of rows from number of columns + n_rows = int(np.ceil(n_files / n_cols)) + +if n_cols is None and n_rows is None: + # display up to three files in one row only + if n_files < 4: + n_rows, n_cols = 1, n_files + + # take the number of rows and columns to + # be the same for more than three files + else: + n = int(np.ceil(np.sqrt(n_files))) + n_rows, n_cols = n, n + +# infer figsize if not set +if figsize is None: + img = mpimg.imread(files[0]) + img_aspect = img.shape[1] / img.shape[0] + scale = 3 # adjust as needed + figsize = (scale * n_cols * img_aspect, scale * n_rows) + +fig, axs = plt.subplots(nrows=n_rows, ncols=n_cols, squeeze=False, figsize=figsize) +axs = axs.flatten() + +for file, title, ax in zip(files, titles, axs): + ax.imshow(mpimg.imread(file)) + ax.set_title( + title, + fontdict=dict(fontsize=title_size_rel / n_cols), + pad=0, + **(dict(x=title_xoffset) if title_xoffset is not None else {}) + ) + +# turn off axes +[ax.axis(""off"") for ax in axs] + +fig.tight_layout(pad=pad) + +plt.savefig(out, dpi=dpi, bbox_inches='tight', pad_inches=pad) + +if testing: + plt.show() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/prepare_config_hgdp.py",".py","888","42",""""""" +Prepare fastDFE config for HGDP data. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-30"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + config_file = snakemake.input.config + spectra_file = snakemake.input.spectra + out = snakemake.output[0] +except NameError: + # testing + testing = True + config_file = '../resources/configs/HGDP/test.yaml' + spectra_file = ""results/spectra/hgdp/1/opts.n.20/all.csv"" + out = ""scratch/config.yaml"" + +from fastdfe import Config, Spectra + +# load config from file +config = Config.from_file(config_file) + +# load spectra from file +spectra = Spectra.from_file(spectra_file) + +# update config with spectra +config.update( + sfs_neut=spectra['neutral'], + sfs_sel=spectra['selected'] +) + +# save config +config.to_file(out) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_presentation_parser.py",".py","663","27",""""""" +Example presentation parser +"""""" + +import fastdfe as fd + +basepath = ""https://github.com/Sendrowski/fastDFE/blob/dev/resources/genome/betula/"" + +p = fd.Parser( + n=8, + vcf=basepath + ""biallelic.with_outgroups.subset.50000.vcf.gz?raw=true"", + fasta=basepath + ""genome.subset.1000.fasta.gz?raw=true"", + gff=basepath + ""genome.gff.gz?raw=true"", + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation(outgroups=[""ERR2103730""]), + fd.DegeneracyAnnotation() + ], + stratifications=[fd.DegeneracyStratification()], + target_site_counter=fd.TargetSiteCounter(n_target_sites=350000) +) + +spectra: fd.Spectra = p.parse() + +spectra.plot() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/prepare_config_hominidae.py",".py","1060","45",""""""" +Prepare fastdfe config for SFS of the great apes study. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-31"" + +import pandas as pd + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + testing = False + sfs_neutral = snakemake.input.neutral + sfs_selected = snakemake.input.selected + out = snakemake.output[0] +except NameError: + # testing + testing = True + type = 'human' + sfs_neutral = f'../resources/SFS/hominidae/uSFS/{type}_4fold_all_sfs.txt' + sfs_selected = f'../resources/SFS/hominidae/uSFS/{type}_0fold_all_sfs.txt' + out = 'scratch/config.yaml' + +from fastdfe import Config, Spectra, Spectrum + +sfs = Spectra.from_spectra(dict( + neutral=Spectrum(pd.read_csv(sfs_neutral, header=None).iloc[0].tolist()), + selected=Spectrum(pd.read_csv(sfs_selected, header=None).iloc[0].tolist()) +)) + +config = Config( + sfs_neut=sfs['neutral'], + sfs_sel=sfs['selected'], + do_bootstrap=True, + n_bootstraps=100 +) + +config.to_file(out) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/scatter_output_est_sfs.py",".py","1162","39",""""""" +Scatter the output of est-sfs. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +try: + probs_in = snakemake.input.probs + data_in = snakemake.input.data + probs_out = snakemake.output.probs +except NameError: + # testing + probs_in = ""results/test/remote/est-sfs/passed.biallelic.90.probs.all.txt"" + data_in = [f""output/default/est-sfs/data/{n}.txt"" for n in range(1, 11)] + probs_out = [f""scratch/est-sfs/probs/{n}.txt"" for n in range(1, 11)] + +with open(probs_in, 'r') as probs_all: + # iterate over files + for data_file, probs_file in zip(data_in, probs_out): + + # obtain number of lines to read and write + line_count = sum(1 for line in open(data_file)) + + with open(probs_file, 'w') as out: + + # iterate over lines + for i in range(line_count): + + line = probs_all.readline() + + # write to out file + out.write(line) + + # raise error if there are lines left from the EST-SFS output + if next(probs_all, None) is not None: + raise AssertionError(""Unassigned sites left from EST-SFS output."") +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/check_overlapping_confidence_intervals.py",".py","1168","45",""""""" +Testing the inference results against the results of polyDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-16"" + +import numpy as np + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input_fastdfe = snakemake.input.fastdfe + input_polydfe = snakemake.input.polydfe +except ModuleNotFoundError: + # testing + testing = True + input_fastdfe = 'results/fastdfe/pendula_C_full_bootstrapped_100/serialized.json' + input_polydfe = 'results/polydfe/pendula_C_full_bootstrapped_100/serialized.json' + +from fastdfe import BaseInference +from fastdfe.polydfe import PolyDFE + +native = BaseInference.from_file(input_fastdfe) +polydfe = PolyDFE.from_file(input_polydfe) + +res = dict( + fastdfe=native.get_discretized(), + polydfe=polydfe.get_discretized() +) + +# fastdfe.plot_discretized(title='fastDFE') +# polydfe.plot_discretized(title='polyDFE') + +# check that the confidence interval overlap +assert np.all(res['fastdfe'][1][0] < res['polydfe'][1][1]) +assert np.all(res['polydfe'][1][0] < res['fastdfe'][1][1]) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/infer_joint_dfe.py",".py","1580","54",""""""" +Infer the joint DFE from the SFS using fastDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + testing = False + config_file = snakemake.input[0] + out_summary = snakemake.output.summary + out_serialized = snakemake.output.serialized + out_dfe = snakemake.output.get('dfe', None) + out_spectra = snakemake.output.get('spectra', None) + out_params = snakemake.output.get('params', None) +except NameError: + # testing + testing = True + # config_file = 'results/configs/example_1_C_full_anc/config.yaml' + # config_file = 'results/configs/example_1_C_deleterious_anc_bootstrapped_100/config.yaml' + # config_file = 'results/configs/pendula_C_full_anc_bootstrapped_100/config.yaml' + config_file = 'scratch/bonobo.yaml' + out_summary = ""scratch/summary.json"" + out_serialized = ""scratch/serialized.json"" + out_dfe = ""scratch/dfe.png"" + out_spectra = ""scratch/spectra.png"" + out_params = ""scratch/params.png"" + +from fastdfe import JointInference + +# create from config +inference = JointInference.from_config_file(config_file) + +# perform inference +inference.run() + +# save object in serialized form +inference.to_file(out_serialized) + +# save summary +inference.get_summary().to_file(out_summary) + +# plot results +inference.plot_inferred_parameters(file=out_params, show=testing) +inference.plot_sfs_comparison(file=out_spectra, show=testing) +inference.plot_discretized(file=out_dfe, show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_selected_sfs.py",".py","1020","49",""""""" +Visualize linearized DFE to SFS transformation. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-27"" + +import numpy as np +from matplotlib import pyplot as plt + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + n = snakemake.params.n + S = snakemake.params.S + out = snakemake.output[0] +except ModuleNotFoundError: + # testing + testing = True + n = 7 + S = -10 + out = ""scratch/sfs_selected.png"" + +from fastdfe.discretization import Discretization +from fastdfe import Spectrum + +d = Discretization( + n=n, + intervals_ben=(1e-15, 1000, 1000), + intervals_del=(-1000000, -1e-15, 1000) +) + +k = np.arange(1, n) +s = Spectrum.from_polymorphic(d.get_counts_semidominant_regularized(S * np.ones_like(k), k)) + +plt.figure(figsize=(2, 2)) +s.plot(file=out, show=False, title=f""S = {S}"", ax=plt.gca()) +plt.gca().set_ylim(bottom=0, top=1.25) +plt.show() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_pendula_biased_gc.py",".py","1255","53","import numpy as np + +import fastdfe as fd + +p = fd.Parser( + n=10, + vcf=""../resources/genome/betula/all.vcf.gz"", + stratifications=[fd.DegeneracyStratification(), fd.BaseTransitionStratification()] +) + +# parse SFS +s: fd.Spectra = p.parse() + +s.plot(use_subplots=True) + +# extract neutral and selected SFS +neut = s['neutral.*'].merge_groups(1) +sel = s['selected.*'].merge_groups(1) + +"""""" +# create inference objects +inferences = [fd.BaseInference( + sfs_neut=neut[t], + sfs_sel=sel[t], + model=fd.DiscreteFractionalParametrization(np.array([-100000, -100, -10, -1, 1, 1000])), + do_bootstrap=True +) for t in neut.types] + +# run inference +[i.run() for i in inferences] + +fd.Inference.plot_discretized(inferences, labels=neut.types) +"""""" + +inf = fd.JointInference( + sfs_neut=neut, + sfs_sel=sel, + shared_params=[fd.SharedParams(params=['S1', 'S4'], types='all')], + model=fd.DiscreteFractionalParametrization(np.array([-100000, -100, -10, -1, 1, 1000])), + covariates=[fd.Covariate( + param='S3', + values=dict((t, int(t not in ['A>T', 'T>A', 'G>C', 'C>G'])) for t in neut.types) + )], + fixed_params=dict(all=dict(eps=0)), + do_bootstrap=True +) + +inf.run() + +inf.plot_discretized(kwargs_legend=dict(prop=dict(size=5))) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_sfs_demographies.py",".py","3144","64",""""""" +Plot SFS from different demographic scenarios. +"""""" +import sys + +# necessary to import fastdfe locally +sys.path.append('.') + +from matplotlib import pyplot as plt +import fastdfe as fd + +from matplotlib.ticker import MultipleLocator + +try: + testing = False + files_fd = snakemake.input.fastdfe + files_slim = snakemake.input.slim + labels = snakemake.params.labels + out = snakemake.output[0] +except NameError: + # testing + testing = True + files_fd = [ + ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/constant/unfolded/sfs.csv"", + ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/expansion_4/unfolded/sfs.csv"", + ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/reduction_4/unfolded/sfs.csv"", + ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/bottleneck_20/unfolded/sfs.csv"", + ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/substructure_0.0001/unfolded/sfs.csv"", + ""results/sfs/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/dominance_0.2/unfolded/sfs.semidominant.csv"" + ] + files_slim = [ + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/constant/unfolded/sfs.csv"", + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/expansion_4/unfolded/sfs.csv"", + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/reduction_4/unfolded/sfs.csv"", + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/bottleneck_20/unfolded/sfs.csv"", + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/substructure_0.0001/unfolded/sfs.csv"", + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/dominance_0.2/unfolded/sfs.csv"" + ] + labels = [""constant"", ""expansion"", ""reduction"", ""bottleneck"", ""substructure"", ""recessiveness""] + out = ""scratch/sfs_demographies.png"" + +fig, ax = plt.subplots(3, 2, figsize=(7, 4.5), sharex=True) +ax = ax.flatten() + +for i in range(len(files_fd)): + sfs = fd.Spectra.from_spectra(dict( + SLiM=fd.Spectra.from_file(files_slim[i])['selected'], + fastDFE=fd.Spectrum.from_file(files_fd[i]), + )) + sfs.plot(ax=ax[i], show=False) + ax[i].set_xlabel("""", fontsize=6) + ax[i].set_title(labels[i], fontsize=14) + if labels[i] == ""expansion"": + ax[i].yaxis.set_major_locator(MultipleLocator(20000)) + ax[i].ticklabel_format(axis=""y"", style=""sci"", scilimits=(0, 0)) + +fig.tight_layout(pad=0.7) + +if testing: + plt.show() + +fig.savefig(out, dpi=300) +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/create_bootstrap_polydfe.py",".py","745","36",""""""" +Create config file for bootstrapped samples to be run with polyDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-10"" + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input = snakemake.input[0] + out = snakemake.output[0] +except NameError: + # testing + testing = True + input = 'scratch/polydfe_wrapper.json' + out = 'scratch/polydfe_config.yaml' + +from fastdfe.polydfe import PolyDFE + +# restore polyDFE wrapper from file +polydfe = PolyDFE.from_file(input) + +# create bootstrap +config = polydfe.create_bootstrap() + +# save polyDFE wrapper object to file +config.to_file(out) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/import_fastdfe.py",".py","20","1","import fastdfe as fd","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_dfe_collage.py",".py","4334","150",""""""" +Combine DFE plots. +"""""" +import re +import sys +from pathlib import Path + +import numpy as np + +# necessary to import fastdfe locally +sys.path.append('.') + +import matplotlib.pyplot as plt +import fastdfe as fd + +try: + testing = False + files_sfs = snakemake.input.slim + files_summary = snakemake.input.fastdfe + labels = snakemake.params.labels + out = snakemake.output[0] +except NameError: + testing = True + files_sfs = [ + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00/n=20/constant/unfolded/sfs.csv"", + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.1/s_d=3e-2/p_b=0.00/n=20/constant/unfolded/sfs.csv"", + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-2/b=0.1/s_d=3e-1/p_b=0.01/n=20/constant/unfolded/sfs.csv"", + ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.3/s_d=3e-2/p_b=0.05/n=20/constant/unfolded/sfs.csv"", + ] + files_summary = [ + Path(f).with_name(""summary.json"") for f in files_sfs + ] + labels = [ + ""Strongly deleterious"", + ""Weakly deleterious"", + ""Rare beneficial"", + ""Frequent beneficial"", + ] + out = ""scratch/dfe_collage.png"" + +plt.rcParams['xtick.labelsize'] = 8 + + +def extract_params(path: str) -> dict: + """""" + Extract simulation parameters from path string. + """""" + params = {} + for key in [""s_d"", ""s_b"", ""b"", ""p_b"", ""N"", ""mu""]: + m = re.search(rf""/{key}=([0-9.eE+-]+)"", path) + if m: + params[key] = float(m.group(1)) + return params + + +def format_params(params_slim: dict, params_fd: dict) -> tuple[dict, dict]: + """""" + Format parameters for display. + """""" + trailing = dict( + p_b=2, + b=2, + S_b=1, + S_d=0, + N_e=0 + ) + + for key in params_slim: + params_slim[key] = f""{params_slim[key]:.{trailing[key]}f}"" + + if key in params_fd: + + params_fd[key] = f""{params_fd[key]:.{trailing[key]}f}"" + + while params_slim[key].endswith(""0"") and params_fd[key].endswith(""0""): + params_slim[key] = params_slim[key][:-1] + params_fd[key] = params_fd[key][:-1] + + params_slim[key] = params_slim[key].rstrip(""."") + params_fd[key] = params_fd[key].rstrip(""."") + + return ( + ','.join( + [f""${k}$={' ' * (len(params_fd[k]) - len(v)) if k in params_fd else ''}{v}"" for k, v in params_slim.items()]), + ','.join([f""${k}$={' ' * (len(params_slim[k]) - len(v)) if k in params_slim else ''}{v}"" for k, v in + params_fd.items()]), + ) + + +fig, ax = plt.subplots(2, 2, figsize=(7, 4), sharex=True, sharey=True) +ax = ax.flatten() + +for i, (f_sfs, f_sum) in enumerate(zip(files_sfs, files_summary)): + spectra = fd.Spectra.from_file(f_sfs) + result = fd.InferenceResult.from_file(f_sum) + + params = extract_params(f_sfs) + + Ne = spectra[""neutral""].theta / (4 * params[""mu""]) + + dfe_slim = fd.DFE(dict( + S_d=-4 * Ne * params[""s_d""], + b=params[""b""], + p_b=params[""p_b""], + S_b=4 * Ne * params[""s_b""], + N_e=Ne + )) + + params_slim = dfe_slim.params.copy() + if params_slim[""p_b""] == 0: + params_slim.pop(""S_b"") + params_fd = {k: v for k, v in result.dfe.params.items() if k in params_slim} + + params_slim, params_fd = format_params(params_slim, params_fd) + + fd.DFE.plot_many( + [dfe_slim, result.dfe], + labels=[ + f""SLiM ({params_slim})"", + f""fastDFE({params_fd})"" + ], + intervals=[-np.inf, -100, -10, -1, 1, np.inf], + ax=ax[i], + show=False, + title=labels[i], + ) + leg = ax[i].legend(loc='upper left', prop={""family"": ""monospace"", ""size"": 6.3}) + for h in leg.legend_handles: + h.set_hatch(None) + + ax[i].set_ylim(0, 1) + + # remove hatch patterns from bars + for container in ax[i].containers: + if container is not None: + for patch in container: + if patch is not None and hasattr(patch, ""set_hatch""): + patch.set_hatch("""") + +fig.tight_layout(pad=0.05) +ax[1].set_ylabel("""") +ax[3].set_ylabel("""") +ax[0].set_xlabel("""") +ax[1].set_xlabel("""") + +fig.savefig(out, dpi=300) + +if testing: + plt.show() +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/parse_polarize_vcf_betula.py",".py","1665","73",""""""" +Parse betula VCF. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-08-06"" + +import pandas as pd + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + vcf_file = snakemake.input.vcf + fasta = snakemake.input.ref + gff = snakemake.input.gff + samples_file = snakemake.input.samples + max_sites = snakemake.params.max_sites.get(""max_sites"", np.inf) + n = snakemake.params.n + out_csv = snakemake.output.csv + out_png = snakemake.output.png +except NameError: + + # testing + testing = True + vcf_file = '../resources/genome/betula/all.with_outgroups.vcf.gz' + fasta = '../resources/genome/betula/genome.fasta' + gff = '../resources/genome/betula/genome.gff.gz' + samples_file = '../resources/genome/betula/sample_sets/pendula.args' + max_sites = 100000 + n = 10 + out_csv = ""scratch/sfs_parsed.csv"" + out_png = ""scratch/sfs_parsed.png"" + +import fastdfe as fd + +ingroups = pd.read_csv(samples_file).iloc[:, 0].tolist() + +p = fd.Parser( + vcf=vcf_file, + fasta=fasta, + gff=gff, + n=n, + annotations=[ + fd.DegeneracyAnnotation(), + fd.MaximumLikelihoodAncestralAnnotation( + n_ingroups=20, + ingroups=ingroups, + outgroups=[""ERR2103730""], + max_sites=10000 + ) + ], + filtrations=[ + fd.CodingSequenceFiltration(), + fd.PolyAllelicFiltration(), + ], + stratifications=[fd.DegeneracyStratification()], + include_samples=ingroups, + max_sites=max_sites +) + +sfs = p.parse() + +sfs.plot(show=testing, file=out_png) + +sfs.to_file(out_csv) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/gather_input_est_sfs.py",".py","507","21",""""""" +Gather the scattered input for est-sfs. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +try: + data_files = snakemake.input + out = snakemake.output[0] +except NameError: + # testing + data_files = [f""output/default/est-sfs/data/{n}.txt"" for n in range(1, 10)] + out = ""scratch/data.combined.txt"" + +# combine contents of all data files +with open(out, 'w') as f: + for file in data_files: + f.writelines(open(file, 'r').readlines()) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_presentation_joint_inference.py",".py","712","32","import matplotlib.pyplot as plt +import fastdfe as fd + +spectra = fd.Spectra.from_file( + ""../resources/SFS/betula/spectra.20.csv"" +) + +inf = fd.JointInference( + sfs_neut=spectra['neutral.*'].merge_groups(1), + sfs_sel=spectra['selected.*'].merge_groups(1), + do_bootstrap=True, + model=fd.DiscreteFractionalParametrization(), + shared_params=[fd.SharedParams(params=['S1', 'S2', 'S4'], types='all')] +) + +inf.run() + + +fig = plt.figure(figsize=(4, 3)) +fd.Inference.plot_inferred_parameters( + ax=plt.gca(), + inferences=list(inf.joint_inferences.values()), + labels=['type 1', 'type 2'], + scale='lin', + show=False +) + +plt.gca().set_xticklabels([f""$p{i}$"" for i in range(1, 8)]) +plt.show() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_slim_fastdfe.py",".py","2771","104",""""""" +Infer the DFE from spectra generated by SLiM. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2024-02-26"" + +import sys + +# necessary to import fastdfe locally +sys.path.append('.') +import fastdfe as fd + +import numpy as np +from matplotlib import pyplot as plt + +try: + + testing = False + sfs_file = snakemake.input[0] + full_dfe = snakemake.params.get('full_dfe') + h = snakemake.params.get('h', 0.5) + mu = snakemake.params.mu + demography = snakemake.params.demography + out_summary = snakemake.output.summary + out_serialized = snakemake.output.serialized + out_dfe = snakemake.output.get('dfe', None) + out_model_fit = snakemake.output.get('model_fit', None) + out_spectra = snakemake.output.get('spectra', None) + out_params = snakemake.output.get('params', None) +except NameError: + # testing + testing = True + sfs_file = 'results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-9/b=5/s_d=3e-1/p_b=0/n=100/folded/sfs.csv' + full_dfe = True + h = 0.5 + mu = 1e-8 + demography = ""constant"" + out_summary = ""scratch/summary.json"" + out_serialized = ""scratch/serialized.json"" + out_dfe = ""scratch/dfe.png"" + out_model_fit = ""scratch/model_fit.png"" + out_spectra = ""scratch/spectra.png"" + out_params = ""scratch/params.png"" + +s = fd.Spectra.from_file(sfs_file) + +theta = s['neutral'].theta +Ne = theta / (4 * mu) + +if demography == 'dominance_function': + h_callback = lambda k, S: np.maximum(0.4 * np.exp(-h * abs(S / (4 * Ne))), 0.1) +else: + h_callback = lambda h, S: np.full_like(S, h) + +# create from config +inf = fd.BaseInference( + sfs_neut=s['neutral'], + sfs_sel=s['selected'], + do_bootstrap=True, + parallelize=True, + bounds=dict(h=(0, h)), + n_runs=100, + h_callback=h_callback, + fixed_params=dict(all=dict(eps=0, h=h) | (dict(p_b=0, S_b=1) if not full_dfe else {})) +) + +# perform inference +inf.run() + +# save object in serialized form +inf.to_file(out_serialized) + +# save summary +inf.get_summary().to_file(out_summary) + +params = {k: v for k, v in inf.bootstraps.select_dtypes('number').median().to_dict().items()} + +params_str = dict( + S_d=f""{params['S_d']:.0f}"", + b=f""{params['b']:.2f}"", + p_b=f""{params['p_b']:.2f}"", + S_b=f""{params['S_b']:.1f}"" +) + +# plot results +inf.plot_inferred_parameters(file=out_params, show=testing) +inf.plot_sfs_comparison(file=out_model_fit, show=testing) + +fig, ax = plt.subplots(figsize=(4.5, 2.2)) +plt.rcParams['axes.titlesize'] = 11 + +inf.plot_discretized( + file=out_dfe, + show=testing, + title=""Inferred DFE\n"" + "", "".join([f""${k}$={v}"" for k, v in params_str.items()]), + intervals=[-np.inf, -100, -10, -1, 1, np.inf], + ax=ax +) +s.plot(file=out_spectra, show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/scatter_lines.jl",".jl","694","27",""""""" +Scatter the lines of a file into several files by writing +the jth line into the `jth % n_files` files. +"""""" + +if @isdefined snakemake + input = snakemake.input[1] + n_chunks = snakemake.params[""n_chunks""] + i = snakemake.params[""i""] + out = snakemake.output[1] +else + input = ""results/test/remote/est-sfs/passed.biallelic.90.data.all.txt"" + n_chunks = 4 + i = 3 + out = ""scratch/$i.data.txt"" +end + +open(input) do f_in + open(out, ""w"") do f_out + for (j, line) in enumerate(eachline(f_in)) + # only write every 'j % n == i % n'th line + if j % n_chunks == i % n_chunks + write(f_out, line * ""\n"") + end + end + end +end","Julia" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_dfe_slim.py",".py","1635","72",""""""" +Plot the distribution of selection coefficients from SLiM simulations. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2024-03-03"" + +import numpy as np +from matplotlib import pyplot as plt + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('.') + + testing = False + spectra_file = snakemake.input[0] + p_b = snakemake.params.p_b + s_b = snakemake.params.s_b + s_d = snakemake.params.s_d + b = snakemake.params.b + mu = snakemake.params.mu + out = snakemake.output[0] +except NameError: + # testing + testing = True + spectra_file = ""results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-9/b=5/s_d=3e-1/p_b=0/n=20/unfolded/sfs.csv"" + p_b = 0.4 + s_b = 18 + s_d = 67 + b = 7 + mu = 1e-9 + out = ""scratch/slim_dfe.png"" + +import fastdfe as fd + +spectra = fd.Spectra.from_file(spectra_file) + +Ne = spectra['neutral'].theta / (4 * mu) + +params = dict( + S_d=-4 * Ne * s_d, + b=b, + p_b=p_b, + S_b=4 * Ne * s_b, + N_e=Ne +) + +params_str = dict( + S_d=f""{params['S_d']:.0f}"", + b=f""{params['b']:.2f}"", + p_b=f""{params['p_b']:.2f}"", + S_b=f""{params['S_b']:.1f}"", + N_e=f""{params['N_e']:.0f}"" +) + +fig, ax = plt.subplots(figsize=(4.5, 2.2)) +plt.rcParams['axes.titlesize'] = 11 + +fd.GammaExpParametrization().plot( + params=dict(S_d=min(params['S_d'], -1e-16), S_b=max(params['S_b'], 1e-16), b=b, p_b=p_b), + intervals=[-np.inf, -100, -10, -1, 1, np.inf], + title='Simulated DFE\n' + "", "".join([f""${k}$={v}"" for k, v in params_str.items()]), + show=testing, + file=out, + ax=ax +) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_parser_pendula.py",".py","673","28","import fastdfe as fd + +basepath = ""../resources/genome/betula/"" + +# instantiate parser +p = fd.Parser( + n=8, # SFS sample size + vcf=(basepath + ""all.with_outgroups.vcf.gz""), + fasta=basepath + ""genome.subset.1000.fasta.gz"", + gff=basepath + ""genome.gff.gz"", + annotations=[ + fd.DegeneracyAnnotation(), # determine degeneracy + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], # use one outgroup + n_ingroups=20, # subsample size + max_sites=50000 + ) + ], + stratifications=[fd.DegeneracyStratification()] +) + +# obtain SFS +spectra: fd.Spectra = p.parse() + +spectra.plot(title=""SFS"") + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_synonymy.py",".py","1302","51",""""""" +Annotate synonymy of variants in a VCF file. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-12"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + vcf_file = snakemake.input.vcf + fasta = snakemake.input.ref + gff = snakemake.input.gff + aliases = snakemake.params.aliases + out = snakemake.output[0] +except ModuleNotFoundError: + # testing + testing = True + vcf_file = ""https://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/1000_genomes_project/release/"" \ + ""20181203_biallelic_SNV/ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"" + fasta = ""https://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" \ + ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"" + gff = ""https://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" \ + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"" + aliases = dict(chr21=['21']) + out = 'scratch/synonymy.vcf' + +import fastdfe as fd + +fd.logger.setLevel('DEBUG') + +# initialize annotator +ann = fd.Annotator( + vcf=vcf_file, + fasta=fasta, + gff=gff, + aliases=aliases, + output=out, + annotations=[fd.SynonymyAnnotation()], +) + +# run annotator +ann.annotate() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_parametrization.py",".py","1512","72",""""""" +Visualize a DFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-06"" + +import numpy as np +from matplotlib import pyplot as plt + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input = snakemake.input[0] + postprocessing_source = '../resources/polydfe/postprocessing/script.R' + out = snakemake.output[0] +except ModuleNotFoundError: + # testing + testing = True + n = 20 + params = { + 'S_d': -1000, + 'b': 0.1, + 'p_b': 0.1, + 'S_b': 0.1 + } + out = ""scratch/parametrization.png"" + +import fastdfe as fd + +p = fd.GammaExpParametrization() +d = fd.Discretization( + n=n, + intervals_ben=(1e-15, 1000, 1000), + intervals_del=(-1000000, -1e-15, 1000) +) + +d1 = p.get_pdf(**params)(d.s) +d2 = p._discretize(params, d.bins) / d.interval_sizes + +plt.plot(np.arange(d.n_intervals), d1, alpha=0.5, label='midpoints') +plt.plot(np.arange(d.n_intervals), d2, alpha=0.5, label='exact') + +plt.legend() + +ax = plt.gca() +xticks = ax.get_xticks() +labels = [""{:.0e}"".format(d.s[int(l)]) if 0 <= int(l) < d.n_intervals else None for l in xticks] +ax.set_xticklabels(labels) + +plt.title(params) +plt.margins(x=0) + +plt.xlabel('S') +plt.ylabel('f(S)') + +plt.gcf().set_size_inches(np.array([1, 0.35]) * np.array(plt.rcParams[""figure.figsize""])) + +plt.savefig(out, dpi=200, bbox_inches='tight', pad_inches=0.1) + +if testing: + plt.show() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_covariates.py",".py","2378","87",""""""" +Infer the joint DFE from the SFS using fastDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + testing = False + config_file = snakemake.input[0] + kwargs_legend = snakemake.params.get('legend', {}) + figsize = snakemake.params.get('figsize', (20, 10)) + out_summary = snakemake.output.summary + out_serialized = snakemake.output.serialized + out_dfe = snakemake.output.get('dfe', None) + out_covariates = snakemake.output.get('covariates', None) + out_spectra = snakemake.output.get('spectra', None) + out_params = snakemake.output.get('params', None) +except NameError: + # testing + testing = True + # config_file = 'results/configs/example_1_C_full_anc/config.yaml' + # config_file = 'results/configs/example_1_C_deleterious_anc_bootstrapped_100/config.yaml' + # config_file = 'results/configs/pendula_C_full_anc_bootstrapped_100/config.yaml' + config_file = 'results/fastdfe/arabidopsis/cov/S_d.mean.rsa.10.20.yaml' + kwargs_legend = {} + figsize = (20, 10) + out_summary = ""scratch/summary.json"" + out_serialized = ""scratch/serialized.json"" + out_dfe = ""scratch/dfe.png"" + out_covariates = ""scratch/covariates.png"" + out_spectra = ""scratch/spectra.png"" + out_params = ""scratch/params.png"" + +import fastdfe as fd + +# create from config +inf = fd.JointInference.from_config_file(config_file) + +# perform inference +inf.run() + +# save object in serialized form +inf.to_file(out_serialized) + +# save summary +inf.get_summary().to_file(out_summary) + +p = f""p: {inf.perform_lrt_covariates():.2e}"" +c0 = f""c0: ({inf.bootstraps.mean()[inf.types[0] + '.c0']:.2e}, {inf.bootstraps.var()[inf.types[0] + '.c0']:.2e})"" + +# plot results +inf.plot_inferred_parameters( + file=out_params, + show=testing, + title=f'inferred parameters, {p}, {c0}', + kwargs_legend=kwargs_legend +) + +inf.plot_sfs_comparison( + use_subplots=True, + file=out_spectra, + show=testing, + title=f'SFS comparison, {p}, {c0}', + kwargs_legend=kwargs_legend +) + +inf.plot_discretized( + file=out_dfe, + show=testing, + title=f'DFE comparison, {p}, {c0}', + kwargs_legend=kwargs_legend +) + +inf.plot_covariate( + file=out_covariates, + show=testing, + title=f'covariate comparison, {p}, {c0}' +) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/simulate_sfs.py",".py","2654","102",""""""" +Simulate the selected SFS using fastDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2024-12-25"" + +import numpy as np +import re +from matplotlib import pyplot as plt + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('.') + + testing = False + sfs_file = snakemake.input[0] + s_b = snakemake.params.s_b + b = snakemake.params.b + s_d = snakemake.params.s_d + p_b = snakemake.params.p_b + n = snakemake.params.n + h = snakemake.params.h + mu = snakemake.params.mu + demography = snakemake.params.demography + parallelize = snakemake.params.get('parallelize', False) + title = snakemake.params.title + out_sfs = snakemake.output.sfs + out_comparison = snakemake.output.comp +except NameError: + + def get_param(string, param): + return float(re.search(rf""{param}=([\d.e+-]+)"", string).group(1)) + + # testing + testing = True + sfs_file = 'results/slim/n_replicate=1/n_chunks=100/g=1e4/L=1e7/mu=1e-8/r=1e-7/N=1e3/s_b=1e-3/b=0.3/s_d=3e-1/p_b=0.00/n=20/constant/unfolded/sfs.csv' + s_b = get_param(sfs_file, 's_b') + b = get_param(sfs_file, '/b') + s_d = get_param(sfs_file, 's_d') + p_b = get_param(sfs_file, 'p_b') + n = 20 + h = float(re.search(r""dominance_function_([\d.]+)"", sfs_file).group(1)) if ""dominance"" in sfs_file else 0.5 + mu = 1e-8 + demography = ""constant"" + parallelize = True + title = f""$s_b$={s_b:.0e}, $b$={b}, $s_d$={s_d:.0e}, $p_b$={p_b}"" + out_sfs = ""scratch/sfs.csv"" + out_comparison = ""scratch/comp.png"" + +import fastdfe as fd + +spectra = fd.Spectra.from_file(sfs_file) + +theta = spectra['neutral'].theta +Ne = theta / (4 * mu) + +model = fd.GammaExpParametrization() +model.bounds['S_b'] = (1e-10, 100) +model.bounds['S_d'] = (-1e6, -1e-2) + +if demography == 'dominance_function': + h_callback = lambda k, S: np.maximum(0.4 * np.exp(-h * abs(S / (4 * Ne))), 0.1) + #h_callback = lambda k, S: np.full_like(S, 0.7) +else: + h_callback = lambda h, S: np.full_like(S, h) + +sim = fd.Simulation( + params=dict( + S_b=4 * Ne * s_b, + b=b, + S_d=-4 * Ne * s_d, + p_b=p_b, + h=h, + ), + intervals_del=(-1.0e+8, -1.0e-5, 100), + intervals_ben=(1.0e-5, 1.0e4, 100), + h_callback=h_callback, + sfs_neut=spectra['neutral'], + model=model, + parallelize=parallelize, +) + +sfs_sel = sim.run() + +sfs_sel.to_file(out_sfs) + +fig, ax = plt.subplots(figsize=np.array([4, 3]) * 0.9) + +comp = fd.Spectra(dict( + slim=spectra['selected'], + fastdfe=sfs_sel +)) + +plt.rcParams['axes.titlesize'] = 11 +comp.plot(file=out_comparison, show=testing, title=title, ax=ax) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/setup_config_est_sfs.py",".py","589","26",""""""" +Set up the config for est-sfs. +We use the substitution model (1) recommended by the paper. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +try: + out = snakemake.output[0] + config = snakemake.config + max_sites = snakemake.config['max_sites'] +except NameError: + # testing + out = ""scratch/est-sfs.config"" + config = { + 'n_outgroup': 2, + 'model': 1, + 'nrandom': 5 + } + +with open(out, 'w') as f: + for param in [""n_outgroup"", ""model"", 'nrandom']: + f.write(f""{param} {config[param]}\n"") +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/create_config.py",".py","1114","48",""""""" +Create a config file which can be used both to run +polyDFE and the new inference tool. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-07"" + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + spectra_file = snakemake.input.sfs + init_file = snakemake.input.init + do_bootstrap = snakemake.params.get('do_bootstrap', None) + model = snakemake.params.get('model', 'GammaExpParametrization') + out = snakemake.output[0] +except ModuleNotFoundError: + # testing + testing = True + spectra_file = 'resources/polydfe/pubescens/spectra/sfs.txt' + init_file = 'resources/polydfe/init/D.full_init' + do_bootstrap = None + model = 'DiscreteParametrization' + out = 'scratch/config.yaml' + +import fastdfe as fd + +# create config object +config = fd.Config( + polydfe_spectra_config=spectra_file, + polydfe_init_file=init_file, + do_bootstrap=do_bootstrap, + n_bootstraps=10, + model=model +) + +# save config to file +config.to_file(out) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/parse_vcf_betula.py",".py","1325","60",""""""" +Parse betula VCF. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-08-06"" + +import pandas as pd + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + vcf_file = snakemake.input.vcf + fasta = snakemake.input.ref + gff = snakemake.input.gff + samples_file = snakemake.input.samples + n = snakemake.params.n + out_csv = snakemake.output.csv + out_png = snakemake.output.png +except NameError: + + # testing + testing = True + vcf_file = '../resources/genome/betula/all.polarized.vcf.gz' + fasta = '../resources/genome/betula/genome.fasta' + gff = '../resources/genome/betula/genome.gff.gz' + samples_file = '../resources/genome/betula/sample_sets/pendula.args' + n = 10 + out_csv = ""scratch/sfs_parsed.csv"" + out_png = ""scratch/sfs_parsed.png"" + +import fastdfe as fd + +p = fd.Parser( + vcf=vcf_file, + fasta=fasta, + gff=gff, + n=n, + annotations=[fd.DegeneracyAnnotation()], + filtrations=[ + fd.CodingSequenceFiltration(), + fd.PolyAllelicFiltration(), + ], + stratifications=[fd.DegeneracyStratification()], + include_samples=pd.read_csv(samples_file).iloc[:, 0].tolist() +) + +sfs = p.parse() + +sfs.plot(show=testing, file=out_png) + +sfs.to_file(out_csv) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/filter_sample_set.py",".py","722","27",""""""" +Filter the given sample set to satisfy `samples[filter_col] == filter_val`. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2022-05-31"" + +import pandas as pd + +try: + samples_file = snakemake.input[0] + filter_col = snakemake.params.get('filter_col', 'species') + filter_val = snakemake.params.filter_val + sep = snakemake.params.get('sep', '\t') + out = snakemake.output[0] +except NameError: + samples_file = ""resources/quercus/ingroups.csv"" + filter_col = 'species' + filter_val = 'Qa' + sep = '\t' + out = ""scratch/acutissima.csv"" + +samples = pd.read_csv(samples_file, sep=sep) + +samples[samples[filter_col] == filter_val].to_csv(out, index=False, sep=sep) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_from_spectra.py",".py","1088","57",""""""" +Infer the DFE from the SFS. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-25"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + spectra_file = snakemake.input.spectra + out_serialized = snakemake.output.serialized +except NameError: + # testing + testing = True + spectra_file = ""scratch/parse_spectra_from_url.spectra.csv"" + out_serialized = ""scratch/infer_dfe_from_url.serialized.json"" + +from fastdfe import BaseInference, Spectra + +# parse spectra and fold +spectra = Spectra.from_file(spectra_file) + +# fold spectra +spectra = spectra.fold() + +# plot spectra +spectra.plot() + +# create inference +inf = BaseInference( + sfs_neut=spectra['neutral'], + sfs_sel=spectra['selected'], + n_bootstraps=100, + do_bootstrap=True, + n_runs=30 +) + +# perform inference +inf.run() + +# save object in serialized form +inf.to_file(out_serialized) + +# plot data +if testing: + inf.plot_discretized() + inf.plot_inferred_parameters() + inf.plot_sfs_comparison() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/create_config_from_spectra.py",".py","1014","42",""""""" +Create a config file given a spectra object. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-07"" + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + spectra_file = snakemake.input.spectra + init_file = snakemake.input.init + levels = snakemake.params.get('levels', [1]) + out = snakemake.output[0] +except ModuleNotFoundError: + # testing + testing = True + spectra_file = 'results/spectra/pendula.pubescens.example_1.example_2.example_3.csv' + init_file = 'resources/polydfe/init/C.full_anc_init' + levels = [1] + out = 'scratch/config_merged.yaml' + +from fastdfe import Spectra, Config + +spectra = Spectra.from_file(spectra_file) + +config = Config( + sfs_neut=spectra[['sfs_neut.*']].merge_groups(levels), + sfs_sel=spectra[['sfs_sel.*']].merge_groups(levels), + polydfe_init_file=init_file, + n_bootstraps=2 +) + +config.to_file(out) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/compare_speed_parallelization.py",".py","591","23","import sys +sys.path.append('.') + +import fastdfe as fd + +inf = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + fixed_params=dict(all=dict(h=0.5)), + parallelize=False +) + +inf.run() + +inf = fd.BaseInference( + sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]), + sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]), + fixed_params=dict(all=dict(h=0.5)), + parallelize=True +) + +inf.run() +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_nested_likelihoods.py",".py","707","35",""""""" +Compare different model type using likelihood ratio tests. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-16"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + input = snakemake.input[0] + out = snakemake.output[0] +except NameError: + # testing + testing = True + input = ""results/fastdfe/pendula_C_full_bootstrapped_100/serialized.json"" + out = ""scratch/lrt.png"" + +import fastdfe as fd + +fd.logger.setLevel(logging.INFO) + +# load object from file +inference = fd.BaseInference.from_file(input) + +# compare nested models +inference.plot_nested_models(file=out, show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dfe_polydfe.py",".py","1522","59",""""""" +Run polyDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-06"" + +import os + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + execute = shell + testing = False + config_file = snakemake.input[0] + bin = snakemake.params.get('bin', '../resources/polydfe/bin/polyDFE-2.0-macOS-64-bit') + out = snakemake.output.polydfe + out_summary = snakemake.output.summary + out_serialized = snakemake.output.serialized + out_dfe = snakemake.output.get('dfe', None) + out_params = snakemake.output.get('params', None) +except ModuleNotFoundError: + # testing + testing = True + execute = None + config_file = 'results/configs/pendula_D_full/config.yaml' + bin = '../resources/polydfe/bin/polyDFE-2.0-macOS-64-bit' + out = 'scratch/polydfe_out.txt' + out_summary = 'scratch/polydfe_out.json' + out_serialized = 'scratch/polydfe_serialized.json' + out_dfe = ""scratch/dfe.png"" + out_params = ""scratch/params.png"" + +from fastdfe import Config +from fastdfe.polydfe import PolyDFE + +config = Config.from_file(config_file) + +polydfe = PolyDFE(config) + +summary = polydfe.run(out, binary=bin, wd=os.getcwd(), execute=execute) + +# save summary to file +summary.to_file(out_summary) + +# save polyDFE wrapper object to file +polydfe.to_file(out_serialized) + +polydfe.plot_inferred_parameters(file=out_params, show=testing) +polydfe.plot_discretized(file=out_dfe, show=testing) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/merge_spectra_hominidae.py",".py","1516","60",""""""" +Merge spectra from the great apes study. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-31"" + +import pandas as pd + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + testing = False + types = snakemake.params.types + param = snakemake.params.param + sfs_neutral = snakemake.input.neutral + sfs_selected = snakemake.input.selected + out = snakemake.output[0] +except NameError: + # testing + testing = True + types = [ + 'bonobo', + 'bornean_orang', + 'central_chimp', + 'eastern_chimp', + 'human', + 'NC_chimp', + 'sumatran_orang', + 'western_chimp', + 'western_lowland_gorilla' + ] + param = 'S_d' + sfs_neutral = [f'../resources/SFS/hominidae/uSFS/{t}_4fold_all_sfs.txt' for t in types] + sfs_selected = [f'../resources/SFS/hominidae/uSFS/{t}_0fold_all_sfs.txt' for t in types] + out = ""scratch/joint_inference.yaml"" + +import fastdfe as fd + + +def get_sfs(file: str) -> fd.Spectrum: + """""" + Get SFS from file. + + :param file: The file to read the SFS from. + :return: The SFS. + """""" + return fd.Spectrum(pd.read_csv(file, header=None).iloc[0].tolist()) + + +neutral = fd.Spectra.from_spectra(dict((t, get_sfs(sfs_neutral[i])) for i, t in enumerate(types))) +selected = fd.Spectra.from_spectra(dict((t, get_sfs(sfs_selected[i])) for i, t in enumerate(types))) + +spectra = neutral.prefix('neutral') + selected.prefix('selected') + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/gather_lines.jl",".jl","964","38",""""""" +Merge the lines of several files into one file. +"""""" + +if @isdefined snakemake + input = snakemake.input + out = snakemake.output[1] +else + input = Dict(i => ""results/test/remote/est-sfs/passed.biallelic.90.probs."" * string(i) * "".4.txt"" for i in 1:4) + out = ""scratch/probs.txt"" +end + +# iterate over all files and write one line per file for each iteration +function gather_lines(f_chunks) + open(out, ""w"") do f_out + while true + # iterate over file handles and write lines + for f in f_chunks + line = readline(f) + + if length(line) > 0 + write(f_out, line * ""\n"") + else + return + end + end + end + end +end + +# initialize file handles +# make sure they are ordered correctly +f_chunks = [open(f) for f in [input[i] for i in 1:length(input)]] + +gather_lines(f_chunks) + +# close file handles +[close(f) for f in f_chunks]","Julia" +"Allele","Sendrowski/fastDFE","snakemake/scripts/plot_pca.py",".py","7731","244",""""""" +Create a PCA plot. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2023-05-27"" + +import warnings + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns +from pandas_plink import read_plink +from sklearn.decomposition import PCA +from sklearn.impute import SimpleImputer + +try: + testing = False + bed = snakemake.input.bed + samples_file = snakemake.input.samples + name_col = snakemake.params.get('name_col', 'name') + add_names = snakemake.params.get('add_names', False) + marker_size = snakemake.params.get('marker_size', 20) + label_col = snakemake.params.get('label_col', None) + label_dict = snakemake.params.get('label_dict', None) + legend_title = snakemake.params.get('legend_title', None) + legend_outside = snakemake.params.get('legend_outside', True) + legend = snakemake.params.get('add_legend', True) + legend_n_cols = snakemake.params.get('legend_n_cols', 3) + legend_size = snakemake.params.get('legend_size', 6) + subsample_size = snakemake.params.get('subsample_size', 0) + seed = snakemake.params.get('seed', 0) + cbar = snakemake.params.get('cbar', True) + cmap = snakemake.params.get('cmap', None) + out = snakemake.output[0] +except NameError: + # testing + testing = True + bed = 'results/plink/hgdp/21.bed' + samples_file = 'results/sample_sets/hgdp/French.csv' + name_col = 'sample' + add_names = False + marker_size = 20 + label_col = 'population' + label_dict = {} + legend_title = None + legend = True + legend_size = 6 + legend_n_cols = 3 + cbar = False + legend_outside = True + subsample_size = 10000 + seed = 0 + cmap = None + out = ""scratch/pca.png"" + + +def load_data( + bed: str, + samples_file: str, + subsample_size: int, + seed: int, + name_col: str = 'name', + sep: str = '\t' +): + """""" + Load the data from the bed file and the samples file. + + :param bed: Bed file with the genotypes. + :param samples_file: File with the samples. + :param subsample_size: Subsample the SNPs to this size. + :param seed: The seed for the random number generator. Use ``None`` for no seed. + :param name_col: The column in the samples file that contains the names of the samples. + :param sep: The separator of the samples file. + :raises ValueError: If the samples in the samples file are not a subset of the samples in the bed file. + """""" + # load genotypes + (bim, fam, genotypes) = read_plink(bed) + + # subsample SNPs if desired + if subsample_size and genotypes.shape[0] > subsample_size: + indices = np.random.default_rng(seed=seed).choice(range(genotypes.shape[0]), subsample_size, replace=False) + genotypes = genotypes[indices] + + # load samples + samples = pd.read_csv(samples_file, sep=sep) + + # make sure the samples in samples_file are a subset of fam.iid + if not set(samples[name_col].values).issubset(set(fam.iid.values)): + raise ValueError(""Some samples in samples file are not in the fam.iid!"") + + # order samples by fam.iid + order = {sample: i for i, sample in enumerate(fam.iid.values)} + samples[""ordering""] = samples[name_col].map(order) + samples.sort_values(by=""ordering"", inplace=True) + + # create a map of sample name to index in fam.iid + fam_order = {name: i for i, name in enumerate(fam.iid.values)} + + # get indices of samples in fam.iid order + samples_indices = samples[name_col].map(fam_order).values + + # subset + genotypes = genotypes[:, samples_indices] + + # Silence FutureWarning: The `numpy.may_share_memory` function is not implemented by Dask array. + # You may want to use the da.map_blocks function or something similar to silence this warning. + # Your code may stop working in a future release + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"") + + # impute missing genotype values + genotypes = SimpleImputer(missing_values=np.nan, strategy=""mean"").fit_transform(genotypes) + + # transpose + return np.array(genotypes).T, samples + + +def prepare_plot( + x: np.ndarray, + y: np.ndarray, + label_dict: dict, + samples: pd.DataFrame, + label_col: str, + marker_size: int = 20, + cmap: str = None, + legend: bool = True, + legend_title: str = None, + legend_outside: bool = True, + legend_n_cols: int = 1, + legend_size: int = 6, + cbar: bool = None, + name_col: str = 'name', + add_names: bool = False, +) -> plt.Axes: + """""" + Prepare a PCA plot. + + :param x: The x values. + :param y: The y values. + :param label_dict: A dictionary that maps the labels to new labels. + :param samples: Dataframe with the samples. + :param label_col: The column in the samples file that contains the labels. + :param marker_size: The size of the markers. + :param cmap: The colormap. + :param legend: Whether to add a legend. + :param legend_title: The title of the legend. + :param legend_outside: Whether to put the legend outside the plot. + :param legend_n_cols: The number of columns in the legend. + :param legend_size: The size of the legend. + :param cbar: Whether to add a color bar. + :param name_col: The column in the samples file that contains the names of the samples. + :param add_names: Whether to add sample names to the plot. + :return: + """""" + # recode labels if desired and replace missing values with placeholder + if label_dict: + samples['label_dict'] = [label_dict[x] if x in label_dict else '-' for x in samples[label_col]] + + label_col = 'label_dict' + else: + # replace missing values + if label_col: + samples.loc[samples[label_col].isna(), label_col] = '-' + + # plot the 2 components + ax = sns.scatterplot(x=x, y=y, hue=samples[label_col] if label_col else None, s=marker_size, palette=cmap) + + # whether to include a legend + if legend: + # set legend title + ax.get_legend().set_title(legend_title) + + # whether to place the legend outside the graph + if legend_outside: + plt.legend(loc='center left', bbox_to_anchor=(1.02, 0.5), ncol=legend_n_cols, prop={'size': legend_size}) + else: + if ax.get_legend(): + ax.get_legend().remove() + + # whether to show a color bar + if cbar: + norm = plt.Normalize(samples[label_col].min(), samples[label_col].max()) + sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + sm.set_array([]) + + ax.figure.colorbar(sm) + + # add sample names if specified + if add_names: + eps = 0.15 + + for i in range(samples.shape[0]): + plt.text(x=x[i] + eps, y=y[i] + eps, s=samples[name_col][i], size=4, alpha=0.5) + + plt.gca().axis('square') + + plt.tight_layout(pad=5) + + return plt.gca() + + +genotypes, samples = load_data( + bed=bed, + samples_file=samples_file, + subsample_size=subsample_size, + seed=seed, + name_col=name_col +) + +pca = PCA(n_components=2) +pc = pca.fit_transform(genotypes) + +prepare_plot( + x=pc[:, 0], + y=pc[:, 1], + label_dict=label_dict, + samples=samples, + label_col=label_col, + marker_size=marker_size, + cmap=cmap, + legend=legend, + legend_title=legend_title, + legend_outside=legend_outside, + legend_n_cols=legend_n_cols, + legend_size=legend_size, + cbar=cbar, + name_col=name_col, + add_names=add_names +) + +# add axis labels +v1 = round(pca.explained_variance_ratio_[0] * 100, 2) +v2 = round(pca.explained_variance_ratio_[1] * 100, 2) +plt.xlabel(f'{v1}%') +plt.ylabel(f'{v2}%') + +plt.savefig(out, dpi=200, bbox_inches='tight', pad_inches=0.1) + +if testing: + plt.show() +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_vep.py",".py","571","30",""""""" +Predict the variant effects with VEP. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2023-05-13"" + +from snakemake.shell import shell + +ref = snakemake.input.ref +vcf = snakemake.input.vcf +gff = snakemake.input.gff +species = snakemake.params.species +out = snakemake.output[0] + +shell( + f""vep "" + f""--gff {gff} "" + f""--fasta {ref} "" + f""-i {vcf} "" + f""--vcf "" + f""--species {species} "" + f""--allow_non_variant "" + f""-o {out} "" + f""--fields 'Consequence,Codons' "" + f""--compress_output bgzip "" + f""--pick"" +) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/determine_4fold_vs_0fold.py",".py","1229","31",""""""" +Determine the ratio of 4-fold to 0-fold sites in a genome by using TargetSiteCounter. +"""""" + +import fastdfe as fd + +p = fd.Parser( + n=20, # number of individuals not important + # choose sufficiently many sites since TargetSiteCounter is restricted to the same genomic interval + max_sites=10000, + vcf=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" + ""genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true"", + fasta=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" + ""genome/betula/genome.subset.1000.fasta.gz?raw=true"", + gff=""https://github.com/Sendrowski/fastDFE/blob/dev/resources/"" + ""genome/betula/genome.gff.gz?raw=true"", + target_site_counter=fd.TargetSiteCounter( + n_target_sites=100000, # doesn't matter since we're only interested in the ratio + n_samples=10000 # choose sufficiently many samples for the ratio to be accurate + ), + stratifications=[fd.DegeneracyStratification()], # stratify by 4-fold and 0-fold sites + annotations=[fd.DegeneracyAnnotation()], # annotate sites with degeneracy on-the-fly + filtrations=[fd.SNPFiltration()], +) + +sfs = p.parse() + +r = sfs['neutral'].data[0] / sfs['selected'].data[0] + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_pendula_model_comp.py",".py","455","25","import matplotlib.pyplot as plt + +import fastdfe as fd + +# create inference object +inf = fd.BaseInference( + # neutral SFS + sfs_neut=fd.Spectrum( + [177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652] + ), + # selected SFS + sfs_sel=fd.Spectrum([ + 797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794] + ), + do_bootstrap=True +) + +# run inference +inf.run() + +# plot discretized DFE +inf.plot_nested_models(show=False) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/remove_info_tags_vcf.py",".py","1000","44",""""""" +Remove polarization from VCF file. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-12-09"" + +from cyvcf2 import VCF, Writer +from tqdm import tqdm + +try: + from snakemake.shell import shell + + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + vcf_in = snakemake.input.vcf + tags = snakemake.params.tags + vcf_out = snakemake.output.vcf +except ModuleNotFoundError: + # testing + testing = True + vcf_in = ""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz"" + tags = [""AA"", ""Degeneracy"", ""Degeneracy_Info"", ""Synonymy"", ""Synonymy_Info"", ""EST_SFS_input"", ""EST_SFS_probs""] + vcf_out = ""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz.new"" + +# remove polarization (AA tag) using cyvcf2 +vcf = VCF(vcf_in) + +writer = Writer(vcf_out, vcf) + +# remove polarization +for v in tqdm(vcf): + for tag in tags: + del v.INFO[tag] + + writer.write_record(v) + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_snpeff.py",".py","420","25",""""""" +Predict the variant effects with SnpEff. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""j.sendrowski18@gmail.com"" +__date__ = ""2023-05-21"" + +from snakemake.shell import shell + +vcf = snakemake.input.vcf +species = snakemake.params.species +out = snakemake.output[0] + +# download database +shell(""snpEff download {species}"") + +# annotate +shell( + f""snpEff "" + f""-v {species} "" + f""{vcf} "" + f""| bgzip > {out}"" +) +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/example_pendula_joint.py",".py","757","32","import fastdfe as fd + +# neutral SFS for two types +sfs_neut = fd.Spectra(dict( + pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] +)) + +# selected SFS for two types +sfs_sel = fd.Spectra(dict( + pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] +)) + +# create inference object +inf = fd.JointInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + shared_params=[fd.SharedParams(types=[""pendula"", ""pubescens""], params=[""eps"", ""S_d""])], + do_bootstrap=True +) + +# run inference +inf.run() + +# plot discretized DFE +inf.plot_discretized() + +# inf.plot_inferred_parameters() + +pass +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/infer_dominance_simulation.py",".py","4925","208","import sys + +import numpy as np +import pandas as pd + +# necessary to import fastdfe locally +sys.path.append('.') + +from matplotlib.cm import ScalarMappable +import matplotlib.gridspec as gridspec +from matplotlib import pyplot as plt +import fastdfe as fd + +try: + testing = False + hs = np.round(np.linspace(0, 1, 11), 2) + n = snakemake.params.n + n_runs = 10 + n_bootstraps = 100 + n_bootstrap_retries = 2 + intervals_del = (-1.0e+8, -1.0e-5, 100) + intervals_ben = (1.0e-5, 1.0e4, 100) + intervals_h = (0, 1, 21) + out = snakemake.output[0] +except NameError: + # testing + testing = True + hs = np.round(np.linspace(0, 1, 11), 2) + n = 20 + n_runs = 10 + n_bootstraps = 10 + n_bootstrap_retries = 2 + intervals_del = (-1.0e+8, -1.0e-5, 100) + intervals_ben = (1.0e-5, 1.0e4, 100) + intervals_h = (0, 1, 21) + out = ""compare_dfe_accuracy.png"" + +d = fd.discretization.Discretization( + n=n, + h=None, + intervals_del=intervals_del, + intervals_ben=intervals_ben, + intervals_h=intervals_h +) + +sims, infs = {}, {} +for h in hs: + sims[h] = fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=n, n_sites=1e8, theta=1e-4), + params=dict(S_d=-300, b=0.3, p_b=0, S_b=1, h=h), + model=fd.GammaExpParametrization(), + intervals_del=intervals_del, + intervals_ben=intervals_ben, + discretization=d + ) + sims[h].run() + + infs[h] = fd.BaseInference( + sfs_neut=sims[h].sfs_neut / 2, + sfs_sel=sims[h].sfs_sel, + intervals_h=intervals_h, + intervals_del=intervals_del, + intervals_ben=intervals_ben, + discretization=d, + fixed_params=dict(all=dict(eps=0, p_b=0, S_b=1)), + n_runs=n_runs, + n_bootstraps=n_bootstraps, + n_bootstrap_retries=n_bootstrap_retries, + ) + + infs[h].run() + +fig = plt.figure(figsize=(9, 5)) + +gs = gridspec.GridSpec(2, 3, width_ratios=[1, 1, 0.05]) + +# generate the 2×2 axes grid in one go +ax = np.array([[fig.add_subplot(gs[i, j]) for j in range(2)] for i in range(2)]) + +# colorbar axis spans all rows in last column +cax = fig.add_subplot(gs[:, 2]) + +plt.rcParams['xtick.labelsize'] = 9 +plt.rcParams[""legend.fontsize""] = 9 + +# global color map for all h +cmap = plt.cm.viridis +norm = plt.Normalize(min(hs), max(hs)) +colors = {h: cmap(norm(h)) for h in hs} + +fd.Spectra.from_spectra( + {f""h={h}"": infs[h].sfs_sel for h in hs} +).plot(ax=ax[0, 0], show=False) +ax[0, 0].set_title( + f'Selected SFS $({"", "".join([f""{k}={v}"" for k, v in sims[hs[0]].params.items() if k in [""S_d"", ""b"", ""p_b""]])})$' +) +ax[0, 0].legend_.remove() + +bars = ax[0, 0].patches +offset = 0 + +# each h +for h in hs: + for b in bars[offset: offset + n + 1]: + b.set_facecolor(colors[h]) + b.set_alpha(0.8) + b.set_hatch("""") + offset += n + 1 + +fd.DFE.plot_many( + [sims[hs[0]].dfe] + [inf.get_dfe() for inf in infs.values()], + labels=['true DFE'] + ['_nolegend_' for _ in hs], + intervals=[-np.inf, -100, -10, -1, 0], + ax=ax[0, 1], + show=False, + point_estimate='mean', + title='Inferred DFE under varying $h$' +) +leg = ax[0, 1].legend() + +bars = ax[0, 1].patches +n_bins = 4 +offset = 0 + +legend_handle = leg.get_patches()[0] +legend_handle.set_facecolor(""grey"") +legend_handle.set_alpha(0.9) + +for b in bars[offset: offset + n_bins]: + b.set_facecolor(""grey"") + b.set_alpha(0.9) + b.set_hatch("""") +offset += n_bins + +# inferred DFEs = one block per h +for h in hs: + for b in bars[offset: offset + n_bins]: + b.set_facecolor(colors[h]) + b.set_alpha(0.9) + b.set_hatch("""") + offset += n_bins + +data = [infs[h].bootstraps[""h""].values for h in hs] + +vp = ax[1, 0].violinplot( + data, + positions=hs, + showmeans=True, + showextrema=False, + widths=0.08 +) + +# recolor each body +for h, body in zip(hs, vp['bodies']): + body.set_facecolor(colors[h]) + body.set_edgecolor(colors[h]) + body.set_alpha(0.8) + +# recolor the means +if 'cmeans' in vp: + vp['cmeans'].set_color('black') + +ax[1, 0].set_xlabel(""true $h$"") +ax[1, 0].set_ylabel(""inferred $h$"") +ax[1, 0].set_title(""Inferred vs true $h$"") + +vals = [] +for h in hs: + df = infs[h].bootstraps.copy() + df[""S_d""] = df[""S_d""].abs() + df[""true_h""] = h + vals.append(df) + +df_all = pd.concat(vals, ignore_index=True) + +# Normalize true_h into [0,1] for colormap +norm = plt.Normalize(min(hs), max(hs)) +cmap = plt.cm.viridis + +sc = ax[1, 1].scatter( + df_all[""S_d""], + df_all[""h""], + s=12, + alpha=0.5, + c=df_all[""true_h""], + cmap=cmap, + norm=norm, +) + +ax[1, 1].set_xscale(""log"") +ax[1, 1].set_xlabel(""$S_d$"") +ax[1, 1].set_ylabel(""$h$"") +ax[1, 1].set_title(""Bootstrap distribution of $h$ vs $S_d$"") + +# add colorbar +sm = ScalarMappable(norm=norm, cmap=cmap) +sm.set_array([]) + +cbar = fig.colorbar(sm, cax=cax) +cbar.ax.set_ylabel(""h"", rotation=0, labelpad=0, va='center', fontsize=13) + +plt.tight_layout(pad=0.8) + +fig.savefig(out, dpi=200) + +if testing: + plt.show() +","Python" +"Allele","Sendrowski/fastDFE","snakemake/scripts/annotate_polarization.py",".py","1310","54",""""""" +Annotate polarization of variants in a VCF file. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-09-26"" + +try: + import sys + + # necessary to import fastdfe locally + sys.path.append('..') + + testing = False + vcf_file = snakemake.input.vcf + n_ingroups = snakemake.params.n_ingroups + outgroups = snakemake.params.outgroups + exclude = snakemake.params.exclude + max_sites = snakemake.params.get(""max_sites"", None) + confidence_threshold = snakemake.params.get(""confidence_threshold"", 0) + out = snakemake.output[0] +except ModuleNotFoundError: + # testing + testing = True + vcf_file = ""resources/genome/betula/biallelic.with_outgroups.vcf.gz"" + outgroups = [""ERR2103730""] + exclude = [""ERR2103731""] + n_ingroups = 20 + max_sites = 10000 + confidence_threshold = 0 + out = 'scratch/biallelic.polarized.vcf.gz' + +import fastdfe as fd + +# initialize annotator +ann = fd.Annotator( + vcf=vcf_file, + output=out, + annotations=[ + fd.MaximumLikelihoodAncestralAnnotation( + outgroups=outgroups, + exclude=exclude, + n_ingroups=n_ingroups, + max_sites=max_sites, + confidence_threshold=confidence_threshold + ) + ] +) + +# run annotation +ann.annotate() + +pass","Python" +"Allele","Sendrowski/fastDFE","fastdfe/spectrum.py",".py","33311","1164",""""""" +SFS utilities. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2022-07-24"" + +import logging +from typing import Dict, List, Union, Iterable, Any, Literal, Sequence +from numpy.random import Generator + +import numpy as np +import pandas as pd +from scipy.stats import hypergeom + +from .io_handlers import download_if_url + +# get logger +logger = logging.getLogger('fastdfe') + + +def standard_kingman(n: int) -> 'Spectrum': + """""" + Get standard Kingman SFS for theta = 1. + + :param n: Standard Kingman SFS + :return: Spectrum + """""" + return Spectrum(pad(1 / np.arange(1, int(n)))) + + +def pad(counts: Sequence) -> np.ndarray: + """""" + Pad array with monomorphic counts. + + :param counts: SFS counts to pad + :return: Padded array + """""" + return np.array([0] + list(counts) + [0]) + + +class Spectrum(Iterable): + """""" + Class for holding and manipulating a site-frequency spectrum. + """""" + + def __init__(self, data: Sequence[float]): + """""" + Initialize spectrum. + + :param data: SFS counts + """""" + self.data: np.ndarray = np.array(data, dtype=float) + + @property + def n(self) -> int: + """""" + The sample size. + + :return: Sample size + """""" + return self.data.shape[0] - 1 + + @property + def n_sites(self) -> float: + """""" + The total number of sites. + + :return: Total number of sites + """""" + return sum(self.data) + + @property + def n_div(self) -> float: + """""" + Number of divergence counts. + + :return: Number of divergence counts + """""" + return self.data[-1] + + @property + def has_div(self) -> bool: + """""" + Whether n_div was specified. + + :return: Whether n_div was specified + """""" + return self.n_div != 0 + + @property + def n_monomorphic(self) -> float: + """""" + Number of monomorphic sites. + + :return: Number of monomorphic sites + """""" + return self.data[0] + self.data[-1] + + @property + def polymorphic(self) -> np.ndarray: + """""" + Get the polymorphic counts. + + :return: Polymorphic counts + """""" + return self.data[1:-1] + + @property + def n_polymorphic(self) -> np.ndarray: + """""" + Get the polymorphic counts. + + :return: Polymorphic counts + """""" + return np.sum(self.polymorphic) + + def to_list(self) -> list: + """""" + Convert to list. + + :return: SFS counts + """""" + return list(self.data) + + def to_spectra(self) -> 'Spectra': + """""" + Convert to Spectra object. + + :return: Spectra object + """""" + return Spectra.from_spectrum(self) + + def to_file(self, file: str): + """""" + Save object to file. + + :param file: File name + """""" + self.to_spectra().to_file(file) + + @staticmethod + def from_file(file: str) -> 'Spectrum': + """""" + Load object from file. + + :param file: File name + :return: Spectrum object + """""" + return Spectra.from_file(file).to_spectrum() + + def to_numpy(self) -> np.ndarray: + """""" + Convert to array. + + :return: SFS counts + """""" + return self.data + + @property + def theta(self) -> float: + """""" + Calculate site-wise population mutation rate using Watterson's estimator. + Note that theta is given per site, i.e. Watterson's estimator is divided by the + total number of sites (:attr:`n_sites`). + """""" + return self.Theta / self.n_sites + + @property + def Theta(self) -> float: + """""" + Calculate genome-wide population mutation rate using Watterson's estimator. + + .. note:: Property :attr:`Theta` is not normalized by the total number of sites, unlike :attr:`theta`. + """""" + return self.n_polymorphic / np.sum(1 / np.arange(1, self.n)) + + def fold(self) -> 'Spectrum': + """""" + Fold the site-frequency spectrum. + + :return: Folded spectrum + """""" + mid = (self.n + 1) // 2 + data = self.data.copy() + + data[:mid] += data[-mid:][::-1] + data[-mid:] = 0 + + return Spectrum(data) + + def misidentify(self, epsilon: float) -> 'Spectrum': + """""" + Introduce ancestral misidentification at rate epsilon. Note that monomorphic counts won't be affected. + + :param epsilon: Misidentification rate (0 <= epsilon <= 1) + :return: Spectrum with misidentification applied + :raise ValueError: If epsilon is not between 0 and 1 + """""" + if not 0 <= epsilon <= 1: + raise ValueError(""epsilon must be between 0 and 1"") + + data = self.data.copy() + n = self.n + + flipped = epsilon * data[1:n][::-1] + retained = (1 - epsilon) * data[1:n] + data[1:n] = retained + flipped + + return Spectrum(data) + + def subsample( + self, + n: int, + mode: Literal['random', 'probabilistic'] = 'probabilistic', + seed: int | Generator = None + ) -> 'Spectrum': + """""" + Subsample spectrum to a given sample size. + + .. warning:: + If using the 'random' mode, The SFS counts are cast to integers before subsampling so this will + only provide sensible results if the SFS counts are integers or if they are large enough to be + approximated well by integers. The 'probabilistic' mode does not have this limitation. + + :param n: Sample size + :param mode: Subsampling mode. Either 'random' or 'probabilistic'. + :param seed: Random state or seed. Only for 'random' mode. + :return: Subsampled spectrum + """""" + if n >= self.n: + raise ValueError(f'Subsampled sample size {n} must be smaller than original sample size {self.n}.') + + if mode not in ['random', 'probabilistic']: + raise ValueError(f'Unknown subsampling mode {mode}.') + + subsample = np.zeros(n + 1, dtype=float) + + if mode == 'random': + # add monomorphic counts + subsample[0] = self.data[0] + subsample[-1] = self.data[-1] + + # iterate over spectrum and subsample hypergeometrically + for i, m in enumerate(self.polymorphic.astype(int)): + # get subsampled counts + samples = hypergeom.rvs(M=self.n, n=i + 1, N=n, size=m, random_state=seed) + + # add subsampled counts + subsample += np.histogram(samples, bins=np.arange(n + 2))[0] + else: + for i, m in enumerate(self.data): + probs = hypergeom.pmf(k=range(n + 1), M=self.n, n=i, N=n) + + # add subsampled counts + subsample += m * probs + + sfs = Spectrum(subsample) + + # fold if original spectrum was folded + if self.is_folded(): + sfs = sfs.fold() + + return sfs + + def resample(self, seed: int | Generator = None) -> 'Spectrum': + """""" + Resample SFS assuming independent Poisson counts. + + :param seed: Random state or seed + :return: Resampled spectrum. + """""" + if isinstance(seed, Generator): + rng = seed + else: + rng = np.random.default_rng(None if seed is None else int(seed)) + + return Spectrum.from_polydfe( + # resample polymorphic sites only + polymorphic=rng.poisson(lam=self.polymorphic), + n_sites=self.n_sites, + n_div=self.n_div + ) + + def is_folded(self) -> bool: + """""" + Check if the site-frequency spectrum is folded. + + :return: True if folded, False otherwise + """""" + mid = (self.n + 1) // 2 + + return np.all(self.data[-mid:] == 0) + + def normalize(self) -> 'Spectrum': + """""" + Normalize SFS so that all non-monomorphic counts add up to 1. + + :return: Normalized spectrum + """""" + # copy array + data = self.data.copy() + + # normalize counts + data[1:-1] /= data[1:-1].sum() + + return Spectrum(data) + + def copy(self) -> 'Spectrum': + """""" + Copy the spectrum. + + :return: Copy of the spectrum + """""" + return Spectrum(self.data.copy()) + + @staticmethod + def from_polymorphic(data: Sequence) -> 'Spectrum': + """""" + Create Spectrum from polymorphic counts only. + + :param data: Polymorphic counts + :return: Spectrum + """""" + return Spectrum([0] + list(data) + [0]) + + @staticmethod + def from_list(data: Sequence) -> 'Spectrum': + """""" + Create Spectrum from list. + + :param data: SFS counts + :return: Spectrum + """""" + return Spectrum(data) + + @staticmethod + def from_polydfe( + polymorphic: Sequence, + n_sites: float, + n_div: float + ) -> 'Spectrum': + """""" + Create Spectra from polyDFE specification which treats the number + of mutational target sites and the divergence counts separately. + + :param polymorphic: Polymorphic counts + :param n_sites: Total number of sites + :param n_div: Number of divergence counts + :return: Spectrum + """""" + # determine number of monomorphic ancestral counts + n_monomorphic = n_sites - np.sum(list(polymorphic) + [n_div]) + + data = [n_monomorphic] + list(polymorphic) + [n_div] + + return Spectrum(data) + + @staticmethod + def _array_or_scalar(data: Iterable | float) -> np.ndarray | float: + """""" + Convert to array if iterable or return scalar otherwise. + + :param data: Iterable or scalar. + :return: Array or scalar + """""" + if isinstance(data, Iterable): + return np.array(list(data)) + + return data + + def __mul__(self, other: Iterable | float) -> 'Spectrum': + """""" + Multiply spectrum. + + :param other: Iterable or scalar + :return: Spectrum + """""" + return Spectrum(self.data * self._array_or_scalar(other)) + + __rmul__ = __mul__ + + def __add__(self, other: Iterable | float) -> 'Spectrum': + """""" + Add spectrum. + + :param other: Iterable or scalar + :return: Spectrum + """""" + return Spectrum(self.data + self._array_or_scalar(other)) + + def __sub__(self, other: Iterable | float) -> 'Spectrum': + """""" + Subtract spectrum. + + :param other: Iterable or scalar + :return: Spectrum + """""" + return Spectrum(self.data - self._array_or_scalar(other)) + + def __pow__(self, other: Iterable | float) -> 'Spectrum': + """""" + Power operator. + + :param other: Iterable or scalar + :return: Spectrum + """""" + return Spectrum(self.data ** self._array_or_scalar(other)) + + def __floordiv__(self, other: Iterable | float) -> 'Spectrum': + """""" + Divide spectrum. + + :param other: Iterable or scalar + :return: Spectrum + """""" + return Spectrum(self.data // self._array_or_scalar(other)) + + def __truediv__(self, other: Iterable | float) -> 'Spectrum': + """""" + Add spectrum. + + :param other: Iterable or scalar + :return: Spectrum + """""" + return Spectrum(self.data / self._array_or_scalar(other)) + + def __iter__(self): + """""" + Get iterator. + + :return: Iterator + """""" + return self.data.__iter__() + + def __len__(self) -> int: + """""" + Get length of spectrum (including monomorphic and fixed counts). + + :return: Length of spectrum + """""" + return self.data.shape[0] + + def plot( + self, + show: bool = True, + file: str = None, + title: str = None, + log_scale: bool = False, + show_monomorphic: bool = False, + kwargs_legend: dict = dict(prop=dict(size=8)), + ax: 'plt.Axes' = None + ) -> 'plt.Axes': + """""" + Plot spectrum. + + :param show: Whether to show plot. + :param file: File to save plot to. + :param title: Title of plot. + :param log_scale: Whether to use log scale on y-axis. + :param show_monomorphic: Whether to show monomorphic counts. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :param ax: Axes to plot on. Only for Python visualization backend. + :return: Axes + """""" + from .visualization import Visualization + + return Visualization.plot_spectra( + spectra=[self.to_list()], + file=file, + show=show, + title=title, + log_scale=log_scale, + show_monomorphic=show_monomorphic, + ax=ax, + kwargs_legend=kwargs_legend + ) + + @staticmethod + def standard_kingman(n: int, n_monomorphic: int = 0) -> 'Spectrum': + """""" + Get standard Kingman SFS. + + :param n: sample size + :param n_monomorphic: Number of monomorphic sites. + :return: Standard Kingman SFS + """""" + sfs = standard_kingman(n) + sfs.data[0] = n_monomorphic + + return sfs + + +class Spectra: + """""" + Class for holding and manipulating site-frequency spectra of multiple types. + """""" + + def __init__(self, data: Dict[str, Iterable]): + """""" + Initialize spectra. + + :param data: Dictionary of SFS counts keyed by type + """""" + self.data: pd.DataFrame = pd.DataFrame(data) + + @property + def n(self) -> int: + """""" + The sample size. + + :return: Sample size + """""" + return self.data.shape[0] - 1 + + @property + def k(self) -> int: + """""" + The number of types. + + :return: Number of types + """""" + return self.data.shape[1] + + @property + def n_monomorphic(self) -> pd.Series: + """""" + The number of monomorphic sites. + + :return: Number of monomorphic sites + """""" + return self.data.iloc[0] + self.data.iloc[-1] + + @property + def polymorphic(self) -> np.ndarray: + """""" + The polymorphic counts. + + :return: Polymorphic counts + """""" + return self.data[1:-1] + + @property + def n_polymorphic(self) -> np.ndarray: + """""" + The total number of polymorphic counts. + + :return: Total number of polymorphic counts for each type + """""" + return self.polymorphic.sum() + + @staticmethod + def from_list(data: Sequence, types: List) -> 'Spectra': + """""" + Create from array of spectra. + Note that data.ndim needs to be 2. + + :param data: Array of spectra + :param types: Types + :return: Spectra + """""" + return Spectra(dict((t, d) for t, d in zip(types, data))) + + @property + def types(self) -> List[str]: + """""" + The types. + + :return: Types + """""" + return self.data.columns.to_list() + + @property + def n_sites(self) -> pd.Series: + """""" + The number of mutational target sites which is the sum of all SFS entries. + + :return: Number of mutational target sites for each type + """""" + return self.data.sum() + + @property + def n_div(self) -> pd.Series: + """""" + The number of divergence counts. + + :return: Number of divergence counts for each type + """""" + return self.data.iloc[-1] + + @property + def has_div(self) -> pd.Series: + """""" + Whether n_div was specified. + + :return: Whether n_div was specified for each type + """""" + # noinspection PyTypeChecker + return self.n_div != 0 + + @property + def theta(self) -> pd.Series: + """""" + Calculate site-wise population mutation rate using Watterson's estimator. + Note that theta is given per site, i.e. Watterson's estimator is divided by the + total number of sites (:attr:`n_sites`). + """""" + return self.Theta / self.n_sites + + @property + def Theta(self) -> pd.Series: + """""" + Calculate genome-wide population mutation rate using Watterson's estimator. + + .. note:: Property :attr:`Theta` is not normalized by the total number of sites, unlike :attr:`theta`. + """""" + return self.n_polymorphic / np.sum(1 / np.arange(1, self.n)) + + def normalize(self) -> 'Spectra': + """""" + Normalize spectra by sum of all entries. + + :return: Normalized spectra + """""" + return self / self.data.sum() + + def to_file(self, file: str): + """""" + Save object to file. + + :param file: File name + """""" + self.data.to_csv(file, index=False) + + def to_spectra(self) -> Dict[str, Spectrum]: + """""" + Convert to dictionary of spectrum objects. + + :return: Dictionary of spectrum objects + """""" + return dict((t, self.select(t, use_regex=False)) for t in self.types) + + def to_dataframe(self) -> pd.DataFrame: + """""" + Get representation as dataframe. + + :return: Dataframe + """""" + return self.data + + def to_numpy(self) -> np.ndarray: + """""" + Convert to numpy array. + + :return: Numpy array + """""" + return self.data.to_numpy().T + + def to_list(self) -> list: + """""" + Convert to nested list. + + :return: Nested list + """""" + return list(list(d) for d in self.to_numpy()) + + def to_dict(self) -> dict: + """""" + Convert to dictionary. + + :return: Dictionary of lists + """""" + # return dictionary of lists + return dict((k, list(v.values())) for k, v in self.data.to_dict().items()) + + def __mul__(self, other: Any) -> 'Spectra': + """""" + Multiply Spectra. + + :param other: Scalar + :return: Spectra + """""" + return Spectra.from_dataframe(self.data * other) + + __rmul__ = __mul__ + + def __floordiv__(self, other: Any) -> 'Spectra': + """""" + Divide Spectra. + + :param other: Scalar + :return: Spectra + """""" + return Spectra.from_dataframe(self.data // other) + + def __truediv__(self, other: Any) -> 'Spectra': + """""" + Divide Spectra. + + :param other: Scalar + :return: Spectra + """""" + return Spectra.from_dataframe(self.data / other) + + def __len__(self) -> int: + """""" + Get number of spectra. + + :return: Number of spectra + """""" + return self.k + + def __add__(self, other: 'Spectra') -> 'Spectra': + """""" + Merge types of two spectra objects by adding up their counts entry-wise. + + :param other: Spectra object + :return: Spectra with merged types + """""" + return Spectra.from_dataframe(self.data.add(other.data, fill_value=0)) + + def __getitem__( + self, + keys: str | List[str] | np.ndarray | tuple, + use_regex: bool = True + ) -> Union['Spectrum', 'Spectra']: + """""" + Get item. + + :param keys: String or list of strings, possibly regex to match type names + :param use_regex: Whether to use regex to match type names + :return: Spectrum or Spectra object depending on the number of matches + """""" + # whether the input in an array + is_array = isinstance(keys, (np.ndarray, list, tuple)) + + if use_regex: + # subset dataframe using column names using regex + subset = self.data.loc[:, self.data.columns.str.fullmatch('|'.join(keys) if is_array else keys)] + else: + # subset dataframe using column names + subset = self.data.loc[:, keys] + + # return spectrum object if we have a series + if isinstance(subset, pd.Series): + return Spectrum(list(subset)) + + # return spectrum object if only one column is left + # and if not multiple keys were supplied + if subset.shape[1] == 1 and not is_array: + return Spectrum(list(subset.iloc[:, 0])) + + # wrap subset dataframe in spectra object + return Spectra.from_dataframe(subset) + + def __setitem__(self, key: str, s: Spectrum): + """""" + Save new spectrum as type. + + :param key: Type + :param s: Spectrum + """""" + self.data[key] = s.to_list() + + def __iter__(self): + """""" + Get iterator. + + :return: Iterator + """""" + return self.data.__iter__() + + def select( + self, + keys: str | List[str] | np.ndarray | tuple, + use_regex: bool = True + ) -> 'Spectra': + """""" + Select types. Alias for __getitem__. + + :param keys: String or list of strings, possibly regex to match type names + :param use_regex: Whether to use regex to match type names + :return: Spectrum or Spectra depending on the number of matches + """""" + return self.__getitem__(keys, use_regex=use_regex) + + def copy(self) -> 'Spectra': + """""" + Copy object. + + :return: Copy of object + """""" + return Spectra.from_dataframe(self.data.copy()) + + def _to_multi_index(self) -> 'Spectra': + """""" + Convert to Spectra object with multi-indexed columns. + + :return: Spectra object with multi-indexed columns + """""" + other = self.copy() + columns = [tuple(col.split('.')) for col in other.data.columns] + other.data.columns = pd.MultiIndex.from_tuples(columns) + + return other + + def _to_single_index(self) -> 'Spectra': + """""" + Convert to Spectra object with single-indexed columns (using dot notation). + + :return: Spectra object with single-indexed columns + """""" + other = self.copy() + + if other.data.columns.nlevels > 1: + columns = other.data.columns.map('.'.join) + other.data.columns = columns + + return other + + def get_empty(self) -> 'Spectra': + """""" + Get a Spectra object with zero counts but having the same shape and types as self. + + :return: Spectra object with zero counts + """""" + return Spectra.from_dataframe(pd.DataFrame(0, index=self.data.index, columns=self.data.columns)) + + def merge_groups(self, level: List[int] | int = 0) -> 'Spectra': + """""" + Group over given levels and sum up spectra so the spectra + are summed over the levels that were not specified. + + :param level: Level(s) to group over + :return: Spectra object with merged groups + """""" + # cast to int + level = [int(l) for l in level] if isinstance(level, Iterable) else int(level) + + return Spectra.from_dataframe(self._to_multi_index().data.T.groupby(level=level).sum().T)._to_single_index() + + def has_dots(self) -> bool: + """""" + Check whether column names contain dots. + + :return: True if column names contain dots, False otherwise + """""" + return any('.' in col for col in self.data.columns) + + def replace_dots(self, replacement: str = '_') -> 'Spectra': + """""" + Replace dots in column names with a given string. + + :param replacement: Replacement string + :return: Spectra object with replaced dots + """""" + other = self.copy() + other.data.columns = other.data.columns.str.replace('.', replacement) + + return other + + @property + def all(self) -> 'Spectrum': + """""" + The 'all' type equals the sum of all spectra. + + :return: Spectrum object + """""" + return Spectrum(self.data.sum(axis=1).to_list()) + + def combine(self, s: 'Spectra') -> 'Spectra': + """""" + Merge types of two Spectra objects. + + :param s: Other Spectra object + :return: Merged Spectra object + """""" + return Spectra(self.to_dict() | s.to_dict()) + + @staticmethod + def from_dict(data: dict) -> 'Spectra': + """""" + Load from nested dictionary first indexed by types and then by samples. + + :param data: Dictionary of lists indexed by types + :return: Spectra object + """""" + lists = [list(v.values() if isinstance(v, dict) else v) for v in data.values()] + + return Spectra.from_list(lists, types=list(data.keys())) + + @staticmethod + def from_dataframe(data: pd.DataFrame) -> 'Spectra': + """""" + Load Spectra object from dataframe. + + :param data: Dataframe + :return: Spectra object + """""" + return Spectra.from_dict(data.to_dict()) + + @classmethod + def from_file(cls, file: str) -> 'Spectra': + """""" + Save object to file. + + :param file: Path to file, possibly URL + :return: Spectra object + """""" + return Spectra.from_dataframe(pd.read_csv(download_if_url( + file, + desc=f'{cls.__name__}>Downloading file')) + ) + + @staticmethod + def from_spectra(spectra: Dict[str, Spectrum]) -> 'Spectra': + """""" + Create from dict of spectrum objects indexed by type. + + :param spectra: Dictionary of spectrum objects indexed by type + :return: Spectra object + """""" + return Spectra.from_list([sfs.to_list() for sfs in spectra.values()], types=list(spectra.keys())) + + @staticmethod + def from_spectrum(sfs: Spectrum) -> 'Spectra': + """""" + Create from single spectrum object. The type of the spectrum is set to 'all'. + + :param sfs: Spectrum + :return: Spectra object + """""" + return Spectra.from_spectra(dict(all=sfs)) + + def to_spectrum(self) -> Spectrum: + """""" + Convert to Spectrum object by summing over all types. + + :return: Spectrum object + """""" + return self.all + + def plot( + self, + show: bool = True, + file: str = None, + title: str = None, + log_scale: bool = False, + use_subplots: bool = False, + show_monomorphic: bool = False, + kwargs_legend: dict = dict(prop=dict(size=8)), + ax: 'plt.Axes' = None + ) -> 'plt.Axes': + """""" + Visualize spectra. + + :param show: Whether to show the plot. + :param file: File name to save the plot to. + :param title: Plot title. + :param log_scale: Whether to use log scale on y-axis. + :param use_subplots: Whether to use subplots. Only for Python visualization backend. + :param show_monomorphic: Whether to show monomorphic sites. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :param ax: Axes to plot on. Only for Python visualization backend and if ``use_subplots`` is ``False``. + :return: Axes + """""" + from .visualization import Visualization + + return Visualization.plot_spectra( + spectra=list(list(v) for v in self.to_spectra().values()), + labels=self.types, + file=file, + show=show, + title=title, + log_scale=log_scale, + use_subplots=use_subplots, + show_monomorphic=show_monomorphic, + kwargs_legend=kwargs_legend, + ax=ax + ) + + def drop_empty(self) -> 'Spectra': + """""" + Remove types whose spectra have no counts. + + :return: Spectra with non-empty types + """""" + return Spectra.from_dataframe(self.data.loc[:, self.data.any()]) + + def drop_zero_entries(self) -> 'Spectra': + """""" + Remove types whose spectra have some zero entries. + Note that we ignore zero counts in the last entry i.e. fixed derived alleles. + + :return: Spectra with non-zero entries + """""" + return Spectra.from_dataframe(self.data.loc[:, self.data[:-1].all()]) + + def drop_sparse(self, n_polymorphic: int) -> 'Spectra': + """""" + Remove types whose spectra have fewer than equal ``n_polymorphic`` polymorphic sites. + + :return: Spectra + """""" + return Spectra.from_dataframe(self.data.loc[:, self.data[1:-1].sum() > int(n_polymorphic)]) + + def rename(self, names: List[str]) -> 'Spectra': + """""" + Rename types. + + :param names: New names + :return: Spectra with renamed types + """""" + other = self.copy() + other.data.columns = names + + return other + + def prefix(self, prefix: str) -> 'Spectra': + """""" + Prefix types, i.e. 'type' -> 'prefix.type' for all types. + + :param prefix: Prefix + :return: Spectra with prefixed types + """""" + return self.rename([prefix + '.' + col for col in self.types]) + + def reorder_levels(self, levels: List[int]) -> 'Spectra': + """""" + Reorder levels. + + :param levels: New order of levels + :return: Spectra with reordered levels + """""" + s = self._to_multi_index() + s.data.columns = s.data.columns.reorder_levels(levels) + s = s._to_single_index() + + return s + + def print(self): + """""" + Print spectra. + """""" + print(self.data.T) + + def fold(self): + """""" + Fold spectra. + + :return: Folded spectra + """""" + return Spectra.from_spectra({t: s.fold() for t, s in self.to_spectra().items()}) + + def subsample( + self, + n: int, + mode: Literal['random', 'probabilistic'] = 'probabilistic', + seed: int | Generator = None + ) -> 'Spectra': + """""" + Subsample spectra to a given sample size. + + .. warning:: + If using the 'random' mode, The SFS counts are cast to integers before subsampling so this will + only provide sensible results if the SFS counts are integers or if they are large enough to be + approximated by integers. The 'probabilistic' mode does not have this limitation. + + :param n: Sample size + :param mode: Subsampling mode. Either 'random' or 'probabilistic'. + :param seed: Random state or seed. Only for 'random' mode. + :return: Subsampled spectra + """""" + return Spectra.from_spectra({t: s.subsample(n, mode, seed) for t, s in self.to_spectra().items()}) + + def resample(self, seed: int | Generator = None) -> 'Spectra': + """""" + Resample SFS assuming independent Poisson counts. + + :param seed: Random state or seed + :return: Resampled spectra. + """""" + return Spectra.from_spectra({t: s.resample(seed) for t, s in self.to_spectra().items()}) + + def is_folded(self) -> Dict[str, bool]: + """""" + Check whether spectra are folded. + + :return: Dictionary of types and whether they are folded + """""" + return {t: s.is_folded() for t, s in self.to_spectra().items()} + + def sort_types(self) -> 'Spectra': + """""" + Sort types alphabetically. + + :return: Sorted spectra object + """""" + return Spectra.from_dataframe(self.data.sort_index(axis=1)) + + +def parse_polydfe_sfs_config(file: str) -> Spectra: + """""" + Parse frequency spectra and mutational target site from + polyDFE configuration file. + + :param file: File name + :return: Spectra object + """""" + df = pd.read_csv(file, header=None, comment='#') + + # parse number of spectra and sample size + n_neut, n_sel, n = np.array(df.iloc[0][0].split()).astype(int) + + # issue notice about number of spectra and sample size + logger.info(f'Parsing {n_neut} neutral and {n_sel} selected SFS with ' + f'a sample size of {n}.') + + # issue notice that fastDFE does not support variable mutation rates + if n_neut > 1 or n_sel > 1: + logger.info('Note that fastDFE does not model variable mutation rates ' + 'as this did not turn out to change the inference result. ' + 'The parsed spectra are thus merged together.') + + def to_spectrum(data: np.ndarray) -> Spectrum: + """""" + Parse spectrum and number of mutational target sites. + We ignore the number of mutational target sites for divergence counts + but include the divergence counts for completeness of the SFS. + + :param data: Spectrum data + :return: Spectrum object + """""" + # iterate over spectra and merge them as we do not + # support variable mutation rates + data_merged = data.sum(axis=0) + + # polymorphic counts + polymorphic = list(data_merged[:n - 1]) + + # parse number mutational target sites for ingroup + n_sites = float(data_merged[n - 1]) + + # parse optional divergence counts + n_div = float(data_merged[n]) if n < data_merged.shape[0] else 0 + + return Spectrum.from_polydfe(polymorphic, n_sites=n_sites, n_div=n_div) + + # iterate over spectra and merge them as we do not + # support variable mutation rates + data_neut = np.array([df.iloc[i][0].split() for i in range(1, n_neut + 1)], dtype=float) + sfs_neut = to_spectrum(data_neut) + + # iterate over spectra and merge them as we do not + # support variable mutation rates + data_sel = np.array([df.iloc[i][0].split() for i in range(n_neut + 1, n_neut + n_sel + 1)], dtype=float) + sfs_sel = to_spectrum(data_sel) + + return Spectra.from_spectra(dict( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel + )) +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/filtration.py",".py","23163","730",""""""" +VCF filtrations and a filterer to apply them. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-11"" + +import functools +import logging +from abc import ABC, abstractmethod +from typing import Iterable, List, Optional, Callable, Dict, Union + +import numpy as np +import pandas as pd + +from .annotation import DegeneracyAnnotation +from .io_handlers import get_major_base, MultiHandler, get_called_bases, DummyVariant + +# get logger +logger = logging.getLogger('fastdfe') + + +def _count_filtered(func: Callable) -> Callable: + """""" + Decorator that increases ``self.n_filtered`` by 1 if the decorated function returns False. + """""" + + @functools.wraps(func) + def wrapper(self, variant): + """""" + Wrapper function. + + :param self: Self. + :param variant: The variant to filter. + :return: The result of the decorated function. + """""" + result = func(self, variant) + if not result: + self.n_filtered += 1 + return result + + return wrapper + + +class Filtration(ABC): + """""" + Base class for filtering sites based on certain criteria. + """""" + + #: The number of sites that didn't pass the filter. + n_filtered: int = 0 + + def __init__(self): + """""" + Initialize filtration. + """""" + #: The logger. + self._logger = logger.getChild(self.__class__.__name__) + + #: The handler. + self._handler: MultiHandler | None = None + + @abstractmethod + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site. + + :param variant: The variant to filter. + :return: ``True`` if the variant should be kept, ``False`` otherwise. + """""" + pass + + def _setup(self, handler: MultiHandler): + """""" + Perform any necessary pre-processing. This method is called before the actual filtration. + + :param handler: The handler. + """""" + self._handler = handler + + def _rewind(self): + """""" + Rewind the filtration. + """""" + self.n_filtered = 0 + + def _teardown(self): + """""" + Perform any necessary post-processing. This method is called after the actual filtration. + """""" + self._logger.info(f""Filtered out {self.n_filtered} sites."") + + +class MaskedFiltration(Filtration, ABC): + """""" + Filter sites based on a samples mask. + """""" + + def __init__( + self, + use_parser: bool = True, + include_samples: List[str] | None = None, + exclude_samples: List[str] | None = None + ): + """""" + Create a new filtration instance. + + :param use_parser: Whether to use the samples mask from the parser, if used together with parser. + :param include_samples: The samples to include, defaults to all samples. + :param exclude_samples: The samples to exclude, defaults to no samples. + """""" + super().__init__() + + #: Whether to use the samples mask from the parser, if used together with parser. + self.use_parser: bool = use_parser + + #: The samples to include. + self.include_samples: List[str] | None = include_samples + + #: The samples to exclude. + self.exclude_samples: List[str] | None = exclude_samples + + #: The samples mask. + self._samples_mask: np.ndarray | None = None + + def _prepare_samples_mask(self): + """""" + Prepare the samples mask. + """""" + from .parser import Parser + + if self.use_parser and isinstance(self._handler, Parser): + + # use samples mask from parser + self._samples_mask = self._handler._samples_mask + + elif self.include_samples is None and self.exclude_samples is None: + + # no samples mask + self._samples_mask = None + + else: + + # determine samples to include + if self.include_samples is None: + + mask = np.ones(len(self._handler._reader.samples)).astype(bool) + else: + mask = np.isin(self._handler._reader.samples, self.include_samples) + + # determine samples to exclude + if self.exclude_samples is not None: + mask &= ~np.isin(self._handler._reader.samples, self.exclude_samples) + + self._samples_mask = mask + + def _setup(self, handler: MultiHandler): + """""" + Prepare the samples mask. + + :param handler: The handler. + """""" + super()._setup(handler) + + # prepare samples mask + self._prepare_samples_mask() + + +class SNPFiltration(MaskedFiltration): + """""" + Only keep SNPs. Note that this entails discarding mono-morphic sites. + """""" + + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site. + + :param variant: The variant to filter. + :return: ``True`` if the variant is an SNP, ``False`` otherwise. + """""" + # simply check whether the variant is an SNP if we don't have a samples mask + if self._samples_mask is None or isinstance(variant, DummyVariant): + return variant.is_snp + + # otherwise check whether the variant is an SNP among the included samples + return len(np.unique(get_called_bases(variant.gt_bases[self._samples_mask]))) > 1 + + +class SNVFiltration(Filtration): + """""" + Only keep single site variants (discard indels and MNPs but keep monomorphic sites). + """""" + + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site. + + :param variant: The variant to filter. + :return: ``True`` if the variant is kept, ``False`` otherwise. + """""" + return np.all([alt in ['A', 'C', 'G', 'T'] for alt in [variant.REF] + variant.ALT]) + + +class PolyAllelicFiltration(MaskedFiltration): + """""" + Filter out poly-allelic sites. + """""" + + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site. Note that we don't check explicitly all alleles, but rather + rely on ``ALT`` field. + + :param variant: The variant to filter. + :return: ``True`` if the variant is not poly-allelic, ``False`` otherwise. + """""" + # if we don't have a samples mask, simply check whether the variant is poly-allelic + if self._samples_mask is None or isinstance(variant, DummyVariant): + return len(variant.ALT) < 2 + + # otherwise check whether the variant is poly-allelic among the included samples + return len(np.unique(get_called_bases(variant.gt_bases[self._samples_mask]))) < 3 + + +class AllFiltration(Filtration): + """""" + Filter out all sites. Only useful for testing purposes. + """""" + + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site. + + :param variant: The variant to filter. + :return: ``False``. + """""" + return False + + +class NoFiltration(Filtration): + """""" + Do not filter out any sites. Only useful for testing purposes. + """""" + + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site. + + :param variant: The variant to filter. + :return: ``True``. + """""" + return True + + +class CodingSequenceFiltration(Filtration): + """""" + Filter out sites that are not in coding sequences. This filter should find frequent use when parsing + spectra for DFE inference as we only consider sites in coding sequences for this purpose. + By using it, the annotation and parsing of unnecessary sites can be avoided which increases the speed. + Note that we assume here that within contigs, sites in the GFF file are sorted by position in ascending order. + + For this filtration to work, we require a GFF file (passed to :class:`~fastdfe.parser.Parser` or + :class:`~fastdfe.filtration.Filterer`). + """""" + + def __init__(self): + """""" + Create a new filtration instance. + """""" + Filtration.__init__(self) + + #: The coding sequence enclosing the current variant or the closest one downstream. + self.cd: Optional[pd.Series] = None + + #: The number of processed sites. + self.n_processed: int = 0 + + def _setup(self, handler: MultiHandler): + """""" + Touch the GFF file to load it. + + :param handler: The handler. + """""" + # require GFF file + handler._require_gff(self.__class__.__name__) + + # setup GFF handler + super()._setup(handler) + + # load coding sequences + _ = handler._cds + + def _rewind(self): + """""" + Rewind the filtration. + """""" + super()._rewind() + + # reset coding sequence + self.cd = None + + @_count_filtered + def filter_site(self, v: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site by whether it is in a coding sequence. + + :param v: The variant to filter. + :return: ``True`` if the variant is in a coding sequence, ``False`` otherwise. + """""" + aliases = self._handler.get_aliases(v.CHROM) + + # if self.cd is None or not on the same chromosome or ends before the variant + if self.cd is None or self.cd.seqid not in aliases or v.POS > self.cd.end: + + # initialize mock coding sequence + self.cd = pd.Series({ + 'seqid': v.CHROM, + 'start': DegeneracyAnnotation._pos_mock, + 'end': DegeneracyAnnotation._pos_mock + }) + + # find coding sequences downstream + cds = self._handler._cds[self._handler._cds['seqid'].isin(aliases) & (self._handler._cds['end'] >= v.POS)] + + if not cds.empty: + # take the first coding sequence + self.cd = cds.iloc[0] + + if self.cd.start == v.POS: + self._logger.debug(f'Found coding sequence for {v.CHROM}:{v.POS}.') + else: + self._logger.debug(f'Found coding sequence downstream of {v.CHROM}:{v.POS}.') + + if self.n_processed == 0 and self.cd.start == DegeneracyAnnotation._pos_mock: + self._logger.warning(f'No subsequent coding sequence found on the same contig as the first variant. ' + f'Please make sure this is the correct GFF file with contig names matching ' + f'the VCF file. You can use the aliases parameter to match contig names.') + + self.n_processed += 1 + + # check whether the variant is in the current coding sequence + if self.cd is not None and self.cd.seqid in aliases and self.cd.start <= v.POS <= self.cd.end: + return True + + return False + + +class DeviantOutgroupFiltration(Filtration): + """""" + Filter out sites where the major allele of the specified outgroup samples differs from the major + allele of the ingroup samples. + """""" + + def __init__( + self, + outgroups: List[str], + ingroups: List[str] = None, + strict_mode: bool = True, + retain_monomorphic: bool = True + ): + """""" + Construct DeviantOutgroupFiltration. + + :param outgroups: The name of the outgroup samples to consider. + :param ingroups: The name of the ingroup samples to consider, defaults to all samples but the outgroups. + :param strict_mode: Whether to filter out sites where no outgroup sample is present, defaults to ``True``. + :param retain_monomorphic: Whether to retain monomorphic sites, defaults to ``True``, which is faster. + """""" + super().__init__() + + #: The ingroup samples. + self.ingroups: List[str] | None = ingroups + + #: The outgroup samples. + self.outgroups: List[str] = outgroups + + #: Whether to filter out sites where no outgroup sample is present. + self.strict_mode: bool = strict_mode + + #: Whether to retain monomorphic sites. + self.retain_monomorphic: bool = retain_monomorphic + + #: The samples found in the VCF file. + self.samples: Optional[np.ndarray] = None + + #: The ingroup mask. + self.ingroup_mask: Optional[np.ndarray] = None + + #: The outgroup mask. + self.outgroup_mask: Optional[np.ndarray] = None + + def _setup(self, handler: MultiHandler): + """""" + Touch the reader to load the samples. + + :param handler: The handler. + """""" + super()._setup(handler) + + # create samples array + self.samples: np.ndarray = np.array(handler._reader.samples) + + # create ingroup and outgroup masks + self._create_masks() + + def _create_masks(self): + """""" + Create ingroup and outgroup masks based on the samples. + """""" + + # create outgroup masks + self.outgroup_mask: np.ndarray = np.isin(self.samples, self.outgroups) + + # make sure all outgroups are present + if self.outgroup_mask.sum() != len(self.outgroups): + raise ValueError(f'Not all outgroup samples are present in the VCF file: {self.outgroups}') + + # create ingroup mask + if self.ingroups is None: + self.ingroup_mask = ~self.outgroup_mask + else: + self.ingroup_mask = np.isin(self.samples, self.ingroups) + + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site. + + :param variant: The variant to filter. + :return: ``True`` if the variant should be kept, ``False`` otherwise. + """""" + # keep monomorphic sites if requested + if not variant.is_snp and self.retain_monomorphic: + return True + + # filter out dummies if retain_monomorphic is false + if isinstance(variant, DummyVariant): + return False + + # get major base among ingroup samples + ingroup_base = get_major_base(variant.gt_bases[self.ingroup_mask]) + + # get major base among outgroup samples + outgroup_base = get_major_base(variant.gt_bases[self.outgroup_mask]) + + # filter out if no outgroup base is present and strict mode is enabled + if outgroup_base is None: + return not self.strict_mode + + # filter out if outgroup base is different from ingroup base + return ingroup_base == outgroup_base + + +class ExistingOutgroupFiltration(Filtration): + """""" + Filter out sites for which at least ``n_missing`` of the specified outgroup samples have no called base. + """""" + + def __init__(self, outgroups: List[str], n_missing: int = 1): + """""" + Construct ExistingOutgroupFiltration. + + :param outgroups: The names of the outgroup samples considered. + :param n_missing: The number of outgroup samples that need to be missing to fail the filter. + """""" + super().__init__() + + #: The outgroup samples. + self.outgroups: List[str] = outgroups + + #: Minimum number of missing outgroups required to filter out a site. + self.n_missing: int = n_missing + + #: The samples found in the VCF file. + self.samples: Optional[np.ndarray] = None + + #: The outgroup mask. + self.outgroup_mask: Optional[np.ndarray] = None + + def _setup(self, handler: MultiHandler): + """""" + Touch the reader to load the samples. + + :param handler: The handler. + """""" + super()._setup(handler) + + # create samples array + self.samples: np.ndarray = np.array(handler._reader.samples) + + # create outgroup mask + self._create_mask() + + def _create_mask(self): + """""" + Create outgroup mask based on the samples. + """""" + self.outgroup_mask: np.ndarray = np.isin(self.samples, self.outgroups) + + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site. + + :param variant: The variant to filter. + :return: ``True`` if the variant should be kept, ``False`` otherwise. + """""" + # keep dummy variants + if isinstance(variant, DummyVariant): + return True + + # get outgroup genotypes + outgroups = variant.gt_bases[self.outgroup_mask] + + # count how many outgroups have no called base + missing_count = sum(len(get_called_bases(outgroup)) == 0 for outgroup in outgroups) + + # filter out if at least n outgroups are missing + return missing_count < self.n_missing + + +class BiasedGCConversionFiltration(Filtration): + """""" + Only retain A<->T and G<->C substitutions (which are unaffected + by biased gene conversion, see [CITGB]_). + + Mono-allelic sites are always retained, and we assume sites are at most bi-allelic. Note that the number of + mutational target sites is reduced by this filtration. + + .. [CITGB] Pouyet et al., 'Background selection and biased + gene conversion affect more than 95% of the human genome and bias demographic inferences.', + Elife, 7:e36317, 2018 + """""" + + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Remove bi-allelic sites that are not A<->T or G<->C substitutions. + + :param variant: The variant to filter. + :return: ``True`` if the variant should be kept, ``False`` otherwise. + """""" + if variant.is_snp and len(variant.ALT) > 0: + return (variant.REF, variant.ALT[0]) in [('A', 'T'), ('T', 'A'), ('G', 'C'), ('C', 'G')] + + return True + +class ContigFiltration(Filtration): + """""" + Filter out sites that are not on the specified contigs. + """""" + + def __init__(self, contigs: List[str]): + """""" + Construct ContigFiltration. + + :param contigs: The contigs to retain. + """""" + super().__init__() + + #: The contigs to retain. + self.contigs: List[str] = contigs + + @_count_filtered + def filter_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Filter site. + + :param variant: The variant to filter. + :return: ``True`` if the variant is on one of the specified contigs, ``False`` otherwise. + """""" + return variant.CHROM in self.contigs + + +class Filterer(MultiHandler): + """""" + Filter a VCF file using a list of filtrations. + + Example usage: + + :: + + import fastdfe as fd + + # only keep variants in coding sequences + f = fd.Filterer( + vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" + ""1000_genomes_project/release/20181203_biallelic_SNV/"" + ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", + gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", + output='sapiens.chr21.coding.vcf.gz', + filtrations=[fd.CodingSequenceFiltration()], + aliases=dict(chr21=['21']) + ) + + f.filter() + + """""" + + def __init__( + self, + vcf: str | Iterable['cyvcf2.Variant'], + output: str, + gff: str | None = None, + filtrations: List[Filtration] = [], + info_ancestral: str = 'AA', + max_sites: int = np.inf, + seed: int | None = 0, + cache: bool = True, + aliases: Dict[str, List[str]] = {} + ): + """""" + Create a new filter instance. + + :param vcf: The VCF file, possibly gzipped or a URL. + :param output: The output file. + :param gff: The GFF file, possibly gzipped or a URL. This argument is required for some filtrations. + :param filtrations: The filtrations. + :param info_ancestral: The info field for the ancestral allele. + :param max_sites: The maximum number of sites to process. + :param seed: The seed for the random number generator. Use ``None`` for no seed. + :param cache: Whether to cache files downloaded from urls. + :param aliases: Dictionary of aliases for the contigs in the VCF file, e.g. ``{'chr1': ['1']}``. + """""" + super().__init__( + vcf=vcf, + gff=gff, + info_ancestral=info_ancestral, + max_sites=max_sites, + seed=seed, + cache=cache, + aliases=aliases + ) + + #: The filtrations. + self.filtrations: List[Filtration] = filtrations + + #: The output file. + self.output: str = output + + #: The number of sites that did not pass the filters. + self.n_filtered: int = 0 + + #: The VCF writer. + self._writer: 'cyvcf2.Writer' | None = None + + def is_filtered(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Whether the given variant is kept. + + :param variant: The variant to check. + :return: ``True`` if the variant is kept, ``False`` otherwise. + """""" + # filter the variant + for filtration in self.filtrations: + if not filtration.filter_site(variant): + self.n_filtered += 1 + return False + + return True + + def _setup(self): + """""" + Set up the filtrations. + """""" + try: + from cyvcf2 import Writer + except ImportError: + raise ImportError( + ""VCF support in fastdfe requires the optional 'cyvcf2' package. "" + ""Please install fastdfe with the 'vcf' extra: pip install fastdfe[vcf]"" + ) + + # setup filtrations + for f in self.filtrations: + f._setup(self) + + # create the writer + self._writer = Writer(self.output, self._reader) + + def _teardown(self): + """""" + Tear down the filtrations. + """""" + for f in self.filtrations: + f._teardown() + + # close the writer and reader + self._writer.close() + self._reader.close() + + def filter(self): + """""" + Filter the VCF. + """""" + self._logger.info('Start filtering') + + # setup filtrations + self._setup() + + # get progress bar + with self.get_pbar(desc=f""{self.__class__.__name__}>Processing sites"") as pbar: + + # iterate over the sites + for i, variant in enumerate(self._reader): + + if self.is_filtered(variant): + # write the variant + self._writer.write_record(variant) + + pbar.update() + + # explicitly stopping after ``n`` sites fixes a bug with cyvcf2: + # 'error parsing variant with `htslib::bcf_read` error-code: 0 and ret: -2' + if i + 1 == self.n_sites or i + 1 == self.max_sites: + break + + # teardown filtrations + self._teardown() + + self._logger.info(f'Filtered out {self.n_filtered} of {self.n_sites} sites in total.') +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/joint_inference.py",".py","54523","1363",""""""" +Joint inference module. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import copy +import functools +import logging +import time +from typing import List, Dict, Tuple, Literal, Optional, cast, Callable + +import jsonpickle +import multiprocess as mp +import numpy as np +import pandas as pd +from numpy.linalg import norm +from tqdm import tqdm + +from .abstract_inference import Inference +from .base_inference import BaseInference +from .bootstrap import Bootstrap +from .config import Config +from .discretization import Discretization +from .optimization import Optimization, SharedParams, pack_shared, expand_shared, \ + Covariate, flatten_dict, merge_dicts, correct_values, parallelize as parallelize_func, expand_fixed, \ + collapse_fixed_to_mean, unpack_shared, collapse_fixed +from .parametrization import Parametrization +from .settings import Settings +from .spectrum import Spectrum, Spectra + +# get logger +logger = logging.getLogger('fastdfe') + + +class JointInference(BaseInference): + """""" + Enabling the sharing of parameters among several Inference objects. + + Example usage: + + :: + + import fastdfe as fd + + # neutral SFS for two types + sfs_neut = fd.Spectra(dict( + pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] + )) + + # selected SFS for two types + sfs_sel = fd.Spectra(dict( + pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] + )) + + # create inference object + inf = fd.JointInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + do_bootstrap=True + ) + + # run inference + inf.run() + + """""" + + def __init__( + self, + sfs_neut: Spectra, + sfs_sel: Spectra, + include_divergence: bool = None, + intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), + intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), + intervals_h: Tuple[float, float, int] = (0.0, 1.0, 21), + h_callback: Callable[[np.ndarray], np.ndarray] = None, + integration_mode: Literal['midpoint', 'quad'] = 'midpoint', + linearized: bool = True, + model: Parametrization | str = 'GammaExpParametrization', + seed: int = 0, + x0: Dict[str, Dict[str, float]] = {}, + bounds: Dict[str, Tuple[float, float]] = {}, + scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, + loss_type: Literal['likelihood', 'L2'] = 'likelihood', + opts_mle: dict = {}, + method_mle: str = 'L-BFGS-B', + n_runs: int = 10, + fixed_params: Dict[str, Dict[str, float]] = None, + shared_params: List[SharedParams] = [], + covariates: List[Covariate] = [], + do_bootstrap: bool = True, + n_bootstraps: int = 100, + n_bootstrap_retries: int = 2, + parallelize: bool = True, + folded: bool = None, + discretization: Discretization = None, + optimization: Optimization = None, + locked: bool = False, + **kwargs + ): + """""" + Create instance. + + :param sfs_neut: Neutral SFS. Note that we require monomorphic counts to be specified in order to infer + the mutation rate. + :param sfs_sel: Selected SFS. Note that we require monomorphic counts to be specified in order to infer + the mutation rate. + :param include_divergence: Whether to include divergence in the likelihood + :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled + selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` + provides nearly identical results while increasing speed, especially when precomputing across dominance + coefficients. + :param intervals_ben: Same as ``intervals_del`` but for positive selection coefficients. Decreasing the number + of intervals to ``100`` provides nearly identical results while increasing speed, especially when + precomputing across dominance coefficients. + :param intervals_h: ``(start, stop, n_interval)`` for dominance coefficients which are linearly spaced. + This is only used when inferring dominance coefficients. Values of ``h`` between the edges will be + interpolated linearly. + :param h_callback: A function mapping the scalar parameter ``h`` and the array of selection + coefficients ``S`` to dominance coefficients of the same shape, allowing models where ``h`` + depends on ``S``. The default is ``lambda h, S: np.full_like(S, h)``, keeping ``h`` constant. + Expected allele counts for a given dominance value are obtained by linear interpolation + between precomputed values in ``intervals_h``. The inferred parameter is still named ``h``, + even if transformed by ``h_callback``, and its bounds, scales, and initial values can be set + via ``bounds``, ``scales``, and ``x0``. The fitness of heterozygotes and mutation homozygotes is defined as + ``1 + 2hs`` and ``1 + 2s``, respectively. + :param integration_mode: Integration mode when computing expected SFS under semidominance. + ``quad`` is not recommended. + :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use + ``scipy.integrate.quad`` in each call. ``False`` not recommended. + :param model: DFE parametrization + :param seed: Random seed. Use ``None`` for no seed. + :param x0: Dictionary of initial values in the form ``{type: {param: value}}`` + :param bounds: Bounds for the optimization in the form ``{param: (lower, upper)}`` + :param scales: Scales for the optimization in the form ``{param: scale}`` + :param loss_type: Loss type + :param opts_mle: Options for the optimization + :param method_mle: Method to use for optimization. See ``scipy.optimize.minimize`` for available methods. + :param n_runs: Number of independent optimization runs out of which the best one is chosen. The first run + will use the initial values if specified. Consider increasing this number if the optimization does not + produce good results. + :param fixed_params: Parameters kept constant during optimization, given as ``{type: {param: value}}``. + By default, the ancestral misidentification rate ``eps`` is fixed to zero, ``h`` to 0.5, and the DFE + parameters are fixed so that only the deleterious component of the DFE is estimated. + :param shared_params: List of shared parameters + :param do_bootstrap: Whether to perform bootstrapping + :param n_bootstraps: Number of bootstraps + :param n_bootstrap_retries: Number of optimization runs for each bootstrap sample. This parameter previously + defined the number of retries per bootstrap sample when subsequent runs failed, but now it defines the + total number of runs per bootstrap sample, taking the most likely one. + :param parallelize: Whether to parallelize computations + :param folded: Whether the SFS are folded. If not specified, the SFS will be folded if all of the given + SFS appear to be folded. + :param discretization: Discretization instance. Mainly intended for internal use. + :param optimization: Optimization instance. Mainly intended for internal use. + :param locked: Whether inferences can be run from the class itself. Used internally. + :param kwargs: Additional keyword arguments which are ignored. + """""" + if sfs_neut.has_dots() or sfs_sel.has_dots(): + raise ValueError('Type names cannot contain dots are not allowed as they are used internally.' + 'You can use the `replace_dots` method to replace dots with another character.') + + # check whether types are equal + if set(sfs_neut.types) != set(sfs_sel.types): + raise ValueError('The neutral and selected spectra must have exactly the same types.') + + #: SFS types + self.types: List[str] = sfs_neut.types + + # initialize parent + # the `self.folded` property will generalize nicely as we + # evaluate ``sfs_sel.all.is_folded and sfs_neut.all.is_folded`` + BaseInference.__init__(**locals()) + + #: original MLE parameters before adding covariates and unpacked shared + self.params_mle_raw: Optional[Dict[str, Dict[str, float]]] = None + + #: Shared parameters with expanded 'all' type + self.shared_params = expand_shared(shared_params, self.types, self.optimization.param_names) + + # add covariates as shared parameters + self._add_covariates_as_shared(covariates) + + # check if the shared parameters were specified correctly + self.check_shared_params() + + # throw error if joint inference does not make sense + if not self.joint_inference_makes_sense(): + self._logger.warning('Joint inference does not make sense as no parameters are shared ' + 'across more than one type. If this is not intended consider running ' + 'several marginal inferences instead, which is more efficient.') + + # issue notice + self._logger.info(f'Using shared parameters {self.shared_params}.') + + #: Covariates indexed by parameter name + self.covariates: Dict[str, Covariate] = {f""c{i}"": cov for i, cov in enumerate(covariates)} + + # only show param and values + cov_repr = dict((k, dict(param=v.param, values=v.values)) for k, v in self.covariates.items()) + + # issue notice + self._logger.info(f'Including covariates: {cov_repr}.') + + # parameter names for covariates + args_cov = list(self.covariates.keys()) + + # bounds for covariates + bounds_cov = dict((k, cov.bounds) for k, cov in self.covariates.items()) + + #: Initial values for covariates + self._x0_cov = dict((k, cov.x0) for k, cov in self.covariates.items()) + + # use linear scale for covariates + scales_cov = dict((k, cov.bounds_scale) for k, cov in self.covariates.items()) + + if fixed_params is None: + fixed_params = {'all': {'eps': 0, 'h': 0.5} | self.model.submodels['dele']} + + if not 'all' in fixed_params: + fixed_params['all'] = {} + + #: fixed parameters with expanded 'all' type + self.fixed_params: Dict[str, Dict[str, float]] = expand_fixed(fixed_params, self.types) + + if discretization is None: + # create discretization instance + #: Discretization instance + self.discretization: Discretization = Discretization( + n=self.n, + h=collapse_fixed(fixed_params, self.types)['all'].get('h', None), + intervals_del=intervals_del, + intervals_ben=intervals_ben, + intervals_h=intervals_h, + h_callback=h_callback, + integration_mode=integration_mode, + linearized=linearized, + parallelize=parallelize + ) + + else: + # otherwise assign instance + self.discretization: Discretization = discretization + + # collapse fixed parameters + fixed_collapsed = collapse_fixed_to_mean(self.fixed_params, self.types) + + # include 'all' type with infers the DFE for all spectra added together + #: Dictionary of marginal inferences indexed by type + self.marginal_inferences: Dict[str, BaseInference] = dict( + all=BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + discretization=self.discretization, + include_divergence=include_divergence, + model=model, + seed=seed, + x0=x0, + bounds=bounds, + scales=scales, + loss_type=loss_type, + opts_mle=opts_mle, + method_mle=method_mle, + fixed_params=dict(all=fixed_collapsed['all']) if 'all' in fixed_collapsed else {}, + do_bootstrap=do_bootstrap, + n_bootstraps=n_bootstraps, + n_bootstrap_retries=n_bootstrap_retries, + parallelize=parallelize, + folded=self.folded, + n_runs=n_runs) + ) + + # check that the fixed parameters are valid + self.check_fixed_params_exist() + + # check if the fixed parameters are compatible with the shared parameters + self.check_no_shared_params_fixed() + + #: parameter scales + self.scales: Dict[str, Literal['lin', 'log', 'symlog']] = \ + self.model.scales | self._default_scales | scales_cov | scales + + #: parameter bounds + self.bounds: Dict[str, Tuple[float, float]] = self.model.bounds | self._default_bounds | bounds | bounds_cov + + # create optimization instance for joint inference + # take initial values and bounds from marginal inferences + # and from this inference for type 'all' + #: Joint optimization instance + self.optimization: Optimization = Optimization( + bounds=self.bounds, + scales=self.scales, + opts_mle=self.optimization.opts_mle, + method_mle=method_mle, + loss_type=self.optimization.loss_type, + param_names=self.model.param_names + ['eps', 'h'] + args_cov, + parallelize=self.parallelize, + fixed_params=self.fixed_params, + seed=self.seed + ) + + # Construct the marginal inference object for each type. + # Note that we use the same discretization + # instance to avoid precomputing the linearization + # several times. + for t in sfs_neut.types: + self.marginal_inferences[t] = BaseInference( + # pass subtypes + sfs_neut=sfs_neut[[t]], + sfs_sel=sfs_sel[[t]], + discretization=self.discretization, + include_divergence=include_divergence, + model=model, + seed=seed, + x0=x0, + bounds=bounds, + scales=scales, + loss_type=loss_type, + opts_mle=opts_mle, + method_mle=method_mle, + fixed_params=dict(all=self.fixed_params[t]) if t in self.fixed_params else {}, + do_bootstrap=do_bootstrap, + n_bootstraps=n_bootstraps, + n_bootstrap_retries=n_bootstrap_retries, + parallelize=parallelize, + folded=self.folded, + n_runs=n_runs + ) + + #: Joint inference object indexed by type + self.joint_inferences: Dict[str, BaseInference] = {} + + # add base inference object for each type + for t in sfs_neut.types: + self.joint_inferences[t] = BaseInference( + # pass subtypes + sfs_neut=sfs_neut[[t]], + sfs_sel=sfs_sel[[t]], + discretization=self.discretization, + include_divergence=include_divergence, + model=model, + seed=seed, + x0=x0, + bounds=bounds, + scales=scales, + loss_type=loss_type, + opts_mle=opts_mle, + method_mle=method_mle, + fixed_params=dict(all=self.fixed_params[t]) if t in self.fixed_params else {}, + do_bootstrap=do_bootstrap, + n_bootstraps=n_bootstraps, + n_bootstrap_retries=n_bootstrap_retries, + parallelize=parallelize, + folded=self.folded, + n_runs=n_runs, + locked=True + ) + + def check_shared_params(self): + """""" + Check if the shared parameters were specified correctly. + """""" + for shared in self.shared_params: + # check parameters + if len(set(shared.params) - set(self.param_names)) != 0: + raise ValueError( + f'Specified shared parameters {list(set(shared.params) - set(self.param_names))} ' + f""don't match with any of {self.param_names}."" + ) + + # check types + if len(set(shared.types) - set(self.types)) != 0: + raise ValueError( + f'Specified types {list(set(shared.types) - set(self.types))} ' + f"" in shared parameters don't match with any of {self.types}."" + ) + + def check_no_shared_params_fixed(self): + """""" + Check that no shared parameters are fixed and raise an error otherwise. + """""" + for shared in self.shared_params: + for t in shared.types: + if t in self.fixed_params: + for p in shared.params: + if p in self.fixed_params[t]: + raise ValueError(f""Parameter '{p}' in type '{t}' is both "" + f""shared and fixed, which is not allowed. "" + f""Note that covariates are automatically shared."") + + def get_shared_param_names(self) -> List[str]: + """""" + Get the names of the shared parameters. + + :return: Names of the shared parameters. + """""" + shared = [] + + for p in self.shared_params: + shared += p.params + + return cast(List[str], np.unique(shared).tolist()) + + def _add_covariates_as_shared(self, covariates: List[Covariate]): + """""" + Add covariates as shared parameters. + + :param covariates: List of covariates. + """""" + cov_but_not_shared = self._determine_unshared_covariates(covariates) + + # add parameters with covariates to shared parameters + if len(cov_but_not_shared) > 0: + self._logger.info(f'Parameters {cov_but_not_shared} have ' + f'covariates and thus need to be shared. ' + f'Adding them to shared parameters.') + + # add to shared parameters + self.shared_params.append(SharedParams(params=cov_but_not_shared, types=self.types)) + + def _determine_unshared_covariates(self, covariates): + """""" + Determine which covariates are not shared. + + :param covariates: + :return: + """""" + # determine completely shared parameters + completely_shared = [] + for shared in self.shared_params: + if len(shared.types) == len(self.types): + completely_shared += shared.params + + # determine parameters with covariates + params_with_covariates = [cov.param for cov in covariates] + + # determine parameters with covariates that are not shared + return list(set(params_with_covariates) - set(completely_shared)) + + def run( + self, + **kwargs + ) -> Spectrum: + """""" + Run inference. + + :param kwargs: Additional keyword arguments + :return: Modelled SFS. + """""" + + # run marginal optimization + self._run_marginal() + + # run joint optimization + return self._run_joint() + + def _run_marginal(self): + """""" + Run marginal optimization. + + :return: Dict of marginal inferences indexed by type. + """""" + + def run_marginal(data: Tuple[str, BaseInference]) -> Tuple[str, BaseInference]: + """""" + Run marginal inference. Start with initial values + obtained from 'all' type. + + :param data: Tuple of type and inference object. + :return: Tuple of type and inference object. + """""" + # issue notice + self._logger.info(f""Running marginal inference for type '{data[0]}'."") + + data[1].run_if_required( + do_bootstrap=False + ) + + return data + + # run for 'all' type + run_marginal(('all', self.marginal_inferences['all'])) + + # update initial values of marginal inferences + # with MLE estimate of 'all' type + for inf in self.marginal_inferences.values(): + inf.x0 = dict(all=self.marginal_inferences['all'].params_mle) + + # skip marginal inference if only one type was specified + if len(self.types) == 1: + self._logger.info('Skipping marginal inference as only one type was specified.') + else: + # issue notice + self._logger.info(f'Running marginal inferences for types {self.types}.') + + # optionally parallelize marginal inferences + run_inferences = dict(parallelize_func( + func=run_marginal, + data=list(self.marginals_without_all().items()), + parallelize=False, + pbar=False + )) + + # reassign marginal inferences + self.marginal_inferences = dict(all=self.marginal_inferences['all']) | run_inferences + + return self.marginal_inferences + + def marginals_without_all(self) -> Dict[str, BaseInference]: + """""" + Get marginal inference without 'all' type. + + :return: Dict of marginal inferences indexed by type. + """""" + return dict((t, inf) for t, inf in self.marginal_inferences.items() if t != 'all') + + def _run_joint(self) -> Spectrum: + """""" + Run joint optimization. + + :return: Modelled SFS. + """""" + # issue notice + self._logger.info(f'Running joint inference for types {self.types}.') + + # issue notice + self._logger.debug(f'Starting numerical optimization of {self.n_runs} ' + 'independently initialized samples which are run ' + + ('in parallel.' if self.parallelize else 'sequentially.')) + + # starting time of joint inference + start_time = time.time() + + # Perform joint optimization. + self.result, params_mle = self.optimization.run( + x0=self.get_x0(), + scales=self.scales, + bounds=self.bounds, + n_runs=self.n_runs, + get_counts=self.get_counts(), + desc=f'{self.__class__.__name__}>Performing joint inference' + ) + + # assign runs dataframe and likelihoods + self.runs = self.optimization.runs + self.likelihoods = self.runs.likelihood.to_list() + + # store packed MLE params for later usage + self.params_mle_raw = copy.deepcopy(params_mle) + + # unpack shared parameters + params_mle = unpack_shared(params_mle) + + # normalize parameters for each type + for t in self.types: + params_mle[t] = self.model._normalize(params_mle[t]) + + # report on optimization result + self._report_result(self.result, params_mle) + + # assign optimization result and MLE parameters for each type + for t, inf in self.joint_inferences.items(): + params_mle[t] = correct_values( + params=Covariate._apply(self.covariates, params_mle[t], t), + bounds=self.bounds, + scales=self.scales + ) + + # remove effect of covariates and assign result + inf._assign_result(self.result, params_mle[t]) + + # assign execution time + inf.execution_time = time.time() - start_time + + # assign MLE params + self.params_mle = params_mle + + # assign joint likelihood + self.likelihood = -self.result.fun + + # calculate L2 residual + self.L2_residual = self.get_residual(2) + + # check L2 residual + self._check_L2_residual() + + # add execution time + self.execution_time += time.time() - start_time + + # perform bootstrap if configured + if self.do_bootstrap: + self.bootstrap() + + return self.sfs_mle + + def joint_inference_makes_sense(self) -> bool: + """""" + Check if joint inference makes sense. + + :return: Whether joint inference makes sense. + """""" + return len(self.types) >= 2 and len(self.shared_params) != 0 + + def get_counts(self) -> dict: + """""" + Get callback functions for modelling SFS counts from given parameters. + + :return: Dict of callback functions indexed by type. + """""" + # Note that it's important we bind t into the lambda function + # at the time of creation. + return dict((t, (lambda params, t=t: inf._model_sfs( + discretization=self.discretization, + model=self.model, + params=correct_values(Covariate._apply(self.covariates, params, t), self.bounds, self.scales), + sfs_neut=self.joint_inferences[t].sfs_neut, + sfs_sel=self.joint_inferences[t].sfs_sel, + folded=self.folded + ))) for t, inf in self.joint_inferences.items()) + + @BaseInference._run_if_required_wrapper + @functools.lru_cache + def run_joint_without_covariates(self, do_bootstrap: bool = True) -> 'JointInference': + """""" + Run joint inference without covariates. Note that the result of this function is cached. + + :return: Joint inference instance devoid of covariates. + """""" + config = self.create_config() + + # retain shared parameters but remove covariates + config.update( + shared_params=self.shared_params, + covariates={}, + do_bootstrap=do_bootstrap + ) + + # create copy + other = JointInference.from_config(config) + + # issue notice + self._logger.info('Running joint inference without covariates.') + + # run inference + other.run() + + return other + + def create_config(self) -> 'Config': + """""" + Create a config object from the inference object. + + :return: Config object. + """""" + return Config( + sfs_neut=Spectra.from_spectra(dict((t, inf.sfs_neut) for t, inf in self.marginals_without_all().items())), + sfs_sel=Spectra.from_spectra(dict((t, inf.sfs_sel) for t, inf in self.marginals_without_all().items())), + intervals_ben=self.discretization.intervals_ben, + intervals_del=self.discretization.intervals_del, + integration_mode=self.discretization.integration_mode, + linearized=self.discretization.linearized, + model=self.model, + seed=self.seed, + opts_mle=self.optimization.opts_mle, + method_mle=self.optimization.method_mle, + x0=self.x0, + bounds=self.bounds, + scales=self.scales, + loss_type=self.optimization.loss_type, + fixed_params=self.fixed_params, + covariates=[c for c in self.covariates.values()], + shared_params=self.shared_params, + do_bootstrap=self.do_bootstrap, + n_bootstraps=self.n_bootstraps, + parallelize=self.parallelize, + n_runs=self.n_runs + ) + + @BaseInference._run_if_required_wrapper + def perform_lrt_covariates(self, do_bootstrap: bool = False) -> float: + """""" + Perform likelihood ratio test against joint inference without covariates. + In the simple model we share parameters across types. Low p-values indicate that + including covariates significantly improves the model fit. + + To access the JointInference object without covariates, you can call :meth:`run_joint_without_covariates`, + which is cached. + + :param do_bootstrap: Whether to bootstrap. + :return: Likelihood ratio test p-value. + """""" + if len(self.covariates) == 0: + raise ValueError('No covariates were specified.') + + # bootstrap if required + if do_bootstrap: + self.bootstrap_if_required() + + # run joint inference without covariates + simple = self.run_joint_without_covariates(do_bootstrap=do_bootstrap) + + return self.lrt(simple.likelihood, self.likelihood, len(self.covariates)) + + def _get_run_bootstrap_sample(self) -> Callable[[int], Tuple['scipy.optimize.OptimizeResult', dict, dict, int]]: + """""" + Get function which runs a single bootstrap sample. + + :return: Static function which runs a single bootstrap sample, taking an optional seed and returning the + optimization result of best run, MLE parameters, the best x0, and its index. + """""" + optimization = self.optimization + discretization = self.discretization + covariates = self.covariates + model = self.model + types = self.types + folded = self.folded + params_mle_raw = self.params_mle_raw + scales = self.scales + bounds = self.bounds + scales_default = self.scales + bounds_default = self.bounds + n_retries = self.n_bootstrap_retries + sfs_neut = dict((t, self.marginal_inferences[t].sfs_neut) for t in self.types) + sfs_sel = dict((t, self.marginal_inferences[t].sfs_sel) for t in self.types) + + def run_bootstrap_sample(seed: int) -> Tuple['scipy.optimize.OptimizeResult', dict, dict, int]: + """""" + Resample the observed selected SFS and rerun the optimization procedure. + We take the MLE params as initial params here. + We make this function static to improve performance when parallelizing. + + :return: :return: Optimization result of best run, MLE parameters, and best x0. + """""" + results = [] + x0 = params_mle_raw + rng = np.random.default_rng(seed) + + # resample spectra + spectra = {} + for t in types: + spectra[t] = dict( + neut=sfs_neut[t].resample(seed=rng), + sel=sfs_sel[t].resample(seed=rng) + ) + + # run `n_retries` times + for _ in range(max(n_retries, 1)): + + # perform joint optimization + # Note that it's important we bind t into the lambda function + # at the time of creation. + result, params_mle = optimization.run( + x0=x0, + scales=scales, + bounds=bounds, + n_runs=1, + debug_iterations=False, + print_info=False, + desc=f""{self.__class__.__name__}>Bootstrapping joint inference"", + get_counts=dict((t, lambda params, t=t: BaseInference._model_sfs( + discretization=discretization, + model=model, + params=correct_values(Covariate._apply(covariates, params, t), bounds_default, scales_default), + sfs_neut=spectra[t]['neut'], + sfs_sel=spectra[t]['sel'], + folded=folded + )) for t in types) + ) + + # unpack shared parameters + params_mle = unpack_shared(params_mle) + + for t in types: + # normalize parameters for each type + params_mle[t] = model._normalize(params_mle[t]) + + # add covariates for each type + params_mle[t] = correct_values( + params=Covariate._apply(covariates, params_mle[t], t), + bounds=bounds_default, + scales=scales_default + ) + + results += [(result, params_mle, x0)] + + x0 = self.optimization.sample_x0(params_mle_raw, random_state=rng) + + return results + + return run_bootstrap_sample + + def bootstrap( + self, + n_samples: int = None, + parallelize: bool = None, + update_likelihood: bool = False, + n_retries: int = None, + pbar: bool = True, + pbar_title: str = 'Bootstrapping joint inference' + ) -> Optional[pd.DataFrame]: + """""" + Perform the parametric bootstrap both for the marginal and joint inferences. + + :param n_samples: Number of bootstrap samples. Defaults to :attr:`n_bootstraps`. + :param parallelize: Whether to parallelize the bootstrap. Defaults to :attr:`parallelize`. + :param update_likelihood: Whether to update the likelihood to be the mean of the bootstrap samples and + the original likelihood. This is not statistically valid but can stabilize maximum likelihood estimate + subject optimization noise. + :param n_retries: Number of optimization runs for each bootstrap sample. Defaults to + :attr:`n_bootstrap_retries`. + :param pbar: Whether to show a progress bar. + :param pbar_title: Title for the progress bar. + :return: DataFrame with bootstrap samples + """""" + # update properties + self.update_properties( + n_bootstraps=n_samples, + parallelize=parallelize, + n_bootstrap_retries=n_retries + ) + + # bootstrap marginal inferences + for t, inf in self.marginal_inferences.items(): + self._logger.info(f""Bootstrapping type '{t}'."") + + inf.bootstrap( + n_samples=int(self.n_bootstraps), + parallelize=self.parallelize, + n_retries=self.n_bootstrap_retries, + update_likelihood=update_likelihood, + pbar_title=f""Bootstrapping '{t}'"" + ) + + # bootstrap joint inference + self._bootstrap( + n_samples=n_samples, + parallelize=parallelize, + update_likelihood=update_likelihood, + n_retries=n_retries, + pbar=pbar, + pbar_title=pbar_title + ) + + # assign bootstrap parameters to joint inference objects + for t, inf in self.joint_inferences.items(): + # filter for columns belonging to the current type + inf.bootstraps = self.bootstraps.filter(regex=f'{t}\\..*').rename(columns=lambda x: x.split('.')[-1]) + + # add estimates for alpha to the bootstraps + inf._add_alpha_to_bootstraps() + + return self.bootstraps + + def bootstrap_if_required(self): + """""" + Bootstrap if not done yet. + """""" + if self.bootstraps is None: + self.bootstrap() + + def get_x0(self) -> Dict[str, Dict[str, float]]: + """""" + Get initial values for joint inference. + + :return: Dictionary of initial values indexed by type + """""" + x0 = {} + + # create initial values from marginal inferences + for t, inf in self.marginals_without_all().items(): + + # the MLE params might not be defined + if inf.params_mle is not None: + x0[t] = inf.params_mle + else: + x0[t] = self.marginal_inferences['all'].x0['all'] + + # get shared parameters from last inference and merge + # with parameters for type 'all' + shared = {} + + # get dict of shared parameters + for s in self.shared_params: + for p in s.params: + # take mean value over types + shared[':'.join(s.types) + '.' + p] = cast(float, np.mean([x0[t][p] for t in s.types])) + + # pack shared parameters + packed = pack_shared(x0, self.shared_params, shared) + + # add parameters for covariates and return + return merge_dicts(packed, {':'.join(self.types): self._x0_cov}) + + @BaseInference._run_if_required_wrapper + def perform_lrt_shared(self, do_bootstrap: bool = False) -> float: + """""" + Compare likelihood of joint inference with product of marginal likelihoods. + This provides information about the goodness of fit achieved by the parameter sharing. + Low p-values indicate that parameter sharing is not justified, i.e., that the marginal + inferences provide a significantly better fit to the data. Note that it is more difficult to properly + optimize the joint likelihood, which makes this test conservative, i.e., the reported p-value + may be larger than what it should be. + + :param do_bootstrap: Whether to perform bootstrapping. + :return: p-value + """""" + if do_bootstrap: + self.bootstrap_if_required() + + # determine likelihood of marginal inferences + ll_marginal = sum([inf.likelihood for inf in self.marginals_without_all().values()]) + + # determine number of parameters, fixed parameters cancel out + n_marginal = np.sum([len(inf.params_mle) for inf in self.marginals_without_all().values()]) + n_joint = len(flatten_dict(self.get_x0())) + + return self.lrt(ll_simple=self.likelihood, ll_complex=ll_marginal, df=n_marginal - n_joint) + + def get_inferences( + self, + types: List[str] = None, + labels: List[str] = None, + show_marginals: bool = True + ) -> Dict[str, 'BaseInference']: + """""" + Get all inference objects as dictionary. + + :param types: Types to include + :param labels: Labels for types + :param show_marginals: Whether to also show marginal inferences + :return: Dictionary of base inference objects indexed by type and joint vs marginal subtypes + """""" + + def get(infs: Dict[str, BaseInference], prefix: str) -> Dict[str, BaseInference]: + """""" + Get filtered and prefixed inferences. + + :param infs: Dictionary of inferences. + :param prefix: Prefix + :return: Dictionary of inferences + """""" + # filter types if types are given + if types is not None: + infs = dict((k, v) for k, v in infs.items() if k in types) + + # add prefix to keys + return dict((prefix + '.' + k, v) for k, v in infs.items()) + + # get joint inferences + inferences = get(self.joint_inferences, 'joint') + + if show_marginals: + # include marginal inferences + inferences = get(self.marginal_inferences, 'marginal') | inferences + + # use labels as keys if given + if labels is not None: + + if len(labels) != len(inferences): + raise ValueError(f'Number of labels ({len(labels)}) does not match ' + f'number of inferences ({len(inferences)}).') + + inferences = dict(zip(labels, inferences.values())) + + return inferences + + @BaseInference._run_if_required_wrapper + def plot_discretized( + self, + file: str = None, + show: bool = True, + intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + show_marginals: bool = True, + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'original', + title: str = 'discretized DFE comparison', + labels: List[str] = None, + kwargs_legend: dict = dict(prop=dict(size=8)), + ax: 'plt.Axes' = None + ) -> 'plt.Axes': + """""" + Plot discretized DFE comparing the different types. + + :param labels: Labels for types + :param title: Title of plot + :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bars. + :param show_marginals: Whether to also show marginal inferences + :param bootstrap_type: Type of bootstrap + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :param ci_level: Confidence level + :param confidence_intervals: Whether to plot confidence intervals + :param file: File to save plot to + :param show: Whether to show plot + :param ax: Axes to plot on. Only for Python visualization backend. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :return: Axes object + """""" + labels, inferences = zip(*self.get_inferences(labels=labels, show_marginals=show_marginals).items()) + + return Inference.plot_discretized(**locals()) + + def plot_sfs_comparison( + self, + sfs_types: List[Literal['modelled', 'observed', 'selected', 'neutral']] = ['observed', 'modelled'], + types: List[str] = None, + labels: List[str] = None, + colors: List[str] = None, + file: str = None, + show: bool = True, + ax: 'plt.Axes' = None, + title: str = 'SFS comparison', + use_subplots: bool = False, + show_monomorphic: bool = False, + kwargs_legend: dict = dict(prop=dict(size=8)), + + ) -> 'plt.Axes': + """""" + Plot SFS comparison. + + :param types: Types to plot + :param file: File to save plot to + :param labels: Labels for types. + :param colors: Colors for types. Only for Python visualization backend. + :param sfs_types: Types of SFS to plot + :param show: Whether to show plot + :param ax: Axes to plot on. Only for Python visualization backend and if ``use_subplots`` is ``False``. + :param title: Plot title + :param use_subplots: Whether to use subplots. Only for Python visualization backend. + :param show_monomorphic: Whether to show monomorphic counts + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :return: Axes object + """""" + from .visualization import Visualization + + if 'modelled' in sfs_types: + self.run_if_required() + + mapping = dict( + observed='sfs_sel', + selected='sfs_sel', + modelled='sfs_mle', + neutral='sfs_neut' + ) + + inferences = self.get_inferences(types=types) + + def get_label(t: str, sfs_type: str) -> str: + """""" + Get label for types. + + :param t: Type + :param sfs_type: SFS type + :return: Label + """""" + subtypes = t.split('.') + + # insert sfs type at second position + return '.'.join([subtypes[0]] + [sfs_type] + subtypes[1:]) + + # get spectra + spectra = {get_label(t, sfs): getattr(inf, mapping[sfs]) for t, inf in inferences.items() for sfs in sfs_types} + + return Visualization.plot_spectra( + spectra=[list(v) for v in spectra.values()], + labels=list(spectra.keys()) if labels is None else labels, + colors=colors, + file=file, + show=show, + ax=ax, + title=title, + use_subplots=use_subplots, + show_monomorphic=show_monomorphic, + kwargs_legend=kwargs_legend + ) + + @BaseInference._run_if_required_wrapper + def plot_continuous( + self, + file: str = None, + show: bool = True, + intervals: np.ndarray = None, + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + title: str = 'DFE comparison', + labels: List[str] = None, + scale_density: bool = False, + scale: Literal['lin', 'log', 'symlog'] = 'lin', + kwargs_legend: dict = dict(prop=dict(size=8)), + ax: 'plt.Axes' = None + ) -> 'plt.Axes': + """""" + Plot discretized DFE. The special constants ``np.inf`` and ``-np.inf`` are also valid interval bounds. + By default, the PDF is plotted as is. Due to the logarithmic scale on + the x-axis, we may get a wrong intuition on how the mass is distributed, + however. To get a better intuition, we can optionally scale the density + by the x-axis interval size using ``scale_density = True``. This has the + disadvantage that the density now changes for x, so that even a constant + density will look warped. + + :param scale_density: Whether to scale the density by the x-axis interval size + :param scale: y-scale + :param labels: Labels for types + :param title: Title of plot + :param bootstrap_type: Type of bootstrap + :param ci_level: Confidence level + :param confidence_intervals: Whether to plot confidence intervals + :param file: File to save plot to + :param show: Whether to show plot + :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :param ax: Axes to plot on. Only for Python visualization backend. + :return: Axes object + """""" + if intervals is None: + intervals = self.discretization.bins + + labels, inferences = zip(*self.get_inferences(labels=labels).items()) + + return Inference.plot_continuous(**locals()) + + @BaseInference._run_if_required_wrapper + def plot_inferred_parameters( + self, + file: str = None, + confidence_intervals: bool = True, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + ci_level: float = 0.05, + show: bool = True, + title: str = 'inferred parameters', + labels: List[str] = None, + ax: 'plt.Axes' = None, + scale: Literal['lin', 'log', 'symlog'] = 'log', + kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right'), + **kwargs: List[str] + ) -> 'plt.Axes': + """""" + Plot discretized DFE comparing the different types. + + :param labels: Labels for types + :param title: Title of plot + :param bootstrap_type: Type of bootstrap + :param ci_level: Confidence level + :param confidence_intervals: Whether to plot confidence intervals + :param file: File to save plot to + :param show: Whether to show plot + :param ax: Axes to plot on. Only for Python visualization backend. + :param scale: y-scale + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :return: Axes object + """""" + labels, inferences = zip(*self.get_inferences(labels=labels).items()) + + return Inference.plot_inferred_parameters(**locals()) + + @BaseInference._run_if_required_wrapper + def plot_inferred_parameters_boxplot( + self, + file: str = None, + show: bool = True, + title: str = 'inferred parameters', + labels: List[str] = None, + **kwargs: List[str] + ) -> 'plt.Axes': + """""" + Plot discretized DFE comparing the different types. + + :param labels: Labels for types + :param title: Title of plot + :param file: File to save plot to + :param show: Whether to show plot + :return: Axes object + :raises ValueError: If no inference objects are given or no bootstraps are found. + """""" + labels, inferences = zip(*self.get_inferences(labels=labels).items()) + + return Inference.plot_inferred_parameters_boxplot(**locals()) + + @BaseInference._run_if_required_wrapper + def plot_covariate( + self, + index: int = 0, + file: str = None, + show: bool = True, + title: str = None, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'original', + show_types: bool = True, + ci_level: float = 0.05, + xlabel: str = ""cov"", + ylabel: str = None, + ax: 'plt.Axes' = None + ) -> 'plt.Axes': + """""" + Plot the covariate given by the index. + + :param index: The index of the covariate. + :param file: File to save plot to. + :param show: Whether to show plot. + :param title: Plot title. + :param bootstrap_type: Bootstrap type. + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :param show_types: Whether to show types on second x-axis. + :param ci_level: Confidence level. + :param xlabel: X-axis label. + :param ylabel: Y-axis label, defaults to the covariate parameter name. + :param ax: Axes to plot on. Only for Python visualization backend. + :return: Axes object. + """""" + from .visualization import Visualization + + key = f""c{index}"" + + # check if covariate exists + if key not in self.covariates: + raise ValueError(f""Covariate with index {index} does not exist."") + + # default title + if title is None: + title = f'covariate {key}' + + cov = self.covariates[key] + values = [self.params_mle[t][cov.param] for t in self.types] + + # get errors if bootstrapped + errors = None + if self.bootstraps is not None: + bootstraps = np.array([self.bootstraps[f""{t}.{cov.param}""] for t in self.types]).T + + # compute errors + values, errors, _ = Bootstrap.get_errors( + values=values, + bs=bootstraps, + bootstrap_type=bootstrap_type, + ci_level=ci_level, + point_estimate=point_estimate + ) + + return Visualization.plot_covariate( + covariates=[cov.values[t] for t in self.types], + values=values, + errors=errors, + file=file, + show=show, + title=title, + xlabel=xlabel, + ylabel=ylabel or cov.param, + labels=self.types if show_types else None, + ax=ax + ) + + def get_discretized( + self, + intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean' + ) -> Dict[str, Tuple[np.ndarray, np.ndarray]]: + """""" + Get discretized DFEs. + + :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bins. + :param confidence_intervals: Whether to return confidence intervals + :param ci_level: Confidence interval level + :param bootstrap_type: Type of bootstrap + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :return: Dictionary of array of values and array of errors indexed by inference type + """""" + return Inference.get_discretized( + inferences=list(self.get_inferences().values()), + labels=list(self.get_inferences().keys()), + intervals=intervals, + confidence_intervals=confidence_intervals, + ci_level=ci_level, + bootstrap_type=bootstrap_type, + point_estimate=point_estimate + ) + + def get_bootstrap_params(self) -> Dict[str, float]: + """""" + Get bootstrap parameters. + + :return: Bootstrap parameters + """""" + return flatten_dict(dict((t, self.joint_inferences[t].get_bootstrap_params()) for t in self.types)) + + def to_json(self) -> str: + """""" + Serialize object. Note that the deserialized inference objects no + longer share the same optimization instance among other things. + + :return: JSON string + """""" + # using make_ref=True resulted in weird behaviour when unserializing. + return jsonpickle.encode(self, indent=4, warn=True, make_refs=False) + + @functools.cached_property + def alpha(self) -> Optional[float]: + """""" + The is no single alpha for the joint inference. Please refer + to the ``self.joint_inferences[t].alpha``. + + :return: None + """""" + return + + def _set_fixed_params(self, params: Dict[str, Dict[str, float]]): + """""" + Set fixed parameters. + + :param params: Fixed parameters + """""" + # set for 'all' type + self.marginal_inferences['all']._set_fixed_params(params) + + # expand types + self.fixed_params = expand_fixed(params, self.types) + + # propagate to inference objects + for t in self.types: + self.marginal_inferences[t]._set_fixed_params(dict(all=self.fixed_params[t])) + self.joint_inferences[t]._set_fixed_params(dict(all=self.fixed_params[t])) + + # propagate to optimization + self.optimization.set_fixed_params(self.fixed_params) + + # check if the fixed parameters are compatible with the shared parameters + self.check_no_shared_params_fixed() + + def get_residual(self, k: int) -> float: + """""" + Residual of joint inference. We calculate the residual over the jointly inferred SFS for all types. + + :param k: Order of the norm + :return: L2 residual + """""" + counts_mle = np.array([inf.sfs_mle.polymorphic for inf in self.joint_inferences.values()]).flatten() + counts_sel = np.array([inf.sfs_sel.polymorphic for inf in self.joint_inferences.values()]).flatten() + + return norm(counts_mle - counts_sel, k) + + def get_alpha(self, params: dict = None) -> float: + """""" + Get alpha, the proportion of beneficial non-synonymous substitutions. + + :param params: DFE parameters to use for calculation of format `{type: {param: value}}`. + """""" + if params is None: + params = self.params_mle + + alphas = {} + for t in self.types: + alphas[t] = self.discretization.get_alpha(self.model, params[t]) + + return alphas +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/settings.py",".py","375","19",""""""" +Package-wide settings +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-09-12"" + + +class Settings: + """""" + Class that holds package-wide settings + """""" + #: Whether to disable the progress bar. + disable_pbar = False + + #: Whether to use parallel processing. Use ``None`` for local setting. + parallelize = None +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/likelihood.py",".py","2556","98",""""""" +MLE utilities. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import numpy as np +from scipy.special import factorial +from scipy.stats import poisson + + +class Likelihood: + """""" + Utilities for computing Poisson likelihoods. + """""" + + #: Epsilon for numerical stability + eps = 1e-50 + + @staticmethod + def add_epsilon(x: np.ndarray) -> np.ndarray: + """""" + Add epsilon to zero counts. + + :param x: Array to add epsilon to + :return: Array with epsilon added to zero counts + """""" + # convert to float + x = x.astype(float) + + # replace 0s with epsilon to avoid log(0) + x[x == 0] = Likelihood.eps + + return x + + @staticmethod + def poisson(mu: np.ndarray, k: np.ndarray) -> np.ndarray: + """""" + Compute Poisson(mu, k). + + :param mu: Mean of Poisson distribution + :param k: Number of events + :return: Poisson(mu, k) + """""" + # add epsilon to zero counts + mu = Likelihood.add_epsilon(mu) + + return poisson.pmf(k, mu) + + @staticmethod + def log_poisson(mu: np.ndarray, k: np.ndarray) -> np.ndarray: + """""" + Compute log(Poisson(mu, k)). + + :param mu: Mean of Poisson distribution + :param k: Number of events + :return: log(Poisson(mu, k)) + """""" + # add epsilon to zero counts + mu = Likelihood.add_epsilon(mu) + + return k * np.log(mu) - mu - Likelihood.log_factorial(k) + + @staticmethod + def log_factorial_stirling(n: np.ndarray | float) -> np.ndarray | float: + """""" + Use Stirling's approximation for values larger than n_threshold. + https://en.wikipedia.org/wiki/Stirling%27s_approximation + + :param n: n + :return: log(n!) + """""" + # np.log(np.sqrt(2 * np.pi * n) * (n / np.e) ** n * (1 + 1 / (12 * n))) + return 0.5 * np.log(2 * np.pi * n) + n * np.log(n / np.e) + np.log(1 + 1 / (12 * n)) + + @staticmethod + def log_factorial(n: np.ndarray, n_threshold: int = 100) -> np.ndarray: + """""" + Compute log(n!). + + :param n: n + :param n_threshold: Threshold for using Stirling's approximation + :return: log(n!) + """""" + x = np.zeros_like(n, dtype=np.float64) + + low = n <= n_threshold + + # compute for low values of n + x[low] = np.log(factorial(n[low])) + + # use Stirling's approximation for large value of n + x[~low] = Likelihood.log_factorial_stirling(n[~low]) + + return x +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/optimization.py",".py","45984","1370",""""""" +Optimization module. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import copy +import logging +import math +from dataclasses import dataclass +from typing import Callable, List, Dict, Literal, Tuple, Optional, Sequence + +import multiprocess as mp +import numpy as np +import pandas as pd +from numpy.linalg import norm +from numpy.random import Generator +from scipy.stats import loguniform, uniform +from tqdm import tqdm + +from .likelihood import Likelihood +from .settings import Settings + +# get logger +logger = logging.getLogger('fastdfe').getChild('Optimization') + + +def parallelize( + func: Callable, + data: Sequence, + parallelize: bool = True, + pbar: bool = None, + desc: str = None, + dtype: type = object, + wrap_array: bool = True +) -> np.ndarray: + """""" + Parallelize given function or execute sequentially. + + :param parallelize: Whether to parallelize + :param data: Data to iterate over + :param func: Function to apply to each element of data + :param pbar: Whether to show a progress bar + :param desc: Description for progress bar + :param dtype: Data type of the returned array + :param wrap_array: Whether to wrap the result in a numpy array + :return: List of results + """""" + n = len(data) + + if parallelize and n > 1 and Settings.parallelize is not False: + # parallelize + iterator = mp.Pool().imap(func, data) + else: + # sequentialize + iterator = map(func, data) + + # whether to show a progress bar + if pbar is True or (pbar is None and n > 1): + iterator = tqdm(iterator, total=n, disable=Settings.disable_pbar, desc=desc) + + if wrap_array: + return np.array(list(iterator), dtype=dtype) + + return list(iterator) + + +def flatten_dict(d: dict, separator='.', prefix=''): + """""" + Flatten dictionary. + + :param d: The nested dictionary + :param separator: The separator character to use in the flattened dictionary keys + :param prefix: The prefix to use in the flattened dictionary keys + :return: The flattened dictionary + """""" + res = {} + + for key, value in d.items(): + if isinstance(value, dict): + # recursive call + res.update(flatten_dict(value, separator, prefix + key + separator)) + else: + res[prefix + key] = value + + return res + + +def unflatten_dict(d: dict, separator='.'): + """""" + Unflatten dictionary. + + :param d: The flattened dictionary + :param separator: The separator character used in the flattened dictionary keys + :return: The original nested dictionary + """""" + res = {} + + for key, value in d.items(): + subkeys = key.split(separator) + subdict = res + + # recursively create nested dictionaries for each subkey + for subkey in subkeys[:-1]: + subdict = subdict.setdefault(subkey, {}) + + # assign value to the final subkey + subdict[subkeys[-1]] = value if not isinstance(value, dict) else unflatten_dict(value, separator) + + return res + + +def unpack_params(x: np.ndarray, original: Dict[str, dict | tuple | float]) -> Dict[str, dict | tuple | float]: + """""" + Unpack params from numpy array. This is the inverse of pack_params and is used + as scipy.optimize.minimize only accepts numpy arrays as parameters. + + :param x: Numpy array + :param original: Original dictionary + :return: Unpacked dictionary + """""" + keys = flatten_dict(original).keys() + + return unflatten_dict(dict(zip(keys, x))) + + +def pack_params(params: Dict[str, dict | tuple | float]) -> np.ndarray: + """""" + Pack params into numpy array. This is used as scipy.optimize.minimize only accepts + numpy arrays as parameters. This is the inverse of unpack_params. + + :param params: Dictionary to pack + :return: numpy array + """""" + flattened = flatten_dict(params) + + return np.array(list(flattened.values())) + + +def filter_dict(d, keys): + """""" + Recursively filter a dictionary by a list of given keys at the deepest level. + + :param d: The dictionary to filter + :param keys: The list of keys to keep in the filtered dictionary + :return: The filtered dictionary + """""" + filtered = {} + + for key, value in d.items(): + if isinstance(value, dict): + filtered_sub = filter_dict(value, keys) + if filtered_sub: + filtered[key] = filtered_sub + else: + if key in keys: + filtered[key] = value + + return filtered + + +def pack_shared( + params: Dict[str, Dict[str, float]], + shared: List['SharedParams'], + shared_values: Dict[str, float] +) -> Dict[str, Dict[str, float]]: + """""" + Pack shared parameters. Here we extract shared parameters from + type-specific keys and instead create entries with joint-types + holding the shared parameters. + Note that we only delete parameters from marginal types but in some + cases we would have to delete them from compound types as well if + a more general shared parameter were to be specified later on. + We instead rely on the user not to do this. + + :param params: Dictionary of parameters indexed by type + :param shared: List of shared parameters + :param shared_values: Dictionary of parameters indexed by joint-type and parameter name, i.e. 'type1:type2.p1' + :return: Packed dictionary + """""" + packed = copy.deepcopy(params) + + # iterator through shared parameter + for s in shared: + + # remove shared keys + for t in s.types: + for p in s.params: + if p in packed[t]: + packed[t].pop(p) + + # create joint type string + type_string = ':'.join(s.types) + + # create shared type with appropriate parameters + packed = merge_dicts(packed, {type_string: dict((p, shared_values[type_string + '.' + p]) for p in s.params)}) + + return packed + + +def unpack_shared(params: dict) -> dict: + """""" + Unpack shared parameters. Here we extract shared parameters from joint-type keys + and add them tp the targeted types. + + :param params: Dictionary of parameters + :return: Unpacked dictionary + """""" + unpacked = {} + + for t, v in params.items(): + if ':' in t: + unpacked = merge_dicts(unpacked, dict((s, v) for s in t.split(':'))) + else: + unpacked[t] = v + + return unpacked + + +def expand_shared(params: List['SharedParams'], types: List[str], names: List[str]) -> List['SharedParams']: + """""" + Expand 'all' type for shared parameters. + + :param params: List of shared parameters + :param types: List of types + :param names: List of parameter names + :return: Expanded list of shared parameters + """""" + expanded = [] + + for x in params: + # expand 'all' type + types = types if x.types == 'all' else x.types + params = names if x.params == 'all' else x.params + + # noinspection PyTypeChecker + expanded.append(SharedParams(types=types, params=params)) + + return expanded + + +def expand_fixed( + fixed_params: Dict[str, Dict[str, float]], + types: List[str] +) -> Dict[str, Dict[str, float]]: + """""" + Expand 'all' type for shared parameters. + + :param fixed_params: Dictionary of fixed parameters indexed by type and parameter + :param types: List of types + :return: Expanded dictionary of fixed parameters + """""" + expanded = {} + + # loop through fixed parameters + for key_type, params in fixed_params.items(): + # expand 'all' type + key_types = types if key_type == 'all' else [key_type] + + # loop through types + for t in key_types: + if t not in expanded: + expanded[t] = {} + + if isinstance(params, dict): + for param, value in params.items(): + expanded[t][param] = value + + return expanded + + +def collapse_fixed_to_mean( + expanded_params: Dict[str, Dict[str, float]], + types: List[str] +) -> Dict[str, Dict[str, float]]: + """""" + Collapse expanded fixed parameters to 'all' type if all types have the same fixed parameter. + Take the mean of the fixed parameters. + + :param expanded_params: Expanded dictionary of fixed parameters + :param types: List of types + :return: Collapsed dictionary of fixed parameters + """""" + out = {""all"": dict(expanded_params.get(""all"", {}))} + + # collect params appearing in any type + params = set() + for t in types: + params |= expanded_params.get(t, {}).keys() + + for p in params: + vals = [expanded_params[t][p] for t in types if p in expanded_params.get(t, {})] + if len(vals) == len(types): + out[""all""][p] = float(np.mean(vals)) + + return out + +def collapse_fixed( + expanded_params: Dict[str, Dict[str, float]], + types: List[str] +) -> Dict[str, Dict[str, float]]: + """""" + Collapse expanded fixed parameters to 'all' type if all types have the same fixed parameter. + + :param expanded_params: Expanded dictionary of fixed parameters + :param types: List of types + :return: Collapsed dictionary of fixed parameters + """""" + # copy first + out = {k: dict(v) for k, v in expanded_params.items()} + out.setdefault(""all"", {}) + + # find params present in *every* type with identical value + common = None + for t in types: + d = expanded_params.get(t, {}) + keys = set(d.keys()) + common = keys if common is None else (common & keys) + + if not common: + return out + + for p in list(common): + vals = [expanded_params[t][p] for t in types] + if all(v == vals[0] for v in vals): + out[""all""][p] = vals[0] + for t in types: + out[t].pop(p, None) + + return out + + + +def merge_dicts(dict1: dict, dict2: dict) -> dict: + """""" + Merge two dictionaries recursively. + + :param dict1: First dictionary + :param dict2: Second dictionary + :return: Merged dictionary + """""" + # make a copy of the first dictionary + result = dict(dict1) + + # loop through the items in the second dictionary + for key, value in dict2.items(): + + # Check if the key already exists in the result dictionary and both the + # value in the result and dict2 dictionaries are dictionaries. + if key in result and isinstance(result[key], dict) and isinstance(value, dict): + + # recursively merge the two dictionaries + result[key] = merge_dicts(result[key], value) + else: + # simply assign the value from dict2 to the result dictionary + result[key] = value + + return result + + +def correct_values( + params: Dict[str, float], + bounds: Dict[str, Tuple[float, float]], + scales: Dict[str, Literal['lin', 'log', 'symlog']], + warn: bool = False, + threshold: float = 1e-6 +) -> Dict[str, float]: + """""" + Correct initial values so that they are within the specified bounds. + + :param bounds: Dictionary of bounds + :param params: Flattened dictionary of parameters + :param scales: Dictionary of scales + :param warn: Whether to warn if values are corrected + :param threshold: Threshold for the error to trigger a warning + :return: Corrected dictionary + """""" + # create a copy of params + corrected = params.copy() + + for key, value in params.items(): + # get base name + name = key.split('.')[-1] + + # get real bounds + bound = get_real_bounds(bounds[name], scale=scales[name]) + + # correct value if outside bounds + if value < bound[0]: + corrected[key] = bound[0] + elif value > bound[1]: + corrected[key] = bound[1] + + # differences between the original and corrected dictionaries + differences = {key: (params[key], corrected[key]) for key in params if params[key] != corrected[key]} + + # warn if there are differences that exceed the threshold + exceeded_threshold = {} + for key, (old_val, new_val) in differences.items(): + + # calculate relative error + err = np.abs(new_val - old_val) + + # add if it exceeds the relative error + if err > threshold: + exceeded_threshold[key] = f""{old_val} -> {new_val}"" + + if exceeded_threshold and warn: + logger.warning(f'Given initial values outside bounds. Adjusting {exceeded_threshold}.') + + return corrected + + +def get_real_bounds(bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog']) -> Tuple[float, float]: + """""" + Get real bounds from the given bounds. + + :param bounds: Bounds of the parameter + :param scale: Scale of the parameter + :return: + """""" + if scale == 'symlog': + return -bounds[1], bounds[1] + + return bounds + + +def evaluate_counts(get_counts: dict, params: dict): + """""" + Evaluate counts using the given parameters. + Here we assign the parameters to the appropriate types + obtaining the counts for each type. + + :param get_counts: Dictionary of functions to evaluate counts for each type + :param params: Dictionary of parameters + :return: Dictionary of counts + """""" + counts = {} + + # unpack shared parameters + unpacked = unpack_shared(params) + + # evaluate counts for each type + for key in get_counts.keys(): + counts[key] = get_counts[key](unpacked[key]) + + return counts + + +def to_symlog(x: float, linthresh: float = 1e-5) -> float: + """""" + Convert a value to the symlog scale. + + :param x: The input value on the original scale. + :param linthresh: The positive value that determines the range within which the + symlog scale is linear. Must be greater than 0. + :return: The value on the symlog scale. + """""" + sign = np.sign(x) + abs_x = np.abs(x) + log_x = np.log10(abs_x + linthresh) - np.log10(linthresh) + + return sign * (abs_x / linthresh if abs_x <= linthresh else log_x) + + +def from_symlog(y: float, linthresh: float = 1e-5) -> float: + """""" + Convert a value from the symlog scale back to the original scale. + + :param y: The input value on the symlog scale. + :param linthresh: The positive value that determines the range within which the + symlog scale is linear. Must be greater than 0. + :return: The value on the original scale. + """""" + sign = np.sign(y) + abs_y = np.abs(y) + exp_y = np.power(10, abs_y + np.log10(linthresh)) - linthresh + + return sign * (abs_y * linthresh if abs_y <= 1 else exp_y) + + +def scale_bound(bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog']): + """""" + Convert a bound to the specified scale. For symlog scale we assume the symmetric bounds, + so that the upper bound denotes the boundaries and the lower bound the linear threshold. + + :param bounds: The bound to convert + :param scale: The scale to convert to + :return: The converted bound + :raises ValueError: if the scale is unknown + """""" + if scale == 'lin': + return bounds + + if scale == 'log': + if bounds[1] < 0: + return -np.log10(-bounds[0]), -np.log10(-bounds[1]) + + if bounds[0] > 0: + return np.log10(bounds[0]), np.log10(bounds[1]) + + raise ValueError('Bounds must not span zero for log scale.') + + if scale == 'symlog': + + if bounds[0] <= 0 or bounds[1] <= 0: + raise ValueError('Both bounds must be positive for symlog scale.') + + return to_symlog(-bounds[1], linthresh=bounds[0]), to_symlog(bounds[1], linthresh=bounds[0]) + + raise ValueError(f'Unknown scale {scale}.') + + +def unscale_bound( + scaled_bounds: Tuple[float, float], + scale: Literal['lin', 'log', 'symlog'], + linthresh: float = 1e-5 +) -> Tuple[float, float]: + """""" + Convert a bound from the specified scale back to the original scale. For symlog scale, + we assume symmetric bounds, so that the upper bound denotes the boundaries and + the lower bound the linear threshold, i.e. ``bounds = (-bounds[1], bounds[1])`` and ``linthresh = bounds[0]``. + Note that we cannot reliably recover negative bounds that were log scaled. + + :param linthresh: + :param scaled_bounds: The bound to convert + :param scale: The scale to convert from + :return: The converted bound + :raises ValueError: if the scale is unknown + """""" + if scale == 'lin': + return scaled_bounds + + if scale == 'log': + return np.power(10, scaled_bounds[0]), np.power(10, scaled_bounds[1]) + + if scale == 'symlog': + upper_bound = from_symlog(scaled_bounds[1], linthresh=linthresh) + + return linthresh, upper_bound + + raise ValueError(f'Unknown scale {scale}.') + + +def scale_bounds( + bounds: Dict[str, Tuple[float, float]], + scales: Dict[str, Literal['lin', 'log', 'symlog']] +) -> Dict[str, Tuple[float, float]]: + """""" + Convert bounds to the specified scale. For symlog scale we assume the symmetric bounds, + so that the upper bound denotes the boundaries and the lower bound the linear threshold. + + :param bounds: Flattened dictionary of bounds to convert index by type and parameter + :param scales: Dictionary of scales indexed by parameter + :return: The converted bounds + :raises ValueError: if the scale is unknown + """""" + scaled_bounds = {} + + for key, value in bounds.items(): + scaled_bounds[key] = scale_bound(value, scale=scales[get_basename(key)]) + + return scaled_bounds + + +def scale_value(value: float, bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog']) -> float: + """""" + Convert a value to the specified scale. For symlog scale, the untransformed bounds are needed, + so that the upper bound denotes the boundaries and the lower bound the linear threshold. + + :param value: The value to convert. + :param bounds: The untransformed bounds for the symlog scale. + :param scale: The scale to convert to. + :return: The converted value. + :raises ValueError: if the scale is unknown. + """""" + if scale == 'lin': + return value + + if scale == 'log': + + if value < 0: + return -np.log10(-value) + + return np.log10(value) + + if scale == 'symlog': + return to_symlog(value, linthresh=bounds[0]) + + raise ValueError(f'Unknown scale {scale}.') + + +def unscale_value(scaled_value: float, bounds: Tuple[float, float], scale: Literal['lin', 'log', 'symlog']) -> float: + """""" + Convert a value from the specified scale back to the original scale. For symlog scale, + the untransformed bounds are needed, so that the upper bound denotes the boundaries + and the lower bound the linear threshold. + + :param scaled_value: The value to convert. + :param bounds: The untransformed bounds for the symlog scale. + :param scale: The scale to convert from. + :return: The converted value. + :raises ValueError: if the scale is unknown. + """""" + if scale == 'lin': + return scaled_value + + if scale == 'log': + + if bounds[1] < 0: + return -np.power(10, -scaled_value) + + return np.power(10, scaled_value) + + if scale == 'symlog': + return from_symlog(scaled_value, linthresh=bounds[0]) + + raise ValueError(f'Unknown scale {scale}.') + + +def perturb_value(value: float, bounds: Tuple[float, float], rng: np.random.Generator) -> float: + """""" + Perturb a value within the given bounds using a normal distribution with mean at the value + and standard deviation equal to the value. + + :param value: The value to perturb. + :param bounds: The bounds to perturb within. + :param rng: The random number generator to use. + :return: The perturbed value. + """""" + std = 2 * abs(value) if value != 0 else 0.1 * abs(bounds[1] - bounds[0]) + perturbed = rng.normal(loc=value, scale=std) + + # ensure within bounds + perturbed = max(bounds[0], min(bounds[1], perturbed)) + + return perturbed + + +def scale_values( + params: Dict[str, Dict[str, float]], + bounds: Dict[str, Tuple[float, float]], + scales: Dict[str, Literal['lin', 'log', 'symlog']] +) -> Dict[str, Dict[str, float]]: + """""" + Scale values according to the given scales. + + :param params: Nested dictionary of parameters indexed by type and parameter + :param scales: Dictionary of scales indexed by parameter name + :param bounds: Dictionary of bounds indexed by parameter name + :return: Nested dictionary of scaled parameters indexed by type and parameter + """""" + scaled = {} + + for key, value in flatten_dict(params).items(): + # scale value + scaled[key] = scale_value(value, bounds[get_basename(key)], scales[get_basename(key)]) + + return unflatten_dict(scaled) + + +def unscale_values( + params: Dict[str, Dict[str, float]], + bounds: Dict[str, Tuple[float, float]], + scales: Dict[str, Literal['lin', 'log', 'symlog']] +) -> Dict[str, Dict[str, float]]: + """""" + Unscale values according to the given scales. + + :param params: Nested dictionary of parameters indexed by type and parameter + :param scales: Dictionary of scales indexed by parameter name + :param bounds: Dictionary of scales indexed by parameter name + :return: Nested dictionary of unscaled parameters indexed by type and parameter + """""" + unscaled = {} + + for key, value in flatten_dict(params).items(): + # unscale value + unscaled[key] = unscale_value(value, bounds[get_basename(key)], scales[get_basename(key)]) + + return unflatten_dict(unscaled) + + +def get_basename(name: str) -> str: + """""" + Get the basename of parameter string, i.e. type.param -> param. + + :param name: The string to get the basename from. + :return: The basename. + """""" + return name.split('.')[-1] + + +def check_bounds( + bounds: Dict[str, Tuple[float, float]], + params: Dict[str, float], + fixed_params: Dict[str, float] = {}, + percentile: float = 1, + scale: Literal['lin', 'log'] = 'lin' +) -> Tuple[Dict[str, Tuple[float, float, float]], Dict[str, Tuple[float, float, float]]]: + """""" + Issue warnings if the passed parameters are close to the specified bounds. + + :param bounds: The bounds to check against. + :param params: The parameters to check. + :param fixed_params: The fixed parameters. + :param percentile: The percentile threshold to consider a parameter close to the bounds. + :param scale: Scale type: 'lin' for linear and 'log' for logarithmic. + :return: Tuple of dictionaries of parameters close to the lower and upper bounds, i.e. (lower, value, upper). + """""" + near_lower = {} + near_upper = {} + + def transform(value: float, to_scale: Literal['lin', 'log']) -> float: + """""" + Transform a value to the specified scale. + + :param value: The value to transform. + :param to_scale: The scale to transform to. + :return: The transformed value. + """""" + if to_scale == 'log': + return math.log(value) if value > 0 else -float('inf') + + return value + + for key, value in params.items(): + # get base name + name = key.split('.')[-1] + + # get bounds + lower, upper = bounds[name] + + # transform values + _lower = transform(lower, scale) + _upper = transform(upper, scale) + _value = transform(value, scale) + + if key not in fixed_params: + if _lower is not None and (_value - _lower) / (_upper - _lower) <= percentile / 100: + near_lower[key] = (lower, value, upper) + + if _upper is not None and (_upper - _value) / (_upper - _lower) <= percentile / 100: + near_upper[key] = (lower, value, upper) + + return near_lower, near_upper + + +@dataclass +class SharedParams: + """""" + Class specifying the sharing of params among types. + ``all`` means all available types or params. + + Example usage: + + :: + + import fastdfe as fd + + # neutral SFS for two types + sfs_neut = fd.Spectra(dict( + pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652], + pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31] + )) + + # selected SFS for two types + sfs_sel = fd.Spectra(dict( + pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794], + pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41] + )) + + # create inference object + inf = fd.JointInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + shared_params=[fd.SharedParams(types=[""pendula"", ""pubescens""], params=[""eps"", ""S_d""])], + do_bootstrap=True + ) + + # run inference + inf.run() + + """""" + #: The params to share + params: List[str] | Literal['all'] = 'all' + + #: The types to share + types: List[str] | Literal['all'] = 'all' + + +@dataclass +class Covariate: + """""" + Class defining a covariate which induces a relationship + with one or many parameters. The relationship is defined + by a callback function which modifies the parameters. The + default callback introduces a linear relationship. + + Below an example of introducing linear covariates for ``S_d``, the for mean strength of deleterious + mutations (cf. :class:`~fastdfe.parametrization.GammaExpParametrization`). Each + of the three types is associated with one covariate. This we pass to + :class:`~fastdfe.joint_inference.JointInference` together with the stratified spectra: + + :: + + import fastdfe as fd + + cov = fd.Covariate( + param='S_d', + values=dict(type1=5, type2=3, type3=1) + ) + + """""" + + #: The parameter to modify + param: str + + #: The values of the covariate for each type + values: Dict[str, float] + + #: The callback function to modify the parameters + callback: Optional[Callable] = None + + #: The bounds of the covariate parameter to be estimated + bounds: tuple = (1e-4, 1e4) + + #: The initial value of the covariate + x0: float = 0 + + #: The scale of the bounds. See :func:`scale_value` for details + bounds_scale: Literal['lin', 'log', 'symlog'] = 'symlog' + + def __post_init__(self): + """""" + Cast bounds to tuple and check if an inverse_callback is provided + when a custom callback is specified. + """""" + self.bounds = tuple(self.bounds) + + def apply(self, covariate: float, type: str, params: Dict[str, float]) -> Dict[str, float]: + """""" + Apply the custom or default callback to modify the given parameters. + + :param covariate: The value of the covariate. + :param type: The type of the relationship. + :param params: The input parameters. + :return: Modified parameters. + """""" + # Use custom callback if given else default callback + callback = self.apply_default if self.callback is None else self.callback + + return callback(covariate=covariate, type=type, params=params) + + def apply_default(self, covariate: float, type: str, params: Dict[str, float]) -> Dict[str, float]: + """""" + Modify the given parameters introducing a linear relationship + with the given covariate. + + :param covariate: The value of the covariate. + :param type: The type of the relationship. + :param params: The input parameters. + :return: Modified parameters. + """""" + # create a copy of input parameters + modified = params.copy() + + # introduce linear relationship + if self.param in params: + modified[self.param] += covariate * self.values[type] + + return modified + + @staticmethod + def _apply(covariates: Dict[str, 'Covariate'], params: dict, type: str) -> dict: + """""" + Apply given covariates to given parameters. + + :param covariates: Dictionary of covariates to add + :param params: Dict of parameters + :param type: SFS type + :return: Dict of parameters with covariates added + """""" + for k, cov in covariates.items(): + params = cov.apply( + covariate=params[k], + type=type, + params=params + ) + + return params + + +class Optimization: + """""" + Class for optimizing the DFE. + """""" + + #: Optimization method to use. Use class property for downward compatibility + method_mle = 'L-BFGS-B' + + def __init__( + self, + bounds: Dict[str, Tuple[float, float]], + param_names: List[str], + loss_type: Literal['likelihood', 'L2'] = 'likelihood', + opts_mle: dict = {}, + method_mle: str = 'L-BFGS-B', + parallelize: bool = True, + fixed_params: Dict[str, Dict[str, float]] = {}, + scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, + seed: int = None + ): + """""" + Create object. + + :param parallelize: Whether to parallelize the optimization + :param bounds: Dictionary of bounds + :param opts_mle: Dictionary of options for the optimizer + :param method_mle: Optimization method to use + :param loss_type: Type of loss function to use + :param fixed_params: Dictionary of fixed parameters + :param scales: Dictionary of scales + :param param_names: List of parameter names + """""" + #: Parameter bounds + self.bounds: Dict[str, Tuple[float, float]] = bounds + + #: Parameter scales to use + self.scales: Dict[str, Literal['lin', 'log', 'symlog']] = scales + + #: additional options for the optimizer + self.opts_mle: dict = opts_mle + + #: Optimization method to use + self.method_mle: str = method_mle + + #: Type of loss function to use + self.loss_type: str = loss_type + + #: Fixed parameters + self.fixed_params: Dict[str, Dict[str, float]] = flatten_dict(fixed_params) + + # check if fixed parameters are within the specified bounds + if correct_values(self.fixed_params, self.bounds, warn=False, scales=scales) != self.fixed_params: + raise ValueError('Fixed parameters are outside the specified bounds. ' + f'Fixed params: {self.fixed_params}, bounds: {self.bounds}.') + + #: Parameter names + self.param_names: List[str] = param_names + + #: Whether to parallelize the optimization + self.parallelize: bool = parallelize + + #: Initial values + self.x0: Optional[dict] = None + + #: Number of runs + self.n_runs: Optional[int] = None + + #: DataFrame holding information about all optimization runs + self.runs: Optional[pd.DataFrame] = None + + #: Random generator instance + self.rng = np.random.default_rng(seed=seed) + + def run( + self, + get_counts: Dict[str, Callable], + x0: Dict[str, Dict[str, float]] = {}, + scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, + bounds: Dict[str, Tuple[float, float]] = {}, + n_runs: int = 1, + debug_iterations: bool = True, + print_info: bool = True, + opts_mle: dict = None, + pbar: bool = None, + desc: str = 'Inferring DFE', + ) -> Tuple['scipy.optimize.OptimizeResult', dict]: + """""" + Perform the optimization procedure. + + :param scales: Scales of the parameters + :param bounds: Bounds of the parameters + :param n_runs: Number of independent optimization runs out of which the best one is chosen. The first run + will use the initial values if specified. Consider increasing this number if the optimization does not + produce good results. + :param x0: Dictionary of initial values in the form ``{type: {param: value}}`` + :param get_counts: Dictionary of functions to evaluate counts for each type + :param debug_iterations: Whether to print debug messages for each iteration + :param opts_mle: Dictionary of options for the optimizer + :param print_info: Whether to print information about the bounds + :param pbar: Whether to show a progress bar + :param desc: Description for the progress bar + :return: The optimization result and the likelihoods + """""" + from scipy.optimize import minimize, OptimizeResult + + # number of optimization runs + self.n_runs = n_runs + + # store the scales of the parameters + if scales: + self.scales = scales + + # store the bounds of the parameters + if bounds: + self.bounds = bounds + + # store the options for the optimizer + if opts_mle: + self.opts_mle = opts_mle + + # filter out unneeded values + # this also holds the fixed parameters + self.x0 = filter_dict(x0, self.param_names) + + # flatten initial values + flattened = flatten_dict(self.x0) + + # determine parameter names of parameters to be optimized + optimized_param_names = list(set(flattened) - set(self.fixed_params)) + + # issue debug messages + logger.debug(f'Performing optimization on {len(flattened)} parameters: {list(flattened.keys())}.') + logger.debug(f'Using initial values: {flattened}.') + + if print_info: + logger.info(f""Optimizing {len(optimized_param_names)} parameters: [{', '.join(optimized_param_names)}]."") + + # issue warning when the number of parameters to be optimized is large + if len(optimized_param_names) > 10: + logger.warning(f'A large number of parameters is optimized jointly. ' + f'Please be aware that this makes it harder to find a good optimum.') + + # correct initial values to be within bounds + self.x0 = unflatten_dict(correct_values(flattened, self.bounds, warn=True, scales=self.scales)) + + # determine parameter bounds + bounds = self.get_bounds(flatten_dict(self.x0)) + + def optimize(x0: Dict[str, Dict[str, float]]) -> OptimizeResult: + """""" + Perform numerical minimization. + + :param x0: Dictionary of initial values in the form ``{type: {param: value}}`` + :return: Optimization result + """""" + logger.debug(f""Initial parameters: {x0}."") + + return minimize( + fun=self.get_loss_function( + get_counts=get_counts, + print_debug=debug_iterations + ), + x0=pack_params(self.scale_values(x0)), + method=self.method_mle, + bounds=pack_params(scale_bounds(bounds, self.scales)), + options=self.opts_mle + ) + + # initial parameters for the samples + initial_params = [self.x0] + [self.sample_x0(self.x0) for _ in range(int(self.n_runs) - 1)] + + # parallelize MLE for different initializations + results = parallelize(optimize, initial_params, self.parallelize, pbar=pbar, desc=desc) + + # build a pandas DataFrame of all runs + records = [] + for i, res in enumerate(results): + params = unpack_params(res.x, self.x0) + params = unscale_values(params, self.bounds, self.scales) + flat = flatten_dict(params) + flat['likelihood'] = -res.fun + flat['success'] = res.success + flat['result'] = str(str) + flat['x0'] = str(flatten_dict(initial_params[i])) + records.append(flat) + + # store runs as DataFrame + self.runs = pd.DataFrame(records) + + # get result with the lowest likelihood + result = results[np.argmax(self.runs.likelihood)] + + # unpack MLE params array into a dictionary + params_mle = unpack_params(result.x, self.x0) + + # unscale parameters + params_mle = unscale_values(params_mle, self.bounds, self.scales) + + # check if the MLE reached one of the bounds + if print_info: + self.check_bounds(flatten_dict(params_mle)) + + return result, params_mle + + def scale_values(self, values: Dict[str, Dict[str, float]]) -> Dict[str, Dict[str, float]]: + """""" + Scale the values of the parameters. + + :param values: Dictionary of initial values in the form ``{type: {param: value}}`` + :return: Dictionary of scaled initial values + """""" + return scale_values(values, self.bounds, self.scales) + + def get_loss_function( + self, + get_counts: Dict[str, Callable], + print_debug: bool = True + ) -> Callable: + """""" + Get the loss function. + + :param get_counts: Dictionary of functions to evaluate counts for each type + :param print_debug: Whether to print debug messages + :return: The loss function + """""" + + def loss(x: np.ndarray) -> float: + """""" + The loss function. + + :param x: Parameters + :return: The loss + """""" + # unpack parameters into dictionary using the keys of self.x0 + params = unpack_params(x, self.x0) + + # unscale parameters + params = unscale_values(params, self.bounds, self.scales) + + # Model SFS from parameters. + # Here the order of types does not matter. + # We only collect the counts for types that are + # given in get_counts. This makes it possible to + # avoid specifying type 'all' which is of no use + # in joint inference. + counts_dict = evaluate_counts(get_counts, params) + + # flatten and convert to array + counts = np.array(list(counts_dict.values())) + + # reshape and merge + counts_modelled, counts_observed = np.stack(counts, axis=1).reshape(2, -1) + + # use independent Poisson likelihoods + LL = Likelihood.log_poisson(mu=counts_modelled, k=counts_observed) + + # combine likelihoods + ll = np.sum(LL) + + # compute L2 norm + L2 = norm(counts_modelled - counts_observed, 2) + + # information on iteration + iter_info = flatten_dict(params) | dict(likelihood=ll, L2=L2) + + # log likelihood + if print_debug: + # check likelihood + if np.isnan(ll): + raise ValueError('Oh boy, likelihood is nan. This is no good...') + + # log variables + logger.debug(iter_info) + + # return appropriate loss + return dict(L2=L2, likelihood=-ll)[self.loss_type] + + return loss + + def sample_x0(self, example: dict, random_state: int | Generator = None) -> Dict[str, dict]: + """""" + Sample initial values. + + :param example: An example dictionary for generating the initial values + :param random_state: Random state or seed + :return: A dictionary of initial values + """""" + if random_state is None: + random_state = self.rng + + sample = {} + + for key, value in example.items(): + if isinstance(value, dict): + sample[key] = self.sample_x0(value, random_state) + elif key in self.bounds and key in self.scales: + sample[key] = self.sample_value(self.bounds[key], self.scales[key], random_state) + + return sample + + @staticmethod + def sample_value( + bounds: Tuple[float, float], + scale: Literal['lin', 'log', 'symlog'], + random_state: int | Generator = None + ) -> float: + """""" + Sample a value between given bounds using the given scaling. + This function works for positive, negative, and mixed bounds. + Note that when ``scale == 'symlog'``, ``bounds[0]`` defines the linear threshold and + the actual bounds are ``(-bounds[1], bounds[1])``. + + :param bounds: Tuple of lower and upper bounds + :param scale: Scaling of the parameter. + :param random_state: Random state or seed + :return: Sampled value + """""" + + def flip(bounds: Tuple[float, float]) -> Tuple[float, float]: + """""" + Flip the bounds. + + :param bounds: Tuple of lower and upper bounds + :return: Flipped bounds + """""" + return -bounds[1], -bounds[0] + + def symlog_rvs(lower: float, upper: float, random_state: int | Generator = None) -> float: + """""" + Sample from a symmetric log-uniform distribution. + + :param lower: Lower bound which is the linear threshold + :param upper: Upper bound so that the actual bounds are (-upper, upper) + :param random_state: Random state + :return: Sampled value + """""" + val = loguniform.rvs(lower, upper, random_state=random_state) + + # flip sign with 50% probability + return val if uniform.rvs() < 0.5 else -val + + # dictionary of scaling functions + scaling_functions = { + 'lin': uniform.rvs, + 'log': loguniform.rvs, + 'symlog': symlog_rvs + } + + # raise an error if the scale is not valid + if scale not in scaling_functions: + raise ValueError(f""Scale must be one of: {', '.join(scaling_functions.keys())}"") + + # raise an error if bounds span 0 and scale is 'log' + if bounds[0] < 0 < bounds[1] and scale == 'log': + raise ValueError(f""Log scale not possible for bounds that span 0."") + + # raise an error if bounds are negative and scale is 'symlog' + if bounds[0] < 0 and scale == 'symlog': + raise ValueError(f""Symlog scale not possible for negative bounds."") + + # flip bounds if they are negative + flipped = bounds[0] < 0 + if flipped: + bounds = flip(bounds) + + # sample a value using the appropriate scaling function + sample = scaling_functions[scale](bounds[0], bounds[1] - bounds[0], random_state=random_state) + + # return the sampled value, flipping back if necessary + return -sample if flipped else sample + + def check_bounds(self, params: Dict[str, float], percentile: float = 1) -> None: + """""" + Check if the given parameters are within the bounds. + + :param params: Parameters + :param percentile: Percentile of the bounds to check + :return: Whether the parameters are within the bounds + """""" + # we scale the bounds to obtain more sensible warnings + bounds = scale_bounds(self.bounds, self.scales) + params_scaled = flatten_dict(self.scale_values(unflatten_dict(params))) + + # get parameters close to the bounds + near_lower, near_upper = check_bounds( + params=params_scaled, + bounds=bounds, + fixed_params=self.fixed_params, + percentile=percentile, + scale='lin' + ) + + if len(near_lower | near_upper) > 0: + + def get_values(keys: List[str]) -> Dict[str, Tuple[str, str, str]]: + """""" + Unscale the parameters. + + :param keys: List of parameter names + :return: Unscaled parameters + """""" + unscaled = {} + + for key in keys: + unscaled[key] = ( + ""{:g}"".format(self.bounds[get_basename(key)][0]), + ""{:.8g}"".format(params[key]), + ""{:g}"".format(self.bounds[get_basename(key)][1]) + ) + + return unscaled + + # string representation of parameters + near_lower_unscaled = str(get_values(list(near_lower.keys()))).replace('\'', '') + near_upper_unscaled = str(get_values(list(near_upper.keys()))).replace('\'', '') + + # issue warning + logger.warning( + f'The MLE estimate is close to the upper bound ' + f'for {near_upper_unscaled} and lower bound ' + f'for {near_lower_unscaled} [(lower, value, upper)], but ' + f'this might be nothing to worry about.' + ) + + def get_bounds(self, x0: Dict[str, float]) -> Dict[str, Tuple[float, float]]: + """""" + Get a nested dictionary of bounds the same structure as the given initial values. + + :param x0: Flattened dictionary of initial values + :return: A dictionary of initial values + """""" + bounds = {} + + for key, value in x0.items(): + + # check if the parameter is fixed + if key in self.fixed_params: + bounds[key] = (self.fixed_params[key], self.fixed_params[key]) + else: + bounds[key] = self.bounds[key.split('.')[-1]] + + return bounds + + def set_fixed_params(self, fixed_params: Dict[str, Dict[str, float]]): + """""" + Set fixed parameters. We flatten the dictionary to make it easier to work with. + + :param fixed_params: Dictionary of fixed parameters + """""" + self.fixed_params = flatten_dict(fixed_params) + + @staticmethod + def perturb_params( + params: Dict[str, Dict[str, float]], + bounds: Dict[str, Tuple[float, float]], + seed: Optional[int] = None, + ) -> Dict[str, Dict[str, float]]: + """""" + Perturb values within the given bounds using a normal distribution with mean at the value + and standard deviation equal to the value. + + :param params: Nested dictionary of parameters indexed by type and parameter + :param bounds: Dictionary of bounds indexed by parameter name + :param seed: Seed for the random number generator + :return: Nested dictionary of perturbed parameters indexed by type and parameter + """""" + rng = np.random.default_rng(seed) + perturbed = {} + + for key, value in flatten_dict(params).items(): + # perturb value + perturbed[key] = perturb_value(value, bounds[get_basename(key)], rng) + + return unflatten_dict(perturbed) +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/polydfe.py",".py","13173","434",""""""" +polyDFE wrapper utilities. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import copy +import json +import logging +import subprocess +import tempfile +import time +from typing import Callable, List, Optional, Literal, Dict + +import numpy as np +import pandas as pd + +from typing_extensions import Self + +from .abstract_inference import AbstractInference, Inference +from .config import Config +from .parametrization import _from_string, Parametrization, DiscreteParametrization +from .polydfe_utils import create_sfs_config, models + +# get logger +logger = logging.getLogger('fastdfe').getChild('PolydfeWrapper') + + +class PolyDFEResult: + """""" + Class for parsing polyDFE output. + """""" + # default postprocessing source + default_postprocessing_source = '../resources/polydfe/postprocessing/script.R' + + # mapping of polyDFE params to new name + param_mapping = dict( + eps_an='eps' + ) + + def __init__( + self, + output_file: str, + additional_data: dict = {}, + postprocessing_source: str = default_postprocessing_source + ): + """""" + Create summary object. + + :param output_file: Path to polyDFE output file + :param additional_data: Additional data to add to summary + :param postprocessing_source: Path to polyDFE postprocessing script + """""" + self.output_file = output_file + self.postprocessing_source = postprocessing_source + + self.data = self.parse_output() | additional_data + + @staticmethod + def map_name(name: str) -> str: + """""" + Map polyDFE parameter name to new name. + + :param name: polyDFE parameter name + :return: New name + """""" + if name in PolyDFEResult.param_mapping: + return PolyDFEResult.param_mapping[name] + + return name + + def parse_output(self) -> dict: + """""" + Parse output from polyDFE output file. + + :return: Dictionary of parsed data + """""" + from rpy2.robjects.packages import importr + + # use the polyDFE R postprocessing script to parse the output file + output = self.get_postprocessing_wrapper().parseOutput(self.output_file)[0] + + # convert to JSON + rj = importr('RJSONIO') + json_str = rj.toJSON(output)[0] + + # load dict from JSON string + data = json.loads(json_str) + + return dict( + output_file=data['input'], + model=data['model'], + likelihood=data['lk'], + criteria=data['criteria'], + params_mle=dict( + # non-nuisance parameters + # map polyDFE param name to new name + (PolyDFEResult.map_name(k), v) for k, v in data['values'][0].items() if not k.startswith('r ') + ) | dict( + # nuisance parameters + r=[data['values'][0][f""r {i}""] for i in range(2, data['n'])] + ), + n=data['n'], + expec=data['expec'][0], + alpha=self.get_alpha(output) + ) + + def get_alpha(self, parsed_output: 'rpy2.robjects.vectors.ListVector') -> float: + """""" + Get alpha, the proportion of beneficial non-synonymous substitutions. + + :return: Parsed output from polyDFE + """""" + return self.get_postprocessing_wrapper().estimateAlpha(parsed_output)[0] + + def get_postprocessing_wrapper(self) -> 'ro.R': + """""" + Get the wrapped polyDFE postprocessing source. + + :return: R object + """""" + import rpy2.robjects as ro + + ps = ro.r + ps.source(self.postprocessing_source) + + return ps + + def to_json(self) -> str: + """""" + Convert object to JSON. + + :return: JSON string + """""" + return json.dumps(self.data, indent=4) + + def to_file(self, file: str): + """""" + Save object to file. + + :return: File path to save to + """""" + with open(file, 'w') as fh: + fh.write(self.to_json()) + + +class PolyDFE(AbstractInference): + """""" + polyDFE wrapper. + + Note that this class has dependencies outside of pip. + Currently only model C is fully implemented. + """""" + + def __init__(self, config: Config): + """""" + Create polyDFE wrapper. + + :param config: Config object + """""" + super().__init__() + + self.config = config + + # polyDFE output file + self.output_file: Optional[str] = None + + # the total execution time in seconds + self.execution_time: float = 0 + + # polyDFE summary + self.summary: Optional[PolyDFEResult] = None + + # bootstrap samples + self.bootstraps: Optional[pd.DataFrame] = None + + @staticmethod + def map_polydfe_model(model: str) -> str: + """""" + Map polyDFE model name to native equivalent. + + :param model: polyDFE model name + :return: Native model name + """""" + return {v: k for k, v in models.items()}[model] + + @classmethod + def from_config(cls, config: Config) -> Self: + """""" + Load from config object. + + :param config: Config object + """""" + return cls(config) + + @classmethod + def from_config_file(cls, file: str) -> Self: + """""" + Load from config object. + + :param file: Config file path, possibly URL. + :return: Inference object. + """""" + return cls.from_config(Config.from_file(file)) + + def run( + self, + output_file: str, + binary: str = 'polydfe', + wd: str = None, + execute: Callable = None, + postprocessing_source: str = PolyDFEResult.default_postprocessing_source + ) -> PolyDFEResult: + """""" + Run polyDFE. + + :param postprocessing_source: polyDFE postprocessing source + :param execute: Function for executing shell commands + :param wd: Working directory + :param binary: polyDFE binary + :param output_file: Output file + :return: polyDFE summary + """""" + start_time = time.time() + + # define default function for executing command + if execute is None: + def shell(command: str): + """""" + Execute shell command. + + :param command: Command string + """""" + return subprocess.run(command, check=True, cwd=wd, shell=True) + + execute = shell + + # save the spectra and init file, so they can be reviewed if necessary + # use temp file to generate the file name. + with open(tempfile.NamedTemporaryFile().name, 'w') as spectra_file: + with open(tempfile.NamedTemporaryFile().name, 'w') as init_file: + # save files + self.config.create_polydfe_sfs_config(spectra_file.name) + self.config.create_polydfe_init_file(init_file.name, n=self.config.data['sfs_neut'].n) + + # add number of fragment if model is DiscreteParametrization + model = _from_string(self.config.data['model']) + k = str(model.k - 1) + ' ' if isinstance(model, DiscreteParametrization) else '' + + # construct command string + command = (f""{binary} "" + f""-d {spectra_file.name} "" + f""-m {self.config.get_polydfe_model()} {k}"" + f""-i {init_file.name} 1 "" + f""-v 1 > {output_file}"") + + # log command signature + self._logger.info(f""Running: '{command}'"") + + # execute command + execute(command) + + # add execution time + self.execution_time += time.time() - start_time + + # create summary from output file + self.summary = PolyDFEResult( + output_file=output_file, + additional_data=dict(execution_time=self.execution_time), + postprocessing_source=postprocessing_source + ) + + return self.summary + + def create_bootstrap(self) -> Config: + """""" + Create a bootstrap sample using polyDFE's resampling. + + :return: Config object + """""" + if self.summary is None: + raise Exception('PolyDFE needs to be run before creating bootstrap samples.') + + # postprocessing wrapper + ps = self.summary.get_postprocessing_wrapper() + + # create temporary SFS config file + with tempfile.NamedTemporaryFile() as tmp: + create_sfs_config( + file=tmp.name, + sfs_neut=self.config.data['sfs_neut']['all'], + sfs_sel=self.config.data['sfs_sel']['all'] + ) + + # create bootstrap SFS config + ps.bootstrapData(tmp.name, rep=1) + + # file name of resampled SFS config + sfs_config_file = tmp.name + '_1' + + # use exiting config as template and load init and SFS file + config = copy.deepcopy(self.config) + config.parse_polydfe_sfs_config(sfs_config_file) + config.data['x0'] = dict(all=self.summary.data['params_mle']) + + return config + + def add_bootstraps(self, bootstraps: 'List[PolyDFE]'): + """""" + Add bootstraps samples. + + :param bootstraps: List of bootstrap samples + """""" + # load MLE params into dataframe + self.bootstraps = pd.DataFrame([bs.get_bootstrap_params() for bs in bootstraps]) + + # drop nuisance parameters and eps_cont + self.bootstraps.drop(columns=['r', 'eps_cont'], inplace=True, errors='ignore') + + # update execution time + self.execution_time += float(np.sum([bs.summary.data['execution_time'] for bs in bootstraps])) + + def plot_all(self, show: bool = True): + """""" + Plot a bunch of plots. + + :param show: Whether to show the plot + """""" + self.plot_inferred_parameters(show=show) + self.plot_discretized(show=show) + + def plot_inferred_parameters( + self, + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + file: str = None, + show: bool = True, + title: str = 'parameter estimates', + scale: Literal['lin', 'log', 'symlog'] = 'log', + legend: bool = True, + ax: 'plt.Axes' = None, + kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right'), + ) -> 'plt.Axes': + """""" + Visualize the inferred parameters and their confidence intervals. + + :param scale: Scale of the y-axis + :param confidence_intervals: Whether to show confidence intervals + :param ci_level: Confidence interval level + :param bootstrap_type: Type of bootstrap + :param legend: Show legend + :param ax: Axes to plot on. Only for Python visualization backend. + :param title: Title of the plot + :param show: Show the plot + :param file: File to save the plot to + :param show: Show the plot + :param ax: Axes to plot on. Only for Python visualization backend. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :return: Axes object + """""" + return Inference.plot_inferred_parameters( + inferences=[self], + labels=['all'], + confidence_intervals=confidence_intervals, + ci_level=ci_level, + bootstrap_type=bootstrap_type, + file=file, + show=show, + title=title, + legend=legend, + scale=scale, + ax=ax, + kwargs_legend=kwargs_legend + ) + + def get_bootstrap_param_names(self) -> List[str]: + """""" + Parameter names for parameters included in bootstraps. + + :return: List of parameter names + """""" + return _from_string(self.config.data['model']).param_names + ['eps', 'alpha'] + + def get_bootstrap_params(self) -> Dict[str, float]: + """""" + Get the parameters to be included in the bootstraps. + + :return: Dict of parameters + """""" + params = self.summary.data['params_mle'] | dict(alpha=self.summary.data['alpha']) + + # filter params + return dict((k, params[k]) for k in self.get_bootstrap_param_names()) + + @property + def params_mle(self) -> dict: + """""" + Get the maximum likelihood estimate of the parameters. + + :return: Dict of parameters + """""" + return self.summary.data['params_mle'] + + @params_mle.setter + def params_mle(self, value): + """""" + Set the maximum likelihood estimate of the parameters. + + :param value: Dict of parameters + """""" + pass + + @property + def model(self) -> Parametrization: + """""" + Get the DFE parametrization. + + :return: Parametrization + """""" + + return _from_string(self.config.data['model']) + + @model.setter + def model(self, value): + """""" + Set the DFE parametrization. + + :param value: Parametrization + """""" + pass +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/base_inference.py",".py","67799","1823",""""""" +Base inference class. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import copy +import functools +import itertools +import logging +import time +from math import comb +from typing import List, Optional, Dict, Literal, cast, Tuple, Sequence, Callable + +import jsonpickle +import multiprocess as mp +import numpy as np +import pandas as pd +from numpy.linalg import norm +from scipy.stats import chi2 +from typing_extensions import Self + +from . import optimization +from . import parametrization +from .abstract_inference import AbstractInference, Inference +from .config import Config +from .discretization import Discretization +from .optimization import Optimization, flatten_dict, pack_params, expand_fixed, unpack_shared +from .parametrization import Parametrization, _from_string, DFE +from .spectrum import Spectrum, Spectra +from .spectrum import standard_kingman +from .utils import Serializable + +# get logger +logger = logging.getLogger('fastdfe') + + +class BaseInference(AbstractInference): + """""" + Base inference class for inferring the SFS given one neutral and one selected SFS. + Note that BaseInference is by default seeded. + + Example usage: + + :: + + import fastdfe as fd + + sfs_neut = fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652]) + sfs_sel = fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]) + + # create inference object + inf = fd.BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel, + n_runs=10, + n_bootstraps=100, + do_bootstrap=True + ) + + # run inference + inf.run() + + # plot discretized DFE + inf.plot_discretized() + + # plot SFS comparison + inf.plot_sfs_comparison() + + """""" + + #: Default parameters not connected to the DFE parametrization + _default_x0 = dict( + eps=0.0, + h=0.5 + ) + + #: Default parameter bounds not connected to the DFE parametrization + _default_bounds = dict( + eps=(0, 0.15), + h=(0, 1) + ) + + #: Default scales for the parameters not connected to the DFE parametrization + _default_scales = dict( + eps='lin', + h='lin' + ) + + #: Default options for the maximum likelihood optimization + _default_opts_mle = dict( + # ftol=1e-10, + # gtol=1e-10 + ) + + # Optimization runs. Static for backward compatibility. + runs: Optional[pd.DataFrame] = None + + def __init__( + self, + sfs_neut: Spectra | Spectrum, + sfs_sel: Spectra | Spectrum, + intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), + intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), + intervals_h: Tuple[float, float, int] = (0.0, 1.0, 21), + h_callback: Callable[[np.ndarray], np.ndarray] = None, + integration_mode: Literal['midpoint', 'quad'] = 'midpoint', + linearized: bool = True, + model: Parametrization | str = 'GammaExpParametrization', + seed: int = 0, + x0: Dict[str, Dict[str, float]] = {}, + bounds: Dict[str, Tuple[float, float]] = {}, + scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, + loss_type: Literal['likelihood', 'L2'] = 'likelihood', + opts_mle: dict = {}, + method_mle: str = 'L-BFGS-B', + n_runs: int = 10, + fixed_params: Dict[str, Dict[str, float]] = None, + do_bootstrap: bool = True, + n_bootstraps: int = 100, + n_bootstrap_retries: int = 2, + parallelize: bool = True, + folded: bool = None, + discretization: Discretization = None, + optimization: Optimization = None, + locked: bool = False, + **kwargs + ): + """""" + Create BaseInference instance. + + :param sfs_neut: The neutral SFS. Note that we require monomorphic counts to be specified in order to infer + the mutation rate. If a :class:`~fastdfe.spectrum.Spectra` object with more than one SFS is provided, the + ``all`` attribute will be used. + :param sfs_sel: The selected SFS. Note that we require monomorphic counts to be specified in order to infer + the mutation rate. If a :class:`~fastdfe.spectrum.Spectra` object with more than one SFS is provided, the + ``all`` attribute will be used. + :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled + selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` + provides nearly identical results while increasing speed, especially when precomputing across dominance + coefficients. + :param intervals_ben: Same as ``intervals_del`` but for positive selection coefficients. Decreasing the number + of intervals to ``100`` provides nearly identical results while increasing speed, especially when + precomputing across dominance coefficients. + :param intervals_h: ``(start, stop, n_interval)`` for dominance coefficients which are linearly spaced. + This is only used when inferring dominance coefficients. Values of ``h`` between the edges will be + interpolated linearly. + :param h_callback: A function mapping the scalar parameter ``h`` and the array of selection + coefficients ``S`` to dominance coefficients of the same shape, allowing models where ``h`` + depends on ``S``. The default is ``lambda h, S: np.full_like(S, h)``, keeping ``h`` constant. + Expected allele counts for a given dominance value are obtained by linear interpolation + between precomputed values in ``intervals_h``. The inferred parameter is still named ``h``, + even if transformed by ``h_callback``, and its bounds, scales, and initial values can be set + via ``bounds``, ``scales``, and ``x0``. The fitness of heterozygotes and mutation homozygotes is defined as + ``1 + 2hs`` and ``1 + 2s``, respectively. + :param integration_mode: Integration mode when computing expected SFS under semidominance. + ``quad`` is not recommended. + :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use + ``scipy.integrate.quad`` in each call. ``False`` not recommended. + :param model: Instance of DFEParametrization which parametrized the DFE + :param seed: Seed for the random number generator. Use ``None`` for no seed. + :param x0: Dictionary of initial values in the form ``{'all': {param: value}}`` + :param bounds: Bounds for the optimization in the form ``{param: (lower, upper)}`` + :param scales: Scales for the optimization in the form ``{param: scale}`` + :param loss_type: Type of loss function to use for optimization. + :param opts_mle: Options for the optimization. + :param method_mle: Method to use for optimization. See ``scipy.optimize.minimize`` for available methods. + :param n_runs: Number of independent optimization runs out of which the best one is chosen. The first run + will use the initial values if specified. Consider increasing this number if the optimization does not + produce good results. + :param fixed_params: Parameters kept constant during optimization, given as ``{'all': {param: value}}``. + By default, the ancestral misidentification rate ``eps`` is fixed to zero, ``h`` to 0.5, and the DFE + parameters are fixed so that only the deleterious component of the DFE is estimated. + :param do_bootstrap: Whether to do bootstrapping. + :param n_bootstraps: Number of bootstraps. + :param n_bootstrap_retries: Number of optimization runs for each bootstrap sample. This parameter previously + defined the number of retries per bootstrap sample when subsequent runs failed, but now it defines the + total number of runs per bootstrap sample, taking the most likely one. + :param pbar: Whether to show a progress bar. + :param parallelize: Whether to parallelize computations. + :param folded: Whether the SFS are folded. If not specified, the SFS will be folded if both of the given + SFS appear to be folded. + :param discretization: Discretization instance. Mainly intended for internal use. + :param optimization: Optimization instance. Mainly intended for internal use. + :param locked: Whether inferences can be run from the class itself. Used internally. + :param kwargs: Additional keyword arguments which are ignored. + """""" + super().__init__() + + # assign neutral SFS + if isinstance(sfs_neut, Spectra): + #: Neutral SFS + self.sfs_neut: Spectrum = sfs_neut.all + else: + # assume we have Spectrum object + self.sfs_neut: Spectrum = sfs_neut + + # assign selected SFS + if isinstance(sfs_sel, Spectra): + #: Selected SFS + self.sfs_sel: Spectrum = sfs_sel.all + else: + # assume we have Spectrum object + self.sfs_sel: Spectrum = sfs_sel + + # check that we have monomorphic counts + if self.sfs_neut.to_list()[0] == 0 or self.sfs_sel.to_list()[0] == 0: + raise ValueError('Some of the provided SFS have zero ancestral monomorphic counts. ' + 'Note that we require monomorphic counts in order to infer the mutation rate.') + + # check that we have polymorphic counts + if self.sfs_neut.n_polymorphic == 0 or self.sfs_neut.n_polymorphic == 0: + raise ValueError('Some of the provided SFS have zero polymorphic counts. ' + 'Note that we require polymorphic counts in order to infer the DFE.') + + if self.sfs_neut.n != self.sfs_sel.n: + raise ValueError('The sample sizes of the neutral and selected SFS must be equal.') + + #: The DFE parametrization + self.model: Parametrization = parametrization._from_string(model) + + if folded is None: + #: Whether the SFS are folded + self.folded: bool = self.sfs_sel.is_folded() and self.sfs_neut.is_folded() + else: + self.folded = folded + + #: Sample size + self.n: int = sfs_neut.n + + if self.n > 400: + raise ValueError( + f""Population sample size n={self.n} above allowed maximum of 400. "" + f""Note that high sample sizes (e.g. n > 50) don't carry much additional "" + f""information over moderate sample sizes and don't necessarily improve DFE inference."" + ) + + if fixed_params is None: + fixed_params = {'all': {'eps': 0, 'h': 0.5} | self.model.submodels['dele']} + + if not 'all' in fixed_params: + fixed_params['all'] = {} + + # expand 'all' type + #: Fixed parameters + self.fixed_params: Dict[str, Dict[str, float]] = expand_fixed(fixed_params, ['all']) + + # check that the fixed parameters are valid + self.check_fixed_params_exist() + + if discretization is None: + # create discretization instance + #: Discretization instance + self.discretization: Discretization = Discretization( + n=self.n, + h=self.fixed_params.get('all', {}).get('h', None), + h_callback=h_callback, + intervals_del=intervals_del, + intervals_ben=intervals_ben, + intervals_h=intervals_h, + integration_mode=integration_mode, + linearized=linearized, + parallelize=parallelize + ) + + else: + # otherwise assign instance + self.discretization: Discretization = discretization + + #: Estimate of theta from neutral SFS + self.theta: float = self.sfs_neut.theta + + # raise warning if theta is unusually large + if self.theta > 0.05 or self.sfs_sel.theta > 0.05: + self._logger.warning(""Mutation rate appears unusually high. "" + ""This is a reminder to provide monomorphic site counts."") + + #: MLE estimates of the initial optimization + self.params_mle: Optional[Dict[str, float]] = None + + #: Modelled MLE SFS + self.sfs_mle: Optional[Spectrum] = None + + #: Likelihood of the MLE, this value may be updated after bootstrapping + self.likelihood: Optional[float] = None + + #: Likelihoods of the different ML runs, controlled by ``n_runs`` + self.likelihoods: Optional[List[float]] = None + + #: Number of MLE runs to perform + self.n_runs: int = n_runs + + #: Dataframe holding information on all optimization runs + self.runs: Optional[pd.DataFrame] = None + + #: Numerical optimization result + self.result: Optional['scipy.optimize.OptimizeResult'] = None + + # Bootstrap options + + #: Whether to do bootstrapping + self.do_bootstrap: bool = do_bootstrap + + #: Number of bootstraps + self.n_bootstraps: int = n_bootstraps + + #: Number of optimization runs for each bootstrap sample + self.n_bootstrap_retries: int = n_bootstrap_retries + + #: Whether to parallelize computations + self.parallelize: bool = parallelize + + #: Parameter scales + self.scales: Dict[str, Literal['lin', 'log', 'symlog']] = self.model.scales | self._default_scales | scales + + #: Parameter bounds + self.bounds: Dict[str, Tuple[float, float]] = self.model.bounds | self._default_bounds | bounds + + if optimization is None: + # create optimization instance + # merge with default values of inference and model + #: Optimization instance + self.optimization: Optimization = Optimization( + bounds=self.bounds, + scales=self.scales, + opts_mle=self._default_opts_mle | opts_mle, + method_mle=method_mle, + loss_type=loss_type, + param_names=self.param_names, + parallelize=self.parallelize, + fixed_params=fixed_params, + seed=seed + ) + else: + # otherwise assign instance + self.optimization: Optimization = optimization + + # warn if folded is true, and we estimate the full DFE + if self.folded: + fixed_dele = set(self.model.submodels['dele'].keys()) if 'dele' in self.model.submodels else set() + fixed = set(self.fixed_params['all'].keys()) if 'all' in self.fixed_params else set() + + if not fixed_dele.issubset(fixed): + self._logger.warning(""You are estimating the full DFE, but the SFS are folded. "" + ""This is not recommend as the folded SFS contains little information "" + ""on beneficial mutations."") + + #: Initial values + self.x0: Dict[str, Dict[str, float]] = dict( + all=self.model.x0 | self._default_x0 | (x0['all'] if 'all' in x0 else {}) + ) + + #: Bootstrapped MLE parameter estimates + self.bootstraps: Optional[pd.DataFrame] = None + + #: Bootstrap optimization results + self.bootstrap_results: Optional[List['scipy.optimize.OptimizeResult']] = None + + #: L2 norm of differential between modelled and observed SFS + self.L2_residual: Optional[float] = None + + #: Random number generator seed + self.seed: int | None = int(seed) if seed is not None else None + + #: Random generator instance + self.rng: np.random.Generator = np.random.default_rng(seed=seed) + + #: Total execution time in seconds + self.execution_time: float = 0 + + #: Whether inferences can be run from the class itself + self.locked: bool = locked + + def get_fixed_param_names(self) -> List[str]: + """""" + Get the names of the fixed parameters. + """""" + fixed = [] + + for p in self.fixed_params.values(): + fixed += list(p.keys()) + + return cast(List[str], np.unique(fixed).tolist()) + + def check_fixed_params_exist(self): + """""" + Check that the fixed parameters are valid. + """""" + fixed = self.get_fixed_param_names() + + if not set(fixed).issubset(set(self.param_names)): + non_valid_params = list(set(fixed) - set(self.param_names)) + + raise ValueError(f'Fixed parameters {non_valid_params} is not a valid parameter ' + f'for this configuration. Valid parameters are {self.param_names}.') + + def raise_if_locked(self): + """""" + Raise an error if this object is locked. + + :raises Exception: + """""" + if self.locked: + raise Exception('This object is locked as inferences ought ' + 'not be run from the class itself') + + def run_if_required(self, *args, **kwargs) -> Optional[Spectrum]: + """""" + Run if not run yet. + + :param args: Arguments. + :param kwargs: Keyword arguments. + :return: DFE parametrization and modelled SFS. + """""" + if self.execution_time == 0: + self._logger.debug('Inference needs to be run first, triggering run.') + + return self.run(*args, **kwargs) + + self._logger.debug('Inference already run, not running again.') + + @staticmethod + def _run_if_required_wrapper(func): + """""" + Decorator to run inference if required. + + :param func: Function to decorate. + :return: Decorated function. + """""" + + @functools.wraps(func) + def wrapper(self, *args, **kwargs): + """""" + Wrapper function. + + :param self: Inference instance + :param args: Positional arguments + :param kwargs: Keyword arguments + :return: Function output + """""" + self.run_if_required(*args, **kwargs) + + return func(self, *args, **kwargs) + + return wrapper + + def run( + self, + do_bootstrap: bool = None, + pbar: bool = None, + **kwargs + + ) -> Spectrum: + """""" + Perform the DFE inference. + + :param pbar: Whether to show a progress bar. + :param do_bootstrap: Whether to perform bootstrapping. + :param kwargs: Additional keyword arguments which are ignored. + :return: Modelled SFS. + """""" + # check if locked + self.raise_if_locked() + + # starting time of inference + start_time = time.time() + + # update properties + self.update_properties( + do_bootstrap=do_bootstrap + ) + + # perform MLE + self._logger.debug(f'Starting numerical optimization of {self.n_runs} ' + 'independently initialized samples which are run ' + + ('in parallel.' if self.parallelize else 'sequentially.')) + + # precompute discretization + self.discretization.precompute() + + # perform numerical minimization + result, params_mle = self.optimization.run( + x0=self.x0, + scales=self.scales, + bounds=self.bounds, + get_counts=self.get_counts(), + n_runs=self.n_runs, + pbar=pbar, + desc=f'{self.__class__.__name__}>Performing inference' + ) + + # assign runs dataframe and likelihoods + self.runs = self.optimization.runs + self.likelihoods = self.runs.likelihood.to_list() + + # unpack shared parameters + params_mle = unpack_shared(params_mle) + + # normalize parameters + params_mle['all'] = self.model._normalize(params_mle['all']) + + # assign optimization result and MLE parameters + self._assign_result(result, params_mle['all']) + + # report on optimization result + self._report_result(result, params_mle) + + # add execution time + self.execution_time += time.time() - start_time + + # perform bootstrap if configured + if self.do_bootstrap: + self.bootstrap() + + return self.sfs_mle + + def get_counts(self) -> dict: + """""" + Get callback functions for modelling SFS counts from given parameters. + + :return: Callback functions for modelling SFS counts for each type. + """""" + return dict(all=lambda params: self._model_sfs( + discretization=self.discretization, + model=self.model, + params=params, + sfs_neut=self.sfs_neut, + sfs_sel=self.sfs_sel, + folded=self.folded + )) + + def evaluate_likelihood(self, params: Dict[str, Dict[str, float]]) -> float: + """""" + Evaluate likelihood function at given parameters. + + :param params: Parameters indexed by type and parameter name. + :return: The likelihood. + """""" + x0_cached = self.optimization.x0 + self.optimization.x0 = params + + # prepare parameters + params = pack_params(self.optimization.scale_values(flatten_dict(params))) + + lk = -self.optimization.get_loss_function(self.get_counts())(params) + + self.optimization.x0 = x0_cached + + return lk + + def _assign_result(self, result: 'scipy.optimize.OptimizeResult', params_mle: dict): + """""" + Assign optimization result and MLE parameters. + + :param params_mle: MLE parameters. + :param result: Optimization result. + """""" + self.result = result + self.params_mle = params_mle + self.likelihood = -result.fun + + # get SFS for MLE parameters + counts_mle, _ = self._model_sfs( + params=params_mle, + discretization=self.discretization, + model=self.model, + sfs_neut=self.sfs_neut, + sfs_sel=self.sfs_sel, + folded=self.folded + ) + + # create spectrum object from polymorphic counts + self.sfs_mle = Spectrum.from_polymorphic(counts_mle) + + # L2 norm of fit minus observed SFS + self.L2_residual = self.get_residual(2) + + # check L2 residual + self._check_L2_residual() + + def get_residual(self, k: int) -> float: + """""" + Residual of the modelled and observed SFS. + + :param k: Order of the norm + :return: L2 residual + """""" + return norm(self.sfs_mle.polymorphic - self.sfs_sel.polymorphic, k) + + def _check_L2_residual(self): + """""" + Check L2 residual. + """""" + ratio = self.get_residual(1) / self.sfs_sel.n_polymorphic + + if ratio > 0.1: + self._logger.warning(""The L1 residual comparing the modelled and observed SFS is rather large: "" + f""`norm(sfs_modelled - sfs_observed, 1) / sfs_observed` = {ratio:.3f}. "" + ""This may indicate that the model does not fit the data well."") + + def _report_result(self, result: 'scipy.optimize.OptimizeResult', params: dict): + """""" + Inform on optimization result. + + :param params: MLE parameters. + :param result: Optimization result. + """""" + # report on optimization result + if result.success: + self._logger.debug(f""Successfully finished optimization after {result.nit} iterations "" + f""and {result.nfev} function evaluations, obtaining a log-likelihood "" + f""of -{result.fun:.4g}"") + else: + self._logger.warning(""Numerical optimization did not terminate normally, so "" + ""the result might be unreliable. Consider adjusting "" + ""the optimization parameters (increasing `gtol` or `n_runs`) "" + ""or decreasing the number of optimized parameters."") + + self._logger.info( + ""Inference results: %s (best_run ± std_across_runs)"", + self._format_mean_std( + self.runs[self.runs.likelihood == self.runs.likelihood.max()].select_dtypes(""number"").iloc[0], + self.runs.select_dtypes(""number"").std().fillna(0) + ) + ) + + @staticmethod + def _format_mean_std(mean: dict, std: dict) -> str: + """""" + Format numerical dictionary for printing as mean ± std. + + :param mean: Dictionary of means. + :param std: Dictionary of standard deviations. + :return: Formatted string. + """""" + mean = flatten_dict(mean) + std = flatten_dict(std) + + return str({ + k: f""{mean[k]:.4g} ± {std.get(k, 0):.2g}"" + for k in mean + }).replace(""'"", """") + + def update_properties(self, **kwargs) -> Self: + """""" + Update the properties of this class with the given dictionary + given that its entries are not ``None``. + + .. warning:: + This will fail to update the optimization instance among other things. Avoid using this method. + + :meta private: + :param kwargs: Dictionary of properties to update. + :return: Self. + """""" + for key, value in kwargs.items(): + if value is not None: + setattr(self, key, value) + + return self + + def bootstrap( + self, + n_samples: int = None, + parallelize: bool = None, + update_likelihood: bool = False, + n_retries: int = None, + pbar: bool = True, + pbar_title: str = 'Bootstrapping' + ) -> pd.DataFrame: + """""" + Perform the parametric bootstrap. + + :param n_samples: Number of bootstrap samples. Defaults to :attr:`n_bootstraps`. + :param parallelize: Whether to parallelize the bootstrap. Defaults to :attr:`parallelize`. + :param update_likelihood: Whether to update the likelihood to be the mean of the bootstrap samples and + the original likelihood. This is not statistically valid but can stabilize maximum likelihood estimate + subject optimization noise. + :param n_retries: Number of optimization runs for each bootstrap sample. Defaults to + :attr:`n_bootstrap_retries`. + :param pbar: Whether to show a progress bar. + :param pbar_title: Title for the progress bar. + :return: Dataframe with bootstrap results. + """""" + self._bootstrap( + n_samples=n_samples, + parallelize=parallelize, + update_likelihood=update_likelihood, + n_retries=n_retries, + pbar=pbar, + pbar_title=pbar_title + ) + + # remove 'all.' prefix from columns + self.bootstraps.columns = self.bootstraps.columns.str.removeprefix(""all."") + + # add estimates for alpha to the bootstraps + self._add_alpha_to_bootstraps() + + return self.bootstraps + + def _bootstrap( + self, + n_samples: int = None, + parallelize: bool = None, + update_likelihood: bool = False, + n_retries: int = None, + pbar: bool = True, + pbar_title: str = 'Bootstrapping', + ) -> pd.DataFrame: + """""" + Perform the parametric bootstrap. + + :param n_samples: Number of bootstrap samples. Defaults to :attr:`n_bootstraps`. + :param parallelize: Whether to parallelize the bootstrap. Defaults to :attr:`parallelize`. + :param update_likelihood: Whether to update the likelihood to be the mean of the bootstrap samples and + the original likelihood. This is not statistically valid but can stabilize maximum likelihood estimate + subject optimization noise. + :param n_retries: Number of optimization runs for each bootstrap sample. Defaults to + :attr:`n_bootstrap_retries`. + :param pbar: Whether to show a progress bar. + :param pbar_title: Title for the progress bar. + :return: Dataframe with bootstrap results. + """""" + # check if locked + self.raise_if_locked() + + # perform inference first if not done yet + self.run_if_required() + + # precompute discretization if not done yet + self.discretization.precompute() + + # update properties + self.update_properties( + n_bootstraps=n_samples, + parallelize=parallelize, + n_bootstrap_retries=n_retries, + ) + + n_bootstraps = int(self.n_bootstraps) + + start_time = time.time() + + # parallelize computations if desired + if self.parallelize: + + self._logger.debug(f""Running {n_bootstraps} bootstrap samples "" + f""in parallel on {min(mp.cpu_count(), n_bootstraps)} cores."") + + else: + self._logger.debug(f""Running {n_bootstraps} bootstrap samples sequentially."") + + # seeds for bootstraps + seeds = self.rng.integers(0, high=2 ** 32, size=n_bootstraps) + + # run bootstraps + results = optimization.parallelize( + func=self._get_run_bootstrap_sample(), + data=seeds, + parallelize=self.parallelize, + pbar=pbar, + desc=f'{self.__class__.__name__}>{pbar_title} ({self.n_bootstrap_retries} runs each)' + ) + + # select best result for each bootstrap sample + i_best = [np.argmax([-r[0].fun if r[0].success else -np.inf for r in res]) for res in results] + + # get best results + result = results[np.arange(n_bootstraps), i_best] + + # number of successful runs + n_success = np.sum([res.success for res in result[:, 0]]) + + # dataframe of MLE estimates + self.bootstraps = pd.DataFrame([flatten_dict(r) for r in result[:, 1]]) + + # assign additional info to bootstraps + self.bootstraps['likelihood'] = [-r.fun for r in result[:, 0]] + self.bootstraps['success'] = [r.success for r in result[:, 0]] + self.bootstraps['result'] = [str(r) for r in result[:, 0]] + self.bootstraps['x0'] = [flatten_dict(r) for r in result[:, 2]] + self.bootstraps['i_best_run'] = i_best + self.bootstraps['likelihoods_runs'] = [[-r[0].fun for r in res] for res in results] + self.bootstraps['likelihoods_std'] = self.bootstraps['likelihoods_runs'].apply(np.std) + self.bootstraps['results_runs'] = [[str(r[0]) for r in res] for res in results] + self.bootstraps['x0_runs'] = [[flatten_dict(r[2]) for r in res] for res in results] + + # assign bootstrap results + self.bootstrap_results = list(result[:, 0]) + + self._logger.info( + ""Bootstrap summary: %s (mean ± std)"", + self._format_mean_std( + self.bootstraps.select_dtypes(""number"").mean().fillna(0), + self.bootstraps.select_dtypes(""number"").std().fillna(0) + ) + ) + + # issue warning if some runs did not finish successfully + if n_success < n_bootstraps: + self._logger.warning( + f""{n_bootstraps - n_success} out of {n_bootstraps} bootstrap samples "" + ""did not terminate normally during numerical optimization. "" + ""The confidence intervals might thus be unreliable. Consider "" + ""increasing the number of optimization runs per bootstrap sample (`n_retries`), "" + ""adjusting the optimization parameters (increasing `gtol` or `n_runs`), "" + ""or decreasing the number of optimized parameters."" + ) + + # add execution time + self.execution_time += time.time() - start_time + + # assign average likelihood of successful runs + if update_likelihood: + self.likelihood = np.mean([-res.fun for res in result[:, 0] if res.success] + [self.likelihood]) + + return self.bootstraps + + def _add_alpha_to_bootstraps(self): + """""" + Add estimates for alpha to the bootstraps. + """""" + self._logger.debug('Computing estimates for alpha.') + + # add alpha estimates + self.bootstraps['alpha'] = self.bootstraps.apply(lambda r: self.get_alpha(dict(r)), axis=1) + + def _get_run_bootstrap_sample(self) -> Callable[[int], Tuple['scipy.optimize.OptimizeResult', dict, dict, int]]: + """""" + Get function which runs a single bootstrap sample. + + :return: Static function which runs a single bootstrap sample, taking an optional seed and returning the + optimization result of best run, MLE parameters, the best x0, and its index. + """""" + + optimization = self.optimization + discretization = self.discretization + model = self.model + folded = self.folded + scales = self.scales + bounds = self.bounds + n_retries = self.n_bootstrap_retries + sfs_sel = self.sfs_sel + sfs_neut = self.sfs_neut + params_mle_all = dict(all=self.params_mle) + + def run_bootstrap_sample(seed: int): + """""" + Resample the selected and neutral SFS and rerun optimization. + Initial point is the MLE; each retry perturbs x0. + """""" + results = [] + x0 = params_mle_all + rng = np.random.default_rng(seed) + + # resample once + sel = sfs_sel.resample(seed=rng) + neut = sfs_neut.resample(seed=rng) + + for _ in range(max(n_retries, 1)): + # run optimizer + result, params_mle = optimization.run( + x0=x0, + scales=scales, + bounds=bounds, + n_runs=1, + debug_iterations=False, + print_info=False, + get_counts=dict(all=lambda p: BaseInference._model_sfs( + discretization=discretization, + model=model, + params=p, + sfs_neut=neut, + sfs_sel=sel, + folded=folded + )), + desc=f""{self.__class__.__name__}>Bootstrapping"" + ) + + # unpack shared + normalize + params_mle = unpack_shared(params_mle) + + # normalize MLE estimates + params_mle['all'] = model._normalize(params_mle['all']) + + results += [(result, params_mle, x0)] + + x0 = optimization.sample_x0(params_mle_all, random_state=rng) + + return results + + return run_bootstrap_sample + + def get_scales_linear(self) -> Dict[str, Literal['lin']]: + """""" + Get linear scales for all parameters. We do this for the bootstraps as x0 should be close to MLE. + + :return: Dictionary of scales. + """""" + return cast(Dict[str, Literal['lin']], dict((p, 'lin') for p in self.scales.keys())) + + def get_bounds_linear(self) -> Dict[str, Tuple[float, float]]: + """""" + Get linear bounds for all parameters. We do this for the bootstraps as x0 should be close to MLE. + + :return: Dictionary of bounds. + """""" + scaled_bounds = {} + + for key, bounds in self.bounds.items(): + + # for symlog we need to convert the bounds to linear scale + if self.scales[key] == 'symlog': + scaled_bounds[key] = (-bounds[1], bounds[1]) + else: + scaled_bounds[key] = bounds + + return scaled_bounds + + @classmethod + def _model_sfs( + cls, + discretization: Discretization, + model: Parametrization, + params: dict, + sfs_neut: Spectrum, + sfs_sel: Spectrum, + folded: bool + ) -> Tuple[np.ndarray, np.ndarray]: + """""" + Model the selected SFS from the given parameters. + + :param discretization: Discretization instance. + :param model: Parametrization instance. + :param params: Dictionary of parameters. + :param sfs_sel: Observed spectrum of selected sites. + :param sfs_neut: Observed spectrum of neutral sites. + :param folded: Whether the SFS are folded. + :return: Array of modelled and observed counts + """""" + # obtain modelled selected SFS + counts_modelled = discretization.model_selection_sfs(model, params) + + # adjust for mutation rate and mutational target size + counts_modelled *= sfs_neut.theta * sfs_sel.n_sites + + # add contribution of demography and adjust polarization error + counts_modelled = cls._add_demography(sfs_neut, counts_modelled, eps=params['eps']) + + # fold if necessary + if folded: + counts_observed = sfs_sel.fold().polymorphic + counts_modelled = Spectrum.from_polymorphic(counts_modelled).fold().polymorphic + else: + counts_observed = sfs_sel.polymorphic + + return counts_modelled, counts_observed + + @staticmethod + def _adjust_polarization(counts: np.ndarray, eps: float) -> np.ndarray: + """""" + Adjust the polarization of the given SFS where + eps is the rate of ancestral misidentification. + + :param counts: Polymorphic SFS counts to adjust. + :param eps: Rate of ancestral misidentification. + :return: Adjusted SFS counts. + """""" + return (1 - eps) * counts + eps * counts[::-1] + + @classmethod + def _add_demography( + cls, + sfs_neut: Spectrum, + counts_sel: np.ndarray, + eps: float + ) -> np.ndarray: + """""" + Add the effect of demography to counts_sel by considering + how counts_neut is perturbed relative to the standard coalescent. + The polarization error is also included here. + + :param sfs_neut: Observed spectrum of neutral sites. + :param counts_sel: Modelled counts of selected sites. + :param eps: Rate of ancestral misidentification. + :return: Adjusted counts of selected sites. + """""" + # normalized counts of the standard coalescent + neutral_modelled = standard_kingman(sfs_neut.n).polymorphic * sfs_neut.theta * sfs_neut.n_sites + + # Apply polarization error to neutral and selected counts. + # Note that we fail to adjust for polarization if we were to + # apply the error to both the selected and neutral modelled counts. + # In addition, note that eps is not easily interpretable, + # as we apply it to both neutral and selected counts, which + # is of course necessary. Testing this on sample datasets + # yields very reasonable results, compatible with polyDFE. + neutral_observed = cls._adjust_polarization(sfs_neut.polymorphic, eps) + selected_modelled = cls._adjust_polarization(counts_sel, eps) + + # These counts transform the standard Kingman case to the observed + # neutral SFS when multiplied and thus account for demography as we assume + # the distortion in sfs_neut to be due to demography alone. + # Note that the nuisance parameters naturally are sensitive to a large + # sampling variance in the neutral SFS. + # However, DFE inference on `wiggly` spectra is not advisable anyway. + r = neutral_observed / neutral_modelled + + # adjust for demography and polarization error + return r * selected_modelled + + @_run_if_required_wrapper + def plot_continuous( + self, + file: str = None, + show: bool = True, + intervals: np.ndarray = None, + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + scale_density: bool = False, + scale: Literal['lin', 'log', 'symlog'] = 'lin', + title: str = 'DFE', + kwargs_legend: dict = dict(prop=dict(size=8)), + ax: 'plt.Axes' = None + + ) -> 'plt.Axes': + """""" + Plot continuous DFE. + The special constants np.inf and -np.inf are also valid interval bounds. + By default, the PDF is plotted as is. Due to the logarithmic scale on + the x-axis, we may get a wrong intuition on how the mass is distributed, + however. To get a better intuition, we can optionally scale the density + by the x-axis interval size using ``scale_density = True``. This has the + disadvantage that the density now changes for x, so that even a constant + density will look warped. + + :param title: Plot title. + :param bootstrap_type: Type of bootstrap to use for confidence intervals. + :param ci_level: Confidence level for confidence intervals. + :param confidence_intervals: Whether to plot confidence intervals. + :param file: File to save plot to. + :param show: Whether to show plot. + :param scale: y-scale + :param scale_density: Whether to scale the density by the x-axis interval size + :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :param ax: Axes to plot on. Only for Python visualization backend. + :return: Axes object + """""" + if intervals is None: + intervals = self.discretization.bins + + return Inference.plot_continuous( + inferences=[self], + file=file, + show=show, + intervals=intervals, + confidence_intervals=confidence_intervals, + ci_level=ci_level, + bootstrap_type=bootstrap_type, + title=title, + scale=scale, + scale_density=scale_density, + kwargs_legend=kwargs_legend, + ax=ax + ) + + @_run_if_required_wrapper + def plot_bucket_sizes( + self, + file: str = None, + show: bool = True, + title: str = 'bucket sizes', + ax: 'plt.Axes' = None + + ) -> 'plt.Axes': + """""" + Plot mass in each bucket for the MLE DFE. + This can be used to check if the interval bounds and spacing + are chosen appropriately. + + :param file: File to save plot to. + :param show: Whether to show plot. + :param title: Plot title. + :param ax: Axes to plot on. Only for Python visualization backend. + :return: Axes object + """""" + from .visualization import Visualization + + # evaluate at fixed parameters + sizes = self.model._discretize(self.params_mle, self.discretization.bins) + + return Visualization.plot_buckets_sizes( + n_intervals=self.discretization.n_intervals, + bins=self.discretization.bins, + sizes=sizes, + title=title, + file=file, + show=show, + ax=ax + ) + + @_run_if_required_wrapper + def plot_interval_density( + self, + file: str = None, + show: bool = True, + intervals: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + interval_labels: List[str] = None, + color: str = 'C0', + ax: 'plt.Axes' = None + ) -> 'plt.Axes': + """""" + Plot density of the discretization intervals chosen. Note that although this plot looks similar, this is + not the DFE! + + :param color: Color of the bars. + :param file: File to save plot to. + :param show: Whether to show plot. + :param interval_labels: Labels for the intervals. + :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. + :param ax: Axes to plot on. Only for Python visualization backend. + :return: Axes object + """""" + from .visualization import Visualization + + # issue warning + if not self.discretization.linearized: + self._logger.warning('Note that the interval density is not important if the DFE was not linearized.') + + return Visualization.plot_interval_density( + density=self.discretization.get_interval_density(intervals), + file=file, + show=show, + intervals=intervals, + interval_labels=interval_labels, + color=color, + ax=ax + ) + + def plot_sfs_comparison( + self, + sfs_types: List[Literal['modelled', 'observed', 'selected', 'neutral']] = ['observed', 'modelled'], + labels: List[str] = None, + colors: List[str] = None, + file: str = None, + show: bool = True, + ax: 'plt.Axes' = None, + title: str = 'SFS comparison', + use_subplots: bool = False, + show_monomorphic: bool = False, + kwargs_legend: dict = dict(prop=dict(size=8)), + ) -> 'plt.Axes': + """""" + Plot SFS comparison. + + :param file: File to save plot to. + :param labels: Labels for the SFS. + :param colors: Colors for the SFS. Only for Python visualization backend. + :param sfs_types: Types of SFS to plot. + :param show: Whether to show plot. + :param ax: Axes to plot on. Only for Python visualization backend and if ``use_subplots`` is ``False``. + :param title: Plot title + :param use_subplots: Whether to use subplots. Only for Python visualization backend. + :param show_monomorphic: Whether to show monomorphic counts + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :return: Axes object + """""" + from .visualization import Visualization + + if 'modelled' in sfs_types: + self.run_if_required() + + mapping = dict( + observed=self.sfs_sel, + selected=self.sfs_sel, + modelled=self.sfs_mle, + neutral=self.sfs_neut + ) + + return Visualization.plot_spectra( + spectra=[list(mapping[t]) for t in sfs_types], + labels=sfs_types if labels is None else labels, + colors=colors, + file=file, + show=show, + ax=ax, + title=title, + use_subplots=use_subplots, + show_monomorphic=show_monomorphic, + kwargs_legend=kwargs_legend + ) + + def plot_observed_sfs( + self, + labels: List[str] = None, + file: str = None, + show: bool = True, + ax: 'plt.Axes' = None + ) -> 'plt.Axes': + """""" + Plot neutral and selected SFS. + + :param file: File to save plot to. + :param labels: Labels for the SFS. + :param show: Whether to show plot. + :param ax: Axes to plot on. Only for Python visualization backend. + :return: Axes object + """""" + return self.plot_sfs_comparison( + sfs_types=['neutral', 'selected'], + labels=labels, + file=file, + show=show, + ax=ax + ) + + @_run_if_required_wrapper + def plot_all(self, show: bool = True): + """""" + Plot a bunch of plots. + + :param show: Whether to show plot. + """""" + self.plot_inferred_parameters(show=show) + self.plot_discretized(show=show) + self.plot_sfs_comparison(show=show) + self.plot_continuous(show=show) + self.plot_interval_density(show=show) + self.plot_likelihoods(show=show) + + def get_stats_discretized( + self, + ci_level: float = 0.05, + intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean' + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]: + """""" + Get statistics for the discretized DFE. + + :param ci_level: Confidence interval level. + :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. + :param bootstrap_type: Type of bootstrap to use. + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :return: Center values, errors around center, and confidence intervals. + """""" + return Inference.get_stats_discretized( + params=self.params_mle, + bootstraps=self.bootstraps, + model=self.model, + ci_level=ci_level, + intervals=intervals, + bootstrap_type=bootstrap_type, + point_estimate=point_estimate + ) + + @_run_if_required_wrapper + def plot_inferred_parameters( + self, + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + file: str = None, + show: bool = True, + title: str = 'parameter estimates', + scale: Literal['lin', 'log', 'symlog'] = 'log', + ax: 'plt.Axes' = None, + kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right'), + **kwargs + ) -> 'plt.Axes': + """""" + Visualize the inferred parameters and their confidence intervals. + + :param scale: y-scale of the plot. + :param title: Plot title. + :param confidence_intervals: Whether to show confidence intervals. + :param bootstrap_type: Type of bootstrap to use. + :param ci_level: Confidence level for the confidence intervals. + :param file: File to save plot to. + :param show: Whether to show plot. + :param ax: Axes to plot on. Only for Python visualization backend. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :return: Axes object + """""" + return Inference.plot_inferred_parameters( + inferences=[self], + labels=['all'], + file=file, + show=show, + title=title, + ci_level=ci_level, + confidence_intervals=confidence_intervals, + bootstrap_type=bootstrap_type, + scale=scale, + ax=ax, + kwargs_legend=kwargs_legend, + ) + + @_run_if_required_wrapper + def plot_inferred_parameters_boxplot( + self, + file: str = None, + show: bool = True, + title: str = 'parameter estimates', + **kwargs + ) -> 'plt.Axes': + """""" + Visualize the inferred parameters and their confidence intervals. + + :param title: Plot title. + :param file: File to save plot to. + :param show: Whether to show plot. + :return: Axes object + :raises ValueError: If no inference objects are given or no bootstraps are found. + """""" + return Inference.plot_inferred_parameters_boxplot( + inferences=[self], + labels=['all'], + file=file, + show=show, + title=title + ) + + @_run_if_required_wrapper + def plot_likelihoods( + self, + file: str = None, + show: bool = True, + title: str = 'likelihoods', + scale: Literal['lin', 'log'] = 'lin', + ax: 'plt.Axes' = None, + ylabel: str = 'lnl', + **kwargs + ) -> 'plt.Axes': + """""" + Visualize the likelihoods of the optimization runs using a scatter plot. + + :param scale: y-scale of the plot. + :param title: Plot title. + :param file: File to save plot to. + :param show: Whether to show plot. + :param ax: Axes to plot on. Only for Python visualization backend. + :param ylabel: Label for the y-axis. + :return: Axes object + """""" + from .visualization import Visualization + + return Visualization.plot_scatter( + values=self.likelihoods, + file=file, + show=show, + title=title, + scale=scale, + ax=ax, + ylabel=ylabel, + ) + + def _lrt_components( + self, + ll_simple: float, + ll_complex: float, + df: int, + m: int = 0 + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """""" + Perform a likelihood ratio test (LRT) with correction for boundary constraints as described in + Molenberghs et Verbeke (2007) (https://doi.org/10.2307/1403361). + + :param ll_simple: Log-likelihood of the simple model. + :param ll_complex: Log-likelihood of the complex model. + :param df: Total number of parameters being tested. + :param m: Number of parameters at the boundary. + :return: Weights and components (p-values), and degrees of freedom. + :raises ValueError: If the number of parameters at the boundary exceeds the total number of parameters. + """""" + if m > df: + raise ValueError('Number of parameters at the boundary exceeds total number of parameters.') + + lr = -2 * (ll_simple - ll_complex) + + # Issue info message + self._logger.info(f""Simple model likelihood: {ll_simple}, "" + f""Complex model likelihood: {ll_complex}, "" + f""Total degrees of freedom: {df}, "" + f""Parameters at boundary: {m}."") + + # compute mixture weights + weights = np.array([comb(m, j - (df - m)) / (2 ** m) for j in range(df - m, df + 1)]) + + # zero degrees of freedom is point mass at 0 + components = np.array([(0 if j == 0 else chi2.sf(lr, j)) for j in range(df - m, df + 1)]) + df = np.array([j for j in range(df - m, df + 1)]) + + self._logger.debug( + "" + "".join([f""{weight} * {component:.3f}"" for weight, component in zip(weights, components)]) + ) + + return weights, components, df + + def lrt(self, ll_simple: float, ll_complex: float, df: int, m: int = 0) -> float: + """""" + Perform a likelihood ratio test (LRT) with correction for boundary constraints as described in + Molenberghs et Verbeke (2007) (https://doi.org/10.2307/1403361). + + :param ll_simple: Log-likelihood of the simple model. + :param ll_complex: Log-likelihood of the complex model. + :param df: Total number of parameters being tested. + :param m: Number of parameters at the boundary. + :return: p-value + """""" + weights, components, _ = self._lrt_components(ll_simple, ll_complex, df, m) + + return np.sum(weights * components) + + def _is_nested(self, complex: 'BaseInference') -> bool: + """""" + Check if the given model is nested within the current model. + The given model's fixed parameters need to be a proper subset of this model's fixed parameters. + + :param complex: More complex model. + :return: Whether the models are nested. + """""" + if type(self.model) != type(complex.model): + return False + + # optimization holds the flattened dictionary + fixed_complex = set(complex.optimization.fixed_params.keys()) + fixed_simple = set(self.optimization.fixed_params.keys()) + + return fixed_complex < fixed_simple + + def _get_df_nested(self, complex: 'BaseInference') -> Tuple[int, int]: + """""" + Get the degrees of freedom for the likelihood ratio test. + + :param complex: More complex model. + :return: Degrees of freedom and number of parameters at bounds. + :raises ValueError: If the models are not nested. + """""" + if type(self.model) != type(complex.model): + raise ValueError(f'DFE parametrizations are not the same: {type(self.model)} vs. {type(complex.model)}.') + + if not self._is_nested(complex): + raise ValueError('Models are not nested.') + + # optimization holds the flattened dictionary + fixed_complex = set(complex.optimization.fixed_params.keys()) + fixed_simple = set(self.optimization.fixed_params.keys()) + + # fixed parameters + fixed = fixed_simple - fixed_complex + fixed_params = self.optimization.fixed_params + + # parameter bounds + bounds = self.optimization.bounds + + # number of parameters at bounds + m = sum([fixed_params[p] == bounds[p.split('.')[1]][0] or + fixed_params[p] == bounds[p.split('.')[1]][1] for p in fixed]) + + # degrees of freedom + df = len(fixed) + + return df, m + + def compare_nested(self, complex: 'BaseInference') -> float | None: + """""" + Perform likelihood ratio test with given more complex model. + The given model's fixed parameters need to be a proper + subset of this model's fixed parameters. + Low p-values indicate that the more complex model provides a significantly better fit. + + :param complex: More complex model. + :return: p-value or None if the models are not nested. + :raises ValueError: If the inference objects are not nested. + """""" + df, m = self._get_df_nested(complex) + + # run inference if not done yet + self.run_if_required() + complex.run_if_required() + + return self.lrt(self.likelihood, complex.likelihood, df, m) + + @_run_if_required_wrapper + @functools.lru_cache + def compare_nested_models(self, do_bootstrap: bool = False) -> Tuple[np.ndarray, Dict[str, 'BaseInference']]: + """""" + Compare the various nested versions of the specified + model using likelihood ratio tests. We check for inclusion of ancestral misidentification + and beneficial mutations. + + :param do_bootstrap: Whether to perform bootstrapping. + :return: Matrix of p-values, dict of base inference objects + """""" + + # get sub-model specifications + submodels_dfe = _from_string(self.model).submodels + submodels_outer = dict( + no_anc=dict(eps=0), + anc={} + ) + if 'all' in self.fixed_params and 'h' in self.fixed_params['all']: + submodels_h = dict(h=self.fixed_params['all']['h']) + else: + submodels_h = {} + + # take outer product to get fixed parameters for each model + inferences: Dict[str, BaseInference] = {} + for p in itertools.product(submodels_dfe.keys(), submodels_outer.keys()): + # create deep copy of object + inference = copy.deepcopy(self) + + # carry over bootstrap setting + inference.do_bootstrap = do_bootstrap + + # dict of params to be fixed + params = dict(all=submodels_dfe[p[0]] | submodels_outer[p[1]] | submodels_h) + + # assign fixed parameters + inference._set_fixed_params(params) + + # inform about fixed parameters + self._logger.info(f'Holding parameters fixed to {params}.') + + # run inference + inference.run() + + # define name + name = '.'.join(p).rstrip('_') + + # save to dict + inferences[name] = inference + + # number of models + n = len(inferences) + + # create input matrix + inputs = list(itertools.product(inferences.items(), inferences.items())) + + # create likelihood ratio matrix + P = [] + for i in inputs: + try: + P.append(i[0][1].compare_nested(i[1][1])) + except ValueError: + P.append(None) + + P = np.reshape(P, (n, n)) + + return P, inferences + + def plot_nested_models( + self, + file: str = None, + show: bool = True, + remove_empty: bool = False, + transpose: bool = False, + cmap: str = None, + title: str = 'nested model comparison', + ax: 'plt.Axes' = None, + do_bootstrap: bool = False, + ) -> 'plt.Axes': + """""" + Plot the p-values of nested likelihoods. + + :param file: File to save plot to. + :param show: Whether to show plot. + :param remove_empty: Whether to remove empty rows and columns. + :param transpose: Whether to transpose the matrix. + :param cmap: Colormap to use. + :param title: Plot title. + :param ax: Axes to plot on. Only for Python visualization backend. + :param do_bootstrap: Whether to perform bootstrapping. + :return: Axes object + """""" + from .visualization import Visualization + + # get p-values and names + P, inferences = self.compare_nested_models(do_bootstrap=do_bootstrap) + + # define labels + labels_x = np.array(list(inferences.keys())) + labels_y = np.array(list(inferences.keys())) + + if remove_empty: + # remove empty columns + nonempty_cols = np.sum(~np.equal(P, None), axis=0) != 0 + P = P[:, nonempty_cols] + labels_x = labels_x[nonempty_cols] + + # remove empty rows + nonempty_rows = np.sum(~np.equal(P, None), axis=1) != 0 + P = P[nonempty_rows] + labels_y = labels_y[nonempty_rows] + + # take transpose if specified + if transpose: + P = P.T + labels_x, labels_y = labels_y, labels_x + + return Visualization.plot_nested_models( + P=P, + labels_x=labels_x, + labels_y=labels_y, + file=file, + show=show, + cmap=cmap, + title=title, + ax=ax + ) + + @functools.wraps(AbstractInference.plot_discretized) + @_run_if_required_wrapper + def plot_discretized(self, *args, **kwargs): + return super().plot_discretized(*args, **kwargs) + + def get_dfe(self) -> DFE: + """""" + Return a frozen DFE object containing the inferred parameters and (if available) the bootstrap samples. + + :return: DFE object + """""" + # ensure inference is run + self.run_if_required() + + return DFE( + model=self.model, + params=self.params_mle, + bootstraps=self.bootstraps + ) + + def get_spectra(self) -> Spectra: + """""" + Return a Spectra object containing the neutral, selected and modelled SFS. + + :return: Spectra object with types ``neutral``, ``selected``, and ``modelled``. + """""" + return Spectra.from_spectra(dict( + neutral=self.sfs_neut, + selected=self.sfs_sel, + modelled=self.sfs_mle + )) + + def get_alpha(self, params: dict = None) -> float: + """""" + Get alpha, the proportion of beneficial non-synonymous substitutions. + + :param params: DFE Parameters to use for calculation. + """""" + if params is None: + params = self.params_mle + + return self.discretization.get_alpha(self.model, params) + + @functools.cached_property + def alpha(self) -> float: + """""" + Cache alpha, the proportion of beneficial non-synonymous substitutions. + """""" + return self.get_alpha() + + def get_bootstrap_params(self) -> Dict[str, float]: + """""" + Get the parameters to be included in the bootstraps. + + :return: Parameters to be included in the bootstraps. + """""" + return self.params_mle | dict(alpha=self.alpha) + + def get_bootstrap_param_names(self) -> List[str]: + """""" + Get the parameters to be included in the bootstraps. + + :return: Parameters to be included in the bootstraps. + """""" + return list(self.get_bootstrap_params().keys()) + + def get_optimized_param_names(self) -> List[str]: + """""" + Get the parameters names for the parameters that are optimized. + + :return: List of parameter names. + """""" + return list(set(flatten_dict(self.get_x0())) - set(flatten_dict(self.fixed_params))) + + def get_n_optimized(self) -> int: + """""" + Get the number of parameters that are optimized. + + :return: Number of parameters that are optimized. + """""" + return len(self.get_optimized_param_names()) + + def create_config(self) -> 'Config': + """""" + Create a config object from the inference object. + + :return: Config object. + """""" + + return Config( + sfs_neut=Spectra.from_spectrum(self.sfs_neut), + sfs_sel=Spectra.from_spectrum(self.sfs_sel), + intervals_ben=self.discretization.intervals_ben, + intervals_del=self.discretization.intervals_del, + integration_mode=self.discretization.integration_mode, + linearized=self.discretization.linearized, + model=self.model.__class__.__name__, + seed=self.seed, + x0=self.x0, + bounds=self.bounds, + scales=self.scales, + loss_type=self.optimization.loss_type, + opts_mle=self.optimization.opts_mle, + method_mle=self.optimization.method_mle, + n_runs=self.n_runs, + fixed_params=self.fixed_params, + do_bootstrap=self.do_bootstrap, + n_bootstraps=self.n_bootstraps, + parallelize=self.parallelize + ) + + @classmethod + def from_config(cls, config: 'Config') -> Self: + """""" + Load from config object. + + :param config: Config object. + :return: Inference object. + """""" + return cls(**config.data) + + @classmethod + def from_config_file(cls, file: str, cache: bool = True) -> Self: + """""" + Load from config file. + + :param file: Config file path, possibly URL. + :param cache: Whether to use the cache if available. + :return: Inference object. + """""" + from . import Config + + return cls.from_config(Config.from_file(file, cache=cache)) + + def get_summary(self) -> 'InferenceResult': + """""" + Get summary. + + :return: Inference results. + """""" + return InferenceResult(self) + + def get_x0(self) -> Dict[str, Dict[str, float]]: + """""" + Get initial values. + + :return: Initial values. + """""" + # filter by parameter names + return dict(all=dict((p, self.x0['all'][p]) for p in self.optimization.param_names)) + + @property + def param_names(self) -> List[str]: + """""" + Parameter names. + + :return: List of parameter names. + """""" + return self.model.param_names + ['eps', 'h'] + + def _set_fixed_params(self, params: Dict[str, Dict[str, float]]): + """""" + Set fixed parameters. + + :param params: Fixed parameters. + """""" + self.fixed_params = expand_fixed(params, ['all']) + + self.optimization.set_fixed_params(self.fixed_params) + + def to_json(self) -> str: + """""" + Serialize object. + + :return: JSON string + """""" + # using make_ref=True resulted in weird behaviour when unserializing. + return jsonpickle.encode(self, indent=4, warn=True, make_refs=False) + + +class InferenceResult(Serializable): + """""" + Inference result. + """""" + + def __init__(self, inference: BaseInference): + """""" + Initialize object. + + :param inference: Inference object. + """""" + #: Configuration of the inference + self.config: 'Config' = inference.create_config() + + #: Inferred DFE + self.dfe: DFE = inference.get_dfe() + + #: Spectra + self.spectra: Spectra = inference.get_spectra() + + #: Bootstrap samples + self.bootstraps: pd.DataFrame = inference.bootstraps + + #: Optimization runs + self.runs: pd.DataFrame = inference.runs +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/discretization.py",".py","33394","909",""""""" +Discretization of DFE to SFS transformation. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import logging +from functools import wraps +from itertools import product +from math import comb +from typing import Literal, Sequence, Tuple, Optional, Callable + +import mpmath as mp +import numpy as np +from scipy.integrate import quad + +from .optimization import parallelize as parallelize_func +from .parametrization import Parametrization + +# configure logger +logger = logging.getLogger('fastdfe').getChild('Discretization') + + +def to_float(func): + """""" + Decorator to convert the return value of a function to float. + + :param func: Function to be decorated + :return: Wrapper function + """""" + + @wraps(func) + def wrapper(*args, **kwargs) -> float | np.ndarray: + """""" + Wrapper function. + + :param args: Positional arguments + :param kwargs: Keyword arguments + :return: Converted result + """""" + result = func(*args, **kwargs) + + if isinstance(result, np.ndarray): + return result.astype(float) + else: + return float(result) + + return wrapper + + +class Discretization: + """""" + Class for discretizing the integral mapping the DFE to the expected SFS. + """""" + + #: Mapped dominance coefficient, static to ensure backward compatibility + h_mapped: float = np.array([0.5]) + + #: Parameter h mapping dominance coefficients if not varying, static to ensure backward compatibility + h: Optional[float] = 0.5 + + #: Dominance coefficient callback, static to ensure backward compatibility + h_callback: Callable[[float, np.ndarray], np.ndarray] = None + + def __init__( + self, + n: int, + h: Optional[float] = 0.5, + h_callback: Callable[[float, np.ndarray], np.ndarray] = lambda h, S: np.full_like(S, h), + intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), + intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), + intervals_h: Tuple[float, float, int] = (0.0, 1.0, 21), + n_outer: int = 1000, + n_inner: int = 200, + s_chunk_size: int = 10, + integration_mode: Literal['midpoint', 'quad'] = 'midpoint', + linearized: bool = True, + parallelize: bool = True, + ): + """""" + Create Discretization instance. + + :param n: Number of individuals in the SFS sample. + :param h: Parameter h mapping dominance coefficients if not varying, else ``None``. When ``None``, dominance + coefficients are precomputed across ``intervals_h`` and interpolated as needed. Otherwise, only the fixed + value is precomputed. + :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled + selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` + provides nearly identical results while increasing speed, especially when precomputing across dominance + coefficients. + :param intervals_ben: ``(start, stop, n_interval)`` for beneficial population-scaled + selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` + provides nearly identical results while increasing speed, especially when precomputing across dominance + coefficients. + :param intervals_h: ``(start, stop, n_interval)`` for dominance coefficients which are linearly spaced. + This is only used when inferring dominance coefficients. Values of ``h`` between the edges will be + interpolated linearly. + :param n_outer: Number of grid points for outer integrals when computing allele counts for varying + dominance coefficients. + :param n_inner: Number of grid points for inner integrals when computing allele counts for varying + dominance coefficients. + :param s_chunk_size: Chunk size for S values when precomputing across dominance coefficients. + This controls memory usage vs. speed trade-off. + :param integration_mode : 'midpoint' or 'quad' for midpoint integration or Scipy's quad method. + :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use + `scipy.integrate.quad` in each call. + :param parallelize: Whether to parallelize the computation of the discretization. + """""" + # make sure lower bounds are lower than upper bounds + if not intervals_del[0] < intervals_del[1] or not intervals_ben[0] < intervals_ben[1]: + raise Exception('Lower intervals bounds must be lower than upper bounds.') + + # make sure |S| is not too large + if intervals_del[0] < -1e10 or intervals_ben[1] > 1e10: + raise Exception('Bounds for S should within the interval [-1e10, 1e10] to avoid ' + 'unexpected numerical behavior.') + + #: SFS sample size + self.n: int = int(n) + + #: Parameter h mapping dominance coefficients if not varying + self.h: float = h + + #: Dominance coefficient callback + self.h_callback: Callable[[float, np.ndarray], np.ndarray] = h_callback + + # interval bounds for discretizing DFE + self.intervals_del: Tuple[float, float, int] = intervals_del + self.intervals_ben: Tuple[float, float, int] = intervals_ben + + # interval bounds for discretizing dominance coefficients + self.intervals_h: Tuple[float, float, int] = intervals_h + + # grid sizes for integrals when computing allele counts for varying dominance coefficients + self.n_outer: int = n_outer + self.n_inner: int = n_inner + + # chunk size for S values when precomputing across dominance coefficients + self.s_chunk_size: int = s_chunk_size + + self.integration_mode: Literal['midpoint', 'quad'] = integration_mode + self.linearized: bool = linearized + self.parallelize: bool = parallelize + + # define bins, midpoints and step size + # these intervals are used when linearizing the integral + # and when plotting the DFE + self.bins: np.ndarray = self.get_bins(intervals_del, intervals_ben) + self.s, self.interval_sizes = self.get_midpoints_and_spacing(self.bins) + + if h is None: + self.h_mapped: Optional[np.ndarray] = None + + #: Grid over which to precompute dominance coefficients. Either fixed or varying. + self.grid_h: Optional[np.ndarray] = np.linspace(intervals_h[0], intervals_h[1], int(intervals_h[2])) + else: + #: Mapped dominance coefficients if ``h`` is not ``None``. + self.h_mapped: Optional[np.ndarray] = self.map_h(h, self.bins) + + self.grid_h: Optional[np.ndarray] = None + + # the number of intervals + self.n_intervals: int = self.s.shape[0] + + # cache for DFE to SFS transformations of shape (n, len(grid_h), n_intervals) + self._cache: np.ndarray = None + + @staticmethod + def default_h_callback(h: float, S: np.ndarray) -> np.ndarray: + """""" + Default callback for mapping dominance coefficients. + + :param h: Dominance coefficient + :param S: Population-scaled selection coefficients + :return: Mapped dominance coefficients + """""" + return np.full_like(S, h) + + @staticmethod + def exp(x: float | np.ndarray) -> float | np.ndarray: + """""" + Vectorized version of mpmath's exp function. + + :param x: Exponent + :return: Result + """""" + return np.vectorize(mp.exp)(x) + + @staticmethod + def hyp1f1(a: float | np.ndarray, b: float | np.ndarray, z: float | np.ndarray) -> float | np.ndarray: + """""" + Vectorized version of mpmath's hyp1f1 function. + + :param a: First parameter + :param b: Second parameter + :param z: Third parameter + :return: Result + """""" + return np.vectorize(mp.hyp1f1)(a, b, z) + + @staticmethod + def get_midpoints_and_spacing(bins: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: + """""" + Obtain midpoints and spacing for the given bins. + + :param bins: Array of bins + :return: Midpoints, spacing + """""" + # obtain midpoints + s = (bins[1:] + bins[:-1]) / 2 + interval_sizes = bins[1:] - bins[:-1] + + return s, interval_sizes + + @staticmethod + def get_bins(intervals_del: tuple, intervals_ben: tuple) -> np.ndarray: + """""" + Get bins using log-spaced distances for positive and negative + values of S given by ``intervals_ben`` and ``intervals_del``, respectively. + + :param intervals_del: ``(min, max, n)`` for negative values of S where we use log-spaced distances + :param intervals_ben: ``(min, max, n)`` for positive values of S where we use log-spaced distances + :return: Bins + """""" + bins_del = -np.logspace( + np.log10(np.abs(intervals_del[0])), + np.log10(np.abs(intervals_del[1])), + int(intervals_del[2]) + 1 + ) + + bins_ben = np.logspace( + np.log10(intervals_ben[0]), + np.log10(intervals_ben[1]), + int(intervals_ben[2]) + 1 + ) + + return np.concatenate([bins_del, bins_ben]) + + @staticmethod + def get_counts_high_precision(x, S): + """""" + Allele frequency sojourn times semidominance using high-precision arithmetic which is not supported + on all platforms. + + :param S: Selection coefficient + :param x: Allele frequency + :return: Allele frequency sojourn time + """""" + return ((1 - np.exp(-S * (1 - x), dtype=np.float128)) / + (x * (1 - x) * (1 - np.exp(-S, dtype=np.float128)))).astype(float) + + @staticmethod + def get_counts_high_precision_regularized(x, S: float | int | np.ndarray): + """""" + As H(x, S) but replacing with the limits close to the limit points. + Note that this function is not used in practice. + + :param x: Allele frequency + :param S: Selection coefficient + :return: Allele frequency sojourn time + """""" + # make it accept scalars + if isinstance(S, (float, int)): + return Discretization.get_counts_high_precision_regularized(x, np.array([S]))[0] + + # else S is an array + y = np.zeros_like(S, dtype=np.float128) + + # S close to zero + close_to_zero = np.abs(S) < 1e-8 + + # limit (1 - exp(-S * (1 - x))) / (x * (1 - x) * (1 - exp(-S))) as S -> 0 + # cf. https://www.wolframalpha.com/input?i=limit+%281+-+exp%28-S+*+%281+-+x%29%29%29+%2F+% + # 28x+*+%281+-+x%29+*+%281+-+exp%28-S%29%29%29+as+S+-%3E+0 + y[close_to_zero] = 1 / x + + # evaluate function as usual + y[~close_to_zero] = Discretization.get_counts_high_precision(x, S[~close_to_zero]) + + return y + + @staticmethod + def get_counts_fixed_semidominant(S: float | int | np.ndarray) -> float | int | np.ndarray: + """""" + The sojourn time as x -> 1 for semidominance. + + :param S: Selection coefficient + :return: Sojourn time as x -> 1 + """""" + return S / (1 - np.exp(-S)) + + @staticmethod + def get_counts_fixed_semidominant_regularized(S: float | int | np.ndarray) -> float | int | np.ndarray: + """""" + As :func:`H_fixed` but replacing with the limits close to the limit points. + + :param S: Selection coefficient + :return: Sojourn time as x -> 1 + """""" + # make it accept scalars + if isinstance(S, (float, int)): + return Discretization.get_counts_fixed_semidominant(np.array([S]))[0] + + # else S is an array + y = np.zeros_like(S) + + # S close to zero + close_to_zero = np.abs(S) < 1e-8 + + # limit as S -> 0 + y[close_to_zero] = 1 + + # avoid overflow for very low S + very_negative = S < -500 + + # for very low S we are close to 0 + y[very_negative] = 0 + + # remaining values + remaining = ~(close_to_zero | very_negative) + + # evaluate as usual + y[remaining] = Discretization.get_counts_fixed_semidominant(S[remaining]) + + return y + + @staticmethod + def get_counts_fixed_dominant( + S: np.ndarray, + h: np.ndarray, + n_bins: int = 1000, + pow_cluster: int = 4 + ) -> np.ndarray: + """""" + Allele frequency sojourn times under selection with specific dominance coefficients + + :param S: Selection coefficients. + :param h: Dominance coefficients associated with selection coefficients or single dominance coefficient. + :param n_bins: Number of grid points for integral over allele frequencies. + :param pow_cluster: Power for clustering grid points towards 0. + :return: Array of shape (len(S),) with sojourn times as x -> 1. + """""" + h = np.full_like(S, h) if np.isscalar(h) else np.asarray(h) + S = np.asarray(S) + + x = np.linspace(0, 1, n_bins) ** pow_cluster # (n_bins,) + + H2 = h[:, None] # (P, 1) + S2 = S[:, None] # (P, 1) + xx = x[None, :] # (1, n_bins) + + exponent = -2 * S2 * H2 * xx - S2 * (1 - 2 * H2) * xx ** 2 # (P, n_bins) + + # stable exponentiation + m = np.max(exponent, axis=1, keepdims=True) + integrand = np.exp(exponent - m) # (P, n_bins) + + Z = np.trapz(integrand, x, axis=1) + + return np.exp(-m[:, 0]) / Z + + def get_counts_fixed(self, h: float) -> np.ndarray: + """""" + Get sojourn times as x -> 1 for fixed dominance coefficient. + + :param h: Parameter h mapping dominance coefficients + :return: Sojourn times as x -> 1 + """""" + hs = self.map_h(h, self.s) + + return self.get_counts_fixed_dominant(self.s, hs) + + @staticmethod + def _get_counts_dominant( + n: int, + k: int, + h: float | np.ndarray, + S: np.ndarray, + n_outer: int = 1000, + n_inner: int = 200, + pow_cluster: int = 4 + ): + """""" + Allele frequency sojourn times under selection with specific dominance coefficients. + + :param n: Sample size. + :param k: Allele count. + :param h: Dominance coefficients associated with selection coefficients or single dominance coefficient. + :param S: Selection coefficients. + :param n_outer: Grid size for outer integral over allele frequencies for binomial sampling. + :param n_inner: Grid size for inner integrals over allele frequencies. + :param pow_cluster: Power for clustering grid points towards 0. + + :return: Array of shape (len(S),) with allele counts. + """""" + h = np.full_like(S, h) if np.isscalar(h) else np.asarray(h) + S = np.asarray(S) + + # x-grid + x = np.linspace(0, 1, n_outer) ** pow_cluster # (n_outer,) + + # binomial term + binom = comb(n, k) * x ** (k - 1) * (1 - x) ** (n - k - 1) # (n_outer,) + + # result array + y = np.empty(S.size, dtype=float) # (P,) + + is_deleterious = S <= 0 + if is_deleterious.any(): + S_neg = S[is_deleterious] # (P1,) + h_neg = h[is_deleterious] # (P1,) + p1 = S_neg.size + + t = np.linspace(0, 1, n_inner) # (n_inner,) + + # q-grid from x to 1 + xx = x[:, None, None] + (1 - x)[:, None, None] * t[None, None, :] + xx = np.broadcast_to(xx, (n_outer, p1, n_inner)) # (n_outer, P1, n_inner) + + H3 = h_neg[None, :, None] # (1, P1, 1) + SN3 = S_neg[None, :, None] # (1, P1, 1) + + exponent = -2 * SN3 * H3 * xx - SN3 * (1 - 2 * H3) * xx ** 2 # (n_outer, P1, n_inner) + + max_exp = exponent.max(axis=2, keepdims=True) # (n_outer, P1, 1) + + norm_q = np.trapz(np.exp(exponent - max_exp), xx, axis=2) # (n_outer, P1) + del exponent, xx + norm0 = norm_q[0] # (P1,) + + H2 = h_neg[None, :] # (1, P1) + SN2 = S_neg[None, :] # (1, P1) + + exponent_main = np.exp( + 2 * SN2 * H2 * x[:, None] + + SN2 * (1 - 2 * H2) * x[:, None] ** 2 + ) # (n_outer, P1) + + ratio = norm_q / norm0 # (n_outer, P1) + + integrand = binom[:, None] * exponent_main * ratio # (n_outer, P1) + + y[is_deleterious] = np.trapz(integrand, x, axis=0) # (P1,) + + if (~is_deleterious).any(): + S_pos = S[~is_deleterious] # (P2,) + h_pos = h[~is_deleterious] # (P2,) + p2 = S_pos.size + + xx0 = np.linspace(0, 1, n_inner) ** pow_cluster # (n_inner,) + + Hn = h_pos[:, None] # (P2, 1) + SPn = S_pos[:, None] # (P2, 1) + XX0 = xx0[None, :] # (1, n_inner) + + exponent0 = -2 * SPn * Hn * XX0 - SPn * (1 - 2 * Hn) * XX0 ** 2 # (P2, n_inner) + norm0 = np.trapz(np.exp(exponent0), xx0, axis=1) # (P2,) + + t = np.linspace(0, 1, n_inner) ** 5 # (n_inner,) + xx = x[:, None, None] + (1 - x)[:, None, None] * t[None, None, :] + xx = np.broadcast_to(xx, (n_outer, p2, n_inner)) # (n_outer, P2, n_inner) + + X = x[:, None, None] # (n_outer, 1, 1) + H3b = h_pos[None, :, None] # (1, P2, 1) + SP3b = S_pos[None, :, None] # (1, P2, 1) + + term = SP3b * (X - xx) * ((1 - 2 * H3b) * (X + xx) + 2 * H3b) # (n_outer, P2, n_inner) + c = np.trapz(np.exp(term), xx, axis=2) # (n_outer, P2) + del term, xx + + integrand = binom[:, None] * c / norm0[None, :] # (n_outer, P2) + + y[~is_deleterious] = np.trapz(integrand, x, axis=0) # (P2,) + + return y + + def map_h(self, h: float, S: np.ndarray) -> np.ndarray: + """""" + Map dominance coefficients using the default mapping. + + :param h: Dominance coefficient + :param S: Population-scaled selection coefficients + :return: Mapped dominance coefficients + """""" + if self.h_callback is not None: + return self.h_callback(h, S) + + return self.default_h_callback(h, S) + + def precompute(self, force: bool = False): + """""" + Precompute DFE to SFS transformation, possibly across dominance coefficients. + """""" + if (hasattr(self, '_cache') and self._cache is not None) and not force: + return + + h_mapped = np.unique(self.h_mapped) + + # compute special case h = 0.5 + if h_mapped.size == 1 and h_mapped[0] == 0.5: + self._cache = self.get_counts_semidominant()[:, None, :] + return + + if isinstance(self.h_mapped, np.ndarray) and np.unique(self.h_mapped).size == 1: + logger.info(f'Precomputing DFE-SFS transformation for fixed h={self.h_mapped[0]}.') + elif self.h is not None: + logger.info('Precomputing DFE-SFS transformation for fixed dominance coefficients.') + else: + logger.info( + f'Precomputing DFE-SFS transformation across dominance coefficients (grid size: {len(self.grid_h)}).' + ) + + self._cache = self.get_counts_dominant() + + def get_counts(self, h: float) -> np.ndarray: + """""" + Get DFE to SFS transformation for given dominance coefficient using precomputed values. + Interpolates linearly between precomputed values. + + :param h: Parameter h mapping dominance coefficients + :return: Matrix of size (n_intervals, n) + :raises ValueError: If ``h`` is outside precomputed range. + """""" + # check for attribute to ensure backwards compatibility + if not hasattr(self, ""_cache"") or self._cache is None: + self.precompute() + + # return single precomputed value if h is fixed + if self.h is not None: + + if h != self.h: + raise ValueError(f'Dominance coefficient {h} does not match precomputed value {self.h}.') + + return self._cache[:, 0, :] + + # get surrounding indices and weights + i, w = self.get_interpolation_weights(h) + j = np.arange(self.n_intervals) + + # linear interpolation between h values + interpolated = (1.0 - w) * self._cache[:, i - 1, j] + w * self._cache[:, i, j] + + return interpolated + + def get_interpolation_weights(self, h: float) -> Tuple[np.ndarray, np.ndarray]: + """""" + Get indices and weights for interpolating precomputed dominance coefficients across S. + + :param h: Parameter h mapping dominance coefficients + :return: Indices and weights + """""" + hs = self.map_h(h, self.s) + + # require h within precomputed range + if hs.min() < self.grid_h.min(): + raise ValueError(f'Dominance coefficient {hs.min()} smaller than precomputed minimum {self.grid_h.min()}.') + + if hs.max() > self.grid_h.max(): + raise ValueError(f'Dominance coefficient {hs.max()} larger than precomputed maximum {self.grid_h.max()}.') + + # find surrounding indices and weights + i = np.searchsorted(self.grid_h, hs) + h0, h1 = self.grid_h[i - 1], self.grid_h[i] + w = (hs - h0) / (h1 - h0) + + return i, w + + def get_counts_semidominant_midpoint(self) -> np.ndarray: + """""" + Precompute linearized integral using midpoint integration. + Consider parallelizing this. + + :return: Matrix of size (n_intervals, n) + """""" + logger.info('Precomputing semidominant DFE-SFS transformation using midpoint integration.') + + I = np.ones((self.n - 1, self.n_intervals + 1)) + + # we use midpoint integration + K = np.arange(1, self.n)[:, None] * I + S = self.bins[None, :] * I + + def compute_slice(i: int) -> np.ndarray: + """""" + Compute allele counts of a given multiplicity. + + :param i: Multiplicity + :return: Discretized counts + """""" + return self.get_counts_semidominant_regularized(S[i], K[i]) + + # retrieve allele counts + P = parallelize_func( + func=compute_slice, + data=np.arange(self.n - 1), + parallelize=self.parallelize, + desc=f""{self.__class__.__name__}>Precomputing"", + dtype=float + ) + + # take midpoint and multiply by interval size + return (P[:, :-1] + P[:, 1:]) / 2 * self.interval_sizes + + def get_counts_semidominant_quad(self) -> np.ndarray: + """""" + Precompute linearized integral using Scipy's quad method. + + :return: Matrix of size (n_intervals, n) + """""" + logger.info('Precomputing semidominant DFE-SFS transformation using scipy.integrate.quad.') + + # initialize matrix + P = np.zeros((self.bins.shape[0] - 1, self.n - 1)) + + # iterate over bins + for i in range(self.bins.shape[0] - 1): + + logger.debug(f""Processing interval {(self.bins[i], self.bins[i + 1])}."") + + # iterate over allele count classes + for j in range(self.n - 1): + P[i, j] = quad(lambda s: (self.get_counts_semidominant_regularized( + s, j + 1)), self.bins[i], self.bins[i + 1])[0] + + # For GammaExpParametrization, there is a discontinuity at 0 + # which can cause problems integrating it using quadrature. + # We remove this discontinuity here by taking the average value + # of the adjacent bins. + # Find bin that contains 0. + i_zero = np.where((self.bins[:-1] < 0) & (self.bins[1:] >= 0))[0][0] + + # take average of adjacent bins + P[i_zero] = (P[i_zero - 1] + P[i_zero + 1]) / 2 + + return P.T + + def get_counts_semidominant(self) -> np.ndarray: + """""" + Get uncached linearized DFE to SFS transformation for ``h = 0.5`` using special formulae. + + :return: Matrix of size (n_intervals, n) + :raises NotImplementedError: If integration mode is not supported. + """""" + # precompute linearized transformation. + if self.integration_mode == 'midpoint': + return self.get_counts_semidominant_midpoint() + + if self.integration_mode == 'quad': + return self.get_counts_semidominant_quad() + + raise NotImplementedError(f'Integration mode {self.integration_mode} not supported.') + + def get_counts_dominant(self) -> np.ndarray: + """""" + Get DFE to SFS transformation for different dominance coefficients. + + :return: Matrix of size (n_intervals, len(grid_h), n) + """""" + K = np.arange(1, self.n) + + # chunk S-bins + n_chunks = int(np.ceil(len(self.bins) / self.s_chunk_size)) + S_chunks = np.array_split(self.bins, n_chunks) + h_mapped_chunks = np.array_split(self.h_mapped, n_chunks) if self.h_mapped is not None else None + + # number of dominance entries + n_h = self.grid_h.size if self.h is None else 1 + + def compute_slice(args): + """""" + Compute allele counts for given (i, j, c). + + :param args: Tuple of (i, j, c) where i is allele count index, j is dominance index, c is S-chunk index + """""" + i, j, c = args + + return [self._get_counts_dominant( + n=self.n, + k=K[i], + S=S_chunks[c], + h=np.full_like(S_chunks[c], self.grid_h[j]) if self.h is None else h_mapped_chunks[c], + n_outer=self.n_outer, + n_inner=self.n_inner + )] + + ijc = list(product( + range(self.n - 1), + range(n_h), + range(n_chunks) + )) + + P = parallelize_func( + func=compute_slice, + data=ijc, + parallelize=self.parallelize, + desc=f""{self.__class__.__name__}>Precomputing"", + dtype=float, + wrap_array=False + ) + + P = np.concatenate(P, axis=1) + P = P.reshape(self.n - 1, n_h, -1) + + return (P[:, :, :-1] + P[:, :, 1:]) / 2 * self.interval_sizes + + @to_float + def get_counts_semidominant_large_negative_S( + self, + S: float | np.ndarray, + k: float | np.ndarray + ) -> np.ndarray | float: + """""" + Limit of get_allele_count for large negative S. + + :param S: Population-scaled selection coefficient + :param k: Allele count + :return: Number of counts in frequency class P(k) + """""" + return self.n / (k * (self.n - k)) * self.hyp1f1(k, self.n, S) + + def get_counts_semidominant_large_positive_S( + self, + S: float | np.ndarray, + k: float | np.ndarray + ) -> np.ndarray | float: + """""" + Limit of get_allele_count for large positive S. + + :param S: Population-scaled selection coefficient + :param k: Allele count + :return: Number of counts in frequency class P(k) + """""" + return self.n / (k * (self.n - k)) + + @to_float + def get_counts_semidominant_unregularized( + self, + S: float | np.ndarray, + k: float | np.ndarray + ) -> np.ndarray | float: + """""" + The number of counts in frequency class P(k) with + population-scaled selection coefficient S and h = 0.5. + Binomial sampling is included here. + See appendix of https://pubmed.ncbi.nlm.nih.gov/31975166 + + :param S: Population-scaled selection coefficient + :param k: Allele count + :return: Number of counts in frequency class P(k) + """""" + return (self.n / (k * (self.n - k))) * ((1 - self.exp(-S) * self.hyp1f1(k, self.n, S)) / (1 - self.exp(-S))) + + def get_counts_semidominant_regularized(self, S: float | np.ndarray, k: float | np.ndarray) -> float | np.ndarray: + """""" + As :meth:`get_counts_semidominant` but using the respective limits + for ``S`` close to zero and ``S`` very negative. + Note that ``S`` and ``k`` need to have the same shape. + + :param S: Population-scaled selection coefficient + :param k: Allele count + :return: Number of counts in frequency class ``P(k)` + """""" + # make it accept scalars for S + if isinstance(S, (float, int)): + return self.get_counts_semidominant_regularized(np.array([S]), np.array([k]))[0] + + # else S is an array + y = np.zeros_like(S, dtype=float) + + # S close to zero + close_to_zero = np.abs(S) < 1e-8 + + # simply take limit value as S -> 0 + # see https://www.wolframalpha.com/input?i=limit+%28n%2F%28k%28n-k%29%29%29+*+ + # 1%2F%281-exp%28-S%29%29+*+%281-exp%28-S%29*1F1%28k%2Cn%2CS%29%29+as+S+-%3E+0 + if close_to_zero.any(): + y[close_to_zero] = np.ones_like(S[close_to_zero]) / k[close_to_zero] + + # large negative S + very_negative = S < -1e4 + + # Evaluate using limit. + # We check if there are any negative values here + # as numpy's vectorize does not work with empty arrays. + if very_negative.any(): + y[very_negative] = self.get_counts_semidominant_large_negative_S(S[very_negative], k[very_negative]) + + # remaining values of S + remaining = np.array(~(close_to_zero | very_negative)) + + # evaluate function as usual for remaining values + if remaining.any(): + y[remaining] = self.get_counts_semidominant_unregularized(S[remaining], k[remaining]) + + return y + + def model_selection_sfs(self, model: Parametrization, params: dict) -> np.ndarray: + """""" + Infer SFS from the given DFE PDF. + Note that demography is not included here. + + :param params: Parameters of the DFE + :param model: DFE parametrization + :return: SFS counts + """""" + if self.linearized: + + # get discretized DFE + dfe = model._discretize(params, self.bins) / self.interval_sizes + + # get SFS from DFE using linearization + # the interval sizes are already included here + counts_modelled = self.get_counts(params.get('h', 0.5)) @ dfe + else: + + if params.get('h', 0.5) != 0.5: + raise NotImplementedError('Non-linearized integral currently only implemented for h = 0.5.') + + dfe_pdf = model.get_pdf(**params) + + def integrate(k: int) -> float: + """""" + Integrate over DFE using scipy's quad. + Here we use the PDF. + """""" + + def integrate_dfe(s: float) -> float: + """""" + Integrate over DFE for fixed k. + Note that this produces too small results for low s, + but we don't make use of it in production code anyway. + """""" + return self.get_counts_semidominant_regularized(s, k) * dfe_pdf(s) + + return quad(integrate_dfe, self.bins[0], self.bins[-1])[0] + + counts_modelled = np.array([integrate(k) for k in range(1, self.n)]) + + return counts_modelled + + def get_alpha(self, model: Parametrization, params: dict) -> float: + """""" + Get alpha, the proportion of beneficial non-synonymous substitutions. + + :param model: DFE parametrization + :param params: Parameters of the DFE + :return: Estimated for alpha + """""" + y = model._discretize(params, self.bins) * self.get_counts_fixed(params.get('h', 0.5)) + + return np.sum(y[self.s > 0]) / np.sum(y) + + def get_interval_density( + self, + inter: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]) + ) -> np.ndarray: + """""" + Get interval density. + + :param inter: Intervals + :return: Interval density + """""" + return np.array([np.sum((inter[i - 1] < self.s) & (self.s < inter[i])) for i in range(1, len(inter))]) + + def __eq__(self, other) -> bool: + """""" + Compare two instances for equality. + + :param other: Other Discretization instance + :return: True if equal, False otherwise + """""" + if not isinstance(other, Discretization): + return False + + return ( + self.n == other.n and + self.h == other.h and + np.array_equal(self.h_mapped, other.h_mapped) and + self.intervals_del == other.intervals_del and + self.intervals_ben == other.intervals_ben and + self.intervals_h == other.intervals_h and + self.n_outer == other.n_outer and + self.n_inner == other.n_inner and + self.s_chunk_size == other.s_chunk_size and + self.integration_mode == other.integration_mode and + self.linearized == other.linearized and + self.parallelize == other.parallelize + ) + + def __hash__(self) -> int: + """""" + Hash instance. + """""" + return hash(( + self.n, + self.h, + tuple(self.intervals_del), + tuple(self.intervals_ben), + tuple(self.intervals_h), + self.n_outer, + self.n_inner, + self.s_chunk_size, + self.integration_mode, + self.linearized, + self.parallelize, + )) +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/__init__.py",".py","6042","207",""""""" +fastDFE package. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-10"" + +__version__ = '1.2.1' + +import logging +import sys + +import jsonpickle +import numpy as np +import pandas as pd +from tqdm import tqdm + +from .json_handlers import DataframeHandler, SpectrumHandler, SpectraHandler, NumpyArrayHandler +from .spectrum import Spectrum, Spectra + +# register custom handles +jsonpickle.handlers.registry.register(pd.DataFrame, DataframeHandler) +jsonpickle.handlers.registry.register(Spectrum, SpectrumHandler) +jsonpickle.handlers.registry.register(Spectra, SpectraHandler) +jsonpickle.handlers.registry.register(np.ndarray, NumpyArrayHandler) + + +class TqdmLoggingHandler(logging.Handler): + """""" + TQDM logging handler + """""" + + def __init__(self, level=logging.NOTSET): + """""" + Initialize the handler. + + :param level: + """""" + super().__init__(level) + + def emit(self, record): + """""" + Emit a record. + """""" + try: + msg = self.format(record) + + # we write to stderr as the progress bar + # to make the two work together + tqdm.write(msg, file=sys.stderr) + self.flush() + except Exception: + self.handleError(record) + + +class ColoredFormatter(logging.Formatter): + """""" + Colored formatter. + """""" + + def __init__(self, *args, **kwargs): + """""" + Initialize the formatter. + """""" + super().__init__(*args, **kwargs) + + self.colors = { + ""DEBUG"": ""\033[36m"", # Cyan + ""INFO"": ""\033[32m"", # Green + ""WARNING"": ""\033[33m"", # Yellow + ""ERROR"": ""\033[31m"", # Red + ""CRITICAL"": ""\033[31m"", # Red + } + + self.reset = ""\033[0m"" + + def format(self, record): + """""" + Format the record. + """""" + color = self.colors.get(record.levelname, self.reset) + + formatted = super().format(record) + + # remove package name + formatted = formatted.replace(record.name, record.name.split('.')[-1]) + + return f""{color}{formatted}{self.reset}"" + + +# configure logger +logger = logging.getLogger('fastdfe') + +# don't propagate to the root logger +logger.propagate = False + +# set to INFO by default +logger.setLevel(logging.INFO) + +# let TQDM handle the logging +handler = TqdmLoggingHandler() + +# define a Formatter with colors +formatter = ColoredFormatter('%(levelname)s:%(name)s: %(message)s') + +handler.setFormatter(formatter) +logger.addHandler(handler) + +# def raise_on_warning(message, category, filename, lineno, file=None, line=None): +# """""" +# Raise exception on warning. +# """""" +# raise Exception(warnings.formatwarning(message, category, filename, lineno, line)) + +# warnings.showwarning = raise_on_warning + +# load class from modules +from .parametrization import Parametrization, GammaExpParametrization, DiscreteParametrization, \ + GammaDiscreteParametrization, DisplacedGammaParametrization, DiscreteFractionalParametrization, DFE +from .discretization import Discretization +from .config import Config +from .settings import Settings +from .abstract_inference import Inference +from .base_inference import BaseInference, InferenceResult +from .joint_inference import JointInference, SharedParams +from .optimization import Covariate +from .simulation import Simulation +from .spectrum import Spectrum, Spectra +from .parser import Parser, Stratification, BaseTransitionStratification, BaseContextStratification, \ + DegeneracyStratification, TransitionTransversionStratification, AncestralBaseStratification, \ + SynonymyStratification, VEPStratification, SnpEffStratification, ContigStratification, ChunkedStratification, \ + RandomStratification, TargetSiteCounter +from .io_handlers import VCFHandler, FASTAHandler, GFFHandler, FileHandler +from .annotation import Annotator, Annotation, MaximumParsimonyAncestralAnnotation, SiteInfo, \ + MaximumLikelihoodAncestralAnnotation, DegeneracyAnnotation, SynonymyAnnotation, SubstitutionModel, \ + K2SubstitutionModel, JCSubstitutionModel, PolarizationPrior, KingmanPolarizationPrior, AdaptivePolarizationPrior +from .filtration import Filterer, Filtration, SNPFiltration, PolyAllelicFiltration, CodingSequenceFiltration, \ + SNVFiltration, DeviantOutgroupFiltration, AllFiltration, NoFiltration, BiasedGCConversionFiltration, \ + ExistingOutgroupFiltration, ContigFiltration + +__all__ = [ + 'Parametrization', + 'GammaExpParametrization', + 'DiscreteParametrization', + 'GammaDiscreteParametrization', + 'DisplacedGammaParametrization', + 'DiscreteFractionalParametrization', + 'DFE', + 'Discretization', + 'Config', + 'Settings', + 'Inference', + 'BaseInference', + 'JointInference', + 'InferenceResult', + 'Simulation', + 'SharedParams', + 'Covariate', + 'Spectrum', + 'Spectra', + 'Parser', + 'FileHandler', + 'VCFHandler', + 'FASTAHandler', + 'GFFHandler', + 'TargetSiteCounter', + 'Stratification', + 'BaseTransitionStratification', + 'BaseContextStratification', + 'DegeneracyStratification', + 'TransitionTransversionStratification', + 'AncestralBaseStratification', + 'SynonymyStratification', + 'VEPStratification', + 'SnpEffStratification', + 'ContigStratification', + 'ChunkedStratification', + 'RandomStratification', + 'Annotator', + 'Annotation', + 'SiteInfo', + 'MaximumParsimonyAncestralAnnotation', + 'MaximumLikelihoodAncestralAnnotation', + 'PolarizationPrior', + 'KingmanPolarizationPrior', + 'AdaptivePolarizationPrior', + 'SubstitutionModel', + 'K2SubstitutionModel', + 'JCSubstitutionModel', + 'DegeneracyAnnotation', + 'SynonymyAnnotation', + 'Filtration', + 'CodingSequenceFiltration', + 'DeviantOutgroupFiltration', + 'AllFiltration', + 'NoFiltration', + 'Filterer', + 'SNPFiltration', + 'SNVFiltration', + 'PolyAllelicFiltration', + 'BiasedGCConversionFiltration', + 'ExistingOutgroupFiltration', + 'ContigFiltration', + 'Filterer', +] +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/visualization.py",".py","32384","1049",""""""" +Visualization module. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import functools +import logging +from typing import Callable, List, Literal, Dict, Sequence + +import matplotlib.colors as mcolors +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns +from matplotlib import colors +from matplotlib.colors import LogNorm +from matplotlib.container import BarContainer +from matplotlib.ticker import MaxNLocator +from mpl_toolkits.axes_grid1 import make_axes_locatable + +from .parametrization import Parametrization + +# get logger +logger = logging.getLogger('fastdfe').getChild('Visualization') + + +class Visualization: + """""" + Visualization class. + """""" + + @classmethod + def change_default_figsize(cls, factor: float | np.ndarray): + """""" + Scale default figure size. + + :return: Factor to scale default figure size by + """""" + plt.rcParams[""figure.figsize""] = list(factor * np.array(plt.rcParams[""figure.figsize""])) + + @staticmethod + def clear_show_save(func: Callable) -> Callable: + """""" + Decorator for clearing current figure in the beginning + and showing or saving produced plot subsequently. + + :param func: Function to decorate + :return: Wrapper function + """""" + + @functools.wraps(func) + def wrapper(*args, **kwargs) -> plt.Axes: + """""" + Wrapper function. + + :param args: Positional arguments + :param kwargs: Keyword arguments + :return: Axes + """""" + + # add axes if not given + if 'ax' not in kwargs or ('ax' in kwargs and kwargs['ax'] is None): + # clear current figure + plt.close() + + kwargs['ax'] = plt.gca() + + # execute function + func(*args, **kwargs) + + # make layout tight + plt.tight_layout() + + # show or save + # show by default here + return Visualization.show_and_save( + file=kwargs['file'] if 'file' in kwargs else None, + show=kwargs['show'] if 'show' in kwargs else True + ) + + return wrapper + + @staticmethod + def show_and_save(file: str = None, show: bool = True, pad: float = 1.08) -> plt.Axes: + """""" + Show and save plot. + + :param file: File path to save plot to + :param show: Whether to show plot + :param pad: Padding for tight layout + :return: Axes + + """""" + plt.tight_layout(pad=pad) + + # save figure if file path given + if file is not None: + plt.savefig(file, dpi=200, bbox_inches='tight', pad_inches=0.1) + + # show figure if specified and if not in interactive mode + if show and not plt.isinteractive(): + plt.show() + + # return current axes + return plt.gca() + + @staticmethod + def interval_to_string(left: float, right: float) -> str: + """""" + Get string representation for given interval. + + :param left: Right interval boundary + :param right: Left interval boundary + :return: String representation of interval + + """""" + # left interval is closed by default + bracket_left = '[' if left != -np.inf else '(' + bracket_right = ')' + + def format_number(n: float) -> str: + """""" + Format number, allowing for np.inf. + + :param n: Number to format + :return: Formatted number + """""" + if n == -np.inf: + return '-inf' + + if n == np.inf: + return 'inf' + + return '{:0.0f}'.format(n) + + return bracket_left + format_number(left) + ', ' + format_number(right) + bracket_right + + @staticmethod + @clear_show_save + def plot_discretized( + ax: plt.Axes, + values: Sequence, + errors: Sequence = None, + labels: Sequence = None, + file: str = None, + show: bool = True, + intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + title: str = 'discretized DFE', + interval_labels: List[str] = None, + kwargs_legend: dict = dict(prop=dict(size=8)), + + ) -> plt.Axes: + """""" + Plot discretized DFEs using a bar plot. + + :param interval_labels: Labels for the intervals (which are the same for all types) + :param labels: Labels for the different types of DFEs + :param title: Title of the plot + :param values: Array of values of size ``intervals.shape[0] - 1``, containing the discretized DFE for each type + :param errors: Array of errors of size ``intervals.shape[0] - 1``, containing the discretized DFE for each type + :param file: File path to save plot to + :param show: Whether to show plot + :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bars. + :param ax: Axes to plot on. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. + :return: Axes + """""" + # number of intervals + n_intervals = len(intervals) - 1 + n_dfes = len(values) + + width_total = 0.9 + width = width_total / n_dfes + + for i in range(n_dfes): + x = np.arange(n_intervals) + i * width + + # plot discretized DFE + bars = ax.bar( + x=x, + height=values[i], + width=width, + yerr=errors[i] if errors is not None else None, + error_kw=dict( + capsize=width * 7 + ), + label=labels[i] if labels is not None else None, + linewidth=0, + hatch=Visualization.get_hatch(i, labels), + color=Visualization.get_color(labels[i], labels) if labels is not None else None + ) + + Visualization.darken_edge_colors(bars) + + ax.set(xlabel='S', ylabel='fraction') + + # determine x-labels + if interval_labels is None: + xlabels = [Visualization.interval_to_string(intervals[i - 1], intervals[i]) for + i in range(1, n_intervals + 1)] + else: + xlabels = interval_labels + + # customize x-ticks + x = np.arange(n_intervals) + ax.set_xticks([i + (width_total - width) / 2 for i in x], x) + ax.set_xticklabels(xlabels) + + # set title + ax.set_title(title) + + # show legend if labels were given + if labels is not None: + ax.legend(**kwargs_legend) + + # remove x-margins + ax.autoscale(tight=True, axis='x') + + return ax + + @staticmethod + @clear_show_save + def plot_continuous( + ax: plt.Axes, + bins: np.ndarray, + values: Sequence, + errors: Sequence = None, + labels: Sequence = None, + file: str = None, + show: bool = True, + title: str = 'continuous DFE', + scale: Literal['log', 'linear'] = 'lin', + ylim: float = 1e-2, + scale_density: bool = False, + kwargs_legend: dict = dict(prop=dict(size=8)), + **kwargs + ) -> plt.Axes: + """""" + Plot DFEs using a line plot. + By default, the PDF is plotted as is. Due to the logarithmic scale on + the x-axis, we may get a wrong intuition on how the mass is distributed, + however. To get a better intuition, we can optionally scale the density + by the x-axis interval size using ``scale_density = True``. This has the + disadvantage that the density now changes for x, so that even a constant + density will look warped. + + :param ylim: y-axis limit + :param scale: Scale of y-axis + :param bins: Array of bin boundaries + :param title: Title of the plot + :param labels: Labels for the DFEs + :param errors: Array of errors + :param values: Array of values + :param file: File path to save plot to + :param show: Whether to show plot + :param scale_density: Whether to scale the density by the bin size + :param ax: Axes to plot on. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. + :return: Axes + """""" + from .discretization import Discretization + + n_bins = len(bins) - 1 + n_dfes = len(values) + + # get interval sizes + _, interval_sizes = Discretization.get_midpoints_and_spacing(bins) + + for i in range(n_dfes): + x = np.arange(n_bins) + + # plot DFE + ax.plot(x, + values[i] if scale_density else values[i] / interval_sizes, + label=labels[i] if labels is not None else None) + + # visualize errors + if errors is not None and errors[i] is not None: + ax.fill_between( + x=x, + y1=(values[i] - errors[i][0]) if scale_density else (values[i] - errors[i][0]) / interval_sizes, + y2=(values[i] + errors[i][1]) if scale_density else (values[i] + errors[i][1]) / interval_sizes, + alpha=0.2 + ) + + # customize x-ticks + Visualization.adjust_ticks_show_s(bins) + + # use log scale if specified + if scale == 'log': + ax.set_yscale('log') + ax.set_ylim(bottom=ylim) + + # show legend if labels were given + if labels is not None: + ax.legend(**kwargs_legend) + + # remove x-margins + ax.set_xmargin(0) + + ax.set_title(title) + + return ax + + @staticmethod + def adjust_ticks_show_s(s: np.ndarray): + """""" + Adjust x-ticks to show bin values. + + :return: Array of selection coefficients + """""" + + n_bins = len(s) - 1 + ax = plt.gca() + + ticks = ax.get_xticks() + ticks_new = [""{:.0e}"".format(s[int(l)]) if 0 <= int(l) < n_bins else None for l in ticks] + + ax.set_xticks(ticks) + ax.set_xticklabels(ticks_new) + + @staticmethod + def name_to_label( + key: str, + param_names: Sequence = None, + vals: Sequence = None + ) -> str: + """""" + Map parameter name to label. + + :param key: Parameter name + :param param_names: Parameter names + :param vals: Parameter values + :return: Label + """""" + # define new names for some parameters + label_mapping = dict( + alpha='α', + eps='ε' + ) + + # map to new name + label = label_mapping[key] if key in label_mapping else key + + # wrap in math mode tags + if param_names is None: + return '$' + label + '$' + + # get index of parameter + k = np.where(np.array(param_names) == key)[0][0] + + # check parameter value and add minus sign if negative + if vals[k] >= 0: + return '$' + label + '$' + + return '$-' + key + '$' + + @staticmethod + @clear_show_save + def plot_inferred_parameters( + ax: plt.Axes, + values: Dict[str, np.ndarray], + labels: Sequence, + param_names: Sequence, + errors: Dict[str, np.ndarray | None], + file: str = None, + show: bool = True, + title: str = 'parameter estimates', + legend: bool = True, + scale: Literal['lin', 'log', 'symlog'] = 'log', + kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right') + ) -> plt.Axes: + """""" + Visualize the inferred parameters and their confidence intervals. + using a bar plot. Note that there problems with parameters that span 0 (which is usually note the case). + + :param labels: Unique labels for the DFEs + :param param_names: Labels for the parameters + :param scale: Whether to use a linear or log scale + :param title: Title of the plot + :param legend: Whether to show the legend + :param errors: Dictionary of errors with the parameter in the same order as ``labels`` + :param values: Dictionary of parameter values with the parameter in the same order as ``labels`` + :param file: File path to save plot to + :param show: Whether to show plot + :param ax: Axes to plot on. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. + :return: Axes + """""" + labels = list(labels) + n_types = len(values) + + width_total = 0.9 + width = width_total / n_types + + # number of parameters + n_params = len(param_names) + + # iterate over types + for i, vals, errs in zip(range(n_types), values.values(), errors.values()): + + x = np.arange(n_params) + i * width + + # get labels for parameters + xlabels = np.array([Visualization.name_to_label(key, param_names, vals) for key in param_names]) + + # flip errors for negative parameters + if errs is not None: + errs = np.array([err if vals[i] >= 0 else err[::-1] for i, err in enumerate(errs.T)]).T + + # Plot bars. + # Note that we plot the absolute value of the parameter + bars = ax.bar( + x=x, + height=np.abs(vals), + yerr=errs, + error_kw=dict( + capsize=width * 7 + ), + label=labels[i], + width=width, + linewidth=0, + hatch=Visualization.get_hatch(i, labels), + color=Visualization.get_color(labels[i], labels) if labels is not None else None + ) + + Visualization.darken_edge_colors(bars) + + # customize x-ticks + x = np.arange(n_params) + ax.set_xticks([i + (width_total - width) / 2 for i in x], x) + ax.set_xticklabels(xlabels) + + # show legend if specified + if legend: + ax.legend(**kwargs_legend) + + # set title + ax.set_title(title) + + # change to log-scale if specified + if scale in ['log', 'symlog']: + ax.set_yscale('symlog', linthresh=1e-3) + + # add y-margin at top + ax.set_ylim(top=ax.get_ylim()[1] * 2) + + # remove x-margins + ax.autoscale(tight=True, axis='x') + + return ax + + @staticmethod + def plot_inferred_parameters_boxplot( + values: Dict[str, pd.DataFrame], + param_names: Sequence, + file: str = None, + show: bool = True, + title: str = 'parameter estimates' + ) -> plt.Axes: + """""" + Visualize the inferred parameters using a boxplot. + + :param values: Type-indexed dictionary of dataframes with parameters as columns and values as rows + :param param_names: Parameters to plot + :param title: Title of the plot + :param file: File path to save plot to + :param show: Whether to show plot + :return: Axes + """""" + plt.close() + + # create a subplot with number of parameters axes + fig, axs = plt.subplots(len(param_names), 1, figsize=(6, 1.4 * len(param_names))) + + axs[0].set_title(title) + + for i, param_name in enumerate(param_names): + ax = axs[i] + + # Prepare a dataframe for seaborn + df_list = [] + for t, df in values.items(): + subset = df[[param_name]].copy() + subset['Type'] = t + df_list.append(subset) + + df_plot = pd.concat(df_list) + + # plot + sns.boxplot(x='Type', y=param_name, data=df_plot, ax=ax) + + ax.set_ylabel( + Visualization.name_to_label(param_name, param_names, df_plot[param_name].abs().values), + rotation=0, + labelpad=20 + ) + + ax.set_xlabel(None) + + if i < len(param_names) - 1: + ax.set(xticklabels=[]) + ax.tick_params(bottom=False) + else: + [l.set_rotation(90) for l in ax.get_xticklabels()] + + # show and save plot + return Visualization.show_and_save(file, show, pad=0.3) + + @staticmethod + def get_color( + label: str, + labels: List[str], + get_group: Callable = lambda x: x.split('.')[-1] + ) -> str: + """""" + Get color for specified label. + + :param label: Label to get color for + :param labels: List of labels + :param get_group: Function to get group from label + :return: Color string + """""" + # determine unique groups + groups = np.unique(np.array([get_group(l) for l in labels])) + + # determine group of current label + group = get_group(label) + + # determine index of group + i = np.where(groups == group)[0][0] if sum(groups == group) > 0 else 0 + + # return color + return f'C{i}' + + @staticmethod + def get_hatch(i: int, labels: List[str] = None) -> str | None: + """""" + Get hatch style for specified index i. + + :param labels: List of labels + :param i: Index + :return: Hatch style + """""" + + # determine whether hatch style should be used + if labels is None or len(labels) < 1 or '.' not in labels[i]: + return + + # determine unique prefixes + prefixes = set([label.split('.')[0] for label in labels if '.' in label]) + hatch_styles = ['/////', '\\\\\\\\\\', '***', 'ooo', 'xxx', '...'] + + prefix = labels[i].split('.')[0] + prefix_index = list(prefixes).index(prefix) + + return hatch_styles[prefix_index % len(hatch_styles)] + + @staticmethod + def plot_spectra( + ax: plt.Axes, + spectra: List[List[float]] | np.ndarray, + labels: List[str] | np.ndarray = [], + colors: List[str] | np.ndarray = None, + log_scale: bool = False, + use_subplots: bool = False, + show_monomorphic: bool = False, + title: str = None, + n_ticks: int = 10, + file: str = None, + show: bool = True, + kwargs_legend: dict = dict(prop=dict(size=8)) + ) -> plt.Axes: + """""" + Plot the given 1D spectra. + + :param show_monomorphic: Whether to show monomorphic site counts + :param n_ticks: Number of x-ticks to use + :param ax: Axes to plot on. + :param ax: Axes to plot on. Only for Python visualization backend and if ``use_subplots`` is ``False``. + :param title: Title of plot + :param spectra: List of lists of spectra or a 2D array in which each row is a spectrum in the + same order as ``labels`` + :param colors: List of colors for each spectrum. + :param labels: List of labels for each spectrum + :param log_scale: Whether to use logarithmic y-scale + :param use_subplots: Whether to use subplots + :param file: File to save plot to + :param show: Whether to show the plot + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. + :return: Axes + """""" + if len(spectra) == 0: + logger.warning('No spectra to plot.') + return ax + + if use_subplots: + + # clear current figure + plt.close() + + n_plots = len(spectra) + n_rows = int(np.ceil(np.sqrt(n_plots))) + n_cols = int(np.ceil(np.sqrt(n_plots))) + + fig = plt.figure(figsize=(6.4 * n_cols ** (1 / 3), 4.8 * n_rows ** (1 / 3))) + axes = fig.subplots(ncols=n_cols, nrows=n_rows, squeeze=False).flatten() + + # plot spectra individually + for i in range(n_plots): + Visualization.plot_spectra( + spectra=[spectra[i]], + labels=[labels[i]] if len(labels) else [], + colors=[colors[i]] if colors else None, + ax=axes[i], + n_ticks=15 // min(2, n_cols), + log_scale=log_scale, + show_monomorphic=show_monomorphic, + show=False + ) + + # set title + axes[i].set_title(labels[i] if i < len(labels) else '') + + # make empty plots invisible + [ax.set_visible(False) for ax in axes[n_plots:]] + + # show and save plot + return Visualization.show_and_save(file, show) + + if ax is None: + plt.close() + _, ax = plt.subplots() + + # determine sample size and width + n = len(spectra[0]) - 1 + width_total = 0.9 + width = width_total / len(spectra) + + x = np.arange(n + 1) if show_monomorphic else np.arange(1, n) + + # iterator over spectra and draw bars + for i, sfs in enumerate(spectra): + bars = ax.bar( + x=x + i * width, + height=sfs if show_monomorphic else sfs[1:-1], + width=width, + label=labels[i] if len(labels) else None, + color=colors[i] if colors else None, + linewidth=0, + hatch=Visualization.get_hatch(i, labels) + ) + + Visualization.darken_edge_colors(bars) + + # adjust ticks + ax.xaxis.set_major_locator(MaxNLocator(integer=True)) + indices_ticks = x + + # filter ticks + if n > n_ticks: + indices_ticks = indices_ticks[indices_ticks % max(int(np.ceil(n / n_ticks)), 1) == 1] + + ax.set_xticks([i + (width_total - width) / 2 for i in indices_ticks], indices_ticks) + + ax.set_xlabel('frequency') + + # remove x-margins + ax.autoscale(tight=True, axis='x') + + if log_scale: + ax.set_yscale('log') + + # set title + ax.set_title(title) + + # show legend if more than one label + if len(labels) > 1: + ax.legend(**kwargs_legend) + + # show and save plot + return Visualization.show_and_save(file, show) + + @staticmethod + def darken_edge_colors(bars: BarContainer): + """""" + Darken the edge color of the given bars. + + :param bars: Bars to darken + """""" + for bar in bars: + color = bar.get_facecolor() + edge_color = Visualization.darken_color(color, amount=0.75) + bar.set_edgecolor(edge_color) + + @staticmethod + def darken_color(color, amount=0.5) -> tuple: + """""" + Darken a color. + + :param color: Color to darken + :param amount: Amount to darken + :return: Darkened color as tuple + """""" + c = mcolors.to_rgba(color) + + return c[0] * amount, c[1] * amount, c[2] * amount, c[3] + + @staticmethod + @clear_show_save + def plot_pdf( + model: Parametrization, + params: dict, + ax: plt.Axes, + s: np.ndarray = np.linspace(-100, 100, 1000), + file: str = None, + show: bool = True + ) -> plt.Axes: + """""" + Plot PDF of given parametrization. + + :param model: DFE parametrization + :param params: Parameters to be used for parametrization + :param s: Selection coefficients + :param file: File to save plot to + :param show: Whether to show plot + :param ax: Axes to plot on. + :return: Axes + """""" + ax.plot(np.arange(len(s)), model.get_pdf(**params)(s)) + + # customize x-ticks + Visualization.adjust_ticks_show_s(s) + + # remove x-margins + ax.margins(x=0) + + return ax + + @staticmethod + @clear_show_save + def plot_cdf( + model: Parametrization, + params: dict, + ax: plt.Axes, + s: np.ndarray = np.linspace(-100, 100, 1000), + file: str = None, + show: bool = True + ) -> plt.Axes: + """""" + Plot CDF of given parametrization. + + :param model: DFE parametrization + :param params: Parameters to be used for parametrization + :param s: Selection coefficients + :param ax: Axes to plot on. + :param file: File to save plot to + :param show: Whether to show plot + :return: Axes + """""" + ax.plot(np.arange(len(s)), model.get_cdf(**params)(s)) + + # customize x-ticks + Visualization.adjust_ticks_show_s(s) + + # remove x-margins + ax.margins(x=0) + + return ax + + @staticmethod + @clear_show_save + def plot_scatter( + values: Sequence, + file: str, + show: bool, + ax: plt.Axes, + title: str | None = None, + scale: Literal['lin', 'log', 'symlog'] = 'lin', + ylabel: str = 'lnl' + ) -> plt.Axes: + """""" + A scatter plot. + + :param scale: Scale of y-axis + :param values: Values to plot + :param file: File to save plot to + :param show: Whether to show plot + :param title: Title of plot + :param ax: Axes to plot on. + :param ylabel: Label of y-axis + :return: Axes + """""" + # plot + sns.scatterplot(x=range(len(values)), y=values, ax=ax) + + ax.set(ylabel=ylabel) + + # set title + ax.set_title(title) + + if scale == 'log': + ax.set_yscale('symlog') + + return ax + + @staticmethod + @clear_show_save + def plot_buckets_sizes( + n_intervals: int, + bins: Sequence, + sizes: Sequence, + title: str, + file: str, + show: bool, + ax: plt.Axes + ) -> plt.Axes: + """""" + A line plot of the bucket sizes. + + :param bins: Bins of the histogram + :param n_intervals: Number of intervals + :param sizes: Sizes of the buckets + :param title: Title of plot + :param file: File to save plot to + :param show: Whether to show plot + :param ax: Axes to plot on. + :return: Axes + """""" + # plot line + ax.plot(np.arange(n_intervals), sizes) + + # use log scale + ax.set_yscale('log') + ax.set_title(title) + + # customize x-ticks + Visualization.adjust_ticks_show_s(bins) + + # remove x-margins + ax.set_xmargin(0) + + return ax + + @staticmethod + @clear_show_save + def plot_nested_models( + P: np.ndarray, + labels_x: Sequence, + labels_y: Sequence, + ax: plt.Axes, + file: str = None, + show: bool = True, + cmap: str = None, + title: str = None, + vmin: float = 1e-10, + vmax: float = 1, + ) -> plt.Axes: + """""" + Plot p-values of nested likelihoods. + + :param P: Matrix of p-values + :param labels_x: Labels for x-axis + :param labels_y: Labels for y-axis + :param file: File to save plot to + :param show: Whether to show plot + :param cmap: Colormap to use + :param title: Title of plot + :param ax: Axes to plot on. + :param vmin: Minimum value for colorbar + :param vmax: Maximum value for colorbar + :return: Axes + """""" + + def format_number(x: float | int | None) -> float | int | str: + """""" + Format number to be displayed. + + :param x: Number to format + :return: Formatted number + """""" + if x == 0 or x is None: + return 0 + + if x < 0.0001: + return ""{:.1e}"".format(x) + + return np.round(x, 4) + + # determine values to display + annotation = np.vectorize(lambda x: str(format_number(x)))(P) + annotation[np.equal(P, None)] = '-' + + # change to 1 to get a nicer color + P[np.equal(P, None)] = 1 + + # keep within color bar bounds + P[P < vmin] = vmin + P[P > vmax] = vmax + + # make the cbar have the same height as the heatmap + cbar_ax = make_axes_locatable(ax).new_horizontal(size=""4%"", pad=0.15) + plt.gcf().add_axes(cbar_ax) + + # default color map + if cmap is None: + cmap = colors.LinearSegmentedColormap.from_list('_', plt.get_cmap('inferno')(np.linspace(0.3, 1, 100))) + + # plot heatmap + sns.heatmap( + P.astype(float), + ax=ax, + cbar_ax=cbar_ax, + cmap=cmap, + norm=LogNorm( + vmin=vmin, + vmax=vmax + ), + annot=annotation, + fmt="""", + square=True, + linewidths=0.5, + linecolor='#cccccc', + cbar_kws=dict( + label='p-value' + ) + ) + + # adjust tick labels + ax.set_xticklabels([l.replace('_', ' ') for l in labels_x], rotation=45) + ax.set_yticklabels([l.replace('_', ' ') for l in labels_y], rotation=0) + + # set title + ax.set_title(title) + + return ax + + @staticmethod + @clear_show_save + def plot_interval_density( + ax: plt.Axes, + density: np.ndarray, + intervals: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + interval_labels: List[str] = None, + file: str = None, + show: bool = True, + color: str = 'C0', + ) -> plt.Axes: + """""" + Plot density of the discretization intervals chosen. + + :param density: Discretized density. + :param color: Color of the bars. + :param file: File to save plot to. + :param show: Whether to show plot. + :param interval_labels: Labels for the intervals. + :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. + :param ax: Axes to plot on. + :return: Axes object + """""" + # number of intervals + n_intervals = len(intervals) + + # x-values + x = np.arange(n_intervals - 1) + + # plot plot + sns.barplot(x=x, y=density / density.sum(), color=color, ax=ax) + + # set labels + ax.set(xlabel='S', ylabel='fraction') + + # determine x-labels + if interval_labels is None: + xlabels = [Visualization.interval_to_string(intervals[i - 1], intervals[i]) for i in range(1, n_intervals)] + else: + xlabels = interval_labels + + # adjust x-ticks + ax.set_xticks(x) + ax.set_xticklabels(xlabels) + + # set title + ax.set_title('interval density') + + # remove x-margins + ax.autoscale(tight=True, axis='x') + + return ax + + @staticmethod + @clear_show_save + def plot_covariate( + covariates: Sequence, + values: Sequence, + xlabel: str, + ylabel: str, + labels: Sequence = None, + errors: Sequence = None, + file: str = None, + show: bool = True, + title: str = 'likelihoods', + ax: plt.Axes = None + ) -> plt.Axes: + """""" + + :param covariates: The covariate values. + :param values: The MLE parameter values. + :param xlabel: X-axis label. + :param ylabel: Y-axis label. + :param labels: Labels for the different types + :param errors: The errors on the MLE parameter values. + :param labels: Labels for the different types + :param file: File to save plot to + :param show: Whether to show plot + :param title: Title of plot + :param ax: Axes to plot on. + :return: Axes + """""" + ax.scatter(x=covariates, y=np.array(values)) + + # plot error bars + if errors is not None: + ax.errorbar( + x=covariates, + y=np.array(values), + yerr=np.array(errors), + fmt='none', + capsize=3 + ) + + # set labels + ax.set(xlabel=xlabel, ylabel=Visualization.name_to_label(ylabel)) + + # set title + ax.set_title(title) + + # Add second x-axis on top of the plot to show the labels + if labels is not None: + ax2 = ax.twiny() + ax2.set_xticks(covariates) + ax2.set_xticklabels(labels, rotation=45, ha='left') + ax2.set_xlim(ax.get_xlim()) + + return ax +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/polydfe_utils.py",".py","5286","203",""""""" +Utilities for parsing polyDFE files. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import logging +import os +from typing import TextIO, List, Tuple + +import pandas as pd + +from .spectrum import Spectrum + +# get logger +logger = logging.getLogger('fastdfe').getChild('polydfe') + +#: model mapping +models = dict( + DisplacedGammaParametrization='A', + GammaDiscreteParametrization='B', + GammaExpParametrization='C', + DiscreteParametrization='D' +) + +# leading column names in init file +columns = [ + 'eps', + 'eps_deprecated', + 'lambda', + 'theta_bar', + 'a' +] + + +class ParamMode: + """""" + Parameter modes in polyDFE input files. + """""" + independent = 0 + fixed = 1 + shared = 2 + + +def create_sfs_config( + file: str, + sfs_neut: Spectrum, + sfs_sel: Spectrum +): + """""" + Create a sfs config file for polyDFE. + + :param sfs_sel: Selected sfs + :param sfs_neut: Neutral sfs + :param file: Path to config file + """""" + + def write_line(f: TextIO, sfs: Spectrum, sep: str = '\t'): + """""" + Concatenate given array and write to stream. + + :param sfs: SFS + :param f: File stream + :param sep: separator + """""" + # SFS and number of mutational target sites + # we ignore divergence data here + data = list(sfs.polymorphic) + [sfs.n_sites] + + f.write(sep.join(map(str, data)) + os.linesep) + + # number of spectra per time + m_neut = 1 + m_sel = 1 + with open(file, 'w') as fh: + fh.write(' '.join(map(str, [m_neut, m_sel, sfs_sel.n])) + os.linesep) + + write_line(fh, sfs_neut) + write_line(fh, sfs_sel) + + +def parse_init_file( + dfe_params: list, + file: str, + id: int = 1, + ignore: list = ['eps_deprecated', 'r'] +) -> Tuple[dict, dict]: + """""" + Parse polyDFE init file. + This will define the initial parameters and + which ones will be held fixed during the optimization. + We do not support fixing some of the polyDFE's parameters + like theta and the nuisance parameters. Some other parameters + are not supported altogether. + + :param dfe_params: List of dfe parameters + :param file: Path to init file + :param id: Init id + :param ignore: List of parameters to ignore + :return Dictionary of fixed parameters and dictionary of initial values + """""" + logger.info('Parsing init file.') + + # columns except for nuisance parameters + cols = columns + list(dfe_params) + + # load init file into dataframe + df = pd.read_csv(file, delimiter=r""\s+"", comment='#', header=None, index_col=0) + + # check if id is present + if id not in df.index: + raise Exception(f'Id {id} not found in init file. Possible ids: {str(df.index.to_list())}.') + + # extract row with specified id + data = df.loc[id] + + # Retrieve parameters and their modes. + # Note that the parameter order is important + # when recreating the init file. + params, params_mode = {}, {} + for i, col in enumerate(cols): + params[col] = data[2 * i + 2] + params_mode[col] = int(data[2 * i + 1]) + + # assign nuisance parameters + params['r'] = list(data[2 * len(cols) + 1:]) + params_mode['r'] = int(data[2 * len(cols) + 1]) + + # determine fixed parameters and initial conditions + fixed_params = {} + x0 = {} + for param in params_mode.keys(): + if param not in ignore: + # here we don't distinguish between shared and independent parameters + if params_mode[param] == ParamMode.fixed: + fixed_params[param] = params[param] + + x0[param] = params[param] + + # issue notice + logger.info(f""Found initial params: {x0} and fixed params: {fixed_params} when parsing init file."") + + return fixed_params, x0 + + +def create_init_file( + file: str, + fixed_params: List, + x0: dict, + dfe_params: List, + n: int, + id: int = 1 +): + """""" + Create an init file for polyDFE. + + :param id: Init id + :param n: SFS sample size + :param dfe_params: List of dfe parameters + :param x0: Dictionary of initial values + :param fixed_params: List of fixed parameters + :param file: File path to write init file to + """""" + cols = columns + list(dfe_params) + ['r'] + + # copy dict to avoid modification + x0 = x0.copy() + + if 'r' in x0: + # assign existing nuisance parameters + x0['r'] = ' '.join([str(r) for r in x0['r']]) + else: + # make up initial nuisance parameters + x0['r'] = ' '.join(['1'] * (n - 1)) + + # create list of initial parameters + params = [] + for col in cols: + if col in x0: + params += [x0[col]] + else: + params += [0] + + # create list of parameter modes + params_mode = [] + for col in cols: + if col in fixed_params: + params_mode += [ParamMode.fixed] + else: + params_mode += [ParamMode.independent] + + # concatenate parameters and their modes + params_with_mode = [str(a) + ' ' + str(b) for a, b in zip(list(params_mode), params)] + + # prepend an id value and join + line = '\t'.join([str(id)] + params_with_mode) + + # write line to file + with open(file, 'w') as fh: + fh.write(line) +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/parser.py",".py","50339","1370",""""""" +A VCF parser that can be used to extract the site frequency spectrum (SFS) from a VCF file. +Stratifying the SFS is supported by providing a list of :class:`Stratification` instances. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-26"" + +import functools +import itertools +import logging +import random +from abc import ABC, abstractmethod +from collections import Counter, defaultdict +from typing import List, Callable, Literal, Optional, Dict, Tuple, Union + +import numpy as np +from Bio.SeqRecord import SeqRecord +from scipy.stats import hypergeom +from tqdm import tqdm + +from .annotation import Annotation, SynonymyAnnotation, DegeneracyAnnotation, AncestralAlleleAnnotation +from .filtration import Filtration, PolyAllelicFiltration, SNPFiltration +from .io_handlers import bases, get_called_bases, FASTAHandler, NoTypeException, \ + DummyVariant, MultiHandler, VCFHandler, is_monomorphic_snp +from .settings import Settings +from .spectrum import Spectra + +# logger +logger = logging.getLogger('fastdfe') + + +def _count_valid_type(func: Callable) -> Callable: + """""" + Decorator for counting the number of sites that had a valid type. + """""" + + @functools.wraps(func) + def wrapper(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Wrapper function. + + :param self: Class instance + :param variant: The vcf site + :return: The result of the decorated function + """""" + res = func(self, variant) + self.n_valid += 1 + return res + + return wrapper + + +class Stratification(ABC): + """""" + Abstract class for Stratifying the SFS by determining a site's type based on its properties. + """""" + + def __init__(self): + """""" + Create instance. + """""" + self._logger = logger.getChild(self.__class__.__name__) + + #: Parser instance + self.parser: Optional['Parser'] = None + + #: The number of sites that didn't have a type. + self.n_valid: int = 0 + + def _setup(self, parser: 'Parser'): + """""" + Provide the stratification with some context by specifying the parser. + This should be done before calling :meth:`get_type`. + + :param parser: The parser + """""" + self.parser = parser + + def _rewind(self): + """""" + Rewind the stratification. + """""" + self.n_valid = 0 + + def _teardown(self): + """""" + Perform any necessary post-processing. + """""" + self._logger.info(f""Number of sites with valid type: {self.n_valid}"") + + @abstractmethod + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> Optional[str]: + """""" + Get type of given Variant. Only the types + given by :meth:`get_types()` are valid, or ``None`` if + no type could be determined. + + :param variant: The vcf site + :return: Type of the variant + """""" + pass + + @abstractmethod + def get_types(self) -> List[str]: + """""" + Get all possible types. + + :return: List of types + """""" + pass + + +class SNPStratification(Stratification, ABC): + """""" + Abstract class for stratifications that can only handle SNPs. We need to issue a warning in this case. + """""" + + def _setup(self, parser: 'Parser'): + """""" + Set up the stratification. + + :param parser: The parser + """""" + super()._setup(parser) + + # issue warning if we have an SNP stratification + self._logger.warning(f""{self.__class__.__name__} can only handle SNPs and not mono-allelic sites. "" + ""This means you have to update the number of mono-allelic sites manually."") + + +class BaseContextStratification(Stratification, FASTAHandler): + """""" + Stratify the SFS by the base context of the mutation. The number of flanking bases + can be configured. Note that we attempt to take the ancestral allele as the + middle base. If ``skip_non_polarized`` is set to ``False``, we use the reference + allele as the middle base. + """""" + + def __init__( + self, + fasta: str, + n_flanking: int = 1, + aliases: Dict[str, List[str]] = {}, + cache: bool = True + ): + """""" + Create instance. Note that we require a fasta file to be specified + for base context to be able to be inferred + + :param fasta: The fasta file path, possibly gzipped or a URL + :param n_flanking: The number of flanking bases + :param aliases: Dictionary of aliases for the contigs in the VCF file, e.g. ``{'chr1': ['1']}``. + This is used to match the contig names in the VCF file with the contig names in the FASTA file and GFF file. + :param cache: Whether to cache files that are downloaded from URLs + """""" + Stratification.__init__(self) + + FASTAHandler.__init__(self, fasta, cache=cache, aliases=aliases) + + #: The number of flanking bases + self.n_flanking: int = n_flanking + + #: The current contig + self.contig: Optional[SeqRecord] = None + + def _rewind(self): + """""" + Rewind the stratification. + """""" + Stratification._rewind(self) + FASTAHandler._rewind(self) + + self.contig = None + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: + """""" + Get the base context for a given mutation + + :param variant: The vcf site + :return: Base context of the mutation + """""" + pos = variant.POS - 1 + + # get the ancestral allele + aa = self.parser._get_ancestral(variant) + + # get aliases + aliases = self.get_aliases(variant.CHROM) + + # check if contig is up-to-date + if self.contig is None or self.contig.id not in aliases: + self._logger.debug(f""Fetching contig '{variant.CHROM}'."") + + # fetch contig + self.contig = self.get_contig(aliases) + + # check if position is valid + if pos < 0 or pos >= len(self.contig): + raise NoTypeException(""Invalid position: Position must be within the bounds of the sequence."") + + # get upstream bases + upstream_start = max(0, pos - self.n_flanking) + upstream_bases = str(self.contig.seq[upstream_start:pos]) + + # get downstream bases + downstream_end = min(len(self.contig), pos + self.n_flanking + 1) + downstream_bases = str(self.contig.seq[pos + 1:downstream_end]) + + return f""{upstream_bases}{aa}{downstream_bases}"" + + def get_types(self) -> List[str]: + """""" + Create all possible base contexts. + + :return: List of contexts + """""" + return [''.join(c) for c in itertools.product(bases, repeat=2 * self.n_flanking + 1)] + + +class BaseTransitionStratification(SNPStratification): + """""" + Stratify the SFS by the base transition of the mutation, i.e., ``A>T``. + + .. warning:: + This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. + """""" + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: + """""" + Get the base transition for the given variant. + + :param variant: The vcf site + :return: Base transition + :raises NoTypeException: if not type could be determined + """""" + if variant.is_snp: + ancestral = self.parser._get_ancestral(variant) + + derived = variant.REF if variant.REF != ancestral else variant.ALT[0] + + if ancestral in bases and derived in bases and ancestral != derived: + return f""{ancestral}>{derived}"" + + raise NoTypeException(""Not a valid base transition."") + + raise NoTypeException(""Site is not a SNP."") + + def get_types(self) -> List[str]: + """""" + Get all possible base transitions. + + :return: List of contexts + """""" + return ['>'.join([a, b]) for a in bases for b in bases if a != b] + + +class TransitionTransversionStratification(BaseTransitionStratification): + """""" + Stratify the SFS by whether we have a transition or transversion. + + .. warning:: + This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. + """""" + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: + """""" + Get the mutation type (transition or transversion) for a given mutation. + + :param variant: The vcf site + :return: Mutation type + """""" + if variant.is_snp: + + if variant.ALT[0] not in bases: + raise NoTypeException(""Invalid alternate allele: Alternate allele must be a valid base."") + + if (variant.REF, variant.ALT[0]) in [('A', 'G'), ('G', 'A'), ('C', 'T'), ('T', 'C')]: + return ""transition"" + else: + return ""transversion"" + + raise NoTypeException(""Site is not a SNP."") + + def get_types(self) -> List[str]: + """""" + All possible mutation types (transition and transversion). + + :return: List of mutation types + """""" + return [""transition"", ""transversion""] + + +class AncestralBaseStratification(Stratification): + """""" + Stratify the SFS by the base context of the mutation: the reference base. + If ``skip_non_polarized`` is set to ``False``, we use the reference allele as + ancestral base. By default, we use the ``AA`` tag to determine the ancestral allele. + + Any subclass of :class:`~fastdfe.parser.AncestralAnnotation` can be used to annotate the ancestral allele. + """""" + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: + """""" + Get the type which is the reference allele. + + :param variant: The vcf site + :return: reference allele + """""" + return self.parser._get_ancestral(variant) + + def get_types(self) -> List[str]: + """""" + The possible base types. + + :return: List of contexts + """""" + return bases + + +class DegeneracyStratification(Stratification): + """""" + Stratify SFS by degeneracy. We only consider sides which 4-fold degenerate (neutral) or + 0-fold degenerate (selected) which facilitates counting. + + :class:`~fastdfe.annotation.DegeneracyAnnotation` can be used to annotate the degeneracy of a site. + """""" + + def __init__( + self, + custom_callback: Callable[['cyvcf2.Variant'], str] = None, + ): + """""" + Initialize the stratification. + + :param custom_callback: Custom callback to determine the type of mutation + """""" + super().__init__() + + #: Custom callback to determine the degeneracy of mutation + self.get_degeneracy = custom_callback if custom_callback is not None else self._get_degeneracy_default + + @staticmethod + def _get_degeneracy_default( + variant: Union['cyvcf2.Variant', DummyVariant] + ) -> Optional[Literal['neutral', 'selected']]: + """""" + Get degeneracy based on 'Degeneracy' tag. + + :param variant: The vcf site + :return: Type of the mutation + """""" + degeneracy = variant.INFO.get('Degeneracy') + + if degeneracy is None: + raise NoTypeException(""No degeneracy tag found."") + else: + if degeneracy == 4: + return 'neutral' + + if degeneracy == 0: + return 'selected' + + raise NoTypeException(f""Degeneracy tag has invalid value: '{degeneracy}' at {variant.CHROM}:{variant.POS}"") + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> Literal['neutral', 'selected']: + """""" + Get the degeneracy. + + :param variant: The vcf site + :return: Type of the mutation + :raises NoTypeException: If the mutation is not synonymous or non-synonymous + """""" + return self.get_degeneracy(variant) + + def get_types(self) -> List[str]: + """""" + Get all possible degeneracy type (``neutral`` and ``selected``). + + :return: List of contexts + """""" + return ['neutral', 'selected'] + + +class SynonymyStratification(SNPStratification): + """""" + Stratify SFS by synonymy (neutral or selected). + + :class:`~fastdfe.annotation.SynonymyAnnotation` can be used to annotate the synonymy of a site. + + .. warning:: + This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. + """""" + + def get_types(self) -> List[str]: + """""" + Get all possible synonymy types (``neutral`` and ``selected``). + + :return: List of contexts + """""" + return ['neutral', 'selected'] + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> Literal['neutral', 'selected']: + """""" + Get the synonymy using the custom synonymy annotation. + + :param variant: The vcf site + :return: Type of the mutation, either ``neutral`` or ``selected`` + """""" + synonymy = variant.INFO.get('Synonymy') + + if synonymy is None: + raise NoTypeException(""No synonymy tag found."") + else: + if synonymy == 1: + return 'neutral' + + if synonymy == 0: + return 'selected' + + raise NoTypeException(f""Synonymy tag has invalid value: '{synonymy}' at {variant.CHROM}:{variant.POS}"") + + +class VEPStratification(SynonymyStratification): + """""" + Stratify SFS by synonymy (neutral or selected) based on annotation provided by VEP. + + .. warning:: + This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. + """""" + + #: The tag used by VEP to annotate the synonymy + info_tag = 'CSQ' + + def get_types(self) -> List[str]: + """""" + Get all possible synonymy types (``neutral`` and ``selected``). + + :return: List of contexts + """""" + return ['neutral', 'selected'] + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> Literal['neutral', 'selected']: + """""" + Get the synonymy of a site. + + :param variant: The vcf site + :return: Type of the mutation, either ``neutral`` or ``selected`` + """""" + synonymy = variant.INFO.get(self.info_tag, '') + + if 'synonymous_variant' in synonymy: + return 'neutral' + + if 'missense_variant' in synonymy: + return 'selected' + + raise NoTypeException(f""Synonymy tag has invalid value: '{synonymy}' at {variant.CHROM}:{variant.POS}"") + + +class SnpEffStratification(VEPStratification): + """""" + Stratify SFS by synonymy (neutral or selected) based on annotation provided by SnpEff. + + .. warning:: + This stratification only works for SNPs. You thus need to update the number of mono-allelic sites manually. + """""" + + #: The tag used by SnpEff to annotate the synonymy + info_tag = 'ANN' + + +class GenomePositionDependentStratification(Stratification, ABC): + pass + + +class ContigStratification(GenomePositionDependentStratification): + """""" + Stratify SFS by contig. + """""" + + def __init__(self, contigs: List[str] = None): + """""" + Initialize the stratification. + + :param contigs: List of contigs to stratify by. Defaults to all contigs in the VCF file. + """""" + super().__init__() + + #: List of contigs + self.contigs: List[str] = contigs + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: + """""" + Get the contig. + + :param variant: The vcf site + :return: The contig name + """""" + if self.contigs is not None and variant.CHROM not in self.contigs: + raise NoTypeException(f""Contig '{variant.CHROM}' not in list of contigs."") + + return variant.CHROM + + def get_types(self) -> List[str]: + """""" + Get all possible contig type. + + :return: List of contexts + """""" + return self.contigs or list(self.parser._reader.seqnames) + + +class ChunkedStratification(GenomePositionDependentStratification): + """""" + Stratify SFS by creating ``n`` contiguous chunks of roughly equal size. + + .. note:: + Since the total number of sites is not known in advance, we cannot create contiguous + chunks of exactly equal size. + """""" + + def __init__(self, n_chunks: int): + """""" + Initialize the stratification. + + :param n_chunks: Number of sites per window + """""" + super().__init__() + + #: Number of chunks + self.n_chunks: int = int(n_chunks) + + #: List of chunk sizes + self.chunk_sizes: Optional[List[int]] = None + + #: Number of sites seen so far + self.counter: int = 0 + + def _setup(self, parser: 'Parser'): + """""" + Set up the stratification. + + :param parser: The parser + """""" + super()._setup(parser) + + # compute base chunk size and remainder + base_chunk_size, remainder = divmod(parser.n_sites, self.n_chunks) + + # create list of chunk sizes + self.chunk_sizes = [base_chunk_size + (i < remainder) for i in range(self.n_chunks)] + + def get_types(self) -> List[str]: + """""" + Get all possible window types. + + :return: List of contexts + """""" + return [f'chunk{i}' for i in range(self.n_chunks)] + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: + """""" + Get the type. + + :param variant: The vcf site + :return: The type + """""" + # find the index of the chunk to which the current site belongs + chunk_index = next(i for i, size in enumerate(self.chunk_sizes) if self.counter < sum(self.chunk_sizes[:i + 1])) + + # get the type + t = f'chunk{chunk_index}' + + # update the counter + self.counter += 1 + + return t + + +class RandomStratification(Stratification): + """""" + Stratify the SFS randomly into a fixed number of bins. + Can be used to analyze expected sampling variance between different stratifications. + """""" + + def __init__(self, n_bins: int, seed: Optional[int] = 0): + """""" + Initialize random stratification. + + :param n_bins: Number of bins to randomly assign sites to. + """""" + super().__init__() + + if n_bins < 1: + raise ValueError(""n_bins must be at least 1."") + + #: Number of bins + self.num_bins: int = n_bins + + #: Random seed for reproducibility + self.seed: Optional[int] = seed + + #: Random generator instance + self.rng = random.Random(seed) + + @_count_valid_type + def get_type(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: + """""" + Assign the variant to a random bin. + + :param variant: The VCF site + :return: Randomly chosen bin label + """""" + return f""bin{self.rng.randint(0, self.num_bins - 1)}"" + + def get_types(self) -> List[str]: + """""" + Get all possible bin labels. + + :return: List of bin labels + """""" + return [f""bin{i}"" for i in range(self.num_bins)] + + +class TargetSiteCounter: + """""" + Class for counting the number of target sites when parsing a VCF file that does not contain monomorphic sites. + This class is used in conjunction with :class:`~fastdfe.parser.Parser` and samples sites from the given fasta + file that are found in between variants on the same contig that were parsed in the VCF. + Ideally, we obtain the SFS by parsing VCF files that contain both mono- and polymorphic sites. This is because + we need to know about the number of mutational opportunities for synonymous and non-synonymous sites which + contain plenty of information on the strength of selection. It is recommended to use a SNPFiltration when + using this class to avoid biasing the result by monomorphic sites present in the VCF file. + + .. warning:: + This class is not compatible with stratifications based on info tags that are pre-defined in the VCF file, as + opposed to those added dynamically using the ``annotations`` argument of the parser. We also need to + stratify mono-allelic sites which, in this case, won't be present in the VCF file so that they have no + info tags when sampling from the FASTA file, and are thus ignored by the stratifications. However, using the + ``annotations`` argument of the parser, the info tags the stratifications are based on are added on-the-fly, + also for monomorphic sites sampled from the FASTA file. + """""" + + def __init__( + self, + n_target_sites: int, + n_samples: int = int(1e5), + ): + """""" + Initialize counter. + + :param n_target_sites: The total number of sites (mono- and polymorphic) that would be present in the VCF file + if it contained monomorphic sites. This number should be considerably larger than the number of polymorphic + sites in the VCF file. This value is not extremely important for the DFE inference, the ratio of synonymous + to non-synonymous sites being more informative, but the order of magnitude should be correct, in any case. + :param n_samples: The number of sites to sample from the fasta file. Many sampled sites will not be valid as + they are non-coding. To obtain good estimates, a few thousand sites should be sampled per type of site + (depending on the stratifications used). + """""" + #: The logger + self._logger = logger.getChild(self.__class__.__name__) + + #: The total number of sites considered when parsing the VCF + self.n_target_sites: int | None = int(n_target_sites) + + #: Number of samples + self.n_samples: int = int(n_samples) + + #: The spectra before inferring the number of target sites + self._sfs_polymorphic: Spectra | None = None + + def _setup(self, parser: 'Parser'): + """""" + Set up the counter. + + :param parser: The parser + """""" + self.parser = parser + + # require fasta file + self.parser._require_fasta(self.__class__.__name__) + + # check if we have a SNPFiltration + if not any([isinstance(f, SNPFiltration) for f in self.parser.filtrations]): + self._logger.warning(""It is recommended to use SNPFiltration together with "" + ""TargetSiteCounter to avoid biasing the result by monomorphic sites."") + + # check if have degeneracy stratification but no degeneracy annotation + if any([isinstance(s, DegeneracyStratification) for s in self.parser.stratifications]) \ + and not any([isinstance(a, DegeneracyAnnotation) for a in self.parser.annotations]): + self._logger.warning(""When using TargetSiteCounter with DegeneracyStratification, "" + ""make sure to provide DegeneracyAnnotation to make sure the "" + ""sites sampled from the FASTA file have a degeneracy tag."") + + def _teardown(self): + """""" + Perform any necessary post-processing. + """""" + # tear down parser + self.parser._teardown() + + def _suspend_snp_filtration(self): + """""" + Suspend SNP filtration to make sure we sample can actually sample monomorphic sites. + """""" + # store original filtrations + self._filtrations = self.parser.filtrations + + # remove SNPFiltration + self.parser.filtrations = [f for f in self.parser.filtrations if not isinstance(f, SNPFiltration)] + + def _resume_snp_filtration(self): + """""" + Resume SNP filtration. + """""" + # restore original filtrations + self.parser.filtrations = self._filtrations + + def count(self): + """""" + Count the number of target sites. + + :return: The number of target sites + """""" + # rewind parser components + self.parser._rewind() + + # suspend SNP filtration + self._suspend_snp_filtration() + + # rewind fasta iterator + FASTAHandler._rewind(self.parser) + + # initialize random number generator + rng = np.random.default_rng(self.parser.seed) + + # initialize progress bar + pbar = tqdm( + total=self.n_samples, + desc=f'{self.__class__.__name__}>Sampling target sites', + disable=Settings.disable_pbar + ) + + # get array of ranges per contig of parsed variants + ranges = np.array(list(self.parser._contig_bounds.values())) + + # get range sizes + range_sizes = ranges[:, 1] - ranges[:, 0] + + # determine sampling probabilities + probs = range_sizes / np.sum(range_sizes) + + # sample number of sites per contig + samples = rng.multinomial(self.n_samples, probs) + + # keep track of SFS before update + self._sfs_polymorphic = Spectra(self.parser.sfs) + + # initialize counter + i = 0 + + # iterate over contigs + for contig, bounds, n in zip(self.parser._contig_bounds.keys(), ranges, samples): + + # get aliases + aliases = self.parser.get_aliases(contig) + + # make sure we have a valid range + if bounds[1] > bounds[0] and n > 0: + + self._logger.debug(f""Sampling {n} sites from contig '{contig}'."") + + # fetch contig + record = self.parser.get_contig(aliases, notify=False) + + # get positions + # we sort in ascending order as the parser expects the positions to be sorted + positions = np.sort(rng.integers(*bounds, size=n)) + + # sample sites + for pos in positions: + + # create dummy variant + variant = DummyVariant( + ref=record.seq[pos - 1], # fasta is 0-based + pos=pos, # VCF is 1-based + chrom=contig + ) + + # check if site was included in the SFS + if self.parser._process_site(variant): + i += 1 + + # update progress bar + pbar.update() + + # close progress bar + pbar.close() + + # resume SNP filtration + self._resume_snp_filtration() + + # tear down + self._teardown() + + # notify on number of sites included in the SFS + self._logger.info(f""{i} out of {self.n_samples} sampled sites were valid."") + + def _update_target_sites(self, spectra: Spectra) -> Spectra: + """""" + Update the target sites of the spectra. + + :param spectra: The spectra, including the sampled monomorphic sites. + :return: The updated spectra. + """""" + # copy spectra + spectra = spectra.copy() + + # cast to float to avoid implicit type conversion later on + spectra.data = spectra.data.astype(float) + + # subtract by monomorphic counts of original spectra + # we only want to consider the monomorphic sites sampled from the FASTA file + spectra.data.iloc[[0, -1], :] -= self._sfs_polymorphic.data.iloc[[0, -1], :] + + # get number of monomorphic and polymorphic sites sampled from the FASTA and VCF file + n_monomorphic = spectra.data.iloc[0, :].sum() + n_polymorphic = spectra.data.iloc[1:, :].sum().sum() + + # check if we have enough target sites + if self.n_target_sites < n_polymorphic: + self._logger.warning(f""Number of polymorphic sites ({n_polymorphic}) exceeds the total "" + f""number of target sites ({self.n_target_sites}) which does not make sense. "" + f""The number of target sites unchanged is left unchanged."") + elif n_monomorphic == 0: + self._logger.warning(f""Number of monomorphic sites is zero which should only happen "" + f""if there are very few sites considered. Failed to adjust "" + f""the number of monomorphic sites."") + else: + + # compute multiplicative factor to scale the total number of sites + # to the number of target sites plus the number of polymorphic sites + x = (self.n_target_sites + self._sfs_polymorphic.n_polymorphic.sum() - n_polymorphic) / n_monomorphic + + # extrapolate monomorphic counts using scaling factor + spectra.data.iloc[0, :] *= x + + # subtract polymorphic counts from original spectra, + # so that the total number of sites is equal to the number of target sites + # we do this to correct for the fact that, for a type, we have relatively + # fewer monomorphic sites if we have more polymorphic sites + # TODO include monomorphic sites here from VCF? + spectra.data.iloc[0, :] -= self._sfs_polymorphic.n_polymorphic + + return spectra + + +class Parser(MultiHandler): + """""" + Parse site-frequency spectra from VCF files. + + By default, the parser looks at the ``AA`` tag in the VCF file's info field to retrieve + the correct polarization. Polymorphic sites for which this tag is not well-defined are by default + ignored (see ``skip_non_polarized``). + + This class also offers on-the-fly annotation of the VCF sites such as site degeneracy and + ancestral allele state. This is done by providing a list of annotations to the parser which are + applied in the order they are provided. + + The parser also allows to filter sites based on site properties which is done by + passing a list of filtrations. By default, we filter out poly-allelic sites as sites are assumed to be + at most bi-allelic. + + In addition, the parser allows to stratify the SFS by providing a list of stratifications. This is useful + to obtain the SFS for different types of sites for which we can jointly infer the DFEs using + :class:`~fastdfe.joint_inference.JointInference`. + + To correctly determine the number of target sites when parsing a VCF file that does not contain monomorphic sites, + we can use a :class:`~fastdfe.parser.TargetSiteCounter`. This class is used in conjunction with the parser and + samples sites from the given FASTA file that are found in between variants on the same contig that were parsed + in the VCF. + + Note that we assume the sites in the VCF file to be sorted by position in ascending order (per contig). + + Example usage: + + :: + + import fastdfe as fd + + # Parse selected and neutral SFS from human chromosome 1. + p = fd.Parser( + vcf=""https://ngs.sanger.ac.uk/production/hgdp/hgdp_wgs.20190516/"" + ""hgdp_wgs.20190516.full.chr21.vcf.gz"", + fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" + ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", + gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", + aliases=dict(chr21=['21']), # mapping for contig names + n=10, # SFS sample size + # we use a target site counter to infer the number of target sites. + target_site_counter=fd.TargetSiteCounter( + n_samples=1000000, + # determine number of target sites by looking at total length of coding sequences + n_target_sites=fd.Annotation.count_target_sites( + ""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"" + )['21'] + ), + # add degeneracy annotation for sites + annotations=[ + fd.DegeneracyAnnotation() + ], + filtrations=[ + # exclude non-SNPs as we infer monomorphic sites with target site counter + fd.SNPFiltration(), + # filter out sites not in coding sequences + fd.CodingSequenceFiltration() + ], + # stratify by 4-fold/0-fold degeneracy + stratifications=[fd.DegeneracyStratification()], + info_ancestral='AA_ensembl' + ) + + sfs = p.parse() + + sfs.plot() + + """""" + + def __init__( + self, + vcf: str, + n: int, + gff: str | None = None, + fasta: str | None = None, + info_ancestral: str = 'AA', + info_ancestral_prob: str = 'AA_prob', + skip_non_polarized: bool = True, + stratifications: List[Stratification] = [], + annotations: List[Annotation] = [], + filtrations: List[Filtration] = None, + include_samples: List[str] = None, + exclude_samples: List[str] = None, + max_sites: int = np.inf, + seed: int | None = 0, + cache: bool = True, + aliases: Dict[str, List[str]] = {}, + target_site_counter: TargetSiteCounter = None, + subsample_mode: Literal['random', 'probabilistic'] = 'probabilistic', + polarize_probabilistically: bool = False + ): + """""" + Initialize the parser. + + :param vcf: The path to the VCF file, can be gzipped or a URL. + :param gff: The path to the GFF file, possibly gzipped or a URL. This file is optional and depends on + the stratifications, annotations and filtrations that are used. + :param fasta: The path to the FASTA file, possibly gzipped or a URL. This file is optional and depends on + the annotations and filtrations that are used. + :param n: The size of the resulting SFS. We down-sample to this number by drawing without replacement from + the set of all available genotypes per site. Sites with fewer than ``n`` genotypes are skipped. + :param info_ancestral: The tag in the INFO field that contains ancestral allele information. Consider using + an ancestral allele annotation if this information is not available yet. + :param skip_non_polarized: Whether to skip poly-morphic sites that are not polarized, i.e., without a valid + info tag providing the ancestral allele. If ``False``, we use the reference allele as ancestral allele + (only recommended if working with folded spectra). + :param stratifications: List of stratifications to use. + :param annotations: List of annotations to use. + :param filtrations: List of filtrations to use. By default, we use + :class:`~fastdfe.filtration.PolyAllelicFiltration`. + :param include_samples: List of sample names to consider when determining the SFS. If ``None``, all samples + are used. Note that this restriction does not apply to the annotations and filtrations. + :param exclude_samples: List of sample names to exclude when determining the SFS. If ``None``, no samples + are excluded. Note that this restriction does not apply to the annotations and filtrations. + :param max_sites: Maximum number of sites to parse from the VCF file. + :param seed: Seed for the random number generator. Use ``None`` for no seed. + :param cache: Whether to cache files downloaded from URLs. + :param aliases: Dictionary of aliases for the contigs in the VCF file, e.g. ``{'chr1': ['1']}``. + This is used to match the contig names in the VCF file with the contig names in the FASTA file and GFF file. + :param target_site_counter: The target site counter. If ``None``, we do not sample target sites. + :param subsample_mode: The subsampling mode. For ``random``, we draw once without replacement from the set of + all available genotypes per site. For ``probabilistic``, we add up the hypergeometric distribution for all + sites. This will produce a smoother SFS, especially when a small number of sites is considered. + :param polarize_probabilistically: Whether to probabilistically polarize sites. In addition to the ``AA`` tag + (see ``info_ancestral``), we use the ``AA_prob`` tag (see ``info_ancestral_prob``) to polarize sites + probabilistically. For example, if the ancestral allele is ``A`` with a probability of 0.8 and + the derived allele is ``G``, we assign 0.8 probability mass to the ancestral allele and 0.2 to the + derived allele. This should enhance accuracy, especially for small datasets. Whenever the ancestral + probability tag is not present, we assume a probability of 1 for the ancestral allele. + """""" + MultiHandler.__init__( + self, + vcf=vcf, + gff=gff, + fasta=fasta, + info_ancestral=info_ancestral, + max_sites=max_sites, + seed=seed, + cache=cache, + aliases=aliases + ) + + # warn if SynonymyAnnotation is used + if any(isinstance(a, SynonymyAnnotation) for a in annotations): + logger.warning(""SynonymyAnnotation is not recommended to be used with the parser as "" + ""it is not possible to determine the synonymy of monomorphic sites. "" + ""Consider using DegeneracyAnnotation instead."") + + #: The target site counter + self.target_site_counter: TargetSiteCounter | None = target_site_counter + + #: The number of individuals in the sample + self.n: int = int(n) + + #: The list of samples to include + self.include_samples: List[str] | None = include_samples + + #: The list of samples to exclude + self.exclude_samples: List[str] | None = exclude_samples + + #: The mask of samples to use + self._samples_mask: np.ndarray | None = None + + #: Whether to skip sites that are not polarized, i.e., without a valid info tag providing the ancestral allele + self.skip_non_polarized: bool = skip_non_polarized + + #: List of stratifications to use + self.stratifications: List[Stratification] = stratifications + + #: List of annotations to use + self.annotations: List[Annotation] = annotations + + #: List of filtrations to use + self.filtrations: List[Filtration] = [PolyAllelicFiltration()] if filtrations is None else filtrations + + #: The number of sites that were skipped for various reasons + self.n_skipped: int = 0 + + # The number of sites with a valid ancestral allele probability + self.n_aa_prob: int = 0 + + #: The number of sites that were skipped because they had no valid ancestral allele + self.n_no_ancestral: int = 0 + + #: Dictionary of SFS indexed by joint type + self.sfs: Dict[str, np.ndarray] = defaultdict(lambda: np.zeros(self.n + 1)) + + #: 1-based positions of lowest and highest site position per contig (only when target_site_counter is used) + # noinspection PyTypeChecker + self._contig_bounds: Dict[str, Tuple[int, int]] = defaultdict(lambda: (np.inf, -np.inf)) + + if subsample_mode not in ['random', 'probabilistic']: + raise ValueError(f""Subsampling mode '{subsample_mode}' is not valid. "" + f""Valid modes are 'random' and 'probabilistic'."") + + #: The subsampling mode + self.subsample_mode: Literal['random', 'probabilistic'] = subsample_mode + + #: The tag in the INFO field that contains the ancestral allele probability + self.info_ancestral_prob: str = info_ancestral_prob + + #: Whether to probabilistically polarize sites + self.polarize_probabilistically: bool = polarize_probabilistically + + def _get_ancestral(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str: + """""" + Determine the ancestral allele. + + :param variant: The vcf site + :return: Ancestral allele + :raises NoTypeException: If the site is not polarized and ``skip_non_polarized`` is ``True`` or if + the ancestral allele or reference allele (in case of monomorphic sites) is not a valid base. + """""" + if variant.is_snp: + # obtain ancestral allele + aa = variant.INFO.get(self.info_ancestral) + + # return the ancestral allele if it is a valid base + if aa in bases: + return aa + + # if we skip non-polarized sites, we raise an error here + if self.skip_non_polarized: + raise NoTypeException(""No valid AA tag found"") + + # if we don't skip non-polarized sites, or if the site is not an SNP + # we return the reference allele if valid + if variant.REF in bases: + return variant.REF + + # if the reference allele is not a valid base, we raise an error + raise NoTypeException(""Reference allele is not a valid base"") + + def _get_ancestral_prob(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> float: + """""" + Determine the ancestral allele probabilistically. + + :param variant: The vcf site + :return: The probability of the ancestral allele being the true ancestral allele + """""" + if variant.is_snp and self.polarize_probabilistically and variant.INFO.get( + self.info_ancestral_prob) is not None: + self.n_aa_prob += 1 + return variant.INFO[self.info_ancestral_prob] + + return 1.0 + + def _parse_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Parse a single site. + + :param variant: The variant. + :return: Whether the site was included in the SFS. + """""" + # check `is_snp` property for performance reasons but site may still be monomorphic + if variant.is_snp: + + # obtain called bases + genotypes = get_called_bases(variant.gt_bases[self._samples_mask]) + + # number of samples + n_samples = len(genotypes) + + # skip if not enough samples + if n_samples < self.n: + self._logger.debug(f'Skipping site due to too few samples at {variant.CHROM}:{variant.POS}.') + return False + + try: + # determine ancestral allele + aa = self._get_ancestral(variant) + except NoTypeException: + self.n_no_ancestral += 1 + return False + + # determine ancestral allele probability + aa_prob = self._get_ancestral_prob(variant) + + # count called bases + counter = Counter(genotypes) + + # determine ancestral allele count + n_aa = counter[aa] + + if len(counter) > 2: + self._logger.debug(f'Site has more than two alleles at {variant.CHROM}:{variant.POS} ({dict(counter)})') + return False + + # determine down-projected allele count. + if self.subsample_mode == 'random': + m = np.zeros(self.n + 1) + k = hypergeom.rvs(M=n_samples, n=n_samples - n_aa, N=self.n, random_state=self.rng) + + m[k] += aa_prob + m[self.n - k] += 1 - aa_prob + else: + # subsample probabilistically drawing from the hypergeometric distribution (without replacement) + m = hypergeom.pmf(k=range(self.n + 1), M=n_samples, n=n_samples - n_aa, N=self.n) + + # polarize probabilistically if site is bi-allelic + if len(counter) == 2: + m = aa_prob * m + (1 - aa_prob) * m[::-1] + + # if we have a mono-allelic SNPs + elif is_monomorphic_snp(variant): + # if we don't have an SNP, we assume the reference allele to be the ancestral allele, + # so the derived allele count is 0 + # The polarization of monomorphic sites is not important for DFE inference with fastDFE, in any case + m = np.zeros(self.n + 1) + m[0] = 1 + else: + # skip other types of sites + self._logger.debug(f'Site is not a valid single nucleotide site at {variant.CHROM}:{variant.POS}.') + return False + + # try to obtain type + try: + # create joint type + t = '.'.join([s.get_type(variant) for s in self.stratifications]) or 'all' + + # add mass + self.sfs[t] += m + + except NoTypeException as e: + self._logger.debug(e) + return False + + return True + + def _process_site(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> bool: + """""" + Handle a single variant. + + :param variant: The variant + :return: Whether the site was included in the SFS. + """""" + # filter the variant + for filtration in self.filtrations: + if not filtration.filter_site(variant): + return False + + # apply annotations + for annotation in self.annotations: + annotation.annotate_site(variant) + + # parse site + return self._parse_site(variant) + + def _rewind(self): + """""" + Rewind the filtrations, annotations and stratifications, and fasta handler. + """""" + FASTAHandler._rewind(self) + + for f in self.filtrations: + f._rewind() + + for a in self.annotations: + a._rewind() + + for s in self.stratifications: + s._rewind() + + def _setup(self): + """""" + Set up the parser. + """""" + # set up target site counter + if self.target_site_counter is not None: + self.target_site_counter._setup(self) + + # make parser available to stratifications + for s in self.stratifications: + s._setup(self) + + # create a string representation of the stratifications + representation = '.'.join(['[' + ', '.join(s.get_types()) + ']' for s in self.stratifications]) or ""[all]"" + + # log the stratifications + self._logger.info(f'Using stratification: {representation}.') + + # prepare samples mask + self._prepare_samples_mask() + + # setup annotations + for annotation in self.annotations: + annotation._setup(self) + + # setup filtrations + for f in self.filtrations: + f._setup(self) + + def _prepare_samples_mask(self): + """""" + Prepare the samples mask. + """""" + # determine samples to include + if self.include_samples is None: + mask = np.ones(len(self._reader.samples)).astype(bool) + else: + mask = np.isin(self._reader.samples, self.include_samples) + + # determine samples to exclude + if self.exclude_samples is not None: + mask &= ~np.isin(self._reader.samples, self.exclude_samples) + + self._samples_mask = mask + + def _teardown(self): + """""" + Tear down parser components. + """""" + # tear down all objects + for f in self.filtrations: + f._teardown() + + for s in self.stratifications: + s._teardown() + + for a in self.annotations: + a._teardown() + + def parse(self) -> Spectra: + """""" + Parse the VCF file. + + :return: The spectra for the different stratifications + """""" + # set up parser + self._setup() + + pbar = self.get_pbar( + total=self.n_sites, + desc=f""{self.__class__.__name__}>Processing sites"" + ) + + # iterate over variants + for i, variant in enumerate(self._reader): + + # handle site + if self._process_site(variant): + + if self.target_site_counter is not None: + # update bounds + low, high = self._contig_bounds[variant.CHROM] + self._contig_bounds[variant.CHROM] = (min(low, variant.POS), max(high, variant.POS)) + else: + self.n_skipped += 1 + + # update progress bar + pbar.update() + + # explicitly stopping after ``n`` sites fixes a bug with cyvcf2: + # 'error parsing variant with `htslib::bcf_read` error-code: 0 and ret: -2' + if i + 1 == self.n_sites or i + 1 == self.max_sites: + break + + # close progress bar + pbar.close() + + # tear down components + self._teardown() + + # inform about number of sites without ancestral tag + if self.n_no_ancestral > 0: + self._logger.info(f'Skipped {self.n_no_ancestral} sites without ancestral allele information.') + + if len(self.sfs) == 0: + self._logger.warning(f""No sites were included in the spectra. If this is not expected, "" + ""please check that all components work as expected. You can also "" + ""set the log level to DEBUG."") + + # warn that sites might not be polarized + if self.skip_non_polarized and not any(isinstance(a, AncestralAlleleAnnotation) for a in self.annotations): + self._logger.warning(""Your variants might not be polarized and are thus not included in the spectra. "" + ""If this is the case, consider annotating the ancestral states or setting "" + ""'Parser.skip_non_polarized' to False."") + else: + n_included = self.n_sites - self.n_skipped + + self._logger.info(f'Included {n_included} out of {self.n_sites} sites in total from the VCF file.') + + if self.polarize_probabilistically: + self._logger.info(f'Considered {self.n_aa_prob} sites with valid ancestral allele probability.') + + # close VCF reader + VCFHandler._rewind(self) + + # count target sites + if self.target_site_counter is not None and self.n_skipped < self.n_sites: + # count target sites + self.target_site_counter.count() + + # update target sites + self.sfs = self.target_site_counter._update_target_sites(Spectra(dict(self.sfs))).to_dict() + + return Spectra(dict(self.sfs)).sort_types() +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/utils.py",".py","1264","57",""""""" +Utilities for fastDFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2025-12-19"" + +from abc import ABC +from typing_extensions import Self + +import jsonpickle + + +class Serializable(ABC): + """""" + Mixin class for serializable objects. + """""" + + def to_json(self) -> str: + """""" + Serialize object. + + :return: JSON string + """""" + return jsonpickle.encode(self, indent=4, warn=True) + + def to_file(self, file: str): + """""" + Save object to file. + + :param file: File to save to + """""" + with open(file, 'w') as fh: + fh.write(self.to_json()) + + @classmethod + def from_json(cls, json: str, classes=None) -> Self: + """""" + Unserialize object. + + :param classes: Classes to be used for unserialization + :param json: JSON string + """""" + return jsonpickle.decode(json, classes=classes) + + @classmethod + def from_file(cls, file: str, classes=None) -> Self: + """""" + Load object from file. + + :param classes: Classes to be used for unserialization. + :param file: File to load from + """""" + with open(file, 'r') as fh: + return cls.from_json(fh.read(), classes) +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/parametrization.py",".py","40992","1193",""""""" +DFE parametrizations. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import logging +import warnings +from abc import abstractmethod, ABC +from functools import wraps +from typing import Callable, List, Union, Dict, Tuple, Literal, Sequence, Optional + +import numpy as np +import pandas as pd +from scipy.stats import gamma, expon + +from fastdfe.utils import Serializable + +# get logger +logger = logging.getLogger('fastdfe') + + +def _from_string(model: Union['Parametrization', str]) -> 'Parametrization': + """""" + Return Parametrization from class name string. + + :param model: Class name string or parametrization object + :return: Parametrization object + """""" + if isinstance(model, Parametrization): + return model + + if isinstance(model, str): + return globals()[model]() + + raise ValueError(f'Unknown parametrization: {model}') + + +def _to_string(model: Union['Parametrization', str]) -> str: + """""" + Return class name string from Parametrization. + + :param model: Class name string or Parametrization object + :return: Class name string + """""" + if isinstance(model, Parametrization): + return model.__class__.__name__ + + return model + + +class Parametrization(Serializable, ABC): + """""" + Base class for DFE parametrizations. + + Note that :func:`get_pdf` is not required to be implemented, provided that the + linearized mode of fastDFE is used (which is highly recommended). + """""" + + #: Default initial parameters + x0: Dict[str, float] = {} + + #: Default parameter bounds + bounds: Dict[str, Tuple[float, float]] = {} + + #: Scales over which to optimize the parameters, either 'log' or 'lin' + scales: Dict[str, Literal['lin', 'log']] = {} + + #: The kind of submodels supported by holding some parameters fixed + submodels: Dict[str, Dict[str, float]] = dict( + full=dict(), + dele=dict() + ) + + def __init__( + self, + bounds: Optional[Dict[str, Tuple[float, float]]] = None, + scales: Optional[Dict[str, Literal['lin', 'log']]] = None, + x0: Optional[Dict[str, float]] = None + ): + """""" + Initialize parametrization. + + :param bounds: Custom parameter bounds merging with defaults + :param scales: Custom scales merging with defaults + :param x0: Custom initial parameters merging with defaults + """""" + self._logger = logger.getChild(self.__class__.__name__) + + # merge custom settings + if bounds is not None: + self.bounds = self.bounds | bounds + + if scales is not None: + self.scales = self.scales | scales + + if x0 is not None: + self.x0 = self.x0 | x0 + + #: argument names + self.param_names: List = list(self.x0.keys()) + + @staticmethod + def _accepts_scalars(func: Callable) -> Callable[[np.ndarray | float], np.ndarray | float]: + """""" + Make func accept scalar values. + + :return: Function that accepts scalars + """""" + + @wraps(func) + def wrapper(S: np.ndarray, *args, **kwargs) -> np.ndarray: + """""" + Wrapper function. + + :param S: Array of selection coefficients + :param args: Positional arguments + :param kwargs: Keyword arguments + :return: Output of func + """""" + if isinstance(S, (int, float)): + return func(np.array([S]), *args, **kwargs)[0] + else: + return func(S, *args, **kwargs) + + return wrapper + + @abstractmethod + def get_pdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get probability distribution function of DFE. + + :return: Function that accepts an array of selection coefficients and returns their probability density + """""" + pass + + @abstractmethod + def get_cdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get probability distribution function of DFE. + + :return: Function that accepts an array of selection coefficients and returns their cumulative probability + """""" + pass + + def _discretize( + self, + params, + bins: np.ndarray, + warn_mass: bool = True + ) -> np.ndarray: + """""" + Discretize by using the CDF. + + :param params: Parameters of the parametrization + :param bins: Bins to use for discretization + :param warn_mass: Whether to warn if the total mass is not near 1. + :return: Histogram + """""" + x = self.get_cdf(**params)(bins) + + # issue warning if values at bounds are outside [0, 1] + if warn_mass and (not -1e-5 < x[0] < 1e-5 or not 1 - 1e-5 < x[-1] < 1 + 1e-5): + self._logger.warning(f'CDF evaluates to {(x[0], x[-1])} at the lower and upper ' + f'bounds, which is a bit off from the expected (0, 1). ' + f'Used parameters: {params}.') + + # compute histogram + hist = x[1:] - x[:-1] + + return hist + + def _normalize(self, params: dict) -> dict: + """""" + Normalize parameters. + + :param params: Parameters of the parametrization + :return: Normalized parameters + """""" + # do nothing by default + return params + + def plot( + self, + params: dict, + intervals: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + file: str = None, + show: bool = True, + title: str = 'discretized DFE', + ax: 'plt.Axes' = None + + ) -> 'plt.Axes': + """""" + Plot the discretized DFE. + + :param params: Parameters of the parametrization + :param intervals: Intervals to use for discretization. + :param file: File to save the plot to. + :param show: Whether to show the plot. + :param title: Title of the plot. + :param ax: Axes to use for the plot. + :return: Axes + """""" + from .visualization import Visualization + + values = self._discretize(params, np.array(intervals), warn_mass=False) + + # check for nan values + if np.isnan(values).any(): + self._logger.warning(f'NaN values in discretized DFE. Are the parameters valid?') + + return Visualization.plot_discretized( + values=[values], + file=file, + show=show, + intervals=np.array(intervals), + title=title, + ax=ax + ) + + def freeze( + self, + params: Dict[str, float] + ) -> 'DFE': + """""" + Freeze parameters to create a DFE object. + + :param params: Parameters of the parametrization + :return: DFE object + """""" + return DFE(model=self, params=params) + + +class GammaExpParametrization(Parametrization): + r"""""" + Parametrization for mixture of a gamma and exponential distribution. This corresponds to + model C in polyDFE. + + We have the following probability density function: + + .. math:: + \phi(S; S_d, b, p_b, S_b) = (1 - p_b) f_\Gamma(-S; S_d, b) \cdot \mathbf{1}_{\{S < 0\}} + + p_b f_e(S; S_b) \cdot \mathbf{1}_{\{S \geq 0\}} + + where: + + * :math:`S_d` is the mean of the DFE for :math:`S < 0` + * :math:`b` is the shape of the gamma distribution + * :math:`p_b` is the probability that :math:`S \geq 0` + * :math:`S_b` is the mean of the DFE for :math:`S \geq 0` + * :math:`f_\Gamma(x; m, b)` is the density of the gamma distribution with mean :math:`m` and shape :math:`b` + * :math:`f_e(x; m)` is the density of the Exponential distribution with mean :math:`m` + * :math:`\mathbf{1}_{\{A\}}` denotes the indicator function, which is 1 if :math:`A` is true, and 0 otherwise. + + The DFE has often been observed to be multi-modal for negative selection coefficients. A gamma distribution + provides a good amount of flexibility to accommodate this. Note that all :math:`S` parameters are population-scaled + selection coefficients, i.e. :math:`S = 4N_es`. + + """""" + + #: Default initial parameters + x0: Dict[str, float] = dict( + S_d=-1000, + b=0.4, + p_b=0.05, + S_b=1 + ) + + #: Default parameter bounds, using non-zero lower bounds for S_d and S_b due to log-scaled scales + bounds: Dict[str, Tuple[float, float]] = dict( + S_d=(-1e5, -1e-2), + b=(0.01, 10), + p_b=(0, 0.5), + S_b=(1e-4, 100) + ) + + #: Scales over which to optimize the parameters + scales: Dict[str, Literal['lin', 'log']] = dict( + S_d='log', + b='log', + p_b='lin', + S_b='log' + ) + + #: The kind of submodels supported by holding some parameters fixed + submodels: Dict[str, Dict[str, float]] = dict( + full=dict(), + dele=dict( + p_b=0, + S_b=1 + ) + ) + + @staticmethod + def get_pdf(S_d: float, b: float, p_b: float, S_b: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get PDF. + + :param S_d: Mean selection coefficient for deleterious mutations + :param b: Shape parameter for gamma distribution + :param p_b: Probability of a beneficial mutation + :param S_b: Mean selection coefficient for beneficial mutations + :return: Function that accepts an array of selection coefficients and returns their probability density + """""" + + @Parametrization._accepts_scalars + def pdf(S: np.ndarray) -> np.ndarray: + """""" + The PDF. + + :param S: Selection coefficients + :return: Probability density + """""" + x = np.zeros_like(S, dtype=float) + + # The gamma distribution may approach infinity as S -> 0 + # so in order to evaluate this function at s = 0, + # we use--unlike polyDFE--the exponential mixture + # distribution at this point. + negative = S < 0 + + # positive S + x[negative] = (1 - p_b) * gamma.pdf(-S[negative], b, scale=-S_d / b) + + # Allow for S_b == 0 when p_b == 0 as well + # which would produce an error otherwise. + if S_b == 0 and p_b == 0: + x[~negative] = 0 + else: + # non-negative S + x[~negative] = p_b * expon.pdf(S[~negative], scale=S_b) + + return x + + return pdf + + @staticmethod + def get_cdf(S_d: float, b: float, p_b: float, S_b: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get CDF. + + :param S_d: Mean selection coefficient for deleterious mutations + :param b: Shape parameter for gamma distribution + :param p_b: Probability of a beneficial mutation + :param S_b: Mean selection coefficient for beneficial mutations + :return: Function that accepts an array of selection coefficients and returns their cumulative probability + """""" + + @Parametrization._accepts_scalars + def cdf(S: np.ndarray) -> np.ndarray: + """""" + The CDF. + + :param S: Selection coefficients + :return: Cumulative probability + """""" + x = np.zeros_like(S, dtype=float) + + negative = S < 0 + + # positive S + x[negative] = (1 - p_b) - ((1 - p_b) * gamma.cdf(-S[negative], b, scale=-S_d / b)) + + # Allow for S_b = 0 when p_b = 0 as well + # which would produce an error otherwise. + if S_b == 0 and p_b == 0: + x[~negative] = 1 + else: + # non-negative S + x[~negative] = (1 - p_b) + p_b * expon.cdf(S[~negative], scale=S_b) + + return x + + return cdf + + +class DisplacedGammaParametrization(Parametrization): + r"""""" + Parametrization for a reflected displaced gamma distribution. + + We have the following probability density function: + + .. math:: + \phi(S; \hat{S}, b, S_{max}) = f_\Gamma(S_{max} - S; S_{max} - \hat{S}, b) \cdot \mathbf{1}_{\{S \leq S_{max}\}} + + where: + + * :math:`\hat{S}` is the mean of the DFE + * :math:`b` is the shape of the gamma distribution + * :math:`S_{max}` is the maximum value that :math:`S` can take + * :math:`f_\Gamma(x; m, b)` is the density of the gamma distribution with mean :math:`m` and shape :math:`b` + * :math:`\mathbf{1}_{\{A\}}` denotes the indicator function, which is 1 if :math:`A` is true, and 0 otherwise. + + This parametrization uses a single gamma distribution for both positive and negative selection coefficients. + This is a less flexible parametrization, which may produce results similar to the other models while requiring + fewer parameters. Note that all :math:`S` parameters are population-scaled selection coefficients, i.e. + :math:`S = 4N_es`. + + .. warning:: + This model does not allow for a purely deleterious sub-parametrization, so + :meth:`Inference.compare_nested_models` won't work as expected. + + """""" + + #: Default initial parameters + x0: Dict[str, float] = dict( + S_mean=-100, + b=1, + S_max=1 + ) + + #: Default parameter bounds + bounds: Dict[str, Tuple[float, float]] = dict( + S_mean=(-100000, -0.01), + b=(0.01, 10), + S_max=(0.001, 100) + ) + + #: Scales over which to optimize the parameters + scales: Dict[str, Literal['lin', 'log']] = dict( + S_mean='log', + b='lin', + S_max='log' + ) + + #: The kind of submodels supported by holding some parameters fixed + submodels: Dict[str, Dict[str, float]] = dict( + full=dict(), + dele=dict() + ) + + @staticmethod + def get_pdf(S_mean: float, b: float, S_max: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get PDF. + + :return: Function that accepts an array of selection coefficients and returns their probability density + """""" + + @Parametrization._accepts_scalars + def pdf(S: np.ndarray) -> np.ndarray: + """""" + The PDF. + + :param S: Selection coefficients + :return: Probability density + """""" + x = np.zeros_like(S, dtype=float) + + # calculate the probability density for S <= S_max + is_lower = S <= S_max + x[is_lower] = gamma.pdf(S_max - S[is_lower], b, scale=max(S_max - S_mean, 1e-16) / b) + + return x + + return pdf + + @staticmethod + def get_cdf(S_mean: float, b: float, S_max: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get CDF. + + :return: Function that accepts an array of selection coefficients and returns their cumulative probability + """""" + + @Parametrization._accepts_scalars + def cdf(S: np.ndarray) -> np.ndarray: + """""" + The CDF. + + :param S: Selection coefficients + :return: Cumulative probability + """""" + x = np.zeros_like(S, dtype=float) + + # calculate the cumulative probability for S <= S_max + is_lower = S <= S_max + x[is_lower] = 1 - gamma.cdf(S_max - S[is_lower], b, scale=max(S_max - S_mean, 1e-16) / b) + + # set the cumulative probability to 1 for S > S_max + x[~is_lower] = 1 + + return x + + return cdf + + +class GammaDiscreteParametrization(Parametrization): + r"""""" + Parametrization for a mixture of a gamma and discrete distribution. This corresponds to polyDFE's model B. + + We have the following probability density function: + + .. math:: + \phi(S; S_d, b, p_b, S_b) = (1 - p_b) f_{\Gamma}(S; S_d, b) \cdot \mathbf{1}_{\{S < 0\}} + + p_b \cdot S_b \cdot \mathbf{1}_{\{0 \leq S \leq 1 / S_b\}} + + where: + + * :math:`S_d` is the mean of the DFE for :math:`S < 0` + * :math:`b` is the shape of the gamma distribution + * :math:`p_b` is the probability that :math:`S \geq 0` + * :math:`S_b` is the shared selection coefficient of all positively selected mutations up to :math:`1/S_b` + * :math:`f_\Gamma(x; m, b)` is the density of the gamma distribution with mean :math:`m` and shape :math:`b` + + This parametrization is similar to :class:`GammaExpParametrization`, but uses a constant mass for positive + selection coefficients. The results should be rather similar in most cases. Note that all :math:`S` parameters + are population-scaled selection coefficients, i.e. :math:`S = 4N_es`. + """""" + + #: Default initial parameters + x0: Dict[str, float] = dict( + S_d=-1000, + b=0.4, + p_b=0.05, + S_b=1 + ) + + #: default parameter bounds + bounds: Dict[str, Tuple[float, float]] = dict( + S_d=(-1e5, -1e-2), + b=(0.01, 10), + p_b=(0, 0.5), + S_b=(1e-4, 100) + ) + + #: scales over which to optimize the parameters + scales: Dict[str, Literal['lin', 'log']] = dict( + S_d='log', + b='log', + p_b='lin', + S_b='log' + ) + + #: The kind of submodels supported by holding some parameters fixed + submodels: Dict[str, Dict[str, float]] = dict( + full=dict(), + dele=dict( + p_b=0, + S_b=1 + ) + ) + + @staticmethod + def get_pdf(S_d: float, b: float, p_b: float, S_b: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get PDF. + + :param S_d: Mean of the DFE for S < 0 + :param b: Shape of the gamma distribution + :param p_b: Probability that S > 0 + :param S_b: Shared selection coefficient of all positively selected mutations up to S_b + :return: Function that accepts an array of selection coefficients and returns their probability density + """""" + + @Parametrization._accepts_scalars + def pdf(S: np.ndarray) -> np.ndarray: + """""" + The PDF. + + :param S: Selection coefficients + :return: Probability density + """""" + x = np.zeros_like(S, dtype=float) + + negative = S < 0 + x[negative] = (1 - p_b) * gamma.pdf(-S[negative], b, scale=-S_d / b) + + equal_to_S_b = (0 <= S) & (S <= 1 / S_b) + x[equal_to_S_b] = p_b * S_b + + # the density is 0 for all other cases, no need to explicitly set it + + return x + + return pdf + + @staticmethod + def get_cdf(S_d: float, b: float, p_b: float, S_b: float, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get CDF. + + :param S_d: Mean of the DFE for S < 0 + :param b: Shape of the gamma distribution + :param p_b: Probability that S > 0 + :param S_b: Shared selection coefficient of all positively selected mutations up to S_b + :return: Function that accepts an array of selection coefficients and returns their cumulative probability + """""" + + @Parametrization._accepts_scalars + def cdf(S: np.ndarray) -> np.ndarray: + """""" + The CDF. + + :param S: Selection coefficients + :return: Cumulative probability + """""" + x = np.zeros_like(S, dtype=float) + + negative = S < 0 + x[negative] = (1 - p_b) - ((1 - p_b) * gamma.cdf(-S[negative], b, scale=-S_d / b)) + + within_S_b = (0 <= S) & (S <= 1 / S_b) + x[within_S_b] = (1 - p_b) + p_b * S_b * S[within_S_b] + + greater_than_S_b = S > 1 / S_b + x[greater_than_S_b] = 1 + + return x + + return cdf + + +class DiscreteParametrization(Parametrization): + r"""""" + Parametrization for a discrete distribution. This corresponds to polyDFE's model D. + By default we use 6 bins, but this can be changed by passing a different array to the constructor. + The resulting parameter names are :math:`S_1, S_2, \dots, S_k`, where :math:`k` is the number of bins. + + That is, the probability density function is given by: + + :math:`\phi(S; S_1, S_2, \dots, S_k) = \sum_{i=1}^{k} S_i/c_i \cdot \mathbf{1}_{\{S \in B_i\}}` + such that :math:`\sum_{i=1}^{k} S_i = 1,` + + where :math:`B_i` and :math:`c_i` are interval :math:`i` and the width of interval :math:`i`, respectively. + + This parametrization has the advantage of not imposing a shape on the DFE. For a reasonably fine parametrization, + the number of parameters is larger than those of the other models, however. We generally also observe larger + confidence intervals for this parametrization, and the optimization procedure may well be less efficient as + we have to re-normalize the parameters to make sure they sum up to 1. Note that all :math:`S` parameters are + population-scaled selection coefficients, i.e. :math:`S = 4N_es`. + """""" + + def __init__( + self, + intervals: Sequence = np.array([-100000, -100, -10, -1, 0, 1, 1000]), + bounds: Optional[Dict[str, Tuple[float, float]]] = None, + scales: Optional[Dict[str, Literal['lin', 'log']]] = None, + x0: Optional[Dict[str, float]] = None + ): + """""" + Constructor. + + :param intervals: The intervals of the discrete distribution. + :param bounds: Custom parameter bounds merging with defaults + :param scales: Custom scales merging with defaults + :param x0: Custom initial parameters merging with defaults + """""" + super().__init__() + + # deprecation warning + self._logger.warning( + 'DiscreteParametrization is deprecated. Use DiscreteFractionalParametrization instead, which ' + 'has better optimization properties.' + ) + + #: Intervals + self.intervals: np.ndarray = np.concatenate(([-np.inf], intervals, [np.inf])) + + #: Interval sizes + self.interval_sizes: np.ndarray = self.intervals[1:] - self.intervals[:-1] + + #: Number of intervals, including the two infinite ones + self.k: int = self.intervals.shape[0] - 1 + + #: All parameter names, including the fixed ones + self.params: np.ndarray = np.array([f""S{i}"" for i in range(self.k)]) + + #: Parameter names that are not fixed + self.param_names: List[str] = self.params[1:-1].tolist() + + #: Fixed parameters + self.fixed_params: Dict[str, int] = {self.params[0]: 0, self.params[-1]: 0} + + #: Default initial parameters + self.x0: Dict[str, float] = dict((p, 1 / (self.k - 2)) for p in self.param_names) | (x0 or {}) + + #: Default parameter bounds + self.bounds: Dict[str, Tuple[float, float]] = dict((p, (0, 1)) for p in self.param_names) | (bounds or {}) + + #: Scales + # noinspection all + self.scales: Dict[str, Literal['lin', 'log']] = dict((p, 'lin') for p in self.param_names) | (scales or {}) + + #: Submodels + self.submodels: Dict[str, Dict[str, float]] = dict( + full=dict(), + dele=dict((p, 0) for p in self.params[1:-1][self.intervals[1:-2] >= 0]) + ) + + def _normalize(self, params: dict) -> dict: + """""" + Add params for boundaries and normalize so that + the parameters sum up to 1. + + :param params: Parameter values + :return: Dict of normalized values plus remaining parameters + """""" + # make sure we only include parameter used for this parametrization + filtered = dict((k, v) for k, v in params.items() if k in self.param_names) + + # sum up + s = np.sum(list(filtered.values())) + + # normalize and include remaining parameters + return params | dict((k, v / s) for k, v in filtered.items()) + + def get_pdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get PDF. + + :param kwargs: Parameter values S1, S2, ..., Sk + :return: Function that computes the PDF for given S values + """""" + + # normalize and add boundary parameters + values = self._normalize(kwargs) | self.fixed_params + + @Parametrization._accepts_scalars + def pdf(S: np.ndarray) -> np.ndarray: + """""" + The PDF. + + :param S: Selection coefficients + :return: Probability density + """""" + x = np.zeros_like(S, dtype=float) + + # iterate over parameters and assign values + for i, p in enumerate(self.params): + x[(self.intervals[i] < S) & (S <= self.intervals[i + 1])] = values[p] / self.interval_sizes[i] + + return x + + return pdf + + def get_cdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get CDF. + + :param kwargs: Parameter values S1, S2, ..., Sk + :return: Function that computes the CDF for given S values + """""" + + # normalize and add boundary parameters + values = self._normalize(kwargs) | self.fixed_params + + # convert to numpy arrays + intervals = np.array(self.intervals) + interval_sizes = np.array(self.interval_sizes) + + # convert to ordered array values + vals = np.array([values[self.params[i]] for i in range(self.k)]) + + @Parametrization._accepts_scalars + def cdf(S: np.ndarray) -> np.ndarray: + """""" + The CDF. + + :param S: Selection coefficients + :return: Cumulative probability + """""" + # iterate over parameters and assign values + cum = np.cumsum([values[self.params[i]] for i in range(self.k)]) + + # obtain bin indices + i = np.sum(self.intervals[:, None] <= S[None, :], axis=0) - 1 + + # make sure we don't go out of bounds which can happen if S is np.inf + i[i >= self.k] = self.k - 1 + + # cumulative probability up to previous bin + cum_prev = cum[np.maximum(i - 1, np.zeros_like(S, dtype=int))] + + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"", RuntimeWarning) + + # probability in current bin + cum_within = np.abs(intervals[i] - S) / interval_sizes[i] * vals[i] + + cum_within[np.isnan(cum_within)] = 0 + + # return cumulative probability + return cum_prev + cum_within + + return cdf + + +class DiscreteFractionalParametrization(Parametrization): + r"""""" + Same model as :class:`DiscreteParametrization`, but re-parametrized by + :math:`\hat{S}_1, \hat{S}_2, \dots, \hat{S}_{k-1}`, so that the mass in the ith interval :math:`S_i` + is determined by the sum of masses to the left, i.e. + + :math:`S_i = \hat{S}_i \sum_{j= 0]) + ) + + def to_nominal(self, params: Dict[str, float]) -> Dict[str, float]: + """""" + Convert representation of fraction of total mass to the left + to representation of fractions which sum to 1. + + :param params: Parameter values S1, S2, ..., Sk + :return: Converted parameters + """""" + # converted parameters + converted = params.copy() + + # cumulative sum up to the previous parameter + mass = 0 + + # take mass of current bin to be fraction of mass assigned to the previous bins + for p in self.params[1:-2]: + converted[p] = params[p] * (1 - mass) + mass += converted[p] + + # assign remaining mass to last bin + converted[self.params[-2]] = 1 - mass + + return converted + + def to_fractional(self, params: Dict[str, float]) -> Dict[str, float]: + """""" + Invert the to_nominal operation: Convert representation of fractions which sum to 1 + back to representation of fraction of total mass to the left. + + :param params: Converted parameters (nominal space) + :return: Original parameters (parameter space) + """""" + # converted parameters + converted = params.copy() + + # cumulative sum up to the previous parameter + mass = 0 + + # Iterate over parameters + for p in self.params[1:-2]: + # Calculate original parameter value + converted[p] = params[p] / (1 - mass) + + # update cumulative sum + mass += params[p] + + # last parameter is simply what's left + converted[self.params[-2]] = 1 - mass + + return converted + + def get_pdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get PDF. + + :param kwargs: Parameter values S1, S2, ..., Sk-1 + :return: Function that computes the PDF for given S values + """""" + + # normalize and add boundary parameters + values = self.to_nominal(kwargs | self.fixed_params) + + @Parametrization._accepts_scalars + def pdf(S: np.ndarray) -> np.ndarray: + """""" + The PDF. + + :param S: Selection coefficients + :return: Probability density + """""" + x = np.zeros_like(S, dtype=float) + + # iterate over parameters and assign values + for i, p in enumerate(self.params): + x[(self.intervals[i] < S) & (S <= self.intervals[i + 1])] = values[p] / self.interval_sizes[i] + + return x + + return pdf + + def get_cdf(self, **kwargs) -> Callable[[np.ndarray], np.ndarray]: + """""" + Get CDF. + + :param kwargs: Parameter values S1, S2, ..., Sk-1 + :return: Function that computes the CDF for given S values + """""" + + # normalize and add boundary parameters + values = self.to_nominal(kwargs | self.fixed_params) + + # convert to numpy arrays + intervals = np.array(self.intervals) + interval_sizes = np.array(self.interval_sizes) + + # convert to ordered array values + vals = np.array([values[self.params[i]] for i in range(self.k)]) + + @Parametrization._accepts_scalars + def cdf(S: np.ndarray) -> np.ndarray: + """""" + The CDF. + + :param S: Selection coefficients + :return: Cumulative probability + """""" + # iterate over parameters and assign values + cum = np.cumsum([values[self.params[i]] for i in range(self.k)]) + + # obtain bin indices + i = np.sum(self.intervals[:, None] <= S[None, :], axis=0) - 1 + + # make sure we don't go out of bounds which can happen if S is np.inf + i[i >= self.k] = self.k - 1 + + # cumulative probability up into previous bin + cum_prev = cum[np.maximum(i - 1, np.zeros_like(S, dtype=int))] + + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"", RuntimeWarning) + + # probability in current bin + cum_within = np.abs(intervals[i] - S) / interval_sizes[i] * vals[i] + + cum_within[np.isnan(cum_within)] = 0 + + # return cumulative probability + return cum_prev + cum_within + + return cdf + + +class DFE(Serializable): + """""" + Frozen parametrization of a DFE. + + Wraps a :class:`Parametrization` instance together with fixed parameter + values. + """""" + + def __init__( + self, + params: dict, + model: Parametrization = None, + bootstraps: Optional[pd.DataFrame] = None + ): + """""" + :param params: Frozen parameter values. + :param model: Parametrization instance used to generate the DFE. Defaults to :class:`GammaExpParametrization`. + :param bootstraps: Optional bootstrap DataFrame (same format as AbstractInference.bootstraps). + """""" + #: Underlying parametrization model + self.model: Parametrization = model or GammaExpParametrization() + + #: Frozen parameters + self.params: Dict[str, float] = params + + #: Optional bootstrap samples + self.bootstraps: Optional[pd.DataFrame] = bootstraps + + def get_bootstrap_dfes(self) -> List['DFE']: + """""" + Get DFEs for all bootstrap samples. + + :return: List of DFE instances for each bootstrap sample. + """""" + if self.bootstraps is None: + return [] + + dfes = [] + + for _, row in self.bootstraps.iterrows(): + params = row.to_dict() + dfes.append(DFE(model=self.model, params=params)) + + return dfes + + def pdf(self, S: np.ndarray | float) -> np.ndarray | float: + """""" + Evaluate the frozen PDF. + + :param S: Selection coefficient(s) + :return: Probability density + """""" + return self.model.get_pdf(**self.params)(S) + + def cdf(self, S: np.ndarray | float) -> np.ndarray | float: + """""" + Evaluate the frozen CDF. + + :param S: Selection coefficient(s) + :return: Cumulative probability + """""" + return self.model.get_cdf(**self.params)(S) + + def discretize( + self, + bins: np.ndarray, + warn_mass: bool = True, + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean' + ) -> Tuple[np.ndarray, Optional[np.ndarray]]: + """""" + Discretize the DFE with optional bootstrap confidence intervals. + + :param bins: Intervals to use for discretization. + :param warn_mass: Whether to warn if mass is lost during discretization. + :param confidence_intervals: Whether to compute confidence intervals. + :param ci_level: Confidence interval level (e.g., 0.05 for 95% CI). + :param bootstrap_type: Type of bootstrap confidence intervals ('percentile' or 'bca'). + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :return: Center values and (optionally) errors for each bin. + """""" + from .abstract_inference import Inference + + # no bootstraps -> plain histogram + if not confidence_intervals or self.bootstraps is None: + return self.model._discretize(self.params, bins, warn_mass=warn_mass), None + + return Inference.get_stats_discretized( + params=self.params, + bootstraps=self.bootstraps, + model=self.model, + ci_level=ci_level, + intervals=bins, + bootstrap_type=bootstrap_type, + point_estimate=point_estimate + )[:2] + + @staticmethod + def plot_many( + dfes: Sequence['DFE'], + labels: Optional[Sequence[str]] = None, + intervals=np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + file=None, + show=True, + title=""discretized DFE"", + ax=None, + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean', + kwargs_legend: dict = dict(prop=dict(size=8)), + ): + """""" + Plot several DFE instances in a single discretized plot. + + :param dfes: Sequence of DFE instances to plot. + :param labels: Labels for the DFEs. + :param intervals: Intervals to use for discretization. + :param file: File to save the plot to. + :param show: Whether to show the plot. + :param title: Title of the plot. + :param ax: Axes to use for the plot. + :param confidence_intervals: Whether to plot confidence intervals. + :param ci_level: Confidence interval level (e.g., 0.05 for 95% CI). + :param bootstrap_type: Type of bootstrap confidence intervals ('percentile' or 'bca'). + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :param kwargs_legend: Additional keyword arguments for the legend. + :return: Matplotlib Axes object. + """""" + from .visualization import Visualization + + intervals = np.array(intervals) + values = [] + errors = [] + + for d in dfes: + vals, errs = d.discretize( + bins=intervals, + confidence_intervals=confidence_intervals, + ci_level=ci_level, + bootstrap_type=bootstrap_type, + point_estimate=point_estimate + ) + values.append(vals) + errors.append(errs) + + return Visualization.plot_discretized( + ax=ax, + values=values, + errors=errors, + labels=labels, + file=file, + show=show, + intervals=intervals, + title=title, + kwargs_legend=kwargs_legend + ) + + def plot( + self, + intervals=np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + file=None, + show=True, + title=""discretized DFE"", + ax=None, + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean', + kwargs_legend: dict = dict(prop=dict(size=8)) + ): + """""" + Plot this DFE instance in a discretized plot. + + :param intervals: Intervals to use for discretization. + :param file: File to save the plot to. + :param show: Whether to show the plot. + :param title: Title of the plot. + :param ax: Axes to use for the plot. + :param confidence_intervals: Whether to plot confidence intervals. + :param ci_level: Confidence interval level (e.g., 0.05 for 95% CI). + :param bootstrap_type: Type of bootstrap confidence intervals ('percentile' or 'bca'). + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :param kwargs_legend: Additional keyword arguments for the legend. + :return: Matplotlib Axes object. + """""" + return DFE.plot_many( + dfes=[self], + intervals=intervals, + file=file, + show=show, + title=title, + ax=ax, + confidence_intervals=confidence_intervals, + ci_level=ci_level, + bootstrap_type=bootstrap_type, + point_estimate=point_estimate, + kwargs_legend=kwargs_legend + ) +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/config.py",".py","14008","343",""""""" +Configuration class. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import json +import logging +from typing import List, Literal, Dict, Tuple, Callable + +import numpy as np +import yaml + +from .discretization import Discretization +from .io_handlers import download_if_url +from .json_handlers import CustomEncoder +from .optimization import Covariate +from .optimization import SharedParams, merge_dicts +from .parametrization import Parametrization, _from_string, _to_string +from .polydfe_utils import create_sfs_config, parse_init_file, create_init_file, models +from .spectrum import Spectra, parse_polydfe_sfs_config, Spectrum + +logger = logging.getLogger('fastdfe').getChild('Config') + + +class Config: + """""" + Configuration class to be used for :class:`~fastdfe.base_inference.BaseInference` and + :class:`~fastdfe.joint_inference.JointInference`. + """""" + + def __init__( + self, + polydfe_spectra_config: str = None, + polydfe_init_file: str = None, + polydfe_init_file_id: int = 1, + sfs_neut: Spectra | Spectrum = None, + sfs_sel: Spectra | Spectrum = None, + intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), + intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), + intervals_h: Tuple[float, float, int] = (0.0, 1.0, 21), + h_callback: Callable[[np.ndarray], np.ndarray] = None, + integration_mode: Literal['midpoint', 'quad'] = 'midpoint', + linearized: bool = True, + model: Parametrization | str = 'GammaExpParametrization', + seed: int = 0, + x0: Dict[str, Dict[str, float]] = {}, + bounds: Dict[str, Tuple[float, float]] = {}, + scales: Dict[str, Literal['lin', 'log', 'symlog']] = {}, + loss_type: Literal['likelihood', 'L2'] = 'likelihood', + opts_mle: dict = {}, + method_mle: str = 'L-BFGS-B', + n_runs: int = 10, + fixed_params: Dict[str, Dict[str, float]] = None, + shared_params: List[SharedParams] = [], + covariates: List[Covariate] = [], + do_bootstrap: bool = True, + n_bootstraps: int = 100, + n_bootstrap_retries: int = 2, + parallelize: bool = True, + **kwargs + ): + """""" + Create config object. + + :param polydfe_spectra_config: Path to polyDFE SFS config file. + :param polydfe_init_file: Path to polyDFE init file. + :param polydfe_init_file_id: ID of polyDFE init file. + :param sfs_neut: Neutral SFS. Note that we require monomorphic counts to be specified in order to infer + the mutation rate. + :param sfs_sel: Selected SFS. Note that we require monomorphic counts to be specified in order to infer + the mutation rate. + :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled + selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` + provides nearly identical results while increasing speed, especially when precomputing across dominance + coefficients. + :param intervals_ben: Same as ``intervals_del`` but for positive selection coefficients. Decreasing the number + of intervals to ``100`` provides nearly identical results while increasing speed, especially when + precomputing across dominance coefficients. + :param intervals_h: ``(start, stop, n_interval)`` for dominance coefficients which are linearly spaced. + This is only used when inferring dominance coefficients. Values of ``h`` between the edges will be + interpolated linearly. + :param h_callback: A function mapping the scalar parameter ``h`` and the array of selection + coefficients ``S`` to dominance coefficients of the same shape, allowing models where ``h`` + depends on ``S``. The default is ``lambda h, S: np.full_like(S, h)``, keeping ``h`` constant. + Expected allele counts for a given dominance value are obtained by linear interpolation + between precomputed values in ``intervals_h``. The inferred parameter is still named ``h``, + even if transformed by ``h_callback``, and its bounds, scales, and initial values can be set + via ``bounds``, ``scales``, and ``x0``. The fitness of heterozygotes and mutation homozygotes is defined as + ``1 + 2hs`` and ``1 + 2s``, respectively. + :param integration_mode: Integration mode when computing expected SFS under semidominance. + ``quad`` is not recommended. + :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use + ``scipy.integrate.quad`` in each call. ``False`` not recommended. + :param model: Parametrization of the DFE. + :param seed: Seed for the random number generator. Use ``None`` for no seed. + :param x0: Dictionary of initial values in the form ``{type: {param: value}}`` + :param bounds: Bounds for the optimization in the form {param: (lower, upper)} + :param scales: Scales for the optimization in the form {param: scale} + :param loss_type: Loss function to use. + :param opts_mle: Options for the optimization. + :param method_mle: Method to use for optimization. See ``scipy.optimize.minimize`` for available methods. + :param n_runs: Number of independent optimization runs out of which the best one is chosen. The first run + will use the initial values if specified. Consider increasing this number if the optimization does not + produce good results. + :param fixed_params: Fixed parameters for the optimization. + :param shared_params: Shared parameters for the optimization. + :param covariates: Covariates for the optimization. + :param do_bootstrap: Whether to do bootstrapping automatically. + :param n_bootstraps: Number of bootstraps. + :param n_bootstrap_retries: Number of optimization runs for each bootstrap sample. This parameter previously + defined the number of retries per bootstrap sample when subsequent runs failed, but now it defines the + total number of runs per bootstrap sample, taking the most likely one. + :param parallelize: Whether to parallelize the optimization. + :param kwargs: Additional keyword arguments which are ignored. + """""" + + # save options + self.data = dict( + model=model, + intervals_del=intervals_del, + intervals_ben=intervals_ben, + intervals_h=intervals_h, + h_callback=h_callback, + integration_mode=integration_mode, + linearized=linearized, + seed=seed, + opts_mle=opts_mle, + method_mle=method_mle, + n_runs=n_runs, + x0=x0, + bounds=bounds, + scales=scales, + fixed_params=fixed_params, + shared_params=shared_params, + covariates=covariates, + sfs_neut=Spectra.from_spectrum(sfs_neut) if isinstance(sfs_neut, Spectrum) else sfs_neut, + sfs_sel=Spectra.from_spectrum(sfs_sel) if isinstance(sfs_sel, Spectrum) else sfs_sel, + do_bootstrap=do_bootstrap, + n_bootstraps=n_bootstraps, + n_bootstrap_retries=n_bootstrap_retries, + parallelize=parallelize, + loss_type=loss_type + ) + + # parse spectra file if specified + if polydfe_spectra_config is not None: + self.parse_polydfe_sfs_config(polydfe_spectra_config) + + # parse init file if specified + if polydfe_init_file is not None: + self.parse_polydfe_init_file(polydfe_init_file, polydfe_init_file_id) + + def update(self, **kwargs) -> 'Config': + """""" + Update config with given data. + + :param kwargs: Data to update. + :return: Updated config. + """""" + # convert spectrum to spectra objects + for key in ['sfs_neut', 'sfs_sel']: + if key in kwargs and isinstance(kwargs[key], Spectrum): + kwargs[key] = Spectra.from_spectrum(kwargs[key]) + + self.data |= kwargs + + return self + + def parse_polydfe_init_file(self, file: str, id: int = 1, type='all'): + """""" + Parse polyDFE init file. + This will define the initial parameters and + which ones will be held fixed during the optimization. + + :param type: Type of parameters to parse for. + :param id: ID of the init file. + :param file: Path to the init file. + """""" + fixed_params, x0 = parse_init_file(_from_string(self.data['model']).param_names, file, id) + + # merge with existing config + self.data['fixed_params'] = merge_dicts( + self.data['fixed_params'] if isinstance(self.data['fixed_params'], dict) else {}, + dict(all=fixed_params) + ) + self.data['x0'] |= {type: x0} + + def create_polydfe_init_file(self, file: str, n: int, type: str = 'all'): + """""" + Create an init file for polyDFE. + + :param type: Type to use for the init file. + :param n: SFS samples size. + :param file: Path to the init file to be created. + """""" + create_init_file( + file=file, + fixed_params=list(self.data['fixed_params'][type].keys()) if type in self.data['fixed_params'] else [], + x0=self.data['x0'][type] if type in self.data['x0'] else {}, + dfe_params=_from_string(self.data['model']).param_names, + n=n + ) + + def parse_polydfe_sfs_config(self, file: str): + """""" + Parse frequency spectra and mutational target site from + polyDFE configuration file. + + :param file: Path to the polyDFE config file. + """""" + spectra = parse_polydfe_sfs_config(file) + + # merge into data dictionary + self.data |= dict( + sfs_neut=Spectra.from_spectrum(spectra['sfs_neut']), + sfs_sel=Spectra.from_spectrum(spectra['sfs_sel']) + ) + + def create_polydfe_sfs_config(self, file: str): + """""" + Create a sfs config file for polyDFE. + + :param file: Path to the sfs config file to be created. + """""" + create_sfs_config( + file=file, + sfs_neut=self.data['sfs_neut'].all if isinstance(self.data['sfs_neut'], Spectra) else self.data['sfs_neut'], + sfs_sel=self.data['sfs_sel'].all if isinstance(self.data['sfs_sel'], Spectra) else self.data['sfs_sel'] + ) + + def to_dict(self) -> dict: + """""" + Represent config as dictionary. + + :return: Dictionary representation of config. + """""" + return self.data + + def to_json(self) -> str: + """""" + Create JSON representation of object. + + :return: JSON string + """""" + return json.dumps(self.data, indent=4, cls=CustomEncoder) + + def to_yaml(self) -> str: + """""" + Create YAML representation of object. + + :return: YAML string + """""" + return yaml.dump(json.loads(self.to_json()), sort_keys=False) + + def to_file(self, file: str): + """""" + Save object to file. + + :param file: Path to file. + """""" + with open(file, 'w') as fh: + fh.write(self.to_yaml()) + + @staticmethod + def from_dict(data: dict) -> 'Config': + """""" + Load config from dictionary. + + :return: Config object. + """""" + # recreate spectra objects + for sfs in ['sfs_neut', 'sfs_sel']: + if sfs in data and data[sfs] is not None: + data[sfs] = Spectra.from_dict(data=data[sfs]) + + # recreate SharedParams objects + if 'shared_params' in data and data['shared_params'] is not None: + data['shared_params'] = [SharedParams(**p) for p in data['shared_params']] + + # recreate Covariate objects + if 'covariates' in data and data['covariates'] is not None: + data['covariates'] = [Covariate(**c) for c in data['covariates']] + + # cast to tuple of (float, float, int) + # useful when restoring from YAML file + for key in ['intervals_ben', 'intervals_del', 'intervals_h']: + if key in data: + data[key] = (float(data[key][0]), float(data[key][1]), int(data[key][2])) + + return Config(**data) + + @staticmethod + def from_json(data: str) -> 'Config': + """""" + Load config from JSON str. + + :param data: JSON string. + :return: Config object. + """""" + return Config.from_dict(json.loads(data)) + + @staticmethod + def from_yaml(data: str) -> 'Config': + """""" + Load config from YAML str. + + :param data: YAML string. + :return: Config object. + """""" + return Config.from_dict(yaml.load(data, Loader=yaml.Loader)) + + @classmethod + def from_file(cls, file: str, cache: bool = True) -> 'Config': + """""" + Load object from file. + + :param file: Path to file, possibly gzipped or a URL. + :param cache: Whether to use the cache if available. + :return: Config object. + """""" + with open(download_if_url(file, cache=cache, desc=f'{cls.__name__}>Downloading file'), 'r') as fh: + return Config.from_yaml(fh.read()) + + def get_polydfe_model(self) -> str: # pragma: no cover + """""" + Get the model name in polyDFE that corresponds + to the configured DFE parametrization. + + :return: polyDFE model name. + """""" + # get name of configured model + name = _to_string(self.data['model']) + + # return polyDFE model name if it exists + if name in models: + return models[name] + + # raise error otherwise + raise NotImplementedError(f'There is no polyDFE equivalent of {name}') +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/annotation.py",".py","171968","4500",""""""" +VCF annotations and an annotator to apply them. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-09"" + +import itertools +import logging +import re +import subprocess +import tempfile +from abc import ABC, abstractmethod +from collections import Counter, defaultdict +from enum import Enum +from functools import cached_property +from io import StringIO +from itertools import product +from typing import List, Optional, Dict, Tuple, Callable, Literal, Iterable, cast, Any, Generator, Union + +import Bio.Data.CodonTable +import jsonpickle +import numpy as np +import pandas as pd +from Bio import Phylo +from Bio.Phylo.BaseTree import Clade, Tree +from Bio.Seq import Seq +from Bio.SeqRecord import SeqRecord +from scipy.stats import hypergeom +from tqdm import tqdm + +from .io_handlers import DummyVariant, MultiHandler, FASTAHandler +from .io_handlers import GFFHandler, get_major_base, get_called_bases +from .optimization import parallelize as parallelize_func, check_bounds +from .settings import Settings +from .spectrum import Spectra + +# get logger +logger = logging.getLogger('fastdfe') + +# order of the bases important +bases = np.array(['A', 'C', 'G', 'T']) + +# base indices +base_indices = {'A': 0, 'C': 1, 'G': 2, 'T': 3} + +# codon table +codon_table = Bio.Data.CodonTable.standard_dna_table.forward_table + +# stop codons +stop_codons = Bio.Data.CodonTable.standard_dna_table.stop_codons + +# start codons +start_codons = ['ATG'] + +# include stop codons in codon table +for c in stop_codons: + codon_table[c] = 'Σ' + +# The degeneracy of the site according to how many unique amino acids +# are coding for when changing the site within the codon. +# We count the third position of the isoleucine codon as 2-fold degenerate. +# This is the only site that would normally have 3-fold degeneracy +# (https://en.wikipedia.org/wiki/Codon_degeneracy) +unique_to_degeneracy = {0: 0, 1: 2, 2: 2, 3: 4} + + +class Annotation(ABC): + """""" + Base class for annotations. + """""" + + def __init__(self): + """""" + Create a new annotation instance. + """""" + #: The logger. + self._logger = logger.getChild(self.__class__.__name__) + + #: The annotator. + self._handler: Annotator | None = None + + #: The number of annotated sites. + self.n_annotated: int = 0 + + def _setup(self, handler: MultiHandler): + """""" + Provide context by passing the annotator. This should be called before the annotation starts. + + :param handler: The handler. + """""" + self._handler = handler + + def _rewind(self): + """""" + Rewind the annotation. + """""" + self.n_annotated = 0 + + def _teardown(self): + """""" + Finalize the annotation. Called after all sites have been annotated. + """""" + self._logger.info(f'Annotated {self.n_annotated} sites.') + + @abstractmethod + def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Annotate a single site. + + :param variant: The variant to annotate. + :return: The annotated variant. + """""" + pass + + @staticmethod + def count_target_sites(file: str, remove_overlaps: bool = False, contigs: List[str] = None) -> Dict[str, int]: + """""" + Count the number of target sites in a GFF file. + + :param file: The path to The GFF file path, possibly gzipped or a URL + :param remove_overlaps: Whether to remove overlapping target sites. + :param contigs: The contigs to count the target sites for. + :return: The number of target sites per chromosome/contig. + """""" + return GFFHandler(file)._count_target_sites( + remove_overlaps=remove_overlaps, + contigs=contigs + ) + + +class DegeneracyAnnotation(Annotation): + """""" + Degeneracy annotation. We annotate the degeneracy by looking at each codon for coding variants. + This also annotates mono-allelic sites. + + This annotation adds the info fields ``Degeneracy`` and ``Degeneracy_Info``, which hold the degeneracy + of a site (0, 2, 4) and extra information about the degeneracy, respectively. To be used with + :class:`~fastdfe.parser.DegeneracyStratification`. + + For this annotation to work, we require a FASTA and GFF file (passed to :class:`~fastdfe.parser.Parser` or + :class:`~fastdfe.annotation.Annotator`). + + Example usage: + + :: + + import fastdfe as fd + + ann = fd.Annotator( + vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" + ""1000_genomes_project/release/20181203_biallelic_SNV/"" + ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", + fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" + ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", + gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", + output='sapiens.chr21.degeneracy.vcf.gz', + annotations=[fd.DegeneracyAnnotation()], + aliases=dict(chr21=['21']) + ) + + ann.annotate() + + """""" + + #: The genomic positions for coding sequences that are mocked. + _pos_mock: int = 1e100 + + def __init__(self): + """""" + Create a new annotation instance. + """""" + Annotation.__init__(self) + + #: The current coding sequence or the closest coding sequence downstream. + self._cd: Optional[pd.Series] = None + + #: The coding sequence following the current coding sequence. + self._cd_next: Optional[pd.Series] = None + + #: The coding sequence preceding the current coding sequence. + self._cd_prev: Optional[pd.Series] = None + + #: The current contig. + self._contig: Optional[SeqRecord] = None + + #: The variants that could not be annotated correctly. + self.mismatches: List['cyvcf2.Variant'] = [] + + #: The variant that were skipped because they were not in coding regions. + self.n_skipped: int = 0 + + #: The variants for which the codon could not be determined. + self.errors: List['cyvcf2.Variant'] = [] + + def _setup(self, handler: MultiHandler): + """""" + Provide context to the annotator. + + :param handler: The handler. + """""" + # require FASTA and GFF files + handler._require_fasta(self.__class__.__name__) + handler._require_gff(self.__class__.__name__) + + # call super + super()._setup(handler) + + # touch the cached properties to make for a nicer logging experience + # noinspection PyStatementEffect + self._handler._cds + + # noinspection PyStatementEffect + self._handler._ref + + handler._reader.add_info_to_header({ + 'ID': 'Degeneracy', + 'Number': '.', + 'Type': 'Integer', + 'Description': 'n-fold degeneracy' + }) + + handler._reader.add_info_to_header({ + 'ID': 'Degeneracy_Info', + 'Number': '.', + 'Type': 'Integer', + 'Description': 'Additional information about degeneracy annotation' + }) + + def _rewind(self): + """""" + Rewind the annotation. + """""" + Annotation._rewind(self) + + self._cd = None + self._cd_next = None + self._cd_prev = None + self._contig = None + + def _parse_codon_forward(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Parse the codon in forward direction. + + :param variant: The variant. + :return: Codon, Codon position, Codon start position, Position within codon, and relative position. + """""" + # position relative to start of coding sequence + pos_rel = variant.POS - (self._cd.start + int(self._cd.phase)) + + # position relative to codon + pos_codon = pos_rel % 3 + + # inclusive codon start, 1-based + codon_start = variant.POS - pos_codon + + # the codon positions + codon_pos = [codon_start, codon_start + 1, codon_start + 2] + + if (self._cd_prev is None or self._cd_next.start == self._pos_mock) and codon_pos[0] < self._cd.start: + raise IndexError(f'Codon at site {variant.CHROM}:{variant.POS} overlaps with ' + f'start position of current CDS and no previous CDS was given.') + + # Use final positions from previous coding sequence if current codon + # starts before start position of current coding sequence + if codon_pos[1] == self._cd.start: + codon_pos[0] = self._cd_prev.end if self._cd_prev.strand == '+' else self._cd_prev.start + elif codon_pos[2] == self._cd.start: + codon_pos[1] = self._cd_prev.end if self._cd_prev.strand == '+' else self._cd_prev.start + codon_pos[0] = self._cd_prev.end - 1 if self._cd_prev.strand == '+' else self._cd_prev.start + 1 + + if (self._cd_next is None or self._cd_next.start == self._pos_mock) and codon_pos[2] > self._cd.end: + raise IndexError(f'Codon at site {variant.CHROM}:{variant.POS} overlaps with ' + f'end position of current CDS and no subsequent CDS was given.') + + # use initial positions from subsequent coding sequence if current codon + # ends before end position of current coding sequence + if codon_pos[2] == self._cd.end + 1: + codon_pos[2] = self._cd_next.start if self._cd_next.strand == '+' else self._cd_next.end + elif codon_pos[1] == self._cd.end + 1: + codon_pos[1] = self._cd_next.start if self._cd_next.strand == '+' else self._cd_next.end + codon_pos[2] = self._cd_next.start + 1 if self._cd_next.strand == '+' else self._cd_next.end - 1 + + # seq uses 0-based positions + codon = ''.join([str(self._contig[int(pos - 1)]) for pos in codon_pos]).upper() + + return codon, codon_pos, codon_start, pos_codon, pos_rel + + def _parse_codon_backward(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Parse the codon in reverse direction. + + :param variant: The variant. + :return: Codon, Codon position, Codon start position, Position within codon, and relative position. + """""" + # position relative to end of coding sequence + pos_rel = (self._cd.end - int(self._cd.phase)) - variant.POS + + # position relative to codon end + pos_codon = pos_rel % 3 + + # inclusive codon start, 1-based + codon_start = variant.POS + pos_codon + + # the codon positions + codon_pos = [codon_start, codon_start - 1, codon_start - 2] + + if (self._cd_prev is None or self._cd_next.start == self._pos_mock) and codon_pos[2] < self._cd.start: + raise IndexError(f'Codon at site {variant.CHROM}:{variant.POS} overlaps with ' + f'start position of current CDS and no previous CDS was given.') + + # Use final positions from previous coding sequence if current codon + # ends before start position of current coding sequence. + if codon_pos[1] == self._cd.start: + codon_pos[2] = self._cd_prev.end if self._cd_prev.strand == '-' else self._cd_prev.start + elif codon_pos[0] == self._cd.start: + codon_pos[1] = self._cd_prev.end if self._cd_prev.strand == '-' else self._cd_prev.start + codon_pos[2] = self._cd_prev.end - 1 if self._cd_prev.strand == '-' else self._cd_prev.start + 1 + + if (self._cd_next is None or self._cd_next.start == self._pos_mock) and codon_pos[0] > self._cd.end: + raise IndexError(f'Codon at site {variant.CHROM}:{variant.POS} overlaps with ' + f'end position of current CDS and no subsequent CDS was given.') + + # use initial positions from subsequent coding sequence if current codon + # starts before end position of current coding sequence + if codon_pos[0] == self._cd.end + 1: + codon_pos[0] = self._cd_next.start if self._cd_next.strand == '-' else self._cd_next.end + elif codon_pos[1] == self._cd.end + 1: + codon_pos[1] = self._cd_next.start if self._cd_next.strand == '-' else self._cd_next.end + codon_pos[0] = self._cd_next.start + 1 if self._cd_next.strand == '-' else self._cd_next.end - 1 + + # we use 0-based positions here + codon = ''.join(str(self._contig[int(pos - 1)]) for pos in codon_pos) + + # take complement and convert to uppercase ('n' might be lowercase) + codon = str(Seq(codon).complement()).upper() + + return codon, codon_pos, codon_start, pos_codon, pos_rel + + def _parse_codon(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Parse the codon for the given variant. + + :param variant: The variant to parse the codon for. + :return: Codon, Codon position, Codon start position, Position within codon, and relative position. + """""" + + if self._cd.strand == '+': + return self._parse_codon_forward(variant) + + return self._parse_codon_backward(variant) + + @staticmethod + def _get_degeneracy(codon: str, pos: int) -> int: + """""" + Translate codon into amino acid. + + :param codon: The codon + :param pos: The position of the variant in the codon, 0, 1, or 2 + :return: The degeneracy of the codon, 0, 2, or 4 + """""" + amino_acid = codon_table[codon] + + # convert to list of characters + codon = list(codon) + + # get the alternative bases + alt = [] + for b in bases[bases != codon[pos]]: + codon[pos] = b + alt.append(codon_table[''.join(codon)]) + + # noinspection PyTypeChecker + return unique_to_degeneracy[sum(amino_acid == np.array(alt))] + + @staticmethod + def _get_degeneracy_table() -> Dict[str, str]: + """""" + Create codon degeneracy table. + + :return: dictionary mapping codons to degeneracy + """""" + codon_degeneracy = {} + for codon in product(bases, repeat=3): + codon = ''.join(codon) + codon_degeneracy[codon] = ''.join( + [str(DegeneracyAnnotation._get_degeneracy(codon, pos)) for pos in range(0, 3)] + ) + + return codon_degeneracy + + def _fetch_cds(self, v: Union['cyvcf2.Variant', DummyVariant]): + """""" + Fetch the coding sequence for the given variant. + + :param v: The variant to fetch the coding sequence for. + :raises LookupError: If no coding sequence was found. + """""" + # get the aliases for the current chromosome + aliases = self._handler.get_aliases(v.CHROM) + + # only fetch coding sequence if we are on a new chromosome or the + # variant is not within the current coding sequence + if self._cd is None or self._cd.seqid not in aliases or v.POS > self._cd.end: + + # reset coding sequences to mocking positions + self._cd_prev = None + self._cd = pd.Series({'seqid': v.CHROM, 'start': self._pos_mock, 'end': self._pos_mock}) + self._cd_next = pd.Series({'seqid': v.CHROM, 'start': self._pos_mock, 'end': self._pos_mock}) + + # filter for the current chromosome + on_contig = self._handler._cds[(self._handler._cds.seqid.isin(aliases))] + + # filter for positions ending after the variant + cds = on_contig[(on_contig.end >= v.POS)] + + if not cds.empty: + # take the first coding sequence + self._cd = cds.iloc[0] + + self._logger.debug(f'Found coding sequence: {self._cd.seqid}:{self._cd.start}-{self._cd.end}, ' + f'reminder: {(self._cd.end - self._cd.start + 1) % 3}, ' + f'phase: {int(self._cd.phase)}, orientation: {self._cd.strand}, ' + f'current position: {v.CHROM}:{v.POS}') + + # filter for positions ending after the current coding sequence + cds = on_contig[(on_contig.start > self._cd.end)] + + if not cds.empty: + # take the first coding sequence + self._cd_next = cds.iloc[0] + + # filter for positions starting before the current coding sequence + cds = on_contig[(on_contig.end < self._cd.start)] + + if not cds.empty: + # take the last coding sequence + self._cd_prev = cds.iloc[-1] + + if self._cd.start == self._pos_mock and self.n_annotated == 0: + self._logger.warning(f""No coding sequence found on all of contig '{v.CHROM}' and no previous "" + f'sites were annotated. Are you sure that this is the correct GFF file ' + f'and that the contig names match the chromosome names in the VCF file? ' + f'Note that you can also specify aliases for contig names in the VCF file.') + + # check if variant is located within coding sequence + if self._cd is None or not (self._cd.start <= v.POS <= self._cd.end): + raise LookupError(f""No coding sequence found, skipping record {v.CHROM}:{v.POS}"") + + def _fetch_contig(self, v: Union['cyvcf2.Variant', DummyVariant]): + """""" + Fetch the contig for the given variant. + + :param v: The variant to fetch the contig for. + """""" + aliases = self._handler.get_aliases(v.CHROM) + + # check if contig is up-to-date + if self._contig is None or self._contig.id not in aliases: + self._logger.debug(f""Fetching contig '{v.CHROM}'."") + + # fetch contig + self._contig = self._handler.get_contig(aliases) + + def _fetch(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Fetch all required data for the given variant. + + :param variant: The variant to fetch the data for. + :raises LookupError: if some data could not be found. + """""" + self._fetch_cds(variant) + + try: + self._fetch_contig(variant) + except LookupError: + # log error as this should not happen + self._logger.warning(f""Could not fetch contig '{variant.CHROM}'."") + raise + + def annotate_site(self, v: Union['cyvcf2.Variant', DummyVariant]): + """""" + Annotate a single site. + + :param v: The variant to annotate. + """""" + v.INFO['Degeneracy'] = '.' + + try: + self._fetch(v) + except LookupError: + self.n_skipped += 1 + return + + # skip locus if not a single site + if len(v.REF) != 1: + self.n_skipped += 1 + return + + # annotate if record is in coding sequence + if self._cd.seqid in self._handler.get_aliases(v.CHROM) and self._cd.start <= v.POS <= self._cd.end: + + try: + # parse codon + codon, codon_pos, codon_start, pos_codon, pos_rel = self._parse_codon(v) + + except IndexError as e: + + # skip site on IndexError + self._logger.warning(e) + self.errors.append(v) + return + + # make sure the reference allele matches with the position on the reference genome + if str(self._contig[v.POS - 1]).upper() != v.REF.upper(): + self._logger.warning( + f""Reference allele does not match with reference genome at {v.CHROM}:{v.POS}, skipping site."" + ) + self.mismatches.append(v) + return + + degeneracy = '.' + if 'N' not in codon: + degeneracy = self._get_degeneracy(codon, pos_codon) + + # increment counter of annotated sites + self.n_annotated += 1 + + v.INFO['Degeneracy'] = degeneracy + v.INFO['Degeneracy_Info'] = f""{pos_codon},{self._cd.strand},{codon}"" + + self._logger.debug(f'pos codon: {pos_codon}, pos abs: {v.POS}, ' + f'codon start: {codon_start}, codon: {codon}, ' + f'strand: {self._cd.strand}, ref allele: {self._contig[v.POS - 1]}, ' + f'degeneracy: {degeneracy}, codon pos: {str(codon_pos)}, ' + f'ref allele: {v.REF}') + + +class SynonymyAnnotation(DegeneracyAnnotation): + """""" + Synonymy annotation. This class annotates a variant with the synonymous/non-synonymous status. + + This annotation adds the info fields ``Synonymous`` and ``Synonymous_Info``, which hold + the synonymy (Synonymous [0] or non-synonymous [1]) and the codon information, respectively. + To be used with :class:`~fastdfe.parser.SynonymyStratification`. + + For this annotation to work, we require a FASTA and GFF file (passed to :class:`~fastdfe.parser.Parser` or + :class:`~fastdfe.annotation.Annotator`). + + This class was tested against `VEP `_ and `SnpEff `_ and provides the same annotations in almost + all cases. + + .. _VEP: https://www.ensembl.org/info/docs/tools/vep/index.html + .. _SnpEff: https://pcingola.github.io/SnpEff/ + + .. warning:: + Not recommended for use with :class:`~fastdfe.parser.Parser` as we also need to annotate mono-allelic sites. + Consider using :class:`~fastdfe.annotation.DegeneracyAnnotation` and + :class:`~fastdfe.parser.DegeneracyStratification` instead. + """""" + + def __init__(self): + """""" + Create a new annotation instance. + """""" + super().__init__() + + #: The number of sites that did not match with VEP. + self.vep_mismatches: List['cyvcf2.Variant'] = [] + + #: The number of sites that did not math with the annotation provided by SnpEff + self.snpeff_mismatches: List['cyvcf2.Variant'] = [] + + #: The number of sites that were concordant with VEP. + self.n_vep_comparisons: int = 0 + + #: The number of sites that were concordant with SnpEff. + self.n_snpeff_comparisons: int = 0 + + def _setup(self, handler: MultiHandler): + """""" + Provide context to the annotator. + + :param handler: The handler. + """""" + # require FASTA and GFF files + handler._require_fasta(self.__class__.__name__) + handler._require_gff(self.__class__.__name__) + + Annotation._setup(self, handler) + + # touch the cached properties to make for a nicer logging experience + # noinspection PyStatementEffect + self._handler._cds + + # noinspection PyStatementEffect + self._handler._ref + + handler._reader.add_info_to_header({ + 'ID': 'Synonymy', + 'Number': '.', + 'Type': 'Integer', + 'Description': 'Synonymous (0) or non-synonymous (1)' + }) + + handler._reader.add_info_to_header({ + 'ID': 'Synonymy_Info', + 'Number': '.', + 'Type': 'String', + 'Description': 'Alt codon and extra information' + }) + + def _get_alt_allele(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> str | None: + """""" + Get the alternative allele. + + :param variant: The variant to get the alternative allele for. + :return: The alternative allele or None if there is no alternative allele. + """""" + if len(variant.ALT) > 0: + + # assume there is at most one alternative allele + if self._cd.strand == '-': + return Seq(variant.ALT[0]).complement().__str__() + + return variant.ALT[0] + + @staticmethod + def mutate(codon: str, alt: str, pos: int) -> str: + """""" + Mutate the codon at the given position to the given alternative allele. + + :param codon: The codon to mutate. + :param alt: The alternative allele. + :param pos: The position to mutate. + :return: Mutated codon. + """""" + return codon[0:pos] + alt + codon[pos + 1:] + + @staticmethod + def is_synonymous(codon1: str, codon2: str) -> bool: + """""" + Check if two codons are synonymous. + + :param codon1: The first codon. + :param codon2: The second codon. + :return: True if the codons are synonymous, False otherwise. + """""" + + # handle case where there are stop codons + if codon1 in stop_codons or codon2 in stop_codons: + return codon1 in stop_codons and codon2 in stop_codons + + return codon_table[codon1] == codon_table[codon2] + + def _parse_codons_vep(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> List[str]: + """""" + Parse the codons from the VEP annotation if present. + + :param variant: The variant. + :return: The codons. + """""" + # match codons + match = re.search(""([actgACTG]{3})/([actgACTG]{3})"", variant.INFO.get('CSQ')) + + if match is not None: + if len(match.groups()) != 2: + self._logger.info(f'VEP annotation has more than two codons: {variant.INFO.get(""CSQ"")}') + + return [m.upper() for m in [match[1], match[2]]] + + return [] + + @staticmethod + def _parse_synonymy_snpeff(variant: Union['cyvcf2.Variant', DummyVariant]) -> int | None: + """""" + Parse the synonymy from the annotation provided by SnpEff + + :param variant: The variant. + :return: The codons. + """""" + ann = variant.INFO.get('ANN') + + if 'synonymous_variant' in ann: + return 1 + + if 'missense_variant' in ann: + return 0 + + def _teardown(self): + """""" + Finalize the annotation. + """""" + super()._teardown() + + if self.n_vep_comparisons != 0: + self._logger.info(f'Number of mismatches with VEP: {len(self.vep_mismatches)}') + + if self.n_snpeff_comparisons != 0: + self._logger.info(f'Number of mismatches with SnpEff: {len(self.snpeff_mismatches)}') + + def annotate_site(self, v: Union['cyvcf2.Variant', DummyVariant]): + """""" + Annotate a single site. + + :param v: The variant to annotate. + :return: The annotated variant. + """""" + v.INFO['Synonymy'] = '.' + + if v.is_snp: + try: + self._fetch(v) + except LookupError: + self.n_skipped += 1 + return + + # annotate if record is in coding sequence + if self._cd.start <= v.POS <= self._cd.end: + + try: + # parse codon + codon, codon_pos, codon_start, pos_codon, pos_rel = self._parse_codon(v) + + except IndexError as e: + + # skip site on IndexError + self._logger.warning(e) + self.errors.append(v) + return + + # make sure the reference allele matches with the position in the reference genome + if str(self._contig[v.POS - 1]).upper() != v.REF.upper(): + self._logger.warning( + f""Reference allele does not match with reference genome at {v.CHROM}:{v.POS}, skipping site."" + ) + self.mismatches.append(v) + return + + # fetch the alternative allele if present + alt = self._get_alt_allele(v) + + info = '' + synonymy = '.' + if alt is not None: + # alternative codon, 'n' might not be uppercase + alt_codon = self.mutate(codon, alt, pos_codon).upper() + + # whether the alternative codon is synonymous + if 'N' not in codon and 'N' not in alt_codon: + synonymy = int(self.is_synonymous(codon, alt_codon)) + + # append alternative codon to info field + info += f'{codon}/{alt_codon}' + + # check if the alternative codon is a start codon + if alt_codon in start_codons: + info += ',start_gained' + + # check if the alternative codon is a stop codon + if alt_codon in stop_codons: + info += ',stop_gained' + + if v.INFO.get('CSQ') is not None: + + # fetch the codons from the VEP annotation + codons_vep = self._parse_codons_vep(v) + + if len(codons_vep) > 0: + # increase number of comparisons + self.n_vep_comparisons += 1 + + # make sure the codons determined by VEP are the same as our codons. + if set(codons_vep) != {codon, alt_codon}: + self._logger.warning(f'VEP codons do not match with codons determined by ' + f'codon table for {v.CHROM}:{v.POS}') + + self.vep_mismatches.append(v) + return + + if v.INFO.get('ANN') is not None: + synonymy_snpeff = self._parse_synonymy_snpeff(v) + + self.n_snpeff_comparisons += 1 + + if synonymy_snpeff is not None: + if synonymy_snpeff != synonymy: + self._logger.warning(f'SnpEff annotation does not match with custom ' + f'annotation for {v.CHROM}:{v.POS}') + + self.snpeff_mismatches.append(v) + return + + # increase number of annotated sites + self.n_annotated += 1 + + # add to info field + v.INFO['Synonymy'] = synonymy + v.INFO['Synonymy_Info'] = info + + +class AncestralAlleleAnnotation(Annotation, ABC): + """""" + Base class for ancestral allele annotation. + """""" + + def _setup(self, handler: MultiHandler): + """""" + Add info fields to the header. + + :param handler: The handler. + """""" + super()._setup(handler) + + handler._reader.add_info_to_header({ + 'ID': self._handler.info_ancestral, + 'Number': '.', + 'Type': 'Character', + 'Description': 'Ancestral Allele' + }) + + +class MaximumParsimonyAncestralAnnotation(AncestralAlleleAnnotation): + """""" + Annotation of ancestral alleles using maximum parsimony. To be used with + :class:`~fastdfe.parser.AncestralBaseStratification` and :class:`Annotator` or :class:`~fastdfe.parser.Parser`. + + Note that maximum parsimony is not a reliable way to determine ancestral alleles, so it is recommended + to use this annotation together with the ancestral misidentification parameter ``eps`` or to fold + spectra altogether. Alternatively, you can use :class:`~fastdfe.filtration.DeviantOutgroupFiltration` to + filter out sites where the major allele among outgroups does not coincide with the major allele among ingroups. + This annotation has the advantage of requiring no outgroup data. If outgroup data is available consider using + :class`MLEAncestralAlleleAnnotation` instead. + """""" + + def __init__(self, samples: List[str] = None): + """""" + Create a new ancestral allele annotation instance. + + :param samples: The samples to consider when determining the ancestral allele. If ``None``, all samples are + considered. + """""" + super().__init__() + + #: The samples to consider when determining the ancestral allele. + self.samples: List[str] | None = samples + + self.samples_mask: np.ndarray | None = None + + def _setup(self, handler: MultiHandler): + """""" + Add info fields to the header. + + :param handler: The handler. + """""" + super()._setup(handler) + + # create mask for ingroups + if self.samples is None: + self.samples_mask = np.ones(len(handler._reader.samples)).astype(bool) + else: + self.samples_mask = np.isin(handler._reader.samples, self.samples) + + def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Annotate a single site. + + :param variant: The variant to annotate. + :return: The annotated variant. + """""" + # assign the ancestral allele + variant.INFO[self._handler.info_ancestral] = self._get_ancestral(variant, self.samples_mask) + + if variant.INFO[self._handler.info_ancestral] != '.': + # increase the number of annotated sites + self.n_annotated += 1 + + @staticmethod + def _get_ancestral( + variant: Union['cyvcf2.Variant', DummyVariant], + mask: np.ndarray, + ) -> str: + """""" + Get the ancestral allele for the given variant using maximum parsimony. + + :param variant: The variant to annotate. + :param mask: The mask for the ingroups. + :return: The ancestral allele or '.' if it could not be determined. + """""" + # take reference allele as ancestral if dummy variant + if isinstance(variant, DummyVariant): + return variant.REF + + # take only base to be ancestral if we have a monomorphic snv + if not variant.is_snp and variant.REF in bases: + b = list(set(get_called_bases(variant.gt_bases[mask]))) + + if len(b) == 1 and b[0] in bases: + return b[0] + + # take major base to be ancestral if we have an SNP + if variant.is_snp: + return get_major_base(variant.gt_bases[mask]) or '.' + + return '.' + + +class SubstitutionModel(ABC): + """""" + Base class for substitution models. + """""" + + #: The possible transitions + _transitions: np.ndarray = np.array([ + (base_indices['A'], base_indices['G']), + (base_indices['G'], base_indices['A']), + (base_indices['C'], base_indices['T']), + (base_indices['T'], base_indices['C']) + ]) + + #: The possible transversions + _transversions: np.ndarray = np.array([ + (base_indices['A'], base_indices['C']), + (base_indices['C'], base_indices['A']), + (base_indices['G'], base_indices['T']), + (base_indices['T'], base_indices['G']), + (base_indices['A'], base_indices['T']), + (base_indices['T'], base_indices['A']), + (base_indices['C'], base_indices['G']), + (base_indices['G'], base_indices['C']) + ]) + + def __init__( + self, + bounds: Dict[str, Tuple[float, float]] = {}, + pool_branch_rates: bool = False, + fixed_params: Dict[str, float] = {} + ): + """""" + Create a new substitution model instance. + + :param bounds: The bounds for the parameters. + :param pool_branch_rates: Whether to pool the branch rates. By default, each branch has its own rate which + is optimized using MLE. If ``True``, the branch rates are pooled and a single rate is optimized. This is + useful if the number of sites used is small. + :param fixed_params: The fixed parameters. Parameters that are not fixed are optimized using MLE. + """""" + #: The logger. + self._logger = logging.getLogger(self.__class__.__name__) + + # validate bounds + self.validate_bounds(bounds) + + #: Whether to pool the branch rates. + self.pool_branch_rates: bool = pool_branch_rates + + #: The fixed parameters. + self.fixed_params: Dict[str, float] = fixed_params.copy() + + #: Parameter bounds. + self.bounds: Dict[str, Tuple[float, float]] = bounds.copy() + + #: Cache for the probabilities. + self._cache: Dict[Tuple[int, int, int], float] | None = None + + def _setup(self, ann: 'MaximumLikelihoodAncestralAnnotation'): + """""" + Set up the substitution model. + + :param ann: The ancestral allele annotation. + """""" + pass + + def cache(self, params: Dict[str, float], n_branches: int): + """""" + Cache the probabilities for the given parameters. + + :param params: The parameters. + :param n_branches: The number of branches. + """""" + self._cache = {} + + for (b1, b2, i) in itertools.product(range(0, 4), range(0, 4), range(n_branches)): + self._cache[(b1, b2, i)] = self._get_prob(b1, b2, i, params) + + @staticmethod + def get_x0(bounds: Dict[str, Tuple[float, float]], rng: np.random.Generator) -> Dict[str, float]: + """""" + Get the initial values for the parameters. + + :param bounds: The bounds for the parameters. + :param rng: The random number generator. + :return: The initial values. + """""" + x0 = {} + + # draw initial values from a uniform distribution + for key, (lower, upper) in bounds.items(): + x0[key] = rng.uniform(lower, upper) + + return x0 + + def get_bounds(self, n_outgroups: int) -> Dict[str, Tuple[float, float]]: + """""" + Get the bounds for the parameters. + + :param n_outgroups: The number of outgroups. + :return: The bounds. + """""" + return self.bounds + + @staticmethod + def validate_bounds(bounds: Dict[str, Tuple[float, float]]): + """""" + Make sure the lower bounds are positive and the upper bounds are larger than the lower bounds. + + :param bounds: The bounds to validate + :raises ValueError: If the bounds are invalid + """""" + for param, (lower, upper) in bounds.items(): + if lower <= 0: + raise ValueError(f'All lower bounds must be positive, got {lower} for {param}.') + + if lower > upper: + raise ValueError(f'Lower bounds must be smaller than upper bounds, got {lower} > {upper} for {param}.') + + @abstractmethod + def _get_prob(self, b1: int, b2: int, i: int, params: Dict[str, float]) -> float: + """""" + Get the probability of a branch using the substitution model. + + :param b1: First nucleotide state. + :param b2: Second nucleotide state. + :param i: The index of the branch. + :param params: The parameters for the model. + :return: The probability of the branch. + """""" + pass + + def _get_cached_prob(self, b1: int, b2: int, i: int, params: Dict[str, float]) -> float: + """""" + Get the probability of a branch using the substitution model with caching. + + :param b1: First nucleotide state. + :param b2: Second nucleotide state. + :param i: The index of the branch. + :param params: The parameters for the model. + :return: The probability of the branch. + """""" + if self._cache is None: + return self._get_prob(b1, b2, i, params) + + # return cached value + return self._cache[(b1, b2, i)] + + +class JCSubstitutionModel(SubstitutionModel): + """""" + Jukes-Cantor substitution model. + """""" + + def __init__( + self, + bounds: Dict[str, Tuple[float, float]] = {'K': (1e-5, 10)}, + pool_branch_rates: bool = False, + fixed_params: Dict[str, float] = {} + ): + """""" + Create a new substitution model instance. + + :param bounds: The bounds for the parameters. K is the branch rate. + :param pool_branch_rates: Whether to pool the branch rates. By default, each branch has its own rate which + is optimized using MLE. If ``True``, the branch rates are pooled and a single rate is optimized. This is + useful if the number of sites used is small. If ``False``, each branch has its own rate denoted by ""K{i}"", + where i is the branch index. If ``True``, the branch rate is denoted by ""K"". + :param fixed_params: The fixed parameters. Parameters that are not fixed are optimized using MLE. + """""" + super().__init__( + bounds=bounds, + pool_branch_rates=pool_branch_rates, + fixed_params=fixed_params + ) + + def get_bound(self, param: str) -> Tuple[float, float]: + """""" + Get the bounds for a parameter. + + :param param: The parameter. + :return: The lower and upper bounds. + """""" + # check if the parameter is fixed + if param in self.fixed_params: + return self.fixed_params[param], self.fixed_params[param] + + # return the bounds if they are defined + if param in self.bounds: + return self.bounds[param] + + # attempt to get the bounds for the branch rates by removing the branch index + param_no_index = re.sub(pattern=r'\d', repl='', string=param) + + return self.bounds[param_no_index] + + def get_bounds(self, n_outgroups: int) -> Dict[str, Tuple[float, float]]: + """""" + Get the bounds for the parameters. + + :param n_outgroups: The number of outgroups. + :return: The lower and upper bounds. + """""" + if self.pool_branch_rates: + # pool the branch rates + return {'K': self.get_bound('K')} + + # get the bounds for the branch lengths + return {f""K{i}"": self.get_bound(f""K{i}"") for i in range(2 * n_outgroups - 1)} + + def _get_prob(self, b1: int, b2: int, i: int, params: Dict[str, float]) -> float: + """""" + Get the probability of a branch using the substitution model. + + :param b1: First nucleotide state. + :param b2: Second nucleotide state. + :param i: The index of the branch. + :param params: The parameters for the model. + :return: The probability of the branch. + """""" + # evolutionary rate parameter for the branch + K = params['K'] if self.pool_branch_rates else params[f'K{i}'] + + if b1 == b2: + return np.exp(-K) + (1 / 6) * K ** 2 * np.exp(-K) + + return (1 / 3) * K * np.exp(-K) + (1 / 9) * K ** 2 * np.exp(-K) + + +class K2SubstitutionModel(JCSubstitutionModel): + """""" + Kimura 2-parameter substitution model. + """""" + + def __init__( + self, + bounds: Dict[str, Tuple[float, float]] = {'K': (1e-5, 10), 'k': (0.1, 10)}, + pool_branch_rates: bool = False, + fixed_params: Dict[str, float] = {}, + fix_transition_transversion_ratio: bool = False + ): + """""" + Create a new substitution model instance. + + :param bounds: The bounds for the parameters. ``K{i}`` are the branch rates. + ``k`` is the transition/transversion ratio. + :param pool_branch_rates: Whether to pool the branch rates. By default, each branch has its own rate which + is optimized using MLE. If ``True``, the branch rates are pooled and a single rate is optimized. This is + useful if the number of sites used is small. + :param fixed_params: The fixed parameters. Parameters that are not fixed are optimized using MLE. + :param fix_transition_transversion_ratio: Whether to fix the transition/transversion ratio to the ratio + observed in the data. + """""" + super().__init__( + bounds=bounds, + pool_branch_rates=pool_branch_rates, + fixed_params=fixed_params + ) + + #: Whether to fix the transition/transversion ratio to the ratio observed in the data. + self.fix_transition_transversion_ratio: bool = fix_transition_transversion_ratio + + def _setup(self, ann: 'MaximumLikelihoodAncestralAnnotation'): + """""" + Set up the substitution model. + + :param ann: The ancestral allele annotation. + """""" + if self.fix_transition_transversion_ratio: + # fix the transition/transversion ratio to the ratio observed in the data + self.fixed_params['k'] = ann.get_observed_transition_transversion_ratio() + + def get_bounds(self, n_outgroups: int) -> Dict[str, Tuple[float, float]]: + """""" + Get the bounds for the parameters. + + :param n_outgroups: The number of outgroups. + :return: The lower and upper bounds. + """""" + bounds = super().get_bounds(n_outgroups) + + # add bounds for the transition/transversion ratio + bounds[""k""] = self.get_bound(""k"") + + return bounds + + def _get_prob(self, b1: int, b2: int, i: int, params: Dict[str, float]) -> float: + """""" + Get the probability of a branch using the K2 model. + + :param b1: First nucleotide state. + :param b2: Second nucleotide state. + :param i: The index of the branch. + :param params: The parameters for the model. + :return: The probability of the branch. + """""" + # evolutionary rate parameter for the branch + K = params['K'] if self.pool_branch_rates else params[f'K{i}'] + + # transition/transversion ratio + k = params[""k""] + + # if the ancestral and descendant nucleotide states are the same + if b1 == b2: + return np.exp(-K) * (1 + 0.5 * K ** 2 * (2 + k ** 2) / (k ** 2 + 4 * k + 4)) + + # if we have a transition + if (b1, b2) in [(0, 2), (2, 0), (1, 3), (3, 1)]: + return K * np.exp(-K) * (k / (k + 2) + K * 1 / (k ** 2 + 4 * k + 4)) + + # if we have a transversion + return K * np.exp(-K) * (1 / (k + 2) + K * k / (k ** 2 + 4 * k + 4)) + + +class SiteConfig: + """""" + Ancestral allele site configuration for a single subsample. + """""" + + def __init__( + self, + n_major: int, + major_base: int, + minor_base: int, + outgroup_bases: np.ndarray, + multiplicity: float = 1.0, + sites: np.ndarray = None, + p_minor: float = np.nan, + p_major: float = np.nan + ): + """""" + Create a new site configuration instance. + """""" + #: The number of major alleles. + self.n_major: int = n_major + + #: The major allele base index. + self.major_base: int = major_base + + #: The minor base index. + self.minor_base: int = minor_base + + #: The outgroup base indices. + self.outgroup_bases: np.ndarray = outgroup_bases + + #: The multiplicity of the site. + self.multiplicity: float = multiplicity + + #: The site indices. + self.sites: np.ndarray = np.array([]) if sites is None else sites + + #: The probability of the minor allele. + self.p_minor: float = p_minor + + #: The probability of the major allele. + self.p_major: float = p_major + + +class SiteInfo: + """""" + Ancestral allele information on a single site. + """""" + + def __init__( + self, + n_major: Dict[int, float], + major_base: str, + minor_base: str, + outgroup_bases: List[str], + p_minor: float = np.nan, + p_major: float = np.nan, + p_major_ancestral: float = np.nan, + major_ancestral: str = '.', + p_bases_first_node: Dict[str, float] = None, + p_first_node_ancestral: float = np.nan, + first_node_ancestral: str = '.', + rate_params: Dict[str, float] = None + ): + #: Dictionary mapping number of major alleles to its probability of observation. + self.n_major: Dict[int, float] = n_major + + #: The major allele base. + self.major_base: str = major_base + + #: The minor base index. + self.minor_base: str = minor_base + + #: The outgroup base indices. + self.outgroup_bases: List[str] = outgroup_bases + + #: The probability of the minor allele being the ancestral allele (without prior). + self.p_minor: float = p_minor + + #: The probability of the major allele being the ancestral allele (without prior). + self.p_major: float = p_major + + #: The probability of the major allele being the ancestral allele rather than the minor allele + #: (possibly with prior if specified). + self.p_major_ancestral: float = p_major_ancestral + + #: The predicted ancestral base based on comparing major and minor allele. + self.major_ancestral: str = major_ancestral + + #: The probability of each base being the ancestral base for the first internal node. + self.p_bases_first_node: Dict[str, float] = {} if p_bases_first_node is None else p_bases_first_node + + #: The probability that the mostly likely base for the first internal node is the ancestral base. + self.p_first_node_ancestral: float = p_first_node_ancestral + + #: The ancestral base index for the first internal node. + self.first_node_ancestral: str = first_node_ancestral + + #: The branch rates. + self.rate_params: Dict[str, float] = {} if rate_params is None else rate_params + + def plot_tree( + self, + ax: 'plt.Axes' = None, + show: bool = True, + ): + """""" + Plot the tree for a site. Only Python visualization is supported. + + :param self: The site information. + :param ax: Axes to plot on. + :param show: Whether to show the plot. + """""" + import matplotlib.pyplot as plt + + if ax is None: + ax = plt.gca() + + if 'K' in self.rate_params: + branch_lengths = {f'K{i}': self.rate_params['K'] for i in range(len(self.outgroup_bases) * 2 - 1)} + else: + branch_lengths = self.rate_params + + n_outgroups = len(self.outgroup_bases) + + # Create major, minor, and ingroup clades + major_clade = Clade(name=self.major_base, branch_length=0) + minor_clade = Clade(name=self.minor_base, branch_length=0) + ingroup = Clade( + name=""ingroup"", + clades=[major_clade, minor_clade], + branch_length=branch_lengths['K0'] if n_outgroups > 0 else 0 + ) + + current = ingroup + + # Create and attach outgroup clades to major and minor clades + for i in range(n_outgroups): + + # last outgroup has half the branch length to the root + # as we have no internal node + if i < n_outgroups - 1: + outgroup_length = branch_lengths[f""K{2 * i + 1}""] + else: + outgroup_length = branch_lengths[f""K{2 * i}""] / 2 + + # create outgroup clade + outgroup = Clade( + name=self.outgroup_bases[i], + branch_length=outgroup_length + ) + + # determine the branch length to the next node + if i < n_outgroups - 2: + node_length = branch_lengths[f""K{2 * i + 2}""] + elif i == n_outgroups - 2: + node_length = branch_lengths[f""K{2 * i + 2}""] / 2 + else: + node_length = 0 + + # create internal node / root + current = Clade( + name=f""internal {i + 1}"" if i < n_outgroups - 1 else None, + clades=[outgroup, current], + branch_length=node_length + ) + + # create a tree object and visualize + tree = Tree(root=current) + Phylo.draw(tree, axes=ax, do_show=False) + + # remove Y-axis + ax.axes.get_yaxis().set_visible(False) + + # remove frame + for pos in ['top', 'right', 'left']: + ax.spines[pos].set_visible(False) + + if show: + plt.show() + + +class _TooFewIngroupsSiteError(ValueError): + """""" + Raised when there are too few ingroups to consider a site for ancestral allele annotation. + """""" + pass + + +class _PolyAllelicSiteError(ValueError): + """""" + Raised when a site has more than two alleles. + """""" + pass + + +class BaseType(Enum): + """""" + The base type, either major or minor. + """""" + MINOR: int = 0 + MAJOR: int = 1 + + +class PolarizationPrior(ABC): + """""" + Base class for priors used with :class:MaximumLikelihoodAncestralAnnotation. + These priors incorporate information about the general probability of the major allele being ancestral + across all sites with the same minor allele count. Prior thus take ingroup allele frequencies into account, + when making predictions about the ancestral state of a site. This is useful because it enhances ancestral + allele probability estimates, especially when outgroup information is unavailable for a particular site. + Knowing the likelihood of the major allele being ancestral in general allows for more informed estimations. + """""" + + def __init__(self, allow_divergence: bool = False): + """""" + Create a new instance. + + :param allow_divergence: Whether to allow divergence. If ``True``, the probability of the minor allele + being ancestral, which is not contained in the ingroup subsample but rather in all specified ingroups + or among the outgroup, is taken to be the same as if it was present in the ingroup subsample with + frequency 1. This is a hack, but allows us to consider alleles that are not present in the ingroup + subsample. + + .. warning:: Setting this to ``True`` greatly increases the probability of high-frequency derived alleles + which introduces a strong bias in the distribution of frequency counts, e.g., the SFS. Only use this + if you're interested in handling divergence counts, i.e., sites where the ingroup is mono-allelic. + + """""" + #: The logger. + self._logger = logger.getChild(self.__class__.__name__) + + #: Whether to allow divergence. + self.allow_divergence: bool = allow_divergence + + #: The polarization probabilities. + self.probabilities: np.ndarray | None = None + + def _add_divergence(self): + """""" + Add divergence to the polarization probabilities. + """""" + # take divergence probabilities to be the same as alleles of frequency 1 + if self.allow_divergence: + self.probabilities[0] = self.probabilities[1] + self.probabilities[-1] = self.probabilities[-2] + + else: + # set divergence probabilities to 0 + self.probabilities[0] = 1 + self.probabilities[-1] = 0 + + @abstractmethod + def _get_prior(self, configs: pd.DataFrame, n_ingroups: int) -> np.ndarray: + """""" + Get the polarization probabilities. + + :param configs: The site configurations. + :param n_ingroups: The number of ingroups. + """""" + pass + + def plot( + self, + file: str = None, + show: bool = True, + title: str = 'polarization probabilities', + scale: Literal['lin', 'log'] = 'lin', + ax: 'plt.Axes' = None, + ylabel: str = 'p' + ) -> 'plt.Axes': + """""" + Visualize the polarization probabilities using a scatter plot. + + :param scale: y-scale of the plot. + :param title: Plot title. + :param file: File to save plot to. + :param show: Whether to show plot. + :param ax: Axes to plot on. Only for Python visualization backend. + :param ylabel: y-axis label. + :return: Axes object + """""" + from .visualization import Visualization + + if self.probabilities is None: + raise ValueError('Polarization probabilities have not been calculated yet.') + + return Visualization.plot_scatter( + values=self.probabilities, + file=file, + show=show, + title=title, + scale=scale, + ax=ax, + ylabel=ylabel + ) + + +class KingmanPolarizationPrior(PolarizationPrior): + """""" + Prior based on the standard Kingman coalescent. To be used with + :class:`MaximumLikelihoodAncestralAnnotation`. + """""" + + def _get_prior(self, configs: pd.DataFrame, n_ingroups: int) -> np.ndarray: + """""" + Get the polarization probabilities. + + :param configs: The site configurations. + :param n_ingroups: The number of ingroups. + """""" + self.probabilities = np.zeros(n_ingroups + 1) + + # calculate polarization probabilities + for i in range(1, n_ingroups): + self.probabilities[i] = 1 / i / (1 / i + 1 / (n_ingroups - i)) + + # add divergence probabilities + self._add_divergence() + + return self.probabilities + + +class AdaptivePolarizationPrior(PolarizationPrior): + """""" + Adaptive prior. To be used with :class:`MaximumLikelihoodAncestralAnnotation`. This is the + same prior as used in the EST-SFS paper. This prior is adaptive in the sense that the most likely polarization + probabilities given the site configurations are found. This is the most accurate prior, but requires a lot of + sites in order to work properly. You can check that the polarization probabilities are smooth enough across + frequency counts by calling :meth:`~fastdfe.annotation.PolarizationPrior.plot`. If they are not + smooth enough, you can increase the number of sites, decrease the number of ingroups, or + use :class:`~fastdfe.annotation.KingmanPolarizationPrior` instead. + + .. note:: In practice, this prior provides very similar results to :class:`KingmanPolarizationPrior` in most cases. + """""" + + def __init__( + self, + n_runs: int = 1, + parallelize: bool = True, + allow_divergence: bool = False, + seed: int | None = 0 + ): + """""" + Create a new adaptive prior instance. + + :param n_runs: The number of runs to perform when determining the polarization parameters. One + run should be sufficient as only one parameter is optimized. + :param parallelize: Whether to parallelize the optimization. + :param allow_divergence: Whether to allow divergence. See :class:`PolarizationPrior` for details. + :param seed: The seed for the random number generator. + """""" + super().__init__(allow_divergence=allow_divergence) + + #: The number of runs to use for the adaptive prior. + self.n_runs: int = n_runs + + #: Whether to parallelize the optimization. + self.parallelize: bool = parallelize + + #: The seed for the random number generator. + self.seed: int | None = seed + + #: The random number generator. + self.rng: np.random.Generator = np.random.default_rng(seed=self.seed) + + def _get_prior( + self, + configs: pd.DataFrame, + n_ingroups: int + ) -> np.ndarray: + """""" + Get the polarization probabilities. + + :param configs: The site configurations. + :param n_ingroups: The number of ingroups. + :return: The polarization probabilities. + """""" + from scipy.optimize import minimize, OptimizeResult + + # folded frequency bin indices + # if the number of polymorphic bins is odd, the middle bin is fixed + freq_indices = range(1, (n_ingroups + 1) // 2) + + # get the likelihood functions + funcs = dict((i, self._get_likelihood(i, configs, n_ingroups)) for i in freq_indices) + + def optimize_polarization(args: List[Any]) -> OptimizeResult: + """""" + Optimize the likelihood function for a single run. + + :param args: The arguments. + :return: The optimization results. + """""" + # unpack arguments + i, _, x0 = args + + # optimize using scipy + return minimize( + fun=funcs[int(i)], + x0=np.array([x0]), + bounds=[(0, 1)], + method=""L-BFGS-B"" + ) + + # prepare arguments + data = np.array(list(itertools.product(freq_indices, range(self.n_runs)))) + + # get initial values + initial_values = np.array([self.rng.uniform() for _ in range(data.shape[0])]) + + # add initial values + data = np.hstack((data, initial_values.reshape((-1, 1)))) + + # run the optimization in parallel for each frequency bin over n_runs + results: np.ndarray = parallelize_func( + func=optimize_polarization, + data=data, + parallelize=self.parallelize, + pbar=True, + desc=f""{self.__class__.__name__}>Optimizing polarization priors"", + dtype=object + ).reshape(len(freq_indices), self.n_runs) + + # get the likelihoods for each run and frequency bin + likelihoods = np.vectorize(lambda r: r.fun)(results) + + # choose run with the best likelihood for each frequency bin + i_best = likelihoods.argmin(axis=1) + + # check for successful optimization + if not np.all(np.vectorize(lambda r: r.success)(results[:, i_best])): + # get the failure messages + failures = [r.message for r in results[:, i_best] if not r.success] + + # raise an error + raise RuntimeError(""Polarization probability optimizations failed with messages: "" + "", "".join(failures)) + + # get the probabilities for each frequency bin + # noinspection all + probs = np.array([results[i, j].x[0] for i, j in enumerate(i_best)]) + + # check for zeros or ones + if np.any(probs == 0) or np.any(probs == 1): + # get the number of bad frequency bins + n_bad = np.sum((probs == 0) | (probs == 1)) + + self._logger.fatal(f""Polarization probabilities are 0 for {n_bad} frequency bins which "" + f""can be a real problem as it means that there are no sites "" + f""for those bins. This may be due to ``n_ingroups`` "" + f""being too large, or the number of provided sites being very "" + f""small. If you can't increase the number of sites or decrease "" + f""``n_ingroups``, consider using a the Kingman prior instead."") + + # if the number of ingroups is even + if n_ingroups % 2 == 0: + # noinspection all + self.probabilities = np.concatenate(([1], probs, [0.5], 1 - probs[::-1], [0])) + else: + # if the number of ingroups is odd + # noinspection all + self.probabilities = np.concatenate(([1], probs, 1 - probs[::-1], [0])) + + # add divergence probabilities + self._add_divergence() + + return self.probabilities + + @staticmethod + def _get_likelihood( + i: int, + configs: pd.DataFrame, + n_ingroups: int + ) -> Callable[[List[float]], float]: + """""" + Get the likelihood function. + + :param i: The ith frequency bin. + :param configs: The site configurations. + :param n_ingroups: The number of ingroups. + The likelihood function evaluated for the ith frequency bin. + """""" + + def compute_likelihood(params: List[float]) -> float: + """""" + Compute the negative log likelihood of the parameters. + + :param params: The probability of polarization. + :return: The negative log likelihood. + """""" + # get the probability of polarization for the ith frequency bin + pi = params[0] + + # mask for sites that have i minor alleles + i_minor = n_ingroups - configs.n_major == i + + # weight the sites by the probability of polarization + p_configs = pi * configs.p_major[i_minor] + (1 - pi) * configs.p_minor[i_minor] + + # return the negative log likelihood + return -(np.log(p_configs) * configs.multiplicity[i_minor]).sum() + + return compute_likelihood + + +class _OutgroupAncestralAlleleAnnotation(AncestralAlleleAnnotation, ABC): + """""" + Abstract class for annotation of ancestral alleles using outgroup information. + """""" + + def __init__( + self, + outgroups: List[str], + n_ingroups: int, + ingroups: List[str] | None = None, + exclude: List[str] = [], + seed: int | None = 0, + subsample_mode: Literal['random', 'probabilistic'] = 'random' + ): + """""" + Create a new ancestral allele annotation instance. + + :param outgroups: The outgroup samples to consider when determining the ancestral allele. A list of + sample names as they appear in the VCF file. + :param n_ingroups: The minimum number of ingroups that must be present at a site for it to be considered + for ancestral allele inference. + :param ingroups: The ingroup samples to consider when determining the ancestral allele. A list of + sample names as they appear in the VCF file. If ``None``, all samples except the outgroups are + considered. + :param exclude: Samples to exclude from the ingroup. A list of sample names as they appear in the VCF file. + :param seed: The seed for the random number generator. + :param subsample_mode: The subsampling mode. Either 'random' or 'probabilistic'. + """""" + # make sure the number of ingroups is at least 2 + if n_ingroups < 2: + raise ValueError(""The number of ingroups must be at least 2."") + + # check subsample mode + if subsample_mode not in ['random', 'probabilistic']: + raise ValueError(f""Invalid subsample mode: {subsample_mode}"") + + super().__init__() + + #: The ingroup samples to consider when determining the ancestral allele. + self.ingroups: List[str] | None = ingroups + + #: The samples excluded from the ingroup. + self.exclude: List[str] = exclude + + #: The outgroup samples to consider when determining the ancestral allele. + self.outgroups: List[str] = outgroups + + #: The number of ingroups. + self.n_ingroups: int = int(n_ingroups) + + #: The number of outgroups. + self.n_outgroups: int = len(outgroups) + + #: The seed for the random number generator. + self.seed: int | None = seed + + #: The subsampling mode. + self.subsample_mode: Literal['random', 'probabilistic'] = subsample_mode + + #: The random number generator. + self.rng: np.random.Generator = np.random.default_rng(seed=self.seed) + + #: The outgroup mask. + self._outgroup_mask: np.ndarray | None = None + + #: The outgroup indices. + self._outgroup_indices: np.ndarray | None = None + + #: The ingroup mask. + self._ingroup_mask: np.ndarray | None = None + + #: 1-based positions of lowest and highest site position per contig (only when target_site_counter is used) + # noinspection PyTypeChecker + self._contig_bounds: Dict[str, Tuple[int, int]] = defaultdict(lambda: (np.inf, -np.inf)) + + def _prepare_masks(self, samples: List[str]): + """""" + Prepare the masks for ingroups and outgroups. + + :param samples: All samples. + """""" + # create mask for ingroups + if self.ingroups is None: + self._ingroup_mask = ~ np.isin(samples, self.outgroups) & ~ np.isin(samples, self.exclude) + else: + self._ingroup_mask = np.isin(samples, self.ingroups) & ~ np.isin(samples, self.exclude) + + # create mask for outgroups + self._outgroup_mask = np.isin(samples, self.outgroups) + + # make sure all specified outgroups are present + if np.sum(self._outgroup_mask) != len(self.outgroups): + # get missing outgroups + missing = np.array(self.outgroups)[~np.isin(self.outgroups, samples)] + + raise ValueError(f""The specified outgroups ({', '.join(missing)}) are not present in the VCF file."") + + # outgroup indices + # we ignore the order when using the mask + self._outgroup_indices = np.array([samples.index(outgroup) for outgroup in self.outgroups]) + + # inform of the number of ingroups + self._logger.info(f""Subsampling {self.n_ingroups} ingroup haplotypes "" + + (""randomly "" if self.subsample_mode == ""random"" else ""probabilistically "") + + f""from {np.sum(self._ingroup_mask)} individuals in total."") + + # inform on outgroup samples + self._logger.info(f""Using {np.sum(self._outgroup_mask)} outgroup samples ({', '.join(self.outgroups)})."") + + def _setup(self, handler: MultiHandler): + """""" + Add info fields to the header. + + :param handler: The handler. + """""" + super()._setup(handler) + + # add AA info field + handler._reader.add_info_to_header({ + 'ID': self._handler.info_ancestral + '_info', + 'Number': '.', + 'Type': 'String', + 'Description': 'Additional information about the ancestral allele.' + }) + + # add AA probability field + handler._reader.add_info_to_header({ + 'ID': self._handler.info_ancestral + '_prob', + 'Number': '.', + 'Type': 'Float', + 'Description': 'Probability that the predicted ancestral allele is correct, as opposed to the other allele.' + }) + + # set reader + self._reader = self._handler.load_vcf() + + # prepare masks + self._prepare_masks(handler._reader.samples) + + @staticmethod + def _subsample( + genotypes: np.ndarray, + size: int, + rng: np.random.Generator + ) -> np.ndarray: + """""" + Subsample a set of bases. + + :param genotypes: A list of bases. + :param size: The size of the subsample. + :return: A subsample of the bases. + """""" + if genotypes.shape[0] == 0: + return np.array([]) + + subsamples = rng.choice( + a=genotypes.shape[0], + size=min(size, genotypes.shape[0]), + replace=False + ) + + return genotypes[subsamples] + + @staticmethod + def _get_outgroup_bases( + genotypes: np.ndarray, + n_outgroups: int + ) -> np.ndarray: + """""" + Get the outgroup bases for a variant. + + :param genotypes: The VCF genotype strings. + :param n_outgroups: The number of outgroups. + :return: The outgroup bases. + """""" + outgroup_bases = np.full(n_outgroups, '.') + + for i, genotype in enumerate(genotypes): + called_bases = get_called_bases([genotype]) + + if len(called_bases) > 0: + outgroup_bases[i] = called_bases[0] + + return outgroup_bases + + @classmethod + def _subsample_site( + cls, + mode: Literal['random', 'probabilistic'], + n: int, + samples: np.ndarray, + rng: np.random.Generator + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """""" + Subsample a site, either randomly or probabilistically. + + :param mode: The subsampling mode. + :param n: The number of ingroups to subsample to. + :param samples: The samples. + :return: Major alleles, major allele counts, and multiplicities, + possibly including zero multiplicities. + """""" + if mode == 'random': + # subsample ingroups + samples = cls._subsample(samples, size=n, rng=rng) + + # get the major allele count + most_common = Counter(samples).most_common() + + if mode == 'random': + + major_alleles = [most_common[0][0]] + n_majors = [most_common[0][1]] + m = [1] + + # if there is only one allele, probabilistic + # subsampling is trivial + elif len(most_common) < 2: + + major_alleles = [most_common[0][0]] + n_majors = [n] + m = [1] + + else: + ref_allele = most_common[0][0] + n_ref = most_common[0][1] + alt_allele = most_common[1][0] + + # get the major allele counts + n_majors = np.arange(n + 1) + major_alleles = np.full(n + 1, ref_allele) + m = hypergeom.pmf(k=n_majors, M=len(samples), n=n_ref, N=n) + + # flip alleles where the ref allele is not the major allele + flip = n_majors < (n + 1) // 2 + n_majors[flip] = n - n_majors[flip] + major_alleles[flip] = alt_allele + + return major_alleles, n_majors, m + + def _parse_variant(self, variant: Union['cyvcf2.Variant', DummyVariant]) -> List[SiteConfig]: + """""" + Parse a VCF variant. We only consider sites that are at most bi-allelic in the in- and outgroups. + + :param variant: The variant. + :return: List of site configurations containing a single element if subsample_mode is ``random`` or + multiple elements if subsample_mode is ``probabilistic`` or ``None`` if the site is not valid. + :raises _TooFewIngroupsSiteError: If there are too few ingroups to consider a site for ancestral allele + annotation. _PolyAllelicSiteError: If a site has more than two alleles. + """""" + # get the called ingroup bases + ingroups = get_called_bases(variant.gt_bases[self._ingroup_mask]) + + # get the numer of called ingroup and outgroup bases + n_ingroups = len(ingroups) + + # make sure we have enough ingroups + if n_ingroups < self.n_ingroups: + raise _TooFewIngroupsSiteError() + + # get the called outgroup bases + # the order does not matter here + outgroups = get_called_bases(variant.gt_bases[self._outgroup_mask]) + + # get total base counts + counts = Counter(np.concatenate((ingroups, outgroups))) + + # make sure we have at most two alleles + if len(counts) > 2: + raise _PolyAllelicSiteError() + + # get the bases + b: List[str] = list(counts.keys()) + + # subsample ingroups either randomly or probabilistically + major_alleles, n_majors, multiplicities = self._subsample_site( + mode=self.subsample_mode, + n=self.n_ingroups, + samples=ingroups, + rng=self.rng + ) + + # Get the outgroup bases. + # The outgroup order is important, so we can't use the mask here. + outgroup_bases = self.get_base_index(self._get_outgroup_bases( + genotypes=np.array([variant.gt_bases[i] for i in self._outgroup_indices]), + n_outgroups=self.n_outgroups + )) + + # create site configurations + sites = [] + for i, (major_allele, n_major, multiplicity) in enumerate(zip(major_alleles, n_majors, multiplicities)): + + if multiplicity > 0: + if len(counts) == 2: + # Take the other allele as the minor allele. We keep track of the minor allele + # even if it wasn't contained in the ingroup subsample. + minor_base: str = b[0] if b[0] != major_allele else b[1] + else: + minor_base: str = '.' + + # create site configuration + site = SiteConfig( + major_base=base_indices[major_allele], + n_major=n_major, + minor_base=self.get_base_index(minor_base), + outgroup_bases=outgroup_bases, + multiplicity=multiplicity + ) + + sites.append(site) + + return sites + + @staticmethod + def get_base_string(indices: int | np.ndarray) -> str | np.ndarray: + """""" + Get base string(s) from base index/indices. + + :param indices: The base index/indices. + :return: Base string(s). + """""" + if isinstance(indices, np.ndarray): + + if len(indices) == 0: + return np.array([]) + + is_valid = indices != -1 + + base_strings = np.full(indices.shape, '.', dtype=str) + base_strings[is_valid] = bases[indices[is_valid]] + + return base_strings + + # assume integer + if indices != -1: + return bases[indices] + + return '.' + + @classmethod + def get_base_index(cls, base_string: str | np.ndarray) -> int | np.ndarray: + """""" + Get base index/indices from base string(s). + + :param base_string: The base string(s). + :return: Base index/indices. + """""" + if isinstance(base_string, np.ndarray): + return np.array([cls.get_base_index(b) for b in base_string], dtype=int) + + # assume string + if base_string in bases: + return base_indices[base_string] + + return -1 + + +class MaximumLikelihoodAncestralAnnotation(_OutgroupAncestralAlleleAnnotation): + """""" + Annotation of ancestral alleles following the probabilistic model of EST-SFS + (https://doi.org/10.1534/genetics.118.301120). Note that only bi-allelic SNPs are supported by this model. + By default, the info field ``AA`` (see :attr:`Annotator.info_ancestral`) is added to the VCF file, which holds the + ancestral allele. To be used with :class:`Annotator` or :class:`~fastdfe.parser.Parser`. + The info field ``AA_prob`` holds the probability that the + predicted ancestral allele (``AA`` tag) is correct, as opposed to the other allele. This probability can be also + be used by :class:`~fastdfe.parser.Parser` to polarize the SFS according to the ancestral allele probability. + In addition to the ancestral allele, the info field ``AA_info`` is added, which contains additional information + about the ancestral allele (see :class:`SiteInfo` for an overview of the available information). + This class can also be used independently, see the :meth:`from_dataframe`, :meth:`from_data` and + :meth:`from_est_sfs` methods. + + Initially, the branch rates are determined using MLE. Similar to :class:`Parser`, we can also specify the number of + mutational target sites (see the ``n_target_sites`` argument) in case our VCF file does not contain the full set of + monomorphic sites. This is necessary to obtain realistic branch rate estimates. You can also choose a prior for the + polarization probabilities (see :class:`PolarizationPrior`). Eventually, for every site, the probability that the + major allele is ancestral is calculated. + + When annotating the variants of a VCF file, we check the most likely ancestral allele against a naive + ad-hoc ancestral allele annotation, and record the sites for which we have disagreement. You might want to + sanity-check the mismatches to make sure the model has been properly specified (see :attr:`mismatches`). + + .. note:: + + * The polarization prior corresponds to the Kingman coalescent probability by default. Using an adaptive prior, + as in the EST-SFS paper, is also possible, but this is only recommended if the number of sites used for the + inference is large (see :attr:`prior`). + + * The model can only handle sites that have at most 2 alleles across the in- and outgroups, so sites with more + than 2 alleles are ignored. Only variants that are at most bi-allelic in the provided in- and outgroups are + annotated. + + * The model determines the probability of the major allele being ancestral opposed to the minor allele. This can + be problematic if the actual ancestral allele is not contained in the ingroup (possibly due to subsampling). + To avoid this issue, we also keep track of potential minor alleles at frequency 0. If we were to ignore this, + it would be impossible to infer divergence, i.e. fixed derived allele that are no longer observed in the + ingroups (see :attr:`PolarizationPrior.allow_divergence`). That said, divergence counts are not informative + on DFE inference with fastDFE and allow_divergence should not be set to ``True`` if interested in the SFS. + + * The model assumes a single coalescent topology for all sites, in which all outgroups coalesce first with the + ingroup and not with each other. It is important to specify the outgroups in order of increasing divergence + and not to select outgroups that are not much more closely related to each other than to the ingroup (as this + would give rise to a different coalescent topology than the one assumed). You can call + :meth:`get_outgroup_divergence` after the inference to check the estimated branch rates for each outgroup. + The assumption of a single fixed topology should be good enough provided that in- and outgroups are + sufficiently diverged. + + Example usage: + + :: + + import fastdfe as fd + + ann = fd.Annotator( + vcf=""https://github.com/Sendrowski/fastDFE/"" + ""blob/dev/resources/genome/betula/all."" + ""with_outgroups.subset.10000.vcf.gz?raw=true"", + annotations=[fd.MaximumLikelihoodAncestralAnnotation( + outgroups=[""ERR2103730""], + n_ingroups=15 + )], + output=""genome.polarized.vcf.gz"" + ) + + ann.annotate() + + """""" + + #: The data types for the data frame + _dtypes = dict( + n_major=np.int8, + multiplicity=np.float64, + sites=object, + major_base=np.int8, + minor_base=np.int8, + outgroup_bases=object, + p_major_ancestral=np.float64, + p_minor=np.float64, + p_major=np.float64 + ) + + #: The columns to group by. + _group_cols = ['major_base', 'minor_base', 'outgroup_bases', 'n_major'] + + def __init__( + self, + outgroups: List[str], + n_ingroups: int = 11, + ingroups: List[str] | None = None, + exclude: List[str] | None = None, + n_runs: int = 10, + model: SubstitutionModel = None, + parallelize: bool = True, + prior: PolarizationPrior | None = '', + max_sites: int = 10000, + seed: int | None = 0, + confidence_threshold: float = 0, + n_target_sites: int | None = None, + n_samples_target_sites: int | None = 100000, + adjust_target_sites: bool = True, + subsample_mode: Literal['random', 'probabilistic'] = 'probabilistic' + ): + """""" + Create a new ancestral allele annotation instance. + + :param outgroups: The outgroup samples to consider when determining the ancestral allele in the order of + increasing divergence. A list of sample names as they appear in the VCF file. The order of the outgroups + is important as it determines the order of the branches in the tree, whose rates are optimized, and whose + topology is predetermined. The first outgroup is the closest outgroup to the ingroups, and the last + outgroup is the most distant outgroup. More outgroups lead to a more accurate inference of the ancestral + allele, but also increase the computational cost. Using more than 1 outgroup is recommended, but more than + 3 is likely not necessary. Sites where these outgroups are not present are not included when optimizing + the rate parameters. Due to assumptions on the tree topology connecting the in- and outgroups, it is + important that the outgroups are not much more closely related to each other than to the ingroups. Ideally, + the optimized branch rates are show markedly different values, and in any case, they should be monotonically + increasing with the outgroups (see :meth:`get_outgroup_divergence`). + :param n_ingroups: The minimum number of ingroups that must be present at a site for it to be considered + for ancestral allele inference. The ingroup subsampling is necessary since our model requires an equal + number of ingroups for all sites. Note that a larger number of ingroups does not necessarily improve + the accuracy of the ancestral allele inference (see ``prior``). A larger number of ingroups can lead + to a large variance in the polarization probabilities, across different frequency counts. ``n_ingroups`` + should thus only be large if the number of sites used for the inference is also large. A sensible value + for a reasonably large number of sites (a few thousand) is 10 or perhaps 20 for a larger numbers of sites. + Very small values can lead to the ingroup subsamples not being representative of the actual allele + frequencies at a site, especially when not using probabilistic subsampling (see ``subsample_mode``). + This value also influences the number of frequency bins used for the polarization probabilities, and should + thus not be too small. Note that if ``ingroups`` is an even number, the major allele is chosen arbitrarily + if the number of major alleles is equal to the number of minor alleles. To avoid this, you can use an odd + number of ingroups. + :param ingroups: The ingroup samples to consider when determining the ancestral allele. If ``None``, + all (non-outgroup) samples are considered. A list of sample names as they appear in the VCF file. + Has to be at least as large as ``n_ingroups``. + :param exclude: Samples to exclude from the ingroup. A list of sample names as they appear in the VCF file. + :param n_runs: The number of optimization runs to perform when determining the branch rates. You can + check that the likelihoods of the different runs are similar by calling :meth:`plot_likelihoods`. + :param model: The substitution model to use. By default, :class:`K2SubstitutionModel` is used. + :param parallelize: Whether to parallelize the computation across multiple cores. + :param prior: The prior to use for the polarization probabilities. See + :class:`KingmanPolarizationPrior` and :class:`AdaptivePolarizationPrior` for more information. By default, + :class:`KingmanPolarizationPrior` is used. Use ``''`` for no prior. + :param max_sites: The maximum number of sites to consider. This is useful if the number of sites is very large. + Choosing a reasonably large subset of sites (on the order of a few thousand bi-allelic sites) can speed up + the computation considerably as parsing can be slow. This subset is then used to calibrate the rate + parameters, and possibly the polarization priors. + :param seed: The seed for the random number generator. If ``None``, a random seed is chosen. By default, the + seed is set to 0. + :param confidence_threshold: The confidence threshold for the ancestral allele annotation. + Only if the probability of the major allele being ancestral as opposed to + the minor allele is not within ``((1 - confidence_threshold) / 2, 1 - (1 - confidence_threshold) / 2)``, + the ancestral allele is annotated. This is useful to avoid annotating sites where the ancestral allele + state is not clear. Use values close to ``0`` to annotate as many sites as possible, and values close to + ``1`` to annotate only sites where the ancestral allele state is very clear. + + .. warning:: This threshold introduces a bias by excluding more sites with high-frequency derived alleles + and should thus be kept at ``0`` if the distribution of frequency counts is important, e.g., if the SFS + is to be determined. + :param n_target_sites: The total number of target sites if this class is used in conjunction with + :class:`Parser` or :class:`Annotator`. This is useful if the provided set of sites only + consists of bi-allelic sites. Specify here the total number of sites underlying the given dataset, i.e., + both mono- and bi-allelic sites. Ignoring mono-allelic sites will lead to overestimation of the rate + parameters. For this to work, a FASTA file must be provided from which the mono-allelic sites can be + sampled. Sampling takes place between the variants of the last and first site on every contig considered + in the VCF file. Use ``None`` to disable this feature. Note that the number of target sites is automatically + carried over if not specified and this class is used together with :class:`Parser`. In order to use this + feature, you also need to specify a FASTA file to :class:`Parser` or :class:`Annotator`. Also note that + by default we extrapolate the number of mono-allelic sites to be sampled from the FASTA file based on the + ratio of sites with called outgroup bases parsed from the VCF file (``adjust_target_sites``). + :param n_samples_target_sites: The number of sites to sample from the FASTA file when determining the number of + target sites (``n_target_sites``). From this the total number of target sites is extrapolated. + :param adjust_target_sites: Whether to adjust the number of target sites based on the parsed VCF sites relative + to the total number of sites in the VCF. Defaults to ``True``. + :param subsample_mode: The subsampling mode. For ``random``, we draw once without replacement from the set of + all available ingroup genotypes per site. For ``probabilistic``, we integrate over the hypergeometric + distribution when parsing and computing the ancestral probabilities. Probabilistic subsampling requires a + bit more time, but produces much more stable results, while requiring far fewer sites, so it is highly + recommended. + """""" + super().__init__( + ingroups=ingroups, + exclude=exclude, + outgroups=outgroups, + n_ingroups=n_ingroups, + seed=seed, + subsample_mode=subsample_mode + ) + + # check that we have at least one outgroup + if len(outgroups) < 1: + raise ValueError(""Must specify at least one outgroup. If you do not have any outgroup "" + ""information, consider using MaximumParsimonyAncestralAnnotation instead."") + + # check that we have enough ingroups specified if specified at all + if ingroups is not None and len(ingroups) * 2 < n_ingroups: + self._logger.warning(""The number of specified ingroup samples is smaller than the "" + ""number of ingroups (assumed diploidy). Please make sure to "" + ""provide sufficiently many ingroups."") + + # raise warning on bias + if confidence_threshold > 0: + self._logger.warning(""Please be aware that a confidence threshold of greater than 0 biases the SFS "" + ""towards fewer high-frequency derived alleles."") + + #: Whether to parallelize the computation. + self.parallelize: bool = parallelize + + #: Maximum number of sites to consider + self.max_sites: int = max_sites + + #: The confidence threshold for the ancestral allele annotation. + self.confidence_threshold: float = confidence_threshold + + #: The prior to use for the polarization probabilities. + self.prior: PolarizationPrior | None = KingmanPolarizationPrior() if prior == '' else prior + + #: Number of random ML starts when determining the rate parameters + self.n_runs: int = int(n_runs) + + #: The substitution model. + self.model: SubstitutionModel = K2SubstitutionModel() if model is None else model + + #: The VCF reader. + self._reader: 'cyvcf2.VCF' | None = None + + #: The data frame holding all site configurations. + self.configs: pd.DataFrame | None = None + + #: The probability of all sites per frequency bin. + self.p_bins: Dict[str, np.ndarray | None] = None + + #: The total number of valid sites parsed (including sites not considered for ancestral allele inference). + self.n_sites: int | None = None + + #: The parameter names in the order they are passed to the optimizer. + self.param_names: List[str] = list(self.model.get_bounds(self.n_outgroups).keys()) + + #: The log likelihoods for the different runs when optimizing the rate parameters. + self.likelihoods: np.ndarray | None = None + + #: The best log likelihood when optimizing the rate parameters. + self.likelihood: float | None = None + + #: Optimization result of the best run. + self.result: Optional['scipy.optimize.OptimizeResult'] = None + + #: The MLE parameters. + self.params_mle: Dict[str, float] | None = None + + #: The MLE parameters for all runs. + self.params_mle_runs: pd.DataFrame | None = None + + #: Mismatches between the most likely ancestral allele and the ad-hoc ancestral allele. + # This is only computed when annotating a VCF file, and only contains the mismatches + # for sites that were actually annotated. + self.mismatches: List[SiteInfo] = [] + + #: The total number of target sites. + self.n_target_sites: int | None = n_target_sites + + #: The number of sites to sample from the FASTA file when determining the number of target sites. + self.n_samples_target_sites: int = n_samples_target_sites + + #: Whether to adjust the number of target sites based on the number of sites parsed from the VCF file. + self.adjust_target_sites: bool = adjust_target_sites + + #: The monomorphic site counts sampled from the FASTA file. + self._monomorphic_samples: Dict[str, int] = {'A': 0, 'C': 0, 'G': 0, 'T': 0} + + def _setup(self, handler: MultiHandler): + """""" + Parse the VCF file and perform the optimization. + + :param handler: The handler. + """""" + from .parser import Parser, TargetSiteCounter + + super()._setup(handler) + + # try to carry over n_target_sites and fasta file from Parser + if isinstance(handler, Parser) and isinstance(handler.target_site_counter, TargetSiteCounter): + + if self.n_target_sites is None: + self.n_target_sites = handler.target_site_counter.n_target_sites + + self._logger.debug(f""Using n_target_sites={self.n_target_sites} from Parser."") + + if self.n_target_sites is not None: + # check that we have a fasta file if we sample mono-allelic sites + handler._require_fasta(self.__class__.__name__) + + # load data + self._parse_vcf() + + # sample mono-allelic sites if necessary + if self.n_target_sites is not None: + self._sample_mono_allelic_sites() + + # notify on statistics + self._log_stats() + + # set up substitution model + self.model._setup(self) + + # infer ancestral alleles + self.infer() + + def _log_stats(self): + """""" + Log statistics about the ancestral allele annotation. + """""" + configs = self._get_mle_configs() + n_sites = int(np.round(configs.multiplicity.sum())) + n_monomorphic = int(np.round(configs[configs.minor_base == -1].multiplicity.sum())) + n_polymorphic = n_sites - n_monomorphic + + self._logger.info( + f""Included {n_sites} sites for the inference ({n_polymorphic} polymorphic, {n_monomorphic} monomorphic)."" + ) + + def _get_n_target_sites_adjusted(self) -> int: + """""" + Get the number of target sites adjusted by the number of sites parsed. + This assumed that the sites have not been sampled yet. + """""" + if self.adjust_target_sites: + ratio = self._get_mle_configs().multiplicity.sum() / self.n_sites + else: + ratio = 1 + + return int(ratio * (self.n_target_sites - self.n_sites)) + + def _get_n_sites(self) -> int: + """""" + Get the number of sites to consider. + """""" + return int(self.configs.multiplicity.sum()) + + def _sample_mono_allelic_sites(self): + """""" + Sample mono-allelic sites from the FASTA file. + """""" + # inform + self._logger.info(f""Sampling mono-allelic sites."") + + if self.n_target_sites < self.n_sites: + raise ValueError(f""The number of target sites ({self.n_target_sites}) must be at least "" + f""as large as the number of sites parsed ({self.n_sites})."") + + # check that we have enough sites to sample + if self.n_samples_target_sites <= 0 or len(self._contig_bounds) == 0: + self._logger.info(""No mono-allelic sites to sample, skipping."") + return + + # initialize progress bar + pbar = tqdm( + total=self.n_samples_target_sites, + desc=f'{self.__class__.__name__}>Sampling mono-allelic sites', + disable=Settings.disable_pbar + ) + + # get array of ranges per contig of parsed variants + ranges = np.array(list(self._contig_bounds.values())) + + # get range sizes + range_sizes = ranges[:, 1] - ranges[:, 0] + + # determine sampling probabilities + probs = range_sizes / np.sum(range_sizes) + + # sample number of sites per contig + sample_counts = self.rng.multinomial(self.n_samples_target_sites, probs) + + # sampled bases + samples = dict(A=0, C=0, G=0, T=0) + + # iterate over contigs + for contig, bounds, n in zip(self._contig_bounds.keys(), ranges, sample_counts): + # get aliases + aliases = self._handler.get_aliases(contig) + + # make sure we have a valid range + if bounds[1] > bounds[0] and n > 0: + self._logger.debug(f""Sampling {n} sites from contig '{contig}'."") + + # fetch contig + record = self._handler.get_contig(aliases, notify=False) + + # sample sites + i = 0 + while i < n: + pos = self.rng.integers(*bounds) + + base = record.seq[pos - 1] + + if base in bases: + # increase counters + samples[base] += 1 + i += 1 + pbar.update() + + # close progress bar + pbar.close() + + # rewind fasta iterator + FASTAHandler._rewind(self._handler) + + n_target_sites = self._get_n_target_sites_adjusted() + + if self.adjust_target_sites: + self._logger.info(f""Extrapolating to {n_target_sites} mutational target sites "" + f""based on the number of sites parsed."") + else: + self._logger.info(f""Extrapolating to {self.n_target_sites} mutational target sites."") + + # ratio for extrapolating to the total number of target sites + ratio = n_target_sites / self.n_samples_target_sites + + # extrapolate the number of monomorphic sites + vec = np.array([samples[k] for k in bases], dtype=float) + scaled = vec * ratio + floors = np.floor(scaled).astype(int) + remainder = n_target_sites - int(floors.sum()) + if remainder > 0: + order = np.argsort(scaled - floors)[::-1] + floors[order[:remainder]] += 1 + + self._monomorphic_samples = {k: int(v) for k, v in zip(bases, floors)} + + # add monomorphic site counts to data frame + self.configs = self._add_monomorphic_sites(self._monomorphic_samples) + + # update number of sites + self.n_sites = self._get_n_sites() + + def _add_monomorphic_sites(self, samples: Dict[str, int]): + """""" + Add monomorphic sites to the data frame holding the site configurations. + + :param samples: The samples. + :return: The data frame. + """""" + + # get indices for new sites + sites = np.concatenate(([self.n_sites], self.n_sites + np.cumsum(list(samples.values())))) + + # construct data frame of new sites + df = pd.DataFrame(dict( + n_major=self.n_ingroups, + major_base=base_indices[base], + minor_base=-1, + outgroup_bases=(base_indices[base],) * self.n_outgroups, + multiplicity=count, + sites=list(range(sites[i], sites[i + 1])), + n_outgroups=self.n_outgroups + ) for i, (base, count) in enumerate(samples.items())) + + # add to data frame + configs = pd.concat((self.configs, df)) + + # aggregate + return configs.groupby(self._group_cols + ['n_outgroups'], as_index=False, dropna=False).sum() + + def _teardown(self): + """""" + Teardown the annotation. + """""" + super()._teardown() + + # inform on mismatches + self._logger.info(f""There were {len(self.mismatches)} mismatches between the most likely "" + f""ancestral allele and the ad-hoc ancestral allele annotation."") + + @classmethod + def _parse_est_sfs(cls, data: pd.DataFrame) -> pd.DataFrame: + """""" + Parse EST-SFS data. + + :param data: The data frame. + :return: The site configurations. + """""" + # extract the number of outgroups + n_outgroups = data.shape[1] - 1 + + # retain site index + data['sites'] = data.index + data['sites'] = data.sites.apply(lambda x: [x]) + + # the first column contains the ingroup counts, split them + ingroup_data = data[0].str.split(',', expand=True).astype(np.int8).to_numpy() + + # determine the number of major alleles per site + data['n_major'] = ingroup_data.max(axis=1) + + # sort by the number of alleles + data_sorted = ingroup_data.argsort(axis=1) + + # determine the number of major alleles per site + data['major_base'] = data_sorted[:, -1] + data['major_base'] = data.major_base.astype(cls._dtypes['major_base']) + + # determine the mono-allelic sites + poly_allelic = (ingroup_data > 0).sum(axis=1) > 1 + + # determine the minor alleles + minor_bases = np.full(data.shape[0], -1, dtype=np.int8) + minor_bases[poly_allelic] = data_sorted[:, -2][poly_allelic] + + # assign the minor alleles + data['minor_base'] = minor_bases + + # extract outgroup data + outgroup_data = np.full((data.shape[0], n_outgroups), -1, dtype=np.int8) + for i in range(n_outgroups): + # get the genotypes + genotypes = data[i + 1].str.split(',', expand=True).astype(np.int8).to_numpy() + + # determine whether the site has an outgroup + has_outgroup = genotypes.sum(axis=1) > 0 + + # determine the outgroup allele indices provided the site has an outgroup + outgroup_data[has_outgroup, i] = genotypes[has_outgroup].argmax(axis=1) + + # assign the outgroup data, convert to tuples for hashing + data['outgroup_bases'] = [tuple(row) for row in outgroup_data] + + # return new columns only + return data.drop(range(n_outgroups + 1), axis=1) + + @classmethod + def from_est_sfs( + cls, + file: str, + prior: PolarizationPrior | None = '', + n_runs: int = 10, + model: SubstitutionModel = None, + parallelize: bool = True, + seed: int = 0, + chunk_size: int = 100000 + ) -> 'MaximumLikelihoodAncestralAnnotation': + """""" + Create instance from EST-SFS input file. + + :param file: File containing EST-SFS-formatted input data. + :param prior: The prior to use for the polarization probabilities (see :meth:`__init__`). + :param n_runs: Number of runs for rate estimation (see :meth:`__init__`). + :param model: The substitution model (see :meth:`__init__`). + :param parallelize: Whether to parallelize the runs (see :meth:`__init__`). + :param seed: The seed to use for the random number generator. + :param chunk_size: The chunk size for reading the file. + :return: The instance. + """""" + # define an empty dataframe to accumulate the data + data = None + n_ingroups = 0 + + # iterate over the file in chunks + for i, chunk in enumerate(pd.read_csv(file, sep=r""\s+"", header=None, dtype=str, chunksize=chunk_size)): + + # determine the number of ingroups + n_ingroups = np.max(np.array(chunk.iloc[0, 0].split(','), dtype=int)) + + # parse the data + parsed = cls._parse_est_sfs(chunk) + + if data is None: + # parse the data + data = parsed + else: + # concatenate with previous data if available + data = pd.concat([data, parsed]) + + data = data.groupby(cls._group_cols, as_index=False, dropna=False).sum() + + # check if there is data + if data is None: + raise ValueError(""No data found."") + + # determine the multiplicity + data['multiplicity'] = data['sites'].apply(lambda x: len(x)) + + # create from dataframe + return cls.from_dataframe( + data=data, + n_runs=n_runs, + model=model, + parallelize=parallelize, + prior=prior, + n_ingroups=n_ingroups, + grouped=True, + seed=seed + ) + + def to_est_sfs(self, file: str): + """""" + Write the object's state to an EST-SFS formatted file. + + :param file: The output file name. + """""" + # get config indices for each site + indices = self._get_site_indices() + + # remove sites that are not included + indices = indices[indices != -1] + + # get the sites + sites = self.configs.iloc[indices] + + with open(file, 'w') as f: + + # iterate over rows + for i, site in sites.iterrows(): + + # ingroup counts + ingroups = np.zeros(4, dtype=int) + + # major allele count + ingroups[site['major_base']] = site['n_major'] + + # minor allele count if not mono-allelic + if site['minor_base'] != -1: + ingroups[site['minor_base']] = self.n_ingroups - site['n_major'] + + # write ingroup counts + outgroups = np.zeros((self.n_outgroups, 4), dtype=int) + + # fill outgroup counts + for j, base in enumerate(site['outgroup_bases']): + if base != -1: + outgroups[j, base] = 1 + + # write line + f.write( + ','.join(ingroups.astype(str)) + + '\t' + + '\t'.join([','.join(o) for o in outgroups.astype(str)]) + + '\n' + ) + + # break if we reached the maximum number of sites + if i + 1 >= self.max_sites: + break + + def to_file(self, file: str): + """""" + Save object to file. + + .. note:: + References to the handler and the reader are discarded. + + :param file: File path. + """""" + with open(file, 'w') as fh: + fh.write(self.to_json()) + + @classmethod + def from_file(cls, file: str) -> 'MaximumLikelihoodAncestralAnnotation': + """""" + Load object from file. + + .. note:: + The handler and the reader are not restored, so serialization is mostly useful + for analyzing the results in detail, not for further processing. + + :param file: File path. + :return: The object. + """""" + with open(file, 'r') as fh: + return cls.from_json(fh.read()) + + def to_json(self) -> str: + """""" + Serialize object. + + .. note:: + References to the handler and the reader are discarded. + + :return: JSON string + """""" + self._reader = None + self._handler = None + + return jsonpickle.encode(self, indent=4, warn=True) + + @classmethod + def from_json(cls, json: str) -> 'MaximumLikelihoodAncestralAnnotation': + """""" + Load object from file. + + .. note:: + The handler and the reader are not restored, so serialization is mostly useful + for analyzing the results in detail, not for further processing. + + :param json: JSON string. + :return: The object. + """""" + anc = jsonpickle.decode(json) + + # convert index to int if necessary + if 'index' in anc.configs: + anc.configs.index = anc.configs.index.astype(int) + + return anc + + @classmethod + def from_data( + cls, + n_major: Iterable[int], + major_base: Iterable[str | int], + minor_base: Iterable[str | int], + outgroup_bases: Iterable[Iterable[str | int]], + n_ingroups: int, + n_runs: int = 10, + model: SubstitutionModel = None, + parallelize: bool = True, + prior: PolarizationPrior | None = '', + seed: int = 0, + pass_indices: bool = False, + confidence_threshold: float = 0 + ) -> 'MaximumLikelihoodAncestralAnnotation': + """""" + Create an instance by passing the data directly. + + :param n_major: The number of major alleles per site. Note that this number has to be lower than ``n_ingroups``, + as we consider the number of major alleles of subsamples of size ``n_ingroups``. + :param major_base: The major allele per site. A string representation of the base or the base index according + to ``['A', 'C', 'G', 'T']`` if ``pass_indices`` is ``True``. Use ``None`` if the base is not defined when + ``pass_indices`` is ``False`` and ``-1`` when ``pass_indices`` is ``True``. + :param minor_base: The minor allele per site. A string representation of the base or the base index according + to ``['A', 'C', 'G', 'T']`` if ``pass_indices`` is ``True``. Use ``None`` if the base is not defined when + ``pass_indices`` is ``False`` and ``-1`` when ``pass_indices`` is ``True``. + :param outgroup_bases: The outgroup alleles per site. A string representation of the base or the base index + if ``pass_indices`` is ``True``. This should be a list of lists, where the outer list corresponds to the + sites and the inner list to the outgroups per site. All sites are required to have the same number of + outgroups. Use ``None`` if the base is not defined when ``pass_indices`` is ``False`` and ``-1`` when + ``pass_indices`` is ``True``. + :param n_ingroups: The number of ingroup samples (see :meth:`__init__`). + :param n_runs: The number of runs for rate estimation (see :meth:`__init__`). + :param model: The substitution model (see :meth:`__init__`). + :param parallelize: Whether to parallelize the runs. + :param prior: The prior to use for the polarization probabilities (see :meth:`__init__`). + :param seed: The seed for the random number generator. + :param pass_indices: Whether to pass the base indices instead of the bases. + :param confidence_threshold: The confidence threshold for the ancestral allele annotation + (see :meth:`__init__`). + :return: The instance. + """""" + # convert to numpy arrays + n_major = np.array(list(n_major), dtype=np.int8) + + # make sure that the number of major alleles is not larger than the number of ingroups + if np.any(n_major > n_ingroups): + raise ValueError(""Major allele counts cannot be larger than the number of ingroups."") + + # convert to base indices + if not pass_indices: + major_base = cls.get_base_index(np.array(list(major_base))) + minor_base = cls.get_base_index(np.array(list(minor_base))) + outgroup_bases = cls.get_base_index(np.array(list(outgroup_bases))).reshape(len(major_base), -1) + + # create data frame + data = pd.DataFrame({ + 'n_major': n_major, + 'major_base': major_base, + 'minor_base': minor_base, + 'outgroup_bases': list(outgroup_bases) + }) + + # create from dataframe + return cls.from_dataframe( + data=data, + n_runs=n_runs, + model=model, + parallelize=parallelize, + prior=prior, + n_ingroups=n_ingroups, + seed=seed, + confidence_threshold=confidence_threshold + ) + + @classmethod + def _from_vcf( + cls, + file: str, + outgroups: List[str], + n_ingroups: int, + ingroups: List[str] = None, + exclude: List[str] = None, + n_runs: int = 10, + model: SubstitutionModel = K2SubstitutionModel(), + parallelize: bool = True, + prior: PolarizationPrior | None = KingmanPolarizationPrior(), + max_sites: int = np.inf, + seed: int | None = 0, + confidence_threshold: float = 0, + subsample_mode: Literal['random', 'probabilistic'] = 'probabilistic' + ) -> 'MaximumLikelihoodAncestralAnnotation': + """""" + Create an instance from a VCF file. In most cases, it is recommended to use the :class:`Annotator` or + :class:`~fastdfe.parser.Parser` classes instead. + + :param file: The VCF file. + :param outgroups: Same as in :meth:`__init__`. + :param n_ingroups: Same as in :meth:`__init__`. + :param ingroups: Same as in :meth:`__init__`. + :param exclude: Same as in :meth:`__init__`. + :param n_runs: Same as in :meth:`__init__`. + :param model: Same as in :meth:`__init__`. + :param parallelize: Same as in :meth:`__init__`. + :param prior: Same as in :meth:`__init__`. + :param max_sites: Same as in :meth:`__init__`. + :param seed: Same as in :meth:`__init__`. + :param confidence_threshold: Same as in :meth:`__init__`. + :param subsample_mode: Same as in :meth:`__init__`. + :return: The instance. + """""" + # create instance + anc = MaximumLikelihoodAncestralAnnotation( + outgroups=outgroups, + n_ingroups=n_ingroups, + ingroups=ingroups, + exclude=exclude, + n_runs=n_runs, + model=model, + parallelize=parallelize, + prior=prior, + max_sites=max_sites, + seed=seed, + confidence_threshold=confidence_threshold, + subsample_mode=subsample_mode + ) + + # set up the handler + super(cls, anc)._setup(MultiHandler( + vcf=file, + max_sites=max_sites, + seed=seed + )) + + # parse the variants + anc._parse_vcf() + + return anc + + @classmethod + def from_dataframe( + cls, + data: pd.DataFrame, + n_ingroups: int, + n_runs: int = 10, + model: SubstitutionModel = None, + parallelize: bool = True, + prior: PolarizationPrior | None = '', + seed: int = 0, + grouped: bool = False, + confidence_threshold: float = 0 + ) -> 'MaximumLikelihoodAncestralAnnotation': + """""" + Create an instance from a dataframe. + + :param data: Dataframe with the columns: ``major_base``, ``minor_base``, ``outgroup_bases``, ``n_major`` of + type ``int``, ``int``, ``list`` and ``int``, respectively. The outgroup bases should have the same length + for every site. + :param n_ingroups: The number of ingroups (see :meth:`__init__`). + :param n_runs: Number of runs for rate estimation (see :meth:`__init__`). + :param model: The substitution model (see :meth:`__init__`). + :param parallelize: Whether to parallelize computations. + :param prior: The prior to use for the polarization probabilities (see :meth:`__init__`). + :param seed: The seed for the random number generator. If ``None``, a random seed is chosen. + :param grouped: Whether the dataframe is already grouped by all columns (used for internal purposes). + :param confidence_threshold: The confidence threshold for the ancestral allele annotation + (see :meth:`__init__`). + :return: The instance. + """""" + # check if dataframe is empty + if data.empty: + raise ValueError(""Empty dataframe."") + + if not grouped: + # only keep the columns that are needed + data = data[cls._group_cols] + + # disable chained assignment warning + with pd.option_context('mode.chained_assignment', None): + # retain site index + data['sites'] = data.index + + # convert outgroup bases to tuples + data['outgroup_bases'] = data['outgroup_bases'].apply(tuple) + + # group by all columns in the chunk and keep track of the site indices + data = data.groupby(cls._group_cols, as_index=False, dropna=False).agg(list).reset_index(drop=True) + + # determine the multiplicity + data['multiplicity'] = data['sites'].apply(lambda x: len(x)) + + # add missing columns with NA as default value + for col in cls._dtypes: + if col not in data.columns: + data[col] = None + + # convert to the correct dtypes + data = data.astype(cls._dtypes) + + # determine the number of outgroups + data['n_outgroups'] = np.sum(np.array(data.outgroup_bases.to_list()) != -1, axis=1) + + # determine the number of outgroups + n_outgroups = data.n_outgroups.max() + + anc = MaximumLikelihoodAncestralAnnotation( + n_runs=n_runs, + model=model, + parallelize=parallelize, + prior=prior, + outgroups=[str(i) for i in range(n_outgroups)], # pseudo names for outgroups + ingroups=[str(i) for i in range(n_ingroups)], # pseudo names for ingroups + n_ingroups=n_ingroups, + seed=seed, + confidence_threshold=confidence_threshold, + subsample_mode='random' + ) + + # assign data frame + anc.configs = data + + # convert outgroup bases to tuples of native integers + anc._convert_outgroup_bases_to_native_types() + + # set the number of sites (which coincides with number of sites parsed) + anc.n_sites = anc._get_n_sites() + + # notify on statistics + anc._log_stats() + + # set up substitution model + anc.model._setup(anc) + + return anc + + def _convert_outgroup_bases_to_native_types(self): + """""" + Convert outgroup bases to tuples of native integers + numpy types cause problems when serializing + """""" + self.configs.outgroup_bases = self.configs.outgroup_bases.apply(lambda x: tuple(int(i) for i in x)) + + def _parse_vcf(self): + """""" + Parse variants from VCF file. + """""" + # initialize data frame + self.configs = pd.DataFrame(columns=list(self._dtypes.keys())) + self.configs.astype(self._dtypes) + + # columns to use as index + index_cols = ['major_base', 'minor_base', 'outgroup_bases', 'n_major'] + + # set index to initial site configuration + self.configs.set_index(keys=index_cols, inplace=True) + + # determine the total number of sites to be parsed + total = min(self._handler.n_sites, self.max_sites) + + # initialize counter in case we do not parse any sites + i = -1 + + # create progress bar + with self._handler.get_pbar(desc=f""{self.__class__.__name__}>Parsing sites"", total=total) as pbar: + + # iterate over sites + for i, variant in enumerate(self._reader): + + # parse the site + try: + configs = self._parse_variant(variant) + + except (_PolyAllelicSiteError, _TooFewIngroupsSiteError): + pass + + else: + + if self.n_target_sites is not None: + # update bounds + low, high = self._contig_bounds[variant.CHROM] + self._contig_bounds[variant.CHROM] = (min(low, variant.POS), max(high, variant.POS)) + + for config in configs: + + index = ( + config.major_base, + config.minor_base, + tuple(config.outgroup_bases), + config.n_major + ) + + if index in self.configs.index: + # get the site data + site_data = self.configs.loc[index].to_dict() + + # update the site data + site_data['multiplicity'] += config.multiplicity + site_data['sites'] += [i] + + # update the site data + # Note that there were problems updating the data frame directly + self.configs.loc[index] = site_data + else: + self.configs.loc[index] = config.__dict__ | {'sites': [i]} + + pbar.update() + + # explicitly stopping after ``n`` sites fixes a bug with cyvcf2: + # 'error parsing variant with `htslib::bcf_read` error-code: 0 and ret: -2' + if i + 1 == self._handler.n_sites or i + 1 == self._handler.max_sites or i + 1 == self.max_sites: + break + + # reset the index + self.configs.reset_index(inplace=True, names=index_cols) + + # create column for number of outgroups + self.configs['n_outgroups'] = None + + if len(self.configs) > 0: + # determine number of outgroups + self.configs['n_outgroups'] = np.sum(np.array(self.configs.outgroup_bases.to_list()) != -1, axis=1) + + # convert outgroup bases to tuples of native integers + self._convert_outgroup_bases_to_native_types() + + # total number of sites considered + self.n_sites = i + 1 + + def infer(self): + """""" + Infer the ancestral allele probabilities for the data provided. This method is only supposed to be called + manually if the data is provided directly, e.g. using :meth:`from_data`, :meth:`from_dataframe` or + :meth:`from_est_sfs`. If the data is provided using a VCF file, this method is called automatically. + """""" + from scipy.optimize import minimize, OptimizeResult + + # get the bounds + bounds = self.model.get_bounds(self.n_outgroups) + + # get the likelihood function + # this will raise an error if no data is available + fun = self._get_likelihood() + + # log warning if unusually low number of monomorphic sites + if self.configs[self.configs.minor_base == -1].multiplicity.sum() / self.n_sites < 0.75: + self._logger.warning(""The number of monomorphic sites is unusually low. Please note that "" + ""including monomorphic sites is necessary to obtain realistic "" + ""branch rate estimates."") + + if self.n_target_sites is None: + self._logger.warning(""If your dataset does not contain any monomorphic sites, consider "" + ""using the `n_target_sites` argument."") + + def optimize_rates(x0: Dict[str, float]) -> OptimizeResult: + """""" + Optimize the likelihood function for a single run. + + :param x0: The initial values. + :return: The optimization results. + """""" + # optimize using scipy + return minimize( + fun=fun, + x0=np.array(list(x0.values())), + bounds=list(bounds.values()), + method=""L-BFGS-B"" + ) + + # run the optimization in parallel + results = parallelize_func( + func=optimize_rates, + data=[self.model.get_x0(bounds, self.rng) for _ in range(self.n_runs)], + parallelize=self.parallelize, + pbar=True, + desc=f""{self.__class__.__name__}>Optimizing rates"", + dtype=object + ) + + # get the likelihoods for each run + self.likelihoods = -np.array([result.fun for result in results]) + + # get the best likelihood + self.likelihood = np.max(self.likelihoods) + + # get the MLE parameters for each run + self.params_mle_runs = pd.DataFrame([result.x for result in results], columns=self.param_names) + + # get the best result + self.result: OptimizeResult = cast(OptimizeResult, results[np.argmax(self.likelihoods)]) + + # check if the optimization was successful + if not self.result.success: + raise RuntimeError(f""Optimization failed with message: {self.result.message}"") + + # get dictionary of MLE parameters + self.params_mle = dict(zip(self.param_names, self.result.x)) + + # check if the MLE parameters are near the bounds + near_lower, near_upper = check_bounds( + params=self.params_mle, + bounds=bounds, + scale='log', + fixed_params=self.model.fixed_params + ) + + # warn if the MLE parameters are near the bounds + if len(near_lower | near_upper) > 0: + self._logger.warning(f'The MLE estimate for the rates is near the upper bound for ' + f'{near_upper} and lower bound for {near_lower}. (The tuples denote ' + f'(lower, value, upper) for every parameter.)') + + # check if the outgroup divergence is monotonically increasing + if not self.is_monotonic(): + self._logger.warning(""The outgroup rates are not monotonically increasing. This might indicate "" + ""that the outgroups were not specified in the order of increasing divergence. "" + f""rates: {dict(zip(self.outgroups, self.get_outgroup_divergence()))}"") + + # cache the branch probabilities for the MLE parameters + self._renew_cache() + + # renew site configuration cache + self._update_configs() + + def _update_configs(self): + """""" + Renew site configuration cache. + """""" + + # obtain the probability for each site and minor allele under the MLE rate parameters + self.configs.p_minor = self.get_p_configs( + configs=self.configs, + model=self.model, + base_type=BaseType.MINOR, + params=self.params_mle + ) + + # obtain the probability for each site and major allele under the MLE rate parameters + self.configs.p_major = self.get_p_configs( + configs=self.configs, + model=self.model, + base_type=BaseType.MAJOR, + params=self.params_mle + ) + + # calculate the ancestral probabilities, i.e. probability of the major allele being ancestral + # opposed to the minor allele + self.configs.p_major_ancestral = self._calculate_p_major_ancestral( + p_minor=self.configs['p_minor'].values, + p_major=self.configs['p_major'].values, + n_major=self.configs['n_major'].values + ) + + def set_mle_params(self, params: Dict[str, float]): + """""" + Set the MLE parameters and update the cache and site configurations. Use this method if you want to + use different parameters for the annotation. + + :param params: The new parameters. + """""" + # set the parameters + self.params_mle = params + + # renew cache + self._renew_cache() + + # renew site configuration cache + self._update_configs() + + def is_monotonic(self) -> bool: + """""" + Whether the outgroups are monotonically increasing in divergence. + + :return: Whether the outgroups are monotonically increasing in divergence. + """""" + # get the outgroup divergence + div = self.get_outgroup_divergence() + + # check if the outgroup divergence is monotonically increasing + return all(div[i] <= div[i + 1] for i in range(len(div) - 1)) + + @cached_property + def p_polarization(self) -> np.ndarray | None: + """""" + Get the polarization probabilities or ``None`` if ``prior`` is ``no``. + """""" + if isinstance(self.prior, PolarizationPrior): + return self.prior._get_prior( + configs=self.configs, + n_ingroups=self.n_ingroups + ) + + @staticmethod + def get_p_tree( + base: int, + n_outgroups: int, + internal_nodes: List[int] | np.ndarray, + outgroup_bases: List[int] | np.ndarray, + params: Dict[str, float], + model: SubstitutionModel + ) -> float: + """""" + Get the probability of a tree. + + :param base: An observed ingroup base index. + :param n_outgroups: The number of outgroups. + :param internal_nodes: The internal nodes of the tree. We have ``n_outgroups - 1`` internal nodes. + :param outgroup_bases: The observed base indices for the outgroups. + :param params: The parameters of the model. + :param model: The model to use. Either 'K2' or 'JC'. + """""" + if n_outgroups < 1: + return 0.0 + + # get the number of branches + n_branches = 2 * n_outgroups - 1 + + # the probability for each branch + p_branches = np.zeros(n_branches, dtype=float) + + # iterate over the branches + for i in range(n_branches): + + # if we are on the first branch + if i == 0: + # combine ingroup base either with only outgroup or with first internal node + b1 = base + b2 = outgroup_bases[0] if n_outgroups == 1 else internal_nodes[0] + + # if we are on intermediate branches + elif i < n_branches - 1: + # every internal node that is not the last one combines either + # with the next internal node or with an outgroup + i_internal = (i - 1) // 2 + + # get internal base + b1 = internal_nodes[i_internal] + + # either connect to outgroup or next internal node + b2 = outgroup_bases[i_internal] if i % 2 == 1 else internal_nodes[i_internal + 1] + else: + # last branch connects to last internal node and last outgroup + b1 = internal_nodes[-1] + b2 = outgroup_bases[-1] + + # get the probability of the branch + p_branches[i] = model._get_cached_prob(b1, b2, i, params) + + # take product of all branch probabilities + prod = p_branches.prod() + + return prod + + @classmethod + def get_p_config( + cls, + config: SiteConfig, + base_type: BaseType, + params: Dict[str, float], + model: SubstitutionModel = K2SubstitutionModel(), + internal: np.ndarray | None = None + ) -> float: + """""" + Get the probability for a site configuration. + + :param config: The site configuration. + :param base_type: The base type. + :param params: The parameters for the substitution model. + :param model: The substitution model to use. + :param internal: Base indices of internal nodes of the tree if fixed. If ``None``, the internal nodes + are considered as free parameters. -1 also indicates a free parameter. The number of internal nodes + is the number of outgroups minus one. + :return: The probability for a site. + """""" + n_outgroups = len(config.outgroup_bases) + + # get the focal base + base = config.major_base if base_type == BaseType.MAJOR else config.minor_base + + # if the focal base is missing we return a probability of 0 + if base == -1: + return 0.0 + + # number of free nodes + n_free = 0 + + # get internal node possibilities + combs_internal = [] + for i in range(n_outgroups - 1): + if internal is not None and internal[i] != -1: + combs_internal.append([internal[i]]) + else: + combs_internal.append([0, 1, 2, 3]) + n_free += 1 + + # get outgroup possibilities + combs_outgroup = [] + for i in range(n_outgroups): + if config.outgroup_bases[i] != -1: + combs_outgroup.append([config.outgroup_bases[i]]) + else: + combs_outgroup.append([0, 1, 2, 3]) + n_free += 1 + + # initialize the probability for each tree + p_trees = np.zeros(4 ** n_free, dtype=float) + + # iterator over all possible internal node combinations + for i, nodes in enumerate(itertools.product(*(combs_internal + combs_outgroup))): + # get the probability of the tree + p_trees[i] = cls.get_p_tree( + base=base, + n_outgroups=n_outgroups, + internal_nodes=np.array(nodes[:n_outgroups - 1]), + outgroup_bases=np.array(nodes[n_outgroups - 1:]), + params=params, + model=model + ) + + return p_trees.sum() + + @classmethod + def get_p_configs( + cls, + configs: pd.DataFrame, + model: SubstitutionModel, + base_type: BaseType, + params: Dict[str, float] + ) -> np.ndarray: + """""" + Get the probabilities for each site configuration. + + :param configs: The site configurations. + :param model: The substitution model. + :param base_type: The base type. + :param params: A dictionary of the rate parameters. + :return: The probability for each site. + """""" + # the probabilities for each site + p_configs = np.zeros(shape=(configs.shape[0]), dtype=float) + + # iterate over the sites + for i, config in enumerate(configs.itertuples()): + # get the log likelihood of the site + p_configs[i] = cls.get_p_config( + config=cast(SiteConfig, config), + base_type=base_type, + params=params, + model=model + ) + + return p_configs + + def evaluate_likelihood(self, params: Dict[str, float]) -> float: + """""" + Evaluate the likelihood function for the rate parameters. + + :param params: A dictionary of parameters. + :return: The log likelihood. + """""" + # cache the branch probabilities + self._renew_cache(params) + + # compute the likelihood + ll = -self._get_likelihood()([params[name] for name in self.param_names]) + + # restore cached branch probabilities if necessary + if self.params_mle is not None: + self._renew_cache() + + return ll + + def _renew_cache(self, params: Dict[str, float] = None): + """""" + Renew the cache of branch probabilities. + + :param params: The model parameters to use for caching. If ``None``, the MLE parameters are used. + """""" + # cache the branch probabilities + self.model.cache(params if params is not None else self.params_mle, 2 * self.n_outgroups - 1) + + def _get_mle_configs(self) -> pd.DataFrame: + """""" + Get the site configurations used for the MLE with only included sites with + the correct number of outgroups. + """""" + # only consider sites with the full number of outgroups + return self.configs[self.configs.n_outgroups == self.n_outgroups] + + def _get_likelihood(self) -> Callable[[List[float]], float]: + """""" + Get the likelihood function for the rate parameters. + + :return: The likelihood function. + """""" + if self.configs is None: + raise RuntimeError(""No sites available. Note that you can't call infer() yourself "" + ""when using this class with Parser or Annotator."") + + # only consider sites with the correct number of outgroups + configs = self._get_mle_configs() + + # Set the minor base to -1 if the major allele is fixed. + # We don't want to consider minor allele not present in the subsample + # when optimizing the branch rates. + configs.loc[configs.n_major == self.n_ingroups, 'minor_base'] = -1 + + # make variables available in the inner function + model = self.model + param_names = self.param_names + n_outgroups = self.n_outgroups + + def compute_likelihood(params: List[float]) -> float: + """""" + Compute the negative log likelihood of the parameters. + + :param params: A list of rate parameters. + :return: The negative log likelihood. + """""" + # unpack the parameters + params = dict(zip(param_names, params)) + + # cache the branch probabilities + model.cache(params, 2 * n_outgroups - 1) + + # the likelihood for each site + p_sites = np.zeros(shape=(configs.shape[0], 2), dtype=float) + + # get the probability for each site and major allele + p_sites[:, 0] = MaximumLikelihoodAncestralAnnotation.get_p_configs( + configs=configs, + model=model, + base_type=BaseType.MAJOR, + params=params + ) + + # get the probability for each site and minor allele + p_sites[:, 1] = MaximumLikelihoodAncestralAnnotation.get_p_configs( + configs=configs, + model=model, + base_type=BaseType.MINOR, + params=params + ) + + # Return the negative log likelihood and take average over major and minor bases + # Also multiply by the multiplicity of each site. + # The final likelihood is the product of the likelihoods for each site. + return -(np.log(p_sites.mean(axis=1)) * configs.multiplicity.values).sum() + + return compute_likelihood + + def _get_site_indices(self) -> np.ndarray: + """""" + Get the list of config indices for each site. + + :return: The list of config indices, use -1 for sites that are not included. + """""" + indices = np.full(self.n_sites, -1, dtype=int) + + for i, config in self.configs.iterrows(): + for j in config.sites: + indices[j] = i + + return indices + + def _get_ancestral_from_prob( + self, + p_major_ancestral: np.ndarray | float, + major_base: np.ndarray | str, + minor_base: np.ndarray | str + ) -> np.ndarray | float: + """""" + Get the ancestral allele from the probability of the major allele being ancestral. + + :param p_major_ancestral: The probabilities of the major allele being ancestral. + :param major_base: The major bases. + :param minor_base: The minor bases. + :return: Array of ancestral alleles. + """""" + # make function accept scalars + if isinstance(p_major_ancestral, float): + return self._get_ancestral_from_prob( + np.array([p_major_ancestral]), + np.array([major_base]), + np.array([minor_base]) + )[0] + + # initialize array + ancestral_bases = np.full(p_major_ancestral.shape, -1, dtype=np.int8) + + ancestral_bases[p_major_ancestral >= 0.5] = major_base[p_major_ancestral >= 0.5] + ancestral_bases[p_major_ancestral < 0.5] = minor_base[p_major_ancestral < 0.5] + + return ancestral_bases + + def _get_internal_prob( + self, + site: SiteConfig, + internal: np.ndarray | None = None + ) -> float: + """""" + Get the ancestral allele for each site. + + :param site: The site configuration. + :param internal: Base indices of internal nodes of the tree if fixed. If ``None``, the internal nodes + are considered as free parameters. -1 also indicates a free parameter. + :return: The ancestral allele, probability for the major being ancestral, the first base being + ancestral, the second base being ancestral. + """""" + # get the probability for the major allele + p_minor = self.get_p_config( + config=site, + base_type=BaseType.MINOR, + params=self.params_mle, + model=self.model, + internal=internal + ) + + # get the probability for the minor allele + p_major = self.get_p_config( + config=site, + base_type=BaseType.MAJOR, + params=self.params_mle, + model=self.model, + internal=internal + ) + + return p_minor + p_major + + def _get_internal_probs( + self, + site: SiteConfig, + i_internal: int, + ) -> np.ndarray: + """""" + Get the internal probabilities for the sites used to estimate the parameters. + + :param site: The site configuration. + :param i_internal: The index of the internal node. + :return: The probabilities for each base and site. + """""" + # number of outgroups considered + n_outgroups = len(site.outgroup_bases) + + # no internal nodes if there are fewer than two outgroups + if n_outgroups < 2: + return np.full(4, self._get_internal_prob(site)) + + # initialize internal nodes + internal = np.full(len(site.outgroup_bases), fill_value=-1, dtype=int) + + # initialize probabilities + probs = np.zeros(shape=4, dtype=float) + + # get the internal node probabilities + for j in range(4): + internal[i_internal] = j + probs[j] = self._get_internal_prob(site, internal=internal) + + return probs + + def get_inferred_site_info(self) -> Generator[SiteInfo, None, None]: + """""" + Get the site information for the sites included in the parsing process. The sites are in the same order as + parsed. You can use :meth:`get_site_info` to get the site information for a specific site. + + :return: A generator yielding a dictionary with the site information (see :meth:`get_site_info`). + :raises RuntimeError: If the subsample mode is ``probabilistic``. + """""" + # check if data is provided using a VCF file + if self.subsample_mode == 'probabilistic': + raise RuntimeError(""get_inferred_site_info() not implemented with probabilistic subsampling."") + + # get config indices for each site + indices = self._get_site_indices() + + # remove sites that are not included + indices = indices[indices != -1] + + # get the sites + sites = self.configs.iloc[indices] + + # iterate over the sites + for site in sites.itertuples(): + yield self.get_site_info( + n_major=site.n_major, + major_base=site.major_base, + minor_base=site.minor_base, + outgroup_bases=site.outgroup_bases, + pass_indices=True + ) + + def _get_site_info(self, configs: List[SiteConfig]) -> SiteInfo: + """""" + Get information on the specified sites using the inferred parameters. + + :param configs: The site configurations with differing numbers of major alleles with their multiplicities + summing up to 1. + :return: The site information. + """""" + if self.params_mle is None: + raise RuntimeError(""No maximum likelihood parameters available."") + + # use most likely configuration as reference + i_max = np.argmax([c.multiplicity for c in configs]) + ref = configs[i_max] + + # get the probability for the minor allele + p_minor = self.get_p_config( + config=ref, # use first config as representative + base_type=BaseType.MINOR, + params=self.params_mle, + model=self.model + ) + + # get the probability for the major allele + p_major = self.get_p_config( + config=ref, # use first config as representative + base_type=BaseType.MAJOR, + params=self.params_mle, + model=self.model + ) + + # get the probability that the major allele is ancestral rather than the minor allele + p_major_ancestral_probs = self._calculate_p_major_ancestral( + p_minor=np.array([p_minor if c.minor_base == ref.minor_base else p_major for c in configs]), + p_major=np.array([p_major if c.major_base == ref.major_base else p_minor for c in configs]), + n_major=np.array([c.n_major for c in configs]) + ) + + # configs for which the minor allele turned out to be the major allele in the subsample + alt_config = np.array([c.minor_base != ref.minor_base for c in configs]) + + p_major_ancestral_probs[alt_config] = 1 - p_major_ancestral_probs[alt_config] + + # take the weighted average + weights = np.array([c.multiplicity for c in configs]) + p_major_ancestral = (p_major_ancestral_probs * weights).sum() + + # get the ancestral alleles using p_major_ancestral + major_ancestral = self.get_base_string(self._get_ancestral_from_prob( + p_major_ancestral=p_major_ancestral, + major_base=ref.major_base, + minor_base=ref.minor_base + )) + + # ancestral base probabilities for the first node + p_bases_first_node = self._get_internal_probs(site=ref, i_internal=0) + + # get the base probabilities for the first node + total = p_bases_first_node.sum() + i_max = np.argmax(p_bases_first_node) + p_first_node_ancestral = p_bases_first_node[i_max] / total if total > 0 else 0 + first_node_ancestral = self.get_base_string(i_max) + + return SiteInfo( + n_major={config.n_major: config.multiplicity for config in configs}, + major_base=self.get_base_string(ref.major_base), + minor_base=self.get_base_string(ref.minor_base), + outgroup_bases=list(self.get_base_string(np.array(ref.outgroup_bases))), + p_minor=p_minor, + p_major=p_major, + p_major_ancestral=p_major_ancestral, + major_ancestral=major_ancestral, + p_bases_first_node=dict(zip(bases, p_bases_first_node)), + p_first_node_ancestral=p_first_node_ancestral, + first_node_ancestral=first_node_ancestral, + rate_params=self.params_mle + ) + + def get_site_info( + self, + n_major: int, + major_base: int | str, + minor_base: int | str, + outgroup_bases: List[int | str] | np.ndarray, + pass_indices: bool = False + ) -> SiteInfo: + """""" + Get information on the specified sites using the inferred parameters. + + :param n_major: The number of copies of the major allele. + :param major_base: The major bases indices or strings. + :param minor_base: The minor bases indices or strings. + :param outgroup_bases: The outgroup base indices or strings. + :param pass_indices: Whether to pass the indices as strings or convert them to integers. + :return: The site information. + """""" + if not pass_indices: + major_base = self.get_base_index(major_base) + minor_base = self.get_base_index(minor_base) + outgroup_bases = self.get_base_index(np.array(outgroup_bases)) + + # initialize site configuration + config = SiteConfig( + n_major=n_major, + major_base=major_base, + minor_base=minor_base, + outgroup_bases=outgroup_bases + ) + + return self._get_site_info([config]) + + def _calculate_p_major_ancestral( + self, + p_minor: float | np.ndarray, + p_major: float | np.ndarray, + n_major: int | np.ndarray + ) -> float | np.ndarray: + """""" + Calculate the probability that the ancestral allele is the major allele. + + :param p_minor: The probability or probabilities of the minor allele. + :param p_major: The probability or probabilities of the major allele. + :param n_major: The number or numbers of major alleles. + :return: The probability or probabilities that the ancestral allele is the major allele. + """""" + # return empty array if p_minor is empty + if isinstance(p_minor, np.ndarray) and len(p_minor) == 0: + return np.array([]) + + try: + if self.prior is not None: + # polarization prior for the major allele + pi = self.p_polarization[self.n_ingroups - n_major] + + # get the probability that the major allele is ancestral + return pi * p_major / (pi * p_major + (1 - pi) * p_minor) + + # get the probability that the major allele is ancestral + return p_major / (p_major + p_minor) + + # only occurs when we deal with scalars + except ZeroDivisionError: + return np.nan + + @staticmethod + def _is_confident(threshold: float, p: float) -> bool: + """""" + Whether we are confident enough about the ancestral allele state. + + :param threshold: Confidence threshold. + :param p: Probability of the major allele being ancestral as opposed to the minor allele. + :return: Whether we are confident enough. + """""" + return not (1 - threshold) / 2 < p < 1 - (1 - threshold) / 2 + + def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Annotate a single site. + + :param variant: The variant to annotate. + :return: The annotated variant. + """""" + # set default values + ancestral_base = '.' + ancestral_prob = '.' + + # use maximum parsimony if we don't have an SNP + if isinstance(variant, DummyVariant) or not variant.is_snp: + ancestral_base = MaximumParsimonyAncestralAnnotation._get_ancestral(variant, self._ingroup_mask) + ancestral_info = 'monomorphic' + + # increase the number of annotated sites + self.n_annotated += 1 + + else: + + try: + configs = self._parse_variant(variant) + + except _PolyAllelicSiteError: + ancestral_info = 'polyallelic' + + except _TooFewIngroupsSiteError: + ancestral_info = 'too few ingroups' + + else: + site = self._get_site_info(configs) + + # only proceed if the ancestral allele is known + if site.major_ancestral in bases: + + # get site information dictionary + site_dict = site.__dict__ + + # update info + ancestral_info = str(site_dict) + + # only proceed with annotation if the confidence is high enough + if self._is_confident(self.confidence_threshold, site.p_major_ancestral): + + # we take most likely configuration as reference + ref = configs[np.argmax([c.multiplicity for c in configs])] + + # obtain ad hoc annotation for sanity checking + site_info_ad_hoc = AdHocAncestralAnnotation._get_site_info(ref) + + # log warning if ad hoc and maximum likelihood annotation disagree + if site_info_ad_hoc['ancestral_base'] != site.major_ancestral: + self._logger.debug( + ""Mismatch with ad hoc ancestral allele annotation: "" + + str(dict( + site=f""{variant.CHROM}:{variant.POS}"", + ancestral_base_ad_hoc=site_info_ad_hoc['ancestral_base'], + ) | site_dict) + ) + + # append site to mismatches + self.mismatches.append(site) + + # update ancestral base + ancestral_base = site.major_ancestral + + # update ancestral probability + if site.major_base == site.major_ancestral: + ancestral_prob = site.p_major_ancestral + else: + ancestral_prob = 1 - site.p_major_ancestral + + # increase the number of annotated sites + self.n_annotated += 1 + + else: + ancestral_info = 'below confidence threshold' + + else: + ancestral_info = 'invalid or unknown ancestral allele' + + # set the ancestral allele + variant.INFO[self._handler.info_ancestral] = ancestral_base + + # set the ancestral allele probability + variant.INFO[self._handler.info_ancestral + '_prob'] = ancestral_prob + + # set info field + variant.INFO[self._handler.info_ancestral + ""_info""] = ancestral_info + + def plot_likelihoods( + self, + file: str = None, + show: bool = True, + title: str = 'rate likelihoods', + scale: Literal['lin', 'log'] = 'lin', + ax: 'plt.Axes' = None, + ylabel: str = 'lnl' + ) -> 'plt.Axes': + """""" + Visualize the likelihoods of the rate optimization runs using a scatter plot. + + :param scale: y-scale of the plot. + :param title: Plot title. + :param file: File to save plot to. + :param show: Whether to show plot. + :param ax: Axes to plot on. Only for Python visualization backend. + :param ylabel: Label for y-axis. + :return: Axes object + """""" + from .visualization import Visualization + + return Visualization.plot_scatter( + values=self.likelihoods, + file=file, + show=show, + title=title, + scale=scale, + ax=ax, + ylabel=ylabel, + ) + + def get_folded_spectra( + self, + groups: List[Literal['major_base', 'minor_base', 'outgroup_bases']] = ['major_base'], + ) -> Spectra: + """""" + Get the folded spectra for the parsed sites (used to estimate the parameters). + + :param groups: The groups to group the spectra by. + :return: Spectra object + """""" + configs = self._get_mle_configs() + + # group by n_major and groups + grouped = configs.groupby(['n_major'] + groups).sum() + + if len(groups) == 0: + index = np.arange(self.n_ingroups + 1) + else: + # new index to include all possible values for n_major + index = pd.MultiIndex.from_product( + [np.arange(self.n_ingroups + 1).tolist()] + grouped.index.levels[1:], + names=['n_major'] + groups + ) + + # reindex + grouped = grouped.reindex(index, fill_value=0) + + # if we only group by n_major + if len(groups) == 0: + return Spectra.from_dict(dict(all=grouped.multiplicity[::-1].tolist())) + + # iterate over groups + spectra = {} + for i, group in grouped.groupby(level=groups): + + if not isinstance(i, tuple): + name = f""{groups[0]}={self.get_base_string(i)}"" + else: + name = "", "".join([f""{a}={self.get_base_string(b)}"" for a, b in zip(groups, i)]) + spectra[name] = group.multiplicity[::-1].tolist() + + return Spectra.from_dict(spectra) + + @staticmethod + def _get_branch(params: Dict[str, float], i: int) -> float: + """""" + Get the branch rate for the given index. + + :param params: The parameters. + :param i: The index. + :return: The branch rate. + """""" + return params['K'] if 'K' in params else params[f'K{i}'] + + def get_outgroup_divergence(self) -> np.ndarray: + """""" + Get the inferred branch rates between the ingroup and outgroups by combining the inferred branch rates. + + :return: One rate for each outgroup. + """""" + if self.params_mle is None: + raise RuntimeError(""No maximum likelihood parameters available."") + + # initialize array + rates = np.zeros(self.n_outgroups, dtype=float) + + for i in range(self.n_outgroups): + # if it's not the last outgroup + if i < self.n_outgroups - 1: + ingroup = [self._get_branch(self.params_mle, 2 * j) for j in range(i + 1)] + outgroup = self._get_branch(self.params_mle, 2 * i + 1) + else: + ingroup = [self._get_branch(self.params_mle, 2 * j) for j in range(i)] + outgroup = self._get_branch(self.params_mle, 2 * i) + + rates[i] = np.sum(ingroup + [outgroup]) + + return rates + + def get_observed_transition_transversion_ratio(self) -> float: + """""" + Get the observed transition/transversion ratio. Note that this may differ from the estimated ratio for + :class:`K2SubstitutionModel`. + + :return: The observed transition/transversion ratio. + """""" + configs = self._get_mle_configs() + + if len(configs) == 0: + raise RuntimeError(""No sites available to calculate the transition/transversion ratio."") + + tuples = configs[[""minor_base"", ""major_base""]].apply(tuple, axis=1) + + transitions = tuples.isin([tuple(e) for e in SubstitutionModel._transitions]) + transversions = tuples.isin([tuple(e) for e in SubstitutionModel._transversions]) + + n_transitions = configs[transitions].multiplicity.sum() + n_transversions = configs[transversions].multiplicity.sum() + + return n_transitions / n_transversions + + +class AdHocAncestralAnnotation(_OutgroupAncestralAlleleAnnotation): + """""" + Ad-hoc ancestral allele annotation using simple rules. Used for testing and sanity checking. + """""" + + @staticmethod + def _get_site_info(config: SiteConfig) -> dict: + """""" + Get site information from the site configuration. + + :param config: The site configuration. + :return: Dictionary of with the key 'ancestral_base', denoting the ancestral base string. + """""" + # get ingroup and outgroup bases + # noinspection PyTypeChecker + bases_combined = np.concatenate(([config.major_base], [config.minor_base], config.outgroup_bases)) + + # get scores for each base + # noinspection PyTypeChecker + scores = np.concatenate(([1.2], [1], [1 for _ in range(1, len(config.outgroup_bases) + 1)])) + + # get valid bases + is_valid = bases_combined != -1 + + # remove missing bases + valid_bases = bases_combined[is_valid] + + # get valid scores + valid_scores = scores[is_valid] + + # return missing if no valid bases + if len(valid_bases) == 0: + return dict( + ancestral_base='.' + ) + + # get sum for each base + score = np.array([np.sum(valid_scores[valid_bases == i]) for i in range(4)]) + + # take most common base as ancestral + ancestral_base = bases[score.argmax()] + + return dict( + ancestral_base=ancestral_base + ) + + def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Annotate a single site. Mono-allelic sites are assigned the major allele as ancestral. Sites with + more than two alleles are ignored. + + :param variant: The variant to annotate. + :return: The annotated variant. + """""" + ancestral_base = '.' + + # use maximum parsimony if we have a mono-allelic site + if isinstance(variant, DummyVariant) or not variant.is_snp: + ancestral_base = MaximumParsimonyAncestralAnnotation._get_ancestral(variant, self._ingroup_mask) + ancestral_info = 'monomorphic' + self.n_annotated += 1 + else: + + try: + # parse the site + configs = self._parse_variant(variant) + + except _PolyAllelicSiteError: + ancestral_info = 'polyallelic' + + except _TooFewIngroupsSiteError: + ancestral_info = 'too few ingroups' + + else: + + # use config with the highest multiplicity + ref = configs[np.argmax([c.multiplicity for c in configs])] + + # get site information dictionary + site = self._get_site_info(ref) + + # only proceed if the ancestral allele is known + if site['ancestral_base'] in bases: + ancestral_base = site['ancestral_base'] + ancestral_info = str(site) + self.n_annotated += 1 + else: + ancestral_info = 'invalid or unknown ancestral allele' + + # set the ancestral allele + variant.INFO[self._handler.info_ancestral] = ancestral_base + + # set info field + variant.INFO[self._handler.info_ancestral + ""_info""] = ancestral_info + + +class _ESTSFSAncestralAnnotation(AncestralAlleleAnnotation): # pragma: no cover + """""" + A wrapper around EST-SFS. Used for testing. + """""" + + def __init__( + self, + anc: MaximumLikelihoodAncestralAnnotation + ): + """""" + Create a new ESTSFSAncestralAnnotation instance. + + :param anc: + """""" + super().__init__() + + #: The ancestral annotation. + self.anc = anc + + #: The likelihoods for each run. + self.likelihoods: np.ndarray | None = None + + #: The minimum likelihood. + self.likelihood: float | None = None + + #: The MLE parameters. + self.params_mle: Dict[str, float] | None = None + + #: The probabilities for each site. + self.probs: pd.DataFrame | None = None + + def create_seed_file(self, seed_file: str): + """""" + Create the seed file. + + :param seed_file: Path to the seed file. + """""" + with open(seed_file, 'w') as f: + f.write(str(self.anc.seed)) + + def create_config_file(self, config_file: str): + """""" + Create the config file. + + :param config_file: Path to the config file. + """""" + models = dict( + JCSubstitutionModel=0, + K2SubstitutionModel=1 + ) + + with open(config_file, 'w') as f: + f.write(f""n_outgroup {self.anc.n_outgroups}\n"") + f.write(f""model {models[self.anc.model.__class__.__name__]}\n"") + f.write(f""nrandom {self.anc.n_runs}\n"") + + def infer( + self, + binary: str = 'EST_SFS', + wd: str = None, + execute: Callable = None, + ): + """""" + Infer the ancestral allele using EST-SFS. + + :param binary: The path to the EST-SFS binary. + :param wd: The working directory. + :param execute: The function to execute the bash command. + """""" + # define default function for executing command + if execute is None: + def shell(command: str): + """""" + Execute shell command. + + :param command: Command string + """""" + return subprocess.run(command, check=True, cwd=wd, shell=True) + + execute = shell + + with tempfile.NamedTemporaryFile('w') as sites_file, \ + tempfile.NamedTemporaryFile('w') as seed_file, \ + tempfile.NamedTemporaryFile('w') as config_file, \ + tempfile.NamedTemporaryFile('w') as out_sfs, \ + tempfile.NamedTemporaryFile('w') as out_p: + # create the sites file + self.anc.to_est_sfs(sites_file.name) + + # create the seed file + self.create_seed_file(seed_file.name) + + # create the config file + self.create_config_file(config_file.name) + + # construct command string + command = (f""{binary} "" + f""{config_file.name} "" + f""{sites_file.name} "" + f""{seed_file.name} "" + f""{out_sfs.name} "" + f""{out_p.name} "") + + # log command signature + self._logger.info(f""Running: '{command}'"") + + # execute command + execute(command) + + self.parse_est_sfs_output(out_p.name) + + def parse_est_sfs_output(self, file: str): + """""" + Parse the output of the EST-SFS program containing the site probabilities. + + :param file: The file name. + :return: The data frame. + """""" + # filter out lines starting with 0 + filtered_lines = [] + with open(file, 'r') as f: + for i, line in enumerate(f): + + # strip line + line = line.strip() + + if line.startswith('0'): + if i == 4: + # parse likelihoods + self.likelihoods = np.array(line.split()[2:], dtype=float) + self.likelihood = np.min(self.likelihoods) + + if i == 5: + # parse MLE parameters + data = np.array(line.split()[2:]) + self.params_mle = dict(zip([d.upper() for d in data[::2]], data[1::2].astype(float))) + + if i == 6 and isinstance(self.anc.model, K2SubstitutionModel): + # parse kappa + self.params_mle['k'] = float(line.split()[2]) + else: + filtered_lines.append(line.strip()) + + # read into dataframe + self.probs = pd.read_csv(StringIO('\n'.join(filtered_lines)), sep="" "", header=None) + + # drop the first column + self.probs.drop(self.probs.columns[0], axis=1, inplace=True) + + # rename columns + self.probs.rename(columns={1: 'config', 2: 'prob'}, inplace=True) + + def annotate_site(self, variant: Union['cyvcf2.Variant', DummyVariant]): + """""" + Not implemented. + + :param variant: The variant to annotate. + :raises: NotImplementedError + """""" + raise NotImplementedError + + def to_file(self, file: str): + """""" + Save object to file (without reference to AncestralAlleleAnnotation object). + + :param file: File path. + """""" + self.anc = None + + with open(file, 'w') as fh: + fh.write(self.to_json()) + + def to_json(self) -> str: + """""" + Serialize object. + + :return: JSON string + """""" + return jsonpickle.encode(self, indent=4, warn=True) + + @classmethod + def from_json(cls, json: str, classes=None) -> 'Self': + """""" + Unserialize object. + + :param classes: Classes to be used for unserialization + :param json: JSON string + """""" + return jsonpickle.decode(json, classes=classes) + + @classmethod + def from_file(cls, file: str, classes=None) -> 'Self': + """""" + Load object from file. + + :param classes: Classes to be used for unserialization + :param file: File to load from + """""" + with open(file, 'r') as fh: + return cls.from_json(fh.read(), classes) + + +class Annotator(MultiHandler): + """""" + Annotate a VCF file with the given annotations. + + Example usage: + + :: + + import fastdfe as fd + + ann = fd.Annotator( + vcf=""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/"" + ""1000_genomes_project/release/20181203_biallelic_SNV/"" + ""ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz"", + fasta=""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/"" + ""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz"", + gff=""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/"" + ""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz"", + output='sapiens.chr21.degeneracy.vcf.gz', + annotations=[fd.DegeneracyAnnotation()], + aliases=dict(chr21=['21']) + ) + + ann.annotate() + + """""" + + def __init__( + self, + vcf: str, + output: str, + annotations: List[Annotation], + gff: str | None = None, + fasta: str | None = None, + info_ancestral: str = 'AA', + max_sites: int = np.inf, + seed: int | None = 0, + cache: bool = True, + aliases: Dict[str, List[str]] = {}, + ): + """""" + Create a new annotator instance. + + :param vcf: The path to the VCF file, can be gzipped, urls are also supported + :param output: The path to the output file + :param annotations: The annotations to apply. + :param gff: The path to the GFF file, can be gzipped, urls are also supported. Required for + annotations that require a GFF file. + :param fasta: The path to the FASTA file, can be gzipped, urls are also supported. Required for + annotations that require a FASTA file. + :param info_ancestral: The tag in the INFO field that contains the ancestral allele + :param max_sites: Maximum number of sites to consider + :param seed: Seed for the random number generator. Use ``None`` for no seed. + :param cache: Whether to cache files downloaded from urls + :param aliases: Dictionary of aliases for the contigs in the VCF file, e.g. ``{'chr1': ['1']}``. + This is used to match the contig names in the VCF file with the contig names in the FASTA file and GFF file. + + """""" + super().__init__( + vcf=vcf, + gff=gff, + fasta=fasta, + info_ancestral=info_ancestral, + max_sites=max_sites, + seed=seed, + cache=cache, + aliases=aliases + ) + + #: The path to the output file. + self.output: str = output + + #: The annotations to apply. + self.annotations: List[Annotation] = annotations + + #: The VCF writer. + self._writer: 'cyvcf2.Writer' | None = None + + def _setup(self): + """""" + Set up the annotator. + """""" + try: + from cyvcf2 import Writer + except ImportError: + raise ImportError( + ""VCF support in fastdfe requires the optional 'cyvcf2' package. "" + ""Please install fastdfe with the 'vcf' extra: pip install fastdfe[vcf]"" + ) + + for annotation in self.annotations: + annotation._setup(self) + + # create the writer + self._writer = Writer(self.output, self._reader) + + def _teardown(self): + """""" + Tear down the annotator. + """""" + for annotation in self.annotations: + annotation._teardown() + + # close the writer and reader + self._writer.close() + self._reader.close() + + def annotate(self): + """""" + Annotate the VCF file. + """""" + self._logger.info('Start annotating') + + # set up the annotator + self._setup() + + # get progress bar + with self.get_pbar(desc=f""{self.__class__.__name__}>Processing sites"") as pbar: + + # iterate over the sites + for i, variant in enumerate(self._reader): + + # apply annotations + for annotation in self.annotations: + annotation.annotate_site(variant) + + # write the variant + self._writer.write_record(variant) + + # update the progress bar + pbar.update() + + # explicitly stopping after ``n`` sites fixes a bug with cyvcf2: + # 'error parsing variant with `htslib::bcf_read` error-code: 0 and ret: -2' + if i + 1 == self.n_sites or i + 1 == self.max_sites: + break + + # tear down the annotator + self._teardown() +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/simulation.py",".py","18044","506",""""""" +Simulate an SFS given a DFE. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2024-09-06"" + +import logging +from typing import Tuple, Literal, Sequence, Callable + +import numpy as np +from scipy.stats import hypergeom +from tqdm import tqdm + +from .base_inference import BaseInference +from .discretization import Discretization +from .parametrization import Parametrization, DFE +from .parametrization import _from_string +from .spectrum import Spectrum, Spectra + +logger = logging.getLogger('fastdfe') + + +class Simulation: + """""" + Simulate an SFS under selection given a DFE and a neutral SFS. + + Example usage: + + :: + + import fastdfe as fd + + # create simulation object by specifying neutral SFS and DFE + sim = fd.Simulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4), + params=dict(S_d=-300, b=0.3, p_b=0.1, S_b=0.1), + model=fd.GammaExpParametrization() + ) + + # perform the simulation + sim.run() + + # plot spectra + sim.get_spectra().plot() + + """""" + + def __init__( + self, + sfs_neut: Spectrum, + params: dict = None, + model: Parametrization | str = 'GammaExpParametrization', + intervals_del: Tuple[float, float, int] = (-1.0e+8, -1.0e-5, 1000), + intervals_ben: Tuple[float, float, int] = (1.0e-5, 1.0e4, 1000), + h_callback: Callable[[np.ndarray], np.ndarray] = None, + integration_mode: Literal['midpoint', 'quad'] = 'midpoint', + linearized: bool = True, + discretization: Discretization = None, + parallelize: bool = True + ): + """""" + Create a simulation object. + + :param sfs_neut: Neutral SFS. This sfs is informative on the population sample size, population mutation rate, + the number of sites, and demography. :func:`get_neutral_sfs` can be used to obtain a neutral SFS. + :param params: Parameters of the DFE parametrization (see model) in addition to ancestral misidentification + params ``eps`` and dominance ``h``. By default, `eps=0`, `h=0.5`, the default parameters of ``model`` + will be used. + :param model: DFE parametrization model + :param intervals_del: ``(start, stop, n_interval)`` for deleterious population-scaled + selection coefficients. The intervals will be log10-spaced. Decreasing the number of intervals to ``100`` + provides nearly identical results while increasing speed, especially when precomputing across dominance + coefficients. + :param intervals_ben: Same as ``intervals_del`` but for positive selection coefficients. Decreasing the number + of intervals to ``100`` provides nearly identical results while increasing speed, especially when + precomputing across dominance coefficients. + :param h_callback: A function mapping the scalar parameter ``h`` and the array of selection + coefficients ``S`` to dominance coefficients of the same shape, allowing models where ``h`` + depends on ``S``. The default is ``lambda h, S: np.full_like(S, h)``, keeping ``h`` constant. + Expected allele counts for a given dominance value are obtained by linear interpolation + between precomputed values in ``intervals_h``. The inferred parameter is still named ``h``, + even if transformed by ``h_callback``, and its bounds, scales, and initial values can be set + via ``bounds``, ``scales``, and ``x0``. The fitness of heterozygotes and mutation homozygotes is defined as + ``1 + 2hs`` and ``1 + 2s``, respectively. + :param integration_mode: Integration mode when computing expected SFS under semidominance. + ``quad`` is not recommended. + :param linearized: Whether to discretize and cache the linearized integral mapping DFE to SFS or use + ``scipy.integrate.quad`` in each call. ``False`` not recommended. + :param parallelize: Whether to parallelize computations + """""" + #: The DFE parametrization + self.model: Parametrization = _from_string(model) + + #: Parameters for the DFE parametrization + self.params: dict = self.model.x0 if params is None else params + + if 'eps' not in self.params: + self.params['eps'] = 0 + + if 'h' not in self.params: + self.params['h'] = 0.5 + + # check if parameters are within bounds + self._check_bounds() + + #: Neutral SFS + self.sfs_neut: Spectrum = sfs_neut + + #: Modelled SFS + self.sfs_sel: Spectrum = None + + #: DFE instance + self.dfe: DFE = DFE(model=self.model, params=self.params) + + #: SFS sample size + self.n: int = self.sfs_neut.n + + #: Population mutation rate + self.theta: float = self.sfs_neut.theta + + #: Number of sites + self.n_sites: float = self.sfs_neut.n_sites + + if discretization is None: + # create discretization instance + #: Discretization instance + self.discretization: Discretization = Discretization( + n=self.n, + h=self.params['h'], + intervals_del=intervals_del, + intervals_ben=intervals_ben, + h_callback=h_callback, + integration_mode=integration_mode, + linearized=linearized, + parallelize=parallelize + ) + + else: + # otherwise assign instance + self.discretization: Discretization = discretization + + #: Logger + self._logger = logger.getChild('Simulation') + + def run(self) -> Spectrum: + """""" + Simulate an SFS given a DFE. + + :return: Simulated SFS + """""" + self._logger.info(""Simulating SFS under selection using parameters: "" + ', '.join( + [f""{k}={v:.4g}"" for k, v in self.params.items()] + )) + + # obtain modelled selected SFS + counts_modelled = self.discretization.model_selection_sfs(self.model, self.params) + + # adjust for mutation rate and mutational target size + counts_modelled *= self.theta * self.n_sites + + # add contribution of demography and adjust polarization error + counts_modelled = BaseInference._add_demography(self.sfs_neut, counts_modelled, eps=self.params['eps']) + + self.sfs_sel = Spectrum([self.n_sites - sum(counts_modelled)] + list(counts_modelled) + [0]) + + return self.sfs_sel + + def _check_bounds(self): + """""" + Check if the specified parameters are within the bounds of the DFE parametrization. + """""" + for k, v in self.params.items(): + if k in self.model.bounds and not self.model.bounds[k][0] <= v <= self.model.bounds[k][1]: + raise ValueError( + f""Parameter {k}={v} is out of bounds {self.model.bounds[k]} "" + f""for model {self.model.__class__.__name__}."" + ) + + if not 0 <= self.params['eps'] <= 1: + raise ValueError(f""Ancestral misidentification parameter eps={self.params['eps']} is out of bounds [0, 1]."") + + if not 0 <= self.params['h'] <= 1: + raise ValueError(f""Dominance parameter h={self.params['h']} is out of bounds [0, 1]."") + + def get_spectra(self) -> Spectra: + """""" + Get the spectra used in the simulation. + + :return: Tuple of neutral SFS and selected SFS + """""" + return Spectra.from_spectra({ + ""neutral"": self.sfs_neut, + ""selected"": self.sfs_sel + }) + + def get_alpha(self) -> float: + """""" + Get the proportion of adaptive substitutions (alpha) under the specified DFE and parameters. + + :return: Proportion of adaptive substitutions + """""" + return self.discretization.get_alpha(self.model, self.params) + + @staticmethod + def get_neutral_sfs( + theta: float, + n_sites: float, + n: int, + r: Sequence[float] = None + ) -> Spectrum: + """""" + Obtain a standard neutral SFS for a given theta and number of sites. + + :param theta: Population mutation rate + :param n_sites: Number of total sites + :param n: Number of frequency classes + :param r: Nuisance parameters that account for demography. An array of length ``n-1`` whose elements are + multiplied element-wise with the polymorphic counts of the Kingman SFS. By default, no demography effects + are considered which is equivalent to ``r = [1] * (n-1)``. Note that non-default values of ``r`` will also + affect estimates of the population mutation rate. + :return: Neutral SFS + """""" + n = int(n) + + if r is None: + r = np.ones(n + 1) + else: + r = list(r) + + if len(r) != n - 1: + raise ValueError(f""The length of r must be n - 1 = {n - 1}; got {len(r)}."") + + r = np.array([1] + r + [1]) + + sfs: Spectrum = Spectrum.standard_kingman(n=n) * theta * n_sites + + # add demography + sfs.data *= r + + # add monomorphic counts + sfs.data[0] = n_sites - sfs.n_sites + + return sfs + + def get_wright_fisher( + self, + pop_size: int, + generations: int + ) -> 'WrightFisherSimulation': + """""" + Get a Wright-Fisher simulation object. + + :param pop_size: Effective population size + :param generations: Number of generations to simulate + :return: Wright-Fisher simulation object + """""" + return WrightFisherSimulation( + params=self.params, + model=self.model, + sfs_neut=self.sfs_neut, + pop_size=pop_size, + n_generations=generations, + ) + + +class WrightFisherSimulation: # pragma: no cover + """""" + Simulate an SFS under selection given a DFE under the Wright-Fisher model. + + Example usage: + + :: + + import fastdfe as fd + + # create simulation object by specifying neutral SFS and DFE + sim = fd.simulation.WrightFisherSimulation( + sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e7, theta=1e-4), + params=dict(S_d=-300, b=0.3, p_b=0.1, S_b=0.1), + model=fd.GammaExpParametrization(), + pop_size=100, + n_generations=500 + ) + + # perform the simulation + sfs_sel = sim.run() + + # plot SFS + sfs_sel.plot() + + """""" + + def __init__( + self, + params: dict = None, + model: Parametrization | str = 'GammaExpParametrization', + sfs_neut: Spectrum = None, + pop_size: int = 1000, + n_generations: int = 100, + n_sites: int = None, + theta: float = None, + parallelize: bool = True, + n_threads: int = 100 + ): + """""" + Create a Wright-Fisher simulation object. + + :param params: Parameters for the DFE parametrization (see model). By default, the default parameters of + ``model`` will be used. + :param model: DFE parametrization model + :param sfs_neut: Neutral SFS. This sfs is informative on the population sample size, population mutation rate, + the number of sites, and demography. :func:`get_neutral_sfs` can be used to obtain a neutral SFS. + :param pop_size: Effective population size + :param n_generations: Number of generations to simulate + :param n_sites: Number of sites in the simulated SFS. If not provided, the number of sites in ``sfs_neut`` will + be used. + :param theta: Population mutation rate. If not provided, the population mutation rate in ``sfs_neut`` will be used. + :param parallelize: Whether to parallelize computations + :param n_threads: Number of threads to use for parallelization + """""" + #: The DFE parametrization + self.model: Parametrization = _from_string(model) + + #: Parameters for the DFE parametrization + self.params: dict = self.model.x0 if params is None else params + + #: Neutral SFS + self.sfs_neut: Spectrum = sfs_neut + + #: SFS sample size + self.n: int = self.sfs_neut.n + + #: Population mutation rate + self.theta: float = self.sfs_neut.theta if theta is None else theta + + #: Number of sites + self.n_sites: int = self.sfs_neut.n_sites if n_sites is None else n_sites + + #: Effective population size + self.pop_size: int = pop_size + + #: Number of generations to simulate + self.n_generations: int = n_generations + + #: CDF of the DFE + self.cdf: Callable[[np.ndarray], np.ndarray] = self.model.get_cdf(**self.params) + + #: Logger + self._logger = logger.getChild('WrightFisherSimulation') + + #: Whether to parallelize computations + self.parallelize: bool = parallelize + + #: Number of threads to use for parallelization + self.n_threads: int = n_threads + + #: Tolerance for CDF bounds + self.tol_bounds = 1e-6 + + #: Tolerance for bisection + self.tol_bisect = 1e-6 + + #: Bounds for the CDF + self.lower, self.upper = self._determine_cdf_bounds() + + def _determine_cdf_bounds(self) -> Tuple[float, float]: + """""" + Determine bounds for the CDF by identifying where the CDF approaches 0 and 1. + + :return: Lower and upper bounds for the CDF. + """""" + lower = -1e-4 + upper = 1e-4 + + # Expand lower bound until CDF is close to 0 + while self.cdf(lower) > self.tol_bounds: + lower *= 2 + + # Expand upper bound until CDF is close to 1 + while self.cdf(upper) < 1 - self.tol_bounds: + upper *= 2 + + self._logger.debug(f""Bounded CDF between {lower} and {upper}."") + + return lower, upper + + def run(self) -> Spectrum: + """""" + Simulate an SFS using the Wright-Fisher model with per-individual, per-locus mutations and selection. + + :return: Simulated SFS. + """""" + rng = np.random.default_rng() + + # population mutation rate for all loci + theta = int(self.sfs_neut.theta * self.n_sites / 2) + + # fixed total of mutations + n_mut = int(self.n_generations * theta) + + self._logger.info(f'Pre-sampling selection coefficients for {n_mut} mutations.') + + # pre-sample selection coefficients for mutations + selection_coefficients = self._sample_cdf( + n=n_mut, + desc=""Number of bisections"" + ) / self.pop_size + + # log number of selection coefficients lower than -1 + if (n_low := (selection_coefficients < -1).sum()) > 0: + self._logger.debug( + f""Number of selection coefficients lower than -1: {n_low}."" + ) + + # selection coefficients per individual and locus + s = np.zeros((self.pop_size, n_mut)) + + # initial allele frequencies per individual and locus + freqs = np.zeros((self.pop_size, n_mut), dtype=np.int8) + + # pre-sample individuals for mutations across all generations + individuals = rng.choice(self.pop_size, size=(self.n_generations, theta), replace=True) + + for g in tqdm(range(self.n_generations), desc=""Simulating generations""): + # indices for mutations + i_muts = np.arange(g * theta, (g + 1) * theta) + + # introduce mutations under assumption of infinite sites + freqs[individuals[g], i_muts] = 1 + s[individuals[g], i_muts] = selection_coefficients[i_muts] + + segregating = (freqs.sum(axis=0) > 0) & (freqs.sum(axis=0) < self.pop_size) + n_segregating = segregating.sum() + + # selection + w = 1 + s[:, segregating] + probs = w / w.sum(axis=0) # selection probabilities + + u = rng.random((self.pop_size, n_segregating)) + + # Compute cumulative sums of probabilities along rows + cumsum_probs = np.cumsum(probs, axis=0) + + idx = (cumsum_probs[:, None, :] < u).sum(axis=0) + + if g % 100 == 0: + self._logger.debug(f""Number of mutations at generation {g}: {freqs.any(axis=0).sum()}"") + + freqs[:, segregating] = freqs[:, segregating][idx, np.arange(n_segregating)] + + # vectorize the hypergeometric PMF calculation + values = hypergeom.pmf(k=np.arange(self.n + 1)[:, None], M=self.pop_size, n=freqs.sum(axis=0), N=self.n) + + sfs = Spectrum(values.sum(axis=1)) + + sfs.data[0] = self.n_sites - sfs.n_polymorphic + sfs.data[-1] = 0 + + return sfs + + def _sample_cdf( + self, + n: int, + seed: int = None, + tolerance: float = 1e-13, + desc: str = ""Bisection"" + ) -> np.ndarray: + """""" + Sample the cdf of the dfe with a fully vectorized bisection method. + + :param n: Number of samples to draw + :param seed: Random seed + :param tolerance: Tolerance for the bisection method + :return: Array of values x such that cdf(x) = u + """""" + # generate uniform samples + samples = np.random.default_rng(seed=seed).uniform(0, 1, n) + + # initialize bounds + lower = np.full(n, self.lower, dtype=float) + upper = np.full(n, self.upper, dtype=float) + + pbar = tqdm(desc=desc) + + while np.mean(upper - lower) > tolerance: + # compute midpoint + mid = (lower + upper) / 2.0 + + # compute cdf at midpoint for all samples + cdf_mid = self.cdf(mid) + + # update bounds vectorized + lower_update = cdf_mid < samples + + lower = np.where(lower_update, mid, lower) + upper = np.where(~lower_update, mid, upper) + + pbar.update(1) + + pbar.close() + + # return final approximated x values + return (lower + upper) / 2.0 +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/abstract_inference.py",".py","20973","528",""""""" +Abstract inference class and static utilities. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-03-12"" + +import logging +from abc import ABC, abstractmethod +from typing import List, Optional, Literal, Tuple, Dict, Sequence + +import jsonpickle +import numpy as np +import pandas as pd +from typing_extensions import Self + +from .bootstrap import Bootstrap +from .parametrization import Parametrization, _from_string +from .utils import Serializable + +logger = logging.getLogger(""fastdfe"") + +class Inference: + """""" + Static utility methods for inference objects. + """""" + + @staticmethod + def plot_discretized( + inferences: List['AbstractInference'], + intervals: Sequence = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean', + file: str = None, + show: bool = True, + title: str = 'discretized DFEs', + labels: Sequence = None, + ax: 'plt.Axes' = None, + kwargs_legend: dict = dict(prop=dict(size=8)), + **kwargs + + ) -> 'plt.Axes': + """""" + Visualize several discretized DFEs given by the list of inference objects. + + :param inferences: List of inference objects. + :param intervals: Intervals over ``(-inf, inf)`` to use for discretization. + :param confidence_intervals: Whether to plot confidence intervals. + :param ci_level: Confidence level for confidence intervals. + :param bootstrap_type: Type of bootstrap to use for confidence intervals. + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :param file: Path to file to save the plot to. + :param show: Whether to show the plot. + :param title: Title of the plot. + :param labels: Labels for the DFEs. + :param kwargs: Additional arguments for the plot. + :param ax: Axes to plot on. Only for Python visualization backend. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :return: Axes of the plot. + """""" + from .visualization import Visualization + + # get data from inference objects + values = [] + errors = [] + for i, inference in enumerate(inferences): + val, errs = inference.get_discretized( + intervals=np.array(intervals), + confidence_intervals=confidence_intervals, + ci_level=ci_level, + bootstrap_type=bootstrap_type, + point_estimate=point_estimate + ) + + values.append(val) + errors.append(errs) + + # plot DFEs + return Visualization.plot_discretized( + values=values, + errors=errors, + labels=labels, + file=file, + show=show, + intervals=np.array(intervals), + title=title, + ax=ax, + kwargs_legend=kwargs_legend + ) + + @staticmethod + def plot_continuous( + inferences: List['AbstractInference'], + intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + file: str = None, + show: bool = True, + title: str = 'continuous DFEs', + labels: Sequence = None, + scale: Literal['lin', 'log', 'symlog'] = 'lin', + scale_density: bool = False, + ax: 'plt.Axes' = None, + kwargs_legend: dict = dict(prop=dict(size=8)), + **kwargs + + ) -> 'plt.Axes': + """""" + Visualize several DFEs given by the list of inference objects. + By default, the PDF is plotted as is. Due to the logarithmic scale on + the x-axis, we may get a wrong intuition on how the mass is distributed, + however. To get a better intuition, we can optionally scale the density + by the x-axis interval size using ``scale_density = True``. This has the + disadvantage that the density now changes for x, so that even a constant + density will look warped. + + :param inferences: List of inference objects. + :param intervals: Intervals to use for discretization. + :param confidence_intervals: Whether to plot confidence intervals. + :param ci_level: Confidence level for confidence intervals. + :param bootstrap_type: Type of bootstrap to use for confidence intervals. + :param file: Path to file to save the plot to. + :param show: Whether to show the plot. + :param title: Title of the plot. + :param labels: Labels for the DFEs. + :param scale: y-scale of the plot. + :param scale_density: Whether to scale the density by the x-axis interval size. + :param ax: Axes to plot on. Only for Python visualization backend. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :param kwargs: Additional arguments for the plot. + :return: Axes of the plot. + """""" + from .visualization import Visualization + + # get data from inference objects + values = [] + errors = [] + for i, inf in enumerate(inferences): + val, errs = inf.get_discretized( + intervals=intervals, + confidence_intervals=confidence_intervals, + ci_level=ci_level, + bootstrap_type=bootstrap_type + ) + + values.append(val) + errors.append(errs) + + # plot DFEs + return Visualization.plot_continuous( + bins=intervals, + **locals() + ) + + @staticmethod + def plot_inferred_parameters( + inferences: List['AbstractInference'], + labels: Sequence, + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean', + file: str = None, + show: bool = True, + title: str = 'parameter estimates', + scale: Literal['lin', 'log', 'symlog'] = 'log', + ax: 'plt.Axes' = None, + kwargs_legend: dict = dict(prop=dict(size=8), loc='upper right'), + **kwargs + + ) -> 'plt.Axes': + """""" + Visualize several discretized DFEs given by the list of inference objects. + Note that the DFE parametrization needs to be the same for all inference objects. + + :param inferences: List of inference objects. + :param labels: Unique labels for the DFEs. + :param scale: y-scale of the plot. + :param confidence_intervals: Whether to plot confidence intervals. + :param ci_level: Confidence level for confidence intervals. + :param bootstrap_type: Type of bootstrap to use for confidence intervals. + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :param file: Path to file to save the plot to. + :param show: Whether to show the plot. + :param title: Title of the plot. + :param ax: Axes to plot on. Only for Python visualization backend. + :return: Axes of the plot. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :param kwargs: Additional arguments which are ignored. + :raises ValueError: If no inference objects are given. + """""" + from .visualization import Visualization + + if len(inferences) == 0: + raise ValueError('No inference objects given.') + + # get sorted list of parameter names + param_names = sorted(list(inferences[0].get_bootstrap_param_names())) + + # get errors and values + errors, values = Inference.get_errors_params_mle( + bootstrap_type=bootstrap_type, + ci_level=ci_level, + confidence_intervals=confidence_intervals, + inferences=inferences, + labels=labels, + param_names=param_names, + point_estimate=point_estimate + ) + + return Visualization.plot_inferred_parameters( + values=values, + errors=errors, + param_names=param_names, + file=file, + show=show, + title=title, + labels=labels, + scale=scale, + legend=len(labels) > 1, + kwargs_legend=kwargs_legend, + ax=ax, + ) + + @staticmethod + def plot_inferred_parameters_boxplot( + inferences: List['AbstractInference'], + labels: Sequence, + file: str = None, + show: bool = True, + title: str = 'parameter estimates', + **kwargs + ) -> 'plt.Axes': + """""" + Visualize several discretized DFEs given by the list of inference objects. + Note that the DFE parametrization needs to be the same for all inference objects. + + :param inferences: List of inference objects. + :param labels: Unique labels for the DFEs. + :param file: Path to file to save the plot to. + :param show: Whether to show the plot. + :param title: Title of the plot. + :param kwargs: Additional arguments for the plot. + :return: Axes of the plot. + :raises ValueError: If no inference objects are given or no bootstraps are found. + """""" + from .visualization import Visualization + + if len(inferences) == 0: + raise ValueError('No inference objects given.') + + # get sorted list of parameter names + param_names = sorted(list(inferences[0].get_bootstrap_param_names())) + + if inferences[0].bootstraps is None: + raise ValueError('No bootstraps found.') + + # create dict of dataframes + values = dict((k, inf.bootstraps) for k, inf in zip(labels, inferences)) + + return Visualization.plot_inferred_parameters_boxplot( + values=values, + param_names=param_names, + file=file, + show=show, + title=title, + ) + + @staticmethod + def get_errors_params_mle( + ci_level: float, + confidence_intervals: bool, + inferences: List['AbstractInference'], + labels: Sequence, + param_names: Sequence, + bootstrap_type: Literal['percentile', 'bca'], + point_estimate: Literal['original', 'mean', 'median'] = 'mean', + ) -> Tuple[Dict[str, Tuple[np.ndarray, np.ndarray] | None], Dict[str, np.ndarray]]: + """""" + Get errors and values for MLE params of inferences. + + :param ci_level: Confidence level for confidence intervals. + :param confidence_intervals: Whether to compute confidence intervals. + :param inferences: List of inference objects. + :param labels: Labels for the inferences. + :param param_names: Names of the parameters to get errors and values for. + :param bootstrap_type: Type of bootstrap to use. + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :return: dictionary of errors and dictionary of center values indexed by labels. + """""" + errors, values, center = {}, {}, {} + for label, inf in zip(labels, inferences): + + values[label] = list(inf.get_bootstrap_params()[k] for k in param_names) + + # whether to compute errors + if confidence_intervals and inf.bootstraps is not None: + + # compute errors + center[label], errors[label], _ = Bootstrap.get_errors( + values=values[label], + bs=inf.bootstraps[param_names].to_numpy(), + bootstrap_type=bootstrap_type, + ci_level=ci_level, + point_estimate=point_estimate, + ) + else: + center[label] = np.array(values[label]) + errors[label] = None + + return errors, center + + @staticmethod + def get_discretized( + inferences: List['AbstractInference'], + labels: Sequence, + intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean' + ) -> Tuple[Dict[str, np.ndarray], Dict[str, Optional[np.ndarray]]]: + """""" + Get values and errors of discretized DFE. + + :param inferences: List of inference objects. + :param labels: Labels for the DFEs. + :param bootstrap_type: Type of bootstrap to use + :param ci_level: Confidence interval level + :param confidence_intervals: Whether to compute confidence intervals + :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bars. + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :return: Dictionary of values and dictionary of errors indexed by labels. + """""" + values = {} + errors = {} + + for label, inf in zip(labels, inferences): + + if confidence_intervals and inf.bootstraps is not None: + # get bootstraps and errors if specified + values[label], errors[label], _ = Inference.get_stats_discretized( + params=inf.get_bootstrap_params(), + bootstraps=inf.bootstraps, + model=inf.model, + ci_level=ci_level, + intervals=intervals, + bootstrap_type=bootstrap_type, + point_estimate=point_estimate + ) + else: + # otherwise just get discretized values + values[label] = Inference.compute_histogram( + params=inf.get_bootstrap_params(), + model=inf.model, + intervals=intervals + ) + errors[label] = None + + return values, errors + + @staticmethod + def get_stats_discretized( + params: dict, + bootstraps: pd.DataFrame, + model: Parametrization | str, + ci_level: float = 0.05, + intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean' + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """""" + Compute errors and confidence interval for a discretized DFE. + + :param params: Parameters of the model + :param bootstraps: Bootstrapped samples + :param model: DFE parametrization + :param ci_level: Confidence interval level + :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. + :param bootstrap_type: Type of bootstrap + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :return: Center values, errors around center, and confidence intervals. + """""" + # discretize MLE DFE + values = Inference.compute_histogram(model, params, intervals) + + # calculate bootstrapped histograms + # get discretized DFE per bootstrap sample + bs = np.array([Inference.compute_histogram(model, dict(r), intervals) for _, r in bootstraps.iterrows()]) + + return Bootstrap.get_errors( + values=values, + bs=bs, + bootstrap_type=bootstrap_type, + ci_level=ci_level, + point_estimate=point_estimate + ) + + @staticmethod + def compute_histogram( + model: Parametrization | str, + params: dict, + intervals: np.ndarray + ) -> np.ndarray: + """""" + Discretize the DFE given a DFE parametrization and its parameter values. + + :param model: DFE parametrization + :param params: Parameters of the model + :param intervals: Array of interval boundaries yielding ``intervals.shape[0] - 1`` bins. + :return: Discretized DFE + """""" + # discrete DFE + y = _from_string(model)._discretize(params, intervals) + + # return normalized histogram + return y / y.sum() + + +class AbstractInference(Serializable, ABC): + """""" + Base class for main Inference and polyDFE wrapper. + """""" + + def __init__(self, **kwargs): + """""" + Initialize the inference. + + :param kwargs: Keyword arguments + """""" + self._logger = logger.getChild(self.__class__.__name__) + + self.bootstraps: Optional[pd.DataFrame] = None + self.params_mle: Optional[dict] = None + self.model: Optional[Parametrization] = None + + @abstractmethod + def get_bootstrap_params(self) -> Dict[str, float]: + """""" + Get the parameters to be included in the bootstraps. + + :return: Parameters to be included in the bootstraps + """""" + pass + + def get_discretized( + self, + intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean' + ) -> Tuple[np.ndarray, Optional[np.ndarray]]: + """""" + Get discretized DFE. + + :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bins. + :param confidence_intervals: Whether to return confidence intervals + :param ci_level: Confidence interval level + :param bootstrap_type: Type of bootstrap + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :return: Array of values and array of deviations + """""" + values, errors = Inference.get_discretized( + inferences=[self], + labels=['all'], + intervals=intervals, + confidence_intervals=confidence_intervals, + ci_level=ci_level, + bootstrap_type=bootstrap_type, + point_estimate=point_estimate + ) + + return values['all'], errors['all'] + + def plot_discretized( + self, + file: str = None, + show: bool = True, + intervals: np.ndarray = np.array([-np.inf, -100, -10, -1, 0, 1, np.inf]), + confidence_intervals: bool = True, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'mean', + title: str = 'discretized DFE', + ax: 'plt.Axes' = None, + kwargs_legend: dict = dict(prop=dict(size=8)), + ) -> 'plt.Axes': + """""" + Plot discretized DFE. + + :param file: File to save the plot to + :param show: Whether to show the plot + :param intervals: Array of interval boundaries over ``(-inf, inf)`` yielding ``intervals.shape[0] - 1`` bars. + :param confidence_intervals: Whether to plot confidence intervals + :param ci_level: Confidence interval level + :param bootstrap_type: Type of bootstrap + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :param title: Title of the plot + :param ax: Axes to plot on. Only for Python visualization backend. + :param kwargs_legend: Keyword arguments passed to :meth:`plt.legend`. Only for Python visualization backend. + :return: Axes + """""" + return Inference.plot_discretized( + inferences=[self], + file=file, + show=show, + intervals=intervals, + confidence_intervals=confidence_intervals, + ci_level=ci_level, + bootstrap_type=bootstrap_type, + point_estimate=point_estimate, + title=title, + kwargs_legend=kwargs_legend, + ax=ax + ) + + @abstractmethod + def get_bootstrap_param_names(self) -> List[str]: + """""" + Get the names of the parameters to be included in the bootstraps. + """""" + pass +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/bootstrap.py",".py","5285","146",""""""" +Bootstrap utilities. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import logging +from typing import Literal, Sequence, Tuple + +import numpy as np +from scipy.stats import norm as normal + +# get logger +logger = logging.getLogger('fastdfe').getChild('Bootstrap') + + +class Bootstrap: + """""" + Bootstrap utilities. + """""" + + @staticmethod + def get_bounds_from_quantile(data: Sequence, a1: float, a2: float, n: int) -> Tuple[float, float]: + """""" + Get confidence interval bounds. + + :param data: Sorted data + :param a1: Lower quantile + :param a2: Upper quantile + :param n: Number of data points + :return: lower bound and upper bound + """""" + if np.isnan(a1) or np.isnan(a2): + return [None, None] + + return data[max(round(a1 * n), 0)], data[min(round(a2 * n), n - 1)] + + @staticmethod + def get_ci_percentile(bootstraps: Sequence, a: float) -> Tuple[float, float]: + """""" + Get the (1 - a)% confidence intervals using the percentile bootstrap. + + :param bootstraps: List of bootstraps + :param a: Confidence level + :return: lower bound and upper bound + """""" + if not 0 <= a <= 0.5: + raise ValueError('Confidence level must be between 0 and 0.5.') + + return Bootstrap.get_bounds_from_quantile(np.sort(bootstraps), a, 1 - a, len(bootstraps)) + + @staticmethod + def get_ci_bca(bootstraps: Sequence, original: float, a: float) -> Tuple[float, float]: + """""" + Get the (1 - a)% confidence intervals using the BCa method. + cf. An Introduction to the Bootstrap, Bradley Efron, Robert J. Tibshirani, section 14.2. + + :param bootstraps: List of bootstraps + :param original: Original value + :param a: Confidence level + :return: lower bound and upper bound + """""" + if len(bootstraps) == 0: + return [0, 0] + + n = len(bootstraps) + data = np.sort(np.array(bootstraps)) + + theta_hat_i = np.array([np.var(np.delete(data, i)) for i in range(n)]) + theta_hat = sum(theta_hat_i) / n + + a_hat = sum((theta_hat - theta_hat_i) ** 3) / (6 * (sum((theta_hat - theta_hat_i) ** 2)) ** (3 / 2)) + + # we add epsilon here to avoid getting -inf when sum(data < original) / n is 0 + z0_hat = normal.ppf(sum(data < original) / n + np.finfo(float).eps) + z_a = normal.ppf(a) + + a1 = normal.cdf(z0_hat + (z0_hat + z_a) / (1 - a_hat * (z0_hat + z_a))) + a2 = normal.cdf(z0_hat + (z0_hat - z_a) / (1 - a_hat * (z0_hat - z_a))) + + return Bootstrap.get_bounds_from_quantile(data, a1, a2, n) + + @staticmethod + def get_errors( + values: Sequence, + bs: np.ndarray, + ci_level: float = 0.05, + bootstrap_type: Literal['percentile', 'bca'] = 'percentile', + point_estimate: Literal['original', 'mean', 'median'] = 'original', + ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """""" + Get error values and confidence intervals from the list of original + values and its bootstraps for a list of parameters. + + :param values: The original values. + :param bs: Array containing bootstraps as first and the values as second dimension. + :param ci_level: The confidence level. + :param bootstrap_type: The bootstrap type. + :param point_estimate: Whether to use 'original' MLE values, 'mean' or 'median' of bootstraps as point estimate. + :return: Center values, errors around center, and confidence intervals. + """""" + # number of values + n_values = len(values) + + # use mean of bootstraps instead of original values + if point_estimate == 'mean': + center = np.mean(bs, axis=0) + elif point_estimate == 'median': + center = np.median(bs, axis=0) + else: + center = np.array(values) + + # determine confidence intervals and errors on y axis + if bootstrap_type == 'percentile': + cis = np.array([Bootstrap.get_ci_percentile(bs[:, i], ci_level) for i in range(n_values)]).T + + elif bootstrap_type == 'bca': + cis = np.array([Bootstrap.get_ci_bca(bs[:, i], values[i], ci_level) for i in range(n_values)]).T + + # raise warning if some confidence intervals could not be determined + if np.sum(np.equal(cis, None)) > 0: + logger.warning('Some confidence intervals could not be computed.') + + # set undefined confidence intervals to values + mask = np.equal(cis, None) + for j in range(cis.shape[1]): + if mask[:, j].any(): + cis[mask[:, j], j] = values[j] + + else: + raise NotImplementedError(f""Bootstrap type {bootstrap_type} not supported."") + + # determine error relative to center + errors = np.array([center - cis[0], cis[1] - center]) + + # issue notice if some errors are negative + if np.sum(np.less(errors, 0)) > 0: + logger.debug('Some computed errors were negative and were adjusted to 0.') + + # set negative errors to 0 + errors[errors < 0] = 0 + + return center, errors, cis +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/io_handlers.py",".py","24131","820",""""""" +Handlers the reading of VCF, GFF and FASTA files. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-05-29"" + +import gzip +import hashlib +import logging +import os +import shutil +import tempfile +import warnings +from collections import Counter +from functools import cached_property +from typing import List, Iterable, TextIO, Dict, Optional, Tuple, Union, Sequence +from urllib.parse import urlparse + +import numpy as np +import pandas as pd +import requests +from Bio import SeqIO +from Bio.SeqIO.FastaIO import FastaIterator +from Bio.SeqRecord import SeqRecord +from pandas.errors import SettingWithCopyWarning +from tqdm import tqdm + +from .settings import Settings + +#: The DNA bases +bases = [""A"", ""C"", ""G"", ""T""] + +# logger +logger = logging.getLogger('fastdfe') + + +def get_called_bases(genotypes: Sequence[str]) -> np.ndarray: + """""" + Get the called bases from a list of calls. + + :param genotypes: Array of genotypes in the form of strings. + :return: Array of called bases. + """""" + # join genotypes + joined_genotypes = ''.join(genotypes).replace('|', '/') + + # convert to numpy array of characters + char_array = np.array(list(joined_genotypes)) + + # return only characters that are in the bases list + return char_array[np.isin(char_array, bases)] + + +def get_major_base(genotypes: Sequence[str]) -> str | None: + """""" + Get the major base from a list of calls. + + :param genotypes: Array of genotypes in the form of strings. + :return: Major base. + """""" + # get the called bases + bases = get_called_bases(genotypes) + + if len(bases) > 0: + return Counter(bases).most_common()[0][0] + + +def is_monomorphic_snp(variant: Union['cyvcf2.Variant', 'DummyVariant']) -> bool: + """""" + Whether the given variant is a monomorphic SNP. + + :param variant: The vcf site + :return: Whether the site is a monomorphic SNP + """""" + return (not (variant.is_snp or variant.is_mnp or variant.is_indel or variant.is_deletion or variant.is_sv) + and variant.REF in bases) + + +def count_sites( + vcf: str | Iterable['cyvcf2.Variant'], + max_sites: int = np.inf, + desc: str = 'Counting sites' +) -> int: + """""" + Count the number of sites in the VCF. + + :param vcf: The path to the VCF file or an iterable of variants + :param max_sites: Maximum number of sites to consider + :param desc: Description for the progress bar + :return: Number of sites + """""" + + # if we don't have a file path, we can just count the number of variants + if not isinstance(vcf, str): + return len(list(vcf)) + + i = 0 + with open_file(vcf) as f: + + with tqdm(disable=Settings.disable_pbar, desc=desc) as pbar: + + for line in f: + if not line.startswith('#'): + i += 1 + pbar.update() + + # stop counting if max_sites was reached + if i >= max_sites: + break + + return i + + +def download_if_url(path: str, cache: bool = True, desc: str = 'Downloading file') -> str: + """""" + Download the VCF file if it is a URL. + + :param path: The path to the VCF file. + :param cache: Whether to cache the file. + :param desc: Description for the progress bar + :return: The path to the downloaded file or the original path. + """""" + if FileHandler.is_url(path): + # download the file and return path + return FileHandler.download_file(path, cache=cache, desc=desc) + + return path + + +def open_file(file: str) -> TextIO: + """""" + Open a file, either gzipped or not. + + :param file: File to open + :return: stream + """""" + if file.endswith('.gz'): + return gzip.open(file, ""rt"") + + return open(file, 'r') + + +class FileHandler: + """""" + Base class for file handling. + """""" + + #: The logger instance + _logger = logger.getChild(__qualname__) + + def __init__(self, cache: bool = True, aliases: Dict[str, List[str]] = {}): + """""" + Create a new FileHandler instance. + + :param cache: Whether to cache files that are downloaded from URLs + :param aliases: The contig aliases. + """""" + #: Whether to cache files that are downloaded from URLs + self.cache: bool = cache + + #: The contig mappings + self._alias_mappings, self.aliases = self._expand_aliases(aliases) + + @staticmethod + def _expand_aliases(alias_dict: Dict[str, List[str]]) -> Tuple[Dict[str, str], Dict[str, List[str]]]: + """""" + Expand the contig aliases. + """""" + # map alias to primary alias + mappings = {} + + # map primary alias to all aliases + aliases = {} + + for contig, alias_list in alias_dict.items(): + all_aliases = alias_list + [contig] + aliases[contig] = all_aliases + + for alias in all_aliases: + mappings[alias] = contig + + return mappings, aliases + + @staticmethod + def is_url(path: str) -> bool: + """""" + Check if the given path is a URL. + + :param path: The path to check. + :return: ``True`` if the path is a URL, ``False`` otherwise. + """""" + try: + result = urlparse(path) + return all([result.scheme, result.netloc]) + except ValueError: + return False + + def download_if_url(self, path: str) -> str: + """""" + Download the VCF file if it is a URL. + + :param path: The path to the VCF file. + :return: The path to the downloaded file or the original path. + """""" + return download_if_url(path, cache=self.cache, desc=f'{self.__class__.__name__}>Downloading file') + + @staticmethod + def unzip_if_zipped(file: str): + """""" + If the given file is gzipped, unzip it and return the path to the unzipped file. + If the file is not gzipped, return the path to the original file. + + :param file: The path to the file. + :return: The path to the unzipped file, or the original file if it was not gzipped. + """""" + # check if the file extension is .gz + if file.endswith('.gz'): + # create a new file path by removing the .gz extension + unzipped = file[:-3] + + # unzip file + with gzip.open(file, 'rb') as f_in: + with open(unzipped, 'wb') as f_out: + shutil.copyfileobj(f_in, f_out) + + return unzipped + + return file + + @staticmethod + def get_filename(url: str): + """""" + Return the file extension of a URL. + + :param url: The URL to get the file extension from. + :return: The file extension. + """""" + return os.path.basename(urlparse(url).path) + + @staticmethod + def hash(s: str) -> str: + """""" + Return a truncated SHA1 hash of a string. + + :param s: The string to hash. + :return: The SHA1 hash. + """""" + return hashlib.sha1(s.encode()).hexdigest()[:12] + + @classmethod + def download_file(cls, url: str, cache: bool = True, desc: str = 'Downloading file') -> str: + """""" + Download a file from a URL. + + :param cache: Whether to cache the file. + :param url: The URL to download the file from. + :param desc: Description for the progress bar + :return: The path to the downloaded file. + """""" + # extract the file extension from the URL + filename = FileHandler.get_filename(url) + + # create a temporary file path + path = tempfile.gettempdir() + '/' + FileHandler.hash(url) + '.' + filename + + # check if the file is already cached + if cache and os.path.exists(path): + cls._logger.info(f'Using cached file at {path}') + return path + + cls._logger.info(f'Downloading file from {url}') + + # start the stream + response = requests.get(url, stream=True) + + # check if the request was successful + response.raise_for_status() + + # create a temporary file with the original file extension + with tempfile.NamedTemporaryFile(delete=False) as tmp: + total_size = int(response.headers.get('content-length', 0)) + chunk_size = 8192 + + with tqdm(total=total_size, + unit='B', + unit_scale=True, + desc=desc, + disable=Settings.disable_pbar) as pbar: + + # write the file to disk + for chunk in response.iter_content(chunk_size=chunk_size): + if chunk: + tmp.write(chunk) + pbar.update(len(chunk)) + + # rename the file to the original file extension + os.rename(tmp.name, path) + + if cache: + cls._logger.info(f'Cached file at {path}') + + return path + + def get_aliases(self, contig: str) -> List[str]: + """""" + Get all aliases for the given contig alias including the primary alias. + + :param contig: The contig. + :return: The aliases. + """""" + if contig in self._alias_mappings: + return self.aliases[self._alias_mappings[contig]] + + return [contig] + + +class FASTAHandler(FileHandler): + + def __init__(self, fasta: str | None, cache: bool = True, aliases: Dict[str, List[str]] = {}): + """""" + Create a new FASTAHandler instance. + + :param fasta: The path to the FASTA file. + :param cache: Whether to cache files that are downloaded from URLs + :param aliases: The contig aliases. + """""" + FileHandler.__init__(self, cache=cache, aliases=aliases) + + #: The path to the FASTA file. + self.fasta: str = fasta + + #: The current contig. + self._contig: SeqRecord | None = None + + @cached_property + def _ref(self) -> FastaIterator | None: + """""" + Get the reference reader. + + :return: The reference reader. + """""" + if self.fasta is None: + return + + return self.load_fasta(self.fasta) + + def load_fasta(self, file: str) -> FastaIterator: + """""" + Load a FASTA file into a dictionary. + + :param file: The path to The FASTA file path, possibly gzipped or a URL + :return: Iterator over the sequences. + """""" + self._logger.info(""Loading FASTA file"") + + # download and unzip if necessary + local_file = self.unzip_if_zipped(self.download_if_url(file)) + + return SeqIO.parse(local_file, 'fasta') + + def get_contig(self, aliases, rewind: bool = True, notify: bool = True) -> SeqRecord: + """""" + Get the contig from the FASTA file. + + Note that ``pyfaidx`` would be more efficient here, but there were problems when running it in parallel. + + :param aliases: The contig aliases. + :param rewind: Whether to allow for rewinding the iterator if the contig is not found. + :param notify: Whether to notify the user when rewinding the iterator. + :return: The contig. + """""" + # if the contig is already loaded, we can just return it + if self._contig is not None and self._contig.id in aliases: + return self._contig + + # if the contig is not loaded, we can try to load it + try: + self._contig = next(self._ref) + + # iterate until we find the contig + while self._contig.id not in aliases: + self._contig = next(self._ref) + + except StopIteration: + + # if rewind is ``True``, we can rewind the iterator and try again + if rewind: + if notify: + self._logger.info(""Rewinding FASTA iterator."") + + # renew fasta iterator + FASTAHandler._rewind(self) + + return self.get_contig(aliases, rewind=False) + + raise LookupError(f'None of the contig aliases {aliases} were found in the FASTA file.') + + return self._contig + + def get_contig_names(self) -> List[str]: + """""" + Get the names of the contigs in the FASTA file. + + :return: The contig names. + """""" + return [contig.id for contig in self._ref] + + def _rewind(self): + """""" + Rewind the fasta iterator. + """""" + if hasattr(self, '_ref'): + # noinspection all + del self._ref + + +class GFFHandler(FileHandler): + """""" + GFF handler. + """""" + + def __init__(self, gff: str | None, cache: bool = True, aliases: Dict[str, List[str]] = {}): + """""" + Constructor. + + :param gff: The path to the GFF file. + :param cache: Whether to cache the file. + :param aliases: The contig aliases. + """""" + FileHandler.__init__(self, cache=cache, aliases=aliases) + + #: The logger + self._logger = logger.getChild(self.__class__.__name__) + + #: The GFF file path + self.gff = gff + + @cached_property + def _cds(self) -> pd.DataFrame | None: + """""" + The coding sequences. + + :return: Dataframe with coding sequences. + """""" + if self.gff is None: + return + + return self._load_cds() + + def _load_cds(self) -> pd.DataFrame: + """""" + Load coding sequences from a GFF file. + + :return: The DataFrame. + """""" + self._logger.info(f'Loading GFF file') + + # download and unzip if necessary + local_file = self.unzip_if_zipped(self.download_if_url(self.gff)) + + # column labels for GFF file + col_labels = ['seqid', 'source', 'type', 'start', 'end', 'score', 'strand', 'phase', 'attributes'] + + dtypes = dict( + seqid='category', + type='category', + start=float, # temporarily load as float to handle NA values + end=float, # temporarily load as float to handle NA values + strand='category', + phase='category' + ) + + # load GFF file + df = pd.read_csv( + local_file, + sep='\t', + comment='#', + names=col_labels, + dtype=dtypes, + usecols=['seqid', 'type', 'start', 'end', 'strand', 'phase'] + ) + + # filter for coding sequences + df = df[df['type'] == 'CDS'] + + # drop rows with NA values + df = df.dropna() + + # convert start and end to int + df['start'] = df['start'].astype(int) + df['end'] = df['end'].astype(int) + + # drop type column + df.drop(columns=['type'], inplace=True) + + # remove duplicates + df = df.drop_duplicates(subset=['seqid', 'start', 'end']) + + # sort by seqid and start + df.sort_values(by=['seqid', 'start'], inplace=True) + + return df + + def _count_target_sites(self, remove_overlaps: bool = False, contigs: List[str] = None) -> Dict[str, int]: + """""" + Count the number of target sites in a GFF file. + + :param remove_overlaps: Whether to remove overlapping coding sequences. + :param contigs: The contigs to consider. + :return: The number of target sites per chromosome/contig. + """""" + cds = self._add_lengths( + cds=self._load_cds(), + remove_overlaps=remove_overlaps, + contigs=contigs + ) + + # group by 'seqid' and calculate the sum of 'length' + target_sites = cds.groupby('seqid', observed=False)['length'].sum().to_dict() + + # filter explicitly for contigs if necessary + # as seqid is a categorical variable, groups were retained even if they were filtered out + if contigs is not None: + target_sites = {k: v for k, v in target_sites.items() if k in contigs} + + return target_sites + + @staticmethod + def remove_overlaps(df: pd.DataFrame) -> pd.DataFrame: + """""" + Remove overlapping coding sequences. + + :param df: The coding sequences. + :return: The coding sequences without overlaps. + """""" + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"", category=SettingWithCopyWarning) + + df['overlap'] = df['start'].shift(-1) <= df['end'] + + df = df[~df['overlap']] + + return df.drop(columns=['overlap']) + + @staticmethod + def _add_lengths(cds: pd.DataFrame, remove_overlaps: bool = False, contigs: List[str] = None) -> pd.DataFrame: + """""" + Compute coding sequences lengths. + + :param cds: The coding sequences. + :param remove_overlaps: Whether to remove overlapping coding sequences. + :param contigs: The contigs to consider. + :return: The coding sequences with lengths. + """""" + # filter for contigs if necessary + if contigs is not None: + cds = cds[cds['seqid'].isin(contigs)] + + # remove duplicates + cds = cds.drop_duplicates(subset=['seqid', 'start']) + + # remove overlaps + if remove_overlaps: + cds = GFFHandler.remove_overlaps(cds) + + # catch warning when adding a new column to a slice of a DataFrame + with warnings.catch_warnings(): + warnings.simplefilter(""ignore"", category=SettingWithCopyWarning) + + # create a new column for the difference between 'end' and 'start' + cds['length'] = cds['end'] - cds['start'] + 1 + + return cds + + +class VCFHandler(FileHandler): + """""" + Base class for VCF handling. + """""" + + def __init__( + self, + vcf: str | Iterable['cyvcf2.Variant'], + info_ancestral: str = 'AA', + max_sites: int = np.inf, + seed: int | None = 0, + cache: bool = True, + aliases: Dict[str, List[str]] = {} + ): + """""" + Create a new VCF instance. + + :param vcf: The path to the VCF file or an iterable of variants, can be gzipped, urls are also supported + :param info_ancestral: The tag in the INFO field that contains the ancestral allele + :param max_sites: Maximum number of sites to consider + :param seed: Seed for the random number generator. Use ``None`` for no seed. + :param cache: Whether to cache files that are downloaded from URLs + :param aliases: The contig aliases. + """""" + FileHandler.__init__(self, cache=cache, aliases=aliases) + + #: The path to the VCF file or an iterable of variants + self.vcf = vcf + + #: The tag in the INFO field that contains the ancestral allele + self.info_ancestral: str = info_ancestral + + #: Maximum number of sites to consider + self.max_sites: int = int(max_sites) if not np.isinf(max_sites) else np.inf + + #: Seed for the random number generator + self.seed: Optional[int] = int(seed) if seed is not None else None + + #: Random generator instance + self.rng = np.random.default_rng(seed=seed) + + @cached_property + def _reader(self) -> 'cyvcf2.VCF': + """""" + Get the VCF reader. + + :return: The VCF reader. + """""" + return self.load_vcf() + + def _rewind(self): + """""" + Rewind the VCF iterator. + """""" + if hasattr(self, '_reader'): + # noinspection all + del self._reader + + def load_vcf(self) -> 'cyvcf2.VCF': + """""" + Load a VCF file into a dictionary. + + :return: The VCF reader. + """""" + try: + from cyvcf2 import VCF + except ImportError: + raise ImportError( + ""VCF support in fastdfe requires the optional 'cyvcf2' package. "" + ""Please install fastdfe with the 'vcf' extra: pip install fastdfe[vcf]"" + ) + + self._logger.info(""Loading VCF file"") + + return VCF(self.download_if_url(self.vcf)) + + @cached_property + def n_sites(self) -> int: + """""" + Get the number of sites in the VCF. + + :return: Number of sites + """""" + return self.count_sites() + + def count_sites(self) -> int: + """""" + Count the number of sites in the VCF. + + :return: Number of sites + """""" + return count_sites( + vcf=self.download_if_url(self.vcf), + max_sites=self.max_sites, + desc=f'{self.__class__.__name__}>Counting sites' + ) + + def get_pbar(self, desc: str = ""Processing sites"", total: int | None = 0) -> tqdm: + """""" + Return a progress bar for the number of sites. + + :param desc: Description for the progress bar + :param total: Total number of items + :return: tqdm + """""" + return tqdm( + total=self.n_sites if total == 0 else total, + disable=Settings.disable_pbar, + desc=desc + ) + + +class MultiHandler(VCFHandler, FASTAHandler, GFFHandler): + """""" + Handle VCF, FASTA and GFF files. + """""" + + def __init__( + self, + vcf: str | Iterable['cyvcf2.Variant'], + fasta: str | None = None, + gff: str | None = None, + info_ancestral: str = 'AA', + max_sites: int = np.inf, + seed: int | None = 0, + cache: bool = True, + aliases: Dict[str, List[str]] = {} + ): + """""" + Create a new MultiHandler instance. + + :param vcf: The path to the VCF file or an iterable of variants, can be gzipped, urls are also supported + :param fasta: The path to the FASTA file. + :param gff: The path to the GFF file. + :param info_ancestral: The tag in the INFO field that contains the ancestral allele + :param max_sites: Maximum number of sites to consider + :param seed: Seed for the random number generator. Use ``None`` for no seed. + :param cache: Whether to cache files that are downloaded from URLs + :param aliases: The contig aliases. + """""" + # initialize vcf handler + VCFHandler.__init__( + self, + vcf=vcf, + info_ancestral=info_ancestral, + max_sites=max_sites, + seed=seed, + cache=cache, + aliases=aliases + ) + + # initialize fasta handler + FASTAHandler.__init__( + self, + fasta=fasta, + cache=cache, + aliases=aliases + ) + + # initialize gff handler + GFFHandler.__init__( + self, + gff=gff, + cache=cache, + aliases=aliases + ) + + def _require_fasta(self, class_name: str): + """""" + Raise an exception if no FASTA file was provided. + + :param class_name: The name of the class that requires a FASTA file. + """""" + if self.fasta is None: + raise ValueError(f'{class_name} requires a FASTA file to be specified.') + + def _require_gff(self, class_name: str): + """""" + Raise an exception if no GFF file was provided. + + :param class_name: The name of the class that requires a GFF file. + """""" + if self.gff is None: + raise ValueError(f'{class_name} requires a GFF file to be specified.') + + def _rewind(self): + """""" + Rewind the fasta and vcf handler. + """""" + FASTAHandler._rewind(self) + VCFHandler._rewind(self) + + +class NoTypeException(BaseException): + """""" + Exception thrown when no type can be determined. + """""" + pass + + +class DummyVariant: + """""" + Dummy variant class to emulate a mono-allelic site. + """""" + + #: Whether the variant is an SNP + is_snp = False + + #: Whether the variant is an MNP + is_mnp = False + + #: Whether the variant is an indel + is_indel = False + + #: Whether the variant is a deletion + is_deletion = False + + #: Whether the variant is a structural variant + is_sv = False + + #: The alternate alleles + ALT = [] + + def __init__(self, ref: str, pos: int, chrom: str): + """""" + Initialize the dummy variant. + + :param ref: The reference allele + :param pos: The position + :param chrom: The contig + """""" + #: The reference allele + self.REF = ref + + #: The position + self.POS = pos + + #: The contig + self.CHROM = chrom + + #: Info field + self.INFO = {} +","Python" +"Allele","Sendrowski/fastDFE","fastdfe/json_handlers.py",".py","3912","166",""""""" +JSON handlers. +"""""" + +__author__ = ""Janek Sendrowski"" +__contact__ = ""sendrowski.janek@gmail.com"" +__date__ = ""2023-02-26"" + +import json +import logging + +import numpy as np +import pandas as pd +from jsonpickle.handlers import BaseHandler + +from .optimization import SharedParams, Covariate +from .parametrization import Parametrization +from .spectrum import Spectrum, Spectra + +# configure logger +logger = logging.getLogger('fastdfe') + + +class NumpyArrayHandler(BaseHandler): + """""" + Handler for numpy arrays. + """""" + + def flatten(self, x: np.ndarray, data: dict) -> dict: + """""" + Convert Spectrum to dict. + + :param x: Numpy array + :param data: Dictionary + :return: Simplified dictionary + """""" + return data | dict(data=x.tolist()) + + def restore(self, data: dict) -> np.ndarray: + """""" + Restore Spectrum. + + :param data: Dictionary + :return: Numpy array + """""" + return np.array(data['data']) + + +class SpectrumHandler(BaseHandler): + """""" + Handler for spectrum objects. + """""" + + def flatten(self, sfs: Spectrum, data: dict) -> dict: + """""" + Convert Spectrum to dict. + + :param sfs: Spectrum object + :param data: Dictionary + :return: Simplified dictionary + """""" + return data | dict(data=sfs.to_list()) + + def restore(self, data: dict) -> Spectrum: + """""" + Restore Spectrum. + + :param data: Dictionary + :return: Spectrum object + """""" + return Spectrum.from_list(data['data']) + + +class SpectraHandler(BaseHandler): + """""" + Handler for spectra objects. + """""" + + def flatten(self, sfs: Spectra, data: dict) -> dict: + """""" + Convert Spectra to dict. + + :param sfs: Spectra object + :param data: Dictionary + :return: Simplified dictionary + """""" + return data | dict(data=sfs.to_dict()) + + def restore(self, data: dict) -> Spectra: + """""" + Restore Spectra. + + :param data: Dictionary + :return: Spectra object + """""" + return Spectra.from_dict(data['data']) + + +class DataframeHandler(BaseHandler): + """""" + There were also problems with dataframes, hence the custom handler. + """""" + + def flatten(self, df: pd.DataFrame, data: dict) -> dict: + """""" + Convert dataframe to dict. + + :param df: Dataframe + :param data: Dictionary + :return: Simplified dictionary + """""" + return data | dict(data=df.to_dict()) + + def restore(self, data: dict) -> pd.DataFrame: + """""" + Restore dataframe. + + :param data: Dictionary + :return: Dataframe + """""" + return pd.DataFrame(data['data']) + + +class CustomEncoder(json.JSONEncoder): + """""" + Convert numpy arrays and objects to lists and primitives. + """""" + + def default(self, obj): + """""" + Convert numpy arrays and objects to lists and primitives. + + :param obj: Object + :return: Simplified object + """""" + from scipy.optimize._lbfgsb_py import LbfgsInvHessProduct + + if isinstance(obj, Spectrum): + return obj.to_list() + + if isinstance(obj, Spectra): + return obj.to_dict() + + if isinstance(obj, np.ndarray): + return obj.tolist() + + if isinstance(obj, np.int64): + return int(obj) + + if isinstance(obj, Parametrization): + return type(obj).__name__ + + if isinstance(obj, SharedParams): + return obj.__dict__ + + if isinstance(obj, Covariate): + # Only include 'param' and 'values' to avoid cluttering + # the config file. + return dict(param=obj.param, values=obj.values) + + # there were serialization problems with this object + if isinstance(obj, LbfgsInvHessProduct): + return str(obj) + + return json.JSONEncoder.default(self, obj) +","Python" +"Allele","Sendrowski/fastDFE","docs/conf.py",".py","1971","72","# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +import datetime +import sys + +sys.path.append('..') + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +project = 'fastDFE' +year = datetime.datetime.now().year +copyright = f'{year}, Janek Sendrowski' +author = 'Janek Sendrowski' +release = '1.2.1' + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.viewcode', + 'sphinx_autodoc_typehints', + 'sphinx_copybutton', + 'myst_nb', + 'sphinxcontrib.bibtex', + 'sphinx_book_theme' +] + +bibtex_bibfiles = ['refs.bib'] + +typehints_use_signature = True +typehints_fully_qualified = False + +pygments_style = 'default' + +# disable notebook execution +nb_execution_mode = 'off' + +templates_path = ['_templates'] +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] + +autodoc_default_options = { + 'members': True, + 'inherited-members': True, + 'member-order': 'bysource', + 'special-members': '__init__', + 'undoc-members': True +} + +add_module_names = False + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +html_theme = 'sphinx_book_theme' +html_theme_options = { + 'search_bar_text': 'Search...', + 'repository_url': 'https://github.com/Sendrowski/fastdfe', + 'repository_branch': 'master', + 'use_repository_button': True, + 'use_edit_page_button': False, + 'use_issues_button': False +} +html_static_path = ['_static'] +html_css_files = [""custom.css""] +html_logo = ""logo.png"" +html_favicon = ""favicon.ico"" +","Python" +"Allele","Sendrowski/fastDFE","docs/reference/R/parser.ipynb",".ipynb","66555","297","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""# VCF parsing\n"", + ""## Introduction\n"", + ""fastDFE provides parser utilities that enable convenient parsing of frequency spectra from VCF files. By default, {class}`~fastdfe.parser.Parser` looks at the ``AA`` tag in the VCF file's info field to retrieve the correct polarization. Sites for which this tag is not well-defined are by default included (see {attr}`~fastdfe.parser.Parser.skip_not_polarized`). Note that non-polarized frequency spectra provide little information on the distribution of beneficial mutations, however.\n"", + ""\n"", + ""We might also want to stratify the SFS by some site properties, such as site-degeneracy. This is done by passing stratifications to the parser. In this example, we will stratify the SFS by 0-fold and 4-fold degenerate sites using a VCF file for ``Betula spp.``"" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 7, + ""metadata"": { + ""editable"": true, + ""is_executing"": true, + ""slideshow"": { + ""slide_type"": """" + }, + ""tags"": [] + }, + ""outputs"": [], + ""source"": [ + ""library(fastdfe)\n"", + ""\n"", + ""# load the fastdfe package\n"", + ""fd <- load_fastdfe()\n"", + ""\n"", + ""# url to the GitHub repository of fastDFE\n"", + ""url <- \""https://github.com/Sendrowski/fastDFE/blob/dev/\"""" + ] + }, + { + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ] + }, + ""cell_type"": ""code"", + ""outputs"": [], + ""execution_count"": null, + ""source"": [ + ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", + ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", + ""source(\""R/fastdfe.R\"")\n"", + ""fastdfe <- load_fastdfe()"" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 9, + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2023-10-06T11:49:59.010Z"", + ""start_time"": ""2023-10-06T11:49:58.962952Z"" + } + }, + ""outputs"": [], + ""source"": [ + ""# instantiate parser\n"", + ""p <- fd$Parser(\n"", + "" n = 8,\n"", + "" vcf = paste0(url, \""resources/genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true\""),\n"", + "" fasta = paste0(url, \""resources/genome/betula/genome.subset.1000.fasta.gz?raw=true\""),\n"", + "" gff = paste0(url, \""resources/genome/betula/genome.gff.gz?raw=true\""),\n"", + "" annotations = c(\n"", + "" fd$DegeneracyAnnotation()\n"", + "" ),\n"", + "" stratifications = c(fd$DegeneracyStratification())\n"", + "")\n"", + ""\n"", + ""# parse SFS\n"", + ""spectra <- fd$Parser$parse(p)"" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 10, + ""metadata"": {}, + ""outputs"": [ + { + ""data"": { + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nAAGKwyqM4iKAAAIIIBAJAv8PswT36m3q2ZIAAAAASUVORK5CYII="", + ""text/plain"": [ + ""plot without title"" + ] + }, + ""metadata"": { + ""image/png"": { + ""height"": 192, + ""width"": 276 + } + }, + ""output_type"": ""display_data"" + } + ], + ""source"": [ + ""# visualize SFS\n"", + ""p <- fd$Spectra$plot(spectra)"" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""fastDFE relies here on VCF info tags to determine the degeneracy of a site but this behavior can be customized (cf. {class}`~fastdfe.parser.DegeneracyStratification`)."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""## Stratifications\n"", + ""We can use also several stratifications in tandem by specifying a list of stratifications. In this example, we will stratify the SFS by synonymy as well as base transitions type. The resulting spectra can be fed directly into fastDFE's inference routines. See {mod}`~fastdfe.parser` module for a complete list of available stratifications."" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 11, + ""metadata"": {}, + ""outputs"": [], + ""source"": [ + ""# instantiate parser\n"", + ""p <- fd$Parser(\n"", + "" n = 8,\n"", + "" vcf = paste0(url, \""resources/genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true\""),\n"", + "" fasta = paste0(url, \""resources/genome/betula/genome.subset.1000.fasta.gz?raw=true\""),\n"", + "" gff = paste0(url, \""resources/genome/betula/genome.gff.gz?raw=true\""),\n"", + "" annotations = c(\n"", + "" fd$DegeneracyAnnotation()\n"", + "" ),\n"", + "" stratifications = c(\n"", + "" fd$DegeneracyStratification(),\n"", + "" fd$AncestralBaseStratification()\n"", + "" )\n"", + "")\n"", + ""\n"", + ""# parse SFS\n"", + ""spectra <- fd$Parser$parse(p)"" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 12, + ""metadata"": {}, + ""outputs"": [ + { + ""data"": { + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\n0f8ec4YkQAIkQAIkYDkC/w/Y0iAiaYCkuQAAAABJRU5ErkJggg=="", + ""text/plain"": [ + ""plot without title"" + ] + }, + ""metadata"": { + ""image/png"": { + ""height"": 192, + ""width"": 276 + } + }, + ""output_type"": ""display_data"" + } + ], + ""source"": [ + ""# visualize SFS\n"", + ""p <- fd$Spectra$plot(spectra)"" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""Note that fastDFE requires the ancestral state of sites to be determined. The {class}`~fastdfe.parser.Parser` achieves this by examining the `AA` field, although this behavior can be customized.\n"", + ""\n"", + ""## Annotations\n"", + ""fastDFE provides a number of annotations accessible directly during the parsing process. To annotate a VCF file directly, consider using the {class}`~fastdfe.annotation.Annotator` class.\n"", + ""\n"", + ""### Degeneracy Annotation\n"", + ""{class}`~fastdfe.annotation.DegeneracyAnnotation` annotates the SFS by the degeneracy of the site. This annotation requires information from a FASTA and GFF file and is useful for stratifying the SFS by 0-fold and 4-fold degenerate sites which is what we often want to do when inferring the DFE (see {class}`~fastdfe.parser.DegeneracyStratification`)."" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 14, + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""outputs"": [], + ""source"": [ + ""# example for degeneracy annotation\n"", + ""ann <- fd$Annotator(\n"", + "" vcf = paste0(url, \""resources/genome/betula/biallelic.subset.10000.vcf.gz?raw=true\""),\n"", + "" fasta = paste0(url, \""resources/genome/betula/genome.subset.1000.fasta.gz?raw=true\""),\n"", + "" gff = paste0(url, \""resources/genome/betula/genome.gff.gz?raw=true\""),\n"", + "" annotations = c(fd$DegeneracyAnnotation()),\n"", + "" output = \""genome.deg.vcf.gz\""\n"", + "")\n"", + ""\n"", + ""fd$Annotator$annotate(ann)"" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""### Ancestral Allele Annotation\n"", + ""Currently, two ancestral allele annotations are available: {class}`~fastdfe.annotation.MaximumParsimonyAncestralAnnotation` and {class}`~fastdfe.annotation.MaximumLikelihoodAncestralAnnotation`. The former is straightforward but susceptible to errors, and only appropriate if no outgroup information is available. Alternatively, if outgroups are missing, DFE inference can also be performed on folded spectra, but please note that this will yield less precise estimates. Ideally, we would like to use {class}`~fastdfe.annotation.MaximumLikelihoodAncestralAnnotation`, which is more sophisticated and requires one or several outgroup to be specified. Its underlying model is very similar to [EST-SFS](https://doi.org/10.1534/genetics.118.301120)."" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": null, + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""outputs"": [], + ""source"": [ + ""# example for ancestral allele annotation with outgroups\n"", + ""ann <- fd$Annotator(\n"", + "" vcf = paste0(url, \""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz?raw=true\""),\n"", + "" annotations = c(fd$MaximumLikelihoodAncestralAnnotation(\n"", + "" outgroups = list(\""ERR2103730\""),\n"", + "" n_ingroups = 10\n"", + "" )),\n"", + "" output = \""genome.aa.vcf.gz\""\n"", + "")\n"", + ""\n"", + ""fd$Annotator$annotate(ann)"" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""## Filtrations\n"", + ""fastDFE also offers a number of filtrations which can be accessed immediately while parsing. Alternatively, to filter a VCF file directly, use the {class}`~fastdfe.filtration.Filterer` class. Some useful filtrations include {class}`~fastdfe.filtration.DeviantOutgroupFiltration`, {class}`~fastdfe.filtration.CodingSequenceFiltration`, and {class}`~fastdfe.filtration.BiasedGCConversionFiltration`. For a complete list of available filtrations, refer to the API reference."" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": null, + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""outputs"": [], + ""source"": [ + ""# example for filtration\n"", + ""f <- fd$Filterer(\n"", + "" vcf = paste0(url, \""resources/genome/betula/biallelic.subset.10000.vcf.gz?raw=true\""),\n"", + "" filtrations = c(fd$BiasedGCConversionFiltration()),\n"", + "" output = \""genome.gc.vcf.gz\""\n"", + "")\n"", + ""\n"", + ""fd$Filterer$filter(f)"" + ] + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""R"", + ""language"": ""R"", + ""name"": ""ir"" + }, + ""language_info"": { + ""codemirror_mode"": ""r"", + ""file_extension"": "".r"", + ""mimetype"": ""text/x-r-source"", + ""name"": ""R"", + ""pygments_lexer"": ""r"", + ""version"": ""4.5.2"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 4 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/R/inference.ipynb",".ipynb","547393","1124","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""# DFE inference\n"", + ""## Estimating the deleterious DFE\n"", + ""A short overview of basic DFE inference and bootstrapping is available in the {doc}`quickstart guide <../R/quickstart>`. DFE inference requires one `neutral` and one `selected` SFS. In this example we use the bundled `Betula pendula` (silver birch) data. By default, bootstrapping is performed automatically, and the inference estimates only the deleterious component of the DFE using {class}`~fastdfe.parametrization.GammaExpParametrization`."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true + }, + ""source"": [ + ""library(fastdfe)\n"", + ""\n"", + ""# load the fastdfe package\n"", + ""fd <- load_fastdfe()"" + ], + ""outputs"": [], + ""execution_count"": null + }, + { + ""metadata"": { + ""is_executing"": true, + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:39:30.125230Z"", + ""start_time"": ""2026-01-04T10:39:02.664983Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", + ""\n"", + ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", + ""reticulate::py_run_string(\""import numpy as np; np.set_printoptions(legacy='1.25')\"")\n"", + ""\n"", + ""source(\""R/fastdfe.R\"")\n"", + ""fd <- load_fastdfe()\n"", + ""\n"", + ""fd$Settings$parallelize <- FALSE"" + ], + ""outputs"": [], + ""execution_count"": 1 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:39:37.871381Z"", + ""start_time"": ""2026-01-04T10:39:30.133080Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""sfs_neut <- fd$Spectrum(c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0))\n"", + ""sfs_sel <- fd$Spectrum(c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0))\n"", + ""\n"", + ""# create inference object\n"", + ""inf <- fd$BaseInference(\n"", + "" sfs_neut = sfs_neut,\n"", + "" sfs_sel = sfs_sel\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""sfs_modelled <- inf$run()\n"", + ""\n"", + ""p <- inf$plot_discretized();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nAAEEEEAgWQL/D0LVEmI87kN7AAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 2 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""It is always good practice to check the variability of estimates across optimization runs to ensure stability. Here, both the standard deviations across initial runs and across runs within each bootstrap sample are low, indicating stable estimates. Individual runs and bootstrap results can be inspected in the corresponding dataframes (cf. {attr}`~fastdfe.base_inference.BaseInference.runs` and {attr}`~fastdfe.base_inference.BaseInference.bootstraps`)."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:39:37.896717Z"", + ""start_time"": ""2026-01-04T10:39:37.883877Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf$runs[sapply(inf$runs, is.numeric)]"", + ""outputs"": [ + { + ""data"": { + ""text/html"": [ + ""\n"", + ""\n"", + ""\n"", + ""\t\n"", + ""\t\n"", + ""\n"", + ""\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\n"", + ""
A data.frame: 10 × 7
all.S_dall.ball.p_ball.S_ball.epsall.hlikelihood
<dbl><dbl><dbl><dbl><dbl><dbl><dbl>
-33894.990.13054400100.5-35.43797
-33893.680.13054460100.5-35.43797
-33888.720.13054670100.5-35.43797
-33894.100.13054440100.5-35.43797
-33893.740.13054450100.5-35.43797
-33898.590.13054250100.5-35.43797
-33894.180.13054430100.5-35.43797
-33890.690.13054580100.5-35.43797
-33891.090.13054560100.5-35.43797
-33893.180.13054480100.5-35.43797
\n"" + ], + ""text/markdown"": ""\nA data.frame: 10 × 7\n\n| all.S_d <dbl> | all.b <dbl> | all.p_b <dbl> | all.S_b <dbl> | all.eps <dbl> | all.h <dbl> | likelihood <dbl> |\n|---|---|---|---|---|---|---|\n| -33894.99 | 0.1305440 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33893.68 | 0.1305446 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33888.72 | 0.1305467 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33894.10 | 0.1305444 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33893.74 | 0.1305445 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33898.59 | 0.1305425 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33894.18 | 0.1305443 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33890.69 | 0.1305458 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33891.09 | 0.1305456 | 0 | 1 | 0 | 0.5 | -35.43797 |\n| -33893.18 | 0.1305448 | 0 | 1 | 0 | 0.5 | -35.43797 |\n\n"", + ""text/latex"": ""A data.frame: 10 × 7\n\\begin{tabular}{lllllll}\n all.S\\_d & all.b & all.p\\_b & all.S\\_b & all.eps & all.h & likelihood\\\\\n & & & & & & \\\\\n\\hline\n\t -33894.99 & 0.1305440 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33893.68 & 0.1305446 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33888.72 & 0.1305467 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33894.10 & 0.1305444 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33893.74 & 0.1305445 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33898.59 & 0.1305425 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33894.18 & 0.1305443 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33890.69 & 0.1305458 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33891.09 & 0.1305456 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\t -33893.18 & 0.1305448 & 0 & 1 & 0 & 0.5 & -35.43797\\\\\n\\end{tabular}\n"", + ""text/plain"": [ + "" all.S_d all.b all.p_b all.S_b all.eps all.h likelihood\n"", + ""1 -33894.99 0.1305440 0 1 0 0.5 -35.43797 \n"", + ""2 -33893.68 0.1305446 0 1 0 0.5 -35.43797 \n"", + ""3 -33888.72 0.1305467 0 1 0 0.5 -35.43797 \n"", + ""4 -33894.10 0.1305444 0 1 0 0.5 -35.43797 \n"", + ""5 -33893.74 0.1305445 0 1 0 0.5 -35.43797 \n"", + ""6 -33898.59 0.1305425 0 1 0 0.5 -35.43797 \n"", + ""7 -33894.18 0.1305443 0 1 0 0.5 -35.43797 \n"", + ""8 -33890.69 0.1305458 0 1 0 0.5 -35.43797 \n"", + ""9 -33891.09 0.1305456 0 1 0 0.5 -35.43797 \n"", + ""10 -33893.18 0.1305448 0 1 0 0.5 -35.43797 "" + ] + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 3 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:39:37.919246Z"", + ""start_time"": ""2026-01-04T10:39:37.903943Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""head(inf$bootstraps[sapply(inf$bootstraps, is.numeric)], 10)"", + ""outputs"": [ + { + ""data"": { + ""text/html"": [ + ""\n"", + ""\n"", + ""\n"", + ""\t\n"", + ""\t\n"", + ""\n"", + ""\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\t\n"", + ""\n"", + ""
A data.frame: 10 × 10
S_dbp_bS_bepshlikelihoodi_best_runlikelihoods_stdalpha
<dbl><dbl><dbl><dbl><dbl><dbl><dbl><dbl><dbl><dbl>
1-100000.0000.11527110100.5-48.6667203.088417e-090
2 -23100.3290.13276660100.5-39.4543904.049241e-100
3 -30897.0310.12652500100.5-44.1165212.611387e-100
4-100000.0000.11704110100.5-40.3326602.842171e-140
5 -27266.6300.13477010100.5-38.6424811.068940e-090
6-100000.0000.11505900100.5-36.2592912.541285e-010
7 -16452.7280.14202350100.5-40.4435513.198863e-100
8 -5995.2900.16447350100.5-43.4620408.127756e-100
9 -2350.2280.18794340100.5-38.7119808.384404e-120
10 -18057.9370.14526310100.5-39.2188801.087983e-100
\n"" + ], + ""text/markdown"": ""\nA data.frame: 10 × 10\n\n| | S_d <dbl> | b <dbl> | p_b <dbl> | S_b <dbl> | eps <dbl> | h <dbl> | likelihood <dbl> | i_best_run <dbl> | likelihoods_std <dbl> | alpha <dbl> |\n|---|---|---|---|---|---|---|---|---|---|---|\n| 1 | -100000.000 | 0.1152711 | 0 | 1 | 0 | 0.5 | -48.66672 | 0 | 3.088417e-09 | 0 |\n| 2 | -23100.329 | 0.1327666 | 0 | 1 | 0 | 0.5 | -39.45439 | 0 | 4.049241e-10 | 0 |\n| 3 | -30897.031 | 0.1265250 | 0 | 1 | 0 | 0.5 | -44.11652 | 1 | 2.611387e-10 | 0 |\n| 4 | -100000.000 | 0.1170411 | 0 | 1 | 0 | 0.5 | -40.33266 | 0 | 2.842171e-14 | 0 |\n| 5 | -27266.630 | 0.1347701 | 0 | 1 | 0 | 0.5 | -38.64248 | 1 | 1.068940e-09 | 0 |\n| 6 | -100000.000 | 0.1150590 | 0 | 1 | 0 | 0.5 | -36.25929 | 1 | 2.541285e-01 | 0 |\n| 7 | -16452.728 | 0.1420235 | 0 | 1 | 0 | 0.5 | -40.44355 | 1 | 3.198863e-10 | 0 |\n| 8 | -5995.290 | 0.1644735 | 0 | 1 | 0 | 0.5 | -43.46204 | 0 | 8.127756e-10 | 0 |\n| 9 | -2350.228 | 0.1879434 | 0 | 1 | 0 | 0.5 | -38.71198 | 0 | 8.384404e-12 | 0 |\n| 10 | -18057.937 | 0.1452631 | 0 | 1 | 0 | 0.5 | -39.21888 | 0 | 1.087983e-10 | 0 |\n\n"", + ""text/latex"": ""A data.frame: 10 × 10\n\\begin{tabular}{r|llllllllll}\n & S\\_d & b & p\\_b & S\\_b & eps & h & likelihood & i\\_best\\_run & likelihoods\\_std & alpha\\\\\n & & & & & & & & & & \\\\\n\\hline\n\t1 & -100000.000 & 0.1152711 & 0 & 1 & 0 & 0.5 & -48.66672 & 0 & 3.088417e-09 & 0\\\\\n\t2 & -23100.329 & 0.1327666 & 0 & 1 & 0 & 0.5 & -39.45439 & 0 & 4.049241e-10 & 0\\\\\n\t3 & -30897.031 & 0.1265250 & 0 & 1 & 0 & 0.5 & -44.11652 & 1 & 2.611387e-10 & 0\\\\\n\t4 & -100000.000 & 0.1170411 & 0 & 1 & 0 & 0.5 & -40.33266 & 0 & 2.842171e-14 & 0\\\\\n\t5 & -27266.630 & 0.1347701 & 0 & 1 & 0 & 0.5 & -38.64248 & 1 & 1.068940e-09 & 0\\\\\n\t6 & -100000.000 & 0.1150590 & 0 & 1 & 0 & 0.5 & -36.25929 & 1 & 2.541285e-01 & 0\\\\\n\t7 & -16452.728 & 0.1420235 & 0 & 1 & 0 & 0.5 & -40.44355 & 1 & 3.198863e-10 & 0\\\\\n\t8 & -5995.290 & 0.1644735 & 0 & 1 & 0 & 0.5 & -43.46204 & 0 & 8.127756e-10 & 0\\\\\n\t9 & -2350.228 & 0.1879434 & 0 & 1 & 0 & 0.5 & -38.71198 & 0 & 8.384404e-12 & 0\\\\\n\t10 & -18057.937 & 0.1452631 & 0 & 1 & 0 & 0.5 & -39.21888 & 0 & 1.087983e-10 & 0\\\\\n\\end{tabular}\n"", + ""text/plain"": [ + "" S_d b p_b S_b eps h likelihood i_best_run likelihoods_std\n"", + ""1 -100000.000 0.1152711 0 1 0 0.5 -48.66672 0 3.088417e-09 \n"", + ""2 -23100.329 0.1327666 0 1 0 0.5 -39.45439 0 4.049241e-10 \n"", + ""3 -30897.031 0.1265250 0 1 0 0.5 -44.11652 1 2.611387e-10 \n"", + ""4 -100000.000 0.1170411 0 1 0 0.5 -40.33266 0 2.842171e-14 \n"", + ""5 -27266.630 0.1347701 0 1 0 0.5 -38.64248 1 1.068940e-09 \n"", + ""6 -100000.000 0.1150590 0 1 0 0.5 -36.25929 1 2.541285e-01 \n"", + ""7 -16452.728 0.1420235 0 1 0 0.5 -40.44355 1 3.198863e-10 \n"", + ""8 -5995.290 0.1644735 0 1 0 0.5 -43.46204 0 8.127756e-10 \n"", + ""9 -2350.228 0.1879434 0 1 0 0.5 -38.71198 0 8.384404e-12 \n"", + ""10 -18057.937 0.1452631 0 1 0 0.5 -39.21888 0 1.087983e-10 \n"", + "" alpha\n"", + ""1 0 \n"", + ""2 0 \n"", + ""3 0 \n"", + ""4 0 \n"", + ""5 0 \n"", + ""6 0 \n"", + ""7 0 \n"", + ""8 0 \n"", + ""9 0 \n"", + ""10 0 "" + ] + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 4 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We can also plot the parameter distributions across bootstrap samples to visualize uncertainty. We see that the mean strength of deleterious selection `S_d` often reaches the lower bounds of `-1e5`. Perhaps a different DFE parameterization or a more complex DFE model would be more appropriate here. It should also be noted that the spectra used in this example are far from exemplary, as they contain few SNPs and have a small sample size."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:39:38.109436Z"", + ""start_time"": ""2026-01-04T10:39:37.927917Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""hist(inf$bootstraps$S_d); hist(inf$bootstraps$b)"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""Plot with title “Histogram of inf$bootstraps$S_d”"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl\nR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRB\nkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4\na73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PC\nv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UA\nVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXd\na8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8\nHOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojL\njVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0\nyDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5Pt\nXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEw\nQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXH\nliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vW\nc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUt\nVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJf\ncl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdd\nuwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqv\ngcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCg\nKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8A\nrD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvF\nY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAAIooAMA\nBAAAAAEAAAGAAAAAANfxKOcAAEAASURBVHgB7Z0HnBRF9scfAqKggIAoRkBPARVzzmLABCpG\nMIfTM2c9RTGc3JmVM2LWMx/mOxURFXP2MJwRFcWEgGIGtP/1q/vX2DM7s9szOzPbu/N9n89u\nT3dXV1V/q7r7ddV7r1tFTgyBAAQgAAEIQAACKSIwV4rqQlUgAAEIQAACEICAJ4CCQkeAAAQg\nAAEIQCB1BFBQUtckVAgCEIAABCAAARQU+gAEIAABCEAAAqkjgIKSuiahQhCAAAQgAAEIoKDQ\nByAAAQhAAAIQSB0BFJTUNQkVggAEIAABCEAABYU+AAEIQAACEIBA6gigoKSuSagQBCAAAQhA\nAAIoKPQBCEAAAhCAAARSRwAFJXVNQoUgAAEIQAACEEBBoQ9AAAIQgAAEIJA6AigoqWsSKgQB\nCEAAAhCAAAoKfQACEIAABCAAgdQRQEFJXZNQIQhAAAIQgAAEUFDoAxCAAAQgAAEIpI4ACkrq\nmoQKQQACEIAABCCAgkIfgAAEIAABCEAgdQRQUFLXJFQIAhCAAAQgAAEUFPoABCAAAQhAAAKp\nI4CCkromoUIQgAAEIAABCKCg0AcgAAEIQAACEEgdARSU1DUJFYIABCAAAQhAAAWFPgABCEAA\nAhCAQOoIoKCkrkmoEAQgAAEIQAACKCj0AQhAAAIQgAAEUkcABSV1TUKFIAABCEAAAhBAQaEP\nQAACEIAABCCQOgIoKKlrEioEAQhAAAIQgAAKCn0AAhCAAAQgAIHUEUBBSV2TUCEIQAACEIAA\nBFBQ6AMQgAAEIAABCKSOAApK6pqECkEAAhCAAAQggIJCH4AABCAAAQhAIHUEUFBS1yRUCAIQ\ngAAEIAABFBT6AAQgAAEIQAACqSOAgpK6JqFCEIAABCAAAQigoNAHIAABCEAAAhBIHQEUlNQ1\nCRWCAAQKERg1apSdfPLJhXazHQJGH2k5naBV5KTlnE7tncmkSZPs+++/9yc+//zzW69evfJC\nmDp1qn3++ed+X6tWrWyFFVbIpPvggw/shx9+8OsLLbSQ6Q9p2QS+/fZbe+GFF+ztt9+2JZZY\nwpZddln7wx/+YK1bt8574upj6mtB+vfvH36WZdlQfX799Vd75ZVXbNiwYfbZZ5/Z/fffb2uv\nvbbNM888dcp/6623bM6cOX774osvbgsssECdNGxoeQSK6SO5Zz99+nSbOHGivfnmm9a+fXvr\n2bOnLbPMMrbooovmJq3o+uTJk+2bb77xZajfqv/WtEhBQZovgU022UQKpv/bfPPNC57IyJEj\nM+nmmmuurHTuRp/ZN3z48Kx9jVl54403oosuuqgxWXBsBQjcddddUZs2bTJtHvrPl19+WbC0\nhx9+OCu9UwAKpi12R0P1eeSRR6JFFlkkq3zVuXPnztG1115bp7gFF1wwk/b666+vsz+tGypx\nvcyaNSu64IILovfeey+tp12WehXbR0KhL730UuQU80x/CdeClrpPOoU4ev/990Pyii933XXX\nTF322GOPipeX9gKY4nE9ESkvgRkzZtjhhx9uK620kj3xxBPlzZzcGkXg66+/tl122SUzwhAy\ncwqAde/ePaxWbdlQfdR/nOLtR01yK6U3zX333dePBOXua07rlbpeHnroIdNI19FHH20//vhj\nc0JSVF1L7SO33Xabrb/++uaUt7zl/fbbb3bzzTfbGmusYRrZQKpPAAWl+sxTV6IeTr179/Z/\n5RgOP+aYY+zvf/97nYdg6k68Biv0zjvv2OzZszNnft1119mUKVNs/PjxmW35fsw777yZPqK+\nUi5pqD6HHnqoubc8X9z222/vpyY7duxo7u0yU4XTTjst87s5/qjE9aIH6pZbbumn8Jojk2Lq\nXEof0TVw0EEH2U8//eSL0rTOFltsYWeddZYdcMABWVPlmv6J97di6kbaxhFo07jDObolEPjn\nP/9Z1tMIDxRlKnsXJD0E4nYkslnac889zQ1lN1hBvWnKVqncUl99NLLgpj18kV26dLE77rjD\nNtpoI3PTUybF6vHHH7dffvnFlO6LL76whRdeuNzVq0p+lbhe4nnqJFrqdVhqH5kwYYLJ7knS\ntm1b38/i9nvit/LKK9t//vMfn0bpp02bZl27dvXr/KsOARSU6nBOdSka6pThoWSttdayddZZ\nJ6u+3333nd1www2mt91PPvnEGybqYaCHxTbbbOMfGDpAF/w111zjDc1CBho+dXPgpjfwP/3p\nT2GzX2oI1c0d24MPPuiHUDV6oyHpDTfc0E8PZSXOWXn99de9oaRuIEsuuaQ/ZuuttzY3p2y6\nmUiWW245/1ak30r36KOP6qf17dvXp7/88st9ehlbDho0yBvGab+M7WSEqQeguPz888/e0FKG\nxTvvvLM3KlU6ic7B2dn8b8X9P+qoo0zTFvfcc4899dRTJiVgvfXWsx133NFz0o3vgQcesMce\ne8yczYetu+66NnDgQD86kckk4Y9i+OkBfsstt9jzzz+flXuou962xaWQfPzxxzZmzJjMbp1n\neOhpGFznItlpp51sscUW822q81f7qx3UT1ZbbbXM8UnqE3/I9ujRI9PPlImMeaXcSFlpSGQA\nrnN/9tln/WjMKqus4qe56pvSKoZtbvnqMypPytXMmTOtT58+vl+rj+lNPUgx10vSa1B5a2rn\n6aefDsX45Y033mhi6GzW/LVVqetBhekeEB7+u+++u80333zmbJj8KJ22a8pE04zOViirjmGl\nmHMNhv86tpg+EhQPHSdDa2fPpJ8ZUd8+44wz7Nhjj7UOHTr4P10D5VJQVL7uA1rqetl4441t\n2223zZTPj/8n4G4CSDMmUGkj2X/961+Re3vNGG65bpP12z10IhniSdwbdta+eFrlERd3o4rW\nXHPNvOllnHbkkUdGbt48fkjm9/nnnx+5t546x+61115R3Bh47733zhxz6aWXZtLvtttukbsh\nZNZVT+ea6NM6b6fIKUlZ++Ln4ZSoyM15Z/LVucf3v/jii5G74WRt036n2ETuxuuX8fT6LWNP\n5z2QyTPJj2L5Pffcc3XqFK/HTTfdVG+x9RnJrrrqqpm83U032mGHHTLroQynUETnnXdepowk\n9VH7uwdFJq9//OMfkVPofH/MZJTnR9xI9qSTToqWX375TB6hPk7BjmRYmU+KZRvPQ3XUuYZy\n4ksZYz755JOZ5Emvl2KuQWUu48p4ufHfoZ9X6npQ+W4kIlP+2LFjo9VXXz2zHuoio2f3IqHk\nWVLsuZbaR8aNG5dVJ9Xx7rvvjpwym1Wfcq84xTf629/+ltdIXfclp8hn6oWRrHubK3cDkF91\nCcQVFPemFl1yySV5/9zbW6bjJ/XicW8nUadOnTLH6aay1VZbRW7o01u4h5vNn//8Z3/SSW+4\nelDHPYeUj+oU8gtLKRG6oONy5513ZqWTN4pzkY3cW5Df7kYsMvsLKShuNCeTRmXpgRI8WNxo\nRtY+5+bnrfzjD0r3RhW5uWtfrVwFJeQtJUXpwrloKeVGy7nnnjuKP0S1zbk1Rm7kJn6qBX+X\nwi+JQlCwQLcjqYISzkvtkauoqa0++ugjX0zS+uS2R7t27SJngxJJiSgkoQ5x9t26dYucO3VW\ne7jRjOjTTz/NyqYUtiGD22+/vY5yktuvte5G8vwhSa6XYq9BZVysghL6bODVmOtB5ccVFDfi\n4Jmr7ePXpsrS9eFGm3SIl1LOVQeW0kek2Oi+Ec45LNW/5A2pl6BiXxr+dxb1/7/11luzyhRr\n586cuX+FemiJgoKCUn9vagZ74wpKvHPX9zupguKG7jMX06abbppFww0j+30uTkDkhib9A8PZ\nA0QulkAUV4YGDBjgt8UvdjcVk8nXDf9Gzp7Ajy589dVX0Yknnpj11uymYTLlKn9noJk5ViMd\nbsrJ79eDZbvttsvs0/lrRCVI/I1R+/TA0jaVHVyrnWFh5iYqhUTnGMRN2WTl7aYL/K5cBUUj\nO3o7k7jh/aybtcoVR+d9ErlpI3+u8XaSm2kSKYWfFCq5mjojwMx56EGubfpTXeuTpAqKzue4\n446LXNwUn50b7s+Up32jR4/225PWR0ziSnLgpYeq3jg1YpUruQrKhRdemEmiNpViEvKJK7FK\nVApbHffMM89kvRU7g8vITYn60UWNFMRdWdWH9aae5Hop9hpUXdSP3bRp5hx1rs7OzF+HbvpR\nSXzfDwy0LNf1oLzjCoryPuyww/xoqF429IIRV4j2339/HeKllHPVgaX0ER2ne1W+vhXnopGV\ncD3rmMaI2jvOxk19ZhR2XS/x+6bq4KbHGlNciziWEZRm3oyVVFDiDxcpEqeffnrk5kwzoxp6\n0OYT3fTDRa7h/rjoph32aRlXQEI6PXhCGjevHDZHuW/duUPEzogto2Do+PoUFCkn+UQ3UcU9\nyM1bCkX8waahaEmuguJcOrOyPeSQQzLnIqUnKFRK5LxnMvtUX2eXknVsvpXG8FN+V199dabM\nONt8ZcW3JVVQNLqWOxKkUajQnlKQ4pKkPi7wWrTiiitm8gh5aSmF8OKLL45nmTU6pesjV5z9\nTCYvPaCCNIbt0KFDM3k6myivgIZ8tdQ5xKd+rrzyyszu+q6XUq9BjVTFOelhHJdchb1c14PK\niD+E9RKROwp6/PHHZ+qmUZQgpZ6rji+2j4QyNWqzzz771BntjLNTH9PIR2Ml9/4VnypW3s4u\nK2skBQUliho233cthTQPAksttZSdeeaZef/cm3vRJyFj1WCEqEiiI0aMMPeg8PEy3A3Z3EPa\nGwEWk7EMT4O4G7aPYxHWw1JufkHcDcQUBVcS9/hwQ7He+DSk01KeHu6NJ76p4G8Zu+YTp0SY\nOMpY2N1QzL19mwue5CNKumHhzCHubSjzO/4jt3z3AMzsVsRWGcQFUX3jUijPeJrG8IvnU6nf\nMjh2I3RZ2ct4MUiIkhnWkyxlvPvaa6/5mDq5kTXlLiqDXe3PJ5tttlmdzXInDeKmirx3htYb\nw1ZGz0HkGaX+GRedgwyig8SNNMO2fMtKXIP5yqnU9SDDT11TcXEjnZlVGTDrGpc05lxL7SMy\n9nfB/vw9xgUMNDeiU8dgXX1MEYwL9bHMyTTwI37/kmGuPOPiogjeur8ivxPIvpP8vp1fzZCA\nHqxuuiLvn3uTLPqMlJ97w60T/lxeKu6Nwl+0SqMLPKm4Of9MUoWRdvYYmfXwIzfOhkKXS9xb\noV/qnxvGr3Pj0/b4w1Dr+USeFG5IO98u/9kA3aSkPOhhqyBXzrYg8xALB+U+hMP2uEKibe7t\nK+yq4ymQ79wziQv8aAy/AlmWdXOuN4Qy1824HLLBBht4DyqV4abmMp9kcG/o3nMkXxl6AOWK\n4v7ERd4ZklLZyutLXklB3AhC+Jm1jPfr0KezEuRZqcQ1mFtMJa+HXNYqO66ka/3DDz/Uwr8Y\nNPZ+U0ofUdlu2skUZ+eqq67y7vT//e9/vUea9knUx5zB7/9WSvwfv3+pX+Yqbso2H68Si2sR\nh6GgtIhmrNxJuGkSf8E62xDvLplbkpQVPdDjb5C5aeLr8QeYsxuJ78r81lttXIIyEX/4q9x8\nEkZb8u0L23RDzidyCdVbnBtq9oqK3CPdFJUPOie3ZilFQQopKHGFRGnjN6FSFJJQXlg2hl/I\no5LL3JEDlVWIVdJ6aPQu3leUn5sWMWfImMni3XffzfyO/8g3YhMfCVPa0L9KZauRQPWVIPG6\nhm1axvt1KDO+v9Dvcl+DueVU8nrId52qPeMSDw5Z6rkW00cUNkAjwHLtlQu4XrZyRdsVd0ex\nUILER9jCtmKW8fPUvSafaEQJ+Z0ACsrvLPhVgIDijCjCot4qFHXUuVL6B7duzBI3fWoaHs0n\nevOIi/NWyawqyJLzZMishx+KZRJED3V9tEsSP1Y3mdwhV92kXn755XBowWW+h6gSa8pKH6ST\n6I1KHw5T7A9FqnSuqlkPmHDuPnEV/8UZFMuvGtWMK2SNLe8vf/mLSSlVLJn4tF/INx63RWny\nyauvvlpnc1yZUf8Kb/SNYRs/1hnu1ilToyzxusQ/1hlPnHu9hH2NuQaVR6F8ta+S10O+qSzF\nxgkiZTM+sqTtxZxrKX1EI3q6d0jhcHZHfjQu1Cd3qajFQQopnmF/Q0uNhgUJwQXDupZqI328\nE/mdAArK7yz4lUPglFNO8fPmetvT8KdEQ5Caj9WD23noZI6Ih08Pdiva6YxIM2n0Q/P/zjAu\ns01hvuPHagREN50gsp0JoxIKeBa/YWj6JbyNKQ99/0fRHhuSeP3iaePBrRQwTjYjQWSPEj+X\n8LXcsL9ay8bwq1Ydy1WO2iC8aaq/6evLcZGiHEQKZD5RlGSNfgVRu7lYIGHVz/mHEZ7GsNVI\nWxC9kSsoXFwUEC8M8UuJi9vBxPtjvI/p+HJcg8onN19tCxIvP2zTshzXw7333pv1IqGHsDNq\nzhQjJTMoSKWca6l9RN93CqJgkS5UQiZYpbbrpeuKK67I+paYAvw1RqSUhnuZ8j/33HOzsnNe\nTHzzJ4uIW3GgkGZMIO7FU+6vGZ999tkZa3t1FXmoyPLcRSONzjnnHB/PQ9v15yJnZijGvSTc\n8HGkYFlxn359XTUcp6W78CNn3OvdbuW2HPbJwt/NT2fy1Y+4B4DSubncyEVBjeKeIuH4Ql48\n7m03K8+wEg/ypjzknuoM2yI3Lx25t7pMvbRPLpESd+PP2p4b/Mt9JyazXy6LcZG3S6irlnG3\n5ni63N+N4ZfEaya3PK0n9eJx0TfrHO4iDmfOUy7IcamvPopVEfcIUV+SC7GWcXdgxdeQR1SQ\nXDdjp2BH7uHnXZydkpupi5grsFxcSmUrDwzFswjt6R660YEHHuivk1z394MPPjheZFTf9VLq\nNag4MaEuWsrd370MeDdfFR734inn9aC8422mshW35tRTT43kuRS/X2mf3J+DlHKupfYRxb9R\nv4gzcopj5IzjfbiCpZdeOmuf2tONvIWqlrx0L1FZ+errxfJe0r3VKYpZ+/DicVpcyaQ5MBUE\n4hd8uRUUxapwb3pZF038gg6/Bw8enOVKqIiMYV98qZtmEPcxwax4J/F0+i3lxIXgD8kzS8US\ncGHj8+avgE1SVkJezk4hc1ySG7IzliwYF8G9ZUdu9CiTt5QuSVMoKCq3VH71KQTKt5A0hYKi\nukgh1sMhtGnu0k3RRC6Me1a14wqK+9pxwWOHDBmSdVxYKZWtlJR8UWvjdVbwwdyYM/VdL6Ve\ngzqXfK7ZUoYklboelHdcQXGjBgX5K35SXEo911L6iMrVC0F9fSu0m16C5CJcDnE2OVmxnEIZ\nWkqRi9/bUFBwM3b9AilEQHO1GqL961//6t1sc9PJaFSGivqWT9z2wL3dmostkJVc00T6KmgQ\n2XXoOH0DJm786m4YfvjbxW3w3+sI6cNSNgPyqnEjOP67IjJslEuwG6mw++67L2v6SHYkxYim\ndGSHErdt0PH6lowLUZ419aQ6NKWUyq8p61xK2fLKkE2HpvfifUxD5U45999dcqNzBbN2iqRd\nf/31Wf1XU4wupo83gsx3YKls5SYquwZ9c6pfv35Z9ZXHmqaW9D2oXHuZ+q6XUq9BnZeLKp3l\n1aapnPpsUXJZlON6cKNIpmm2+DdsxF/TOfpeVVxKPddS+4im2WSPpHuV7jtxUV+TLYymttX/\n3Gc54rtL/i0OspNzynEmhIPKknux7jFutDGTd7y/ZzbW2I9W0gpr7Jw53RII6MameAX6WKDE\nDQt7N8/6LiLZg8joSxd6METMV7Tylp2AbqAu/HTmws1NG9w55Uoc7AZy08guZvz48X7zCSec\nYO67F7lJGlxXfeR6KoNgWfNLuUqzJOWX5nNIUjd5hMjzwkVK9X9xxTbJ8TLOdG/pXuFMauTc\nGLZSyNX/ZeSdpA81dL2oLsVeg7K5kSGojMqlaEsJKFaKvR5k9Bpch6UkuWCFGqn39VCsH9kL\nNcS/lHPVeZXaR1SernfVW4ykYMY9s4plliS9vMl03xMvvewhdQmgoNRlwpaUEtAFLSNZKScK\n2KU4JXFDSRnY6sYSXBv1Bdf63q5TeppUqx4CGkmRN1kSY+h6smFXBQnkU1AqWFydrOkjdZA0\n2w1tmm3NqXjNEVC8BsUlkBuyojLqT2+UGn6Vh4SGSINy0r17d9Pn7ZGWRcAZ2Vq+2CYt6yw5\nm8YQqGQfcd8Ls/vvv7/o6inCtDyOkOIIoKAUx4vUTUxAkR4VMlyjKRJN54QpnVA1TRXJrbPY\nKYBwPMv0EnAG2emtHDVLBYFK9hG9FCkwZbHiPJRQUIqF5tKjoJQAjUOajsBKK63k57IVS8FZ\n4fvYBZrr13yx7GJkbCYDPNmyIBCAQPUJ6AUiBCWrz/as+jVrfImaYpYdVLESj6lU7LG1nB4b\nlFpu/RZy7grSFgIgtZBT4jQgAAEI1DwBFJSa7wIAgAAEIAABCKSPAKHu09cm1AgCEIAABCBQ\n8wRQUGq+CwAAAhCAAAQgkD4CKCjpaxNqBAEIQAACEKh5AigoNd8FAAABCEAAAhBIHwEUlPS1\nCTWCAAQgAAEI1DwBFJSa7wIAgAAEIAABCKSPAApK+tqEGkEAAhCAAARqngAKSs13AQBAAAIQ\ngAAE0kcABSV9bUKNIAABCEAAAjVPAAWl5rsAACAAAQhAAALpI4CCkr42oUYQgAAEIACBmieA\nglLzXQAAEIAABCAAgfQRQEFJX5tQIwhAAAIQgEDNE0BBqfkuAAAIQAACEIBA+gigoKSvTagR\nBCAAAQhAoOYJoKDUfBcAAAQgAAEIQCB9BFBQ0tcm1AgCEIAABCBQ8wRQUGq+CwAAAhCAAAQg\nkD4CKCjpaxNqBAEIQAACEKh5AigoNd8FAAABCEAAAhBIHwEUlPS1CTWCAAQgAAEI1DwBFJSa\n7wIAgAAEIAABCKSPAApK+tqEGkEAAhCAAARqngAKSs13AQBAAAIQgAAE0kcABSV9bUKNIAAB\nCEAAAjVPAAWl5rsAACAAAQhAAALpI4CCkr42oUYQgAAEIACBmieAglLzXQAAEIAABCAAgfQR\nQEFJX5tQIwhAAAIQgEDNE0BBqfkuAAAIQAACEIBA+gigoKSvTagRBCAAAQhAoOYJoKDUfBcA\nAAQgAAEIQCB9BFBQ0tcm1AgCEIAABCBQ8wRQUGq+CwAAAhCAAAQgkD4CKCjpaxNqBAEIQAAC\nEKh5AigoNd8FAAABCEAAAhBIHwEUlPS1CTWCAAQgAAEI1DwBFJSa7wIAgAAEIAABCKSPQJv0\nVall1Ojtt9+2WbNmJT6ZX375xVZfffXE6eMJ33rrLZszZ058U5P/btOmjfXr16/J60EFIAAB\nCECgeRJoFTlpnlVPb63ff/99W2aZZaxYtFIyWrduXdSJPfroo7bpppsWdUy1Eo8bN84GDBhQ\nreIoBwIQgAAEWhABRlAq0JhLL720ffvtt4lHNV544QUbOHCg/frrr0UrKBp5adeunT3wwAMV\nOJPSs9xmm21MdUMgAAEIQAACpRBAQSmFWoJj5p9//gSp/pekY8eOidPmS9iqVStrbB758m3M\nNtUJgQAEIAABCJRKACPZUslxHAQgAAEIQAACFSOAglIxtGQMAQhAAAIQgECpBFBQSiXHcRCA\nAAQgAAEIVIwACkrF0JIxBCAAAQhAAAKlEkBBKZUcx0EAAhCAAAQgUDECKCgVQ0vGEIAABCAA\nAQiUSgAFpVRyHAcBCEAAAhCAQMUIoKBUDC0ZQwACEIAABCBQKgEUlFLJcRwEIAABCEAAAhUj\nUHORZGfMmOHD0CsM+3zzzWedO3e2Dh06VAwwGUMAAhCAAAQgUDyBmhhBefXVV23//fe37t27\nW5cuXaxXr17Wp08fW2yxxbySstRSS9mBBx5oU6dOLZ4gR0AAAhCAAAQgUHYCLX4E5YwzzrAR\nI0Z4cEsssYStvfbaXknR6Ik+6Dd9+nSbPHmyjR492saMGWOjRo2yoUOHlh00GUIAAhCAAAQg\nkJxAi1ZQ7rzzTq+c6EvBZ511lq2yyip5yURRZE8++aQdc8wxNmzYMOvZs6ets846edOyEQIQ\ngAAEIACByhNo0VM899xzj/Xu3du0LKScCLG+vLvBBhvY2LFjTV8hvvHGGytPnhIgAAEIQAAC\nEChIoEUrKBMnTvRTOu3atSsIIL5jgQUWsP79+9uUKVPim/kNAQhAAAIQgECVCbRoBaVHjx72\n8ssv2+zZsxNhlYePlBoZ0CIQgAAEIAABCDQdgRatoOy111729ttv25AhQ+z5558vSDnYoMhW\n5ccff7TtttuuYFp2QAACEIAABCBQeQIt2khW3jhfffWVDR8+3O6//35bdNFFvWtx165drWPH\njjZz5kzvxfPxxx/b559/bm3atLHzzz/f1l133cqTpwQIQAACEIAABAoSaNEKioxfjzrqKBs8\neLCdfPLJNmHChDojKe3bt7dFFlnEe/AcccQRtvjiixeElXTHN998Y6eeemriqaUvvvgiadak\ngwAEIAABCNQEgRatoIQWlCfPrbfe6lc1aqL4Jz///LMP3NapU6eQrGzLOXPmmJSUWbNmJcrz\nu+++S5SORBCAAAQgAIFaIVATCkq8MTW1o78gCnmvKR5Fk23dunXY3Khlt27dinJVfvbZZ+3R\nRx9tVJkcDAEIQAACEGhJBFq0kWxoqA8//NCuuOIKu/vuu+3777/3m2VzsuOOO5qUiWWXXdYr\nLZoGSurxE/JmCQEIQAACEIBA+Qm0+BGUCy+80I4++ugMOUWJfeGFF+zII4/0oe31scAtt9zS\nXnvtNRs5cqS9//77dvvtt2fS8wMCEIAABCAAgeoTaNEjKA899JA3fl1uueXs4osv9h46skFZ\nb7317I477rCzzz7bPvvsM/v3v/9tkyZNsj322MNvf/jhh6vfEpQIAQhAAAIQgECGQIseQdGU\nTocOHbznjpYSGcxuv/323t1Y394JdifzzDOPXXnllfbggw/6vy222CIDiR8QgAAEIAABCFSX\nQIseQVFwNgVfC8qJ0G6++eYmZWSbbbbJKCcB+bzzzuujyL733nthE0sIQAACEIAABJqAQFEK\nymGHHWb33ntvszEk1bd1pKT89ttvGbSKe/KXv/zF+vbtm9kWfsg1+MUXX/RxUcI2lhCAAAQg\nAAEIVJ9AUQqKbDUUBl4RWWVkKsPSNIumaT755BNvJBsPhqapncMPPzyr6vLeOemkk0xux5ts\nsknWPlYgAAEIQAACEKgugaIUFMXruOiii3y0VRmdrrzyyrbSSiv5bQopnzaRErXKKqt4A1l5\n7+hjgPlkzJgx3ibl8ssvt4033th23XXXfMnYBgEIQAACEIBAlQgUpaB0797dFA5eXwh+4403\n7Pjjj7evv/7ah5PXqIpCysswNS2xRGRr8tRTT/kw9/379zdN+eSTH374wUd91aiKRokUIh+B\nAAQgAAEIQKDpCBSloMSrKddduelOnjzZHn/8cZN9ynPPPWc77LCDt+FQ7JE0GJvK8FU2J4p9\nUkh22mknr2hpVEhKDQIBCEAAAhCAQNMSKFlBCdX+4IMP/Ef4nnjiCf/lYI0+aKRFU0F9+vSx\nM844IyRN7VJKTHA3Tm0lqRgEIAABCECghgiUpKBMnTrV/v73v9uaa65pyyyzjP9y77Rp0/xS\nkVjffPNNk+Ky7bbb2ogRI+z666+vIaScKgQgAAEIQAACjSVQlIIiY9Ktt97aT+HIXuP111+3\nYcOG2bhx40zfuzn99NN9IDRVqlevXj7wmX7zITxRQCAAAQhAAAIQSEqgqEiyxx13nFdE1lpr\nLdtnn31sl112sU6dOhUsq02bNrbkkkt6T5qCidgBAQhAAAIQgAAEcggUpaAceuihttVWW3nb\nkpx88q527drVPvroo7z72AgBCEAAAhCAAAQKEShqikeeOTJ81ZSNbEyC6IN7e+65J1M5AQhL\nCEAAAhCAAAQaRaAoBUWKyKBBg2zTTTf1IeRDyfoS8E033eS3n3rqqWEzSwhAAAIQgAAEIFAS\ngaIUFIWI19d+NdWjj+4FWW+99Wzs2LG2/vrr25lnnmnPPPNM2MUSAhCAAAQgAAEIFE0gsYIS\nRZH/UOD222/vXYy7deuWVdhmm21mt99+u48nctttt2Xtq9UVMUv6V6uMOG8IQAACEIBAPgKJ\njWS/++47++mnn2zAgAH58vHbevToYauttpqPLlswUQ3skH2ObHXmzJlTA2fLKUIAAhCAAATK\nTyCxgtKxY0cflK2+LxjrGzyyR1l33XXLX9NmlGPv3r3tySef9N/3SVJtfdfokEMOSZKUNBCA\nAAQgAIGaIJBYQRENfen3qquusg022MB22223LEDff/+9KXiboszKiLaWReH+FSsmqbRt2zZp\nUtJBAAIQgAAEaoJAUQqKvqujLxkPHTrUR43t16+fde7c2eTdo4/xzZgxw/bYYw/bcsstawIe\nJwkBCEAAAhCAQGUIFKWg6COAjz32mB8p0ReM77nnHm8EqqottthiNnLkSDvggAMqU1NyhQAE\nIAABCECgZggUpaCIynzzzWfXXnutB/Ttt996g1iFs5eNCgIBCEAAAhCAAATKQaBoBSVeqL7D\ns8IKK8Q38RsCEIAABCAAAQg0mkDRCsr48eN91NivvvrKux0rzkeu7L333rbXXnvlbmYdAhCA\nAAQgAAEIJCJQlIJyxx13+C8YN5Tzhhtu2FAS9kMAAhCAAAQgAIGCBIpSUE455RTr0KGDjR49\n2rscy2g2n8w1V+IAtfkOZxsEIAABCEAAAjVOILGC8sMPP9h7771nBx54oHczrnFunD4EIAAB\nCEAAAhUkkHioY9555/WeOhpBQSAAAQhAAAIQgEAlCSRWUDRtI9uSW2+91X777bdK1qmieSuY\n3EcffWTvvPOOTZkyxTQyhEAAAhCAAAQgkC4CiRUUVVth7tu3b2877rijTZgwwcdAmTZtmuX+\n6aOCaZJXX33V9t9/f5PNTJcuXaxXr17+Y34KLqe4LksttZSfulKYfgQCEIAABCAAgaYnkNgG\nRVUdNGiQyb347rvv9n+Fqj9ixAg77bTTCu2u6naF51d9JEsssYStvfbaXkmRYqJAc9OnT/eK\nlgx/x4wZY6NGjcLGpqotRGEQgAAEIACBugSKUlBWXnllW2SRRermkrOlb9++OVuaZvXOO+/0\nysnAgQPtrLPOslVWWSVvRRTLRV8fPuaYY2zYsGHWs2dPW2eddfKmZSMEIAABCEAAApUnUJSC\ncvnll1e+RmUsQd8K6t27t/9mULt27QrmrK8P6wvNY8eONYXtv/HGG1FQCtJiBwQgAAEIQKDy\nBIqyQYlXR3Ymr7/+uj3//PN+cxqNTSdOnOindOpTTuLntMACC1j//v298Wx8O78hAAEIQAAC\nEKgugaIVlMmTJ9vOO+/sA7bpYX7sscf6Gu++++42fPhw++WXX6p7BvWU1qNHD3v55Zdt9uzZ\n9aT6fZc8fKTU9OnT5/eN/IIABCAAAQhAoOoEilJQPv/8c2/HIdsOPcQ1HRJEdhyy81h11VXt\n559/DpubdKnvAb399ts2ZMiQzEhPvgoFGxTZqvz444+23Xbb5UvGNghAAAIQgAAEqkSgKBuU\nww8/3H8gUAal6623nu2www4WXHPlASNvGSkpN9xwg3fbrdI5FCxm6NCh3utIIzv333+/Lbro\noibX4q5du/qgczNnzvRePB9//LFJ+WrTpo2df/75tu666xbMkx0QgAAEIAABCFSeQFEKyqOP\nPmqHHHKIV05yq9a6dWuvoFxyySX23HPPpUJBkfHrUUcdZYMHD7aTTz7Zx24JNjOh/orrIs8k\nefAcccQRtvjii4ddJS81zSVD21mzZiXKY9KkSYnSkQgCEIAABCBQKwQSKygabZCNxrLLLluQ\nTdu2bW255Zbz6QomaoId8uRRBFyJzkPxTzQNpcBtnTp1KnuNFCvmsssuS2z7omklBAIQgAAE\nIACB3wkkVlA6duxoCy+8sL344ou23377/Z5D7Jce/m+++aYddNBBsa3p+akQ/ToP/eWTX3/9\n1Ssw+u7QPPPMky9Jom0ahVH02qTy7LPP4tacFBbpIAABCECgJggUZSS75ZZb2tVXX22axvn+\n+++zAH3zzTe25557+tGJzTbbLGtfU658+eWXtssuu/josVJMNt54Y3v66afzVklu0wqFf/bZ\nZ+fdz0YIQAACEIAABKpDoCgF5YILLvD2Gocddpg3OH3mmWdM9hPyetH3bO69917be++9bcCA\nAdWpfQOlSIlaffXV7Y477jCNjshA9oknnvBB2WSTgkAAAhCAAAQgkE4CRSkonTt3tldeecUb\nwMqGQ6MTn332mVdMdHr6jo1GWNIi5557rn3yySfeePfTTz/1Lseaolp++eVt5MiRdvTRR6el\nqtQDAhCAAAQgAIEYgcQ2KOGYbt262RVXXGGXXnqpyT33iy++8N+uSfKNnpBHtZYa4ZEhrNyM\n5UIsUZwWfYl52223tQsvvNAUzO24446rVpUoBwIQgAAEIACBBASKVlBCnnIrlneM/tIqU6ZM\nsfXXXz+jnIR6ynPngQce8PtOOOEEH3BO0XERCEAAAhCAAATSQaCoKZ50VDl5LRTpdty4cXkj\n28pg9t///re3S1HE2UKGs8lLIyUEIAABCEAAAuUiUNQIyoEHHujtThoqfNdddzX9NbXIWPeh\nhx6yk046yX8zKHcaSpFlH3nkET+SstVWW9nxxx/f1FWmfAhAAAIQqBKBd9991/SCKieKNIlm\nKBSRfZlllklTtapel6IUFD3MP/zww3orKU+ZDTfcsN401dp56KGH2nXXXedtTS6++GK7+eab\n6yhOCjw3duxY734sWxWJvs2DQAACEIBAyybw/vvv20svvZSKyOdx0ldeeaWpbigocSoN/Fbw\nMQU7i4vW5SHzxhtv+LDyGjlRePk0iIKtKbS9XIrvu+8+m3vuufNWa6WVVvKdVAqNRlwQCEAA\nAhCoDQJyoFAMrzTJNddck6bqNFldihpBKRQWXh/fW3HFFX2Y+5VXXtlPmQwaNKjJTipe8Hzz\nzWcaPdFfrnIVT6c4Lg8++KCPlNuYKLLxPPkNAQhAAAIQgEBpBMpqJKuRCBmmaioojTLXXA2f\nrgK7rbDCCmmsPnWCAAQgAAEI1AyBhp/YRaDQV3ynTZtm+lgeAgEIQAACEIAABEolUNQUj6LH\n5jMgnTNnjk2dOtUHRFN4+dVWW63U+nAcBCAAAQhAAAIQsKIUlH79+jXoxaPAbX/84x9BCwEI\nQAACEIAABEomUJSCssEGG+R1e5JthwKf9e/f3/bff38rZExbci05EAIQgAAEIACBmiJQlIJy\n/fXX1xQcThYCEIAABCAAgaYhUFYj2aY5BUqFAAQgAAEIQKClEShqBCVpqPtcSHvssYcNGTIk\ndzPrEIAABCAAAQhAIC+BohSUiRMn+oix8tSR6HsBnTt3tunTp+f17gklrrnmmuEnSwhAAAIQ\ngAAEINAggaIUlJtuusnWW28922STTWzEiBHeKFZhgmfNmmXjx4+3o48+2hvLKqy8tgdp3759\n+FkTy08++cQUSXf27NmJzvfHH39MlI5EEIAABCAAgVoh8LsWkeCM99tvP1Mo+7vvvtviUVn1\njZuBAwfa8ssvb/r43l133WUHHXRQghxbZpLu3bvbwQcf7BW3JGc4adIku+CCC5IkJQ0EIAAB\nCECgJggkVlAUJfa5556za6+9Nks5iVPSl4wV7v6JJ56oaQWlXbt2dsABB8TR1Pv72WefRUGp\nlxA7IQABCECg1ggk9uLRlI0+vDdlypSCjDSl8cEHH5g+HohAAAIQgAAEIACBUgkkVlBkELvZ\nZpvZyJEj7YUXXqhTnuwogpePpnsQCEAAAhCAAAQgUCqBxFM8KuCkk06yp556yuSVo6iyffv2\ntfnnn98+/fRTbySrjwTKTmWbbbYptT4cBwEIQAACEIAABIr7Fo9C2b/44ou277772pNPPmkT\nJkzIIFxooYXsyiuv9KHuMxv5AQEIQAACEIAABEogUNQIivLv0aOHPfjgg/bbb7/Zu+++a19+\n+aUttdRStuiii1qrVq1KqAKHQAACEIAABCAAgWwCiW1Qsg8zk1ePjGLnmWcek/cOsTxyCbEO\nAQhAAAIQgECpBIpWUCZPnmw777yzdejQwQdqO/bYY33Zu+++uw0fPtwrLqVWhuMgAAEIQAAC\nEICACBQ1xfP555/bKqusYtOmTfMGsvFRkyiK7KyzzrJ77rnHXnrpJT+yAmIIQAACEIAABCBQ\nCoGiRlAOP/xw++mnn7yB7FtvveWVlVDomDFj7OSTT7Y333zTbrjhhrCZJQQgAAEIQAACECia\nQFEKyqOPPmqHHHKI/x5PbkmKk6Lv83Tq1MlHnM3dn5b1GTNm2EcffWTvvPOODzr3ww8/pKVq\n1AMCEIAABCAAgf8nkFhBmTlzpunhrm/tFJK2bdvacsst59MVStMU21999VXv/qxv5HTp0sV6\n9eplffr08ca9io4rLyQFmZs6dWpTVI8yIQABCEAAAhDIIZBYQenYsaMtvPDCPg5KTh6ZVSkx\nmuLRwz8tcsYZZ/ipqGuuucbmnXdeW3vttW3rrbe2XXbZxX/gcI011vAeSKNHj/Z2Nbfcckta\nqk49IAABCEAAAjVLoCgj2S233NKuvvpq/9XivffeOwvaN998Y9r27bff+pD4WTubaOXOO+/0\n004KvS8DXhn45hMZ+Crw3DHHHGPDhg2znj172jrrrJMvKdsgAAEIQAACEKgCgcQjKKrLBRdc\nYIsssogddthhPjDbM888Y5MmTbLtttvOT5Pce++9XkkZMGBAFarecBHyKOrdu7f3LCqknCgX\nBZhT6P6xY8f60P033nhjw5mTAgIQgAAEIACBihEoagSlc+fO9sorr/h4J9ddd51pSkcixUS2\nHaNGjbKDDz64YpUtNuOJEyf6KZ127dolOnSBBRbwsV3q+2JzooxIBAEIQAACWQTGjx9v999/\nf9a2pl758MMPTSPoSDoJFKWg6BS6detmV1xxhV166aX28ccf2xdffOGnRDSykjZRWP6XX37Z\nR7yVAW9DIiNgKTUymEUgAAEIQKB8BG666Sb/mZQ02SjKo1OfbUHSSaAoBUUuxjI0/dvf/mZt\n2rTx0yeaQkmr7LXXXqYIt0OGDPExWvQV5nwiDVpfaVZUXAWf05QVAgEIQAAC5SOg++yqq67q\n7QLLl2vjcrrqqquI29U4hBU9OrGCom/vKACbvrtz3nnnVbRS5cp86NCh9tVXX/kpKQ0t6oOG\nqn/Xrl1NXkmaopo+fbofCVKUXCld559/vq277rrlqgL5QAACEIAABCBQAoHECsrcc8/tDUg1\nwiBNuDl8uVh1POqoo2zw4MF+BGXChAn2/PPPZ2Fq3769N/yVB88RRxxhiy++eNb+UlbER+XM\nmjUr0eFvvPFGonQkggAEIAABCNQKgcQKih72d999t/9Q4KBBg+zQQw+1pZde2hZccME6rGSU\nmtQwtc7BFdigaahbb73V56xRE7lC//zzz6bAbYp8W26RZ9P6669vc+bMKXfW5AcBCEAAAhCo\nCQKJFRTRCDYaDzzwgOmvkCjk/WmnnVZod5Nu19SO/iopikw7e/bsxNbhzz77LNNKlWwQ8oYA\nBCAAgWZHoCgFRdbXcsVtSOoLh9/QsS1pf9JpsKTpWhIbzgUCEIAABCBQH4GiFBRFkUUgAAEI\nQAACEIBApQnUq6DIqFR2FJtsskml61GR/OVCFoLJFVOAwtzrmz0IBCAAAQhAAAJNQ6BeBeXw\nww/3BqWKtheX119/3aZNm2YbbbRRfHPqfl922WX22muvFV0v2c+goBSNjQMgAAEIQAACZSNQ\nr4JSqJThw4fbfffdl9gItFA+ld7+4IMP2g477GAyQpWr8b777puoSGxoEmEiEQQgAAEIQKBi\nBEpSUCpWmzJnvPDCC9tjjz1mG264oQ+xLO+ilVdeucylkB0EIAABCEAAAuUmMFe5M0xbforH\ncs011/hq6SvMCAQgAAEIQAAC6SfQ4hUUNcFyyy1nI0eO9Aazsp9BIAABCEAAAhBIN4GaUFDU\nBAplry8Vr7DCCuluEWoHAQhAAAIQgIDVjIJCW0MAAhCAAAQg0HwINGgkO2PGDDvhhBOyzuit\nt97y67nbQ6LNNtvMNt1007DKEgIQgECLJKBPWowfP95+/fXXVJ2fvge2xBJL+C+0p6Vin376\naaq+0ZYWLtSjMIEGFRR9WO+cc87Jm0Oh7fpCMApKXmRshAAEWhABKScDBw60eeaZJ1VnpS+p\nt27d2v+lpWL6QOtWW22VlupQj2ZAoF4F5ayzzrJvvvmm6NPo379/0cdwAAQgAIHmRkAjJ1JO\nnnjiiVRVXYEmzz777FR9hFQxqRAIFEOgXgVl6623LiYv0kIAAhCAAAQgAIGyEMBItiwYyQQC\nEIAABCAAgXISqHcEpZwFkRcEINB8COhzD7nf4Grq2ms6pVWrVjbXXOl5r/rtt99SVZ+mbiPK\nh0A5CaCglJMmeUGghRD45JNP/Ler+vXrl5ozOvPMM6137942bNiw1NTpoYcesnHjxqWmPlQE\nAi2JAApKS2pNzgUCZSSgUZS11lqrjDk2Lit9tqJbt26pqhORqRvXphwNgfoIpGestL5asg8C\nEIAABCAAgZoiwAhKBZr766+/tqOPPtoUiyCJKD1SmwQ0lXLiiSfanDlzUgVAAcgQCEAAAk1J\nAAWlAvTbtGljnTt3tqQ3+V9++aUCtSDL5kBAUwS33367DRo0KFXVlfEnAgEIQKApCaCgVIC+\nlJNRo0YlzvnZZ5+1e+65J3F6ErYsAm3btvWjKGk6q3vvvTdN1aEuEIBADRLABqUGG51ThgAE\nIAABCKSdAApK2luI+kEAAhCAAARqkAAKSg02OqcMAQhAAAIQSDsBFJS0txD1gwAEIAABCNQg\nARSUGmx0ThkCEIAABCCQdgJ48aS9hZpp/aIo8rE9krpaV+s05TGDQAACEIBA+gmgoKS/jZpl\nDRV4bPDgwamr+7HHHmvnnntu6upFhSAAAQhAIJsACko2D9bKREAjKIcddpj179+/TDk2Ppvr\nrrvOpk6d2viMyAECEIAABCpOAAWl4ohrt4BevXqlSkFRAD0EAhCAAASaBwGMZJtHO1FLCEAA\nAhCAQE0RYASlppq7tk/2s88+szfeeMO22mqr1ID46quvjO/epKY5qAgEIJAiAigoKWoMqlJZ\nArI/mXvuua1Lly6VLaiI3D/99FOTvQ4CAQhAAALZBFBQsnmw1sIJ9O3b1w4//PDUnOVVV11l\nb7/9dmrqQ0UgAAEIpIUANihpaQnqAQEIQAACEIBAhgAKSgYFPyAAAQhAAAIQSAuBmpvimTFj\nhn377bf2yy+/2HzzzWdyPe3QoUNa2oN6QAACEIAABCDgCNTECMqrr75q+++/v3Xv3t0bSCo+\nR58+fWyxxRbzSspSSy1lBx54IEG8uCQgAAEIQAACKSHQ4kdQzjjjDBsxYoTHvcQSS9jaa6/t\nlRSNnmgkZfr06TZ58mQbPXq0jRkzxkaNGmVDhw5NSfNQDQhAAAIQgEBtEmjRCsqdd97plZOB\nAwfaWWedZausskreVpab55NPPmnHHHOMDRs2zHr27GnrrLNO3rRJN3733Xf+Y3lJ0s+cOTNJ\nsoJpVP/G5lEw80bs+PHHH1NVL3HSN4LSxEpTjbRfsk5G+yXjFFJx/QUShZdpvf7U1xFHwIFo\nseJGQqLevXtHP//8c6JzdKMp0fzzzx+56Z5E6Qsleu+996JWrVqphxX15x6ehbIsuH3cuHFF\nlVFsnUpNP9dcc6WyXqWeT60dR/sVd+2mrX/Qfs27/dSfdG+vdWnRIygTJ070Uzrt2rVz7d2w\nLLDAAv7bMVOmTGk4cT0pll56aXvrrbds1qxZ9aTK3iVNvnXr1tkbE6wNGDDA3nzzzcSjNQmy\nLEuSr7/+2rp161aWvMqVyQ8//GBOcbT27duXK8uy5JNGVmmsE+2XvLvRfs2bVZs2baxfv37J\nT6KFpmzRCkqPHj3s5ZdfttmzZ1vbtm0bbEJ5+EipkcFsY0VGuNUSOnK1SFMOBCAAAQhUi0CL\n9uLZa6+9fJTOIUOG2PPPP1+QqRtG8zYoslXRvO12221XMC07IAABCEAAAhCoPIFWmuOqfDFN\nU4JO7aKLLrLhw4d7xWPRRRf1rsVdu3a1jh07emNJefF8/PHH9vnnn5uG1c477zw74ogjmqbC\nlAoBCEAAAhCAgCfQohWU0MaTJk2yk08+2SZMmGD6om1cZI+wyCKL2ODBg71isvjii8d3N4vf\n8kzhi7jNoqmoJAQgAIEGCTgjZ//C3GDCFp6gJhSUeBvKxVTxT5xnjw/c1qlTp/juZvf7+uuv\nt3322afZ1ZsKQwACEIBAYQLXXXed7b333oUT1MCeFm0km6/9NLWjv5Yi8pSRl9Jjjz3WUk6p\nYudx5pln+rxPOeWUipXRUjLeeOONfeygxsYDaik8Cp3HM88840dnuf4KEfp9O9ff7ywa+qXr\nL21ekA3VuRL7a05BqQTEpsxTQ4FyT1aEXKR+AvrUgQRW9XPSXvWpvn37wqoBVPL84/prANL/\n7+b6S8ZJqdSndG+vdYFArfcAzh8CEIAABCCQQgIoKClsFKoEAQhAAAIQqHUCKCi13gM4fwhA\nAAIQgEAKCaCgpLBRqBIEIAABCECg1gmgoNR6D+D8IQABCEAAAikkgIKSwkahShCAAAQgAIFa\nJ4CCUus9gPOHAAQgAAEIpJAACkoKG4UqQQACEIAABGqdAApKrfcAzh8CEIAABCCQQgJEkk1h\noxRTpbZt29rcc89dzCE1mxZOyZterNS3kPoJcP3Vzye+l+svTqP+31x//+NTcx8LrL9bNL+9\n+orxRx99ZL17925+la9yjadPn+5L7NKlS5VLbn7F6QvgPXv2JNx2A03H9dcAoNhurr8YjAZ+\ncv39DxAKSgMdhd0QgAAEIAABCFSfADYo1WdOiRCAAAQgAAEINEAABaUBQOyGAAQgAAEIQKD6\nBFBQqs+cEiEAAQhAAAIQaIAACkoDgNgNAQhAAAIQgED1CaCgVJ85JUIAAhCAAAQg0AABFJQG\nALEbAhCAAAQgAIHqE0BBqT5zSoQABCAAAQhAoAECKCgNAGI3BCAAAQhAAALVJ4CCUn3mlAgB\nCEAAAhCAQAMEUFAaAMRuCEAAAhCAAASqTwAFpfrMKRECEIAABCAAgQYIoKA0AIjdEIAABCAA\nAQhUnwAKSvWZUyIEIAABCEAAAg0QQEFpABC7IQABCEAAAhCoPoE21S+SEkXgo48+sqefftqG\nDRvWJEA+/fRTe/XVV61Dhw625ppr+mW+ikyePNmiKMq3yxZddFFr04YulBdOFTfOnj3bXn/9\ndZs0aZL16tXLVl55ZZtrruq/eyTtU7loxo8fb/PMM4+ts846ubtYbyICP/74o+9TH3/8sb/O\nl19+eevUqVPVa/Prr7/a888/b59//rn179/f/vCHPySqw2effeaP23DDDa1Lly6JjiFRCgm4\nhw9SZQLffvtt1Ldv32i++earcsn/K+7UU0+NnGIhrcP/tW7dOjr77LPr1OXLL7/MpAlp48t3\n3nmnzjFsqC6B+++/P+rcuXNWO6266qrRu+++W9WKJO1TuZX617/+5eu++eab5+5ivYkI3HDD\nDVH37t2z+tT8888fXXzxxVWtkfpwnz59surRr1+/yL001VuPOXPmRGuvvbY/7plnnqk3LTvT\nTUBvx0gVCUyfPj3aYost/MXTFArK2LFjfdnbb7999Morr0Tu7SRTn1GjRmWRePjhh33aTTfd\nNDryyCPr/H311VdZ6VmpLoH77rsvatWqVeTebqO77rrLt+dBBx0USeHUtlmzZlWlQsX0qXiF\n1H8WWmgh38dQUOJkmu632lJ9qmfPntHIkSMjNzLnFZNll13Wt9ONN95Ylcr99tsm7lnbAAAc\nlUlEQVRv0frrrx9JMbrpppui9957Lxo9enQ077zzRksssUT0/fffF6zH6aef7uuqlykUlIKY\nmsUOFJQqNpMeIj169PAXz9xzz132EZRrr702WmuttSI31J/3rH744Qd/43FTM5HeMoL88ssv\nfvtiiy2Wtf1vf/ubr+vjjz8ekrJMEYHVVlvN38BzR0t23nln326PPfZYWWrrpl6ik046KW9e\nxfapeCaDBg2KFlxwQV9XFJQ4mab7vdFGG/n20MtJXF544QW/XSMY5ZD6+pTyv+yyy3x5V1xx\nRVZxUlKkeORuD4n0wqXR4dCvUFACmea5rP5EtetdtSgPPvig7bDDDubeau3ee++15ZZbrl4M\nToHw6dzbgLmHg91xxx32008/1XuMbACee+450/xxPnniiSe87cvuu+9u7i07k8QpSzZ06FDT\n8Q899FBm+2uvvWbubcpWWWWVzDZ+pIOA2vKll17yfSN3Xv68886zcePGmXuY1KmsexO1K6+8\n0o4++mhzI2Y2ceLEOmlyN6hPOSUod7NfL7ZPhUzcg8bcCJBpKVE/Q5qWgBu1MKdw+n4zYMCA\nrMqsvvrq5kZRzE3rmuxC4lLuPqW8r7/+emvXrp3tsssu8aL8uuyVrr766qztWlHdZdPnXtJs\nr7328vvpV3UwNasNWDhWqblkTDp8+HA76qijvNHWaaedVrBkGTvutttu5t5arGPHjta2bVub\nNm2aObsVu+2227yxWMGD69mh/CRrrLFGnVRhmx56W2+9td8vBWWZZZbxStWtt95qX3zxhb95\nbbDBBuaGWuvkwYbqEXj55Zd9YW7kwS+dXZO98cYbvr0WX3xx01+unH/++V6hkVGtDJxleOje\nq+zEE0+0v/zlLyUpCcX2KdVJDzQpSIcccogNHDgwt5qsNxEBGVaH9sytws8//+z7i5v6yXq5\nqUSfUv/UvUcKkbOvyqqK7ofOLsX+85//mNLp3hhE91ZnN2dumsor4WE7y+ZLgBGUKrXdZptt\nZmeeeWaDFuV6YOitQYqCm3u1b775xr7++mt/0eni22mnnbzCUEq1dbyka9eudQ4Plu5Tpkzx\n+zQKo7dmlS/PEI2w6KGiB8qKK65Y8EZWJ2M2VISARrskCyywgG277ba+X6233nrmjBttyJAh\nXqGNF+yMae3YY4/1b5c69pNPPrEZM2b4vuZsDczZFsSTJ/5dTJ9SphoZ1Fuum060c845J3E5\nJGxaAs6I3mbOnOn7VqhJpfqU+qVGmvPdp1S27lVSTqZOnRqq4kebr7rqKrvooov8/Sqzgx/N\nm0DznJlq/rV2rqB5bVDcSIWfY91mm23qnOQpp5ySNf/qRlO8wZiMxvTn3AD9ftm5hG1aymtI\n4h4Mfr97066Tt7a5nhw5RcTve/bZZ/26bGXcgyR66623ojfffDP685//7I0wZeXvRnXq5MOG\n6hAIdibqR879MnJD3pH6w+DBg327aY5fhoZBgpGjU3zDJr+UsaEMD9VnQnrZMcX7j/pF+/bt\ns7a5EUB/fDF9Sge4UURvI+De1P3xbtrS11eG40g6Cdx+++2RG12J3FRi5F5cMpWsVJ+SQaz6\n3I477pgpK/5D27U/2F65kcCoW7duvu+HdCeccIJPo/sY0nwJMMXjeno5RG8XmsONi+ZK9VeM\naL5fsskmm9SxDwg2BRpdOfDAA815AdmSSy6ZyV4xSzTUv8gii5h7oGS2h5gYoS659VTCMK8c\nbFN69+5tmtbRVMG6666byUtv20qrt98LLrjATw1kdvKjrAT0FpnPnkjD3upvEg29O2+sTD/T\n6Jum4J588klvt6R1jYLJdkC2KhoSz7U7kX3BhAkTTLEjNPWjv/jQufqV+lO8r2nkRlJMn3IG\ni/bXv/7VnKJtKhNpGgLF3KtkC/LHP/7RnNGpH6UIU7tN1adELPdete+++/q4PxpBQVoYgear\nW6Wr5u6B7jV21z0yS2nxhaTQCMpWW22VOT6eV/y3LO3zyRlnnOGPzTdCovRhBCafV448PlTG\noYcemi/rrG1htEV1RSpHQC6d8XYPvzXqsM8++/h9l1xySZ0KXHrppX7fEUcc4fdptCIcW98y\nX79QBnp7LvQ2m7RPuYdi5KYKI/V7jejJ+0d/GoVTneTKrnV5lCGVJZD0XhXcddVuuTGPKtmn\n3PSNd3UudJ9zwdd8n3FT35H6v/qPRg9Dn9LSTUf77bqvaT2MDlaWLLmXmwAjKK53l0M04hFG\nOEJ+MuYqVsIb6c0332wuRkTew2UoVopoZEXiYrHUOTxs09tzQ6K3KUl4i28oPftLIyA7DTfV\nV+dgjYhpnyRfH3EPe78vzNGHPuWmUey4447z+/L9U7TQYiVpn1LU4g8//NBnny8iqbyOFNV4\n11139SN3xdaD9MkJNHSvcg8Zc3GPvJeXRrpka5LbzyrZp+RQIFuqcE/KPTNt14ieRhLHjBnj\nd6vf5JONN97Yb3777be90W2+NGxLLwEUlDK1TbmGF+U1I5ESkuvqp2FVTe8svPDCJdVaXkAS\nuYa6QG1ZeWibJHjzXHjhheZiDZi8jeRRFBdd7BJZ2SOVI6Cba7jB5pYS2lLTO250I2u3vHMk\nYRpl6aWX9h46MrbO7VNKp1DimtpzQbG0WpSEejTUp6TIHHbYYXXyltHs5Zdfbs7mxZz9DC7t\ndQiVf0N99ypN/+63336mqZ3tttvO9KIUny4Otalkn1IZ6ldPPfWUdxBw9iWhWG8Y+9///tdc\npFjfZ3Ufy6dY6zMiujbkVKD7ZZiSzGTEj+ZBoNxDMuSXjEChKR4FFlIkR4VqjgdTU67BIFFG\na/lE291Npd5Q0CussELkLtiM4azycYqPj+i50korRRpelfzzn//0Q6QuXkvW8KiGSkMkXPdQ\n8mn5V30Cmgpx9kGRe/BHzisnqwLBiDBuEBvaTKHl46LpOhlCy9C2UORZF7/HG0rHj4v/Ttqn\n4seE3xjJBhLpWIYAaYo0nXv/ya1hJfuUGxnx95/cT3A4Gya//c4778ytTtY6RrJZOJrtiuIg\nIE1AoJCCoqoE+wJnnOrnVhWBds899/QXpqJvNkZuueUWn48LvhbpIncB4LxdgMKju9gamax1\nc3Jv7z6t5oJlD6F6OHdpv23//ffPpOVH0xBwb7lemXVvm5EbhYgU/VNeWO7VKHIuxVmVcqNe\nkRuW93/ywFFIc938l1pqKe+V9eKLL2alL2YlaZ/KlycKSj4qTbNNNh3hu05uGsh7xcgrLPfv\nu+++8xWsZJ9yhrD+e2Wyf5Ln1yOPPBKdfPLJ3h5KylNDgoLSEKHmsR8FpYnaqT4FRRenXHuD\n27AeOBpVcfEtIrnUNVb+8Y9/RG7I0z/IlLd+y001V9xcbxS+7aJ0+nOxCep9m87Ng/XKEtCI\niFyCQ/vIXdjZmWSNeoUauKFx/30T3fRDemdzFEnRaawk7VO55aCg5BJpuvV77rkn0y9C/8i3\n1H0hSCX7lLOhilzcJX/vC/XQJxGS3ANRUEILNe9lK1XfNT6SUgJy8VTgIgVLK9U4Nt+pqdk/\n+OADc1MFpvlkhZUuJHJlVfRP2SgokiSSPgKK8isbpSSG2SEIn+blZWwbXMsbe1bF9KnGlsXx\n6SJQqT6ls3QjNj5opAz4S7W/SxctapOUAApKUlKkgwAEIAABCECgagQIdV811BQEAQhAAAIQ\ngEBSAigoSUmRDgIQgAAEIACBqhFAQakaagqCAAQgAAEIQCApARSUpKRIBwEIQAACEIBA1Qig\noFQNNQVBAAIQgAAEIJCUAApKUlKkgwAEIAABCECgagRQUKqGmoIgAAEIQAACEEhKAAUlKSnS\nQQACEIAABCBQNQIoKFVDTUEQgAAEIAABCCQlgIKSlBTpIAABCEAAAhCoGgEUlKqhpiAIQAAC\nEIAABJISQEFJSop0EIAABCAAAQhUjQAKStVQUxAEIAABCEAAAkkJoKAkJUU6CEAAAhCAAASq\nRgAFpWqoKQgCEIAABCAAgaQEUFCSkiIdBCAAAQhAAAJVI4CCUjXUFAQBCEAAAhCAQFICKChJ\nSZEOAhCAAAQgAIGqEUBBqRpqCoIABCAAAQhAICkBFJSkpEgHAQhAAAIQgEDVCKCgVA01BUEA\nAhCAAAQgkJQACkpSUqSDAAQgAAEIQKBqBFBQqoaagiAAAQhAAAIQSEoABSUpKdJBAAIQgAAE\nIFA1AigoVUNNQRCAAAQgAAEIJCWAgpKUFOkgAAEIQAACEKgaARSUqqGmIAhAAAIQgAAEkhJA\nQUlKinQQgAAEIAABCFSNAApK1VBTEAQgAAEIQAACSQmgoCQlRToIQAACEIAABKpGAAWlaqgp\nCALlJfDPf/7TxowZU95Mya1sBH799Vfbc8897bfffitbnmQEgVoi0KaWTpZzhUC1CHz33Xc2\nbtw46927t6244oolFfvTTz/Zo48+ai+88IJ16NDB9tlnH+vevbs9//zzduONN9q//vUva9u2\nrU2ZMsV22203W3DBBbPKee655+zzzz+3bbbZxqfL2slKxQj8+OOPduWVV9pjjz1m999/v7Vp\n08b22msv22CDDaxVq1Z5y/3qq6/slVdesddee82nUZ9ZaaWVbOGFF86bvrEbZ8+ebQ888IAt\nuuiitsYaazQ2O46HQGUIRAgEIFB2Am+88Ubkrtjo4IMPLilv99YdDR482OehfPT32WefRe7B\nF7mHnP/r0aNH5BQWv88pKtGDDz6YVVY4fsaMGVnbq7kya9as6Jxzzoluu+22kopt7PElFdqI\ng2bOnBn16dPHt4l7+PvlQgst5JebbLJJ5BSDOrlfffXVUbt27Xya0NZazjXXXNHIkSPrpC/H\nhunTp/vydthhh3JkRx4QqAgBpnjcnQCBQLkJzDfffLb11lvb8ssvX1LWkyZNsnvvvdf69u3r\n36o1SjJnzhw74ogjbIkllrCJEyfavvvua3/84x/tySef9NMIe+yxh09TUoEVOuiOO+6w448/\n3r7//vuSSmjs8SUV2oiDTjzxRHv77bftz3/+s18qq3feececImDjx4+3Sy+9NCt3re+///62\nzDLLmM7VKbb21ltvmabvNIJy0kkn2WGHHZZ1DCsQqBUCTPHUSktznlUlsOSSS/oh9FILlUIi\nkZITpohuvfVW+/nnn/0DLa74rLfeerbddtvZf/7zH/8wXG655UotluMaSUDTeh07drThw4fb\n3HPP7XOTsnrKKaf4KZ/33nsvqwRN1bmRErvllluylFkppquttpotvfTSdt1119m5555r88wz\nT9axrECgpRNAQWnpLcz5NQmBb775xo+AuOF+W3PNNX0dHn/8cZs6darttNNO3t5A619++aV/\nU9Ybthvm9+lkt/DUU0/53xpJueGGG7yS4qYP/LYFFljAL+P/9MZdn+jtXTYR8847r0mhkT1E\nPnnzzTftkUcesY8//th69erl0+lNPp80lFYjO/qTPPPMM94WY/vtt/cPcG2TfYzq/cEHH3jb\nGilWUshksyEpdHywn1h33XX9yMydd95pK6+8sm255ZbeVkfHPv30037k6f3337cuXbr4EQo3\n5ZX1kA/8d9llF2/rM2HCBBNb1eEPf/iDssmShuqrxGojMZYyETeOFUM3rZKVn/ZLqXRTQNav\nX7+sfVqRknv44Yf7c9EoTFBU6yRMsOHdd9+1f//736Z+6aaabIUVVkhwFEkg0MQEKjJxRKYQ\nqHEC+WxQ3MM5kt3I+eef721I3IM4Y3fgHrDRtGnTPDX3MMtsd7cHn/bUU0+NQp5K64wqo5NP\nPjlyb+oFSQcblL333tvnJ3sV2aooT2dwG7nRmKxjjzrqqKh169YZ+xbZusgOQttzbSeSpB06\ndGid83DTH75MpwRl7C66du0audEGn9aNGkSffvqpT1Po+JdeesmnddMfUadOnTJlOKUucg/g\nyCmAfpvq361bt8x+N40SuZGpzDmrPVT2kUce6dNof+fOnf1vN3WWSacfSeqrdDvuuKM/XnYl\nsp8Razc1p115RXYpSvPXv/61DuO8B5SwUXZQKkNtH3jst99+fhs2KCUA5ZCqEbCqlURBEKgh\nAkGZiBvJ6oGoh6bztokuv/zySIaK7q08cm/s/mERN4h03jt+25lnnplFLTxY9GCWIqMH6S+/\n/JKVJqwEBcWNCvgHrLY7W5Bo11139Xmfd955IWl0zTXX+G1bbLFF9MUXX/jtbrQn2nbbbRuV\n9h//+Ic/Xg/suLjRGf+wdKMwfrPzeoqkcOhBesIJJ2SS5js+KChS8IYMGRI5b6YonMuIESN8\nHs5WJ1L9Jc6mI6M4qIwgag+V50ZYIjda4zdLETvggAP8dhkkB0laX+eF4/NTvhtttJHP58MP\nPwzZ1Fm6kZ5MeimQw4YNi66//vroo48+qpO2lA1XXXWVr8Puu+8e/fDDDz4LNw2VKRMFpRSq\nHFMtAigo1SJNOTVFoJCCogfXFVdckcVCD2lt1wMzSCEFRd49ehjrbV/H6M/ZOER6IEv5iEtQ\nUC655JL4Zv+gkpKkPxerI1KeGjnQg1ojEHFRns7V1Zeh38WkVT75FAznPu1HZjbccEOfXyhP\nIzpS0txURNiU9/igoMhLJncUSBw222yzzMM4ZBSOkUITJCgoF198cdjkl8pTeS+yyCJ+vZj6\n6oDXX3892nnnnTMjRGojKZNuis3nl/tPo0pbbbWVH70Kbaqlm/aJRo8enZu8qPXFFlsskheR\nc33OOk7nrDJQULKwsJIyAnjxuKsUgUA1CayzzjpZxfXs2dOvBxuTrJ05K24Exo455hhvDOtG\nZ2z11Vf38U/cA8fWX399k31GrrgRk6xN7du3t80339zbw8jWRH+yTZDthRuZyUqr+CvuQe5t\nPeSdUkzarIxiK7LPkP3IE088YWJx4YUX2n//+19vgyPvF9mSJBHZZAS7nZD+oosusrFjx5rO\nUfL11197ex7FjJEoRkmuuKmkrE3KU3ycW7cpPkmx9ZUB8+23326ffPKJz1f2RU5h9bYf+WyF\nll12WR/TRnXVfrWrvHrkzSMvLcVQcUpTVh2TrLgpQ3PTZf5cZBcTF9ndIBBIOwEUlLS3EPVr\ncQRyg28F7wwZTRYjMuh0UzLendVNxdirr77qDWrjeUjBcHYW8U3+t3uz9ksZ4coAUyKjzHwS\ntsvgtJi0+fIK2/Qg3njjjU3B5I4++mhvJKqgdqeddpo5242QrN6ljHhzRQxlVKy8nb2FV96k\nuElxkbgXxKxDxEfpciXwcaMhflcp9Q3GzHIfljImcfYufpnvnxvFMjfC412RxVnHyFhXnj7K\no1gJdVcwtlxRwL9c5S43DesQaGoCKChN3QKUX3ME5FZaiujtX1FkcxUZubMedNBBPkvtj0uh\nh72zR/DJ9HDWQ1oStvmV2D9FxZVIkSombSyLOj/1gJRnkR7EUh4GDhzovXpOP/10k7KVRIIb\nbzztoYceas4o2CZPnmxumsWuvfZae/nll/1oRDxd+K0Rp1ylRfvCaFZQJpPWVyNMUuRyRSNF\nchuW+3hwIb/rrrts0KBBGY+t3GPkaaX6S8IIUG6a+taDYpqvXXXOuf2ovrzYB4GmIICbcVNQ\np0wIlEBAw/0333yzd4mVq2hcgtKj0Pdx0QNYD2sFd4uLpg8kSy21VEYxCdvi6fQ7bNdIivNC\n8rvDtvrS5u4L63pgarRHofk1vaHpDAWg05SEpm00RaPpFWcDEg5JtNR0jDM+9qMxzubEu/uG\nA+V2LNH3ceIiBU5KRZhmC/s0naVpIrmJJ62vFEiNeGjERi7LuZLbRoqXIpdyuRnL9TufBCUj\njLLlS1Nom1yXNbWjc8kVnXO+6cDcdKxDoCkJlPYq15Q1pmwI1CiBMLKgIf9cccaoflO+76qM\nGjUqK/mLL77oY6LI5kRBxPSAXGuttbxioAd7XGQ7cd999/mYKFIeikmrfILCFH+L1wiDHuLO\nsyRelJ+KkhLkXJ0z8UryHZ91UGzFecv4NdUxbnOh0QIpLpJ8D+Uw/eMTuH+KTSIlSXVUXZLW\nV0HVpNAoho2mzuKiPDS6pfPTaIzEGQl7mx9NScmGKFfETAHfJBppKVZUd9n6KHicvvMTl9w+\nEd/HbwikhoC7eBEIQKDMBOrz4nHGkFmlyZPG3RAiZzeR2Z7Pi8dNO0QumJlPe8ghh3iXVMX8\nCK7Aio/iHsCZPOTFI1dc9/Yd/elPf/Lf6pFHj9yO3QM8coapmbTyclGcDLkvy0tIrqjuwe09\ne+TdI/fZIMWkleeKzs2NLEQu5H3kRnN8NjpXbVcd5VbrjEojF6rfb4t7luQ7XuXrWMViiYt7\noHvPJO1TjBgXHM5/A8hF2Y3caIjn0L9//8whwYtHrt9yB3/44Yejyy67zLs/y/tF3z4KkrS+\nctdWfnJLdqNdvp6Ke+OUEv/b2bKELP1S56dYLKqzix4bua8fR3KVlluwG/Xy2+V6XMiVPCuz\nPCviLS8staELq+/PUeeq9lfMmzjrPIezCQJNSgA34ybFT+EtlUAlFBSxUmwPZ6+RCbimB5se\niHoIK3hbXPTwl8Khh2B4QCq9HtJulCCe1P92b9nRqquu6h+KSqeH2IABAyJnw1FyWilMzmPE\nK0rK00V99XlJSXNfYM5yrZ1//vkjKV4KcBYk3/GFFBQdo3gmbiQjcw56CLuvOUdudMUvFXgu\nBGsLCopcod2oiz9GAeM23XTTOnyS1ld1kJISPhSoc9afAqQV+mCii6Tr6ya35pBe9ZTCcvbZ\nZyvLRokbMYsUEE4KqPLXuboout51HAWlUWg5uMIEWil/12kRCECgGRGQ4ap7mPvvuMhNN3iM\n1HcKCncuN2JNgdQnMhB1gcL8dEU+Q9T4sUnTulgipjqH6Y2Qh4ut4m1AVI6mSORGnU8KHZ8v\nrYw/ZXejusm+pZD9htx/7777bu+K7EYYTHxk9+IUpXzZ+m1J66vEmipSiHs3+uRDywcblIKZ\nux0Khy/2qrem38op3377rXebzhfGv5zlkBcEykUABaVcJMkHAlUmIPsEPdBdtNkql9wyiosr\nKMEYtZxnpq9Py4ZGS9mDIBCAQHEE8OIpjhepIZAaAvpCLpJeAvrooQLglUs5kfGtRkGSiNzB\nXaj9JElJA4HUEkBBSW3TUDEI1E+AQFv182lor0Y3NLVUaFqpoeOT7M+NzJvkmEJpjj32WO+e\nXWh/fLumiEKgtvh2fkOgORFgiqc5tRZ1hQAEIAABCNQIAeKg1EhDc5oQgAAEIACB5kQABaU5\ntRZ1hQAEIAABCNQIARSUGmloThMCEIAABCDQnAigoDSn1qKuEIAABCAAgRohgIJSIw3NaUIA\nAhCAAASaEwEUlObUWtQVAhCAAAQgUCMEUFBqpKE5TQhAAAIQgEBzIoCC0pxai7pCAAIQgAAE\naoQACkqNNDSnCQEIQAACEGhOBFBQmlNrUVcIQAACEIBAjRBAQamRhuY0IQABCEAAAs2JAApK\nc2ot6goBCEAAAhCoEQIoKDXS0JwmBCAAAQhAoDkRQEFpTq1FXSEAAQhAAAI1QgAFpUYamtOE\nAAQgAAEINCcCKCjNqbWoKwQgAAEIQKBGCKCg1EhDc5oQgAAEIACB5kQABaU5tRZ1hQAEIAAB\nCNQIARSUGmloThMCEIAABCDQnAigoDSn1qKuEIAABCAAgRohgIJSIw3NaUIAAhCAAASaEwEU\nlObUWtQVAhCAAAQgUCMEUFBqpKE5TQhAAAIQgEBzIoCC0pxai7pCAAIQgAAEaoQACkqNNDSn\nCQEIQAACEGhOBFBQmlNrUVcIQAACEIBAjRD4P7Yd5KH5zxooAAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + }, + { + ""data"": { + ""text/plain"": [ + ""Plot with title “Histogram of inf$bootstraps$b”"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl\nR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRB\nkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4\na73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PC\nv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UA\nVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXd\na8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8\nHOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojL\njVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0\nyDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5Pt\nXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEw\nQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXH\nliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vW\nc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUt\nVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJf\ncl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdd\nuwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqv\ngcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCg\nKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8A\nrD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvF\nY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAAIooAMA\nBAAAAAEAAAGAAAAAANfxKOcAAEAASURBVHgB7Z0HuNRE18cP0kE6Ir2rKIiAFQRRFAEbCBYE\nFMSCrw0R2ysgioK9YceO+loQUVFQFFR6EVEQxEJVQEDpveWb//hNzObu7k327m5yd//zPPcm\nO5lM+U2SOZk556SApYIwkAAJkAAJkAAJkECICBwUorqwKiRAAiRAAiRAAiSgCVBA4YVAAiRA\nAiRAAiQQOgIUUELXJawQCZAACZAACZAABRReAyRAAiRAAiRAAqEjQAEldF3CCpEACZAACZAA\nCVBA4TVAAiRAAiRAAiQQOgIUUELXJawQCZAACZAACZAABRReAyRAAiRAAiRAAqEjQAEldF3C\nCpEACZAACZAACVBA4TVAAiRAAiRAAiQQOgIUUELXJawQCZAACZAACZAABRReAyRAAiRAAiRA\nAqEjQAEldF3CCpEACZAACZAACVBA4TVAAiRAAiRAAiQQOgIUUELXJawQCZAACZAACZAABRRe\nAyRAAiRAAiRAAqEjQAEldF3CCpEACZAACZAACVBA4TVAAiRAAiRAAiQQOgIUUELXJawQCZAA\nCZAACZAABRReAyRAAiRAAiRAAqEjQAEldF3CCpEACZAACZAACVBA4TVAAiRAAiRAAiQQOgIU\nUELXJawQCZAACZAACZAABRReAyRAAiRAAiRAAqEjQAEldF3CCpEACZAACZAACVBA4TVAAiRA\nAiRAAiQQOgIUUELXJawQCZAACZAACZAABRReAyRAAiRAAiRAAqEjQAEldF3CCpEACZAACZAA\nCVBA4TVAAiRAAiRAAiQQOgIUUELXJawQCZAACZAACZAABRReAyRAAiRAAiRAAqEjQAEldF3C\nCpEACZAACZAACVBA4TVAAiRAAiRAAiQQOgIUUELXJawQCZAACZAACZAABRReAyRAAiRAAiRA\nAqEjQAEldF3CCpEACZAACZAACVBA4TVAAiRAAiRAAiQQOgIUUELXJawQCZBAsgn88ssvctNN\nN8mUKVOSnTXzyyACw4cPlwEDBmRQi/J3Uwrl7+qz9okS2L59uyxZssQ+vX79+lKiRAn7t3Pn\nxx9/lAMHDuioypUrS6VKlezDyAN5IRx66KH6zz7InYwjYFmWLF68WGbNmiX79++XBg0ayJFH\nHinly5eP2dZUXiNe6rN+/Xp555135Mknn5QtW7ZIjRo1pHbt2lHru2jRItm3b58+hnTlypWL\nmo6RmUUA1/J3330nTz/9tKxevVrOOOMMad68uRQrVixHQ//++29ZtWqVji9SpIi+B3IkYkRy\nCKgbnCELCUyePNlSV5D9N3369JgU1E1opxsyZEhEOnUT28cGDhwYcSwvP5RQZD3xxBN5yYLn\nJpnAtm3brFatWtn9ba6f//znP3FLStU1klt9cLxXr15WgQIFctS5Q4cO1h9//JGj3occcoid\n9rXXXstxPKwRqbhfUpFnGPl98cUXVtWqVe1+N9d12bJlrVdeeSVHlZ955hk7rRJ0cxxnRPII\ncIknOXIec0kSgY0bN8qNN94oTZo0kW+++SZJuTKbZBAYNGhQ1CWSpk2bJiN733nkVp/zzjtP\nlJAh6nGZI+/x48fL1VdfnSM+v0Wk4n5JRZ5h5YpnzJlnnqlnTdx13LRpk/Tu3Vtmz57tPsTf\naSJAASVNoDO1GPXmIXXr1tV/yZgO79+/vzz11FP2NHumcsuP7VqwYIFd7ZNPPll+/vlnvdxz\n4YUX2vHRdpJ9jZgy4tVn9OjRMmnSJJ0U1+UNN9yg9y+66CJRsyR6f9y4cfl+8EnF/ZKKPE2f\nhW17/fXX2wLs+eefL0cffbSULl1aLr30Uruqd999t73PnfQSoA5KenlnXGnvv/9+UtvkfNtV\nU/NJzZuZ5Y3A0qVL7Qw6duwohx9+uP073k6yrxFTVrz6qCVMk0zU0qM0btxYC74tW7aU008/\nXc/SQQ/lq6++khNOOMFOm992UnG/pCLPMHLFTBH06xCgQ/Xee+/JqaeeKoUKFZJXX31Vvv76\na9m9e7cg3Z9//inQv2NILwEKKOnlnXGlQfkQSmUIJ510krRo0SKijVOnTpXPPvtMVq5cKZgy\nhYItZly6d+8utWrVstNu3rxZXn75ZVm4cKEd9+uvv8pjjz0mxYsXF6XnYMdjB0q7au1YMFWP\nvPGWjEGodevWenkoIrHjx969e+Xtt9/Wb84bNmzQ9cVgC4VIzNzgOMKVV16p36Sw//zzz8uO\nHTuwq6d8Ucc333xTP8iULoOeIsZDDeH333+XN954Qysgr1u3TtcdDzYo3Z177rniFLrQBqVn\no8/Dv379+slff/0lH374oYBbqVKlBAPqBRdcoMvCwPHJJ5/oQXXt2rWCWYz27dtrnnYmHnf8\n8BszZowsW7ZMoBxoAqa90TdqnV4zMfHRtvGukbfeekvQFgTMxFSvXl33KdqP/m/YsKGcc845\nctxxx9lZe6nPmjVr7PQ1a9a097GDvr3qqqsi+iIigeMHFMD/97//yYwZM/SbdrNmzeTiiy+O\nUBR3JNe7uB9wDgY/KOVCkRjXJpacYimi40Q/feLnftm6dau8/vrresYL1ycUP3FNYjAGW3Pt\nes0zVfcDGOAZgHog9OjRQw4++GD5/PPP9WwY4iFMgr+ZBdMJHf+8Pm9wivMaqVKlis0BxwoW\nLCgQgA0bxMULuB8+/fRT/fyC4A62WDpiyCMB9dBjyEICqVaS3bNnj6UeyLYymbpMI/YPOugg\nS71Z2+SVpUfEcWd69XZjp8OOelBZJ554YtT0yFeZk1pKoIg4Bz9QxvHHH5/jvAoVKlhQEi5Z\nsqR9bPny5fb5TsXJZ5991lIPLTudErgsJdTotDimHmz2MWcbsN+tWzdLvZHZ+YKRM82cOXMs\nNUBHxOG4Wpaw1CCjt8702IcinxKY7Dy97Pjlp4SgHHUy9ahXr16uRcZTkj322GPtvJXwZXXu\n3Nn+bcoA00ceecQux0t9br/9djsfJThbSmDQv5UZqZ1PtB1nX995551Wo0aN7HxMfdTgbkGx\nMlpQgmvMa+Cwww6zlJlztNN8X9Ne7xc1aFq4f0zd3Vsl+Fm4DhG85ulklMz7AXWoU6eOXdcJ\nEyZEvV+h0IrnlzP4fd7gXDwjnArU6Dsl9Gtezrzd+04lWSX8Wvfdd5+F546bbc+ePS0oajMk\nTgBvBQxZSMAtoKh1Z0uZ2EX9cw66Xq14brvtNvuGhRUQBqKzzjrLgjBgbmTsq7dNTd/rwxED\ntXPAQ17RHg6nnXaapd5I7Z5VZoSWeou1y8Z5eNCqmRMdp2ZpIgaWWAIK0pn6Y6vWsHUZEHCc\nD7uiRYvqwU3N7ESkd/JzCygmbwgpTmEJ5Zh8wNI5QOAYLAnQPi8hEX5eBIJ4ZTv7y23p5RRQ\nTLvUG34OQQ1CoekTL/VRMx4R3NEfYDV48OB4Vc3BFudUrFjRwkCEffOnZkJyWAG9++67EdcQ\n0rqvTfyeOHFiRB0S6RMv94uaIbDKlClj1xkDO+5BpdQcUa///ve/uj5e8kRC009on7lmDZe8\n3A/I2ymgmGcF+l7NJtrtQFm4P8yzA+f5fd7gHAT3tYTrROmgaIHxnxQ5/zsFFNNuPCPVzImF\na9fEYasU/nNmwBjPBCigeEaVWQndAorzpoq37xxgQSTW4IO3RZOPmna14WEgVcsWFh4EGJzU\nWq8+hpmF+fPnR8y6KF0BHeecITj77LPtfNX0rz4fD3i1nGLdcccdEULCc889Z5f70ksv2eeh\nXs43abUEZSEvU19s1ZKGfa7zgYxjainCUsswFoS6uXPn6nR4EBkBpU2bNvYMDoQQNS1t592u\nXTs7X7eAUrhwYevLL7/Ux9XSQMTDGuWqZSJLLZNZu3bt0m111hcmoV5CIvyUzwdLLbdYmDkw\nZeI6QJwRGuKVHesawTlOAQV533rrrfZbp5rut8vDsREjRuhivNbniiuuiDjf1P2oo46yHn74\n4YjZLFN/d18//vjj5pCF6wSCickHJswmQEB1zqyhn5USsZ6dwL3mvB/UEqello7MqVYifeLl\nflHLZ3Zdce04A9qCdlSrVs1SS496QPaSJ/JwM0rW/YC8nQIK6qeUm/W9hJeNUaNGRQhEaqkO\np+jg5OvleWPOw33jFOJM30LwuuSSSyzMarqDW0BRirXWihUrdDLMmKglY5s77mnlJNCdBX97\nJEABxSOoTEuWagHFzEzghlfrsZayqrCUspnGiJvYLIu4ueKhbx4SmO53BjzwzTFsnQKISYeH\nikmj1pVNdMSbEgQId8B0vjkP21gCCt6kd+7c6T5d/4ZQMW3aNAsDqDPce++9dt5YYjLBLaDc\nfPPN5pDeXnfddfZ5EH6U/oB9HGU466uUPe1jsXbywg95OpefXnjhhVjF5Ij3KqDgzd49E+S8\njoYOHRqRd271waB211135XirNdwgHDmZInPn4BvtOlF6QjZ3DGwmYPnO5Kt0q7QQaY5hqxzA\nRcyuGH557ZN494tTwIMAfs8991g//PCDPbMIYTdaiJcn0jsZJfN+QN5OAQUzns5ZUBx3zpRg\nFsUE53Xi53mD89E3xxxzjN1/ph+xhYChHPyZYvTWLaDgWeoMSqE24ppzCrnOdNzPncBBqhMY\nSEArDaqBVKL9qelL34RgKWECtOG7dOkiaspW1AAt6u1VnCaiJl1uW+RjAuoEHwXuAOVHE6AE\nBy+iCE6LD2fdTFo11Wt2426h6BrNuyROglKrURJWb3tyyy23iNKVETVI2nmqt1R7370DNs6g\nBkD7pxoItAKpiXB7bo2XrzknL/xMHqncKkFG1BJIRBFQXjQBStZ+ghLqRA3K2usn3Ny7g5r9\nkr59+7qj7d9t27a1982Omhkxu1qZ0ygOKwHRjr/ssstEzRDav7EDb7tQajZBCQp6N5V9AoVx\nNaujy1EvBaKWt0QNxFrBVwlUWqkTSrx5Cam8H9xK5ahnp06d7OpCgdkoujrvab/PG/TN999/\nr/0uKUHHzh87UJqH8jqORwt4FkCR3RngURt+nExQS2dml1ufBCKfBj5PZvLMIXD55Zdrc0yY\nZLr/EhFQ4FYcFg/OoN6G5Ntvv9WDBo7BgsBYADnTxdpXnj/tQ2pqWuBm2h1gIeQMcF2OoJYi\n9Bb/8ABxB+dA6D7m/O20PHLGYx8WNngwoW7wt/Hoo49qayH1nmAndQ/A9gG14xRIEK/e3uzD\nsJZxhmhtdx6Ptp8XftHyS3acu43IP5Yw6KdsCHNqGUWfomaptFWUOf+DDz7QllPmt3MLSxd3\ngE8XZ1BT+9rlP8xQTVCzAGY3Yuu8Ns11mco+UQrMopY2tUWKsyKwFIMlGyzpkEZ5S3Ue9rWf\nyvvBzRoVU7NmEfVTM536dzKeN6eccorgRQDXIcyMzXMCzy1YF0ULSANB2B2cdcc1wpAYAQoo\niXHjWbkQgLMjmN7BYRYGB5gLugPM8vAm5zU4BzCldxL1NGOiaA4qBUe96xz8zayKSYNttDjn\ncbMfy0wUZpx4uzNvxnD4BIdXY8eOlfvvv9+cnmOGwD6gdpwCCeKdD75EBBJn3tjPCz93Xqn4\n7Z51QBnxBLrc6qCWi2wTZpMWvk8wu6V0FkyUNme2fzh2os3YGHNzkwzXFwR45/Xt5do012Wq\n+0RZkmiTd6WfFfWbMRBWYHbtnAEybfOyTeX9gLq5A2aCnAHuBRDy8rxBns4+wzXXq1cv/YJh\nysLHJqOFaNcI0jmvE9PX0c5nXHwCFFDi8+HRPBDAgxuDNmYW4OxI6WfoaWYMEibA1bSZJjdx\nZos3F2dwnof8ok2dYobGBAzqxpmY89yZM2eaJPbWOdVuR0bZiTaIItmwYcP0mzT2le6IKIVf\nUaaxepbIOYOSyGwU8kxGcDLwyy8Z5eeWh1Mgyy1tvOMQUvEmjL7CzNhPP/2UIzl8k5iApblo\nYd68eTminQMVri/zRu9kqxQrc5wHYcmZHwRYBOd5ee0T9/1iKoFZDqW/ozko3SXtw0fpd9kz\nK7g+MZMULcTK06RN5f1ghH1TFrbwjWMCBAnnrJTf540yD9azluh/59KwyR9LPybEukZwrZlZ\nHJMWW2c9nXV0puF+7gQooOTOiCl8EsCDBc7PMAjgDQtr/VgLh37G3XffrZ1YObNUyqL2T7Nm\njghnPH5j/V8pxmFXB8xQGMdqiMAsCB46JsA5mpmVMFP8OPbxxx9rocmkg1Dz0EMPmZ9xt876\nmYR403MOXFi6cgalRGf/NF/KtSPSuJMXfmmsZp6LwmwZ3lohFGDwxZKl8zqBAz3lY0OXg+vD\nCLHuguEB16krhb5T1l92MuhzmBkeDPgmYPkEjt2cAQ75zDIjBDGjy5LXPnFej+77Bd8qgt4L\nWMCNOwKWHrC0g5lNp96Gk0+8PJ1twr4zrTmWrPvho48+itD9gLCEpRwTIEBAQEr0eQPneUYH\nBzzc39yBM0YTlD8cs5tji2ea8yUE9Xa+PLmXunNkwIjYBBRYhiwk4LbiSebXjGFCaXwYqCvP\nUt5A9VdBoS2v3Elrc1nE4w++A5zBaSUBk05Y16jvYthJlPdSfZ45X938FqxkYGIMk0kTDw1/\n9WZjn6eElwjfImpg0SbSMHlWg5R9njnfea7TakF9fM7O0+yogSvC/BGOweCHA39KkTcib5hD\nmuC24nE7/1IPPvtcp/UPzoe1i6krtjAb9RIS5Ye8c7OaiVW+Vysetwk78oNFhmknTJCdIV59\nYOFlzsNWzSLo32pQjrg2YSruDM6+xnlqcLfUQK9NnHGtOPOEYzkTYLmBa9kcVwOn1adPH0sJ\nvpaaRbTjcfzaa681p+ltXvok3v3y4IMPRpQLKzE1Y2nNmjVL10vNANnH4cjOhHh5Io2TUTLv\nB+TttOIBK/gkgSUWrJ5gVWX4YmscPSb6vIGjNmd5eN6gbdg6Tb/V7EmEZZ7bigd1gX8ZmMEP\nGDAgwoIH960SrNA0hgQI0Mw4AWiZcEoqBRTwUS7ota8T5wPFvY8HJAZxZ1BuzCMeQuYceD81\nQbmkt32OmOPOLYQT5V7dJLe3ahlHP/CcabEPnwcPPPBARLnqbdc+L7cHMhI6H+ru/J0mkBi4\n4LcFIQgBBeUmyi+eQIB8Y4UgBBQMCuozBBF96u4X+KeBabgzOPvaLVw6z1dWac7T9D6ElGie\nZ53nwYGgu0ycnGifxLtfYA6vZmjiMkDd4LfDOYjGyxN1dTKKJqAgTSL3A85zCgzwL+Jk59yH\n7xZnSPR5A4EN96Qzb+c+nlEjR450FmU5BZRWrVpF+LhxngvT7ngvfhGZ8kdUAlziUVcUQ/IJ\nwGxXufXW3x8x0+DOUrDkot7k9Pd73PGwKHIGTFHjuzkm4Auk+L4LvoPjVH7FdC+mzKH/ge91\nuAPMLqHzgvzr16+v9ROQDl+9dS/LKKHFfXrc31CEVQ/liClv5AHzVuXrwv7uEMyB8a2dIEOi\n/IKss9+ysYyCpTyYGcO83RmgN6K8p+rrM5ZuAdKr2TtRA7C2yjLnY4kReeLDcu4Aiw7oMuG7\nUcoZXISSMyy7sDykvMhqc3T3uYn2Ce6jWPcLLKCw3IBrE+W7gxI0tCIo7iWn/k+8PN15xPqd\njPtBzUAJltmc/Qf+WLpy30OJPm9guQOdIZgKOxlg6U/N2AiWZ51fNna3F/o9WM5TMyj2cjLS\nKB87Ol+YzjMkTqAAxJbET+eZJJA7AWjJ44N+WPuH6SZu6twEACjOLl68WKfFgBIrYF0aegJY\nCz/iiCMiBATnOdBPQZlOawvncQhTeFiZoN4+EzJxxZo29FEgLGGNPNoavSkjDFuv/MJQ10Tr\ngDbClBaKkPAFAp0BvwFKj7gm8PFCr4rOEKpxDUPHBUK215BIn+R2vyBP+AzBxwIRoJwby0TW\n1DO3PE26eFu/9wMUStXyqs5SfXpDK5xjiIKQD+EeuiC58U/keYMCoTujZrj0swrPK+fLT7w2\nmmOw3MHLESzEnEKVOc5tAgSizqswkgQyjAC+N6JuD/0hMHgsVbMmES3EN1pwHH/qIRlxjD/y\nPwHo96BvnZ84yP+tyrwWOJd48G2wdAcvHwtMd52yubxC6qZlIIGMJ2C8eOKtFn/wv4JlHfhP\ngJURPtNuAvxCMGQWAcxmKUVL29NvZrWOrUkWAaWILbF8mySrDObjnQCXeLyzYsp8TqBHjx6i\nPqAWtxVqdkXgJwU+LhhIgATSSyDaEk96a8DSwkSAMyhh6g3WJaUElDa+/ibQs88+qx0pYU0e\nvi3gG0JNLUvXrl3l6quvDr3eSEohMXMSCJAAZjrhfh8hnu5ZgFVk0WkkwBmUNMJmUeEioNZ2\ntTOvsCuyhosaa0MCJEAC6SFAASU9nFkKCZAACZAACZCADwL0g+IDFpOSAAmQAAmQAAmkhwAF\nlPRwZikkQAIkQAIkQAI+CFBA8QGLSUmABEiABEiABNJDgAJKejizFBIgARIgARIgAR8EKKD4\ngMWkJEACJEACJEAC6SFAASU9nFkKCZAACZAACZCADwIUUHzAYlISIAESIAESIIH0EKCAkh7O\nLIUESIAESIAESMAHAQooPmAxKQmQAAmQAAmQQHoIUEBJD2eWQgIkQAIkQAIk4IMABRQfsJiU\nBEiABEiABEggPQQooKSHM0shARIgARIgARLwQYACig9YTEoCJEACJEACJJAeAhRQ0sOZpZAA\nCZAACZAACfggQAHFBywmJQESIAESIAESSA8BCijp4cxSSIAESIAESIAEfBCggOIDFpOSAAmQ\nAAmQAAmkhwAFlPRwZikkQAIkQAIkQAI+CFBA8QGLSUmABEiABEiABNJDgAJKejizFBIgARIg\nARIgAR8EKKD4gMWkJEACJEACJEAC6SFAASU9nFkKCZAACZAACZCADwIUUHzAYlISIAESIAES\nIIH0EKCAkh7OLIUESIAESIAESMAHAQooPmAxKQmQAAmQAAmQQHoIUEBJD2eWQgIkQAIkQAIk\n4IMABRQfsJiUBEiABEiABEggPQQooKSHM0shARIgARIgARLwQYACig9YTEoCJEACJEACJJAe\nAhRQ0sOZpZAACZAACZAACfggQAHFBywmJQESIAESIAESSA8BCijp4cxSSIAESIAESIAEfBCg\ngOIDFpOSAAmQAAmQAAmkhwAFlPRwZikkQAIkQAIkQAI+CBTykZZJPRLYsGGD3HHHHbJnzx5P\nZ+zevVuWLl0qs2bN8pSeiUiABEiABEgg0wlwBiUEPbx582aZPXu2Z4EmBFVmFUiABEiABEgg\npQQKWCqktARmniuBGTNmSIsWLQQzKUWKFMk1PROQAAmQAAmQQKYT4AxKpvcw20cCJEACJEAC\n+ZAAdVDyYae5q7xo0SLZt2+fOzrtvw855BCpUqVK2stlgSRAAiRAAplHgAJKPu/TiRMnyhln\nnBGKVtSqVUuWL18eirqwEiRAAiRAAvmbAAWU/N1/Wm+laNGi8sknnwTakkmTJsmrr74aaB1Y\nOAmQAAmQQOYQoICSAX1ZoEABKV26dKAtKV68eKDls3ASIAESIIHMIkAl2czqT7aGBEiABEiA\nBDKCAAWUjOhGNoIESIAESIAEMosABZTM6k+2hgRIgARIgAQyggAFlIzoRjaCBEiABEiABDKL\nAAWUzOpPtoYESIAESIAEMoJA1lnxbNy4UfDtG7iVP/jgg6Vs2bJSsmTJjOhMNoIESIAESIAE\nMoVAVsygzJs3T6688kqpVKmSlC9fXurUqSMNGjSQ6tWrayGlXr160qdPH1m/fn2m9CvbQQIk\nQAIkQAL5mkDGz6AMGTJEBg8erDupZs2a0rx5cy2kYPYEMykbNmyQlStXyogRI2T06NEyfPhw\n6datW77uVFaeBEiABEiABPI7gYwWUEaNGqWFk/bt28vQoUOlWbNmUfsLH3SeMmWK9O/fX7p3\n7y61a9fWXxeOmpiRJEACJEACJEACKSeQ0Us8H374odStW1ewjSWcgDA8sZ5yyikyYcIEKVWq\nlIwcOTLl4FkACZAACZAACZBAbAIZLaDMnz9fL+ngWzVeQrly5aRx48ayatUqL8mZhgRIgARI\ngARIIEUEMlpAqVKlisydO1f27t3rCR8sfCDUQIGWgQRIgARIgARIIDgCGS2g9OzZUxYvXixd\nunSRWbNmxaRsdFCgq7Jjxw7p1KlTzLQ8QAIkQAIkQAIkkHoCGa0kC2ucdevWycCBA2Xs2LFS\nrVo1bVpcoUIF/fXfLVu2aCueFStWyJo1a6RQoULy6KOPysknn5x68iyBBEiABEiABEggJoGM\nFlCg/NqvXz/p2LGjDBgwQCZPnpxjJqVEiRJStWpVbcHTt29fqVGjRkxYXg/s2bNH3nrrLcHW\nS1i6dKmXZExDAiRAAiRAAllDIKMFFNOLsOR5++239U/MmsD/ya5du7TjtjJlyphkSduuXbtW\nHnvsMc+6Lzt37kxa2cyIBEiABEiABDKBQFYIKM6OKl26tF7eMXFweY8lHniTLViwoInO0xaz\nMAsWLPCcx4wZM+h3xTMtJiQBEiABEsgGAhmtJGs6cNmyZfL888/LmDFjZNu2bToaOicXXHCB\nVKxYUY444ggttGAZyKvFj8mbWxIgARIgARIggeQTyPgZlMcff1xuvvlmmxy8xM6ePVtuuukm\n7doeHwvs0KGDfP/99zJs2DD57bff5N1337XTc4cESIAESIAESCD9BDJaQPnss8+08mvDhg3l\n6quvln379mmX9y1btpRffvlFHnzwQbnhhhukePHiWicFad544w3p3bu3tGvXLv29kY9LhKIv\nPrYIpeOgQ+vWrWX8+PFBV4PlkwAJkAAJ5IFARgsoWNIpWbKkttzBFgEKs+eff742N8a3d4ze\nSbFixeSFF17QAxsGNwoo/q4qLJ3BY+99993n78Qkp542bZr8+OOPSc6V2ZEACZAACaSbQEYL\nKHDOBudrRjgB3DPPPFMgjJxzzjm2cGKgYyYFXmR//fVXE8WtDwKFCxcO3IfMn3/+SQHFR58x\nKQmQAAmElUBGK8ni2zoQUg4cOGDzxxIE3vKPPPJIO87sbNq0SebMmaP9opg4bkmABEiABEiA\nBNJPIKMFFCzT/P7771pJFm/WJmBp58YbbzQ/9RbWO3feeafA7LhNmzYRx/iDBEiABEiABEgg\nvQQyWkCBpU6zZs3kySefFFjv4GOA0cLo0aO1Tspzzz0np512mnTt2jVaMsaRAAmQAAmQAAmk\niUBGCyjQNZk6dap2c9+4cWPBkk+0sH37du2WHrMq48aNE7jIZyABEiABEiABEgiOgC8BBSa5\nH330Ub5yZgbFV+icwPdJrHDhhRfKX3/9pWdaINQwkAAJkAAJkAAJBEvAl4CC2YVOnTrprwJj\n+QTOzTIhQIgx5saZ0B62gQRIgARIgATyOwFfAgq+GfPEE0/oL/5Cr6Np06bSpEkTHbdu3br8\nzoL1JwESIAESIAESCAkBXwJKpUqVpG/fvjJ37lzta+K2227TSyP9+vXTsyodO3bU37vh92xC\n0rusBgmQAAmQAAnkUwK+BBRnG+E+Hq7iV65cKV9//bV2GT9z5kzp3Lmz9iOC79/Q4ZmTGPdJ\ngARIgARIgAS8EkhYQDEFLFmyRCZPnizffPONYJkHFjCYacFSELyyDhkyxCTllgRIgARIgARI\ngAQ8EUhIQMFH4Z566ik58cQT5fDDD5e77rpL/v77b73F14AXLlwoEFzOPfdcGTx4sLz22mue\nKsNEJEACJEACJEACJAACvgQUODQ7++yz9RIOfIYsWLBAunfvLl9++aUsW7ZM7rnnHv0xPmRc\np04d/fE97E+cOBEbBhIgARIgARIgARLwRMDXxwJvvfVWLYicdNJJcvnll8vFF18sZcqUiVlQ\noUKFpFatWtqba8xEPEACJEACJEACJEACLgK+BJTrr79ezjrrLK1b4son6s8KFSrI8uXLox5j\nJAmQAAmQAAmQAAnEIuBLQIFlDgKWbPBtm3r16unfq1evljvuuEN69uwpp59+uo7L9n+LFy/W\n7vO9cIDeDgMJkAAJkAAJkMC/BHwJKBBErrnmGhk7dqy89dZbtoCydOlSeeONN/TfoEGDst5y\nBwLHUUcdJZZl/UuaeyRAAiRAAiRAAp4J+FKS7d+/v4wfP16w1HPmmWfahbRs2VImTJggrVq1\nknvvvVemT59uH8vGnfr168vmzZtlw4YNnv4+++yzbMTENpMACZAACZBATAKeZ1AwG4APBZ5/\n/vnaxNidY9u2baVRo0baDf4777wjLVq0cCfJqt+lSpXy3N7SpUt7TsuEJEACJEACJJANBDzP\noGzdulV27twZV8ekSpUqctxxx2nvstkAj20kARIgARIgARJIDQHPAgre8uGULd4XjPENHuij\nGOXZ1FSZuZIACZAACZAACWQ6Ac8CCkCcdtpp8uKLL8rbb7+dg8u2bdukT58+Ai+zZ5xxRo7j\njCABEiABEiABEiABrwQ866AgQ3xXB18y7tatm/YaC0uVsmXLCqx7Zs+eLRs3bpRLL71UOnTo\n4LV8piMBEiABEiABEiCBHAR8CSj4COBXX30lcHOPLxh/+OGHtilt9erVZdiwYXLVVVflKIQR\nJEACJEACJEACJOCHgC8BBRkffPDB8sorr+gyYEq7cuVK7c6elih+sDMtCZAACZAACZBAPAK+\nBRRnZvgOz9FHH+2M4j4JkAAJkAAJkAAJ5JmAbwFl0qRJ2mPsunXrtNlxNG+pvXr10m7v81w7\nZkACJEACJEACJJCVBHwJKO+9957+gnFupFq3bp1bEh4nARIgARIgARIggZgEfAko+M5OyZIl\nZcSIEdrkGEqz0cJBB/myXo6WRcriYGkE3Zndu3drfRpYIaFNDCRAAiRAAiRAAuEh4FmS2L59\nu/z666/ajBhmxvAaW7Bgwah/BQoUCE8LVU3mzZsnV155pUCgKl++vNSpU0caNGggsDyC0i8c\nyxkfLqGqOCtDAiRAAiRAAllKwPMMSvHixQWWOvlttgG+WwYPHqy7t2bNmtK8eXMtpEAwMR/0\ngyUSZoVGjx4tw4cP135esvR6YLNJgARIgARIIBQEPAsoWLaBbgm8yD700EMS5mUcQ3bUqFFa\nOGnfvr0MHTpUmjVrZg5FbKHoO2XKFMHXmrt37y61a9fO+o8dRgDiDxIgARIgARJIMwHPSzyo\nF9zclyhRQi644AKZPHmy9oHy999/i/sPHxUMQ4Ajubp162qHcrGEE9QTS1KnnHKKTJgwQfAV\n4pEjR4ah+qwDCZAACZAACWQtAV8CynnnnScwLx4zZoyeTalVq5ZUrFgxx9+DDz4YCqDz58/X\nSzpFixb1VJ9y5cpJ48aNZdWqVZ7SMxEJkAAJkAAJkEBqCHhe4kHxTZs2lapVq+ZakyOPPDLX\nNOlIAEVefDsIX1kuXLhwrkXCwgdCDRRmGUiABEiABEiABIIj4EtAee6554KraQIl9+zZU3r0\n6CFdunSRAQMGyIknnhg1F+igTJ06VW655RbZsWOHdOrUKWo6RpIACZAACZAACaSHgC8BxVkl\n6Jn89ttvekDHwA8z5LBZ+MAcGktSAwcOlLFjx0q1atW0aXGFChW0RdKWLVtkw4YNsmLFClmz\nZo0UKlRIHn30UTn55JOdTeU+CZAACZAACZBAmgn4FlBgkouZhvfff19/ybhly5baAgYzFQ0b\nNhQ4c/Oq85HqtkL5tV+/ftKxY0c9gwLF3lmzZkUUC6VfLFvBgqdv375So0aNiOP8QQIkQAIk\nQAIkkH4CvgQUzDLAGgZWO9AzwXKICVgmgSkvLGe+/fZbKVasmDkU+BaWPDCPRsCsCfyf7Nq1\nSztuwwcPkx2WLl0qxx57rOzZs8dT1vv37/eUjolIgARIgARIIFsI+BJQbrzxRv2BQPgMwcxJ\n586dZf369ZoVnJzBIRqElNdffz2UiqYHDhzQSztwOBctQFCAAAOndHkRsOBHBd8tgnKul/DT\nTz/pWSkvaZmGBEiABEiABLKBgC8BZeLEiXLddddp4cQNB27vIaA8/fTTMnPmzNAIKGvXrhUI\nVl988YWe0Tj++OPlvvvui6pnsmDBAm2pdPfdd9veZ93t9PIbTuzatm3rJalOA/NmBhIgARIg\nARIggX8JePaDgpkFmOEeccQR/57t2oMpL/RQkC4MYdu2bQKBBLMZmB3Bt3e++eYb7ZQNVj0M\nJEACJEACJEAC4STgWUDBskjlypVlzpw5MVsCIWbhwoX6Q3wxE6XxwMMPPyy///67ng35448/\nZPHixbr+jRo1kmHDhsnNN9+cxtqwKBIgARIgARIgAa8EPAsoyLBDhw7y0ksv6WUczE44w6ZN\nm+Syyy7TCqh+ljeceSR7f/r06VoRFmbGcGGPAOVVWPO0atVKHn/8cYEQw0ACJEACJEACJBAu\nAr4ElMcee0yb5N5www3apwgEAFiswLFZvXr15KOPPpJevXrJ6aefHopWwmU9BBH4N3EGWO58\n8skn2q397bffrpeAnMe5TwIkQAIkQAIkECwBXwJK2bJl5bvvvtMKsDDThQLq6tWrtWCCZgwf\nPlzPsATbpH9Lx7eCvvzyS21S/G/sP3tYsho3bpzWS4HH2WnTprmT8DcJkAAJkAAJkEBABHwJ\nKKgjPg74/PPPax8oS5Ys0QM7ZirgGwUzK7DmCUvATA58ntx5551akHLXC55lYd2D5Z+zzjpL\nPv30U3cS/iYBEiABEiABEgiAgG8BxdQRgggcoLVo0cLTBwTNeencXn/99XLUUUdpXRN4iH3n\nnXdyFA+rpAkTJghMg6GrggCncwwkQAIkQAIkQALBEUhYQAmuyt5LhrM1uLaHH5SaNWtKkSJF\nop7cpEkT7f22ffv2UY8zkgRIgARIgARIIL0EIrVHcym7T58+Wu8kl2TStWtX/ZdbunQcP/jg\ng+XJJ5/Uf/AkGytAyXf8+PHaDDkvXmRj5c94EiABEiABEiAB7wR8CSjQ11i2bFnc3OEMrXXr\n1nHTBHUQyzi5BTh2YyABEiABEiABEgiWgC8BZd68eeKehcBvOEH78ccf9ZeDMXuCLwgzkAAJ\nkAAJkAAJkECiBHwJKLG+/FuhQgU55phjtJv7pk2bat8j5513XqJ14nkkQAIkQAIkQAJZTiD3\nNQ8fgKBsCt8jWApiIAESIAESIAESIIFECSRVQNm9e7f2h7Ju3bpE68PzSIAESIAESIAESEB8\nLfHAe2w0HyH79u2T9evXaz8i+EbPcccdR7QkQAIkQAIkQAIkkDABXwIKnJ7lZsUD521XX311\nwhXiiSRAAiRAAiRAAiTgS0A55ZRT5PDDD89BDea7+LZN48aN5corr5RYyrQ5TmQECZAACZAA\nCZAACUQh4EtAee2116JkwSgSIAESIAESIAESSC6BpCrJJrdqzI0ESIAESIAESCBbCfiaQfHq\n6t4N89JLL5UuXbq4ozP2959//im9e/eWPXv2eGojvrjMQAIkQAIkQAIk8C8BXwLK/PnztcdY\nWOog4IvGZcuWlQ0bNkS17jHFnHjiiWY3K7b4/k/z5s09CyjwxPvtt99mBRs2kgRIgARIgAS8\nEPAloLzxxhvSsmVLadOmjQwePFgrxRYqVEgPxJMmTZKbb75ZK8t+/PHHgngTSpQoYXazYgsB\nZdCgQZ7bOmPGDKF+j2dcTEgCJEACJJAFBP6VIjw09oorrhC4sh8zZow4P7xXpEgRad++vTRq\n1EiOOOII+eCDD+Saa67xkCOTkAAJkAAJkAAJkEBOAp6VZOEldubMmdKjR48I4cSZJb5kDHf3\n33zzjTOa+yRAAiRAAiRAAiTgi4BnAQVLNli6WLVqVcwC9u7dK0uWLBF8PJCBBEiABEiABEiA\nBBIl4FlAgUJs27ZtZdiwYTJ79uwc5e3YsUOMlQ+WexhIgARIgARIgARIIFECvnRQ7rzzTpk6\ndarAKgdeZY888kgpVaqUwAoFSrL4SCD0VM4555xE68PzSIAESIAESIAESMDfxwLhyn7OnDna\nx8eUKVNk8uTJNsJDDz1UXnjhBe3q3o7kDgmQAAmQAAmQAAkkQMDXDAryr1KliowfP14OHDgg\nv/zyi6xdu1bq1asn1apVkwIFCiRQBZ5CAiRAAiRAAiRAApEEPOugRJ4mAqseKMUWK1ZMYL0D\nHRQGEiABEiABEiABEkgGAd8CysqVK+Wiiy6SkiVLakdtt9xyi64HzI8HDhyoBZdkVIx5kAAJ\nkAAJkAAJZC8BX0s8a9askWbNmsnff/+tFWSdsyaWZcnQoUPlww8/1G7bMbPCQAIkQAIkQAIk\nQAKJEPA1g3LjjTfKzp07BQqyixYt0sKKKXT06NEyYMAAWbhwobz++usmOnTbjRs3yvLly+Xn\nn3/WPl22b98eujqyQiRAAiRAAiSQ7QR8CSgTJ06U6667Tn+Pxw0OflLwfZ4yZcpoj7Pu40H+\nnjdvnrYuqlSpkpQvX17q1KkjDRo00LozcD4HJV/4cFm/fn2Q1WTZJEACJEACJEAC/0/A8xLP\nli1bBLMP+NZOrFC4cGFp2LChThcrTbrjhwwZogUnlFuzZk39lWEIKRBMNm/erL/EDL2aESNG\nCGaBhg8fLt26dUt3NVkeCZAACZAACZCAg4BnAaV06dJSuXJl7QcFztiiBQgxWOIJy4cCR40a\npYUTeLaFfgz0Z6IF6M9g2ap///7SvXt3qV27trRo0SJaUsaRAAmQAAmQAAmkgYCvJZ4OHTrI\nSy+9JE8//bRs27YtonqbNm2Syy67TM9KwCV+GAIUduvWrasVd2MJJ6gn/LfAM+6ECRO0Z9yR\nI0eGofqsAwmQAAmQAAlkLQFfAspjjz0mVatWlRtuuEE7Zps+fbosXbpUOnXqpPU4PvroI+nV\nq5ecfvrpoQA6f/58vaRTtGhRT/UpV66cNp2O90FETxkxEQmQAAmQAAmQQJ4I+BJQypYtK999\n951WKN21a5f2Irt69WqBYIIA/Q3MsIQlwOvt3LlztUM5L3WCjg2EGijQMpAACZAACZAACQRH\nwJeAgmpWrFhRnn/+ee05dsmSJTJt2jRtrgvfKJhZgTVPWELPnj1l8eLF0qVLF5k1a1bMahkd\nFOiqwLcLZoQYSIAESIAESIAEgiPgWUkWVYSJcfHixeWBBx6QQoUKaf0O6HiENcAaB19Yhofb\nsWPH6mUpuOWvUKGCQOkXSr0bNmyQFStWCJzQoU2PPvqonHzyyWFtEutFAiRAAiRAAllBwLOA\ngm/vwAEbBvhHHnkkX8CB8mu/fv2kY8eO2okcvr7snkkpUaKE1quBBU/fvn2lRo0aeW4bFIih\nr4NvFXkJf/zxh5dkTOOBAEzH//rrLxk0aJCH1KlLghlF/B1++OGpK8Rjzi1btpR27dp5TM1k\nJEACJBAOAp4FlCJFimgLFyyBYEkkP325GLM8b7/9tiaOWRMMYtChgeM2OJZLdoCAMnPmTNmz\nZ4+nrFEfhuQQgNL21q1btUVWcnJMLBcsLUJAPfrooxPLIEln/f7779o1AAWUJAFlNiRAAmkj\n4FlAgUAyZswY/aHA8847T66//nqpX7++HHLIITkqC6sZr5YzOU5OcQSWdvCXygB/MePGjfNc\nxIwZM+h3xTOt3BNCT+qpp57KPWEKU+CzEBA8g64HXAKsXbs2hS1l1iRAAiSQGgK+lGTx5WLM\noHzyyScChVIIKJiBcP/df//9qaktcyUBEiABEiABEsgKAp5nUEAD5rfwFZJbiOcOP7dzeZwE\nSIAESIAESIAEfAkoYfJx4qXrXnzxRW2p4yWtMw3c3Ddv3twZxX0SIAESIAESIIE0EogroMDq\nZd++fdKmTZs0Vil5RT377LPy/fff+87w7rvvpoDimxpPIAESIAESIIHkEYgroBhFv2XLlkWU\nuGDBAm1Ceeqpp0bEh+3H+PHjpXPnzgIlVJga9+7d21MVuUTlCRMTkQAJkAAJkEDKCMQVUGKV\nCsdnH3/8sTY3jpUmDPGwpvnqq6+kdevWAmFl8ODB0rRp0zBUjXUgARIgARIgARKIQyAhASVO\nfqE7BHPnl19+WfA1Y7jinzp1aujqyAqRQKYT+Pzzz+Wdd94J/KUG7hK6du1Kx3WZfsGxfRlB\nIOMFFPRSw4YNZdiwYdoTLpangnaelRFXDhtBAj4IwIfShAkTpEmTJj7OSn5S6KThpYWO65LP\nljmSQLIJZIWAAmhwZY8/BhIggWAI4EUBy6xBBixPM5AACeQPAr4cteWPJrGWJEACJEACJEAC\n+Z0ABZT83oOsPwmQAAmQAAlkIIFcl3g2btwot99+e0TTFy1apH+7402itm3byhlnnGF+cksC\nJEACJEACJEACvgjkKqDgg2cPPfRQ1ExjxZcoUYICSlRijCQBEiABEiABEvBCIK6AMnToUNm0\naZOXfCLSNG7cOOI3f5AACZAACZAACZCAHwJxBZSzzz7bT15MSwIkQAIkQAIkQAJJIUAl2aRg\nZCYkQAIkQAIkQALJJEABJZk0mRcJkAAJkAAJkEBSCFBASQpGZkICJEACJEACJJBMAhRQkkmT\neZEACZAACZAACSSFQFwl2aSUkIWZHDhwQCZOnCh79+711PqffvrJUzomIgESIAESIIFsIUAB\nJQU9vXz5crnoootkz549nnLfv3+/p3RMRAIkQAIkQALZQoACSgp6um7dugIPvF7DjBkzpEWL\nFl6TMx0JkAAJkAAJZDwB6qBkfBezgSRAAiRAAiSQ/whQQMl/fcYakwAJkAAJkEDGE+AST8Z3\nMRtIAiRgCEA/bO7cuTJp0iQTFdj2rrvukh49egRWPgsmgbAToIAS9h5i/UiABJJGYOvWrVKz\nZk1p165d0vJMJKNRo0bJjz/+mMipPIcEsoYABZSs6Wo2lARIAATq1KkjnTt3DhTG5MmTAy2f\nhZNAfiBAHZT80EusIwmQAAmQAAlkGQEKKFnW4WwuCZAACZAACeQHAhRQ8kMvsY4kQAIkQAIk\nkGUEKKBkWYezuSRAAiRAAiSQHwhQQMkPvcQ6kgAJkAAJkECWEaCAkmUdzuaSAAmQAAmQQH4g\nQAElP/QS60gCJEACJEACWUaAAkqWdTibSwIkQAIkQAL5gQAFlPzQS6wjCZAACZAACWQZAQoo\nWdbhbC4JkAAJkAAJ5AcCdHWfH3qJdSSBBAls2LBBfvvtNxk0aFCCOSTntDlz5kiFChWSk1kG\n5LJp0yaBu/ug++WXX37R/RJ03yxatEiqVq0qZcuWDbR3FyxYILVr15ZSpUoFWo+CBQvKjTfe\nKOXLlw+0HkEXnnUCysaNG2Xz5s2ye/duOfjgg/UNUbJkyaD7geWTQEoI4Ou969evlwkTJqQk\nf6+ZYgA6+eSTvSbP+HTr1q0TCI/79+8PtK3z58/Xg2D16tUDrccPP/wglSpVkipVqgRaj3nz\n5glYHHLIIYHWAwL9CSecIGeddVag9Qi68KwQUHDRPfPMM/Lxxx/rh7Ubet26deWMM86Q++67\nL/AL0103/iaBvBJo0KCBPPXUU3nNJk/nX3zxxXk6PxNPPvPMM+X6668PtGmoQ8eOHaVXr16B\n1qNNmzZyySWXSJcuXQKtxymnnCKXX3554F+7bt26daAcwlJ4xgsoQ4YMkcGDB2ve+Mx68+bN\n9RsDZk8wk4K3mJUrV8qIESNk9OjRMnz4cOnWrVtY+of1IAESIAESIIGsJJDRAsqoUaO0cNK+\nfXsZOnSoNGvWLGonW5YlU6ZMkf79+0v37t31GmSLFi2ipvUauXXrVtm3b5+n5Fu2bPGULlYi\n1D+vecTK22v8nj17JAz12Lt3rxw4cCBwHuh7TN8H3S+oA+oSdD3QJ2GoB65RXKtB80A9sMzM\nevzzhAGPnTt3hoJHWOrh9dmb0enUhZGxQc2EWGr5xtq1a5enNqrZFEspR1l9+vTxlD5Wol9/\n/dUqUKCApS4cX3/qAR4ry5jxX375pa8y/NaJ6f31IXmRl5dr4KCDDgrFfVuoUCHWw/GcVsqp\noeCBawjP9mwPGT2DAgUwLOkULVpU9XfuoVy5ctK4cWNZtWpV7onjpKhfv75AKRBval4D3qag\nue03nH766bJw4ULPszV+8/eaHm/IUEAO2hrAvKUHrf2OmZzt27cHbpWghHN9HZYuXdprV6Yk\n3Y4dO/TMFpZWgwzbtm0TJRxIiRIlgqyGnikoUqSIFCtWLNB6wJoIRgKFCxcOtB5Yasc1qgSm\nQOvx999/C8YBXCNBBnA46qijgqxCKMoO9mpIMQJohM+dO1cwWHi5ATHAQqhRMyh5rhkUE9MV\neCGnizTLIQESIAESSBeBYMXEFLeyZ8+esnjxYq0ZPmvWrJilqWk0rYMCXRW86XXq1ClmWh4g\nARIgARIgARJIPYECWONKfTHBlICmPfHEEzJw4EAteFSrVk3buGMZAtOJUFDD1OKKFStkzZo1\nenrxkUcekb59+wZTYZZKAiRAAiRAAiSgCWS0gGL6eOnSpTJgwADtuXH16tUmWm+xFg0PhvAF\nAMGkRo0aEcf5wzsBLKVlsLzrHQRTkgAJkEAeCEAHJmh9nDxUP2mnZoWA4qSFWRP4P4HyIDwX\nlilTxnmY+wkSeOihh+T2229P8GyeRgIkQAIk4CTw6quvBu5Az1mfIPYzWkk2GlAs7QRt0RCt\nXvk9DgrJFStW1N5683tbklH/kSNHytSpU7UDwGTkl9/zePDBB7VVExwnMoj069dPDjvsMLn2\n2muJQxGAF9kLL7xQOnfuTB6KwGmnnaafp9kOI+sElGzv8FS1HybSMJuEWTeDyNdff60/OEYe\n/1wNlStX1jOX5PEPD5iyQieOPP7hgaV2fHKEPP7hgedp0KbO/9Qk2P8ZbcUTLFqWTgIkQAIk\nQAIkkCgBCiiJkuN5JEACJEACJEACKSNAASVlaJkxCZAACZAACZBAogQooCRKjueRAAmQAAmQ\nAAmkjAAFlJShZcYkQAIkQAIkQAKJEqCAkig5nkcCJEACJEACJJAyAhRQUoaWGZMACZAACZAA\nCSRKgAJKouR4HgmQAAmQAAmQQMoIUEBJGVpmTAIkQAIkQAIkkCgBCiiJkuN5EQTgRbZw4cIR\ncdn8gzwie588yCOSQOQvXh/kEUngn19Z97HAaBAYl3cC+/btk1WrVkmtWrXynlkG5LBjxw7Z\ntGmT/lJ2BjQnz00Ai/3790uFChXynFcmZLB27VqBe/dSpUplQnPy3Ibff/9df7y1aNGiec4r\nEzJYunSp1K5dO+vd3VNAyYSrmW0gARIgARIggQwjwCWeDOtQNocESIAESIAEMoEABZRM6EW2\ngQRIgARIgAQyjAAFlAzrUDaHBEiABEiABDKBAAWUTOhFtoEESIAESIAEMowABZQM61A2hwRI\ngARIgAQygQAFlEzoRbaBBEiABEiABDKMAAWUDOtQNocESIAESIAEMoEABZRM6EW2gQRIgARI\ngAQyjAAFlAzrUDaHBEiABEiABDKBAAWUTOhFtoEESIAESIAEMowABZQM61A2hwRIgARIgAQy\ngQAFlEzoRbaBBEiABEiABDKMAAWUDOtQNocESIAESIAEMoEABZRM6EW2gQRIgARIgAQyjEDB\nu1XIsDaxOQkS+OOPP+Sbb76RVatWSaVKlaRIkSIJ5iTy4Ycfyv79+3U+sTJZunSpzJgxQxYt\nWiQFChSQihUrxkoaSHy6eZhGrl69Wr788ks59NBDpXjx4iY68G26efz555/6ely2bJmULl1a\nSpYsGTgDUwFc2zNnzpTZs2dL4cKFpUKFCuZQQtvc7pddu3bJ3Llz9f2yfft2fa8UKlQoobJS\ncVIyeOzYsUO+++47mT59umzatEnKlCkjxYoVi1rdZJQXNeMkRSajfn6ej37YJamJ6cnGYiAB\nReCuu+6y1APPUled/itYsKD14IMPJsRmxIgROo9HHnkk6vlr1qyxOnbsaJdlyjzttNOsJUuW\nRD0n3ZHp5OFs2759+6zmzZtrNupB7TwU6H46eWzevNk6//zzI64PNVBZw4YNC5Q2vBX/AAAc\nfklEQVSBKfyXX36xGjRoEFG/o446ylq5cqVJ4mub2/0yceJEq1atWhHl1a5d20J8GEIyeLz+\n+uuWeimKaGOpUqWsJ598MkcTk1FejkyTGJHX+vl9Pvphl8RmpiUrSUspLCTUBCZMmKAfDBgU\n1BuMNWvWLKtdu3Y6bvjw4b7qrt4ELfVGqc+NJqCoNwurdevW+vhFF11kjRs3zvr666+t3r17\nW2oWxWrYsKG1c+dOX2UmO3E6ebjrfs8992g2ENrCIqCkm8fxxx+vGfz3v/+15s+fb7366qsW\nBAAwefvtt93I0vr7wIEDVqtWrSwMnm+88Yb166+/WhAw1EyXVbNmTWvbtm2+6pPb/bJixQpL\nzSRYZcuW1S8MP/74o/XQQw9Z5cuXt9SskqVml3yVl+zEyeCB6wv3PoQuCKELFizQgskRRxyh\n+3zkyJF2tZNRnp1ZCnbyWj+/z0c/7FLQ3JRnSQEl5YjDXYCaLtYPhmrVqll4ezdh9+7dOr56\n9eoR8ea4e/vXX39Z3bt31w+UokWL6m00AQXCCAYazBK4w1lnnaWPvffee+5Dafudbh7OhkEw\nxCzWIYccojmEQUBJN49PPvlEt71Pnz5ONNbChQt1PITbIMOzzz6r6/H8889HVMPMgrjjIxI5\nfni9Xx5++GFd3qBBgxxnW9bgwYN1/L333hsRn+4fyeBx6qmn6rZ8/vnnEdVXy2c6HsKpCcko\nz+SVim1e6+f3+eiHXSram+o8KaCkmnDI88cMBgSG22+/PUdN77zzTn0Mg0Zu4YQTTtBpL7zw\nQgtTjsgzmoDy2muvacHnxRdfzJEl3o5xnlKLynEsXRHp5mHahTfv+vXrWy1btrRuueUWzUHp\n55jDgW3TzQMPXMwWRJtFw5IGBq0gA65zCOAbN26MqAaWpbAMddxxx0XEx/rh9X7BfYl74qOP\nPorICiwQf+2110bEp/tHXnlgxgAzZhBCnC9Iph2YRcFyszmW1/JMvqna5rV+fp6Pftmlqs2p\nzJdWPOouz+YAJT8EdWPlwGDivv322xzH3BHHHnusfPHFF6JmP0QNMO7D9u+ePXsKlB6vvPJK\nO87sQCkMoV69eiYq7dt08zAN7Nevn6xdu1bUdLaoB7KJDnybbh5QBFVLKFo5Uj34RM2ciFrm\nETVASZs2bUQNZoEx2bt3r3z//fdy+OGH57jGocSr9FLkhx9+EKTLLXi9X9q2bauzUgNXRJbq\nJUD/NscjDqbpRzJ4HHTQQVrRGP3svu6hGKz0MUQt/ehjySgvlWiSUT8/z0c/7FLZ7lTmHR41\n8FS2knnHJIBBESGaFYJa59bHYNWTW1BTm7kliXtcTXnL448/rq01zjjjjLhpU3kwCB7q7VjU\njJK8/PLLUqdOnVQ2z3fe6eSxZcsW2bp1qyhdDhkzZoxcffXVgusCAdeiWkaRLl26+G5Dsk5Q\nsyayZ8+eqPeKqSMGqfXr10vVqlXjFuv1flEzSqIUlGXo0KHSqFEjOeecc0TpHWhB6eabb5az\nzz47bjmpPJhMHtHqqZT0BdfENddcow+nurxodfATl8r6+X0+utn5aUeY0nIGJUy9EUBd8ABA\niGbiawQUmDWmMiB/PHhxEz722GNSuXLlVBYXN+9084ApLWaTlFWTKEXhuHUL4mA6eRhBeMqU\nKXLJJZfIZZddJh988IEoPQzd9AsuuECUnkIQGHSZ8VggQSruF8wqgINaAtGzSRh45s2bJ3Xr\n1tUDN0ycgwqp5IGZ2CFDhshhhx0mxhNGKstLBsNU1c/v8zEau2S0L4g8KKAEQT1EZRo/A0r7\nPEet1BqnjnNPveZImIcICCWYplYKonLjjTfKFVdckYfc8n5qunlAKMFULWZQwhjSycM84LGk\ng9mSRx99VJRlmSidHL10CD433XRTYJjisUClUnG/YLA5+uijtQ8YLLcpXSW9JAIhvkmTJjaX\nIKCkigeWs3r06CFKWVwwu2h8AaWqvGSxS0X9/D4fY7FLVhvTnQ8FlHQTD1l5Zip6w4YNOWpm\n4uAwKRVB+TwRZc2jnU8NGDBAlM+DVBTjK8908njmmWdk/Pjxoky59QAEZ0v4wzIBAtbg8Ru6\nGEGFdPKoUqWKbiYGJswaOIPykaNn1hYvXqydeDmPpWsfQgEcCpr7wl2uiU/m/YJlzxIlSsin\nn36q9W/grA56OPiNcrD0E1RIBQ/Mmlx++eWirAdl8uTJcuSRR9rNS0V5duZJ2El2/fw+H+Ox\nS0LzAsmCAkog2MNTqJcBSJkgJ73Cyp+DVoZcvny5flu+7777kl5GIhmmk8fo0aN1Fbt27aoF\nFAw++MMyFwIGZfxWjp/07yD+pZMHysJsErwYuwPiwQMBOh5BBHhuRd2MIOKuA+IhTMRTEnef\nE+832olZEygNm+Ujkx7CCWYeMdukHMSZ6LRuk8kDQnjfvn1FmU9rAQwepqGM7AzJLM+Zb7L2\nk1k/P89HL+yS1cZ050Ml2XQTD1l55g0FLu4xne4MiEMw1jzOY3nZh1WQcgSnZwrwJnjmmWfm\nJbuknptOHuANxUd3mDZtmnb5rUy29axBuXLl3EnS9judPPCAV6bW8vPPP+uZIwz2zgCLDrBA\nmqACeEydOlXrSzn1tiBM/PTTT3pGMFlLosgHS6/r1q2L2lwo7CKYpaWoiVIcmQweaCOWdrE8\n0alTJ3nrrbe0oBet6skoL1q+yYpLRv38PB/9sEtWG9Oaj5K+GLKcgFrjttT0pAVfDiaob2FY\n6lswllrnttSSg4n2tIXPBnURR/WDopYstB8U+JIIgyOyaA1KJ49o5RvfF2Hwg4L6pZPHc889\np68dOCJzBmW+q/1hKGVqZ3Ta99Wsl66f+zMQ999/v44fNWqU7zrFu1/gHwSemefMmRORr/ou\nkvYwCweLQYZk8DDOzeDJ2vg7idWmZJQXK+9kxOe1fn6fj37YJaN96c6DjtrSTTyE5f3vf//T\nD9dmzZpZeMAqxTyradOmekBQfikiaoyHCIQPZV0REe/8Ee+BC4+YOF9N5+vv8eCbPO6/aE7c\nnPmnej+dPKK1JWwCSjp5KL0bS72F6msETsiUjo52JY/vtEBgDvpbTXCOhfqpJSdr4MCBlvL9\nYyn9Kf0b94Y75PV+UXoYOm81c2Q98MAD1qRJkyzcH3Crj/tIzUC6i0zrbz88IGSizo0bN7br\nqJRAtWM+xCs/NzmeBebZoMzP9Tl+yrMLSeOOn/pF4+Hn+eiXXRoxJK0oCihJQ5m/M3rzzTct\nPATxoMAf9l966aUcjcrrAxczMqaMWFtlzZOj3HRHpItHtHaFTUBBHdPJQ1nzWN26dbPU17T1\ntaKWfqwWLVpYbmE5Grt0xKnlHKt9+/b6+zHmGlbLlBY+8uYOeb1fkB+EFLUUGHHfKP0MC99h\nCUPwyiPagIxvERmG8bZKv8duqtfy7BPSvOO1ftF4+Hk+JsIuzSjyXFwB5KAuDAYS0NYi0BxX\n3+HR6/xqGSarqeDWII9/L4F084COBax24LxOfZzv34qEZA9O5aDADCVyWHCkOvz9998CpXI4\nsoOlU9hCunmkuzy/vMNeP7/tCSI9BZQgqLNMEiABEiABEiCBuARoZhwXDw+SAAmQAAmQAAkE\nQYACShDUWSYJkAAJkAAJkEBcAhRQ4uLhQRIgARIgARIggSAIUEAJgjrLJAESIAESIAESiEuA\nAkpcPDxIAiRAAiRAAiQQBAEKKEFQZ5kkQAIkQAIkQAJxCVBAiYuHB0mABEiABEiABIIgQAEl\nCOoskwRIgARIgARIIC4BCihx8fAgCZAACZAACZBAEAQooARBnWWSAAmQAAmQAAnEJUABJS4e\nHiQBEiABEiABEgiCAAWUIKizTBIgARIgARIggbgEKKDExcODJEACJEACJEACQRCggBIEdZZJ\nAiRAAiRAAiQQlwAFlLh4eJAESIAESIAESCAIAhRQgqDOMkmABEiABEiABOISoIASFw8PkgAJ\nkAAJkAAJBEGAAkoQ1FkmCZAACZAACZBAXAIUUOLi4UESIAESIAESIIEgCFBACYI6yyQBEiAB\nEiABEohLgAJKXDw8SAIkQAIkQAIkEAQBCihBUGeZJEACJEACJEACcQlQQImLhwdJgARIgARI\ngASCIEABJQjqLJMESIAESIAESCAuAQoocfHwIAmQAAmQAAmQQBAEKKAEQZ1lkgAJkAAJkAAJ\nxCVAASUuHh4kARIgARIgARIIggAFlCCos0wSIAESIAESIIG4BCigxMXDgyRAAiRAAiRAAkEQ\noIASBHWWSQIkQAIkQAIkEJcABZS4eHiQBDKHwP79++Wyyy6TAwcOZE6jMqwl77//vowePTrD\nWsXmkEBiBAoldhrPIgESSDaB2bNny6pVq+Tss8+WIkWKJJT9zz//LBMnTpTVq1fLCSecIOed\nd57s2LFDXnjhBfnqq69k7NixUqhQIenZs6eccsopUqBAAbucmTNnypo1a+Scc86RwoUL2/Hc\nST2BWbNmyciRI+XTTz/V7HEdXHLJJXLIIYfYhW/evFkmTZok9evXl6OPPtqO5w4JZCwBi4EE\nSCAUBC644AJLPWisdevWJVSfGTNmWEqw0Xkgn6uvvtrasmWL1aBBAx1XrVo1vT300EP1tk2b\nNtbevXvtsjp27KjjN27caMcFsbNgwQKrW7duCRW9Z88e66GHHrLeeeedhM4P4iQlPFpKUNR/\nVapUsSpVqqT7QQmJ1vjx4+0qzZs3T8f37dvXjuMOCWQyAS7xZKzoyYblNwLNmjXL0+zJM888\nI2qAlgceeEDPhDz44INyxx13yOLFi+W///2v3oIJZlk6d+6s38ZxTtjC+eefL5MnT06oWu+9\n957cdtttsm3btoTOT/dJv//+uyiBQ2rWrCnz58+X3r17ixIsZcqUKXop7tJLL5V9+/alu1os\njwRCQYACSii6gZUgAdFCxCeffCJlypRJCAeWBbBkc91110nlypWlbNmy8uWXX0rp0qVl4MCB\nUqxYMZ3vwQcfLIMGDZJy5crJr7/+mlBZPCk5BKZOnSq7du2SK6+8Uho1amRn2rJlS+nUqZPu\nQwiUDCSQjQSog5KNvc42h5LAN998I8uXL5eLL75YCxNqqUU+/vhjad68uRY4Pv/8c5kzZ46o\nJRpp27atNG7cWLcDb+HQTTACilGyhJ6JWuKR4sWL6/ycyrFNmjSRDRs2xOSA/KCzgnMxWEJf\nJVpYuHChfPHFF7JixQqpU6eOToe8owXM7nzwwQeilnD04WOOOUbru5QoUUL/Rl3HjBmj66yW\nnuT111+380QC6MdAiXTJkiWilkGkYcOGesYJOjUImHXAH8L06dO1rg1mY5AXBL+TTz5Zz6yM\nGjVKmjZtKh06dJCSJUvq9NOmTZPvv/9efvvtNylfvrwcfvjhopa8bKEOiUx/nHTSSVqIRJ4Q\n8Fq3bi2nnXaaZqUz+/9/aupdPvvsM4FuD2Z01FKbTou8TUCbESAsugPaGiusX79es0T50Ec5\n66yzIvRVYp3HeBLIVwQyef2KbSOB/ETArYPyww8/aJ0DNdthHXXUUbZegnrAWGpQtqC7gKAG\nda2/gHj8GX0GJZBYJs+XXnrJgn4Gjqslg6hYjA5Kr169dDroQkAPAudcfvnllnrTjzivX79+\nVsGCBW3dCZR70EEHWYh36rbgpO+++85Syp06r1KlSllqVkfvI04piOp8f/nllxzt6Nq1qz6m\nhCCraNGi+pwKFSrYujbHHXec9ccff+g00FsxDAwHtbxlffvttzr+zjvvtNTslJ1GzV5YmzZt\nsi688EIdh/pXrFjRPq4ECUsJfTpv/DP98Z///MeqWrWqhXZAvwfnId+ffvrJTgvW7du313mB\nkdErgY7QU089Zaf78ccfdRolMGndowEDBlhqtss+7twxOiinn366Vb16dd03Jl81Y2apZTFn\ncu6TQL4nIPm+BWwACWQIASNMGCVZMyBiAMQgqmYF9MD/4Ycf6gFavXVb27dvt1vfqlUrLTDY\nEWpHzQpYakZAD4Knnnqq3i5btsyZxN43AgryhUCAoN78LQgJGPAfeeQRO+3LL7+s49q1a2f9\n+eefOl691VvnnntujrTKisg64ogjLDVbYb399tuWMne2IDypmR49yGOwVxYqdt4QWjAAO4Oa\nndHCg5qx0dFbt261IHCgXrfffrud9M0339RxEMhMMAIKhLouXbpYylLGbsvgwYN1eiieov4I\nixYtsgU7lGGC6Q+U2aNHD2v37t36kJrVspS1jW6jaYea/dH53nrrrVpRGQlRdyjBqqU2y6mI\nfMUVV+i0EHLU7JNWbjZ5m7KxNQIKylcWPrpvEK+W8Sy1nGdB+dl5PeAYAwnkZwIUUPJz77Hu\nGUUgloBSq1YtezA0DTZv/Rg0TYgmoOAYrGIuuugiewYCAxwGQrWEY07VWyOgPP300xHxGPQw\nAOPPCBcYECH4YAbCGSDQ4G1e6bnYA+hjjz2mB+AhQ4Y4k+r9Rx99VB+7++677WNuAWXnzp16\nZkYtpWjBxiTEjM6wYcOscePGmSgrnoACKyb3LBAEE7VclmNgN0INBBoTjIACIQN1cgbMioDr\niBEjdLQRntRSmTOZpZbpLPA1Qh0OQliD8IcZG+SBP/BD3cDTBCOgQHhztwOWSzhv+PDhJjm3\nJJDvCVBJVt3VDCQQZgLHHntsDr8otWvX1lU2Ogzx6g/ly3fffVegq4IACx61tCDKzFjrdLjP\nVTMmEVHQETnzzDMFeg/QNcGfEky0/odboRc6HdD7gM4FrIcQ1MCut927d9db5z81E6F/KoHA\nGR2xD+Ve6I9AR6dFixby+OOPi1pOEbXkoxWLoUviJUDnBec4wxNPPCETJkwQowfz119/CRRX\n4Y8EAT5k3AH8jMKxOQZ/MwhKiNBbtQyjt4i/9tprtf8ZJehpjlBihh6RCWqGTPr376+tq5D2\n+OOP1/okTz75pCihU+vQmLTYQnnW3Q4wR4jHUSfgPxLIRwQooOSjzmJVs5MALHLcwQyQTsVX\ndxr3b6OICVNcDPYIN910U0QyCBhKxyMiDj/UW7uOW7p0qR5I8UPN7Og49z8TD4VTBFihYBCu\nUaOGO6lWdoUirkmbI8H/R0BhFIqoUDi9+eabRenkSN26dUXNvGjT6ljnOeOhxOsO4AdlXOSt\n9E+0YAChAIILgnoFdZ8Std1qdka30SgAQ/hTy0yi9E/kueee0w7zwBVO8OCULVZAH6llMy3c\nqeUyLfCgfs5g+DrjnP3jjOc+CeRnAhRQ8nPvse5ZQUApnibcTsx2RBv8MROhFEy15Q+sf0yA\npU20gLd/BAzixvLFxLnTK/0QHWWEKKTHQK+WRdxJtXChlityzEi4E8JqB5ZFEHYgPCgFVG3V\nc8899wgGci8hmnfe66+/XpRSsKxcuVLUMpi88sorMnfuXFF6KDGzjMYIbUYbncKk0i0RtZSj\nZ09QDoQIzMzAIurrr7/W+WOGBgKLW9BEXa+55hqdxi3QRCvf9AX6h4EEMoVA4k++TCHAdpBA\nhhKAYIKlIDj/ihaM4ON0aw+TXAzW7mAG7Hr16slhhx2mD5u4WGnNm3689FgGwsBu0rrzwm8M\nvlh2gXACE104NlMeVkVZ7whmLrBEA9f+foNSRtazG5iNwZLXs88+K8paSeAwD6bMCPh+kTtE\n8x1jlrOwHIcA9ko3RgtemDVROio6Dk70IGAoZWGdDk7ZYLZsBBYd+f//ovUPDkUTOE1fKP0d\nZxbcJ4F8TYACSr7uPlaeBGITwGAF3xsY3LE04wwY5PBmDsEAsxPOoBQtnT+17xX4RME3guDk\nDfoTGFQhGLh1HjDQw3cLllOg84EAnQmE+++/P8eSiVJy1ceMDgV+QGAyMwL4jbpi2cXoqyAO\nAUsmqD+WUcxsjRG2nOf/kzrnf2XNpCPRHiwzmQCBCcsyCBDY3AFLZG6BSCm56iUe+ERBUNY7\nmpfRZTF5QPhBMDovZvYH3+FxB6Xwq6PwTSVnUFZctj6RiVdKsrp8zAIxkEDGEFA3IwMJkEAI\nCMSy4lHLAzlqB98o6iFkKV0S+1g0Kx6YA8NMGWa6b731lj4HljPGf4bS7bDPhxUPTHHVYG/B\n1we+AwOLE5gdqwE8ws8HrFzgIwWmsbBAgamrWnrRlj2w7oF5szMoAUSXrYQcSzlrs2AqbeKu\nuuqqCOscWOugbWrpxUL9EZSOiI5DHV977TVLKf1ayg28jlNKq3ZRsEzCuWrWxlIu7y01G2T7\nQYF/FmdQQoy2TEJ6+B+BGTe+4aMEKksJEJqDcoZnn2KseJAePGFKDJNlWEgh7t5777XTwnoH\nPmFgOQSLHrCExZGagdLWVOrDkDqtUnK2lMM5fb5SnrWUIrE2KTfm2vCPYnzKGCseWPjA0unF\nF1+0lLM4myN4MZBAJhHAGw0DCZBACAikQkBBszDIY6DEIGr+4JDM/UE9DP4QODDIGwEG6TFI\nO82ZDSo4X1NLGnaeEGLgREzpcJgk9lYta1gQqpQ+ip0eg7X6RlCEcIIT1HKHXT4GbwRlXaN9\nf8DpmWkDHKVhUEfeJmAwV554taCFdMprbEwBBecoz7O2AzmkR/5qScZSsyt6CyHDOGszAgoE\nAZSBYzhHzeLotpk6mC344pipLwRFONxTir4mid7C/wqcukHgc6aFoGR84iChEVDUMpH+mKIp\nHwIlhKBYDvgiCuMPEshHBAqgruqmYCABEshwAjD3hRt6uHSHe3Q1wMVtsfLsql26O01io50A\nU2e46MdyUjRFVOc5eNxguQnpoln1ONOuXbtWl2+Wb3AM5stQ/MX5WMKCdVC0AIVcKK66l6+i\npYWCKvRu0A7ouDjLc6bHx/ywbAWFV+iUID2UYHFOrIC8sRwEfRfUF99FihVQX5ggo19gSm2s\nruKlBwtwN+7+Y6VlPAnkRwL/fMQiP9acdSYBEvBFAN+uQYBflNyEE6SLN/DiuAkYdM13gUxc\nrC0ECijaegnRBCPowJh2xMsDOiVOvZJ4acECysR+A9odT+BAfsgb1jvGDDheGWpGSH/VGIxy\nE06QD9I7PzAYL28eI4H8SIACSn7sNdaZBBIggLdsOFiDUilDOAngK9MMJEAC/xCggMIrgQSy\niIDb82sWNT3PTcXMBpaWUrmc4vYQm+dKMwMSyMcEqIOSjzuPVScBEiABEiCBTCUQX0suU1vN\ndpEACZAACZAACYSaAAWUUHcPK0cCJEACJEAC2UmAAkp29jtbTQIkQAIkQAKhJkABJdTdw8qR\nAAmQAAmQQHYSoICSnf3OVpMACZAACZBAqAlQQAl197ByJEACJEACJJCdBCigZGe/s9UkQAIk\nQAIkEGoCFFBC3T2sHAmQAAmQAAlkJwEKKNnZ72w1CZAACZAACYSaAAWUUHcPK0cCJEACJEAC\n2UmAAkp29jtbTQIkQAIkQAKhJkABJdTdw8qRAAmQAAmQQHYSoICSnf3OVpMACZAACZBAqAlQ\nQAl197ByJEACJEACJJCdBCigZGe/s9UkQAIkQAIkEGoCFFBC3T2sHAmQAAmQAAlkJwEKKNnZ\n72w1CZAACZAACYSaAAWUUHcPK0cCJEACJEAC2UmAAkp29jtbTQIkQAIkQAKhJkABJdTdw8qR\nAAmQAAmQQHYSoICSnf3OVpMACZAACZBAqAlQQAl197ByJEACJEACJJCdBCigZGe/s9UkQAIk\nQAIkEGoCFFBC3T2sHAmQAAmQAAlkJwEKKNnZ72w1CZAACZAACYSaAAWUUHcPK0cCJEACJEAC\n2Ung/wCgciJKCaytYAAAAABJRU5ErkJggg=="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 5 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We can also inspect how parameters covary."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:39:38.129070Z"", + ""start_time"": ""2026-01-04T10:39:38.113586Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""plot(abs(inf$bootstraps$S_d), inf$bootstraps$b, log=\""x\"")"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nB1TFCCIAnhulAAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 6 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We observe a slight dependence between the mean `S_d` and the shape parameter `b` of {class}`~fastdfe.parametrization.GammaExpParametrization`. This is because a large fraction of moderately deleterious mutations and a smaller fraction of strongly deleterious mutations can leave a similar signal in the SFS. Spectra with larger sample sizes might facilitate disentangling the two."" + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""## Estimating beneficial effects\n"", + ""Parameters can be held fixed during maximum-likelihood optimization, and this was already done internally in the example above. By default, fastDFE infers only the deleterious DFE, fixes the ancestral-allele misidentification rate `eps`, and assumes semi-dominant mutations (`h = 0.5`) (see {attr}`~fastdfe.base_inference.BaseInference.fixed_params`). Here, we estimate the full DFE, allowing for beneficial mutations by letting the parameters `S_b` and `p_b` of {class}`~fastdfe.parametrization.GammaExpParametrization` vary, while `eps` and `h` remain fixed. The fixed parameters are wrapped in a dictionary under the key `all`, meaning these settings apply to all SFS types, which matters when running joint inference (cf. {class}`~fastdfe.joint_inference.JointInference`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:39:56.190042Z"", + ""start_time"": ""2026-01-04T10:39:38.136123Z"" + } + }, + ""source"": [ + ""# create inference object\n"", + ""inf <- fd$BaseInference(\n"", + "" sfs_neut = sfs_neut,\n"", + "" sfs_sel = sfs_sel,\n"", + "" fixed_params = list(all = list(eps = 0, h = 0.5))\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""sfs_modelled <- inf$run()\n"", + ""\n"", + ""p <- inf$plot_discretized();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\npAUIUJKmY0MEEEAAAQQQSJfA/wPKP3gn9TW3MQAAAABJRU5ErkJggg=="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 7 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""The inferred full DFE shows substantial uncertainty, which is expected with a small sample and few SNPs. This is most pronounced for the [-1, 0] and [0, 1] bins, where many mutations are effectively neutral and provide little signal. Adjusting the discretization intervals can help reveal the structure more clearly (cf. {func}`~fastdfe.base_inference.BaseInference.plot_discretized`)."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:39:56.328396Z"", + ""start_time"": ""2026-01-04T10:39:56.202507Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""p <- inf$plot_discretized(intervals = c(-Inf, -100, -10, -1, 1, Inf));"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 8 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": [ + ""## Ancestral-allele misidentification\n"", + ""We can also adjust for ancestral-allele misidentification by letting parameter `eps` vary. `eps` is the probability that an allele is misidentified as derived when it is actually ancestral, and vice versa (cf. {func}`~fastdfe.spectrum.Spectrum.misidentify`). This can correct biases to the SFS caused by mis-polarization, but `eps` is somewhat difficult to interpret because it is applied simultaneously to both the neutral and selected SFS. In addition, `eps` assumes the fraction of ancestral misidentification to be constant across site classes, but in practise errors may differ across classes. Nevertheless, below, we infer the full DFE while allowing `eps` to vary."" + ] + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:40:17.167462Z"", + ""start_time"": ""2026-01-04T10:39:56.333306Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf <- fd$BaseInference(\n"", + "" sfs_neut = sfs_neut,\n"", + "" sfs_sel = sfs_sel,\n"", + "" fixed_params = list(all = list(h=0.5))\n"", + "")\n"", + ""\n"", + ""sfs_modelled <- inf$run()"" + ], + ""outputs"": [], + ""execution_count"": 9 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:40:17.190224Z"", + ""start_time"": ""2026-01-04T10:40:17.177731Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""hist(inf$bootstraps$eps)"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""Plot with title “Histogram of inf$bootstraps$eps”"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nFArWAAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 10 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""`eps` is estimated to be rather low, indicating that ancestral-allele misidentification is not a major issue in this dataset, or, at least, that including it that does not significantly improve the model fit. We can also check this in a more principled way by performing a likelihood-ratio test as done below."" + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""## Nested model comparison\n"", + ""We can automatically check for the significance of include ancestral-allele misidentification and beneficial fitness affects using likelihood ratio tests. This is done with {func}`~fastdfe.base_inference.BaseInference.plot_nested_models`. The LRTs are performed by comparing the likelihood of the inferred DFE to the likelihood of a nested model where some parameters are held fixed. Alternatively, we can use {func}`~fastdfe.base_inference.BaseInference.compare_nested` to directly compare two nested models."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:40:20.133385Z"", + ""start_time"": ""2026-01-04T10:40:17.194912Z"" + } + }, + ""source"": ""p <- inf$plot_nested_models();"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nQKQE/gcS15eirh3MZwAAAABJRU5ErkJggg=="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 11 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""Including ancestral allele misidentification or beneficial mutations does not appear to improve the fit significantly."" + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": [ + ""## Dominance effects\n"", + ""By default, fastDFE assumes semi-dominance (`h = 0.5`), which is more or less appropriate depending on the organism and type of mutations considered. We can change the dominance coefficient to a different value of `h` if we believe this is more appropriate. However, in practise, `h` often depends on the strength of selection, with more deleterious mutations being more recessive. To model this, we can specify a callback function that returns the dominance coefficient as a function of the selection coefficient `S = 4Ne`.\n"", + ""\n"", + ""In the example below, we use an exponential decay: `h` is about 0.4 for neutral mutations and approaches 0 for strongly deleterious ones. The callback also receives `h` itself, allowing the dominance function to be parametrized and optimized; for simplicity, this parameter is still called `h`. Its bounds can be set via {attr}`~fastdfe.base_inference.BaseInference.bounds`."" + ] + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:40:53.729928Z"", + ""start_time"": ""2026-01-04T10:40:20.144689Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf <- fd$BaseInference(\n"", + "" sfs_neut = sfs_neut,\n"", + "" sfs_sel = sfs_sel,\n"", + "" fixed_params = list(all = list(eps = 0, h = 0, p_b = 0, S_b = 1)),\n"", + "" h_callback=function(h, S) { 0.4 * exp(-0.1 * abs(S)) }\n"", + "")\n"", + ""\n"", + ""sfs_modelled <- inf$run()"" + ], + ""outputs"": [], + ""execution_count"": 12 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Let's compare the inferred DFE under this dominance relationship to that of the default semi-dominant model."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:40:59.882806Z"", + ""start_time"": ""2026-01-04T10:40:53.740932Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf2 <- fd$BaseInference(\n"", + "" sfs_neut = sfs_neut,\n"", + "" sfs_sel = sfs_sel,\n"", + "" fixed_params = list(all = list(eps = 0, h = 0.5, p_b = 0, S_b = 1))\n"", + "")\n"", + ""\n"", + ""sfs_modelled <- inf2$run()"" + ], + ""outputs"": [], + ""execution_count"": 13 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:41:00.051362Z"", + ""start_time"": ""2026-01-04T10:40:59.893382Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""p <- fd$DFE$plot_many(c(inf$get_dfe(), inf2$get_dfe()), labels=c('partly recessive', 'h=0.5'))"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nfH1OiyEAAQhAAAI5T+D/A178eZRzoLKYAAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 14 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": [ + ""We see that assuming mutations are partly recessive leads to a more deleterious inferred DFE since stronger selection is necessary to remove a similar amount of recessive mutations.\n"", + ""\n"", + ""We can also let `h` vary when inferring the DFE (cf. the {doc}`simulation guide <../R/simulation>`)."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""## Folded inference\n"", + ""To infer the DFE from a folded SFS, simply pass folded spectra to {class}`~fastdfe.base_inference.BaseInference`. Folded inference is performed whenever the spectra are folded, i.e., when all entries where the derived allele is the major allele are zero. Folded spectra contain little information on beneficial mutations so we only infer the deleterious part of the DFE here."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:41:06.583674Z"", + ""start_time"": ""2026-01-04T10:41:00.056878Z"" + } + }, + ""source"": [ + ""# create inference object\n"", + ""inf <- fd$BaseInference(\n"", + "" sfs_neut = sfs_neut$fold(),\n"", + "" sfs_sel = sfs_sel$fold()\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""sfs_modelled <- inf$run()\n"", + ""\n"", + ""p <- inf$plot_discretized(intervals = c(-Inf, -100, -10, -1, 0));"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl\nR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRB\nkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4\na73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PC\nv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UA\nVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXd\na8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8\nHOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojL\njVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0\nyDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5Pt\nXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEw\nQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXH\nliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vW\nc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUt\nVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJf\ncl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdd\nuwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqv\ngcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCg\nKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8A\nrD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvF\nY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAAIooAMA\nBAAAAAEAAAGAAAAAANfxKOcAAD7HSURBVHgB7d0HnBRFvsDx/8KSc5YMAoriCSrIiXKKJwiI\nwFMxPEUQEVGOx4mnHoingsB5KKBnOBVBfOIDBRMqBhQEEUyAShARQSQHyRl2Xv/rrtuZ2Qnd\nGyb0/OrzWaanu7q76lvMzn+rq6uzAlYSEgIIIIAAAgggkEICRVKoLBQFAQQQQAABBBAwAgQo\n/EdAAAEEEEAAgZQTIEBJuSahQAgggAACCCBAgML/AQQQQAABBBBIOQEClJRrEgqEAAIIIIAA\nAgQo/B9AAAEEEEAAgZQTIEBJuSahQAgggAACCCBAgML/AQQQQAABBBBIOYHslCtREgv0pz/9\nSZYvXy4vvfSS1K5dW44cOSIdO3aUqlWryquvvprEkuX91OvWrZMGDRo4B0i1OoWbOwWNsLBw\n4UIZOnRori1FixaV0qVLS926deXaa6+Vtm3b5sqjK+6991757LPPIm4LXlm+fHl58803zaol\nS5bI4MGDgzfHXP6///s/Oemkk2LmYSMCCCCAQHwBApQgo8WLF4t+CR48eNCszcnJkblz55pg\nJShbWizu3btXbr31Vvn111/l/fffd8qcanUKN3cKGmFhx44dpj0ibHJWPfXUU3LhhRfKv/71\nL2natKmzXheWLVsWd3/NV7lyZX0xadeuXa72sfMfPnzYXuQVAQQQQCAfAgQoMfCKFSsmo0aN\nknLlysXIlZqb1qxZI1OnTpX27duHFDCd62RX5KyzzpK33nrLfivHjh2TPXv2yNKlS2X06NHy\nySefSI8ePeSrr76SEiVKOPnshTFjxpieFvt9+GuRIrmvfGqw8+GHH4ZnzfW+Zs2audaxAgEE\nEEDAuwABSgyz7OxsGTJkSIwc6bfJD3XSoKNOnTq58Fu0aGECD+1B+eKLL8wlnUceeSRXvkqV\nKkXcP1fGoBUa2EU6Z1AWFhFAAAEEClAgIwMUfT6i/nX97rvvinbh65iF7t2752I9fvy4TJgw\nQcqUKSM9e/YM2a5jE3Scws8//yw1atSQ008/Xbp06RJyeSB4hx9//FHmzJkjn3/+uRnTol+i\nnTp1crLo2JBJkyZJo0aNpGXLlvLss8+KXtLo2rWrXHDBBZKVlWXy7tu3z5xXewsOHDggzZs3\nl86dO0u9evWcY+llqQ8++MC837Bhg7nccfLJJ0uHDh0kvE56Kejll1929o22oD0SVapUcTa7\nKYeT2Vpwax68T16WS5YsacYQnXLKKTJu3Dj5n//5nxCbvByTfRBAAAEEkiCgTzPOpGSNEQic\nd955+gRn82P1KJhX60s+8Lvf/c4s//DDD4bEGoti3lsDZkOIrMGWZr0ew/rL2lmuVatWwAoO\nQvLqm9tuu83JE5zfChgCWh5NO3fuNHn+67/+K/D73//eyW8FPwHrEobJ8+mnnwYaNmxotlkB\nS6B48eJm2RrUGXjxxRdNHv3n5ptvdva363nVVVeZ7eF1sgKnXHntfYJfv/32W+f4bsth7+DF\n3N4n0qt1WceUVX3iJSvoNHlnzpzpZLWCPbPOCjqddfEWPvroI7OP/t8gIYAAAggkTkD/ss2o\nZH95X3311YGNGzcGjh49Gnj77bcD1p065otIv5RjBSjWpQOTz/oLPaBf1Prl+8svvwSsu0vM\n+mbNmoV4jhgxwqxv06ZN4LvvvgucOHEisGDBAicIueOOO0x+O0CxegACGnAMGzYs8Pe//z3w\nxBNPmO2bNm0KWGNhAtbljcBjjz0WsHowAlavS+C9994LWOMezDn0uJqs8RgBqwfFrLN6agKb\nN28OWD1FZlt4gKL1X7lyZa4fawxL4JJLLjHHuP76682++o+Xctg7eTG394n06iVAGThwoCn7\nww8/7BzKDlCs3qmA1ZMU8UfbJzjZAYrVQxawBhzH/FFbEgIIIIBAwQhkVIBi3aFjvrQ0uAj/\nInrnnXfMtngBigYHmscaPBvSAno8DXqsS0HmS0w3agCkea0xD4Hdu3eH5P/mm28C1mDMgHXZ\nxPSQ2AGK5n/++edD8uqb3r17m2NZAzxzbdMAS/ezLg0526y7Y8w6a5Css04XwgOUkI1Bb+65\n5x6zv3V5yenl0c1ey+HVPKgIuRa9BCgjR4405e/Vq5dzHDtAUatoP+G9M3aAEi1/8Pq7777b\nORcLCCCAAAL5E8ioMSh6S6umvn37SvidGjqOw7p8ImvXrjV5ov1jdfWbTTq+oXr16tKtWzcz\npkSPN23atJDddJyIJqsHQipUqBCy7cwzzxSr58LcwqwDV4OTjjsJT1YQYsah9OnTJ3yTGVui\nAz91XI0VCEnFihVz5fGy4plnnhGr58GMh3n99ddD7oTxWo6CMPdSdjuv3tmjScf2hCedpyS8\nPew89evXtxdDXkuVKmXG+4SsDHsTPA4obBNvEUAAAQQ8CoR+M3rcOd2yW70Wpsg6YDRSatKk\nSdwARQfUXnfddaITcmmg069fPznnnHPMQFUdSGpd4nEOrQNpNenA10hJB3KGJw0udGK44KRB\nhw6Y1QnJdKBrpGR/Ia9evVpatWoVKYurdTpweMCAAaIBj9WrFFKWvJSjIMxdFTwsk95mrUmD\nzvD00EMPiXXZKXx1zPeNGzc2c+TEzMRGBBBAAIECE8g94UOBHTr1DrR161ZTKJ0pNFIKDwwi\n5dHejilTppgfvQtHb3n98ssv5cEHH5QzzjjDzDpqXe4xu65fv968RvtrPdLxg++Usbfb5bYG\nxZqeH+2tCf857bTTTGBiXcKxd/P8qgHVNddcY449Y8YMOfXUU0OOkZdy2PvkxzykEC7f2AFK\ntGDU5WHIhgACCCCQJIGM6kHRW3L11mBrUGtE7i1btkRcH75Sb/n97//+b/NjDZKVefPmmYnD\n9JZkvfRjDYgV664ZsS8XWANLww9h3uuXt35x6+WDWEkvHeg5NRjS+T0KI2kwddlll8n+/ftl\n4sSJ0q5du1ynyUs5Cso8V2FirNDgRC93qdn5558fIyebEEAAAQRSVSCjelB0fhFN8+fPz9Ue\nGmhYd9nkWh++QntP9PKAPb5E593Qyy7W3TZmzg3NrwGLJr1kpClSUKGXZPTSkD5DRudIiZU0\ngNHgQC+x2GM6gvNbd+LI7bffbiYmswbbBm9ytayzsGpwYt3tI3/961/lpptuirhfXspREOYR\nCxNj5Z133ilqovPSaM8SCQEEEEAg/QQyKkDRv6Z1YKs+DPDrr78OaS2dcXT79u0h6yK9WbFi\nhelhuO+++3Jt1knbNGmvgSb9gtQH2FlzceR6SJ0OqLXu8jETvOn4hnjJum3WZNGJx8Iv4zzw\nwAPy9NNPy/Tp052J4jRw0hSvThooXXnlleY5NTq2Rqf2j5W8lqMgzGOVx96mAYkGmNpzpb1k\nWv/777/f3swrAggggECaCWTUJR59CNwbb7xhLl/84Q9/EH2SrvZyWLeSmjtw9O6OeJd5rEnX\nzOyyejfLueeea4IQ7VnQmVv1ODooU+/s0aTr9ZKPdfux/PGPfxTdV5/pogNR9UenT3/uuedc\n/ZfRwERnfLXmOhF9Fo11u695RpAOZNVnxOj4FH1Qnl7W0KRPY9ZxKtrTo+fWy07WnCy5zmXN\ntWLKrWNr9Evdui3X3Pli3RwWkteaQM4MDvZajoIwDymI9UbHyti9U7pNZ9TVdrPLrO76rB7t\noSqotGrVqpBzRjvuoEGDzP+raNtZjwACCCDgUiB/dymn5946n4bONGrdFaPfwmZiNGua+YA1\nrsS8jzVRm9bY+tIPXHzxxSav7q8/1pdiQOfZsO62yYViXVIKWJcaQvLrhG4ff/yxk9eeB8W6\n48dZF76gk8LdddddgbJly4Ycy7prJzBnzpzw7GZCN530TcunM9BqCp8HxQo4Qo5l1yf81Xom\nkXN8r+XQHd2aOyeJsGDPgxJeNp2d17oEZmYItu7QCVhjeyLsHTDto/vmZSbZ8HNGez98+PCI\n52YlAggggIA3gSzNbv2yzchkzQwqOoBVn6OjvQ1ek+6vl3W090J7RvQ24FhJn/ujtwHrQ+es\nafFjZY25TZts3bp15vJNgwYNzGWraDtoXr2UpHco2Zd9ouX1ut5LOexj59fcPg6vCCCAAAL+\nFsjoAMXfTUvtEEAAAQQQSF8B790G6VtXSo4AAggggAACaSJAgJImDUUxEUAAAQQQyCQBApRM\nam3qigACCCCAQJoIEKCkSUNRTAQQQAABBDJJgAAlk1qbuiKAAAIIIJAmAgQoadJQFBMBBBBA\nAIFMEiBAyaTWpq4IIIAAAgikiQABSpo0FMVEAAEEEEAgkwQIUDKptakrAggggAACaSJAgJIm\nDUUxEUAAAQQQyCQBApRMam3qigACCCCAQJoIEKCkSUNRTAQQQAABBDJJIDtTKvv555/Lbbfd\nJmXLls2UKlNPBBBAAAEEUk6gdOnS8t5778UtV8YEKDk5OdK+fXt5+OGH46KQAQEEEEAAAQQK\nXuDYsWPSsWNHVwfmEo8rJjIhgAACCCCAQCIFCFASqc25EEAAAQQQQMCVAAGKKyYyIYAAAggg\ngEAiBQhQEqnNuRBAAAEEEEDAlQABiismMiGAAAIIIIBAIgUIUBKpzbkQQAABBBBAwJUAAYor\nJjIhgAACCCCAQCIFCFASqc25EEAAAQQQQMCVAAGKKyYyIYAAAggggEAiBQhQEqnNuRBAAAEE\nEEDAlQABiismMiGAAAIIIIBAIgUy5lk8iUQtiHNdcsklsnz5cleHCgQCTr6srCxnOd7Cxo0b\npUgRYtR4TmxHAAEEEEi8AAFK4s1dnbFEiRJSsmRJV3kPHjwo27Ztk4oVK5ofVzuRCQEEEEAA\ngRQWIEBJ0cZ55513XJds1qxZ0rlzZxk8eLDcd999rvcjIwIIIIAAAqkqQP9+qrYM5UIAAQQQ\nQCCDBQhQMrjxqToCCCCAAAKpKkCAkqotQ7kQQAABBBDIYAEClAxufKqOAAIIIIBAqgoQoKRq\ny1AuBBBAAAEEMliAACWDG5+qI4AAAgggkKoCBCip2jKUCwEEEEAAgQwWIEDJ4Man6ggggAAC\nCKSqAAFKqrYM5UIAAQQQQCCDBQhQMrjxqToCCCCAAAKpKkCAkqotQ7kQQAABBBDIYAEClAxu\nfKqOAAIIIIBAqgok/WGB+/btkwULFoi+tm7dWurVqxfTKicnRxYuXChr1qyR3/3ud9K8eXMp\nUsRdnHX80/myv9f1MY+fjhsPbdxkin1kxquy/8fv07EKcctcdvKUuHnIgAACCCDgHwF33+yF\nVN+1a9dKt27dZPr06bJs2TLp06ePLFq0KOrZjh07JnfffbeMHTtWNm3aJA8++KDZR4MWEgII\nIIAAAgj4RyCpPSijR4+Wrl27yqBBgyQrK0smT54s48aNk6lTp5r34cwffPCBrFq1SiZNmiRV\nq1aVI0eOyFVXXSUfffSRtG/fPjw77xFAAAEEEEAgTQWS1oOyc+dOWblypelB0eBEU5cuXUzP\nyIoVKyJyvv766yYg0eBEU4kSJUywct5550XMz0oEEEAAAQQQSE+BpPWgbNmyxYjVqlXLkatS\npYoUL15ctm3bJs2aNXPW2wvr168Xza89LYsXL5ZKlSrJDTfcII0bN7azOK89e/Y041TsFQ0b\nNpST7De8IoAAAggggEBKCyStB2Xz5s2mB0R7QYJTuXLlZNeuXcGrzPLBgwfl0KFDJjhZunSp\nXHDBBaJBzq233irr1q3LlV+PW6pUKeenWLFiufKwAgEEEEAAAQRSUyBpPSgaMBw/fjyXyokT\nJ6R06dIR1+vKsmXLmnEquqzjT6688kp5+eWXZejQobrKSRMmTHCWdUHv/Jn+lztD1vEGAQQQ\nQAABBFJTIGk9KDqORIMR7RkJTnv37pWaNWsGrzLL2rOivSIXXXSRs03Hruj4kw0bNjjrWEAA\nAQQQQACB9BdIWoBSp04dyc7OluXLlzuKOmhWbxkOHpfibLQWdByJPXbFXv/TTz9J/fr17be8\nIoAAAggggIAPBJIWoFSoUEE6dOhg7sLZv3+/HD58WPSyTMeOHaVatWqGdt68eTJr1iyH+brr\nrpOZM2fKV199ZXpf9LZjvePn4osvdvKwgAACCCCAAALpL5C0MShK179/fzPZ2uWXX24u3+is\nsAMHDnRUZ8+ebW477tSpk1mngYje4TNkyBAJBAJmAOzgwYOlVatWzj4sIIAAAggggED6CyQ1\nQNHbhMePHy867qRo0aJSpkyZENHhw4eHvNc31157rfTo0UN27Ngh1atXjzihW66dWIEAAggg\ngAACaSWQ1ADFlipfvry96OpVg5kaNWq4yksmBBBAAAEEEEg/gaSNQUk/KkqMAAIIIIAAAokS\nIEBJlDTnQQABBBBAAAHXAgQorqnIiAACCCCAAAKJEiBASZQ050EAAQQQQAAB1wIEKK6pyIgA\nAggggAACiRIgQEmUNOdBAAEEEEAAAdcCBCiuqciIAAIIIIAAAokSIEBJlDTnQQABBBBAAAHX\nAgQorqnIiAACCCCAAAKJEiBASZQ050EAAQQQQAAB1wIEKK6pyIgAAggggAACiRIgQEmUNOdB\nAAEEEEAAAdcCKfGwQNelzaCMu44cleM5Oa5qvOfoUZPvwLHjsv3QYVf7aKZqpUq6zktGBBBA\nAAEEEilAgJJIbQ/n6vzBbFm2a7eHPUTGr1hpftzutPuGa6VoETrR3HqRDwEEEEAgcQIEKImz\n9nSmP5xUQ+qXLeNpH6+Zs7KyvO5CfgQQQAABBBIiQICSEGbvJ3m41Tned2IPBBBAAAEEfCJA\n/75PGpJqIIAAAggg4CcBAhQ/tSZ1QQABBBBAwCcCBCg+aUiqgQACCCCAgJ8ECFD81JrUBQEE\nEEAAAZ8IEKD4pCGpBgIIIIAAAn4SIEDxU2tSFwQQQAABBHwiQIDik4akGggggAACCPhJgADF\nT61JXRBAAAEEEPCJAAGKTxqSaiCAAAIIIOAnAQIUP7UmdUEAAQQQQMAnAgQoPmlIqoEAAggg\ngICfBAhQ/NSa1AUBBBBAAAGfCBCg+KQhqQYCCCCAAAJ+EiBA8VNrUhcEEEAAAQR8IkCA4pOG\npBoIIIAAAgj4SYAAxU+tSV0QQAABBBDwiQABik8akmoggAACCCDgJwECFD+1JnVBAAEEEEDA\nJwIEKD5pSKqBAAIIIICAnwQIUPzUmtQFAQQQQAABnwgQoPikIakGAggggAACfhIgQPFTa1IX\nBBBAAAEEfCJAgOKThqQaCCCAAAII+EmAAMVPrUldEEAAAQQQ8IkAAYpPGpJqIIAAAggg4CcB\nAhQ/tSZ1QQABBBBAwCcCBCg+aUiqgQACCCCAgJ8ECFD81JrUBQEEEEAAAZ8IEKD4pCGpBgII\nIIAAAn4SIEDxU2tSFwQQQAABBHwiQIDik4akGggggAACCPhJgADFT61JXRBAAAEEEPCJAAGK\nTxqSaiCAAAIIIOAnAQIUP7UmdUEAAQQQQMAnAgQoPmlIqoEAAggggICfBAhQ/NSa1AUBBBBA\nAAGfCBCg+KQhqQYCCCCAAAJ+EiBA8VNrUhcEEEAAAQR8IkCA4pOGpBoIIIAAAgj4SYAAxU+t\nSV0QQAABBBDwiQABik8akmoggAACCCDgJwECFD+1JnVBAAEEEEDAJwIEKD5pSKqBAAIIIICA\nnwQIUPzUmtQFAQQQQAABnwgQoPikIakGAggggAACfhIgQPFTa1IXBBBAAAEEfCJAgOKThqQa\nCCCAAAII+EmAAMVPrUldEEAAAQQQ8IkAAYpPGpJqIIAAAggg4CcBAhQ/tSZ1QQABBBBAwCcC\nBCg+aUiqgQACCCCAgJ8ECFD81JrUBQEEEEAAAZ8IEKD4pCGpBgIIIIAAAn4SIEDxU2tSFwQQ\nQAABBHwiQIDik4akGggggAACCPhJgADFT61JXRBAAAEEEPCJAAGKTxqSaiCAAAIIIOAngaQH\nKPv27ZP33ntPXn31VVm/fr0nW93nxx9/9LQPmRFAAAEEEEAg9QWSGqCsXbtWunXrJtOnT5dl\ny5ZJnz59ZNGiRa7UZs6cKY8//jgBiistMiGAAAIIIJBeAtnJLO7o0aOla9euMmjQIMnKypLJ\nkyfLuHHjZOrUqeZ9tLJt2LBBnn32WSlWrFi0LKxHAAEEEEAAgTQWSFoPys6dO2XlypWmB0WD\nE01dunSRTZs2yYoVK6KSHj9+XEaMGCG9evWSUqVKxQxkoh6EDQgggAACCCCQ0gJ5ClBmzJgh\nbdq0kdq1a0vlypWlUqVKuX7i1XrLli0mS61atZysVapUkeLFi8u2bducdeEL2stSunRpufLK\nK8M3hbzX4+uYFvtn9+7dIdt5gwACCCCAAAKpK+D5Es9nn30m11xzjem9aN68uVSvXj1PvRib\nN2+WEiVKmJ9gnnLlysmuXbuCVznLOk7ljTfekIkTJ8Y9Z9++fWX16tXOvqeddpo0ct6xgAAC\nCCCAAAKpLOA5QNE7Z0qWLCmLFy+WJk2a5LluOn5EL9eEpxMnTpgekvD1Bw8eNJd2dLxKtWrV\nwjfnet+uXTvRoMRO2jNzeG70nhk7H68IIIAAAgggkHwBzwGK9ny0bNkyX8GJVrtq1aqiwYgG\nHnrJxk579+6VmjVr2m+d17feekt27NghH374ofnRDQcOHJBp06aZO3kGDBjg5NWFO++8M+T9\nwoULZfrcOSHreIMAAggggAACqSngeQyKBifae6KBRX5SnTp1JDs7W5YvX+4cRgfN5uTkSPC4\nFHvj6aefLjfeeKPoq/1TtGhRk7dBgwZ2Nl4RQAABBBBAwAcCnntQevfuLRMmTJAHHnhAHnro\nITOoNS8OFSpUkA4dOsikSZPMpRgNVvS4HTt2dC7hzJs3z/SSdOrUSc4880zzE3yuV155Rdq2\nbSuXXnpp8GqWEUAAAQQQQCDNBTz3oMyZM8cEEGPGjJHy5ctL48aNRQfLhv+4cenfv78JcC6/\n/HLp3r276VEZOHCgs+vs2bNF7xgiIYAAAggggEBmCXjuQdE7bI4cOSKtWrXKt5Tenjx+/HjR\ncSd6uaZMmTIhxxw+fHjI+/A377zzTvgq3iOAAAIIIICADwQ8Byj9+vUT/SnIpD0xJAQQQAAB\nBBBAwBbwHKDYO+otwnPnzpVVq1bJsWPHpEWLFuanYsWKdhZeEUAAAQQQQACBPAnkKUD5+uuv\nRQfL6sRp4WnUqFEyZMiQ8NW8RwABBBBAAAEEXAt4DlB0ynh9ArH2oIwdO1Zat24tZcuWlXXr\n1pkZXocOHWomcrvjjjtcF4KMCCCAAAIIIIBAsIDnAOW5554TDVJ0LpRTTjnFOZbeBqxPJr71\n1lvl6aefFgIUh4YFBBBAAAEEEPAo4Pk242+++UYuuuiikOAk+Jw6gFafgaNPJSYhgAACCCCA\nAAJ5EfAcoOjtwEePHo16LnubTmNPQgABBBBAAAEE8iLgOUDRqe4/+eQT+eKLL3KdLxAIyD/+\n8Q/znJ26devm2s4KBBBAAAEEEEDAjYDnMSh9+/Y1g2P1Ms8tt9wi5557rplRVgfJvvDCC2Zs\nysSJE92cmzwIIIAAAggggEBEAc8BSqlSpWTBggVy8803y+OPPx5yUJ0Z9sknn5SbbropZD1v\nEEAAAQQQQAABLwKeAxQ9uD5teNasWbJhwwbRJxDv3LlTGjVqZB76p7cckxBAAAEEEEAAgfwI\n5ClAsU9Yp04d0R8SAggggAACCCBQkAKeB8kW5Mk5FgIIIIAAAgggEEkgbg+KzmfSoUMHadOm\njTz77LNmjIlOxBYvRZoGP94+bEcAAQQQQAABBFQgboBSpEgRM5V9yZIljVjx4sXNe/gQQAAB\nBBBAAIHCEogboJx00kmyaNEi5/x6a7H+kBBAAAEEEEAAgcIS8DwG5cUXX5S77747anneeOMN\nqV+/vhw6dChqHjYggAACCCCAAAKxBOL2oOjO27dvd6a3X7JkiZlFduPGjbmOq9Pcv/vuu7J+\n/Xo5fPiw6JwpJAQQQAABBBBAwKuAqwBl0qRJcs8994QcO9btxS1atBCdtI2EAAIIIIAAAgjk\nRcBVgHLHHXfI8ePH5dixYzJnzhz5+eefpXfv3rnOl52dbQKTHj165NrGCgQQQAABBBBAwK2A\nqwClWLFiMnToUHPMpk2byooVK+T+++93ew7yIYAAAggggAACngQ8D5K95pprTHDy3HPPyQcf\nfOCcbMaMGaIPENQp8EkIIIAAAggggEB+BDwHKHqZ5+yzz5Z+/frJjz/+6Jy7aNGi8uWXX8pl\nl10mL7/8srOeBQQQQAABBBBAwKuA5wBl7ty58t1338nbb78tt99+u3O+7t27yy+//CLt27eX\nwYMHS05OjrONBQQQQAABBBBAwIuA5wDlzTfflAsvvND0lISfqHLlyvLnP/9Ztm7dKmvXrg3f\nzHsEEEAAAQQQQMCVgOcARY+qg2ajJQ1SNOmU+CQEEEAAAQQQQCAvAp4DlHbt2plbjRcsWJDr\nfHpZZ8yYMVK9enWpW7duru2sQAABBBBAAAEE3Ai4us04+ECXXnqptG7d2tyxc/XVV4tOylau\nXDnRmWWnT58u33//vUyZMiV4F5YRQAABBBBAAAFPAp4DlLJly8qHH35o7uLR8SjBd+xor4m+\nv+666zwVgswIIIAAAggggECwgOcARXcuWbKk6EMDA4GAGQyrvScNGzaU2rVrS1ZWVvDxWUYA\nAQQQQAABBDwLeB6DEnwGDUZOPvlkadu2reizefS9Bi3z588PzsYyAggggAACCCDgSSBPPSgT\nJ06UJ598UrZt22aez6Nn1MBEn9ezb98+s07fkxBAAAEEEEAAgbwIeO5B0d6Rvn37yrfffiv1\n69c3c55o70m1atVk//79UqRIEXn66afzUhb2QQABBBBAAAEEjIDnAEVnkNUgRCdi+/TTT+X0\n008XvZtn2bJlsnz5cqlRo4botPckBBBAAAEEEEAgrwKeA5Q1a9bIeeedZ8ac6EnPOussWbRo\nkTl/48aN5eGHH5Zhw4bltTzshwACCCCAAAIIiOcApVKlSlKqVCmH7tRTT5UlS5Y479u0aWPG\npmzYsMFZxwICCCCAAAIIIOBFwHOA0rRpU1m4cKEZe6In0ks869atk/Xr15vz6mUevQQUazp8\nLwUkLwIIIIAAAghknoDnAOXGG280PShNmjSRTz75RC6++GIpU6aMXHnllTJq1Cj505/+ZC4B\n6VgUEgIIIIAAAgggkBcBzwGK3q3z+uuvm7Enhw8fFr3ko3ftLF26VO6991755ZdfZNCgQXkp\nC/sggAACCCCAAAJGwPM8KNu3b5cGDRqY3hN7rpOePXtKhw4dzFiUZs2a8aBA/nMhgAACCCCA\nQL4EPPegPP/881KvXj1ZtWpVyLT2ekmnY8eOBCf5ag52RgABBBBAAAEV8BygrFy50sjpgwFJ\nCCCAAAIIIIBAYQh4DlAGDBggVapUkfvuu090DAoJAQQQQAABBBAoaAHPY1B0EKyOMxk7dqyM\nHz/eXNLRgCU8ff311+GreI8AAggggAACCLgS8Byg6CDZ3bt3S4sWLZwT5OTkOMssIIAAAggg\ngAAC+RWIG6DomJNHH31URowYITVr1pQ+ffpIr169QmaTzW8h2B8BBBBAAAEEEAgWiDsG5Ycf\nfhC9c2fbtm1mv5EjR0rnzp2Dj8EyAggggAACCCBQoAJxe1AaNWpkTjhmzBjp16+fbN68Wfbv\n3y+LFy+OWZCzzz475nY2IoAAAggggAAC0QTiBig6ILZt27YyZcoU82Mf6JxzzrEXI77ak7hF\n3MhKBBBAAAEEEEAghkDcACUrK0s++ugjmT17tmzcuNFMc//jjz/KHXfcEeOwbEIAAQQQQAAB\nBPIuEDdA0UPrk4k7depkznLkyBHRW4j79++f97OyJwIIIIAAAgggEEPAVYASvL9O1EZCAAEE\nEEAAAQQKUyDuXTyFeXKOjQACCCCAAAIIRBIgQImkwjoEEEAAAQQQSKoAAUpS+Tk5AggggAAC\nCEQSIECJpMI6BBBAAAEEEEiqAAFKUvk5OQIIIIAAAghEEiBAiaTCOgQQQAABBBBIqgABSlL5\nOTkCCCCAAAIIRBIgQImkwjoEEEAAAQQQSKoAAUpS+Tk5AggggAACCEQSIECJpMI6BBBAAAEE\nEEiqAAFKUvk5OQIIIIAAAghEEiBAiaTCOgQQQAABBBBIqgABSlL5OTkCCCCAAAIIRBIgQImk\nwjoEEEAAAQQQSKoAAUpS+Tk5AggggAACCEQSIECJpMI6BBBAAAEEEEiqAAFKUvk5OQIIIIAA\nAghEEiBAiaTCOgQQQAABBBBIqgABSlL5OTkCCCCAAAIIRBIgQImkwjoEEEAAAQQQSKpAdlLP\nzskRQAABBBDwucCGDRtk5cqVhVrL0047TerUqVOo50j0wQlQEi3O+RBAAAEEMkrg7bfflttu\nu61Q6/zEE0/IgAEDCvUciT44AUqixTkfAggggEBGCbRs2VL+9re/ua7z+PHjJScnRwYPHux6\nn1atWrnOmy4Zkx6g7Nu3TxYsWCD62rp1a6lXr15MO2207777TpYuXSo1atSQdu3aSYkSJWLu\nw0YEEEAAAQSSJaABiv64TS+88IIcP35cHnzwQbe7+DJfUgfJrl27Vrp16ybTp0+XZcuWSZ8+\nfWTRokVRoXfs2CFXXHGFjBo1SjZu3ChPPvmk9O7dW/bu3Rt1HzYggAACCCCAQPoJJLUHZfTo\n0dK1a1cZNGiQZGVlyeTJk2XcuHEydepU8z6cUwOZWrVqyVNPPWU2HTp0yAQs06ZNk1tuuSU8\nO+8RQAABBBBAIE0FktaDsnPnTjOqWXtQNDjR1KVLF9m0aZOsWLEiImfp0qXlxhtvdLaVKlVK\nmjZtavZxVrKAAAIIIIAAAmkvkLQelC1bthg87RGxU5UqVaR48eKybds2adasmb3aeQ0OTnTl\nr7/+KkuWLIk4cvnjjz8OufSzfft25zgsIIAAAggggEBqCyQtQNm8ebMZ3Bo+wLVcuXKya9eu\nuGpHjx6VBx54QOrXry/du3fPlX/s2LGyevVqZ73eI97IeccCAggggAACCKSyQNIClGLFiplR\nyuE4J06cEL2UEyvpoNghQ4aYHhIds6LHCk+333677Nmzx1mtQc+aKS8571lAAAEEEEAAgdQV\nSFqAUrVqVdFg5ODBgyEBiQYfNWvWjCqmd/L8+c9/ljJlyohOTFOhQoWIeTt37hyyfuHChQQo\nISK8QQABBNJXYH+v69O38HFKnrNzhzUPSkD8WMdj1lQhgV93xhH49+akDZLVKXmzs7Nl+fLl\nTkF1KmCd5yR4XIqz0VrYunWraM9I3bp15fHHH48anATvwzICCCCAAAIIpJ9A0npQtOejQ4cO\nMmnSJNHxIRqsTJgwQTp27CjVqlUzkvPmzZMDBw5Ip06dzPtHH33U9Lr06NFDvv/+e0e7fPny\n0rBhQ+c9CwgggAACCCCQ3gJJC1CUrX///mamvMsvv9wMmG3evLkMHDjQEZ09e7a5hVgDFL39\nWC/TaNJ5U4KTzkD7yCOPBK9iGQEEEEAAAQTSWCCpAUqlSpVEnzmg406KFi1qxpUEWw4fPtx5\nq5d95s+f77xnAQEEEEAAAQT8K5DUAMVm1Us0JAQQQAABBBBAwBZI2iBZuwC8IoAAAggggAAC\n4QIp0YMSXijeI4AAAggg4BeBF1evkXu+/Np1dQ5aTzIOWLlrvvyK631GtTxbbjqlsev86ZCR\nACUdWokyIoAAAgikrUDZYtlSx5q7qzBTOescfkv+q5HfWoj6IIAAAgiktcAVDeqL/pC8CTAG\nxZsXuRFAAAEEEEAgAQL0oCQAmVMgEE/g6aeflsWLF8fLlq/tDz30kNSoUSNfx2BnBBBAIFEC\nBCiJkuY8CMQQ0EkJX3vttRg58r/prrvuIkDJPyNHQACBBAkQoCQImtMgEEtAJywMnpgwVt61\na9eKzr7crVs3GTlyZKysIdsaNGgQ8p43CCCAQCoLEKCkcutQtowR0Adguk363CpNOhNzs2bN\n3O5GPgQQQCCtBBgkm1bNRWERQAABBBDIDAEClMxoZ2qJAAIIIIBAWgkQoKRVc1FYBBBAAAEE\nMkOAACUz2plaIoAAAgggkFYCBChp1VwUFgEEEEAAgcwQIEDJjHamlggggAACCKSVAAFKWjUX\nhUUAAQQQQCAzBAhQMqOdqSUCCCCAAAJpJUCAklbNRWERQAABBBDIDAEClMxoZ2qJAAIIIIBA\nWgkQoKRVc1FYBBBAAAEEMkOAACUz2plaIoAAAgggkFYCBChp1VwUFgEEEEAAgcwQIEDJjHam\nlggggAACCKSVAAFKWjUXhUUAAQQQQCAzBAhQMqOdqSUCCCCAAAJpJUCAklbNRWERQAABBBDI\nDAEClMxoZ2qJAAIIIIBAWgkQoKRVc1FYBBBAAAEEMkOAACUz2plaIoAAAgggkFYCBChp1VwU\nFgEEEEAAgcwQyM6MalLLTBTY3+t6X1b7wJ69pl7H5n8ifq2jVrDs5Cm+bD8qhQAC7gToQXHn\nRC4EEEAAAQQQSKAAPSgJxOZUCCCAgAo89thjMnny5ELFeOKJJ6RNmzaFeg4OjkBhChCgFKYu\nx0YAAQQiCGzdulVWrFgRYUvuVYFAQI4ePSpFihSRYsWK5c4QZc3+/fujbGE1AukhQICSHu1E\nKRFAwEcCo0aNEv1xk44fP24Ck/PPP1/mzZvnZhfyIOALAcag+KIZqQQCCCCAAAL+EiBA8Vd7\nUhsEEEAAAQR8IUCA4otmpBIIIIAAAgj4S4AAxV/tSW0QQAABBBDwhQABii+akUoggAACCCDg\nLwHu4vFXe1KbNBXYdPCg7Dt2zFXp1+07YPLtsW49XbVnj6t9NNPJ5cpJMetWVRICCCCQDgIE\nKOnQSpTR9wJ3ffGVvLV+g6d6vv3LRtEft2lxty7SpEJ5t9nJhwACCCRVgAAlqfycHIF/C1x4\n0klSvljxQuWoUNz9JF+FWhAOjgACCLgQIEBxgUQWBApboF/TUwr7FBwfAQQQSCsBLkinVXNR\nWAQQQAABBDJDgB6UzGhnaomA7wX297rel3U8npNj6nVi1ffi1zpqBctOnuLL9qNSeRegByXv\nduyJAAIIIIAAAoUkQIBSSLAcFgEEEEAAAQTyLkCAknc79kQAAQQQQACBQhJgDEohwXJYBBBA\nIJrAkRMn5MiJf48tiZbHXm+PQdHXvUfdTean+5bJLipFmZjPZuQ1DQUIUNKw0SgyAgikt8CI\npd/KY8tXeqrEFzt2Su2pr7re57U/XiTta9dynZ+MCKSaAAFKqrUI5UEAAd8LNClfXv5Yq2ah\n1rNqyZKFenwOjkBhCxCgFLYwx0cAAQTCBHo1aST6Q0IAgegCDJKNbsMWBBBAAAEEEEiSAAFK\nkuA5LQIIIIAAAghEFyBAiW7DFgQQQAABBBBIkgABSpLgOS0CCCCAAAIIRBcgQIluwxYEEEAA\nAQQQSJIAAUqS4DktAggggAACCEQXIECJbsMWBBBAAAEEEEiSAAFKkuA5LQIIIIAAAghEFyBA\niW7DFgQQQAABBBBIkgABSpLgOS0CCCCAAAIIRBcgQIluwxYEEEAAAQQQSJIAAUqS4DktAggg\ngAACCEQXIECJbsMWBBBAAAEEEEiSAAFKkuA5LQIIIIAAAghEFyBAiW7DFgQQQAABBBBIkgAB\nSpLgOS0CCCCAAAIIRBcgQIluwxYEEEAAAQQQSJIAAUqS4DktAggggAACCEQXIECJbsMWBBBA\nAAEEEEiSAAFKkuA5LQIIIIAAAghEFyBAiW7DFgQQQAABBBBIkkB2ks7rnHbfvn2yYMEC0dfW\nrVtLvXr1nG2RFk6cOCFLly6VFStWSNOmTaVVq1aRsrEOAQQQQAABBNJYIKk9KGvXrpVu3brJ\n9OnTZdmyZdKnTx9ZtGhRVE4NTvr37y/333+/bNy4UYYPHy5jx46Nmp8NCCCAAAIIIJCeAknt\nQRk9erR07dpVBg0aJFlZWTJ58mQZN26cTJ061bwPJ33llVdk//79Mm3aNClTpoz8/PPP0rNn\nT7nsssvk1FNPDc/OewQQQAABBBBIU4Gk9aDs3LlTVq5caXpQNDjR1KVLF9m0aZO5fBPJ89NP\nP5X27dub4ES3169fX8444wz58MMPI2VnHQIIIIAAAgikqUDSelC2bNliyGrVquXQValSRYoX\nLy7btm2TZs2aOevthc2bN0twfl2v7zV/ePrnP/8pW7dudVYXLVpUvrF6Xx76aZ2zjoX0Ecge\nNsxzYY/T1p7NUmkHr21Oe6dS63kvC+3t3Swd98gJuC910gIUDTZKlChhfoKLW65cOdm1a1fw\nKrN8/Phx2bFjh5QvXz5km77/4YcfQtbpm/fff19Wr17trG/ZsqXc9/g/nfd+Wli3bp289dZb\n8vvf/17OPfdcP1Utf3Wxetv8mPTz8b//+79y2mmnmR5FP9YxT3XyaXvn5OTIE088Yf4Yu+qq\nq/JE48udfNre2laTJk0Sbfebb77Zl013ValSruqVtAClWLFiokFHeNKBsKVLlw5fLdoDUqRI\nkVz76DF0PEp40g/0kSNHnNV6zLp16zrv/bagg4wvvvhiufDCC/1WNeoTJvDTTz+ZQeVNmjSh\nvcNs/PhWf8fpzQH6Bx2fbz+2cO466Y0g+l2Y6e2dtAClatWqpgEOHjwYEpDs3btXatasmavF\ndJxK5cqVze3IwRs1/0knnRS8yiw3aNAg1zpWIIAAAggggEB6CCRtkGydOnUkOztbli9f7kjp\noFnt1gofZ2JnOPnkk0Py63qdD6V27dp2Fl4RQAABBBBAwAcCSQtQKlSoIB06dDDX2vTW4cOH\nD8uECROkY8eOUq1aNUM7b948mTVrlsOs119nz55tgpJAICAzZsyQo0ePSufOnZ08mbigl6/0\njqaKFStmYvUzrs56eVTb2/6cZBxAhlVYe4+1vSP1LGcYRcZUV/+A9/OQBLcNmWV90XsYU+v2\nsO7y6WC/Bx98UL755htzfbV58+Zy7733OgNh//a3v5nbjjVwsdPEiRPNAEH9Ja09JwMGDBAd\nAEtCAAEEEEAAAf8IJDVAsRl1HIkOgo002NXOE/yqvSa6j45jISGAAAIIIICA/wRSIkDxHys1\nQgABBBBAAIH8CCRtDEp+Cs2+CCCAAAIIIOBvgaIPWMnfVUxc7fSJzM8991zUydJ0gK9OUBfv\nic12iXUCtpdeeslM5a/PGipbtqy9KU+vOuj4119/zTXYTss9Z84cWbJkiehEeTqAOTjp/fi6\n7aOPPjKDkoPvmtIJ4o4dOybVq1cP3sXXy/qQy9dff92YaEXjDV5UP51YTe9C07ksglM8+3jb\ng4/ldVkfuKkTGobP2hyrvXUOFt1HHzFB+k1Ax8bpZ0T/b+gEevFSXj+L8Y4ba3uk9s7Ez28s\no/xuK8jfDfHKEu13g94Jq8+0O/vss82dsvGOk8rb6UEpwNbRhx3q5FnR0scffxzzac3h+91z\nzz3y1VdfSaVKlVyPzwk/hv1+6dKlooOO9bbs4BTvidL6ZRXrCdLnnHOOPPnkk5LEsdbB1UnI\nspq9+OKLZk6e4MkAo538qaeeMneo6d1qwSmefbztwcfyuqxl+etf/2qCjeB947W3Bln65frL\nL78E75bRy/p/X2f+1JmrDxw4ENcir5/FuAeOkSFae2fi5zcGU743FdTvhngFifW7QSc01T+a\npk+fHu8wqb9d7+Ih5V/A+uskcP311wesX/D5P5h1BOu268AFF1wQWLhwYb6OZ/VuBKy/7gLt\n2rULXHTRRQGrRybkeLfcckvAirYDVtRt1r/wwguBq6++2nn/8ssvB6699tqA9QvObLd6dQJt\n27YNfP/9985xRowYEbAe2Oi89/uC1ZMUsB5aGbea1vOmAn/5y18C1gy/pi31/0hwimcfb3vw\nsbwsL1q0KHDFFVeYcllTaYfs6qa9rYd2BoYMGRKyXya/0c+Om89qfj+LeTWO1d56zEz7/ObV\n0c1+BfW7Id654v1u0O+PHj16BHbv3h3vUCm9nR6UAoohn332WbG+uM10/NEO+dprrzl/seoE\nddrjYn3Ry+jRo8X6IpOpU6ea2XX1IYePPPKIOcwbb7yRr0j43XfflXfeeUdGjRqV6756N0+U\ndvME6UsuuUS0/nqph/SbwN///nfTs/Twww//tvI/S/Hs423PdUCXK7RbeOjQodKpUye57rrr\ncu3lpr1bt24t2gvw7bff5tqfFdEF8vtZjH7k6Fvitbfuyec3ul9hbYn1uyHeOd38btBLyWed\ndZZYf3DGO1xKbydAKYDm0WdlfPLJJ2L9FRXzaF988YXzS127yF999VWx/nqRGjVqmHEAzzzz\njLl0oP+5TjnlFHMsnbI/PxP2nH/++Sbw0QcJhqd4T5TW/G6eIK3z0OjYFp0JmPSbgF5C0UAz\n0oRq8ezjbf/tLN6WSlkP6XrllVekb9++Ea9Pu2lvnQFagxQdt0RyL5Dfz6L7M/2WM157a04+\nv795JWop1u+GeGVw+7tB/7+l+2eUACXe/wYX23XwmQYpOvufl7Rnzx4ZPny49OnTR2666SYz\nI+6XX35pZoS1Z8fVoEe/DPKaqlSpEvGLSI8X74nSWqdoT5DWgMRO+oWl1zytyz/2Kl4tAQ08\no6V49vG2RztuvPXaVvp/IlJy2966rwbNtHckxejr8vNZjH7U2Ftitbe9J59fWyJxr7F+N8Qr\nhdvfDfoZ1d4W7UVL15S0hwWmK1ikcuuAJe31sO9+0S/vDz74wMmqd7jok4bDU/HixaVRo0bO\nas0XPojV2RhnQWfjDe7B0MFvsQbs6uHiPVHayxOktezqkInp7bffluABsN27d5eSJUvGpIhn\nH297zINbG93+Hww+jpf21l+wb775ZvDuLP9HoDA+i/Fw89LewcfM5M9vsENBL+fld0O8Mrj9\n3WAHQfp7+cwzz4x32JTcToBSAM2iT2TWYMNO2jOit+/ZqWnTphEDlPAvMR19bY1Ysnfz9KqB\nzcyZM5199M6feAFKvCdKe3mCtNZfHTIx6e3j27Ztc6quz5MKb1tn438W4tnrX7V6R43bp32H\nH9/t/8Hg/by0t/6SPHToUPDuLP9HoDA+i/Fw89LewcfM5M9vsENBL+fld0O8MsT73WHvr79D\nNKXz72UCFLs18/GqgYB2o1kjps3lmYYNG4p1N0Q+juh9Vx3wGGnQY6wjBT9RulWrViZr+BOl\n7SdIX3bZZc6h9BewPrgxOOmYGu05yMQ0fvx4z9WOZ69fGPoLRgdTR2ubWCfN6/9BL+3duHHj\nWEXI2G2F9VmMBZrX9raPmcmfX9ugMF7z8rshXjni/e6w99+wYYNZjPeHqp0/FV8Zg1IAraK/\nHPQvyvXr1xfA0aIfYu7cuc5dQNFzud/i5onSbp4grWMX9MNgD+x1X4LMzRnPPt52ldOu2ylT\nphToX0hu2lvP/fPPP4tOHkgqGIFktbeWns9vwbRhQR1Fe071c613eEZKbv6v6H76faTjnqKN\nOYt07FRbR4BSAC2if+nqWJI1a9YUwNGiH2LWrFmitx0XZNJJ2PSv9csvv9z0gGhdBg4c6JxC\n7/6x5kExT42+9NJLRa+pDhs2LGRWW/3rSy9NpXOk7lQ4gQvx7ONt/+GHH+Rf//pXgQYobtpb\niXRGWQKUgv3Pkoz21hrw+S3Ydszv0TRA0c91rNv44/1f0TL44jOa0rO0pFHhrC/uQO/evQu1\nxDrpjjUbbKGcw7qG7UzGFukE1oypge3bt0faZCZ6GzlyZMRtflzpdjImt3WPZx9ru04EZz3d\n2+2pXOeL1d7WINBA165dA9asqa6P5+eMbidqc2uQ6PbWiRoz6fPrth3ykq+gfjdYj9IIWDOP\nxy1CtP8rOimgTsb42WefxT1GKmegByW/4e5/9teJr3SQ6+eff15AR8x9GJ262PpiyL2hANaU\nL18+5nT62suig7PCk467sT6U0q9fv/BNvn6vz7vQLlTrF0S+6xnPPtr27777zvTc6eXFgk7R\n2lvPo8+H0vYuXbp0QZ82rY9nBfDm1v38ViKR7Z2pn9/8tlGs/fP7u0EvuemcWTo/TbwU7f+K\nNbO36NCD8847L94hUnp7lkZPKV3CNCqc3l74/PPPy+OPP14opdam0jstUilpffWyUK9evVKp\nWIValvnz58s//vEPcw69/GU94qBQzxft4Mn4/6DdxtZf2+ahmBqQk8Rc3rT/cNC5J/TZS4WR\nCqO9M/HzWxhtYx+zoH435KetdV+dV+v+++83QYpdtnR8JUAp4Faz7+Qp4MOm7OH07iX9S1rn\n0CD5X0Afjqh/IeoMpaT0F+Dzm/5tGF4D/XzqvEzau5LuiQAl3VuQ8iOAAAIIIOBDAfpofdio\nVAkBBBBAAIF0F2CitnRvQcqPQAYI6MDBVatWmblf9HZ2/WEMTAY0PFXMaAF6UDK6+ak8Aqkv\nMHr0aClXrpycccYZZr4efXSEvn/ooYfy/GiI1K81JUQAAXpQ+D+AAAIpKzB48GCx5umQa665\nRnr27Cn6jKkFCxaYCQPvu+8+80TlCRMmpGz5KRgCCORdgEGyebdjTwQQKEQBnVFTn7Jbq1Yt\n0Vv4gy/p6DbtSdEp9/VBjRUrVizEknBoBBBIhgCXeJKhzjkRQCCuwI4dO+TXX3+V008/PSQ4\n0R31tnadi0Z7VjZu3Bj3WGRAAIH0E6AHJf3ajBIjkDECZ555pugTth999FG54YYbpHLlyhlT\ndyqKQKYLEKBk+v8A6o9ACgvoE131MRLr1q0zvSitWrWSdu3aSfv27eXCCy9kgsAUbjuKhkB+\nBQhQ8ivI/gggUKgCu3btkhdeeEHeeustsR5+JtbDEc359AniM2bMkObNmxfq+Tk4AggkR4AA\nJTnunBUBBPIgcPDgQXMXjz44U58jU6JECdHnn5x99tl5OBq7IIBAKgswSDaVW4eyIZDBAnp5\nx3rsvHn2j82gz33SyzvPPPOM6VHRgGXatGn2Zl4RQMBHAgQoPmpMqoKAnwRmzpwpV1xxhekh\niVSvDh06mB6U1atXR9rMOgQQSHMBApQ0b0CKj4BfBbp27Wqqdu+998r27dtzVVN7TvTpypde\nemmubaxAAIH0F2AMSvq3ITVAwLcCw4YNk5EjR5rJ2jRgadGihehlnc8//1xeeeUVadmypbz/\n/vtmhlnfIlAxBDJUgAAlQxueaiOQLgJTp06VMWPGyIoVK+Tw4cOm2DVr1pQuXbrIY489JqVK\nlUqXqlBOBBDwIECA4gGLrAggkDwBnd5+zZo1UrZsWdOjkryScGYEEEiEAAFKIpQ5BwIIIIAA\nAgh4EmCQrCcuMiOAAAIIIIBAIgQIUBKhzDkQQAABBBBAwJMAAYonLjIjgAACCCCAQCIECFAS\nocw5EEAAAQQQQMCTAAGKJy4yI4AAAggggEAiBAhQEqHMORBAAAEEEEDAkwABiicuMiOAAAII\nIIBAIgQIUBKhzDkQQAABBBBAwJMAAYonLjIjgAACCCCAQCIECFASocw5EEAAAQQQQMCTwP8D\nS5tWTVhuISQAAAAASUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 15 + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:41:06.769324Z"", + ""start_time"": ""2026-01-04T10:41:06.594849Z"" + } + }, + ""source"": ""p <- inf$plot_sfs_comparison();"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nlBSEAAIIIIAAAhUl8P8Bo1Ey3dEel4YAAAAASUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 16 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": [ + ""## Serialization\n"", + ""Inference objects can be serialized to JSON files for later use (cf. {func}`~fastdfe.base_inference.BaseInference.to_file`)."" + ] + }, + { + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:41:06.817857Z"", + ""start_time"": ""2026-01-04T10:41:06.774213Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""# save the inference object to a file\n"", + ""# unserialize with BaseInference$from_file\n"", + ""inf$to_file(\""serialized.json\"")\n"", + ""\n"", + ""# we can also save a short summary to fa ile\n"", + ""inf$get_summary()$to_file(\""summary.json\"")"" + ], + ""outputs"": [], + ""execution_count"": 17 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""## Joint inference\n"", + ""fastDFE supports joint inference of several SFS types, where any parameters can be shared between types. In this example, we create a {class}`~fastdfe.joint_inference.JointInference` object with two types, where we share ``eps``, the rate of ancestral misidentification and ``S_d``, the mean selection coefficient for deleterious mutations (cf. {class}`~fastdfe.parametrization.GammaExpParametrization`). For more complex stratifications, see the {class}`~fastdfe.parser.Parser`) module."" + ] + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:41:33.575105Z"", + ""start_time"": ""2026-01-04T10:41:06.821782Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""# neutral SFS for two types\n"", + ""sfs_neut <- fd$Spectra(list(\n"", + "" pendula = c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0),\n"", + "" pubescens = c(172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 0)\n"", + ""))\n"", + ""\n"", + ""# selected SFS for two types\n"", + ""sfs_sel <- fd$Spectra(list(\n"", + "" pendula = c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0),\n"", + "" pubescens = c(791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 0)\n"", + ""))\n"", + ""\n"", + ""# create inference object\n"", + ""inf <- fd$JointInference(\n"", + "" sfs_neut = sfs_neut,\n"", + "" sfs_sel = sfs_sel,\n"", + "" shared_params = list(fd$SharedParams(types = c(\""pendula\"", \""pubescens\""), params = list(\""S_d\"")))\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""sfs_modelled <- inf$run()"" + ], + ""outputs"": [], + ""execution_count"": 18 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""{class}`~fastdfe.joint_inference.JointInference` both runs the joint inference and marginal inference where each type is inferred separately. To see this better we can plot the inferred parameters for the different inference types."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:41:33.823404Z"", + ""start_time"": ""2026-01-04T10:41:33.585544Z"" + } + }, + ""source"": ""p <- inf$plot_inferred_parameters();"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nSUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 19 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""``marginal.pendula`` and ``marginal.pubescens`` are the marginal inferences for the respective type. ``marginal.all`` is the marginal inference obtaining by adding up the spectra of all types. ``joint.pendula`` and ``join.pubescens`` are the joint inferences for the respective type. We can see that ``eps`` and ``S_d`` are indeed shared between the two. The parameter ``alpha`` in the plot denotes the proportion of beneficial non-synonymous substitutions. Each marginal inference is a {class}`~fastdfe.base_inference.BaseInference` object itself and can be accessed via ``inf.marginal_inferences[type]``.\n"", + ""\n"", + ""We can now also investigate to what extent the inferred DFEs differ:"" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:41:34.010647Z"", + ""start_time"": ""2026-01-04T10:41:33.828588Z"" + } + }, + ""source"": ""p <- inf$plot_discretized();"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nBNpHQA5K+/pEGomACIiACIjA4An8Cx6pBnwSHmT2AAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 20 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""### Model comparison\n"", + ""We can obtain information about the goodness of fit achieved by sharing the parameter by performing a likelihood ratio test (cf. {func}`~fastdfe.joint_inference.JointInference.perform_lrt_shared`). This compares the likelihood of the joint inference with the product of the marginal likelihoods."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:41:34.023128Z"", + ""start_time"": ""2026-01-04T10:41:34.016254Z"" + } + }, + ""source"": ""inf$perform_lrt_shared()"", + ""outputs"": [ + { + ""data"": { + ""text/html"": [ + ""0.509749259118573"" + ], + ""text/markdown"": ""0.509749259118573"", + ""text/latex"": ""0.509749259118573"", + ""text/plain"": [ + ""[1] 0.5097493"" + ] + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 21 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""The test is not significant, indicating that the simpler model of sharing the parameters explains the data sufficiently well. Indeed, we do not observe a lot of differences between the inferred parameters of joint and the marginal inferences."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""## Covariates\n"", + ""{class}`~fastdfe.joint_inference.JointInference` also supports the inclusion of covariates associates with the different SFS types. This provides more powerful model testing and reduces the number of parameters that need to be estimated for the joint inference. For a more interesting example we stratify the SFS of `B. pendula` by the sites' reference base as is described in more detail in the {mod}`~fastdfe.parser` module."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:43:11.789241Z"", + ""start_time"": ""2026-01-04T10:41:34.027105Z"" + } + }, + ""source"": [ + ""# instantiate parser\n"", + ""p <- fd$Parser(\n"", + "" n = 10,\n"", + "" vcf = paste0(\n"", + "" \""https://github.com/Sendrowski/fastDFE/\"",\n"", + "" \""blob/dev/resources/genome/betula/\"",\n"", + "" \""all.polarized.deg.subset.200000.vcf.gz?raw=true\""\n"", + "" ),\n"", + "" stratifications = list(fd$DegeneracyStratification(), fd$AncestralBaseStratification())\n"", + "")\n"", + ""\n"", + ""# parse SFS\n"", + ""s <- p$parse()\n"", + ""\n"", + ""# visualize spectra\n"", + ""p <- s$plot();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nAAAASUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 22 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""We now create the inference object from the spectra. In this contrived example we make up some covariates that covary with ``S_d``, the mean strength of negative selection. Covariates introduce a linear relationship by default but this can be modified by specifying a custom callback function (see {class}`~fastdfe.optimization.Covariate`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:44:16.011902Z"", + ""start_time"": ""2026-01-04T10:43:11.813818Z"" + } + }, + ""source"": [ + ""# create inference object\n"", + ""inf <- fd$JointInference(\n"", + "" sfs_neut = s$select('neutral.*')$merge_groups(1),\n"", + "" sfs_sel = s$select('selected.*')$merge_groups(1),\n"", + "" covariates = list(fd$Covariate(param = 'S_d', values = list(A = 1, C = 2, T = 3, G = 4))),\n"", + "" n_runs = 50 # increase number of initial runs for stability\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""sfs_modelled <- inf$run()"" + ], + ""outputs"": [], + ""execution_count"": 23 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""Let's visualize the inferred parameters"" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:44:16.342497Z"", + ""start_time"": ""2026-01-04T10:44:16.035756Z"" + } + }, + ""source"": ""p <- inf$plot_inferred_parameters();"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\ngg=="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 24 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""We observe that ``S_d`` shows little variation across the jointly inferred types, because it does not change linearly with respect to the arbitrary covariates specified. Indeed, the median of the covariate across all bootstrap replicates is close to zero. Note that covariates are named ``c0``, ``c1``, etc., by default."" + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:44:16.359309Z"", + ""start_time"": ""2026-01-04T10:44:16.348411Z"" + } + }, + ""source"": ""median(inf$bootstraps[['A.c0']])"", + ""outputs"": [ + { + ""data"": { + ""text/html"": [ + ""0"" + ], + ""text/markdown"": ""0"", + ""text/latex"": ""0"", + ""text/plain"": [ + ""[1] 0"" + ] + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 25 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""### Model comparison\n"", + ""We can perform a likelihood ratio test to see whether including the covariates produces a significantly better fit than simply sharing the parameter in question among the types (cf. {func}`~fastdfe.joint_inference.JointInference.perform_lrt_covariates`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""is_executing"": true, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:44:30.067234Z"", + ""start_time"": ""2026-01-04T10:44:16.363152Z"" + } + }, + ""source"": ""inf$perform_lrt_covariates()"", + ""outputs"": [ + { + ""data"": { + ""text/html"": [ + ""1"" + ], + ""text/markdown"": ""1"", + ""text/latex"": ""1"", + ""text/plain"": [ + ""[1] 1"" + ] + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 26 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""As expected, the specified covariates do not improve the fit significantly."" + ] + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""R"", + ""language"": ""R"", + ""name"": ""ir"" + }, + ""language_info"": { + ""codemirror_mode"": ""r"", + ""file_extension"": "".r"", + ""mimetype"": ""text/x-r-source"", + ""name"": ""R"", + ""pygments_lexer"": ""r"", + ""version"": ""4.3.1"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 4 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/R/spectra.ipynb",".ipynb","186532","350","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""# Working with SFS\n"", + ""## Subtypes\n"", + ""fastDFE offers a set of utilities for handling and manipulating site-frequency spectra (SFS) data, especially when there are multiple types. The {class}`~fastdfe.spectrum.Spectra` class is designed to hold and manipulate spectra of multiple types. It provides a number of methods and properties for creating, accessing, and manipulating the spectra data. Usually we would obtain already stratified spectra from {class}`~fastdfe.parser.Parser`, but we can also create them manually."" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 14, + ""outputs"": [], + ""source"": [ + ""library(fastdfe)\n"", + ""\n"", + ""# load the fastdfe package\n"", + ""fd <- load_fastdfe()"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-08-20T13:49:41.777182Z"", + ""start_time"": ""2023-08-20T13:49:41.765783Z"" + } + } + }, + { + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:46:12.179064Z"", + ""start_time"": ""2025-11-30T10:46:08.231657Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", + ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", + ""source(\""R/fastdfe.R\"")\n"", + ""fd <- load_fastdfe()\n"", + ""# set plot size\n"", + ""options(repr.plot.width = 7, repr.plot.height = 3)"" + ], + ""outputs"": [], + ""execution_count"": 10 + }, + { + ""cell_type"": ""code"", + ""source"": [ + ""# create spectra with two subtypes and two types\n"", + ""sfs <- fd$Spectra$from_spectra(list(\n"", + "" subtype1.type1=fd$Spectrum$standard_kingman(10) * 1,\n"", + "" subtype1.type2=fd$Spectrum$standard_kingman(10) * 2,\n"", + "" subtype2.type1=fd$Spectrum$standard_kingman(10) * 3\n"", + ""))\n"", + ""\n"", + ""# plot spectra\n"", + ""p <- fd$Spectra$plot(sfs)"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:46:12.292823Z"", + ""start_time"": ""2025-11-30T10:46:12.190045Z"" + } + }, + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nRU5ErkJggg=="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 11 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""We access types by their index from which we obtain a {class}`~fastdfe.spectrum.Spectrum` object."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:46:12.388087Z"", + ""start_time"": ""2025-11-30T10:46:12.304095Z"" + } + }, + ""source"": [ + ""sub <- fd$Spectra$select(sfs, \""subtype1.type1\"")\n"", + ""\n"", + ""p <- fd$Spectrum$plot(sub)"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 12 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""We can also use wildcards to access multiple types at once."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:46:12.501769Z"", + ""start_time"": ""2025-11-30T10:46:12.402431Z"" + } + }, + ""source"": [ + ""subtypes <- fd$Spectra$select(sfs, \""subtype1.*\"")\n"", + ""\n"", + ""p <- fd$Spectra$plot(subtypes)"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nKZpZYhbCAAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 13 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""### Grouping\n"", + ""To get rid of the subtypes, we can merge the spectra over the specified number of groups."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:46:12.615478Z"", + ""start_time"": ""2025-11-30T10:46:12.512197Z"" + } + }, + ""source"": [ + ""merged <- fd$Spectra$merge_groups(sfs, 1)\n"", + ""\n"", + ""p <- fd$Spectra$plot(merged)"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nlGcLSQnOpQoAAAAASUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 14 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""All subtypes for each type are merged into a single spectrum by adding them upp."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""### Serialization\n"", + ""We can also save the spectra to a file and restore them again."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:46:12.640578Z"", + ""start_time"": ""2025-11-30T10:46:12.634094Z"" + } + }, + ""source"": [ + ""sfs$to_file(\""spectra.csv\"")\n"", + ""\n"", + ""sfs2 <- fd$Spectra$from_file(\""spectra.csv\"")"" + ], + ""outputs"": [], + ""execution_count"": 15 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""### Prefixing\n"", + ""Here we prefix the spectra with a string to distinguish them and then combine them into a single spectra object."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:46:12.758027Z"", + ""start_time"": ""2025-11-30T10:46:12.649226Z"" + } + }, + ""source"": [ + ""sfs <- fd$Spectra$prefix(sfs, 'original')\n"", + ""sfs2 <- fd$Spectra$prefix(sfs2, 'restored')\n"", + ""\n"", + ""combined <- fd$Spectra$combine(sfs, sfs2)\n"", + ""\n"", + ""p <- combined$plot()"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 16 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""For a complete reference of the available methods and properties, see {class}`~fastdfe.spectrum.Spectra` and {class}`~fastdfe.spectrum.Spectrum`."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""## Folded spectra\n"", + ""{class}`Spectrum` and {class}`Spectra` objects can also be folded by collapsing the bins corresponding to the derived allele counts onto the bins corresponding to the ancestral allele counts. Basing the DFE inference on folded spectra, we have less information to work with, which is particularly noticeable when including beneficial mutations. However, folded spectra are easier to obtain, and are robust to misspecification of the ancestral state, which is often unknown. DFE inference is based on folded spectra whenever spectrum.is_folded is ``True``."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:46:12.872606Z"", + ""start_time"": ""2025-11-30T10:46:12.768548Z"" + } + }, + ""source"": [ + ""# fold spectra object\n"", + ""folded <- fd$Spectra$fold(sfs)\n"", + ""\n"", + ""p <- folded$plot()"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nSUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 17 + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""R"", + ""language"": ""R"", + ""name"": ""ir"" + }, + ""language_info"": { + ""codemirror_mode"": ""r"", + ""file_extension"": "".r"", + ""mimetype"": ""text/x-r-source"", + ""name"": ""R"", + ""pygments_lexer"": ""r"", + ""version"": ""4.2.3"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 1 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/R/quickstart.ipynb",".ipynb","82153","216","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""# Quickstart\n"", + ""The easiest way to get started is by using the {class}`~fastdfe.base_inference.BaseInference` class which infers the DFE from a single pair of frequency spectra, one `neutral` and one `selected`. In this example we create {class}`~fastdfe.spectrum.Spectrum` objects holding the SFS counts and pass them to {class}`~fastdfe.base_inference.BaseInference`. Note that we are required to specify the number of monomorphic sites (the last and first entries of the specified counts which correspond to the number of mono-allelic sites where the ancestral and derived allele is fixed, respectively). By default, only the deleterious part of the DFE is inferred (cf. {attr}`~fastdfe.base_inference.BaseInference.fixed_params`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""tags"": [], + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:38:54.543415Z"", + ""start_time"": ""2025-11-30T10:38:50.343961Z"" + } + }, + ""source"": [ + ""library(fastdfe)\n"", + ""\n"", + ""# load the fastdfe package\n"", + ""fd <- load_fastdfe()"" + ], + ""outputs"": [], + ""execution_count"": 11 + }, + { + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:39:44.148868Z"", + ""start_time"": ""2025-11-30T10:39:40.364824Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", + ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", + ""source(\""R/fastdfe.R\"")\n"", + ""fd <- load_fastdfe()"" + ], + ""outputs"": [], + ""execution_count"": 17 + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:39:44.749545Z"", + ""start_time"": ""2025-11-30T10:39:44.162784Z"" + } + }, + ""source"": [ + ""# configure inference\n"", + ""inf <- fd$BaseInference(\n"", + "" sfs_neut = fd$Spectrum(c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0)),\n"", + "" sfs_sel = Spectrum(c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0)),\n"", + "" do_bootstrap = False\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""sfs_models <- fd$BaseInference$run(inf)"" + ], + ""outputs"": [], + ""execution_count"": 18 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""slideshow"": { + ""slide_type"": """" + }, + ""tags"": [] + }, + ""source"": ""fastDFE uses maximum likelihood estimation (MLE) to find the DFE. By default, 10 local optimization runs are carried out to make sure a reasonably good global optimum has been bound. The DFE furthermore needs to parametrized where {class}`~fastdfe.parametrization.GammaExpParametrization` is used by default. We also report the standard deviation across optimization runs to give an idea of the reliability of the estimates. In this case, the standard deviations are low, indicating that the estimates are stable."" + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""We can now plot the inferred DFE in discretized form (cf. {func}`~fastdfe.base_inference.BaseInference.plot_discretized`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""tags"": [], + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:39:44.904067Z"", + ""start_time"": ""2025-11-30T10:39:44.794296Z"" + } + }, + ""source"": ""p <- fd$BaseInference$plot_discretized(inf)"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nrQA4AAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 19 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""We can also plot a comparison of the `selected` modelled and observed SFS (cf. {func}`~fastdfe.base_inference.BaseInference.plot_sfs_comparison`)."" + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:39:45.014626Z"", + ""start_time"": ""2025-11-30T10:39:44.915448Z"" + } + }, + ""source"": ""p <- fd$BaseInference$plot_sfs_comparison(inf)"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\n/6QZPfhmM1wrAAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 20 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""## Bootstrapping\n"", + ""\n"", + ""To quantify uncertainly we can perform parametric bootstrapping (cf. {func}`~fastdfe.base_inference.BaseInference.bootstrap`)"" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-11-30T10:39:46.688618Z"", + ""start_time"": ""2025-11-30T10:39:45.026173Z"" + } + }, + ""source"": [ + ""bs <- inf$bootstrap()\n"", + ""\n"", + ""# redo the plotting\n"", + ""p <- fd$BaseInference$plot_discretized(inf)"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAigAAAGACAYAAACHqpmbAAAEDmlDQ1BrQ0dDb2xvclNwYWNl\nR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRB\nkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4\na73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PC\nv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UA\nVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXd\na8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8\nHOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojL\njVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0\nyDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5Pt\nXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEw\nQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXH\nliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vW\nc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUt\nVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJf\ncl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdd\nuwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqv\ngcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCg\nKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8A\nrD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvF\nY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAAIooAMA\nBAAAAAEAAAGAAAAAANfxKOcAAEAASURBVHgB7d0J2BTFmcDx9+O+kVuQU1FAjCCCRCKrkHAp\n16qIxiiIiCiyLGajgroqKMQgh8YjCoKYYEBhRfEWg6IIeIHKISKC3HKI4b5n+61sz8430zPT\nPd9Mz/Wv5/mYnurq7upf9zDvVFdXFwSsJCQEEEAAAQQQQCCDBIplUF2oCgIIIIAAAgggYAQI\nUDgREEAAAQQQQCDjBAhQMu6QUCEEEEAAAQQQIEDhHEAAAQQQQACBjBMgQMm4Q0KFEEAAAQQQ\nQIAAhXMAAQQQQAABBDJOgAAl4w4JFUIAAQQQQAABAhTOAQQQQAABBBDIOIESGVejNFbotttu\nk5UrV8rf/vY3Oe200+TIkSPStWtXqV69urz00ktprFnim96wYYM0bNgwuIJM26dw82BFHSYW\nL14sI0eOjJhTvHhxKVeunNSrV0+uvvpqad++fUQZzbj77rvl448/dpwXmlmpUiV55ZVXTNay\nZcvk9ttvD50dc/rvf/+7nHrqqTHLMBMBBBBAIL4AAUqI0RdffCH6JXjw4EGTe/LkSXn//fdN\nsBJSLCsm9+7dKzfffLP89NNP8vbbbwfrnGn7FG4erKjDxK5du8zxcJgVzHryySfl4osvlr/8\n5S/StGnTYL5OrFixIu7yWq5q1ar6YtKePXtcLWOXP3z4sD3JKwIIIIBAEQQIUGLglSxZUsaM\nGSMVK1aMUSozZ61bt05mzpwpnTp1KlTBbN4ne0fOO+88efXVV+23cuzYMfnnP/8py5cvl7Fj\nx8oHH3wgffr0kc8++0xKly4dLGdPjBs3zrS02O/DX4sVi7zyqcHOu+++G1404n3t2rUj8shA\nAAEEEPAuQIASw6xEiRIyYsSIGCWyb1Yu7JMGHXXr1o3Ab9mypQk8tAXlk08+MZd0HnnkkYhy\nVapUcVw+omBIhgZ2TtsMKcIkAggggEASBfIyQNHnI+qv6zfeeEO0CV/7LPTu3TuC9fjx4zJl\nyhQpX768XHfddYXma98E7afwww8/SK1ateTss8+W7t27F7o8ELrAd999JwsWLJClS5eaPi36\nJdqtW7dgEe0bMm3aNDnjjDOkdevW8swzz4he0ujZs6dcdNFFUlBQYMru27fPbFdbCw4cOCAt\nWrSQSy+9VOrXrx9cl16Weuedd8z7zZs3m8sdp59+unTu3FnC90kvBb3wwgvBZaNNaItEtWrV\ngrPd1CNY2Jpwax66TCLTZcqUMX2IzjrrLJk4caL8x3/8RyGbRNbJMggggAACaRDQpxnnU7L6\nCAQuvPBCfYKz+bNaFMyr9SUf+MUvfmGmv/32W0Ni9UUx760Os4WIrM6WJl/XYf2yDk7XqVMn\nYAUHhcrqm1tuuSVYJrS8FTAEtD6adu/ebcr8+7//e+CXv/xlsLwV/ASsSximzEcffRRo1KiR\nmWcFLIFSpUqZaatTZ+D55583ZfSfG2+8Mbi8vZ9XXnmlmR++T1bgFFHWXib09auvvgqu3209\n7AW8mNvLOL1al3VMXdUnXrKCTlN23rx5waJWsGfyrKAzmBdv4r333jPL6LlBQgABBBDwT0B/\n2eZVsr+8r7rqqsCWLVsCR48eDbz22msB604d80WkX8qxAhTr0oEpZ/1CD+gXtX75btq0KWDd\nXWLymzdvXshz9OjRJr9du3aBr7/+OnDixInAokWLgkHI8OHDTXk7QLFaAAIacNxzzz2BP/7x\nj4HHH3/czN+6dWvA6gsTsC5vBB599NGA1YIRsFpdAm+99VbA6vdgtqHr1WT1xwhYLSgmz2qp\nCWzbti1gtRSZeeEBiu7/6tWrI/6sPiyB3/zmN2Yd1157rVlW//FSD3shL+b2Mk6vXgKUoUOH\nmro//PDDwVXZAYrVOhWwWpIc//T4hCY7QLFayAJWh+OYf2pLQgABBBBIjkBeBSjWHTrmS0uD\ni/Avotdff93MixegaHCgZazOs4WOgK5Pgx7rUpD5EtOZGgBpWavPQ+Dnn38uVP7LL78MWJ0x\nA9ZlE9NCYgcoWv7ZZ58tVFbf9O/f36zL6uAZMU8DLF3OujQUnGfdHWPyrE6ywTydCA9QCs0M\neXPnnXea5a3LS8FWHp3ttR5ezUOqEDHpJUB56KGHTP379esXXI8doKhVtL/w1hk7QIlWPjT/\njjvuCG6LCQQQQACBognkVR8UvaVV08CBAyX8Tg3tx2FdPpH169ebMtH+sZr6zSzt31CzZk3p\n1auX6VOi65s1a1ahxbSfiCarBUIqV65caN65554rVsuFuYVZO66GJu13Ep6sIMT0QxkwYED4\nLNO3RDt+ar8aKxCSU045JaKMl4ynn35arJYH0x/m5ZdfLnQnjNd6JMPcS93tsnpnjybt2xOe\ndJyS8ONhl2nQoIE9Wei1bNmypr9PocywN6H9gMJm8RYBBBBAwKNA4W9GjwtnW3Gr1cJUWTuM\nOqUzzzwzboCiHWqvueYa0QG5NNAZNGiQnH/++aajqnYktS7xBFetHWk1acdXp6QdOcOTBhc6\nMFxo0qBDO8zqgGTa0dUp2V/Ia9eulTZt2jgVcZWnHYeHDBkiGvBYrUqF6pJIPZJh7qriYYX0\nNmtNGnSGpwcffFCsy07h2THfN27c2IyRE7MQMxFAAAEEkiYQOeBD0ladeSv68ccfTaV0pFCn\nFB4YOJXR1o4ZM2aYP70LR295/fTTT+WBBx6Qc845x4w6al3uMYtu3LjRvEb7te60/tA7Zez5\ndr2tTrGm5Udba8L/mjVrZgIT6xKOvZjnVw2o+vbta9Y9Z84cadKkSaF1JFIPe5mimBeqhMs3\ndoASLRh1uRqKIYAAAgikSSCvWlD0lly9Ndjq1OrIvX37dsf88Ey95fe3v/2t+bM6ycrChQvN\nwGF6S7Je+rE6xIp114zYlwusjqXhqzDv9ctbv7j18kGspJcOdJsaDOn4HqlIGkxddtllsn//\nfpk6dap06NAhYjOJ1CNZ5hGViZGhwYle7lKzX/3qVzFKMgsBBBBAIFMF8qoFRccX0fThhx9G\nHA8NNKy7bCLywzO09UQvD9j9S3TcDb3sYt1tY8bc0PIasGjSS0aanIIKvSSjl4b0GTI6Rkqs\npAGMBgd6icXu0xFa3roTR2699VYzMJnV2TZ0lqtpHYVVgxPrbh+566675IYbbnBcLpF6JMPc\nsTIxMn//+9+Lmui4NNqyREIAAQQQyD6BvApQ9Ne0dmzVhwF+/vnnhY6Wjji6c+fOQnlOb1at\nWmVaGO69996I2TpomyZtNdCkX5D6ADtrLI6Ih9Rph1rrLh8zwJv2b4iXrNtmTREdeCz8Ms79\n998vTz31lMyePTs4UJwGTpri7ZMGSldccYV5To32rdGh/WMlr/VIhnms+tjzNCDRAFNbrrSV\nTPf/vvvus2fzigACCCCQZQJ5dYlHHwI3d+5cc/ni3/7t30SfpKutHNatpOYOHL27I95lHmvQ\nNTO6rN7NcsEFF5ggRFsWdORWXY92ytQ7ezRpvl7ysW4/ll//+teiy+ozXbQjqv7p8OmTJ092\ndcpoYKIjvlpjnYg+i8a63dc8I0g7suozYrR/ij4oTy9raNKnMWs/FW3p0W3rZSdrTJaIbVlj\nrZh6a98a/VK3bss1d75YN4cVKmsNIGc6B3utRzLMC1XEeqN9ZezWKZ2nI+rqcbPrrO76rB5t\noUpWWrNmTaFtRlvvsGHDzHkVbT75CCCAAAIuBYp2l3J2Lq3jaehIo9ZdMfotbAZGs4aZD1j9\nSsz7WAO16R5bX/qBjh07mrK6vP5ZX4oBHWfDutsmAsW6pBSwLjUUKq8Duv3jH/8IlrXHQbHu\n+AnmhU/ooHB/+MMfAhUqVCi0LuuuncCCBQvCi5sB3XTQN62fjkCrKXwcFCvgKLQue3/CX61n\nEgXX77UeuqBb8+BGHCbscVDC66aj81qXwMwIwdYdOgGrb4/D0gFzfHTZREaSDd9mtPejRo1y\n3DaZCCCAAALeBAq0uPWfbV4ma2RQ0Q6s+hwdbW3wmnR5vayjrRfaMqK3AcdK+twfvQ1YHzpn\nDYsfq2jMeXrINmzYYC7fNGzY0Fy2iraAltVLSXqHkn3ZJ1pZr/le6mGvu6jm9np4RQABBBDI\nbYG8DlBy+9CydwgggAACCGSvgPdmg+zdV2qOAAIIIIAAAlkiQICSJQeKaiKAAAIIIJBPAgQo\n+XS02VcEEEAAAQSyRIAAJUsOFNVEAAEEEEAgnwQIUPLpaLOvCCCAAAIIZIkAAUqWHCiqiQAC\nCCCAQD4JEKDk09FmXxFAAAEEEMgSAQKULDlQVBMBBBBAAIF8EiBAyaejzb4igAACCCCQJQIE\nKFlyoKgmAggggAAC+SRAgJJPR5t9RQABBBBAIEsECFCy5EBRTQQQQAABBPJJoES+7OzSpUvl\nlltukQoVKuTLLrOfCCCAAAIIZJxAuXLl5K233opbr7wJUE6ePCmdOnWShx9+OC4KBRBAAAEE\nEEAg+QLHjh2Trl27uloxl3hcMVEIAQQQQAABBPwUIEDxU5ttIYAAAggggIArAQIUV0wUQgAB\nBBBAAAE/BQhQ/NRmWwgggAACCCDgSoAAxRUThRBAAAEEEEDATwECFD+12RYCCCCAAAIIuBIg\nQHHFRCEEEEAAAQQQ8FOAAMVPbbaFAAIIIIAAAq4ECFBcMVEIAQQQQAABBPwUIEDxU5ttIYAA\nAggggIArAQIUV0wUQgABBBBAAAE/BfLmWTx+otrbGj16tDz55JP224jXQCBg8goKCiLmaUb9\n+vVFH3JIQgABBBBAIN8ECFBSeMRLliwpZcqUcdzC4cOH5ccff5RKlSpJ1apVHcuULl3aMZ9M\nBBBAAAEEcl2AACWFR/iuu+4S/XNKixcvlnbt2snAgQNl/PjxTkXIQwABBBBAIG8F6IOSt4ee\nHUcAAQQQQCBzBQhQMvfYUDMEEEAAAQTyVoAAJW8PPTuOAAIIIIBA5goQoGTusaFmCCCAAAII\n5K0AAUreHnp2HAEEEEAAgcwVIEDJ3GNDzRBAAAEEEMhbAQKUvD307DgCCCCAAAKZK0CAkrnH\nhpohgAACCCCQtwIEKHl76NlxBBBAAAEEMleAACVzjw01QwABBBBAIG8F0j7U/b59+2TRokWi\nr23btjUPyIt1NE6ePCk6TPy6devkF7/4hbRo0UKKFSPOimXGPAQQQAABBLJNIK3f7OvXr5de\nvXrJ7NmzZcWKFTJgwABZsmRJVMNjx47JHXfcIRMmTJCtW7fKAw88YJbRoIWEAAIIIIAAArkj\nkNYWlLFjx0rPnj1l2LBhUlBQINOnT5eJEyfKzJkzzftw5nfeeUfWrFkj06ZNk+rVq8uRI0fk\nyiuvlPfee086deoUXpz3CCCAAAIIIJClAmlrQdm9e7esXr3atKBocKKpe/fupmVk1apVjpwv\nv/yyCUg0ONFUunRpE6xceOGFjuXJRAABBBBAAIHsFEhbC8r27duNWJ06dYJy1apVk1KlSsmO\nHTukefPmwXx7YuPGjaLltaXliy++kCpVqsjvfvc7ady4sV0k+Dp58mTZuXNn8H0gEAhOM4EA\nAggggAACmS2QtgBl27ZtpgVEW0FCU8WKFWXPnj2hWWb64MGDcujQIROc1KhRQy666CJzaefm\nm2+WZ599Vho2bFhomVdeeUXWrl0bzGvWrJk0adIk+J4JBBBAAAEEEMhcgbQFKCVLlpTjx49H\nyJw4cULKlSvnmK+ZFSpUMP1UdFr7n1xxxRXywgsvyMiRIzUrmB555BE5fPhw8L3e9fPJJ58E\n3zOBAAIIIIAAApkrkLYARfuRaDCiLSOhAcnevXuldu3aEWLasqKtLZdccklwnvZd0f4nejdQ\neGratGmhLG19ISGAAAIIIIBAdgikLUCpW7eulChRQlauXClt2rQxWtppVm8ZDu2XEsrYqFEj\nsfuu2Pnff/99xOUde1746/GPPpT9/a4Nz07L+4M7/tU/5uhbb8j+Xf/qj5OWijhstML0GQ65\nZCGAAAIIIOCfQNru4qlcubJ07tzZ3IWzf/9+czlmypQp0rVrV9E+JpoWLlwob775ZlDjmmuu\nkXnz5slnn31mWl/0tmO946djx47BMkwggAACCCCAQPYLpK0FRekGDx5sBlvr0aOHuXyjo8IO\nHTo0qDp//nxz23G3bt1MngYieofPiBEjRO/KKVu2rNx+++3BFpjggkwggAACCCCAQFYLpDVA\n0duEJ02aJNrvpHjx4lK+fPlCmKNGjSr0Xt9cffXV0qdPH9m1a5fUrFnTcUC3iIXIQAABBBBA\nAIGsEkhrgGJLVapUyZ509arBTK1atVyVpRACCCCAAAIIZJ9A2vqgZB8VNUYAAQQQQAABvwQI\nUPySZjsIIIAAAggg4FqAAMU1FQURQAABBBBAwC8BAhS/pNkOAggggAACCLgWIEBxTUVBBBBA\nAAEEEPBLgADFL2m2gwACCCCAAAKuBQhQXFNREAEEEEAAAQT8EiBA8Uua7SCAAAIIIICAawEC\nFNdUFEQAAQQQQAABvwQIUPySZjsIIIAAAggg4FqAAMU1FQURQAABBBBAwC8BAhS/pNkOAggg\ngAACCLgWIEBxTUVBBBBAAAEEEPBLgADFL2m2gwACCCCAAAKuBQhQXFNREAEEEEAAAQT8EiBA\n8Uua7SCAAAIIIICAawECFNdUFEQAAQQQQAABvwQIUPySZjsIIIAAAggg4FqAAMU1FQURQAAB\nBBBAwC8BAhS/pNkOAggggAACCLgWIEBxTUVBBBBAAAEEEPBLgADFL2m2gwACCCCAAAKuBQhQ\nXFNREAEEEEAAAQT8Eijh14bycTsTVqySad9+57jrR06cMPnPr10nr23c7Fimbvly8maX3zjO\nIxMBBBBAAIFcFiBASeHR1SBk//FjUbdQvXRpkQKJWubg8eNRl2UGAggggAACuSxAgJLCozui\nxS9E/0gIIIAAAggg4E2APijevCiNAAIIIIAAAj4IEKD4gMwmEEAAAQQQQMCbAAGKNy9KI4AA\nAggggIAPAgQoPiCzCQQQQAABBBDwJkCA4s2L0ggggAACCCDggwABig/IbAIBBBBAAAEEvAkQ\noHjzojQCCCCAAAII+CBAgOIDMptAAAEEEEAAAW8CBCjevCiNAAIIIIAAAj4IEKD4gMwmEEAA\nAQQQQMCbAAGKNy9KI4AAAggggIAPAgQoPiCzCQQQQAABBBDwJkCA4s2L0ggggAACCCDggwAB\nig/IbAIBBBBAAAEEvAkQoHjzojQCCCCAAAII+CBAgOIDMptAAAEEEEAAAW8CBCjevCiNAAII\nIIAAAj4IEKD4gMwmEEAAAQQQQMCbAAGKNy9KI4AAAggggIAPAgQoPiCzCQQQQAABBBDwJkCA\n4s2L0ggggAACCCDggwABig/IbAIBBBBAAAEEvAkQoHjzojQCCCCAAAII+CBAgOIDMptAAAEE\nEEAAAW8CBCjevCiNAAIIIIAAAj4IEKD4gMwmEEAAAQQQQMCbAAGKNy9KI4AAAggggIAPAgQo\nPiCzCQQQQAABBBDwJkCA4s2L0ggggAACCCDggwABig/IbAIBBBBAAAEEvAkQoHjzojQCCCCA\nAAII+CBAgOIDMptAAAEEEEAAAW8CBCjevCiNAAIIIIAAAj4IEKD4gMwmEEAAAQQQQMCbAAGK\nNy9KI4AAAggggIAPAgQoPiCzCQQQQAABBBDwJkCA4s2L0ggggAACCCDggwABig/IbAIBBBBA\nAAEEvAkQoHjzojQCCCCAAAII+CBAgOIDMptAAAEEEEAAAW8CBCjevCiNAAIIIIAAAj4IEKD4\ngMwmEEAAAQQQQMCbAAGKNy9KI4AAAggggIAPAgQoPiCzCQQQQAABBBDwJkCA4s2L0ggggAAC\nCCDggwABig/IbAIBBBBAAAEEvAkQoHjzojQCCCCAAAII+CBAgOIDMptAAAEEEEAAAW8CaQ9Q\n9u3bJ2+99Za89NJLsnHjRk+112W+++47T8tQGAEEEEAAAQQyXyCtAcr69eulV69eMnv2bFmx\nYoUMGDBAlixZ4kpt3rx58thjjxGguNKiEAIIIIAAAtklUCKd1R07dqz07NlThg0bJgUFBTJ9\n+nSZOHGizJw507yPVrfNmzfLM888IyVLloxWhHwEEEAAAQQQyGKBtLWg7N69W1avXm1aUDQ4\n0dS9e3fZunWrrFq1Kirp8ePHZfTo0dKvXz8pW7ZszEAm6kqYgQACCCCAAAIZLZC2FpTt27cb\nmDp16gSBqlWrJqVKlZIdO3ZI8+bNg/mhE9rKUq5cObniiitk2rRpobMKTa9cuVIOHToUzNu0\naVNwmgkEEEAAAQQQyGyBhAKUOXPmyPjx4+WHH34wQUAgEIjYyz179kTkhWZs27ZNSpcubf5C\n8ytWrCjRltV+KnPnzpWpU6fGbTm58847Ze3atcFVN2vWTM4IvmMCAQQQQAABBDJZwHOA8vHH\nH0vfvn3N5ZUWLVpIzZo14wYLTgDaf0Qv14SnEydOmBaS8PyDBw+aSzvaX6VGjRrhsyPeawvL\nrl27gvm6rV2vzQu+ZwIBBBBAAAEEMlfAc4Cit/aWKVNGvvjiCznzzDMT3rPq1auLBiMaeOgl\nGzvt3btXateubb8Nvr766qsm4Hj33XdF/zQdOHBAZs2aZe7kGTJkSLCsTtxwww2F3i9evFhm\nE6AUMuENAggggAACmSrgOUDRSzOtW7cuUnCiGHXr1pUSJUqI9hVp06aN8dFOsydPnpTQfik2\n3Nlnny3XX3+9/da8fvbZZ6Zsw4YNC+XzBgEEEEAAAQSyW8BzgKLByahRoyJaPrwyVK5cWTp3\n7mw6umr/EA1WpkyZIl27dg1ewlm4cKFpJenWrZuce+655i90Oy+++KK0b99eunTpEprNNAII\nIIAAAghkuYDn24z79+9vWi3uv/9+OXr0aJF2f/DgweaunR49ekjv3r1NkDJ06NDgOufPny/a\nIZeEAAIIIIAAAvkl4LkFZcGCBaaFY9y4cWYkV71UU758+Qi1L7/8MiIvPKNKlSoyadIk0X4n\nxYsXj1iPttTESq+//nqs2cxDAAEEEEAAgSwV8Byg6C3AR44cCfYbScZ+V6pUKRmrYR0IIIAA\nAgggkCMCngOUQYMGif6REEAAAQQQQACBVAl4DlDsiui4Iu+//76sWbNGjh07Ji1btjR/p5xy\nil2EVwQQQAABBBBAICGBhAKUzz//XLSzrI7sGp7GjBkjI0aMCM/mPQIIIIAAAggg4FrAc4Dy\n888/mwf8aQvKhAkTpG3btlKhQgXZsGGDGYJ+5MiRZiC34cOHu64EBRFAAAEEEEAAgVABzwHK\n5MmTRYMUHUn2rLPOCq5Lxynp2bOn3HzzzfLUU08JAUqQhgkEEEAAAQQQ8CjgeRwUvX34kksu\nKRSchG5TO9DqQ/q2bt0ams00AggggAACCCDgWsBzgKLjlcQaoM2ep8/ZISGAAAIIIIAAAokI\neA5QdKj7Dz74QD755JOI7QUCAfnTn/4k+iDAevXqRcwnAwEEEEAAAQQQcCPguQ/KwIEDTedY\nvcxz0003yQUXXCA60Jp2kn3uuedM35SpU6e62TZlEEAAAQQQQAABRwHPAUrZsmVl0aJFcuON\nN5qh7kPXqkPXP/HEE3LDDTeEZjONAAIIIIAAAgh4EvAcoOja69SpI2+++aZs3rxZVq9eLbt3\n75YzzjhD9KnEessxCQEEEEAAAQQQKIpAQgGKvUF9UKD+kRBAAAEEEEAAgWQKeO4km8yNsy4E\nEEAAAQQQQMBJIG4Lio5n0rlzZ2nXrp0888wzpo+JDsQWLzkNgx9vGeYjgAACCCCAAAIqEDdA\nKVasmOlXUqZMGSNWqlQp+plw7iCAAAIIIIBASgXiBiinnnqqLFmyJFgJvbVY/0gIIIAAAggg\ngECqBDz3QXn++efljjvuiFqfuXPnSoMGDeTQoUNRyzADAQQQQAABBBCIJRC3BUUX3rlzZ3B4\n+2XLlplRZLds2RKxXh3m/o033pCNGzfK4cOHRcdMISGAAAIIIIAAAl4FXAUo06ZNkzvvvLPQ\numPdXtyyZUvRQdtICCCAAAIIIIBAIgKuApThw4fL8ePH5dixY7JgwQL54YcfpH///hHbK1Gi\nhAlM+vTpEzGPDAQQQAABBBBAwK2AqwClZMmSMnLkSLPOpk2byqpVq+S+++5zuw3KIYAAAggg\ngAACngQ8d5Lt27evCU4mT54s77zzTnBjc+bMEX2AoA6BT0IAAQQQQAABBIoi4DlA0cs8rVq1\nkkGDBsl3330X3Hbx4sXl008/lcsuu0xeeOGFYD4TCCCAAAIIIICAVwHPAcr7778vX3/9tbz2\n2mty6623BrfXu3dv2bRpk3Tq1Eluv/12OXnyZHAeEwgggAACCCCAgBcBzwHKK6+8IhdffLFp\nKQnfUNWqVeU///M/5ccff5T169eHz+Y9AggggAACCCDgSsBzgKJr1U6z0ZIGKZp0SHwSAggg\ngAACCCCQiIDnAKVDhw7mVuNFixZFbE8v64wbN05q1qwp9erVi5hPBgIIIIAAAggg4EbA1W3G\noSvq0qWLtG3b1tyxc9VVV4kOylaxYkXRkWVnz54t33zzjcyYMSN0EaYRQAABBBBAAAFPAp4D\nlAoVKsi7775r7uLR/iihd+xoq4m+v+aaazxVgsIIIIAAAggggECogOcARRcuU6aM6EMDA4GA\n6QyrrSeNGjWS0047TQoKCkLXzzQCCCCAAAIIIOBZwHMflNAtaDBy+umnS/v27UWfzaPvNWj5\n8MMPQ4sxjQACCCCAAAIIeBJIqAVl6tSp8sQTT8iOHTvM83l0ixqY6PN69u3bZ/L0PQkBBBBA\nAAEEEEhEwHMLiraODBw4UL766itp0KCBGfNEW09q1Kgh+/fvl2LFislTTz2VSF1YBgEEEEAA\nAQQQMAKeAxQdQVaDEB2I7aOPPpKzzz5b9G6eFStWyMqVK6VWrVqiw96TEEAAAQQQQACBRAU8\nByjr1q2TCy+80PQ50Y2ed955smTJErP9xo0by8MPPyz33HNPovVhOQQQQAABBBBAQDwHKFWq\nVJGyZcsG6Zo0aSLLli0Lvm/Xrp3pm7J58+ZgHhMIIIAAAggggIAXAc8BStOmTWXx4sWm74lu\nSC/xbNiwQTZu3Gi2q5d59BJQrOHwvVSQsggggAACCCCQfwKeA5Trr7/etKCceeaZ8sEHH0jH\njh2lfPnycsUVV8iYMWPktttuM5eAtC8KCQEEEEAAAQQQSETAc4Cid+u8/PLLpu/J4cOHRS/5\n6F07y5cvl7vvvls2bdokw4YNS6QuLIMAAggggAACCBgBz+Og7Ny5Uxo2bGhaT+yxTq677jrp\n3Lmz6YvSvHlzHhTIyYUAAggggAACRRLw3ILy7LPPSv369WXNmjWFhrXXSzpdu3YlOCnS4WBh\nBBBAAAEEEFABzwHK6tWrjZw+GJCEAAIIIIAAAgikQsBzgDJkyBCpVq2a3HvvvaJ9UEgIIIAA\nAggggECyBTz3QdFOsNrPZMKECTJp0iRzSUcDlvD0+eefh2fxHgEEEEAAAQQQcCXgOUDRTrI/\n//yztGzZMriBkydPBqeZQAABBBBAAAEEiioQN0DRPifjx4+X0aNHS+3atWXAgAHSr1+/QqPJ\nFrUSLI8AAggggAACCIQKxO2D8u2334reubNjxw6z3EMPPSSXXnpp6DqYRgABBBBAAAEEkioQ\ntwXljDPOMBscN26cDBo0SLZt2yb79++XL774ImZFWrVqFXM+MxFAAAEEEEAAgWgCcQMU7RDb\nvn17mTFjhvmzV3T++efbk46v9iBujjPJRAABBBBAAAEEYgjEDVAKCgrkvffek/nz58uWLVvM\nMPffffedDB8+PMZqmYUAAggggAACCCQuEDdA0VXrk4m7detmtnLkyBHRW4gHDx6c+FZZEgEE\nEEAAAQQQiCHgKkAJXV4HaiMhgAACCCCAAAKpFIh7F08qN866EUAAAQQQQAABJwECFCcV8hBA\nAAEEEEAgrQIEKGnlZ+MIIIAAAggg4CRAgOKkQh4CCCCAAAIIpFWAACWt/GwcAQQQQAABBJwE\nCFCcVMhDAAEEEEAAgbQKEKCklZ+NI4AAAggggICTAAGKkwp5CCCAAAIIIJBWAQKUtPKzcQQQ\nQAABBBBwEiBAcVIhDwEEEEAAAQTSKkCAklZ+No4AAggggAACTgIEKE4q5CGAAAIIIIBAWgUI\nUNLKz8YRQAABBBBAwEmAAMVJhTwEEEAAAQQQSKsAAUpa+dk4AggggAACCDgJEKA4qZCHAAII\nIIAAAmkVIEBJKz8bRwABBBBAAAEngRJOmeQhgAACCDgLHD58WPbu3es802VuzZo1XZakGAL5\nK0CAkr/Hnj1HAIEEBGbNmiX9+/dPYMn/X+TgwYNStmzZ/89gCgEEIgQIUCJIyEAAAQSiC9Sv\nX1969erlWODYsWPyxhtvSI0aNaRdu3aOZTSzePHiUecxAwEE/iVAgMKZgAACCHgQ6NChg+if\nU9JLP5UrV5ZWrVrJ3LlznYqQhwACLgXoJOsSimIIIIAAAggg4J8AAYp/1mwJAQQQQAABBFwK\npP0Sz759+2TRokWir23bthW9vhsrnTx5Ur7++mtZvny51KpVyzS1li5dOtYizEMAAQQQQACB\nLBNIawvK+vXrTWez2bNny4oVK2TAgAGyZMmSqIS7du2Syy+/XMaMGSNbtmyRJ554wvSmL+ot\nf1E3yAwEEEAAAQQQSItAWltQxo4dKz179pRhw4ZJQUGBTJ8+XSZOnCgzZ84078NFNJCpU6eO\nPPnkk2bWoUOHTMCit/3ddNNN4cV5jwACCCCAAAJZKpC2FpTdu3fL6tWrTQuKBieaunfvLlu3\nbpVVq1Y5cpYrV06uv/764DwdR6Bp06ZmmWAmEwgggAACCCCQ9QJpa0HZvn27wdMWETtVq1ZN\nSpUqJTt27JDmzZvb2cHX0OBEM3/66SdZtmyZDBkyJFjGnvjtb38r33//vf1WGjVqJP+/pWA2\nEwggkOUC+/tdmzF7sP/oMVOX419/JZlUL61UhekzMsaJiiDgRiBtAcq2bdtEO7eGd3CtWLGi\n7NmzJ27djx49Kvfff780aNBAevfuHVG+fPnyouuyU5kyZexJXhFAAAEEEEAgwwXSFqCULFlS\njh8/HsFz4sQJ0Us5sZJ2ih0xYoR5Hob2WdF1hafJkycXylq8eLHM/q/fF8rjDQIIIIAAAghk\npkDa+qBUr15dNBjRZ1KEJg0+ateuHZpVaFrv5Ln11ltNcPP444+LroeEAAIIIIAAArklkLYA\npW7dulKiRAlZuXJlUFQ7zeo4J6H9UoIzrYkff/zRBCf16tWTxx57zAwpHTqfaQQQQAABBBDI\nDYG0XeLR51V07txZpk2bJs2aNTPBypQpU6Rr167mQVvKu3DhQjlw4IB069bNaI8fP960uvTp\n00e++eab4BGoVKmS6QQbzGACAQQQQAABBLJaIG0BiqoNHjxYHnjgAenRo4fpLNuiRQsZOnRo\nEHT+/PnmFmINUPT2Y+1HoknHTQlNOgLtI488EprFNAIIIIAAAghksUBaA5QqVarIpEmTTGdX\nffy43nkTmkaNGhV8q5d9Pvzww+B7JhBAAAEEEEAgdwXSGqDYrHqJhoRANIG1a9cWuqQXrVy0\nfB1bp0uXLtFmk48AAgggkIECGRGgZKALVcogAX2Uwb333ptwjXQAQL37i4QAAgggkD0CBCjZ\nc6zytqYdO3YUvQTolPTOrkcffVRat25tnsvkVCbeuDpOy5CHQDSBmd+vl9s+XhpttslfsHWb\nVP/bzKhlNl/TR8pEOaejLsQMBPJMgAAlzw54Nu5uu3btRP+ckt6mrgFKy5YtzeB9TmXIQyCZ\nApWsgSHPqly0y9L/evpYMmvFuhDIPQEClNw7puwRAgikUODSenVF/0gIIJBagbQN1Jba3WLt\nCCCAAAIIIJDNAgQo2Xz0qDsCCCCAAAI5KkCAkqMHlt1CAAEEEEAgmwUIULL56FF3BBBAAAEE\nclSAACVHDyy7hQACCCCAQDYLEKBk89Gj7ggggAACCOSoAAFKjh5YdgsBBBBAAIFsFiBAyeaj\nR90RQAABBBDIUQEClBw9sOwWAggggAAC2SxAgJLNR4+6I4AAAgggkKMCBCg5emDZLQQQQAAB\nBLJZgAAlm48edUcAAQQQQCBHBQhQcvTAslsIIIAAAghkswABSjYfPeqOAAIIIIBAjgoQoOTo\ngWW3EEAAAQQQyGYBApRsPnrUHQEEEEAAgRwVIEDJ0QPLbiGAAAIIIJDNAgQo2Xz0qDsCCCCA\nAAI5KkCAkqMHlt1CAAEEEEAgmwUIULL56FF3BBBAAAEEclSAACVHDyy7hQACCCCAQDYLEKBk\n89Gj7ggggAACCOSoQIkc3S92K4UC+/tdm8K1e1v1wZ9/Ngsce3+BZFK9tFIVps/wtjOURgAB\nBBAICtCCEqRgAgEEEEAAAQQyRYAAJVOOBPVAAAEEEEAAgaAAl3iCFEwgkNsCr7/+ukyZMiXh\nnSxevLjMnj074eVZEAEEEPAiQIDiRYuyCGSxwLp162Tu3LkJ70GJEvx3kTAeCyKAgGcB/sfx\nTMYCCGSnwE033SR9+/Z1rPyWLVvk/PPPlx49esjkyZMdyxQUFDjmk4kAAgikQoAAJRWqrBOB\nDBQoW7as6J9TOnr0qMkuU6aM1KpVy6kIeQgggICvAnSS9ZWbjSGAAAIIIICAGwECFDdKlEEA\nAQQQQAABXwUIUHzlZmMIIIAAAggg4EaAAMWNEmUQQAABBBBAwFcBAhRfudkYAggggAACCLgR\nIEBxo0QZBBBAAAEEEPBVgADFV242hgACCCCAAAJuBBgHxY0SZdIq8MWu3fLprl2Oddh+8JDJ\nX/3zP+Xpb9Y4lilTvIT0O/MMx3lkIoAAAghkpgABSmYeF2oVIvDu1m3y4PKvQnIiJz+xAhj9\nc0pVS5ciQHGCIQ8BBBDIYAEClAw+OFTtXwI969eVRhUqJMxRqjhXMhPGY0EEEEAgTQIEKGmC\nZ7PuBZqdcoroX66l/f2uzZhdOnDggKnL8U+WSibVSytVYfqMjHGiIggg4J8APy39s2ZLCCCA\nAAIIIOBSgADFJRTFEEAAAQQQQMA/AQIU/6zZEgIIIIAAAgi4FCBAcQlFMQQQQAABBBDwT4AA\nxT9rtoQAAggggAACLgW4i8clFMUQyHaBb6zB7KINeLfnyBGzez/s3y9//W6d464WkwK5tvHp\njvPIRAABBJItQICSbFHWh0CGCizYtl3u+PTzmLX7YvdPcuvHSx3LFC8gQHGEIRMBBFIiQICS\nElZWikDmCVxSu5Y89ssLEq5YMStAISGAAAJ+CRCg+CXNdhBIs0CuDniXZlY2jwACKRKgk2yK\nYFktAggggAACCCQuQICSuB1LIoAAAggggECKBAhQUgTLahFAAAEEEEAgcQEClMTtWBIBBBBA\nAAEEUiRAgJIiWFaLAAIIIIAAAokLEKAkbseSCCCAAAIIIJAiAQKUFMGyWgQQQAABBBBIXIAA\nJXE7lkQAAQQQQACBFAkQoKQIltUigAACCCCAQOICBCiJ27EkAggggAACCKRIgAAlRbCsFgEE\nEEAAAQQSFyBASdyOJRFAAAEEEEAgRQIEKCmCZbUIIIAAAgggkLgAAUridiyJAAIIIIAAAikS\nIEBJESyrRQABBBBAAIHEBQhQErdjSQQQQAABBBBIkQABSopgWS0CCCCAAAIIJC5AgJK4HUsi\ngAACCCCAQIoECFBSBMtqEUAAAQQQQCBxAQKUxO1YEgEEEEAAAQRSJECAkiJYVosAAggggAAC\niQuUSHzR5Cy5b98+WbRokehr27ZtpX79+jFXfOLECVm+fLmsWrVKmjZtKm3atIlZnpkIIIAA\nAgggkH0CaW1BWb9+vfTq1Utmz54tK1askAEDBsiSJUuiKmpwMnjwYLnvvvtky5YtMmrUKJkw\nYULU8sxAAAEEEEAAgewUSGsLytixY6Vnz54ybNgwKSgokOnTp8vEiRNl5syZ5n046Ysvvij7\n9++XWbNmSfny5eWHH36Q6667Ti677DJp0qRJeHHeI4AAAggggECWCqStBWX37t2yevVq04Ki\nwYmm7t27y9atW83lGyfPjz76SDp16mSCE53foEEDOeecc+Tdd991Kk4eAggggAACCGSpQNpa\nULZv327I6tSpE6SrVq2alCpVSnbs2CHNmzcP5tsT27Ztk9Dymq/vtXx4+vOf/yw//vhjMLt4\n8eLypdX68uD3G4J5TDgLlLjnHucZ/5d7HMOYPvZMHG2Jor3iWDQ/e+l4jnY5v16///57+fzz\nz4u0OW09L1euXJHWke0Lb9q0KWbXCDf795vf/EaqVKnipmiRywQCAdfrSFuAosFG6dKlzV9o\nbStWrCh79uwJzTLTx48fl127dkmlSpUKzdP33377baE8ffP222/L2rVrg/mtW7eWex/7c/B9\nuid0/1966SU577zzpH379umujrftW61YmZK0JW7GjBkmoP31r3+dKdVyV48MctRO6tOmTZPG\njRvLpZde6q7+mVIqgxyPHj0qf/nLX0xn/969e2eKUEbWQy/R6//30dJXX31lgg89J6OlLl26\nSJkyZaLNzot8veoQy0D7d+oP/7POOiuqR9euXSO+W6MWTsIM7XvqJqUtQClZsqRo0BGetCOs\nU0SsLSDFihWLWEbXof1RwtPjjz8uR44cCWbrOuvVqxd8n+6JZcuWmY7BehfSxRdfnO7qZO32\nNQjVD2CzZs1wLMJR1ID597//vdStWxfHIjhqH7nbbrtNTjnlFBxdOF5//fVRS2m/Qr2r8+mn\nn45ahhn/ErjmmmuiUrRq1cqcj9nomLYApXr16qLByMGDBwsFJHv37pXatWtHYGs/lapVq5rb\nkUNnavlTTz01NMtMN2zYMCKPDAQQQAABBBDIDoG0dZLVX2olSpSQlStXBqW00+zJkycj+pnY\nBU4//fRC5TVfx0M57bTT7CK8IoAAAggggEAOCKQtQKlcubJ07tzZXPfWZtHDhw/LlClTRK+F\n1ahRw9AuXLhQ3nzzzSDzlVdeKfPnzzdBiXa0mTNnjug136y7Zm7tkV4z1LuQ/OqYFETMsQm9\ntqqO2sGalLiA/lhQR/uzl/ia8ntJvQytjrVq1cpviCTsvTo6taYnYdV5tQq9TBZ+c0m2ABRY\nX/Tuu9Qmea+0M+wDDzwgX375peks26JFC7n77ruDnXX++7//29x2rIGLnaZOnSp//etfRfuw\naMvJkCFDRDvAkhBAAAEEEEAgdwTSGqDYjNqPRDvBOnV2tcuEvmqriS6j/VhICCCAAAIIIJB7\nAhkRoOQeK3uEAAIIIIAAAkURSFsflKJUmmURQAABBBBAILcFit9vpdzexdh7pwNUTZ48WS64\n4ALHgtopV8eIiPeUZXthHXtFnxX0yiuvmHFbtKNXUZJ2FP7pp58iOotpvRcsWCA6nooOdqSd\njkOT3sKt89577z3TkTj0TqdXX31Vjh07JjVr1gxdJKFpfeDjyy+/bLalK4jXqU3rpX2I9I4s\nHagvNMXbp3jzQ9fldVofPqmD+4WPYBzLUUfC1GX0cQt+JO1/pcdUzXXcl3gp0XMn3npjzXdy\nTOb5FmvbRZ3n9Vx22le3ddi4caO5AUAH2dIOtdrZW5PexajPI9OxK7TjcrYnp3M2WZ9jJ3+/\nP5OpOj76f7v9/7sOmVG2bNngppz2OzgzysS6devM+XbuuedGKRGZrf9//P3vfzc3peg2k/Wd\nEbml6Dl534KiDyg888wzowr94x//8DSM8HPPPSd/+9vfTNAQa5TEqBsMmbF8+XLRjsJ6K3Vo\nivcUaP1SjfXU5/PPP1+eeOIJSUb/aK3L888/b8anCR0YL7S+odNPPvmkuVtL79wKTfH2Kd78\n0HV5nda63HXXXSbYCF02nqMGWfoh1qGmU530WOlIrzow3YEDB+JuLtFzJ+6KYxSI5pjM8y3G\n5os8y8u5HG1f3VRCA3R9yKl+rvUBqLfccktw9Gy9C0iDfH3Ce7Ynp3M2WZ/jaP5+fiZTeXz0\ne0cDFA3mNGi1U7T9tudHe9XATR/C6zatWbPG3LCi45RpX8+0fYatkyhvkxUVBq699tqA9UWU\nNIM//OEPgTFjxhRpfVakGrB+eQQ6dOgQuOSSSwJWwFNofTfddFPA+pUVsE5ck28FRYGrrroq\n+P6FF14IXH311QHrZDbzN2zYELCG0w988803wfWMHj06YD1kMfg+0QmrhSZgPcAx7uLWs5cC\n//Vf/xXo2LFj4KKLLgqofWiKt0/x5oeuy8v0kiVLApdffrmp14033lhoUTeO1gMsAyNGjCi0\nXCre6LFWt8WLF8dcfVHPnZgrjzEzlqMulqzzLUYVijzL7bkcb19jVcQa3t18rq2WMFNMj5ee\nd0899VRwMWvIhUCfPn0CP//8czAvGyecztlkfI7j+fv1mUzlMbnnnnsivkfi7Xcy6/PGG28E\nrGFACn03puMznNctKM8884x5Do7+aomW/ud//if4y1oHldMWF+uLXsaOHSvWF66JSvWXtiZd\nn/7C1QHnHn74YdMkFm29sfKtk0Nef/11sQKdiOH53TwF2s1Tn/XhUFpfbbbzI/3xj380LTbq\nEp7i7VO8+eHrc/tef52MHDlSunXrJk5DRbtxbNu2rWhrhT43JBNSUc+dRPYhnqOu0+/zLZH9\ncLOMm32NtZ5PPvnEjEnRsmVLU0wv4+jYT6FPZNdLn/qMLm2NzaWUjM+xG/9M+0wm4xi62e9Y\n29HvrkcffdQU0cfD6P/DenlRnxt1++23y4QJE8yz7rTABx98IK+99pppuRk3bpx5lIjmp+Mz\nHP2bWWuUw0kPkh4I61dpzL3U/1DsLx9tytcH/FmRpLlurP0V9PkGeolD0xlnnCEVKlQwg4Zp\nH4FYgU+sjf7qV78ygc8vf/nLiGLxngKtC2ifmfCBecKf+qxjx2jfFg2m/Eh6CeWRRx5xHAgs\n3j7Fm59o/fW6rjaxDxw40PF6vxtH/YLR/xC1OTYTUlHPnUT2IZ6jrtPv8y2R/XCzjJt9jbUe\nPadC+4NpWf1s6oNQQ5vy9ThmyjkVa3+8zEvG59iNf6Z9Jr0YRSvrZr+jLav5dr8VndYf1BqA\n6A9s/Q7Q70B9qrQGKpq0b6JeZtSxxvR7zO7fmI7PcN4GKHrANEjRIfe9pH/+858yatQoGTBg\ngNxwww1mFNtPP/3UrEKfpqsjcep10J49e5qxXbys2y6ro6JG6yCn/8HFegq07lO0pz7ryWgn\nXb+ehNblHzsrpa+xRtaMt0/x5idacTWINgKtW0fdtj6E0i/HePtalHMn3rqjzY/laC/j9/lm\nbzfZr272NdY29Us6/Ins2ldNgxP9v8VOek5pi4P+cs6VlIzPsVv/TPpMJuP4ud1vL9uyLreb\nFmTrErcMHz7cdL7X7w4NSnTQVB3tXL/H7IfspuMznP3dxL0ckZCy2llLv+jt6FBnaVSpnZDs\n5PS4dO1try0ldtJoM7wTqz0v3quOoBvagqEdkWJ12NX1xXsKtJenPmvd1SGZyckw1qPA3exT\nvH2OV38NzN55551gMd1v/XDGSl4cNfjSu7b8TKk4d+LVPxHH0HWm4nwLXX+ypxM5l+PVwelc\n1mBYU+hT3O2AXj+fXu68iLf9dM532netj/6iD933ZNQxHZ/JZNTbz3WE3gmon01N+siZWMnv\nz3DeBijaO9m+tc8+IHpL8Y4dO+y35tpw8M3/TYR/2eplHKtzUngxV+81sJk3b16wrD6XJ16A\nEu8p0F6e+qz7rw7JTE6G4Wbh24u3Txq5639ibp98Hb5+/WWqt7raqWnTpnEDFC+O+h/voUOH\n7NX78pqKcydexRNxDF1nKs630PUnezqRczleHfRcD29t01Gx9bMfetu9nvOakv35jFe/VM6P\n9zlP5rbT8ZlMZv39WJdeNrKT3R0h3neZ35/hvA1QNBDQ5lOrp7yccsop5jhNmjTJPl6+vGrH\nTKfOmbE2HvoU6DZt2pii4U+B1ktM2inqsssuC65Kv9D0YYuhSfvUOLUShZbxOp2IYbx90g+F\n/oet+xRtn2PVs1GjRmLdkROriOM8L46NGzd2XEeqMlN17sSqb6KO9jpTcb7Z607FayLncrx6\nqOFbb71lLi/bQYie1+H9UjZv3mxWFe8HS7ztZdL8eJ/zZNZVzzW/P5PJrH+mrsvvz3De9kHR\n/yg0ytYBk1KZ3n///eBdQMnYjpunQLt56rM2K+t/gmeddVYyqlWkdcTbp3jzdePJdtZ1unHU\nctato9KkSROdzOjkxlEvKcyYMSPpv9wz6XxL5UHSlj710zv9nJLeCaFJy2i/Ex2fQu+80nFR\nQpP+v6T9iaL1kQotmy3Tfp5/2fKZTNaxi3feJWM76fgM522Aor9etC+JjrCXyvTmm2/K3Llz\nk7oJHYRNWxV69OhhWkB0X4YOHRrcht79Y42DYp703KVLF9O3xrqv3txhZBfSSFib8zLlF1q8\nfYo3PxXObhzVU79ksiFA0brGc/z222/NrYfJvrSQaeebWqQi6ReF3rpp3/kXvg29jKN3Aero\ny3p7sXZO1E6K7dq1K1Q0m86pQhWP88av8y9X/aLxxjvvoi3nJT8tn+FkDu6SbeuyOsEF+vfv\nn9Jq62BL1miwKdmG1ScgOBib0waskV0DO3fudJplBnp76KGHHOd5yXQ7uJXbdcbbp2jzU+kc\ny9HqrBqweroHrNFd3e5iQuWcBr1KaEX/t1A0R52tA+pZTwwvyuojltWBBZNxvkWsOIkZyTqX\nreAjYI0EGrdm1h09hQbCshfQwdt08MCPP/7YzsrK11jnbCrPP78+k6k8KE4DtcXbntvzLt56\nos1Px2c4b1tQNHLUAbq0c9DSpUu9BJKeyuqQ1XqrViqS3q5Yvnz5qKvWVhbtmBaetN+N9Z+x\nDBo0KHxWQu+1qVqbpK3/dBJaPnShePsUbX4qnaM5ar31sQbqmOy7EEJNQqetgNOMcxOal8h0\nNMevv/7atCzq5c9kpWSfb8mql9N6inouazO4jp2kY0bES3qnid05MbSsDtqml6AvvPDC0Oys\nnXY6Z1N5/vn9mUzVgdE7SvX/VTeDaXo57xKpb7o+wwUaLSVS4VxZRm/XfPbZZ+Wxxx5LyS4p\nr94RkklJ91cvC/Xr16/I1frwww/lT3/6k1mPXlayHh1Q5HUmsoJ0OGszstUqYB426fRFk8h+\nRFtG988OdHVcAn2mUSpSKhyTeb6lYp/tdSbrXC6KoS6r4yvdd999Jkix65aNr4mcs0WxUyM/\nP5OpPCY6UrnVgmY28fjjj4ubh84W1S7W/qTrM5z3AYoeFI0O7Tt5Yh2kXJmndy/pL34d64OU\nuIA+HFF/cYferpf42nJ3Sc4398dWzyf95awtDCTvAnwmvZu5WSJdn2ECFDdHhzIIIIAAAggg\n4KtAXvdB8VWajSGAAAIIIICAa4G8HajNtRAFEUAg7QLaCXDNmjXm0Qx6a7z+pbrfT9p3mgog\nkOcCtKDk+QnA7iOQ6QLaYVAfqHfOOeeYsX/0UQX6/sEHH0z4MROZvs/UDwEERGhB4SxAAIGM\nFdBHwFvjL0jfvn3NaKv6zJpFixaZwQfvvfde81ybKVOmZGz9qRgCCCQuQCfZxO1YEgEEUiig\no2Pq01Pr1KkjOhxA6CUdnactKTqkuT7gM5/uwkshOatGIKMEuMSTUYeDyiCAgC2wa9cu+emn\nn+Tss88uFJzofL1FXsff0ZaVLVu22IvwigACOSRAC0oOHUx2BYFcEzj33HNFn9Y9fvx4+d3v\nfidVq1bNtV1kfxBAIIoAAUoUGLIRQCD9AvpUYH0kxYYNG0wrSps2baRDhw7SqVMnufjiixls\nMP2HiBogkDIBApSU0bJiBBBIhsCePXvkueeek1dffdUM/209yNCsVp9GPmfOHGmM0ZVGAAAB\n90lEQVTRokUyNsM6EEAgwwQIUDLsgFAdBBCILnDw4EFzF48+HFKfD1K6dGnRZ+i0atUq+kLM\nQQCBrBSgk2xWHjYqjUDuC+jlHesR8uZ5R/be6jOk9PLO008/bVpUNGCZNWuWPZtXBBDIIQEC\nlBw6mOwKArkkMG/ePLn88stNC4nTfnXu3Nm0oKxdu9ZpNnkIIJDlAgQoWX4AqT4CuSrQs2dP\ns2t333237Ny5M2I3teVEn17bpUuXiHlkIIBA9gvQByX7jyF7gEDOCtxzzz3y0EMPmcHaNGBp\n2bKl6GWdpUuXyosvviitW7eWt99+W3SEWRICCOSWAAFKbh1P9gaBnBOYOXOmjBs3TlatWiWH\nDx82+1e7dm3p3r27PProo1K2bNmc22d2CAEERAhQOAsQQCArBHR4+3Xr1kmFChVMi0pWVJpK\nIoBAwgIEKAnTsSACCCCAAAIIpEqATrKpkmW9CCCAAAIIIJCwAAFKwnQsiAACCCCAAAKpEiBA\nSZUs60UAAQQQQACBhAUIUBKmY0EEEEAAAQQQSJUAAUqqZFkvAggggAACCCQsQICSMB0LIoAA\nAggggECqBAhQUiXLehFAAAEEEEAgYQEClITpWBABBBBAAAEEUiVAgJIqWdaLAAIIIIAAAgkL\nEKAkTMeCCCCAAAIIIJAqgf8FIb/+2ymUZ+MAAAAASUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 276, + ""height"": 192 + } + }, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 21 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""By default, we perform 2 optimization runs per bootstrap sample taking the best result (cf. {attr}`~fastdfe.base_inference.BaseInference.n_bootstrap_retries`). The standard deviation across runs is computed for each bootstrap sample, and the average of these standard deviations across all samples is reported to summarize the uncertainty of the bootstrap estimates. In this case, we can see that the uncertainty is quite low indicating reliable bootstrap estimates."" + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""R"", + ""language"": ""R"", + ""name"": ""ir"" + }, + ""language_info"": { + ""codemirror_mode"": ""r"", + ""file_extension"": "".r"", + ""mimetype"": ""text/x-r-source"", + ""name"": ""R"", + ""pygments_lexer"": ""r"", + ""version"": ""4.3.3"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 4 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/R/parametrizations.ipynb",".ipynb","43676","148","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""# DFE parametrizations\n"", + ""\n"", + ""The DFE needs to be parametrized in some way in order to be amenable to maximum likelihood estimation. {class}`~fastdfe.parametrization.GammaExpParametrization` is used by default. Other parametrizations are also implemented (cf. {mod}`~fastdfe.parametrization`). You can also create your own parametrization by subclassing {class}`~fastdfe.parametrization.Parametrization`.\n"", + ""\n"", + ""To see how the parametrization affects the shape of the DFE, we use our example data for `B. pendula`."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": {}, + ""source"": [ + ""library(fastdfe)\n"", + ""\n"", + ""# load the fastdfe package\n"", + ""fd <- load_fastdfe()"" + ], + ""outputs"": [], + ""execution_count"": null + }, + { + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:22:47.836082Z"", + ""start_time"": ""2025-12-12T12:22:40.714119Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", + ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", + ""source(\""R/fastdfe.R\"")\n"", + ""fd <- load_fastdfe()\n"", + ""fd$Settings$parallelize <- FALSE\n"", + ""# set plot size\n"", + ""options(repr.plot.width = 6, repr.plot.height = 3)"" + ], + ""outputs"": [], + ""execution_count"": 1 + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:23:46.701447Z"", + ""start_time"": ""2025-12-12T12:22:47.841053Z"" + } + }, + ""source"": [ + ""# the different DFE parametrizations\n"", + ""parametrizations = c(\n"", + "" fd$GammaExpParametrization(),\n"", + "" fd$DiscreteParametrization(),\n"", + "" fd$GammaDiscreteParametrization(),\n"", + "" fd$DisplacedGammaParametrization()\n"", + "")\n"", + ""\n"", + ""inferences <- vector(\""list\"", length = 4)\n"", + ""\n"", + ""for(i in seq_along(parametrizations)) {\n"", + "" # create inference object\n"", + "" inference <- fd$BaseInference(\n"", + "" sfs_neut = fd$Spectrum(c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0)),\n"", + "" sfs_sel = fd$Spectrum(c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0)),\n"", + "" fixed_params = list(all = list(h = 0.5, eps = 0)),\n"", + "" model = parametrizations[[i]]\n"", + "" )\n"", + ""\n"", + "" # run inference\n"", + "" inference$run()\n"", + ""\n"", + "" inferences[[i]] <- inference\n"", + ""}"" + ], + ""outputs"": [], + ""execution_count"": 2 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:23:47.307243Z"", + ""start_time"": ""2025-12-12T12:23:46.718841Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""# plot the inferred DFEs\n"", + ""p <- fd$Inference$plot_discretized(\n"", + "" inferences = inferences,\n"", + "" labels = c(\""GammaExp\"", \""Discrete\"", \""GammaDiscrete\"", \""DisplacedGamma\""),\n"", + "" intervals = c(-Inf, -100, -10, -1, 1, Inf),\n"", + "")"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAtAAAAFoCAYAAAB+JswZAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\no/8AAAAASUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 360, + ""height"": 180 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 3 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""The overall shape is similar, but {class}~fastdfe.parametrization.DiscreteParametrization shows noticeably wider confidence intervals. In general, estimating the full DFE with a sample size of 10 and the limited SNP count used here leads to substantial uncertainty."" + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""R"", + ""language"": ""R"", + ""name"": ""ir"" + }, + ""language_info"": { + ""codemirror_mode"": ""r"", + ""file_extension"": "".r"", + ""mimetype"": ""text/x-r-source"", + ""name"": ""R"", + ""pygments_lexer"": ""r"", + ""version"": ""4.2.3"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 1 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/R/simulation.ipynb",".ipynb","291046","445","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""# SFS simulation\n"", + ""fastDFE provides a {class}`~fastdfe.simulation.Simulation` module to generate an expected SFS under a specific DFE, and potentially demographic nuisance parameters. In fact, when inferring the DFE with fastDFE, the expected SFS is repeatedly simulated for different parameters to find the maximum likelihood estimates. Below, we illustrate how to use the simulation module to generate SFS data under a given DFE. To do this, we need to specify a neutral SFS ({attr}`~fastdfe.simulation.Simulation.sfs_neut`), which is informative on the population sample size, population mutation rate, the number of sites, and possibly demography. {func}`~fastdfe.simulation.Simulation.get_neutral_sfs` can be used to obtain a neutral SFS under a constant panmictic population. We also specify the DFE parameters and parametrization. By default, we assume not ancestral misidentification (`eps=0`) and mutation are assumed to be semi-dominant (`h=0.5`)."" + ] + }, + { + ""metadata"": {}, + ""cell_type"": ""code"", + ""source"": [ + ""library(fastdfe)\n"", + ""\n"", + ""# load the fastdfe package\n"", + ""fd <- load_fastdfe()"" + ], + ""outputs"": [], + ""execution_count"": null + }, + { + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:39:55.590290Z"", + ""start_time"": ""2025-12-12T12:39:48.829119Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""setwd(\""/Users/au732936/PycharmProjects/fastDFE\"")\n"", + ""reticulate::use_condaenv(\""/Users/au732936/miniconda3/envs/dev-r-fastdfe\"", required = TRUE)\n"", + ""source(\""R/fastdfe.R\"")\n"", + ""fd <- load_fastdfe()\n"", + ""options(repr.plot.width = 7, repr.plot.height = 3)"" + ], + ""outputs"": [], + ""execution_count"": 1 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:39:55.618753Z"", + ""start_time"": ""2025-12-12T12:39:55.598913Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""# create simulation object by specifying neutral SFS and DFE\n"", + ""sim <- fd$Simulation(\n"", + "" sfs_neut = fd$Simulation$get_neutral_sfs(n = 20, n_sites = 1e8, theta = 1e-4),\n"", + "" params = list(S_d = -300, b = 0.3, p_b = 0, S_b = 1),\n"", + "" model = fd$GammaExpParametrization()\n"", + "")"" + ], + ""outputs"": [], + ""execution_count"": 2 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Let's plot the DFE we are going to use for the simulation which is purely deleterious and follows a gamma distribution."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:39:56.100130Z"", + ""start_time"": ""2025-12-12T12:39:55.624085Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""p <- sim$dfe$plot()"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 3 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Let's now run the simulation and plot the expected SFS for both neutral (specified) and selected (simulated) sites."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:39:56.779859Z"", + ""start_time"": ""2025-12-12T12:39:56.108834Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""sfs_sel <- sim$run()\n"", + ""p <- sim$get_spectra()$plot()"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nOgIIIIAAAggggAACCCQK/D9sgKw1XDyJlQAAAABJRU5ErkJggg=="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 4 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We can now use the simulated SFS to infer the DFE parameters and assess how closely the inference recovers the true DFE used to generate the data."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:39:58.300627Z"", + ""start_time"": ""2025-12-12T12:39:56.786554Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf = fd$BaseInference(\n"", + "" sfs_neut = sim$sfs_neut,\n"", + "" sfs_sel = sim$sfs_sel,\n"", + "" fixed_params = list(all = list(eps = 0, h = 0.5, p_b = 0, S_b = 1))\n"", + "")\n"", + ""\n"", + ""sfs_modelled <- inf$run()\n"", + ""\n"", + ""p <- fd$DFE$plot_many(c(sim$dfe, inf$get_dfe()), labels = c('True DFE', 'Inferred DFE'))"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nKfD/m3sZPYGj+P4AAAAASUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 5 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""The DFE is recovered quite well which is expected given the simplicity of the DFE parametrization and lack of demographic complications."" + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We may want to see how the expected SFS changes as we vary the degree of dominance. Here, we run a second simulation with the same parameters except that we set `h=0.3` so that mutations are partially recessive."" + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:40:37.220613Z"", + ""start_time"": ""2025-12-12T12:39:58.326241Z"" + } + }, + ""source"": [ + ""# run simulation with h=0.3\n"", + ""sim2 <- fd$Simulation(\n"", + "" sfs_neut = fd$Simulation$get_neutral_sfs(n = 20, n_sites = 1e8, theta = 1e-4),\n"", + "" params = list(S_d = -300, b = 0.3, p_b = 0, S_b = 1, h = 0.3),\n"", + "" model = fd$GammaExpParametrization()\n"", + "")\n"", + ""\n"", + ""sfs_sel <- sim2$run()\n"", + ""\n"", + ""p <- fd$Spectra$from_spectra(list(\n"", + "" neutral = sim$sfs_neut,\n"", + "" semidominant = sim$sfs_sel,\n"", + "" recessive = sim2$sfs_sel\n"", + ""))$plot()"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nFvh/wCbm6CVkDM0AAAAASUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 6 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""As expected, partially recessive mutations lead to an excess of rare variants because they are masked in heterozygotes and experience weaker purifying selection. At higher frequencies, the difference from the semidominant case diminishes as derived-allele homozygotes become more common."" + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""We can now infer the DFE under the (incorrect) assumption that mutations are semidominant (`h=0.5`) and see how this affects the inference result."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:40:38.944551Z"", + ""start_time"": ""2025-12-12T12:40:37.239819Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf <- fd$BaseInference(\n"", + "" sfs_neut = sim2$sfs_neut,\n"", + "" sfs_sel = sim2$sfs_sel\n"", + "")\n"", + ""\n"", + ""sfs_modelled <- inf$run()\n"", + ""\n"", + ""p <- fd$DFE$plot_many(c(sim2$dfe, inf$get_dfe()), labels = c('True DFE (h=0.3)', 'Inferred DFE (h=0.5)'))"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nEEgi8P9Fka+NvgmT7QAAAABJRU5ErkJggg=="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 7 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Assuming semidominance when mutations are actually partially recessive leads to an inferred DFE shifted toward weaker selection coefficients. This happens because rare variants generated by recessive mutations are misattributed to weaker selection when the dominance reduction in purifying selection is not accounted for."" + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We can also try to infer the DFE while letting the dominance coefficient `h` vary during the optimization. To optimize `h`, it needs to be discretized; in this example we use the default grid of 21 points between 0 and 1, with intermediate values obtained by linear interpolation. All required values are precomputed before the optimization, but allowing `h` to vary increases the computational cost because the expected SFS must be simulated for each `h` in the grid. To speed up the precomputation step, we instruct {class}`~fastdfe.base_inference.BaseInference` to use a coarser DFE discretization grid than the default, which should be sufficient for most inference scenarios."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:41:07.078128Z"", + ""start_time"": ""2025-12-12T12:40:38.961602Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf <- fd$BaseInference(\n"", + "" sfs_neut = sim$sfs_neut,\n"", + "" sfs_sel = sim$sfs_sel,\n"", + "" intervals_h = c(0, 1, 21),\n"", + "" intervals_del = c(-1.0e+8, -1.0e-5, 100),\n"", + "" intervals_ben = c(1.0e-5, 1.0e4, 100),\n"", + "" fixed_params = list(all = list(eps = 0, p_b = 0, S_b = 1))\n"", + "")\n"", + ""\n"", + ""sfs_modelled <- inf$run()\n"", + ""\n"", + ""p <- fd$DFE$plot_many(c(sim2$dfe, inf$get_dfe()), labels = c('True DFE (h=0.3)', 'Inferred DFE'))"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nQCA/Av8PDYGSO7Df7b4AAAAASUVORK5CYII="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 8 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We see that allowing `h` to vary during inference roughly recovers the true DFE used for the simulation, but with substantially greater uncertainty. Finally, we can examine the bootstrap results to assess how well `h` was estimated."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:41:07.119512Z"", + ""start_time"": ""2025-12-12T12:41:07.095752Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""hist(inf$bootstraps$h)"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""Plot with title “Histogram of inf$bootstraps$h”"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nwtY+7QAAAABJRU5ErkJggg=="" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 9 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We see that `h` was estimated with considerable uncertainty, but the bootstrap distribution still puts substantial mass near the true value `h = 0.3`. How well dominance can be inferred from SFS data alone remains an open question, especially when the DFE is more complex or additional nuisance parameters such as demography are included."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:41:07.155670Z"", + ""start_time"": ""2025-12-12T12:41:07.134129Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""plot(abs(inf$bootstraps$S_d), inf$bootstraps$h, log=\""x\"")"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""plot without title"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA0gAAAFoCAYAAABt1NvEAAAEDmlDQ1BrQ0dDb2xvclNwYWNl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\nQiAAAQhAAAIQgAAEIACBugn8H69Zl/9u2fTGAAAAAElFTkSuQmCC"" + }, + ""metadata"": { + ""image/png"": { + ""width"": 420, + ""height"": 180 + } + }, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 10 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Indeed, we see that `h` covaries with `S_d`, with larger `h` associated with less strongly deleterious mutations."" + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""R"", + ""language"": ""R"", + ""name"": ""ir"" + }, + ""language_info"": { + ""codemirror_mode"": ""r"", + ""file_extension"": "".r"", + ""mimetype"": ""text/x-r-source"", + ""name"": ""R"", + ""pygments_lexer"": ""r"", + ""version"": ""4.2.3"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 1 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/example_pendula_complex.ipynb",".ipynb","53942","146","{ + ""cells"": [ + { + ""cell_type"": ""code"", + ""execution_count"": 1, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""Counting sites: 2439037it [00:41, 59006.72it/s]\n"", + ""\u001B[32mINFO:fastdfe.Parser: Using stratification: [neutral, selected].[A, C, G, T].\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Parser: Starting to parse.\u001B[0m\n"", + ""Processing sites: 100%|██████████| 2439037/2439037 [05:29<00:00, 7402.38it/s] \n"", + ""\u001B[32mINFO:fastdfe.PolyAllelicFiltration: Filtered out 0 sites.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.DegeneracyStratification: Number of sites with valid type: 980934 / 2438327\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.AncestralBaseStratification: Number of sites with valid type: 980934 / 981644\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Parser: Included 980934 out of 2439037 sites in total.\u001B[0m\n"" + ] + } + ], + ""source"": [ + ""import fastdfe as fd\n"", + ""\n"", + ""# instantiate parser\n"", + ""p = fd.Parser(\n"", + "" n=10,\n"", + "" vcf=\""../../resources/genome/betula/all.vcf.gz\"",\n"", + "" stratifications=[fd.DegeneracyStratification(), fd.AncestralBaseStratification()]\n"", + "")\n"", + ""\n"", + ""# parse SFS\n"", + ""spectra: fd.Spectra = p.parse()"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:28:11.159868Z"", + ""start_time"": ""2023-07-19T10:21:59.120287Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 2, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:fastdfe.JointInference: Using shared parameters [SharedParams(params=['p_b', 'S_b'], types=['A', 'C', 'G', 'T'])].\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Including covariates: {}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'all'.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_b': 100} and lower bound for {'all.p_b': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 90 iterations and 685 function evaluations, obtaining a log-likelihood of -37.51293539207359.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -53949.40796474576, 'all.b': 0.11366118571317227, 'all.p_b': 0.0035695995726279578, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inferences for types ['A', 'C', 'G', 'T'].\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'A'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_b': 100} and lower bound for {'all.S_d': -100000.0, 'all.b': 0.01}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 18 iterations and 120 function evaluations, obtaining a log-likelihood of -31.8637145820187.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -100000.0, 'all.b': 0.09522023308068508, 'all.p_b': 0.006569641953718728, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'C'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_b': 100} and lower bound for {}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 85 iterations and 645 function evaluations, obtaining a log-likelihood of -32.31745271402025.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -4185.848942283267, 'all.b': 0.19089043196990704, 'all.p_b': 0.006698568663111203, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'G'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.b': 10} and lower bound for {'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 65 iterations and 460 function evaluations, obtaining a log-likelihood of -39.34106087078578.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -165.01887014239622, 'all.b': 10.0, 'all.p_b': 0.23938783194502647, 'all.S_b': 0.18076846503635546, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'T'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.S_d': -100000.0, 'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 46 iterations and 295 function evaluations, obtaining a log-likelihood of -39.58658201021626.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -100000.0, 'all.b': 0.15428875493961483, 'all.p_b': 0.17278065494179437, 'all.S_b': 0.0001, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'A.S_d': -100000.0, 'A.b': 0.01, 'G.S_d': -100000.0, 'T.S_d': -100000.0, 'T.b': 0.01}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Successfully finished optimization after 172 iterations and 2365 function evaluations, obtaining a log-likelihood of -146.11003066065462.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Inferred parameters: {'A.S_d': -100000.0, 'A.b': 0.09494023640538324, 'A.eps': 0.0, 'A.p_b': 0.006134398085142732, 'A.S_b': 44.275753637691146, 'C.S_d': -4941.28735561608, 'C.b': 0.1853951938413811, 'C.eps': 0.0, 'C.p_b': 0.006134398085142732, 'C.S_b': 44.275753637691146, 'G.S_d': -100000.0, 'G.b': 0.12013852605367349, 'G.eps': 0.0, 'G.p_b': 0.006134398085142732, 'G.S_b': 44.275753637691146, 'T.S_d': -100000.0, 'T.b': 0.1005073962112379, 'T.eps': 0.0, 'T.p_b': 0.006134398085142732, 'T.S_b': 44.275753637691146}.\u001B[0m\n"" + ] + } + ], + ""source"": [ + ""inf = fd.JointInference(\n"", + "" sfs_neut=spectra['neutral.*'].merge_groups(1),\n"", + "" sfs_sel=spectra['selected.*'].merge_groups(1),\n"", + "" shared_params=[fd.SharedParams(params=['p_b', 'S_b'], types='all')],\n"", + "" fixed_params=dict(all=dict(eps=0))\n"", + "")\n"", + ""\n"", + ""inf.run()"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:28:22.897447Z"", + ""start_time"": ""2023-07-19T10:28:11.161033Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 3, + ""outputs"": [ + { + ""data"": { + ""text/plain"": ""
"", + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""source"": [ + ""inf.plot_discretized();"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:28:23.216497Z"", + ""start_time"": ""2023-07-19T10:28:22.900228Z"" + } + } + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 2 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython2"", + ""version"": ""2.7.6"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 0 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/parser.ipynb",".ipynb","62693","472","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""# VCF parsing\n"", + ""## Introduction\n"", + ""fastDFE provides parser utilities that enable convenient parsing of frequency spectra from VCF files. By default, {class}`~fastdfe.parser.Parser` looks at the ``AA`` tag in the VCF file's info field to retrieve the correct polarization. Sites for which this tag is not well-defined are by default included (see {attr}`~fastdfe.parser.Parser.skip_not_polarized`). Note that non-polarized frequency spectra provide little information on the distribution of beneficial mutations, however.\n"", + ""\n"", + ""We might also want to stratify the SFS by some site properties, such as site-degeneracy. This is done by passing stratifications to the parser. In this example, we will stratify the SFS by 0-fold and 4-fold degenerate sites using a VCF file for ``Betula spp.``"" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:49.285604Z"", + ""start_time"": ""2024-06-05T09:37:48.920029Z"" + } + }, + ""source"": [ + ""import matplotlib.pyplot as plt\n"", + ""\n"", + ""plt.rcParams['figure.figsize'] = [4.4, 3.3]"" + ], + ""outputs"": [], + ""execution_count"": 1 + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:50.147793Z"", + ""start_time"": ""2024-06-05T09:37:49.287162Z"" + } + }, + ""source"": [ + ""import fastdfe as fd\n"", + ""\n"", + ""# url to the GitHub repository of fastDFE\n"", + ""url = \""https://github.com/Sendrowski/fastDFE/blob/dev/\"""" + ], + ""outputs"": [], + ""execution_count"": 2 + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:39:31.193351Z"", + ""start_time"": ""2024-06-05T09:37:50.148707Z"" + } + }, + ""source"": [ + ""# instantiate parser\n"", + ""p = fd.Parser(\n"", + "" n=8,\n"", + "" vcf=url + \""resources/genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true\"",\n"", + "" fasta=url + \""resources/genome/betula/genome.subset.1000.fasta.gz?raw=true\"",\n"", + "" gff=url + \""resources/genome/betula/genome.gff.gz?raw=true\"",\n"", + "" annotations=[\n"", + "" fd.DegeneracyAnnotation()\n"", + "" ],\n"", + "" stratifications=[fd.DegeneracyStratification()]\n"", + "")\n"", + ""\n"", + ""# parse SFS\n"", + ""spectra: fd.Spectra = p.parse()"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Parser: Using stratification: [neutral, selected].\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Loading VCF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/70975cbc50c2.biallelic.polarized.subset.50000.vcf.gz\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Loading GFF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/2d03158a125f.genome.gff.gz\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Loading FASTA file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/eb1f2b2b0185.genome.subset.1000.fasta.gz\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/70975cbc50c2.biallelic.polarized.subset.50000.vcf.gz\u001B[0m\n"", + ""Parser>Counting sites: 50000it [00:01, 28368.14it/s]\n"", + ""Parser>Processing sites: 100%|██████████| 50000/50000 [01:38<00:00, 509.88it/s]\n"", + ""\u001B[32mINFO:PolyAllelicFiltration: Filtered out 0 sites.\u001B[0m\n"", + ""\u001B[32mINFO:DegeneracyStratification: Number of sites with valid type: 13771\u001B[0m\n"", + ""\u001B[32mINFO:DegeneracyAnnotation: Annotated 19002 sites.\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Skipped 1669 sites without ancestral allele information.\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Included 13771 out of 50000 sites in total from the VCF file.\u001B[0m\n"" + ] + } + ], + ""execution_count"": 3 + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:39:31.364248Z"", + ""start_time"": ""2024-06-05T09:39:31.194667Z"" + } + }, + ""source"": [ + ""# visualize SFS\n"", + ""spectra.plot();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 4 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""fastDFE relies here on VCF info tags to determine the degeneracy of a site but this behavior can be customized (cf. {class}`~fastdfe.parser.DegeneracyStratification`)."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""## Stratifications\n"", + ""We can use also several stratifications in tandem by specifying a list of stratifications. In this example, we will stratify the SFS by synonymy as well as base transitions type. The resulting spectra can be fed directly into fastDFE's inference routines. See {mod}`~fastdfe.parser` module for a complete list of available stratifications."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:41:09.309665Z"", + ""start_time"": ""2024-06-05T09:39:31.366320Z"" + } + }, + ""source"": [ + ""# instantiate parser\n"", + ""p = fd.Parser(\n"", + "" n=10,\n"", + "" vcf=url + \""resources/genome/betula/biallelic.polarized.subset.50000.vcf.gz?raw=true\"",\n"", + "" fasta=url + \""resources/genome/betula/genome.subset.1000.fasta.gz?raw=true\"",\n"", + "" gff=url + \""resources/genome/betula/genome.gff.gz?raw=true\"",\n"", + "" annotations=[\n"", + "" fd.DegeneracyAnnotation()\n"", + "" ],\n"", + "" stratifications=[\n"", + "" fd.DegeneracyStratification(),\n"", + "" fd.AncestralBaseStratification()\n"", + "" ]\n"", + "")\n"", + ""\n"", + ""# parse SFS\n"", + ""spectra: fd.Spectra = p.parse()"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Parser: Using stratification: [neutral, selected].[A, C, G, T].\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Loading VCF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/70975cbc50c2.biallelic.polarized.subset.50000.vcf.gz\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Loading GFF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/2d03158a125f.genome.gff.gz\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Loading FASTA file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/eb1f2b2b0185.genome.subset.1000.fasta.gz\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/70975cbc50c2.biallelic.polarized.subset.50000.vcf.gz\u001B[0m\n"", + ""Parser>Counting sites: 50000it [00:01, 31807.00it/s]\n"", + ""Parser>Processing sites: 100%|██████████| 50000/50000 [01:35<00:00, 525.23it/s]\n"", + ""\u001B[32mINFO:PolyAllelicFiltration: Filtered out 0 sites.\u001B[0m\n"", + ""\u001B[32mINFO:DegeneracyStratification: Number of sites with valid type: 13771\u001B[0m\n"", + ""\u001B[32mINFO:AncestralBaseStratification: Number of sites with valid type: 13771\u001B[0m\n"", + ""\u001B[32mINFO:DegeneracyAnnotation: Annotated 19002 sites.\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Skipped 1666 sites without ancestral allele information.\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Included 13771 out of 50000 sites in total from the VCF file.\u001B[0m\n"" + ] + } + ], + ""execution_count"": 5 + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:41:09.512412Z"", + ""start_time"": ""2024-06-05T09:41:09.310448Z"" + } + }, + ""source"": [ + ""# visualize SFS\n"", + ""spectra.plot();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 6 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""Note that fastDFE requires the ancestral state of sites to be determined. The {class}`~fastdfe.parser.Parser` achieves this by examining the `AA` field, although this behavior can be customized.\n"", + ""\n"", + ""## Annotations\n"", + ""fastDFE provides a number of annotations accessible directly during the parsing process. To annotate a VCF file directly, consider using the {class}`~fastdfe.annotation.Annotator` class.\n"", + ""\n"", + ""### Degeneracy Annotation\n"", + ""{class}`~fastdfe.annotation.DegeneracyAnnotation` annotates the SFS by the degeneracy of the site. This annotation requires information from a FASTA and GFF file and is useful for stratifying the SFS by 0-fold and 4-fold degenerate sites which is what we often want to do when inferring the DFE (see {class}`~fastdfe.parser.DegeneracyStratification`).\n"" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:41:24.220951Z"", + ""start_time"": ""2024-06-05T09:41:09.513298Z"" + } + }, + ""source"": [ + ""# example for degeneracy annotation\n"", + ""ann = fd.Annotator(\n"", + "" vcf=url + \""resources/genome/betula/biallelic.subset.10000.vcf.gz?raw=true\"",\n"", + "" fasta=url + \""resources/genome/betula/genome.subset.1000.fasta.gz?raw=true\"",\n"", + "" gff=url + \""resources/genome/betula/genome.gff.gz?raw=true\"",\n"", + "" annotations=[fd.DegeneracyAnnotation()],\n"", + "" output=\""genome.deg.vcf.gz\""\n"", + "")\n"", + ""\n"", + ""ann.annotate()"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Annotator: Start annotating\u001B[0m\n"", + ""\u001B[32mINFO:Annotator: Loading GFF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/2d03158a125f.genome.gff.gz\u001B[0m\n"", + ""\u001B[32mINFO:Annotator: Loading FASTA file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/eb1f2b2b0185.genome.subset.1000.fasta.gz\u001B[0m\n"", + ""\u001B[32mINFO:Annotator: Loading VCF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Downloading file from https://github.com/Sendrowski/fastDFE/blob/dev/resources/genome/betula/biallelic.subset.10000.vcf.gz?raw=true\u001B[0m\n"", + ""Annotator>Downloading file: 100%|██████████| 14.5M/14.5M [00:07<00:00, 1.93MB/s]\n"", + ""\u001B[32mINFO:FileHandler: Cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/7a41c74709e8.biallelic.subset.10000.vcf.gz\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/7a41c74709e8.biallelic.subset.10000.vcf.gz\u001B[0m\n"", + ""Annotator>Counting sites: 10000it [00:00, 34184.99it/s]\n"", + ""Annotator>Processing sites: 100%|██████████| 10000/10000 [00:03<00:00, 2631.79it/s]\n"", + ""\u001B[32mINFO:DegeneracyAnnotation: Annotated 3566 sites.\u001B[0m\n"" + ] + } + ], + ""execution_count"": 7 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""### Ancestral Allele Annotation\n"", + ""Currently, two ancestral allele annotations are available: {class}`~fastdfe.annotation.MaximumParsimonyAncestralAnnotation` and {class}`~fastdfe.annotation.MaximumLikelihoodAncestralAnnotation`. The former is straightforward but susceptible to errors, and only appropriate if no outgroup information is available. Alternatively, if outgroups are missing, DFE inference can also be performed on folded spectra, but please note that this will yield less precise estimates. Ideally, we would like to use {class}`~fastdfe.annotation.MaximumLikelihoodAncestralAnnotation`, which is more sophisticated and requires one or several outgroup to be specified. Its underlying model is very similar to [EST-SFS](https://doi.org/10.1534/genetics.118.301120)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:42:06.554436Z"", + ""start_time"": ""2024-06-05T09:41:24.221968Z"" + } + }, + ""source"": [ + ""# example for ancestral allele annotation with outgroups\n"", + ""ann = fd.Annotator(\n"", + "" vcf=url + \""resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz?raw=true\"",\n"", + "" annotations=[fd.MaximumLikelihoodAncestralAnnotation(\n"", + "" outgroups=[\""ERR2103730\""],\n"", + "" n_ingroups=10\n"", + "" )],\n"", + "" output=\""genome.aa.vcf.gz\""\n"", + "")\n"", + ""\n"", + ""ann.annotate()"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Annotator: Start annotating\u001B[0m\n"", + ""\u001B[32mINFO:Annotator: Loading VCF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Downloading file from https://github.com/Sendrowski/fastDFE/blob/dev/resources/genome/betula/all.with_outgroups.subset.10000.vcf.gz?raw=true\u001B[0m\n"", + ""Annotator>Downloading file: 100%|██████████| 4.60M/4.60M [00:00<00:00, 17.8MB/s]\n"", + ""\u001B[32mINFO:FileHandler: Cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/a3b0e449a317.all.with_outgroups.subset.10000.vcf.gz\u001B[0m\n"", + ""\u001B[32mINFO:Annotator: Loading VCF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/a3b0e449a317.all.with_outgroups.subset.10000.vcf.gz\u001B[0m\n"", + ""\u001B[32mINFO:MaximumLikelihoodAncestralAnnotation: Subsampling 10 ingroup haplotypes probabilistically from 378 individuals in total.\u001B[0m\n"", + ""\u001B[32mINFO:MaximumLikelihoodAncestralAnnotation: Using 1 outgroup samples (ERR2103730).\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/a3b0e449a317.all.with_outgroups.subset.10000.vcf.gz\u001B[0m\n"", + ""Annotator>Counting sites: 10000it [00:00, 88694.19it/s]\n"", + ""MaximumLikelihoodAncestralAnnotation>Parsing sites: 100%|██████████| 10000/10000 [00:28<00:00, 351.43it/s]\n"", + ""\u001B[32mINFO:MaximumLikelihoodAncestralAnnotation: Included 6688 sites for the inference.\u001B[0m\n"", + ""MaximumLikelihoodAncestralAnnotation>Optimizing rates: 100%|██████████| 10/10 [00:00<00:00, 27.84it/s]\n"", + ""Annotator>Processing sites: 100%|██████████| 10000/10000 [00:11<00:00, 887.02it/s]\n"", + ""\u001B[32mINFO:MaximumLikelihoodAncestralAnnotation: Annotated 10000 sites.\u001B[0m\n"", + ""\u001B[32mINFO:MaximumLikelihoodAncestralAnnotation: There were 195 mismatches between the most likely ancestral allele and the ad-hoc ancestral allele annotation.\u001B[0m\n"" + ] + } + ], + ""execution_count"": 8 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""## Filtrations\n"", + ""fastDFE also offers a number of filtrations which can be accessed immediately while parsing. Alternatively, to filter a VCF file directly, use the {class}`~fastdfe.filtration.Filterer` class. Some useful filtrations include {class}`~fastdfe.filtration.DeviantOutgroupFiltration`, {class}`~fastdfe.filtration.CodingSequenceFiltration`, and {class}`~fastdfe.filtration.BiasedGCConversionFiltration`. For a complete list of available filtrations, refer to the API reference."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:42:08.344579Z"", + ""start_time"": ""2024-06-05T09:42:06.555812Z"" + } + }, + ""source"": [ + ""# example for filtration\n"", + ""f = fd.Filterer(\n"", + "" vcf=url + \""resources/genome/betula/biallelic.subset.10000.vcf.gz?raw=true\"",\n"", + "" filtrations=[fd.BiasedGCConversionFiltration()],\n"", + "" output=\""genome.gc.vcf.gz\""\n"", + "")\n"", + ""\n"", + ""f.filter()"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Filterer: Start filtering\u001B[0m\n"", + ""\u001B[32mINFO:Filterer: Loading VCF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/7a41c74709e8.biallelic.subset.10000.vcf.gz\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/7a41c74709e8.biallelic.subset.10000.vcf.gz\u001B[0m\n"", + ""Filterer>Counting sites: 10000it [00:00, 33500.75it/s]\n"", + ""Filterer>Processing sites: 100%|██████████| 10000/10000 [00:01<00:00, 6810.30it/s]\n"", + ""\u001B[32mINFO:BiasedGCConversionFiltration: Filtered out 7903 sites.\u001B[0m\n"", + ""\u001B[32mINFO:Filterer: Filtered out 7903 of 10000 sites in total.\u001B[0m\n"" + ] + } + ], + ""execution_count"": 9 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""Note that all components can easily be customized by extending the corresponding base class."" + ] + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3 (ipykernel)"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 3 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython3"", + ""version"": ""3.10.14"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 4 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/example_sapiens.ipynb",".ipynb","4488","101","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""source"": [ + ""# Inference on H. sapiens"" + ], + ""metadata"": { + ""collapsed"": false + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 1, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:fastdfe: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/b9755b5299a6.ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/b9755b5299a6.ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz\u001B[0m\n"", + ""Counting sites: 976599it [00:18, 54065.13it/s]\n"", + ""\u001B[32mINFO:fastdfe.Parser: Using stratification: [neutral, selected].\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/641b1ad7806e.Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.DegeneracyAnnotation: Loading GFF file.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.DegeneracyAnnotation: Loading FASTA file\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/f36fd1bf6304.Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/641b1ad7806e.Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.CodingSequenceFiltration: Loading GFF file.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Parser: Starting to parse.\u001B[0m\n"", + ""Processing sites: 2%|▏ | 16046/976599 [00:01<01:12, 13333.56it/s]/Users/au732936/PycharmProjects/fastDFE/fastdfe/bio_handlers.py:490: SettingWithCopyWarning: \n"", + ""A value is trying to be set on a copy of a slice from a DataFrame.\n"", + ""Try using .loc[row_indexer,col_indexer] = value instead\n"", + ""\n"", + ""See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n"", + "" cds.loc[:, 'length'] = cds['end'] - cds['start'] + 1\n"", + ""Processing sites: 100%|██████████| 976599/976599 [03:23<00:00, 4810.71it/s] \n"", + ""\u001B[32mINFO:fastdfe.CodingSequenceFiltration: Filtered out 965325 sites.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.DegeneracyStratification: Number of sites with valid type: 8794 / 11274\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.DegeneracyAnnotation: Annotated 11274 sites.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.MaximumParsimonyAncestralAnnotation: Annotated 11274 sites.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Parser: Included 8794 out of 976599 sites in total.\u001B[0m\n"" + ] + } + ], + ""source"": [ + ""import fastdfe as fd\n"", + ""\n"", + ""parser = fd.Parser(\n"", + "" vcf=\""http://ftp.1000genomes.ebi.ac.uk/vol1/ftp/data_collections/1000_genomes_project/release/\""\n"", + "" \""20181203_biallelic_SNV/ALL.chr21.shapeit2_integrated_v1a.GRCh38.20181129.phased.vcf.gz\"",\n"", + "" fasta=\""http://ftp.ensembl.org/pub/release-109/fasta/homo_sapiens/\""\n"", + "" \""dna/Homo_sapiens.GRCh38.dna.chromosome.21.fa.gz\"",\n"", + "" gff=\""http://ftp.ensembl.org/pub/release-109/gff3/homo_sapiens/\""\n"", + "" \""Homo_sapiens.GRCh38.109.chromosome.21.gff3.gz\"",\n"", + "" aliases=dict(chr21=['21']),\n"", + "" n=10,\n"", + "" annotations=[\n"", + "" fd.DegeneracyAnnotation(),\n"", + "" fd.MaximumParsimonyAncestralAnnotation()\n"", + "" ],\n"", + "" filtrations=[\n"", + "" fd.CodingSequenceFiltration()\n"", + "" ],\n"", + "" stratifications=[fd.DegeneracyStratification()],\n"", + "")\n"", + ""\n"", + ""spectra: fd.Spectra = parser.parse()"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-06-30T08:08:09.738291Z"", + ""start_time"": ""2023-06-30T08:04:19.241902Z"" + } + } + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 2 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython2"", + ""version"": ""2.7.6"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 0 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/inference.ipynb",".ipynb","363440","1653","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""# DFE inference\n"", + ""## Estimating the deleterious DFE\n"", + ""A short overview of basic DFE inference and bootstrapping is available in the {doc}`quickstart guide <../Python/quickstart>`. DFE inference requires one `neutral` and one `selected` SFS. In this example we use the bundled `Betula pendula` (silver birch) data. By default, bootstrapping is performed automatically, and the inference estimates only the deleterious component of the DFE using {class}`~fastdfe.parametrization.GammaExpParametrization`."" + ] + }, + { + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:29:54.386673Z"", + ""start_time"": ""2026-01-04T10:29:52.766471Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""import matplotlib.pyplot as plt\n"", + ""import numpy as np\n"", + ""\n"", + ""plt.rcParams['figure.figsize'] = [4.8, 3.3]\n"", + ""plt.rcParams['xtick.labelsize'] = 9\n"", + ""plt.rcParams['ytick.labelsize'] = 9\n"", + ""\n"", + ""np.set_printoptions(legacy='1.21')\n"", + ""\n"", + ""import fastdfe as fd\n"", + ""fd.Settings.parallelize = False"" + ], + ""outputs"": [], + ""execution_count"": 1 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:30:04.532407Z"", + ""start_time"": ""2026-01-04T10:29:54.391397Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""import fastdfe as fd\n"", + ""\n"", + ""sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0])\n"", + ""sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0])\n"", + ""\n"", + ""inf = fd.BaseInference(\n"", + "" sfs_neut=sfs_neut,\n"", + "" sfs_sel=sfs_sel\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""inf.run()\n"", + ""\n"", + ""inf.plot_discretized();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:01<00:00, 8.41it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 21.32it/s]\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -3.389e+04 ± 4.2, all.b: 0.1305 ± 1.7e-06, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -35.44 ± 3.2e-09} (best_run ± std_across_runs)\u001B[0m\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:06<00:00, 15.49it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -5.482e+04 ± 3.9e+04, all.b: 0.1331 ± 0.022, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -42.9 ± 5.9, i_best_run: 0.5 ± 0.5, likelihoods_std: 0.007777 ± 0.046} (mean ± std)\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 2 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""It is always good practice to check the variability of estimates across optimization runs to ensure stability. Here, both the standard deviations across initial runs and across runs within each bootstrap sample are low, indicating stable estimates. Individual runs and bootstrap results can be inspected in the corresponding dataframes (cf. {attr}`~fastdfe.base_inference.BaseInference.runs` and {attr}`~fastdfe.base_inference.BaseInference.bootstraps`)."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:30:04.585748Z"", + ""start_time"": ""2026-01-04T10:30:04.574875Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf.runs.select_dtypes('number')"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + "" all.S_d all.b all.p_b all.S_b all.eps all.h likelihood\n"", + ""0 -33890.424207 0.130546 0.0 1.0 0.0 0.5 -35.437968\n"", + ""1 -33898.475526 0.130543 0.0 1.0 0.0 0.5 -35.437968\n"", + ""2 -33894.520478 0.130544 0.0 1.0 0.0 0.5 -35.437968\n"", + ""3 -33896.257305 0.130544 0.0 1.0 0.0 0.5 -35.437968\n"", + ""4 -33893.352524 0.130545 0.0 1.0 0.0 0.5 -35.437968\n"", + ""5 -33898.090546 0.130543 0.0 1.0 0.0 0.5 -35.437968\n"", + ""6 -33894.032960 0.130544 0.0 1.0 0.0 0.5 -35.437968\n"", + ""7 -33887.045393 0.130547 0.0 1.0 0.0 0.5 -35.437968\n"", + ""8 -33899.733825 0.130542 0.0 1.0 0.0 0.5 -35.437968\n"", + ""9 -33889.470185 0.130546 0.0 1.0 0.0 0.5 -35.437968"" + ], + ""text/html"": [ + ""
\n"", + ""\n"", + ""\n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + ""
all.S_dall.ball.p_ball.S_ball.epsall.hlikelihood
0-33890.4242070.1305460.01.00.00.5-35.437968
1-33898.4755260.1305430.01.00.00.5-35.437968
2-33894.5204780.1305440.01.00.00.5-35.437968
3-33896.2573050.1305440.01.00.00.5-35.437968
4-33893.3525240.1305450.01.00.00.5-35.437968
5-33898.0905460.1305430.01.00.00.5-35.437968
6-33894.0329600.1305440.01.00.00.5-35.437968
7-33887.0453930.1305470.01.00.00.5-35.437968
8-33899.7338250.1305420.01.00.00.5-35.437968
9-33889.4701850.1305460.01.00.00.5-35.437968
\n"", + ""
"" + ] + }, + ""execution_count"": 3, + ""metadata"": {}, + ""output_type"": ""execute_result"" + } + ], + ""execution_count"": 3 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:30:04.642611Z"", + ""start_time"": ""2026-01-04T10:30:04.633046Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf.bootstraps.select_dtypes('number')"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + "" S_d b p_b S_b eps h likelihood i_best_run \\\n"", + ""0 -100000.000000 0.115271 0.0 1.0 0.0 0.5 -48.666719 1 \n"", + ""1 -23100.047602 0.132767 0.0 1.0 0.0 0.5 -39.454392 0 \n"", + ""2 -30896.328327 0.126525 0.0 1.0 0.0 0.5 -44.116520 1 \n"", + ""3 -100000.000000 0.117041 0.0 1.0 0.0 0.5 -40.332661 1 \n"", + ""4 -27268.784916 0.134769 0.0 1.0 0.0 0.5 -38.642477 0 \n"", + "".. ... ... ... ... ... ... ... ... \n"", + ""95 -59604.675726 0.121741 0.0 1.0 0.0 0.5 -38.589821 1 \n"", + ""96 -3523.479918 0.172044 0.0 1.0 0.0 0.5 -33.468514 1 \n"", + ""97 -100000.000000 0.114860 0.0 1.0 0.0 0.5 -44.168668 1 \n"", + ""98 -5645.681207 0.160873 0.0 1.0 0.0 0.5 -34.451027 1 \n"", + ""99 -12974.655531 0.146723 0.0 1.0 0.0 0.5 -36.749411 1 \n"", + ""\n"", + "" likelihoods_std alpha \n"", + ""0 2.112557e-09 0.0 \n"", + ""1 6.220944e-10 0.0 \n"", + ""2 5.387903e-10 0.0 \n"", + ""3 3.066069e-02 0.0 \n"", + ""4 5.865388e-10 0.0 \n"", + "".. ... ... \n"", + ""95 5.672405e-10 0.0 \n"", + ""96 2.810907e-10 0.0 \n"", + ""97 3.818051e-01 0.0 \n"", + ""98 3.464038e-10 0.0 \n"", + ""99 1.489667e-09 0.0 \n"", + ""\n"", + ""[100 rows x 10 columns]"" + ], + ""text/html"": [ + ""
\n"", + ""\n"", + ""\n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + "" \n"", + ""
S_dbp_bS_bepshlikelihoodi_best_runlikelihoods_stdalpha
0-100000.0000000.1152710.01.00.00.5-48.66671912.112557e-090.0
1-23100.0476020.1327670.01.00.00.5-39.45439206.220944e-100.0
2-30896.3283270.1265250.01.00.00.5-44.11652015.387903e-100.0
3-100000.0000000.1170410.01.00.00.5-40.33266113.066069e-020.0
4-27268.7849160.1347690.01.00.00.5-38.64247705.865388e-100.0
.................................
95-59604.6757260.1217410.01.00.00.5-38.58982115.672405e-100.0
96-3523.4799180.1720440.01.00.00.5-33.46851412.810907e-100.0
97-100000.0000000.1148600.01.00.00.5-44.16866813.818051e-010.0
98-5645.6812070.1608730.01.00.00.5-34.45102713.464038e-100.0
99-12974.6555310.1467230.01.00.00.5-36.74941111.489667e-090.0
\n"", + ""

100 rows × 10 columns

\n"", + ""
"" + ] + }, + ""execution_count"": 4, + ""metadata"": {}, + ""output_type"": ""execute_result"" + } + ], + ""execution_count"": 4 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We can also plot the parameter distributions across bootstrap samples to visualize uncertainty. We see that the mean strength of deleterious selection `S_d` often reaches the lower bounds of `-1e5`. Perhaps a different DFE parameterization or a more complex DFE model would be more appropriate here. It should also be noted that the spectra used in this example are far from exemplary, as they contain few SNPs and have a small sample size."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:30:04.889437Z"", + ""start_time"": ""2026-01-04T10:30:04.757832Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf.bootstraps[['S_d', 'b']].hist(figsize=(6, 2));"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 5 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We can also inspect how parameters covary."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:30:05.169196Z"", + ""start_time"": ""2026-01-04T10:30:04.931707Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf.bootstraps.assign(S_d=inf.bootstraps.S_d.abs()).plot.hexbin('S_d', 'b', xscale='log', gridsize=15);"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAbsAAAFFCAYAAAB18UN3AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAARTJJREFUeJztnQm8FNWV/09Vr29/D0EWHyIwirggKJlAGAP5ixAmH5WACAIaEVBkMRL5OLJFURaJEZLIECYKMSTGhcmIy2AmQqKyqMgoasAQh6hADKAsb6XXqv/n3O5q+r3X3a+23n9fP+Vrum+drq6uvr865957jqSqqkoAAABAASNn+wAAAACAdAOxAwAAUPBA7AAAABQ8EDsAAAAFD8QOAABAwQOxAwAAUPBA7AAAABQ8EDsAAAAFD8QOAABAwQOxAwAAUPBA7AAAANiO3++n6dOnU8+ePamiooIuvvhi2rBhQ+z1+vp6mjhxIlVWVlLnzp3p4YcfTmnPaPvWOE1/EgAAACAJoVCIunbtSlu3bqVevXrRO++8Q6NGjaLa2loaMWIEzZkzh06ePEmHDh2i48eP0/Dhw6lHjx506623JrRntH1rJCSCBgAAkAnGjBlDl112Gd1///1UU1NDO3fupIEDB4rXHn30UXrllVfojTfeaLNfc3OzofaJgGcXRVEU+uKLL4S7LUmSfd8uAADYBBepaWhooG7dupEsWxuF8vl8FAgEDL9/6/7R4/GITc/77d69W4QiDxw4IN67f//+sdf58fLlyxPua7R9IiB2UVjounfvrvvEAQBAtjh8+LAIB5rF5/NRSVUZUUAxtF95eTk1Nja2eO6BBx6gBx98sF2RnDZtGl144YXCu2MPraysjJzOsxJUXV0thDwR/J5G2icCYheFPTrtIuIB0PbgL8+vqNQcCpNLlqnMKZNswiNkO3y5hRSVZInIKUmmPMt02OG9XXJ27TBhVY3ZccqSqfPMKKpKQZvs8PEwsJP+86NGrx877PDxOEzaUaPXj2aH/Sqzvw2zdniSBt+Ua/2VWQLs0bHQXd2FD0LfTiGFGrcfbdNHtufV8eedOXOm8M54/I49UhZNDk3yuJ4mYHV1dUk/l9H2iYDYRdEuNv4SU4kdf3EBRaXGUJj4ai2NPh8kolKnTKUOWfeFq3XiravnslA5JP0/AK0Tb23HYVD0CtkOn2cWX2/c87JBEY63Q2myY0Qc7LKjdb6FaCekqhRudQFpN19m7HhywI7Yx66hFresX+yizdrrI1t/5lmzZonJKdu2baOqqirxfJ8+fcjlctEHH3xAV111lXhu7969dPnllye0Y7R9isMHeggqCp0KhKguGG7zA+J/NoUU+sofEt5eqgLw3En5w0rCjpwJRb1GIYQ67LD4JmrFx6jXTiAP7fD3oddOomANP6fHjppBOwGddrhNe3b4vfTY8eehHUWnnda/U/G6ATt8reaKnbQgScY2g8yePVuELF977TUxwUSjtLSUxo8fT4sXLxYe2ieffEKPP/64CHUmwmj7REDsdMAX6ulAiE4FwhRq51rklxtDCp0IhMjX6sfdXieeTPTCrcTBrJ3WItNe55vrdpKJZ3tiYNSOPwftJOo09Ypwe51vPtgJ2GintQjH2+FrNRt2Mip6ks7NIJ9//jmtXbtWhC95iQCHInmbMWOGeH3NmjXC0+OxxyFDhtDUqVNbLCPgZQrxE1Daa9/ux8TSg7OxcD6RfNeguegcZmwKhskXHX8wA4fcypwOcVdhbCi41RcVtcWHYocd/i2Fc8COFkvnM5wrdhz8PykiOoVmh2/OQwVmh39bcg7a4e/LiqlE4fpE/ZQZ6qN26NpajqHq2ymoEL12xPJ7ZwuM2SWB78pO+kOWLlaGL3hxl2Yxxs7HYfVHmIt2mBDllh0hljZ8NtjJzPnhmz+lAO1ofYeHVS9dyAbie3keB4TYpcCuQILZWWQAgOIm7cFMycBYXJ73YxA7AAAoViQD43H5rXUQOwAAKFpkKbLpbZvHwLMDAIBiRYJnBwAAoNCRMGYHAACg0JHg2QEAACh0ZIzZAQAAKHQkeHYAAAAKHQljdiCarsdKiiaXJKU3+wEAoKBJe+8hI4xZ9HA+ug5uJzWHFVHNwAhOicjjkEXdrFRZ3gEAIHk/Ein1lVYkhDFBtGYUJ3EucchC8M6EU4seX5geWRY1tzSRs63uFACgKDBaz9K62En62+YxWFSuM7dlhcshirMmqoLA+VHZk+MCjBA5AIAZjBYltg2JigKInQE4LFnpdlJptFI5157yyBK549LowJMDABjBaAV2W5ExZgdSwBdmtdsZKbKIMwUAMAnfKGe1KgrG7IAeOGzJVYgBACAvy39JWHoAAACg0JFRvBUAAEChI8GzAwAAUOhIWGcHAACg0JHg2QEAACh05OIZs8vzwwcAAGDZs5N0bgZYs2YNDRw4kDweD40ePTr2/KFDh6i8vLzF5nQ66frrr09qa9iwYcJO/D5ffPGFoeOB2AEAQLGP2Uk6NwN069aNFi1aRNOnT2/x/Pnnn0+NjY2x7eTJk1RdXU0TJkxIaW/lypUt9mP7RkAGFZNwWrAQ1tgBACzAfUjG8mBmOIPKmDFjxN+9e/fSkSNHkrbbvHkzKYoSa58u4NmZFDleTB5Oz3cCACgSQmq0L1HU7FRIkYyHMevr61tsfr/f0iGsX7+eJk2aRF6vN2W7pUuXUocOHWjAgAG0ceNGw+8DsdMJX4h8QfKFyRcoAADYRVBVRa7dsJph0ZOMhzG7d+9OVVVVsW3FihWm3/7zzz+nrVu30rRp01K24/c4ePAgHTt2jB555BGaM2cOvfDCC4beC2HMduALj/NfsjcHiQMApAvuX4KKKjTFJWcqlZikO4QaOTKiw4cPU2VlZex5njhill/+8pfCU7viiitSths8eHDs8ciRI+nOO++k5557jr773e/qfi+IXQoUVRUXH0QOAJApuL9hL08mNe3VECQjJYW4GDWRELp4sTMLj9Ox2M2fP9/wvrIs51cYMxgM0uzZs6mmpkbEYtk1DYVCbdpxTJhn9PTs2ZMqKiro4osvpg0bNrRow7HjiRMnii+hc+fO9PDDD1v26PiCg9ABALIBR5S4D8rTlQfEfbnP5xN/Wdj4cSAQiL3+2muv0VdffUU333xzSjunT5+mLVu2UHNzM4XDYdq2bRutW7eOxo4dmz9ixwOOO3bsoP3799O+ffto+/bttHz58jbt+GR17dpVxHZZ1J566im699576Q9/+EOsDQslT2HlNRxs54knnjA1iAkAAMWCLEmGNqP9e0lJCS1btoxefvll8XjEiBEtJqbceOONYtyvNaNGjYppATtFS5YsoS5dugjHaO7cubRq1SoaN26coeOR1KxMATo70Ll69WrxgZlNmzbRvHnzxKBle/A01csuu4weeughofh8Enbu3CkWMTKPPvoovfLKK/TGG2/oOhYWUT7pdXV1wjvk04LyPQCAbON1yEn7KbPUR+24Zl1Oksehax/VH6bgv39k+b2zRdY8u1OnTom1F/379489x4/ZM+OTmQp2h3fv3k39+vUT/z5w4IBwj1vb+vDDD5Pa4NBo6ym0AABQTEjRMTu9Wz6TNbHjFfAMr5zX0B43NDQk3Y89Lp6meuGFF8YWIbKtsrIykXIm3lYqOzyVNX76LHuZAABQTEgQu/TDuc2YeC9Oe8yTUJIJ3cyZM4Unx6vutRk5bItDmfGTW9hWMjsMzwDiNtrG02kBAKCYkNI4QSXXyJpnx2NstbW1IpWMBj/WFiwmErpZs2bRO++8IyamxLfp06cPuVwu+uCDD1rYuvzyy5O+P68N0abQ2jWVFgAA8gkJnl1mmDJlipipc/ToUbHx7JtkK+l5iQJPQOHpqiyU8ZSWltL48eNp8eLFwkv75JNP6PHHH293VT4AABQzEsQuM7A48cr4vn37im3IkCG0YMEC8dqMGTPExvDszLVr14rwZY8ePWIlHrTXtXIS7O2xt8h2pk6dSrfeemuGPgkAAOQfksH/8pmsLj3IJXJ96YHIzalqScrz+6IDAOTG0oPyuVcZWnrQuPp/83bpAdKFpYAlRc0RkeMEsQw/ljKQRggAUPiTKiQjE0/yvLuB2KWIZbtlzo8ZyUielQTUaqQESLKEsZw7zwHRA6DgYF0RN7Rpfh/ZQC09FWJXuPBFwIUVZeFZJRaeTIpcotx5SlzC2Hxf9AkAIHKJ1FyZKegqGUwEnc/As9MBXwxOiciRRtFjkVNNlhLSEsY6JN4gegDkI87ozXUmb1oliB1oT/RY8Fj47IJFjkXLCpHxPBI/GABAfsC/Vxa6rERmJP0OG8KYRQhflBxqcCgKBWwSPKtCp8HhDwBAfuDJ8vCDZEBk832YBGFMC4gvHys3AABW+pAsIkuy/kKoUlYrwlkGYgcAAEWKBM8OAABAoSMZGLPL8ygmPDsAAChWJHh2AAAACh0JYgcAAKDQkcUC9uKIY2KCCgAAFCkSxuwAAAAUOghjAl3pvThFV64eW7bX7wAA2ieoKNnLnkJn69npbZvP5PcqwSwJCV+gXOvOTqlzcSYFG+wE444LpQoByG04xR/3JSInbhYSVEhprFTOBbUHDhxIHo+HRo8e3eK1YcOGiee1Qty8ffHFFynr702cOFHU0evcuTM9/PDDhj8rxuwM1pVLV+UDHiR2cUkh/gFYEFKt/I9W807U5IOnB0BOw/1KSOUcmZFcmZny9KQ0zsbs1q0bLVq0iLZu3UpHjhxp8/rKlSvpnnvu0WVrzpw5dPLkSTp06BAdP36chg8fTj169KBbb71V9/FA7LIscm1KCrHwRevoWXnPWM07SRVhEu2uEeFNAHJf9FxcWiwDoieZmKDCXlY87KHx1poxY8aIv3v37k0odnppbm6mZ599lnbu3EnV1dViY/Fbv369IbFDGDMF4ei4XCaEro3oyVw8lkt+WLvYWTTjPwNCmwDkPlwwmn+3Spr7HslEGLN79+5UVVUV21asWGHqvZcuXUodOnSgAQMG0MaNG5O2O3DgAAUCAerfv3/sOX784YcfGno/eHYpx+bUnKqjx+JrSfRUrndHwnuEhwdAbsO/dhY8bxprdkmSLDa9bZnDhw+LsTONRF5de7BAXnLJJVRaWkp//OMf6aabbqKKigr67ne/26ZtY2MjlZWVkdN5Vq7Yu2toaDD0nvDs8gAhejbV7rGzBh8AIM+RDHh1Uc+OhS5+MyN2gwcPFl6hy+WikSNH0p133knPPfdcwrY8eYVDmaFQKPZcXV2dEEcjQOwAAKBIkXgSmyzr3NLnYaYqM9SnTx8hih988EHsOR4HvPzyy429h6UjBAAAkLdI0TCm3s0I7In5fD7xV1EU8ZjH3k6fPk1btmwR3lo4HKZt27bRunXraOzYsQntcKhz/PjxtHjxYuHRffLJJ/T444/TtGnTDB0PxA4AAIoUKY3r7HgCSklJCS1btoxefvll8XjEiBEUDAZpyZIl1KVLF6qpqaG5c+fSqlWraNy4cbF9R40aRcuXL2+xZo/DnrW1tTRkyBCaOnWqoZmY4rOqmJ4Xm07LJ5PvHDgOzaeFF3vmEv4wr8KzDs/yxAQVAPIDr0NO2k+ZpT5q56KV/0qOEpeufcJngvTXf9ti+b2zBWZjAgBAkSKhxA8AAIBCRzKx9CBfgWcHAABFigTPDuQinPZLIc6qYN4Gj0X6wry4nHNxYuwOgGJGgmcHGHba7ZkSYg+8zMUhySKFECeLVgyKHOfcU+LSEfmj2RmyWWIEAJAcznaUTiR4doAvArdDEsISXzYnm2iCxP93OSKiJ0qD6EhkHU70GhGdCaskE4uebFuWFgCA9Rtt/j1yNZR0IsGzA7GLjkUvWnqnPWHJhui5k4ieEDmd6cH4szWHFXIoRF5ZFkmoAQCZR9zIZkDkYvBvXe/vPc/7BUxQMVF6h0OAlIOix6FNLiwrhNnEIbIwNoUVcipEHodsueICAEAfkubJZThJuwTPDiS+MLjkDpEcrUKQ6dI/ydB+HHzjlSxkaQRRT0uNFJEEAKQXHjPPZMHWeCL5nfUWb6W8Bp6dhdI7sqJSIDf0LnZcVoVOA0IHQPrxZHlGtATPDui7UCQeHMPJAgCYFJvsuksSxA4AAEChIxXR0oOs5n/h7NezZ88Wma+5PPucOXNaFOiLh7NeDxw4UBQKHD16dJvX9+/fT9dcc42wxdm077jjDlFCAgAAQOZL/OQaWT16LgGxY8cOIVT79u2j7du3tyjrEE+3bt1o0aJFNH369ISvT5w4URT5O3bsGH300Uei0N/DDz+c5k8AAAD5i5TGEj+5RlbFbsOGDULAunbtKraFCxfS+vXrE7YdM2aM8Og6duyY8PW//e1vNHnyZHK73dSpUye6/vrrheglw+/3izIX8RsAABQVkgGvDp6dOU6dOkVHjhyh/v37x57jx4cOHRL1kowyb9482rhxI505c4aOHj1KL7zwAl133XVJ269YsULUc9K27t27m/wkAACQn0jw7NJPY2Oj+FtdXR17Tnvc0NBg2B5XtuWQaEVFhfASWbxuv/32pO3nz58vRFXbDh8+bOpzAABAviKx1ybr3ODZmaO8vFz8jffitMcsWEa9xOHDh4vxPJ6UcvLkSSorKxNhzWTwRBeuthu/AQBAMSHBs0s/PGuytraW9u7dG3uOH7NHxmFFIxw8eFCEL++++24xZse277zzTvrv//5vShdKtGpArmHXELIaza9pyUZ0f6t2AChUAmFF9CXZQsJszMwwZcoUWrZsmRhj441nYk6bNi1hW16S4PP5xF9FUcTjQCAgXrv44ouFp7h27VrxOodBn3jiCRowYIDtx8wXJl+ggRwUOqbMKYvsLlbhzxhWVSFURsUqfh+Rq1Nt+RwAIALnseW+hH9v2fh9SPDsMsPixYtp8ODB1LdvX7ENGTKEFixYIF6bMWOG2OKXKZSUlAhxfPnll8XjESNGiNdY6Pi5Z555RszWvOCCC+j06dP0q1/9yrZjVeNELpdq3LWGs6WXOh2mRY/ThLlFInRJ5Nnk8kaaruv5MWptWCjFuYrmEA0YtANAMcF9CkeK+OYwk78PSYid3hmZ+b30QFLR8wh46QGHT3ncMH78LlL0NFITLh/h0j9+9tLaacdVHVIlo41lZZckcU5atzsrchGhSwbvxSWEHEnsAACSJ4dO1k8ZpT5q5xtP3UXOUo+ufULNftp12891vzcnAnnqqafEEjCeQLh582bx/PHjx2nu3Ln0xhtviOPo3bs3LVmyRCwXSwY7MLyG2uGIlLN1Op3CoTFCfi+Jz4RQKPkrdBQVqFKnTCUOOeGXzZcOe3LcLpXw8CkIauEW7bm4MCd7bey9pRI6zU4ogR0AwFn4Blv0PWkeLpHSOGaXLBEIz8TnIaa3335bCNZDDz1EN998s0gukgqO3PG+vBkVOgZVD5KgeXSFAIuYiwVNksVn8oXViKdmoqyIJnpc3Zw9ND5FYmzP4DHF2xEV0tkQvDwAWsC1Mx22TTtLgJHF4gbFjhOBaBMPeU21Rq9evcS6aA1eD83Zr1j8LrnkEkoX8OyKCCF6skxumf9aS/+jRMWKxdPKLUFs/BNCB0BeTFCpb5V5irNRWYHDmh9//DH169cvZTueYc9zMniex5YtWwy/D8QOAACKFDNhTG15mLZxNiqz8Iz6CRMm0E033SQS/Sfj17/+NX366af097//XRQMGDt2LL377ruG3gthTAAAKFJkKTLpTG9bhrNNxU9Q4QQdZoXuxhtvpNLSUrFULBVXX311i6T/PNnld7/7HX3ta1/T/X4QOwAAKFKk6H962zJ2ZJxioRs3bpz4++KLL4pkIEaQZeNBSYgdAAAUKVIaK5Vzgg9t0xKBsEjx2B+HLZuamuiVV15p1zPk4gCfffYZff3rXxf7c5J/Fsg//elPho4HY3YAAFCkSGnMoJIsEciuXbuEWO3cuVNMOOGkILzF1zK99NJL6emnnxaPeakBp4I855xzRPm2H//4x/T888/ToEGDjH1WLCpPvFhTzdHcl3bAi8xzCZ4disXlACTG65DTtqj8mmf+zdCi8m03r7T83tkCYUwAAChSJAMeW77fkELsihBn3GJws2hpv6zaIW1xuaSKFGJmf1B8DOyx8t4ezhaT5z9MADKBJGZj6h2zy+/fFMQuxRfrkPI7VVgyxKUtcS5MTvZs7DO2zm1p1k48alxOTYdB0eMqFL6wQqG49w6GFBEa9SA8CgogR2auzcbMVyB2KeBsIw5OG5bjlQ6MEi8kWgJozoTS3hAl//A4s5dVO6k4K3qpE1Nr9QTZK0yEKJuiqELwMCYI8g2+9vn3lm5vSkrjbMxcA2LXDhwOczsk0bkWmugxUtRDY2HnzxhO8BnZ0+Ifn9Y+lR1xJ2qL6EU8Rc7fyQKrva82cUhvPUGtrcfB+UExEQbkNnJcdZFMIGHMDqQSPfYmCim6qQkJ/9/lkGPCziLDQhffRo+dePFM5nnphUVTUvn8R8TPzAxZ3oOTX/tJFTPbzCTABiCdiN9eBkVOA2FMkFr05LOJkKlARc/tkE3Xm4u3w5vVs8T7nwlbv8FQY/+H0IHcQKsTqd1UZvz9JYQxQcoLRBJjVJKkUqCw9K6lWFn8AYrQZo75wDLfy8KrAzlCtseTZZLEprdtPoMxOwuIi7RAat4BADJPtm+8JDIwQSXPE25B7AAAoEiRMEEFAABAoSNFA5l62+Yz8OwAAKBIkeDZAQAAKHQkzMYEAABQ6EgG0oDl91xMhDEBAKCo1w3LOmeE5ntydYzZWUAkQgYAAAt9SDaXH0iYoALau0BFBhVonY4fk/UMKvZ+byrJ0QMy28nEd1DZ7qxAfsN5W53y2bR8mUbCBBWQKkEx543MlQ481+F8f1olA0t2JKJwtCqCUTRB4mM45msmr+ygGo9HiJ4RodLs8CGEuNp7NDM9BA+YRY2mHQyRmpXcmGRgggq3zWcQxtRJISaAzgQsDpx42REVPLM174QdUUooYoOFT2+Ymb25M0E/+ZWQ+HdQCVNjKECVLg9Vuz2RQfp2OhnNVlBRzlZzUIkCWjmiuOMEwChq1MuTSc1s1QNCPTsQpVBL+2RH9CTL9QHPimdq0WNxiiSQDpAvHGz7OhHVBf3UEAwIwat0uWP2W9thUgn12Rp8nDM10giiB8ygxIkee3qoZ2cf8OxSEAwrujwIoB/+8bockdCfXaLHVcqVVhOGzoSD5AsH2vXE2es7GfAJ4atxe6nc6WrxupEQ7NkafDzsD9ED5uHrmctZ8TXOnl66kDEbE3DHCaFLv+hZrXkn7EgRD7wpHKawqgihMxpwZqH6yn+G6gJ+6uwtI3bwzIZctRp8fGeO8TxgBb6WnGlc4SYV0WzM/D56kPfYNTbBdjhk2Sy8OfPiGVQV8iksmtaOR9Uq52EMD+QwUnQ2pt7NCGvWrKGBAweSx+Oh0aNHt3itvr6eJk6cSJWVldS5c2d6+OGHU9oy2j4tYUwtdIQfNQAA5BdSGieodOvWjRYtWkRbt26lI0eOtHhtzpw5dPLkSTp06BAdP36chg8fTj169KBbb701oS2j7W317NavX0+XXXYZeb1esfHjJ5980qw5AAAAWcqNKencjDBmzBjh0XXs2LHF883NzfTss8/S0qVLqbq6mi666CIhZqwpiTDa3lax++EPf0jf//736brrrqNNmzaJjR/PnTtXvAYAAKAww5j19fUtNr/fb+g9Dxw4QIFAgPr37x97jh9/+OGHtrS3NYz585//nJ544gm6+eabY89df/311K9fP6G4Dz30kBmzAAAAMogspp3Iutsy3bt3b/H8Aw88QA8++KDu92xsbKSysjJyOs/KD3tsDQ0NtrRPfvwmCAaDYuCxNVdddRWFQiHDtmbPnk01NTXUoUMHIZbJbKQa8NTgUGqfPn3EybngggvoxRdfNHQ8AABQLEgmPLvDhw9TXV1dbJs/f76h9ywvLxehyfh+nu1UVFTY0t5WsbvllluEd9eaX/ziFzRp0iRDtjgOu2PHDtq/fz/t27ePtm/fTsuXL0854Dl9+vSEr/P7P/bYYyK+y3cD77zzDl1++eWGjgcAAIoFObrOTu/G8IzI+I2dDyOwM+JyueiDDz6IPbd3796kfbXR9pbDmD/4wQ9ij1nh2YP6wx/+QIMGDRLPsbDwTBkjs2OYDRs20OrVq6lr167i3wsXLqR58+YlHPvjAU/tg7ae3RMOh8U+GzdupAEDBojneIoqAACAVGFMnSV+DM7GZE9M2xRFIZ/PR7IsU2lpKY0fP54WL15MzzzzjJhd+fjjjyddTmC0ffLj18n7778f2z766CMRsuzUqRMdPHhQbDzj5sorrxTemV5OnTolRKv1wCOLJrupRuBBzGPHjtF7770nwpe1tbXCA+QB1ETwoGrrgVaQHXjxNWeJsLLiji/kzt5Ssbll88tHSxxOKnU4RBYUyXJRTJSBAsW7zm7p0qVUUlJCy5Yto5dfflk8HjFiRGxIqqqqSvTTQ4YMoalTp7ZwlEaNGtUiwtdee1s9uz/96U9kNxxq1AYbNbTHPPjIH04vvAaD4TUde/bsEY8nTJggZogmmqK6YsUKWrJkSbvpqDiDAUgvmjDIMmdUMXbOeT8tcS6v+XQR3zlWUGMwQKcCfgqp+hKSeWQHdfB4yetwxtaOOmSZwgqnANO/TL318WD9KbB6I5hOJAPpwoxeyzxpJdnEFQ5/speWjFdffdVQ+5zPoMIDj0y8F6c9Njr4qNniwVL2Mnnjx3xHkQh+LX6QlQddW8OdlkeWRFZ7kD7i7xz5t+0W51zSJSpux9ngSvzdZ5nTRbWl5XSO25vyx+ySZTrXW0rdSsuF4LW2w8cjPE+TxwOAGfh6i/Q9aRY7kg1t+UxWE0HzDEx2S3kMrnfv3uI5fsxTW414ddogJi9u1wsPquoZWI3kXpTIKRIOmy9RA/ShCQRXD+AfeqJqAyLRclwfkEhUtOcqXG4qd7lFomfOe6nG2ahulfg5lR1O7OwWx9M2MbSe4wFAD3xjLULoGbqGZCSCzhxTpkwRMV2OwzIcp502bZqhAU+32y3iwZMnT6aVK1eKsUO+WPjxDTfcYMtxaqJntUQN0H++GUe0A+AbDXFvGe0D9HYGwkvj8LgrUsaHBc8hyUlL+hgRYb4v1rx+CBywAvtMmSjp0xqIXQbhGTYnTpygvn37in+zYC1YsEA8njFjhvi7bt262IBn/DgbC9zQoUPp9ddfF//+yU9+QrNmzaKePXsKr40Xuq9atcr2i8MdzdbPdadAehGVwTnze7QTMNsZiBCpSqKMj1U7DIq1ArtELpPFWlsjMmPqveFLY/WFTCCp8UXAihiejcmhUx6/48FQPfCp45pTAABgBq9DTns/lcrOPdt+S57yUl37+Bub6SfXTLT83tkCxVsBAKBIkQyMD+Z7qB5iBwAARYosyWLT2zafgdgBAECRIqcxg0quAbEDAIAiRUIYEwAAQKEjY50dAACAYkDK8/CkXhDGBACAIkWGZwf0gCWKAAArZDtZuAyxA+1doJwjMYT15MCmji7bnR7IDpyUgqurcNq5bHz/koEEz0gEXZQiB5UD1q4jkQaNiILhSJZVrZ4fRK/40BLMO+VI+rBMip4Mzw7Ewx0Qd0mcABoyB+wQuVBYaZFMPKhwomuVHBC9okTc+ChqtFQUe3qZETwJSw+ABid85osQIgfsGNsNKoooUJsIFj+FRU+KJL7W9kN4s/hEL0SqqIKQ7gTRMjw7wB0NX3Qo5QPsEDkOVenNGc7tAiqXEorc4SO0WXzwpcJVVbiklMtgsmgjyMigAhgIHbACixbHBMwW/NUKxYo6Z/gqipIw17lLo30JYUwAgFVYqOwIfyOEDtKFjETQAAAACh0p+p/etvkMMqgAAECRIhmYoJLvE6Xyu0ARAAAAy7MxZZ2bEcrLy1tsLpeL+vXrl7T9bbfdRm63u8U+b731lm3fLjw7AAAoUqQ0hjEbGxtb/JuFbsKECSn3mTlzJv3kJz+hdACxAwCAIkXO0Dq73bt30/79+4X3li0QxgQAgCJFEksPZJ1bROzq6+tbbH6/v933Wb9+PY0aNYq6deuWst3GjRupQ4cOdOmll9Jjjz1GimLfAjCIHQAAFClyLBW0vo3p3r07VVVVxbYVK1akfI+mpiZ69tlnadq0aSnb3X333XTgwAH68ssvhTj+9Kc/FZtdIIwJQDqy76gq+aIpUzirvZkEv2znTDhEDUE/D5hQjdtL5U6XKTu+sEKNwaD4d7nLSV6HI+9n1wHryHxt6rwMtHaHDx+mysrK2PMejyflfps2baLS0lL6zne+k7LdlVdeGXs8aNAguv/++4WnN3fuXLIDiF0SuCNwyUj+DIyJCpd9YmGJXwjOz4kEvxRJ9NueyAhxUkJUH/SLhemRJ4m+8p+huoCfOni8VOJw6rITUBRqCIbO2uEwVDBETaGwED2PfDY8BXIL/lY4ew7lWAaVysrKFmLXHk8++SR973vfI6fTmNzIsr2BR4QxU8B5Cd2yJJLyApAKrojRFFLoTCuha5HgV41snFw8Gf5wiL7yN9OpgK+FQGkEVYWO+ZrpH2eayBcOJbUTCCt0yh+g04FgQjv8XF0gSCf9AdEW5J7IuTORCJqMhzGNwGHJXbt20dSpU9tt+/zzz4sxQL5J27NnDz3yyCM0duxYsgt4djruZkRxRZGnELXsQFvRYE9Ob/5LTfQkNVK0U+vMgkpYeHJ+hbMhtg+3Y8FjD6+D20tuh0M8H4p6cuzR6YETVJ8KBETHWu5ykcvmu2lgDL6xzmQhV4kMeHYmxI7H3q6++mq68MIL27w2Y8YM8XfdunXi75o1a+iOO+6gUChE5513nliGcO+995JdQOxMiJ5WbBEUL0pU5MxWq9dET1XC1Bzyk0+nyLWGx/T+fqaRSh0ucssOkSnfDLwfe3leWaYKtyvtHgXIrshlaunBj370o6SvaSKn8eabb1I6gdiZGctj4RPjIahzV6xwuNKOGx6efBJUzQld6zBqpE6Htc6Sy8lA5jIHCxwLXbbGTSUD4UnkxixS+OJ0yxxOgotXlNj0tdt29djUV0LqMku2w8YSSvwAAAAodGQUbwUAAFDoSPDsAAAAFDpyhnJj5gKYoAIAAEWKjDAmAACAQkcSyx30t81n4NkBAECRIiOMCQAAoNCR0li8NdeAZ2eBVDkOAcg0fDnme6ip2OA8kNlMxC0XkWeX9UR4wWCQZs+eTTU1NaJo35w5c0RutERw7rSBAweKkhKjR49OavPYsWPCVv/+/dNXwkVRRLonUJw4bcpG73HYc78ZVhVbOk0tNydf42bhfeM3kOp8R/qSbJ0nOc2JoHOJrIvd0qVLaceOHaJk+759+2j79u20fPnyhG25yu2iRYto+vTpKW2yeA4YMCBtIscXKHJjFjceh0xlTlnkSzUL79vR46Ha0nIqtSB6nBOzwuUVwmnl7pv3VUmmxhDfyBkXK60tJy0LKpF0epxgCKKXGu5LuE/hlG+ZFj0pus5O75bPZF3sNmzYIASsa9euYlu4cKHIlJ2IMWPGCI+uY8eOSe29+OKLdPLkSbrllltSvi+Xkm9dXj5lnTJFhciBNiWgSp0OKnXIIsehEZFjoeR9WWBcsoM6l5RRt5Jy8sqR6gV6cEkOqnKVUIWrhBySLGyx4AnRM3AXzm09DkdMLLm79YUjJYu0RNepOmHtNf4/lwsSnXb0NU6azsKn1WCAp5ccPleZFj0pGsbUs0HsLHDq1Ck6cuRIi3AjPz506BDV1dUZtsf7/OAHP2iTTTsRXEo+vrQ8l5pvDV9w4ajI8YUIQLKQJgseb6nuHlnGRDunQwhla1hwupaWUxdvGblT5ExkYat0eanSXULOBOIoRM/pFGV/UkmeFPUKua0stX0/JZrwmgu9apGM+E44XuSCYUWIWrJaftyBsxBqr0P0ksN9DXvFXD4q3edJipuk0v5/+U1WPbvGxkbxt7q6Ovac9rihocGwvfvuu49uu+22hLWTWjN//nwhjtrGpebbVnlWRTgHAF0loGRJeGwljpYdA//ISoTIybrG+kqcTuHlnestbVE4mD2wCqdXeHMuuf2wJ4sie2ssaFIikXM4yaEjETELXXNYoeZQuI2HJsau4zy3VAhRhOjpQjtXvKUT2YBnl+8TVLI6G7O8vFz8ZbHRQpOaR1dRUWHIFo/17dy5k9577z1d7XmSC2+pgMwB0yWgpMiNEncPZkq4cPsyp0uM5Z0I+MVMS7fsNGXHEe2otIrlDpMhKQ5phkIKebiCdtTzs9KRR4rXmjRSJKS7hrxcRLMxsyp2PAOztraW9u7dS7179xbP8WMOKXJo0Qjbtm2jv/3tb2ISizYmd+bMGSGiH330kRgPBCCjJaBs6BzYTonDZXlCVKT4sD2dlQivRW2C/EYqonV2WZ+gMmXKFFq2bBkdPXpUbDwTc9q0aQnb8pIEn88n/iqKIh4HAgHxGo/V/fWvfxViydtDDz1Effr0EY/PPffcDH8qAADIfWTJ2JbPZH1R+eLFi+nEiRPUt29f8e/JkyfTggULxOMZM2aIv9qEE16msGTJkti+JSUlNHToUHr99depsrJSbPFeo8vlEp4jAACA4vbsJBXTogS89IBDpzxmyKLJpwVVyEEuED8bMhcQY202hDE5rMreAsKhqfE65KT9lFnqo3Ze/eQjKtM5P6KpoYFGXXi55fcuWs8OAABAdnBIvEZU32iW3na5CsQOAACKFLmIZmPmt1QDAADIyXRht912G7ndbrHETNveeustW/IkmwFiBwAwhF25LrlqiLb2zwrIvWkeyUASaDMTVGbOnCmSh2jb4MGDbcmTbAaIHQA5DqcYq3DK5LYw95uTirmlyGYkj2fbROhhagyFqD4UojO8BMiEWLGdxmCA/n6mgQ43N9AJ/xlRtcGMHU7nF4huoSxWD8hXZBMZVFrnFOY1zZnOk2wGiF2qRcFyvk+2BYWAFkLizCXlTplcBkSPf+CawGl2NOHTm3I6kghdIV84JP5q+BWF6oNB8oXDukSG2zSHgnTM10T1IX8sQ1F9MECHmxrodMCnSzzjRS4+Zy3PWC0k0RPfXZoXt0kGN0ZL+qFtnGc4GRs3bhQhyUsvvZQee+wxsT46E3mSE4EJKimIZJGPpFmKz+QOQDYQYyaqSl45InxcmSBZgnLuKLXyQ63HWrR/O0gVgsdpwBJ1QSwYStSbS3Xts9j5w2HyOhwigXXr92M7PiVE9UF/0rAlP3sq4Ke6QIBqPB6qcLoT2uHjZKFLdTwsevw+jjiRzyf4aPmGJjMTQqQ4GdPTlkQe4filB8nSLt5999306KOPCrF799136aabbiJZlmnu3LmG8yQbzaiVCHh2OuBcgnyHxRdgfv1sQKERmyzA4U1n25p6oqOUIp0lly1P1dGL10SJIc7n2bIzCHPdxnCIAu0InQa3ORMOU0MwSIE4z4ptfOVvplMBn67xOa6LcMLvoyPNDSLUGauRFy0VZOSmM6xVD8hCnTgrIsd9TaZmPkpkYIJKtPfTEnhoWzKxu/LKK6lTp07kcDho0KBBdP/999Nzzz3Xbp5kDbN5kpMBz04nWviHk8TznSNK/oBsookYCxSXDOISO3xNinp00Y5dT3epteGOzCVzKR6tuoE5cWDPqzk6gy6kBClgYixO7Kuq9KX/jAhxdvCUWMrewbYklYUkd708V5YW2EuG/TrzsFeXiTzJSd/fFitFWMqFw0j6y2wCkL7rUUPzBsx0mNouHI40K3TxBCwIXTweLmVkg1OWq2vEOIuM6Es4apSFY5QM/meE559/Xkxg4ZuvPXv20COPPEJjx461JU+yGeDZWRK9yPgBAAVDdFzQKnb9KnJUo2xDT33DdCJFItm62xphzZo1dMcdd4i1cuedd55YhnDvvffGXm+d+zhVnmQ7QG5MCznnkD8T5AocxrSj9llTKCQKslrFrwRNLSdoTZXLQ6UOl2Wvh8fdc3GySnzeSz3YnRtz52cHqbxS35hYY30DDbmgN3JjAgAAyC+kIqp6gDAmAAAUKVIGJ6hkG4gdAAAUKZKBnJe5FgI2CmZjAgAAKHjg2QEAQFGHMSXdbfMZiB0AABQpEsKYQA9mMr4DAPIbu1KPsZ1A2I4FI5lNBJ2vwLMzKXKcoy+7lykAZ5FliRQbEhxwImdRNcCiHafkIEW1boerJHgdTpJV85MkRJUETqXGa9q0VGom7TD8qaweD8Olkjg1W6nDQdUeF7lSpNNKFxKWHoDk9bwgciD34EXTkbyt3LGbtUHkdjpErk3uhHmBuTk7shCoMnLTmXCQzoQD5hfLq4ooCVTmdFGF0yPESq/AaKLCialFGaIg1wZ0UJnLacpOYygYS2hd4XJTjdsjRM+oHV9YEUKnRYaaw2Fqbg5ThctJVS6XSB0G7Aeend56XhY6EQAylsKOM4VEr1e9jp4oBxSXm5H/X+5yCtFrCoZEZ6zLjqig4GiRh7LU6SavwyUEzxcOWsjsEhReXrnTLTZxnElEhn+v/FowKnLxERj+LFydodTppDKnQ5ed5nCITvl9Qng1GoIBUZWBM7xUuT2RMF87dlh0G4OhpEnkG4Ih8Xqly0mVbldG8nlKRTRmB7FrN/yBCgcgv+BOibPoR4quJo9ESFGRS9ap8vMVbheVKg7RCfuSpBGTuWKCw5HSTpnTI0SvORSggGLOY2SJaAgFhPCxZ8VpxLTPGy8qLCa+UChl7bymaKV19vJKHI6EdvxKmE76feJvMjung35RmaHa7aFKlzvx8SiqOG6OCun5jHVBrv0Xomq3S3h76RQZCWFMIAaPUbAV5LvoOaTYGLOqU+Ra45BlqvK4qTTqmbCHotlhkeOwpS47kkwVLm+0jJCfgqo+j7E1PGZWF/RTYyhAlU4PlTgjoheOipze8ltK1JvikG2Z0ynyVGoe4cmAj86EQ7qPh9vzMdW4vVTujOTy5ONpDARFRXejRIrZBqkpFKaupV5KJxIVB/DsUoCoJSgEWNTcUdFjUoXcUsETKGo8bmoIRASF7Zqx45RlqnSXUH3gjGnBY1hMTgUjouSSHBS2YKc+GKS6gMKp8XWLXCI7X/nPUGMwMqmGb5atYkdS7qyVPcgxIHYAFAl2jQGxWNkx/V4cjw13lCwyEumfcJIMHpMLJQlZGoFvBPxhJS/GuCTkxgQAAFDoSBizAwAAUOhIEDsAAACFjlQ8Q3YYswMAgOJFKppRO0xQAQCAIkUqGqmD2AEAQNEiFVEGFRRvBQAYQrKp4xDpxXQuSM8EnLiaN6ucqDtB+z/9mPJpgoqk8798JneuNABAXuBxSFTuclCJw1z3x/t4ZIk6e0uotqyCzvWWmhY9XkzOFRaseB282L4p5KPG0BnycQ7PUMCU6DU2N9LPnnmcht05nL5z72i6+Ye30kcH/0xWE3zna4kfv99P06dPp549e1JFRQVdfPHFtGHDhqTthw0bRh6Ph8rLy2PbF198QXaBMbsk8I/HI3MGA1Q5AKD1b0N0HpJE5U5Or6WSX2dqPRY5dzSrv2an1OGk0tJyaggF6XS0qkC7HZfkEEIXb8covDCeE1SfCftaHLtCnEA6INKbuWQnye0IsT/gp2f/5zlau2kdNZ1pignl7n3v0nXzxtC/fuPbNG/iXOp1Xk9DxyeqILgjqdDycdQuFApR165daevWrdSrVy965513aNSoUVRbW0sjRoxIuM/KlSvpnnvuoXQAsUuBFJdmCfXrAGj7+2BcMm+c1T8ieolggWOhi9+vtZ0KUcbHRXXBANUF/CLnZJsOiwVIcloWOb/CeSdZ5JILa1hVKBwORIRVbpuQORwO00tvvkw//e3P6MtTX7WxFY5mY/mft1+j37/1B5pw7Tj6/vjZ1LlD55THx9UYOAk0Z6rJ56UHZWVl9NBDD8X+PWjQIPrWt75FO3bsSCp2BR3GDAaDNHv2bKqpqaEOHTrQnDlzxB1BItasWUMDBw4Uru7o0aNbvHb8+HGaNGmSuGuorKykAQMG0EsvvWRjbkFZ/GDzO2oNQPomOfDvo8IZ+Z1ocPWFcqecVOgS2alyual7WYUonyPF18iT3ULoIh20uaKp/jDXpGsQIUt9viin/+KyQH4KhIPCBm/bdv+RrrvnBlr474vpy9Ntha616LG399zW/6Sr77yGVv76x1TXVN+mXYlDpq4lXuro9WRE6MyO2dXX17fYOFypB5/PR7t376Z+/folbbN06VKhA9x/b9y4kQpK7PjDsdLv37+f9u3bR9u3b6fly5cnbNutWzdatGiRiAO3prGxUZygt99+m06fPi3uKG6++WZh1y6E6MlcswuiB0BrNAFiYWOB463EyQWAjM/6498aF0ft6i2nEoebPDLXd9Pew7jQhdUwnQ42UkOoOaHHqFf0/nb0M5owfyLN+dH36dDRw+J5vXlCWfQCoQD9xwtP0pDpQ2nTH/9LPO+RZepS4qFzS7zipjrX6d69O1VVVcW2FStWtLsPn6Np06bRhRdeSGPGjEnYhu0cPHiQjh07Ro888ohwfF544QXbjltS7cjoavHErV69mm688Ubx702bNtG8efPo888/T7rPgw8+SHv37qXNmzentH3llVcKr/H2229v9zj4DoW/uLq6OuEZ6qp1p6hkLj86AIWN1q1Yna5eH+BK59aTMzeFzliqmK7xi/98gp783ZO2zNqsKq+if2z6MFZaSA9G+6n27Bz4x5dUodNOQ3099enaiQ4fPtzivTnSxluqa2HmzJm0Z88eMX7H76uH++67jw4dOkTPPvss5f2Y3alTp+jIkSPUv3//2HP8mD8gf5l6T0oiOKz58ccfJ3WZ2fWOd7/5yzcCX5x8E8ZjeQCAtr+PQkRVFZJlmZSwDaV3VIVKotXSs4VkYsyOhU6v0LLQzZo1S0xO2bZtm6E+nc+znWTVZ+bQI1NdXR17Tnvc0NBg2m4gEKAJEybQTTfdJMb4krnM8a44e5gAAADsgyNrO3fupNdee03My0gGDz1t2bKFmpubxcQfFsZ169bR2LFjC0PseB0Fw16chvaY12WYFToOiZaWltITTzyRtN38+fPFe2kbu+YAAFBMSGlcVM5DUWvXrqUDBw5Qjx49YmvnZsyYIV7nZQja/AyeqLhkyRLq0qWLEMW5c+fSqlWraNy4cbZ91qyGMflD8exJHn/r3bu3eI4fawOgZoSOTw7/ffHFF8ntdidt216cGQAAgHlY4FJNCXn11Vdjjzt16iRCnekk6+vspkyZQsuWLaMhQ4aIf7PS86ydRPCSBG1TFEVMZeW4Losa3xlw2LKpqYleeeUVCBkAALSDhBI/mWPx4sV04sQJ6tu3r/j35MmTacGCBeKx5u5y7FZbpsCurkZJSQkNHTqUXn/9ddq1a5fw5rxeL3Xs2DHWhm1p9gAAABQnWV96kCuYmdIbycSA0wdA2n6XObb04D82/Qf9cvNTFApbX3RUVVZBpzcbSxht99KDg8e+MrT0oHfnjpbfO1tkPYwJAAAgO0hFVM8u95fr5yjaonIAQPEgSbKYL2AHzUEfbfu/t3RnYAHWgNiZETlVFUlvkT0FgPRS6uQSPtZ9ikjKMesLuG/41vV0VZ8rLC96lp0y1fTpRHe88EO68env054j1koBWZ2gIunc8hmInQGUqMhxSRPciwGQfjghcgePW5S64XyZRuE9yp1O6lJSSr0rzqHupVXkNiF6bKeTt4yG9rqM3li9mf5ryS/potpekdd0pyAhkmSJqnudQ+df/U9U3jWyvOqjowdo/DNzaep/LqQDX35KmUVKY0W73AJjdjpAiR8AsgeLidfhEAmTebJKYzCk62aTvcIyJ9ejO9tJV7q9VOHyiLp5x32NFNKR47KDp5Q6ecpaVCIY9fVraMTAYfT86y/S4l+upC+++kfyY+K3V4kqa2uouldHcnqcbUoJMds/+19649PddP0l19AP/uU2qq3qQplAouIAszFTzHLikCWKtwKQW/DvsjkUpqZQYtHjxMrlLle7Vb75Jvakv5m+9DUlrIRQ5fLSud5ycjsc7RZvXf/qb2npr1dRXVNDLEk0izQfa1mXSurwT53IVZo8yUU8DlGUVqXJA66nmYMmUseymrTNxvz0+Anddnifnueek7ezMRHGbGdZgT1D0QAAu2ARKXM5Rd039t402PM7R4Q83e0KHcMeX0dvGV1U1ZE6espiHk650y1CnrVlVe0KnXhft4dm3jCFDmx8ixZM+j65XZHq4t4OpXTeoJ7Uud95uoVOK0fE3t5v3n+Jbn72XkonUtEEMRHGBADkKSxWFS4XlTqd4ubUbMFTLgzbuaSczvGUUEhVyeswN7pTUVpOCyfPJXfXMlq/61lylEVEzywseEcbvqR0IiGDCgAA5AcOm6YKOmWHLZMYysvKyFPhpZBifTE8sA9MUAEAgCJFwqJyAAAAoHCAZwcAAEU82UfSGQLO9+rzmI0JAACg4IFnBwAARYqEMTsAAACgcIBnBwAANpMvhQykIvLsIHYpiKa0AwAA3VzUsafIgsJpv/ivFS7uFEk2nS6kIlpUjgkqKWYeuWXJcnkRPsEuiQrOjpSjdlw22HFG7Ug22OGt0Oy4ZEmca6t9H5/jXLLjtMnOyAuH0OZb/p0GnX9FLEOL0cwwVd4K+uE1s+jpCT+2eDRAA55dO4LHnYNDJZFGKKwa7xTiM67nop1w1JYRO05ZapF70IodOW5Ks1125Gzbkfg8x38u1bAdrRNvbYfrBQcN2uHjcdhth4+N7RBRyGDJq5bHU5h2Lu9yEW28aSW9dWgvPfL6L+jPxz4Rvz1OPp0MWZLJ7XDRjK+PpykDx1K5u5TSjVREYUx4djrgi9cly+SJdoZ6RMXjkNvU3zJjh73LVHb4x2XFDnfwRu04LNjROnHNTvzanXTY0eMxOu22I1u340lix2HCjjOddgxEQOyyw9dGe3ZcNtqRTNphBp/fX3h5a2/4IdVWdY3Yb2WRPT9OVfa9K0fTm3f+huZ845aMCF0mUkEHg0GaPXs21dTUUIcOHWjOnDkUCoUstzUDxM5oaNMhR4Sj9WutOl+zdlJ14onssOgls+M0aMeTATuJOvFUdhKJnhE7qcQzWeeb73ZSdb7J7CQSmVy1w9dGe3ZSiTlfm0bsuG2wM/Kiq+m1qRto+ci5dE5ptRA8Fjnei+vXbZv2FC36f3eJ1wqpUvnSpUtpx44dtH//ftq3bx9t376dli9fbrmtGVDPzkKdKK2oq9wqTGQU2Mns+eHdufMya0eN2qFcshMNj9liR42EdK3aYVMum+yIELMFOxxG5u8/F+z4gn769fsv0f+d+JxuHziW+nTqqXtfu+vZHT15ylA9uy4dagy9d/fu3Wn16tV04403in9v2rSJ5s2bR59//rmltmbAmF3chax9oQAAe/DhRCZk/MUjY4+N9DlaW62/skpDfb3u4CS3jT8GDY/HI7bWnDp1io4cOUL9+/ePPcePDx06JASTxdZMW7NA7LQvsqEhdncBAAC53l9ZEQC3201dunShCy/oYWi/8vLyNn3kAw88QA8++GCbto2NjeJvdfXZ0Kz2uPXxG2lrFohdlG7dutHhw4epoqKiRdiF72L4y+XXcr0U/de+9jV69913c9q+WRtG9tPTtr02Zl7HtWLu+7LyPVndR29bK9eLndcKe3Tc+XN/ZQWv10uffvopBQIBQ/vx+7cOSyfy6jRhZNgz69ixY+wxw/2s2bZmgdhFkWWZamtrk54oviBzXewcDkdaj9EO+2ZtGNlPT9v22lh5HdeKfdeiGTt2Xyt62qV63e5rxQ4vRxM83tIFz6rkPnXv3r3Uu3dv8Rw/ZpFv/RmMtDULZmMWELNmzcp5+2ZtGNlPT9v22lh9PdfJh2vFrB27rxU97VK9nu/XihWmTJlCy5Yto6NHj4qNZ1dOmzbNclszYDZmhmY/gcIH1wrAtdJ27dw999xDv/3tb8W/J0+eLGZcOp1OmjFjhnhu3bp17ba1A4hdO/j9flqxYgXNnz8/aWwaAFwrwAjoVzIPxA4AAEDBgzE7AAAABQ/EDgAAQMEDsQMAAFDwQOxMcuzYMfrGN75BQ4cOpX/5l3+hP//5z/Z+M6Dg4CS3vCD3q6++yvahgBynrKyMhg0bJrbf//732T6cggATVEwSDodFx8WL0V9//XV68skn6Te/+Y293w4oKMaOHSty/b366quxLBEAJOKyyy7DDbTNwLMzCWdFYKFjTp8+TVdcEalKDEAiXnnlFREB4Dt2ANqD04h985vfpEmTJtGJEydwwmygqMVuzZo1NHDgQLF+bvTo0YYLCXLdJQ5l8msczgSFi5VrRVEUWrt2Ld11111ZOHKQj33LwYMH6c0336RrrrmGFi5cmOGjL0yKWuw4meqiRYto+vTppgoJXnLJJbRr1y5x184XLChcrFwrnBHi+uuvT2seQlBYfYsW5p4wYQK9//77GTvugkYF6gMPPKDecMMNLc5EbW2tumnTpti/n3/+efX888+P/dvn88Uef/bZZ+qwYcNwJosAM9fKfffdp15zzTXqyJEj1ZqaGvXaa6/N6DGD/LpeGhsb1VAoJB5v2bJFnTRpUgaPuHBB1YME6Ckk+N5779H9998vxu247MWqVasyeY8C8uhaWblyZew1nl2n5f4DxYee6+Uvf/mLSIDMuXg5DMqT34B1IHYJ0FNIcPDgwfTGG2/Y8BWAfMZo0UmeuQuKFz3Xy1VXXYXQZRoo6jG7ZMQXEtSwu5AgKAxwrQBcL/kBxC4B8YUENewuJAgKA1wrANdLflDUYsfTfX0+n/jL08P5sVamPt2FBEF+gWsF4HrJc9QinynFpyB+Gzp0qHgtEAioM2fOVKurq8U2e/ZsNRgMZvuQQZbAtQJwveQ3SBcGAACg4CnqMCYAAIDiAGIHAACg4IHYAQAAKHggdgAAAAoeiB0AAICCB2IHAACg4IHYAQAAKHggdgAAAAoeiB0AAICCB2IHQA4gSRJt3rw524cBQMECsQPABF9++SXddddddP7554sCm126dKGRI0fSzp07cT4ByEFQvBUAE4wdO1ZUyPjVr35FvXr1omPHjtG2bdvoxIkTOJ8A5CAQOwAMcvr0adq+fbuoOj506FDxXI8ePeif//mfde3/ySef0NSpU2n37t1CKH/605/iOwAgzUDsADBRnZw3HmMbNGiQCGPqhesmjhkzhjp37kzvvPMO1dXV0T333IPvAIA0gzE7AAzidDrpqaeeEiHM6upqGjJkCC1YsIA+/PDDdvfdunUr/eUvf6GNGzfSFVdcQd/85jdFYWAAQHqB2AFgcszuiy++oJdeeom+/e1vi5DmlVdeKUQwFR9//DF1796dunXrFntu8ODB+A4ASDMQOwBM4vV66dprr6XFixfTrl276LbbbqMHHngA5xOAHARiB4BNXHLJJdTU1JSyTd++fenw4cP0j3/8I/bc22+/je8AgDSDCSoAGISXF4wbN45uv/126tevH1VUVNCePXvoRz/6Ed1www0p9x0+fDhddNFF9L3vfY8effRRqq+vp4ULF+I7ACDNQOwAMAjPxPz6179Oq1evpoMHD1IwGBTjcNOnTxcTVVIhyzK98MILYukBL1W44IIL6Gc/+5kY9wMApA9JVVU1jfYBAACArIMxOwAAAAUPxA4AG3n66adji85bb5deeinONQBZAmFMAGykoaFB5MlMhMvlEmnFAACZB2IHAACg4EEYEwAAQMEDsQMAAFDwQOwAAAAUPBA7AAAABQ/EDgAAQMEDsQMAAFDwQOwAAAAUPBA7AAAAVOj8fzRKqGd7fO0+AAAAAElFTkSuQmCC"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 6 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We observe a slight dependence between the mean `S_d` and the shape parameter `b` of {class}`~fastdfe.parametrization.GammaExpParametrization`. This is because a large fraction of moderately deleterious mutations and a smaller fraction of strongly deleterious mutations can leave a similar signal in the SFS. Spectra with larger sample sizes might facilitate disentangling the two."" + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""## Estimating beneficial effects\n"", + ""Parameters can be held fixed during maximum-likelihood optimization, and this was already done internally in the example above. By default, fastDFE infers only the deleterious DFE, fixes the ancestral-allele misidentification rate `eps`, and assumes semi-dominant mutations (`h = 0.5`) (see {attr}`~fastdfe.base_inference.BaseInference.fixed_params`). Here, we estimate the full DFE, allowing for beneficial mutations by letting the parameters `S_b` and `p_b` of {class}`~fastdfe.parametrization.GammaExpParametrization` vary, while `eps` and `h` remain fixed. The fixed parameters are wrapped in a dictionary under the key `all`, meaning these settings apply to all SFS types, which matters when running joint inference (cf. {class}`~fastdfe.joint_inference.JointInference`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:30:30.012552Z"", + ""start_time"": ""2026-01-04T10:30:05.210262Z"" + } + }, + ""source"": [ + ""# create inference object\n"", + ""inf = fd.BaseInference(\n"", + "" sfs_neut=sfs_neut,\n"", + "" sfs_sel=sfs_sel,\n"", + "" fixed_params=dict(all=dict(eps=0, h=0.5))\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""inf.run()\n"", + ""\n"", + ""inf.plot_discretized();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:01<00:00, 7.46it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 4 parameters: [all.S_b, all.p_b, all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:01<00:00, 6.90it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {all.S_b: (0.0001, 100, 100)} and lower bound for {all.p_b: (0, 0.0043678716, 0.5)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -9823 ± 4.3e+03, all.b: 0.1549 ± 0.13, all.p_b: 0.004368 ± 0.091, all.S_b: 100 ± 52, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -34.73 ± 0.24} (best_run ± std_across_runs)\u001B[0m\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:20<00:00, 4.91it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -2.192e+04 ± 3.4e+04, all.b: 0.75 ± 2.1, all.p_b: 0.06205 ± 0.087, all.S_b: 58.15 ± 49, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -40.92 ± 5.8, i_best_run: 0.39 ± 0.49, likelihoods_std: 0.3645 ± 0.67} (mean ± std)\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 7 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""The inferred full DFE shows substantial uncertainty, which is expected with a small sample and few SNPs. This is most pronounced for the [-1, 0] and [0, 1] bins, in which mutations are effectively neutral and provide little signal. Adjusting the discretization intervals can help reveal the structure more clearly (cf. {func}`~fastdfe.base_inference.BaseInference.plot_discretized`)."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:30:30.138329Z"", + ""start_time"": ""2026-01-04T10:30:30.025803Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf.plot_discretized(intervals=[-np.inf, -100, -10, -1, 1, np.inf]);"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 8 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": [ + ""## Ancestral-allele misidentification\n"", + ""We can also adjust for ancestral-allele misidentification by letting parameter `eps` vary. `eps` is the probability that an allele is misidentified as derived when it is actually ancestral, and vice versa (cf. {func}`~fastdfe.spectrum.Spectrum.misidentify`). This can correct biases to the SFS caused by mis-polarization, but `eps` is somewhat difficult to interpret because it is applied simultaneously to both the neutral and selected SFS. In addition, `eps` assumes the fraction of ancestral misidentification to be constant across site classes, but in practise errors may differ across classes. Nevertheless, below, we infer the full DFE while allowing `eps` to vary."" + ] + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:31:03.254Z"", + ""start_time"": ""2026-01-04T10:30:30.144510Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf = fd.BaseInference(\n"", + "" sfs_neut=sfs_neut,\n"", + "" sfs_sel=sfs_sel,\n"", + "" fixed_params=dict(all=dict(h=0.5))\n"", + "")\n"", + ""\n"", + ""inf.run();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:01<00:00, 7.68it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 5 parameters: [all.S_b, all.b, all.eps, all.S_d, all.p_b].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:01<00:00, 5.05it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.p_b: (0, 0, 0.5)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1.004e+04 ± 7e+02, all.b: 0.1508 ± 0.0042, all.p_b: 0 ± 0.0065, all.S_b: 0.000167 ± 0.065, all.eps: 0.006854 ± 0.00012, all.h: 0.5 ± 0, likelihood: -34.63 ± 0.0061} (best_run ± std_across_runs)\u001B[0m\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:28<00:00, 3.54it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -2.061e+04 ± 3.3e+04, all.b: 0.7611 ± 2.1, all.p_b: 0.07106 ± 0.09, all.S_b: 0.04142 ± 0.27, all.eps: 0.006649 ± 0.0068, all.h: 0.5 ± 0, likelihood: -40.64 ± 5.6, i_best_run: 0.53 ± 0.5, likelihoods_std: 0.01924 ± 0.074} (mean ± std)\u001B[0m\n"" + ] + } + ], + ""execution_count"": 9 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:31:03.332893Z"", + ""start_time"": ""2026-01-04T10:31:03.265103Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf.bootstraps[['eps']].hist(figsize=(4, 2));"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 10 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""`eps` is estimated to be rather low, indicating that ancestral-allele misidentification is not a major issue in this dataset, or, at least, that including it that does not significantly improve the model fit. We can also check this in a more principled way by performing a likelihood-ratio test as done below."" + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""## Nested model comparison\n"", + ""We can automatically check for the significance of include ancestral-allele misidentification and beneficial fitness affects using likelihood ratio tests. This is done with {func}`~fastdfe.base_inference.BaseInference.plot_nested_models`. The LRTs are performed by comparing the likelihood of the inferred DFE to the likelihood of a nested model where some parameters are held fixed. Alternatively, we can use {func}`~fastdfe.base_inference.BaseInference.compare_nested` to directly compare two nested models."" + ] + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:31:08.127726Z"", + ""start_time"": ""2026-01-04T10:31:03.337423Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""# set logging level to warning to avoid cluttering\n"", + ""fd.logger.setLevel('WARNING')\n"", + ""\n"", + ""inf.plot_nested_models()\n"", + ""\n"", + ""fd.logger.setLevel('INFO')"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:01<00:00, 6.02it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {all.S_b: (0.0001, 100, 100)} and lower bound for {all.p_b: (0, 0.0043680056, 0.5)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:01<00:00, 5.24it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.p_b: (0, 0, 0.5)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 25.52it/s]\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 16.20it/s]\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 11 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Including ancestral allele misidentification or beneficial mutations does not appear to improve the fit significantly."" + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": [ + ""## Dominance effects\n"", + ""By default, fastDFE assumes semi-dominance (`h = 0.5`), which is more or less appropriate depending on the organism and type of mutations considered. We can change the dominance coefficient to a different value of `h` if we believe this is more appropriate. However, in practise, `h` often depends on the strength of selection, with more deleterious mutations being more recessive. To model this, we can specify a callback function that returns the dominance coefficient as a function of the selection coefficient `S = 4Ne`.\n"", + ""\n"", + ""In the example below, we use an exponential decay: `h` is about 0.4 for neutral mutations and approaches 0 for strongly deleterious ones. The callback also receives `h` itself, allowing the dominance function to be parametrized and optimized; for simplicity, this parameter is still called `h`. Its bounds can be set via {attr}`~fastdfe.base_inference.BaseInference.bounds`."" + ] + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:31:45.694656Z"", + ""start_time"": ""2026-01-04T10:31:08.145021Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""import numpy as np\n"", + ""\n"", + ""inf = fd.BaseInference(\n"", + "" sfs_neut=sfs_neut,\n"", + "" sfs_sel=sfs_sel,\n"", + "" fixed_params=dict(all=dict(eps=0, h=0, p_b=0, S_b=1)),\n"", + "" h_callback=lambda h, S: 0.4 * np.exp(-0.1 * abs(S))\n"", + "")\n"", + ""\n"", + ""inf.run();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing DFE-SFS transformation for fixed dominance coefficients.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 1809/1809 [00:32<00:00, 56.02it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 41.92it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[33mWARNING:BaseInference: The L1 residual comparing the modelled and observed SFS is rather large: `norm(sfs_modelled - sfs_observed, 1) / sfs_observed` = 0.157. This may indicate that the model does not fit the data well.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 0, all.b: 0.1401 ± 2.4e-09, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0 ± 0, likelihood: -74.33 ± 1.3e-12} (best_run ± std_across_runs)\u001B[0m\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:03<00:00, 29.31it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -1e+05 ± 0, all.b: 0.1396 ± 0.0032, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0 ± 0, likelihood: -83.91 ± 15, i_best_run: 0.55 ± 0.5, likelihoods_std: 2.238 ± 22} (mean ± std)\u001B[0m\n"" + ] + } + ], + ""execution_count"": 12 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Let's compare the inferred DFE under this dominance relationship to that of the default semi-dominant model."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:31:54.608903Z"", + ""start_time"": ""2026-01-04T10:31:45.705758Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf2 = fd.BaseInference(\n"", + "" sfs_neut=sfs_neut,\n"", + "" sfs_sel=sfs_sel,\n"", + "" fixed_params=dict(all=dict(eps=0, h=0.5, p_b=0, S_b=1))\n"", + "")\n"", + ""\n"", + ""inf2.run();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:01<00:00, 8.24it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 27.87it/s]\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -3.389e+04 ± 4.2, all.b: 0.1305 ± 1.7e-06, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -35.44 ± 3.2e-09} (best_run ± std_across_runs)\u001B[0m\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:05<00:00, 17.10it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -5.482e+04 ± 3.9e+04, all.b: 0.1331 ± 0.022, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -42.9 ± 5.9, i_best_run: 0.5 ± 0.5, likelihoods_std: 0.007777 ± 0.046} (mean ± std)\u001B[0m\n"" + ] + } + ], + ""execution_count"": 13 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:31:54.766879Z"", + ""start_time"": ""2026-01-04T10:31:54.621633Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""fd.DFE.plot_many([inf.get_dfe(), inf2.get_dfe()], labels=['partly recessive', 'h=0.5']);"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAdYAAAE/CAYAAAD7UeIQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOXNJREFUeJzt3Ql4E3XeB/BfSw8KLS0ISLnlkoICgou7cou7giggLHhQ5XgLsgisB7pQKJcUkF1B5aoulyiI+q6yh4oocrpesHRBqggKhSpIgdIDKG3pvM/37zshSdM2adOZTPL9PM/QyczkP5MhyS//O0jTNE2IiIjIK4K9kwwRERExsBIREXkZc6xERERexMBKRETkRQysREREXsTASkRE5EUMrERERF7EwEpERORFDKxERERexMBK5IbZs2dLUFCQw7bmzZvLqFGjLHX/jh8/rl7HunXrDD0v7hPuF1EgYGAl8kMbN26UF154Qaymd+/eKvBjCQ4Ollq1asmNN94oDz/8sHz00Ucun4OArT/HecnPz1fH4IdEacdg+fzzzw1+peTPQsy+ACKrOnz4sPry99XA+vXXX8vjjz/usL1Zs2Zy+fJlCQ0NFV/VuHFjWbBggVq/ePGiHD16VN555x15/fXXZfjw4eqv8/V36tRJnnrqqRJphYWFOTyeO3eu3HDDDSWOa9WqlddfBwUuBlaiCgoPDzfs3iHA1KxZs9LpIHdWvXp18WXR0dESHx/vsG3hwoUyefJkWbFihcqhPvfccw77GzVqVOI5rvTv319uvfVWr18zkT3f/LlNZKI9e/bIr371KxWAWrZsKS+//LLL45zrWAsLC2XOnDnSunVr9dzrrrtOunfvXqII89tvv1U5r3r16klERIQq6pw+fXqJ+ty0tDR56KGHpHbt2iodHXJsXbp0Uc+tU6eOPPDAA3Ly5EmH4tT33ntP0tPTbUWdev2mcx3rjh07Si0eda4T/eCDD6RHjx4qwEdFRcmAAQPk0KFDJe7L5s2b5aabblL3AH/fffddqaxq1arJSy+9JO3atZNly5ZJdnZ2pdMkqirMsRLZOXjwoPzud79TQQ8BrqioSGbNmiXXX399ufcJx6MIMyEhQbp27So5OTmyd+9e+c9//iO//e1v1TEHDhxQwQlFmePGjVPB6/vvv5d//vOfkpyc7JDesGHDVJCeP3++6LM74pikpCQVmHGezMxMWbp0qfTs2VP2798vMTExKkgj8GRkZMiSJUvU8yIjI11ec1xcnLz22msO2y5cuCBPPvmk1K9f37YNx4wcOVLuuusulVu8dOmSrFy5UgV8nFcPwlu3bpWhQ4eqAIh7ce7cORk9erQq3vVGcH3wwQfV68ePHwR2+x81Z8+edTi+Ro0aarGH++J8HH5E4EcQkddgPlYi+sXgwYO16tWra+np6bZbkpaWplWrVg2RzeE2NWvWTBs5cqTtcceOHbUBAwaUeSt79uypRUVFOaQPxcXFtvVZs2apcz344IMOxxw/flxdR3JyssP2gwcPaiEhIQ7bcR24PmfHjh1Taa9du9bl9eE67rnnHi0yMlI7dOiQ2pabm6vFxMRoY8eOdTj29OnTWnR0tMP2Tp06abGxsdqFCxds27Zu3arO6ep6nPXq1Utr3759qfvfffddldaLL75o24Z0sc15wX3U4fW6OgZLeHh4uddF5AnmWIn+39WrV+XDDz+UwYMHS9OmTR1ydcipvf/++2XeK+QWUTR65MgRldN0htzlrl275I9//KND+uDclQfGjx/v8BgNeIqLi1Vu1T7X1aBBA3W+7du3S2JiYqX+P5999ln517/+Jf/7v/+rcp2AomzkYpFbtD8vcpC33XabOi+cOnVKUlNTZerUqaqeVIfcOtJCPXFl6Tnv3Nxch+24jnnz5jlsa9GiRYnnL1++XNq0aeOwDa+DyJsYWInsAh9azLoKiqgHLS+wosXpoEGD1Bc36hb79eunuol06NBB7f/hhx/UX+xzh3PrVQRsFAm7uj6obEvfLVu2qDriadOmqeJc+/PCHXfc4fJ56BIDqNOF0u4fisQrKy8vT/1FHa+9unXryp133lnu81FEz8ZLVNUYWIm8BPWcqC/9+9//ruoaV61apeo4U1JSVH2op9A4yR5yq8jZohGRq1xWafWo7jh27JiMGDFC5S6dc344r17Pityxs5AQ475G0IUI2D2GfBkDK9H/01vp6jk05z6r7kArXTTWwYLcFYItGjUhsOpFk3pw8BRaKCPHipysc3GmM1dFy6VBLn3IkCGqKPuNN94o0TcX5wU0ZiorV4g+slCZ+1deUT3656JBkn0raSJfw+42RP8PuUDUpaK7yIkTJ2z35ZtvvlF1r+VBC1jnHCRyVleuXLEFbgTaNWvWOKQPeqvfsiD44RpRXOt8PB7bnx9dYtztkoK63O+++051i0HXHme4JyjuRetktL51VYQOsbGxaqCGV1991eHcqKNF16HKBlX0Y8X/Bf7qxc9Evog5ViI7CFqoa0SXmAkTJqjuNujO0r59e9VVpixooIM+pOhjipwrutqgEdDEiRNtx6AvJnJbnTt3Vt1tkPtE31L0O0XDn7Ig54hiWtSB4jloZIW6RhTjIigivSlTpqhjcQ1vvvmm6jaDPrkI8vfee2+JNHHe9evXqzpVvD7714jn4BwIYuhag/piXDf6zeJHAn4c4PndunVTfUsBXWzQDQavccyYMXL+/Hnb/dPrR8uDoIy+uoBuPfrISyhmx7nRwKqiUIyOfsTObr/9dpeNnYgqxKM2xEQBYOfOnVqXLl20sLAwrUWLFlpKSoqtC0xZ3W3mzZunde3aVXVNiYiI0Nq2bau6wBQUFDg87+uvv9buu+8+dRy69tx4441aUlKSbb9+rszMTJfX97e//U3r3r27VrNmTbXgPI899ph2+PBh2zF5eXnaQw89pM5h39XFubtNWd1QnLvHbN++XbvrrrtUFxtcd8uWLbVRo0Zpe/fuLXF9cXFxqhtLu3bttHfeeUfdJ3e729hfA7r9tG7dWouPj1fddlxBuuV1cyrrdZbV/YioIoLwT8VCMhERETljHSsREZEXMbASERF5EQMrERGRFzGwEhEReREDKxERkRcFTD9WDMv2008/qX5/noxKQ0REpGmamvyhYcOGJUYnC9jAiqDapEkTsy+DiIgs7OTJk+XOLxwwgVWfDQM3hcOhERGRJ3JyclTmzHlmpYAOrHrxL4IqAysREVWEO1WJbLxERETkRQysREREXhQwRcFERJ5OVedqmjzyb6GhoWp6xspgYCUicoIp7jIyMtyaJ5f8rw61cePGatrEimJgJSJyyqkiqNaoUUPNO8t+74FD0zTJzMxU//+tW7eucM6VgZWIyA6Kf/EFi6AaERHBexNg6tWrJ8ePH1fvg4oGVlMbL+HCJ06cKLVr15Y6derIpEmTpKioyOWxyJbbLygH79Chg+HXTESBgTnVwBTkhZH5TA2s8+bNkz179khaWpocOnRIdu/eLfPnzy+1zsN+iYuLkwceeMDwayYiIvLZouA1a9bIkiVLJDY2Vj2ePn26TJkyRWbOnFnm87788ksVjEeNGlXqMVeuXFGL/agZnjp16pRaSoPr1q+diPzY7OgqTDtbjLJjxw7Jz8+Xfv36qcco8uzUqZNcuHBBrDxc7f33368yZr7CtBxrVlaWqiDGf6oO6ydOnJDs7LLfaKtXr5b+/furwZBLs2DBAomOjrYtFRkn+OWXX5YuXbqUumA/EZEVoJoNgXXLli1eT9dMDRs29KmgampgRXEuxMTE2Lbp65hBoDQXL16UTZs2SUJCQpnpT5s2TQVofcEYwZ569NFHZd++faq4Wod1bMOC/URERtT7zZgxQ2655RZp06aNbNiwwbZvxIgRcuutt6o2JwMGDJDTp0/bcqP4Tv3Tn/4knTt3lmXLlklKSop6LjIxc+fOdTjHX/7yFxk3bpztMXKxdevWlfPnz5e4nubNm6t0u3btKiNHjlTtZaZOnaoed+rUSYYPH64yT4DvX3xf33TTTdKxY0cZM2aM2l7Wc1atWiXt2rVT22+++Wb54osv1AxlaJODakCkg8wNct/664Tk5GR1jH2cQfsdtPTVXyPOh/uBXHt6err4VVGw3kcINx3/efo6lDXI8dtvv62aweMNVJbw8HC1VIZe1ItgrsN/dM2aNSuVLhFRRYLr/v375YcfflCBtFu3birAvfDCC6olKyxcuFBmz56tAqj+ndq+fXt57rnnbMESC54DCEo6BD8E7UWLFqlAtXbtWhk0aJAKTK6cO3dOBTxcF9rG4HsR1XTw7LPPqh8Cy5cvl8cff1y1rj5w4ICabk0Pcn/+859Lfc5TTz0l3377rfr+RQBGtd5///tf2bZtm2qPg3Tw2sLCwsTeI488ogLu888/r77/ES/69Omj7s/GjRvl8OHD8tlnn6nWvq+99ppMmDBB3nvvPfGbwIqWwOiEm5qaKi1btlTbsI4iWxTdlga/ZPALKSSkgpe+oLFIuIetvgrsOoknx4qEBfl0PQoR+R+9lK5FixbSs2dP2bVrlwqsCBgIEsi9YdEzKoDeE/Hx8W6lj2D6+9//XrV9eeKJJ2TlypXy5ptvlno82rjoLWg3b96sAt3f/vY39bigoEBdG/zrX/9SAVifw1T/EVDWc/r27SsPP/yw3HvvvaraDwEfrxvFzsjxIlgic+U8LyriB3L1//jHP2TYsGGybt06efrpp23n++qrr1Tg1fsr+2XjpdGjR6usO355AX71lFXEi18b//73v9UvKSKiQIaghqqpl156SeXC6tevrwKKfeNPlO6VNym3vcmTJ8vAgQNVcSsCIIJUaexHJkK/36VLl8rvfvc7t89V1nMQbFHdhjrhu+++W/UgQS+Qr7/+Wnbu3Cnbt29X1X34ceGcyULgRYxAAD169KitoRbOh+fYF3dXFVO72yQlJclvfvMb9Z+IBQE2MTFR7Rs/frxanBst9ejRQ42IQUQUSPQMBYpv0VgH34Wok0TV2XXXXadyfOU1qMSUmWU1Dm3btq3KGSL42NdVlmfw4MGqh8elS5fUY/xFkS0gUKNuE3WkoBcFl/Yc5Eq///57VdyNXiLIRaO4GM9DtRwCMTJhyN2id4ira0HOFA1YkVvXAy+2o4hcrzNGETOK1v0ux4piCpSnY3Gm1xHYQ9m/kU7lFsupPE0uF14rCk49fVUiQn8p/oiNDJLYKE4QROT3fKAqB0WXyEEiuCCXisDSqFEjef311+XGG29UwfXOO++UH3/8sdQ07rvvPlVsjLYiQ4YMUXWSzsaOHauCKgKau9CQCfWgt912m614GNtQv4vgiaJlNELCd/6vfvUr+etf/1rqc1q1aqVynQiACIrIOeNHBRqg4toQEHEvkBFDMbHz60XdKhpCrVixQr755huHRl6oF0YxMujFymXlyisqSAuQUabRjxV1t9lTo6SWm3Wss3fky5ydBaXun9UrTGb3rm6ZDyYRlQ/1lMeOHZMbbrhBqld38/NdxRB4kDu170VRVRBUr7/+elWiGIjyS/n/t8WQ7GyV8y8Lxwouw6NdwmTgjaGl7keOlYjIH2CghTvuuEO1Av7www/NvhxLY2AtA4p5Y0vv+UNEZAgjChYx0AK6uFDlsYKQiIjIixhYiYiIvIiBlYiIyIsYWImIiLyIjZeIiMrR9Im3JTi8hu1x8ZVLUnDmmASFVpew+s0lKLiabV9R9hkpyv5ZQqKvl5Do+rbtWvFVKThzXLTCfAmrf4MtveMLyx73nKyHOVYiovK+KKsoqHrSj7Wyc6ZiWECMy44Fc1+Xpnfv3qoPJwaRwIIBHsgzzLESEbnJ20EV6RkBY+q+8cYbaoYZjGaEUYtuv/32UmcJQzDFEIBUMcyxEhGZFFSRnrswRB/mEkVu0tOJSDBLDWaLwTRtGPIPQ/kh0FLVYI7VB506dUot5c0TS0TWDqpIz10IiBiMHoM4YLxdBErkPjEOL2Z7cQWD8mMs3hMnTkj37t1t2zHO8KZNm0o9FyYgx5CGmGwcg9ljYH5yHwOrD8KHYc6cOaXunzVrlprMmIiMUVVBFem5C4PI6zPQIKCePn1azWnt7TpQDNKPeU0x2hMmSLnnnntcziJDpWNg9UGPPvqommrp8uXLtl+ZmHcxIiJCrTO3SmSsqgqq9umVx35A+GrVqqnZWcCdHGvTpk0lPT3dth1Tz2GbKwiq6jUHBakB+TF1G2aFwew55B4GVh+kF/VieigdWuehfoSIjGd2UC2LOznWYcOGyWOPPSaTJk1Sud01a9a4LPVCsEYQxew2+oTjWGdQ9QwDKxFROdIXDbT0PUIXmvvvv1/NiQpYRxEv7N27V2bOnCnvv/++mh8VLYXxNzg4WOrWrSv/+Mc/TL566+F8rEapwHysyLFGRkaq9by8POZYiQJ0Play1nys7G5DRETkRQysREREXsTASkRk0uTi5J//72y8RERkJzQ0VHU1yczMlHr16ql1CpygmpmZqf7P8T6oKAZWgzSf+p7HTfJDYhrYtsclbZHiyzkeN/HnzBlEnkEfUQy8kJGRofp7UmAJCgpS//94H1g2sBYWFqoOzhs2bFAvCKOLoF8W+lq5gqbfaBp+5MgR1UIL6+PHjxer8KSfm1ZUaNtXlJMpxZcu+OQA30T+Bq3xW7durb6fKLCEhoZWKqj6RGDFVEYYVUgfMqt///4yf/58FTCdbdmyRSZMmCCvv/669OjRQzV//vnnn8UqPO08rsm1D/XVnDMSel2TKhvgm4gc4cu1sl+wFJhMb7yEEUBmzJhhG20I8wSuXr3a5bEYFBoBF52d8YavXbu2GjfTFXRwRuC1X8xU2RFZqtWqX6UDfBMRkR8E1qysLFWPgeH6dFjHTAzohOs8WMK+ffvkxx9/lDZt2kiDBg3UMF2lzQKDGRlQVKwv+viXZqlIUEXxry6kVr0qHeCbiIj8ILBiNCGIiYmxbdPXc3NzSwRhtNjavHmzfPTRR3L06FE1jVJ8fLzLtKdNm6aCs76cPHlSzORxUM0+o4p/S6RjwlikRERkkTpWfbg+BD6MSamvQ1RUlMtjJ0+eLM2aNVPrmFoNDQyQm3UeoB5BF4uv8DSoovUvin/tMagSEfk+U3OsqCNFs+bU1FTbNqyj2BbFt/aQky1tmiMrdOT2NKiq1r8VLP5lTpWIKIAbL40ePVqSk5PVpL1Y0CI4ISHB5bHjxo2TpUuXqnpWzFU6d+5c6du3ry03awVuB1W7hkpQkJleoeJkIiIylundbdDSF/P/xcXFqceoM01MTFTrev/UlJQU9Xfq1Kly/vx56dixo3rcp08fNdu9vwfVXw64ImENb/Q450tERMbitHEGaZq9yuOgejX/omS8eL9ab/TYegmJrONxkM5YOdqol0hE5Lc4bZwP8jSoqjrVzHTb4+CwGt7J+RIRkX/XsQYKj4PqmeOq+NcZgyoRkW9jYDWIp0EVDZVC6/3SrUjHoEpE5PtMb7wUKDwNqmj9K0HXfvcUF1ySoqxTHud8iYjIWMyxGszdoGrf+hcKM9MrVpxMRESGYo7VB4NqcWG+FGb9JFphge2YwpxMCa9eUzVaqhZZR7UQdic9IiIyFgOrD+ZUc756V7I/fcPh+VlbXrKtR3d7UCJv/q17xclERGQoBlaDeFL8G9mpv1Rv1lEKz/8kQSFhElqnoUN9qxQXV6g4mYiIqh4Dq0E8CYLBah7VIAm7vmWFWhMzqBIRmYeNlwxSkUnKGVSJiKyHgdVgRgZVpEdERMZiYPXjoIr0iIjIWAysfhxUkR4RERmLgdUgZgRVpEdERMZiYDWIGUHVPj0iIjIGA6tBGFSJiAIDA6tRN5o5VSKigMDAajAji3+RHhERGYuB1Y+DKtIjIiJjMbD6cVBFekREZCwGVoOYEVTt0yMiImMwsBqEQZWIKDCYGlgLCwtl4sSJUrt2balTp45MmjRJioqKXB47atQoCQsLk8jISNvy2WefiVUwp0pEFBhMDazz5s2TPXv2SFpamhw6dEh2794t8+fPL/X4CRMmSF5enm35zW9+I1ZhRvEv0iMiogAKrGvWrJEZM2ZIbGysWqZPny6rV6/2StpXrlyRnJwch8UXGBlUkR4REQVIYM3KypKMjAzp1KmTbRvWT5w4IdnZ2S6fs379elVk3L59e3n++eeluLi41PQXLFgg0dHRtqVJkyYSaEEV6RERUYAEVhTlQkxMjG2bvp6bm1vi+MmTJ8vhw4clMzNT5WpffPFFtZRm2rRpKkDry8mTJyXQgirSIyKiAAmsaHwE9rlTfT0qKqrE8Z07d5Z69epJtWrV5Ne//rVMnTpV3nzzzVLTDw8Pl1q1ajksZjIjqNqnR0REfh5Y0RK4cePGkpqaatuGdRTZoui2PMHB1uopxKBKRBQYTI1Oo0ePluTkZDl9+rRa0CI4ISHB5bFvvfWWaoCkaZrs3btXFi5cKEOHDhWrYE6ViCgwhJh58qSkJDl37pzExcWpx/Hx8ZKYmKjWx48fr/6mpKSov8uWLZNx48apfq6NGjVSXW+eeuopsRoji3+RHhERGStIQxYwACC3iyLm7KlRUis8yPDzN8/faHhQRXqnNzxj4KskIvLzGJKdXW6bHWtVVFqYGUEV6RERkbEYWA1iRlBFekREZCwGVoOYEVTt0yMiImMwsBqEQZWIKDAwsBp1o5lTJSIKCAysBjOy+BfpERGRsRhY/TioIj0iIjIWA6sfB1WkR0RExmJgNYgZQdU+PSIiMgYDq0EYVImIAgMDq0GYUyUiCgwMrAYxo/gX6RERkQVmtzly5Ihs375dzpw5I8XFxQ77Zs6c6a1r80tGBlWkR0REPh5Y//rXv8of/vAHqVu3rjRo0ECCgq7NFIN1BlbfCapIj4iIfDywzps3T01O/qc//alqrshPmRFUkR4REfl4HWtWVpYMGzasaq7Gj5kRVO3TIyIiHw2sCKpbt26tmqvxYwyqRESBweOi4FatWklSUpJ8/vnncvPNN0toaKjD/smTJ3vz+vwGc6pERIEhSNM0zZMn3HBD6fV2aLz0ww8/iC/KycmR6OhoyZ4aJbXCrzW4Mkrz/I2GF/8ivRNLWGxPROS1GJKdLbVq1fJujvXYsWOVubaAZnRQRXpERGShASKQ2fUwwxuwzAiqSI+IiCwQWNevX6/qVyMiItTSoUMHee2117x/dX7EjKCK9IiIyMcD6+LFi9UAEXfffbe89dZbaunXr5+MHz9elixZ4vEFFBYWysSJE6V27dpSp04dmTRpkhQVFZX5nMuXL6tGVDExMWIVZgRV+/SIiMgYHtexLl26VFauXCmPPPKIbdvAgQOlffv2Mnv2bHniiSc8HnBiz549kpaWph73799f5s+fX+YITtjXrFkzOXv2rFgFgyoRUWDwOMd66tQpuf3220tsxzbs89SaNWtkxowZEhsbq5bp06fL6tWrSz1+3759smXLlnJHfrpy5YpqxWW/mIk5VSKiwOBxYEURLIp/nb355pvSunVrj0dxysjIkE6dOtm2Yf3EiROqSbMzFBGPHTtWli9fLmFhYWWmvWDBAtU0Wl+aNGkivsDI4l+kR0REPl4UPGfOHLn//vtl165d0q1bN7Xt008/lW3btrkMuGXJy8tTf+3rSvX13NxcFRDt/fnPf5ZbbrlFevbsKTt27Cgz7WnTpsmTTz5pe4wcq9nB1eigivSIiMjHA+vQoUPliy++UA2VNm/erLbFxcXJl19+qYKeJyIjI9Vf5E4xW46+DlFRUQ7HHj16VFJSUmT//v1upR0eHq4WX2FGUEV6RERkgflYu3TpIq+//nqlT46WwI0bN5bU1FRp2bKl2oZ15Cydc6to4PTzzz9LmzZtbK2JkatFQH7vvffktttuE19mRlC1T4+IiHwosKIYVR/CqbxGQOUN9eRs9OjRaho6vVgZLYITEhJKHDd8+HC58847bY8/++wzdRwCcf36vh9AGFSJiAJDiLs5S7T4RQBDHaj95OY6jMCE7VevXvXoAjCg/7lz51RxMsTHx0tiYqJaR99YQBFwjRo11KKrV6+eOh9yvFbAnCoRUWBwaxD+nTt3qhxlSEiIWi9Lr169xBf5yiD8Rk96nr5ooCGvj4jIn+V4exB++2CJ2W1QB+qca0V8PnnyZEWvOWAYGVSRHhER+Xg/VgTWzMzMEtvPnz9f5pRyZHxQRXpEROTjgVWvS3XVJ7V6dc6m4ktBFekREZGPdrfRB1tAUEWDI/uGRGiwhL6t9iMokSMzgqp9ekRE5GOBVR+YATnWgwcPOgwpiPWOHTvKlClTquYq/QCDKhFRYHA7sG7fvt3W7/TFF1/0uL9qoGNOlYgoMHhcx/rCCy+4nC8VjZfMnkHGCows/kV6RETk44H1gQcekE2bNpXYjgH4sY98J6giPSIi8vHAikZKffr0KbG9d+/eah/5TlBFekRE5OOBFROIuyoKxqD4ly9f9tZ1+R0zgirSIyIiHw+sXbt2lVdeeaXEdozni1lvyDUzgqp9ekRE5KPTxs2bN0/NMvPf//5X+vbtq7ZhkvOvvvpKtm7dWhXX6BcYVImIAoPHOVYMxo8p2zBeMBos/fOf/5RWrVrJgQMHpEePHlVzlX6AOVUiosBQoYnOMcLShg0bvH81AcDI4l+kR0REFgisuvz8fCkoKHDYxoEjfCeoIj0iIvLxouBLly7JxIkT1aTnNWvWVJOg2y/kO0EV6RERkY8H1qefflo++eQTWblypYSHh8uqVatkzpw50rBhQ1m/fn3VXKUfMCOo2qdHREQ+WhSMxkoIoBgQAuMGo8ESGi81a9ZM1buOGDGiaq7U4hhUiYgCg8c5VowJ3KJFC1t9Kh5D9+7dZdeuXd6/Qj/BnCoRUWDwOLAiqB479ssYtG3btlVdbvScbExMjPev0E+YUfyL9IiIyMcDK4p/MTgETJ06VZYvXy7Vq1eXJ554QtW/UtmMDKpIj4iIfLyOFQFUhxGYvv32W9m3b5+qZ+3QoYO3r8+vGB1UkR4REflwjhUD7WMYwyNHjti2odHSkCFDKhxUkSa676CrTp06dWTSpEkuB/kH7MOIT6jbbdSokTz++OMl+tH6KjOCKtIjIiIfDqyhoaFq6EJvwtjDe/bskbS0NDl06JDs3r1b5s+f7/LYCRMmqBwyJlRHcTSWRYsWiRWYEVTt0yMiIh+tY42Pj5fVq1d77QLWrFkjM2bMkNjYWLVMnz691PTj4uLUoBSgaZoEBwc75J6dp7dDALZfzMSgSkQUGDyuY0UxLYLhxx9/rKaJ0wOdbvHixW6nlZWVJRkZGWrsYR3WT5w4IdnZ2RIdHV3iOQsXLlS53IsXL8p1110nzz33nMu0FyxYoAau8BXMqRIRBQa3cqwo/i0uLlbrX3/9tXTu3FmioqLku+++k/3799uW1NRUj06el5en/tp309HXc3NzXT4HLZHxPBQdjx8/Xho0aODyuGnTpqngrC8nT54UX2Bk8S/SIyIiH8yx3nLLLXLq1Ck1PnB6erqaexW5xcqKjIxUfxH46tata1sHBO6yoFi4Y8eOMmrUKJV7dobhFrH4EqODKtIjIiIfzLEiF6kPCnH8+HFb7rWy0BK4cePGDjldrKPlr6tiYFctikurY/U1ZgRVpEdERD6YYx06dKj06tVLNS4KCgqSW2+9VapVu/blb++HH37weMCJ5ORkNYE6oEVwQkJCieNQ/Pv222/Lfffdp4IuiqRR13rXXXeJFZgRVJEeERH5YGB95ZVXVF/Vo0ePyuTJk2Xs2LHlFtW6KykpSc6dO6eKdvVWx4mJiWoddaiQkpKiAvrGjRtlypQpqsUviqUR8H2pgVJZzAiq9ukREZExgjT0W/Ewh/nSSy95LbAaBd1tkNPNnholtcKDDD9/0+xVpgTV4wsHGPYaiYj8lS2GZGerQYq82t1m7dq1lbm2gMWcKhFRYPB4gAiqHCOLf5EeEREZi4HVj4Mq0iMiImMxsPpxUEV6RERkLAZWg5gRVO3TIyIiYzCwGoRBlYgoMDCwGoQ5VSKiwMDAahAzin+RHhERGYuB1WBGBlWkR0RExmJg9eOgivSIiMhYDKx+HFSRHhERGYuB1SBmBFX79IiIyBgMrAZhUCUiCgwMrAZhTpWIKDAwsBrMyOJfpEdERMZiYPXjoIr0iIjIWAysfhxUkR4RERnL44nOqWLMCKpIj8jfnTp1Si2liY2NVQuRURhYDWJGULVPj8hfvfzyyzJnzpxS98+aNUtmz55t6DVRYGNgNQiDKlHVePTRR2XgwIFy+fJl6d69u9q2Z88eiYiIUOvMrZLRGFgNwpwqUdXQi3ovXrxo29apUyepWbMmbzmZgo2XDGZk8S/SIyKiAMuxFhYWyhNPPCEbNmyQoKAgGTFihCxZskRCQhwv7cqVKzJx4kT5+OOP5ezZs9KoUSN55plnZMyYMWIVRgdVpEdkRc2e+YfHn4+Q2tcaKMUlbcFOjz9vxxcOMOT1kX8zPcc6b948VR+SlpYmhw4dkt27d8v8+fNLHFdUVKSKexBYc3JyZN26dfLUU0/J1q1bxQrMCKpIj8iKKvT5CLP7fBRw/mIK4MC6Zs0amTFjhq2eZPr06bJ69eoSx6G+ZO7cudKyZUuVs/31r38tffr0UUHZFeRwEYDtFzOZEVTt0yOyoopOOFGYmc75iykwA2tWVpZkZGSohgY6rJ84cUKys7PLfG5+fr58+eWX0qFDB5f7FyxYINHR0balSZMmYiYGVSLPVGoWp5Bwzl9MgRlY8/Ly1N+YmBjbNn09Nze31OdpmiYJCQnSunVrGTJkiMtjpk2bpoKzvpw8eVLMxJwqkfsqVJJTcG1s7LB6zTh/MQVm46XIyEj1F4Gvbt26tnWIiooqNahOmDBBDh8+rOpbg4Nd/zYIDw9Xi68wo/gX6RFZUUU+Hyj+1XH+YgrYwFq7dm1p3LixpKamqrpTwDqKbVF86yqoPvbYY/LFF1/Itm3bXB7j64wMqkiPyIo8+XwUnv9R8k8eEs3u+QU//yBBoWFyNS9LtKsFEt6gtefFyURW7W4zevRoSU5Olm7duqnHaBGMYl5X0N3m008/lU8++UQFZasxOqgiPSIr8uTzkf3Z23Lx648dnv/zxmds61FdBkrNG7u5lR6RXwTWpKQkOXfunMTFxanH8fHxkpiYqNbHjx+v/qakpEh6erqsWLFCFe82a9bM9nwcj/2+zoygivSIrMydz0eNuJ4S1flulP/a9iGnejXvnFSLvE7CGrR0Oz0ivwisoaGhsnz5crU4sw+YCKYoCrYqM4Iqf4mTlbn7+Yho1LbE50MruCxhN3Tm/MUUmP1YAwWDKpH7OH8xWZnpOdZAwZwq+TNvz4nK+YvJyhhY/fyXOJEV50Tl/MVkZQysfl68RWTFOVE5fzFZGQOrQVhnRP7M23Oicv5isjIGVoOwzogsZ3YFBmApsGu5nxwrEhZUwZNvVP9y/mKyIrYKNgjrjIg8w/mLyaqYYzUI64zIn53KLZZTeZpcLryWY009fVUiQn/JscZGBklslPu/4zl/MVkZA6tBWGfkO105yPte3lcgc3YWOGzrvvZaq/RZvcJkdu/qbqfH+YvJyhhYDcY6I/O7cpD3PdolTAbeGFrqfuRYPcH5i8nKGFgNxDoj3+jKQd6HYt5Y1zM9VgjnLyYrY2A1COuMfKcrB/k+zl9MVsZWwQZhnRGR5zh/MVkRA6tBWGdE5BnOX0xWxcBqENYZEbmP8xeTlTGwGoR1RkTu4/zFZGUMrAZjnRFR+Th/MVkZA6uBWGdE5B7OX0xWxsBqENYZEXmO8xeTFTGwGoR1RkSe4fzFZFUMrAZhnRGR+zh/MVkZA6tBWGdE5D7OX0xWZnpgLSwslIkTJ0rt2rWlTp06MmnSJCkqKnJ57LJly+TWW2+V8PBwGTx4sFgR64yI3PicFOZzqkWyLNMD67x589SA6mlpaXLo0CHZvXu3zJ8/3+WxDRs2lBkzZsjYsWPFilhnROQezl9MVmb6IPxr1qyRJUuW2GYomT59ukyZMkVmzpxZ4tghQ4aov6mpqZKRkVFmuleuXFGLLicnR8zEOiNHDUYs8niYx/wfD9sexyVtkeCw6h5PcHB84QCxukCYn5bzF5OVmRpYs7KyVIDETCU6rJ84cUKys7MlOjq6wmkvWLCgzDk8jcY6o8qPnSxF134oVWbWIKsLpPlpOX8xWZGpgTUvL0/9jYmJsW3T13NzcysVWKdNmyZPPvmkQ461SZMmYhbWGVV+7OTQes0k0INqIM1Py/mLyapMDayRkZHqL3KndevWta1DVFTlZk1GAycsvoJ1RpUfO1mCrjUJKC64JEVZpzzO+fqDQJiflvMXk5WZGljRErhx48aqzrRly5ZqG9aRs6xMbtUXWb3OqKrq9dx5vdVqxkhh1k+iFRbY9l/67jMJDq8poXUaytVL2RISWcet9MgaOH8xWZnpjZdGjx4tycnJ0q1bN/UYLYITEhJcHotuOPpSXFws+fn5EhwcLGFhYWIVVq0z+stf/iKLFy8udT+K3Z9//nmP0nT39eZ89a5kf/qGw3OzPlppW4/u9qDEdB/hVnpkDZy/mKzM9MCalJQk586dk7i4OPU4Pj5eEhMT1fr48ePV35SUFFvXHPtGG6hT6tWrl+zYsUOswOfqjGZ7UCrw78vl7F8qMnuV28kVZb/g9uuN7NRfIlrdprYVnv9JgkLCVE5VLxquFlnH/eJksgTOX0xWFqRpmiYBAI2XULycPTVKaoUHGX7+ptmrTCneylg52iuB9VRusZzKK/2tEhsZJLFR7neLbvDdNFOGefSH7jY61LHq7RTQENDrdaye/PDysub5G02ZwCJ90UBDXh9ZOIZkZ0utWrV8O8caKKxeZ4SgGVu59mQOOHYyuYPzF5MVMbAaxMpBtSpw7GRHzae+5/H/b3HBtTrjFuNWSJBoHr9fyizRMBnnLyarMn1Iw0DBoOoax04W7/xoKrri/Tp4E3H+YrIy5lgNYkZO1df7bXLsZKnQ/29R3nm5mndeiguuNSjTRFNdkvTGXMGh1d1Kz1dx/mKyMgZWg7HOyD/GTkZ/a0waUZr27ds7DNVZHk9eb17qByW6H2W+dW1s7Vq3/V4iWv7K0tUFrIMnK2NgNRDrjHx87GQPWsE+vi5PdqYXl7q/V7Ng2THqlxa77ggKfdbt1xvZ4XcSUruRaEUFqtuR/Q8G3IOrl3MtHVSBdfBkZQysBmGdkX+NnfzCXdXl0NnSA2v7up41X/Dk9V69lCMhteqV+npDatW3dFC1xzp4siIGVoOwzsiRlYMqdIoNkU5eHOuedfAlsQ6erIqtgg3COiOnN56Fg2pVYh28f9TBU2BjYDUI64z8a+zkqsA6eB+vgydyEwOrwVhn5MNjJ5uIdfD+VQdPgY2B1UCsM7qG8206Yh28IwZVsjIGVoOwzsi/xk72NtbBO2JOlayMgdUgrDNyxKDqiHXwrrEOnqyIgdUgrDNyxJyqb7SG9WWsgyerYmA1COuMHLHfZkmsg7+GdfBkZQysRt1otm50if02f8E6eEesgycrY2A1GOuMrmG/zWtYB++IdfBkZQysBmKd0TXst+mIdfCOWAdPVsbAahDWGTliv01HrIN3xDp4sjIGVoOwzsgR+206fRBZB+8S6+DJihhYDcI6I0fst+ka6+CvYR08WZWpgbWwsFAmTpwotWvXljp16sikSZOkqKio0sf6ItYZucZ+m9ewDv4a1sGTlZkaWOfNmyd79uyRtLQ0OXTokOzevVvmz59f6WN9EeuMSmK/zWtYB++IdfBkZaZOdL5mzRpZsmSJxMb+MmP09OnTZcqUKTJz5sxKHQtXrlxRiy47O1v9zbmiiRn0UW6KcjKlKOeMhNSqL8HVI23bVZDJPCFaUb6E1W3m8Bz1pXs2XYJCqktodH3RCq+I/irKSy8np3fpF2XSvYCrl3Or5PWWl15OTo5P3o/8H7+pktdbXnq+ej+CI2oZ8vlwTq/M++GBAwcOyDfffFPq/ri4OOnQoYNXzuVL5/bFazrgpXPr7w1Nc+NzoZnk/PnzuDrtyJEjtm3fffed2nbhwoUKH6ubNWuW2s+F94DvAb4H+B7ge0C8dA9OnjxZbnwzLceal5en/sbExNi26eu5ubkSHR1doWN106ZNkyeffNL2uLi4WM6fPy/XXXedBAUFiZHwS6dJkyZy8uRJqVWrlgQ63g/eD74/+Hmx2ncHcqqINw0bNiz3WNMCa2RkpK2Itm7durZ1iIqKqvCxuvDwcLXYsw/MZsAbgYGV94PvD35e+P1hze9SV5k4n2q8hNa9jRs3ltTUVNs2rOPXiPPFe3IsERFRwLYKHj16tCQnJ8vp06fVgla+CQkJlT6WiIgoIFsFJyUlyblz51SrLIiPj5fExES1Pn78ePU3JSWl3GN9HYqkZ82aVaJoOlDxfvB+8P3Bz4s/f3cEoQWT2RdBRETkLzikIRERkRcxsBIREXkRAysREZEXBVRg3bRpkwwfPrzU/Whp/OCDD7qd3ueffy7t2rVTfWlfeukl8TXHjx+Xtm3bOgztCM2bN5eIiAi54447JFCgY3fLli3l7NmzHj/XiverMq+3onzhPm3YsEFGjBghvsboe3P16lW5+eabyxzKz+qvPzIyUg4ePOj28ePGjVMTuDRo0KDqPx9agLh69ap2ww03aAcOHPBamn379tXmzp1bqTTGjh2rtWnTRgsKCtKWLFlSYn9aWpp2++23axEREVrr1q21v//97x7tHzVqlPbCCy84bGvWrJn27rvvlnldP/30k3bvvfdqsbGxahiv/fv3lzgGabRq1Uqdu1u3bto333zj0X5PzZgxQ7vpppu0atWqaX/84x9L7P/xxx+1/v37azVq1NCaNGmivfLKKw77Z8+erT3++OMen9eo++Xt+1HR11tR3rpP5SnrPuJzjn3/+c9/NF/i6t4UFBRojz32mBYTE6PVrl1bmzhxolZYWOh2mkuXLtW6dOmihYWFaYMGDSqxf926ddrgwYM1X339S8u5fm/avXu3usf2Q+BW5ecjYHKs77//vvq1gl9x3nLs2LFKp9exY0dZsWKFdO3a1eVUeffee6/07dtXDce4ePFieeihh+To0aNu7YeRI0fKsmXLPL6u4OBg6devn2zevNnl/sOHD6ucASZGwLnxS3TQoEG2qfzK218RrVq1kkWLFsnAgQNd7kdpA36NnjlzRt5++215+umnZefOnQ73Yu3atXLp0i8DsXtTZe9XVdyPqny9VXWfylPefUT62I/PlK+r7IxdGFpvxowZMnbsWJf7f//738u2bdvkxIkT4osalnP93oTv6qZNmzoMKFSlnw8tQCBn+PTTT5d5DAbut//lhNuzcuVKrX379lpUVJT6pa3/4rn++utVLrN69epazZo1tcOHD1fq+nr16lUix/rxxx+rX7P4Zau7++67tZkzZ7q1H7AP14icrSc5C3uuchbILQ0YMMDhPLiWTz75xK39lTFy5MgSObSjR49qwcHB2unTp23bJkyYoD3yyCMOx7Vo0UJ7//33PTqfEffL2/ejMq+3orxxn8rjzn3ctWuX+nz6Elf3pnHjxtrbb79te/zWW29pTZs29Tht5+8te3fccYe2YsUKzWzNynhvlHX97r5/kMY999yjSgCio6NVidWmTZvUvhdffFELDw9X3w/4rsbnpao/HwGTY8UQiKhv9NRbb70ln3zyifrVl5GRoX4pA0Z/wi+gN954Q00S0KZNmyqZ7qh9+/YSGhpq29apUye13Z39gH3I2dgPB+mta8O57M+D+mb7aytrv7chXUwpeP3115d6LwDX4O174e71GXk/zH69Zt5HPP7555/l1KlT4quysrLU94n9a8E6vmf0cdC9wd/+/8vy4YcfSs+ePdVAQigNwMh8qEudPHmyGmgIpYv4rl63bl2V35+ACax4I1dk0OZnnnlG6tevrwbwHzp0qOzbt0+MgjeB88QBeIw3izv7dXjdeP2+eG1GXU9V3gt3GH0/zH69Zt5H/XPuy6+7vBm7vMXf/v/L0rlzZ9U4tVq1avLwww9LQUGBfPfdd6bcn4AJrBjI334SY9RloFUZlv79+5f6PNTZ6WrWrFnhNz1+iernw+JOvQeOc/71isf6jD7l7dfhdeP1l9WSUr8u5IDd4a1rKyt9fUHdU2Wvx9174Y6quF/evh/efL1G3idv3Ef9c27W63aH/YxduvJm7KoIM///jWb/XY2pQdEKubzv66q6PwETWFHM8u2339oeY5xh/GrE8sEHH1T5+VFsrJ8PCx6XB7Pao1EDGinpUGyhN5gqbz9gHxoz2Rc5OUNjD/26kJ47cG77IhScB40w7K+trP3lsb9XPXr0cOt6fvrpJ9VwqbR7AbiGsu6FO6rifnn7fnjz9Rp5n7xxH/EYVQKoGvBVRs3YZeb/vxVU1f0JmMCK1rPbt2+v0nPs2LHD40nUUVyRn5+vJmJHy0as6y0cUV+AlsyY1Qd9UdGyGed45JFH3NoP//73v6VRo0a2yQs8gWvB4nyd+iQIqHvGOXFuXAPmysU1ubMffWxxr/DXXfgSxTWgjx4WrOs/KtAnrVu3buoHE1r5ffnllyrH9D//8z+256enp6t+a/o1eFtl7pe374cRr7cq7lN596G8+wjYP2DAAPF15c3YNXv2bOndu3epz7f/vsD9wzrupw6fg6+++kruvvtu8UVF5Vz/qFGj1FJVqvTzoQWIoqIirXnz5trBgwc9ahVs32oRrXbRere0lm6vvvqq6lPqCaSH89gvuA7doUOHVJpo2Yv+eZs3b3Z4fnn7x4wZoy1evLhCrTedrwvL9u3bbfvfeecddU6cG9fg3C+zrP07d+5U12Hfork8aM3nfD32LfwyMjK0fv36qX6saHHp3I8VfY4nT56secqI+1UV96Oir7eivHGf3LkPZd1H9GNFf+59+/ZpVujHipbraNWMxbkf6+jRo7XExMRS08T3hPN9tP9+Wr9+vTZw4EDNV1//rHKuv0+fPiU+w2W1CnZuWYzWwfr7au3atVrHjh0d9lfl5yNgAits3LhRGz58eJWlj8EYtmzZovmK48ePa23bttXy8/MdtmNACnQfuvPOO027NnTOTklJMex8OTk5WsuWLbUzZ854/Fwj7pe370dlXm9FeeM+VfY+bNiwQXvooYc0X1ORe4PBP86ePVuh8+EHxs0336x+eFvx9efn56vnePJD05c+H5w2joiIyIsCpo6ViIjICAysREREXsTASkRE5EUMrERERF7EwEpERORFDKxERERexMBKRETkRQysREREXsTAShTgMjMz5Q9/+IOaGCI8PFzNEnLXXXfJp59+avalEVlSiNkXQETmwjzDGPz81VdflRYtWqhJwrdt26YmjCYiz3FIQ6IAduHCBTWFGWZF6tWrl9mXQ+QXWBRMFMD0icg3b96spmEjospjYCUKYCEhIbJu3TpVDBwTE2Ob0/bAgQNmXxqRZbEomIjUJNO7d++Wzz//XD744AM1UfyqVauqdKJpIn/FwEpEJSQkJMhHH30k6enpvDtEHmJRMBGV0K5dO7l48SLvDFEFsLsNUQBDl5phw4bJmDFjpEOHDhIVFSV79+6VRYsWyaBBg8y+PCJLYmAlCmBoEXzbbbfJkiVL5Pvvv5fCwkJp0qSJjB07VjViIiLPsY6ViIjIi1jHSkRE5EUMrERERF7EwEpERORFDKxERERexMBKRETkRQysREREXsTASkRE5EUMrERERF7EwEpERORFDKxERERexMBKREQk3vN/YJXLfkk8ip0AAAAASUVORK5CYII="" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 14 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": [ + ""We see that assuming mutations are partly recessive leads to a more deleterious inferred DFE since stronger selection is necessary to remove a similar amount of recessive mutations.\n"", + ""\n"", + ""We can also let `h` vary when inferring the DFE (cf. the {doc}`simulation guide <../Python/simulation>`)."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""## Folded inference\n"", + ""To infer the DFE from a folded SFS, simply pass folded spectra to {class}`~fastdfe.base_inference.BaseInference`. Folded inference is performed whenever the spectra are folded, i.e., when all entries where the derived allele is the major allele are zero. Folded spectra contain little information on beneficial mutations so we only infer the deleterious part of the DFE here."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:32:05.127421Z"", + ""start_time"": ""2026-01-04T10:31:54.770854Z"" + } + }, + ""source"": [ + ""import matplotlib.pyplot as plt\n"", + ""import numpy as np\n"", + ""\n"", + ""# create inference object\n"", + ""inf = fd.BaseInference(\n"", + "" sfs_neut=sfs_neut.fold(),\n"", + "" sfs_sel=sfs_sel.fold()\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""inf.run()\n"", + ""\n"", + ""# plot the inferred DFE and the SFS comparison\n"", + ""ax1, ax2 = plt.subplots(ncols=2, figsize=(7, 3.2))[1]\n"", + ""\n"", + ""inf.plot_discretized(ax=ax1, show=False, intervals=np.array([-np.inf, -100, -10, -1, 0]))\n"", + ""inf.plot_sfs_comparison(ax=ax2, show=False)\n"", + ""\n"", + ""plt.tight_layout()\n"", + ""plt.show()"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:01<00:00, 8.07it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 25.12it/s]\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1.558e+04 ± 1.2, all.b: 0.1464 ± 1.4e-06, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -21.58 ± 1.6e-09} (best_run ± std_across_runs)\u001B[0m\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:06<00:00, 14.61it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -3.681e+04 ± 3.9e+04, all.b: 0.1487 ± 0.027, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -25.07 ± 4.2, i_best_run: 0.51 ± 0.5, likelihoods_std: 0.001907 ± 0.013} (mean ± std)\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAArIAAAE2CAYAAACdsHHTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAS5xJREFUeJzt3Ql4E+X2P/DTQimUQtmxUBZZBWQTfqKALIKsgggCslx2BNlELnplKfuiIiICCnoBr8oiehVQZBVU4CIKsgmKoGxVoAgFWpaW0vk/33P/k5ukaZu2aZJpv5/nGZpkJpnJlL45eee85w0wDMMQIiIiIiKLCfT1ARARERERZQQDWSIiIiKyJAayRERERGRJDGSJiIiIyJIYyBIRERGRJTGQJSIiIiJLYiBLRERERJbEQJaIiIiILImBLBERERFZEgNZyrApU6ZIQECAw2Ply5eXfv36Weqsnj59Wt/He++959X94jzhfBERkXdY8TOKUsdAlnKMlStXyhtvvCFW06xZMw20sQQGBkrBggWlatWq8re//U22bt2aYmNtPsd5uX37tm6DwD2lbbB89913Xn6nRNnXkSNH5KmnnpJy5cpJ3rx5pXTp0vLYY4/JggUL0v23C59//rk0bdpUSpQoISEhIVKhQgXp1q2bbNq0yQfvjsh3cvtw35QNHT9+XIMtfw1kf/rpJxk9erTD4/hguXXrlgQFBYm/ioiIkNmzZ+vtGzduyMmTJ+XTTz+VDz/8UD+88NP5+OvUqSN///vfk71Wnjx5HO5PmzZN7r333mTbVapUyePvgygn+s9//iPNmzeXsmXLyuDBg+Wee+6Rc+fO6ZfF+fPny8iRI9P1t/vaa6/JCy+8oIHsuHHjNJBFm7Bt2zZZvXq1tGnTxmvvzWr8+TOKMoaBLHlUcHCw184oArr8+fNn+nXQ04EeEn8WFhYmvXv3dnjs5ZdfllGjRslbb72lvTivvPKKw3r0+Dg/x5W2bdtK/fr1PX7MRPRfM2fO1L/hH374QQoVKuRwWqKjo5OdptT+dhMTE2X69Onam7tly5Zk6129Xk5nGIb2ZufLl8+rn1HkHfxaQm7ZtWuX/N///Z8GfBUrVpQlS5a4lX90584dmTp1qlSuXFmfW7RoUWncuHGyS+K//PKL9iwWL15cGxtcOp8wYUKyfNxjx45Jz549pXDhwvo6JvRI1qtXT59bpEgRefrpp7XHw/7y/IYNG+TMmTO2y3RmfqpzjuzXX3+d4qU955zWjRs3yiOPPKIBdYECBaR9+/Zy9OjRZOdl7dq1cv/99+s5wM/PPvss0//zcuXKJW+++aZUr15dFi5cKNeuXcv0axKR5/32229So0aNZEEsIDUgPf766y+5fv26NGrUyOV6d18PbeaDDz6ovbloT5s0aZIsMMaXZBw3gr9SpUrJ8OHD5erVqw7boG1Fm3b48GHtIcbr4WrOJ598ouu/+eYbadCgga1dR6+xPbNtNz8DkDqFz4nnnnvOIZUCli9fLo8++qi+RxwT2r6333472XtDO/3444/L5s2b9Us69m1+ZmX0M2r79u22th6/xyeeeEJ+/vlnl+8FvePYB7bDF5j+/fvLzZs33fq9UPqxR5bcyu1q1aqVBpn4Q0WPwOTJk6VkyZJpPhfb45L4oEGDtNFEA7xv3z758ccftUcB0ACigcCl8WeeeUYbGjT8yAFDT4a9rl27aoMza9Ys/ZYN2CYyMlIbQezn0qVLmneGhvnAgQPamCAoRqAXFRUl8+bN0+eFhoa6POZq1arJBx984PAYGu8xY8Y4fEhgm759+0rr1q21NxQNFRpVNILYrxn04sOhS5cu2ujiXFy+fFkbNqQLeCKY7dGjh75/fNlAIG3fQONDzx4+ZLDYw3lx3g6NMRp0Iso8pC/t2bNHU5sQ9KUltb9dtEEIzNA+IiUBX9zTC4Eb2uaGDRtqahFSFvbu3avBGtp6wHps17JlS3n22Wf1kjzaN/Qq79692yGVKSYmRgNHdCCgjcZ2uL1ixQpN5Ro6dKh2QMyZM0fzhNHJgC/+9tB+o81EG4mUC3xJx+u+//77tm3wugisO3bsKLlz59ZzMGzYMElKStIg2x6OF23jkCFDNJ0DQXRGP6MQfOPKFfKQsT1S0fAZgy8T2M65gwPvBelaeF2s/+c//6m/N+erZuQhBlEaOnXqZOTNm9c4c+aM7bFjx44ZuXLlQiTpsG25cuWMvn372u7Xrl3baN++faqv36RJE6NAgQIOrw9JSUm225MnT9Z99ejRw2Gb06dP63HMnDnT4fEjR44YuXPndngcx4Hjc3bq1Cl97eXLl7s8PhzH448/boSGhhpHjx7Vx2JjY41ChQoZgwcPdtj2woULRlhYmMPjderUMcLDw42rV6/aHtuyZYvu09XxOGvatKlRo0aNFNd/9tln+lrz58+3PYbXxWPOC86jCe/X1TZYgoOD0zwuInIP/t7RTmF5+OGHjRdffNHYvHmzkZCQkGxbd/52J02apI/lz5/faNu2rbZz+/fvd+tYTpw4YQQGBhpPPvmkcffuXZdtbnR0tJEnTx6jVatWDtssXLhQ97ts2TKH9gmPrVy50vbYL7/8oo9hP999953tcbxn57bWbNs7duzocCzDhg3Txw8dOmR77ObNm8neT+vWrY0KFSq4PIebNm1Ktn1GPqPQhpcoUcK4fPmy7TEcF95fnz59kr2XAQMGODwf57po0aKp7oMyjqkFlKq7d+/q5ZlOnTrpQAX7Xkv0RKYFvaG41H7ixAmX69F7+u2338qAAQMcXh+cS3sBvtnbw4AnfBvHN2D0YJgLBlOg53bHjh2Z/g0jH+2LL77Q1AP0qgIuO6GXFt/47feLHlJcRjP3e/78eTl48KD23OISkwnf9M3XyiyzZzk2NtbhcRwHjtN+6dOnT7LnL1q0KNl2SJkgIs/A3zt6ZNGTeOjQIXn11Ve1/UQu7Pr165Ntn9bfLnpKMXi1bt262j7jihNSqx544IFkl7tdpTmhzZw0aVKyQU9mm4seyISEBO1Ntd8GPZu49I80Lec2CD2wJvR+ou3H5wTei/37gt9//z3ZcTn3qJoD4L788kvbY+iJdr6ShHQGvJ5zahV6RD3xGWW24UgVsO/9rlWrlv5e7Y8vpc8pXHHElTj09pLnMbWAUoVAE5dREBQ6Q2Pl6o/YHi5bIZeoSpUqekkNo2lRNgqNgH2D5s7lNnAeXY/GBykGro4PMluJAKVs8KGBkcFID7DfLyBfyxU09oCcXEjp/OGyU2bFxcXpT+dLdcWKFdPLgmnB5TQO9iLKWhhjgC/eCBARzCJPHmlOuNSOQMn+i607f7v4Eo0FwRHSAvBFG8Fthw4dNIUhpQGsSNtCcJraF2mz3XK+HI8UBFxeN9ebkCbl3PGAL+5lypRJ9hggZcCZcxuJsRg4ToxhMCGlAWlt+FLgnHOKQNa+s8BVJZaMfEaldC4AgTq+SDgPPHbulEEOsvm+zc8G8hwGspSlkKeKhnPdunWaK4pcITTeixcv1pyk9LL/Rg7oWUADih5E9IY6SykP1h2nTp2SXr166bfuGTNmJNuvmSeL3l9nyN/yFnxoActlEfk/BIMIarEgeEK+/Mcff6wBWkYgMEIbhQVf3P/1r39pYIueSm9x1fam9rg5viE1zoExPkdatGgh9913n7z++usaJONcojMFnylmm5zSZ4W3PqMy+74p/RjIUqrMKgKuLrsgmd4duByDxhoLeg/RcCBhHo0Evt3bB2PphW/taBzw7RsfCqlxlaqQEvRCd+7cWS87rVq1KtklOOwXkMCfWs8JBnlAZs5fWqkf6IXBIBD7Kg5E5P/MKyG4fO2p10Mgm9rroe1C0IcKMKhXm1q7hTbKbKMBvcn4gu/OlZ70Qhtp34uKkf84TnMgFQZ2xcfHayqGfY+nJ9LHUvuMsj8XzlBpAb3nnigDSRnHHFlK85sl8oyQV3X27Fnb48jDwiWVtCAvyLmHFD2HaJDMQBmNxrJlyxxe391vrwg2cYy4/O+8Pe7b7x+NjbslqpDj9Ouvv+rlP/OykD2cE/SEoHoCRhi7SsmA8PBw/bDAh4v9vpHzhg+SzAaxqCOL3wV+8pIVkX9CsOWqPTNTs1IaUe8KLqnj0rorZm57aq+H8Q74Yo5L6s69mOYxIlBFbycqB9gf99KlS7Uds6+O4inI1bdnzniGagH2vZz2x4NjQUmuzEjrM8q+DbcvPYbOF/TgtmvXLlP7p8xjjyylCUEickWRsI5SJyi/hUYGZVBQOis1yMNCnUEMRMC3XpQ1QX3BESNG2LZBY4neRAxUQPktfCtHXhQGFCB3LDXoXcBlf+Sw4jlopJEril4DBKF4vbFjx+q2OIaPPvpIy2jhsh4aLOSTOcN+UfIFObF4f/bvEc/BPhA0ohQMcqlw3BjogKAcwTiej7IsqO0KKMGChh/vEYParly5Yjt/Zn5rWtBgo+6j+UFmzuyFS2LYNwakZRQ+/NCz4Ayleex7Y4goYzBwCX+3Tz75pF4aR88mZvtCe4QeR/QEuguvg7/Nhx56SPM5cYkdARY6G3bu3KntEwaBpQRBGgaHoc1Am47OANRkRVkt1IpFe4W2DG0q2n7sA4PU0COJurJoO92ZaCW90GZjP9gfAnW0dyjZVbt2bV2PsmAIrtFmo6QW2s53331Xr4plpkfbnc8olA1DQP3www/LwIEDbeW3kJOLnlvysUxUPKAc5JtvvjHq1aunJVlQ6mTx4sW2UiOplTaZMWOG8eCDD2qpqnz58hn33XeflopxLjvz008/aYkSbIdSX1WrVjUiIyNt6819Xbp0yeXx/fvf/zYaN26s5WiwYD/Dhw83jh8/btsmLi7O6Nmzp+7DvvSVc/mt1MpSOZfL2rFjh5Z/QcktHHfFihWNfv36Gfv27Ut2fNWqVdOyVtWrVzc+/fRTPU/ult+yPwaUAatcubLRu3dvLevjCl43rZIyqb3P1MqREVH6bNy4UUsyoV3C3y/a0UqVKhkjR440Ll68mK6/3Tt37hjvvvuulkXEtmhTQkJCjLp16xpz5swx4uPj3TomlNDCc/D8woULazuzdetWh21QbgvHHBQUZJQsWdJ49tlnjZiYGLfKA6b0PtC2oG12bttR0vGpp57SUow4nhEjRhi3bt1yeO769euNWrVqaVtbvnx545VXXtH3geejHXfnHGb0M2rbtm1Go0aNdJuCBQsaHTp00GO2l9LnlNnW2h8jeU4A/vF1ME1EREQ5jznxAtKxkG9KlF7MkSUiIiIiS2IgS0RERESWxECWiIiIiCyJObJEREREZEnskSUiIiIiS2IgS0RERESWlGMmRMAMJn/++acWy0/PVKVERO5CNcPY2FgtLO88rXF2wbaUiPypLc0xgSyCWMyAQkSU1c6dOycRERHZ8kSzLSUif2pLc0wgi55Y86RwTnoiygrXr1/XL8xme5MdsS0lIn9qS3NMIGumEyCIZSBLRN5ob7IjtqVE5E9tafZM4iIiIiKibI+BLBERERFZUo5JLSAiIiJy1927d+XOnTs8YVkoKChIcuXKlanXYCBLREREZCcuLk6ioqK0DBRlbQ4sqhKEhoZm+DUYyBIRERHZ9cQiiA0JCZHixYtn68GbvoQvCZcuXdJzXbly5Qz3zDKQJSIiIvr/kE6AIAtBbL58+XheshDO8enTp/WcZzSQ5WAvIiIiIifsibXGOWaPrAedP39el8wKDw/XhYiIiCglX3/9tYwePVoOHjzo1ydp4cKFsm/fPnnvvfc8/toMZD1oyZIlMnXq1Ey/zuTJk2XKlCkeOSYioqxw/+TNEhgckq7nnH65PX8ZZEnlX9qQJa/rz38TiYmJkju3/4eJ/n+EFjJkyBDp2LGjy3W3bt2Sxo0b6+1du3almnfD3lgiypamhGXwedc8fSRElrN582YZN26cBpiFCxeWt99+Wx/H/T59+siPP/4owcHBsnTpUqlTp46cOHFC+vXrpxUYkpKS5IknnpAZM2ZoPmpkZKRs375dEhISpEqVKtoRh9fE9oGBgXLy5EmJjo6Wv/3tb3qlGT2qgNcqW7asHD9+XPNbX3vtNVmzZo0eQ4kSJfR1ypUrJ7GxsTJo0CDtKcZ2NWrUyLLzwkDWg1JLCbhx44btNv6D5c+f35O7JiIiomwKQWXPnj01laBmzZqyYsUKeeqpp2TRokVy9OhRmT9/vrz//vsaVD799NPy888/a/D5+OOPa/ALV65c0Z9z5szRGOT777/X+9OnT5eJEyfqa8H+/fu1w61AgQJy7tw5qVevnsydO1eD5I8//liaN2+uwenKlSs1oN2zZ48O1Prggw9k2LBhsmHDBpk2bZpu/8svv8j169floYcekgYNGmTJueFgLyIiP4MPoPr16+sHQadOnVxuc/HiRSlSpIh+Mbb3559/Srt27fSDCj0n7777brrWE5H/2bt3rwawWKBXr176t/zHH39I+fLlpUWLFvp4t27d5MKFCxqANmnSRP++J0yYIFu2bJFChQrpNmvXrpUPP/xQ2w4sq1atklOnTtn21bVrVw1ioUyZMlK3bl1Zv3693keOa//+/W2vs23bNg108TqvvvqqnD17Vtd99dVXMnDgQB3MFRYWpkF4VmGPLBGRnylVqpT2kOBDAjUWXRkxYoR+wFy+fNnh8R49ekjFihW1B+enn36S1q1b66XDpk2burWeiKwtICBAly5dukjDhg1l69at+uX4jTfekC+//FJLiy1YsEBatWrl8vnOkxMMGDBAli9frgErUg7atGmjj+N10Nv7zDPPuHVMWYU9skREfqZz587aE1usWDGX69etW6eXCZG/Zu+3337TS4KzZ8/WHldcykPPzbJly9xaT0T+CZfmjxw5ol8+YfXq1VK6dGldUId1x44d+vgnn3wiJUuW1NmykCOL28ifRW/pd999p9ugbZk3b57cvHlT7+Mn0hNSgu1/+OEHbTd69+5tGwCGxxcvXmxLWUDu7YEDB/R2y5YtNfhFsIvUAvT6ZhX2yBIRWci1a9dkzJgxsmnTJtm9e7fDusOHD2uePj68TLjk99Zbb7m13pX4+HhdTPhQIiLvQk4q8mIRlJqDvZCvGh0drQOpcMl/1KhRkidPHg0a0QOKoBYpBHgMg70QdMI//vEP/ZvGF1mzpxSPpTQgCylOSFlAO4HcWxO+BOOKEHJmAceF3ltcKcJgMgz2uu+++/TYMdjdvh3xJAayREQW8uKLL+rIYkzp6BzIYkSxmQdnwn2MIHZnvSvohfFEWUEiK/OHMlm4pG9e1jdVr17d1kvrDJf9zYFe9tCjisFYWJylVOcVA8HMwWD2EDxjcYYc248++ki8gakFREQWsXPnTg1e0XuSUm4bemzt4b45cCOt9a7ggxDbmAsGkRAR+Qv2yBIRWQRGAv/+++86GAxwqQ41qpFLi/y5WrVq6UhmXG5ETUdAHUdzpHNa61O6rIiFiMgfsUeWiMjPINfs9u3b+hO5bbiNwuXIjf311181+MSCS4NVq1bV2whMUY2gUaNGMn78eB3AgTqRyKtDGRxIaz0RkdX4vEcWo9yef/55bUyRdIzkYYymS2laNNQymzRpko7GQ20y3B46dGiWTqvoCUkJt223q0VuksA8eSWn5vkQUeow+459XipmAkR5LBRDL1iwoO1xDPgICgrSEcomDPTAIAsMsECdWYxWti+tldZ6IiIrye0PDTbKwRw7dkzvt23bVmbNmqUBqjOM0sWsERiF98gjj+joWRQFJyLKTqZMmaJLWjDoC4s9lOPZuHFjis9Jaz0RkZX4PLUA9QtR+Nuc3hUzUGCeYFdQzgEBbrNmzXQ6NPRGoLQDEREREeU8Pg1kY2JidNYa+ykWcRtTnDmPrL1x44bO/4vp2DALzT333KPTqJ0/f97la2MQBHps7RciIiIiyj58mlqAmoZgX9fQvI26hsiBtQ96MUME5vbFdGtFixbV3FjMMoGRvM5Y+5CIiIg8Ysr/4hGPmuLYaedNX3zxhbz22muae58a1JZF7IUF244ePVoHmKYHat0+/vjjOgtZtuqRNefzte99NW871zU0t0Xh3XLlyul9DIbAtGzorXXG2odERERE2ZtPA1nkuGK0rX1kj9tlypRx6I01e2rLli3r8nXQU+sMdQ8xutd+ISIiIrIaVHWaOXOmTitbvnx57R3Flef69evrLH/2vaoffPCB1ozG0r59e03JNKtEYcA8tn/wwQe1I9AenofXf+CBB6RJkyZy6NChNI9r8+bNOv1svXr1kr0mBqxiX1i3evVqybaDvfr376+/nAsXLuiCigUoDePKM888IwsWLNBfCoqAo4ZiixYtbL21RERERNkRYp29e/fqgHikVWKA/L59+zRueuGFF2yX8HEblUkOHz4sDRs2tMVU77zzjhw/flyOHj2q1aJ+/PFH22tjxkCU5vv222/1ccRlPXv2TPV4MDkLgtUvv/xSxzCtXLlSn4MxShs2bJCPP/5YH8cxZkVKgd+U30IlgsuXL0u1atX0Pn45KNYNZn3YxYsX68+XXnpJrly5IrVr19b7zZs3128QRERERNlZ9+7d9Sd6YZFS+fTTT+t99ISitj6gR7RNmzZaZg/QA4tOv7t37+p4oj59+kiePHl03YABA2xVotatW6c9sOiRNSHeQqdhSlAS9eTJk9p7awoMDNQB+9hXt27dbFfDhwwZosFztgxkUcx70aJFujgzA1gTSm7NnTtXFyIiIqKcIm/evLZYyPl+YmJiiikJKbFfhxTNvn37au+uu/Ccxx57THti05LacVg+tYCIiIiIMq958+baU/rnn3/aOgSRgolgt2XLljqhFHJlMeX18uXLbc/r2LGjrkNvKmBqbKQEpKZ169aybds2TWEwYdprwL6QWoAKVAh4kdaQVXzeI0tEREREmXf//ffLnDlzNL0AMHj+3Xff1duDBw/WHNrq1avrYHvMkIocVsBtTFf95JNPau8uAl0MFEMaQ0oqVaqkvbFIG7h586Y+p27duvpYu3btNKjFwDGkF2DW1qwSYLga8p8NYUIEVEIoM3qNBAaHeH3/SQm35dy8p/R2mec/kcA8/70k4G2nX27vk/0S5aR2BmUEs2ullMy0pafzpj54xB9rbVLOc/v2bTl16pTce++9tsv35N1znZ62lKkFRERERGRJDGSJiIiIyJIYyBIRERGRJTGQJSIiInKSQ4YQWf4cs2oBERERkV19e9Q9vXTpkhQvXjxLa6Dm9CD20qVLen5xzjOKgSwRERHR/4eaqxERERIVFZWlU6uSaBCLc21O8pARDGQ9KDHuityNu+JynXEnwXY74eLvEhD03yniXMkVWkRyhxbx5KERERGRm0JDQ6Vy5co6eQBlHfTEZiaIBQayHhR3cKNc270qze0urnwx1fVhjXpIoca9PHhkRERElB4IsDIbZFHWYyDrQaF12kq+Sg0y/TrokSUiIiKi1LFqgQchHSD4nkqZXphWQJSzLVy4UKeGDA4Olk6dOtkej46Oll69emlOGWa7wXSQ69evd3gu5ljH9JD58+eXsmXL2qandHc9EZGVsEeWiMjPlCpVSiZOnCjbtm3TASemuLg4DV5feeUV3WbDhg3y9NNPyw8//KDzp0OPHj2kYsWKGvRiXvXWrVtLlSpVpGnTpm6tJyKyEvbIEhH5mc6dO2tPbLFixRwer1ChgowdO1Z7ZAMDA6VDhw5StWpV+e6773T9b7/9Jrt27ZLZs2drj2uDBg20B3fZsmVurScishoGskREFoVe1Z9//llq1aql9w8fPizh4eFSsmRJ2zZ16tTRx91Z70p8fLxcv37dYSEi8hcMZImILCghIUHTCrp166b5tGbqQaFChRy2w/3Y2Fi31ruC3tuwsDDbUqZMmSx5P0REGcFAlojIgkHsU089JSEhIQ6DtVD78tq1aw7b4n6BAgXcWu/KuHHjdBtzOXfunMffDxFRRnGwFxGRxYLYrl276s9169ZJnjz/m1wFKQaoSoCUgxIlSuhjBw8elJo1a7q13hVUTsBCROSP2CNLRORnEhMT5fbt2/ozKSlJbyNwxSxDSCW4ceOGrF27NlmAiWoEjRo1kvHjx8vNmzfl+++/lxUrVsjAgQPdWk9EZDUMZImI/MyMGTMkX758MnPmTPn888/1dqtWreQ///mP9sLu3r1bKxogVQDLrFmzbM9dtWqV/PHHH1K8eHHp0qWLvPrqqw6ltdJaT0RkJUwtICLyM1OmTNHFFcMwUn1u6dKlZePGjRleT0RkJeyRJSIiIiJL8mkgi3yvESNGSOHChaVIkSIycuRIzQlzpV+/fjqowbyUhmXPnj1eP2YiIiIi8g+Bvs4Dwywzx44dk6NHj8rOnTsdcr2cDRs2TOsgmsvDDz/s1eMlIiIiIv/h00AW0yJiPnHMNINlwoQJsnTpUl8eEhERERFZhM8C2ZiYGImKitLpEU24ffbs2WQFu03vv/++piDUqFFD5s6dq2VpUsJpFYmIiIiyN58FskgNAPvpEs3brqZLHDVqlBw/flwuXbqkvbbz58/XJSWcVpGIiIgoe/NZIIvBWmDf+2redjVd4gMPPKB1D3PlyiUPPfSQvPTSS/LRRx+l+PqcVpGIiIgoe/NZHVlUKoiIiNDpETHbDOB2mTJlJCwsLM3nBwamHoNzWkUiIiKi7M2ng7369++vM9dcuHBBF1QsGDRokMtt16xZI9evX9di4Pv27ZOXX35ZZ6UhIiIiopzJpzN7RUZGyuXLl6VatWp6v3fv3joHOAwdOlR/Ll68WH8uXLhQnnnmGa0zi5lpUIrr73//uw+PnoiIiIhybCAbFBQkixYt0sWZGcCavv32Wy8eGRERERH5O05RS0RERESWxECWiIiIiCyJgSwRERERWRIDWSIiIiKyJAayRERERGRJDGSJiIiIyJIYyBIRERGRJTGQJSIiIiJLYiBLRORnMJNh/fr1JTg4WDp16uSwDlN19+zZUwoWLCglS5aU6dOne3Q9EZGV+HRmLyIiSq5UqVIyceJE2bZtm0RFRTmsGzlypFy5ckXOnj0r0dHR0rJlSylXrpz06dPHI+uJiKyEgSwRkZ/p3Lmz/jx48KBDIHvz5k1ZvXq17N69WwoVKqQLAtOlS5dqIJrZ9UREVsPUAiIiizh+/LgkJCRInTp1bI/h9uHDhz2y3pX4+HhNR7BfiIj8BQNZIiKLiIuLk/z580vu3P+7mIZe1djYWI+sd2X27NkSFhZmW8qUKZNF746IKP0YyBIRWURoaKimByQmJtoeu3btmhQoUMAj610ZN26cbmMu586dy6J3R0SUfgxkiYgsomrVqhIUFCSHDh2yPYY82po1a3pkvSuonIAKB/YLEZG/YCBLRORn0GN6+/Zt/ZmUlKS3kdsaEhIi3bt3l8jISO0dPXHihCxYsEAGDRqkz8vseiIiq2EgS0TkZ2bMmCH58uWTmTNnyueff663W7VqZasxi1zViIgIadSokQwcONCh4kBm1xMRWUmAYRiG5AAYaasDFUavkcDgEMmpTr/c3teHQJTt2xn0dmbXS/CZaUtP5+2ZsZ1OuZax5xFRtm9L2SNLRERERJbEQJaIiIiILImBLBERERFZEgNZIiIiIrIkBrJEREREZEk+D2Tv3LkjI0aMkMKFC0uRIkVk5MiRDrPOuHLr1i2pVKmSTq1IRERERDnT/ybcTgcU0d6xY4dER0drsW57kyZNSne9xF27dsmxY8f0ftu2bWXWrFmpvg7WlStXTv7666+MHD4RERER5cRA9t1335Vnn31WihUrJvfcc48EBATY1uF2egPZZcuWybx58yQ8PFzvT5gwQcaOHZvi6+zfv182bdokc+fOlW7duqX38ImIiIgopway6EHFbDP/+Mc/Mr3zmJgYiYqKkjp16tgew+2zZ89qEVwUw7WHlIPBgwfLokWLkvUEO4uPj9fFvrguEREREeXgHFkEn127dvXIzuPi4vSnfa6reTs2NjbZ9nPmzJG6detKkyZN0nzt2bNnayBsLmXKlPHIMRMRERGRRQNZBLFbtmzxyM5DQ0P1J3pfTebtAgUKOGx78uRJWbx4sQaz7hg3bpy+lrmcO3fOI8dMRERERBZNLUC1gMjISPnuu++kZs2aEhQU5LB+1KhRbr8WKhVERETIwYMHpWLFivoYbqP31DmtAAPCLl68KFWqVLFVO0CvLXJ1N2zYIA0aNHDYPjg4WBciIiIiyp7SHci+88472pP6zTff6GIPg73SE8hC//79Nee2UaNGeh8VCwYNGpRsOwzsatmype3+nj17dDsEviVKlEjv2yAiIiKinBbInjp1yqMHgN7dy5cvS7Vq1fR+7969Zfz48Xp76NCh+hMpBSEhIbqYihcvroEzenSJiIiIKOfJUB1Zk2EY+tO+BFd6ITUBVQiwOEMAm5JmzZrJ1atXM7xfIiIiIsqBM3u9//77mh+bL18+XWrVqiUffPCB54+OiIiIiMhTPbKvv/66pgNgWlkzrxUDsZAGgJm2nn/++fS+JBERERFR1geyCxYskLffflv69Olje6xjx45So0YNmTJlCgNZIiIiIvLP1ILz589Lw4YNkz2Ox7COiIiIiMgvA1nUkV2zZk2yxz/66COpXLmyp46LiIiIiMizgezUqVNl0qRJ0qZNG5k+fbouuI3Hp02blt6XIyKidPrjjz+kU6dOUrRoUZ0UBnW2L126ZJssBmMYMOFMkSJFZOTIkZKYmGh7blrriYiydSDbpUsX2bt3rzaea9eu1QW3v//+e3nyySez5iiJiMhm+PDh+vPMmTNa2/v27du2yWhmzJihA3CPHTsmR48elZ07d+pEM6a01hMRZfvyW/Xq1ZMPP/xQ9u/frwtu161b1/NHR0REyfz+++/aC4tZFgsUKCDdu3eXI0eO6Lply5bJxIkTJTw8XJcJEybI0qVLbc9Naz0RUbarWnD9+nUpWLCg7XZqzO2IiChrjBkzRj7++GNp3769TkyzatUq6dChg8TExEhUVJTUqVPHti1unz17Vq5duyZJSUmprg8LC0u2r/j4eF1MaX0GEBH5XY8scqmio6P1dqFChfS+82I+TkREWQs1vNEmm3muCGDHjRsncXFxtnbaZN6OjY1Nc70rs2fP1gDXXMqUKZOl742IyOM9stu3b9fGEnbs2JGuHRARkeegV/Wxxx7T1IKtW7fqY6jh3apVK9m4caPeR+8qxi6YtwEpCHhuautdQYCMHmD7HlkGs0RkqUC2adOmttv33nuvNmIBAQEO2+Dy1rlz5zx/hEREZHPlyhUd5IXBXSEhIfoYKg/MmTNH7t69KxEREXLw4EGpWLGirsNttNlm2kBa650FBwfrQkSULQZ7IZA1y7w4N65YR0REWQc9qajnvWjRIq1WgAW3EaBiXf/+/WXmzJly4cIFXVCRYNCgQbbnp7WeiChbT1GLnlfn3lhA7lXevHk9dVxERJSCdevW6XTgpUuX1nQBVI1Zv369rouMjJTLly9LtWrV9H7v3r1l/PjxtuemtZ6IKFsGsmaOFIJYNITmJS3A5SzUlrUfCUtERFmjevXqsnnzZpfrgoKCtIcWS0bWExFly0D2wIEDth5Z1CvMkyePbR1u165dW8aOHZs1R0lERERElNFA1qxWgPyq+fPns14sEREREVlrsNcbb7zhcl5uDPZioWwiIiIi8ttA9umnn5bVq1cne3zNmjW6joiIiIjILwNZDOpq3rx5ssebNWum64iIiIiI/DKQxZzbrlIL7ty5I7du3fLUcREREREReTaQffDBB+Wdd95J9vjixYulXr166X05IiIiIiLvTIgwY8YMadmypRw6dEhatGihj3311Vfyww8/yJYtWzJ2FEREREREWd0j26hRI9mzZ4/OzY0BXp9//rlOl3j48GF55JFH0vtyRERERETeCWQBM3itWLFCjh49Kvv27ZNly5ZJ5cqVM3QAyK0dMWKEFC5cWIoUKSIjR450mYMLWIcAumDBgjo14+jRoyUhISFD+yUiIiKiHBjImm7fvq21Y+2XjKQq7Nq1S44dO6aB8c6dO2XWrFkutx02bJj88ssvuh+kNmB59dVXM/MWiIiIiCinBLI3b97UHtQSJUpI/vz5tSfVfkkv9OZOnDhRwsPDdZkwYYIsXbrU5bbVqlXTfZpT5QYGBsqJEyfSvU8iIiIiyoGB7AsvvCDbt2+Xt99+W4KDg+Wf//ynTJ06VUqVKiXvv/9+ul4rJiZGoqKiNFXBhNtnz56Va9euuXzOyy+/LKGhoRpIo0cW6QYplQnLbG8xEREREWWjQBaDu9566y3p0qWL5M6dWwd4oUcV6QDIm02PuLg4/VmoUCHbY+bt2NhYl8956aWX9HlIRRg6dKjcc889LrebPXu2hIWF2Rbk1hIRERFRDg5kr1y5IhUqVNDbGHSF+9C4cWP59ttv0/Va6FkF+95X83aBAgVSfS7SDGrXri39+vVzuX7cuHH6WuZy7ty5dB0bEREREWWzQBZB7KlTp/T2fffdpyW4zJ5a+55VdyCnNiIiQg4ePGh7DLfRe4peVHcqHqSUI4u0BwTa9gsRERER5eBAtn///pqbal7mX7RokeTNm1eef/55zZ/NyOvNnDlTLly4oAtSFAYNGpRsO6QTLF++XK5evaoDvY4cOaIVD1q3bp3ufRIRERFRDpzZCwGrCTN8oRzW/v37dVKEWrVqpfsAIiMj5fLly5oqAL1795bx48frbeTAmtPfBgQEyMqVK2Xs2LE6kAuDvZCni4FmRERERJTzpCuQxaX8Nm3aaGBpToBQrlw5XTIqKChIe3WxOMN+TCi7tXXr1gzvh4iIiIhycGoBgk5MRUtEREREZLkcWVz6T2nCAiIi8o7169dr3W1crUIdb/MKFmpm9+zZUwe4lixZUqZPn+7wvLTWExFl6xzZxMREnY1r27ZtUq9ePdtMW6bXX3/dk8dHRERONm3apFN2f/jhh1rLG8HpxYsXdR0miUFZREwsEx0drWMZkP7Vp08ft9Zna1PCMvg81xP0EJFFAlmkE9x///06JexPP/0kDzzwgD7+66+/OmyHAVlERJS1MEh20qRJ0qxZM71vThGOKcRXr14tu3fv1nKIWBC44ioaAtW01hMRZctAtm7dunL+/HmtFHDmzBn54YcfpGjRoll/dERE5ODGjRtaKaZdu3ZSpUoV7Y1Fr+ybb76pJQwTEhKSTfuNsoZw/PjxVNe7gioxWEyc7puILJcji2/t5iQIp0+flqSkpKw+LiIiciEmJkZraa9du1YruZw8eVIngMH4BdTbRroXpg+3b7/NKb/TWu8Kp/smIsv3yKJea9OmTSU8PFzTB+rXry+5cuVyue3vv//u6WMkIiKnqb1HjRplK32IetooiTht2jRNH8BYBjNYxRTd5pTfeG5q61Oa7nvMmDEOPbKYfdGXyr+0IUPPO53X44dCRFYIZN955x3p3LmzfvNH4zl48OBUGz4iIsoa6EEtW7asy3U1a9bUMomYfRGDcc1pv/E4VK1aNdX1rqC3FwsRkaWrFmAiBEBu1nPPPcdAlojIR5555hlZsGCBtstFihTRntgWLVpoSa3u3bvrYLBVq1ZpVQJsZ5bYCgkJSXU9EVG2ryO7fPlyBrFERD700ksvaeBau3ZtvcyPdIEPPvhA1y1cuFDCwsIkIiJCGjVqJAMHDnSoSJDWeiKibF1HloiIfAtjFObOnauLM/TKorc1JWmtJyLK1j2yRERERET+gIEsEREREVkSA1kiIiIisiQGskRERERkSQxkiYiIiMiSGMgSERERkSUxkCUiIiIiS2IgS0RERESWxECWiIiIiCyJgSwRERERWRKnqCUiyzh//rwumRUeHq4LERFZGwNZIrKMJUuWyNSpUzP9OpMnT5YpU6Z45JiIiCgHB7J37tyR559/XlasWCEBAQHSq1cvmTdvnuTO7Xho8fHxMmLECNm2bZv89ddfUrp0aXnxxRdlwIABPjt2IvKuIUOGSMeOHV2uu3XrljRu3Fhv79q1S/Lly5fi67A3logoe/B5IDtjxgz90Dl27Jjeb9u2rcyaNUsmTZrksF1iYqJ++CCQrVChguzdu1e3jYiIkFatWvno6InIm1JLCbhx44btdp06dSR//vxePDIiIsqRg72WLVsmEydOtH1ATZgwQZYuXZpsO3woTZs2TSpWrKg9tw899JA0b95cg2AiIiIiynl8GsjGxMRIVFSU9p6YcPvs2bNy7dq1VJ97+/Zt+f7776VWrVou1yMV4fr16w4LEREREWUfPg1k4+Li9GehQoVsj5m3Y2NjU3yeYRgyaNAgqVy5snTu3NnlNrNnz5awsDDbUqZMGY8fPxERERHl0BzZ0NBQ/Yne12LFitluQ4ECBVIMYocNGybHjx/XfNnAQNex+Lhx42TMmDG2++iRZTBLlLXKv7TBZ6c4KeG27Xa1yE0SmCev948h/qbX90lElJP5NJAtXLiwDtY6ePCg5r4CbiPgRC+qqyB2+PDhOtDrq6++crmNKTg4WBciIiIiyp58Ptirf//+MnPmTLlw4YIuqFiAtAFXUH5r9+7dsnXrVg2CiYhyMpQcq1SpkkN6Fq4+9ezZUwoWLCglS5aU6dOnOzwnrfVERFbi8/JbkZGRcvnyZalWrZre7927t4wfP15vDx06VH8uXrxYzpw5I2+99Zb2spYrV872fGyP9UREOQ3KFKI9RG1t08iRI+XKlSs6aDY6Olpatmyp2/Tp08et9UREVuLzQDYoKEgWLVqkizP7ABUNLVILiIhIZP/+/bJp0yaZO3eudOvWTU/JzZs3ZfXq1XrlCr20WBC4oqQhAtW01hMRWY3PA1kiInclxl2Ru3FXXK4z7iTYbidc/F0CgvKk+Dq5QotI7tAilj3xmCBm8ODB2gGQlJRkexyDYBMSEpKVNETKljvrUypliMXEUoZE5E8YyBKRZcQd3CjXdq9Kc7uLK19MdX1Yox5SqHEvsao5c+ZI3bp1pUmTJvL11187lDTE5DH2U3yj19UsZ5jW+pRKGU6dOjXL3gsRUWYwkCUiywit01byVWqQ6ddBj6xVnTx5UtOuDhw44LKkIdIH0GNrBqsoaWiWM0xrvSssZUhE/oyBLBFZRm6LpwR4AqblvnjxolSpUkXv37lzR3tUUYv73//+t447OHTokNSrV89W0rBmzZp6u2rVqqmud4WlDInInzGQJa85f/68LpkVHh6uC1FOhIFdqDRg2rNnj5YsREBaokQJ6d69u1aDWbVqlVYlWLBgga3EVkhISKrriYishoEsec2SJUs8kms3efJkmTJlikeOichqEIxiMRUvXlwCAgJ0chlYuHChDBkyRO/ny5dP62/bVyRIaz0RkZUwkCWvwYdnx44dUyzs3rhxY9ulU3zApoS9sUT/06xZM7l69artPiY6QG9rStJaT0RkJQxkyWtSSwm4ceOGQzkgjKwmIiIiSg0DWSIiIjeVf2lDhs/V6Zfb8zwTeVigp1+QiIiIiMgbGMgSERERkSUxkCUiIiIiS2KOLBERkTdMCcvg8655+kiIsg32yBIRERGRJTGQJSIiIiJLYiBLRERERJbEQJaIiIiILImBLBERERFZEgNZIiIiIrIklt8iIiLK5lPkcnpcyq4YyBIREWV3Ga1hq89lHVvyX0wtICIiIiJLYiBLRERERJbk89SCO3fuyPPPPy8rVqyQgIAA6dWrl8ybN09y505+aAsXLpT33ntPjhw5Im3btpW1a9f65Jizs4zmX2VWUsJt2+1qkZskME9e8RXmkhEREVmDzwPZGTNmyK5du+TYsWN6HwHqrFmzZNKkScm2LVWqlEycOFG2bdsmUVFRPjhaoqxz/vx5XTIrPDxcFyIiouzO54HssmXLtAfW/OCdMGGCjB071mUg27lzZ/158OBBBrKU7SxZskSmTp2a6deZPHmyTJkyxSPHRERE5M98GsjGxMRoQFqnTh3bY7h99uxZuXbtmoSFZXyUZXx8vC6m69evZ/p4ibLSkCFDpGPHji7X3bp1Sxo3bqy3cQUjX758Kb4Oe2OJiCin8GkgGxcXpz8LFSpke8y8HRsbm6lAdvbs2R7p3SLyltRSAm7cuOHwZS9//vz8xeRQ+II+YsQITbH666+/pHTp0vLiiy/KgAEDbF/ahw4dKl988YV+4cG2kZGRtuentZ6IyEp8GsiGhobqT/S+FitWzHYbChQokKnXHjdunIwZM8ah8S5TpkymXpOIyNcSExP1Cw8C2QoVKsjevXt1bEFERIS0atVKRo4cKVeuXNErW9HR0dKyZUspV66c9OnTR5+f1noiIivxafmtwoULa+OLnFcTbiPgzExvLAQHB0vBggUdFiIiq0Nv/LRp06RixYpa6eWhhx6S5s2ba8rJzZs3ZfXq1TqIFle3qlSpooHr0qVL9blprScishqf15Ht37+/zJw5Uy5cuKALKhYMGjQoxZ6I27dv68+kpCS9nZCQ4PVjJiLyF2gHv//+e6lVq5YcP35c20TncQeHDx/W22mtTymVAVe07BciIn/h86oFyM26fPmyVKtWTe/37t1bxo8fr7eRxwWLFy/Wn+hFsM97RX5X06ZN5euvv/bJsVP6JMZdkbtxV1yuM+787wtJwsXfJSAoT4qvkyu0iOQOLcLTTzmeYRj6xb9y5cpa1WX37t3aY2tfhxs9rxhzYI5LSG29KxxvQET+zOeBbFBQkCxatEgXZ2YAa0JJIZYVsq64gxvl2u5VaW53ceWLqa4Pa9RDCjXu5cEjI7JmEDts2DDtZUW+bGBgoI47QPoArlqZwSrGHZhjDtJa7wrHGxCRP/N5IEs5R2idtpKvUoNMvw56ZIlyehA7fPhwHej11Vdf2cYUVK1aVTsHDh06JPXq1bONO6hZs6Zb61Mab4CFiMgfMZAl7/1nywYpAZzCl1P4+gOUzEIawfbt23XQrCkkJES6d++uKVurVq3SqgQLFiyQ6dOnu7WeiMhqfD7Yi4iI3HfmzBl56623NKUAZbOQLoDFHFOwcOFC7aFFRZhGjRrJwIEDHUprpbWeiMhK2CNLRGQhCF6RWpASlBpEb2tG1xMRWQl7ZImIiIjIktgjS+QnWJ6MiIgofRjIEvkJlicjIiJKHwayRH6C5cmIiIjSh4EskZ/IDuXJiIiIvImDvYiIiIjIkhjIEhEREZElMbWAiIiIstaUsAw+75qnj4SyGQayRERElKXTdJ/OyxNMWYOpBURERERkSQxkiYiIiMiSGMgSERERkSUxkCUiIiIiS2IgS0RERESWxECWiIiIiCyJgSwRERERWRIDWSIiIiKyJAayRERERGRJDGSJiIiIyJIYyBIRERGRJfk0kL1z546MGDFCChcuLEWKFJGRI0dKYmJiprclIiLPtL1ERP7Mp4HsjBkzZNeuXXLs2DE5evSo7Ny5U2bNmpXpbYmIyDNtLxGRP/NpILts2TKZOHGihIeH6zJhwgRZunRpprclIiLPtL1ERP4st692HBMTI1FRUVKnTh3bY7h99uxZuXbtmoSFhWVoW1N8fLwuJmwHSfE3JSe7fv16qutz+vlJ6xzx/PD8pMb8/2EYhvir9LannmxLrwdk8Lw4/U1m9O/QE/vPTBvgy/1neN++3n8an1mUvT+H3WpLDR85e/Ysjs64dOmS7bHo6Gh97Ny5cxne1jR58mRdz4XngP8H+H/A2/8HUmqX/EF621O2pfz7YRvK/wPix21pAP4RH/UKYJDByZMnpWLFivoYbleuXFmuXr2arEfW3W1T6kVISkqSK1euSNGiRSUgIEB89Q2jTJkycu7cOSlYsKBPjsGf8fzw/Fj9/xCa09jYWClVqpQEBvpnUZj0tqeeakt9/bvJyfvPye/d1/vPye89M/tPT1vqs9QCjJaNiIiQgwcP2hpT3MYbdm5I07OtKTg4WBd7hQoVEn+AXyYDWZ4f/v/Jnn9jKbVJ/iK97amn21Jft385ef85+b37ev85+b1ndP/utqU+7TLo37+/zJw5Uy5cuKALRs0OGjQo09sSEZFn2l4iIn/msx5ZiIyMlMuXL0u1atX0fu/evWX8+PF6e+jQofpz8eLFaW5LRESeaXuJiKzEp4FsUFCQLFq0SBdnZgDrzrZWgctzkydPTnaZjnh++P+Hf2Pe5Iv21NftX07ef05+777ef05+797av88GexERERERZYZ/DqslIiIiIkoDA1kiIiIisqQcGciuXr1aunXrluJ6jODt0aOH26/33XffSfXq1aVAgQLy5ptvir85ffq03HfffQ61IFNSvnx5yZcvnzz66KOSU6BWHcoQ/fXXX5l+LSueP0++f6ufuxUrVkivXr18tn8iIkqfHBfIopg3Rudi1G5KsH7VqlVuvybmLEfgi4Bg1KhRGTquZ555RqpWraqFf994441k63/++Wdp1KiRhISESJUqVWT9+vVur0eA8PDDDycbQJcSvPft27enuP78+fPSsWNHLVSMguioQels7dq1WmAdx9O4cWP55Zdf0rU+vfD7rFmzpuTOnVtGjx6dbP2ff/4p7dq1k/z580vZsmXl3Xffta3DF5A+ffpoOSJP8Mb58+T58fT79/W5S0tq5xZ/x99//70cOHAgw++Bklu4cKHUr19fB3x06tTJq6cIX+AHDx4s9957r/5fx5f6ZcuWefUYRo4cqXV6UUezdOnS+jeYkJDg1WO4deuWVKpUyav11Pv16yd58uSR0NBQ27Jnzx7xNnweYhpmtP9oO9z9LMwM+/eMBQMsa9WqJd70xx9/6N8bJi8pVqyYduBdunTJa/v/7bffpG3btlq7Gv/vX3311SzZT44LZL/88kud1QYf6p5y6tSpTL9e7dq15a233pIHH3ww2bo7d+5Ihw4dpEWLFjqjzuuvvy49e/bU2XjcWQ99+/bVDxNPQLDdpk0bDQhcOX78uPZqzZs3T48HPWxPPPGEJCYmurU+I9BA448EQY4rCFDuueceiY6Olo8//lheeOEF+eabbxzOz/Lly+XmzYzPo+6t85cV58eb7z8rz11a0jq3eH2sx98ieQ6CB3zhR0DpbfjdhoeHy7Zt23SWoffee0/+/ve/y5YtW7x2DMOGDdMvTNj/oUOHdMmqD/WUTJo0ScqVKyfehvceFxdnW9Cp4k2bNm3SY0AHEc7/0aNHpVmzZlm+X/v3jAWl7p5++mnxpuHDh+vPM2fOaJxy+/btDHe2pdfdu3f18+aBBx7Qz110UCAGWblyped3ZuQwgwcPNl544YVUt8Hc4k888YTtPk7T22+/bdSoUcMoUKCA0aFDB+Pq1au6rmTJkkZAQICRN29eI3/+/Mbx48czdXxNmzY15s2b5/DYtm3bjEKFChkJCQm2x9q1a2dMmjTJrfWAdTjGY8eOpbr/cuXKGZ999pnbx4tzc+DAAYfHJk6caLRv395h3zi+7du3u7U+M/r27Ws899xzDo+dPHnSCAwMNC5cuGB7bNiwYUafPn0ctqtQoYLx5ZdfZmr/3jh/nj4/nnz/vj53aXHn3H777bf6d02e59y2+sqTTz5pREZG+mTf0dHRxqOPPpqs/clK+/btM+6//35j8+bNRlhYmNf2m1p74y3169c3lixZ4tNj2Lt3r5ErVy7jjz/+8Op+a9asaaxYscJ2/8MPP9Q4xhuOHj2q7zk+Pt722JQpUzTG8bQc1yOLS5G4tJRea9as0W8UZ8+elaioKO3RAcyKg0vVuCSKb124rO9phw8flho1auilCRMuk+Bxd9YD1qFXLiOXYjNyvNi//b6RQ2x/vKmtz4rjQY9MyZIlUzw/gGPwxvlJi7fPj7+9f1+fW9y/ePGipjFQ9oNeKaSPePsy78svv6yXmEuUKKE9skg38FaPNHrCUTMYl/m97f3339eroPiMmjt3rqb3ecuNGzdk//79eokdn824Kte1a1ev/20vXbpUL7HjyoQ3jRkzRq9AXrt2Ta5evapxCq7eeoP5e7av8IrHsuJzLMcFsjExMRmab/jFF1/UBgj5RV26dNE/Dm9BgOyc14T7yMl1Z70J7xvv3yrH663j8fb5SYu3z4+/vX9fn1uzfcju5yInwocqpuJFjnTnzp29uu+XXnpJ//8dO3ZMZ65EUOUNc+bMkbp160qTJk3E23AZG+k8yMtEMDd//nxdvAV/w/idIxVp69atmm6HPG3MZOfNYBoDzH0xBXSjRo30sj5yVPFlAudj3LhxXtk3xvxgfA5SWpCnjpQO5KYjvcPTclwgi1+o/YlEhQIzGRvfmFJi3+ggYTyjQQV6dO0TwHE/LdgO36js4T4GLriz3oT3jfef3lHc5rHiG7U7PHW8qb2+uezcuTPTx5OZ8+OL8+fp85OV79/b584T59ZsH/zpXFDmIaBBriQCKwQ2yIf2BeRKYkwEBkJlNQRuGNiEYNYXkB9ZvHhxyZUrlzz00EMazH/00Ude2z/+3s2AGvnBuD916lTZsWOHBpjegB5RDCxt3769eFNSUpI89thjGsyaebq43apVK6/sH1e71q1bpwNnMdALYw/69++vA888LccFsrisaD9KGRUKzF/yxo0bs3z/SEOwTwDH/bTgEhi+zWBQlwmXgM0BZmmtB6xDo2Z/WdUd+M9nHiv24Q4cj/0lauwbvRD2x5va+rTYn79HHnnEreNB1QJ8M03p/ACOIb3nxxfnz9PnJyvfv7fPnSfOLe4jDQXpKJR9glgMfNm7d68O8goLC/Pp8eD/3YkTJ7J8P7t27dI0GVxWx6h1DGzEFzXcxrnwNm9/ecDVlpQ+Y701qek///lPHUyLijHedOXKFR3khSAegTQWpLPg9+6tUovogMDfG/aHdhc9s02bNvX4fnJcIIv8EHwby0pff/21lgZKD5RiQe4WvkUhpwm3zZHUuCSEywIoj4T/CKi8gH2gZJI76+E///mPfitCb4An4PiwOB874LIN8olxHDgeHBcaTvPSVlrrUfcW5w8/0/PBgGPASEksuG0G9qiRim+i+NKCUfnIj0Nv38CBA23Pxx88/ti8dfktM+fP0+fHF+8/q85dWucmrXMLWO/t3pPszr5Nw+8Kt71ZfmrEiBGye/duvbzs7Z52fBFDRRDkKCJ4OnLkiMyYMUNat26d5ftGuSV0YCCIwIKgClcfcBvpBlkNY0sQOON979u3T/OEkZrnTShtuWDBAs2TRQmyadOmaYUfs7c2K6H3H5+99p813lKsWDEdF4PcaLPNxO2IiAhd5w3Ih0XPN/7WP/30U00tQPUSjzNymMTERKN8+fLGkSNH0lW1wH50NKoK2I+8cx5t/a9//cto2LBhuo4Lr4f92C84DvsRgHhNVB6oVKmSsXbtWofnp7V+wIABxuuvv+6xkePOx4plx44dtvWffvqpHgeOB8f1888/Ozw/tfXffPONHod9FQZ3Rsc6Hw8eM0VFRRlt2rQxQkJCjIiICOOdd95xeP60adOMUaNGGZnljfOXFefHU+/f1+fOnXOT2rm9e/euUblyZWP//v0eelcEaMucf2dZMXrZldOnT+v+goODtbKMuQwZMsQr+4+LizNatmxpFClSRPd77733GmPHjjVu3LhheBv+TrxZteCRRx7R/eF9V6lSxXjllVf0b8zbn/ljxowxihYtqstTTz1lnD9/3iv7RoWkJk2aGL5y9OhRo1WrVvp/D9VZmjdvbvz4449e2/+ECRN03/jcffjhh41du3ZlyX4C8I/kMBi5hxyprMrVQR4I6sV54xu3O9Dbhtqb+BaORPe0ErQxorNBgwbae+ELyGFCTvKQIUO8sj/kO6N3AoW6kc+VGd44f54+P558/74+d5k9N6hxuGHDBu2xJyIi/5cjA1kiIiIisr4clyNLRERERNkDA1kiIiIisiQGskRERERkSQxkiYiIiMiSGMgSERERkSUxkCUiIiIiS2IgS0RERESWxECWiIgom0KpeEzTimnMMX0zJsYhyk4YyBK5cOnSJXn22WelbNmyOhsaZovCTG2Yr52IyCo2bdok7733nnzxxRc6c97999/v60Mi8qjcnn05ouyhS5cukpCQIP/617+kQoUKcvHiRfnqq6/k8uXLvj40IiK3/fbbbxIeHi4NGzZ0uR7tXJ48eXhGybLYI0vk5OrVq7Jz50555ZVXpHnz5lKuXDl58MEHZdy4cdKxY0eeLyKyhH79+snIkSPl7NmzmlZQvnx5adasmYwYMUJGjx4txYoV0ytN8NNPP0nbtm0lNDRUSpYsKX/729/kr7/+sr3WjRs3pE+fProegfHcuXP1tfA6Juxj7dq1DsdQqFAh7RE2nTt3Trp166aPI93hiSeekNOnTzscc6dOneS1117T/RQtWlSGDx8ud+7csW0THx8v//jHP6RMmTJ6xaxSpUqydOlSTaPAbTzXHtIpcGwnT5708Bkmf8BAlsgJGmosaJDRYBIRWdH8+fNl2rRpEhERoWkFP/zwgz6OK03ohUWq1OLFi/XL+6OPPip169aVffv2aToCrkIh4DS98MIL8s0338i6detky5Yt8vXXX8uPP/6YruNBMIrAuUCBAtpZgP2jrW3Tpo32DJt27NihPcn4iWNFIGwfDCOgXrVqlbz55pvy888/y5IlS/R1EKwOGDBAli9f7rBf3G/SpIkGuZQNGUSUzCeffGIULlzYyJs3r9GwYUNj3LhxxqFDh3imiMhS5s2bZ5QrV852v2nTpkbdunUdtpk+fbrRqlUrh8fOnTtnIEQ4fvy4ERsba+TJk8dYs2aNbf3ly5eNfPnyGc8995ztMWz/2WefObxOWFiYsXz5cr39wQcfGFWrVjWSkpJs6+Pj4/V1Nm/erPf79u2rx5uYmGjbpmvXrkb37t31No4H+9m6davL9/vHH38YuXLlMvbu3av3ExISjGLFihnvvfdeus4bWQd7ZIlSyJH9888/Zf369dpbgN6HBx54wKFXgIjIiurVq+dw/9ChQ9r7aV6NwnLffffpOvSMYkGPaYMGDWzPQVpA1apV07Vf7AeX99Eja+4Hr3P79m3dh6lGjRqSK1cu232kGERHR9vSBLCuadOmLvdRqlQpad++vSxbtkzvf/7553plrWvXruk6VrIODvYiSkHevHnlscce0yUyMlIGDRokkydP1hwuIiKryp8/v8P9uLg46dChg44LcIYg0t3cUlza/2/H7P/Y57ZiPwiiV6xYkey5xYsXt90OCgpK9rpJSUl6O1++fGkeB9pq5PjOmzdP0wq6d+8uISEhbr0Hsh4GskRuql69erKBDEREVoerTf/+9791MFju3MnDgooVK2pwuXfvXi1JCDExMfLrr7869IwiGEUurunEiRNy8+ZNh/189NFHUqJECSlYsGCGjrVmzZoa1CJft2XLli63adeunQbrb7/9tub7fvvttxnaF1kDUwuInKDEFgY+fPjhh3L48GE5deqUfPzxx/Lqq6/qCFsiouwEVQGuXLkiPXr00AFhuMy/efNm6d+/v9y9e1dTAAYOHKgDvrZv364VDnBlKjDQMYRAu7lw4UI5cOCADhobOnSoQ+9qr169tFIC2lEM9kLbirStUaNGSVRUlFvHimC7b9++OqgLHQvma6xZs8a2DVIPcHyoNFO5cmV5+OGHPXi2yN8wkCVygkYbuWC4LIWRriggjtSCwYMHayNNRJSdIK8UFQQQtLZq1Up7PVFWCyWyzGB1zpw58sgjj2gKAnpCGzdunCzXFiW5UBIL2/Xs2VPGjh3rcEkft9E7il7dzp07S7Vq1TRARo5senpo0dP61FNPybBhwzSXF20zyoPZw+sirxfBOGVvARjx5euDICIiImtBHdk6derIG2+8If4GPb4tWrTQurWoi0vZF3NkiYiIKFtAhQJMMT5lyhStVMAgNvtjagERERFlC5goAbMxYpIHjGug7I+pBURERERkSeyRJSIiIiJLYiBLRERERJbEQJaIiIiILImBLBERERFZEgNZIiIiIrIkBrJEREREZEkMZImIiIjIkhjIEhEREZElMZAlIiIiIrGi/wcJgCpI2Mb2hAAAAABJRU5ErkJggg=="" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 15 + }, + { + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""cell_type"": ""markdown"", + ""source"": [ + ""## Serialization\n"", + ""Inference objects can be serialized to JSON files for later use (cf. {func}`~fastdfe.base_inference.BaseInference.to_file`)."" + ] + }, + { + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:32:05.192135Z"", + ""start_time"": ""2026-01-04T10:32:05.141253Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""# save the inference object to a file\n"", + ""# we can unserialized the inference by using BaseInference.from_file\n"", + ""inf.to_file(\""out/serialized.json\"")\n"", + ""\n"", + ""# we can also save a short summary to fa ile\n"", + ""inf.get_summary().to_file(\""out/summary.json\"")"" + ], + ""outputs"": [], + ""execution_count"": 16 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""## Joint inference\n"", + ""fastDFE supports joint inference of several SFS types, where any parameters can be shared between types. In this example, we create a {class}`~fastdfe.joint_inference.JointInference` object with two types, where we share ``eps``, the rate of ancestral misidentification and ``S_d``, the mean selection coefficient for deleterious mutations (cf. {class}`~fastdfe.parametrization.GammaExpParametrization`). For more complex stratifications, see the {class}`~fastdfe.parser.Parser`) module."" + ] + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:32:48.702624Z"", + ""start_time"": ""2026-01-04T10:32:05.197541Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""# neutral SFS for two types\n"", + ""sfs_neut = fd.Spectra(dict(\n"", + "" pendula=[177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0],\n"", + "" pubescens=[172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31]\n"", + ""))\n"", + ""\n"", + ""# selected SFS for two types\n"", + ""sfs_sel = fd.Spectra(dict(\n"", + "" pendula=[797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0],\n"", + "" pubescens=[791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41]\n"", + ""))\n"", + ""\n"", + ""# create inference object\n"", + ""inf = fd.JointInference(\n"", + "" sfs_neut=sfs_neut,\n"", + "" sfs_sel=sfs_sel,\n"", + "" shared_params=[fd.SharedParams(types=[\""pendula\"", \""pubescens\""], params=[\""S_d\""])]\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""inf.run();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:JointInference: Using shared parameters [SharedParams(params=['S_d'], types=['pendula', 'pubescens'])].\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Including covariates: {}.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'all'.\u001B[0m\n"", + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:01<00:00, 8.13it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 28.89it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 0, all.b: 0.1066 ± 2.2e-09, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -45.09 ± 3.5e-12} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inferences for types ['pendula', 'pubescens'].\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'pendula'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 27.00it/s]\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -3.389e+04 ± 4.4, all.b: 0.1305 ± 1.8e-06, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -35.44 ± 3.3e-09} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'pubescens'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 28.84it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 6.4e+03, all.b: 0.1035 ± 0.00072, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -43.81 ± 0.094} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running joint inference for types ['pendula', 'pubescens'].\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 3 parameters: [pendula:pubescens.S_d, pubescens.b, pendula.b].\u001B[0m\n"", + ""JointInference>Performing joint inference: 100%|██████████| 10/10 [00:01<00:00, 8.37it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {pendula:pubescens.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Inference results: {pendula.b: 0.1168 ± 0.00083, pendula.p_b: 0 ± 0, pendula.S_b: 1 ± 0, pendula.eps: 0 ± 0, pendula.h: 0.5 ± 0, pubescens.b: 0.1035 ± 0.00098, pubescens.p_b: 0 ± 0, pubescens.S_b: 1 ± 0, pubescens.eps: 0 ± 0, pubescens.h: 0.5 ± 0, pendula:pubescens.S_d: -1e+05 ± 8e+03, likelihood: -79.46 ± 0.12} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Bootstrapping type 'all'.\u001B[0m\n"", + ""BaseInference>Bootstrapping 'all' (2 runs each): 100%|██████████| 100/100 [00:05<00:00, 19.88it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -8.665e+04 ± 2.7e+04, all.b: 0.1094 ± 0.0073, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -54 ± 7.5, i_best_run: 0.46 ± 0.5, likelihoods_std: 0.0002605 ± 0.0016} (mean ± std)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Bootstrapping type 'pendula'.\u001B[0m\n"", + ""BaseInference>Bootstrapping 'pendula' (2 runs each): 100%|██████████| 100/100 [00:05<00:00, 16.69it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -5.482e+04 ± 3.9e+04, all.b: 0.1331 ± 0.022, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -42.9 ± 5.9, i_best_run: 0.5 ± 0.5, likelihoods_std: 0.007777 ± 0.046} (mean ± std)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Bootstrapping type 'pubescens'.\u001B[0m\n"", + ""BaseInference>Bootstrapping 'pubescens' (2 runs each): 100%|██████████| 100/100 [00:04<00:00, 21.74it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -9.267e+04 ± 2.1e+04, all.b: 0.1049 ± 0.0055, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -53.15 ± 7.6, i_best_run: 0.4 ± 0.49, likelihoods_std: 3.296e-05 ± 0.00033} (mean ± std)\u001B[0m\n"", + ""JointInference>Bootstrapping joint inference (2 runs each): 100%|██████████| 100/100 [00:16<00:00, 6.19it/s]\n"", + ""\u001B[32mINFO:JointInference: Bootstrap summary: {pendula.b: 0.12 ± 0.0069, pendula.p_b: 0 ± 0, pendula.S_b: 1 ± 0, pendula.eps: 0 ± 0, pendula.h: 0.5 ± 0, pendula.S_d: -8.714e+04 ± 2.5e+04, pubescens.b: 0.1058 ± 0.0059, pubescens.p_b: 0 ± 0, pubescens.S_b: 1 ± 0, pubescens.eps: 0 ± 0, pubescens.h: 0.5 ± 0, pubescens.S_d: -8.714e+04 ± 2.5e+04, likelihood: -96.88 ± 9.2, i_best_run: 0.5 ± 0.5, likelihoods_std: 6.776 ± 68} (mean ± std)\u001B[0m\n"" + ] + } + ], + ""execution_count"": 17 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""{class}`~fastdfe.joint_inference.JointInference` both runs the joint inference and marginal inference where each type is inferred separately. To see this better we can plot the inferred parameters for the different inference types."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:32:49.023182Z"", + ""start_time"": ""2026-01-04T10:32:48.716054Z"" + } + }, + ""source"": [ + ""inf.plot_inferred_parameters();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 18 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""``marginal.pendula`` and ``marginal.pubescens`` are the marginal inferences for the respective type. ``marginal.all`` is the marginal inference obtaining by adding up the spectra of all types. ``joint.pendula`` and ``join.pubescens`` are the joint inferences for the respective type. We can see that ``eps`` and ``S_d`` are indeed shared between the two. The parameter ``alpha`` in the plot denotes the proportion of beneficial non-synonymous substitutions. Each marginal inference is a {class}`~fastdfe.base_inference.BaseInference` object itself and can be accessed via ``inf.marginal_inferences[type]``.\n"", + ""\n"", + ""We can now also investigate to what extent the inferred DFEs differ:"" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:32:49.263232Z"", + ""start_time"": ""2026-01-04T10:32:49.028181Z"" + } + }, + ""source"": [ + ""inf.plot_discretized();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 19 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""### Model comparison\n"", + ""We can obtain information about the goodness of fit achieved by sharing the parameter by performing a likelihood ratio test (cf. {func}`~fastdfe.joint_inference.JointInference.perform_lrt_shared`). This compares the likelihood of the joint inference with the product of the marginal likelihoods."" + ] + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:32:49.271002Z"", + ""start_time"": ""2026-01-04T10:32:49.268209Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf.perform_lrt_shared()"", + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:JointInference: Simple model likelihood: -79.46473650022017, Complex model likelihood: -79.24744560917105, Total degrees of freedom: 1, Parameters at boundary: 0.\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""0.5097492591276529"" + ] + }, + ""execution_count"": 20, + ""metadata"": {}, + ""output_type"": ""execute_result"" + } + ], + ""execution_count"": 20 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""The test is not significant, indicating that the simpler model of sharing the parameters explains the data sufficiently well. Indeed, we do not observe a lot of differences between the inferred parameters of joint and the marginal inferences."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""## Covariates\n"", + ""{class}`~fastdfe.joint_inference.JointInference` also supports the inclusion of covariates associates with the different SFS types. This provides more powerful model testing and reduces the number of parameters that need to be estimated for the joint inference. For a more interesting example we stratify the SFS of `B. pendula` by the sites' reference base as is described in more detail in the {mod}`~fastdfe.parser` module."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:36:22.713728Z"", + ""start_time"": ""2026-01-04T10:32:49.275520Z"" + } + }, + ""source"": [ + ""# instantiate parser\n"", + ""p = fd.Parser(\n"", + "" n=10,\n"", + "" vcf=\""https://github.com/Sendrowski/fastDFE/\""\n"", + "" \""blob/dev/resources/genome/betula/\""\n"", + "" \""all.polarized.deg.subset.200000.vcf.gz?raw=true\"",\n"", + "" stratifications=[fd.DegeneracyStratification(), fd.AncestralBaseStratification()]\n"", + "")\n"", + ""\n"", + ""# parse SFS\n"", + ""spectra: fd.Spectra = p.parse()\n"", + ""\n"", + ""# visualize spectra\n"", + ""spectra.plot();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Parser: Using stratification: [neutral, selected].[A, C, G, T].\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Loading VCF file\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/011b01ee5cec.all.polarized.deg.subset.200000.vcf.gz\u001B[0m\n"", + ""\u001B[32mINFO:FileHandler: Using cached file at /var/folders/w6/18ktl5312413jw46btlxrh59fzxvt4/T/011b01ee5cec.all.polarized.deg.subset.200000.vcf.gz\u001B[0m\n"", + ""Parser>Counting sites: 200000it [00:02, 82178.86it/s]\n"", + ""Parser>Processing sites: 100%|██████████| 200000/200000 [03:30<00:00, 948.92it/s] \n"", + ""\u001B[32mINFO:PolyAllelicFiltration: Filtered out 154 sites.\u001B[0m\n"", + ""\u001B[32mINFO:DegeneracyStratification: Number of sites with valid type: 64083\u001B[0m\n"", + ""\u001B[32mINFO:AncestralBaseStratification: Number of sites with valid type: 64083\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Skipped 983 sites without ancestral allele information.\u001B[0m\n"", + ""\u001B[32mINFO:Parser: Included 64083 out of 200000 sites in total from the VCF file.\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 21 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""We now create the inference object from the spectra. In this contrived example we make up some covariates that covary with ``S_d``, the mean strength of negative selection. Covariates introduce a linear relationship by default but this can be modified by specifying a custom callback function (see {class}`~fastdfe.optimization.Covariate`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:38:07.769833Z"", + ""start_time"": ""2026-01-04T10:36:22.739615Z"" + } + }, + ""source"": [ + ""# create inference object\n"", + ""inf = fd.JointInference(\n"", + "" sfs_neut=spectra[['neutral.*']].merge_groups(1),\n"", + "" sfs_sel=spectra[['selected.*']].merge_groups(1),\n"", + "" covariates=[fd.Covariate(param='S_d', values=dict(A=1, C=2, T=3, G=4))],\n"", + "" n_runs=50 # increase number of initial runs for stability\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""inf.run();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:JointInference: Parameters ['S_d'] have covariates and thus need to be shared. Adding them to shared parameters.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Using shared parameters [SharedParams(params=['S_d'], types=['A', 'C', 'G', 'T'])].\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Including covariates: {'c0': {'param': 'S_d', 'values': {'A': 1, 'C': 2, 'T': 3, 'G': 4}}}.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'all'.\u001B[0m\n"", + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:01<00:00, 8.05it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 32.61it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 0, all.b: 0.1069 ± 2.5e-08, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -26.61 ± 1.5e-10} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inferences for types ['A', 'C', 'G', 'T'].\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'A'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 33.18it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[33mWARNING:BaseInference: The L1 residual comparing the modelled and observed SFS is rather large: `norm(sfs_modelled - sfs_observed, 1) / sfs_observed` = 0.200. This may indicate that the model does not fit the data well.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 0, all.b: 0.0857 ± 2e-08, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -22.72 ± 2.3e-11} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'C'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 25.80it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 3.1e+03, all.b: 0.1219 ± 0.0004, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -19.47 ± 0.00011} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'G'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 31.50it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 1.6e+04, all.b: 0.1221 ± 0.024, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -18.88 ± 0.43} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'T'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 32.98it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 8.8e+03, all.b: 0.1079 ± 0.0012, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -18.44 ± 0.0042} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running joint inference for types ['A', 'C', 'G', 'T'].\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 6 parameters: [A:C:G:T.S_d, T.b, C.b, A:C:G:T.c0, G.b, A.b].\u001B[0m\n"", + ""JointInference>Performing joint inference: 100%|██████████| 50/50 [00:13<00:00, 3.69it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {A:C:G:T.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[33mWARNING:JointInference: Numerical optimization did not terminate normally, so the result might be unreliable. Consider adjusting the optimization parameters (increasing `gtol` or `n_runs`) or decreasing the number of optimized parameters.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Inference results: {A.b: 0.0857 ± 3.3, A.p_b: 0 ± 0, A.S_b: 1 ± 0, A.eps: 0 ± 0, A.h: 0.5 ± 0, C.b: 0.1219 ± 1.9, C.p_b: 0 ± 0, C.S_b: 1 ± 0, C.eps: 0 ± 0, C.h: 0.5 ± 0, G.b: 0.1221 ± 0.52, G.p_b: 0 ± 0, G.S_b: 1 ± 0, G.eps: 0 ± 0, G.h: 0.5 ± 0, T.b: 0.1079 ± 2, T.p_b: 0 ± 0, T.S_b: 1 ± 0, T.eps: 0 ± 0, T.h: 0.5 ± 0, A:C:G:T.S_d: -1e+05 ± 4.9e+04, A:C:G:T.c0: 0 ± 5.2e+03, likelihood: -79.5 ± 4.1e+02} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[33mWARNING:BaseInference: The L1 residual comparing the modelled and observed SFS is rather large: `norm(sfs_modelled - sfs_observed, 1) / sfs_observed` = 0.200. This may indicate that the model does not fit the data well.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Bootstrapping type 'all'.\u001B[0m\n"", + ""BaseInference>Bootstrapping 'all' (2 runs each): 100%|██████████| 100/100 [00:04<00:00, 20.35it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -7.856e+04 ± 3.8e+04, all.b: 0.1168 ± 0.026, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -35.92 ± 6.4, i_best_run: 0.44 ± 0.5, likelihoods_std: 0.000985 ± 0.0099} (mean ± std)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Bootstrapping type 'A'.\u001B[0m\n"", + ""BaseInference>Bootstrapping 'A' (2 runs each): 100%|██████████| 100/100 [00:04<00:00, 22.51it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -7.758e+04 ± 4.1e+04, all.b: 0.1052 ± 0.044, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -91.89 ± 1.8e+02, i_best_run: 0.48 ± 0.5, likelihoods_std: 0.02762 ± 0.26} (mean ± std)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Bootstrapping type 'C'.\u001B[0m\n"", + ""BaseInference>Bootstrapping 'C' (2 runs each): 100%|██████████| 100/100 [00:04<00:00, 20.66it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -5.573e+04 ± 4.8e+04, all.b: 0.1812 ± 0.084, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -85.79 ± 1.5e+02, i_best_run: 0.47 ± 0.5, likelihoods_std: 0.004738 ± 0.027} (mean ± std)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Bootstrapping type 'G'.\u001B[0m\n"", + ""BaseInference>Bootstrapping 'G' (2 runs each): 100%|██████████| 100/100 [00:04<00:00, 20.75it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -6.275e+04 ± 4.7e+04, all.b: 0.1613 ± 0.066, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -109.6 ± 2.2e+02, i_best_run: 0.48 ± 0.5, likelihoods_std: 0.001265 ± 0.01} (mean ± std)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Bootstrapping type 'T'.\u001B[0m\n"", + ""BaseInference>Bootstrapping 'T' (2 runs each): 100%|██████████| 100/100 [00:05<00:00, 19.16it/s]\n"", + ""\u001B[32mINFO:BaseInference: Bootstrap summary: {all.S_d: -5.627e+04 ± 4.7e+04, all.b: 0.1616 ± 0.088, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -50.91 ± 82, i_best_run: 0.49 ± 0.5, likelihoods_std: 0.01103 ± 0.11} (mean ± std)\u001B[0m\n"", + ""JointInference>Bootstrapping joint inference (2 runs each): 100%|██████████| 100/100 [00:43<00:00, 2.29it/s]\n"", + ""\u001B[32mINFO:JointInference: Bootstrap summary: {A.b: 0.09628 ± 0.021, A.p_b: 0 ± 0, A.S_b: 1 ± 0, A.eps: 0 ± 0, A.h: 0.5 ± 0, A.S_d: -7.297e+04 ± 4e+04, A.c0: -235.5 ± 1.4e+03, C.b: 0.1376 ± 0.029, C.p_b: 0 ± 0, C.S_b: 1 ± 0, C.eps: 0 ± 0, C.h: 0.5 ± 0, C.S_d: -7.321e+04 ± 4e+04, C.c0: -235.5 ± 1.4e+03, G.b: 0.1386 ± 0.035, G.p_b: 0 ± 0, G.S_b: 1 ± 0, G.eps: 0 ± 0, G.h: 0.5 ± 0, G.S_d: -7.347e+04 ± 4e+04, G.c0: -235.5 ± 1.4e+03, T.b: 0.1226 ± 0.028, T.p_b: 0 ± 0, T.S_b: 1 ± 0, T.eps: 0 ± 0, T.h: 0.5 ± 0, T.S_d: -7.334e+04 ± 4e+04, T.c0: -235.5 ± 1.4e+03, likelihood: -506.9 ± 5.4e+02, i_best_run: 0.28 ± 0.45, likelihoods_std: 157 ± 2.1e+02} (mean ± std)\u001B[0m\n"" + ] + } + ], + ""execution_count"": 22 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""Let's visualize the inferred parameters"" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:38:08.278144Z"", + ""start_time"": ""2026-01-04T10:38:07.796594Z"" + } + }, + ""source"": [ + ""inf.plot_inferred_parameters();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 23 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": ""We observe that ``S_d`` shows little variation across the jointly inferred types, because it does not change linearly with respect to the arbitrary covariates specified. Indeed, the median of the covariate across all bootstrap replicates is close to zero. Note that covariates are named ``c0``, ``c1``, etc., by default."" + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:38:08.293049Z"", + ""start_time"": ""2026-01-04T10:38:08.290243Z"" + } + }, + ""source"": ""inf.bootstraps['A.c0'].median()"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""0.0"" + ] + }, + ""execution_count"": 24, + ""metadata"": {}, + ""output_type"": ""execute_result"" + } + ], + ""execution_count"": 24 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""### Model comparison\n"", + ""We can perform a likelihood ratio test to see whether including the covariates produces a significantly better fit than simply sharing the parameter in question among the types (cf. {func}`~fastdfe.joint_inference.JointInference.perform_lrt_covariates`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2026-01-04T10:38:30.696550Z"", + ""start_time"": ""2026-01-04T10:38:08.308144Z"" + } + }, + ""source"": [ + ""inf.perform_lrt_covariates()"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:JointInference: Using shared parameters [SharedParams(params=['S_d'], types=['A', 'C', 'G', 'T'])].\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Including covariates: {}.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running joint inference without covariates.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'all'.\u001B[0m\n"", + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:01<00:00, 8.54it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 32.00it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 0, all.b: 0.1069 ± 2.5e-08, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -26.61 ± 1.5e-10} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inferences for types ['A', 'C', 'G', 'T'].\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'A'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 34.27it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[33mWARNING:BaseInference: The L1 residual comparing the modelled and observed SFS is rather large: `norm(sfs_modelled - sfs_observed, 1) / sfs_observed` = 0.200. This may indicate that the model does not fit the data well.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 0, all.b: 0.0857 ± 2e-08, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -22.72 ± 2.3e-11} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'C'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 29.24it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 3.1e+03, all.b: 0.1219 ± 0.0004, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -19.47 ± 0.00011} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'G'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 34.58it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 1.6e+04, all.b: 0.1221 ± 0.024, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -18.88 ± 0.43} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running marginal inference for type 'T'.\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 50/50 [00:01<00:00, 36.12it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {all.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inference results: {all.S_d: -1e+05 ± 8.8e+03, all.b: 0.1079 ± 0.0012, all.p_b: 0 ± 0, all.S_b: 1 ± 0, all.eps: 0 ± 0, all.h: 0.5 ± 0, likelihood: -18.44 ± 0.0042} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Running joint inference for types ['A', 'C', 'G', 'T'].\u001B[0m\n"", + ""\u001B[32mINFO:Optimization: Optimizing 5 parameters: [A:C:G:T.S_d, T.b, C.b, G.b, A.b].\u001B[0m\n"", + ""JointInference>Performing joint inference: 100%|██████████| 50/50 [00:13<00:00, 3.66it/s]\n"", + ""\u001B[33mWARNING:Optimization: The MLE estimate is close to the upper bound for {} and lower bound for {A:C:G:T.S_d: (-100000, -100000, -0.01)} [(lower, value, upper)], but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[33mWARNING:JointInference: Numerical optimization did not terminate normally, so the result might be unreliable. Consider adjusting the optimization parameters (increasing `gtol` or `n_runs`) or decreasing the number of optimized parameters.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Inference results: {A.b: 0.0857 ± 0.0009, A.p_b: 0 ± 0, A.S_b: 1 ± 0, A.eps: 0 ± 0, A.h: 0.5 ± 0, C.b: 0.1219 ± 0.0011, C.p_b: 0 ± 0, C.S_b: 1 ± 0, C.eps: 0 ± 0, C.h: 0.5 ± 0, G.b: 0.1221 ± 0.0012, G.p_b: 0 ± 0, G.S_b: 1 ± 0, G.eps: 0 ± 0, G.h: 0.5 ± 0, T.b: 0.1079 ± 0.00096, T.p_b: 0 ± 0, T.S_b: 1 ± 0, T.eps: 0 ± 0, T.h: 0.5 ± 0, A:C:G:T.S_d: -1e+05 ± 8e+03, likelihood: -79.5 ± 0.023} (best_run ± std_across_runs)\u001B[0m\n"", + ""\u001B[33mWARNING:BaseInference: The L1 residual comparing the modelled and observed SFS is rather large: `norm(sfs_modelled - sfs_observed, 1) / sfs_observed` = 0.200. This may indicate that the model does not fit the data well.\u001B[0m\n"", + ""\u001B[32mINFO:JointInference: Simple model likelihood: -79.50114061683993, Complex model likelihood: -79.50114061683993, Total degrees of freedom: 1, Parameters at boundary: 0.\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""1.0"" + ] + }, + ""execution_count"": 25, + ""metadata"": {}, + ""output_type"": ""execute_result"" + } + ], + ""execution_count"": 25 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""As expected, the specified covariates do not improve the fit significantly."" + ] + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3 (ipykernel)"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 3 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython3"", + ""version"": ""3.10.14"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 4 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/spectra.ipynb",".ipynb","137101","373","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""# Working with SFS\n"", + ""## Subtypes\n"", + ""fastDFE offers a set of utilities for handling and manipulating site-frequency spectra (SFS) data, especially when there are multiple types. The {class}`~fastdfe.spectrum.Spectra` class is designed to hold and manipulate spectra of multiple types. It provides a number of methods and properties for creating, accessing, and manipulating the spectra data. Usually we would obtain already stratified spectra from {class}`~fastdfe.parser.Parser`, but we can also create them manually."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:45.954268Z"", + ""start_time"": ""2024-06-05T09:37:45.950315Z"" + } + }, + ""source"": [ + ""import matplotlib.pyplot as plt\n"", + ""\n"", + ""plt.rcParams['figure.figsize'] = [4.4, 3.3]"" + ], + ""outputs"": [], + ""execution_count"": 13 + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:46.087047Z"", + ""start_time"": ""2024-06-05T09:37:45.956175Z"" + } + }, + ""source"": [ + ""import fastdfe as fd\n"", + ""import matplotlib.pyplot as plt\n"", + ""\n"", + ""# create spectra with two subtypes and two types\n"", + ""spectra = fd.Spectra.from_spectra({\n"", + "" \""subtype1.type1\"": fd.Spectrum.standard_kingman(10) * 1,\n"", + "" \""subtype1.type2\"": fd.Spectrum.standard_kingman(10) * 2,\n"", + "" \""subtype2.type1\"": fd.Spectrum.standard_kingman(10) * 3,\n"", + ""})\n"", + ""\n"", + ""# plot spectra\n"", + ""spectra.plot();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 14 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""We access types by their index from which we obtain a {class}`~fastdfe.spectrum.Spectrum` object."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:46.150399Z"", + ""start_time"": ""2024-06-05T09:37:46.088373Z"" + } + }, + ""source"": [ + ""sfs: fd.Spectrum = spectra[\""subtype1.type1\""]\n"", + ""\n"", + ""sfs.plot();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 15 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""We can also use wildcards to access multiple types at once."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:46.254654Z"", + ""start_time"": ""2024-06-05T09:37:46.151250Z"" + } + }, + ""source"": [ + ""spectra[\""subtype1.*\""].plot();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 16 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""### Grouping\n"", + ""To get rid of the subtypes, we can merge the spectra over the specified number of groups."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:46.346311Z"", + ""start_time"": ""2024-06-05T09:37:46.256536Z"" + } + }, + ""source"": [ + ""spectra.merge_groups(1).plot();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 17 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""All subtypes for each type are merged into a single spectrum by adding them upp."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""### Serialization\n"", + ""We can also save the spectra to a file and restore them again."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:46.351880Z"", + ""start_time"": ""2024-06-05T09:37:46.347234Z"" + } + }, + ""source"": [ + ""spectra.to_file(\""out/spectra.csv\"")\n"", + ""\n"", + ""spectra2 = fd.Spectra.from_file(\""out/spectra.csv\"")"" + ], + ""outputs"": [], + ""execution_count"": 18 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""### Prefixing\n"", + ""Here we prefix the spectra with a string to distinguish them and then combine them into a single spectra object."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:46.532350Z"", + ""start_time"": ""2024-06-05T09:37:46.352835Z"" + } + }, + ""source"": [ + ""spectra.prefix('original').combine(spectra2.prefix('restored')).plot();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 19 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""For a complete reference of the available methods and properties, see {class}`~fastdfe.spectrum.Spectra` and {class}`~fastdfe.spectrum.Spectrum`."" + ] + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""## Folded spectra\n"", + ""{class}`Spectrum` and {class}`Spectra` objects can also be folded by collapsing the bins corresponding to the derived allele counts onto the bins corresponding to the ancestral allele counts. Basing the DFE inference on folded spectra, we have less information to work with, which is particularly noticeable when including beneficial mutations. However, folded spectra are easier to obtain, and are robust to misspecification of the ancestral state, which is often unknown. DFE inference is based on folded spectra whenever spectrum.is_folded is ``True``."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + }, + ""ExecuteTime"": { + ""end_time"": ""2024-06-05T09:37:46.698821Z"", + ""start_time"": ""2024-06-05T09:37:46.533198Z"" + } + }, + ""source"": [ + ""# create subplots\n"", + ""fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(7, 3))\n"", + ""\n"", + ""# fold spectra object\n"", + ""spectra.fold().plot(ax=ax1)\n"", + ""\n"", + ""# fold spectrum object\n"", + ""sfs.fold().plot(ax=ax2);"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 20 + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3 (ipykernel)"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 3 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython3"", + ""version"": ""3.10.14"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 4 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/example_pendula_biased_gc.ipynb",".ipynb","231834","515","{ + ""cells"": [ + { + ""cell_type"": ""code"", + ""execution_count"": 1, + ""metadata"": { + ""collapsed"": true, + ""ExecuteTime"": { + ""end_time"": ""2023-07-18T18:02:50.331613Z"", + ""start_time"": ""2023-07-18T17:56:29.623886Z"" + } + }, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""Counting sites: 2439037it [00:41, 58823.11it/s]\n"", + ""\u001B[32mINFO:fastdfe.Parser: Using stratification: [neutral, selected].[A>C, A>G, A>T, C>A, C>G, C>T, G>A, G>C, G>T, T>A, T>C, T>G].\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Parser: Starting to parse.\u001B[0m\n"", + ""Processing sites: 100%|██████████| 2439037/2439037 [05:30<00:00, 7388.54it/s] \n"", + ""\u001B[32mINFO:fastdfe.PolyAllelicFiltration: Filtered out 0 sites.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.DegeneracyStratification: Number of sites with valid type: 91224 / 1548617\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseTransitionStratification: Number of sites with valid type: 91224 / 981644\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Parser: Included 91224 out of 2439037 sites in total.\u001B[0m\n"" + ] + } + ], + ""source"": [ + ""import numpy as np\n"", + ""\n"", + ""import fastdfe as fd\n"", + ""\n"", + ""p = fd.Parser(\n"", + "" n=10,\n"", + "" vcf=\""../../resources/genome/betula/all.vcf.gz\"",\n"", + "" stratifications=[fd.DegeneracyStratification(), fd.BaseTransitionStratification()]\n"", + "")\n"", + ""\n"", + ""# parse SFS\n"", + ""s: fd.Spectra = p.parse()"" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 2, + ""outputs"": [ + { + ""data"": { + ""text/plain"": """" + }, + ""execution_count"": 2, + ""metadata"": {}, + ""output_type"": ""execute_result"" + }, + { + ""data"": { + ""text/plain"": ""
"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + }, + { + ""data"": { + ""text/plain"": ""
"", + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAcQAAAG9CAYAAACLcgYWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACdEklEQVR4nOy9eXgUZbr+f3dXb9mbJKY7YcsCAgJJUBFBWUYcccRRj86IgojgBoKKjopRh+HAoDijA8c5fAfxBIFRlOE3DjIouKCCC46AbAoKZGFJ0h0gdCek9676/dFUpaq7qpfs3Tyf68p1pWt9q5Kuu973ed7nVnEcx4EgCIIgLnLUXd0AgiAIgugOkCASBEEQBEgQCYIgCAIACSJBEARBACBBJAiCIAgAJIgEQRAEAYAEkSAIgiAAkCASBEEQBABA09UNIAiC6Gr8fj+8Xm9XN4NoI1qtFgzDtHp/EkSCIC5qzp8/j1OnToGKdsU/KpUKvXr1Qmpqauv2p9JtBEFcrPj9fhw9ehTJycm45JJLoFKpurpJRCvhOA6nT5+Gw+FA//79W9VTpB4iQRAXLV6vFxzH4ZJLLkFSUlJXN4doI5dccgmqq6vh9XpbJYiUVEMQxEUP9QwTg7b+HamHSBAEIcI8eQk0GSZoMnKEZRzrh6e+GpzXBV1OAdT6ZGEd63bAU18FldYAXU4+VOqWnonPXg+f3Socr3rJxE69FjHLli3DXXfdBbPZ3Kr9VSoVzp07B6PRKLv+888/x3XXXYe1a9di6tSpMR+/oqIC8+bNw549e5CZmQmGYfDQQw/hgQceaFV7WwP1EAmCIER0lBh2NcuWLYPFYpFdx7IsWJZt0/HLy8sxfvx4lJeXS5Y3NDRETFiyWCy49tprMWHCBFRVVWHPnj346KOP4PP52tSmWCFBJAiCENEdxFClUuHFF1/EVVddhYKCArz55pvCuqNHj2LixIkYPnw4iouL8b//+7+S/Ww2m/A5Ozsb1dXVWLhwIWprazFp0iSUlpZi3759WLBgAe644w5MmDABQ4YMQV1dHZ566ikMHz4cpaWlGDNmDH7++eeo2muz2fDBBx/grbfewqFDh3Ds2DFh3YYNG9C/f3+UlZXh4MGDsvsvX74co0ePxoMPPigs69GjB2bOnBntLWsXSBAJgiBkaG8x5Fh/TOfX6/X47rvvsGXLFjz22GPw+Xzw+/24++678eqrr2LXrl349ttvsXLlSuzatSvssebPn4+8vDysX78e+/btQ2lpKQBg586dWLt2LQ4dOoSePXti3rx52LVrF/bt24dHHnkEjz/+eFRtXbduHSZMmACz2Yx77rkHq1atEtY9/PDD+Pbbb9GnTx/MmTMHJSUlePHFF1FVVSVss2fPHowcOTKm+9MRkCASBEEE0RFi6KmvjqkNU6ZMAQAMHDgQGo0GFosFP//8M3788UfcddddKC0txahRo9DU1IRDhw616jpvuukmmEwm4fMnn3yCkSNHYsiQIVi4cCH27dsX1XHKy8sxY8YMAMCMGTOwZs0a+P0tLwDZ2dmYNWsWtm/fji1btqC6uhpFRUWSnm93gJJqCIIgRHSUGHJeV0ztMBgMwu8Mw8Dn84HjOGRmZioKFcMwEiFyucKfUzyB/cSJE5gzZw527dqFoqIiHDhwAGPGjInYzn379uHAgQN48MEHhSzPM2fOYMuWLbj55puF7aqqqrB+/XqsX78eaWlpWL58OW677TYAwBVXXIGdO3fiiSeeiHi+joR6iARBECI6Sgx1OQVtbtuAAQOQnp4u6VkdO3YMDQ0NAIB+/frhP//5DwDgvffeQ3Nzs7Bdeno67Ha74rHtdju0Wi1yc3PBcZwkNhmO8vJy/O53v8Px48dRXV2N6upqLFu2TEiu2bZtG0aOHInbb78darUa77//Pnbs2IFZs2ahR48eAIBHHnkE27dvl1yXzWbD66+/HuWdaR9IEAmCIER0lBiKj9daNBoNNm/ejPfeew/FxcUYPHgw7r//fjidTgDA0qVL8fjjj+Pyyy/H3r17kZWVJez72GOP4cEHHxSSaoIZOnQo7rrrLgwePBjDhw9Hnz59FNsxf/58rFixAi6XC2+//bYwvMtz55134uOPP4bVakVaWhpWrVqFvXv34plnnpE9bm5uLr766its3rwZBQUFKC4uxvjx46HValt5p1oHlW4jCOKixeVyoaqqCgUFBZIhSiI+aevfk3qIBEEQBAESRIIgCIIAQIJIEARBEABIEAmCIAgCAAkiQRAEQQAgQSQIgiAIACSIBEEQBAGASrcRBEFIWZAh/FptY1Ft45BvVCHf2NJ/8LEcDlhZNHuAErMa6foWY9pGN4f9FhYpOqDYpIZGLTKtXaBcKaaj6e5+iMeOHUNZWRl2794No9EIlmVxww034I9//CP0en2r2hwr1EMkCIKQob3FsNrWNr/BttKd/RDr6upw7bXX4sYbb0RVVRX27t2Lb775Bunp6WhqampTu2KBBJEgCCKIjhDDalv0RcEuRj/EcePG4f777xeWpaSk4Pe//z2ys7OjvW1thgSRIAhCREeJYb5RhVi4mPwQv//+e4wYMSKm+9MRkCASBEGI6CgxFB8vGi5mP8SlS5eitLQUffr0wdatW1t1ba2BkmoIgiBEdAcxBC4uP8Rhw4bhu+++E7Z94okn8MQTT2DcuHERr6E9oR4iQRCEiO4ghkokqh/i7NmzsW3bNqxevVo4LsuynSqGAAkiQRCELO0thj627U57ieqHmJeXhy+//BL//ve/kZ+fjyuuuALXXnstxo4di9GjR7fybsUO+SESBHHRQn6IiQX5IRIEQRBEO0CCSBAEQRAgQSQIgiAIACSIBEEQBAGABJEgCIIgAJAgEgRBEAQAqlRDEAQhYeiaofA7/XCddEGtV8PQywAV0zLP0HPGA+8ZL7TZWuiydcJyzs/BdcoF1s3C0NsAJokR1vHHq1xc2anXQsQG9RAJgiBEdJQYqvVd+7gNZ/8UDcFOGsF8/vnnUKlU+Pvf/x7TcTdt2oTS0lKUlpbCbDbjkksuET6//fbbrW5va6CJ+QRBXLTITeQufL6wQ8TQ0MuAH2b80HkXF0R+fj42btwoOF2I4b0Q1Wpl0Y5kEHzPPffAYrHA5/Phiy++EJY3NDSgR48eQp3TcCxYsAA2mw3Lli2LuK0cNDGfIAiiHekoMRQfLxIXmx9id4EEkSAIQkRXiyHPxeSH2F0gQSQIghDRHcQQuLj9ELsKyjIlCIKQob3F0HPGE9P5LyY/xO4C9RAJgiCC6Agx9J7xtrldieqH2F2gHiJBEISIg9O6b+IH74c4d+5cLF26FH6/H9nZ2Vi3bh2AgB/iY489hhdeeAETJ06U9UNMTk6WGPHyiP0Qs7Kywvbe+Jjkfffdh7fffhvbt2+XrL/zzjvx1FNPSfwQBw0a1C73oCOhaRcEQVy0kB9iYkHTLgiCIAiiHSBBJAiCIAiQIBIEQRAEABJEgiAIggBAgkgQBEEQAEgQCYIgCAIAzUMkCIKQ8HafvrhUr0cq0zLp/rzfjyNuN5LUalyq14MROTfUer2o8XrRU6tFnlYrLPdzHI643XCyrHC8QT8d7tRrEbNs2TLcddddMJvNrdo/nNtFfX095s2bh+3btyMjIwMqlQq/+c1v8Nxzz8V0js8//xzXXXcd1q5di6lTp7aqnW2BeogEQRAiOkoMu5pwfogsywoWULHidDoxduxY9O3bF0ePHsXevXvx1VdfISUlBUDACUNcTi4c5eXlGD9+vFDlprMhQSQIghDRHcQwnuyf1q1bh7S0NCxYsADMhWtNTk4WnDK+/vprFBUV4dFHH8XOnTsVjxPOQqqzIEEkCIKQob3F8HyUvSSeeLF/2rNnD0aOHKm4fuLEiThw4ACGDx+ORYsWYcCAAXj++efx448/SrYLZyHVWZAgEgRBBNERYnjE7Y6pDfFk/xSJ9PR03Hvvvfjwww/xzTffAABKSkqwYMECYZtIFlKdASXVEARBiOgoMUxSx9b/iBf7pyuuuAIrV66MuJ3FYsGGDRvw7rvvwu12Y8mSJYLoR2sh1dFQD5EgCEJER4nhpXp9m9vWHe2f7r77bthsNixatEgQY6fTiddeew1AQOzGjx+PcePG4fTp01i1ahV2796Np556Crm5uQAiW0h1FiSIBEEQIjpKDMXHay28/dN7772H4uJiDB48GPfffz+cTieAgP3T448/jssvvxx79+6VtX/ik2qCEds/DR8+HH369FFsx/z587FixQoAgQSa7du3o6KiAv369cPQoUMxYsQIOBwOAIBWq8VLL72En376CQsXLsSAAQMkx3K5XHj77beF3iLPnXfeiY8//hhWq7VV96o1kP0TQRAXLWT/lFiQ/RNBEARBtAMkiARBEAQBEkSCIAiCAECCSBAEQRAASBAJgiAIAgAJIkEQBEEAoEo1BEEQEpbP/Ez4nWX9qDlbCY/PhZ5ZRTDokoV1Lo8DNWcroNMY0DOrEGp1yxzEhiYrzjZZkJVmRmZaS2m02Suu65yLIFoF9RAJgiBkaG8xZNnOrcsZTDj7p2gIdtIQU19fj+nTp6OwsBDDhg3D5ZdfjhdffDGm41utVsyYMQOFhYUoKSlBcXExZs6cibNnz7a6zbFCgkgQBBFER4hhzdnKTr2GYLqzH6LD4cCYMWOQn5+Po0ePYv/+/di9ezdKSkpQU1PTqna1BhJEgiAIER0lhh5f+ELbYi42P8R169ahR48emD9/vnAMnU6HWbNmobi4OOr71lZIEAmCIER0lBj2zCqKqR0Xkx/i999/jxEjRkR3YzoQEkSCIAgRHSWG4uNFw8Xmhyhm/fr1KC0tRUFBAd544412aUM0UJYpQRCEiO4ghsDF5Yc4bNgwrFq1Sth20qRJmDRpEu677z6JhVVHQz1EgiAIEd1BDJVIVD/EyZMn48yZM1i8eLFE0HkLqc6CeogEQRAiuvNcQd4Pce7cuVi6dCn8fj+ys7Oxbt06AAE/xMceewwvvPACJk6cKOuHmJycjNWrV4ccW+yHmJWVhdtuu02xHXxMcubMmYIf4rPPPot+/fohNTUVKpUKkydPBtDih3jVVVcpHi8lJQU7duxAWVkZ+vXrB6PRiKSkJJSWluL2229v3c1qBeSHSBDERQv5ISYW5IdIEARBEO0ACSJBEARBgASRIAiCIACQIBIEQRAEABJEgiAIggBAgkgQBEEQAGgeIkEQhIRXJ92Mc80ONDicyExOQo+Ulon1LMuhzt4Ij9+P3Iw0GLRaYZ3L60WdvQk6hkFuRjrUapWwjj/e//tMvrh1Z7Bs2TLcddddMJvNrdpfpVLh3LlzMBqNIevq6+sxb948bN++HRkZGVCpVPjNb36D5557LuJxd+/ejQceeAAA0NDQALvdjoKCAgCB8nVPP/10q9rbGkgQCYIgRHSUGGYmJ3XqdQSzbNkyjBs3TlYQeesntTr2QUPe/mnSpEk4evQoGIaBw+EQapDabDakpaUJLhbBXHnllUIputWrV2Pjxo3YuHFjzO1oD2jIlCAIQkRHiaH4eJG42Oyfugtx2UNkWRa1tbVIS0uDSqWKvANBEIQMHo8HLMvC7/cLNTQ7UgwjGeWK0Wq12LlzJ3766SdcffXVmDx5MlQqFe6++26sWbMGAwcOhMPhwDXXXIMrr7wSw4cPF84hPo/f78fzzz+PVatWYd26dYL103vvvYedO3di9+7dguPFU089hZdffhlAwHHisccew4cffig5VvA17N69G1dffbXitd14443Yu3cv3n//fSxcuBCVlZW4/fbbcffdd2Pw4MGSbVmWBcdxMd0nMX6/HyzL4vz58/B4PMJyjuPQ1NSEvLy8sL3guBTE2tpa9O7du6ubQRBEnNO3b1+sWLECTqdTWNaRPcO9e/dG3bahQ4cK26tUKnz66adobm7GDz/8gP/6r/8StmtubsbWrVuh0QQe5wcOHEBaWhoAwOfz4ccff8S5c+fg8Xjw008/ga/WabFYcNVVV6G2tha1tbUAgK1bt+If//gHmpubwXEc7Ha7pM3iY/OcPn0aGo0m4rUNGTIEQ4YMgc1mw7p163D55ZdjxowZeOihh4Rtjh8/HnLOWDlz5gwmTpyI48ePh6w7efIkevXqpbhvXAoi/wc5efIk0tPTu7g1BEHEKx6PB1arFfn5+ULty+0X1rW3GLIsh2HDhkXdtuHDhwsJLDqdDgMHDkRzczOysrJw+PBh2X0YhhGKcwMBQRw8eDDy8/OFY/A9RLPZjKSkJKFNJ06cwF/+8hd8++23gv3TL37xC0mbi4uLQ5JqJkyYgDfeeCPitVksFvx//9//h/Xr18Pj8eDFF1/E5MmTBccLICC4GRkZMd0nMS6XC9XV1di9ezd0Op2wvLGxEb179w4R82DiUhD5YdL09HQSRIIgWo3L5cLp06fBMIwk6aMjxLDO3qiYWCJHcJsYhsFll12G9PR0rF27FtOnTwcQsH/KzMxEZmYm+vXrh927d+Omm24S7J/446Snp+P8+fPCMdVqNVQqlfD5/Pnz0Gq16NWrF9RqNf72t78J51VqExDIBH3llVfw4osv4rnnngPDMHA6nXjjjTfw2GOPYd++ffjd736Hmpoa3HnnnXjzzTcxYMAA2WsOblOsMAwDtVqN1NRU2eLekUJslFRDEAQhoqPE0NPKuJgY3v7pvffeQ3FxMQYPHoz7779fGPJdunQpHn/8cVx++eXYu3evrP0Tn1QTjNj+afjw4ejTp49iO+bPn48VK1YAgGD/VFFRgX79+mHo0KEYMWKE4GXI2z/99NNPWLhwoaIYdgfi0v6psbERGRkZsNvt1EMkCKLVkP1TYqH094xWM6iHSBAEQRAgQSQIgiAIACSIBEEQBAGABJEgCIIgAJAgEgRBEAQAEkSCIAiCAECCSBAEQRAA4rRSDUEQREex9b5VGJRTCEbdUi3llN2Ck3YLemeY0SujxT7Jz/pxuL4SDq8Tg3KKkKZPEdY1uZtxuL4Cydok4Xi9lozu1GsR05F+iFarFWVlZfjiiy+QlpYGjuMwatQoLF68WFIcIBrefPNNzJgxAzt27MDo0Z17v6iHSBAEIaKjxLCrWbZsGSwWi+w6lmUFT8RYcTgcGDNmDPLz83H06FHs378fu3fvRklJCWpqagAEjH+jrQFTXl6O8ePHo7y8vFXtaQskiDGy4vVeWPY/Pbu6GQRBdBDdQQzjzQ+xR48emD9/vlCDVKfTYdasWSguLgYAbNiwAf3790dZWRkOHjyoeKyff/4ZVVVVWLt2LTZu3IjGxsZYb12bIEGMkcJCHQwG8mAkiESnvcXwlF2+d6aEXq/Hd999hy1btuCxxx6Dz+eD3+/H3XffjVdffRW7du3Ct99+i5UrV2LXrl1hjzV//nzk5eVh/fr12Ldvn+B4sXPnTqxduxaHDh1Cz549MW/ePOzatQv79u3DI488Ipj8huP777/HiBEjwm7z8MMP49tvv0WfPn0wZ84clJSU4MUXX0RVVZVku/LyckydOhV5eXm47rrr8O6770Y8f3tCghgjDKNCYaEu8oYEQcQtHSGGJ2MUxClTpgAABg4cCI1GA4vFgp9//hk//vgj7rrrLpSWlmLUqFFoamrCoUOHWnWdN910k2AODACffPIJRo4ciSFDhmDhwoWyRcAjsX79epSWlqKgoABvvPGGsDw7OxuzZs3C9u3bsWXLFlRXV6OoqEjo/fp8PomLx4wZMzp92JSSaloBw1APkSASlY4Sw94ZsSWziItTMwwDn88HjuOQmZmpKFQMw0jc5l0uV9hzpKamCr+fOHECc+bMwa5duwQ/xDFjxkRs57Bhw7Bq1Srh86RJkzBp0iTcd999aG5ulmxbVVWF9evXY/369UhLS8Py5ctx2223AQA2b94Mm82GCRMmAAi43NfW1uKHH37AkCFDIrajPaAeIkEQhIiOEsNeMQqiHAMGDEB6erokpnjs2DE0NDQAAPr164f//Oc/ACD4IfKkp6fDbrcrHttut0Or1SI3Nxccx0lik+GYPHkyzpw5g8WLF0vEmLd/AoBt27Zh5MiRuP3226FWq/H+++9jx44dmDVrFnr06AEgMFy6bNkyVFdXo7q6GsePH8eTTz7Zqb1E6iHGiNXqg8lEt40gEpXfrntUdnlfjFPcZ5DC8l4Arm5zi1rg/RDnzp2LpUuXwu/3Izs7G+vWrQMQ8EN87LHH8MILL2DixImyfojJyclYvXp1yLHFfohZWVlCz00OPiY5c+ZMpKSkYMeOHSgrK0O/fv1gNBqRlJSE0tJS3H777QCAtLQ0rFq1CoMGyd+p2tpabNu2LaRdU6ZMwfjx4/Hyyy9Dp+v4UBX5IcbA3Llz0afvBpjNGky++3innZcgiI6B/BATC/JD7ESMRiPMZg0sFl9XN4UgCIJoZ2jsL0ZouJQgCCIxoR5iKyBRJAiCSDxIEGOgtaWNCIIgiO4PCWIMWK1W+P1xl4NEEARBRAEJYgx4PB5UVnpIFAmCIBIQCobFgNlshsvFobLS09VNIQiig1iwYIHwu9vthsVigU6ng8lkglrd0oew2Wyw2WwwGo0SSySWZWG1WuHxeGA2m6HX62WP3dnEg/1TRUUF5s2bhz179iAzMxMMw+Chhx7CAw880Ko2xwr1EGNAr9ejqEgHl4t6iASR6LS3GLrd7s5sfgjd3f7JYrHg2muvxYQJE1BVVYU9e/bgo48+gs/XedPcSBBjJDlZjaIiKu5NEIlMR4ihkhjJcTHaPy1fvhyjR4/Ggw8+KCzr0aMHZs6cGfV9ayskiK0gOZluG0EkKh0lhrGWHrvY7J/27NmDkSNHRr4xHQg92WOgq4c8CILoeDpKDMU2S9Fwsdk/dQcoqSYGLBYLHA6WeogEkcB0lBiKjxcNF5v90xVXXIGdO3fiiSeeiHjOjoKe7DGg0+lQUeGBw0ET9AkiUekOYqhEIts/PfLII9i+fbvk2mw2G15//fWo2tEexPRX8vv9+P3vf4+CggIkJSWhqKgIixYtkmQPcRyH+fPnIzc3F0lJSbj++utx9OhRyXEaGhowZcoUpKenw2g04v7778f58+fb54o6EJPJBINBhYoKmnZBEIlKdxVDoMX+6b333kNxcTEGDx6M+++/H06nE0DA/unxxx/H5Zdfjr1798raP/FJNcGI7Z+GDx+OPn36KLZj/vz5WLFiBQAI9k9Hjx5Fv379MGzYMIwaNQrZ2dkh9k979+7FM888I3vs3NxcfPXVV9i8eTMKCgpQXFyM8ePHQ6vVtuWWxQYXA4sXL+aysrK4zZs3c1VVVdyGDRu41NRU7n/+53+EbZYsWcJlZGRwGzdu5Pbv38/dcsstXEFBAed0OoVtbrzxRq6kpIT79ttvuS+//JLr168fd/fdd0fdDrvdzgHg7HZ7LM1vM3/4wx+4jz4u4P62omennpcgiI7B6XRyhw4dkjyfiPhF6e8ZrWbEFEP85ptvcOutt2LixIkAgPz8fLzzzjv47rvveHHFsmXL8MILL+DWW28FAKxduxYmkwkbN27EXXfdhcOHD2Pr1q3YtWsXrrzySgDAX//6V9x000145ZVXkJeX135q3wEwjAqFhTTtgiAIItGIqS8/atQobNu2DUeOHAEA7N+/H1999RV+9atfAQgETC0WC66//nphn4yMDIwYMQI7d+4EEEjzNRqNghgCwPXXXw+1Wi2MfQfjdrvR2Ngo+elKGEbVpecnCIIg2p+YeojPPvssGhsbMXDgQCGbafHixUJ6MD/xNDi92GQyCessFgtycnKkjdBokJmZqThx9aWXXsJ///d/x9LUDkE84ZUgCIJILGLqIf7jH//A22+/jXXr1uH777/HmjVr8Morr2DNmjUd1T4AQFlZGex2u/Bz8uTJDj2fEjabDVZr55URIgiCIDqPmHqITz/9NJ599lncddddAAJZScePH8dLL72EadOmCUVjrVYrcnNzhf2sVqtQGcFsNqO+vl5yXJ/Ph4aGBsWis3q9XpLF1VUYjUZYLCSIBEEQiUhMPUSHwxGSQswwjFAUtqCgAGazGdu2bRPWNzY24j//+Y9QkmfkyJGw2WzYs2ePsM1nn30GlmUjlv/paoxGI8xmDYkiQRBEAhJTD/HXv/41Fi9ejD59+mDw4MHYu3cv/vKXv2DGjBkAAoVl586diz/+8Y/o378/CgoK8Pvf/x55eXlCNYJBgwbhxhtvxIMPPogVK1bA6/Vizpw5uOuuu7p9hikAmExU3IcgCCIRienp/te//hW///3v8cgjj6C+vh55eXl4+OGHMX/+fGGbZ555Bs3NzXjooYdgs9lw7bXXYuvWrZIyRG+//TbmzJmD8ePHQ61W44477sBrr73WflfVwZAoEkTi8vEnhais9MDl4lBUpJOUanQ4WFRUeGAwBKZfiTPOrVYfLBYfzGaN5Bnh93PC8eY+XtOp1yKmO/shbtq0SdARi8UCv9+Pnj17AgiE6vjEzY4mpid7Wloali1bhmXLliluo1KpsHDhQixcuFBxm8zMTKxbty6WU3cLWusXRhBE/NBRYtjVtnHLli3DuHHjZAWRf7a1pqoO74c4ZcoUHD16FAzDwOPxoLy8HDU1NcjKykJDQwN69OgBlUp+ytott9yCW265BUDARNlms4XVmY6CapnGgNVqhd9P5sAEkch0lBjGYgpwMfohdgdIEGPA4/GgstJDokgQCUxXiyHPxeaH2B0gQYwBs9kMlyvwj04QRGLSHcQQID/EroCyQ2JAr9ejqEhHbhcEcRHQ3mIYq23cxeaH2B2gHmKMJCeruzw4ThBEx9IRYtgeL9KJ7IfYHaAeYito7RAIQRDdn/HXVXR1ExTh/RDnzp2LpUuXwu/3Izs7W8jaX7p0KR577DG88MILmDhxoqwfYnJyMlavXh1ybLEfYlZWVtieGx+TnDlzpuCHWFZWhn79+sFoNCIpKQmlpaUhfoiDBg1q1/vR3qg4jou7DJHGxkZkZGTAbrcjPT29085bVlaG63/5DwDd+0tDEER0uFwuVFVVoaCgQDJEScQnSn/PaDWDujoxYLFYYo4DEARBEPEBCWIM6HSBhBoSRYIgiMSDBDEGTCYTDAYVZZkSBEEkICSIMaBWq1FYqIPBIF9+iCAIgohfSBBjhGECadgEQRBEYkGC2ArEc5IIgiCIxIDmIcaAuGguQRCJSeay/wNjzgNjavFn5fx++CqPgHO5oCnqD3VyS4UX1nEevoqjUBkM0BReCtWFAtcA4LfWwm+pFY5n+UVpZ16KhI6wf9q9ezceeOABAEBDQwPsdjsKCgoABErPPf3001Ef//PPP8d1112HtWvXYurUqa1qY1shQYwBm80Gq9VHfogEkcB0lBh2NR1h/3TllVcKZeRWr16NjRs3YuPGjcJ6m82GtLQ0wQUjHOXl5Rg/fjzKy8u7TBBpyDQGjEYjLBYfrFZfVzeFIIgOojuIYTzZP4Xj66+/RlFRER599FHs3LlTcTubzYYPPvgAb731Fg4dOoRjx4616bythQQxBoxGI8xmDSwWEkSCSHTaWww5UZ3PaIgX+6dwTJw4EQcOHMDw4cOxaNEiDBgwAM8//zx+/PFHyXbr1q3DhAkTYDabcc8990iKhXcmJIgxYjJpYDbTkClBJDIdIYa+yiMxtSFe7Z+CSU9Px7333osPP/wQ33zzDQCgpKQECxYsELYpLy/HjBkzAAAzZszAmjVrJIXCOwt6srcCiiESROLSUWLIRbBiCiZe7J+iwWKxYMOGDXj33XfhdruxZMkSQfD37duHAwcO4MEHH4RKFcjgP3PmDLZs2YKbb765Xc4fLdRDjAE+8EwQROLSUWKoKerf5rZ1R/uncOzbtw/jx4/HuHHjcPr0aaxatQq7d+/GU089hdzcXACB3uHvfvc7HD9+HNXV1aiursayZctQXl7e5vPHCgliDFitVvj9cWcOQhBEDHSUGIqP11p4+6f33nsPxcXFGDx4MO6//344nU4AAfunxx9/HJdffjn27t0ra//EJ9UEI7Z/Gj58OPr06aPYjvnz52PFihUR26vVavHSSy/hp59+wsKFCzFgwADJepfLhbffflvoLfLceeed+Pjjj2G1WiOeoz0h+6cYmD59OkZc/QkKC3W44ZeVnXZegiA6BrJ/SizI/qkTMZvNcLkCrtgEQRBEYkGCGAN6vR5FRTq4XHHXqSYIgiAiQIIYI8nJahQVUXFvgiCIRIMEsRUkJ9NtIwiCSDToyR4Dbre7q5tAEARBdBAkiDFgsVjgcNBcRIIgiESEBDEGdDodKio8JIoEQRAJCNUgiwGTyQSDQYWKCpp2QRCJSv6zHwi/++z18Nmt0GSYoMnIEZZzrB+e+mpwXhd0OQVQ65OFdazbAU99FVRaA3Q5+VCpWybxVy+Z2DkXIUN39kOsr6/HvHnzsH37dmRkZEClUuE3v/kNnnvuuVa1tbWQIMaAWq1GYaGO5iESxEVAe4uhz17fqe0Pprv6ITqdTowdOxaTJk3C0aNHwTAMHA4H3njjjZja0h7QkGmMMIwKhYU07YIgEpmOEEOfPfoyZBeTH+K6deuQlpaGBQsWCMKZnJzcZuup1kCC2AoYRtXVTSAIooPoKDHUZJgQCxeLH+KePXswcuTINp2nvSBBjAHxmxdBEIlJR4mh+HjRcDH5IXYXKIYYAzabDVarj/wQCSKB6Q5iCFw8fohXXHEFVq5c2S7naSvUQ4wBo9EIi8UHq9XX1U0hCKKD6A5iqEQi+iHefffdsNlsWLRokSDmTqcTr732WpvPHyskiDFgNBphNmtgsZAgEkSi095iyLF+tJVE80MEAgk027dvR0VFBfr164ehQ4dixIgRcDgcUdyR9oX8EGNgwYIFGD3m77BafZh89/FOOy9BEB0D+SEmFuSH2AVQDJEgCCLxIEGMAX7yKkEQBJF4kCDGgNVqhd8fdyPMBEEQRBSQIMaAx+NBZaWHRJEgCCIBIUGMAbPZDJeLo1qmBEEQCQgJYgzo9XoUFengclEPkSAIItGgdMkYSU5Wo6iIinsTRMKyIAONbg77LSxSdECxSQ2NuqV+cbWNRbWNQ75RhXxjS5/Cx3I4YGXR7AFKzGqk61v24Y83+s3znXopRGxQD7EVJCfTbSOIRKWjxDCli9+jly1bBovF0ur9g500gIAfYmlpKUpLS9GnTx9kZGQIn//85z9HfWyr1YoZM2agsLAQJSUlKC4uxsyZM3H27NlWt7c1UA8xBtxud1c3gSCIDqajxLDY1LUv0t3VD9HhcGDMmDGYMmWK4Ifo8XhQXl6OmpoaSbWdjoa6OjFgsVjgcNBcRIJIZDpKDMXHi8TF5ofYo0cPzJ8/XxBOnU6HWbNmobi4uE3njxUSxBjQ6XSoqPCQKBJEAtPVYshzsfghfv/99xgxYkSbztNekCDGgMlkgsGgQkUFTbsgiESlO4ghcPH6Ia5fvx6lpaUoKCjAG2+80ebzxwLFEGNArVajsFBH8xAJ4iKgvcWw2sYiP4bzXyx+iMOGDcOqVauEbSdNmoRJkybhvvvuk9hXdQbUQ4wRhlGhsJCmXRBEItMRYlhta/v85UT0Q5w8eTLOnDmDxYsXS8S8K+yfEr6HeOrZLwEAvZaMbrdjMkzrhkAIgogDFtiRD8j25jQALlfYLR2A0lNG6Xixwvshzp07F0uXLoXf70d2djbWrVsHIOCH+Nhjj+GFF17AxIkTZf0Qk5OTsXr16pBji/0Qs7KycNtttym2g49Jzpw5M2x7eT/Eq666SnGblJQU7NixA2VlZejXrx+MRiOSkpJQWlqK22+/PfwNaWcS1g/x1Uk3AwAmFcxDk7sZg5be2Obzzp07F7++5d8AgPHXVbT5eARBdC3kh5hYdLofYk1NDe655x5kZWUhKSkJQ4cOxe7du4X1HMdh/vz5yM3NRVJSEq6//nocPXpUcoyGhgZMmTIF6enpMBqNuP/++3H+fMdUcGhyN+NwffuIl81mg9Xqa5djEQRBEN2LmATx3LlzuOaaa6DVarFlyxYcOnQIr776Knr06CFs86c//QmvvfYaVqxYgf/85z9ISUnBhAkTJMHdKVOm4Mcff8Qnn3yCzZs3Y8eOHXjooYfa76ou4PJ6cbi+AsnapHY5ntFohMXiI1EkCIJIQGKKIb788svo3bu3JKBbUFAg/M5xHJYtW4YXXngBt956KwBg7dq1MJlM2LhxI+666y4cPnwYW7duxa5du3DllVcCAP7617/ipptuwiuvvIK8vLz2uC64vF7U2ZtwRXoSBuUUtssxjUYjzGYNLBYSRIIgiEQjph7ipk2bcOWVV+K3v/0tcnJyMGzYMMk8kaqqKlgsFlx//fXCsoyMDIwYMUKoUrBz504YjUZBDAHg+uuvh1qtFrKjgnG73WhsbJT8RKLO3gQdw2BQTiEYtXLZoFgxmTQwmxM+F4kgCOKiIyZBrKysxN/+9jf0798fH330EWbNmoXHHnsMa9asAQChcKx4oif/mV9nsViQk5MjWa/RaJCZmalYePall15CRkaG8NO7d++IbdUxDHIz0ttVDHlMJhJEgiCIRCMmQWRZFpdffjlefPFFDBs2DA899BAefPBBrFixoqPaBwAoKyuD3W4Xfk6ePBlxn9yMdKhbWSFCCb4ALkEQBJF4xNTVyc3NxWWXXSZZNmjQIPzzn/8EAKGKutVqFSZd8p/52nlmsxn19fWSY/h8PjQ0NMhWYQcCNf30en0sTZWI4Sm7Bb1i2lseq9UKv5+jeYgEkcAMXTMUnJ+D65QLrJuFobcBTFLLSJPf6YfrpAtqvRqGXgaoRM8DzxkPvGe80GZroctuKeDBH+/Y/GPt3l45l4lYqK6uxtatWyPOKVQiOzsbu3fvRn5+vuz6zz//HNdddx3Wrl2LqVOnxnz8iooKzJs3D3v27EFmZiYYhsFDDz2EBx54oFXtDUdMPcRrrrkmpPr5kSNH0LdvXwCBBBuz2Yxt27YJ6xsbG/Gf//wHI0eOBACMHDkSNpsNe/bsEbb57LPPwLJshxR4PWW34KS99R5gYjweDyorPfD7427qJkEQMaBiVDD0MkCtV8N10gW/s6WCCpPEwNDbANbNwnXKBU70PNBl66DN1sJ7xgvPGU/I8boj1dXVHTrKV15ejvHjx6O8vFyyvKGhAZGmwVssFlx77bWYMGECqqqqsGfPHnz00Ufw+TomsTEmQXziiSfw7bff4sUXX8SxY8ewbt06rFy5ErNnzwYQsB6ZO3cu/vjHP2LTpk04ePAg7r33XuTl5QlVDwYNGoQbb7wRDz74IL777jt8/fXXmDNnDu666652yzDlOdfswEm7Bb0z5HuesWI2m+FycVTLlCAuAjpCFKPB6XRi0qRJuOyyy1BSUoIbbrgBAPD3v/8dI0aMwOWXX44xY8Zg//79svuH2+7ll1/G0KFDUVJSgquvvhoOhwMzZ87Ezz//jNLSUtxyyy0AwltMbdq0CYMGDUJxcTGeeeaZsNdis9nwwQcf4K233sKhQ4dw7FhLD3nDhg3o378/ysrKcPDgQdn9ly9fjtGjR+PBBx8UlvXo0aPVvdlIxDRkOnz4cPzrX/9CWVkZFi5ciIKCAixbtkwo0goAzzzzDJqbm/HQQw/BZrPh2muvxdatWyVVA95++23MmTMH48ePh1qtxh133IHXXnut/a4KATFscDjRu7cZvdpJEPV6PYqKdOR2QRAJjOeMRxju5EXRdcoF10mXZPiUF0XXSRdcp1yS4VN+f+8Zr+RzNGzduhU2m01wsGhoaMDXX3+Nd955Bzt27IBer8eXX36JyZMnS2yUAITdbs2aNfjnP/+Jr776ChkZGTh37hz0ej1WrFiBuXPnCgXDeYupt956CwMHDoTD4cDVV1+NESNGoG/fvpg+fTq+/PJLXHbZZVi5cmVYV/t169ZhwoQJMJvNuOeee7Bq1Sq8+OKLAICHH34Yd9xxBzZs2IA5c+bAZrNh0qRJuPvuu4XpfHv27MEvf/nLqO9dW4k5XfLmm2/GzTffrLhepVJh4cKFWLhwoeI2mZmZQu29jqLB4URmclK7iSFPcrIaRUVU3JsgEpVgEetsUSwpKcHhw4fxyCOPYOzYsbjpppvw/vvvY//+/ZKwUkNDA5xOp2TfcNtt3rwZM2fOREZGBgBICqqIEVtM8fAWU3V1dSguLhZySe6//348+uijitdSXl6Ol156CQAwY8YMTJgwAYsWLRKMgLOzszFr1izMmjULtbW1WLBgAYqKilBeXo7p06dHdb/ak4SdP5CZnIQeKckdcuzkZDIJIYhEhR/uBNpfFKOhsLAQhw4dwmeffYZPP/0UzzzzDG644QZMmzZN6F0pwXFcVNtFOoaSxdSmTZskn1Uq5WHgffv24cCBA3jwwQeF7c6cOYMtW7ZIOlVVVVVYv3491q9fj7S0NCxfvlwIsV1xxRXYuXMnnnjiiVZfTywk7JNdLIZ+1h9my+hxu93tchyCILovkRJj2hJTjIZTp05BpVLhlltuwSuvvAKO43DPPffgrbfewokTJwAEpoCJa0jz3HLLLYrb3XLLLVixYoVgAWWz2eD3+0NsocJZTI0cORIHDhzATz/9BABYtWoVPB75EFJ5eTl+97vf4fjx46iurkZ1dTWWLVsmJNds27YNI0eOxO233w61Wo33338fO3bswKxZs4Te6yOPPILt27dL2mKz2fD6669HdS9jJWF7iDx+1o/D9ZXoi3FRbb+2T1/01GoxviI0PdpiscDhYKmHSBAJjtJwZ1t7itFw8OBBlJWVgeM4+Hw+TJ06FWPHjsWf/vQn/Nd//Rd8Ph88Hg8mTpwoqfgFAKNHj1bcburUqaitrcWoUaOg0WiQkpKCTz/9FMXFxRg8eDCGDBmCwsJCbNq0SdFiqmfPnli1ahX+67/+CzqdDjfeeKPEYoq3hbrvvvvw9ttvY/v27ZL23XnnnXjqqadgtVqRlpaGVatWYdCgQYr3Ijc3F1999RWeffZZLFy4EGlpadBqtUIiZ3uT0PZPLMthaModcHiduP3t6G7gtqJ+qPF6ce+J4yHrHn74YQy6bDOKinT49c1VbboGgiC6HrJ/Sizaav+UsD1EluVQZ29Ekc6JQTlFUe+Xp9UqrjOZTDAYVJRlShAEkYAk7Nhfnb0RHr8fg3KKkKZPiWlfJVFUq9UoLNTBYKBKNQRBEIlGwgqix+9HbkZazGIYCYZRobCQpl0QBEEkGgkriLkZaTCEGf5Uwh9FSJVqmRIEQSQeCSuIYjFscjdHvd8Rt1tRFG02W9h9h64ZiqFrhkZ9LoIgCKL7kLCCyNPkbsbh+oqot3eyLI4ozDe02WywWpWLyornJREEQRDxRcJmmQKAy+vF4foKJGuTot7nUr1eURCNRiMsFmVB5OclEQQRvxwe2DIv7rzfjyNuN5LUalyq14MRVWap9XpR4/Wip1YrScTzcxyOuN1wsiwu1euRyrRYRw366XDnXATRKhK2h+jyelFnb0KyNgmDcgqj3i+VYXCpgvei0WiE2axRFEW+ggVBEPHLeX/LSA//POBHjsThlDytFj21WtR4vaj1tlShYVQqXKrXI0mtxhG3W3K8jmD16tVCqbPW0Fb7p+zsbFRXVyuu//zzz6FSqfD3v/+9Vcc/duwYfvvb36KgoADDhg1DSUkJnn766Q6pHJawglhnb4KOYTAopxCMmom8gwjxG10wJpMGZrN8x5ov60QQRPwSLGLxIIptoTv7IdbV1eHaa6/FjTfeiKqqKuzduxfffPMN0tPT0dTU1O5tTdint45hkJuRHrMYRoPJJC+I3dkElCCI6JATsc4URfJDbGH58uUYN24c7r//fmFZSkoKfv/73yM7OzvCnYydhI0h5makQ62OfXrEeb9fsYfIsmzE/aM1ASUIonvC5xEccbslMUBeFMXr+JgiH0OsuSCI/GdeFPl9hkdxfvJDbPFD/P777zvVDzFhe4hiMTxlt0S9X7g3OavVCr8/7kq/EgQRA+F6dm3tKUaD2A9x/fr10Gq1Ep/D0tJSPProoxH9EIO3k/NDZGRe/sV+iKWlpRg1apTgh/jtt9+G+CHqdMqFSsrLyzFjxgwAAT/ENWvWwC+6n7wf4vbt27FlyxZUV1ejqKhI4m4hZunSpSgtLUWfPn2wdevWqO5nLCSsIPKcsltwMgZB5L8Ecng8HlRWehRFUWwVQxBE/NJRohgNvB/ijTfeiK+//hpDhgzBuXPnMG3aNOzbt0/4qaurQ1KSNIOe90OMtF04xH6I/E9VVRWmTZsWsm20foj5+fm4+eabBT9EMVVVVViyZAkmTpyIn376SeKHOGzYMHz33XfCtk888QT27duHwsJCuFztn8CY0IJ4rtmBk3YLemeYo94n3Juc2WyGy8WhslJe+IL90wiCiF86QhSjgfwQW/wQZ8+ejW3btmH16tXCcVmW7RAxBBI4hniu2YEGhxO9e5vRKwZBDPcmp9frUVSkU3S7iMUElCCI7knwXMEhYbZVigkqO/xFhvwQW8jLy8OXX36J5557DgsWLEBWVhb0ej3Gjh2L0aNHt+Euy5OwfoiPXDcSmclJmDnkvwEAvZZEd/P4SblyE2gXLFiA0WP+DoeDlfVDHLpmKDxnPPj5dz9HeykEQXQh5IeYWLTVDzFhh0wzk5PQIyW5Q46dnKx822JxxiYIgiC6DwkriGIx9LPRT4oVj/kH0xGVEQiCIIjuQcIKIo+f9eNwfWXU2wcHwsVYLBY4HMpzETmakkEQBBG3JLQgsiyHw/WVcHidkTe+AJ8dJodOF0ioURJF1ykXiSJBEESckrBZpizLoc7eiCKdE4NyiqLeLy+MqbDJZILBoFLMMmXdLFynqLg3QRBEPJKwPcQ6eyM8fj8G5RQhTZ8S075KoqhWq1FYqIPBID+fyNDbANYdubwbQRAE0f1I2B6ix+9HbkZazGIYCYZRobBQPpOUSWLID5Eg4pwnb/0f6DQG9MwqhFpkDtDQZMXZJguy0szITDMJy1nWj5qzlfD4XOiZVQSDriWhz+VxoOZshXC8R1e2f13O1atXY+PGjdi4cWOr9q+ursbWrVsxc+bMVu2fnZ2N3bt3Iz8/X3b9559/juuuuw5r167F1KlToz7upk2bMH/+fACB/A2/34+ePXsCAJ5++mlMmTKlVe0NR8L2EHMz0mAIM/yphD+KaZlMmALeTFL7u2sQBNF59MwqgsfnQs3ZSrCiDPXMNBOy0sw422RBQ5NVWK5WM+iZVQidxoCasxVweRzCOoMuWXK87kh3tX+65ZZbhNJxM2fOxJQpU4TPHSGGQAILolgMm9zNUe8XXIZJjM1ma2uzCILo5gSLWHuKYjSQ/VPXkbBDpjxN7mYcrq+IupQSX5tQrlyTzWaD1epT9EP0O/3UQySIBIAXsZqzFag5WykZPuWHS882WSSfeVGsOVuJmrMVkuFT/njRQPZPLfZPnU3C9hABwOX14nB9BZK10Vd65wv2ymE0GmGx+GC1+uTPd9IFv7P7OmMTBBE9HdFTjAayf1K2f+poEraH6PJ6UWdvwhXpSRiUUxj1fnwVezmMRiPMZg0sFnlBVOvVcJ2kaRcEEc+4PI6Qnl179RSjgbd/+uyzz/Dpp5/imWeewQ033IBp06YJvSslePunSNtFOgZv/xTMpk2bJJ+jtX/it+Ptn26++WZhu6qqKqxfvx7r169HWlqaxP6ps0nYHmKdvQk6hsGgnEIw6tiGMVNl3pp4TCYNzGb59whDLwPU+oS9pQRxURApMaatPcVIkP1Ti/1TZ5OwPUQdwyA3Iz1mMYwGpRiiilHB0IumXRBEPMOLmFwMsK09xWgg+6euI2Htn/7824lQq1WYVDAPQPT2T7v6X4pUhpG1f5o/fz7GjnsbADD+uoqQ9UPXDAUAHJzWPTKmCIIID9k/JRZk/6SAWt0ytn3Kbol6v2BnbDFWqxV+qlVKEASRkCSsIPKcsltwMgZBTFKrcUTB5snj8aCy0qMoip4z8mPpBEEQRPcnYWOIAHCu2YGTjAW9M8xR73OpXq8oiGazGS4Xh8pKeeHznlH2UiQIgiC6NwnbQzzX7ECDw4neGWb0ikEQGZVKcdqFXq9HUZEOLpd8D1GbrSVRJAiCiFMStofY4HAiMzkpJjHkYcLMrUlOVqOoSH4iqi5beYIqQRAE0b1J2B5iZnISeqREPxk2FpKTlW8biSJBEER8krCCKBZDPxt9ObVar/KQp1shtkgQBEHEPwk7ZMrjZ/04XF+JvhgX1fY1FwRRbqqoxWKBw8Eq9hA5PwdVGGsogiC6P69OCpQV4/MQgkebWJYTDMiDbeb4kpF8YRDx9K9zzQ78cfNn7d7e7uyHWF9fj3nz5mH79u3IyMiASqXCb37zGzz33HMxnaO1noqxkrA9RCDwj3u4vhIOrzPyxhfoqdUKohiMTqdDRYUHDod88W/XKRc4mqdIEAlBj5RkZCYnocHhxLnmltJrarUKuRnp0DEM6uxNcImeFwatFrkZafD4/aizN4JlOcnxuiMd5YfodDoxduxY9O3bF0ePHsXevXvx1VdfISUlYNrOl46LBiVPxfYmYQWRf4tzeJ0YlBNdySQAyNNq0VPBWNhkMsFgUKGiQn7aBetm4TpFxb0JIp4JFrH2FMVoSBQ/xHXr1iEtLQ0LFiwQXDWSk5Px+OOPAwhYVRUVFeHRRx/Fzp07FY8TzlOxvUnYIVN+SGNQThHS9Ckx7ZunIIhqtRqFhTrFeYiG3gZyuyCIOKfO3igZ7uR7dg0Op+QzL4p19kbU2Zskw6e8KNbZm0KOF4lE8UPcs2cPRo4cqXidEydOxOjRo7Fx40YsWrQIFRUV+M1vfoPJkydj8ODBwnbhPBXbm4TtIfLj+7GKYSQYRoXCQvlMUiaJgaE31UMkiHhGabizs3qKieSHGIn09HTce++9+PDDD/HNN98I179gwQJhm0ieiu1JwvYQg4Pd0eLnuLDzEIGAKCquS2p/dw2CIDoPpZ5de/QUoyFR/BCvuOIKrFy5MuL5LBYLNmzYgHfffRdutxtLlizBlClTAETvqdheJGwPUSyGTe7mqPc74nbDr2AAYrPZ2tosgiC6OZESY9rSU4yGRPFDvPvuu2Gz2bBo0SKhR+d0OvHaa68BCIjd+PHjMW7cOJw+fRqrVq3C7t278dRTTyE3NxdAZE/F9iZhe4g8Te5mHK6vkJ1GIYeTZXHE7cYQmXU2mw1Wq0/RD9Hv9FMPkSDinN+t39yl508EP8SZM2ciOTkZ27dvx7PPPot+/fohNTUVKpUKkydPBgBotVq89NJLuOqqq2Tvg8vliuipaDKZ2vXeJ6wf4quTbobL68WgpFuQrE3CjatnhGxjnrwElnXPSpbt6n8pjrjdmHLieMj2c+fORZ++G2A2azD57tD1hc8XwtDbgEMzD7XyygiC6EzIDzGxID9EBfgJssnaJAzKKZTdRpMR+naRyjCKxb2NRiPMZg0sFp/serVeTVmmBEEQcUrCDpny1SIG5RSCUcsPY2oycmSXp8pkXvEoDZcCgKGXgeYhEgRBxClt6iEuWbIEKpUKc+fOFZa5XC7Mnj0bWVlZSE1NxR133AGr1SrZ78SJE5g4cSKSk5ORk5ODp59+Gj6ffK+rtfClk5TEsC0oiaKKUcHQi4ZdCIIg4pFWC+KuXbvw+uuvo7i4WLL8iSeewL///W9s2LAB27dvR21tLW6//XZhvd/vx8SJE+HxePDNN99gzZo1WL16NebPn9/6q5AhlomwYs6HyQRjWfmSbWKolilBEER80ipBPH/+PKZMmYI33ngDPXr0EJbb7XaUl5fjL3/5C6677jpcccUVePPNN/HNN9/g22+/BQB8/PHHOHToEN566y2UlpbiV7/6FRYtWoTly5crpu+2BrEYnrJbZLfhZFwwjrjdiqJotVrhp1qlBEEQCUmrBHH27NmYOHEirr/+esnyPXv2wOv1SpYPHDgQffr0EWrV7dy5E0OHDpWky06YMAGNjY0hZYh43G43GhsbJT/RcspuwUkFQfTUV4csS1KrcUTB5snj8aCy0qMoip4z7SfoBEEQROcSc1LNu+++i++//x67du0KWWexWKDT6WA0GiXLTSYTLBaLsE3w3BH+M79NMC+99BL++7//O9am4lyzAycZC3pnmGXXc97QBJhL9XpFQTSbzXC5OMVapt4zyl6KBEHEB6ee/VL4nbeP400CxKUg+TnOfCa7OF+BfxHvnWFGL9Hzp9eS0e3e3kS3f7JarSgrK8MXX3yBtLQ0cByHUaNGYfHixZI5kO1BTD3EkydP4vHHH8fbb7/dqXN2ysrKYLfbhZ+TJ08K676cniq7D+9lFvwPKUaXUxCyjFGpFKdd6PV6FBXp4HLJ9xC12VoSRYKIc8QhFkYdyFRP1ibhcH2FpOpVmj4Fg3KK4PA6cbi+UmJE3ivDjN4ZZpy0WxRDNt2F7mz/5HA4MGbMGOTn5+Po0aPYv38/du/ejZKSEtTU1LR7m2MSxD179qC+vh6XX345NBoNNBoNtm/fjtdeew0ajQYmkwkejyekxJnVaoXZHBAls9kcknXKf+a3CUav1yM9PV3yw5OiUFeWN/ZUEkMAUOvl/cnC1TJNTlajqEj+pLpsHbTZsddPJQii+xAsYp0timT/JD1Gjx49MH/+fOEYOp0Os2bNCknobA9iGjIdP348Dh48KFk2ffp0DBw4EPPmzUPv3r2h1Wqxbds23HHHHQACldNPnDgh2ICMHDkSixcvRn19PXJyAvMAP/nkE6SnpwsV1GOh2CSv6cEu1+1JcrLye4Quu/WV3wmC6Hp4EQMgvFDzoni4vjJQClI0fMqL4uH6Chyur5QMn/L7C8eL4vxk/9Ri//T9999jxIgRUdy19iEmQUxLS8OQIdIqnykpKcjKyhKW33///XjyySeRmZmJ9PR0PProoxg5ciSuvvpqAMANN9yAyy67DFOnTsWf/vQnWCwWvPDCC5g9ezb0CkOVYS9AYWqFWAz9MtmkStR6vYp+iG6F2CJBEIlDiIi1oyheHcX5xfZPY8eOxU033SSxdeKJZP8UvJ2c/ZMcYvsnHt7+qa6uLsT+6dFHH43iquTh7Z/uvfdenD17Fn/5y19QUlKCF154QWIBxbN+/Xq89NJLsNvteO655/Dggw+2+txytHvptqVLl+Lmm2/GHXfcgTFjxsBsNuO9994T1jMMg82bN4NhGIwcORL33HMP7r33XixcuLC9mwKgJSguB+t2hCyr8XpR65WPA1osFjgcynMROZqSQRAJgdJwZ1uHT6OBt3+68cYb8fXXX2PIkCE4d+4cpk2bhn379gk/dXV1SEpKkuzL2z9F2i4cYvsn/qeqqgrTpk0L2TaS/RM/3S4cFosFf/3rX3HLLbfgo48+wpIlS/Dwww8DAIYNG4bvvvtO2HbSpEnYt28fxo4di+bm6F2MoqXNgvjFF19g2bJlwmeDwYDly5ejoaEBzc3NeO+990Jig3379sWHH34Ih8OB06dP45VXXoFG0/5V5FiWEzLE5PDUV4Us66nVokZBEHU6HSoqPIqi6DrlIlEkiAShI0QxGsj+qcX+afLkyThz5gwWL14sScBxOEI7M+1B3NcyrbaxyJdZzrIc6uyNKNIF0qXlUGlDM2WVhkuBwPQQg0GFigr5fwDWzVItU4KIc/ysXzkG2Mbh02gg+6cWUlJSsGPHDpSVlaFfv34wGo1ISkpCaWmppAJaexH39k/fP5aHcavPh2zz5A2j4fH7Mbt4PtL0KbLzf/o+swnH/3SLZNnhgQHnxEE/HQ7ZfsGCBRh1zVpUVnow8+FTIesvW3EZXCddqFwsP0RLEET3guyfEouL3v4p3yg/hu3x+5GbkSaZSBuMqhWFvxlGhcJC+UxSJomBoTd9qQiCIOKRBBBE+UvIzUiDIczwpxL+KDrMTJgC3kxS+7trEARBEB1P3AuiEmIxFAe9I3HE7VYUxeCCAwRBEETikLCCyMPXG5TDZ68PWeZkWcVapjabDVarsm+j3xn9fEeCIAiiexH3guhjlYc4XV6vUHxXdl+7NWTZpXo9nAq+h0ajERaLT1EUXSddJIoEQRBxStwL4gGrwpxArxd19iahEr0cmgxTyLJUhlEs7m00GmE2a2CxyAuiWq+G6yRNuyAIgohH4n4eYrOCBWGdvQk6hgk7B0iTkSO7PJVRTowxmZRvmaGXgeYhEgRBxClxL4glZvlOro5hkJuRHtOE2GhREkUVo4KhF027IIh45uGHH4bH44HZbJbUV3a73YLnq8lkglrd8uyx2Wyw2WwwGo0SP1iWZWG1WoXjvfTSS+3e3kT1Q9y9ezceeOABAIF6rHa7HQUFAcu+KVOm4Omnn25Ve8MR90Om6Xr5KRC5GelQKxT+Dsf5MP5crEJsUYwqzJQMgiC6PyaTCTqdDhaLRVLQX6/Xw2w2w+PxwGq1Sp4HvBDywsijVqslx+uOdFc/xCuvvFKopbpw4UL84he/ED53hBgCCSCISojFUMmLjJNxwTjidiuKotVqhZ9qlRJEQhMsYu0pitFAfohdR9wPmUbilN2iaLviqa8OWZakVuOI243hctt7PKis9ChWqvGc8ZAfIkEkALyIWa1WWCwWyfApL4oWiwVWq1UyfMoPl/KCyH/mjxcN5IfY4ofY2cS9IDa6OShVpjvX7MBJxqJou8J5QxNgLtXrFechms1muFwcKivlM3m8Z+RdMgiCiD86QhSjgfwQlf0QO5q4F8T9FhahZbsDYtjgcKJ3b7Oi7YoupyBkGaNSKU670Ov1KCrSKbpdaLO1JIoEEefwyTFA+4tiNPB+iJ999hk+/fRTPPPMM7jhhhswbdo0vPjii2H35f0QI20X6Ri8H2IwmzZtknyO5Ie4cuXKiOezWCzYsGED3n33XbjdbixZsgRTpkyJud3tQdzHEFMURigbHE5kJieF9SBT65NllzNh/sjJyWoUFcmfVJetgzY79vqpBEF0HyIlxrQ1phgJ8kNs8UPsbOK+h1hsktf0zOQk9EiRF7y2kpys/B5BMUSCiG9Wr17dpecnP8SuI+79ENP/0htYYA/Z5tVJNwMAJhXMg5/1o++fxoVsk//sB6heMlGybFtRP+RptbJ+iGVlZbj+l/8AAIy/LrQ+6tA1QwEAB6cdjPmaCILofMgPMbG46P0QI+Fn/ThcL2/Yy7odIctqvF7UeuXjgBaLBQ6H8lxEjqZkEARBxC0JLYgsy+FwfSUcXqfsek99VciynlotahQEUacLJNQoiaLrlItEkSAIIk6Je0GstsmLE8tyqLM3wuF1YlBOkew2Km3oEEmeVoueCsbCJpMJBoNKMcuUdbNUy5QgCCJOSQBBlO+R1dkb4fH7MSinCGn6FNltdDn5ssvzFARRrVajsFAHg0E+C9XQ2wDWHbm8G0EQBNH9iHtBzDfKi5PH70duRpqiGAKAqhWFvxlGJalU0+eJDS3rkhgYelNgniAIIh5JAEGUv4TcjDQYFHp64fBHkXTLiAp4B8chmaT2d9cgCIIgOp64n4eohFgMm9zNUe93xO1WrFQjN7lWLg5JEET8su2zIjgcLCoqPDAYAiNC4pdgq9UHi8UHs1kjsYLz+wNlHV0uDkVFOsl8Zf54cx+vaff2dmf7J6vVirKyMnzxxRdIS0sDx3EYNWoUFi9eLJm/GA1vvvkmZsyYgR07dmD0aLn6ZG0n7nuIkWhyN+NwfeicQQDw2etDljlZVrGWqc1mg9XqkywTxyH9TmUrE4Ig4ge+IhVfu1jscmMyaWA2a2Cx+CTPAz6cwifeibPRw1W46mo6yv7J4XBgzJgxyM/Px9GjR7F//37s3r0bJSUlqKkJvBg0NDQg2qnw5eXlGD9+PMrLy9u9rTxxL4g+VvlmurxeHK6vQLI2SX5fuzVk2aV6PZwKvodGozHkSyCOQ7pOukgUCSJB6AhRjIZEsn/q0aMH5s+fL9g/6XQ6zJo1C8XFxQCADRs2oH///igrK8PBg8oFTX7++WdUVVVh7dq12LhxIxobG6O6l7ES90OmB6wsLpdZ7vJ6UWdvwhXpSRiUUyi7ryYj1I4llWEUh0yNRqPwJZBDrVfDdZKmXRBEPONwsIJ48aJYUdFi/cYPn/LDpfzzgP/Mi2JlpQcVFZ6Q4dNIJIr90/fffy9x3ZDj4Ycfxh133IENGzZgzpw5sNlsmDRpEu6++24UFLSYL5SXl2Pq1KnIy8vDddddh3fffRcPPfRQ1Pc0WuK+h9gsPyUQdfYm6BgGg3IKwShkk2oycmSXpzLKiTH8m6Echl4GqPVxf0sJ4qJGabizvXqKkRDbP61fvx5arVZi61RaWopHH300ov1T8HZy9k+MzLNObP9UWlqKUaNGCfZP3377bYj9U7TGx+vXr0dpaSkKCgrwxhtvCMuzs7Mxa9YsbN++HVu2bEF1dTWKioqE4uI+nw9r167F9OnTAQAzZszosGHTuO8hlpjlBUjHMMjNSFcUw7YgDqSL45AqRgVDL0qyIYh4hhcxcc+uvXqK0ZAo9k/Dhg3DqlWrhM+TJk3CpEmTcN9996G5WZroWFVVhfXr12P9+vVIS0vD8uXLcdtttwEANm/eDJvNhgkTJgjtq62txQ8//IAhQ4a08irlifvuTLpe/g+Sm5EOtVr5j6XEeb9yDJCViS0GxyFVTOznJAii+xApMaYtPcVoSBT7p8mTJ+PMmTNYvHixYP8EBJJteLZt24aRI0fi9ttvh1qtxvvvv48dO3Zg1qxZgoFxeXk5li1bhurqalRXV+P48eN48sknO6SXGPc9RCXEYnjKbkEvmW04NlT8wk27sFqt8Ps5SQq2XBySIIj4JVwMsK09xWhIFPunlJQU7NixA2VlZejXrx+MRiOSkpJQWlqK22+/HQCQlpaGVatWYdCgQbL3ora2Ftu2bQux5JoyZQrGjx+Pl19+Oeoh22hIePunazKn4aTdgt+uezRkm9z7XkPd6scky97LL4CTZTHlxPGQ7adPn44RV3+CwkIdbvhlwEFDbCE14NUB0GXryP6JIOIEsn9KLC56+6dGt7Ken2t24KTdgt4ZZtn1nDc0I/RSvR5JavnbYjabheESObxnvPCcie4tkCAIguhexL0g7rfIZ2+da3agweFE7wwzeikIoi6nIGQZo1IpDpnq9XohhiCHNlsL7xl56yiCIAiiexP3gpiiMHzc4HAiMzlJUQwBQK1Pll3OhMmcCq44IY5D6rJ10GbHXj+1o3j44Ycxf/78rm4GQRBEXBD3glhskr+EzOQk9EiRF7y2Ip5k66mvlqzTZXef8kwejwdWa2g1HoIgCCKUuBdEjcLUCrEY+mWySZWo9bYMeb466Wb8+bcThc9umRqncnHI7oLZbFZMiSYIgiCkxL0gRsLP+nG4vlJ2Het2hCyr8XoloiievmGxWEIqTojjkJy/eyXs6vV6mM1mLPufnl3dFIIgiG5PQgsiy3I4XF8Jh9cpuz7YyxAAemq1qPHKJ8bodLqQybriOKTrlKtbimJ3rbJPEATRnYj7ifnVNhb5MstZlkOdvRFFOicG5RTJ7ivnZZgn8lE81+yQDL2aTKawFSdYNwvXqe43hBpLYWGCuNgxfboHKlGNT7+1Fn5LLRhzHhhTnrCc8/vhqzwCzuWCpqg/1MmpwjrWcR6+iqNQGQzQFF4qHM/yi9J2b+/F4IdYUVGBefPmYc+ePcjMzATDMHjooYfwwAMPtKrNSsT9k7LaJt8jq7M3wuP3Y1BOEdL0KbLbiL0MxfCi2OBw4lxzy7CqWq0WyjDJYehtAOuOvohvRyMX8yQIIjy+yiPgRKXGGFMeGHMe/JZa+K21wnIVwwTEzmCAr+IoWMd5YZ06ORWaov7gXK6Q43U3ursfosViwbXXXosJEyagqqoKe/bswUcffQSfT951qC3EvSDmG+XFyeP3IzcjTVEMAamXoRyZyUlocEiHW/kyTDziOCSTxMDQu/tUu7BYLCSKBBEjciLWmaJIfohSli9fjtGjR+PBBx8UlvXo0aPVPdpwxP2Qab5RXtNzM9Jg0MY+J9DPccI8RH64dMPkvwaq3VwoWyquZRoch2SS2t9do7XodDrZRCCCIJTRFPWHr+IofJVHJMOd/HCp31Ir+cyLoq/yCHwVRyXDp7wo8scDroh4fvJDlPoh7tmzB7/85S8j3rf2IO57iEqIxbDJ3RxmSylH3G74RV34HinJ6J1hxkm7BTabLWR7ldaAL6enorFMuT5eV2EymYREIIIgoiNcz66tPcVoID9EqR9iZ5KwgsjT5G7G4foK2XViL0MeJ8viSNAwY68MM3pnmGGz2STWLkAgDpmiC5SQ8zvbJ05w6tkv2+U4arVaSAQiCCJ6OkoUo4H3Q7zxxhvx9ddfY8iQITh37hymTZuGffv2CT91dXVISkqS7Mv7IUbaLhxiP0T+p6qqCtOmTQvZNpIf4nfffSd8njRpEvbt24exY8fK+iEuWbIEEydOxE8//STxQ7ziiiuwc+fOqNvfFuJeEH2sckDW5fXicH0FkrXy/wzBXoZAoLi384LvISs6dq8MM4xGY4jfmUrNoNikRooOcJ10tZsothd8IhBBELHREaIYDeSHKPVDfOSRR7B9+3ZJe2w2G15//fWo7mcsxL0gHrDKx8dcXi/q7E1I1iZhUE6h7DZyXoapDCMU966zN0pE0Wg0CiagkuOoVSg2qaHWq+E62fZpF6fsljYfQwxDpsUEETXRJsa0RhSj4eDBg7jmmmtQUlKCYcOGhfghlpSUYPDgwXj33XdD9hX7IQZvN3XqVNxxxx0YNWoUSkpKcNNNN8Htdkv8EG+55RZoNBps3rwZ7733nrDu/vvvh9PpxCWXXCL4IZaUlODo0aMhfoh8xirvh3j06FH069cPw4YNw6hRo5CdnR3ih7h3714888wz6NOnT8g15ebm4quvvsLmzZtRUFCA4uJijB8/HtpW5IhEIu79EPc/nofRb4b+w80ZPwo6hsHjpYvAqBn0WjI6ZBuxlyHP4YEBo8pBPx0OOcb/GbZh9Ji/w2r1YfLdx1uOYZgMABjSpzdcp1w4Nv9Ym65vw+S/yvo3xsrcuXNhNBoxeszfMf46+WFjgriYIT/ExOKi90MsMctfgo5hkJuRDibC1Ipw5GakweMPlH4T10PlnbABaRxSxahg6NX2L5WSf2Os2Gw22UQggiAIIpS4F8R0vfxwYG5GuqQOabScFw2JGLRa5GakweF14nB9JVg2dHjWZ7ei2tayXNUOw5PhLKtiwWg0yiYCEQRBEKHEvSAqIRZDpZgcJ+OCccTtDhHFQTlFcHidsFqt8AfVKtVkmFBt4ySi2FpeuPk6vDrp5jYfh8doNAqJQARBEER4ElYQeU7ZLTgZJIjmz/fB9OmeEC9DAEhSq3HE7carMzYLy9L0KRiUUwSPx4PKSo9EFDUZOcg3qlBt4+A507b5fh3h38gnAhEEQRDhiUkQX3rpJQwfPhxpaWnIycnBbbfdhp9//lmyjcvlwuzZs5GVlYXU1FTccccdISa1J06cwMSJE5GcnIycnBw8/fTTra5L1+hWzgk61+zASbslJCYnFOWV8TK8VK9HklqNmrMVcIlcL9L0KTCbzXC5OFRWSoUv36hGvlEF7xlvm0URiM2/MRrEMU+CIAhCnpgEcfv27Zg9eza+/fZbfPLJJ/B6vbjhhhskkyyfeOIJ/Pvf/8aGDRuwfft21NbWCim2QKAs0MSJE+HxePDNN99gzZo1WL16NebPn9+qC9hvkR+qPNfsQIPDid4Z5pCYHF+hXuxlyMOoVLhUr4dOY0CdvUkiiryVksvFIWvlOzB9ukdYl29UQ5uthfeMvHVUtPCWVe2BXMyTIAiCkCemrsPWrVsln1evXo2cnBzs2bMHY8aMgd1uR3l5OdatW4frrrsOAPDmm29i0KBB+Pbbb3H11Vfj448/xqFDh/Dpp5/CZDKhtLQUixYtwrx587BgwYKoywDxpChs3uBwIjM5STZBRbBrqbXL7BkQxZ5ZhahqYlBnb0KTu1koEp6crEZRkQ5c5YV5SWxL8XBddtsmwIstq9oDq9UKkyl0riVBEMqYJy+BJsMETUaOsIxj/fDUV4PzBl6kxT6orNsBT30VVFoDdDn5EtMAn70ePrtVOF7wNC+ie9GmGCJf3SAzMxNAoAir1+vF9ddfL2wzcOBA9OnTRyi9s3PnTgwdOlTyoJ4wYQIaGxtDCtXyuN1uNDY2Sn54ik3yl5CZnKQYkwv2LpNDrQ5M29AxDA7XV0jqoSYnq4XJup76akm1nLaIotiyqj3weDyyiUAEQSijyTDBZ7dKp1SpmYDYaQ3w1FdJXG7U+mTocgrAeQPPA3GyniYjR/Z47cnq1auFMmetoa32T9nZ2aiurpZdZ7VaMWPGDBQWFqKkpATFxcWYOXOmYkHwYDZt2oTS0lKUlpbCbDbjkksuET6//fbbrW6zEq0WRJZlMXfuXFxzzTUYMmQIgIDdkE6ng9FolGxrMplgsViEbYJ7LfxnfptgXnrpJWRkZAg/vXv3FtZpFKZWiMUwOCYXTgxrRUOkarUKuRnpSNYm4XB9hcRKSahg4XXhgJUNW0IuWqKxrIoFs9ksJAIRBBEdSiLWHqLYHenOfoi33HKLUE915syZmDJlivB5ypQp7d7mVgvi7Nmz8cMPP8iWD2pvysrKYLfbhZ+TJ09Gva+f9SvG5MT/0Dw1Xm+IKA7KKUSyNinESkmdnApdTgGaPYESclwbe2KttaxSQq/XC4lAcgx4dQAKy+TL2hHExUxHiWI0kB9i19Gq9MM5c+Zg8+bN2LFjB3r16iUs53skNptN0ku0Wq0wm83CNuIK6Px6fp0cer0e+gv1RWOBT1BxeENjcqzjfIiXIQD01GpR4/WiockKvo/JqBkMyimEzv4fVFR4UFSkAy504tT6ZJSY1dhvYeE65WpTpZr2FEMePhFIjrbGPAkikeFjiHzPjv/Mi6Knvhqe+ipJTJEXRU99FTz11ZKYojgmGQ7yQ5T6IXYmMfUQOY7DnDlz8K9//QufffZZSIOvuOIKaLVabNu2TVj2888/48SJExg5ciQAYOTIkTh48CDq61veuj755BOkp6cLHluxoDQhnk9QcXidITE51nEevoqjUGlDxStPq0VPrRZnmyw419zy9seoGcFKqaLCIynYm65XocSsBusOiGJbicW/8fDAQUL9VSWSk5X/zCSKBCElmhhga3uK0UB+iHHihzh79my89dZbWLduHdLS0mCxWGCxWIQ/SkZGBu6//348+eST+Pzzz7Fnzx5Mnz4dI0eOxNVXXw0AuOGGG3DZZZdh6tSp2L9/Pz766CO88MILmD17dqt6gdU2DgNeHYCha4ZKlosTVIJjcr6Ko1AZAhlhcuRptchKM6PB4ZSIIm+lZDCoQqrYp+tVMPQ2gHW3baoDb1kVLeLh3WDcQb6OBEFEJtrEmI4SRfJDlPohdiYxCeLf/vY32O12jBs3Drm5ucLP+vXrhW2WLl2Km2++GXfccQfGjBkDs9mM9957T1jPMAw2b94MhmEwcuRI3HPPPbj33nuxcOHCVl1AvlEl28sJl6CiMhgC9ixhCn9nppmQmZyEBodTUvqNYVQoLNS1WLuIvgRMEgND79YPmYotq6IlOOYpxmKxhBXFtsY8CSIRiSVbtCNEkfwQpX6InUlMMcRonKIMBgOWL1+O5cuXK27Tt29ffPjhh7GcWpF8o7ymh0tQ0RReCpXMUAEA+DkOzIW3Hj5TVSj9dkHrGEYFTeGl8FUegae+Co0GTigyziS13l2jzt4EHcMo+jfKwcc85dDpdCGJQGLaGvMkiETE8rZyokhncPDgQZSVlYHjOPh8vhA/RJ/PB4/Hg4kTJ+LKK6+U7Cv2QwzeburUqaitrcWoUaOg0WiQkpKCTz/9VOKHWFhYiE2bNmHz5s2YO3culi5dCr/fj+zsbKxbtw49e/YU/BB1Oh1uvPHGED/EvLw8zJw5U/BDLCsrQ79+/WA0GpGUlITS0tIQP8RBg8KHfTqLhKnpFdzbEYthcExOSQyBQHHvS0VDtz1SktE7w4yTdgtsepvkGJrCS6H65jT2W1hFG6pYaI1lVV6YRByTyQSr1YqKCvk3uPaKeRIE0X786le/wq9+9auQ5XfddRfuuuuukOX33Xcf7rvvvojbAcC8efMwb968kOWbN2+WfC4qKsK///1v2WPceuutuPXWW4XPL7/8svB78Ehfbm4uVq9eLXscALjqqqsU1wWzYMGCqLdtLQlR3Jvzc4oP9iZ3s2JMTm6irJNlccTtBisa3uiVYUbvDHOIlZKKCQyXpOgCJeT8zsA+kZJclGitZZWSKKrVaiERSI72iHkSBEEkCnEviD42IIZyD3Y+QUUuJue31spOlL1Ur4eTZVFzthKsaLJ9rwyzYKUkEUU1g2KTGik6wHXSJYhia2iNGEY+ZiARSI62xjwJgiASibgXxANWFqybDXmwixNUgmNyfmst/JZa2YmyqQyDS/V6eHwu1NkbJaLIWylZLD74rbXCco1ahWKTGmq9Gq6TLomfYmtQ8m+Uwx9FXJcJY1rclpgnQRBEIhH3gtjsCQz9BT/YxQkqwTE5v6UWjDlPMlH2shWXCVM3UhkGPbOK4PH7UWdvlJR+M5k0MJs18FtqQ0TR0MsAtT7gp9haeMuqaDnidiuKos1ma3U7CIIgLjbiXhBLzGrZXk64BBXGnAfGlCdZFjzcadAlIzcjDR5/oPRbsCgy5jz4LbXSFGwmIIpJauXb2liWji+ny9dSFVtWRQsf85TDZrOFFcW2DO8SBEEkGnEviPx0BwDY1f9SvN2nLwD5BJW/LO2Jde/0DRFDALLDnQatFrkZaXB4nThcXynxF2RMeWDMefDZrZJqOSpGJclSDWa/hW2VZZUSfMxTDqPRGJIIJKatMU+CIIhEImGmXfidfhxxu4XemVgMT9kt6AXAbNZI3OPFE2UNvQxwnXKFTLswaLUYlFOEw/UVgpUSH5NjTHnQZFhRbeMAiMQyTPWGFF3rLKuU4GOecvD1ZC0WeUHkXwIIghCxIAM+lsMBK4tmT2AUSvzi3ejmhBfbYpNa4rhTbWNRbeOQb1RJ5kjzx7v89fNob1avXo2NGzdi48aNrdq/uroaW7duxcyZM1u1f3Z2Nnbv3o38/Hxh2e7du/HAAw8ACNRitdvtQqnPKVOm4Omnn476+J9//jmuu+46rF27FlOnTm1VG6Ml7nuIQEAMXSddSFKrQ8ThlN0ixOQkYugPGH7yiIc7j7jdcHlaqimk6VMwKKdIsFIS+wtqMnKQb1Sh2sbBcyayzVLwF0hMrGLIkxpmXiWfCCQHH/MkCEIKnyjHT6lqdLd85/naxbzLjdj6Ld+oFp4H4pEj/njdkY6wf7ryyiuFsm8LFy7EL37xC+Hz008/LVTJiYby8nKMHz8e5eXl7dpGObrnXygGGt0cXCddUOsDYijunfEJKsExOc7vD7jde6W9I364M0mtRs3ZCrhEFWDS9CmClVJlpQec6I/Jfwm8Z7wRRVFJDMUE+ze2FfGLgBj+JYAgiFA6QhSjIVHsn8Lx9ddfo6ioCI8++qhgHi+HzWbDBx98gLfeeguHDh3CsWPHWnW+aIl7QdxvYaHWq2HoZQgRQz5BRRyT8/u5gBi6XNDlhNqLMKqAKOo0BtTZmySiyFspuVwXjhEkitpsLbxnlGuLRgNvWSVHnyc2wDzlT5Jl4aZ4sAqxRTGqMFMyCOJiRK5n116iGA1i+6f9+/fj3Xffldg6ff/991i8eDEmT54csm+47cT2T/v378eWLVsE+6cBAwZg37592LRpk2D/9Oqrr2LXrl349ttvsXLlSuzatQv19fWYPn06/vnPf+LAgQPo16+fov1TOCZOnIgDBw5g+PDhWLRoEQYMGIDnn38+xM5q3bp1mDBhAsxmM+655x6sWrUq5nPFQtwLYoouMPQX/GCXS1Dx+y/07lwuaIr6Cx5mACQ9O0alQs+sQugYBnX2Jknpt+RkNYqKdOBcroAoinpzumwdtNnKtUV5orGsksNTXxViWXXE7VYURavVGpUoEgTRgtJwZ2eJYqLaPwWTnp6Oe++9Fx9++CG++eYb4drFJdrKy8sxY8YMAMCMGTOwZs2aqIdaW0PcJ9UUm9QSMaz1ejEI8gkqlZUeuFwcNP36Q52cCqClwrv3DC9ifFJOYNpGnb0Rh+srAp6KF7QoOVkNTVF/+CqOwlN/Gr4+nDAcosvWoadW+Q8mBN1l1oktq+RQaUMtq/iY53CZ7T0ej5AIJIfnjIf8EAkiCF7EAFZIjOFF8YCVFWoX84k2vCjut7A4YGUleQKB/dmW40Vxft7+6bPPPsOnn36KZ555BjfccAOmTZuGF198Mey+vP1TpO0iHYO3fwpm06ZNks/h7J+iwWKxYMOGDXj33XfhdruxZMkSTJkyBQCwb98+HDhwAA8++KBwnjNnzmDLli24+eab23ReJeK+hygel6/1eoXemVgM+Zicy8WhqEh3QQylyA13qtUq5GakI1mbhMP1FRIrJXVyKjRF/cF5XSFvhuEKbvMZaHKEs6wCIHHf5uFjnnKYzWYhEUiOaGKeXcG2z4qw7p2+Xd0M4iIlUmJMW3qK0ZAo9k/h2LdvH8aPH49x48bh9OnTWLVqFXbv3o2nnnoKubm5AAK9w9/97nc4fvw4qqurUV1djWXLlnVock3c9xB5PGc8qPF60TNIjPxsYGJ9X4xDUZFO4h4v9i7je0o1QYk2arUKg3IKcbi+UrBS4o+hTk6FLqcAzbbAl4DL5yLG5ILTscWEs6wCIOvfyMc85dDr9UIikBz8S0B3RCkRiCA6g5CeXTv1FKMhUeyfwqHVavHSSy8pul24XC68/fbb2L59u2T5nXfeiaeeegpWqxUmU2jpzbaSEE8dzxkPvGcCYijunfEJKnxMTiKGjvPw1FdJjsMPd9Z4vWhosoLvYzLqQAk4nf0/qKjwoKhIB1zoxKn1ycKXIBp/QSUxBBBWDMMRbt4jnwgkR3ccLp0/fz7GjuvqVhAXNQsCvaX8Cz/BaABcrrBrOoDRCuvkjiVHItk/ybUPAAYPHix7bB6DwYCGhoaQ5VlZWWhubpbZo32I+yHTahsL7xkvtNmhYsgnqATH5FjHefgqjoYkqACB4c6eWi3ONllwrrmlB8moGcFKqaLCA9bRMsGWfzPk/QWjKbgdjmD/RjFyllWREL8IBNPdRDFczJMgCKIjSQBB5KDN1oY82MUJKuKYnMPBBsTQIE1QERsM52m1yEozo8HhlIgib6VkMKjgqzgaIoq8v2Ck4t7i+EIwvGWV7H72+hDLqnBTPNxtKDIeLa9Oat/gtlzxA4IgiM4g7gUx36iSiCHfO5NLUHE4WFRUeKAyGAJu96KYnOuUSyKKmWkmZCYnocHhlNgxMYwKhYU6qAyGgCiK4pC8v6BSbVGgpYSTHGLLKtl97dYQy6oar/K8R4vFElYUuW4oOuLiBwRBEJ1JAghiyyX4OU7oncklqFRUeGAwqAJiGDT/Rm64s0dKMjKTk3DSbgkRRU3hpVAZDPDUV0myzZgk5dqiAIT6iHKILavk0GSYJJZVANBTqzzvUafTCYlAcgS/BHQHxMUPCIIgOpO4F0Qezh8QQ753JhZDPiZnMFzo3clMRhUPdwaLYu8MM07aLRIrJRXDBERRawhJwQ5XW5QvFixHOMsqACFiCLTEPOUwmUzQ6XSoqJBXYP4loC2Ih5TbC774AUEQRGcS14I45A8fAQiIoeuUC06WxaV6PZbP/EzYpsndLMTkCgt1Evd4n70eX9yXiuq5aZLhziNuN1hRBZpeGWb0zjCHWCmpGAa6nHxhXlI0VkrBlfPFyFlWRYPSvEe1Wi0kAsnBvwS0hQaHfFWdthIuEYggCKIjiPtpFz42IIasOyCG4t4Zn6CSrE26kM7fIgx+ay1gtyI/p2VeID/cecTtRs3ZSmSpOUGgemWYYdQbW6yULlSEU6kZYV6S66QLht7hp10oiSGAqMSQi7HwN58IJAf/EtAWMpPl452tpTMSgQgiHEPXDBV+5510+HrJ4nnG/HSv4KQ+/gWddbMw9DZIDMwPTjvYORdBtIq4fg3nWD8OWFnhHy9YDPkElUE5hVCLqrn4rbXwW2qhyTCFzAvk/QU9Phfq7I1gRRmhvJWSxeILCOoF+Mm6cibDrUEcrwy+XrFlFYCopngwYYoFiL+sraG1llVKhIt5EkRnIB7p4V8a+fCCOObO1y4OrvjEu8jwz4OONuFevXo1brvttlbv31b7p+zsbFRXV0uW7d69G6WlpSgtLUWfPn2QkZEhfP7zn/8c9bH5YuKFhYUYNmwYLr/88jaVpYtEXAui5/QJNHsQ8hbm8jgkCSrimJzV6oPfUgvGnCeJyYn/aVMZBj2ziuDx+1Fnb5TYMZlMGpjNGvgttSGiyH8JIk27EMcbg+Etq2Svt746xLIqOOYpRhzzjBf4mCeJItFVBItYPIhiW+iufohOpxNjx45F3759cfToUezduxdfffUVUlLkS1u2B3EtiJzPhRKzWiKG5/1+1JytkE1QsVp9sFh8YMx5YEx5wnIfy4X80xp0ycjNSIPHHyj9FiyKjDkPfkutZKK82GRYCd5tWw6xZZXs9XpDLav4mKccNpstrCi215f0+DNfYOt97WPLIi5+QBBdgZyIdaYokh9igHXr1iEtLQ0LFiwQXDmSk5Px+OOPt+qc0RDXMURddl9JTO68348jbjd0GgOyghJUbDYbLBYfzGZNiBgesLJQ9+SHOzXC0KtBq0VuRhocXicO11eC7dMiZPwxfN8dQLW+pdYhbzKsxH4LixSFBEo5yyrJ9eYUSCyrAAgxTzmMRmNIIpCYaGKekQgujxcNhwcOAgAM+ulwyDo+5knzEImuwtDLANcpl/D94F+4eVF0nXQJZRr5mCIfQ+RrA/OfeVHkjxcNYj9EAGhoaJD4HOr1enz55ZeYPHlyiH9guO3EfogZGRk4d+6c4Ic4d+5cwd2C90N86623MHDgQDgcDlx99dUYMWIE+vbti+nTp+PLL7/EZZddhpUrV7baD3H06NHYuHEjFi1ahIqKCvzmN7/B5MmThbJue/bswciRI2M+dluI6x6iWBz8zoAYJqnV6JlVKBHDUxemTJjNGknRaD4G2eyBZLhTHAM0aLUYlFMEh9cZUlaMMeVBk2EKqYofrrZoii5gWSWHnGWV0vXy8DFPOYxGI4xGUSJQyPHUUX9JlVAqj9cW+OIHBNEVhOvZtbWnGA3kh7igVcdrD+K6h8jDZ4IlqdW4VK9HnWiY9JTdgpN2C4w5RqkY+gMJKs2qwFSIluHOgLC6PC3z69L0KRiUU4R/23ajstITeFhfOJQmIwf5+oC1SzT+guIK+MG0NkEl3LxHPhFIDv7NtS3IlceLhJ/jwr40AOETgQiiownu2bVXTzEayA8x4Id4xRVXYOXKlW06fqzEdQ8RCMTk+LToS/V6yYOWT1DpnWGG0WgUlnN+f8Dt3uuSzAvkhzuT1GrUnK2AS1QBJk2fIikrxol6kbzfWTT+gkpiKMYfZmqFuFRctIhfBHrNehP5z34AILYvqRLh/BuVSLREICIx6YieYjSQH2LAD/Huu++GzWbDokWLhAQcp9OJ1157LebzRUtc9xBZtwP7bSzUBYE5Qoyq5R9WSFDpbb4QkwuMtfv9HHxVR8C5AgkqwfMCeX/B7zQG1NmakJuRJqzjy4pVVHjgqzwCTeGlwrp8oxraNN5kWI1Brb2mCzG5vhgne73BllXn/X7FHiLLspLpJgBCioNH+yVVojWWVXwi0BCZdXzMk/wQia6iq+cKkh9igOTkZGzfvh3PPvss+vXrh9TUVKhUKkyePLltNzgMcf3U8Zw5jpQeCJkw29BklU1Q8fsv9O7cLmiK+kNdaxcdq2W4k1Gp0DOrEFVNDOrsTWhyNwu9IL6sGFfpCvQy2ZbekZLJcDDVNlbWG423rCrSySeoeOqrQiyrjrjdijFEORNNTYYJPrsV1XPTgGFyrWgdSpZV+c9+AJ+9Hqf+Nl1YFikRSCnmSRAXA+SH2ILZbMbq1auj2rY9iOshU5XGgGKTWiKGtV4vzjZZQhJUWJZFZaUHLhcXEMPkVGFdo5sLGd5QqwPTNnQMg8P1FZIHfnKyGpqi/uBcLnjqqyV2TgGTYeVeU7WNd+EORWxZJXu9WqllFQAkqZXnPXo8npBEIE1GjpAIFGl4V2BBBnzz0xVXi8vjBSNnWRUpEYgvfiBHv4X9UPi8fPFzgiCIthDXgqi7pI8kJlfr9aLG60VWmlkihn7WD6vVCpeLQ1GRLkQM91tYYcxfbKWkVquQm5GOZG0SDtdXSMqKqZNTA6LodeGAlZWIolJtUSDg35hvlB+mlLOsklxvTr7EsgqAEPN88tb/waszpG95ZrNZ8BcUo8nIiTrmCUS2rOLL48nuK2NZBYRPBOKLH8gRS7YeQRBELMT1k0UsDp4zHtR4veip1SIzreUB7GcDE+s9Hg+KinSSotGs2yHMC+QD4cH+gmq1CoNyCpGsTQopK6ZOToUupwDNnoCtUzRWSvlGVUi5OB45yyql6+XhY546jQE1Z6W9NL1eLyQChbZDLbwERCKSZRVfHk8OOcuqaFCKIbY1EejVSTe3q6nxfffdh7lz57bb8QiC6DriWhB5+CK7PbVaSe9MPGncbDZLxdBxHp76Ksm8QH64s8brRUNTyzAfow6UgJMrK6bWJ6PErEazJzp/QSUxBFqXoAK0xDx1GgPmjB8lWccnAvGIi4PzLwGRiGRZFVweT4ycGIar9cqGMVfmaWsiUHtaVvHFDwiCiH/iXhCrbaxQcT5YDMWTxvWimBXrOA9fxVGotIaQeYG8v+DZJovkwcmoGUlZMdZxXliXrlehxKyWNRluDXIJKubP9wGApFScGLWaCYiizFCk+EXAU18dIoqRiGRZpSSGSgQXPxATHPNsb/js4/aCL35AEET8E9eC6Gs8jWobF2K/wrJ+SYKKOCbncLABMTQEElR4MRT37PK0WmSlmdHgcEpEkS8rZjCo4Ks4GiKKYpPhsO1mlR/4fExOdj+ZBBXp8G4gEWjrfavw3pTlslZKnDc0ESgS7W1ZFSkRqLLSoyiKUScCKcBnH7cnRqMR697pi78s7dmuxyUIonOJ62kXvsZ65PdUScTQz3GoOVspm6DicLCoqPBAlWQIuN1XtrhK8BUneDLTTHDbk9DgcOKU3SJM3+DLiqmqDAFRdKcCF3ZrMRmWn4IAtCSoXC6zjresuiI99IHN+zcGJ6jUeKUxQD7mebi+EhaLBWZzoN18D1OXUwBPfVUg5pnPtXn4keeU3YJeMsvlLKvCTbsQFz+QI5qYZzgilcdrLTRvMnF4u09foeqVuNAHn7QXHJrxcxyOuN2CQbk4YYyvr8wfb8jPP7V7e1evXo2NGzdi48aNrdq/uroaW7dujTh3UIns7Gzs3r0b+fn5wrLdu3fjgQceABCoxWq321FQEDAmmDJlCp5++umojm21WlFWVoYvvvgCaWlp4DgOo0aNwuLFiyXzH9uLuO4hatJzJDE5/h/T43OFJKi43W5UVHhgMKgCYij6p622sbLDnT1SkpGZnISTdovEo5BhLhzDYICnvkpi58SbDCsRKUGFj8kFw/s3BsfkIsU8QxKB9MlCIlA0MU+ecJZVfHk8OeQsq/hEIDn4mKdcIhCAqBOBlGhvMRTHPJVEUWw42x2gRKDwXKrXC8UjxM8DPpwSnHjH/z/zIx/icAA/xSicK01X013tnxwOB8aMGYP8/HwcPXoU+/fvx+7du1FSUoKampp2bS9PnAviJcLvnL/lLa1nVpFEDJvczbBYLDAYLvTugsSw2sZJhjuDRbF3hhknLxQI51ExTEAUtQbst7ASwQg3pSBSgopSTC7Yv5FHHPMMFkWTySQkAomHd/lEIP4lIBKRLKv48nhyyFlWAeELoPPFD+SINhEoEu1lWWW1WqNKBOpOUCJQeIJFrD1FMRrI/inAunXr0KNHD8yfP18oQq7T6TBr1iwUFxe36ryRSIhxHs7PwXXKJQxZ2HTJcF0YteQnjetSdSgs1EmKRvvs9ah2BuYFioc7j7jdYEVxL3641GbbIykrpmIY6HLykWIP2Dr5+/ojOtBHSlBRiskF7Kbk34r4mOfZJgvcrDTmyScC+SqOQlPUX1iXrlfBYDZE5XYRybKqpTxeKHKWVdEgTgQKOWYUiUDhaI1llRLi4gcdVZD81Uk343frN0feMEriNQlo22dF8Ps53PDLyg4/Fy9iR9xuoRoU/xLHD5fy4Qr+My+K4n34l+NwxSiCIfunQBWb77//HiNGjIj52G0hrnuIwAVz31MusO7Q8XvxpHGTySR5YPmttfDZrZJ5gfxwp5NlUXO2Eqwo8aTXhQLhFotP4i+oUjMoNqmRogt12pajPRNUhqxqqQaamWYSEoHEw7t8IpDKwMc8RZmzF14C3u7TF+/lh/bieCJZVimJISBvWVXrVR7ylEsEak+Cs4/birj4QUclAnUE8SqKnemC0hE9xWgg+6cFstuvX78epaWlKCgowBtvvNGqc0YirgWR9zNk3SwMvQ0hYiieNC4ucu231goxueB5gfyXwONzoc7eKBFFcVkxv7VWWK5Rq1BsUgtV8ZWmFPAuE2LkhEgsaNs+K8K2z4qE6xUnqATHPDPTTFHFPINFMdJwTntbVgU/RMQExzx5vpyeiu8fTo065qmEUvZxJH4YMFB2ubj4QUclAl3sdHbMM1wMsK2iGA28/dONN96Ir7/+GkOGDMG5c+cwbdo0IQ63b98+1NXVISlJmoDH2z9F2k6JxsaDsNt/Euyf+J+qqipMmzYtZPv2sH/661//iltuuQUfffQRlixZgocffhgAMGzYMHz33XfCtpMmTcK+ffswduxYNDcrJy62hbgWRM/pEwFzX5FXGQC4PA5Jgoo4Jme1+uC31IbE5MQ9u1SGQc+sInj8gekbYjsmvqyY31IbIopik+FwiOONwcMofEwuGN6/UZyg0tqYZ3AiUKThnPa2rOIfInLIFT8AEFPxg3BEKo+nRLiYZzSJQG3BFaZHrcSu/pfi8EB5z5WOjnm2dzUgPuYpHpnpSCIlxnS0KHa9/VNBt7B/mjx5Ms6cOYPFixdLEnAcjvYrrBFMXAsi5wv4GYrF8Lzfj5qzFbIJKlarDxaLD4w570JMLoCP5UKGOw26ZORmpMHjD5R+CxZFxpwHv6VWMlG+xWRY+bbyCSr9FvbDkFVDQvwbGxzOkAQVv58T/BvFCSqBmCcrG/PsnWGGzWYLEUVdTr6QCBT8EtBa+PJ4cshZVvEPkbm3LMULN18neXiKix/kfPCVMF0kuPhBRBZkyC6OVB4PkO/JRyJSIlBbqLM3Yet9q3D8mS9k14s9LnkiFT9gWVYYeWg1Cve4tezqf6nscr74QXC4oqOIJlu0raL445kf8UP9D7LnP3jwIK655hqUlJRg2LBhIfZPJSUlGDx4MN59992QfcX2T8HbTZ06FXfccQdGjRqFkpIS3HTTTXC73YL904ABA3DXXY9Co9Fg8+bNeO+994R1999/P5xOJy655BLB/qmkpARHjx4NsX+KJmOVt3/66aefsHDhQgwYMCBkm5SUFOzYsQNHjx5Fv379MGzYMIwaNQrZ2dm4/fbbI56jNcR1Uo0uu68kJsfP+dFpDMgKSlCx2WywWHwwmzUhYnjAykLdkx/u1AjiYNBqkZuRBofXicP1lWD7tLxZ88fwfXcA1XpWGHrlTYbl4P0bU3ShllUAJJZV/Dj6qGtaLKuCE1T44c4jbjdqzlaiZ1bLdI1eGWYY9aI36wsaq1K3JALxTuDREM6yKlyCipxlFdCSCFRXF9jv1LNfAgDUhkDMs7LSIyQC5T/7AaoNsSUCKRGcfdxW3G63UAUpXCJQW2hNeTz+ITxcZns5F5TW0OjmoOSB0pryeOFeyqJxQTk2/1jM5+Q5faIaWoaBuag/bq+uUtxO7n4CCPE/ra0NjB6lpp7FkHT5aTcqhZGXaO2f6o4dAdB+9k9VVVXo0aMJgLz9049nfoTtjK1T7Z9yc3PJ/ilaxOLgd7ZMgO2ZVSgRw1MXhg/NZo1krhgfg2z2QDLcKX6TM2i1GJRTBIfXGfIQYUx5gpVStU0klgrDa+LaqXIT4iNaVskkqIhjnsGJQOI3a/HwLp8IFCnmyRPJsipcgoqcZZVwvRdinsGJQELxgzCJQG0lkmVVMOFinh2dCNSa8nh8z0QOJRcUnsKyQgx4NfSNPZhwU3Eilcfr88SGiMcPJpILSntgrzrTLsfx+dqpJ1u7N/AjQ2vid40HD+LMgQOy69RqNdxuTvIMEcN6uuf0IpvtAKxW+SkosRLXgsjjd/rhOukSqkGoRQ8PftK40WiUiuGFmBw/L1A83HnE7YbL0/IQTtOnYFBOkWw2IW+lFI2/oFztVPGDNlgMlSyrghFinhcSgcTDu/ybdaSYZzhRjGRZFS5BRWxZVfh8Ifot7NcuxQ8iEU15vHCWVcGEi3kqJQLxtDURqDXl8SIVP1ByQQGiL34QbipOpPJ4sUzFiab4QVQVlxZkBIyxFfD6/WA5+b/j/koL9ldJ/y/OHjiAcwri4vf7w4oiF0PpxPZEq1JBpyCkGo0GKjXgVirCwXUvUaytrUVtbS3UahX0Ctn7sRbFiHtBbHQH4n9qfWipJfGkcXGaOef3CzE58bxAfrgzSa1GzdkKSTJDmj5Fkk3IiQQk36iOyl9QXDsVaLGsWjTlHSyf+ZmwnPdvVLKs4jMug2OefCJQa2Ke4RKB+KkpQ9cMxeGBgyQZl5ESVMSWVe1Z/EApYYQnnH9jNJZVwSiZPouLHyiJYtQxzwgxuVMK1YDkyuMB0SUCyRFt8YNwU3F6pCTj1LNfCkPh0RAp5tlWwo10+PwsOI6DQauQXKZSQRW0zqBSQalVDMPA7/fD65U/H+flohZFLoxZgPOkHecq5Qv+K6FV+L9QqVTQ69VQKaiCSqsCukbHZRH/T0Tz0hgNcS2IvJ+hWq+GoZdBMUFFPE9OSFBxBWJywfMCxf6CdfYmiSiKswl9lUdCRFHOZFhMsH8jb1kl9m/kY3IejyfUsupCggo/7Bo83MknAgkxT1Ya82TMefDZrSGiqDS8Zp68JJCwIVMeTzinSCjKysowffp0AIDp0z1CQozQBqH4QfhEIMk8T774gQ4hiUDhiKY8XiwxOXHtSnEikLj4QUVF4KT5z34gSXJh3dE9zNuzPF40tLX4QTRTccJlHwcTruB7e8Q8w410cBwHLcOAUVCDYDEEALVKBUOY3hbDMPD6FNqsCohiJDiOg0Oho8lxHFxeN9QKbd5fWYf9x2MbAlYB0CsYcKvUqoAothHPqSbZ5QdO2XDglC1keePBg7Lbe73ekBelcC8P0RDXSTWeM8eR0iM0QaWhySpJUOHx+1sSVDRF/aGutYuO5REeAry/YFUTgzp7E5rczUIviM8m5CpdAVFkW3pH/P41ER5O1TYWXjdvWaUGX+6XnzRepHPC3MccYlnFJ6jww65qjVqoiMHDxzwP11fAarXCZGoR20DM0wqf3YpqvTTmKTe8Flw7VVwe79UZm2HQtTz4mtzNsNgs0Ol0+PiTQqg07wnrfPZ6fHFfKvCLgpBEoCw1J7zd8YlAQuKEKBGo2KTGASsbdSJQa8rjRQsfHzv17JeAoaX4AR+TY92OwJDghR6foXdPoWC0UsIGn308WmbduWYHTjKxlcer9XolIi5GnAhk/nwfWMd51E+8NuJ1xwqffdwX40LWBU/FARA25mmxWFBZ6UFhobxQR1P8QM6cW6vVQqVSweXxQqth4PJ5wLpCv7+cL3B8l2id+8LD2CWzPT9cyrHy66ECOB8nv06Ew8WB4wBGZjun1wuN1g+9hpE9DscBKo6VbbNKoc0eD6d4TaxX+XoF6gPVdZBzWciq0yeqAQDJjBEprtD/Tc7nAefzwOWSfr+bWRY6ufawgWvT6Vio1So4nU6cPn0aKpUK2gv/+7GGK+JaEFUaQ0iCSq3Xi7NNlvAJKv36X4jJBQSx0c3B6+Z7dYEvDG+lVGdvxOH6ikDSyIW/U3KyGpqi/vBVHIWn/jR8fTjhbTlgMhwuHhcYttH25i2rfBfaJ7WsOqA/LezjcLDwVR6FXiu1rAoMd/qFmCcvUHzM89+23S1v1hf+0rzA8TFP8UtAMGIx5CsCicvj8YjL4wVXBOItq/JzWpbxiUB7fC7UORuRm9GSqygpfqCqFbJ5heIHmpZs4HCk61VC/GDVHwOltKacOB62PB7foxV/Hfst7AdDLwM2AMKwtiQRiHc6uZAIBASSp3Q5BRIXlHAOH0D7l8fjY55yA8tiFxQAIfFpzt92F5Roso+DiSbm2ZbiB3Lm3AzDoFevXtj71Q40JifDpnFC4wx94ao/F7gOnbMlNuo9HfiOamVePPihf4OhGTZb6B+2/nxglEbbHH5o2nXmDHQMoPa23K/Gs074/F6Ac6BZF7gf4jafbGwCGA1UF26VzpmE2qZacH4OPc4DGpUKOpk2NzQ0IDnZeaHdoev5NmtsYb57ttNgOUDdHPr3bTxdD5bjoFXbkeI5J1l30uWB6rwLHDjovdIepOv0adhkquHw8yjPnnVCo1UhOSnwctOrVy+hAk9U4QoRcS2Iukv6hCSo1Hi9yEozI9knHbaxWq3IzApNUOHfzLVD+OFOtfBmrVarkJuRjmRtEg7XV8BtaHmgqZNToSnqD+4/3+CAlZXEU5TezMW1U4P9G6OxrNLlZEmGXfnhzkBvqwI9s1oyPfmYJ/9mzRX5haLmmowc5OtVoodI+JFzfmoKmx25PF5wRSDesirfqIbf2VLrlU8EqjreUvyA77XxiRN+Sy3E8IlArlMuxSkFfZ7YALU+GdUXng/i7OO/PvRJSPbxC/fdF5LWLU5QaXFBafmq8C9aJ+0W2PQ2IT7NvwgIxQ8MnDAkH6n4QXuXxwsufiCuhypJBJIJ/wZboSkRbioOP9IRnH2c88FX8FUEXu6CiSbmWVHhQdbKd3D2obsl61tT/ODtPn0x5cRxpKamYs9b/wddahrGmu5BQVloP/2B976Ar6kB2xcE5r9dv/R6LN2qQbJajYItH4Zs/9prr0GtVuOKK9/HyEGfhKx//F+PAwA2/demsG08/6/fIFWnwi0984Rtl/x5LbQaPYyqzzCxz4MAAPPvWl59Jn+wHUx2DvRfBZKAtv1uHB7/1+Pwu/2Y+boTerUKN2zbhjefCNg9TV8amDe4cuVKXHPNf5CVzeDpxtcAALoddfjs6esAAHPenQNGz4Rt8/m//AY/neZw5Uvfh6xb9vIC2J1u3FpwHwoWlEjW3b1+MzS7LNBm9cLnZaWSdRWPzMaWwY/A1nwGydznyEhKwvSlK/C///u/YFkWOaZ/wu3mMO3eHShd9Blc/gpUL5kIIPpwBU+XCeLy5cvx5z//GRaLBSUlJfjrX/+Kq666KqZjBMfkeK+ypjQTXBdeQPhhG49KPkGFnxeoNNwZ7C/ocLDCMdTJqQErJRui8hfke0rBMbmas5XRWVaJ/Bv5aR78cOd3GgNqzlYgi5HGPPk3a1/lEWgKWyY+5xvV0KaFvgQEI5ma0tuAVKZlCIKvCHRFeiBB5Vv1iZbrulAeTy8adg0e7uRjnnX2Jhyur5QkuZhMGjAqPhGIEXpbLYlA8r3w4Kk44uzjOrns4xxjywR11T+F7GOhjb0D8x75mCefwcwnAtlseyTnN3++D/qcfHjqq7HfwkqGbuXm2Zmn/AkqrQEn+7RkHx8eOAi1Xi/+PXg2stLMiuXxcj74CurkVKFH21iWjvSXGgG0vJTNvWVp4AVRtJ/JZILVag24oPQ7D3VyqhDzrF4yUXgJ+GHAQDAqFQb9dFj2/NU2ThBEPslp0E+HZcvjbfus6MJIx/wL5txZwpDygDQzdNk6/EN07CdvGA2P34/ZxfOBC7lG4nBF7n2vQZeTj+N/Crgz6LJ12FbUDzVeL+49cVy2vUDg5Y5/6IlfUPxeD87VW/Bz0xEMNvxSaDMATFH9E5pTdfDZrTAYAnfb4rXgSJUXl+r1KJ8bqMM5e8V1wvEqKipgMpnAsrXI3xkIimj+sRc+uxWWdc+izlMHAKgqHQY/x4X4JJqn/Am6nAKcyDgFeIA6jwoHhxYHRoOGP4esrDy4bGeh6RH4PvLtAoC6TBPAAoYmPzjWj0OPZ6NuVAGgAvLPBEZLFkxZgyz1aajVKpxZsAtAIP524uRxeLwanDJfGIVq5qB5MQcHrCyqsnNg6G2QnCuYXUePB+ZZy2xz4sSJwMsdsoT1H39SiMpKD064FyFVa4LarRXWDVk1BCpGhX/U+aAfkAmtx4sTdYFjGAwGnD8fcPDJyzuNykoPDAYDHI7mkHBFLHSJIK5fvx5PPvkkVqxYgREjRmDZsmWYMGECfv75Z+TkhCY0REKcoJKn1UpicvywjblPUILKhZhcSmrLmzk/3Mn7C/IPEcFf0P4fVFQEhJV/s+atlPZb2Ihv1sG1U/mYnMfnCvTumqViaLFY0Ddf2bKKh4951pytRJ1NGvPk36zFMU/+RSL4JSB4eI3PXmxWQVQRKDDE6/I4hIpAsuXxrBfK41la2tky77Hjih/wSLOPNaHZxwyffdxSqZ/PPtZ6XQFx0avAFPQRXFAiFT8QXFDUoS4oSqiChsGHrhmKZaKRjsygl7uHH34YHo8Ht9/xBdQp/xKOw7/czeIfIgh1QREXP1ByQQGkLwFy97nXrDfhs1vxbU7LsPQ/EHi5e/aO10NGOhYsWIArrlQ25xaPVPDD0uJwhdsgLX7Aj8x46qvhm58euHcFfRRf6oBAotMxXWCk4zfPF8LQ24B/MoxwPrE59/z586FWqzF6zIX7LmPOLReueHXSzZhUMA9N7mZpIlBQuOKL+1LhGdozbLgieBg8dJ619OWON+fe9lkRoPonAOn3l6c9whW7+l+K4UePyN5nfqRD+L94yYf/74r5IWGsBQsWgGVZ5PUUhbH4nI4FGYHvb1KOomn7t7M2ABf+HHy4ImvlO9DWnwwJV+zqfyn2OcPPi+XpkizTv/zlL3jwwQcxffp0XHbZZVixYgWSk5OxalXs/nTVNhbeM3yCSssXItjVIDhBxVdxVHZeoNhfUFxtg/cX5LMJxf6CwWXF/AqZTsEJKnxMrmdWUWiCiiWQoCJrWXUhW06cSKBWM+iZVQgdw+BwfYWkCovwEHG5AhmJoiHBwEuAfG1RPnsx2LJKKI+nMYQkqPAVgeTK43VG8QOg/bOP+RhgpOIH4VxQlKYUiOdpAtKRDnH2sTDSESH7OLjWa8wuKAsyQrKBg/GJhsGF9rXBnFsuO1scrggufsCPzHBeFw5YWcmc02hHOsLVPhYP+/O1j4UEswvTY0KmaAXNWxYXPxBno/PzliNN0RKLIf9yF26e9dy5cyUuEeLaxyVmdafUas697zXZedZnmywhIx3h5lnzYaxIpu3iKVrCvGWFWs399NGVT+z0HqLH48GePXtQVlYmLFOr1bj++usVjSLdbrfkC8EXovWcOYEf/SzUg9VgUhic9wceSM2uRhw/2wCv3y9k5rndbjQ3s3A6WXirD0Cl10OTkQOHFwA4+M77oGJUOO/3I12tRoohHRZLE9xenyAuXpUXJpMG1dUeeH88AKagCKzbgUZV4OZrs7Vw17ixz+lFn8bGkOvgt/WxHBzHHGA9LPK0GtSBg9PTDLfXC5fXhz01PwApgYdtYPI0B1Z1Hp7Tx+FrrEdWNpCZpIK7xo2jbjVyNRo4PYE29khOAscBe2p+QKOqEXq9Hs3NLKAC1Ll58Dv+A9epn9DQu2UKQ7pajWaGQWNQm/0OG3TZfQEE/kn9Tj8sXg+OuT3gOA6ZaSZ4Glvuj9Vuhd1ux5ChaqhS08E2nwfrdoBj/fjG6gebx0KbpQUHL/Y5nbCdPwOIHoK9M8w4b/8GP/7oQn6+Dqwm8NKhNqQiC8CP9Sycp5zQZelw3u8PaS8A+BrPwHPmOLgUDtosLVgPK4hRbUMVrI1N6JGUhAxDGprczXCr3Ghs9KO62gPWcw5MQRFQ1Sh8ocQPkqy0XNQ2VKHJ1QBzesv+SUlJSE9XB/4vnMegu7CvQxXIbAQH7HM60U+vQ8+gNnNeNzgAjSoOx20s3I1uGBkG6Wq18Dd1uj3YfepHOH1O9OjVI/A/3syCVZ0H62wGW3MYKo0B+UYVfI0+OI45YPcxYFQqOD3NSNKnIkWrxc9nqtDsccCdE/guuVwc1KY8+KuPwVVzGLrsvmhUccI152k1OOb2hNxndVI61IZU4X+C83PY53TCybLISssFHIEeV5O7GefdzThhP4EcEweTSQvO5QR34btw0O7HCTsHZiADv8uPY243ahuq0CM1B+4L/xe9MkxAY2C47cwZH5KS1GBVgf8LTYYJ9XYO33j88Jl8wt9Z7v/Cdeon1Ks4DLkwGuR3+nHe74ft/BnUNlQBHIceyUlweF3Cs6aqyoP6eh9UJiPUBk7y/fU7/XCyLPI0GnAch0rLj8hknC0vooaAvZLN5of3x31g8vsJLx2ZSSqoU9WS729wm/ltT3lY/GBlgb5AnkYDJ8sK/xdWWyN+ZqvQK92EpKQk4RnnZ+3wVx+DRvT9dRxzQN9Tj/MXXpY4BK7X2tiE3ad+xIBL8uFWBfZPTVVD5TTCV10Bz2kGjTmBfVhPy/dX7h6Ln6d+px+esx4cc7uRYkhHkj4VLmfgb2pzNuKk9SQ8Hg9yczXgOAjPCtbtwDd2P5J10udps6sRajUDt9eLJJ0WmUnpqK+vF64ZADiVE5qMHHhOn8A3J/wYYlILf2fh+xZpWgbXydTU1HAAuG+++Uay/Omnn+auuuoq2X3+8Ic/BFSBfuiHfuiHfuinlT8nT54Mq09xkWVaVlaGJ598UvjMsiwaGhqQlZXVZj8uIPBG2bt3b5w8eRLp6UrlirsX8dbmeGsvEH9tjrf2AtTmziDe2gu0f5s5jkNTUxPy8vLCbtfpgpidnQ2GYWC1SusCWq1WydwoMXq9XhIDBDrG8Ts9PT1u/mF44q3N8dZeIP7aHG/tBajNnUG8tRdo3zZnZGRE3KbTk2p0Oh2uuOIKbNu2TVjGsiy2bduGkSNHdnZzCIIgCAJAF027ePLJJzFt2jRceeWVuOqqq7Bs2TI0NzcLdTAJgiAIorPpEkGcNGkSTp8+jfnz58NisaC0tBRbt26V1N3sTPR6Pf7whz+EDMt2Z+KtzfHWXiD+2hxv7QWozZ1BvLUX6Lo2qziujeXBCYIgCCIBiGv7J4IgCIJoL0gQCYIgCAIkiARBEAQBgASRIAiCIABc5IK4Y8cO/PrXv0ZeXh5UKhU2btzY1U0Ky0svvYThw4cjLS0NOTk5uO222/Dzzz93dbPC8re//Q3FxcXCBNuRI0diy5YtXd2sqFmyZAlUKhXmzp3b1U1RZMGCBVCpVJKfgQMHdnWzIlJTU4N77rkHWVlZSEpKwtChQ7F79+6ubpYs+fn5IfdYpVJh9uzZXd00Rfx+P37/+9+joKAASUlJKCoqwqJFiyLX8+xCmpqaMHfuXPTt2xdJSUkYNWoUdu3a1Wnnj4vSbR1Fc3MzSkpKMGPGDNx+++1d3ZyIbN++HbNnz8bw4cPh8/nw3HPP4YYbbsChQ4eQkiLj9NoN6NWrF5YsWYL+/fuD4zisWbMGt956K/bu3YvBgwd3dfPCsmvXLrz++usoLi7u6qZEZPDgwfj000+FzxpN9/5qnzt3Dtdccw1+8YtfYMuWLbjkkktw9OhR9OjRo6ubJsuuXbvgFxWJ/uGHH/DLX/4Sv/3tb7uwVeF5+eWX8be//Q1r1qzB4MGDsXv3bkyfPh0ZGRl47LHHurp5sjzwwAP44Ycf8Pe//x15eXl46623cP311+PQoUPo2TM2b8NW0R4FuxMBANy//vWvrm5GTNTX13MAuO3bt3d1U2KiR48e3P/93/91dTPC0tTUxPXv35/75JNPuLFjx3KPP/54VzdJkT/84Q9cSUlJVzcjJubNm8dde+21Xd2MVvP4449zRUVFHMuyXd0URSZOnMjNmDFDsuz222/npkyZ0kUtCo/D4eAYhuE2b94sWX755Zdzzz//fKe04aIeMo13eBuszMzMLm5JdPj9frz77rtobm7u9mX6Zs+ejYkTJ+L666/v6qZExdGjR5GXl4fCwkJMmTIFJ06c6OomhWXTpk248sor8dvf/hY5OTkYNmwY3njjja5uVlR4PB689dZbmDFjRruYC3QUo0aNwrZt23DkSMDMd//+/fjqq6/wq1/9qotbJo/P54Pf74fBIDVZT0pKwldffdU5jegU2Y0DEGc9RL/fz02cOJG75ppruropETlw4ACXkpLCMQzDZWRkcB988EFXNyks77zzDjdkyBDO6XRyHMd1+x7ihx9+yP3jH//g9u/fz23dupUbOXIk16dPH66xsbGrm6aIXq/n9Ho9V1ZWxn3//ffc66+/zhkMBm716tVd3bSIrF+/nmMYhqupqenqpoTF7/dz8+bN41QqFafRaDiVSsW9+OKLXd2ssIwcOZIbO3YsV1NTw/l8Pu7vf/87p1aruUsvvbRTzk+CeIF4E8SZM2dyffv2jejv1R1wu93c0aNHud27d3PPPvssl52dzf34449d3SxZTpw4weXk5HD79+8XlnV3QQzm3LlzXHp6erceltZqtdzIkSMlyx599FHu6quv7qIWRc8NN9zA3XzzzV3djIi88847XK9evbh33nmHO3DgALd27VouMzOzW790HDt2jBszZgwHgGMYhhs+fDg3ZcoUbuDAgZ1yfhLEC8STIM6ePZvr1asXV1lZ2dVNaRXjx4/nHnrooa5uhiz/+te/hC8j/wOAU6lUHMMwnM/n6+omRsWVV17JPfvss13dDEX69OnD3X///ZJl/+///T8uLy+vi1oUHdXV1ZxareY2btzY1U2JSK9evbj//d//lSxbtGgRN2DAgC5qUfScP3+eq62t5TiO4+68807upptu6pTzUgwxjuA4DnPmzMG//vUvfPbZZygoKOjqJrUKlmXhdru7uhmyjB8/HgcPHsS+ffuEnyuvvBJTpkzBvn37wDBMVzcxIufPn0dFRQVyc3O7uimKXHPNNSFTho4cOYK+fft2UYui480330ROTg4mTpzY1U2JiMPhgFotfcQzDAOWZbuoRdGTkpKC3NxcnDt3Dh999BFuvfXWTjlv987N7mDOnz+PY8eOCZ+rqqqwb98+ZGZmok+fPl3YMnlmz56NdevW4f3330daWhosFguAgPFlUlJSF7dOnrKyMvzqV79Cnz590NTUhHXr1uGLL77ARx991NVNkyUtLQ1DhgyRLEtJSUFWVlbI8u7CU089hV//+tfo27cvamtr8Yc//AEMw+Duu+/u6qYp8sQTT2DUqFF48cUXceedd+K7777DypUrsXLlyq5umiIsy+LNN9/EtGnTuv20FgD49a9/jcWLF6NPnz4YPHgw9u7di7/85S+YMWNGVzdNkY8++ggcx2HAgAE4duwYnn76aQwcOLDzrAE7pR/aTfn88885ACE/06ZN6+qmySLXVgDcm2++2dVNU2TGjBlc3759OZ1Ox11yySXc+PHjuY8//rirmxUT3T2GOGnSJC43N5fT6XRcz549uUmTJnHHjh3r6mZF5N///jc3ZMgQTq/XcwMHDuRWrlzZ1U0Ky0cffcQB4H7++eeubkpUNDY2co8//jjXp08fzmAwcIWFhdzzzz/Pud3urm6aIuvXr+cKCws5nU7Hmc1mbvbs2ZzNZuu085P9E0EQBEHgIi/dRhAEQRA8JIgEQRAEARJEgiAIggBAgkgQBEEQAEgQCYIgCAIACSJBEARBACBBJAiCIAgAJIgE0W5wHIeHHnoImZmZUKlU2LdvX1c3iSCIGKCJ+QTRTmzZsgW33norvvjiCxQWFiI7OzsuSnwRBBGAvq0E0U7wBbVHjRolu97j8UCn03VyqwiCiBYaMiWIduC+++7Do48+ihMnTkClUiE/Px/jxo3DnDlzMHfuXGRnZ2PChAkAgB9++AG/+tWvkJqaCpPJhKlTp+LMmTPCsZqbm3HvvfciNTUVubm5ePXVVzFu3DjMnTtX2EalUmHjxo2SNhiNRqxevVr4fPLkSdx5550wGo3IzMzErbfeiurqakmbb7vtNrzyyivIzc1FVlYWZs+eDa/XK2zjdrsxb9489O7dG3q9Hv369UN5eTk4jkO/fv3wyiuvSNqwb98+qFQqSdF8gogXSBAJoh34n//5HyxcuBC9evVCXV0ddu3aBQBYs2YNdDodvv76a6xYsQI2mw3XXXcdhg0bht27d2Pr1q2wWq248847hWM9/fTT2L59O95//318/PHH+OKLL/D999/H1B6v14sJEyYgLS0NX375Jb7++mukpqbixhtvhMfjEbb7/PPPUVFRgc8//xxr1qzB6tWrJaJ677334p133sFrr72Gw4cP4/XXX0dqaipUKhVmzJiBN998U3LeN998E2PGjEG/fv1acRcJoovptDLiBJHgLF26lOvbt6/weezYsdywYcMk2yxatIi74YYbJMtOnjwpuCg0NTVxOp2O+8c//iGsP3v2LJeUlCRx3ICMoXVGRobgfPL3v/+dGzBgAMeyrLDe7XZzSUlJ3EcffcRxHPf/t3c/IYkFARjAv1a8qEWEFgqpEFERQiQUQVKUdCgkiEQqQs2CKIgOdejWtSLqEHirU0RBEHQpgv4oHaQgpC79kQ4VHYLqYKUPbPa0sm+NpdzdbOH7nZzH+GbeA/mYmfcc4Xa7hclkkm167HQ6hcvlEkIIcXp6KgCIra2tN6/35uZGKBQKEQqFhBBCSJIktFrtl96Rneh3uIZI9A9ZrVZZORwOY2dnBxqNJqVuJBLBy8sLJElCdXV18nheXh5KSko+1G44HMbFxQWys7Nlx2OxGCKRSLJcXl4u2/RYr9fj+PgYAJIbItfV1b3ZhsFgQEtLC+bn51FVVYX19XXE43E4nc4P9ZXoq2AgEv1DarVaVo5Go3A4HJiYmEipq9fr3732lpWVBfHLA+I/r/1Fo1FYrVYsLi6mfFen0yU/K5XKlPP+2FH9PZtO9/b2oru7GzMzM1hYWIDL5YJKpXrXNRB9NQxEok9UWVmJ1dVVmM3mN1/JKCoqglKpRCgUgtFoBAA8PDzg7OxMNlLT6XS4vb1Nls/Pz/H8/CxrZ3l5Gfn5+cjJyUmrrxaLBa+vr9jb24Pdbn+zTnNzM9RqNfx+PzY2NhAIBNJqi+gr4EM1RJ9ocHAQ9/f36OjowMHBASKRCDY3N+H1epFIJKDRaODz+TA6Oort7W2cnJzA4/Hg2zf5T7WhoQFzc3M4OjrC4eEh+vv7ZaO9rq4uaLVatLa2IhgM4vLyEru7uxgaGsL19fW7+mo2m+F2u9HT04O1tbXkOVZWVpJ1FAoFPB4PxsbGUFxcjJqamr9zo4gygIFI9IkMBgP29/eRSCTQ1NQEi8WC4eFh5ObmJkNvamoKNpsNDocDdrsdtbW1KWuR09PTKCwshM1mQ2dnJ0ZGRmRTlSqVCoFAAEajEW1tbSgrK4PP50MsFvvQiNHv96O9vR0DAwMoLS1FX18fnp6eZHV8Ph8kSYLX6/2DO0OUefynGqL/QH19PSoqKjA7O5vprqQIBoNobGzE1dUVCgoKMt0dorRxDZGI0hKPx3F3d4fx8XE4nU6GIf33OGVKRGlZWlqCyWTC4+MjJicnM90doj/GKVMiIiJwhEhERASAgUhERASAgUhERASAgUhERASAgUhERASAgUhERASAgUhERASAgUhERASAgUhERAQA+A4UsXs0a3qeKwAAAABJRU5ErkJggg=="" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""source"": [ + ""s.plot()"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:06:58.627227Z"", + ""start_time"": ""2023-07-19T10:06:57.910086Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 32, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"" + ] + } + ], + ""source"": [ + ""# extract neutral and selected SFS\n"", + ""neut = s['neutral.*'].merge_groups(1)\n"", + ""sel = s['selected.*'].merge_groups(1)\n"", + ""\n"", + ""# create inference objects\n"", + ""inferences = [fd.BaseInference(\n"", + "" sfs_neut=neut[t],\n"", + "" sfs_sel=sel[t],\n"", + "" model=fd.DiscreteFractionalParametrization(np.array([-100000, -100, -10, -1, 1, 1000])),\n"", + "" do_bootstrap=True\n"", + "") for t in neut.types]"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:45:04.121103Z"", + ""start_time"": ""2023-07-19T10:45:04.104195Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 33, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.S1': 0, 'all.S2': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 19 iterations and 138 function evaluations, obtaining a log-likelihood of -24.914217983522075.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.0, 'all.S2': 0.0, 'all.S3': 0.4594999163725839, 'all.S4': 0.8564984167403228, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 129.01it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S4': 1} and lower bound for {'all.S1': 0, 'all.S2': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 20 iterations and 138 function evaluations, obtaining a log-likelihood of -30.022839771992494.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.0, 'all.S2': 0.0, 'all.S3': 0.3600023106856762, 'all.S4': 1.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 202.65it/s]\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: 1 out of 100 bootstrap samples did not terminate normally during numerical optimization. The confidence intervals might thus be unreliable. Consider adjusting the optimization parameters (increasing `gtol` or `n_runs`) or decrease the number of optimized parameters.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S4': 1} and lower bound for {'all.S2': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 37 iterations and 258 function evaluations, obtaining a log-likelihood of -34.3671111014056.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.12817267732799753, 'all.S2': 0.0, 'all.S3': 0.010323679106065416, 'all.S4': 1.0, 'all.eps': 0.009174211460959952}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 124.16it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S4': 1} and lower bound for {'all.S2': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 22 iterations and 144 function evaluations, obtaining a log-likelihood of -25.475375215288608.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.11928977848583686, 'all.S2': 0.0, 'all.S3': 0.615869562627708, 'all.S4': 1.0, 'all.eps': 0.019263299838964024}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 144.39it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S4': 1} and lower bound for {'all.S1': 0, 'all.S2': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 16 iterations and 108 function evaluations, obtaining a log-likelihood of -34.468833337430766.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.0, 'all.S2': 0.0, 'all.S3': 0.5846558887680596, 'all.S4': 1.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 282.29it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.S1': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 32 iterations and 234 function evaluations, obtaining a log-likelihood of -29.682901017745053.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.0, 'all.S2': 0.30746187589641, 'all.S3': 0.40455830317845365, 'all.S4': 0.932973607767187, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 117.30it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.S1': 0, 'all.S3': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 36 iterations and 258 function evaluations, obtaining a log-likelihood of -38.199479587045985.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.0, 'all.S2': 0.38338017269595326, 'all.S3': 0.0, 'all.S4': 0.9783636846779312, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 145.22it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S4': 1} and lower bound for {'all.S1': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 23 iterations and 174 function evaluations, obtaining a log-likelihood of -31.770373796111585.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.0, 'all.S2': 0.18601401092014383, 'all.S3': 0.33898326285021646, 'all.S4': 1.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 108.27it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S4': 1} and lower bound for {'all.S2': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 29 iterations and 210 function evaluations, obtaining a log-likelihood of -28.529378505340308.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.04456723721483778, 'all.S2': 0.0, 'all.S3': 0.49148973090950193, 'all.S4': 1.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 148.61it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S4': 1} and lower bound for {'all.S2': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 22 iterations and 150 function evaluations, obtaining a log-likelihood of -35.771914171887104.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.13396428310264583, 'all.S2': 0.0, 'all.S3': 0.4412430748097687, 'all.S4': 1.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 178.44it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.S2': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 37 iterations and 252 function evaluations, obtaining a log-likelihood of -33.30327874167497.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.08605769588041276, 'all.S2': 0.0, 'all.S3': 0.32069661118788106, 'all.S4': 0.9551595448209943, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 121.36it/s]\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S4': 1} and lower bound for {'all.S1': 0, 'all.S2': 0, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 14 iterations and 126 function evaluations, obtaining a log-likelihood of -30.804263015169496.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S1': 0.0, 'all.S2': 0.0, 'all.S3': 0.22481984572414715, 'all.S4': 1.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 207.02it/s]\n"" + ] + }, + { + ""data"": { + ""text/plain"": ""[,\n ,\n ,\n ,\n ,\n ,\n ,\n ,\n ,\n ,\n ,\n ]"" + }, + ""execution_count"": 33, + ""metadata"": {}, + ""output_type"": ""execute_result"" + } + ], + ""source"": [ + ""# run inference\n"", + ""[i.run() for i in inferences]"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:45:23.306782Z"", + ""start_time"": ""2023-07-19T10:45:07.639665Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 34, + ""outputs"": [ + { + ""data"": { + ""text/plain"": """" + }, + ""execution_count"": 34, + ""metadata"": {}, + ""output_type"": ""execute_result"" + }, + { + ""data"": { + ""text/plain"": ""
"", + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""source"": [ + ""fd.Inference.plot_inferred_parameters(inferences, labels=neut.types)"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:45:49.374298Z"", + ""start_time"": ""2023-07-19T10:45:49.092720Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 35, + ""outputs"": [ + { + ""data"": { + ""text/plain"": """" + }, + ""execution_count"": 35, + ""metadata"": {}, + ""output_type"": ""execute_result"" + }, + { + ""data"": { + ""text/plain"": ""
"", + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""source"": [ + ""fd.Inference.plot_discretized(inferences, labels=neut.types)"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:46:27.125840Z"", + ""start_time"": ""2023-07-19T10:46:26.797675Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 31, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[33mWARNING:fastdfe.JointInference: Mutation rate is unusually highly. This is a reminder to provide monomorphic counts.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Parameters ['S3'] have covariates and thus need to be shared. Adding them to shared parameters.\u001B[0m\n"" + ] + }, + { + ""ename"": ""ValueError"", + ""evalue"": ""Specified shared parameters ['p_b', 'S_b'] don't match with any of ['S1', 'S2', 'S3', 'S4', 'eps']."", + ""output_type"": ""error"", + ""traceback"": [ + ""\u001B[0;31m---------------------------------------------------------------------------\u001B[0m"", + ""\u001B[0;31mValueError\u001B[0m Traceback (most recent call last)"", + ""Cell \u001B[0;32mIn[31], line 3\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mnumpy\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m \u001B[38;5;21;01mnp\u001B[39;00m\n\u001B[0;32m----> 3\u001B[0m inf \u001B[38;5;241m=\u001B[39m \u001B[43mfd\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mJointInference\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 4\u001B[0m \u001B[43m \u001B[49m\u001B[43msfs_neut\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mneut\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 5\u001B[0m \u001B[43m \u001B[49m\u001B[43msfs_sel\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msel\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 6\u001B[0m \u001B[43m \u001B[49m\u001B[43mshared_params\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m[\u001B[49m\u001B[43mfd\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mSharedParams\u001B[49m\u001B[43m(\u001B[49m\u001B[43mparams\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mp_b\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mS_b\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtypes\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mall\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m)\u001B[49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 7\u001B[0m \u001B[43m \u001B[49m\u001B[43mmodel\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mfd\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mDiscreteFractionalParametrization\u001B[49m\u001B[43m(\u001B[49m\u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[43m(\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;241;43m-\u001B[39;49m\u001B[38;5;241;43m100000\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m-\u001B[39;49m\u001B[38;5;241;43m100\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m-\u001B[39;49m\u001B[38;5;241;43m10\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m-\u001B[39;49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m1000\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 8\u001B[0m \u001B[43m \u001B[49m\u001B[43mcovariates\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m[\u001B[49m\u001B[43mfd\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mCovariate\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m 9\u001B[0m \u001B[43m \u001B[49m\u001B[43mparam\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mS3\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m 10\u001B[0m \u001B[43m \u001B[49m\u001B[43mvalues\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mdict\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43m(\u001B[49m\u001B[43mt\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mint\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43mt\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;129;43;01mnot\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[38;5;129;43;01min\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mA>T\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mT>A\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mG>C\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mC>G\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43;01mfor\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[43mt\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;129;43;01min\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[43mneut\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mtypes\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 11\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\u001B[43m]\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 12\u001B[0m \u001B[43m \u001B[49m\u001B[43mfixed_params\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m \u001B[49m\u001B[38;5;28;43mdict\u001B[39;49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mall\u001B[39;49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mdict\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43meps\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;241;43m0\u001B[39;49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m 13\u001B[0m \u001B[43m \u001B[49m\u001B[43mdo_bootstrap\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43m \u001B[49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\n\u001B[1;32m 14\u001B[0m \u001B[43m)\u001B[49m\n"", + ""File \u001B[0;32m~/PycharmProjects/fastDFE/fastdfe/joint_inference.py:156\u001B[0m, in \u001B[0;36mJointInference.__init__\u001B[0;34m(self, sfs_neut, sfs_sel, include_divergence, intervals_del, intervals_ben, integration_mode, linearized, model, seed, x0, bounds, scales, loss_type, opts_mle, n_runs, fixed_params, shared_params, covariates, do_bootstrap, n_bootstraps, parallelize, folded, **kwargs)\u001B[0m\n\u001B[1;32m 153\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39madd_covariates_as_shared(covariates)\n\u001B[1;32m 155\u001B[0m \u001B[38;5;66;03m# check if the shared parameters were specified correctly\u001B[39;00m\n\u001B[0;32m--> 156\u001B[0m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mcheck_shared_params\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 158\u001B[0m \u001B[38;5;66;03m# throw error if joint inference does not make sense\u001B[39;00m\n\u001B[1;32m 159\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mjoint_inference_makes_sense():\n"", + ""File \u001B[0;32m~/PycharmProjects/fastDFE/fastdfe/joint_inference.py:305\u001B[0m, in \u001B[0;36mJointInference.check_shared_params\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 302\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m shared \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mshared_params:\n\u001B[1;32m 303\u001B[0m \u001B[38;5;66;03m# check parameters\u001B[39;00m\n\u001B[1;32m 304\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(\u001B[38;5;28mset\u001B[39m(shared\u001B[38;5;241m.\u001B[39mparams) \u001B[38;5;241m-\u001B[39m \u001B[38;5;28mset\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mparam_names)) \u001B[38;5;241m!=\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[0;32m--> 305\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[1;32m 306\u001B[0m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mSpecified shared parameters \u001B[39m\u001B[38;5;132;01m{\u001B[39;00m\u001B[38;5;28mlist\u001B[39m(\u001B[38;5;28mset\u001B[39m(shared\u001B[38;5;241m.\u001B[39mparams)\u001B[38;5;250m \u001B[39m\u001B[38;5;241m-\u001B[39m\u001B[38;5;250m \u001B[39m\u001B[38;5;28mset\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mparam_names))\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m \u001B[39m\u001B[38;5;124m'\u001B[39m\n\u001B[1;32m 307\u001B[0m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\""\u001B[39m\u001B[38;5;124mdon\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mt match with any of \u001B[39m\u001B[38;5;132;01m{\u001B[39;00m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mparam_names\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m.\u001B[39m\u001B[38;5;124m\""\u001B[39m\n\u001B[1;32m 308\u001B[0m )\n\u001B[1;32m 310\u001B[0m \u001B[38;5;66;03m# check types\u001B[39;00m\n\u001B[1;32m 311\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(\u001B[38;5;28mset\u001B[39m(shared\u001B[38;5;241m.\u001B[39mtypes) \u001B[38;5;241m-\u001B[39m \u001B[38;5;28mset\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtypes)) \u001B[38;5;241m!=\u001B[39m \u001B[38;5;241m0\u001B[39m:\n"", + ""\u001B[0;31mValueError\u001B[0m: Specified shared parameters ['p_b', 'S_b'] don't match with any of ['S1', 'S2', 'S3', 'S4', 'eps']."" + ] + } + ], + ""source"": [ + ""inf = fd.JointInference(\n"", + "" sfs_neut=neut,\n"", + "" sfs_sel=sel,\n"", + "" shared_params=[fd.SharedParams(params=['p_b', 'S_b'], types='all')],\n"", + "" model=fd.DiscreteFractionalParametrization(np.array([-100000, -100, -10, -1, 1, 1000])),\n"", + "" covariates=[fd.Covariate(\n"", + "" param='S3',\n"", + "" values=dict((t, int(t not in ['A>T', 'T>A', 'G>C', 'C>G'])) for t in neut.types)\n"", + "" )],\n"", + "" fixed_params = dict(all=dict(eps=0)),\n"", + "" do_bootstrap = True\n"", + "")"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:43:42.065108Z"", + ""start_time"": ""2023-07-19T10:43:41.956291Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 16, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'all'.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.S_b': 100} and lower bound for {}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 48 iterations and 320 function evaluations, obtaining a log-likelihood of -37.11273875592235.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -14.237006794498091, 'all.b': 0.1458170683377238, 'all.p_b': 0.011838391666043677, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inferences for types ['A>C', 'A>G', 'A>T', 'C>A', 'C>G', 'C>T', 'G>A', 'G>C', 'G>T', 'T>A', 'T>C', 'T>G'].\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'A>C'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.b': 10} and lower bound for {}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 34 iterations and 195 function evaluations, obtaining a log-likelihood of -24.704319521655766.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -3.8567454840664306, 'all.b': 10.0, 'all.p_b': 0.29143034677368906, 'all.S_b': 7.396979801318865, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'A>G'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.S_b': 100} and lower bound for {}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 37 iterations and 220 function evaluations, obtaining a log-likelihood of -30.012275463201547.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -2.239183199810254, 'all.b': 0.27802524131704337, 'all.p_b': 0.006865462720810218, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'A>T'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_b': 100} and lower bound for {'all.S_d': -100000.0, 'all.b': 0.01}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 21 iterations and 190 function evaluations, obtaining a log-likelihood of -34.90111999594789.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -100000.0, 'all.b': 0.011232843334602316, 'all.p_b': 0.011479822938903853, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'C>A'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.S_b': 100} and lower bound for {}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 16 iterations and 100 function evaluations, obtaining a log-likelihood of -26.261891419653175.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -11.610276055007697, 'all.b': 0.36652863093931753, 'all.p_b': 0.03569932398989778, 'all.S_b': 100.0, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'C>G'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.b': 10} and lower bound for {'all.p_b': 0, 'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 13 iterations and 130 function evaluations, obtaining a log-likelihood of -30.138893406241486.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -2.1205379603542265, 'all.b': 10.0, 'all.p_b': 0.0, 'all.S_b': 0.0001, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'C>T'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01} and lower bound for {}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 37 iterations and 220 function evaluations, obtaining a log-likelihood of -29.482862608756065.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -17.42025190546462, 'all.b': 0.4799909983945452, 'all.p_b': 0.16748120196875874, 'all.S_b': 3.8537114057993476, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'G>A'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.b': 10, 'all.p_b': 0.5} and lower bound for {}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 16 iterations and 95 function evaluations, obtaining a log-likelihood of -37.071948363729746.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -19.828090886137, 'all.b': 10.0, 'all.p_b': 0.5, 'all.S_b': 1.1584077616195951, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'G>C'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.p_b': 0.5} and lower bound for {'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 33 iterations and 235 function evaluations, obtaining a log-likelihood of -31.6998772863962.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -12.608451652959161, 'all.b': 1.9042969165049093, 'all.p_b': 0.5, 'all.S_b': 0.35474087234269114, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'G>T'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01} and lower bound for {'all.p_b': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 14 iterations and 85 function evaluations, obtaining a log-likelihood of -28.497094398987027.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -4.223931861806486, 'all.b': 0.3246801507593634, 'all.p_b': 0.0, 'all.S_b': 92.55395724020116, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'T>A'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01} and lower bound for {'all.p_b': 0, 'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 11 iterations and 110 function evaluations, obtaining a log-likelihood of -36.222961471577335.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -9.117929611246703, 'all.b': 0.21103125965514108, 'all.p_b': 0.0, 'all.S_b': 0.0001, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'T>C'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01} and lower bound for {}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 38 iterations and 255 function evaluations, obtaining a log-likelihood of -33.04133966408648.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -5.802931321924449, 'all.b': 0.952062208073529, 'all.p_b': 0.31800002143513917, 'all.S_b': 2.725194868759536, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Running marginal inference for type 'T>G'.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.b': 10} and lower bound for {'all.p_b': 0, 'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 14 iterations and 110 function evaluations, obtaining a log-likelihood of -29.923197089705358.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -0.8145869272910264, 'all.b': 10.0, 'all.p_b': 0.0, 'all.S_b': 0.0001, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: A large number of parameters is optimized jointly (16). Please be aware that this makes it harder to find a good optimum.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'C>G.b': 10, 'A>C:A>G:A>T:C>A:C>G:C>T:G>A:G>C:G>T:T>A:T>C:T>G.S_b': 100, 'A>C:A>G:A>T:C>A:C>G:C>T:G>A:G>C:G>T:T>A:T>C:T>G.S_d': -0.01} and lower bound for {'A>C.b': 0.01, 'A>G.b': 0.01, 'A>T.b': 0.01, 'G>T.b': 0.01, 'T>C.b': 0.01, 'T>G.b': 0.01, 'A>C:A>G:A>T:C>A:C>G:C>T:G>A:G>C:G>T:T>A:T>C:T>G.c0': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Successfully finished optimization after 312 iterations and 6205 function evaluations, obtaining a log-likelihood of -392.4972323914126.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Inferred parameters: {'A>C.b': 0.04240807049739001, 'A>C.eps': 0.0, 'A>C.p_b': 0.014020203430891979, 'A>C.S_b': 100.0, 'A>C.S_d': -2.576838661756256, 'A>C.c0': -28.832925311021302, 'A>G.b': 0.051291030167721616, 'A>G.eps': 0.0, 'A>G.p_b': 0.014020203430891979, 'A>G.S_b': 100.0, 'A>G.S_d': -2.576838661756256, 'A>G.c0': -28.832925311021302, 'A>T.b': 0.09142144254109813, 'A>T.eps': 0.0, 'A>T.p_b': 0.014020203430891979, 'A>T.S_b': 100.0, 'A>T.S_d': -2.576838661756256, 'A>T.c0': -28.832925311021302, 'C>A.b': 0.17377574363664494, 'C>A.eps': 0.0, 'C>A.p_b': 0.014020203430891979, 'C>A.S_b': 100.0, 'C>A.S_d': -2.576838661756256, 'C>A.c0': -28.832925311021302, 'C>G.b': 10.0, 'C>G.eps': 0.0, 'C>G.p_b': 0.014020203430891979, 'C>G.S_b': 100.0, 'C>G.S_d': -2.576838661756256, 'C>G.c0': -28.832925311021302, 'C>T.b': 0.17683501545665492, 'C>T.eps': 0.0, 'C>T.p_b': 0.014020203430891979, 'C>T.S_b': 100.0, 'C>T.S_d': -2.576838661756256, 'C>T.c0': -28.832925311021302, 'G>A.b': 0.13281571672044995, 'G>A.eps': 0.0, 'G>A.p_b': 0.014020203430891979, 'G>A.S_b': 100.0, 'G>A.S_d': -2.576838661756256, 'G>A.c0': -28.832925311021302, 'G>C.b': 0.978224368650702, 'G>C.eps': 0.0, 'G>C.p_b': 0.014020203430891979, 'G>C.S_b': 100.0, 'G>C.S_d': -2.576838661756256, 'G>C.c0': -28.832925311021302, 'G>T.b': 0.09815078271461786, 'G>T.eps': 0.0, 'G>T.p_b': 0.014020203430891979, 'G>T.S_b': 100.0, 'G>T.S_d': -2.576838661756256, 'G>T.c0': -28.832925311021302, 'T>A.b': 3.2423653254762814, 'T>A.eps': 0.0, 'T>A.p_b': 0.014020203430891979, 'T>A.S_b': 100.0, 'T>A.S_d': -2.576838661756256, 'T>A.c0': -28.832925311021302, 'T>C.b': 0.062106223079901136, 'T>C.eps': 0.0, 'T>C.p_b': 0.014020203430891979, 'T>C.S_b': 100.0, 'T>C.S_d': -2.576838661756256, 'T>C.c0': -28.832925311021302, 'T>G.b': 0.023255813973911417, 'T>G.eps': 0.0, 'T>G.p_b': 0.014020203430891979, 'T>G.S_b': 100.0, 'T>G.S_d': -2.576838661756256, 'T>G.c0': -28.832925311021302}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'all'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'A>C'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'A>G'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'A>T'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'C>A'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'C>G'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'C>T'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'G>A'.\u001B[0m \n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: 1 out of 100 bootstrap samples did not terminate normally during numerical optimization. The confidence intervals might thus be unreliable. Consider adjusting the optimization parameters (increasing `gtol` or `n_runs`) or decrease the number of optimized parameters.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'G>C'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'G>T'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'T>A'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'T>C'.\u001B[0m \n"", + ""\u001B[32mINFO:fastdfe.JointInference: Bootstrapping type 'T>G'.\u001B[0m \n"", + ""Bootstrapping marginal inferences: 100%|██████████| 1300/1300 [00:19<00:00, 65.01it/s]\n"", + ""Bootstrapping joint inference: 100%|██████████| 100/100 [03:27<00:00, 2.07s/it]\n"" + ] + } + ], + ""source"": [ + ""inf.run()"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:37:24.299502Z"", + ""start_time"": ""2023-07-19T10:33:03.155380Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 17, + ""outputs"": [ + { + ""data"": { + ""text/plain"": """" + }, + ""execution_count"": 17, + ""metadata"": {}, + ""output_type"": ""execute_result"" + }, + { + ""data"": { + ""text/plain"": ""
"", + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""source"": [ + ""inf.plot_inferred_parameters()"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:37:39.235187Z"", + ""start_time"": ""2023-07-19T10:37:38.553983Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 29, + ""outputs"": [ + { + ""data"": { + ""text/plain"": ""-14.40348634304522"" + }, + ""execution_count"": 29, + ""metadata"": {}, + ""output_type"": ""execute_result"" + } + ], + ""source"": [ + ""inf.bootstraps.filter(regex='.*\\.c0').iloc[:, 0].max()"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T10:41:25.275190Z"", + ""start_time"": ""2023-07-19T10:41:25.270493Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": null, + ""outputs"": [], + ""source"": [], + ""metadata"": { + ""collapsed"": false + } + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 2 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython2"", + ""version"": ""2.7.6"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 0 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/quickstart.ipynb",".ipynb","50500","210","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""# Quickstart\n"", + ""The easiest way to get started is by using the {class}`~fastdfe.base_inference.BaseInference` class which infers the DFE from a single pair of frequency spectra, one `neutral` and one `selected`. In this example we create {class}`~fastdfe.spectrum.Spectrum` objects holding the SFS counts and pass them to {class}`~fastdfe.base_inference.BaseInference`. Note that we are required to specify the number of monomorphic sites (the last and first entries of the specified counts which correspond to the number of mono-allelic sites where the ancestral and derived allele is fixed, respectively). By default, only the deleterious part of the DFE is inferred (cf. {attr}`~fastdfe.base_inference.BaseInference.fixed_params`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2025-12-01T14:35:31.059679Z"", + ""start_time"": ""2025-12-01T14:35:30.100564Z"" + } + }, + ""source"": [ + ""import matplotlib.pyplot as plt\n"", + ""\n"", + ""plt.rcParams['figure.figsize'] = [4.8, 3.3]\n"", + ""plt.rcParams['xtick.labelsize'] = 9\n"", + ""plt.rcParams['ytick.labelsize'] = 9"" + ], + ""outputs"": [], + ""execution_count"": 1 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-01T14:35:42.914994Z"", + ""start_time"": ""2025-12-01T14:35:31.439120Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""import fastdfe as fd\n"", + ""\n"", + ""inf = fd.BaseInference(\n"", + "" sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0]),\n"", + "" sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0]),\n"", + "" do_bootstrap=False\n"", + "")\n"", + ""\n"", + ""# run inference\n"", + ""inf.run();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:02<00:00, 3.20it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:01<00:00, 6.40it/s]\n"", + ""\u001B[32mINFO:BaseInference: Successfully finished optimization after 18 iterations and 84 function evaluations, obtaining a log-likelihood of -35.44\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inferred parameters: {all.S_d: -3.389e+04, all.b: 0.1305, all.p_b: 0, all.S_b: 1, all.eps: 0}.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Standard deviations across runs: {all.S_d: 1.061e+04, all.b: 0.04187, all.p_b: 0, all.S_b: 0, all.eps: 0, likelihood: 7.282}.\u001B[0m\n"" + ] + } + ], + ""execution_count"": 2 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""fastDFE uses maximum likelihood estimation (MLE) to find the DFE. By default, 10 local optimization runs are carried out to make sure a reasonably good global optimum has been bound. The DFE furthermore needs to parametrized where {class}`~fastdfe.parametrization.GammaExpParametrization` is used by default. We also report the standard deviation across optimization runs to give an idea of the reliability of the estimates. In this case, the standard deviations are low, indicating that the estimates are stable."" + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""We can now plot the inferred DFE in discretized form (cf. {func}`~fastdfe.base_inference.BaseInference.plot_discretized`)."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-01T14:35:44.622434Z"", + ""start_time"": ""2025-12-01T14:35:43.006515Z"" + } + }, + ""source"": [ + ""inf.plot_discretized();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 3 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""We can also plot a comparison of the `selected` modelled and observed SFS (cf. {func}`~fastdfe.base_inference.BaseInference.plot_sfs_comparison`)."" + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-01T14:35:45.545452Z"", + ""start_time"": ""2025-12-01T14:35:44.668492Z"" + } + }, + ""source"": [ + ""inf.plot_sfs_comparison();"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 4 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": [ + ""## Bootstrapping\n"", + ""\n"", + ""To quantify uncertainly we can perform parametric bootstrapping (cf. {func}`~fastdfe.base_inference.BaseInference.bootstrap`)"" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-01T14:36:05.139787Z"", + ""start_time"": ""2025-12-01T14:35:45.608852Z"" + } + }, + ""source"": [ + ""inf.bootstrap(n_samples=100)\n"", + ""\n"", + ""# redo the plotting\n"", + ""inf.plot_discretized();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:18<00:00, 5.55it/s]\n"", + ""\u001B[32mINFO:BaseInference: Standard deviations across bootstraps: {all.S_d: 3.862e+04, all.b: 0.02186, all.p_b: 0, all.S_b: 0, all.eps: 0, likelihood: 5.922, i_best_run: 0.5016, likelihoods_std: 0.04005}.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Average standard deviation of likelihoods across runs within bootstrap samples: 0.005547.\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""execution_count"": 5 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""By default, we perform 2 optimization runs per bootstrap sample taking the best result (cf. {attr}`~fastdfe.base_inference.BaseInference.n_bootstrap_retries`). The standard deviation across runs is computed for each bootstrap sample, and the average of these standard deviations across all samples is reported to summarize the uncertainty of the bootstrap estimates. In this case, we can see that the uncertainty is quite low indicating reliable bootstrap estimates."" + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3 (ipykernel)"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 3 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython3"", + ""version"": ""3.10.14"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 4 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/parametrizations.ipynb",".ipynb","30790","170","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""# DFE parametrizations\n"", + ""\n"", + ""The DFE needs to be parametrized in some way in order to be amenable to maximum likelihood estimation. {class}`~fastdfe.parametrization.GammaExpParametrization` is used by default. Other parametrizations are also implemented (cf. {mod}`~fastdfe.parametrization`). You can also create your own parametrization by subclassing {class}`~fastdfe.parametrization.Parametrization`.\n"", + ""\n"", + ""To see how the parametrization affects the shape of the DFE, we use our example data for `B. pendula`."" + ] + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:21:07.341532Z"", + ""start_time"": ""2025-12-12T12:21:05.883863Z"" + } + }, + ""source"": [ + ""import matplotlib.pyplot as plt\n"", + ""\n"", + ""plt.rcParams['figure.figsize'] = [4.8, 3.3]\n"", + ""plt.rcParams['xtick.labelsize'] = 9\n"", + ""plt.rcParams['ytick.labelsize'] = 9\n"", + ""\n"", + ""import fastdfe as fd\n"", + ""fd.Settings.parallelize = False"" + ], + ""outputs"": [], + ""execution_count"": 1 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:22:11.877491Z"", + ""start_time"": ""2025-12-12T12:21:07.350235Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""import fastdfe as fd\n"", + ""import numpy as np\n"", + ""import logging\n"", + ""\n"", + ""# set logging level to only show very important messages\n"", + ""logging.getLogger('fastdfe').setLevel(logging.FATAL)\n"", + ""\n"", + ""# the different DFE parametrizations\n"", + ""parametrizations = [\n"", + "" fd.GammaExpParametrization(),\n"", + "" fd.DiscreteFractionalParametrization(),\n"", + "" fd.GammaDiscreteParametrization(),\n"", + "" fd.DisplacedGammaParametrization()\n"", + ""]\n"", + ""\n"", + ""inferences = []\n"", + ""for p in parametrizations:\n"", + "" # create inference object\n"", + "" inference = fd.BaseInference(\n"", + "" sfs_neut=fd.Spectrum([177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0]),\n"", + "" sfs_sel=fd.Spectrum([797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 0]),\n"", + "" fixed_params=dict(all=dict(h=0.5, eps=0)),\n"", + "" model=p\n"", + "" )\n"", + ""\n"", + "" # run inference\n"", + "" inference.run()\n"", + ""\n"", + "" inferences.append(inference)"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:00<00:00, 10.58it/s]\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:01<00:00, 8.12it/s]\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:14<00:00, 7.12it/s]\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:00<00:00, 10.46it/s]\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 12.39it/s]\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:12<00:00, 8.25it/s]\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:00<00:00, 10.16it/s]\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 12.88it/s]\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:12<00:00, 8.00it/s]\n"", + ""Discretization>Precomputing: 100%|██████████| 9/9 [00:00<00:00, 10.56it/s]\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 10.08it/s]\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:18<00:00, 5.48it/s]\n"" + ] + } + ], + ""execution_count"": 2 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:22:12.190295Z"", + ""start_time"": ""2025-12-12T12:22:11.930610Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""# plot the inferred DFEs\n"", + ""fd.Inference.plot_discretized(\n"", + "" inferences=inferences,\n"", + "" labels=[p.__class__.__name__ for p in parametrizations],\n"", + "" intervals=[-np.inf, -100, -10, -1, 1, np.inf],\n"", + "");"" + ], + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 3 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": ""The overall shape is similar, but {class}~fastdfe.parametrization.DiscreteParametrization shows noticeably wider confidence intervals. In general, estimating the full DFE with a sample size of 10 and the limited SNP count used here leads to substantial uncertainty."" + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3 (ipykernel)"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 3 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython3"", + ""version"": ""3.10.14"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 4 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/simulation.ipynb",".ipynb","143849","465","{ + ""cells"": [ + { + ""cell_type"": ""markdown"", + ""metadata"": { + ""collapsed"": false, + ""jupyter"": { + ""outputs_hidden"": false + } + }, + ""source"": [ + ""# SFS simulation\n"", + ""fastDFE provides a {class}`~fastdfe.simulation.Simulation` module to generate an expected SFS under a specific DFE, and potentially demographic nuisance parameters. In fact, when inferring the DFE with fastDFE, the expected SFS is repeatedly simulated for different parameters to find the maximum likelihood estimates. Below, we illustrate how to use the simulation module to generate SFS data under a given DFE. To do this, we need to specify a neutral SFS ({attr}`~fastdfe.simulation.Simulation.sfs_neut`), which is informative on the population sample size, population mutation rate, the number of sites, and possibly demography. {func}`~fastdfe.simulation.Simulation.get_neutral_sfs` can be used to obtain a neutral SFS under a constant panmictic population. We also specify the DFE parameters and parametrization. By default, we assume not ancestral misidentification (`eps=0`) and mutation are assumed to be semi-dominant (`h=0.5`)."" + ] + }, + { + ""metadata"": { + ""tags"": [ + ""remove-cell"" + ], + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:08:49.057385Z"", + ""start_time"": ""2025-12-12T12:08:48.542055Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""import matplotlib.pyplot as plt\n"", + ""\n"", + ""plt.rcParams['figure.figsize'] = [4.8, 3.3]\n"", + ""plt.rcParams['xtick.labelsize'] = 9\n"", + ""plt.rcParams['ytick.labelsize'] = 9"" + ], + ""outputs"": [], + ""execution_count"": 1 + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:08:50.132512Z"", + ""start_time"": ""2025-12-12T12:08:49.060784Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""import fastdfe as fd\n"", + ""\n"", + ""# create simulation object by specifying neutral SFS and DFE\n"", + ""sim = fd.Simulation(\n"", + "" sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4),\n"", + "" params=dict(S_d=-300, b=0.3, p_b=0, S_b=1),\n"", + "" model=fd.GammaExpParametrization()\n"", + "")"" + ], + ""outputs"": [], + ""execution_count"": 2 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Let's plot the DFE we are going to use for the simulation which is purely deleterious and follows a gamma distribution."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:08:50.391050Z"", + ""start_time"": ""2025-12-12T12:08:50.169032Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""sim.dfe.plot();"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 3 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Let's now run the simulation and plot the expected SFS for both neutral (specified) and selected (simulated) sites."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:08:50.911942Z"", + ""start_time"": ""2025-12-12T12:08:50.394971Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""sim.run()\n"", + ""sim.get_spectra().plot();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Simulation: Simulating SFS under selection using parameters: S_d=-300, b=0.3, p_b=0, S_b=1, eps=0, h=0.5\u001B[0m\n"", + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 19/19 [00:00<00:00, 63.02it/s]\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 4 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We can now use the simulated SFS to infer the DFE parameters and assess how closely the inference recovers the true DFE used to generate the data."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:09:47.014352Z"", + ""start_time"": ""2025-12-12T12:08:50.926586Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf = fd.BaseInference(\n"", + "" sfs_neut=sim.sfs_neut,\n"", + "" sfs_sel=sim.sfs_sel,\n"", + "" fixed_params=dict(all=dict(eps=0, h=0.5, p_b=0, S_b=1))\n"", + "")\n"", + ""\n"", + ""inf.run()\n"", + ""\n"", + ""fd.DFE.plot_many([sim.dfe, inf.get_dfe()], labels=['True DFE', 'Inferred DFE']);"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 19/19 [00:00<00:00, 66.18it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:02<00:00, 3.47it/s]\n"", + ""\u001B[32mINFO:BaseInference: Successfully finished optimization after 15 iterations and 93 function evaluations, obtaining a log-likelihood of -69.67\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inferred parameters: {all.S_d: -300, all.b: 0.3, all.p_b: 0, all.S_b: 1, all.eps: 0, all.h: 0.5}.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Standard deviations across runs: {all.S_d: 0.0008215, all.b: 2.279e-07, all.p_b: 0, all.S_b: 0, all.eps: 0, all.h: 0, likelihood: 3.484e-10}.\u001B[0m\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:52<00:00, 1.90it/s]\n"", + ""\u001B[32mINFO:BaseInference: Standard deviations across bootstraps: {all.S_d: 51.03, all.b: 0.01354, all.p_b: 0, all.S_b: 0, all.eps: 0, all.h: 0, likelihood: 3.079, i_best_run: 0.5024, likelihoods_std: 4.029}.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Average standard deviation of likelihoods across runs within bootstrap samples: 0.4029.\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 5 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""The DFE is recovered quite well which is expected given the simplicity of the DFE parametrization and lack of demographic complications."" + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We may want to see how the expected SFS changes as we vary the degree of dominance. Here, we run a second simulation with the same parameters except that we set `h=0.3` so that mutations are partially recessive."" + }, + { + ""cell_type"": ""code"", + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:10:34.907015Z"", + ""start_time"": ""2025-12-12T12:09:47.033359Z"" + } + }, + ""source"": [ + ""# run simulation with h=0.3\n"", + ""sim2 = fd.Simulation(\n"", + "" sfs_neut=fd.Simulation.get_neutral_sfs(n=20, n_sites=1e8, theta=1e-4),\n"", + "" params=dict(S_d=-300, b=0.3, p_b=0, S_b=1, h=0.3),\n"", + "" model=fd.GammaExpParametrization()\n"", + "")\n"", + ""\n"", + ""sim2.run()\n"", + ""\n"", + ""fd.Spectra.from_spectra(dict(\n"", + "" neutral=sim.sfs_neut,\n"", + "" semidominant=sim.sfs_sel,\n"", + "" recessive=sim2.sfs_sel\n"", + "")).plot();"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Simulation: Simulating SFS under selection using parameters: S_d=-300, b=0.3, p_b=0, S_b=1, h=0.3, eps=0\u001B[0m\n"", + ""\u001B[32mINFO:Discretization: Precomputing DFE-SFS transformation for fixed h=0.3.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 3819/3819 [00:47<00:00, 80.13it/s]\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 6 + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""As expected, partially recessive mutations lead to an excess of rare variants because they are masked in heterozygotes and experience weaker purifying selection. At higher frequencies, the difference from the semidominant case diminishes as derived-allele homozygotes become more common."" + }, + { + ""cell_type"": ""markdown"", + ""metadata"": {}, + ""source"": ""We can now infer the DFE under the (incorrect) assumption that mutations are semidominant (`h=0.5`) and see how this affects the inference result."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:12:05.855105Z"", + ""start_time"": ""2025-12-12T12:10:34.914162Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf = fd.BaseInference(\n"", + "" sfs_neut=sim2.sfs_neut,\n"", + "" sfs_sel=sim2.sfs_sel\n"", + "")\n"", + ""\n"", + ""inf.run()\n"", + ""\n"", + ""fd.DFE.plot_many([sim2.dfe, inf.get_dfe()], labels=['True DFE (h=0.3)', 'Inferred DFE (h=0.5)']);"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing semidominant DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 19/19 [00:00<00:00, 41.28it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 2 parameters: [all.b, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:04<00:00, 2.19it/s]\n"", + ""\u001B[32mINFO:BaseInference: Successfully finished optimization after 14 iterations and 63 function evaluations, obtaining a log-likelihood of -71.14\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inferred parameters: {all.S_d: -154.4, all.b: 0.3252, all.p_b: 0, all.S_b: 1, all.eps: 0, all.h: 0.5}.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Standard deviations across runs: {all.S_d: 0.0004465, all.b: 3.327e-07, all.p_b: 0, all.S_b: 0, all.eps: 0, all.h: 0, likelihood: 6.952e-10}.\u001B[0m\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [01:25<00:00, 1.18it/s]\n"", + ""\u001B[32mINFO:BaseInference: Standard deviations across bootstraps: {all.S_d: 20.61, all.b: 0.01421, all.p_b: 0, all.S_b: 0, all.eps: 0, all.h: 0, likelihood: 3.41, i_best_run: 0.4976, likelihoods_std: 7.301}.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Average standard deviation of likelihoods across runs within bootstrap samples: 0.7301.\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 7 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Assuming semidominance when mutations are actually partially recessive leads to an inferred DFE shifted toward weaker selection coefficients. This happens because rare variants generated by recessive mutations are misattributed to weaker selection when the dominance reduction in purifying selection is not accounted for."" + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We can also try to infer the DFE while letting the dominance coefficient `h` vary during the optimization. To optimize `h`, it needs to be discretized; in this example we use the default grid of 21 points between 0 and 1, with intermediate values obtained by linear interpolation. All required values are precomputed before the optimization, but allowing `h` to vary increases the computational cost because the expected SFS must be simulated for each `h` in the grid. To speed up the precomputation step, we instruct {class}`~fastdfe.base_inference.BaseInference` to use a coarser DFE discretization grid than the default, which should be sufficient for most inference scenarios."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:13:18.252291Z"", + ""start_time"": ""2025-12-12T12:12:05.908953Z"" + } + }, + ""cell_type"": ""code"", + ""source"": [ + ""inf = fd.BaseInference(\n"", + "" sfs_neut=sim.sfs_neut,\n"", + "" sfs_sel=sim.sfs_sel,\n"", + "" intervals_h=(0, 1, 21),\n"", + "" intervals_del=(-1.0e+8, -1.0e-5, 100),\n"", + "" intervals_ben=(1.0e-5, 1.0e4, 100),\n"", + "" fixed_params=dict(all=dict(eps=0, p_b=0, S_b=1))\n"", + "")\n"", + ""\n"", + ""inf.run()\n"", + ""\n"", + ""fd.DFE.plot_many([sim2.dfe, inf.get_dfe()], labels=['True DFE (h=0.3)', 'Inferred DFE']);"" + ], + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:Discretization: Precomputing DFE-SFS transformation across dominance coefficients (grid size: 21).\u001B[0m\n"", + ""Discretization>Precomputing: 100%|██████████| 8379/8379 [01:05<00:00, 127.93it/s]\n"", + ""\u001B[32mINFO:Optimization: Optimizing 3 parameters: [all.b, all.h, all.S_d].\u001B[0m\n"", + ""BaseInference>Performing inference: 100%|██████████| 10/10 [00:00<00:00, 26.84it/s]\n"", + ""\u001B[32mINFO:BaseInference: Successfully finished optimization after 29 iterations and 172 function evaluations, obtaining a log-likelihood of -69.67\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Inferred parameters: {all.S_d: -298.9, all.b: 0.3003, all.p_b: 0, all.S_b: 1, all.eps: 0, all.h: 0.5021}.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Standard deviations across runs: {all.S_d: 0.04796, all.b: 4.789e-06, all.p_b: 0, all.S_b: 0, all.eps: 0, all.h: 6.518e-05, likelihood: 5.245e-08}.\u001B[0m\n"", + ""BaseInference>Bootstrapping (2 runs each): 100%|██████████| 100/100 [00:05<00:00, 18.82it/s]\n"", + ""\u001B[32mINFO:BaseInference: Standard deviations across bootstraps: {all.S_d: 1.316e+04, all.b: 0.03581, all.p_b: 0, all.S_b: 0, all.eps: 0, all.h: 0.257, likelihood: 3.019, i_best_run: 0.5024, likelihoods_std: 0.1654}.\u001B[0m\n"", + ""\u001B[32mINFO:BaseInference: Average standard deviation of likelihoods across runs within bootstrap samples: 0.02186.\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 8 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We see that allowing `h` to vary during inference roughly recovers the true DFE used for the simulation, but with substantially greater uncertainty. Finally, we can examine the bootstrap results to assess how well `h` was estimated."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:13:18.382541Z"", + ""start_time"": ""2025-12-12T12:13:18.302474Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf.bootstraps.h.hist();"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAa0AAAEoCAYAAADrK65cAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAHJRJREFUeJzt3QlsFNcdx/G/jc0K4wswBRwbJylHQgIJxG1BKCmRYhMaUW6HuAlNAgREIBKHWgg42GBbQCsSCadyRaEENYaAqlJooMEcEkco4FJTBSRCpYJxSEocsI0xXl9TvVft1sbX7jLG+3a/H+lpx7szu7N/z87Pb/Z5JsSyLEsAADBAaFevAAAAniK0AADGILQAAMYgtAAAxiC0AADGILQAAMYgtAAAxggTgzU2Nsr169clKipKQkJCunp1AAA+Uv8yfPv2bYmPj5fQ0NDADC0VWImJiV29GgAAm1y7dk0SEhICM7RUD8v1JqOjoz1erq6uTg4ePCipqakSHh4uwY56UA+2Dz4zXb0Pqays1J0Q1349IEPLdUhQBZa3oRUREaGXIbSoB9sHnxdvsQ/pvHp09FUPAzEAAMYgtAAAxiC0AADGILQAAMYgtAAAxiC0AADGILQAAMYgtAAAxiC0AADGMPqMGLDfw8s/9YuyXln3UlevAgA/RE8LAGAMQgsAYAxCCwAQmKGVl5cnycnJ4nA4ZPLkye77S0pKJDIyslkLCwuTn/70p20+17hx4/TzNF1GXR8LAABbQktdUXLVqlUyd+7cZvcPHDhQqqqq3O3mzZsSGxsrM2fObPf51q9f32w59fwAANgyenDq1Kn6tri4WEpLS9ucb8+ePdLY2Oie3y5Op1O3phcNc13LRTVPueb1ZplA1rQejm6W+IOu/N2wfVAPtpEH/5nxdNkQy7K83ktlZmbq4FLh1Jrx48fLkCFDZNOmTe0eHvziiy90uCUlJcnixYtl1qxZHb5uVlZWi/sLCgr0BcgAAGaqrq6W9PR0qaioaPeivraH1tWrV+XRRx+Vc+fOyVNPPdXmc5w6dUqGDRumw+bIkSOSlpYm27ZtkylTpnjV01KXZy4rK/P6ysWFhYWSkpLClYvvqcfInCPiD77IHN9lr832QT3YRh78Z0btz+Pi4joMLdv/ufj3v/+9jBw5st3AUsaMGdOsZzZv3jz55JNP2g0tNXBDtXupIvlSKF+XC1SqFs6G9i91/aD4w++F7YN6sI08uM+Mp8vZOuRdHepToTVnzhyvlw0NZfQ9AKB9XiVFfX291NTU6FsVUGq6trbW/bjqHqpDda+88kq7z1NeXi779+/XxzAbGhrk8OHDkp+fL9OmTfNmdQAAQcar0MrOzpYePXpITk6O7Nu3T0+npqa6H9+yZYtMnz5dYmJiWiw7YcIEyc3NdR//VAMq+vfvL7169dKDMDZu3CgzZsyw4z0BAAJUmLcDMFRry65du9p87MCBA+7pvn37yunTp715aQAAOI0TAMAcjH4AABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYw/YrFwOB5OHln4o/uLLupa5eBcAv0NMCABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAEZmjl5eVJcnKyOBwOmTx5crPHxo0bp++PjIx0t+vXr7f5XJWVlZKeni7R0dHSr18/Wbt2re/vAgAQFLwKrfj4eFm1apXMnTu31cfXr18vVVVV7qbmb8uiRYvk5s2bUlJSIsePH5fNmzfL9u3bvX8HAICg4dW5B6dOnapvi4uLpbS01OcXra6ulp07d8rJkyclNjZWNxViW7ZskVmzZvn8vACAwGbrCXOzs7NlzZo1kpSUJIsXL24zgC5duiS1tbXy9NNPu+9T07m5ue0+v9Pp1K3pIUalrq5ON0+55vVmmUDWtB6Obpb4g6783VCPtusBatJZ24iny4ZYluX1XiozM1P3tvbs2eO+79SpUzJs2DCJiIiQI0eOSFpammzbtk2mTJnSYnl1OHDChAn6EKLL2bNnZcyYMVJfX9/u62ZlZbW4v6CgQL8uAMBM6gicGudQUVGhxzp0ek9LBY7L+PHjZd68efLJJ5+0GlpqkIZaQRVQYWH/WwW1olFRUe2+xooVK2TJkiXNelqJiYmSmpra7ptsLdELCwslJSVFwsPDJdg1rcfInCPiD77IHN9lr0092q4Hnxdq0lnbiOvIWZddTys0tO0xHkOHDtVv7Pz58/LMM8/o+1TPbfjw4e0+pxqdqNq91HP5UihflwtUqhbOhhDxB/7we6EeLevhD78Xf0JN7KuHp8t5NXpQ9Yxqamr0bWNjo55W302Vl5fL/v37de+poaFBDh8+LPn5+TJt2rRWn0cdynv55ZclIyND97AuX74smzZtkjlz5nizOgCAIBPq7UCLHj16SE5Ojuzbt09Pq0Nzqmuovmvq37+/9OrVSw/C2Lhxo8yYMcO9rPoOq+lAC/U/XzExMZKQkCBjx46V2bNnM3IQAGDf4UE1EEK11pw+fbrdZQ8cONDsZ/Ud1I4dO7x5eQBAkOM0TgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGOEdfUKAK15ePmnXVYYRzdLNvxQ5MnMz0QkpMvWA0BL9LQAAMYgtAAAgRlaeXl5kpycLA6HQyZPnuy+/8aNG/Kzn/1MEhISJDo6WkaOHCl79+5t97kefvhh6dGjh0RGRuoWGxvr+7sAAAQFr0IrPj5eVq1aJXPnzm12f1VVlQ6qv/3tb1JeXi5r1qyRV155RS5evNju8+3YsUMvq5paDgAA2wZiTJ06Vd8WFxdLaWmp+/5HH31Uli1b5v554sSJMnToUB1iw4YNE7s4nU7dXCorK/VtXV2dbp5yzevNMoGsaT3UIIRg5wi1mt36g67cVvm8UJMHsY14umyIZVlefzIzMzN1cO3Zs6fVx9XhwqSkJDl+/Lg+nNjW4cG7d+9KQ0ODDB48WDIyMuQnP/lJh6+blZXV4v6CggKJiIjw9m0AAPxEdXW1pKenS0VFhf6a6YGFVm1trbz44ouSmJgoH330UZvPoQLtmWeekW7duskf//hHmT17thw7dkx+8IMfeNXTUq9TVlbW7ptsLdELCwslJSVFwsPDJdg1rcfInCMS7FQPa21yo2QUhYqz0T+GvH+ROb7LXpvPCzV5ENuI2p/HxcV1GFq2/p+WCqzp06frXs/mzZvbnffZZ591T6t0VQGowqu90FIDQFS7lyqSL4XydblApWrhbPCPnbQ/UIHlL/Xwh+2Uzws16cxtxNPlwuwMrBkzZujbP//5z9K9e3evlg8NZfQ9AMDG0Kqvr3e3xsZGqamp0WETEhIiaWlpcufOHfnLX/7Sam+oqZKSErly5Yr86Ec/0sv/6U9/0kF39OhRb1YHABBkvOreZGdn6/+tysnJkX379unp1NRU+fzzz3XonDx5Uh+TdP3vVW5urnvZJ554Qj7++GM9rYa4v/POO9KnTx/p27ev/PrXv5Zdu3bJ6NGj7X+HAIDg7GmpARiqtaaj8RwXLlxwT6th8GogBwAA3uCEuYAB/OEEwoA/YPQDAMAYhBYAwBiEFgDAGIQWAMAYhBYAwBiEFgDAGIQWAMAYhBYAwBiEFgDAGIQWAMAYhBYAwBiEFgDAGIQWAMAYhBYAwBiEFgDAGIQWAMAYhBYAwBiEFgDAGIQWAMAYhBYAwBiEFgDAGIQWAMAYhBYAIDBDKy8vT5KTk8XhcMjkyZObPVZZWSnp6ekSHR0t/fr1k7Vr17b7XN7ODwBAmDcliI+Pl1WrVsmhQ4ektLS02WOLFi2SmzdvSklJidy4cUNeeOEFSUpKklmzZrX6XN7ODwCAV6E1depUfVtcXNwstKqrq2Xnzp1y8uRJiY2N1U2F0pYtW1oNIW/nd3E6nbo17a0pdXV1unnKNa83ywSypvVwdLMk2DlCrWa3wc5VBz4v/8c+xP56eLpsiGVZXn8yMzMzdXDt2bNH//yPf/xDRo0apV80LOx/OVhYWChpaWly69atFst7O3/T183Kympxf0FBgURERHj7NgAAfkJ1ZtRXRhUVFfprI1t6Wm2pqqqSnj17ugNIUb2n27dv2zK/y4oVK2TJkiXNelqJiYmSmpra7pu8lwpLFZIpKSkSHh4uwa5pPUbmHJFgp3oWa5MbJaMoVJyNIRLsXPXg8/J/7EPsr4fryFlHbAmtyMhInZL19fXuIFJpGRUVZcv8LmoAiGr3UkXypVC+LheoVC2cDeykXVRgUY/m2wefl5afGWpiTz08Xc6WIe9Dhw7VL3j+/Hn3ferw4fDhw22ZHwAAr0NL9Yxqamr0bWNjo56ura3V3ye9/PLLkpGRoXtMly9flk2bNsmcOXNafR5v5wcAwOvQys7Olh49ekhOTo7s27dPT6vvk1z/wxUTEyMJCQkyduxYmT17drORgBMmTJDc3Fz3zx3NDwDAfX2npUbvqdYaNRBix44dbS574MABr+YHAOBenMYJAGAMQgsAYAxCCwBgDEILAGAMQgsAYAxCCwBgDFtO44T79/DyT7usjOrM7ht+KPJk5mfqHMpdth4A0BF6WgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAY3CWdwAeUVcBcDZ0/VUArqx7qatXAV2InhYAwBiEFgAgOEMrMjKyWQsPD5cRI0a0Of/rr78u3bt3b7bMqVOn7FwlAEAAsfU7raqqqmY/q8CaOXNmu8ssWLBAPvjgAztXAwAQoDptIMaZM2fk4sWLujdlF6fTqZtLZWWlvq2rq9PNU655vVnmQVzyvsteO9RqdhvsqId/18MfPrf+uA8xvR6eLhtiWVanbInz5s2T69evy759+9qcRwXa3r179fSAAQPkzTfflMWLF0toaOtHLTMzMyUrK6vF/QUFBRIREWHj2gMAHqTq6mpJT0+XiooKiY6OfrChdefOHYmPj5ft27fLpEmT2pzv3LlzkpiYKL1795azZ89KWlqaDi3VPO1pqeXLysrafZOtJXphYaGkpKTo7938ZThxV1F/Qa9NbpSMolBxNnb9kOauRj38ux5fZI7v6lXwy32I6fVQ+/O4uLgOQ6tTDg/u3r1b93xeeqn9/6cYNWqUe3r06NGyfPlyHXRthZbD4dDtXqpIvhTK1+U6gz/8/4vaIfnDevgL6uGf9fCXz6y/7UNMr4eny3XKkPff/e538vOf/1zCwrzLxLYOCwIAoHPC7jJcunRJPv/8c5k9e3aH8+7atUt3CdURyqKiIlm3bp1MmzaN3wwA4MEcHtyyZYs8++yzMnjw4BaPzZ8/X9/m5+fr27y8PHnrrbekvr5eHnroIT38fenSpXavEgAgQNgeWhs2bGjzMVdYuRw7dszulwcABDBOmAsABnt4+ad+8X+mG374YF6LkQ8AAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGMQWgAAYxBaAABjEFoAAGNwlnc/OUsyAPM8mfmZOBtCuno1ggo9LQCAMQgtAIAxCC0AgDEILQCAMQgtAIAxCC0AgDEILQCAMQgtAIAxCC0AQHCG1uuvvy7du3eXyMhIdzt16lSb89fV1cnChQulV69e0rt3b1m0aJHU19fbuUoAgABie09rwYIFUlVV5W5jxoxpc97s7Gw5ceKEXLx4US5cuCDHjx+X3Nxcu1cJABAguvTcg1u3bpX3339fBgwYoH9euXKlLFu2TN57771W53c6nbq5VFZWuntsqnnKNa/r1tHNkmDmCLWa3QY76uHf9fDms97Z6+AvNelqrjrcz+/G02VDLMuy7Dw8uHfvXj2tgujNN9+UxYsXS2hoyw7drVu39CHBy5cvy6BBg/R9anrIkCFSXl4uMTExLZbJzMyUrKysFvcXFBRIRESEXW8DAPCAVVdXS3p6ulRUVEh0dPSDCa1z585JYmKiDqOzZ89KWlqaDi3V7nXt2jUZOHCgfPvttxIXF6fvU9Pf+9739GMJCQke9bTU65WVlbX7JltL9MLCQklJSZHw8HB9puZg/ytpbXKjZBSFirORM1ZTD7YPPjO+fWZc+1RfqP25yoKOQsvWw4OjRo1yT48ePVqWL18u27dvbzW01CANRa2gK7TUtBIVFdXq8zscDt3upYrkS6Fcy3Fpgf9RgUUt/o96NEc9WqIm9uyLXct2+ZD31g4LuqgRg6o3VVxc7L5PTaueU2uHBgEAsDW0du3apbt46ohjUVGRrFu3TqZNm9bm/G+88Ybk5OTIN998o5saOThnzhx+KwCAzj88mJeXJ2+99Zb+X6uHHnpID39funSp+/H58+fr2/z8fH2bkZEh3333nTz++OP651dffVXeffddO1cJABBAbA2tY8eOtfu4K6yaHsP88MMPdQMAoCOcxgkAYAxCCwBgDEILAGAMQgsAYAxCCwBgDEILAGAMQgsAYAxCCwBgDEILAGAMQgsAYAxCCwBgDEILAGAMQgsAYAxCCwBgDEILAGAMQgsAYAxCCwBgDEILAGAMQgsAYAxCCwBgDEILAGAMQgsAYAxCCwAQnKHldDpl7ty58sgjj0hUVJQ89thjsnXr1jbnHzdunDgcDomMjHS369ev27lKAIAAYmto1dfXy4ABA+TQoUNSWVkp27Ztk6VLl8rBgwfbXGb9+vVSVVXlbvHx8XauEgAggNgaWj179pQ1a9bI97//fQkJCZHRo0fL888/LydOnLDzZQAAQSqsM5+8pqZGzpw5I+np6W3Ok52drYMuKSlJFi9eLLNmzWr38KNqLqo3p9TV1enmKde8rltHN0uCmSPUanYb7KgH9WAb8e0z481++F6eLhtiWVan7KnU07722mvy1VdfyeHDhyU0tGWn7tSpUzJs2DCJiIiQI0eOSFpamj6kOGXKlFafMzMzU7KyslrcX1BQoJ8DAGCm6upq3cGpqKiQ6OjoBxta6ikXLFggRUVF+vutmJgYj5b7xS9+ISUlJbJz506Pe1qJiYlSVlbW7ptsLdELCwslJSVFwsPD5cnMzyTY/0pam9woGUWh4mwMkWBHPagH24hvnxnXPtUXan8eFxfXYWiFdUZgvf3223L69Gndw/I0sJTWemNNqZGGqt1LFcmXQrmWczawo1ZUYFGL/6MezVGPlqiJPfti17Jd8n9aCxculJMnT+qeTK9evdqcr7y8XPbv36+7hA0NDTrg8vPzZdq0aXavEgAgQNgaWlevXpXf/OY3cunSJT2wwvW/V/Pnz9ePT5gwQXJzc92H6NT3U/3799fhpgZhbNy4UWbMmGHnKgEAAoithwdVULX3FdmBAwfc03379tWHEAEA8BSncQIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACABiD0AIAGIPQAgAYg9ACAARvaNXV1cnChQulV69e0rt3b1m0aJHU19ff97wAANgeWtnZ2XLixAm5ePGiXLhwQY4fPy65ubn3PS8AAGF2l2Dr1q3y/vvvy4ABA/TPK1eulGXLlsl77713X/MqTqdTN5eKigp9e/PmTd1r85Sat7q6Wr777jsJDw+XsPo7EszCGi2prm6UsLpQaWgMkWBHPagH24hvnxnXPtUXt2/f1reWZbU/o2WjmzdvqlezLl++7L7vyy+/1PeVl5f7PK/L6tWr9eM0asA2wDbANiABWYNr1661mzO29rSqqqr0bWxsrPs+17RK0ZiYGJ/mdVmxYoUsWbLE/XNjY6PuZfXp00dCQjzvIVRWVkpiYqJcu3ZNoqOjJdhRD+rB9sFnpqv3IaqHpfb98fHx7c5na2hFRka6D9vFxcW5p5WoqCif53VxOBy6NdU09LyliktoUQ+2Dz4v7EPscb/71NY6K506EEONAkxISJDi4mL3fWpaJfC9K+PNvAAA2B5ayhtvvCE5OTnyzTff6KZGA86ZM+e+5wUAwPbRgxkZGXoEyeOPP65/fvXVV+Xdd9/V0/Pnz9e3+fn5Hc7bmdQhxtWrV7c41BisqAf1YPvgM2PKPiREjcbo9FcBAMAGnMYJAGAMQgsAYAxCCwBgDEILAGAMQgsAYIyADS0ukeJbPdQJiefOnSuPPPKIPjPJY489pk9sHGh8uSzO3bt3ZdCgQfd1FpZAqcfevXvl6aeflp49e+rT7rj+jSUY6/HVV1/J5MmT9enk1Nl90tLS5Ntvv5VAkpeXJ8nJyXpIu3qvHZ3SKT09XZ8Zo1+/frJ27Vpb1yVgQ4tLpPhWD/XBVGfdP3TokN74tm3bJkuXLpWDBw9KIPHlsjjq6gNJSUkSiLypx1//+ldZsGCBfPDBB3obUfOPGzdOgrUeb7/9tr69evWq/Pvf/5aamhp55513JJDEx8fLqlWr9B+0HVEBr84JW1JSouu2efNm2b59u30rYwWohIQEa/fu3e6fd+3aZQ0cOPC+5zXV/bzHKVOmWBkZGVYw16OoqMh68sknrc8++8yKiYmxAo039UhOTrZ++9vfWoHMm3oMHz7c+vjjj90//+EPf7CeeOIJKxCtXr3amjRpUpuP37lzx+revbt19uxZ930bNmywnnvuOdvWISB7Wrdu3ZLS0lJ9+MJFTavkd52U15d5TXU/71H91XjmzBkZMWKEBApv66F6n+ovzA8//FC6d+8ugcabety5c0f+/ve/60NiQ4YMkf79+8uMGTPk66+/lmDdPtSVJ3bv3q0fKy8vlx07dsjEiRMlGF26dElqa2tb1O6f//ynba8RkKHV0WVPfJ3XVL6+R3WyFHUuyMGDB8vUqVMlUHhbj1/96lcycuRIee655yQQeVMPtUNX28WePXuksLBQ/vWvf+nvOdQp2IJ1+xg7dqzcuHHD/f2XqpG6jFIwqqqq0t9zhoWFNaudnfvSgAytppc9cfHkEikdzWsqX96j2jGp7y3UX05qBxUaGjibijf1UDtlNchABVeg8uXzor6zUd/vqZ+zsrLk6NGjuhcWbPVQ1/RLSUnRwaV22Kqp6dTUVAlGkZGR+qrwTQetqNrZuS8NnD1RE1wixfd6uAJLfbl8+vRpPQAj0C4V40091Jfx//nPf/ShMDUybNKkSXrwgZpW9Qm2eqi/mgcOHNjq8wTKaUy9qYcacKAGYKgQj4iI0E0NRFDbRllZmQSboUOHSnh4uJw/f75Z7YYPH27fi1gBSg0cGDlypPX111/rpqazsrLue15TefMeFyxYYI0YMcIqKyuzApWn9VBfLKvLf7ua+kI+OjpaTzudTisYt4/s7GzrqaeeskpLS63q6mpr1qxZ1gsvvGAFEm/qMWjQIGv58uXW3bt3dfvlL3+pB3IEkrq6Ov3eVq5caU2cOFFPt7X9v/baa9aECROs8vJy68svv9QDWD766CPb1iVgQ6u2tlbvfGNjY3VbuHChLrwyb9483TyZN9jqceXKFfXnsuVwOKyePXu6W9N6Bdv20dTRo0cDcvSgN/Wor6+3lixZYvXp00e36dOn6x17sNbjwoULVmpqqtW7d2897/PPP2+dO3fOCrRRgyLSrP34xz/Wj7344otWTk6Oe96Kigpr5syZVmRkpNW3b1/bOwBcmgQAYIyA/E4LABCYCC0AgDEILQCAMQgtAIAxCC0AgDEILQCAMQgtAIAxCC0AgDEILQCAMQgtAIAxCC0AgJjivzgB7YX+oOATAAAAAElFTkSuQmCC"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 9 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""We see that `h` was estimated with considerable uncertainty, but the bootstrap distribution still puts substantial mass near the true value `h = 0.3`. How well dominance can be inferred from SFS data alone remains an open question, especially when the DFE is more complex or additional nuisance parameters such as demography are included."" + }, + { + ""metadata"": { + ""ExecuteTime"": { + ""end_time"": ""2025-12-12T12:13:18.790855Z"", + ""start_time"": ""2025-12-12T12:13:18.392111Z"" + } + }, + ""cell_type"": ""code"", + ""source"": ""inf.bootstraps.assign(S_d=inf.bootstraps.S_d.abs()).plot.hexbin('S_d', 'h', xscale='log', gridsize=15, figsize=(4, 3));"", + ""outputs"": [ + { + ""data"": { + ""text/plain"": [ + ""
"" + ], + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"", + ""jetTransient"": { + ""display_id"": null + } + } + ], + ""execution_count"": 10 + }, + { + ""metadata"": {}, + ""cell_type"": ""markdown"", + ""source"": ""Indeed, we see that `h` covaries with `S_d`, with larger `h` associated with less strongly deleterious mutations."" + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3 (ipykernel)"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 3 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython3"", + ""version"": ""3.10.14"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 4 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/example_pendula_simple.ipynb",".ipynb","98781","101","{ + ""cells"": [ + { + ""cell_type"": ""code"", + ""execution_count"": 5, + ""metadata"": { + ""collapsed"": true, + ""ExecuteTime"": { + ""end_time"": ""2023-06-30T08:36:09.918427Z"", + ""start_time"": ""2023-06-30T08:36:07.179278Z"" + } + }, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.p_b': 0, 'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 79 iterations and 594 function evaluations, obtaining a log-likelihood of -34.63216290448145.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -9867.852019677897, 'all.b': 0.15081059927802082, 'all.p_b': 0.0, 'all.S_b': 0.00010000034366964345, 'all.eps': 0.006854767570905897}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 123.80it/s]\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: 1 out of 100 bootstrap samples did not terminate normally during numerical optimization. The confidence intervals might thus be unreliable. Consider adjusting the optimization parameters (increasing `gtol` or `n_runs`) or decrease the number of optimized parameters.\u001B[0m\n"" + ] + } + ], + ""source"": [ + ""import fastdfe as fd\n"", + ""import matplotlib.pyplot as plt\n"", + ""\n"", + ""# create inference object\n"", + ""inf = fd.BaseInference(\n"", + "" # neutral SFS\n"", + "" sfs_neut=fd.Spectrum(\n"", + "" [177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 0]\n"", + "" ),\n"", + "" # selected SFS\n"", + "" sfs_sel=fd.Spectrum(\n"", + "" [797939,1329, 499, 265, 162, 104, 117, 90, 94, 119, 794]\n"", + "" ),\n"", + "" n_runs=10,\n"", + "" n_bootstraps=100,\n"", + "" do_bootstrap=True\n"", + "")\n"", + ""\n"", + ""inf.run();"" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 17, + ""outputs"": [ + { + ""data"": { + ""text/plain"": ""
"", + ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAABEcAAAPeCAYAAADu6HSLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxV1f7/8fcBZRAERGVyAByus6KohHNFonFTy5yyxCGtlMy8WdlNRUspszSHNLs5lFrWvWVlOYVTFjmGY5maUyZqKaCogLB/f/jjfDsCCnjggOf1fDz2Q/baa6392Zsje/Nh7bVNhmEYAgAAAAAAsFMOtg4AAAAAAADAlkiOAAAAAAAAu0ZyBAAAAAAA2DWSIwAAAAAAwK6RHAEAAAAAAHaN5AgAAAAAALBrJEcAAAAAAIBdIzkCAAAAAADsGskRAAAAAABg10iOALgjBAUFaeDAgbYOAwAAq4qNjZXJZLIoK4vXvGPHjslkMmnRokUlut+BAwcqKCioRPcJoGwiOQLcpr179+rhhx9WYGCgXFxcVK1aNd13332aNWuWRb2goCCZTKY8l6tXr5rrffXVV+rYsaN8fHxUoUIF1apVS71799bq1atL+tAAAAAKZdmyZZoxY4atwyi0Tp06me/LHBwc5OHhoXr16umxxx7TunXr8mxTkHu7RYsW5VvHZDLpxx9/LMnDBHAT5WwdAFCW/fDDD7r77rtVs2ZNDR06VH5+fjp58qR+/PFHvf3223r66act6oeEhOhf//pXrn6cnJwkSdOmTdOYMWPUsWNHjR07VhUqVNDhw4f17bff6uOPP1aXLl1K5LjKooMHD8rBgXwvAODOV5qvecuWLdO+ffs0atQoi/LAwEBduXJF5cuXt01gBVC9enXFxcVJktLS0nT48GF99tlnWrJkiXr37q0lS5bkiv9W93Y5Jk2apODg4Fz16tSpY8UjAHA7SI4At2Hy5Mny9PTU9u3b5eXlZbHt7NmzuepXq1ZNjz76aJ59Xbt2Ta+88oruu+8+rV27Ntf2vPqzd4Zh6OrVq3J1dZWzs7OtwwEAoESU5DUvLS1Nbm5ut92PyWSSi4uLFSIqPp6enrnu01577TWNHDlS77zzjoKCgvT6669bbL/Zvd3fde3aVS1btrRqvACsq3SmnIEy4siRI2rUqFGuxIgk+fj4FKqvP//8U6mpqWrbtm2e2wva35IlS9S6dWtVqFBBlSpVUocOHXIlW9555x01atRIzs7OCggI0IgRI5ScnGxRp1OnTmrcuLH27Nmjjh07qkKFCqpTp47++9//SpI2bdqksLAwubq6ql69evr2228t2uc8I/3LL7+od+/e8vDwUOXKlfXMM89YPEYkSQsXLtQ999wjHx8fOTs7q2HDhpo7d26uYwsKCtI///lPrVmzRi1btpSrq6veffdd87a/P3+dmZmpiRMnqm7dunJxcVHlypXVrl27XENj169fr/bt28vNzU1eXl7q3r27fv755zyP5fDhwxo4cKC8vLzk6empQYMG6fLly7f+pgAAUABbtmxRq1at5OLiotq1a5uvcTcq6jUv55pctWpV8/X73//+t3l7zvXuwIEDeuSRR1SpUiW1a9fOvH3JkiUKDQ2Vq6urvL291bdvX508edK8vVOnTvr66691/Phx82MjOfN93DjnyMaNG/N91OTGOUJWrVplvlZXrFhRUVFR2r9/f67zsmLFCjVu3FguLi5q3LixPv/884Kc9ptydHTUzJkz1bBhQ82ePVspKSm33SeA0omRI8BtCAwMVEJCgvbt26fGjRvfsn5mZqb+/PNPi7IKFSqoQoUK8vHxkaurq7766is9/fTT8vb2LnQ8EydOVGxsrNq0aaNJkybJyclJW7du1fr169W5c2dJ1298Jk6cqIiICD311FM6ePCg5s6dq+3bt+v777+3GC564cIF/fOf/1Tfvn3Vq1cvzZ07V3379tXSpUs1atQoPfnkk3rkkUf0xhtv6OGHH9bJkydVsWJFi5h69+6toKAgxcXF6ccff9TMmTN14cIFffDBB+Y6c+fOVaNGjdStWzeVK1dOX331lYYPH67s7GyNGDHCor+DBw+qX79+euKJJzR06FDVq1cvz3MRGxuruLg4Pf7442rdurVSU1O1Y8cO7dq1S/fdd58k6dtvv1XXrl1Vq1YtxcbG6sqVK5o1a5batm2rXbt25bo56927t4KDgxUXF6ddu3bpP//5j3x8fHL9FQkAgMLau3evOnfurKpVqyo2NlbXrl3ThAkT5Ovre8u2Bbnm7dmzR+3bt1f58uU1bNgwBQUF6ciRI/rqq680efJki/569eqlunXrasqUKTIMQ9L10bLjxo1T79699fjjj+vcuXOaNWuWOnTooJ9++kleXl7697//rZSUFP3++++aPn26JMnd3T3PmBs0aKAPP/zQoiw5OVmjR4+2+IPQhx9+qOjoaEVGRur111/X5cuXNXfuXLVr104//fST+Vq9du1a9ezZUw0bNlRcXJz++usvDRo0SNWrVy/YN+AmHB0d1a9fP40bN05btmxRVFSUedvN7u3+LiUlJVc9k8mkypUr33Z8AKzEAFBka9euNRwdHQ1HR0cjPDzceP755401a9YYGRkZueoGBgYaknItEyZMMNcZP368Iclwc3MzunbtakyePNnYuXNngWI5dOiQ4eDgYDz44INGVlaWxbbs7GzDMAzj7NmzhpOTk9G5c2eLOrNnzzYkGQsWLDCXdezY0ZBkLFu2zFz2yy+/GJIMBwcH48cffzSXr1mzxpBkLFy40Fw2YcIEQ5LRrVs3i1iGDx9uSDJ2795tLrt8+XKu44mMjDRq1aplUZZzDlevXp2rfmBgoBEdHW1eb9asmREVFZWr3t+FhIQYPj4+xl9//WUu2717t+Hg4GAMGDAg17EMHjzYov2DDz5oVK5c+ab7AACgIHr06GG4uLgYx48fN5cdOHDAcHR0NG68ZS/KNa9Dhw5GxYoVLfo3jP+7RzCM/7ve9evXz6LOsWPHDEdHR2Py5MkW5Xv37jXKlStnUR4VFWUEBgbm2v/Ro0dz3SvcGMc///lPw93d3di/f79hGIZx8eJFw8vLyxg6dKhF3aSkJMPT09OiPCQkxPD39zeSk5PNZWvXrjUk5RnPjTp27Gg0atQo3+2ff/65Icl4++23zWUFubdbuHBhnnUkGc7OzreMC0DJ4bEa4Dbcd999SkhIULdu3bR7925NnTpVkZGRqlatmr788stc9cPCwrRu3TqLZcCAAebtEydO1LJly9S8eXOtWbNG//73vxUaGqoWLVrketTjRitWrFB2drbGjx+fa5K2nFcAfvvtt8rIyNCoUaMs6gwdOlQeHh76+uuvLdq5u7urb9++5vV69erJy8tLDRo0UFhYmMVxSdJvv/2WK64bR37kTFL7zTffmMtcXV3NX+f8ZaVjx4767bffcg1fDQ4OVmRk5E3OxHVeXl7av3+/Dh06lOf206dPKzExUQMHDrQYpdO0aVPdd999FvHlePLJJy3W27dvr7/++kupqam3jAcAgPxkZWVpzZo16tGjh2rWrGkub9CggVWueefOndPmzZs1ePBgi/6l/7tH+Lsbr3efffaZsrOz1bt3b/3555/mxc/PT3Xr1tWGDRsKcpg39corr2jlypVatGiRGjZsKElat26dkpOT1a9fP4v9Ojo6KiwszLzfnGt6dHS0PD09zX3ed9995r5uV84ImIsXL1qU3+reLsecOXNy1Vu1apVVYgNgHTxWA9ymVq1a6bPPPlNGRoZ2796tzz//XNOnT9fDDz+sxMREi4tylSpVFBERcdP++vXrp379+ik1NVVbt27VokWLtGzZMj3wwAPat29fvpOZHTlyRA4ODje9CTh+/Lgk5XoUxcnJSbVq1TJvz1G9evVcN02enp6qUaNGrjLp+mM4N6pbt67Feu3ateXg4KBjx46Zy77//ntNmDBBCQkJuebwSElJsbjRyWum97xMmjRJ3bt31z/+8Q81btxYXbp00WOPPaamTZtKyv9cSNdvRtesWZNrErobbygrVaok6fpxe3h4FCguAABudO7cOV25ciXXNVO6fp3KK2H/d7e65uX88aIgjwBLua+1hw4dkmEYecYn6bbfQLN69WpNnDhRY8eOVc+ePS32K0n33HNPnu1yrr051/T8zt+uXbtuKz5JunTpkiTleny4IPd2ktS6dWsmZAVKOZIjgJU4OTmpVatWatWqlf7xj39o0KBB+vTTTzVhwoQi9efh4aH77rtP9913n8qXL6/Fixdr69at6tixo5Ujz5+jo2Ohyo3//1zyzdyYbDly5Ijuvfde1a9fX2+99ZZq1KghJycnffPNN5o+fbqys7Mt6v99lMnNdOjQQUeOHNEXX3yhtWvX6j//+Y+mT5+uefPm6fHHHy9QHze6neMGAKC4WPuad+O1Njs7WyaTSatWrcrzWpjfvCIFcfToUfXv31/33XefXn311Vz7la7PO+Ln55erbblyJferzL59+yTx6l3gTkZyBCgGOX8ZOH36tNX6W7x48U37q127trKzs3XgwAGFhITkWScwMFDS9UlNa9WqZS7PyMjQ0aNHC/SXj8I6dOiQxV+gDh8+rOzsbPMEal999ZXS09P15ZdfWozMsMYQXW9vbw0aNEiDBg3SpUuX1KFDB8XGxurxxx+3OBc3+uWXX1SlShWrvLoQAIBbyXl7TF6PxeR1ncrLza55Odf8nF/wC6t27doyDEPBwcH6xz/+cdO6eT2mk58rV67ooYcekpeXlz766KNcjwXXrl1b0vU39t3sHiXnmn475+9msrKytGzZMlWoUMHi7T0A7izMOQLchg0bNuQ5aiBn+Gt+b1LJy+XLl5WQkJDntpxnUm/WX48ePeTg4KBJkyblGm2RE2NERIScnJw0c+ZMi7jff/99paSkWMy+bi1z5syxWJ81a5YkqWvXrpL+bzTG3+NJSUnRwoULb2u/f/31l8W6u7u76tSpo/T0dEmSv7+/QkJCtHjxYovXGO/bt09r167V/ffff1v7BwCgoBwdHRUZGakVK1boxIkT5vKff/5Za9asuWX7W13zqlatqg4dOmjBggUW/UsFG/340EMPydHRURMnTsxV3zAMi/27ubkV+HW3Tz75pH799Vd9/vnn5kdV/y4yMlIeHh6aMmWKMjMzc20/d+6cJMtr+t/3vW7dOh04cKBAseQnKytLI0eO1M8//6yRI0fyGC1wB2PkCHAbnn76aV2+fFkPPvig6tevr4yMDP3www9avny5goKCNGjQoAL3dfnyZbVp00Z33XWXunTpoho1aig5OVkrVqzQd999px49eqh58+b5tq9Tp47+/e9/65VXXlH79u310EMPydnZWdu3b1dAQIDi4uJUtWpVjR07VhMnTlSXLl3UrVs3HTx4UO+8845atWqlRx991BqnxcLRo0fVrVs3denSRQkJCVqyZIkeeeQRNWvWTJLUuXNnOTk56YEHHtATTzyhS5cu6b333pOPj89tjbxp2LChOnXqpNDQUHl7e2vHjh3673//q5iYGHOdN954Q127dlV4eLiGDBlifpWvp6enYmNjb/fQAQAosIkTJ2r16tVq3769hg8frmvXrmnWrFlq1KiR9uzZc9O2BbnmzZw5U+3atVOLFi00bNgwBQcH69ixY/r666+VmJh40/5r166tV199VWPHjtWxY8fUo0cPVaxYUUePHtXnn3+uYcOG6bnnnpMkhYaGavny5Ro9erRatWold3d3PfDAA7n6/Prrr/XBBx+oZ8+e2rNnj8Uxuru7q0ePHvLw8NDcuXP12GOPqUWLFurbt6+qVq2qEydO6Ouvv1bbtm01e/ZsSVJcXJyioqLUrl07DR48WOfPnzefv5z5Qm4lJSVFS5YskXT9vuzw4cP67LPPdOTIEfXt21evvPJKgfrJy6pVq/TLL7/kKm/Tpo3FaF4ANmSjt+QAd4RVq1YZgwcPNurXr2+4u7sbTk5ORp06dYynn37aOHPmjEXdwMDAm75mLzMz03jvvfeMHj16GIGBgYazs7NRoUIFo3nz5sYbb7xhpKenFyimBQsWGM2bNzecnZ2NSpUqGR07djTWrVtnUWf27NlG/fr1jfLlyxu+vr7GU089ZVy4cMGiTn6vtMvvOCQZI0aMMK/nvA7wwIEDxsMPP2xUrFjRqFSpkhETE2NcuXLFou2XX35pNG3a1HBxcTGCgoKM119/3ViwYIEhyTh69Ogt952z7e+vNXz11VeN1q1bG15eXoarq6tRv359Y/Lkybles/ztt98abdu2NVxdXQ0PDw/jgQceMA4cOGBRJ+dYzp07Z1Ge83q+v8cIAEBRbdq0yQgNDTWcnJyMWrVqGfPmzTNfg/6uqNe8ffv2GQ8++KDh5eVluLi4GPXq1TPGjRtn3p7f9S7H//73P6Ndu3aGm5ub4ebmZtSvX98YMWKEcfDgQXOdS5cuGY888ojh5eVl8RrdG1/le7NX3N746t0NGzYYkZGRhqenp+Hi4mLUrl3bGDhwoLFjx45c8TVo0MBwdnY2GjZsaHz22WdGdHR0gV/l+/cY3N3djbp16xqPPvqosXbt2jzb3Ore7lbH+ffzAcD2TIbBTIIArC82NlYTJ07UuXPnVKVKFVuHAwAAAAD5Ys4RAAAAAABg10iOAAAAAAAAu0ZyBAAAAAAA2DXmHAEAAAAAAHaNkSMAAAAAAMCukRwBAAAAAAB2rZytAygu2dnZ+uOPP1SxYkWZTCZbhwMAQJEYhqGLFy8qICBADg78TaMkcS8BALgTcC9RMHdscuSPP/5QjRo1bB0GAABWcfLkSVWvXt3WYdgV7iUAAHcS7iVu7o5NjlSsWFHS9Q+Ah4eHjaMBAKBoUlNTVaNGDfN1DSWHewkAwJ2Ae4mCuWOTIznDXz08PLihAQCUeTzWUfK4lwAA3Em4l7g5HjgCAAAAAAB2jeQIAAAAAACwa3fsYzUAAOvJyspSZmamrcO4ozk6OqpcuXIMeQUAALABkiMAgJu6dOmSfv/9dxmGYetQ7ngVKlSQv7+/nJycbB0KAACAXSE5AgDIV1ZWln7//XdVqFBBVatWZVRDMTEMQxkZGTp37pyOHj2qunXrysGBJ18BAABKCskRAEC+MjMzZRiGqlatKldXV1uHc0dzdXVV+fLldfz4cWVkZMjFxcXWIQEAANgN/iwFALglRoyUDEaLAAAA2AZ3YQAAuzdjxgwlJSUVub3JZFJycrL1AgIAAECJ4rEaAEChBL34dbH0e+y1qGLptyBmzJihTp06yc/PL9e27OxsSYzqAAAAuJNxpwcAKFNMJpOmTJmi1q1bKzg4WAsXLjRvO3TokKKiotSqVSs1bdpUs2fPtmj399EdVapU0bFjxzRp0iT98ccf6tOnj0JCQpSYmKjY2Fj17NlTkZGRaty4sU6fPq3nnntOrVq1UkhIiDp06KCDBw+W5GEDAACgGJEcAQCUOc7Oztq2bZtWrVqlkSNH6tq1a8rKylK/fv305ptvavv27frxxx81f/58bd++/aZ9jR8/XgEBAVq+fLkSExMVEhIiSUpISNAHH3ygAwcOqFq1anrhhRe0fft2JSYmavjw4XrmmWdK4EgBAABQEnisBgBQ5vTv31+SVL9+fZUrV05JSUlKTU3V/v371bdvX3O9ixcv6sCBA2rVqlWh93H//ffL19fXvL5u3TrNmjVLFy9eVHZ2ts6fP3/7BwIAAIBSgeQIAKDM+ftrbh0dHXXt2jUZhiFvb28lJibm2cbR0VFZWVnm9atXr950H+7u7uavT5w4oZiYGG3fvl21a9fWnj171KFDh9s7CAAAAJQaPFYDALgj1KtXTx4eHhZzkBw+fNg8wqNOnTraunWrJOmzzz5TWlqauZ6Hh4dSUlLy7TslJUXly5eXv7+/DMOwmMsEJWfOnDkKCgqSi4uLwsLCtG3btpvWT05O1ogRI+Tv7y9nZ2f94x//0DfffFNC0QIAgLKE5AgA4I5Qrlw5rVy5Up999pmaNm2qRo0aaciQIbpy5Yokafr06XrmmWfUokUL/fTTT6pcubK57ciRIzV06FDzhKw3atKkifr27atGjRqpVatWqlmzZkkdFv6/5cuXa/To0ZowYYJ27dqlZs2aKTIyUmfPns2zfkZGhu677z4dO3ZM//3vf3Xw4EG99957qlatWglHDgAAygKTYRiGrYMoDqmpqfL09FRKSoo8PDxsHQ4AlElXr17V0aNHFRwcbPEoC4pHXueb69l1YWFhatWqlXnUTnZ2tmrUqKGnn35aL774Yq768+bN0xtvvKFffvlF5cuXL9I+S+Lcnz59WqdPn77tfvz9/eXv72+FiAAAdxruJQqGOUfyE+tZpGZNgov+18S90XuL3BYAgDtVRkaGdu7cqbFjx5rLHBwcFBERoYSEhDzbfPnllwoPD9eIESP0xRdfqGrVqnrkkUf0wgsvyNHRMc826enpSk9PN6+npqZa90Dy8O6772rixIm33c+ECRMUGxt7+wEBAGCnSI4AAIBS7c8//1RWVpbF24MkydfXV7/88kuebX777TetX79e/fv31zfffKPDhw9r+PDhyszM1IQJE/JsExcXZ5VERWE88cQT6tatW57brly5onbt2kmStmzZIldX13z7YdQIAAC3h+QIAAC442RnZ8vHx0fz58+Xo6OjQkNDderUKb3xxhv5JkfGjh2r0aNHm9dTU1NVo0aNYo3zZo/D/H3S4JCQELm5uRVrLAAA2DOSIwAAoFSrUqWKHB0ddebMGYvyM2fOyM/PL882/v7+Kl++vMUjNA0aNFBSUpIyMjLk5OSUq42zs7OcnZ1zlTeesEYOzhVu8yjydu3SeWVdOp/nNiMzw/x17WHvyFQ+d8w5HN29Vc7d2+rx5Tj2WlSx9Q0AQGlAcgQAAJRqTk5OCg0NVXx8vHr06CHp+siQ+Ph4xcTE5Nmmbdu2WrZsmbKzs+XgcP3lfL/++qv8/f3zTIzYyqXEVUr5/qNb1juz7Pmbbvds209e7fpbKywAAOwOyREAAFDqjR49WtHR0WrZsqVat26tGTNmKC0tTYMGDZIkDRgwQNWqVVNcXJwk6amnntLs2bP1zDPP6Omnn9ahQ4c0ZcoUjRw50paHkYt7SFe51gm77X4ci3HUCAAA9oDkCAAAKPX69Omjc+fOafz48UpKSlJISIhWr15tnqT1xIkT5hEiklSjRg2tWbNGzz77rJo2bapq1arpmWee0QsvvGCrQ8hTuWJ+HAYAABQMyREAQOEU8VXnt+43pVi6XbRokVasWKEVK1YUqf2xY8e0evVqPfnkk0VqX6VKFe3YsUNBQUFFao//ExMTk+9jNBs3bsxVFh4erh9//LGYowIAAHcCh1tXAQDAfh07dkzz5s2zdRgAAAAoRiRHAABlypUrV9SnTx81bNhQzZo1U+fOnSVJH374ocLCwtSiRQt16NBBu3fvzrP9zeq9/vrratKkiZo1a6a77rpLly9f1pNPPqmDBw8qJCRE3bp1kyQdOnRIUVFRatWqlZo2barZs2eb+/jyyy/VoEEDNW3aVM8/f/NJNAEAAFA68FgNAKBMWb16tZKTk3XgwAFJ0vnz5/X999/ro48+0ubNm+Xs7KzvvvtOjzzyiPbv32/R9mb1Fi9erP/973/asmWLPD09deHCBTk7O2vevHkaNWqUEhMTJUlZWVnq16+flixZovr16+vy5cu66667FBYWpsDAQA0aNEjfffedGjZsqPnz5+uvv/4q6VMEAACAQiI5AgAoU5o1a6aff/5Zw4cPV8eOHXX//ffriy++0O7duxUW9n9v/Th//ryuXLli0fZm9VauXKknn3xSnp7X51SpVKlSnvs/ePCg9u/fr759+5rLLl68qAMHDuj06dNq2rSpGjZsKEkaMmSInn76aasdOwAAAIoHyREAQJlSq1YtHThwQOvXr9e3336r559/Xp07d1Z0dLSmTJly07aGYRSo3q368Pb2No8k+bsvv/zSYt1kMhV5PwAAACg5zDkCAChTfv/9d5lMJnXr1k3Tpk2TYRh69NFHtWTJEp04cUKSlJ2drR07duRq261bt3zrdevWTfPmzVNKyvW35iQnJysrK0seHh7mMkmqV6+ePDw8tHDhQnPZ4cOHdf78eYWHh2vPnj365ZdfJEkLFixQRkZG8ZwIAAAAWA0jRwAAZcrevXs1duxYGYaha9eu6bHHHlPHjh01depUPfjgg7p27ZoyMjIUFRWlli1bWrRt3759vvUee+wx/fHHH2rTpo3KlSsnNzc3ffvtt2ratKkaNWqkxo0bq1atWvryyy+1cuVKjRo1StOnT1dWVpaqVKmiZcuWqVq1alqwYIEefPBBOTk5qUuXLqpcubKNzhQAAAAKymQYhmHrIIpDamqqPD09lZKSIg8Pj8J3EOtZpP02Ca5ZpHaStDd6b5HbAkBxuHr1qo4eParg4GC5uLjYOpw7Xl7n+7avZyiynHNfY9QncnCuYOtwbOrYa1G2DgEAUETcSxQMj9UAAAAAAAC7RnIEAAAAAADYNZIjAAAAAADArpEcAQAAAAAAdo3kCAAAAAAAsGskRwAAAAAAgF0jOQIAsHsrV65Up06dbllv0aJF6tGjhyRp48aNCgkJKfS+9u3bp6CgoEK3AwAAQPEpZ+sAAABlS5PFTYql373Re4ulXwAAAOBWGDkCAChTTCaTJk+erLCwMAUFBWnFihWKi4tTy5YtVbduXW3cuNFc98MPP1TTpk3VtGlTRUVF6dSpU5KkzMxMDR8+XHXr1lXr1q21YcMGi318+OGHCgsLU4sWLdShQwft3r37lnGtWbNG7dq1U2hoaK4+Y2NjVbduXYWGhurjjz+2zokAAACA1TByBABQ5ri7u2vr1q2Kj49X9+7dNXv2bO3YsUOffvqpxowZo+3bt2vfvn0aM2aMdu7cqWrVqmny5Ml6/PHHtWrVKs2fP18HDx7U/v37JUmRkZHmvr///nt99NFH2rx5s5ydnfXdd9/pkUceMdfNy2+//abY2FitWbNGHh4eOnz4sNq3b69jx47p22+/1aeffqqdO3eqYsWKeuyxx4r9/AAAAKBwSI4AAMqcPn36SJJatmyptLQ09e3bV5LUunVrHTp0SJK0YcMGdenSRdWqVZMkDR8+XJMmTVJWVpbi4+M1YMAAOTk5SZIGDx6s999/X5L0xRdfaPfu3QoLCzPv7/z587py5Uq+8axevVqHDx9Whw4dzGUODg46ceKE4uPj1bt3b3l4eEiSnnjiCW3ZssVapwIAAABWQHIEAFDmuLi4SJIcHR1zrV+7di3PNiaTKd/+/r7NMAxFR0drypQpBY7HMAzdd999WrZs2S3r3iwOAAAA2AZzjgAA7kh33323Vq9erT/++EOSNG/ePN17771ydHRURESElixZoszMTGVkZGjhwoXmdt26ddOSJUt04sQJSVJ2drZ27Nhx031FRkbq22+/1Z49e8xl27ZtkyRFRETo008/1cWLF2UYhubPn2/tQwUAAMBtYuQIAOCO1LhxY73xxhvq0qWLJKlGjRp67733JElDhw7Vvn371LBhQ1WqVEnt27fXzp07JUnt27fX1KlT9eCDD+ratWvKyMhQVFSUWrZsme++6tSpo2XLlumJJ57Q5cuXlZGRoebNm2vZsmW6//77tW3bNrVo0UIeHh7q2rVr8R88AAAACsVkGIZh6yCKQ2pqqjw9PZWSkmJ+zrtQYj2LtN8mwTWL1E7iNZYASp+rV6/q6NGjCg4ONj+6guKT1/m+7esZiizn3NcY9YkcnCvYOhybOvZalK1DAAAUEfcSBcNjNQAAAAAAwK4VOjmyefNmPfDAAwoICJDJZNKKFSvM2zIzM/XCCy+oSZMmcnNzU0BAgAYMGGB+3jvH+fPn1b9/f3l4eMjLy0tDhgzRpUuXLOrs2bNH7du3l4uLi2rUqKGpU6cW7QgBAAAAAABuotDJkbS0NDVr1kxz5szJte3y5cvatWuXxo0bp127dumzzz7TwYMH1a1bN4t6/fv31/79+7Vu3TqtXLlSmzdv1rBhw8zbU1NT1blzZwUGBmrnzp164403FBsbyyR2AAAAAADA6go9IWvXrl3znUzO09NT69atsyibPXu2WrdurRMnTqhmzZr6+eeftXr1am3fvt08ud2sWbN0//33a9q0aQoICNDSpUuVkZGhBQsWyMnJSY0aNVJiYqLeeustiyQKAAAAAADA7Sr2OUdSUlJkMpnk5eUlSUpISJCXl5fFrP8RERFycHDQ1q1bzXU6dOggJycnc53IyEgdPHhQFy5cKO6QAQA3uEPn7i51srOzbR0CAACAXSrWV/levXpVL7zwgvr162eeFTcpKUk+Pj6WQZQrJ29vbyUlJZnrBAcHW9Tx9fU1b6tUqVKufaWnpys9Pd28npqaatVjAQB7VL58eZlMJp07d05Vq1aVyWSydUh3JMMwlJGRoXPnzsnBwcHijwMAAAAofsWWHMnMzFTv3r1lGIbmzp1bXLsxi4uL08SJE4t9PwBgTxwdHVW9enX9/vvvOnbsmK3DueNVqFBBNWvWlIMDL5MDAAAoScWSHMlJjBw/flzr16+3eJeyn5+fzp49a1H/2rVrOn/+vPz8/Mx1zpw5Y1EnZz2nzo3Gjh2r0aNHm9dTU1NVo0YNqxwPANgzd3d31a1bV5mZmbYO5Y7m6OiocuXKMToHAADABqyeHMlJjBw6dEgbNmxQ5cqVLbaHh4crOTlZO3fuVGhoqCRp/fr1ys7OVlhYmLnOv//9b2VmZqp8+fKSpHXr1qlevXp5PlIjSc7OznJ2drb24QAAdP0Xd0dHR1uHAQAAABSLQo/bvXTpkhITE5WYmChJOnr0qBITE3XixAllZmbq4Ycf1o4dO7R06VJlZWUpKSlJSUlJysjIkCQ1aNBAXbp00dChQ7Vt2zZ9//33iomJUd++fRUQECBJeuSRR+Tk5KQhQ4Zo//79Wr58ud5++22LkSEAAAAAAADWUOiRIzt27NDdd99tXs9JWERHRys2NlZffvmlJCkkJMSi3YYNG9SpUydJ0tKlSxUTE6N7771XDg4O6tmzp2bOnGmu6+npqbVr12rEiBEKDQ1VlSpVNH78eF7jCwAAAAAArK7QyZFOnTrd9JWOBXndo7e3t5YtW3bTOk2bNtV3331X2PAAAAAAAAAKhenwAQAAAACAXSM5AgAAAAAA7BrJEQAAAAAAYNdIjgAAAAAAALtGcgQAAAAAANg1kiMAAAAAAMCukRwBAAAAAAB2jeQIAAAAAACwayRHAAAAAACAXSM5AgAAAAAA7BrJEQAAAAAAYNdIjgAAAAAAALtGcgQAAAAAANg1kiMAAAAAAMCukRwBAAAAAAB2jeQIAAAAAACwayRHAABAmTBnzhwFBQXJxcVFYWFh2rZtW751Fy1aJJPJZLG4uLiUYLQAAKAsITkCAABKveXLl2v06NGaMGGCdu3apWbNmikyMlJnz57Nt42Hh4dOnz5tXo4fP16CEQMAgLKE5AgAACj13nrrLQ0dOlSDBg1Sw4YNNW/ePFWoUEELFizIt43JZJKfn5958fX1LcGIAQBAWUJyBAAAlGoZGRnauXOnIiIizGUODg6KiIhQQkJCvu0uXbqkwMBA1ahRQ927d9f+/ftLIlwAAFAGkRwBAACl2p9//qmsrKxcIz98fX2VlJSUZ5t69eppwYIF+uKLL7RkyRJlZ2erTZs2+v333/PdT3p6ulJTUy0WAABgH0iOAACAO054eLgGDBigkJAQdezYUZ999pmqVq2qd999N982cXFx8vT0NC81atQowYgBAIAtkRwBAAClWpUqVeTo6KgzZ85YlJ85c0Z+fn4F6qN8+fJq3ry5Dh8+nG+dsWPHKiUlxbycPHnytuIGAABlB8kRAABQqjk5OSk0NFTx8fHmsuzsbMXHxys8PLxAfWRlZWnv3r3y9/fPt46zs7M8PDwsFgAAYB/K2ToAAACAWxk9erSio6PVsmVLtW7dWjNmzFBaWpoGDRokSRowYICqVaumuLg4SdKkSZN01113qU6dOkpOTtYbb7yh48eP6/HHH7flYQAAgFKK5AgAACj1+vTpo3Pnzmn8+PFKSkpSSEiIVq9ebZ6k9cSJE3Jw+L8BsRcuXNDQoUOVlJSkSpUqKTQ0VD/88IMaNmxoq0MAAAClGMkRAABQJsTExCgmJibPbRs3brRYnz59uqZPn14CUQEAgDsBc44AAAAAAAC7RnIEAAAAAADYNZIjAAAAAADArpEcAQAAAAAAdo3kCAAAAAAAsGskRwAAAAAAgF0jOQIAAAAAAOwayREAAAAAAGDXSI4AAAAAAAC7RnIEAAAAAADYNZIjAAAAAADArpEcAQAAAAAAdo3kCAAAAAAAsGskRwAAAAAAgF0jOQIAAAAAAOwayREAAAAAAGDXSI4AAAAAAAC7RnIEAAAAAADYNZIjAAAAAADArhU6ObJ582Y98MADCggIkMlk0ooVKyy2G4ah8ePHy9/fX66uroqIiNChQ4cs6pw/f179+/eXh4eHvLy8NGTIEF26dMmizp49e9S+fXu5uLioRo0amjp1auGPDgAAAAAA4BYKnRxJS0tTs2bNNGfOnDy3T506VTNnztS8efO0detWubm5KTIyUlevXjXX6d+/v/bv369169Zp5cqV2rx5s4YNG2benpqaqs6dOyswMFA7d+7UG2+8odjYWM2fP78IhwgAAAAAAJC/coVt0LVrV3Xt2jXPbYZhaMaMGXr55ZfVvXt3SdIHH3wgX19frVixQn379tXPP/+s1atXa/v27WrZsqUkadasWbr//vs1bdo0BQQEaOnSpcrIyNCCBQvk5OSkRo0aKTExUW+99ZZFEgUAAAAAAOB2WXXOkaNHjyopKUkRERHmMk9PT4WFhSkhIUGSlJCQIC8vL3NiRJIiIiLk4OCgrVu3mut06NBBTk5O5jqRkZE6ePCgLly4kOe+09PTlZqaarEAAAAAAADcilWTI0lJSZIkX19fi3JfX1/ztqSkJPn4+FhsL1eunLy9vS3q5NXH3/dxo7i4OHl6epqXGjVq3P4BAQAAAACAO16hH6sprcaOHavRo0eb11NTU1WjRg01nrBGDs4VCt3fMRdrRgcAAAAAAEorq44c8fPzkySdOXPGovzMmTPmbX5+fjp79qzF9mvXrun8+fMWdfLq4+/7uJGzs7M8PDwsFgAAAAAAgFuxanIkODhYfn5+io+PN5elpqZq69atCg8PlySFh4crOTlZO3fuNNdZv369srOzFRYWZq6zefNmZWZmmuusW7dO9erVU6VKlawZMgAAAAAAsHOFTo5cunRJiYmJSkxMlHR9EtbExESdOHFCJpNJo0aN0quvvqovv/xSe/fu1YABAxQQEKAePXpIkho0aKAuXbpo6NCh2rZtm77//nvFxMSob9++CggIkCQ98sgjcnJy0pAhQ7R//34tX75cb7/9tsVjMwAAAAAAANZQ6DlHduzYobvvvtu8npOwiI6O1qJFi/T8888rLS1Nw4YNU3Jystq1a6fVq1fLxeX/JvFYunSpYmJidO+998rBwUE9e/bUzJkzzds9PT21du1ajRgxQqGhoapSpYrGjx/Pa3wBAAAAAIDVFTo50qlTJxmGke92k8mkSZMmadKkSfnW8fb21rJly266n6ZNm+q7774rbHgAAAAAAACFYtU5RwAAAAAAAMoakiMAAAAAAMCukRwBAAAAAAB2jeQIAAAAAACwayRHAAAAAACAXSM5AgAAAAAA7BrJEQAAAAAAYNdIjgAAAAAAALtGcgQAAAAAANg1kiMAAAAAAMCukRwBAAAAAAB2jeQIAAAAAACwayRHAAAAAACAXSM5AgAAAAAA7BrJEQAAAAAAYNdIjgAAAAAAALtGcgQAAAAAANg1kiMAAAAAAMCukRwBAAAAAAB2jeQIAAAAAACwayRHAAAAAACAXSM5AgAAAAAA7BrJEQAAUCbMmTNHQUFBcnFxUVhYmLZt21agdh9//LFMJpN69OhRvAECAIAyi+QIAAAo9ZYvX67Ro0drwoQJ2rVrl5o1a6bIyEidPXv2pu2OHTum5557Tu3bty+hSAEAQFlEcgQAAJR6b731loYOHapBgwapYcOGmjdvnipUqKAFCxbk2yYrK0v9+/fXxIkTVatWrRKMFgAAlDUkRwAAQKmWkZGhnTt3KiIiwlzm4OCgiIgIJSQk5Ntu0qRJ8vHx0ZAhQwq0n/T0dKWmplosAADAPpAcAQAApdqff/6prKws+fr6WpT7+voqKSkpzzZbtmzR+++/r/fee6/A+4mLi5Onp6d5qVGjxm3FDQAAyg6SIwAA4I5y8eJFPfbYY3rvvfdUpUqVArcbO3asUlJSzMvJkyeLMUoAAFCalLN1AAAAADdTpUoVOTo66syZMxblZ86ckZ+fX676R44c0bFjx/TAAw+Yy7KzsyVJ5cqV08GDB1W7du1c7ZydneXs7Gzl6AEAQFnAyBEAAFCqOTk5KTQ0VPHx8eay7OxsxcfHKzw8PFf9+vXra+/evUpMTDQv3bp10913363ExEQelwEAALkwcgQAAJR6o0ePVnR0tFq2bKnWrVtrxowZSktL06BBgyRJAwYMULVq1RQXFycXFxc1btzYor2Xl5ck5SoHAACQSI4AAIAyoE+fPjp37pzGjx+vpKQkhYSEaPXq1eZJWk+cOCEHBwbEAgCAoiE5AgAAyoSYmBjFxMTkuW3jxo03bbto0SLrBwQAAO4Y/IkFAAAAAADYNZIjAAAAAADArpEcAQAAAAAAdo3kCAAAAAAAsGskRwAAAAAAgF0jOQIAAAAAAOwayREAAAAAAGDXSI4AAAAAAAC7RnIEAAAAAADYNZIjAAAAAADArpEcAQAAAAAAdo3kCAAAAAAAsGskRwAAAAAAgF2zenIkKytL48aNU3BwsFxdXVW7dm298sorMgzDXMcwDI0fP17+/v5ydXVVRESEDh06ZNHP+fPn1b9/f3l4eMjLy0tDhgzRpUuXrB0uAAAAAACwc1ZPjrz++uuaO3euZs+erZ9//lmvv/66pk6dqlmzZpnrTJ06VTNnztS8efO0detWubm5KTIyUlevXjXX6d+/v/bv369169Zp5cqV2rx5s4YNG2btcAEAAAAAgJ0rZ+0Of/jhB3Xv3l1RUVGSpKCgIH300Ufatm2bpOujRmbMmKGXX35Z3bt3lyR98MEH8vX11YoVK9S3b1/9/PPPWr16tbZv366WLVtKkmbNmqX7779f06ZNU0BAgLXDBgAAAAAAdsrqI0fatGmj+Ph4/frrr5Kk3bt3a8uWLeratask6ejRo0pKSlJERIS5jaenp8LCwpSQkCBJSkhIkJeXlzkxIkkRERFycHDQ1q1b89xvenq6UlNTLRYAAAAAAIBbsfrIkRdffFGpqamqX7++HB0dlZWVpcmTJ6t///6SpKSkJEmSr6+vRTtfX1/ztqSkJPn4+FgGWq6cvL29zXVuFBcXp4kTJ1r7cAAAAAAAwB3O6iNHPvnkEy1dulTLli3Trl27tHjxYk2bNk2LFy+29q4sjB07VikpKebl5MmTxbo/AAAAAABwZ7D6yJExY8boxRdfVN++fSVJTZo00fHjxxUXF6fo6Gj5+flJks6cOSN/f39zuzNnzigkJESS5Ofnp7Nnz1r0e+3aNZ0/f97c/kbOzs5ydna29uEAAAAAAIA7nNVHjly+fFkODpbdOjo6Kjs7W5IUHBwsPz8/xcfHm7enpqZq69atCg8PlySFh4crOTlZO3fuNNdZv369srOzFRYWZu2QAQAAAACAHbP6yJEHHnhAkydPVs2aNdWoUSP99NNPeuuttzR48GBJkslk0qhRo/Tqq6+qbt26Cg4O1rhx4xQQEKAePXpIkho0aKAuXbpo6NChmjdvnjIzMxUTE6O+ffvyphoAAAAAAGBVVk+OzJo1S+PGjdPw4cN19uxZBQQE6IknntD48ePNdZ5//nmlpaVp2LBhSk5OVrt27bR69Wq5uLiY6yxdulQxMTG699575eDgoJ49e2rmzJnWDhcAABSjQ4cOacOGDTp79qx5FGmOv98bAAAA2JLJMAzD1kEUh9TUVHl6eqrGqE/k4Fyh0O2PuTxSpP02Ca5ZpHaStDd6b5HbAgDuTDnXs5SUFHl4eNg6nEJ577339NRTT6lKlSry8/OTyWQybzOZTNq1a5cNo7u1272XuJMcey3K1iEAAIqoLN9LlCSrjxwBAACQpFdffVWTJ0/WCy+8YOtQAAAAbsrqE7ICAABI0oULF9SrVy9bhwEAAHBLJEcAAECx6NWrl9auXWvrMAAAAG6Jx2oAAECxqFOnjsaNG6cff/xRTZo0Ufny5S22jxw50kaRAQAAWCI5AgAAisX8+fPl7u6uTZs2adOmTRbbTCYTyREAAFBqkBwBAADF4ujRo7YOAQAAoECYcwQAABQ7wzBkGIatwwAAAMgTyREAAFBsPvjgAzVp0kSurq5ydXVV06ZN9eGHH9o6LAAAAAs8VgMAAIrFW2+9pXHjxikmJkZt27aVJG3ZskVPPvmk/vzzTz377LM2jhAAAOA6kiMAAKBYzJo1S3PnztWAAQPMZd26dVOjRo0UGxtLcgQAAJQaPFYDAACKxenTp9WmTZtc5W3atNHp06dtEBEAAEDeSI4AAIBiUadOHX3yySe5ypcvX666devaICIAAIC88VgNAAAoFhMnTlSfPn20efNm85wj33//veLj4/NMmgAAANgKI0cAAECx6Nmzp7Zu3aoqVapoxYoVWrFihapUqaJt27bpwQcftHV4AAAAZowcAQAAxSY0NFRLliyxdRgAAAA3RXIEAABYTWpqqjw8PMxf30xOPQAAAFsjOQIAAKymUqVKOn36tHx8fOTl5SWTyZSrjmEYMplMysrKskGEAAAAuZEcAQAAVrN+/Xp5e3tLkjZs2GDjaAAAAAqG5AgAALCajh07mr8ODg5WjRo1co0eMQxDJ0+eLOnQAAAA8sXbagAAQLEIDg7WuXPncpWfP39ewcHBNogIAAAgbyRHAABAsciZW+RGly5dkouLiw0iAgAAyBuP1QAAAKsaPXq0JMlkMmncuHGqUKGCeVtWVpa2bt2qkJAQG0UHAACQG8kRAABgVT/99JOk6yNH9u7dKycnJ/M2JycnNWvWTM8995ytwgMAAMiF5AgAALCqnLfUDBo0SG+//bY8PDxsHBEAAMDNMecIAAAoFjNmzNC1a9dylZ8/f16pqak2iAgAACBvJEcAAECx6Nu3rz7++ONc5Z988on69u1rg4gAAADyRnIEAAAUi61bt+ruu+/OVd6pUydt3brVBhEBAADkjeQIAAAoFunp6Xk+VpOZmakrV64Uur85c+YoKChILi4uCgsL07Zt2/Kt+9lnn6lly5by8vKSm5ubQkJC9OGHHxZ6nwAAwD6QHAEAAMWidevWmj9/fq7yefPmKTQ0tFB9LV++XKNHj9aECRO0a9cuNWvWTJGRkTp79mye9b29vfXvf/9bCQkJ2rNnjwYNGqRBgwZpzZo1RToWAABwZ+NtNQAAoFi8+uqrioiI0O7du3XvvfdKkuLj47V9+3atXbu2UH299dZbGjp0qAYNGiTpeoLl66+/1oIFC/Tiiy/mqt+pUyeL9WeeeUaLFy/Wli1bFBkZWbQDAgAAdyxGjgAAgGLRtm1bJSQkqEaNGvrkk0/01VdfqU6dOtqzZ4/at29f4H4yMjK0c+dORUREmMscHBwUERGhhISEW7Y3DEPx8fE6ePCgOnToUKRjAQAAdzZGjgAAgGITEhKipUuX3lYff/75p7KysuTr62tR7uvrq19++SXfdikpKapWrZrS09Pl6Oiod955R/fdd1++9dPT05Wenm5e53XDAADYD5IjAACg2F29elUZGRkWZR4eHsW6z4oVKyoxMVGXLl1SfHy8Ro8erVq1auV65CZHXFycJk6cWKwxAQCA0onHagAAQLG4fPmyYmJi5OPjIzc3N1WqVMliKagqVarI0dFRZ86csSg/c+aM/Pz88m3n4OCgOnXqKCQkRP/617/08MMPKy4uLt/6Y8eOVUpKink5efJkgWMEAABlG8kRAABQLMaMGaP169dr7ty5cnZ21n/+8x9NnDhRAQEB+uCDDwrcj5OTk0JDQxUfH28uy87OVnx8vMLDwwvcT3Z2tsVjMzdydnaWh4eHxQIAAOwDj9UAAIBi8dVXX+mDDz5Qp06dNGjQILVv31516tRRYGCgli5dqv79+xe4r9GjRys6OlotW7ZU69atNWPGDKWlpZnfXjNgwABVq1bNPDIkLi5OLVu2VO3atZWenq5vvvlGH374oebOnVssxwoAAMo2kiMAAKBYnD9/XrVq1ZJ0fX6R8+fPS5LatWunp556qlB99enTR+fOndP48eOVlJSkkJAQrV692jxJ64kTJ+Tg8H8DYtPS0jR8+HD9/vvvcnV1Vf369bVkyRL16dPHSkcHAADuJCRHAABAsahVq5aOHj2qmjVrqn79+vrkk0/UunVrffXVV/Ly8ip0fzExMYqJiclz28aNGy3WX331Vb366qtFiBoAANgj5hwBAADFYtCgQdq9e7ck6cUXX9ScOXPk4uKiZ599VmPGjLFxdAAAAP+HkSMAAKBYPPvss+avIyIi9Msvv2jnzp2qU6eOmjZtasPIAAAALDFyBAAAWF1mZqbuvfdeHTp0yFwWGBiohx56iMQIAAAodUiOAAAAqytfvrz27Nlj6zAAAAAKhOQIAAAoFo8++qjef/99W4cBAABwS8w5AgAAisW1a9e0YMECffvttwoNDZWbm5vF9rfeestGkQEAAFgiOQIAAKxmz549aty4sRwcHLRv3z61aNFCkvTrr79a1DOZTLYIDwAAIE/F8ljNqVOn9Oijj6py5cpydXVVkyZNtGPHDvN2wzA0fvx4+fv7y9XVVRERERYTtknS+fPn1b9/f3l4eMjLy0tDhgzRpUuXiiNcAABgJc2bN9eff/4pSTp+/Lj++9//asOGDbmW9evX2zhSAACA/2P15MiFCxfUtm1blS9fXqtWrdKBAwf05ptvqlKlSuY6U6dO1cyZMzVv3jxt3bpVbm5uioyM1NWrV811+vfvr/3792vdunVauXKlNm/erGHDhlk7XAAAYEVeXl46evSoJOnYsWPKzs62cUQAAAC3ZvXHal5//XXVqFFDCxcuNJcFBwebvzYMQzNmzNDLL7+s7t27S5I++OAD+fr6asWKFerbt69+/vlnrV69Wtu3b1fLli0lSbNmzdL999+vadOmKSAgwNphAwAAK+jZs6c6duwof39/mUwmtWzZUo6OjnnW/e2330o4OgAAgLxZPTny5ZdfKjIyUr169dKmTZtUrVo1DR8+XEOHDpUkHT16VElJSYqIiDC38fT0VFhYmBISEtS3b18lJCTIy8vLnBiRpIiICDk4OGjr1q168MEHrR02AACwgvnz5+uhhx7S4cOHNXLkSA0dOlQVK1a0dVgAAAA3ZfXkyG+//aa5c+dq9OjReumll7R9+3aNHDlSTk5Oio6OVlJSkiTJ19fXop2vr695W1JSknx8fCwDLVdO3t7e5jo3Sk9PV3p6unk9NTXVmocFAAAKqEuXLpKknTt36plnniE5AgAASj2rJ0eys7PVsmVLTZkyRdL1idn27dunefPmKTo62tq7M4uLi9PEiROLrX8AAFA4f3/EFgAAoDSz+oSs/v7+atiwoUVZgwYNdOLECUmSn5+fJOnMmTMWdc6cOWPe5ufnp7Nnz1psv3btms6fP2+uc6OxY8cqJSXFvJw8edIqxwMAAAAAAO5sVk+OtG3bVgcPHrQo+/XXXxUYGCjp+uSsfn5+io+PN29PTU3V1q1bFR4eLkkKDw9XcnKydu7caa6zfv16ZWdnKywsLM/9Ojs7y8PDw2IBAAAAAAC4Fas/VvPss8+qTZs2mjJlinr37q1t27Zp/vz5mj9/viTJZDJp1KhRevXVV1W3bl0FBwdr3LhxCggIUI8ePSRdH2nSpUsXDR06VPPmzVNmZqZiYmLUt29f3lQDAAAAAACsyurJkVatWunzzz/X2LFjNWnSJAUHB2vGjBnq37+/uc7zzz+vtLQ0DRs2TMnJyWrXrp1Wr14tFxcXc52lS5cqJiZG9957rxwcHNSzZ0/NnDnT2uECAAAAAAA7Z/XkiCT985//1D//+c98t5tMJk2aNEmTJk3Kt463t7eWLVtWHOEBAAAAAACYWX3OEQAAAAAAgLKE5AgAAAAAALBrJEcAAAAAAIBdIzkCAAAAAADsGskRAAAAAABg10iOAAAAAAAAu0ZyBAAAAAAA2DWSIwAAAAAAwK6RHAEAAAAAAHaN5AgAAAAAALBrJEcAAAAAAIBdIzkCAAAAAADsGskRAAAAAABg10iOAAAAAAAAu0ZyBAAAAAAA2DWSIwAAAAAAwK6RHAEAAAAAAHaN5AgAAAAAALBrJEcAAAAAAIBdIzkCAAAAAADsWjlbB4DSp8niJkVuuzd6rxUjAQAAAACg+DFyBAAAAAAA2DVGjtzJYj2L1i64pnXjAAAAAACgFGPkCAAAAAAAsGskRwAAAAAAgF0jOQIAAAAAAOwayREAAAAAAGDXSI4AAAAAAAC7RnIEAAAAAADYNZIjAAAAAADArpEcAQAAAAAAdo3kCAAAAAAAsGskRwAAAAAAgF0jOQIAAAAAAOwayREAAFAmzJkzR0FBQXJxcVFYWJi2bduWb9333ntP7du3V6VKlVSpUiVFRETctD4AALBvJEcAAECpt3z5co0ePVoTJkzQrl271KxZM0VGRurs2bN51t+4caP69eunDRs2KCEhQTVq1FDnzp116tSpEo4cAACUBeVsHQAAAMCtvPXWWxo6dKgGDRokSZo3b56+/vprLViwQC+++GKu+kuXLrVY/89//qP//e9/io+P14ABA0okZgCl0+nTp3X69Onb7sff31/+/v5WiAhAaUByBAAAlGoZGRnauXOnxo4day5zcHBQRESEEhISCtTH5cuXlZmZKW9v73zrpKenKz093byemppa9KABlFrvvvuuJk6ceNv9TJgwQbGxsbcfEIBSgeQIAAAo1f78809lZWXJ19fXotzX11e//PJLgfp44YUXFBAQoIiIiHzrxMXFWeUXJgCl2xNPPKFu3brlue3KlStq166dJGnLli1ydXXNtx9GjQB3FpIjpVzQi18Xue0xFysGAgBAGfXaa6/p448/1saNG+Xikv/FcezYsRo9erR5PTU1VTVq1CiJEAGUoJs9DpOWlmb+OiQkRG5ubiUVFgAbIzkCAABKtSpVqsjR0VFnzpyxKD9z5oz8/Pxu2nbatGl67bXX9O2336pp06Y3revs7CxnZ+fbjhcAAJQ9JEcAAECp5uTkpNDQUMXHx6tHjx6SpOzsbMXHxysmJibfdlOnTtXkyZO1Zs0atWzZsoSiBXC7bmfk9O3Kzrhq/rrBuNVycLLdUOxjr0XZbN+APSI5AgAASr3Ro0crOjpaLVu2VOvWrTVjxgylpaWZ314zYMAAVatWTXFxcZKk119/XePHj9eyZcsUFBSkpKQkSZK7u7vc3d1tdhwAAKB0IjkCAABKvT59+ujcuXMaP368kpKSFBISotWrV5snaT1x4oQcHBzM9efOnauMjAw9/PDDFv3wdgkAAJAXkiMAAKBMiImJyfcxmo0bN1qsHzt2rPgDAgAAdwyHW1cBAAAAAAC4cxV7cuS1116TyWTSqFGjzGVXr17ViBEjVLlyZbm7u6tnz565ZqA/ceKEoqKiVKFCBfn4+GjMmDG6du1acYcLAAAAAADsTLE+VrN9+3a9++67uV6d9+yzz+rrr7/Wp59+Kk9PT8XExOihhx7S999/L0nKyspSVFSU/Pz89MMPP+j06dMaMGCAypcvrylTphRnyAAAAADuYNcunVfWpfN5bjMyM8xfZ5z5TabyTvn24+jurXLu3laPD4BtFFty5NKlS+rfv7/ee+89vfrqq+bylJQUvf/++1q2bJnuueceSdLChQvVoEED/fjjj7rrrru0du1aHThwQN9++618fX0VEhKiV155RS+88IJiY2Pl5JT/DykAAAAAyM+lxFVK+f6jW9Y7s+z5m273bNtPXu36WyssADZWbMmRESNGKCoqShERERbJkZ07dyozM1MRERHmsvr166tmzZpKSEjQXXfdpYSEBDVp0sQ8A70kRUZG6qmnntL+/fvVvHnzXPtLT09Xenq6eT01NbWYjgwAAABAWeUe0lWudcJuux9HRo0Ad5RiSY58/PHH2rVrl7Zv355rW1JSkpycnOTl5WVR7uvrq6SkJHOdvydGcrbnbMtLXFycJk6caIXoAQAAANypyvE4DIA8WH1C1pMnT+qZZ57R0qVL5eLiYu3u8zV27FilpKSYl5MnT5bYvgEAAAAAQNll9eTIzp07dfbsWbVo0ULlypVTuXLltGnTJs2cOVPlypWTr6+vMjIylJycbNHuzJkz8vPzkyT5+fnlentNznpOnRs5OzvLw8PDYgEAAAAAALgVqydH7r33Xu3du1eJiYnmpWXLlurfv7/56/Llyys+Pt7c5uDBgzpx4oTCw8MlSeHh4dq7d6/Onj1rrrNu3Tp5eHioYcOG1g4ZAAAAAADYMavPOVKxYkU1btzYoszNzU2VK1c2lw8ZMkSjR4+Wt7e3PDw89PTTTys8PFx33XWXJKlz585q2LChHnvsMU2dOlVJSUl6+eWXNWLECDk7O1s7ZAAAAAAAYMeK7W01NzN9+nQ5ODioZ8+eSk9PV2RkpN555x3zdkdHR61cuVJPPfWUwsPD5ebmpujoaE2aNMkW4QIAAAAAgDtYiSRHNm7caLHu4uKiOXPmaM6cOfm2CQwM1DfffFPMkQEAAAAAAHtn9TlHAAAAAAAAyhKSIwAAAAAAwK6RHAEAAAAAAHaN5AgAAAAAALBrJEcAAAAAAIBdIzkCAAAAAADsGskRAAAAAABg10iOAAAAAAAAu0ZyBAAAAAAA2DWSIwAAAAAAwK6RHAEAAAAAAHaN5AgAAAAAALBrJEcAAAAAAIBdIzkCAAAAAADsGskRAAAAAABg10iOAAAAAAAAu0ZyBAAAAAAA2DWSIwAAAAAAwK6RHAEAAAAAAHaN5AgAAAAAALBrJEcAAAAAAIBdIzkCAAAAAADsGskRAAAAAABg10iOAAAAAAAAu0ZyBAAAAAAA2DWSIwAAAAAAwK6RHAEAAAAAAHaN5AgAAAAAALBrJEcAAAAAAIBdIzkCAAAAAADsGskRAAAAAABg18rZOgDgpmI9i9guxbpxAAAAAADuWCRHAAAAUKqdPn1ap0+fvu1+/P395e/vb4WIAAB3GpIjAAAAuC1BL35drP2fX/8fXdy+4rb7qdiqh7zvefz2A8rHsdeiiq1vAEDxYs4RAAAAAABg1xg5AgAAgFLNo/VDcmvY6bb7cXT3vv1gAAB3JJIjAAAAKNXKuXurHIkNAEAxIjmCO1KTxU2K3HZv9F4rRgIAAAAAKO2YcwQAAAAAANg1kiMAAKBMmDNnjoKCguTi4qKwsDBt27Yt37r79+9Xz549FRQUJJPJpBkzZpRcoAAAoMwhOQIAAEq95cuXa/To0ZowYYJ27dqlZs2aKTIyUmfPns2z/uXLl1WrVi299tpr8vPzK+FoAQBAWUNyBAAAlHpvvfWWhg4dqkGDBqlhw4aaN2+eKlSooAULFuRZv1WrVnrjjTfUt29fOTs7l3C0AACgrGFCVhS7oBe/LnLbYy5WDAQAUCZlZGRo586dGjt2rLnMwcFBERERSkhIsGFkAADgTkFyBAAAlGp//vmnsrKy5Ovra1Hu6+urX375xWr7SU9PV3p6unk9NTXVan0DAIDSjcdqAAAAJMXFxcnT09O81KhRw9YhAQCAEmL15EhcXJxatWqlihUrysfHRz169NDBgwct6ly9elUjRoxQ5cqV5e7urp49e+rMmTMWdU6cOKGoqChVqFBBPj4+GjNmjK5du2btcAEAQClXpUoVOTo65rpXOHPmjFUnWx07dqxSUlLMy8mTJ63WNwAAKN2snhzZtGmTRowYoR9//FHr1q1TZmamOnfurLS0NHOdZ599Vl999ZU+/fRTbdq0SX/88Yceeugh8/asrCxFRUUpIyNDP/zwgxYvXqxFixZp/Pjx1g4XAACUck5OTgoNDVV8fLy5LDs7W/Hx8QoPD7fafpydneXh4WGxAAAA+2D1OUdWr15tsb5o0SL5+Pho586d6tChg1JSUvT+++9r2bJluueeeyRJCxcuVIMGDfTjjz/qrrvu0tq1a3XgwAF9++238vX1VUhIiF555RW98MILio2NlZOTk7XDBgAApdjo0aMVHR2tli1bqnXr1poxY4bS0tI0aNAgSdKAAQNUrVo1xcXFSbo+ieuBAwfMX586dUqJiYlyd3dXnTp1bHYcAACgdCr2OUdSUlIkSd7e3pKknTt3KjMzUxEREeY69evXV82aNc0zzickJKhJkyYWE69FRkYqNTVV+/fvL+6QAQBAKdOnTx9NmzZN48ePV0hIiBITE7V69WrzvcKJEyd0+vRpc/0//vhDzZs3V/PmzXX69GlNmzZNzZs31+OPP26rQwAAAKVYsb6tJjs7W6NGjVLbtm3VuHFjSVJSUpKcnJzk5eVlUdfX11dJSUnmOnnNSJ+zLS/MMA8AwJ0tJiZGMTExeW7buHGjxXpQUJAMwyiBqAAAwJ2gWEeOjBgxQvv27dPHH39cnLuRxAzzAAAAAACgaIotORITE6OVK1dqw4YNql69urncz89PGRkZSk5Otqj/9xnn/fz88pyRPmdbXphhHgAAAAAAFIXVkyOGYSgmJkaff/651q9fr+DgYIvtoaGhKl++vMWM8wcPHtSJEyfMM86Hh4dr7969Onv2rLnOunXr5OHhoYYNG+a5X2aYBwAAAAAARWH1OUdGjBihZcuW6YsvvlDFihXNc4R4enrK1dVVnp6eGjJkiEaPHi1vb295eHjo6aefVnh4uO666y5JUufOndWwYUM99thjmjp1qpKSkvTyyy9rxIgRcnZ2tnbIAAAAQJl3+vRpi4mJi8rf31/+/v5WiAgAyg6rJ0fmzp0rSerUqZNF+cKFCzVw4EBJ0vTp0+Xg4KCePXsqPT1dkZGReuedd8x1HR0dtXLlSj311FMKDw+Xm5uboqOjNWnSJGuHCwAAANwR3n33XU2cOPG2+5kwYYJiY2NvPyAAKEOsnhwpyMzwLi4umjNnjubMmZNvncDAQH3zzTfWDA0AAACwmaAXvy7W/tPPVFblf/4rz23GtUydXz1TkuTdZaRM5crn28+7xytrUTHGeuy1qGLrGwCKqlhf5QsAAACgZFw5lKCU7z+6Zb2cJEl+PNv2k7NvLWuFBQBlAskRAAAA4A7gHtJVrnXCbrsfR3dvK0QDAGULyREAAADgDlDO3VvlSGwAQJFY/VW+AAAAAAAAZQnJEQAAAAAAYNd4rAYobrGeRWrWJLhmkXe5N3pvkdsCAAAAgL0hOQIUwO28eu+YixUDAQAAAABYHY/VAAAAAAAAu0ZyBAAAAAAA2DWSIwAAAAAAwK6RHAEAAAAAAHaN5AgAAAAAALBrJEcAAAAAAIBdIzkCAAAAAADsGskRAAAAAABg10iOAAAAAAAAu0ZyBAAAAAAA2LVytg4AQMkIevHrIrc99lpUkdo1WdykyPvcG723yG3zFOtZxHYp1o0DZR+fJQAAgDsOyREAZcZtJXhcrBgIUARFTRZmXcmyciQAAAC4EckRALiJUjX6BQAAAECxIDkCALA7jEICAADA35EcAXBrRZ1jIbimdeNAqWD389cAAADgjsPbagAAAAAAgF0jOQIAAAAAAOwaj9UAAEoOj2gBAACgFCI5AgBlRVETC7Ep1o0DAAAAuMPwWA0AAAAAALBrjBwBgBJki1fI8qYXAAAA4OYYOQIAAAAAAOwayREAAAAAAGDXSI4AAAAAAAC7RnIEAAAAAADYNZIjAAAAAADArpEcAQAAAAAAdo3kCAAAAAAAsGskRwAAAAAAgF0jOQIAAAAAAOwayREAAAAAAGDXytk6AAAAAABA6XL69GmdPn36tvvx9/eXv7+/FSICihfJEQAAAACAhXfffVcTJ0687X4mTJig2NjY2w8IKGYkRwAAAAAAFp544gl169Ytz21XrlxRu3btJElbtmyRq6trvv0wagRlBckRAAAAAICFmz0Ok5aWZv46JCREbm5uJRUWUGyYkBUAAAAAANg1kiMAAAAAAMCukRwBAAAAAAB2jeQIAAAAAACwa6U6OTJnzhwFBQXJxcVFYWFh2rZtm61DAgAANlLY+4JPP/1U9evXl4uLi5o0aaJvvvmmhCIFAABlTal9W83y5cs1evRozZs3T2FhYZoxY4YiIyN18OBB+fj42Do8AABQggp7X/DDDz+oX79+iouL0z//+U8tW7ZMPXr00K5du9S4cWMbHAEAWE/Qi1/bdP/ZGVfNXzcYt1oOTi42i+XYa1E22zfuLKV25Mhbb72loUOHatCgQWrYsKHmzZunChUqaMGCBbYODQAAlLDC3he8/fbb6tKli8aMGaMGDRrolVdeUYsWLTR79uwSjhwAAJQFpXLkSEZGhnbu3KmxY8eayxwcHBQREaGEhAQbRgYAAEpaUe4LEhISNHr0aIuyyMhIrVixojhDBQDYmdOnT+v06dO33Y+/v7/8/f2tEBGKqlQmR/78809lZWXJ19fXotzX11e//PJLnm3S09OVnp5uXk9JSZEkZadfLlIMqSajSO2yrmQVqZ0kpaam5ioravwSx1DkfXIMufvjGIq2T44hd38cQ5HbGUbR9nsnKMp9QVJSUp71k5KS8t2Pte8l7iR5/T/6O87RdZynguE8FczNzlNJnKNraReUdelCntuMaxnmr6/+fkCmck759uPoXknl3CpZPb4cNztPjSesKbb95riwebEu7br9x5zcW0SpUodoK0SUW87nxZ7vJQrEKIVOnTplSDJ++OEHi/IxY8YYrVu3zrPNhAkTDEksLCwsLCx35HLy5MmSuASXSkW5LyhfvryxbNkyi7I5c+YYPj4++e6HewkWFhYWljt5sed7iYIolSNHqlSpIkdHR505c8ai/MyZM/Lz88uzzdixYy2Gz2ZnZ+v8+fOqXLmyTCaT1WJLTU1VjRo1dPLkSXl4eFit35LEMZQOHEPpwDGUDhxD/gzD0MWLFxUQEGC1PsuaotwX+Pn5Faq+VHL3EoVxJ/zfKAmcp4LhPBUM56lgOE8FUxrOE/cSBVMqkyNOTk4KDQ1VfHy8evToIen6DUp8fLxiYmLybOPs7CxnZ2eLMi8vr2KL0cPDo8z/EOAYSgeOoXTgGEoHjiFvnp6eVu2vrCnKfUF4eLji4+M1atQoc9m6desUHh6e735K+l6iMO6E/xslgfNUMJynguE8FQznqWBsfZ7s/V6iIEplckSSRo8erejoaLVs2VKtW7fWjBkzlJaWpkGDBtk6NAAAUMJudV8wYMAAVatWTXFxcZKkZ555Rh07dtSbb76pqKgoffzxx9qxY4fmz59vy8MAAAClVKlNjvTp00fnzp3T+PHjlZSUpJCQEK1evTrX5GoAAODOd6v7ghMnTsjBwcFcv02bNlq2bJlefvllvfTSS6pbt65WrFihxo0b2+oQAABAKVZqkyOSFBMTk+9wWVtxdnbWhAkTcg27LUs4htKBYygdOIbSgWNAQdzsvmDjxo25ynr16qVevXoVc1TFi89VwXCeCobzVDCcp4LhPBUM56nsMBkG7/MBAAAAAAD2y+HWVQAAAAAAAO5cJEcAAAAAAIBdIzkCAABwE3/99Zd8fHx07NgxSdfnNzGZTEpOTi5UP7GxsfL19ZXJZNKKFSusHqe1vfjii3r66afz3d6pUyeZTCaZTCYlJiaWXGClVN++ffXmm28Wqe2dci4PHDig6tWrKy0trcT3XdrOYUZGhoKCgrRjxw5bh5InW5+vu+66S//73/9KfL+3UpznZeDAgebX0RdUUlKS7rvvPrm5ucnLy6vUf67KOpIjBbR582Y98MADCggIKDM3NTeKi4tTq1atVLFiRfn4+KhHjx46ePCgrcMqlLlz56pp06bm94SHh4dr1apVtg6ryF577TWZTCaNGjXK1qEUSmxsrPnCkbPUr1/f1mEV2qlTp/Too4+qcuXKcnV1VZMmTcrUxSYoKCjX98FkMmnEiBG2Dq3AsrKyNG7cOAUHB8vV1VW1a9fWK6+8orI0HdbFixc1atQoBQYGytXVVW3atNH27dttHRasaPLkyerevbuCgoIkXX8TzunTp+Xp6VngPn7++WdNnDhR7777rk6fPq2uXbsWOZ758+erU6dO8vDwyDdJc/78efXv318eHh7y8vLSkCFDdOnSJYs6e/bsUfv27eXi4qIaNWpo6tSpFtufe+45LV68WL/99lu+sQwdOlSnT5++6VuArl69qoEDB6pJkyYqV65cvr8cbNy4US1atJCzs7Pq1KmjRYsW5aozZ84cBQUFycXFRWFhYdq2bVu++y0oa8X38ssva/LkyUpJSSlSHCV9Loti8uTJatOmjSpUqCAvL69c2xs2bKi77rpLb731llX2V1jWPIcFcbPPo5OTk5577jm98MILRe6/uOV1vk6cOKGoqChVqFBBPj4+GjNmjK5du1aofgvye9PLL7+sF198UdnZ2bd7GFaX13kZOXKkQkND5ezsrJCQkCL1+/bbbxf6/+L06dN1+vRpJSYm6tdffy0Tn6uyjORIAaWlpalZs2aaM2eOrUMpsk2bNmnEiBH68ccftW7dOmVmZqpz5842ye4XVfXq1fXaa69p586d2rFjh+655x51795d+/fvt3VohbZ9+3a9++67atq0qa1DKZJGjRrp9OnT5mXLli22DqlQLly4oLZt26p8+fJatWqVDhw4oDfffFOVKlWydWgFtn37dovvwbp16ySpTL2d4/XXX9fcuXM1e/Zs/fzzz3r99dc1depUzZo1y9ahFdjjjz+udevW6cMPP9TevXvVuXNnRURE6NSpU7YODVZw+fJlvf/++xoyZIi5zMnJSX5+fjKZTAXu58iRI5Kk7t27y8/P77beWnD58mV16dJFL730Ur51+vfvr/3792vdunVauXKlNm/erGHDhpm3p6amqnPnzgoMDNTOnTv1xhtvKDY2VvPnzzfXqVKliiIjIzV37tx891OhQgX5+fmpXLn8X4CYlZUlV1dXjRw5UhEREXnWOXr0qKKionT33XcrMTFRo0aN0uOPP641a9aY6yxfvlyjR4/WhAkTtGvXLjVr1kyRkZE6e/ZsvvsuCGvF17hxY9WuXVtLliwpUhwleS6LKiMjQ7169dJTTz2Vb51BgwZp7ty5hf6F2hqsdQ4LoiCfx/79+2vLli2l9j71xvOVlZWlqKgoZWRk6IcfftDixYu1aNEijR8/vlD9FuT3pq5du+rixYul8o+c+X2OBg8erD59+hS5X09PzzyTijdz5MgRhYaGqm7duvLx8ZFU+j9XZZqBQpNkfP7557YO47adPXvWkGRs2rTJ1qHclkqVKhn/+c9/bB1GoVy8eNGoW7eusW7dOqNjx47GM888Y+uQCmXChAlGs2bNbB3GbXnhhReMdu3a2ToMq3rmmWeM2rVrG9nZ2bYOpcCioqKMwYMHW5Q99NBDRv/+/W0UUeFcvnzZcHR0NFauXGlR3qJFC+Pf//63jaKCNX366adG1apVLco2bNhgSDIuXLhgGIZhLFy40PD09DRWr15t1K9f33BzczMiIyONP/74wzCM6z8zJVks1nBjHDkOHDhgSDK2b99uLlu1apVhMpmMU6dOGYZhGO+8845RqVIlIz093VznhRdeMOrVq2fR1+LFi43q1avnuf+iXL+io6ON7t275yp//vnnjUaNGlmU9enTx4iMjDSvt27d2hgxYoR5PSsrywgICDDi4uIKFUNxxWcYhjFx4sQiXVtK+lzerpzPfF7S09MNZ2dn49tvv7Xa/grCmuewIAr6ebz77ruNl19+uUj7KE55na9vvvnGcHBwMJKSksxlc+fONTw8PCx+VhTGzX5vGjRokPHoo48Wqd/icqvP0e3cA9/4eevYsaPx9NNPG2PGjDEqVapk+Pr6GhMmTDBvDwwMtLhuREdHm7eV1s9VWcfIETuWM+zT29vbxpEUTVZWlj7++GOlpaUpPDzc1uEUyogRIxQVFXVbf7GwtUOHDikgIEC1atVS//79deLECVuHVChffvmlWrZsqV69esnHx0fNmzfXe++9Z+uwiiwjI0NLlizR4MGDC/XXbFtr06aN4uPj9euvv0qSdu/erS1bttzWIwcl6dq1a8rKypKLi4tFuaura5kbTYW8fffddwoNDb1lvcuXL2vatGn68MMPtXnzZp04cULPPfecpOuPpyxcuFCSzCO9ilNCQoK8vLzUsmVLc1lERIQcHBy0detWc50OHTrIycnJXCcyMlIHDx7UhQsXzGWtW7fW77//bp5vpThjvvGaGBkZqYSEBEnXf8bt3LnToo6Dg4MiIiLMdWwZX47WrVtr27ZtSk9PL/aY8lPQWIuLk5OTQkJC9N1335XI/myhMJ/H1q1bl5lzkZCQoCZNmsjX19dcFhkZqdTU1GIZpVCWzk1xWbx4sdzc3LR161ZNnTpVkyZNMo8E3r59u7p06aLevXvr9OnTevvtt83tOHfFg+SIncrOztaoUaPUtm3bmz6XWRrt3btX7u7ucnZ21pNPPqnPP/9cDRs2tHVYBfbxxx9r165diouLs3UoRRYWFqZFixZp9erVmjt3ro4ePar27dvr4sWLtg6twH777TfNnTtXdevW1Zo1a/TUU09p5MiRWrx4sa1DK5IVK1YoOTlZAwcOtHUohfLiiy+qb9++ql+/vsqXL6/mzZtr1KhR6t+/v61DK5CKFSsqPDxcr7zyiv744w9lZWVpyZIlSkhIKPZfgFEyjh8/roCAgFvWy8zM1Lx589SyZUu1aNFCMTExio+PlyS5u7ubh1L7+fnJz8+vOENWUlKSefh1jnLlysnb21tJSUnmOn//BUiSeT2njiTzsR8/frw4Q843ntTUVF25ckV//vmnsrKy8qzz93htFV+OgIAAZWRklEhM+SlorMUpICCg2D8ztlSYz2NZOhcF/blgLQEBATp58mSpnHekpDRt2lQTJkxQ3bp1NWDAALVs2dJ87ahataqcnZ3l6uoqPz8/i3muytLnqiwhOWKnRowYoX379unjjz+2dSiFVq9ePSUmJmrr1q166qmnFB0drQMHDtg6rAI5efKknnnmGS1dujTXX5rLkq5du6pXr15q2rSpIiMj9c033yg5OVmffPKJrUMrsOzsbLVo0UJTpkxR8+bNNWzYMA0dOlTz5s2zdWhF8v7776tr164F+iWuNPnkk0+0dOlSLVu2TLt27dLixYs1bdq0MpWk+vDDD2UYhqpVqyZnZ2fNnDlT/fr1k4MDl9g7wZUrVwr087pChQqqXbu2ed3f3/+258KYMmWK3N3dzYstRui5urpKuj4ypiAaNWpkjrc0jgAr7vgKe75uxpbn8sknn7T47BWWq6urVc7B7SoNn8fSci5KI1dXV2VnZ9t0pJWt3Tj3YEGvHXyuikf+sxXhjhUTE2OenK169eq2DqfQnJycVKdOHUlSaGiotm/frrffflvvvvuujSO7tZ07d+rs2bNq0aKFuSwrK0ubN2/W7NmzlZ6eLkdHRxtGWDReXl76xz/+ocOHD9s6lALz9/fPNeKoQYMGpfK1crdy/Phxffvtt/rss89sHUqhjRkzxjx6RJKaNGmi48ePKy4uTtHR0TaOrmBq166tTZs2KS0tTampqfL391efPn1Uq1YtW4cGK6hSpYrFYyb5KV++vMW6yWS67bcuPfnkk+rdu7d5vaDJTz8/v1w319euXdP58+fNo1b8/Px05swZizo5638f2XL+/HlJ1/+CWRDffPONMjMzJf1foqCgMecVj4eHh1xdXeXo6ChHR8c86xRmJE5xxZejsOfLlrHezKRJk8yPhRXF+fPnLZKFtlLUc3grVapUKfDn8fz581b5PJQEPz+/XG+AyuvngrWcP39ebm5uVv3elDV5XTsKMpKmLH2uyhL+rGVHDMNQTEyMPv/8c61fv17BwcG2DskqylLG+d5779XevXuVmJhoXlq2bKn+/fsrMTGxTCZGJOnSpUs6cuSI/P39bR1KgbVt2zbXq6x//fVXBQYG2iiiolu4cKF8fHwUFRVl61AK7fLly7lGWDg6OpbJIbZubm7y9/fXhQsXtGbNGnXv3t3WIcEKmjdvbrPRid7e3qpTp455udkbOP4uPDxcycnJ2rlzp7ls/fr1ys7OVlhYmLnO5s2bzb84StK6detUr149i7d27du3T+XLl1ejRo0KtO/AwEBzvNWqVStQm5x4coaS/z2enDnFnJycFBoaalEnOztb8fHxhZp3rLjiy7Fv3z5Vr15dVapUKXDftor1Znx8fCw+e4W1b98+NW/evNDtrK2o5/BWCvN5LC3noiDCw8O1d+9ei+TqunXr5OHhUSyPsJelc1PacO6KByNHCujSpUsWfxU/evSoEhMT5e3trZo1a9owsoIbMWKEli1bpi+++EIVK1Y0Pzvo6elZZjK2Y8eOVdeuXVWzZk1dvHhRy5Yt08aNG63yerqSULFixVxzvLi5ualy5cplau6X5557Tg888IACAwP1xx9/aMKECXJ0dFS/fv1sHVqBPfvss2rTpo2mTJmi3r17a9u2bZo/f77FayzLguzsbC1cuFDR0dEF/sWpNHnggQc0efJk1axZU40aNdJPP/2kt956S4MHD7Z1aAW2Zs0aGYahevXq6fDhwxozZozq16+vQYMG2To0WEFkZKTGjh2rCxculJpXfSclJSkpKcl8X7J3715VrFhRNWvWlLe3txo0aKAuXbqYHxXMzMxUTEyM+vbtax598sgjj2jixIkaMmSIXnjhBe3bt09vv/22pk+fbrGv7777Tu3bt7/t+4QDBw4oIyND58+f18WLF5WYmChJCgkJkXR9lMzs2bP1/PPPa/DgwVq/fr0++eQTff311+Y+Ro8erejoaLVs2VKtW7fWjBkzlJaWZpX/a9aIT7p+vjp37nzb8ZRErEVx4sQJnT9/XidOnFBWVpZ533Xq1DE/fnPs2DGdOnWqVE86f6tzWBAF/Tx+9913euWVV6wYffHp3LmzGjZsqMcee0xTp05VUlKSXn75ZY0YMaJQrx8v6O9NJfH/xVoOHz6sS5cuKSkpSVeuXDF/Zho2bGgxsXVJKUufqzLFti/LKTtyXpd34/L3VyqVdnnFL8lYuHChrUMrsMGDBxuBgYGGk5OTUbVqVePee+811q5da+uwbktZfJVvnz59DH9/f8PJycmoVq2a0adPH+Pw4cO2DqvQvvrqK6Nx48aGs7OzUb9+fWP+/Pm2DqnQ1qxZY0gyDh48aOtQiiQ1NdV45plnjJo1axouLi5GrVq1jH//+99FfmWgLSxfvtyoVauW4eTkZPj5+RkjRowwkpOTbR0WrKh169bGvHnzzOv5vcr37z7//HOLV/beuP73fo4ePVqoePJ6NfCN1/O//vrL6Nevn+Hu7m54eHgYgwYNMi5evGjRz+7du4127doZzs7ORrVq1YzXXnst177q1atnfPTRR3nGUZjr142vpMxZ/m7Dhg1GSEiI4eTkZNSqVSvP+5NZs2YZNWvWNJycnIzWrVsbP/74o8X26Ohoo2PHjgWKydrxXblyxfD09DQSEhIKvf+SPpcLFy4s0iulo6Oj89z3hg0bzHWmTJli1dcGF5Q1z+HRo0dzHVdebvV5/OGHHwwvLy/j8uXLhT2cYpff+Tp27JjRtWtXw9XV1ahSpYrxr3/9y8jMzDRvL8i5KcjvTb///rtRvnx54+TJk1Y8qtuX33np2LFjnsf095/ft/q9Kq9X+d64r+7du1ucpxvXDaN0f67KOpNh3OYDsQAAAHewr7/+WmPGjNG+ffusOtHuwoULNWXKFB04cCDXc+elwapVq/Svf/1Le/bsyXNkWqdOnRQSEqIZM2aUfHD56Nixo+6++27FxsaW+L7nzp2rzz//XGvXri1025I+lxMmTNCmTZu0ceNGq/abkZGhunXratmyZWrbtq1V+74Va57DDRs26KGHHtJvv/12WyPG+vTpo2bNmumll1667Zisrajny1rn5oUXXtCFCxdK3Yjdop6Xo0eP6h//+IcOHDigunXrFk9w/19p/lyVdcw5AgAAcBNRUVEaNmyYTp06ZdV+v/nmG02ZMqVUJkYkKS0tTQsXLrzpI3vvvPOO3N3dtXfv3hKMLG8pKSk6cuTIbU0kejvKly+vWbNmFbl9SZ7LVatWaerUqVbv98SJE3rppZdKPDGSw1rn8JtvvtFLL710W7/8Z2RkqEmTJnr22WdvK5biVJTzZY1zI12f16a0PhZS1PMybNiwYk+MlIXPVVnGyBEAAAAU2qlTp3TlyhVJUs2aNW3y3P2dgnN5+ziHhcP5yhvnxb6RHAEAAAAAAHaNx2oAAAAAAIBdIzkCAAAAAADsGskRAAAAAABg10iOAAAAAAAAu0ZyBAAAAAAA2DWSI0AZZRiGhg0bJm9vb5lMJiUmJto6JAAAAAAok0iOAGXU6tWrtWjRIq1cuVKnT59W48aNbR0SAABAgZw7d05PPfWUatasKWdnZ/n5+SkyMlLff/+9rUMDYKfK2ToAAEVz5MgR+fv7q02bNnluz8jIkJOTUwlHBQAAcGs9e/ZURkaGFi9erFq1aunMmTOKj4/XX3/9ZevQANgpRo4AZdDAgQP19NNP68SJEzKZTAoKClKnTp0UExOjUaNGqUqVKoqMjJQk7du3T127dpW7u7t8fX312GOP6c8//zT3lZaWpgEDBsjd3V3+/v5688031alTJ40aNcpcx2QyacWKFRYxeHl5adGiReb1kydPqnfv3vLy8pK3t7e6d++uY8eOWcTco0cPTZs2Tf7+/qpcubJGjBihzMxMc5309HS98MILqlGjhpydnVWnTh29//77MgxDderU0bRp0yxiSExMlMlk0uHDh2//pAIAgBKRnJys7777Tq+//rruvvtuBQYGqnXr1ho7dqy6detm6/AA2CmSI0AZ9Pbbb2vSpEmqXr26Tp8+re3bt0uSFi9eLCcnJ33//feaN2+ekpOTdc8996h58+basWOHVq9erTNnzqh3797mvsaMGaNNmzbpiy++0Nq1a7Vx40bt2rWrUPFkZmYqMjJSFStW1Hfffafvv/9e7u7u6tKlizIyMsz1NmzYoCNHjmjDhg1avHixFi1aZJFgGTBggD766CPNnDlTP//8s9599125u7vLZDJp8ODBWrhwocV+Fy5cqA4dOqhOnTpFOIsAAMAW3N3d5e7urhUrVig9Pd3W4QCAJB6rAcokT09PVaxYUY6OjvLz8zOX161bV1OnTjWvv/rqq2revLmmTJliLluwYIFq1KihX3/9VQEBAXr//fe1ZMkS3XvvvZKuJ1iqV69eqHiWL1+u7Oxs/ec//5HJZJJ0PXHh5eWljRs3qnPnzpKkSpUqafbs2XJ0dFT9+vUVFRWl+Ph4DR06VL/++qs++eQTrVu3ThEREZKkWrVqmfcxcOBAjR8/Xtu2bVPr1q2VmZmpZcuW5RpNAgAASrdy5cpp0aJFGjp0qObNm6cWLVqoY8eO6tu3r5o2bWrr8ADYKUaOAHeQ0NBQi/Xdu3drw4YN5r/QuLu7q379+pKuz1ly5MgRZWRkKCwszNzG29tb9erVK9R+d+/ercOHD6tixYrm/Xh7e+vq1as6cuSIuV6jRo3k6OhoXvf399fZs2clXX9ExtHRUR07dsxzHwEBAYqKitKCBQskSV999ZXS09PVq1evQsUKAABsr2fPnvrjjz/05ZdfqkuXLtq4caNatGhhMaIUAEoSI0eAO4ibm5vF+qVLl/TAAw/o9ddfz1XX39+/wHN1mEwmGYZhUfb3uUIuXbqk0NBQLV26NFfbqlWrmr8uX758rn6zs7MlSa6urreM4/HHH9djjz2m6dOna+HCherTp48qVKhQoGMAAACli4uLi+677z7dd999GjdunB5//HFNmDBBAwcOtHVoAOwQyRHgDtaiRQv973//U1BQkMqVy/3fvXbt2ipfvry2bt2qmjVrSpIuXLigX3/91WIER9WqVXX69Gnz+qFDh3T58mWL/Sxfvlw+Pj7y8PAoUqxNmjRRdna2Nm3aZH6s5kb333+/3NzcNHfuXK1evVqbN28u0r4AAEDp07Bhw1wTwANASeGxGuAONmLECJ0/f179+vXT9u3bdeTIEa1Zs0aDBg1SVlaW3N3dNWTIEI0ZM0br16/Xvn37NHDgQDk4WP5ouOeeezR79mz99NNP2rFjh5588kmLUSD9+/dXlSpV1L17d3333Xc6evSoNm7cqJEjR+r3338vUKxBQUGKjo7W4MGDtWLFCnMfn3zyibmOo6OjBg4cqLFjx6pu3boKDw+3zokCAAAl5q+//tI999yjJUuWaM+ePTp69Kg+/fRTTZ06Vd27d7d1eADsFMkR4A4WEBCg77//XllZWercubOaNGmiUaNGycvLy5wAeeONN9S+fXs98MADioiIULt27XLNXfLmm2+qRo0aat++vR555BE999xzFo+zVKhQQZs3b1bNmjX10EMPqUGDBhoyZIiuXr1aqJEkc+fO1cMPP6zhw4erfv36Gjp0qNLS0izqDBkyRBkZGRo0aNBtnBkAAGAr7u7uCgsL0/Tp09WhQwc1btxY48aN09ChQzV79mxbhwfATpmMGycSAGD3OnXqpJCQEM2YMcPWoeTy3Xff6d5779XJkyfl6+tr63AAAAAA3AGYcwRAmZCenq5z584pNjZWvXr1IjECAAAAwGp4rAZAmfDRRx8pMDBQycnJmjp1qq3DAQAAAHAH4bEaAAAAAABg1xg5AgAAAAAA7BrJEQAAAAAAYNdIjgAAAAAAALtGcgQAAAAAANg1kiMAAAAAAMCukRwBAAAAAAB2jeQIAAAAAACwayRHAAAAAACAXSM5AgAAAAAA7BrJEQAAAAAAYNdIjgAAAAAAALtGcgQAAAAAANg1kiMAAAAAAMCukRwBAAAAAAB2jeQIgDItKChIAwcOtHUYAADc1MaNG2UymbRx40Zbh3JTx44dk8lk0qJFiwrdtqwcoy0tWrRIJpNJx44ds3UoAG5AcgSwAwcOHFBsbGyZvRD/8MMPio2NVXJysq1DsTBlyhStWLHC1mEAAKyIn+0AYJ9IjgB24MCBA5o4cWKZTo5MnDgxz+TIwYMH9d5775V8UOIGGgDuRPxsR3F67LHHdOXKFQUGBto6FAA3IDkCWIlhGLpy5YqtwyhRaWlptg5Bzs7OKl++vK3DAAAAyFfOPZOjo6NcXFxkMplsHBGAG5EcgV2IjY2VyWTSL7/8ot69e8vDw0OVK1fWM888o6tXr1rUXbhwoe655x75+PjI2dlZDRs21Ny5c3P1GRQUpH/+859as2aNWrZsKVdXV7377rtF6mPjxo3mPpo0aWJ+Vvezzz5TkyZN5OLiotDQUP3000+5+vjll1/08MMPy9vbWy4uLmrZsqW+/PJL8/ZFixapV69ekqS7775bJpMp1/PAq1atUvv27eXm5qaKFSsqKipK+/fvt9jPwIED5e7uriNHjuj+++9XxYoV1b9//5ue91OnTmnw4MHy9fWVs7OzGjVqpAULFuSqN2vWLDVq1EgVKlRQpUqV1LJlSy1btkzS9e/dmDFjJEnBwcHm+HNGwdw450jOs7xbtmzRyJEjVbVqVXl5eemJJ55QRkaGkpOTNWDAAFWqVEmVKlXS888/L8MwLOKZNm2a2rRpo8qVK8vV1VWhoaH673//a1HHZDIpLS1NixcvNsf09ziscewAYM9yrt2HDx/WwIED5eXlJU9PTw0aNEiXL1/OVX/JkiUKDQ2Vq6urvL291bdvX508edKizqFDh9SzZ0/5+fnJxcVF1atXV9++fZWSkiLJej/bf//9d/Xo0UNubm7y8fHRs88+q/T09EId96+//qpHH31Unp6eqlq1qsaNGyfDMHTy5El1795dHh4e8vPz05tvvpmrj7Nnz2rIkCHy9fWVi4uLmjVrpsWLF+eql5ycrIEDB8rT01NeXl6Kjo7O9xHWW91vFNapU6c0ZMgQBQQEyNnZWcHBwXrqqaeUkZFhrvPbb7+pV69e8vb2VoUKFXTXXXfp66+/tugnZ56TTz75RBMnTlS1atVUsWJFPfzww0pJSVF6erpGjRolHx8fubu7a9CgQbm+FyaTSTExMVq6dKnq1atnvu/avHmzRb3jx49r+PDhqlevnlxdXVW5cmX16tUr18jcnHuRTZs2afjw4fLx8VH16tUttv29zY4dOxQZGakqVarI1dVVwcHBGjx4sEWfaWlp+te//qUaNWrI2dlZ9erV07Rp03Ldw+Qcy4oVK9S4cWPz53T16tWF+v4A9qicrQMASlLv3r0VFBSkuLg4/fjjj5o5c6YuXLigDz74wFxn7ty5atSokbp166Zy5crpq6++0vDhw5Wdna0RI0ZY9Hfw4EH169dPTzzxhIYOHap69eoVuo/Dhw/rkUce0RNPPKFHH31U06ZN0wMPPKB58+bppZde0vDhwyVJcXFx6t27tw4ePCgHh+t5zf3796tt27aqVq2aXnzxRbm5uemTTz5Rjx499L///U8PPvigOnTooJEjR2rmzJl66aWX1KBBA0ky//vhhx8qOjpakZGRev3113X58mXNnTtX7dq1008//aSgoCBzrNeuXVNkZKTatWunadOmqUKFCvme6zNnzuiuu+4yX6SrVq2qVatWaciQIUpNTdWoUaMkSe+9955Gjhyphx9+2Jys2rNnj7Zu3apHHnlEDz30kH799Vd99NFHmj59uqpUqSJJqlq16k2/108//bT8/Pw0ceJE/fjjj5o/f768vLz0ww8/qGbNmpoyZYq++eYbvfHGG2rcuLEGDBhgbvv222+rW7du6t+/vzIyMvTxxx+rV69eWrlypaKioszn7fHHH1fr1q01bNgwSVLt2rWteuwAgOvX7uDgYMXFxWnXrl36z3/+Ix8fH73++uvmOpMnT9a4cePUu3dvPf744zp37pxmzZqlDh066KeffpKXl5cyMjIUGRmp9PR08zXi1KlTWrlypZKTk+Xp6WmVn+1XrlzRvffeqxMnTmjkyJEKCAjQhx9+qPXr1xfquPv06aMGDRrotdde09dff61XX31V3t7eevfdd3XPPffo9ddf19KlS/Xcc8+pVatW6tChg3n/nTp10uHDhxUTE6Pg4GB9+umnGjhwoJKTk/XMM89Iuj7itXv37tqyZYuefPJJNWjQQJ9//rmio6NzxVKQ+43C+OOPP9S6dWslJydr2LBhql+/vk6dOqX//ve/unz5spycnHTmzBm1adNGly9f1siRI1W5cmUtXrxY3bp103//+99c+4yLi5Orq6tefPFFHT58WLNmzVL58uXl4OCgCxcuKDY2Vj/++KMWLVqk4OBgjR8/3qL9pk2btHz5co0cOVLOzs5655131KVLF23btk2NGzeWJG3fvl0//PCD+vbtq+rVq+vYsWOaO3euOnXqpAMHDuS6Lxo+fLiqVq2q8ePH5zva9uzZs+rcubOqVq2qF198UV5eXjp27Jg+++wzcx3DMNStWzdt2LBBQ4YMUUhIiNasWaMxY8bo1KlTmj59ukWfW7Zs0Weffabhw4erYsWKmjlzpnr27KkTJ06ocuXKhfpeAXbFAOzAhAkTDElGt27dLMqHDx9uSDJ2795tLrt8+XKu9pGRkUatWrUsygIDAw1JxurVq3PVL2wfP/zwg7lszZo1hiTD1dXVOH78uLn83XffNSQZGzZsMJfde++9RpMmTYyrV6+ay7Kzs402bdoYdevWNZd9+umnudoahmFcvHjR8PLyMoYOHWpRnpSUZHh6elqUR0dHG5KMF198Mdex5WXIkCGGv7+/8eeff1qU9+3b1/D09DSfo+7duxuNGjW6aV9vvPGGIck4evRorm2BgYFGdHS0eX3hwoWGJCMyMtLIzs42l4eHhxsmk8l48sknzWXXrl0zqlevbnTs2NGizxu/fxkZGUbjxo2Ne+65x6Lczc3NYt85rHnsAGCvcq7dgwcPtih/8MEHjcqVK5vXjx07Zjg6OhqTJ0+2qLd3716jXLly5vKffvrJkGR8+umnN93v7f5snzFjhiHJ+OSTT8x10tLSjDp16uR5Lc7vuIcNG2Yuy7lemUwm47XXXjOXX7hwwXB1dbWIN2f/S5YsMZdlZGQY4eHhhru7u5GammoYhmGsWLHCkGRMnTrVYj/t27c3JBkLFy40lxf0fmPDhg0FOsYBAwYYDg4Oxvbt23Nty7l2jxo1ypBkfPfdd+ZtFy9eNIKDg42goCAjKyvLYp+NGzc2MjIyzHX79etnmEwmo2vXrhb9h4eHG4GBgRZlkgxJxo4dO8xlx48fN1xcXIwHH3zQXJbX/V1CQoIhyfjggw/MZTn3Iu3atTOuXbtmUT9nW849zeeff25IyvNc5Mj5Xr366qsW5Q8//LBhMpmMw4cPWxyLk5PT/2Pv3uN7rP8/jj8/mx0MG9vYAUvOOW1MG8mx9dWcQko6GIpOU32Xigoph0rWVAqVQ6pvUqFSUouUSKY5E3IKG3PYbNjpc/3+8NsnHxt2MNdn9rjfbteN67re1/t6Xde17fP5vD7vg922DRs2GJKMt95666LnAGAYdKtBuXJhq43hw4dLkr799lvbtooVK9r+n5qaqpSUFHXs2FF///23rdltnuuvv15du3bNd56i1NGkSRO1bdvWth4eHi5J6tKli4KCgvJt//vvvyVJx48f108//aS77rpLp06dUkpKilJSUnTs2DF17dpVO3fu1MGDBy95P3744QedPHlSAwYMsB2fkpIiZ2dnhYeHa/ny5fmOeeSRRy5Zp3TuG44vvvhCPXv2lGEYdnV37dpVqampWr9+vSSpatWq+ueff/THH39ctt6ieOCBB+z684aHh8swDD3wwAO2bc7OzmrdurXtnuY5//mdOHFCqampat++vS3mS3GEaweAa8nDDz9st96+fXsdO3ZMaWlpks51QbVarbrrrrvs/ub6+/urQYMGttcyLy8vSdL3339fYLecSynK3/Zvv/1WAQEB6tevn+14Dw8PW0uUwnrwwQdt/897vbrwdaxq1apq1KiR3evYt99+K39/fw0YMMC2zcXFRY8//rjS09P1888/28pVqFDB7nXd2dnZ9t4oz5V4v3E+q9WqRYsWqWfPnmrdunW+/Xmv3d9++63CwsJ088032/ZVrlxZw4YN0969e7V161a74wYOHGg3Blne6/6F3VPCw8N14MAB5eTk2G1v27atQkNDbetBQUG6/fbb9f333ys3N1eS/fuD7OxsHTt2TPXr11fVqlULfI8wdOhQOTs7X/J+VK1aVZL0zTffKDs7u8Ay3377rZydnfX444/bbX/qqadkGIa+++47u+0RERG2Fk+S1KJFC3l6euZ7vwPAHt1qUK40aNDAbr1evXpycnKy6/e5atUqjR07VqtXr8735ik1NdX25ko6lxwpSFHqOD8BIv375q127doFbj9x4oSkc91xDMPQ6NGjNXr06ALjOHLkiGrWrFngPulc32vpXCKmIJ6ennbrFSpUsPWZvZSjR4/q5MmTmjlzpmbOnHnR2CTp2Wef1Y8//qiwsDDVr19f//nPf3TPPfeoXbt2lz3PpRTlvubd0zzffPONxo8fr8TERLt+yYUZPM0Rrh0AriUX/j2vVq2apHOvh56entq5c6cMw8j3Gp8n7wPz9ddfr5iYGMXGxurjjz9W+/bt1atXL9u4HpdSlL/t+/btU/369fO9ZuR1vS2sgl7H3N3dbd1Lz99+7Ngx2/q+ffvUoEEDWxfcPHndafft22f7NyAgQJUrV75knFfi/cb5jh49qrS0NFtXlYvZt2+f7Yuhi13H+XUU5XXfarUqNTXVrotJQT8/DRs21OnTp3X06FH5+/vrzJkzmjRpkmbPnq2DBw/ajfdx4Zdf0sXfJ56vY8eOuuOOOzRu3Di98cYb6tSpk3r37q177rlHbm5utmsNDAxUlSpVLnovznfhvZDO/d5c+H4HgD2SIyjXLnzjsnv3bt1yyy1q3LixYmNjVbt2bbm6uurbb7/VG2+8IavValf+/G8QilvHxb5RuNj2vBfivHpGjBhRYOsVSapfv36B2/Pk1TFv3jz5+/vn21+hgv2fCDc3t3xvti5V73333Vdg32Xp3LcY0rkX9h07duibb77R0qVL9cUXX+idd97RmDFjNG7cuMue62KKcl/Pf3Pzyy+/qFevXurQoYPeeecdBQQEyMXFRbNnzy7UQKmOcO0AcC0pzOuhxWLRd999V2DZ8z/8T5kyRYMGDdLixYu1bNkyPf7447ZxyC6V/C/K3/YrpaBrudy9KA1X4v3G1VDc91NFMXz4cM2ePVtPPvmk2rZtKy8vL1ksFt1999353t9JBb9PvJDFYtHnn3+uNWvW6Ouvv9b333+vIUOGaMqUKVqzZk2+5FVhmPFzAlwLSI6gXNm5c6ddFn/Xrl2yWq22QUe//vprZWZm6quvvrLLuhfUveRirkQdhVG3bl1J574Ri4iIuGTZi7V4yGtyWaNGjcvWURTVq1dXlSpVlJubW6h6K1WqpP79+6t///7KyspS3759NWHCBI0aNeqqT3f3xRdfyN3dXd9//73tGxvp3AxEFyoorit97QCAS6tXr54Mw9D111+vhg0bXrZ88+bN1bx5c73wwgv67bff1K5dO02fPl3jx4+XVPK/7dddd502b94swzDs6tqxY0cRr6x4rrvuOm3cuFFWq9XuC43t27fb9uf9Gx8fr/T0dLsP4BfGWZT3G4VRvXp1eXp6avPmzZe9joLu2YXXcaXktaY9319//SUPDw/bIPCff/65oqKi7GYIOnv27EVn+CmKNm3aqE2bNpowYYI++eQT3Xvvvfr000/14IMP6rrrrtOPP/6oU6dO2bUeKa17AZRXjDmCcmXatGl262+99ZYkKTIyUtK/mfYLm0kW9MH4Yq5EHYVRo0YNderUSTNmzNDhw4fz7T969Kjt/5UqVZKkfC/eXbt2laenpyZOnFhgP9fz6ygKZ2dn3XHHHfriiy8KfPNzfr3nNwWWJFdXVzVp0kSGYdhiulj8pcHZ2VkWi8XWv1iS9u7dq0WLFuUrW6lSpXwxXelrBwBcWt++feXs7Kxx48bl+2bcMAzb39q0tLR840w0b95cTk5Odl0oS/q3vVu3bjp06JDdFPCnT5++aHecK61bt25KSkrS/PnzbdtycnL01ltvqXLlyurYsaOtXE5Ojt59911budzcXNt7ozxFeb9RGE5OTurdu7e+/vprrVu3Lt/+vGfYrVs3rV27VqtXr7bty8jI0MyZM1WnTh01adKkSOe9nNWrV9uNG3LgwAEtXrxY//nPf2zv7ZydnfP9jL311lt27xmK6sSJE/nqDAkJkSTbz2W3bt2Um5urt99+267cG2+8IYvFYnsfC6BkaDmCcmXPnj3q1auXbrvtNq1evVofffSR7rnnHgUHB0uS/vOf/8jV1VU9e/bUQw89pPT0dL333nuqUaNGgW8ICnIl6iisadOm6eabb1bz5s01dOhQ1a1bV8nJyVq9erX++ecfbdiwQdK5F1lnZ2e9+uqrSk1NlZubm7p06aIaNWro3Xff1f33369WrVrp7rvvVvXq1bV//34tWbJE7dq1y/dCXFivvPKKli9frvDwcA0dOlRNmjTR8ePHtX79ev344486fvy4pHP3y9/fX+3atZOfn5+2bdumt99+W927d7d9O5I3QNrzzz+vu+++Wy4uLurZs6ctaXIlde/eXbGxsbrtttt0zz336MiRI5o2bZrq16+vjRs32pUNDQ3Vjz/+qNjYWAUGBur6669XeHj4Fb12AMCl1atXT+PHj9eoUaO0d+9e9e7dW1WqVNGePXu0cOFCDRs2TCNGjNBPP/2k6Oho3XnnnWrYsKFycnI0b948W+IjT0n/tg8dOlRvv/22Bg4cqISEBAUEBGjevHn5pnktLcOGDdOMGTM0aNAgJSQkqE6dOvr888+1atUqxcXF2V5fevbsqXbt2mnkyJHau3evmjRpoi+//LLAsTMK+36jsCZOnKhly5apY8eOGjZsmG644QYdPnxYCxYs0K+//qqqVatq5MiR+t///qfIyEg9/vjj8vb21ty5c7Vnzx598cUXhermWxTNmjVT165d7abylWTXzbVHjx6aN2+evLy81KRJE61evVo//vhjiabHnTt3rt555x316dNH9erV06lTp/Tee+/J09NT3bp1k3TuWXXu3FnPP/+89u7dq+DgYC1btkyLFy/Wk08+aTf4KoASuAoz4gCmy5sWb+vWrUa/fv2MKlWqGNWqVTOio6ONM2fO2JX96quvjBYtWhju7u5GnTp1jFdffdWYNWtWvqlkr7vuOqN79+4Fnq+kdUgyHnvsMbtte/bsMSQZkydPttu+e/duY+DAgYa/v7/h4uJi1KxZ0+jRo4fx+eef25V77733jLp16xrOzs75ptlbvny50bVrV8PLy8twd3c36tWrZwwaNMhuSruoqCijUqVKBV7vxSQnJxuPPfaYUbt2bcPFxcXw9/c3brnlFmPmzJm2MjNmzDA6dOhg+Pj4GG5ubka9evWMp59+2khNTbWr6+WXXzZq1qxpODk52d3Hi03le+GUeHk/A0ePHrXbXtB1ffDBB0aDBg0MNzc3o3Hjxsbs2bNtx59v+/btRocOHYyKFSsakuziuJLXDgDl0cX+bl84FWqeL774wrj55puNSpUqGZUqVTIaN25sPPbYY8aOHTsMwzCMv//+2xgyZIhRr149w93d3fD29jY6d+5s/Pjjj3b1lPRvu2Gcmwa2V69ehoeHh+Hr62s88cQTxtKlS4s0lW9hXq8MwzA6duyYb1r45ORkY/DgwYavr6/h6upqNG/e3G5q3jzHjh0z7r//fsPT09Pw8vIy7r//ftuUxxeWL8z7jcJO5WsY5+7RwIEDjerVqxtubm5G3bp1jccee8zIzMy0O2e/fv2MqlWrGu7u7kZYWJjxzTff2NWTd84Lp2guyvuBvPddH330ke31v2XLlvmu48SJE7b7WrlyZaNr167G9u3bC/1e5Px9eT+/69evNwYMGGAEBQUZbm5uRo0aNYwePXrYvQczjHPTGP/3v/81AgMDDRcXF6NBgwbG5MmTbVMfX3gtF7owRgD5WQyDkXlw7XvxxRc1btw4HT16NN8o7wAAACi/LBaLHnvssWK3lgVwbWDMEQAAAAAAUK6RHAEAAAAAAMX2zTffqFGjRmrQoIHef/99s8MpFodPjpw+fVrXXXedRowYYXYoAAAAAADgPDk5OYqJidFPP/2kP//8U5MnT843K2NZ4PDJkQkTJqhNmzZmh4Ey7sUXX5RhGIw3AgAAADuGYTDeCFACa9euVdOmTVWzZk1VrlxZkZGRWrZsmdlhFZlDJ0d27typ7du3M3c3AAAAAAClYOXKlerZs6cCAwNlsVi0aNGifGWmTZumOnXqyN3dXeHh4Vq7dq1t36FDh1SzZk3bes2aNXXw4MGrEfoVVWrJkZLeYEkaMWKEJk2aVFohAgAAAABQrmVkZCg4OFjTpk0rcP/8+fMVExOjsWPHav369QoODlbXrl115MiRqxxp6apQWhXn3eAhQ4aob9+++fbn3eDp06crPDxccXFx6tq1q3bs2KEaNWpo8eLFatiwoRo2bKjffvutyOe3Wq06dOiQqlSpIovFciUuCQCAq84wDJ06dUqBgYFycnLoBp8AAMABZGZmKjMz026bm5ub3NzcCiwfGRl5yd4asbGxGjp0qAYPHixJmj59upYsWaJZs2Zp5MiRCgwMtGspcvDgQYWFhV2BK7m6Si05UtIbvGbNGn366adasGCB0tPTlZ2dLU9PT40ZM6bA+i78ATh48KCaNGlyZS8KAACTHDhwQLVq1TI7DEhKSEgwOwQAgIMLDQ0t9rG5+rhE5540aafGjRtnt23s2LF68cUXi1xXVlaWEhISNGrUKNs2JycnRUREaPXq1ZKksLAwbd68WQcPHpSXl5e+++47jR49ukTXYIZSS45cSmFu8KRJk2xdaubMmaPNmzdfNDGSV/7CHwDp3JtJT0/PK3wF15ZmY78v1fqTF4xV1sFtJa7HteYN8rsz/zO+UjaP61pqdQNAcaWlpal27dqqUqWK2aHgPCGh280OAZISExqrWfB6s8Mo9zZvaMXvhINITGjMs3AYxU+OlNSoUaMUExNjt+1irUYuJyUlRbm5ufLz87Pb7ufnp+3bz/2sVahQQVOmTFHnzp1ltVr1zDPPyMfHp3jBm8iU5EhhbnBRXfgDkPdm0tPTk+TIZTi5eZRq/d63PqLslH0lrsfF97pSjZWfEwCOjC6iAACUD4ZhlOj4S3WhKS29evVSr169ruo5rzRTkiNFNWjQoMuWMeMHAIXj5ldXbn51zQ4DAAAAAMqAkiVHriRfX185OzsrOTnZbntycrL8/f1Niqp0mDKyW3m6wQAAAAAAlEWurq4KDQ1VfHy8bZvValV8fLzatm1rYmRXninJkfJ0gwEAAAAAKCzDsJZoKar09HQlJiYqMTFRkrRnzx4lJiZq//79kqSYmBi99957mjt3rrZt26ZHHnlEGRkZtslVrhWl1q0mPT1du3btsq3n3WBvb28FBQUpJiZGUVFRat26tcLCwhQXF3dN3mAAAAAAAArLMHKv6vnWrVunzp0729bzxvKMiorSnDlz1L9/fx09elRjxoxRUlKSQkJCtHTp0nxjiJZ1pZYc4QYDAAAAAODYOnXqdNlBYKOjoxUdHX2VIjJHqSVHuMEAAAAAABTN1W45gnPKxGw1AAAAAACUByRHzGHKgKwAAAAAAACOgpYjAAAAAAA4CEO0HDEDyREAAAAAABwE3WrMQbcaAAAAAABQrtFyBAAAAAAAB0HLEXPQcgQAAAAAAJRrtBwBAAAAAMBR0HLEFCRHAAAAAABwEHSrMQfdagAAAAAAQLlGyxEAAAAAAByFNcfsCMolkiMAAAAAADgIutWYg241AAAAAACgXKPlCAAAAAAADsMwO4ByieQIAAAAAACOwrCaHUG5RLcaAAAAAABQrtFyBAAAAAAAR0HLEVOQHAEAAAAAwEEYBlP5moFuNQAAAAAAoFyj5QgAAAAAAI7CyDU7gnKJ5AgAAAAAAI6C5Igp6FYDAAAAAADKNVqOAAAAAADgKKy0HDEDLUcAAAAAAEC5RssRAAAAAAAchIUxR0xBcgQAAAAAAEdh5JgdQblEtxoAAAAAAFCu0XIEAAAAAABHwYCspiA5AgAAAACAo2DMEVPQrQYAAAAAAJRrtBwBAAAAAMBR0HLEFCRHAAAAAABwEBar1ewQyiW61QAAAAAAgHKNliMAAAAAADgMWo6YwWFbjpw8eVKtW7dWSEiImjVrpvfee8/skAAAKPMMw9CwYcPk7e0ti8WixMTEQh1nsVi0aNEiSdLevXuLdCwAACgCwyjZgmJx2JYjVapU0cqVK+Xh4aGMjAw1a9ZMffv2lY+Pj9mhAQBQZi1dulRz5szRihUrVLduXfn6+podEq6SdX/s06wPftOWzYd19Gi63px2lyIiGpsdVpny6Sd/as7sP5SSkqGGjapr1HO3qHmLgIuWT0s7q7em/qr4H3cqNfWsAgM99czIzmrfoa4kad26A5oz6w9t25qso0czFPfm7epyS4N89fy9+5jeiF2phHUHlJNrVb26PoqNu10BgZ6SpM8/26Bvv92mbVuPKCMjS7+ujpanp3vp3IRrDL8XjoNnAbM5bMsRZ2dneXh4SJIyMzNlGIYMsmAAAJTI7t27FRAQoJtuukn+/v6qUMFhvyfBFXb6dJYaNfLT6LHdzA6lTFr63XZNfm2FHn60reYvuF+NGtXQww99rmPHMgosn52Vq4ceXKBDh1I15Y1e+mrJEI0d9x/VqFHZVubMmWw1alRDz70QcdHzHth/UlH3/0/XX++tD+b01xdfDtKwh9vK1c3533rO5qhdu+v14NDwK3fB5QS/F46DZ3Eew1qyBcVSasmRlStXqmfPngoMDLRrinu+adOmqU6dOnJ3d1d4eLjWrl1rt//kyZMKDg5WrVq19PTTT/PtFgAAJTBo0CANHz5c+/fvl8ViUZ06dSRJderUUVxcnF3ZkJAQvfjii8U+V506dTRx4kQNGTJEVapUUVBQkGbOnGlXZtOmTerSpYsqVqwoHx8fDRs2TOnp6RetMzc3Vw888ICuv/56VaxYUY0aNdLUqVPzXWPv3r31+uuvKyAgQD4+PnrssceUnZ1tK5OZmalnn31WtWvXlpubm+rXr68PPvig2NdaVnTo2EBP/LeLIm7lm9ji+HDuOt3Rr7l692muevV9NXrsraro7qJFX24usPzChZuUmnZWcW/2VstWNVWzppda31hbjRrXsJVp376uhj9xs26JyN9aJM9bb/6i9h3qKmZER91wg59qB1VV5y715eNTyVbm/oGhemBouFoEX7wVCwrG74Xj4Fn8y2LNLdGC4im15EhGRoaCg4M1bdq0AvfPnz9fMTExGjt2rNavX6/g4GB17dpVR44csZWpWrWqNmzYoD179uiTTz5RcnJyaYULAMA1b+rUqXrppZdUq1YtHT58WH/88Uepnm/KlClq3bq1/vzzTz366KN65JFHtGPHDknn3id07dpV1apV0x9//KEFCxboxx9/VHR09EXrs1qtqlWrlhYsWKCtW7dqzJgxeu655/TZZ5/ZlVu+fLl2796t5cuXa+7cuZozZ47mzJlj2z9w4ED973//05tvvqlt27ZpxowZqly5soCLyc7K1batyWrT9jrbNicni8LbBGnDhkMFHrNi+W4FBwdq4vh4derwjvrcPlvvzVyj3NzCf6trtRpa+fPfuu66anp46Ofq2H6a7rn7I/0Uv7PE1wQAsFdqyZHIyEiNHz9effr0KXB/bGyshg4dqsGDB6tJkyaaPn26PDw8NGvWrHxl/fz8FBwcrF9++eWi58vMzFRaWprdAgAA/uXl5aUqVarI2dlZ/v7+ql69eqmer1u3bnr00UdVv359Pfvss/L19dXy5cslSZ988onOnj2rDz/8UM2aNVOXLl309ttva968eRf9MsTFxUXjxo1T69atdf311+vee+/V4MGD8yVHqlWrprfffluNGzdWjx491L17d8XHx0uS/vrrL3322WeaNWuW+vTpo7p16+qWW25R//79S/VeoGw7cfKMcnMNu9YakuTjU0kpKQV3q/nnn1T9sOwvWa1WvfNuXz30cFt9OGedZs5YU+jzHj92WqdPZ+uDD35Xu5vraMbMO3XLLQ303ycWa90fB0p0TQAcmJFbsgXFYsqYI1lZWUpISFBExL/9K52cnBQREaHVq1dLkpKTk3Xq1ClJUmpqqlauXKlGjRpdtM5JkybJy8vLttSuXbt0LwIAAFxSixYtbP+3WCzy9/e3tRDdtm2bgoODVanSvx8227VrJ6vVamtdUpBp06YpNDRU1atXV+XKlTVz5kzt37/frkzTpk3l7PzveAwBAQG28yYmJsrZ2VkdO3Ys1DUU9OVLVlZWoY5F+WZYDXl7e2jMi/9Rk6b+ui2ysYYOa6MF8zcUug7r/4+317lzfd0f1VqNb6ihB4aGq0PHevqsCPUAAC7PlORISkqKcnNz5efnZ7fdz89PSUlJkqR9+/apffv2Cg4OVvv27TV8+HA1b978onWOGjVKqamptuXAAbLpAAAUhpOTU75Bz88fo6O4XFxc7NYtFous1uIPFPfpp59qxIgReuCBB7Rs2TIlJiZq8ODB+ZIVlzpvxYoVi3TOC7988fLy0uzZs4t9DSibqlWtKGdnS77BV48dy5Cvb6UCj/GtXknX1akmZ+d/325fX89bKSkZys4q3De71apWVIUKTqpXz362xrp1vZV0mFbSwDXLai3ZgmJx2CHqw8LClJiYWOjybm5ucnNzK72AAAC4RlWvXl2HDx+2raelpWnPnj2les4bbrhBc+bMUUZGhq31yKpVq+Tk5HTRlqKrVq3STTfdpEcffdS2bffu3UU6b/PmzWW1WvXzzz/btWC9mFGjRikmJsZu25YtWyT9XaTzomxzcXXWDU389Pua/bapdq1WQ7//vl8DBrQs8JiQljX13ZJtsloNOTlZJEn79p5Q9eqV5OLqXOAxBZ23aTN/7d17wm77vn0nbNP4Arj2WOgaYwpTWo74+vrK2dk5X5/i5ORk+fv7mxESAADlVpcuXTRv3jz98ssv2rRpk6Kiouy6pRRG48aNtXDhwkKXv/fee+Xu7q6oqCht3rxZy5cv1/Dhw3X//ffna1map0GDBlq3bp2+//57/fXXXxo9enSRB5WtU6eOoqKiNGTIEC1atEh79uzRihUr8o1bksfNzU2enp52i6ura5HO6SgyMrK0bVuStm0710r34D8ntW1bkg4dSjU5srJhYFRrffH5Ri1etFl/7z6m8S/9oDNnstW7TzNJ0nOjvtXUN1bayvfvH6zU1LN6ddJP2rv3uFb+vFvvv/e7+p+XTDmdkaXt245o+7Zz3b4O/pOq7duO6PChf1uFDBp8o5Z+t12fL9io/ftO6H8fr9fPK3ar/90htjIpRzO0fdsR7d9/UpK0c2eKtm87otSTZ0rxjlwb+L1wHDwLmM2UliOurq4KDQ1VfHy8evfuLencCPTx8fGXHKUeAABceaNGjdKePXvUo0cPeXl56eWXXy5yy5EdO3YoNbXwb2A9PDz0/fff64knntCNN94oDw8P3XHHHYqNjb3oMQ899JD+/PNP9e/fXxaLRQMGDNCjjz6q7777rkixvvvuu3ruuef06KOP6tixYwoKCtJzzz1XpDrKoi2bD2nQwA9t669OWiZJ6t0nWBNfud2ssMqM2yIb68Tx03rn7VVKSTmtRo2r690Z/eTz/91qkg6nyclisZX3D/DU9Jn99Nqry9Wvz1zV8Kuse+9rpSEPhNnKbNmSpAcG/5uYm/zaCklSr9ubavzESEnSLRENNHrsrfrgvd/16qSfVKdONcXG3a5WobVsx332WaKmv7Patj544KeSpJfH36bb/z95g4Lxe+E4eBbnoWuMKSzGhZ2Mr5D09HTt2rVLktSyZUvFxsaqc+fO8vb2VlBQkObPn6+oqCjNmDFDYWFhiouL02effabt27df9BujokhLS5OXl5dSU1Pl6Umzw0upM3KJ2SE4hL2vdDc7BADIh9czx5OQkKCQ0O1mhwFJiQmN1Sx4vdlhlHubN7Tid8JBJCY05lk4CGfdW+xjz/wVWaJzV2xYtC8NcE6ptRxZt26dOnfubFvP668bFRWlOXPmqH///jp69KjGjBmjpKQkhYSEaOnSpVckMQIAAAAAAFBYpZYc6dSpU76R7y8UHR1NNxoAAAAAAPLQrcYUDjtbDQAAAAAA5Y5BcsQMpsxWAwAAAAAA4ChoOQIAAAAAgIOwWHPNDqFcIjkCAAAAAICjoFuNKehWAwAAAAAAyjVajgAAAAAA4CguM+srSgfJEQAAAAAAHAXJEVPQrQYAAAAAAJRrtBwBAAAAAMBBWBiQ1RQkRwAAAAAAcBQkR0xBtxoAAAAAAFCu0XIEAAAAAABHYaXliBloOQIAAAAAAMo1Wo4AAAAAAOAoGHPEFCRHAAAAAABwEBa61ZiCbjUAAAAAAKBcIzkCAAAAAICjsFpLtjiYAwcOqFOnTmrSpIlatGihBQsWmB1SgehWAwAAAACAo7jGxhypUKGC4uLiFBISoqSkJIWGhqpbt26qVKmS2aHZITkCAAAAAABKRUBAgAICAiRJ/v7+8vX11fHjxx0uOUK3GgAAAAAAHITFai3RUlQrV65Uz549FRgYKIvFokWLFuUrM23aNNWpU0fu7u4KDw/X2rVri3VtCQkJys3NVe3atYt1fGmi5QgAAAAAAI7iKnerycjIUHBwsIYMGaK+ffvm2z9//nzFxMRo+vTpCg8PV1xcnLp27aodO3aoRo0akqSQkBDl5OTkO3bZsmUKDAyUJB0/flwDBw7Ue++9V7oXVEwkRwAAAAAAuEZkZmYqMzPTbpubm5vc3NwKLB8ZGanIyMiL1hcbG6uhQ4dq8ODBkqTp06dryZIlmjVrlkaOHClJSkxMvGxMvXv31siRI3XTTTcV4WquHrrVAAAAAADgKEo4W82kSZPk5eVlt0yaNKlYoWRlZSkhIUERERG2bU5OToqIiNDq1asLVYdhGBo0aJC6dOmi+++/v1hxXA20HAEAAAAAwFGUsFvNqFGjFBMTY7ftYq1GLiclJUW5ubny8/Oz2+7n56ft27cXqo5Vq1Zp/vz5atGihW08k3nz5ql58+bFiqm0kBwBAAAAAOAacakuNGa4+eabZS3GQLFXG8kRAAAAAAAchQMlEnx9feXs7Kzk5GS77cnJyfL39zcpqtLBmCMAAAAAADgIi2Et0XIlubq6KjQ0VPHx8bZtVqtV8fHxatu27RU9l9loOQIAAAAAQDmVnp6uXbt22db37NmjxMREeXt7KygoSDExMYqKilLr1q0VFhamuLg4ZWRk2GavuVaQHAEAAAAAwFEYV/d069atU+fOnW3reYO5RkVFac6cOerfv7+OHj2qMWPGKCkpSSEhIVq6dGm+QVrLOpIjAAAAAACUU506dZJhXDojEx0drejo6KsUkTlIjgAAAAAA4Cguk6hA6SA5AgAAAACAo7jCg6qicJitBgAAAAAAlGu0HAEAAAAAwFHQrcYUJEcAAAAAAHAUVrrVmMFhu9UcOHBAnTp1UpMmTdSiRQstWLDA7JAAAAAAAMA1yGFbjlSoUEFxcXEKCQlRUlKSQkND1a1bN1WqVMns0AAAAAAAKB0MyGoKh02OBAQEKCAgQJLk7+8vX19fHT9+nOQIAAAAAOCaZbEy5ogZSq1bzcqVK9WzZ08FBgbKYrFo0aJF+cpMmzZNderUkbu7u8LDw7V27doC60pISFBubq5q165dWuECAAAAAIByqtSSIxkZGQoODta0adMK3D9//nzFxMRo7NixWr9+vYKDg9W1a1cdOXLErtzx48c1cOBAzZw5s7RCBQAAAADAMRjWki0ollLrVhMZGanIyMiL7o+NjdXQoUM1ePBgSdL06dO1ZMkSzZo1SyNHjpQkZWZmqnfv3ho5cqRuuummS54vMzNTmZmZtvW0tLQrcBUAAAAAAFxFdKsxhSmz1WRlZSkhIUERERH/BuLkpIiICK1evVqSZBiGBg0apC5duuj++++/bJ2TJk2Sl5eXbaELDgAAAAAAKAxTBmRNSUlRbm6u/Pz87Lb7+flp+/btkqRVq1Zp/vz5atGihW28knnz5ql58+YF1jlq1CjFxMTY1tPS0kiQAACAUpGY0NjsEPD/Nm9oZXYIEL8TjoRn4RhCQ0twMF1jTOGws9XcfPPNsloL/0Ph5uYmNze3UowIAADgnJDQ7WaHAJ37EMizMB/PwXHwLBxJCbIjdKsxhSndanx9feXs7Kzk5GS77cnJyfL39zcjJAAAAAAAUE6ZkhxxdXVVaGio4uPjbdusVqvi4+PVtm1bM0ICAAAAAMB8zFZjilLrVpOenq5du3bZ1vfs2aPExER5e3srKChIMTExioqKUuvWrRUWFqa4uDhlZGTYZq8BAAAAAAC4GkotObJu3Tp17tzZtp43WGpUVJTmzJmj/v376+jRoxozZoySkpIUEhKipUuX5hukFQAAAACAcoMxR0xRasmRTp06yTAu/VCjo6MVHR1dWiEAAAAAAFC2XOZzNEqHKWOOAAAAAAAAOAqHncoXAAAAAIDyh5YjZiA5AgAAAACAo6BbjSnoVgMAAAAAAMo1Wo4AAAAAAOAomK3GFCRHAAAAAABwFHSrMQXdagAAAAAAQLlGyxEAAAAAABwF3WpMQXIEAAAAAABHQbcaU9CtBgAAAAAAlGu0HAEAAAAAwFHQrcYUJEcAAAAAAHAUdKsxBd1qAAAAAABAuUbLEQAAAAAAHAXdakxByxEAAAAAAFCu0XIEAAAAAAAHwZAj5iA5AgAAAACAo6BbjSnoVgMAAAAAAMo1Wo4AAAAAAOAoaDhiCpIjAAAAAAA4CpIjpqBbDQAAAAAAKNdIjgAAAAAAgHKNbjUAAAAAADgKq9kBlE+0HAEAAAAAAOUaLUcAAAAAAHAUDMhqCpIjAAAAAAA4CpIjpqBbDQAAAAAAKNdoOQIAAAAAgIMwrBazQyiXSI4AAAAAAOAo6FZjCrrVAAAAAACAco2WIwAAAAAAOAq61ZiC5AgAAAAAAI6CbjWmoFsNAAAAAAAo12g5AgAAAACAo6BbjSloOQIAAAAAAMo1h06O9OnTR9WqVVO/fv3MDgUAAFyCYRgaNmyYvL29ZbFYlJiYeNljLBaLFi1aJEnau3dvoY8DAOBaZhiWEi0oHodOjjzxxBP68MMPzQ4DAABcxtKlSzVnzhx98803Onz4sJo1a2Z2SLjAuj/26dGH/6eON8eqSaOX9OOP280OqdziWTgOnoXj4FmcxyjhgmJx6ORIp06dVKVKFbPDAAAAl7F7924FBATopptukr+/vypUYFgzR3P6dJYaNfLT6LHdzA6l3ONZOA6ehePgWcBspZYcWblypXr27KnAwEC7ZrPnmzZtmurUqSN3d3eFh4dr7dq1pRUOAAAoJYMGDdLw4cO1f/9+WSwW1alTR3Xq1FFcXJxduZCQEL344ovFPs+8efPUunVrValSRf7+/rrnnnt05MgR2/4VK1bIYrEoPj5erVu3loeHh2666Sbt2LHDrp6vv/5aN954o9zd3eXr66s+ffoUO6aypEPHBnriv10UcWtjs0Mp93gWjoNn4Th4FuexWkq2oFhKLTmSkZGh4OBgTZs2rcD98+fPV0xMjMaOHav169crODhYXbt2tXuTAwAAHN/UqVP10ksvqVatWjp8+LD++OOPUjlPdna2Xn75ZW3YsEGLFi3S3r17NWjQoHzlnn/+eU2ZMkXr1q1ThQoVNGTIENu+JUuWqE+fPurWrZv+/PNPxcfHKywsrFTiBQCgeCwlXFAcpdbmNTIyUpGRkRfdHxsbq6FDh2rw4MGSpOnTp2vJkiWaNWuWRo4cWeTzZWZmKjMz07aelpZW9KABAECReXl5qUqVKnJ2dpa/v3+pnef8JEfdunX15ptv6sYbb1R6eroqV65s2zdhwgR17NhRkjRy5Eh1795dZ8+elbu7uyZMmKC7775b48aNs5UPDg4utZgBAEDZYMqYI1lZWUpISFBERMS/gTg5KSIiQqtXry5WnZMmTZKXl5dtqV279pUKFwAAOICEhAT17NlTQUFBqlKlii0Bsn//frtyLVq0sP0/ICBAkmwtUxMTE3XLLbcU+pyZmZlKS0uzW7Kyskp6KQAAXJRhlGxB8ZiSHElJSVFubq78/Pzstvv5+SkpKcm2HhERoTvvvFPffvutatWqdcnEyahRo5SammpbDhw4UGrxAwCAS3NycpJxwTu07OzsYteXkZGhrl27ytPTUx9//LH++OMPLVy4UJLyJStcXFxs/7dYzjUvtlqtkqSKFSsW6bwXfvni5eWl2bNnF/s6AAC4LMNSsgXF4tBDyf/444+FLuvm5iY3N7dSjAYAABRW9erVdfjwYdt6Wlqa9uzZU+z6tm/frmPHjumVV16xtQ5dt25dketp0aKF4uPjbd16L2fUqFGKiYmx27ZlyxZJfxf53AAAwHGZkhzx9fWVs7OzkpOT7bYnJyeXal9lAABwdXTp0kVz5sxRz549VbVqVY0ZM0bOzs5FqqNx48aaNGmS+vTpo6CgILm6uuqtt97Sww8/rM2bN+vll18uclxjx47VLbfconr16unuu+9WTk6Ovv32Wz377LMFli/oyxdXV9cin9cRZGRkaf/+47b1g/+c1LZtSfLyqqjAQC8TIyt/eBaOg2fhOHgW56H1hylMSY64uroqNDRU8fHx6t27t6RzzV3j4+MVHR1tRkgAAOAKGjVqlPbs2aMePXrIy8tLL7/8cpFbjuzYsUOpqamSzrVEmTNnjp577jm9+eabatWqlV5//XX16tWrSHV26tRJCxYs0Msvv6xXXnlFnp6e6tChQ5HqKKu2bD6kQQM/tK2/OmmZJKl3n2BNfOV2s8Iql3gWjoNn4Th4FudhOl5TWIwLOwRfIenp6dq1a5ckqWXLloqNjVXnzp3l7e2toKAgzZ8/X1FRUZoxY4bCwsIUFxenzz77TNu3b883FklxpKWlycvLS6mpqfL09CxxfdeyOiOXmB2CQ9j7SnezQwCAfHg9czwJCQkKCd1udhiQlJjQmGfhAHgOjoNn4TicdW+xj82cWLVE53Z77mSJji8tp0+f1g033KA777xTr7/+utnh5FNqLUfWrVunzp0729bz+utGRUVpzpw56t+/v44ePaoxY8YoKSlJISEhWrp06RVJjAAAAAAAUBYZ12i3mgkTJqhNmzZmh3FRpZYc6dSpU75R6i8UHR1NNxoAAAAAAPJcg91qdu7cqe3bt6tnz57avHmz2eEUyJSpfAEAAAAAgPlWrlypnj17KjAwUBaLRYsWLcpXZtq0aapTp47c3d0VHh6utWvXFukcI0aM0KRJk65QxKWD5AgAAAAAAA7CMCwlWooqIyNDwcHBmjZtWoH758+fr5iYGI0dO1br169XcHCwunbtqiNHjtjKhISEqFmzZvmWQ4cOafHixWrYsKEaNmxY7HtyNZgyWw0AAAAAALjyMjMzlZmZabetoKnp80RGRioyMvKi9cXGxmro0KEaPHiwJGn69OlasmSJZs2apZEjR0qSEhMTL3r8mjVr9Omnn2rBggVKT09Xdna2PD09NWbMmCJeWemi5QgAAAAAAI7CsJRomTRpkry8vOyW4nZpycrKUkJCgiIiImzbnJycFBERodWrVxeqjkmTJunAgQPau3evXn/9dQ0dOtThEiMSLUcAAAAAAHAcJRyQddRzo2yzxea5WKuRy0lJSVFubm6+WWX9/Py0ffu1NW00yREAAAAAAK4Rl+pCY7ZBgwaZHcJFkRwBAAAAAMBBFGdQ1dLi6+srZ2dnJScn221PTk6Wv7+/SVGVDsYcAQAAAADAUZRwzJErydXVVaGhoYqPj7dts1qtio+PV9u2ba/oucxGyxEAAAAAAMqp9PR07dq1y7a+Z88eJSYmytvbW0FBQYqJiVFUVJRat26tsLAwxcXFKSMjwzZ7zbWC5AgAAAAAAA7CKOGArEW1bt06de7c2baeN5hrVFSU5syZo/79++vo0aMaM2aMkpKSFBISoqVLl+YbpLWsIzkCAAAAAICjuMpjjnTq1EmGYVyyTHR0tKKjo69SROZgzBEAAAAAAFCu0XIEAAAAAAAH4Uiz1ZQnJEcAAAAAAHAUJEdMQbcaAAAAAABQrtFyBAAAAAAAR3HpsVFRSkiOAAAAAADgMOhWYwa61QAAAAAAgHKNliMAAAAAADgIw0rLETPQcgQAAAAAAJRrJEcAAAAAAHAUhqVkSzmye/duvfDCCxowYICOHDkiSfruu++0ZcuWItdFcgQAAAAAAAdhGJYSLeXFzz//rObNm+v333/Xl19+qfT0dEnShg0bNHbs2CLXR3IEAAAAAACUKSNHjtT48eP1ww8/yNXV1ba9S5cuWrNmTZHrY0BWAAAAAAAcBQOyFsqmTZv0ySef5Nteo0YNpaSkFLk+Wo4AAAAAAOAg6FZTOFWrVtXhw4fzbf/zzz9Vs2bNItdHcgQAAAAAAJQpd999t5599lklJSXJYrHIarVq1apVGjFihAYOHFjk+kiOAAAAAADgIGg5UjgTJ05U48aNVbt2baWnp6tJkybq0KGDbrrpJr3wwgtFro8xRwAAAAAAcBTlKMFREq6urnrvvfc0evRobd68Wenp6WrZsqUaNGhQrPpIjgAAAAAAgDIpKChIQUFBJa6H5AgAAAAAAA7CYLaaQhkyZMgl98+aNatI9ZEcAQAAAADAUdCtplBOnDhht56dna3Nmzfr5MmT6tKlS5HrIzkCAAAAAADKlIULF+bbZrVa9cgjj6hevXpFro/ZagAAAAAAcBDMVlN8Tk5OiomJ0RtvvFHkY2k5AgAAAACAoyjnCY6S2r17t3Jycop8nEMnR7755hs99dRTslqtevbZZ/Xggw+aHRIAAAAAADBZTEyM3bphGDp8+LCWLFmiqKioItfnsMmRnJwcxcTEaPny5fLy8lJoaKj69OkjHx8fs0MDAAAAAKBUGGYHUEb8+eefdutOTk6qXr26pkyZctmZbArisMmRtWvXqmnTpqpZs6YkKTIyUsuWLdOAAQNMjgwAAAAAAJhp+fLlV7S+UhuQdeXKlerZs6cCAwNlsVi0aNGifGWmTZumOnXqyN3dXeHh4Vq7dq1t36FDh2yJEUmqWbOmDh48WFrhAgAAAABgPsNSsgXFUmotRzIyMhQcHKwhQ4aob9+++fbPnz9fMTExmj59usLDwxUXF6euXbtqx44dqlGjRmmFBQAAAACAwyrvM85cSsuWLWWxFO7+rF+/vkh1l1pyJDIyUpGRkRfdHxsbq6FDh2rw4MGSpOnTp2vJkiWaNWuWRo4cqcDAQLuWIgcPHlRYWNhF68vMzFRmZqZtPS0t7QpcBQAAAAAAcAS9e/cutbpNGXMkKytLCQkJGjVqlG2bk5OTIiIitHr1aklSWFiYNm/erIMHD8rLy0vfffedRo8efdE6J02apHHjxpV67AAAAAAAlBpajlzU2LFjS63uUhtz5FJSUlKUm5srPz8/u+1+fn5KSkqSJFWoUEFTpkxR586dFRISoqeeeuqSM9WMGjVKqamptuXAgQOleg0AAAAAAFxphtVSogXF47Cz1UhSr1691KtXr0KVdXNzk5ubWylHBAAAAAAAzJabm6s33nhDn332mfbv36+srCy7/cePHy9SfaYkR3x9feXs7Kzk5GS77cnJyfL39zcjJAAAgEJLTGhsdgj4fzwLx8BzcBw8C8cQGlr8YxmQtXDGjRun999/X0899ZReeOEFPf/889q7d68WLVqkMWPGFLk+U5Ijrq6uCg0NVXx8vG1AFavVqvj4eEVHR5sREgAAQKE1abHG7BAgaevGNmoessHsMMq9TYnBCgndbnYY0LnESIP6n5sdBiRJJcmOXLkormUff/yx3nvvPXXv3l0vvviiBgwYoHr16qlFixZas2aNHn/88SLVV2rJkfT0dO3atcu2vmfPHiUmJsrb21tBQUGKiYlRVFSUWrdurbCwMMXFxSkjI8M2ew0AAAAAAEBBkpKS1Lx5c0lS5cqVlZqaKknq0aPHJSdzuZhSS46sW7dOnTt3tq3HxMRIkqKiojRnzhz1799fR48e1ZgxY5SUlKSQkBAtXbo03yCtAAAAAACUF3SrKZxatWrp8OHDCgoKUr169bRs2TK1atVKf/zxR7HGIy215EinTp1kGJduDxQdHU03GgAAAAAA/h/JkcLp06eP4uPjFR4eruHDh+u+++7TBx98oP379+u///1vketz6NlqAAAAAAAALvTKK6/Y/t+/f39dd911+u2339SgQQP17NmzyPWRHAEAAAAAwEHQcqRwzp49K3d3d9t6mzZt1KZNm2LX53QlggIAAAAAAFeAYSnZUk7UqFFDUVFR+uGHH2S1WktcH8kRAAAAAABQpsydO1enT5/W7bffrpo1a+rJJ5/UunXril0fyREAAAAAAByEYbWUaCkv+vTpowULFig5OVkTJ07U1q1b1aZNGzVs2FAvvfRSkesjOQIAAAAAAMqkKlWqaPDgwVq2bJk2btyoSpUqady4cUWuh+QIAAAAAAAOw1LCpXw5e/asPvvsM/Xu3VutWrXS8ePH9fTTTxe5HmarAQAAAADAQRiG2RGUDd9//70++eQTLVq0SBUqVFC/fv20bNkydejQoVj1kRwBAAAAAABlSp8+fdSjRw99+OGH6tatm1xcXEpUH8kRAAAAAAAcRvnrGlMcycnJqlKliiTpn3/+UWBgoJycij9yCGOOAAAAAADgIAzDUqKlvMhLjEhSkyZNtHfv3hLVR3IEAAAAAACUWcYVGKiFbjUAAAAAADgIw1p+Wn84EpIjAAAAAAA4iPLUNeZKee6551StWrUS1UG3GgAAAAAAUOZ88MEHatasmcaOHSt/f381a9ZM77//frHqouUIAAAAAAAOgpYjhTNmzBjFxsZq+PDhatu2rSRp9erV+u9//6v9+/frpZdeKlJ9JEcAAAAAAHAUJR9btFx499139d5772nAgAG2bb169VKLFi00fPjwIidH6FYDAAAAAADKlOzsbLVu3Trf9tDQUOXk5BS5PpIjAAAAAAA4CMOwlGgpL+6//369++67+bbPnDlT9957b5Hro1sNAAAAAAAOojwlOErqgw8+0LJly9SmTRtJ0u+//679+/dr4MCBiomJsZWLjY29bF0kRwAAAAAAQJmyefNmtWrVSpK0e/duSZKvr698fX21efNmWzmLpXDJJpIjAAAAAAA4CFqOFM7y5cuvaH0kRwAAAAAAcBAkR8zBgKwAAAAAAKBco+UIAAAAAAAOgpYj5qDlCAAAAAAAKNdIjgAAAAAAgHKNbjUAAAAAADgIutWYg5YjAAAAAACg1OzZs0edO3dWkyZN1Lx5c2VkZJgdUj60HAEAAAAAAKVm0KBBGj9+vNq3b6/jx4/Lzc3N7JDyITkCoEw5fPiwDh8+XOJ6AgICFBAQcAUiAgAAAK6ca61bzZYtW+Ti4qL27dtLkry9vU2OqGAkRwCUKa+//rpiY2NLXE9MTIymTJlyBSICAAAAyq6VK1dq8uTJSkhI0OHDh7Vw4UL17t3brsy0adM0efJkJSUlKTg4WG+99ZbCwsIKVf/OnTtVuXJl9ezZUwcPHlS/fv303HPPlcKVlAzJEQBXVJ2RS0q1/uO//H1F6nnvl7/1RSnGuveV7qVWNwAAAK5dV7vlSEZGhoKDgzVkyBD17ds33/758+crJiZG06dPV3h4uOLi4tS1a1ft2LFDNWrUkCSFhIQoJycn37HLli1TTk6OfvnlFyUmJqpGjRq67bbbdOONN+rWW28t9WsrCpIjAMoUz7C+qtSkU4nrca7smM35AAAAUL6VNDmSmZmpzMxMu21ubm4XHecjMjJSkZGRF60vNjZWQ4cO1eDBgyVJ06dP15IlSzRr1iyNHDlSkpSYmHjR42vWrKnWrVurdu3akqRu3bopMTGR5AgAlESFyt6qQGIDAAAAKNCkSZM0btw4u21jx47Viy++WOS6srKylJCQoFGjRtm2OTk5KSIiQqtXry5UHTfeeKOOHDmiEydOyMvLSytXrtRDDz1U5FhKm0NP5dunTx9Vq1ZN/fr1MzsUAAAAAABKnWFYSrSMGjVKqampdsv5yY2iSElJUW5urvz8/Oy2+/n5KSkpqVB1VKhQQRMnTlSHDh3UokULNWjQQD169ChWPKXJoVuOPPHEExoyZIjmzp1rdigAAAAAAJS6knaruVQXGrNcruuOI3DoliOdOnVSlSpVzA4DAIAyq1OnTnryyScLXX7OnDmqWrVqqcUDAADKDl9fXzk7Oys5Odlue3Jysvz9/U2KqnQUu+VIaU/3A5Q3hw8f1uHDh0tcT0BAgAICAq5ARAAAR/Dp/zZo7uz1OpZyWg0b+erZ5zqqefPLvyFd+u1fGvnMUnXqUldxb/7bfPlYymnFvbFKa37br1OnMtUqNFDPPtdJ111X1VYmMzNHUyb/ou+/26msrFzd1C5Iz73QWT6+HrYyIc3ezHfOV167Tbd1a1iyC3Zg//tkvebM+l0pKRlq1KiGRj0foeYtAi9aPi3trN6culLxP/yl1NSzCgz01DMjb1GHjvXylX3/vTWa+sbPuu/+UD07KkKSlHryjKa9/atW/7ZXhw+nqVq1iupyS0NFP95eVaqc+1b45MkzGvnM1/prx1GdPHlG3j4e6tylgZ54soMqV3asb44d0bo/9mnWB79py+bDOno0XW9Ou0sREY3NDqvM+GzBbn300U4dO3ZWDRp46ekRwWratOCx4RYu2qNvl+zX7r/TJEmNG1fVY482tStvGIZmzNymRYv2KD09Wy1a+Gjksy0VFFTZVmbWrO36dVWS/vorVS4uTlr+U0+78/z110nN/fAvJSYeU2pqpgICKqlv3+s14O76pXAHSsfVnq3mUlxdXRUaGqr4+Hjb532r1ar4+HhFR0ebG9wVVuzkSGlP9xMYePEXGuBaNGPGjHwDJxVHcQdbAgA4nu+/+0tTXvtFz4/pouYt/PTxvEQ9+tBiLf76fnn7eFz0uIMH0xQ75Re1CrV/P2UYhv77xDeqUMFJb7zZQ5Uru2reh3/q4QcX6svF96mih4sk6fVXf9EvK/docmykKld20ysTVyjmySWa+9GddvWNGx+hdjdfZ1vP+8B+LVr63TZNfvUnjR77H7VoEah589bpoWGf6eslQ+XjUylf+eysXA17cL68vT0UG9dbNfyq6NChVHlWcc9XdvOmw/r8s0Q1bFTdbvuRo+k6ejRdTz3dWfXq+ejQoTS9PO57HT16SrFxfSRJFotFnbs00PDH26taNQ/t339CE8b/oNTUM3ptcq/SuRnXkNOns9SokZ/63tFSj0d/ZnY4ZcqyH/5RXNwmjRwZomZNvfW/T3dp+OOr9PmCW+Xtnf/nPCEhRf/pWkstWvjIzdVZcz/coejhqzT/0wjVqFFRkvThh39p/vzdenFsqAIDK2n6jK0a/viv+mz+rXJzc5YkZedYFXFLTTVv7q2vvtqX7zzbt59UtWpueuml1vLz89DGjcc0ceKfcnay6K678icmHdHVTo6kp6dr165dtvU9e/YoMTFR3t7eCgoKUkxMjKKiotS6dWuFhYUpLi5OGRkZttlrrhXF7lYTGRmp8ePHq0+fPgXuP3+6nyZNmmj69Ony8PDQrFmzbGUSExO1efPmfEtxEiOZmZlKS0uzW4Cy5KGHHlJCQkKBy6+//mor9+uvv160XEJCgkOO/Azg6sjIyNDAgQNVuXJlBQQEaMqUKfnKZGZmasSIEapZs6YqVaqk8PBwrVix4pL1Ll68WK1atZK7u7vq1q2rcePGFfjlRp5Bgwapd+/eev311xUQECAfHx899thjys7OtpU5ceKEBg4cqGrVqsnDw0ORkZHauXPnJeOIjY1V8+bNValSJdWuXVuPPvqo0tPTbfvzugR9//33uuGGG1S5cmXddttt+VrlzZo1S02bNpWbm5sCAgIc+puveR/+qb79mql3nyaqV89HL4zpInf3Clq0cOtFj8nNteq5Z7/XI4+2Uc1aXnb79u87qY0bkvTc6M5q1txPda6vpudHd9bZzBx99+0OSdKpU5la+OUWPfVMe4WF11aTpjU07uUIbUg8rI0b7O9llSpu8vWtZFvc3Bx6OLsS+XDOH7rjzmD16dtC9er7aszYrqro7qKFX24qsPzCLzcqNfWspr7VVy1b1VLNml668cYgNWpcw67c6YwsjXzma40dd5s8Pe0/UDZoUF1vTO2jTp3rq3ZQNYW3uU7Dn+igFct3KyfHKkny8nJX/7tbqmmzAAXW9FKbtnV0990ttT7hn9K5EdeYDh0b6In/dlHErbQWKapPPtmp3r3rqFfPOqpb11OjRraUu7uzvvo6f8JCksa/fKPu7FdPjRpWVZ06VfTC86EyDEN//HFE0rnk7f8+3aUhQxqpY8dANWjgpXEvtlZKyln9/PMhWz0PDWuie+5poPr1vQo8T69edTTiqWCFtqquWjUrqVtkkHr2vE7Llx8qsDykdevWqWXLlmrZsqUkKSYmRi1bttSYMWMkSf3799frr7+uMWPGKCQkRImJiVq6dGm+QVrLulJ5BbsS0/0UVUHTFQFlyaW6w2RkZNj+HxISokqV8n9DBQBPP/20fv75Zy1evFg1atTQc889p/Xr1yskJMRWJjo6Wlu3btWnn36qwMBALVy4ULfddps2bdqkBg0a5Kvzl19+0cCBA/Xmm2+qffv22r17t4YNGybpXEu1i1m+fLkCAgK0fPly7dq1S/3791dISIiGDh0q6VwCZefOnfrqq6/k6empZ599Vt26ddPWrVvl4uJSYJ1OTk568803df311+vvv//Wo48+qmeeeUbvvPOOrczp06f1+uuva968eXJyctJ9992nESNG6OOPP5Ykvfvuu4qJidErr7yiyMhIpaamatWqVUW+11dDdnautm09oiEPtrZtc3KyKLxN7XxJivPNeHetvL0rqs8dTbV+vf2HgaysXEmSm6uzXZ2uLs7688/D6tuvmbZtPaKcHKvC2wTZylxf11sBAVW0YUOSWgT/+1o1acIKvTQ2XjVreenOu5rp9j5NZLE4TnPwKyU7K1dbtybpgaFtbNucnCxq07aONiQeLPCY5ct3KTg4UBPG/6DlP+2UdzUPdeveREMeDJez87/fT04Y/4Pad6yntjfV0cwZv102lvT0TFWu7KoKFQr+jvPIkVP68ce/1Lp17SJeJVB42dlWbd9+UoOiGtm2OTlZFHZjDW3adLxQdZw9m6OcHKs8PV0lSQcPndaxY5kKC/s3gVi5souaNvXWxk3H9Z//FP9nOj09W55eBb+2OCLjKp+vU6dOMoxLnzU6Otqhv0y4EkolOXKp6X62b99e6HoiIiK0YcMGZWRkqFatWlqwYIHatm1bYNlRo0YpJibGtp6WlqbatXlRAACUD+np6frggw/00Ucf6ZZbbpEkzZ07V7Vq1bKV2b9/v2bPnq39+/fbWmmOGDFCS5cu1ezZszVx4sR89Y4bN04jR45UVFSUJKlu3bp6+eWX9cwzz1wyOVKtWjW9/fbbcnZ2VuPGjdW9e3fFx8dr6NChtqTIqlWrdNNNN0mSPv74Y9WuXVuLFi3SnXfeWWCd5w8sW6dOHY0fP14PP/ywXXIkOztb06dPV71655pOR0dH66WXXrLtHz9+vJ566ik98cQTtm033njjRa/DTCdOnFFuriGfC7rP+Ph4aO+eEwUe8+f6Q1q0cIvmf35PgfvrXF9NAQFV9ObU3zR6TBdV9HDRRx/+qeTkdKUcPZeIT0k5LRcXJ3l62neR8fbx0LGU07b1R6Pb6MawWqpYsYJW/7ZfE8ev0OnT2brnvpASXLVjOnHy9Lln4Wv/5YSPj4f2/H2swGP++eek1v6equ49muid6XfqwP4TGv/SMuXk5OqRx26WJH337VZt3ZqkTz+LKlwcJ05rxru/qd+dIfn2PTPiKy3/aafOns1Rp871Ne5lx54VAmXbyZOZys015O19wd8Jbzft3XeqUHW89fZm+fpWtCVDjh07K0nyuaBOH283277i2LDxmH744R/FvXFTsetA+eDQbR9//PHHQpd1xOmKAAC4Wnbv3q2srCyFh4fbtnl7e6tRo3+/1du0aZNyc3PVsKH9gJmZmZny8fEpsN4NGzZo1apVmjBhgm1bbm6uzp49q9OnT8vDo+BxL5o2bSpn539bJwQEBGjTpnPdD7Zt26YKFSrYxerj46NGjRpp27ZtF73GH3/8UZMmTdL27duVlpamnJycfHF4eHjYEiN55z1y5FyT7SNHjujQoUO25FFhZGZmKjMz025bVlZWoY+/mjIysvT8qGUa8+ItqlatYoFlXFycNSWuu14c86M6tJspZ+dzLVHatb+uyF9VDnv430H2G99QQ2fO5Gju7PXXZHKkOAyrIW9vD40dd5ucnZ3UtKm/kpNPac6stXrksZuVdDhNr0yK18z3+xeqO1J6eqYee/hz1a3no0cea5dv/zPPdtHDj7bTvr3HNfWNnzX51Z/0wpj/lMalASU2Z+4O/fDDP5r+bgfbWCKlYdfuVI0YsVpDH7xBbdqUnS4gjjQga3lSKsmR8jTdDwAAZUV6erqcnZ2VkJBgl7iQpMqVK1/0mHHjxhU4+Lq7e/4B9/Jc2DXGYrHIarUWI+pz9u7dqx49euiRRx7RhAkT5O3trV9//VUPPPCAsrKybMmRgs6b11S4YsWCEwaXUlC33aFDh2pq6+BiXknhVatWUc7OFh07dtpu+7Fjp+Xrmz8pdeBAqg4dTNMT0V/btlmt5649NPgtLfr6ftUOqqomTWvosy/u0alTmcrOzpW3t4fuGzBfTZqe+/bW19dD2dlWpaVl2rUeOX7stN1sNRdq1txPM6evVVZWjlxdHfr7tyKrVtXj3LNIybDbfuzY6XytSfL4Vq+sChWc7LrQ1K3ro5SUDGVn5WrLliQdP3Za/fvNse3PzTWUsO6A/vfJeiUkjrAdm5GRqYeHfSaPSq6a+lZfubjk/zDpW72yfKtXVt26PvLyqqio+z/WQ4/cpOrVC/7dBkqialU3OTtbdPy4ffL4+PFM+fhc/LVBkuZ99Jfmzv1L096+WQ0a/DtuSN5xx45nytf337/Xx45nqmHDgscXuZS//07TY4/9qj69r9cDD5StMWVIjpij2AOyXsr50/3kyZvu52LdYgAAQPHVq1dPLi4u+v33323bTpw4ob/++su23rJlS+Xm5urIkSOqX7++3XKxLy9atWqlHTt25Ctfv359OTkV723EDTfcoJycHLtYjx07ph07dqhJkyYFHpOQkCCr1aopU6aoTZs2atiwoQ4dKtrgelWqVFGdOnXs3p9czqhRo5Sammq3XK3R+V1cnHVDkxpa+/sB2zar1dDa3w/YjfuR5/rrq+nzhfdq/uf32JaOnevqxrBamv/5PfIPqGJXvkoVN3l7e2jfvpPauuWIOnWuK0m6oUkNVajgZHfevXtO6PDhUwoOvviXXDu2p8jT0+2aS4xIkours5o08dfva/4daNJqNbRmzV4Fh9Qs8JiWLWvqwP4TtgSVJO3bd0LVq1eWi6uz2rS9Tl8uHqIFXw62LU2b+at7j6Za8OVgW2IkPT1Twx78TC4uznpr2h2FamVi/f+EYN4YM8CV5uLipMaNq9oGU5XO/U78se6ImjcveCpf6dxsNB98sF1vTm2nJk2q2e2rGeghHx83/fHHUdu29PRsbdlyXC0uUWdBdu9O0yOP/qLu3YL06KNNi3Qsyq9iv3ox3Q8AAI6jcuXKeuCBB/T000/Lx8dHNWrU0PPPP2+XwGjYsKHuvfdeDRw4UFOmTFHLli119OhRxcfHq0WLFurevXu+eseMGaMePXooKChI/fr1k5OTkzZs2KDNmzdr/PjxkqSBAweqZs2amjRpUqFibdCggW6//XYNHTpUM2bMUJUqVTRy5EjVrFlTt99+e4HH1K9fX9nZ2XrrrbfUs2dPrVq1StOnTy/yfXrxxRf18MMPq0aNGoqMjNSpU6e0atUqDR8+vMDyBXXbdXV1LfJ5i+v+gS01+vkf1KSpn5o189PHHyXqzJkc3d77XBLphVHLVKNGJT3+33Zyc6ug+g3su0flTa17/vZl3+9UtWoVFRBQRTt3pui1V1aqc5e6uqnddbZj+vRtqimv/SIvLzdVqnRuKt8Wwf62pMzPK/7WsZTTahEcIFc3Z635bb8+eP8PDYxqdTVuiykGDrpRz49aoqbN/NW8eYDmfbhOZ85kq3ef5pKk50Z+oxo1qujJmI6SpP53t9T/PlmvVyb+qHvuC9X+fSf03szVuvfeUElSpUpuatDAfureihVdVLWqu217enqmHnpwvs6czdErr/ZQRnqmMtLPfVNfzdtDzs5OWvnzbh07lqFmzQPk4eGq3btSNGXycrVsVVM1axb92/byJiMjS/v3/zuA6MF/TmrbtiR5eVVUYCD371LuuaeBxo1bpxtuqKamTavpf5/u0pkzuerZ49zfkrFj16l6DXdFP9ZMkjR37g7NmLlN41++UQEBHkpJOTeOiIdHBXl4VJDFYtGAu+tr1qztql27kmoGVtL06Vvl6+uujh3/nc00Kem0UtOylJR0WlaroR1/nZQk1a5VWR4eFbRrd6oeffRXtWlTQ/fc08B2Hmdni6pVKxvDMNByxBzFTo6sW7dOnTt3tq3nDYYaFRWlOXPmqH///jp69KjGjBmjpKQkhYSEXJPT/QAA4CgmT56s9PR09ezZU1WqVNFTTz2l1NRUuzKzZ8+2DUp68OBB+fr6qk2bNurRo0eBdXbt2lXffPONXnrpJb366qtycXFR48aN9eCDD9rK7N+/v8itSGbPnq0nnnhCPXr0UFZWljp06KBvv/32ojPVBAcHKzY2Vq+++qpGjRqlDh06aNKkSRo4cGCRzhsVFaWzZ8/qjTfe0IgRI+Tr66t+/foVqY6rqWtkQ504cUbvvr1GKSkZatS4ut6Zfrute8vhw6dkcSram+iUoxma8tovOnbstKpXr6QevRrbjR8iSSOebS+Lk/TUk98qKztXN910nZ4b3cm2v0IFJ83/dKNef+0XGYZUO8hLI55ur779mpX4mh3VbZE36Pjx05r21q9KSclQ48Y1NH3GXfL9/241hw+n2T0L/wBPTX/vLk1+JV539J6lGn5VdN99rTXkwfCLnSKfbVuTtXHjuZmJut02027f0h8eVs2aXnJ3r6AvPt+gya/+pKysXPn7V9EttzbUAw+2KahKXGDL5kMaNPBD2/qrk5ZJknr3CdbEVwpO1uKc/9xaSydPZGrGzK06duxc15c3p7azdY9JSj4ty3kvDV98uUfZ2VY9O/J3u3qGPthYw4adS/gOHNhQZ87mauLEP5Wenq3gYB+9ObWd3bgk02ds1ZIl+23r993307nt77ZXaGh1/RR/UCdOZOq77w7ou+/+bQEXEOChrxbfdsXvQ2kgOWIOi3G5OXvKqLS0NHl5eSk1NVWenp5mh+PQ6oxcYnYIDmHvK/m/MXUUGRkZtvEA0tPTHXoqX36eznHknyeULbyeOZ6EhAQ1abHG7DAgaevGNmoessHsMMq9TYnBCgkt/IyUKD2JCY3VoP7nZocBSZ5ehWtNWZA/I0qWxGn549ISHV9eXXudQgEAAAAAKKOuydYLZQDJEQAAAAAAHAXdakxRKrPVAAAAAAAAlBW0HCmBw4cP6/DhwyWuJyAgQAEB+afkAwAAAACUL3SrMcc1nxxpNvZ7Obl5lErdJ3/9WKmr/lfierzaDVDVm++9AhEVjIEhAQAAAKBsYLYac1zzyZHSVDkkUhXrFzwdm5GdpeRPnpEk+d3zmiwurhetx7myd6nEBwAAAAAALo/kSAlUqOytChdJbFizztr+7+pXV06u7lcrLAAAAABAGUXLEXOQHAEAAAAAwEEYIjliBmarAQAAAAAA5RotRwAAAAAAcBB0qzEHLUcAAAAAAEC5RssRAAAAAAAchGGYHUH5RHIEAAAAAAAHQbcac9CtBgAAAAAAlGu0HAEAAAAAwEEwla85SI4AAAAAAOAg6FZjDrrVAAAAAACAco2WIwAAAAAAOAhajpiD5AgAAAAAAA6CmXzNQbcaAAAAAABQrtFyBAAAAAAAB0G3GnOQHAEKqc7IJaad25p11vb/G0YvlZOru2mx7H2lu2nnBgAAAK51dKsxB91qAAAAAABAuUbLEQAAAAAAHAXdakxBcgQAAAAAAAdBtxpz0K0GAAAAAACUa7QcAQCUW4cPH9bhw4dLXE9AQIACAgKuQEQAAKC8s9KtxhQkRwAA5daMGTM0bty4EtczduxYvfjiiyUPCAAAAKYgOQIAKLceeugh9erVq8B9Z86c0c033yxJ+vXXX1WxYsWL1kOrEQAAcKUYtBwxBckRAEC5danuMBkZGbb/h4SEqFKlSlcrLAAAUI4ZIjliBgZkBQAAAAAA5RotRwAAAAAAcBAGc/maguQIAAAAAAAOgm415qBbDQAAAAAAKNcctuXIgQMHdP/99+vIkSOqUKGCRo8erTvvvNPssACgTDh8+LAOHz5c4nouNWApAAAArjxmqzGHwyZHKlSooLi4OIWEhCgpKUmhoaHq1q0bswUAQCHMmDFD48aNK3E9Y8eO1YsvvljygAAAAFAojDliDodNjpz/baW/v798fX11/PhxkiMAUAgPPfSQevXqVeC+M2fO6Oabb5Yk/frrr6pYseJF66HVCAAAAMqDYidHVq5cqcmTJyshIUGHDx/WwoUL1bt3b7sy06ZN0+TJk5WUlKTg4GC99dZbCgsLK/K5EhISlJubq9q1axc3XAAoVy7VHSYjI8P2/5CQEJLOAAAADsTKgKymKHZyJCMjQ8HBwRoyZIj69u2bb//8+fMVExOj6dOnKzw8XHFxceratat27NihGjVqSDr3pjwnJyffscuWLVNgYKAk6fjx4xo4cKDee++94oYKAAAAAECZwJgj5ih2ciQyMlKRkZEX3R8bG6uhQ4dq8ODBkqTp06dryZIlmjVrlkaOHClJSkxMvOQ5MjMz1bt3b40cOVI33XRTcUMFAAAAAAC4qFKZyjcrK0sJCQmKiIj490ROToqIiNDq1asLVYdhGBo0aJC6dOmi+++//7LlMzMzlZaWZrcAAAAAAABcTqkkR1JSUpSbmys/Pz+77X5+fkpKSipUHatWrdL8+fO1aNEihYSEKCQkRJs2bbpo+UmTJsnLy8u2MD4JAAAAAKCsMUq4oHgcdraam2++WVartdDlR40apZiYGNt6WloaCRIAAAAAAHBZpZIc8fX1lbOzs5KTk+22Jycny9/fvzROKTc3N7m5uZVK3QAAAAAAXA0MyGqOUkmOuLq6KjQ0VPHx8bbpfa1Wq+Lj4xUdHV0apwQAALhqtm5sY3YI+H+bEoPNDgGSEhMamx0C/t/OXf3MDgGSQkOLfyxdY8xR7ORIenq6du3aZVvfs2ePEhMT5e3traCgIMXExCgqKkqtW7dWWFiY4uLilJGRYZu9BgAAoKwKCd1udgjQuQ/kPAvz8RwcB8/CkZQgOwJTFDs5sm7dOnXu3Nm2njfeR1RUlObMmaP+/fvr6NGjGjNmjJKSkhQSEqKlS5fmG6QVAAAAAACcQ7cacxQ7OdKpUycZxqUb/ERHR9ONBgAAAAAAODSHna0GAAAAAIDyxhAtR8xAcgQATFBn5BLTzm3NOmv7/w2jl8rJ1d20WPa+0t20cwMAADgiKyOymsLJ7AAAAAAAAADMRMsRAAAAAAAcBN1qzEFyBAAAAAAAB8FsNeagWw0AAAAAACjXaDkCAHBYDFwrWTNPm3JeAABgDoMBWU1BcgQAAAAAAAfBmCPmoFsNAAAAAAAo12g5AgAAAACAg7DSrcYUtBwBAAAAAMBBGLKUaHFEb7zxhpo2baomTZro8ccfl+GAA6uQHAEAAAAAAKXi6NGjevvtt5WQkKBNmzYpISFBa9asMTusfOhWAwAAAAAASk1OTo7Onj03E2B2drZq1KhhckT50XIEAAAAAAAHYRglW4pq5cqV6tmzpwIDA2WxWLRo0aJ8ZaZNm6Y6derI3d1d4eHhWrt2baHrr169ukaMGKGgoCAFBgYqIiJC9erVK3qgpYzkCAAAAAAA5VRGRoaCg4M1bdq0AvfPnz9fMTExGjt2rNavX6/g4GB17dpVR44csZUJCQlRs2bN8i2HDh3SiRMn9M0332jv3r06ePCgfvvtN61cufJqXV6h0a0GAAAAAAAHUdJBVTMzM5WZmWm3zc3NTW5ubgWWj4yMVGRk5EXri42N1dChQzV48GBJ0vTp07VkyRLNmjVLI0eOlCQlJiZe9PgFCxaofv368vb2liR1795da9asUYcOHYpyWaWOliMAAAAAAFwjJk2aJC8vL7tl0qRJxaorKytLCQkJioiIsG1zcnJSRESEVq9eXag6ateurd9++01nz55Vbm6uVqxYoUaNGhUrntJEyxEAAAAAABxESSe5HTVqlGJiYuy2XazVyOWkpKQoNzdXfn5+dtv9/Py0ffv2QtXRpk0bdevWTS1btpSTk5NuueUW9erVq1jxlCaSIwAAAAAAOAjDKFm3mkt1oTHLhAkTNGHCBLPDuCS61QAAAAAAgHx8fX3l7Oys5ORku+3Jycny9/c3KarSQXIEAAAAAAAHYZRwuZJcXV0VGhqq+Ph42zar1ar4+Hi1bdv2Cp/NXHSrAQAAAADAQVhL2K2mqNLT07Vr1y7b+p49e5SYmChvb28FBQUpJiZGUVFRat26tcLCwhQXF6eMjAzb7DXXCpIjAAAAAACUU+vWrVPnzp1t63mDuUZFRWnOnDnq37+/jh49qjFjxigpKUkhISFaunRpvkFayzqSIwAAAAAAOIgr3TXmcjp16iTDuPRZo6OjFR0dfZUiMgfJEQAAAAAAHERJZ6tB8ZAcAYBrUE76ceWmHy9wn5GdZft/VvLfsri4XrQe58reqlDZ+4rHBwAAADgSkiMAcA1KT/xOqav+d9lyyZ88c8n9Xu0GqOrN916psAAAAHAZV7tbDc4hOQIA16DKIZGqWD+8xPU402oEAADgqrras9XgHJIjAHANqkB3GAAAAKDQSI4AAAAAAOAg6FZjDpIjAAAAAAA4CGarMYeT2QEAAAAAAACYiZYjAAAAAAA4CLrVmIOWIwAAAAAAoFyj5QgAAAAAAA7CStMRUzhsy5GTJ0+qdevWCgkJUbNmzfTee++ZHRIAAAAAAKXMUsIFxeGwLUeqVKmilStXysPDQxkZGWrWrJn69u0rHx8fs0MDAAAAAADXEIdNjjg7O8vDw0OSlJmZKcMwZBi0LwIAAAAAXLv41GuOYnerWblypXr27KnAwEBZLBYtWrQoX5lp06apTp06cnd3V3h4uNauXVukc5w8eVLBwcGqVauWnn76afn6+hY3XAAAAAAAHJ5RwgXFU+zkSEZGhoKDgzVt2rQC98+fP18xMTEaO3as1q9fr+DgYHXt2lVHjhyxlckbT+TC5dChQ5KkqlWrasOGDdqzZ48++eQTJScnFzdcAABwhXXq1ElPPvlkocrOmTNHVatWLdV4AAAAiqvY3WoiIyMVGRl50f2xsbEaOnSoBg8eLEmaPn26lixZolmzZmnkyJGSpMTExEKdy8/PT8HBwfrll1/Ur1+/AstkZmYqMzPTtp6WllbIKwEAALj2rftjn2Z98Ju2bD6so0fT9ea0uxQR0djssMq0Tz7+Q7M++E0pR9PVqLGfnh8dqRYtahZYNjs7V+/N+FWLF21UcnKarr/eVzEjblH7DvVtZSK6TNWhg6n5jh1wT2uNHttNkrR//3FNfvUHrU84oKysHN3cvr6eH32bfH0rl85FXuP4vXAcPIt/GQaDqpqhVGarycrKUkJCgiIiIv49kZOTIiIitHr16kLVkZycrFOnTkmSUlNTtXLlSjVq1Oii5SdNmiQvLy/bUrt27ZJdBAAAwDXk9OksNWrkZ/uQjZL57tstenXSMj36WEd9vnCYGjf217AHPtaxYxkFln8zbrk+m79ez42+TV9/+6j63x2qx6M/09ath21lPvv8Qf38a4xteX/2fZKkrrc1kXTuGQ4d8rEsFotmz71fH/9vsLKzc/XYw5/KytyfxcLvhePgWfyLbjXmKJXkSEpKinJzc+Xn52e33c/PT0lJSYWqY9++fWrfvr2Cg4PVvn17DR8+XM2bN79o+VGjRik1NdW2HDhwoETXAAAA/pWRkaGBAweqcuXKCggI0JQpU+z2Z2ZmasSIEapZs6YqVaqk8PBwrVix4pJ1Ll68WK1atZK7u7vq1q2rcePGKScn56Ll//jjD916663y9fWVl5eXOnbsqPXr19uVsVgsev/999WnTx95eHioQYMG+uqrr+zKbNmyRT169JCnp6eqVKmi9u3ba/fu3UW7IWVQh44N9MR/uyji1vL5TeyVNmf2at15Vyv1vSNE9etX19hx3eXu7qIvv/izwPJfLd6oYQ/frI4dG6h27Wq6+57W6tCxvubMWmMr4+1dSdWrV7YtPy/fqdpB1XRj2HWSpD/XH9DBgyc18ZXb1bCRnxo28tOkV2/X5s2HtGbNnqty3dcafi8cB88CZiuV5MiVEBYWpsTERG3YsEEbN27UQw89dMnybm5u8vT0tFsAAMCV8fTTT+vnn3/W4sWLtWzZMq1YscIuMREdHa3Vq1fr008/1caNG3XnnXfqtttu086dOwus75dfftHAgQP1xBNPaOvWrZoxY4bmzJmjCRMmXDSGU6dOKSoqSr/++qvWrFmjBg0aqFu3braWpnnGjRunu+66Sxs3blS3bt1077336vjx45KkgwcPqkOHDnJzc9NPP/2khIQEDRky5JJJGeBCWVm52rrlsNrcdL1tm5OTRW1vul6Jf/5T8DHZuXJzte/R7ubmovXr91/0HF9/tVF97wiRxWL5/205slgkV1fn8+qoICcni9YnFFwPgLLHMEq2oHhKZSpfX19fOTs75xtANTk5Wf7+/qVxSgAAUErS09P1wQcf6KOPPtItt9wiSZo7d65q1aolSdq/f79mz56t/fv3KzAwUJI0YsQILV26VLNnz9bEiRPz1Tlu3DiNHDlSUVFRkqS6devq5Zdf1jPPPKOxY8cWGEeXLl3s1mfOnKmqVavq559/Vo8ePWzbBw0apAEDBkiSJk6cqDfffFNr167VbbfdpmnTpsnLy0uffvqpXFxcJEkNGzYsye1BOXTyxGnl5hry9alkt93Hp5L+/julwGNuvrme5sxZo9AbgxQU5K01q//Wjz9sU25uwZ9k4n/crlOnzqpPnxDbtuCQWqpY0VVTJsfryZguMgxDsVPilZtr6OjR9Ct2fQDMZRVjjpihVJIjrq6uCg0NVXx8vHr37i1Jslqtio+PV3R0dGmcEgAAlJLdu3crKytL4eHhtm3e3t62scA2bdqk3NzcfEmGzMxM+fj4FFjnhg0btGrVKruWIrm5uTp79qxOnz4tDw+PfMckJyfrhRde0IoVK3TkyBHl5ubq9OnT2r/f/hvzFi1a2P5fqVIleXp62mbLS0xMVPv27W2Jkcu5cMB36dzYakBRjXq+q8a88I16RL4ji0WqXdtbffqG6MsvEgss/+UXf6p9h/qq4VfFts3bu5LemNpPL734rT6a97ucnCzq1r2ZmjQNkJOFD1MAUBLFTo6kp6dr165dtvU9e/YoMTFR3t7eCgoKUkxMjKKiotS6dWuFhYUpLi5OGRkZttlrAADAtSE9PV3Ozs5KSEiQs7Oz3b7KlQueQSM9PV3jxo1T37598+1zd3cv8JioqCgdO3ZMU6dO1XXXXSc3Nze1bds2X7LiwsSHxWKR1WqVJFWsWLHQ1yWdG/B93LhxdtuGDh2qsLYdi1QPri1Vq3nI2dmilAsGXz12LOOis8Z4e1fS2+/0V2Zmjk6ePK0aNaoo9vV41apdLV/ZgwdPavVvezT1rbvy7Wt3cz19/+NwnTh+Ws4VnOTp6a727aYoslvTK3NxAExHzxhzFDs5sm7dOnXu3Nm2HhMTI+ncG5c5c+aof//+Onr0qMaMGaOkpCSFhIRo6dKl+QZpBQAAjq1evXpycXHR77//rqCgIEnSiRMn9Ndff6ljx45q2bKlcnNzdeTIEbVv375QdbZq1Uo7duxQ/fr1L1/4/61atUrvvPOOunU7N5PBgQMHlJJScBeGi2nRooXmzp2r7OzsQrUeGTVqlO09Tp4tW7ZI+rtI58W1xdXVWU2aBmjN6j22qUatVkNrVu/RPffdeMlj3dwqyM/PU9nZuVq2bJtui2ySr8zCLxPl7VNJHTs1uGg91bzPta5as3qPjh/LUJcudA8DrhWMG2KOYidHOnXqJOMyTy06OppuNAAAlHGVK1fWAw88oKefflo+Pj6qUaOGnn/+eTk5nRvXvWHDhrr33ns1cOBATZkyRS1bttTRo0cVHx+vFi1aqHv37vnqHDNmjHr06KGgoCD169dPTk5O2rBhgzZv3qzx48dLkgYOHKiaNWtq0qRJkqQGDRpo3rx5at26tdLS0vT0008XuSVIdHS03nrrLd19990aNWqUvLy8tGbNGoWFhdm6CZ3Pzc1Nbm5udttcXV2LdE5HkZGRpf37j9vWD/5zUtu2JcnLq6ICA71MjKxsGjS4rUY9u0jNmgWqeYtAfTj3d505k60+fUMkSSOfWaQaflUU89S5cXo2bPhHR5JPqfEN/kpOTtO0t36WYTX0wIPt7Oq1Wg0t/HKDevduoQoV8s+d8OUXiapXz1fVvD2U+Oc/mjTxew0c1EbX1/Ut9Wu+FvF74Th4FjBbqYw5AgAAri2TJ09Wenq6evbsqSpVquipp55Samqqbf/s2bM1fvx4PfXUUzp48KB8fX3Vpk0bu4FSz9e1a1d98803eumll/Tqq6/KxcVFjRs31oMPPmgrs3//flsCRpI++OADDRs2TK1atVLt2rU1ceJEjRgxokjX4ePjo59++klPP/20OnbsKGdnZ4WEhKhdu3aXP7iM27L5kAYN/NC2/uqkZZKk3n2CNfGV280Kq8yK7NZUx49n6K03VyjlaLoa3+CnGe/fY+tWc/hwqpyc/h0HJCszR1PjluufAyfk4eGqDh0b6NXX+sjT074b2erf/tbhQ6nqe0fLAs+7d0+K3oiNV2rqGdWsWVUPPXyzoga1Kb0Lvcbxe+E4eBb/MhiQ1RQW43LNP8qotLQ0eXl5qfaTn8nJLf+gbqXNmnVWB97oJ0mq/d/P5eRacP/pq2HvK/m/sTtfnZFLrlIkjs2R7xM/T2UP96lwHPk+OcrvnTXztA7E3aXU1FSmqXcQCQkJCgndbnYYkJSY0Jhn4QB4Do6DZ+E4nHVvsY99vf5jJTr3iF3TSnR8eUXLEQAAAAAAHMS12XzB8ZEcAQAAAADAQVjNDqCcyj/KEwAAAAAAQDlCyxEAAAAAAByEYTAgqxlIjgAAAAAA4CAYcsQcdKsBAAAAAADlGskRAAAAAABQrtGtBgAAAAAAB0G3GnPQcgQAAAAAAJRrtBwBAAAAAMBBGDQdMQXJEQAAAAAAHIRVTOVrBrrVAAAAAACAco2WIwAAAAAAOAi61ZiD5AgAAAAAAA6C3Ig56FYDAAAAAADKNVqOAAAAAADgIOhWYw6SIwAAAAAAOAhyI+agWw0AAAAAACjXaDkCAAAAAICDsMpidgjlEi1HAAAAAABAuUbLEQAAAAAAHAQDspqD5AgAAAAAAA6C3Ig56FYDAAAAAADKNVqOAAAAAADgIOhWYw6SIwAAAAAAOAhyI+agWw0AAAAAACjXaDkCAAAAAICDoOWIOUiOAAAAAADgIBhzxBx0qwEAAAAAAOUaLUcAAAAAAHAQhixmh1AukRwBAAAAAMBB0KvGHHSrAQAAAAAA5RotRwAAAAAAcBAMyGoOkiMAAAAAADgIciPmoFsNAAAAAAAo12g5AgAAAACAg7DSdMQUtBwBAAAAAADlGi1HAAAAAABwEDQcMQfJkRLIST+u3PTjBe4zsrNs/89K/lsWF9eL1uNc2VsVKntf8fgAAAAAAGXLtThbTZ8+fbRixQrdcsst+vzzz+32ffPNN3rqqadktVr17LPP6sEHHzQlRpIjJZCe+J1SV/3vsuWSP3nmkvu92g1Q1ZvvvVJhAQAAAADgMJ544gkNGTJEc+fOtduek5OjmJgYLV++XF5eXgoNDVWfPn3k4+Nz1WN02OTItGnTNHnyZCUlJSk4OFhvvfWWwsLCzA7LTuWQSFWsH17iepxpNQIAAAAA0LXZraZTp05asWJFvu1r165V06ZNVbNmTUlSZGSkli1bpgEDBlzlCB10QNb58+crJiZGY8eO1fr16xUcHKyuXbvqyJEjZodmp0Jlb7n51y/xQpcaAAAAAIB0braakixFtXLlSvXs2VOBgYGyWCxatGhRvjLTpk1TnTp15O7urvDwcK1du7bkFyrp0KFDtsSIJNWsWVMHDx68InUXlUMmR2JjYzV06FANHjxYTZo00fTp0+Xh4aFZs2aZHRoAAAAAANeMjIwMBQcHa9q0aQXuL0zjhZCQEDVr1izfcujQoat1GSXmcN1qsrKylJCQoFGjRtm2OTk5KSIiQqtXr77ocZmZmcrMzLStp6amSpKsmadLL9gyIi0t7ZL7uUfnmH2fcjJOKDf9RIH7jJx/B/g9+89WWSpcaoDfaqpQqdoVjy+P2feprOA+FY7Z96ks/N7l3QPjWhydDQAA5FPSV/wLPxtLkpubm9zc3AosHxkZqcjIyIvWd37jBUmaPn26lixZolmzZmnkyJGSpMTExGLFGhgYaNdS5ODBg+YNp2E4mIMHDxqSjN9++81u+9NPP22EhYVd9LixY8caOvdzxMLCwsLCcs0tBw4cKO2XYJQTZ8+eNcaOHWucPXvW7FDKPZ6F4+BZOA6eRckV9Nl47NixhTpWkrFw4ULbemZmpuHs7Gy3zTAMY+DAgUavXr2KFNfy5cuNO+64w25bdna2Ub9+feOff/4xTp06ZTRs2NBISUkpUr1XisUwHOurqLw+R7/99pvatm1r2/7MM8/o559/1u+//17gcRdmx6xWq44fPy4fHx9ZLJZSj7sgaWlpql27tg4cOCBPT09TYigLuE+Fw30qHO5T4XCfCscR7pNhGDp16pQCAwPl5OSQvWFRxqSlpcnLy0upqan8/puMZ+E4eBaOg2dRckVtOXI+i8WihQsXqnfv3pKK//n8QhEREdqwYYMyMjLk7e2tBQsW2Or76quvNGLECFmtVj3zzDMaNmxYIa/0ynK4bjW+vr5ydnZWcnKy3fbk5GT5+/tf9LiCHnbVqlVLI8Qi8/T05Be7ELhPhcN9KhzuU+FwnwrH7Pvk5eVl2rkBAEDZUthEyNX0448/XnRfr1691KtXr6sYTcEc7isoV1dXhYaGKj4+3rbNarUqPj7eLlMFAAAAAABKT3EbL5RFDpcckaSYmBi99957mjt3rrZt26ZHHnlEGRkZtgFgAAAAAABA6SpPjRccrluNJPXv319Hjx7VmDFjlJSUpJCQEC1dulR+fn5mh1Ykbm5uGjt2rMM1aXI03KfC4T4VDvepcLhPhcN9wrWIn2vHwbNwHDwLx8GzuPrS09O1a9cu2/qePXuUmJgob29vBQUFKSYmRlFRUWrdurXCwsIUFxd3TTZecLgBWQEAAAAAwNWxYsUKde7cOd/2qKgozZkzR5L09ttva/LkybbGC2+++abCw8OvcqSli+QIAAAAAAAo1xxyzBEAAAAAAICrheQIAAAAAAAo10iOAAAAAACAco3kyBX0zz//6OGHH1b9+vXl7u4uPz8//ec//9GmTZvMDs3hce9wJYwcOVI9evQwOwwAAAAAZQzJkStk7969atmypY4dO6Z58+Zp+/bt+vzzz9WkSROmoboM7h2ulMTERAUHB5sdBsqopKQkWSwWTZ06VS1btpS7u7uaNm2qX3/91ezQAIeWN7Z/dna2yZEAAFB8JEeukLfeekuVKlXS/Pnz1bZtW9WpU0ft27dXXFycGjZsaHZ4Do17d3lr165Vp06dVLFiRTVu3Fjr1q3TzJkz1atXL7NDcyiJiYlq0aKF2WE4vPfff18tWrRQxYoV5eXlpS5dupgdkkNITEyUJM2aNUtxcXFKTExUUFCQ7r33XlmtVnODAxyUYRiyWCxauXKlpk+frj179pgd0jXtwkkmmXTS8eU9o7Vr1+rLL780ORoAl0Jy5Ao5ceKEzp49q/3795sdSpnDvbu0NWvWqGPHjurevbs2btyoG264QS+99JJeffVVjRs3zuzwHEZSUpKSk5OVm5urDh06yMPDQzfeeCNdsy7w5Zdf6plnntHo0aO1Y8cO/fbbb3rqqafMDsshbNiwQS4uLlq8eLE6duyoxo0ba/z48dq/f78OHjyoJUuWKDo62uwwAYdisVj0xRdfqFu3bjp58qROnTpldkjXrLxE1E8//aQJEyZIOnf/4bjyntkXX3yh3r17a/ny5dqxY4fZYV2z8hJRa9as0fLly5WRkWFyRChrSI5cIdHR0XJzc1PdunV14403auTIkdq6dattP2+qL+5y964gERER2rlz51WK0FwxMTG688479fTTT6tBgwYaMGCAlixZouDgYLVs2dLs8BxG3rf+cXFxmjRpktatW6fKlStrwIAB5gbmYHbs2KHrrrtOt956q4KCgtS0aVN1797d7LAcQmJiovr27as6derYtnl6etr+v3HjRoWEhFz9wAAHlpiYqOjoaL3xxhsaPXo0rfdKUd6H7H79+mnfvn36888/zQ4Jl2GxWLRq1SoNHjxYL730kmJjY9WoUSOzw7omnZ+I6tGjh5YuXarjx4+bHRbKGJIjV0irVq30999/a/ny5frPf/6jL7/8UsHBwfr6668llb831SNHjpTFYrnksn37dkmXv3cF2blzp+rVq3e1Lsc0//zzj1avXq2HH37Ytq1ChQoyDINWIxdITEyUu7u7Fi1apHbt2qlJkyaaMGGCtmzZopSUFLPDcxhDhw6VYRjy9vZW5cqVaQJ/nsTExHx/p1evXi1fX1/VrFlTGzdu1Pbt2xUaGqomTZrY/oYB5dnmzZtVs2ZN3XnnnbZtdPUoHRs2bNAjjzyiV199VTNnzuQLEgeX93uwcuVKde3aVQ8++KCcnZ0lSbm5uWaGdk3KS0Q98MADmjJlikaPHq3atWubHRbKGJIjV5Czs7M6duxo+0BWo0YNffLJJ5JU7t5UP/XUU9q2bdsll7p169rKX+reSdKWLVsUHh6uFi1aaMKECfL395eT07X/47tt2zZJ5xJIeXbs2KGwsDA1b97crLAcUmJiou666y4FBgbatlWrVk2SGC/i/2VnZ+vuu+/WTTfdpD/++EOJiYl2rSTKszNnzmjnzp12b1itVqvi4uIUFRUlJycnbdy4UbVr11ZCQoKefPJJvf766yZGDJgr7+9qUlKSzpw5Y2tlZbVabV09Vq9eTQL2Cvrrr7/UqFEjDRgwwHb/L/yQTWLKceT9Hhw4cEAHDx6UJDk5OckwDFuSZMOGDabFdy367bff1K5dOw0YMEAVK1aUxHtAFM21/+nSJFarVZmZmapevboklbs31dWrV1fjxo0vubi6uhZ47IX3LjMzU/3799f777+vjRs36o8//ig3zXZTU1Pl7Oxse4E9fvy4Xn/9dXl4eJgcmeMp6Fv/NWvWqGbNmqpRo4Y5QTmYhQsXateuXXrnnXcUGhqq+vXr01/9/23atEkWi0UfffSRVq9erW3btql///46efKkXnjhBWVmZur06dMaPny4JCkkJIQWSSjX8r6gaN26tbZt26ZPP/3Ubntubq4WLFign376iQ8nV0hycrL++usvZWdn5/uQnTerFn/THU+tWrV07Ngxbdu2zZY8NAxDp0+f1tSpU/Xtt9+aHeI1IzExUadOnZKrq6ucnZ1ltVptf5N2796t06dPmxwhHB3JkSvg/vvv16RJk/T7779r7969+umnn2x9+J988kneVF/C5e6dJC1atEgdO3a0tZS44YYbyk1yJCQkRLm5uXrttde0fft2DRgwQHXq1NHWrVu1b98+s8NzGKdPny7wW/+pU6dq0KBB5gXmYLKysnT48GHNmzdPe/fu1ebNmzVjxgzl5OSYHZrpEhMT1bhxYz333HO644471Lp1a+Xm5urnn39W1apVtXXrVt1www22N1nr168vN3+HAOnfFgkbNmzQokWLtH79ep06dUqdOnXS8OHDNWTIEH344Yc6deqUkpKSNGbMGH344Yfq2LFjuWjpeTXUq1dPHh4eWrJkiU6fPm37kC1JU6dO1RtvvGFyhOVb3rPYvXu3du/erb///lvSufez2dnZevjhh7VlyxZlZWUpOztbEydO1IoVK9S0aVMzw76mdO3aVfv379ePP/4o6Vyy1mq16vjx45oyZQrj9ODyDJRYbGyscdNNNxm+vr6Gu7u70aBBA+Oxxx4zDhw4YBiGYaxfv96IjIy0lX/33XeN0aNHmxWuQ7ncvTMMw3j++eeNmTNn2tZvvfVWY8WKFWaEa4qXXnrJ8PHxMdzd3Y1BgwYZKSkpRqtWrYzGjRubHZrDWL16teHi4mI0adLEWLt2rbF9+3bjjjvuMBo2bGikpaWZHZ7DyM7ONmJiYoxatWoZLi4uhp+fn3HPPfeYHZZDePTRR40BAwZcdP+cOXOMhg0bGllZWUZycrIRGhpqHDly5CpGCJhvwYIFho+PjxEYGGg0aNDAePjhh41jx44Zp0+fNp577jnDycnJqFevntG0aVMjKCjIWL9+vdkhl0lWq9UwDMP4888/jfj4eCM+Pt62r2/fvkbt2rWN2bNnGwcPHjSSk5ON5557zggICDB27NhhVsj4f59//rkRGBho1KlTx2jSpIkxe/ZswzAMY//+/UaDBg2MRo0aGTfccINx6623Gj4+PvyOFFPe78i+ffuMjRs3GmfPnjUMwzA2b95sdOjQwejXr5/x/fffG4ZhGGlpacbYsWONWrVqGX///bdpMaNssBgGnRNL29y5czVx4kRt3rxZJ06cULdu3fTdd9/Zuo3g0mJjY7Vv3z5NnTpVy5Yt02233aZjx47ZxpMApk+frrfffltjxoxRTEyMTp48qZ49e+rtt9+Wj4+P2eGhDGjXrp169uypkSNHFrg/b7rj+Ph45ebmKjY2VrfeeuvVDBEwhfH/M0AcOnRIw4YN0x133KHbbrtNH3/8sRYtWqSaNWvqnXfekY+Pj9auXavdu3erYsWKCg0NZTDEEvjiiy80ePBg1ahRQ4cOHVJUVJTeffddSeda3a5bt04HDhzQDTfcoKSkJH311VcM0GqSvN+R5ORkhYWFafTo0fLx8dFvv/2m2NhYvfPOO3rooYeUmZmpjz76SAcOHJCvr68iIyPLxeQCpeWLL75QdHS0XFxcZLFYNG3aNPXo0UMrVqzQ5MmTtWHDBvn4+Khy5cr666+/tGzZMn5HcFkkR64C3lSXzJEjRxQZGSmr1apmzZrp119/ZYA3AFeMYRjy8vLSp59+qm7dupkdDuBwEhISNHXqVJ0+fVozZsywJZ3ff/99zZ49WzVr1tRbb70lPz8/kyMt2/I+ZKenpysiIkKPPvqowsPDtWnTJg0ZMkQ9e/bUxx9/LOlc176//vpLVatWVbNmzVSrVi2Toy/ffvrpJ61fv15JSUm2cQVPnDihuLg4vfzyy5o2bZoeeeQRk6Ms+/J+R3bs2KFevXrpkUce0U033aQ33nhD8fHxmjx5sqKiorR3715t3bpVP/zwgxo3bqyIiAgSUSgUkiMAAAAokGEYeumllzRnzhwZhqHt27fL3d3dtv+DDz7QRx99JFdXV3300Ue0ii2hZcuWaeHChcrJydGrr74qb29vSdIPP/ygfv36qWfPnvroo49MjhLnO3PmjJ566ilNnz5dnTp10k8//WTbd+LECU2dOlUTJ07UlClTbOMPovhWrVqlv/76S5s2bVJsbKxt+4MPPqivv/5akydP1h133KFKlSqZGCXKKkbIAgAAQIEsFotGjRqlRx99VJL0+OOPKy0tzbb/gQceUL9+/eTs7KysrCyzwrxm/PPPP5o5c6aWLl2qChUqSDqXoLr11lv1+eefa+nSperbty9T9jqAvGdQsWJFPf7443riiSe0YsUKLV682FamWrVqevLJJ/XEE09ozJgxOnnyJM+uhF588UU98MADWr9+vc6cOWPb/v7776tnz556/vnn9fHHHysjI8PEKFFW0XIEAAAAkv5ttn769Gm5u7srJydHrq6uyszM1GuvvabvvvtOrVu31qRJk+y+mU1NTZWXl5eJkZddefdckjIyMrR48WINGTJETzzxhF599VW7st9++60eeeQRrV69WoGBgWaEW+7lPa/zn5sk7dq1S5MnT9ann36qefPmqVevXrZ9J0+eVE5Ojnx9fc0I+Zpw/v2+9957tXDhQn322Wfq2rWrXFxcbOX69++vDRs26Pfff+dvEoqM5AgAAABsHz6+++47zZkzR3///bciIiLUo0cPtWvXTpmZmXr11Vf13XffqU2bNnr55ZdVuXJls8Mus/Lu95kzZ+Tq6ipnZ2dJ57ppfPrppxo2bJieeeYZTZgwwe6406dPy8PDw4yQy728Z/bzzz/rs88+k9VqVb169TRixAhJ5xIkU6ZM0f/+9z99/PHH6t69u8kRl23nJ0SsVqvdtOC33XabNm7cqDlz5qhLly62llaSdPjwYQUEBFz1eFH20a0GAAAAslgsWrx4se644w41bNhQvXv31ubNmzV8+HDFx8fLzc1Nzz77rHr06KGlS5dq/PjxdBEoprwPfd9//7369++v2267TXfddZfOnDmjihUr6v7779eMGTP02muvacyYMXbHkhgxj8Vi0cKFC9W7d2+lpqbKyclJr732mh566CFJUv369fXUU0/pvvvuU8+ePbV06VKTIy678n5HfvrpJ40YMUL9+vXTwoULlZSUJElaunSpmjdvrkGDBmnFihXKycmxHUtiBMVFcgQAAADasmWLnn/+eb355pt6+eWX9cgjj+j3339Xenq6nnjiCVuC5KmnntKQIUP08MMP23UrQOHlJaLuvPNONWjQQHfffbc2btyoW2+9Vdu2bVOFChU0cOBAvffeexo/fvz/tXfnYVXW+f/HnwdZZHFJEU3MbUwLc0EwlzQIzMQcxw23shQRl1TcQtPR1FIUtRRjUccFNWMkFdILN3LSzEhtSk2LtAkXJDJFYzkhB873D3+c0V/N4lTeAq/HX1z3ubmu1zmXR6/75efz/vD6668bHVmAzz77jKlTpxIZGcnmzZttJ1KuWbOG4OBg4FZBMmHCBCZPnkyTJk2MjFuumUwmkpOT6devH5cuXaJWrVq8+OKLrFixgtOnTwOwd+9evL29efbZZ/nwww8NTiwVgbbViIiIiAgZGRksXryY6Ohorl27RmBgIN26dWPQoEGMHj0aJycnFi9eTFBQkNFRy72MjAyCg4MJCwtj/PjxZGdn07FjR3Jzc3nwwQdJTk7m0UcfxWKx8Ne//pV27drx6KOPGh270nv33Xf5+OOPWbZsGRcvXsTPz49u3brRo0cPBg0aREhICKtWrQKguLj4jlkYcnc+/fRT+vfvz+zZsxk5ciQAbm5uODk5MXjwYCZOnEiLFi0A6N+/P5GRkTRv3tzIyFIBqBwREREREQBycnKoW7cuISEhFBUVsXbtWqpWrUrfvn356KOPaN68OXv27MHV1VWrRn6FY8eOsXPnTubOnUt2djZ+fn4EBgYya9YsnnrqKTw9PYmJiaFVq1ZGR5XbFBcXc+LECby9venduzfu7u4kJCRw9epVunTpQkZGBkOHDtVxy7+S1Wpl3759HDp0iAULFnD+/Hn8/Pzo27cvbdq0ISQkhMmTJzNs2DDatm1rdFypQOz/8y0iIiIiUhnUrVuXn376iZMnT9KvXz/biTXu7u7MmTOHQYMGaQjrb6B9+/ZUq1YNOzs7XnnlFXx9fYmOjsbe3p4WLVqwZ88eRowYwZEjR3B0dDQ6rnDrgd3BwQFfX19ycnLIzs5m0qRJADg5OdG5c2ciIyN57LHHjA1aAZhMJtq0aUPDhg0pLi5mwoQJBAYGsmjRIpycnIiKiuKtt97C0dERLy8vHBwcVNbKb0LliIiIitMM+wAAFxBJREFUiIjYmEwmWrRowYEDB3j00UdJT0/n/fffZ+7cudSpU8foeOVGSUmJ7QSa25UNmnzkkUe4efMmmZmZBAcH4+TkBEDTpk05dOgQjRo1UjFyH7n94dve3p7z58+za9cuvL29Wbp0KUePHmXRokX6jvxG6tWrR7169bh69SpZWVkMHjwYJycn8vLy6Ny5M6GhofTu3VvfEflNqRwRERERqURuPx7z9p/LODk5MWjQIOLi4hg/fjw1atTg3XffxdPT04i45VJUVBRffPEFq1evpmrVqne8dvvn7ejoSElJCYmJibRs2ZKUlBS2bdvGjBkzaNCgwb2OLf8Fq9VK7dq1WbZsGePGjeO9997jp59+IjU1VcXI7+DatWtcuXKFzMxMPv/8c3bs2EF6ejpvvvkm1apVMzqeVDCaOSIiIiJSCZQVIWXHxf5SMXL7tStXrlBQUICrq6se+u5ScnIyAwYMYMyYMSxduvRnBQlAaWkpdnZ2nDlzhoEDB1JYWIiDgwOJiYl4e3sbkFp+6Tvxr14rLS0lMzOTf/zjH3h5eVG/fv17FbNC+XefeZmlS5cyb948PDw8MJvN7Nq1i3bt2t2jhFKZqBwRERERqeDKHkB2795NbGwsBQUF1KhRgwULFuDl5fWL98rdy8zMxNPTEwcHB3bv3k2/fv0YPnw4b7755h0Fyf+/5aa0tJRz587h7u5OrVq1jIhe6ZX9uT9w4AC7du3iwoULdO/encDAQP7whz/ccY/8emWfZWFhIS4uLhQVFeHk5GT7bpSVh2WOHDmCnZ0dDRo00Koq+d3Y/edbRERERKQ8M5lM7Nq1iz59+uDl5UX79u3Jy8ujY8eObN++Hbj1sFJ2r9y9d955hxYtWvDBBx9gsVgICgpi27ZtbNiwgcmTJ/PTTz/Z7i0rRnbv3k1WVhZ2dnY0b95cxYiBTCYTO3bs4Nlnn+XixYsAREREMGPGDA4cOGC7R369smJkz549hISEEBAQwMiRI/n888+pUqUKVqvVVowcPnwYgM6dO9OxY0cVI/K7UjkiIiIiUsEVFhby5ptvMmXKFBYvXszixYtJS0vjueeeY/jw4Zw9exaTyYQWFP/vhgwZQpcuXRg5ciQffPABxcXF9OzZ818WJH/729949tlnSUhIoKSkxMDkAnD58mXmzJnDkiVLSEpK4t1332XPnj1cvnyZ+Ph4W2Eiv57JZCIlJYW+ffvSsmVLBg0axI0bN2jXrh2XLl2ylVBr165l5MiRrF+/3uDEUlmoHBERERGp4EpLS/nuu+9o0qQJAMXFxQDExcXh7e3N/PnzAf3P+P/KYrEA8P777/PII4/wwgsvcPDgwX9bkDz11FNER0fTp0+fXzzVRu4te3t7CgsLeeihh4Bb35mOHTuybNkyUlNTOXTokMEJy7+y8vXHH38kOjqaBQsWMHv2bHr16sXJkycJDQ29Y2WIn58fPj4++Pv7G5RYKhuVIyIiIiIVnJubG56enuzYsQMABwcHW0HSvHlzCgsLjYxX7tnb//MAyH379uHl5fUvC5KXX36Z/Px8AMaPH/+zmS9y75Q9rFutVsxmM2azmR9++AG4VXiVFSSdOnWybe+Qu7N06VKio6OBf5avZrOZc+fO0bNnT3JycujQoQM9evRg9erVAGzZsoWsrCyaNWvGxo0bbaWuyO9N5YiIiIhIBVL2wHf9+nWuX79uux4WFkZOTg4RERHArYIE4ObNm7i6ulJcXKxtNb/C6dOnOXbsGABpaWm/WJDs2LGDmJgYXn31VX3WBir77G/f5tSoUSOGDx/OSy+9RHp6Oo6Ojra5F6WlpTz44IOGZC3PCgoKyMrKYvr06axZs8Z2vWbNmvj6+rJv3z4ef/xxevXqRUxMDHBre9Pu3bv55JNPsFqtWlUl95T9f75FRERERMoLk8lEcnIyb7zxBtnZ2QwdOpRhw4bRp08fzp49S2JiIkePHqV79+5kZGSwfft20tPTbWWJ3B2r1cqVK1fo168fPj4+TJ06FR8fH9LS0ujWrRsvvPACGzduxN/fnx49erB3714eeughbWEyyO3DQOPj43F2diYwMJBhw4YxZ84cMjMz8fPzY8mSJdSoUYPTp09z/PhxYmNjjY5e7ri6uvLyyy9TrVo1pk6dSmlpKaNHj8bJyYkHHniASZMm8ac//YmYmBhbCRIdHc3nn39OZGSkviNyz+koXxEREZEK5OjRowQFBTFmzBgAEhIS6Ny5M3/+85/x8vJi7969rF69mmvXruHh4cHcuXNp1aqVwanLj7y8PKpVq/az64mJiSxcuJD27dszduxYfH19AejWrRtnz54lLi6O7t2737EFR4xx+PBhAgICGD16NJ999hkWiwVvb29WrFiBnZ0dr7/+Ops3b8bZ2Znq1asTExND27ZtjY5dbmVnZxMTE0N0dDSLFy9m7NixwK25OxcvXmTIkCHUrVuXkydPsnXrVg4ePEibNm0MTi2VkcoRERERkQri22+/JSkpiZKSEl555RUADh48SHh4OA8//DAzZszAx8cHuLWdxmQyacXIXQgLC8NisRAfH4+joyNmsxlnZ2fb69u2bWP27Nl07tyZsWPH2j7r9u3bU1BQwPHjx3FxcTEqvgDnzp0jOTkZe3t7Jk2aRFFRETExMSQmJtK2bVtWrFiBs7MzWVlZ1KhRg9LSUqpXr2507HIvKyuL2NhYoqOjiYyMZPz48QCMGTOGr7/+mmvXruHl5cXMmTN57LHHDE4rlZWqaxEREZFyzmq1kpOTQ5cuXcjPz2f06NG21/z8/Fi+fDnh4eEsW7aM0NBQAgICcHR0NDBx+ZOYmEhycjL79u3D0dGRI0eOsHv3bkaMGEHTpk0B6N+/P1arlcmTJ1NUVMSUKVPw9vbm2LFjXLhwQcWIwTIyMggLCyMzM5MFCxYA4OTkxNixYzGZTCQmJhIeHs7y5cvx9PQ0OG35VbZ16cqVKxQUFFC3bl08PT2ZOXMmpaWltuJ2/PjxxMfHYzabsVqtODg4qKwVQ2kgq4iIiEg5ZzKZqFevHitXrsTV1ZXPPvuMM2fO2F739/cnOjqaw4cPs3nzZsxms4Fpy6eLFy9Su3Zt2rZty969ewkODiYuLo61a9dy/vx5230DBgxg+vTppKSkEBUVxaeffgpAw4YNjYou/4+Hhwfe3t4UFRWxZ88e23VnZ2fGjh3Lc889x8GDB5kxY4aBKcu3smIkOTmZ7t27ExgYyBNPPMH06dPJy8sjIiKC8PBwZs6cyapVq4Bbn7+Li4uKETGcVo6IiIiIlHNlDyT9+vXDZDIxYcIEYmJimDBhAo888ghwawXJli1bqF+//h1bQeS/4+/vz9q1awkICODgwYN88MEHfPnll8yfP982aLJx48bArYfwJk2acOnSJerXr29scAFunTjzwAMPMH/+fFxcXEhNTWXOnDnMmzcPk8lE1apVCQsLw8HBgaCgIKPjlkulpaXY2dmRlpbG888/z2uvvcaIESNYuHAhK1euxNfXl+DgYF566SXs7OwYO3YsTk5ODB8+3OjoIoDKEREREZFyIzY2ls6dO/9sOKTJZLIVJH379sVisTBlyhSsVivh4eG0aNECgC5duhiQumJo3749gYGBxMXF8fjjj9O1a1e6du2K2WxmyZIlAAwdOpRWrVpx8uRJxowZw9ChQ6lRo4bByQXAzs7ONj8kIiICi8XC3r17sVqtzJ8/31aQlA0Llf/Opk2byMvLY9y4cdjZ2XHz5k0SExMJCwtj8uTJfP/99yQlJTFixAiCg4MBqFu3LhMmTMDR0ZFOnToZ/A5E/kkDWUVERETKgeLiYnx9fcnNzSU1NfUXhxaWFSQASUlJRERE0LVrV2bPns3DDz98ryNXKGazmV69etG0aVOOHDlC69ateeeddwB46623iI+Pp6ioCA8PD06ePMnHH3+swZIGuv27cLuy1Q3Xr19n4cKFHDlyhA4dOrB06VIdHXuXCgoK6NOnDwUFBYSFhdlWgAwcOJABAwbw1FNP0bZtW3r16mXbQpOcnIybmxvdunWjpKTEdoSvyP1A5YiIiIjIfa7sVJT8/Hz69OnDN998w3vvvfezI3jLHvzKbNq0icWLF5OWlka9evXudewKp7CwEBcXF9atW0dUVBTe3t62gmT//v2cOXOGK1euMGzYMNtqHbm3/lMpcvvrubm5zJo1i7Nnz7Jlyxbq1Klzr+OWe9nZ2YSHh3PlyhWGDh3KqFGjGDVqFKdOneL7778nKCiIFStWYG9vT0FBAaGhobRp04aXX35ZxYjcd1SOiIiIiNzHFi5cSE5ODrNnz8bd3Z38/Hz++Mc/kpmZ+YsFCcD58+dp2LAhJpOJvLw8qlWrZkDyiis/P5+kpCRbQbJlyxajIwn/LEbS09M5dOgQFouFZs2aMXDgQODO8vCHH37A3d2d3NxciouL8fDwMDJ6uWO1WrFYLDg4OHDmzBmmTZvG9evXmTZtGt7e3gwcOJDs7GwuXbpk+51Zs2bx9ttvk5aWRrNmzQxML/LLdFqNiIiIyH3M3d2dlStXsnz5cq5evYqbmxs7d+6kcePG9O7dm1OnTt1x/6uvvkpQUJDtlBQ3NzcjYldobm5uDBw4kIiICE6dOkXv3r2NjiTcmr2zfft2evbsSXp6OqdOnSI0NJTJkycD2IqRJUuWEB4eTmZmJg888ICKkf+Rg4MDW7duZd68eVy/fp0TJ04wffp00tLSmDZtGiaTyVaU9O/fn/j4eHbs2KFiRO5bKkdERERE7mNhYWFs3LiRhQsXsmzZsv9YkIwcOZLS0lLc3d0BNEfhd+Lq6srAgQMZN24cOTk5XL582ehIlZLFYrH9/PXXXzNp0iRee+01tm/fzty5c7FarRQVFd3xOzdu3ODbb7/FycnpXsetMEwmE5988gkjRozgmWeeYf369Zw4cQJPT0/efvttfvzxRw4cOIC/vz8uLi60bt2a9PR0vL29jY4u8i9pW42IiIjIfer2bQAbNmwgJCSEGTNmMHXqVGrXrn3HFpudO3fSsmVLTCaTBh3eQ4WFhRQXF+tUmnssMTGRwYMHA7cKEnt7ew4dOkRERATp6emcP3+eLl260KtXL+Li4gA4fvw4vr6+AFy9epXatWsblr8iWL16NStWrOD48eO248EvXbrE4MGDycnJISoqir59+xqcUuS/p5UjIiIiIvcpOzs7srKyKC4uZvjw4axbt45Fixb9bAVJs2bNeOKJJ/jyyy9tvyf3houLi4qRe+zcuXNMmDCBwMBAAOzt7QFwdHSkSpUqHD58mCeffJKePXvy1ltvAfDpp58SGxtLRkYGgIqR34CzszMlJSXk5+cDt07UatCgAXFxcXz33XfMnj2bhIQE4NaMEpH7nf7lFBEREblP/f3vf6d///5s2rQJi8XyLwuS7du38+STT+Lo6AhoK41UbA0bNmTdunXk5OTQvXt32/Xq1atTWFhIUFAQAQEBrFq1yraC6u233yYrK0sn0vyGOnXqxPnz51m5ciVwawYJwM2bN/Hx8aF169YEBAQA+jtJygd7owOIiIiIyC9r0qQJLi4uJCQk4ODgwJAhQxg+fDgAISEhVKlShYkTJ1KnTh3ee+89PYBIpeDo6EiPHj2ws7Nj6tSpPP300+zfvx8vLy8mTpzIyJEj8fDw4OOPP6Z69eqsW7eO9evXc+jQIWrVqmV0/AqjWbNmrFmzhpCQEEpKShg1ahQ1a9YkJSWFxo0bEx0dTfXq1Y2OKfJf08wREREREYP9u+N2r1+/zvPPP09ubi5jxoxhyJAh2Nvbs3HjRoYPH868efOYNWuWttJIpVF2ZO/NmzfZt28fU6dOpUGDBrz//vsALF++nLVr13LhwgWaNGmCyWRi/fr1tG3b1tjgFZDVaiUxMZGwsDDq1KmDnZ0dubm57N+/n3bt2hkdT+SuqBwRERERMVBYWBglJSWsWrUKe3t7jh49yo8//ki3bt1s9+Tm5jJs2DCys7OZNm0awcHB2Nvbs2XLFtq2bYuXl5eB70Dk3igrRUpLS7l58yZVq1altLSUffv2MWHCBB566CEOHDgAwDfffMONGzdwdXWlTp06WjHyO8vMzOTkyZOYzWY6dOhA48aNjY4kctdUjoiIiIgYJDExkYkTJ7J37168vb0pLS2lY8eOmEwmIiMjbfv1AfLz8/Hx8aFmzZqEhoYyYsQI2yBKkYqurBjZs2cPSUlJtnk8Xbt2xc/Pj9TUVKZMmYKnp6dtBYmIyN3Q+ksRERERg1y8eJHatWvj7e1NSkoKCQkJJCcnA7Bw4cI7HvLc3NwICAjgq6++YufOnRQUFBiUWuTeM5lMpKSk0L9/fzw8PBgxYgSpqamMHz+es2fP8vTTT7Ns2TJycnJ4/PHHjY4rIuWQyhERERERg/j7+2O1WgkMDKRv3744OjpSv359kpKSyM3NJTIykrS0NNv91apV4y9/+QuxsbE6PlYqhdLSUgBycnJYvHgxixYtIjIykrCwMDIyMnjmmWd4+OGHcXBwoGfPnrz++usAXLhwwcjYIlIOaVuNiIiIiIFeeukl4uLi6NSpEx999JHt+oULFwgODsbJyYlGjRrh6urKO++8w+nTp2nQoIGBiUV+X5s2bSIvL49x48bZruXm5hIQEEBKSgoWi4Unn3ySnj17snr1agDS0tJo3bo1tWrVoqioCFdXV6Pii0g5pZUjIiIiIgYxm8189dVXjBw50nYqTZmGDRuSnJyMr68v33//Pd9++y0ffvihihGp0AoKCti4cSObN29mw4YNtus3btygqKiIY8eO0b17d3r06EF8fDwAX3/9NRs2bOCLL77A3t5exYiI/E+0ckRERETEQIWFhbi4uLBu3TqioqLw9fVl8+bNttctFgv29va2+0QquuzsbMLDw7ly5QrPPfccoaGhAEyaNIno6GgGDBjA1q1bbffPnDmT1NRUdu3apfJQRP5nKkdERERE7gP5+fkkJSURFRWFj4+PrSApLi7GwcHB4HQivz+r1YrFYsHBwYEzZ84wbdo08vLyCA0N5cUXX+SHH35g7Nix7Nmzh+joaMxmM19++SUJCQl8+OGHtGnTxui3ICLlmMoRERERkftEQUEBW7du5Y033qBp06akpKQYHUnknik7rnfr1q1s27aNixcvcuLECerXr8/s2bN54YUX+O6774iMjGT37t1Uq1aNRo0aMW/ePFq1amV0fBEp51SOiIiIiNxHymYubNiwgR07dlC/fn2jI4ncM5988gkBAQGsXLmSJ554gipVqjBq1CjMZjPjx4+3zeW5fPkyHh4eFBcX4+zsbHBqEakIVI6IiIiI3GcKCwspLi7Wcb1S6axevZoVK1Zw/PhxW+mRlZXF4MGDyc7O5tVXX2XYsGEGpxSRikin1YiIiIjcZ1xcXFSMSKXk7OxMSUkJ+fn5wK2ZO56ensTGxpKTk8PSpUvZuHGjwSlFpCJSOSIiIiIiIveFTp06cf78eVauXAlgG0Z88+ZNfHx8aNmyJf7+/gYmFJGKyt7oACIiIiIiIgDNmjVjzZo1hISEUFJSwqhRo6hZsyYpKSk0btyY6OhoqlevbnRMEamANHNERERERETuG1arlcTERMLCwqhTpw52dnbk5uayf/9+2rVrZ3Q8EamgVI6IiIiIiMh9JzMzk5MnT2I2m+nQoQONGzc2OpKIVGAqR0RERERERESkUtNAVhERERERERGp1FSOiIiIiIiIiEilpnJERERERERERCo1lSMiIiIiIiIiUqmpHBERERERERGRSk3liIiIiIiIiIhUaipHRERERERERKRSUzkiIiIiIiIiIpWayhERERERERERqdRUjoiIiIiIiIhIpaZyREREREREREQqNZUjIiIiIiIiIlKp/R8lS+NagRepuAAAAABJRU5ErkJggg=="" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""source"": [ + ""axs = plt.subplots(nrows=2, ncols=2, figsize=(11, 10))[1].flatten()\n"", + ""\n"", + ""inf.plot_sfs_comparison(ax=axs[0], sfs_types=['neutral', 'selected', 'modelled'])\n"", + ""inf.plot_discretized(ax=axs[1])\n"", + ""inf.plot_inferred_parameters(ax=axs[2])\n"", + ""inf.plot_nested_models(ax=axs[3]);"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-06-30T08:39:41.226546Z"", + ""start_time"": ""2023-06-30T08:39:40.518715Z"" + } + } + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 2 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython2"", + ""version"": ""2.7.6"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 0 +} +","Unknown" +"Allele","Sendrowski/fastDFE","docs/reference/Python/example_pendula_marginal.ipynb",".ipynb","30635","161","{ + ""cells"": [ + { + ""cell_type"": ""code"", + ""execution_count"": 7, + ""metadata"": { + ""collapsed"": true, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T14:20:36.945744Z"", + ""start_time"": ""2023-07-19T14:14:22.579061Z"" + } + }, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""Counting sites: 2439037it [00:43, 55635.67it/s]\n"", + ""\u001B[32mINFO:fastdfe.Parser: Using stratification: [neutral, selected].[A, C, G, T].\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Parser: Starting to parse.\u001B[0m\n"", + ""Processing sites: 100%|██████████| 2439037/2439037 [05:30<00:00, 7379.49it/s] \n"", + ""\u001B[32mINFO:fastdfe.PolyAllelicFiltration: Filtered out 0 sites.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.DegeneracyStratification: Number of sites with valid type: 980934 / 2438327\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.AncestralBaseStratification: Number of sites with valid type: 980934 / 981644\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Parser: Included 980934 out of 2439037 sites in total.\u001B[0m\n"" + ] + } + ], + ""source"": [ + ""import matplotlib.pyplot as plt\n"", + ""import fastdfe as fd\n"", + ""\n"", + ""# instantiate parser\n"", + ""p = fd.Parser(\n"", + "" n=10,\n"", + "" vcf=\""../../resources/genome/betula/all.vcf.gz\"",\n"", + "" stratifications=[fd.DegeneracyStratification(), fd.AncestralBaseStratification()]\n"", + "")\n"", + ""\n"", + ""# parse SFS\n"", + ""s: fd.Spectra = p.parse()\n"", + ""\n"", + ""# extract neutral and selected SFS\n"", + ""neut = s['neutral.*'].merge_groups(1)\n"", + ""sel = s['selected.*'].merge_groups(1)"" + ] + }, + { + ""cell_type"": ""code"", + ""execution_count"": 8, + ""outputs"": [ + { + ""name"": ""stderr"", + ""output_type"": ""stream"", + ""text"": [ + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.S_d': -100000.0, 'all.b': 0.01, 'all.p_b': 0, 'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 10 iterations and 78 function evaluations, obtaining a log-likelihood of -31.429538741494866.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -100000.0, 'all.b': 0.09250725380768925, 'all.p_b': 0.0, 'all.S_b': 0.00010003368718414257, 'all.eps': 0.007131399121042546}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.p_b': 0, 'all.S_b': 0.0001}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 48 iterations and 420 function evaluations, obtaining a log-likelihood of -31.781333903397154.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -4680.964377262656, 'all.b': 0.18103245458802353, 'all.p_b': 0.0, 'all.S_b': 0.0016690592847306126, 'all.eps': 0.008521268228204374}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {'all.S_d': -0.01, 'all.b': 10} and lower bound for {'all.S_b': 0.0001, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 70 iterations and 552 function evaluations, obtaining a log-likelihood of -39.34106087079692.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -165.01922058474526, 'all.b': 10.0, 'all.p_b': 0.23938807176874125, 'all.S_b': 0.18076469877510834, 'all.eps': 0.0}.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.Discretization: Precomputing linear DFE-SFS transformation using midpoint integration.\u001B[0m\n"", + ""\u001B[33mWARNING:fastdfe.Optimization: The MLE estimate is within 1% of the upper bound for {} and lower bound for {'all.S_d': -100000.0, 'all.S_b': 0.0001, 'all.eps': 0}, but this might be nothing to worry about.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Successfully finished optimization after 53 iterations and 360 function evaluations, obtaining a log-likelihood of -39.58658201020549.\u001B[0m\n"", + ""\u001B[32mINFO:fastdfe.BaseInference: Inferred parameters: {'all.S_d': -100000.0, 'all.b': 0.15428868835376694, 'all.p_b': 0.17278049460737993, 'all.S_b': 0.0001, 'all.eps': 0.0}.\u001B[0m\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:01<00:00, 87.26it/s]\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:00<00:00, 131.56it/s]\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:01<00:00, 96.94it/s]\n"", + ""Bootstrapping: 100%|██████████| 100/100 [00:01<00:00, 74.68it/s]\n"", + ""\u001B[33mWARNING:fastdfe.BaseInference: 1 out of 100 bootstrap samples did not terminate normally during numerical optimization. The confidence intervals might thus be unreliable. Consider adjusting the optimization parameters (increasing `gtol` or `n_runs`) or decrease the number of optimized parameters.\u001B[0m\n"" + ] + }, + { + ""data"": { + ""text/plain"": ""[ S_d b p_b S_b eps alpha\n 0 -99999.999995 0.107708 0.070929 0.0001 0.006586 0.217027\n 1 -100000.000000 0.109729 0.078056 0.0001 0.006550 0.238850\n 2 -100000.000000 0.106905 0.075633 0.0001 0.009989 0.226993\n 3 -100000.000000 0.092369 0.000000 0.0001 0.007258 0.000000\n 4 -100000.000000 0.092633 0.000000 0.0001 0.007840 0.000000\n .. ... ... ... ... ... ...\n 95 -100000.000000 0.092453 0.000000 0.0001 0.006751 0.000000\n 96 -99999.999995 0.096245 0.018803 0.0001 0.007973 0.058274\n 97 -100000.000000 0.092126 0.000000 0.0001 0.006828 0.000000\n 98 -100000.000000 0.092910 0.000000 0.0001 0.007155 0.000000\n 99 -100000.000000 0.092115 0.000000 0.0001 0.007363 0.000000\n \n [100 rows x 6 columns],\n S_d b p_b S_b eps alpha\n 0 -4680.964377 0.181213 0.000000 0.001669 0.008718 0.000000\n 1 -4680.964381 0.184826 0.007134 0.000100 0.008475 0.036644\n 2 -4680.964377 0.180935 0.000000 0.001669 0.008442 0.000000\n 3 -4680.964377 0.180756 0.000000 0.001669 0.008772 0.000000\n 4 -4680.964377 0.181145 0.000000 0.001669 0.008300 0.000000\n .. ... ... ... ... ... ...\n 95 -4680.964367 0.190641 0.020606 0.001592 0.006240 0.114330\n 96 -4680.964377 0.181881 0.000000 0.001669 0.007890 0.000000\n 97 -4680.964377 0.180451 0.000000 0.001668 0.008380 0.000000\n 98 -4680.964377 0.181728 0.000000 0.001669 0.008656 0.000000\n 99 -4680.964377 0.180317 0.000000 0.001668 0.008479 0.000000\n \n [100 rows x 6 columns],\n S_d b p_b S_b eps alpha\n 0 -165.021299 9.999100 0.242666 0.000100 0.00469 0.904842\n 1 -165.018806 10.000000 0.237185 0.209108 0.00000 0.999957\n 2 -165.019141 9.999925 0.238228 0.354965 0.00000 0.999976\n 3 -165.019021 9.999747 0.241067 0.127548 0.00000 0.999926\n 4 -165.019238 10.000000 0.239614 0.174623 0.00000 0.999948\n .. ... ... ... ... ... ...\n 95 -165.018849 9.999458 0.240645 0.139773 0.00000 0.999933\n 96 -165.019967 10.000000 0.236135 0.290712 0.00000 0.999970\n 97 -165.017626 9.997525 0.245683 0.039552 0.00000 0.999752\n 98 -165.018603 10.000000 0.236898 0.223611 0.00000 0.999960\n 99 -165.019358 9.999935 0.241033 0.163738 0.00000 0.999944\n \n [100 rows x 6 columns],\n S_d b p_b S_b eps alpha\n 0 -100000.000000 0.165492 0.191358 0.0001 0.0 0.598316\n 1 -99999.999998 0.181340 0.213989 0.0001 0.0 0.660550\n 2 -99999.999998 0.152756 0.170284 0.0001 0.0 0.536507\n 3 -99999.999998 0.152751 0.170241 0.0001 0.0 0.536429\n 4 -100000.000000 0.154141 0.173122 0.0001 0.0 0.544419\n .. ... ... ... ... ... ...\n 95 -99999.999998 0.151335 0.176511 0.0001 0.0 0.542307\n 96 -99999.999999 0.170290 0.198358 0.0001 0.0 0.618442\n 97 -99999.999999 0.131814 0.125572 0.0001 0.0 0.400518\n 98 -99999.999999 0.159440 0.180728 0.0001 0.0 0.569011\n 99 -100000.000000 0.146955 0.159420 0.0001 0.0 0.503854\n \n [100 rows x 6 columns]]"" + }, + ""execution_count"": 8, + ""metadata"": {}, + ""output_type"": ""execute_result"" + } + ], + ""source"": [ + ""# create inference objects\n"", + ""inferences = [fd.BaseInference(sfs_neut=neut[t], sfs_sel=sel[t]) for t in neut.types]\n"", + ""\n"", + ""# run inferences\n"", + ""[i.run() for i in inferences]\n"", + ""\n"", + ""# bootstrap inferences\n"", + ""[i.bootstrap() for i in inferences]"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T14:20:45.210689Z"", + ""start_time"": ""2023-07-19T14:20:36.947846Z"" + } + } + }, + { + ""cell_type"": ""code"", + ""execution_count"": 9, + ""outputs"": [ + { + ""data"": { + ""text/plain"": """" + }, + ""execution_count"": 9, + ""metadata"": {}, + ""output_type"": ""execute_result"" + }, + { + ""data"": { + ""text/plain"": ""
"", + ""image/png"": ""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"" + }, + ""metadata"": {}, + ""output_type"": ""display_data"" + } + ], + ""source"": [ + ""fd.Inference.plot_inferred_parameters(inferences, labels=neut.types)"" + ], + ""metadata"": { + ""collapsed"": false, + ""ExecuteTime"": { + ""end_time"": ""2023-07-19T14:20:45.486776Z"", + ""start_time"": ""2023-07-19T14:20:45.203382Z"" + } + } + } + ], + ""metadata"": { + ""kernelspec"": { + ""display_name"": ""Python 3"", + ""language"": ""python"", + ""name"": ""python3"" + }, + ""language_info"": { + ""codemirror_mode"": { + ""name"": ""ipython"", + ""version"": 2 + }, + ""file_extension"": "".py"", + ""mimetype"": ""text/x-python"", + ""name"": ""python"", + ""nbconvert_exporter"": ""python"", + ""pygments_lexer"": ""ipython2"", + ""version"": ""2.7.6"" + } + }, + ""nbformat"": 4, + ""nbformat_minor"": 0 +} +","Unknown" +"Allele","Sendrowski/fastDFE","tests/testthat.R",".R","39","2","library(testthat) +test_check(""fastdfe"")","R" +"Allele","Sendrowski/fastDFE","tests/testthat/test_plot_base_inference.R",".R","828","37","library(fastdfe) + +if (fastdfe_is_installed()) { + + # load python package + fd <- load_fastdfe() + + # import classes + Spectrum <- fd$Spectrum + BaseInference <- fd$BaseInference + + sfs_neut <- Spectrum(c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652)) + sfs_sel <- Spectrum(c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794)) + + Spectrum$plot(sfs_neut) + + # configure inference + inf <- BaseInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel + ) + + # Run inference + BaseInference$run(inf) + + BaseInference$plot_likelihoods(inf) + BaseInference$plot_inferred_parameters(inf) + BaseInference$plot_discretized(inf) + + BaseInference$bootstrap(inf, n_samples = 10) + + BaseInference$plot_inferred_parameters(inf) + BaseInference$plot_discretized(inf) + + BaseInference$plot_nested_models(inf) +} +","R" +"Allele","Sendrowski/fastDFE","tests/testthat/test_plot_joint_inference.R",".R","1049","44","library(fastdfe) + +if (fastdfe_is_installed()) { + + # load python package + fd <- load_fastdfe() + + # import classes + JointInference <- fd$JointInference + Spectrum <- fd$Spectrum + Spectra <- fd$Spectra + + # neutral SFS for two types + sfs_neut <- Spectra(list( + pendula=c(177130, 997, 441, 228, 156, 117, 114, 83, 105, 109, 652), + pubescens=c(172528, 3612, 1359, 790, 584, 427, 325, 234, 166, 76, 31) + )) + + # selected SFS for two types + sfs_sel <- Spectra(list( + pendula=c(797939, 1329, 499, 265, 162, 104, 117, 90, 94, 119, 794), + pubescens=c(791106, 5326, 1741, 1005, 756, 546, 416, 294, 177, 104, 41) + )) + + # configure inference + inf <- JointInference( + sfs_neut=sfs_neut, + sfs_sel=sfs_sel + ) + + # Run inference + JointInference$run(inf) + + JointInference$plot_likelihoods(inf) + JointInference$plot_inferred_parameters(inf) + JointInference$plot_discretized(inf) + + JointInference$bootstrap(inf, n_samples = 10) + + JointInference$plot_inferred_parameters(inf) + JointInference$plot_discretized(inf) +} + +","R" +"Allele","nhansen/Shimmer","check_statmod.R",".R","100","3","is.installed <- function(mypkg) is.element(mypkg, installed.packages()[,1]) +is.installed(""statmod"") +","R" +"Allele","nhansen/Shimmer","sim_scripts/simulation_performance.py",".py","6610","215","# calculates sensitivity and specificity from counts of TPs, FPs, FNs + +class mutation: + fields = [] + def __init__(self): + self.properties={} + for field in mutation.fields: + self.properties[field]=[] + +def getFields(vsfile, prog, cutoff): + import os,sys,re + + file_by_chr = {} #dictionary of chromosomes + + v = open(vsfile) + fields = v.readline().rstrip('\n').split(""\t"") + mutation.fields=fields + chr_ind = fields.index(""Chr"") + var_ind=fields.index('var_allele') + ref_ind=fields.index('ref_allele') + pos_ind=fields.index('LeftFlank') + + last_chr = """" + last_pos = 0 + + for line in v: + li = line.split(""\t"") + if li[var_ind].upper()!=li[ref_ind].upper(): + if prog == ""varscan"": + p_index=fields.index('p_value') + pvalue = float(li[p_index]) + if prog == ""shimmer"": + q_index=fields.index('q_value') + qvalue = float(li[q_index]) + if prog == ""somaticsniper"": + ss_index=fields.index('Somatic_Score') + ssvalue = float(li[ss_index]) + if prog == ""jsnvmix"": + ps_index=fields.index('p_somatic_genotype') + psvalue = float(li[ps_index]) + cutoff = float(cutoff) + if prog == ""varscan"" and pvalue > cutoff: + continue + + if prog == ""shimmer"" and qvalue > cutoff: + continue + + if prog == ""somaticsniper"" and ssvalue < cutoff: + continue + + if prog == ""jsnvmix"" and psvalue < cutoff: + continue + + new_mut = mutation() + + #get the field properties of mutation from the vsfile fields + for i,field in enumerate(li): + new_mut.properties[fields[i]] = field + + #mutation is added to the chromosome to which it belongs + # check to be sure this isn't a dup: + if li[chr_ind] == last_chr and li[pos_ind]==last_pos: + continue + + if li[chr_ind] in file_by_chr: + file_by_chr[li[chr_ind]].append(new_mut) + else: + file_by_chr[li[chr_ind]]=[new_mut] + + last_chr = li[chr_ind] + last_pos = li[pos_ind] + return file_by_chr + +# parse out the mutations -- only care about SNPs, not indels +def parse_mutations(cosmic): + import os,sys,re + mutations = {} #dictionary {chr: {pos:mut}} + + f = open(cosmic) + for line in f: + li = line.strip('\n').split('\t') + chr,start,end,type,strand=li[0],int(li[1]),int(li[2]),li[3],li[4] + + # convert all to forward strand + mut='' + if re.match('\w>\w',type): #if SNP + if strand=='-': + for i,char in enumerate(type): + if char=='C': + mut+='G' + elif char=='G': + mut+='C' + elif char=='T': + mut+='A' + elif char=='A': + mut+='T' + else: + mut+=type[i] + else: + mut=type + + # add to dict of mutations + if chr in mutations: + mutations[chr][start]=mut + else: + mutations[chr]={start:mut} + + return mutations + +def simulation_performance(cosmic,subdir,prog,cutoff,fh): + import os,re,sys,glob,subprocess + truemuts = parse_mutations(cosmic) + + vsfile = '/cluster/ifs/projects/seqSim/shimmerpaper/newsims/'+prog+'/'+subdir+'/' + if prog == ""shimmer"": + vsfile = vsfile + 'somatic_diffs.ANN.vs' + if prog == ""varscan"": + possfiles = glob.glob(vsfile+'*'+'.ann.vs') + if len(possfiles) > 1: + print 'More than one file in varscan directory!' + vsfile = possfiles[0] + if prog == ""somaticsniper"": + possfiles = glob.glob(vsfile+'*'+'.finalfilter.dbSNP.filtered') + if len(possfiles) > 1: + print 'More than one file in somaticsniper directory!' + vsfile = possfiles[0] + if prog == ""deepsnv"": + vsfile = vsfile + 'deepSNV.final.out' + execstring = '/cluster/ifs/projects/seqSim/shimmerpaper/newsimplots/compare_deepSNV_to_truth.pl '+vsfile+' '+cosmic+' '+str(cutoff)+'\n' + output = os.popen(execstring).read() + #print output + fh.write(output) + if prog == ""jsnvmix"": + possfiles = glob.glob(vsfile+'*'+'.dbSNP.filtered') + if len(possfiles) > 1: + print 'More than one file in jsnvmix directory!' + vsfile = possfiles[0] + + if prog != ""deepsnv"": + vsmuts = getFields(vsfile, prog, cutoff) + else: + vsmuts = {} + + totalmuts=0 + for chr in truemuts.iterkeys(): + totalmuts+=len(truemuts[chr]) + + #print 'Total muts '+str(totalmuts)+' detected\n' + fpcount=0 + tpcount=0 + fncount=0 + + for chr in vsmuts.iterkeys(): + for mut in vsmuts[chr]: + pos = int(mut.properties['LeftFlank'])+1 + if (chr in truemuts) and (pos in truemuts[chr]): + assert mut.properties['var_allele']==truemuts[chr][pos][2],'detected variant allele incorrect' + tpcount+=1 + else: + fpcount+=1 + print prog + '\t' + chr + '\t' + str(pos) + '\t' + mut.properties['var_allele'] + + fncount=totalmuts-tpcount + + if prog != ""deepsnv"": + fh.write(str(cutoff) + ' ' + str(tpcount) + ' ' + str(fpcount) + ' ' + str(fncount) + '\n') + + sensitivity = 0 + specificity = 0 + if tpcount+fncount: + sensitivity = float(tpcount)/float(tpcount+fncount) + if tpcount+fpcount: + specificity = float(tpcount)/float(tpcount+fpcount) + + print prog + ':' + str(cutoff) + ':sens='+`sensitivity`+',spec='+`specificity` + +if __name__ == ""__main__"": + import os,sys + + outdir = sys.argv[3] + + # shimmer: + if not os.path.exists(outdir): + os.makedirs(outdir) + + fh = open(outdir + '/shimmer_sens_spec.txt', 'w') + shim_cuts = [0.01, 0.05, 0.1, 0.2, 0.3, 0.5] + for cutoff in shim_cuts: + simulation_performance(sys.argv[1],sys.argv[2],'shimmer',cutoff,fh) + fh.closed + # varscan: + fh = open(outdir + '/varscan_sens_spec.txt', 'w') + vs_cuts = [0.01, 0.005, 0.002, 0.0005, 0.0002, 0.00005, 0.00002] + for cutoff in vs_cuts: + simulation_performance(sys.argv[1],sys.argv[2],'varscan',cutoff,fh) + fh.closed + # deepsnv: + fh = open(outdir + '/deepsnv_sens_spec.txt', 'w') + deepcuts = [0.1, 0.2, 0.9999] + for cutoff in deepcuts: + simulation_performance(sys.argv[1],sys.argv[2],'deepsnv',cutoff,fh) + fh.closed + # sniper: + fh = open(outdir + '/sniper_sens_spec.txt', 'w') + snipercuts = [40, 45, 50, 60, 70, 90, 110, 130] + for cutoff in snipercuts: + simulation_performance(sys.argv[1],sys.argv[2],'somaticsniper',cutoff,fh) + fh.closed + # jsnvmix: + fh = open(outdir + '/jsnvmix_sens_spec.txt', 'w') + jsnvmixcuts = [1.0] + for cutoff in jsnvmixcuts: + simulation_performance(sys.argv[1],sys.argv[2],'jsnvmix',cutoff,fh) + fh.closed +","Python" +"Allele","nhansen/Shimmer","sim_scripts/mutate.sh",".sh","79","4","#!/bin/bash + +python2.7 /home/meil/projects/python/mutate_sample.py $1 $2 $3 $4 +","Shell" +"Allele","nhansen/Shimmer","sim_scripts/plot_roccurves.R",".R","9716","201","current_2_datasets <- c(""set2_1"", ""set2_2"", ""set2_3"", ""set2_4"", ""set2_5"", ""set2_6"", ""set2_7"", ""set2_8"", ""set2_9"", ""set2_10"", ""set2_11"", ""set2_12"", ""set2_13"", ""set2_14"", ""set2_15"", ""set2_16"", ""set2_17"", ""set2_18"", ""set2_19"", ""set2_20"") +current_10_datasets <- c(""set10_1"", ""set10_2"", ""set10_3"", ""set10_4"", ""set10_5"", ""set10_6"", ""set10_7"", ""set10_8"", ""set10_9"", ""set10_10"") +jsnvmix_10_datasets <- c(""set10_3"", ""set10_4"", ""set10_5"", ""set10_7"", ""set10_8"", ""set10_9"") +jsnvmix_2_datasets <- c(""set2_1"", ""set2_2"", ""set2_5"", ""set2_13"", ""set2_10"", ""set2_4"", ""set2_8"", ""set2_9"", ""set2_11"", ""set2_12"", ""set2_16"", ""set2_14"", ""set2_15"", ""set2_17"", ""set2_18"", ""set2_19"") +plotdir <- function(outdir, purity) { + shimmer <- read.table(paste(outdir, ""/shimmer_sens_spec.txt"", sep=""""), header=FALSE, sep="" "") + sniper <- read.table(paste(outdir, ""/sniper_sens_spec.txt"", sep=""""), header=FALSE, sep="" "") + varscan <- read.table(paste(outdir, ""/varscan_sens_spec.txt"", sep=""""), header=FALSE, sep="" "") + deep <- read.table(paste(outdir, ""/deepsnv_sens_spec.txt"", sep=""""), header=FALSE, sep="" "") + shimmer_tp <- shimmer[,""V2""] + shimmer_fp <- shimmer[,""V3""] + shimmer_fn <- shimmer[,""V4""] + deep_tp <- deep[,""V2""] + deep_fp <- deep[,""V3""] + deep_fn <- deep[,""V4""] + varscan_tp <- varscan[,""V2""] + varscan_fp <- varscan[,""V3""] + varscan_fn <- varscan[,""V4""] + sniper_tp <- sniper[,""V2""] + sniper_fp <- sniper[,""V3""] + sniper_fn <- sniper[,""V4""] + alldata <- rbind(shimmer, varscan, sniper, deep) + minmax_x <- range(alldata[,""V3""]) + minmax_y <- range(alldata[,""V2""]/(alldata[,""V2""]+alldata[,""V4""])) + plot(shimmer_fp, shimmer_tp/(shimmer_tp+shimmer_fn), col=c(""red""), xlim=minmax_x, ylim=minmax_y, main=c(purity, "" Percent Tumor""), type=""o"", lty=1, pch=16) + points(deep_fp, deep_tp/(deep_tp+deep_fn), col=c(""darkblue""), type=""o"", lty=2, pch=16) + points(sniper_fp, sniper_tp/(sniper_tp+sniper_fn), col=c(""darkgreen""), type=""o"", lty=3, pch=16) + points(varscan_fp, varscan_tp/(varscan_tp+varscan_fn), col=c(""purple""), type=""o"", lty=4, pch=16) +} + +read_average_frame <- function(files) { + catpipe <- pipe(paste(""cat "", paste(files, collapse = ' '))) + df <- read.table(catpipe, header=FALSE, sep="" "") + avgtp <- tapply(df[,2], df[""V1""], mean) + avgfp <- tapply(df[,3], df[""V1""], mean) + avgfn <- tapply(df[,4], df[""V1""], mean) + avgdf <- t(rbind(avgtp, avgfp, avgfn)) + return(avgdf) +} + +read_error_frame <- function(files) { + catpipe <- pipe(paste(""cat "", paste(files, collapse = ' '))) + df <- read.table(catpipe, header=FALSE, sep="" "") + stderr <- function(x) sqrt(sd(x)/length(x)) + errtp <- tapply(df[,2], df[""V1""], stderr) + errfp <- tapply(df[,3], df[""V1""], stderr) + errfn <- tapply(df[,4], df[""V1""], stderr) + errdf <- t(rbind(errtp, errfp, errfn)) + return(errdf) +} + +multiplotdir <- function(outdirs, title='', titlesize=1, text='', textpos=c(0,0), legendpos=c(0,10.0), minmax_x=c(-1,-1), minmax_y=c(-1, -1), no_ylab=0, plotlabel='') { + shimfiles <- lapply(outdirs, function(x) paste(x, ""/shimmer_sens_spec.txt"", sep="""")) + avgshim <- read_average_frame(shimfiles) + shimmer_tp <- avgshim[,1] + shimmer_fp <- avgshim[,2] + shimmer_fn <- avgshim[,3] + deepfiles <- lapply(outdirs, function(x) paste(x, ""/deepsnv_sens_spec.txt"", sep="""")) + avgdeep <- read_average_frame(deepfiles) + deep_tp <- avgdeep[,1] + deep_fp <- avgdeep[,2] + deep_fn <- avgdeep[,3] + sniperfiles <- lapply(outdirs, function(x) paste(x, ""/sniper_sens_spec.txt"", sep="""")) + avgsniper <- read_average_frame(sniperfiles) + sniper_tp <- avgsniper[,1] + sniper_fp <- avgsniper[,2] + sniper_fn <- avgsniper[,3] + varscanfiles <- lapply(outdirs, function(x) paste(x, ""/varscan_sens_spec.txt"", sep="""")) + avgvarscan <- read_average_frame(varscanfiles) + varscan_tp <- avgvarscan[,1] + varscan_fp <- avgvarscan[,2] + varscan_fn <- avgvarscan[,3] + alldata <- rbind(avgshim, avgsniper, avgdeep, avgvarscan) + if (minmax_x[[1]] < 0) { + minmax_x <- range(alldata[,""avgfp""]) + } + if (minmax_y[[1]] < 0) { + minmax_y <- range(alldata[,""avgtp""]/(alldata[,""avgtp""]+alldata[,""avgfn""])) + } + names <- c(""Shimmer"", ""deepSNV"", ""SomaticSniper"", ""VarScan2"") + linetypes <- c(1,2,3,4) + pointtypes <- c(1,2,3,4) + pointcolors <- c(""black"", ""blue"", ""darkgreen"", ""darkred"") + if (no_ylab == 1) { + ylabel = c("""") + } + else { + ylabel = c(""Sensitivity"") + } + plot(shimmer_fp, shimmer_tp/(shimmer_tp+shimmer_fn), col=pointcolors[[1]], xlab=c(""False Positives""), ylab=ylabel, cex.lab=1.4, xlim=minmax_x, ylim=minmax_y, type=""o"", lty=linetypes[[1]], pch=pointtypes[[1]]) + title(main=title, cex.main=titlesize) + points(deep_fp, deep_tp/(deep_tp+deep_fn), col=pointcolors[2], type=""o"", lty=2, pch=2) + points(sniper_fp, sniper_tp/(sniper_tp+sniper_fn), col=pointcolors[3], type=""o"", lty=3, pch=3) + points(varscan_fp, varscan_tp/(varscan_tp+varscan_fn), col=pointcolors[4], type=""o"", lty=4, pch=4) + legend(x=legendpos[[1]], y=legendpos[[2]], names, lty=linetypes, pch=pointtypes, col=pointcolors, cex=1.2) + text_xpos <- minmax_x[[1]] + textpos[[1]]*(minmax_x[[2]] - minmax_x[[1]]) + text_ypos <- minmax_y[[1]] + textpos[[2]]*(minmax_y[[2]] - minmax_y[[1]]) + text(x=text_xpos, y=text_ypos, labels=text, cex=1.3) + par(xpd=T) + text(-0.15*(par(""usr"")[2]-par(""usr"")[1]),par(""usr"")[4]+0.08*(par(""usr"")[4]-par(""usr"")[3]),plotlabel,cex=1.3) + par(xpd=F) +} + +filelist <- function(set, purity) { + allfiles <- list.files(""/cluster/ifs/projects/seqSim/shimmerpaper/newsimplots"") + txtfiles <- allfiles[grep(glob2rx(paste(""set"",set,""_*"",purity, sep="""")), allfiles)] + return(txtfiles) +} + +simfilelist <- function(set, purity) { + allfiles <- list.files(""/cluster/ifs/projects/seqSim/shimmerpaper/newsimplots"") + txtfiles <- allfiles[grep(glob2rx(paste(""sim"",set,""_*"",purity, sep="""")), allfiles)] + return(txtfiles) +} + +allfilelist <- function(set, purity, extension='') { + allfiles <- list.files(""/cluster/ifs/projects/seqSim/shimmerpaper/newsimplots"") + globstring <- paste(set,""_"",extension,""*"", purity, sep="""") + txtfiles <- allfiles[grep(glob2rx(globstring), allfiles)] + return(txtfiles) +} + +mean_frame <- function(set, purity, prog, extension='') { + dirs <- unlist(lapply(set, function(x) allfilelist(x, purity, extension))) + topdir <- ""/cluster/ifs/projects/seqSim/shimmerpaper/newsimplots"" + progfiles <- lapply(dirs, function(x) paste(topdir,""/"",x, ""/"",prog,""_sens_spec.txt"", sep="""")) + meanframe <- read_average_frame(progfiles) + return(meanframe) +} + +error_frame <- function(set, purity, prog, extension='') { + dirs <- unlist(lapply(set, function(x) allfilelist(x, purity, extension))) + topdir <- ""/cluster/ifs/projects/seqSim/shimmerpaper/newsimplots"" + progfiles <- lapply(dirs, function(x) paste(topdir,""/"",x, ""/"",prog,""_sens_spec.txt"", sep="""")) + errorframe <- read_error_frame(progfiles) + return(errorframe) +} + +plotsets <- function(setnames) { + par(mfrow=c(1,3)) + files100 <- unlist(lapply(setnames, function(x) filelist(x, 100))) + multiplotdir(files100) + files60 <- unlist(lapply(setnames, function(x) filelist(x, 60))) + multiplotdir(files60) + files20 <- unlist(lapply(setnames, function(x) filelist(x, 20))) + multiplotdir(files20) +} + +errsens <- function(setnames, purity, prog, extension='') { + meandf <- mean_frame(setnames, purity, prog, extension) + errdf <- error_frame(setnames, purity, prog, extension) + senserr <- errdf[,""errtp""]/meandf[,""avgtp""] + (errdf[,""errtp""]+errdf[,""errfn""])/(meandf[,""avgtp""] + meandf[,""avgfn""]) + senserr <- senserr*meandf[,""avgtp""]/(meandf[,""avgtp""] + meandf[,""avgfn""]) + return(senserr) +} + +meansens <- function(setnames, purity, prog, extension='') { + meandf <- mean_frame(setnames, purity, prog, extension) + sensmean <- meandf[,""avgtp""]/(meandf[,""avgtp""] + meandf[,""avgfn""]) + return(sensmean) +} + +errfp <- function(setnames, purity, prog, extension='') { + errdf <- error_frame(setnames, purity, prog, extension) + fperr <- errdf[,""errfp""] + return(fperr) +} + +meanfp <- function(setnames, purity, prog, extension='') { + meandf <- mean_frame(setnames, purity, prog, extension) + fpmean <- meandf[,""avgfp""] + return(fpmean) +} + +plotsimsets <- function(setnames) { + par(mfrow=c(1,3)) + files100 <- unlist(lapply(setnames, function(x) simfilelist(x, 100))) + multiplotdir(files100) + files60 <- unlist(lapply(setnames, function(x) simfilelist(x, 60))) + multiplotdir(files60) + files20 <- unlist(lapply(setnames, function(x) simfilelist(x, 20))) + multiplotdir(files20) +} + +publicationplot <- function(set1names, set2names,extension='') { + par(mfrow=c(2,3)) + files1_100 <- unlist(lapply(set1names, function(x) allfilelist(x, 100, extension))) + multiplotdir(files1_100, text='100% purity', textpos=c(0.6, 0.15), minmax_y=c(0.725, 0.765), plotlabel=expression(bold('A'))) + files1_60 <- unlist(lapply(set1names, function(x) allfilelist(x, 60, extension))) + multiplotdir(files1_60, title='10 Mutations/Mb', titlesize=1.5, text='60% purity', textpos=c(0.6, 0.15), minmax_y=c(0.69,0.75), no_ylab=1, plotlabel=expression(bold('B'))) + files1_20 <- unlist(lapply(set1names, function(x) allfilelist(x, 20, extension))) + multiplotdir(files1_20, text='20% purity', textpos=c(0.6, 0.15), minmax_y=c(0.0, 0.6), no_ylab=1, plotlabel=expression(bold('C'))) + files2_100 <- unlist(lapply(set2names, function(x) allfilelist(x, 100, extension))) + multiplotdir(files2_100, text='100% purity', textpos=c(0.6, 0.15), minmax_y=c(0.725, 0.765), plotlabel=expression(bold('D'))) + files2_60 <- unlist(lapply(set2names, function(x) allfilelist(x, 60, extension))) + multiplotdir(files2_60, title='2 Mutations/Mb', titlesize=1.5, text='60% purity', textpos=c(0.6, 0.15), minmax_y=c(0.69, 0.75), no_ylab=1, plotlabel=expression(bold('E'))) + files2_20 <- unlist(lapply(set2names, function(x) allfilelist(x, 20, extension))) + multiplotdir(files2_20, text='20% purity', textpos=c(0.6, 0.15), legendpos=c(45, 0.5), minmax_y=c(0.0, 0.6), no_ylab=1, plotlabel=expression(bold('F'))) +} + +","R" +"Allele","nhansen/Shimmer","sim_scripts/mutate_sample.py",".py","6941","248","#takes as input the original bam file and a file of mutations in the cosmic format +#outputs a bam file that is the same as the original but with the mutations in the cosmic file + +def parse_mutations(cosmic): + import os,sys,re + mutations = {} #dictionary {chr: {pos:mut}} + + f = open(cosmic) + for line in f: + li = line.strip('\n').split('\t') + chr,start,end,type,strand=li[0],int(li[1]),int(li[2]),li[3],li[4] + + # convert all to forward strand + mut='' + if strand=='-': + #convert each base to its complement + for i,char in enumerate(type): + if char=='C': + mut+='G' + elif char=='G': + mut+='C' + elif char=='T': + mut+='A' + elif char=='A': + mut+='T' + else: + mut+=type[i] + if re.match('ins\w+',type): + mut=mut[0:3]+mut[len(mut):2:-1] #reverse the order of insertion sequence + else: + mut=type + + if chr in mutations: + mutations[chr][start]=mut + else: + mutations[chr]={start:mut} + + return mutations + +def create_mut(mutations,ar,percent): + import random,pysam,sys,re + tempq=ar.qual + nr=ar + seq = [] #list of tuples (pos, nuc) + cigar=[] #0=M,1=I,2=D,3=N,4=S,5=H,6=P,7==,8=X + mutseq = '' #mutated sequence + hardclips=[] + + readname = ar.qname + if ar.cigar is None: + return ar + + #expand cigar string out into a list (e.g. if alignedread.cigar()=[(1,1),(2,0)] then cigar=[1,0,0]) + for tup in ar.cigar: + cigar=cigar+[tup[0]]*tup[1] + + #remove hardclips at the start of a cigar string so that the sequence(which doesn't contain the hardclipped region) and cigar string match up + while cigar[0]==5: + cigar.remove(5) + hardclips.append(5) + + refcount=0 + pos=ar.pos+1 + for i,nuc in enumerate(ar.seq): + if cigar[i]!=1: + seq.append((pos+refcount,nuc)) + refcount+=1 + else: + seq.append((-100,nuc)) #if mutation is insertion, position is irrelevant b/c pos refers to reference + + loopseq = enumerate(seq) + for i,nuc in loopseq: + if nuc[0] in mutations: + if random.random()<=percent: #mutate with a given probability + mut=mutations[nuc[0]] + #print 'Mutating read '+readname+' with mutation '+mut + + if re.match('\w+>\w+',mut): #if it's a SNP + mutseq+=mut[2] #mutate the base + elif re.match('ins\w+',mut): #if it's an insertion + insertion=re.sub('ins','',mut) + mutseq+=nuc[1]+insertion #insert after current position + for j in range(0,len(insertion)): + cigar.insert(i+j+1,1) #insert '1' for insertion into cigar string + tempq=tempq[0:i+1]+tempq[i]+tempq[i+1:len(tempq)] #make insertion's quality same as quality of base before insertion + elif re.match('del\w+',mut): #if it's a deletion + deletion=re.sub('del','',mut) + for j in range(0,len(deletion)): + if i+jB',...}, ...} + orig = pysam.Samfile(origbam,'rb') + tumor = pysam.Samfile(outbam,'wb',template=orig) + + # set of alignedReads that need to be checked to mutate + toCheck = set([]) + for chr in mutations.iterkeys(): + for pos in mutations[chr].iterkeys(): + for ar in orig.fetch(chr,pos-1,pos): + samref = pysam.Samfile.getrname(orig,ar.tid) + if not samref == chr: + readname = ar.qname + print readname+""is not really on chr""+chr+""!\n"" + toCheck.add(ar.qname) + + #fetch all the reads + for ar in orig.fetch(): + if ar.qname in toCheck: #if read spans a mutation position, mutate it with input probability + ref=pysam.Samfile.getrname(orig,ar.tid) + if ref in mutations.iterkeys(): + nr=create_mut(mutations[ref],ar,percent) + tumor.write(nr) + else: + tumor.write(ar) + else: + tumor.write(ar) + + tumor.close() + orig.close() + +if __name__ == ""__main__"": + import sys,os,re + + bam1=sys.argv[1] + bam2=sys.argv[2] + cosmicfile=sys.argv[3] + + # will make six directories: + topdir=sys.argv[4] + if re.split('.+/', topdir)[-1] != '': + topdir = topdir + '/' + + nt100dir = topdir+'nt100/' + try: + os.makedirs(nt100dir) + print 'Creating directory '+nt100dir + except: + print nt100dir+"" already exists!\n"" + + mutate_sample(bam2, cosmicfile, 1.0, nt100dir+'tumor.bam') + os.system('samtools index '+nt100dir+'tumor.bam') + os.symlink(bam1, nt100dir+'normal.bam') + os.symlink(bam1+'.bai', nt100dir+'normal.bam.bai') + + nt60dir = topdir+'nt60/' + try: + os.makedirs(nt60dir) + print 'Creating directory '+nt60dir + except: + print nt60dir+"" already exists!\n"" + mutate_sample(bam2, cosmicfile, 0.6, nt60dir+'tumor.bam') + os.system('samtools index '+nt60dir+'tumor.bam') + os.symlink(bam1, nt60dir+'normal.bam') + os.symlink(bam1+'.bai', nt60dir+'normal.bam.bai') + + nt20dir = topdir+'nt20/' + try: + os.makedirs(nt20dir) + print 'Creating directory '+nt20dir + except: + print nt20dir+"" already exists!\n"" + mutate_sample(bam2, cosmicfile, 0.2, nt20dir+'tumor.bam') + os.system('samtools index '+nt20dir+'tumor.bam') + os.symlink(bam1, nt20dir+'normal.bam') + os.symlink(bam1+'.bai', nt20dir+'normal.bam.bai') + + tn100dir = topdir+'tn100/' + try: + os.makedirs(tn100dir) + print 'Creating directory '+tn100dir + except: + print tn100dir+"" already exists!\n"" + + mutate_sample(bam1, cosmicfile, 1.0, tn100dir+'tumor.bam') + os.system('samtools index '+tn100dir+'tumor.bam') + os.symlink(bam2, tn100dir+'normal.bam') + os.symlink(bam2+'.bai', tn100dir+'normal.bam.bai') + + tn60dir = topdir+'tn60/' + try: + os.makedirs(tn60dir) + print 'Creating directory '+tn60dir + except: + print tn60dir+"" already exists!\n"" + + mutate_sample(bam1, cosmicfile, 0.6, tn60dir+'tumor.bam') + os.system('samtools index '+tn60dir+'tumor.bam') + os.symlink(bam2, tn60dir+'normal.bam') + os.symlink(bam2+'.bai', tn60dir+'normal.bam.bai') + + tn20dir = topdir+'tn20/' + try: + os.makedirs(tn20dir) + print 'Creating directory '+tn20dir + except: + print tn20dir+"" already exists!\n"" + mutate_sample(bam1, cosmicfile, 0.2, tn20dir+'tumor.bam') + os.system('samtools index '+tn20dir+'tumor.bam') + os.symlink(bam2, tn20dir+'normal.bam') + os.symlink(bam2+'.bai', tn20dir+'normal.bam.bai') + +","Python" +"Allele","nhansen/Shimmer","printCompCounts/main.c",".c","9592","341","/************************************************************************** +# +# This software/database is ""United States Government Work"" under the terms of +# the United States Copyright Act. It was written as part of the authors' +# official duties for the United States Government and thus cannot be +# copyrighted. This software/database is freely available to the public for +# use without a copyright notice. Restrictions cannot be placed on its present +# or future use. +# +# Although all reasonable efforts have been taken to ensure the accuracy and +# reliability of the software and data, the National Human Genome Research +# Institute (NHGRI) and the U.S. Government does not and cannot warrant the +# performance or results that may be obtained by using this software or data. +# NHGRI and the U.S. Government disclaims all warranties as to performance, +# merchantability or fitness for any particular purpose. +# +# In any work or product derived from this material, proper attribution of the +# authors as the source of the software or data should be made, using ""NHGRI +# Genome Technology Branch"" as the citation. +# +**************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include ""printcomp.h"" +#define MAXDEPTH 1000000 + +extern Params *parameters; + +int main(int argc, char **argv) +{ + int i,j,k; + int baseLength; + FILE *fil; + long chunkSize; + long position; + long lastPosition; + int totalBases1; + int totalBases2; + char *charPtr; + char *chrPtr; + char cmd[10000]; + char tmpcmd[10000]; + char mapQual, baseQual; + int baseQualNo; + char nextChar; + char refBase; + int fieldNo; + int noBases[10]; + int noIndelAlleles; + int firstIndelChar; + char thisIndelAllele[1000]; + char *indelAlleleStrings[100000]; + int indelCount1[100000]; + int indelCount2[100000]; + int indelLength; + int indelNoDigits; + int posLength; + int refID; /* store current reference base as an integer */ + int sampleShift; + /* char posBases[3000000]; */ + char *posBases; + char posString[50]; + char chromosome[1000]; + char baseArray[6] = ""ATGCN""; + int maxBases; + int maxBase; + int nextMaxBases; + int nextMaxBase; + int baseCount; + + posBases = (char *)malloc(sizeof(char) * MAXDEPTH); + if (!posBases) { + fprintf(stderr, ""Unable to allocate space for base array!\n""); + exit(1); + } + + get_params(argc, argv); + + if (!parameters->bam1 || !parameters->bam2 || !parameters->fasta) { + fprintf(stderr, ""Usage: printCompCounts -fasta -bam1 -bam2 \n""); + exit(1); + } + + /* specify reference fasta file, then chromosome, then normal bam file, then mutated bam file */ + chunkSize = 4096; + + /* base command which is always run */ + sprintf(cmd, ""samtools mpileup -f %s -BQ0 -d100000 -A"", parameters->fasta); + + if (strcmp(parameters->region, """") != 0) { + sprintf(tmpcmd, ""%s -r %s"", cmd, parameters->region); + sprintf(cmd, ""%s"", tmpcmd); + } + + if (strcmp(parameters->bedfile, """") != 0) { + sprintf(tmpcmd, ""%s -l %s"", cmd, parameters->bedfile); + sprintf(cmd, ""%s"", tmpcmd); + } + + if (parameters->mapqual != 0) { + sprintf(tmpcmd, ""%s -q %i"", cmd, parameters->mapqual); + sprintf(cmd, ""%s"", tmpcmd); + } + + sprintf(tmpcmd, ""%s %s %s"", cmd, parameters->bam1, parameters->bam2); + sprintf(cmd, ""%s"", tmpcmd); + + /* check to be sure we can open mpileup */ + if ((fil = popen(cmd,""r"")) == NULL) { + printf(""error printCompCounts: unable to run mpileup: %s\n"",cmd); + exit(1); + } + + fieldNo = 0; + noBases[0] = 0; + noBases[1] = 0; + noBases[2] = 0; + noBases[3] = 0; + noBases[4] = 0; + noBases[5] = 0; + noBases[6] = 0; + noBases[7] = 0; + noBases[8] = 0; + noBases[9] = 0; + totalBases1 = 0; + totalBases2 = 0; + baseLength = 0; + noIndelAlleles = 0; + while((nextChar = fgetc( fil )) != EOF) { + if (nextChar == '\t') { + fieldNo++; + } + if (fieldNo == 0) { /* populate chromosome with the current chromosome */ + chrPtr = chromosome; + *chrPtr = nextChar; + chrPtr++; + while ((nextChar = fgetc( fil )) != '\t') { + *chrPtr = nextChar; + chrPtr++; + } + *chrPtr = '\0'; + fieldNo++; + } + if (fieldNo == 1) { /* populate position with current position */ + posLength = 0; + while ((nextChar = fgetc( fil )) != '\t') { + posString[posLength++] = nextChar; + } + posString[posLength] = '\0'; + fieldNo = 2; + position = atoi(posString); + } + if (fieldNo == 2) { /* record reference base */ + nextChar = fgetc ( fil ); + refBase = nextChar; + switch( refBase ) { + case 'A' : + case 'a' : + refID = 0; + break; + case 'T' : + case 't' : + refID = 1; + break; + case 'G' : + case 'g' : + refID = 2; + break; + case 'C' : + case 'c' : + refID = 3; + break; + } + while ((nextChar = fgetc( fil )) != '\t') { + } + fieldNo = 3; + } + if ((fieldNo == 4) || (fieldNo == 7)) { /* record read bases */ + sampleShift = 0; + if (fieldNo == 7) { + sampleShift += 5; /* will store counts for second sample in indices 5-9 */ + } + + baseLength = 0; + while ((nextChar = fgetc( fil )) != '\t') { + posBases[baseLength++] = nextChar; + } + posBases[baseLength] = '\0'; + fieldNo++; + /* now read quality scores as needed */ + for (i=0; i 0) { + indelLength /= 10; + i++; + indelNoDigits++; + } + /* store this allele */ + for (j=0; jindelNoDigits) { + thisIndelAllele[j] = toupper(posBases[j+firstIndelChar]); /* print the allele in uppercase */ + } + else { + thisIndelAllele[j] = posBases[j+firstIndelChar]; + } + } + thisIndelAllele[j] = '\0'; + /* have we seen this indelAllele before at this position? */ + for (j=0; j=noIndelAlleles) { + indelAlleleStrings[noIndelAlleles] = (char *)malloc(sizeof(char)*(strlen(thisIndelAllele) + 1)); + for (j=0; jminqual == 0) || (baseQualNo >= parameters->minqual)) { + switch( posBases[i] ) { + case 'A' : + case 'a' : + noBases[0+sampleShift]++; + break; + case 'T' : + case 't' : + noBases[1+sampleShift]++; + break; + case 'G' : + case 'g' : + noBases[2+sampleShift]++; + break; + case 'C' : + case 'c' : + noBases[3+sampleShift]++; + break; + case '.' : + case ',' : + noBases[refID+sampleShift]++; + break; + } + } + } + } + } + if (nextChar == '\n') { /* end of line */ + /* determine most frequent base, then next most frequent base */ + maxBases = 0; + maxBase = 4; + nextMaxBases = 0; + nextMaxBase = 4; + for (j=0; j<4; j++) { + baseCount = noBases[j] + noBases[j+sampleShift]; /* how many of this base? */ + if (baseCount > maxBases) { /* move things down the ladder */ + nextMaxBase = maxBase; + nextMaxBases = maxBases; + maxBase = j; + maxBases = baseCount; + } + else if (baseCount > nextMaxBases) { + nextMaxBase = j; + nextMaxBases = baseCount; + } + } + printf(""%s\t%ld\t%c\t%c\t%i\t%i\t%c\t%i\t%i\n"", chromosome, position, refBase, baseArray[maxBase], noBases[maxBase], noBases[maxBase+sampleShift], baseArray[nextMaxBase], noBases[nextMaxBase], noBases[nextMaxBase+sampleShift]); + + for (j=0; j +#include + +typedef struct params { + char *fasta; + char *bam1; + char *bam2; + char *region; + char *bedfile; + int minqual; + int mapqual; + +} Params; + +void free_params(); +void get_params(int argc, char** argv); +","Unknown" +"Allele","nhansen/Shimmer","printCompCounts/params.c",".c","3070","83","/************************************************************************** +# +# This software/database is ""United States Government Work"" under the terms of +# the United States Copyright Act. It was written as part of the authors' +# official duties for the United States Government and thus cannot be +# copyrighted. This software/database is freely available to the public for +# use without a copyright notice. Restrictions cannot be placed on its present +# or future use. +# +# Although all reasonable efforts have been taken to ensure the accuracy and +# reliability of the software and data, the National Human Genome Research +# Institute (NHGRI) and the U.S. Government does not and cannot warrant the +# performance or results that may be obtained by using this software or data. +# NHGRI and the U.S. Government disclaims all warranties as to performance, +# merchantability or fitness for any particular purpose. +# +# In any work or product derived from this material, proper attribution of the +# authors as the source of the software or data should be made, using ""NHGRI +# Genome Technology Branch"" as the citation. +# +**************************************************************************/ + +#include ""printcomp.h"" +#include +#include +#include + +Params *parameters; + +void get_params(argc, argv) + int argc; + char **argv; +{ + int i; + char *emptyptr; + + parameters = (Params *) malloc(sizeof(Params)); + + emptyptr = (char *) malloc(sizeof(char)); + strcpy(emptyptr, """"); + parameters->region = emptyptr; + parameters->bedfile = emptyptr; + parameters->minqual = 0; + parameters->mapqual = 0; + + for (i = 1; i < argc; i++) { + if (!strcmp(argv[i], ""-fasta"")) { + parameters->fasta = (char *) malloc((strlen(argv[++i]) + 1) * sizeof(char)); + strcpy(parameters->fasta, argv[i]); + } + else if (!strcmp(argv[i], ""-bam1"")) { + parameters->bam1 = (char *) malloc((strlen(argv[++i]) + 1) * sizeof(char)); + strcpy(parameters->bam1, argv[i]); + } + else if (!strcmp(argv[i], ""-bam2"")) { + parameters->bam2 = (char *) malloc((strlen(argv[++i]) + 1) * sizeof(char)); + strcpy(parameters->bam2, argv[i]); + } + else if (!strcmp(argv[i], ""-region"")) { + parameters->region = (char *)malloc((strlen(argv[++i]) + 1) * sizeof(char)); + strcpy(parameters->region, argv[i]); + } + else if (!strcmp(argv[i], ""-minqual"")) { + parameters->minqual = atoi(argv[++i]); + } + else if (!strcmp(argv[i], ""-mapqual"")) { + parameters->mapqual = atoi(argv[++i]); + } + else if (!strcmp(argv[i], ""-bedfile"")) { + parameters->bedfile = (char *)malloc((strlen(argv[++i]) + 1) * sizeof(char)); + strcpy(parameters->bedfile, argv[i]); + } + } +} + +void free_params() { + free(parameters->fasta); + free(parameters->bam1); + free(parameters->bam2); + free(parameters->region); + free(parameters->bedfile); +} +","C" +"Allele","WGLab/PennCNV2","cnv/hmm_cnv_dimension.h",".h","470","15","//#define HMM_BLOCK_HEIGHT 1 +//#define MAX_COPY_NUM 4 +//#define HMM_STATES 1024 +//#define HMM_GRID_WIDTH HMM_BLOCK_WIDTH*HMM_BLOCK_WIDTH +//#define HMM_GRID_HEIGHT 1 +//#define HMM_OBSERVATIONS 41263 +//#define HMM_OBSERVATIONS 100 +//#define HMM_OBS_BLOCK_WIDTH 32 +#define HMM_SMALL 1e-10 +#define HMM_STATE_BLOCK_WIDTH 512 +#define HMM_OBS_BLOCK_WIDTH 512 +#define HMM_TRANSITION_LARGE 1e8 +//#define HMM_TRANSITION_LARGE 1e4 +// MAXIMUM TOTAL BLOCK WIDTH FOR NVS 290 IS 65536 +","Unknown" +"Allele","WGLab/PennCNV2","cnv/compile.sh",".sh","60","2","g++ -o compute_alpha -lm -lgsl -lgslcblas compute_alpha.cpp +","Shell" +"Allele","WGLab/PennCNV2","cnv/hmm_cnv.c",".c","9954","310"," //#include""/home/garyc/development/mpi_lasso/src/hmm_dimension.h"" +//#pragma OPENCL EXTENSION cl_amd_fp64 : enable +#include""hmm_cnv_dimension.h"" +//#include""/home/garykche/gary/code/src/hmm_cnv_dimension.h"" +#pragma OPENCL EXTENSION cl_khr_fp64 : enable + +__kernel void rescale_transition( +__const int states, +__constant int * cn_vec, +__constant float * forward_gap, +__constant float * backward_gap, +__global float * penalty_mat, +__global float * trans_mat, +__global float * forward_scaled_mat, +__global float * backward_scaled_mat, +__local float * rowsum, +__local float * rowvals +) +{ + int currentstate = get_group_id(0); + if (currentstate>=states) return; + int direction = get_group_id(1); + int futurestate = get_local_id(0); + + rowsum[futurestate] = 0; + rowvals[futurestate] = 0; + barrier(CLK_LOCAL_MEM_FENCE); + float gap = direction==0?*forward_gap:*backward_gap; + if (futurestate0; s>>=1) { + if (futurestateHMM_SMALL?(1-rowsum[0]):rowvals[currentstate]; + //rowvals[currentstate] *= rowsum[0]>(1-HMM_TRANSITION_DIAG)?rowsum[0]/(1-HMM_TRANSITION_DIAG):1; + barrier(CLK_LOCAL_MEM_FENCE); + //rowsum[0]+=rowvals[currentstate]; + if (direction==0 && futurestate=states) return; + int direction = get_group_id(1); + int otherstate = get_local_id(0); + int obs = counter[currentstate]; + avg_log[otherstate] = 0; + sum_log[otherstate] = 0; + barrier(CLK_LOCAL_MEM_FENCE); + if(direction==0 && otherstate0; s>>=1) { + if (otherstate0; s>>=1) { + if (otherstate=states) return; + int otherstate = get_local_id(0); + int obs = counter[currentstate]; + + best_index[otherstate] = 0; + best_prob[otherstate] = -1e11; + barrier(CLK_LOCAL_MEM_FENCE); + if(otherstate0; s>>=1) { + if (otherstate0; s>>=1) { + if (state0; s>>=1) { + if (state=states) return; + int tid = get_local_id(0); + temp1[tid] = 0; + barrier(CLK_LOCAL_MEM_FENCE); + //for(int chunk=0;chunk<2;++chunk){ + for(int chunk=0;chunk<(observations-1)/HMM_OBS_BLOCK_WIDTH+1;++chunk){ + int index = chunk*HMM_OBS_BLOCK_WIDTH+tid; + if (index<(observations-1)){ + temp1[tid] += exp(prob_mat_log[index*states+state]); + } + barrier(CLK_LOCAL_MEM_FENCE); + } + if(tid==-1){ + float sum = 0; + for(int i=0;i0; s>>=1) { + if (tid=states) return; + int futurestate = get_local_id(0); + if (futurestate=states) return; + int futurestate = get_local_id(0); + if (futurestate=states) return; + int futurestate = get_local_id(0); + float t = futurestate filelist_vec; // list of filenames for input + vector sample_info_vec; + //vector global_alphas; + vector alpha_percents; + string chr; // chr to operate on + int * pos_vec; // positions in base pairs + int * gap_vec; // inter-SNP distance in base pairs + //vector state_object_vector; // vector of state objects + string * rslist; // list of SNP IDs + int samples; // total samples + int total_markers; + int current_sample; + int observations; // total markers + int states; // total states + int iteration; // current iteration + float sd_alpha; + int hmm_matrix_size; + int trans_matrix_size; + + + // observed data here + int * segment_length_vec; // relevant for penncnv-seq + float *intensity_vec; + float *baf_vec; + map pfb_map; + // these are large matrices MARKERS * SUBJECTS + float *forward_mat,*backward_mat, *prob_mat, * prev_prob_mat; + float * trans_mat; // transition matrix + //float * trans_mat; // previous transition matrix + float * emission_cache_mat; + // these track the number of rescalings needed to prevent underflow + // dimension is number of markers + int * forward_rescalings; + int * backward_rescalings; + // viterbi variables + int * greedy_rescalings; + int * backtrace_vec; + float * greedy_mat; + int * bestpath_mat; + + float likelihood_log; + // needed by GPU + int * state_tumorcn_vec; // for use on GPU. copy numbers + bool * state_het_ident; + bool * state_alpha_ident; + bool * state_tumor_ident; + float * state_het_ratio; + float * state_total_alpha; + float * state_mu_rr; + float * state_sd_rr; + //float * state_baf_het_mean; + float * state_alpha_prior; + + // functions below + float get_baf_mean(int bac,int cn, float alpha); + float get_baf_sd(int state,int bac); + bool load_input_filelist(const string & filelist); + void load_input_file(); + void init_emission_cache_mat_orig(); + void compute_emission_cache_mat(); + void print_summary(); + void init_state_objects(); + void allocate_global_matrices(); + void allocate_sample_matrices(); + void initialize_global_matrices(); + void initialize_state_parameters(); + void initialize_state_parameter(int id,int tumor_cn, int percent, float het_ratio,bool alpha_identifiable, bool het_identifiable, bool tumor_identifiable, float * sd_rr_alpha, float * sd_rr_loh, float sd_rr_normal); + void free_sample_matrices(); + void adjust_aneuploidy(); + void forwardbackward(); + void viterbi(); + void viterbi_output(); + void baumwelch(); + float get_rr_offset(); + float get_mean_depth(); + void normalize_across_alphas(float * emission_vec); + // utilities + float get_binom_sum(int n, float pop_b, float baf); + void parse_pfb_file(); + double addMultipleLogs(double * logs, int len); + void normalize(int len, float * probs, float * normalized); + //void set_global_alpha(); + //ofstream ofs; +}; + +//struct state_t{ +// state_t(int id,int tumor_cn, int percent, float het_ratio,bool alpha_identifiable, bool het_identifiable, bool tumor_identifiable, float * sd_rr_alpha, float * sd_rr_loh, float sd_rr_normal); +// state_t(); +// void update_rr_mean(float offset); +// int id; +// float total_alpha; +// float het_ratio; +// //float baf_mean_precompute; +// bool alpha_ident; +// bool het_ident; +// bool tumor_ident; +// //int alpha_block; +// int normal_bac; // B allele count +// int normal_cn; +// int tumor_bac; +// int tumor_cn; +// float mu_rr; +// float sd_rr; +// float alpha_prior; +// void debug(); +// +//}; +","Unknown" +"Allele","WGLab/PennCNV2","cnv/hmm_cnv.cpp",".cpp","40694","1128","#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef USE_GPU +#include +#include""../common/clsafe.h"" +#endif +#include""hmm_cnv_dimension.h"" +#include""../common/main.hpp"" +#include""../common/analyzer.hpp"" +#include""../common/io.hpp"" +#include""../common/utility.hpp"" +#include ""hmm_cnv.hpp"" +//#include ""compute_alpha.hpp"" + +using namespace std; + + +void HMM_CNV::init(const ptree & pt){ + verbose_output = false; + //verbose_output = false; + LOG_SMALL = log(SMALL); + LOG_LARGE = log(LARGE); + this->math = new MathUtils(123); + // load configurations + //total_markers = pt.get(""total_markers""); + // the following are tuning parameters for sensitivity/specificity + sd_rr_loh = new float[5]; + sd_baf_percent = new float[100]; + sd_rr_alpha = new float[100]; + memset(sd_rr_loh,0,sizeof(float)*5); + memset(sd_baf_percent,0,sizeof(float)*100); + memset(sd_rr_alpha,0,sizeof(float)*100); + if (analysis_type==ANALYSIS_TUMOR){ + this->alpha_percents.push_back(1); + this->alpha_percents.push_back(33); + this->alpha_percents.push_back(66); + this->alpha_percents.push_back(99); + }else if (analysis_type==ANALYSIS_SEQ){ + this->alpha_percents.push_back(1); + } + // 4 states incorporate heterogeneity, normal and LOH state do not. + int abberant_states = analysis_type==ANALYSIS_TUMOR?4:2; + this->states = alpha_percents.size() * abberant_states + 2; + if(analysis_type==ANALYSIS_TUMOR){ + // + // TUMOR RELATED TUNING PARAMETERS + // + for(vector::iterator it = alpha_percents.begin(); + it!=alpha_percents.end();it++){ + int percent = *it; + ostringstream oss_tumor; + oss_tumor<<""lrr_sd_cn.stromal.""<(oss_tumor.str()); + } + for(int i=2;i<=2;++i){ + ostringstream oss; + oss<<""lrr_sd_cn.loh.""<(oss.str()); + } + sd_rr_normal = pt.get(""lrr_sd_normal""); + sd_alpha=pt.get(""alpha_sd""); + }else if(analysis_type==ANALYSIS_SEQ){ + + // + // SEQUENCING RELATED TUNING PARAMETERS + // + shape = pt.get(""seq_info.shape""); + coverage_offset = pt.get(""seq_info.mean_coverage_offset""); + dispersion = pt.get(""seq_info.dispersion""); + } + + // + // SHARED TUNING PARAMETERS + // + // + // + sd_baf_homo_del = pt.get(""baf_sd_homo_del""); + normal_cdf = math->normal_cdf(0,.5,sd_baf_homo_del); + int baf_percents[]={0,25,33,50}; + for(uint i=0;i(oss.str()); + } + + output_dir=pt.get(""output_dir""); + cerr<<""Will save results in ""<(""pfb_file""); + cerr<<""Reading population B allele frequencies from ""<>name>>chr>>pos>>pfb; + pfb_map[pos] = pfb; + } + ifs_pfb.close(); + } + input_filelist = pt.get(""input_filelist""); + cerr<<""Loading signal files defined in ""<backtrace_vec; + delete[] this->pos_vec; + //this->alpha_block_vec = new int[total_markers]; + delete[] this->rslist; + delete[] this->gap_vec; + delete[] this->forward_rescalings; + delete[] this->backward_rescalings; + delete[] this->greedy_rescalings; + delete[] this->intensity_vec; + delete[] this->segment_length_vec; + delete[] this->baf_vec; + delete[] this->emission_cache_mat; + delete[] this->forward_mat; + delete[] this->greedy_mat; + delete[] this->bestpath_mat; + delete[] this->backward_mat; + delete[] this->prob_mat; + delete[] this->prev_prob_mat; +} + +void HMM_CNV::allocate_global_matrices(){ + cerr<<""Total States: ""<trans_mat = new float[trans_matrix_size]; +} + +void HMM_CNV::allocate_sample_matrices(){ + cerr<<""Scanning ""<backtrace_vec = new int[total_markers]; + this->pos_vec = new int[total_markers]; + this->rslist = new string[total_markers]; + this->gap_vec = new int[total_markers]; + this->forward_rescalings = new int[total_markers]; + this->backward_rescalings = new int[total_markers]; + this->greedy_rescalings = new int[total_markers]; + this->intensity_vec = new float[total_markers]; + this->segment_length_vec = new int[total_markers]; + this->baf_vec = new float[total_markers]; + hmm_matrix_size = states * total_markers; + this->emission_cache_mat = new float[hmm_matrix_size]; + this->forward_mat = new float[hmm_matrix_size]; + this->greedy_mat = new float[hmm_matrix_size]; + this->bestpath_mat = new int[hmm_matrix_size]; + this->backward_mat = new float[hmm_matrix_size]; + this->prob_mat = new float[hmm_matrix_size]; + this->prev_prob_mat = new float[hmm_matrix_size]; +}; + +void HMM_CNV::initialize_state_parameter(int state,int tumor_cn, int percent, float het_ratio, bool alpha_identifiable,bool het_identifiable, bool tumor_identifiable, float * sd_rr_alpha, float * sd_rr_loh, float sd_rr_normal){ + state_tumorcn_vec[state] = tumor_cn; + state_het_ident[state] = het_identifiable; + state_alpha_ident[state] = alpha_identifiable; + state_tumor_ident[state] = tumor_identifiable; + state_het_ratio[state] = het_ratio; + state_total_alpha[state] = percent/100.; + float slope = (1.-INTERCEPT)/2.; + if (intensity_type==INTENSITY_LRR){ + state_mu_rr[state] = (1-state_total_alpha[state])*(INTERCEPT+tumor_cn*slope)+ (state_total_alpha[state]); + if (tumor_cn==2){ + if (het_ratio>0){ + // the variance of the normal tissue + state_sd_rr[state] = (sd_rr_normal); + }else{ + state_sd_rr[state] = (sd_rr_loh[tumor_cn]); + } + }else{ + state_sd_rr[state] = sd_rr_alpha[percent]; + } + }else if (intensity_type==INTENSITY_READS){ + state_mu_rr[state] = tumor_cn/2.; + state_sd_rr[state] = dispersion; + } + cerr<<""for cn ""<normal_pdf(state_total_alpha[state],global_alpha,sd_alpha):1; + if(alpha_prioranalysis_type = ANALYSIS_TUMOR; + this->intensity_type = INTENSITY_LRR; + }else if (strcmp(analysis_type,""seq_cnv"")==0){ + this->analysis_type = ANALYSIS_SEQ; + this->intensity_type = INTENSITY_READS; + }else{ + throw ""Unknown analysis type\n""; + } +} + +bool HMM_CNV::load_input_filelist(const string & filelistpath){ + ifstream ifslist(filelistpath.data()); + if (!ifslist.is_open()){ + cerr<<""File list is not found.\n""; + return false; + } + string line; + // skip header + getline(ifslist,line); + float epsilon=.01; + int sample_id = 0; + while(getline(ifslist,line)){ + sample_info_t sample_info; + istringstream iss(line); + if (intensity_type==INTENSITY_LRR){ + iss>>sample_info.filename>>sample_info.annot>>sample_info.global_alpha; + if (sample_info.global_alpha==0) sample_info.global_alpha+=epsilon; + else if (sample_info.global_alpha==1) sample_info.global_alpha-=epsilon; + }else{ + iss>>sample_info.filename>>sample_info.annot; + } + ++sample_id; + sample_info_vec.push_back(sample_info); + } + ifslist.close(); + samples = sample_info_vec.size(); + cerr<<""Total samples: ""< existing_position_map; + ifstream ifsobs(sample_info_vec[current_sample].filename.data()); + int lastpos = 0; + string line; + getline(ifsobs,line); // skip header + string last_chr=""""; + int last_pos = -1; + //cerr<<""Reading in ""<>rslist[j]>>chr>>pos_vec[j]>>baf_vec[j]>>intensity; + if (last_chr.compare("""")!=0 && last_chr.compare(chr)!=0){ + cerr<<""Found chr string of ""<>rslist[j]>>chr>>pos_vec[j]>>baf_vec[j]>>intensity_vec[j]>>segment_length_vec[j]; + break; + } + gap_vec[j] = pos_vec[j]-lastpos; + lastpos = pos_vec[j]; + // for the first sample, record all observed positions + //if (i==0) { + //cerr<<""Mapping position ""<forwardbackward(); + }else{ + this->baumwelch(); + this->forwardbackward(); + } + cerr<<""Last LL: ""<1){ + mean = 0; + mean_increment =1./(n-1); + } + for(int k=0;kbinom_prob(n,k,pop_b) * math->normal_pdf(baf,mean,sd); + mean+=mean_increment; + } + return binom_sum; +} + + + +float ordered_binom(int n,int k,float p){ + float prob = 1; + for(int i=0;i=2 && bac==0) || bac==cn){ + // if tumor homo , assume normal is always homo + return bac/cn; + } + int normal_bac = 1; + int normal_cn = 2; + float mu = ((1.-global_alpha-alpha)*bac + (global_alpha+alpha)*normal_bac) + / ((1.-global_alpha-alpha)*cn+(global_alpha+alpha)*normal_cn); + //cerr<<""alpha ""<.5) frac = 1.-frac; + int percent = (int)(frac * 100. + .5); + float sdnorm = sd_baf_percent[50]; + float sdtumor = sd_baf_percent[percent]; + float var = pow((total_alpha)*sdnorm,2) + + pow((1-total_alpha)*sdtumor,2); + //cerr<<""debug: ""<id = id; +// this->tumor_cn = tumor_cn; +// this->het_ident = het_identifiable; +// this->alpha_ident = alpha_identifiable; +// this->tumor_ident = tumor_identifiable; +// this->het_ratio = het_ratio; +// this->total_alpha = percent/100.; +// float slope = (1.-INTERCEPT)/2.; +// this->mu_rr = (1-total_alpha)*(INTERCEPT+tumor_cn*slope)+ (total_alpha); +// //cerr<<""for cn ""<mu_rr<0){ +// // the variance of the normal tissue +// sd_rr = (sd_rr_normal); +// }else{ +// sd_rr = (sd_rr_loh[tumor_cn]); +// } +// }else{ +// sd_rr = sd_rr_alpha[percent]; +// } +//} + +//void state_t::update_rr_mean(float offset){ +// this->mu_rr += offset; +//} +// +//void state_t::debug(){ +// cerr<::iterator it = alpha_percents.begin(); + it!=alpha_percents.end();it++){ + int percent = *it; + if (analysis_type==ANALYSIS_TUMOR){ + // homozygous deletion + initialize_state_parameter(states,0,percent,HET_RATIO,true,false, true,sd_rr_alpha,sd_rr_loh,sd_rr_normal); + ++states; + } + // hemizygous deletion + initialize_state_parameter(states,1,percent,HET_RATIO,true,false, true,sd_rr_alpha,sd_rr_loh,sd_rr_normal); + ++states; + // amplifications + initialize_state_parameter(states,3,percent,HET_RATIO,true,false, true,sd_rr_alpha,sd_rr_loh,sd_rr_normal); + ++states; + if (analysis_type==ANALYSIS_TUMOR){ + initialize_state_parameter(states,4,percent,HET_RATIO,true,false, true,sd_rr_alpha,sd_rr_loh,sd_rr_normal); + ++states; + } + } + assert(states == this->states); + cerr<<""Total states matched: ""<normal_pdf(intensity,state_mu_rr[state],state_sd_rr[state]); + }else if (intensity_type==INTENSITY_READS){ + // set this to one to ignore length scaling + // for now. + float scaling_coeff = 1; + //float scaling_coeff = segment_length_vec[i]; + float scale = state_sd_rr[state]/scaling_coeff; + // the expected value of a gamma distrib is shape * scale + float mean = shape * scale; + // how far is the observed value from expected value for the state + float deviance = intensity - (coverage * state_mu_rr[state]) ; + // add offset of mean as appropriate for the gamma dist + float expected_intensity = mean+deviance; + intensity_prob = math->gamma_pdf(expected_intensity,shape,scale); + //cerr<<""at marker ""<normal_pdf(baf,.5,sd_baf_homo_del); + } + }else{ // these other cases take into account stromal contamination + bool status_loh = (tumorcn==1 || (tumorcn==2 && state_het_ratio[state]==0)); + int effective_tumorcn = status_loh?1:tumorcn; + // the first two cases only happen when tumor and normal are homozygote + if (baf==0){ + baf_prob+=math->binom_prob(effective_tumorcn,0,pfb)*pointmass; + }else if (baf==1){ + baf_prob+=math->binom_prob(effective_tumorcn,effective_tumorcn,pfb) + * pointmass; + }else{ + // this loop assumes the normal genotype is a heterozygote. + for (int bac=0;bac<=effective_tumorcn;++bac){ + baf_prob+=math->binom_prob(effective_tumorcn,bac,pfb)*math->normal_pdf(baf,get_baf_mean(bac,effective_tumorcn,alpha),get_baf_sd(state,bac)); + } + if (status_loh){ + // assume homozygote normal too + int bac = (baf<.5)?0:1; + baf_prob+=math->binom_prob(effective_tumorcn,bac,pfb)*math->normal_pdf(baf,bac,sd_baf_percent[0]); + } + } + } + //cerr<<""observation: ""<0) alpha_normalizer += alpha_probs[j]; + if (het_probs[j]>0) het_normalizer += het_probs[j]; + } + float exp_alpha = 0; + float exp_het = 0; + for(int j=0;j<100;++j){ + if (alpha_probs[j]>0){ + alpha_probs[j]/=alpha_normalizer; + ofs_alpha<<""\t""<<(j/100.)<<"":""<0){ + het_probs[j]/=het_normalizer; + ofs_het<<""\t""<<(j/100.)<<"":""<0) normalizer += tumor_cn_probs[j]; + } + float exp_tumor_cn=0; + for(int j=0;j0) { + tumor_cn_probs[j]/=normalizer; + ofs_tumor_cn<<""\t""<=0;--obs){ + backward_rescalings[obs] = backward_rescalings[obs+1]; + if (verbose_output && obs % 10000 == 0) cerr<<"" ""<1){ + cerr<<""Mismatch in likelihoods. See debugging dir\n""; + ofstream ofs_emission(""debugging/emission.mat""); + ofstream ofs(""debugging/posterior.mat""); + ofstream ofs_f(""debugging/forward.mat""); + ofstream ofs_b(""debugging/backward.mat""); + for(int obs=0;obslikelihood_log = likelihood_log; + for(int obs=0;obsnormal_pdf(baf,.5,.001); + rr_offset+=weight * (rr-1.); + denom+=weight; + } + } + rr_offset = denom>0?rr_offset/denom:0; + return rr_offset; +} + +void HMM_CNV::viterbi(){ + cerr<<""Running Viterbi decoding...\n""; + //float sum,forwardsum,backwardsum; + //int back_trace[total_markers][states]; + //int trace[total_markers]; + float max = SMALL; + int obs = 0; + for(int j=0;j max){ + backtrace_vec[obs] = j; + max = greedy_mat[j]; + } + } + for(int i=0;i=max){ + maxind = prevstate; + max = curr_val; + } + + } + if (maxind<0) { + cerr <<""Never found a max beyond ""< currval){ + backtrace_vec[total_markers-1] = state; + currval = greedy_mat[(total_markers-1)*states+state]; + } + } + for(int obs = total_markers-2;obs>=0;--obs){ + backtrace_vec[obs] = bestpath_mat[(obs+1)*states+backtrace_vec[obs+1]]; + } +} + +","C++" +"Allele","WGLab/PennCNV2","examples/run.sh",".sh","50","5","#!/bin/bash + +gunzip -v *.gz +../analyzer tumor_cnv +","Shell" +"Allele","WGLab/PennCNV2","common/main.hpp",".hpp","529","27","#include +#include +#include + +using namespace::std; + +class Analyzer; + +class global_settings_t{ +public: + bool use_db; + string db_host; + string db_user; + string db_pw; + string db_db; + string db_table; + string pedfile; + string snpfile; + string genofile; + string covariatedatafile; + string covariateselectionfile; + string selected_analysis; + list ptrees; + void load(const string & filename, Analyzer * & analyzer); +}; + +","Unknown" +"Allele","WGLab/PennCNV2","common/analyzer.cpp",".cpp","8256","260","#include + +#include +#include +#include +#include +#include + +#include""analyzer.hpp"" +#include""io.hpp"" + +using namespace std; + +const int MAX=100; + +Analyzer::Analyzer(){ } + +//void Analyzer::run(){} + +Analyzer::~Analyzer(){ + cerr<<""Analyzer is deleted.\n""; +} + +bool Analyzer::chDecomp(const double * inputMatrix, double * decompMat,uint dim){ + for(uint i=0;ij) infoMatrix[k*params+j] = infoMatrix[j*params+k]; + } + //cerr<0){ + delta_beta[j] = 0; + } + } + }else{ + delta_beta[j] = (num-beta[j]/fabs(beta[j])*n*lambda)/den; + if ((beta[j]>0 && beta[j]+delta_beta[j]<0) || + (beta[j]<0 && beta[j]+delta_beta[j]>0 )){ + delta_beta[j] = -1*beta[j]; + } + } + if (delta_beta[j]!=0){ + beta[j]+=delta_beta[j]; + for(int i=0;i.000001); + cerr<<""Iterations: ""<.0001 && count++=MAX) { + return false; + }else{ + return true; + } +} + +","C++" +"Allele","WGLab/PennCNV2","common/utility.cpp",".cpp","10625","353","#include +//#include ""gwa.hpp"" +#include +#include +#include +#include +#include +#include +//#include ""pathwaysearch.hpp"" +//#include ""db_manager.hpp"" +#include ""utility.hpp"" + + +using namespace std; + +void debugMatrix(const gsl_matrix *m); + + +void MathUtils::outputMatrix(const double * mat, uint dim1, uint dim2){ + gsl_matrix_const_view newmat = gsl_matrix_const_view_array(mat,dim1,dim2); + debugMatrix(&newmat.matrix); +} + +double MathUtils::corrIndicator(const double * data1,const double * data2,int len,double * termWeights,double termWeightsTotal){ + double sum=0.; + for(int i=0;i0 && data2[i]>0){ + sum+=termWeights[i]; + } + } + sum/=(1.*termWeightsTotal); + return sum; +} + +double MathUtils::beta(double a,double b){ + return gsl_ran_beta (rng,a,b); +} + +double MathUtils::corr(const double * data1,const double * data2,int len){ + double cor2 = 0.; + double mu1 = mean(data1,len); + double mu2 = mean(data2,len); + for(int i=0;istdNormal(1.0); + } + int dim = static_cast(dimension); + + for (int i = dim-1;i >=0; --i) { + randomSample[i] *= gsl_matrix_get(&decompMat.matrix,i,i); + for (int j = 0; j < i; ++j) { + randomSample[i] += gsl_matrix_get(&decompMat.matrix,i,j)* randomSample[j]; + } + } + // Add means if necessary + if (mu != NULL) { + for (uint i = 0; i < dimension; ++i) { + randomSample[i] += mu[i]; + } + } +} + + + +double MathUtils::RandomUniform(){ + return gsl_rng_uniform (this->rng); +} + + +double MathUtils::stdNormal(double sd){ + double x= gsl_ran_gaussian(this->rng, sqrt(sd)); + return x; + +} + + +double MathUtils::cdfNormal(const double mean,const double var, +const double x){ + //cerr<<""mean:""<j) infoMatrix[k*rank+j] = infoMatrix[j*rank+k]; + } + } + } + for(int j=0;j(n-k);--i){ + num*=i; + } + float den=1; + for(int i=k;i>1;--i){ + den*=i; + } + //cerr<<""num:""<size1;++i){ + for (uint j=0;jsize2;++j){ + if (j) cerr<<"" ""; + cerr< +using namespace std; + +const char * clError (cl_int rc); +void clSafe (cl_int rc, string functionname); + +inline void checkErr(cl_int err, const char * name) +{ + if (err != CL_SUCCESS) { + std::cerr << ""ERROR: "" << name + << "" ("" << err << "")"" << std::endl; + exit(EXIT_FAILURE); + } +} + +","Unknown" +"Allele","WGLab/PennCNV2","common/clsafe.c",".c","4421","71","#include +#include +#include""clsafe.h"" + +using namespace std; + +const char * clError (cl_int rc) { + string message; + switch (rc) { + case CL_SUCCESS : return ""SUCCESS""; + case CL_DEVICE_NOT_FOUND : return ""DEVICE_NOT_FOUND""; + case CL_DEVICE_NOT_AVAILABLE : return ""DEVICE_NOT_AVAILABLE""; + case CL_COMPILER_NOT_AVAILABLE : return ""COMPILER_NOT_AVAILABLE""; + case CL_MEM_OBJECT_ALLOCATION_FAILURE : return ""MEM_OBJECT_ALLOCATION_FAILURE""; + case CL_OUT_OF_RESOURCES : return ""OUT_OF_RESOURCES""; + case CL_OUT_OF_HOST_MEMORY : return ""OUT_OF_HOST_MEMORY""; + case CL_PROFILING_INFO_NOT_AVAILABLE : return ""PROFILING_INFO_NOT_AVAILABLE""; + case CL_MEM_COPY_OVERLAP : return ""MEM_COPY_OVERLAP""; + case CL_IMAGE_FORMAT_MISMATCH : return ""IMAGE_FORMAT_MISMATCH""; + case CL_IMAGE_FORMAT_NOT_SUPPORTED : return ""IMAGE_FORMAT_NOT_SUPPORTED""; + case CL_BUILD_PROGRAM_FAILURE : return ""BUILD_PROGRAM_FAILURE""; + case CL_MAP_FAILURE : return ""MAP_FAILURE""; + + case CL_INVALID_VALUE : return ""INVALID_VALUE""; + case CL_INVALID_DEVICE_TYPE : return ""INVALID_DEVICE_TYPE""; + case CL_INVALID_PLATFORM : return ""INVALID_PLATFORM""; + case CL_INVALID_DEVICE : return ""INVALID_DEVICE""; + case CL_INVALID_CONTEXT : return ""INVALID_CONTEXT""; + case CL_INVALID_QUEUE_PROPERTIES : return ""INVALID_QUEUE_PROPERTIES""; + case CL_INVALID_COMMAND_QUEUE : return ""INVALID_COMMAND_QUEUE""; + case CL_INVALID_HOST_PTR : return ""INVALID_HOST_PTR""; + case CL_INVALID_MEM_OBJECT : return ""INVALID_MEM_OBJECT""; + case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR : return ""INVALID_IMAGE_FORMAT_DESCRIPTOR""; + case CL_INVALID_IMAGE_SIZE : return ""INVALID_IMAGE_SIZE""; + case CL_INVALID_SAMPLER : return ""INVALID_SAMPLER""; + case CL_INVALID_BINARY : return ""INVALID_BINARY""; + case CL_INVALID_BUILD_OPTIONS : return ""INVALID_BUILD_OPTIONS""; + case CL_INVALID_PROGRAM : return ""INVALID_PROGRAM""; + case CL_INVALID_PROGRAM_EXECUTABLE : return ""INVALID_PROGRAM_EXECUTABLE""; + case CL_INVALID_KERNEL_NAME : return ""INVALID_KERNEL_NAME""; + case CL_INVALID_KERNEL_DEFINITION : return ""INVALID_KERNEL_DEFINITION""; + case CL_INVALID_KERNEL : return ""INVALID_KERNEL""; + case CL_INVALID_ARG_INDEX : return ""INVALID_ARG_INDEX""; + case CL_INVALID_ARG_VALUE : return ""INVALID_ARG_VALUE""; + case CL_INVALID_ARG_SIZE : return ""INVALID_ARG_SIZE""; + case CL_INVALID_KERNEL_ARGS : return ""INVALID_KERNEL_ARGS""; + case CL_INVALID_WORK_DIMENSION : return ""INVALID_WORK_DIMENSION""; + case CL_INVALID_WORK_GROUP_SIZE : return ""INVALID_WORK_GROUP_SIZE""; + case CL_INVALID_WORK_ITEM_SIZE : return ""INVALID_WORK_ITEM_SIZE""; + case CL_INVALID_GLOBAL_OFFSET : return ""INVALID_GLOBAL_OFFSET""; + case CL_INVALID_EVENT_WAIT_LIST : return ""INVALID_EVENT_WAIT_LIST""; + case CL_INVALID_EVENT : return ""INVALID_EVENT""; + case CL_INVALID_OPERATION : return ""INVALID_OPERATION""; + case CL_INVALID_GL_OBJECT : return ""INVALID_GL_OBJECT""; + case CL_INVALID_BUFFER_SIZE : return ""INVALID_BUFFER_SIZE""; + case CL_INVALID_MIP_LEVEL : return ""INVALID_MIP_LEVEL""; + case CL_INVALID_GLOBAL_WORK_SIZE : return ""INVALID_GLOBAL_WORK_SIZE""; + default: + cout< +#include +#include +#include +#include + +#include +#ifdef USE_DB +#include +#endif + +using namespace std; + +typedef map > covar_map_t; +typedef vector > covar_vector_t; +//class global_settings_t; + + +class plink_data_t{ +public: + bool initialized; + plink_data_t(); + ~plink_data_t(); + bool snp_major; + int veclen; + int totalpersons; + int totalsnps; + int * affection; + char ** genomatrix; + map rs_map; + vector rs_list; + map subject_map; + vector subject_list; +}; + +class IO{ +private: + #ifdef USE_DB + MYSQL * mysql; + #endif + void init(); + void fetchgeno(char * genomatrix,int veclen,float * geno,int totalcols); + bool plink_format; + //global_settings_t * settings; + void loadgarymatrix(); + void loadplinkmatrix(); + //covar_map_t covar_map; + +public: + const static int AFF_CASE = 1; + const static int AFF_CONTROL = -1; + const static int AFF_UNDEF = -99; + const static float MISSING_GENO=9.; + //const char * prefix; + virtual ~IO(); + IO(); + //IO(global_settings_t * settings, bool plink_format); + //IO(int totalpersons,int veclen); + //IO(const char * prefix); //PLINK style + void connectToDB(const char * host,const char * user,const char * pw,const char * db); + bool is_plink_format(); + + int snpindex(string rs,plink_data_t & data); + void readPlinkFiles(const char * bim,const char * fam, const char * bed, plink_data_t & data); + bool readAllCovariates(const char * data, covar_vector_t & covar_vector); + bool readCovariates(const char * data,const char * selected, covar_map_t & covar_map); + void fetchgeno(char * genomatrix,int veclen,int rowindex,float * geno,int totalcols); + void fetchgeno(char ** genomatrix,int veclen, int rowindex,float * geno,int totalcols); + bool fetchimputedgeno(const char * db_table,string rsid,float * geno,int len); + //covar_map_t getcovars(); +}; +","Unknown" +"Allele","WGLab/PennCNV2","common/main.cpp",".cpp","3010","117","#include +#include +#include +#ifdef USE_GPU +#include +#include""clsafe.h"" +#endif +#ifdef USE_MPI +#include +#endif + +//#include +#include""io.hpp"" +#include""main.hpp"" +#include""analyzer.hpp"" +#include""utility.hpp"" +#if defined gwas +#include""../gwas/stepwise.hpp"" +#include""../gwas/univariate.hpp"" +#endif +#if defined pimsa +#include""../pimsa/pathwaysearch.hpp"" +#endif +#if defined lasso +#include""../parallel-lasso/dimension2.h"" +#include""../parallel-lasso/lasso_mpi2.hpp"" +#include""../parallel-lasso/stability.hpp"" +#include""../parallel-lasso/power.hpp"" +#include""../parallel-lasso/cross_validation.hpp"" +#endif +#if defined gpu_impute +#include""../gpu-impute/hmm_impute_dimensions.h"" +#include""../gpu-impute/hmm_impute.hpp"" +#endif +#if defined cnv +#include""../cnv/hmm_cnv.hpp"" +#endif +#if defined ssvs +#include""../ssvs/ssvs_dimensions.h"" +#include""../ssvs/ssvs.hpp"" +#endif + + +int main(int argc,char* argv[]){ + if (argc<2){ + cout<<""""<init(pt); + analyzer->run(); + }catch(const char * & mesg){ + cerr<<""Analyzer aborted with message: ""< +#include + + +class MathUtils{ +public: + MathUtils(unsigned long int seed); + ~MathUtils(); + double beta(double a,double b); + bool chDecomp(const double * inputMatrix, double * decompMat,uint dim); + void invert(const double * decompMat,double * invertedMat,uint dim); + double SD(const double * data,uint dim); + double SD(const double * data,uint dim,double mean); + double corr(const double * data1,const double * data2,int len); + double corrIndicator(const double * data1,const double * data2,int len,double * termWeights,double termWeightsTotal); + double mean(const double * data,uint dim); + void ranMVNormal(const double * sigmaMat, const double * means, double * randomSample, uint dimension); + void standardize(double * data,uint len); + void matrixMultiply(bool transpose1,bool transpose2,double * mat1,double * mat2,double * mat3,int dim1y,int dim1x,int dim2y,int dim2x,int dim3y,int dim3x); + double RandomUniform(); + //double expRV(double dLambda); + double stdNormal(double sd); + double cdfNormal(const double mean,const double var,const double x); + void outputMatrix(const double * mat, uint dim1, uint dim2); + bool linReg(double * outcome, double * covariates, double * coeff, double * variances, int totalrows, int rank, double & logL, double * fitted); + bool scoreTest(double * outcome, double * covariates, double * coeff, double * variances, int totalrows, int rank, double & logL, double & chiSq); + float binom_prob(int n,int k,float p); + float gamma_function(float k); + float gamma_pdf(float x,float shape,float scale); + float normal_pdf(float x,float mu,float sigma); + float normal_cdf (float x, float mu, float sigma); + gsl_rng * rng; +private: +}; +","Unknown" +"Allele","WGLab/PennCNV2","common/io.cpp",".cpp","11562","429","#include +#include +#include +#include +#include""io.hpp"" +#include""main.hpp"" + +using namespace std; + +//int masks[4] = {3,12,48,192}; +//int totalpersons; +//int totalsnps; + +//int veclen; +//char ** genomatrix; +const int PLINK_WT_HOMO=0; +const int PLINK_MUT_HOMO=3; +const int PLINK_HET=2; +const int PLINK_MISSING=1; + +plink_data_t::plink_data_t(){ + initialized = false; + affection = NULL; + genomatrix = NULL; +} + +plink_data_t::~plink_data_t(){ + if (affection!=NULL) delete[]affection; + int totalrows = snp_major?totalsnps:totalpersons; + if (genomatrix!=NULL){ + for(int i=0;i::iterator it = data.rs_map.find(rsid); + if(it==data.rs_map.end()) return -1; + return it->second; +} + +bool IO::readAllCovariates(const char * data, covar_vector_t & covar_vector){ + // NOW LOAD THE RAW DATA + ifstream ifs_covdata(data); + if (ifs_covdata.is_open()){ + string line,token; + getline(ifs_covdata,line); + istringstream iss(line); + while(iss>>token){ + vector subvec; + covar_vector.push_back(subvec); + } + int totalcols = covar_vector.size(); + while(getline(ifs_covdata,line)){ + istringstream iss(line); + float cell; + for(int i=0;i>cell; + covar_vector[i].push_back(cell); + } + } + ifs_covdata.close(); + } + cerr<<""Covariates loaded\n""; + return true; + // let's run a test! + //covar_map_t::iterator it = covar_map.find(""e1""); +// vector vec = it->second; +// for(uint i=0;i sel_cov_set; + ifstream ifs_seldata(selected); + string line; + if (ifs_seldata.is_open()){ + while(getline(ifs_seldata,line)){ + sel_cov_set.insert(line); + } + ifs_seldata.close(); + }else{ + cerr<<""Found a covariate data file but not selection file\n""; + return false; + } + cerr<<""Selecting ""< namevec; + while(iss>>colname){ + namevec.push_back(colname); + } + int totalcols = namevec.size(); + bool include[totalcols]; + for(int i=0;i::iterator it = sel_cov_set.find(namevec[i]); + include[i] = it!=sel_cov_set.end()?true:false; + if (include[i]) { + vector values; + covar_map[namevec[i]] = values; + } + } + while(getline(ifs_covdata,line)){ + istringstream iss(line); + string cell; + for(int i=0;i>cell; + if (include[i]){ + covar_map_t::iterator it = covar_map.find(namevec[i]); + (it->second).push_back(atof(cell.data())); + } + } + } + ifs_covdata.close(); + } + cerr<<""Covariates loaded\n""; + return true; + // let's run a test! + //covar_map_t::iterator it = covar_map.find(""e1""); +// vector vec = it->second; +// for(uint i=0;i>subject_id; + data.subject_map[subject_id] = data.totalpersons; + data.subject_list.push_back(subject_id); + ++data.totalpersons; + } + cerr<<""Found ""<>val1; + iss>>aff; + if (aff==1){ + data.affection[j] = AFF_CONTROL; + }else if (aff==2){ + data.affection[j] = AFF_CASE; + }else{ + data.affection[j] = AFF_UNDEF; + } + ++j; + } + cerr<<""Loaded ""<<(j)<<"" affection status rows\n""; + ifsperson.close(); + } + if (bim!=NULL){ + data.totalsnps = 0; + ifstream ifssnp(bim); + while(getline(ifssnp,line)){ + istringstream iss(line); + int chr,position; + string rsid; + float morgan; + char other,ref; + iss>>chr>>rsid>>morgan>>position>>other>>ref; + data.rs_map[rsid] = data.totalsnps; + data.rs_list.push_back(rsid); + ++data.totalsnps; + } + cerr<<""Found ""<totalpersons = totalpersons; +// this->veclen = veclen; +//} + + +//void IO::loadgarymatrix(){ +// ostringstream bedstr; +// //bedstr<prefix<<"".gary""; +// ifstream ifs(bedstr.str().data()); +// int totalinlen = totalpersons+1; // for EOF +// char inputvec[totalinlen]; +// +// for (int snp=0;snpgenomatrix,snpindex,geno); +//} + +void IO::fetchgeno(char * genomatrix,int veclen, int rowindex,float * geno, int len){ + unsigned int i = rowindex*veclen; + char * vector_read = genomatrix+i; + fetchgeno(vector_read,veclen,geno,len); +} + +void IO::fetchgeno(char ** genomatrix,int veclen, int rowindex,float * geno,int len){ + char * vector_read = genomatrix[rowindex]; + fetchgeno(vector_read,veclen,geno,len); +} + + +// used internally, shared by all the above function signatures. + +void IO::fetchgeno(char * vector_read,int veclen,float * geno,int totalcols){ + int masks[4]; + masks[0] = 3; + masks[1] = 12; + masks[2] = 48; + masks[3] = 192; + int colindex = 0; + //cerr<<""Vec len: ""<>2; + if (colindex\n""; + exit(1); + } + //int totalpersons = atoi(argv[1]); + //int totalsnps = atoi(argv[2]); + //IO io(NULL,true); + //io.readInputFiles(); + //io.loadplinkmatrix(); + //float test[io.totalpersons]; + //io.fetchgeno(1,test); + //for(int i=0;i