pax_global_header 0000666 0000000 0000000 00000000064 13531251524 0014513 g ustar 00root root 0000000 0000000 52 comment=ecb9a1b55facaeb36c05235cc02b9566bfc9c7ed
ClonalFrameML-1.12/ 0000775 0000000 0000000 00000000000 13531251524 0014052 5 ustar 00root root 0000000 0000000 ClonalFrameML-1.12/.gitignore 0000664 0000000 0000000 00000000064 13531251524 0016042 0 ustar 00root root 0000000 0000000 src/ClonalFrameML
src/main.o
src/main
src/.vscode/*
ClonalFrameML-1.12/README.md 0000664 0000000 0000000 00000005215 13531251524 0015334 0 ustar 00root root 0000000 0000000 # ClonalFrameML
# Introduction #
This is the homepage of ClonalFrameML, a software package that performs efficient inference of recombination in bacterial genomes. ClonalFrameML was created by [Xavier Didelot](http://xavierdidelot.github.io) and [Daniel Wilson](http://www.danielwilson.me.uk/). ClonalFrameML can be applied to any type of aligned sequence data, but is especially aimed at analysis of whole genome sequences. It is able to compare hundreds of whole genomes in a matter of hours on a standard Desktop computer. There are three main outputs from a run of ClonalFrameML: a phylogeny with branch lengths corrected to account for recombination, an estimation of the key parameters of the recombination process, and a genomic map of where recombination took place for each branch of the phylogeny.
ClonalFrameML is a maximum likelihood implementation of the Bayesian software [ClonalFrame](http://xavierdidelot.github.io/clonalframe.html) which was previously described by [Didelot and Falush (2007)](http://www.genetics.org/cgi/content/abstract/175/3/1251). The recombination model underpinning ClonalFrameML is exactly the same as for ClonalFrame, but this new implementation is a lot faster, is able to deal with much larger genomic dataset, and does not suffer from MCMC convergence issues. A scientific paper describing ClonalFrameML in detail has been published, see [Didelot X, Wilson DJ (2015) ClonalFrameML: Efficient Inference of Recombination in Whole Bacterial Genomes. PLoS Comput Biol 11(2): e1004041. doi:10.1371/journal.pcbi.1004041](http://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1004041).
# Download and Installation #
You can obtain the most up to date version of ClonalFrameML by downloading and compiling the C++ source code via GIT using the command:
```
git clone https://github.com/xavierdidelot/ClonalFrameML
```
Please note that the code for ClonalFrameML is distributed under the terms of the GNU GPL v3 license, for more details see https://www.gnu.org/copyleft/gpl.html
You can compile the code using the following command:
```
cd ClonalFrameML/src
./make.sh
```
Compilation requires a C++ compiler, such as [GCC](https://gcc.gnu.org/), to be installed. Running the bundled R scripts requires [R](http://cran.r-project.org/) to be installed with the ape and phangorn packages.
# User guide #
The user guide for ClonalFrameML is available [here](https://github.com/xavierdidelot/clonalframeml/wiki).
# Getting help #
If you need assistance using ClonalFrameML, you can get in touch by emailing either [Xavier Didelot](http://xavierdidelot.github.io/contact.html) or [Daniel Wilson](http://www.danielwilson.me.uk/contact.html).
ClonalFrameML-1.12/src/ 0000775 0000000 0000000 00000000000 13531251524 0014641 5 ustar 00root root 0000000 0000000 ClonalFrameML-1.12/src/bank/ 0000775 0000000 0000000 00000000000 13531251524 0015554 5 ustar 00root root 0000000 0000000 ClonalFrameML-1.12/src/bank/MLST.h 0000664 0000000 0000000 00000007755 13531251524 0016522 0 ustar 00root root 0000000 0000000 /* Copyright 2012 Daniel Wilson.
*
* MLST.h
* Part of the myutils library.
*
* The myutils 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 3 of the License, or
* (at your option) any later version.
*
* The myutils 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 the myutils library. If not, see .
*/
#ifndef _MLST_H_
#define _MLST_H_
#pragma warning(disable: 4786)
#include "myutils/myerror.h"
#include "myutils/vector.h"
#include "myutils/matrix.h"
#include "myutils/DNA.h"
using namespace myutils;
class MLST {
public:
int n; // number of sequences
int nloc; // number of loci
Vector nhap; // nhap[l] (l=0..nloc-1) gives the number of unique alleles at locus l
Vector allele; // allele[l] (l=0..nloc-1) stores the DNA sequences of the nhap[l] unique alleles at locus l
Matrix count; // count[l][i] (l=0..nloc-1,i=0..nhap[l]-1) is the count of unique allele i at locus l
Matrix haplotype; // haplotype[i] (i=0..n-1) gives the allelic profile for sequence i, so that
// haplotype[i][l] (l=0..nloc-1) is allele number at locus l, so that the DNA sequence
// is accessed using allele[l][haplotype[i][l]]. However, a short-cut would be, rather than
// using MLST.allele[l][haplotype[i][l]], to use MLST.seq(i,l).
public:
string& seq(const int i, const int l) {
return allele[l][haplotype[i][l]];
}
MLST() {};
MLST(const int nloc_in, const char* filename[]) {
nloc = nloc_in;
Vector temp(nloc);
int l;
for(l=0;l &temp) {
initialize(temp);
}
void initialize(Vector &temp) {
nloc = temp.size();
if(nloc<1) myutils::error("MLST::initialize(): must be at least one locus");
int l;
n = temp[0]->nseq;
for(l=1;lnseq!=n) myutils::error("MLST(): all loci should have the same number of sequences");
nhap.resize(nloc);
allele.resize(nloc);
haplotype = Matrix(n,nloc,-1);
count = Matrix(nloc,n,0);
Vector convert(n);
int i,j;
for(l=0;lsequence[i]==temp[l]->sequence[j]) {
++count[l][j];
haplotype[i][l] = j;
break;
}
int check_total = 0;
for(i=0;i0) ? 1 : 0;
check_total += count[l][i];
}
if(check_total!=n) myutils::error("MLST(): problem in counting haplotypes");
allele[l].resize(nhap[l],temp[l]->lseq);
int hap = 0;
for(i=0;i0) {
allele[l][hap] = temp[l]->sequence[i];
count[l][hap] = count[l][i];
convert[i] = hap;
++hap;
}
}
if(hap!=nhap[l]) myutils::error("MLST(): hap and nhap disagree");
for(;hap1) {
double pi = allele[l].pi();
double H = allele[l].H();
}*/
}
/*cout << "Allelic profiles of the " << n << " haplotypes" << endl;
for(i=0;i.
*/
#ifndef _APPROXDF_H_
#define _APPROXDF_H_
#include "myutils/vector.h"
#include "myutils/myerror.h"
#include
namespace myutils {
class approxdf {
public:
int n;
Vector CDF,G,EV,PR;
public:
approxdf() {
n = 0;
CDF = G = EV = PR = Vector(0);
}
approxdf(Vector &EV_in, Vector &PR_in) {
initialize(EV_in,PR_in);
}
void initialize(Vector &EV_in, Vector &PR_in) {
n = EV_in.size();
if(PR_in.size()!=n) error("approxdf(): EV and PR must have same length");
EV = Vector(n);
PR = Vector(n);
int i;
for(i=0;i0 && EV[i] PDF(n-1);
for(i=1;i(n); CDF[0] = 0;
for(i=1;i(n-1);
for(i=1;ix) {
--wh;
break;
}
}
if(wh==-1 || wh==n) error("cdf(): x lies outside original range");
//# A piecewise quadratic approximation to the c.d.f.
return CDF[wh]+(x-EV[wh])*(PR[wh]+G[wh]/2*(x-EV[wh]));
}
double icdf(const double U) {
int wh;
for(wh=0;whU) {
--wh;
break;
}
}
if(wh==-1) error("icdf(): U is less than 0");
if(wh==n) error("icdf(): U is greater than 1");
//# A piecewise inverse-quadratic approximation to the i.c.d.f.
return ((G[wh]*EV[wh]-PR[wh]+sqrt(PR[wh]*PR[wh]+2*G[wh]*(U-CDF[wh])))/G[wh]);
}
double pdf(const double x) {
int wh;
for(wh=0;whx) {
--wh;
break;
}
}
if(wh==-1 || wh==n) error("cdf(): x lies outside original range");
//# A piecewise linear approximation to the p.d.f.
return PR[wh]+(x-EV[wh])*G[wh];
}
};
}; //namespace myutils
#endif//_APPROXDF_H_
ClonalFrameML-1.12/src/bank/census.h 0000664 0000000 0000000 00000017566 13531251524 0017244 0 ustar 00root root 0000000 0000000 /* Copyright 2012 Daniel Wilson.
*
* census.h
* Part of the myutils library.
*
* The myutils 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 3 of the License, or
* (at your option) any later version.
*
* The myutils 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 the myutils library. If not, see .
*/
/********************************************/
/* census.h 28th August 2009 */
/* */
/* Keeps track of the membership of a */
/* finite number of individuals among a */
/* finite number of populations. */
/* */
/* (c) Danny Wilson. */
/* www.danielwilson.me.uk */
/********************************************/
#ifndef _MYUTILS_CENSUS_H_
#define _MYUTILS_CENSUS_H_
#include "myutils/myerror.h"
#include "myutils/vector.h"
#include "myutils/utils.h"
#include
//#include
using std::cout;
using std::endl;
namespace myutils {
class Census {
public:
/*Default constructor*/
Census() {
Vector where(0);
initialize(0,0,where);
}
/*Constructor*/
Census(const unsigned int npop, const unsigned int nind) {
Vector where(nind,0);
initialize(npop,nind,where);
}
/*Constructor*/
Census(const unsigned int npop, const unsigned int nind, Vector &where) {
initialize(npop,nind,where);
}
/*Copy constructor*/
Census(const Census& cen) {
_npop = cen._npop;
_nind = cen._nind;
_where = cen._where;
_who = cen._who;
_index = cen._index;
_mind = cen._mind;
_cind = cen._cind;
}
/*Assignment operator*/
Census& operator=(const Census& cen) {
_npop = cen._npop;
_nind = cen._nind;
_where = cen._where;
_who = cen._who;
_index = cen._index;
_mind = cen._mind;
_cind = cen._cind;
return *this;
}
Census& initialize(const unsigned int npop, const unsigned int nind, Vector &where) {
if(npop<0) error("Census::Census(): number of populations must be non-negative");
if(nind<0) error("Census::Census(): number of individuals must be non-negative");
/* Accept the arguments */
_npop = npop;
_nind = nind;
/* Initialize the membership lists */
_where = Vector(_nind);
_mind = Vector(_npop,0);
int i;
for(i=0;i<_nind;i++) {
if(where[i]<0) error("Census::Census(): population cannot be negative");
if(where[i]>=_npop) error("Census::Census(): population number exceeds maximum");
_where[i] = where[i];
_mind[where[i]]++;
}
/* Calculate the cumulative membership numbers */
_cind = Vector(_npop,0);
int p;
for(p=1;p<_npop;p++) {
_cind[p] = _cind[p-1] + _mind[p-1];
}
if(_npop>0 && _cind[_npop-1]+_mind[_npop-1]!=_nind) error("Census::Census(): number of individuals doesn't match");
/* Initialize the who list */
_who = Vector(_nind);
_index = Vector(_nind);
Vector _tind(_npop,0);
for(i=0;i<_nind;i++) {
const int pop = _where[i];
const int ix = _cind[pop]+_tind[pop];
_who[ix] = i;
_index[i] = ix;
++_tind[pop];
}
return *this;
}
/*Destructor*/
~Census() {}
/*Simple functions*/
int npop() {return _npop;}
int nind() {return _nind;}
int nind(const int p) {return _mind[p];}
Vector where() {return _where;}
int where(const int i) {return _where[i];}
Vector who(const int p) {
if(p<0 || p>=_npop) error("Census::who(): Population p out of range");
Vector ret(_mind[p]);
int i;
for(i=0;i<_mind[p];i++) {
ret[i] = _who[_cind[p]+i];
}
return ret;
}
int who(const int p, const int i) {return _who[_cind[p]+i];}
int ferocious_who(const int p, const int i) {
if(p<0 || p>=_npop) error("Census::who(): Population p out of range");
if(i<0 || i>=_mind[p]) error("Census::who(): Index i out of range for population p");
return _who[_cind[p]+i];
}
int meek_who(const int p, const int i) {
if(p<0 || p>=_npop) return -1;
if(i<0 || i>=_mind[p]) return -1;
return _who[_cind[p]+i];
}
/* Last individual in the population */
int last(const int p) {
if(p<0 || p>=_npop) error("Census::last(): population out of range");
if(_mind[p]==0) error("Census::last(): population is empty");
return _who[_cind[p]+_mind[p]-1];
}
/*Not-so simple functions*/
int migrate(const int from, const int to) {
const int ind = last(from);
migrate(ind,from,to);
return ind;
}
/* ind is the absolute index of the individual */
Census& migrate(const int ind, const int from, const int to) {
if(from==to) return *this;
if(from<0 || from>=_npop) error("Census::migrate(): donor population out of range");
if(_where[ind]!=from) error("Census::migrate(): individual is not member of donor population");
if(to<0 || to>=_npop) error("Census::migrate(): recipient population out of range");
if(fromto;p--) {
/* 1. Add to new pop */
--_mind[p];
++_mind[p-1];
++_cind[p];
/* 2. Swap from last to first position */
const int ix_from = _cind[p-1]+_mind[p-1]-1;
const int ix_to = _cind[p-1];
const int ifrom = _who[ix_from];
const int ito = _who[ix_to];
SWAP(_who[ix_from],_who[ix_to]);
SWAP(_index[ifrom],_index[ito]);
}
/* Update _where */
_where[ind] = to;
}
return *this;
}
Census& inspect() {
int i;
cout << "_where = {" << _where[0];
for(i=1;i<_nind;i++) cout << " " << _where[i];
cout << "}" << endl;
cout << "_who = {" << _who[0];
for(i=1;i<_nind;i++) cout << " " << _who[i];
cout << "}" << endl;
cout << "_index = {" << _index[0];
for(i=1;i<_nind;i++) cout << " " << _index[i];
cout << "}" << endl;
cout << "_mind = {" << _mind[0];
for(i=1;i<_npop;i++) cout << " " << _mind[i];
cout << "}" << endl;
cout << "_cind = {" << _cind[0];
for(i=1;i<_npop;i++) cout << " " << _cind[i];
cout << "}" << endl;
return *this;
}
protected:
/* Number of populations */
int _npop;
/* Number of individuals */
int _nind;
/* _where[i], i=0.._nind-1, has value [0,_npop-1],
Population to which individual i belongs */
Vector _where;
/* _who[i], i=0.._nind-1, has value [0,_nind-1],
Collapsed unordered list of individuals belonging to the
population to which i corresponds */
Vector _who;
/* _index[i], i=0.._nind-1, has value [0,_nind-1],
Position of individual i in vector _who */
Vector _index;
/* _mind[p], p=0.._npop-1, has value [0,_nind],
Number of members of population p */
Vector _mind;
/* _cind[p], p=0.._npop-1, has value [0,_nind],
Cumulative number of members of population p */
Vector _cind;
};
};
#endif // _MYUTILS_CENSUS_H_
ClonalFrameML-1.12/src/bank/cmatrix.h 0000664 0000000 0000000 00000010325 13531251524 0017375 0 ustar 00root root 0000000 0000000 /* Copyright 2012 Daniel Wilson.
*
* cmatrix.h
* Part of the myutils library.
*
* The myutils 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 3 of the License, or
* (at your option) any later version.
*
* The myutils 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 the myutils library. If not, see .
*/
/********************************************/
/* cmatrix.h 23rd February 2005 */
/* (c) Danny Wilson. */
/* www.danielwilson.me.uk */
/********************************************/
#ifndef _CMATRIX_H_
#define _CMATRIX_H_
#include
#include
namespace myutils
{
/*Cannot accept objects of type class*/
template
class CMatrix
{
public:
/*Preserve public access for back-compatibility*/
T **element;
protected:
int protected_nrows;
int protected_ncols;
int initialized;
public:
/*Default constructor*/ CMatrix()
{
initialized=0;
initialize(0,0);
}
/*Constructor*/ CMatrix(int nrows, int ncols)
{
initialize(nrows,ncols);
}
/*Constructor*/ CMatrix(int nrows, int ncols, T value)
{
initialize(nrows,ncols);
int i,j;
for(i=0;i=0;i--) free((T*) element[i]);
free((T**) element);
}
CMatrix& initialize(int nrows, int ncols)
{
element=(T **) malloc((unsigned) nrows*sizeof(T*));
if (!element) error("row allocation failure in Matrix::initialize()");
int i;
for(i=0;i& resize(int nrows, int ncols)
{
int i;
if (!initialized) initialize(nrows,ncols);
else
{
if(nrows!=protected_nrows)
{
element=(T **) realloc(element,(unsigned) nrows*sizeof(T*));
if (!element) error("row allocation failure in Matrix::resize()");
if(nrows=nrows;i--)
free ((T*) element[i]);
}
if(nrows>protected_nrows)
{
for(i=protected_nrows;i& mat)
/* Copy constructor for the following cases:
Matrix mat2(mat);
Matrix mat2=mat;
and when Matrix is returned from a function */
{
initialize(mat.nrows(),mat.ncols());
int i,j;
for(i=0;i& operator=(CMatrix& mat)
{
if(this==&mat)return *this;
resize(mat.nrows(),mat.ncols());
int i,j;
for(i=0;i.
*/
#ifndef _HRCOALESCENT_H_
#define _HRCOALESCENT_H_
//#include "coalesce/coalescent_control.h"
//#include "coalesce/coalescent_process.h"
#include "coalesce/coalescent_record.h"
#endif
ClonalFrameML-1.12/src/bank/coalescent_control.h 0000664 0000000 0000000 00000021344 13531251524 0021611 0 ustar 00root root 0000000 0000000 /* Copyright 2013 Daniel Wilson.
*
* coalescent_control.h
* Part of the coalesce library.
*
* The myutils 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 3 of the License, or
* (at your option) any later version.
*
* The myutils 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 the myutils library. If not, see .
*/
#ifndef _CONTROL_H_
#define _CONTROL_H_
#pragma warning(disable: 4786)
#include
#include
#include
#include
using namespace std;
#include "myutils/matrix.h"
#include "myutils/controlwizard.h"
using myutils::Matrix;
using myutils::ControlWizard;
using myutils::TP_UNRECOGNISED;
using myutils::TP_INT;
using myutils::TP_DOUBLE;
using myutils::TP_STRING;
using myutils::TP_VEC_INT;
using myutils::TP_VEC_DOUBLE;
using myutils::TP_EXT_VEC_DOUBLE;
//using myutils::DATA_TYPE;
class Control
{
public:
int nsamp; // Sample size
vector ntimes; // Times (in Ne gens) of samples, ordering unimportant
double Negens; // Expresses 1 unit of Ne gens in the same units as ntimes
int loci; // Number of independent loci simulated
int seq_len; // Total length of sequences simulated
vector len; // Lengths for each locus
double r; // Per site rate of crossing-over per Negens (standard model, lambda = 0)
// or TWICE the per site rate of initiation of recombination per Negens
// (bacterial model, lambda > 0)
vector rmap; // Map for heterogeneous recombination rates
double lambda; // 1/mean tract length
double M; // headline per site mutation rate
int n_states; // number of states (e.g. 4 nucleotides, 64 codons)
vector state_freq; // initial state frequencies
vector state_rel_mut_rate; // mutation rates relative to headline mutation rate
vector state_M; // 1/(state-specific per site mutation rate)
// (to be calculated)
Matrix mut_matrix; // transition matrix for the states
vector state_name; // letters for the states
int nruns; // store this in control class also
int update_interval;
bool coutput;
/* Variables for structured coalescent */
int ndemes;
vector deme_config; // for each sample member, their starting deme (0..ndemes-1)
Matrix mig; // ndemes * ndemes matrix: double the backwards in time migration rate from i to j
vector N_deme_over_D; // for each deme, the pop size relative to the total
public:
Control()
{
coutput=true;
/* Set defaults */
nsamp = 2;
ntimes = vector(2,0.0);
Negens = 1.0;
loci = 1;
seq_len = 1;
len = vector(1,1);
r = lambda = M = 0.0;
rmap = vector(0);
ndemes = 0;
}
Control& read_input(char* filename)
{
seq_len=-1;
Negens=1.0; //By default
ControlWizard control_file;
control_file.coutput=coutput;
control_file.add_ITEM("n",TP_INT,&nsamp);
control_file.add_ITEM("ntimes",TP_VEC_DOUBLE,&ntimes);
control_file.add_item("Negens",TP_DOUBLE,&Negens);
control_file.add_ITEM("loci",TP_INT,&loci);
control_file.add_ITEM("len",TP_VEC_INT,&len);
control_file.add_ITEM("lambda",TP_DOUBLE,&lambda);
control_file.add_ITEM("n_states",TP_INT,&n_states);
control_file.add_ITEM("mu",TP_DOUBLE,&M);
control_file.add_ITEM("r",TP_DOUBLE,&r);
vector temp_mut_matrix;
control_file.add_ITEM("mut_matrix",TP_EXT_VEC_DOUBLE,&temp_mut_matrix);
control_file.add_item("state_rel_mut_rate",TP_EXT_VEC_DOUBLE,&state_rel_mut_rate);
control_file.add_item("state_M",TP_EXT_VEC_DOUBLE,&state_M);
control_file.add_ITEM("state_freq",TP_EXT_VEC_DOUBLE,&state_freq);
control_file.add_item("nruns",TP_INT,&nruns);
control_file.add_item("seq_len",TP_INT,&seq_len);
control_file.add_ITEM("update_interval",TP_INT,&update_interval);
control_file.read_input(filename);
if(coutput)control_file.check_required();
else
if(!control_file.got_required)error("Not all necessary items found in control file");
/*Check for necessary parameters*/
if(!control_file.got_required)error("read_input(): necessary parameters not found");
vector_to_Matrix(&temp_mut_matrix,&mut_matrix,n_states,n_states);
if(ntimes.size()!=nsamp)error("ntimes inconsistent in size with n");
sort(ntimes.begin(),ntimes.end());
if(coutput) {
int o;
for(o=0;o<(int)ntimes.size();o++)printf("%g ",ntimes[o]);
}
if(len.size()!=loci)error("len inconsistent in size with loci");
if(state_freq.size()!=n_states)error("state_freq inconsistent in size with n_states");
if(update_interval==0)update_interval=1;
int ind_seq_len=0;
int i;
for(i=0;i0)
{
one_or_the_other=true;
got_state_M=true;
}
if(state_rel_mut_rate.size()>0)
one_or_the_other=true;
if(!one_or_the_other)error("read_input(): neither state_M or state_rel_mut_rate received");
if(got_state_M)
{
if(state_M.size()!=n_states)error("state_M inconsistent in size with n_states");
state_rel_mut_rate.resize(n_states);
int i;
for(i=0;i *vec, Matrix *mat, int rows, int cols)
{
if((int)vec->size()<(rows*cols))error("vector_to_Matrix(): vector too small to fill matrix");
if((int)vec->size()>(rows*cols))error("vector_to_Matrix(): vector too large to fit matrix");
mat->resize(rows,cols);
int current_row=0;
int i,j;
for(i=0;i<(int)vec->size();i+=cols)
{
for(j=0;jelement[current_row][j]=vec->at(i+j);
}
++current_row;
}
return *this;
}
Control& read_mut_matrix(Matrix &G, vector &pi)
{
/*Check it is a rate matrix*/
int i,j;
if(G.nrows()!=G.ncols())error("read_mut_matrix(): not a square matrix");
for(i=0;i.
*/
#ifndef _COALESCENT_PROCESS_H_
#define _COALESCENT_PROCESS_H_
#include
#include
#include
#include
using namespace std;
#include "myutils/matrix.h"
using myutils::Matrix;
#include "myutils/random.h"
using myutils::Random;
#include "myutils/myerror.h"
using myutils::error;
#include "coalesce/coalescent_record.h"
#include "coalesce/coalescent_control.h"
#include "coalesce/mutation.h"
class ptr_vector
{
int size;
public:
class mt_node **ptr; //vec of generic ptrs
public:
ptr_vector() {};
ptr_vector& initialize(const int size_in)
{
size=size_in;
ptr=(class mt_node**) malloc((size_t) size*sizeof(class mt_node*));
int i;
for(i=0;iptr[i];
return *this;
}
ptr_vector& copy(ptr_vector *donor, const int position)
{
ptr[position]=donor->ptr[position];
return *this;
}
ptr_vector& copy(ptr_vector *donor)
{
int i;
for(i=0;iptr[i];
return *this;
}
inline ptr_vector& assign(class mt_node *target, const int position)
{
ptr[position]=target;
return *this;
}
inline ptr_vector& assign(class mt_node *target, const int from, const int to)
{
int i;
for(i=from;i<=to;i++)
ptr[i]=target;
return *this;
}
int get_size() {return size;};
~ptr_vector()
{
//nullify();
free((class mt_node**) ptr);
}
};
class ap_node
{
public:
/*Fixed once*/
int id;
/*Recyclable*/
enum {NOT_IN_USE,IN_USE,FIXED_NODE} flag;
int deme; // records the deme the node belongs to
double time;
class ptr_vector AMP;
double rlen;
double L;
int ltr;
int rtr;
int active_id; // records the position in active_node
int ctree_id; // records the position in the conditional marginal tree
public:
ap_node() {};
ap_node& initialize(const int id_in, const int size)
{
id=id_in;
active_id = ctree_id = -1;
AMP.initialize(size);
recycle();
return *this;
}
ap_node& recycle()
{
flag = NOT_IN_USE;
active_id = ctree_id = deme = -1;
//time=0.0;
//AMP.nullify();
return *this;
}
ap_node& activate(double *time_in)
{
flag = IN_USE;
time=*time_in;
return *this;
}
~ap_node() {};
};
class eventChain {
public:
enum eventType {NONE,COALESCENCE,RECOMBINATION,ADD_LINEAGE,END};
protected:
class eventChainEvent {
public:
double k,rlen,time;
eventType type;
eventChainEvent() {
k = rlen = time = 0.0;
type = NONE;
}
};
vector ev;
public:
double rho;
public:
eventChain() {
ev = vector(0);
}
eventChain(const int size_in) {
ev = vector(size_in);
}
const int size() const {
return (int)ev.size();
}
void resize(const int size_in) {
// cout << "resize to " << size_in << endl;
if(size_in<0) myutils::error("eventChain::resize(): cannot have a negative size");
ev.resize(size_in);
// cout << "done resizing" << endl;
}
eventChainEvent& operator[](const int pos) {
return ev[pos];
}
double loglikelihood(const double rh) {
if(ev.size()<=0) myutils::error("eventChain::loglikelihood(): chain has zero length");
if(ev[0].type==NONE) myutils::error("eventChain::loglikelihood(): no chain exists");
int e = 0;
if(ev[e].type==END) myutils::error("eventChain::loglikelihood(): first event is the last");
double rate = (ev[e].k*ev[e].rlen*rh + ev[e].k*(ev[e].k-1.0))/2.0;
double prec = ev[e].k*ev[e].rlen*rh/2.0/rate;
double L = 0.0;
if(ev[e].type==ADD_LINEAGE) {
L += - rate * (ev[e].time);
}
else if(ev[e].type==RECOMBINATION) {
L += log(rate) - rate * (ev[e].time) + log(prec);
}
else if(ev[e].type==COALESCENCE) {
L += log(rate) - rate * (ev[e].time) + log(1.-prec);
}
for(e=1;e<(int)ev.size();e++) {
if(ev[e].type==END) break;
rate = (ev[e].k*ev[e].rlen*rh + ev[e].k*(ev[e].k-1.0))/2.0;
prec = ev[e].k*ev[e].rlen*rh/2.0/rate;
if(ev[e].type==ADD_LINEAGE) {
L += - rate * (ev[e].time - ev[e-1].time);
}
else if(ev[e].type==RECOMBINATION) {
L += log(rate) - rate * (ev[e].time - ev[e-1].time) + log(prec);
}
else if(ev[e].type==COALESCENCE) {
L += log(rate) - rate * (ev[e].time - ev[e-1].time) + log(1.-prec);
}
}
if(e==ev.size()) error("eventChain::loglikelihood() chain has no end");
return L;
}
};
class coalescent
{
public:
/*Fixed*/
class Control *con; //ptr to con
class Random *ran; //ptr to ran
class marginal_tree *tree; //vec of tree's
class ap_node **node; //vec of ptrs to ap_node's
class ap_node **active_node;//vec of ptrs to ap_node's
class ap_node **inactive_node;//vec of ptrs to ap_node's
int nodes_reserved;
int L;
int **segregating_tree;
int **internal_seg_tree;
int seg_tree_id;
Matrix genotype;
bool no_gene_conversion;
/*Recyclable*/
int n_inactive;
int ARG_k; //#lineages in ARG
int gen; //number of events
double total_rlen;
double rho; //total_rlen/ARG_k
int n_segregating;
bool samples_waiting;
double time_next_sample; // contemporaneous samples
vector::iterator ntimes_itr;// iterator for rifling through con->ntimes
int next_waiting_sample;
int nrecTypeI;
int nrecTypeII;
int nrecTypeIII;
int nco,nrec,naddbase,nmut;
vector nrecWatt;
int ncoI,ncoIIa,ncoIIb,ncoIII;
/* Variables for conditional simulation */
int ARG_k_fixed;
vector ftimes; // times for fixed events
vector fnode;
/* Variables for structured coalescent */
ap_node ***ptr_deme; // con->ndemes * con->nsamp matrix: members of each deme
Vector k_deme; // number of ancestral lineages in each deme
Vector rho_deme; // effective recn rate of each deme
Vector sum_mig; // total backwards-in-time mig for each deme i
double rate_coal, rate_recn, rate_mign;
Vector coal_deme;
protected:
vector _uniqueHaps;
vector _sites;
LowerTriangularMatrix ____B;
vector _M;
vector _F;
vector _four;
LowerTriangularMatrix< vector > _G;
LowerTriangularMatrix _A,___B,___C;
Matrix _D;
public:
coalescent() {};
coalescent& initialize(class Control *con_in, class Random *ran_in)
{
con=con_in;
ran=ran_in;
if(con->nsamp<0) con->nsamp = 0;
if(con->ntimes.size()==0) con->ntimes = vector(con->nsamp,0.0);
if(con->seq_len<0) con->seq_len = 0;
if(con->Negens<0) con->Negens = 1;
if(con->len.size()==0) con->len = vector(1,con->seq_len);
if(con->r<0.0) con->r = 0.0;
if(con->lambda<0.0) con->lambda = 0.0;
if(con->lambda==0.0)no_gene_conversion=true;
else no_gene_conversion=false;
L=con->seq_len;
tree=(class marginal_tree*) malloc((size_t) L*sizeof(marginal_tree));
int i;
for(i=0;insamp);
internal_seg_tree=(int**) malloc((size_t) 2*sizeof(int*));
internal_seg_tree[0]=(int*) malloc((size_t) L*sizeof(int));
internal_seg_tree[1]=(int*) malloc((size_t) L*sizeof(int));
seg_tree_id=0;
segregating_tree=&(internal_seg_tree[seg_tree_id]);
ARG_k=ARG_k_fixed=0;
node=(class ap_node**) malloc((size_t) ARG_k*sizeof(ap_node*));
active_node=(class ap_node**) malloc((size_t) ARG_k*sizeof(ap_node*));
inactive_node=(class ap_node**) malloc((size_t) ARG_k*sizeof(ap_node*));
if(con->ndemes>0) {
ptr_deme = (ap_node***) malloc((size_t) con->ndemes*sizeof(ap_node**));
for(i=0;indemes;i++) ptr_deme[i] = (ap_node**) malloc((size_t) ARG_k*sizeof(ap_node*));
}
n_inactive=0;
nodes_reserved=0;
reserve_nodes(10*con->nsamp);
genotype.initialize(con->nsamp,L);
return *this;
}
coalescent& go()
{
recycle();
if(add_next_sample()!=0.0)error("Most recent node does not occur at time zero");
double current_time=0.0;
gen=0;
while((ARG_k>1)||(samples_waiting))
{
//event(¤t_time);
double denom = 1.0/((double)ARG_k*rho+(double)ARG_k*((double)ARG_k-1.0));
current_time += constant_size_model(2.0*denom);
if((samples_waiting)&&(current_time>=time_next_sample))
{
current_time = add_next_sample();
}
else
{
/*2nd, choose type of event*/
double rnum1 = ran->U();
double pr_recom=(double)ARG_k*rho*denom;
if (rnum1 <= pr_recom) recombine(¤t_time);
else coalesce(¤t_time);
}
++gen;
}
return *this;
}
coalescent& go(eventChain& e)
{
recycle();
if(add_next_sample()!=0.0)error("Most recent node does not occur at time zero");
double current_time=0.0;
gen=0;
e.rho = 2.0*con->r;
if(e.size()<1000) e.resize(1000);
while((ARG_k>1)||(samples_waiting))
{
if(e.size()<=gen) e.resize(2*e.size());
double denom = 1.0/((double)ARG_k*rho+(double)ARG_k*((double)ARG_k-1.0));
current_time += constant_size_model(2.0*denom);
e[gen].k = (double)ARG_k;
e[gen].rlen = rho/e.rho;
e[gen].time = current_time;
if((samples_waiting)&&(current_time>=time_next_sample))
{
current_time = add_next_sample();
e[gen].time = current_time;
e[gen].type = eventChain::ADD_LINEAGE;
}
else
{
/*2nd, choose type of event*/
double rnum1 = ran->U();
double pr_recom=(double)ARG_k*rho*denom;
if (rnum1 <= pr_recom) {
recombine(¤t_time);
e[gen].type = eventChain::RECOMBINATION;
}
else {
coalesce(¤t_time);
e[gen].type = eventChain::COALESCENCE;
}
}
++gen;
}
e[gen-1].type = eventChain::END;
return *this;
}
coalescent& migrate()
{
recycle();
if(add_next_sample()!=0.0)error("Most recent node does not occur at time zero");
double current_time=0.0;
gen=0;
int i,j;
//const char tab = '\t';
//for(i=0;indemes;i++) cout << tab << "k" << i << tab << "co" << tab << "mig";
//cout << endl;
//cout << setprecision(3);
//Vector k_avg(con->ndemes,0);
while((ARG_k>1)||(samples_waiting))
{
//if(gen%2==0) {
rate_coal = rate_recn = rate_mign = 0.0;
for(i=0;indemes;i++) {
coal_deme[i] = (double)k_deme[i] * (double)(k_deme[i]-1) / con->N_deme_over_D[i];
rate_coal += coal_deme[i];
rate_recn += rho_deme[i];
rate_mign += (double)k_deme[i] * sum_mig[i];
}
rate_coal /= 2.0;
rate_recn /= 2.0;
rate_mign /= 2.0;
//}
//cout << current_time;
//for(i=0;indemes;i++) {
// cout << tab << k_deme[i] << tab << coal_deme[i]/2. << tab << (double)k_deme[i] * sum_mig[i]/2.;
// k_avg[i] += k_deme[i];
//}
//cout << endl;
double denom = (rate_coal + rate_recn + rate_mign);
current_time += constant_size_model(1.0/denom);
if((samples_waiting)&&(current_time>=time_next_sample))
{
current_time = add_next_sample();
}
else
{
/*2nd, choose type of event*/
double rnum1 = ran->U() * denom;
if(rnum1 <= rate_coal) migrate_coalesce(¤t_time);
else if(rnum1 <= rate_coal+rate_recn) migrate_recombine(¤t_time);
else migrate_migrate(¤t_time);
}
for(i=0;indemes;i++)
for(j=0;jflag==ap_node::NOT_IN_USE) error("migrate(): pointer problem");
++gen;
}
//cout << current_time;
//for(i=0;indemes;i++) cout << tab << (double)k_avg[i]/(double)gen;
//cout << endl;
return *this;
}
coalescent& conditional(class marginal_tree &ctree)
{
recycle();
int i;
fnode = vector(ctree.size,(ap_node*)NULL);
ftimes = vector(ctree.size,0.0);
for(i=0;i1)||(samples_waiting))
{
//event(¤t_time);
//double denom = (double)ARG_k*rho+2.*(double)(ARG_k_fixed)*(double)(ARG_k-ARG_k_fixed);
//if(ARG_k>ARG_k_fixed) denom += (double)(ARG_k-ARG_k_fixed)*((double)(ARG_k-ARG_k_fixed)-1.0);
double denom = (double)ARG_k*rho+(double)(ARG_k)*(double)(ARG_k-1);
if(ARG_k_fixed>1) denom -= (double)(ARG_k_fixed)*(double)(ARG_k_fixed-1);
if(denom == 0.0) {
if(samples_waiting) current_time = add_conditional_event(ctree);
else error("conditional(): infinite time until next event");
}
else {
denom = 1.0/denom;
current_time += constant_size_model(2.0*denom);
if((samples_waiting)&&(current_time>=time_next_sample))
{
current_time = add_conditional_event(ctree);
}
else
{
/*2nd, choose type of event*/
double rnum1 = ran->U();
double pr_recom=(double)ARG_k*rho*denom;
if (rnum1 <= pr_recom) {
conditionally_recombine(¤t_time);
/*if(tree[0].node[2].time!=0) {
warning("MRCA is not supposed to be found during recombination");
}*/
}
else {
conditionally_coalesce(¤t_time);
}
}
}
if(ARG_k_fixed==1) {
warning("Single fixed lineage left");
}
if(ARG_k_fixed>0)
for(i=0;i<(int)fnode.size();i++) if(fnode[i]!=NULL) if(fnode[i]->active_id==-1) {
warning("fnode inconsistency");
}
if(ARG_k_fixed>ARG_k) error("conditional(): ARG_k_fixed > ARG_k");
for(i=0;iactive_id!=i) error("conditional(): active_id's incorrect");
int ctr_fnode = 0;
for(i=0;i ARG_k_fixed");
++gen;
}
return *this;
}
coalescent& mutate()
{
int i;
for(i=0;idraw(),M);
return *this;
}
coalescent& mutate(const int site, Mutation_Matrix *M) {
mutate_tree(site,tree[site].size-1,M->draw(),M);
return *this;
}
coalescent& mutate(const int site, Mutation_Matrix *M, vector& mutLog) {
mutLog.clear();
mutate_tree_and_record(site,tree[site].size-1,M->draw(),M,mutLog);
return *this;
}
coalescent& output_FASTA(vector &code, const char* filename)
{
FILE* fout=fopen(filename,"w");
// fprintf(fout,"%d %d\n\n",con->nsamp,con->seq_len);
int n;
for(n=0;nnsamp;n++)
{
fprintf(fout,">seq%d_%g\n",n,con->ntimes[n]*con->Negens);
int pos;
for(pos=0;posseq_len;pos++)
fprintf(fout,"%c",code[(int)genotype[n][pos]]);
fprintf(fout,"\n");
}
fclose(fout);
return *this;
}
coalescent& output_FASTA(vector code, const char* filename)
{
// FILE* fout=fopen(filename,"w");
// fprintf(fout,"%d %d\n\n",con->nsamp,con->seq_len);
ofstream fout(filename);
// fout << con->nsamp << " " << con->seq_len << endl << endl;
int n;
for(n=0;nnsamp;n++)
{
fout << ">seq" << n << "_" << con->ntimes[n]*con->Negens << endl;
//fprintf(fout,">seq%d_%g\n",n,con->ntimes[n]*con->Negens);
int pos;
for(pos=0;posseq_len;pos++)
fout << code[(int)genotype[n][pos]];
//fprintf(fout,"%s",code[genotype[n][pos]].c_str());
fout << endl;
//fprintf(fout,"\n");
}
//fclose(fout);
fout.close();
return *this;
}
/* which is a vector true or false whether to include each sequence */
coalescent& output_FASTA(vector &code, const char* filename, vector &which)
{
if(which.size()!=con->nsamp) error("coalescent::output_FASTA(): which must have length nsamp");
FILE* fout=fopen(filename,"w");
int n;
for(n=0;nnsamp;n++)
{
if(which[n]) {
fprintf(fout,">seq%d_%g\n",n,con->ntimes[n]*con->Negens);
int pos;
for(pos=0;posseq_len;pos++)
fprintf(fout,"%c",code[(int)genotype[n][pos]]);
fprintf(fout,"\n");
}
}
fclose(fout);
return *this;
}
/* which is a vector true or false whether to include each sequence */
coalescent& output_FASTA(vector &code, const char* filename, vector &which)
{
if(which.size()!=con->nsamp) error("coalescent::output_FASTA(): which must have length nsamp");
ofstream fout(filename);
int n;
for(n=0;nnsamp;n++)
{
if(which[n]) {
fout << ">seq" << n << "_" << con->ntimes[n]*con->Negens << endl;
int pos;
for(pos=0;posseq_len;pos++)
fout << code[(int)genotype[n][pos]];
fout << endl;
}
}
fout.close();
return *this;
}
coalescent& output_MEP(const char* filename)
{
FILE* fout=fopen(filename,"w");
fprintf(fout,"n=%d, mu=%g, r=%g, Negens=%g\n",con->nsamp,con->M/con->Negens,con->r/con->Negens,con->Negens);
fprintf(fout,"Time points = ");
int i;
for(i=0;i<(int)con->ntimes.size();i++)fprintf(fout,"%g ",con->ntimes[i]*con->Negens);
fprintf(fout,"\n\n");
int mrca=2*con->nsamp-2;
double t_height=0.0;
for(i=0;iseq_len;i++)
{
double temp=tree[i].node[mrca].time;
if(t_height!=tree[i].node[mrca].time)
{
t_height=tree[i].node[mrca].time;
fprintf(fout,"Position %d\tHeight %g\t\t%g\n",i,t_height,t_height*con->Negens);
}
}
fclose(fout);
return *this;
}
coalescent& output_tree(const int site)
{
/*This node is always the mrca*/
int mrca=2*(con->nsamp-1);
int i=site;
/*Create names for the files*/
stringstream ageout_file;
ageout_file << "age" << i << ".dat";
stringstream treeout_file;
treeout_file << "tree" << i << ".dat";
/*Open them for writing*/
FILE *ageout = fopen(ageout_file.str().c_str(), "w");
FILE *treeout = fopen(treeout_file.str().c_str(), "w");
int tree_id=site;
/*ageout contains ages for each of the nodes*/
int j;
for(j=0;j<=mrca;j++)
{
fprintf(ageout,"%d %g\n",mrca-j,10.0*tree[tree_id].node[j].time);
}
/*treeout contains the labels for each of the base nodes*/
/*followed by a colon then a list of all nodes ancestral to it*/
for(j=0;jnsamp;j++)
{
int gt=(int)genotype[j][tree_id];
fprintf(treeout,"%2d : %d ",gt+1,mrca-j);
class mt_node* anc;
class mt_node* nextanc=tree[tree_id].node[j].ancestor;
do
{
anc=nextanc;
fprintf(treeout,"%d ",mrca-anc->id);
nextanc=anc->ancestor;
}while(nextanc!=NULL);
fprintf(treeout,"\n");
}
fclose(ageout);
fclose(treeout);
FILE *tpicout = fopen("tpic.bat","w");
int number=1;
for(i=0;indemes>0) {
for(i=con->ndemes-1;i>=0;i--) free((ap_node**) ptr_deme[i]);
free((ap_node***) ptr_deme);
}
for(i=0;indemes>0) {
for(i=0;indemes;i++)
ptr_deme[i] = (ap_node**) realloc(ptr_deme[i],(size_t) number*sizeof(ap_node*));
}
for(i=nodes_reserved;iinitialize(i,L);
inactive_node[n_inactive]=node[i];
++n_inactive;
}
nodes_reserved=number;
return *this;
}
coalescent& recycle()
{
int i,j;
for(i=0;intimes.begin();
next_waiting_sample=0;
nrecTypeI=0;
nrecTypeII=0;
nrecTypeIII=0;
nco=nrec=naddbase=nmut=0;
nrecWatt = vector(con->seq_len,0);
ncoI=ncoIIa=ncoIIb=ncoIII=0;
if(con->ndemes>0) {
for(i=0;indemes;i++)
for(j=0;j(con->ndemes,0);
rho_deme = Vector(con->ndemes,0.0);
if(con->N_deme_over_D.size()!=con->ndemes) error("recycle(): con->N_deme_over_D wrong # demes");
if(con->mig.nrows()!=con->ndemes) error("recycle(): con->mig wrong number of rows");
if(con->mig.ncols()!=con->ndemes) error("recycle(): con->mig wrong number of columns");
sum_mig = Vector(con->ndemes,0.0);
coal_deme = Vector(con->ndemes,0.0);
if(con->deme_config.size()!=con->nsamp) error("recycle(): con->deme_config wrong sample size");
for(i=0;indemes;i++)
for(j=0;jndemes;j++)
sum_mig[i] += con->mig[i][j];
}
if(!no_gene_conversion && con->lambda<=0.0) error("coalescent::recycle(): lambda<=0.0 in gene conversion model");
return *this;
}
coalescent& event(double *time)
{
double denom = 1.0/((double)ARG_k*rho+(double)ARG_k*((double)ARG_k-1.0));
(*time)+=constant_size_model(2.0*denom);
if((samples_waiting)&&((*time)>=time_next_sample))
{
(*time) = add_next_sample();
}
else
{
/*2nd, choose type of event*/
double rnum1 = ran->U();
double pr_recom=(double)ARG_k*rho*denom;
if (rnum1 <= pr_recom) recombine(time);
else coalesce(time);
}
return *this;
}
coalescent& coalesce(double *time)
{
++nco;
/*Create new lineage in the ARG*/
class ap_node *new_node=create_node(time);
//printf(" : ");int o;for(o=0;oid);printf("\n");
/*NB If you deactivate the nodes before */
/*creating the new one then you overwrite*/
/*memory you want to read from! */
/*However, must not allow the new node to*/
/*be chosen as one of the coalescing */
/*nodes. Since it is added at the end of */
/*the active_node vector, simply restrict*/
/*the maximum node that can be chosen. */
/*Choose 1st lineage to coalesce*/
int lin1=ran->discrete(0,ARG_k-2); //New node is in position ARG_k-1, so do not
class ap_node *ap_node1=active_node[lin1]; //allow this position to be chosen
deactivate_node(lin1);
//printf(" : ");for( o=0;oid);printf("\n");
/*Unfortunately, now the new node has */
/*been switched into position lin1 in the*/
/*vector. Therefore, restrict the maximum*/
/*again and if lin1 is chosen, override */
/*it and choose the end lineage. */
/*Choose 2nd lineage to coalesce*/ //New node is now in position lin1, so if it
int lin2=ran->discrete(0,ARG_k-2); //is chosen, force it to choose the last old node
if(lin2==lin1)lin2=ARG_k-1; //instead. As a result, do not let the last old node
class ap_node *ap_node2=active_node[lin2]; //(in position ARG_k-1) be chosen initially.
deactivate_node(lin2);
//printf(" : ");for( o=0;oid);printf("\n");
if((new_node->id==ap_node1->id)||(new_node->id==ap_node2->id)
||(ap_node1->id==ap_node2->id))error("coalesce(): nodes not chosen correctly");
// printf("Identity of New node: %d Coalescing nodes: %d and %d\n",new_node->id,ap_node1->id,ap_node2->id);
// printf(" which point to: %d and %d\n",ap_node1->AMP.ptr[0]->id,ap_node2->AMP.ptr[0]->id);
/*Perform copying and coalescing*/
int imax=n_segregating;
int i;
for(i=0;iAMP.ptr[tree_id]==NULL)
{
/*Rule 2.ii */
if(ap_node2->AMP.ptr[tree_id]==NULL)
{ ++ncoI;
new_node->AMP.assign(NULL,tree_id);}
/*Rule 2.i */
else
{ ++ncoIIa;
new_node->AMP.assign(ap_node2->AMP.ptr[tree_id],tree_id);}
}
else
{
/*Rule 2.ii */
if(ap_node2->AMP.ptr[tree_id]==NULL)
{ ++ncoIIb;
new_node->AMP.assign(ap_node1->AMP.ptr[tree_id],tree_id);}
/*Rule 2.iii */
else
{
++ncoIII;
new_node->AMP.assign(tree[tree_id].coalesce(*time,ap_node1->AMP.ptr[tree_id]->id,ap_node2->AMP.ptr[tree_id]->id),tree_id);
}
}
}
if(!samples_waiting)
{
deactivate_trees();
/*i=0;
while(iAMP.ptr[0]->id);
return *this;
}
virtual coalescent& recombine(double *time)
{
++nrec;
int rtype=-1;
/*Create new lineages in the ARG*/
class ap_node *new_node1=create_node(time);
class ap_node *new_node2=create_node(time);
/*First choose the lineage*/
double rnum1=ran->U()*total_rlen;
int lin;
for(lin=0;linrlen) break;
rnum1 -= active_node[lin]->rlen;
}
if (lin>=ARG_k) error("recombine(): lineage not chosen correctly");
class ap_node *old_node=active_node[lin];
deactivate_node(lin);
//active_node[lin]->edge_time=(*time)-active_node[lin]->time;
if(new_node1==old_node)error("Aah!");
if(new_node2==old_node)error("Aah!");
/*Determine the number of breakpoints*/
if (old_node->L==0.0)error("recombine(): recombination at an empty locus");
int ltr=old_node->ltr;
int rtr=old_node->rtr;
/*Is it a swap?*/
if(no_gene_conversion)
{
perform_single_crossover(<r,&rtr);
if(tree[ltr-1].get_k()>1 && tree[ltr].get_k()>1 && ltr!=old_node->ltr && old_node->AMP.ptr[ltr-1]!=NULL && old_node->AMP.ptr[ltr]!=NULL)
++nrecWatt[ltr-1];
else if(tree[rtr-1].get_k()>1 && tree[rtr].get_k()>1 && rtr!=old_node->rtr && old_node->AMP.ptr[rtr-1]!=NULL && old_node->AMP.ptr[rtr]!=NULL)
++nrecWatt[rtr-1];
rtype=2;
++nrecTypeII;
}
/* else
{
double a,b,c,swap_yn,rnum3,single_yn;
a = con->lambda*old_node->L;
b = exp(-a);
c = a+b;
swap_yn = b/c; //=1 if L=0 so "swap", but has no effect
//this error shouldve been caught anyway
rnum3 = ran->U();
if (rnum3<=swap_yn)
{
//It's a swap!
//In which case all of the recipient's genome is
//ancestral except for the locus of interest
//ltr and rtr do not need modifying
rtype=1;
++nrecTypeI;
}*/
else
{
/*Is it a single cross-over?*/
//single_yn = (1-a)/c;
//rnum3 -= swap_yn;
double rnum3 = ran->U() * old_node->rlen;
/* Before 11.08.06 the next line was the same, but changes to calc_node_rlen
imply that the relative rate of single to double xovers is altered. */
double single_yn = con->r/con->lambda*(1.-pow(1.-con->lambda,(double)(old_node->L-1)));
if (rnum3<=single_yn)
{
/*It's a single cross-over!*/
perform_single_crossover(<r,&rtr);
rtype=2;
++nrecTypeII;
if(tree[ltr-1].get_k()>1 && tree[ltr].get_k()>1 && ltr!=old_node->ltr && old_node->AMP.ptr[ltr-1]!=NULL && old_node->AMP.ptr[ltr]!=NULL)
++nrecWatt[ltr-1];
else if(tree[rtr-1].get_k()>1 && tree[rtr].get_k()>1 && rtr!=old_node->rtr && old_node->AMP.ptr[rtr-1]!=NULL && old_node->AMP.ptr[rtr]!=NULL)
++nrecWatt[rtr-1];
}
else
{
/*It's a double cross-over!*/
perform_double_crossover(<r,&rtr);
rtype=3;
++nrecTypeIII;
//++nrecWatt[ltr-1];
//++nrecWatt[rtr-1];
}
}
//}
/*Copy the relevant parts of AMP*/
int i,pos;
for(i=0,pos=(*segregating_tree)[0];(posAMP.assign(old_node->AMP.ptr[pos],pos);
new_node2->AMP.assign(NULL,pos);
}
for(;(posAMP.assign(old_node->AMP.ptr[pos],pos);
new_node1->AMP.assign(NULL,pos);
}
for(;iAMP.assign(old_node->AMP.ptr[pos],pos);
new_node2->AMP.assign(NULL,pos);
}
/*Recalculate rlen*/
calc_rlen(new_node1,new_node2);
return *this;
}
coalescent& conditionally_coalesce(double *time)
{
++nco;
/*Create new lineage in the ARG*/
class ap_node *new_node=create_node(time);
int lin1,lin2;
class ap_node *ap_node1,*ap_node2;
if(true){//ARG_k_fixed>=ARG_k) {
while(true) {
lin1=ran->discrete(0,ARG_k-2);
ap_node1=active_node[lin1];
/* Always accept if not a FIXED_NODE */
if(ap_node1->flag!=ap_node::FIXED_NODE) break;
/* otherwise accept with probability */
else if(ran->U()<1.-(ARG_k_fixed-1.)/(ARG_k-2.)) break;
}
/* If ap_node1 is a FIXED_NODE make new_node a FIXED_NODE */
if(ap_node1->flag==ap_node::FIXED_NODE) {
new_node->flag = ap_node::FIXED_NODE;
new_node->ctree_id = ap_node1->ctree_id;
}
deactivate_node(lin1);
while(true) {
/* Choose a different lineage */
lin2=ran->discrete(0,ARG_k-2);
if(lin2==lin1)lin2=ARG_k-1;
ap_node2=active_node[lin2];
/* Don't accept if both nodes have FIXED_NODE status */
if(!(new_node->flag==ap_node::FIXED_NODE && ap_node2->flag==ap_node::FIXED_NODE)) break;
}
/* If ap_node2 is a FIXED_NODE make new_node a FIXED_NODE */
if(ap_node2->flag==ap_node::FIXED_NODE) {
new_node->flag = ap_node::FIXED_NODE;
new_node->ctree_id = ap_node2->ctree_id;
}
//else new_node->ctree_id = -1;
if(new_node->ctree_id>-1) fnode[new_node->ctree_id] = new_node;
/*Finally, deactivate*/
deactivate_node(lin2);
}
else {
}
/*
//Choose 1st lineage to coalesce
int lin1=ran->discrete(0,ARG_k-2);
//Do not choose FIXED_NODEs
while(active_node[lin1]->flag==ap_node::FIXED_NODE) lin1 = ran->discrete(0,ARG_k-2);
class ap_node *ap_node1=active_node[lin1];
deactivate_node(lin1);
//Choose 2nd lineage to coalesce
int lin2=ran->discrete(0,ARG_k-2);
if(lin2==lin1)lin2=ARG_k-1;
class ap_node *ap_node2=active_node[lin2];
//Sort out fnode stuff
new_node->flag = ap_node2->flag;
new_node->ctree_id = ap_node2->ctree_id;
if(new_node->ctree_id>-1) fnode[new_node->ctree_id] = new_node;
//Finally, deactivate
deactivate_node(lin2);*/
if((new_node->id==ap_node1->id)||(new_node->id==ap_node2->id)
||(ap_node1->id==ap_node2->id))error("coalesce(): nodes not chosen correctly");
/*Give new_node the flag of ap_node2, which might be a FIXED_NODE
int found_fnode = 0;
int a;
for(a=0;aflag==ap_node::FIXED_NODE && found_fnode!=1) error("coalescent::conditionally_coalesce(): problem finding FIXED_NODE");*/
/*Perform copying and coalescing*/
int imax=n_segregating;
int i;
for(i=0;iAMP.ptr[tree_id]==NULL)
{
/*Rule 2.ii */
if(ap_node2->AMP.ptr[tree_id]==NULL)
{ ++ncoI;
new_node->AMP.assign(NULL,tree_id);}
/*Rule 2.i */
else
{ ++ncoIIa;
new_node->AMP.assign(ap_node2->AMP.ptr[tree_id],tree_id);}
}
else
{
/*Rule 2.ii */
if(ap_node2->AMP.ptr[tree_id]==NULL)
{ ++ncoIIb;
new_node->AMP.assign(ap_node1->AMP.ptr[tree_id],tree_id);}
/*Rule 2.iii */
else
{
++ncoIII;
new_node->AMP.assign(tree[tree_id].coalesce(*time,ap_node1->AMP.ptr[tree_id]->id,ap_node2->AMP.ptr[tree_id]->id),tree_id);
}
}
}
if(!samples_waiting)
{
//deactivate_trees2();
i=0;
while(iU()*total_rlen;
int lin;
for(lin=0;linrlen) break;
rnum1 -= active_node[lin]->rlen;
}
if (lin>=ARG_k) error("recombine(): lineage not chosen correctly");
class ap_node *old_node=active_node[lin];
/*new_node1 is always the recipient*/
new_node1->flag = old_node->flag;
new_node1->ctree_id = old_node->ctree_id;
if(new_node1->ctree_id!=-1) fnode[new_node1->ctree_id] = new_node1;
int old_node_flag = (int)old_node->flag;
deactivate_node(lin);
//active_node[lin]->edge_time=(*time)-active_node[lin]->time;
if(new_node1==old_node)error("Aah!");
if(new_node2==old_node)error("Aah!");
/*Determine the number of breakpoints*/
if (old_node->L==0.0)error("recombine(): recombination at an empty locus");
int ltr=old_node->ltr;
int rtr=old_node->rtr;
/*Is it a swap?*/
if(no_gene_conversion)
{
//error("coalescent::conditionally_recombine(): only donor-recipient style rec defined");
perform_single_crossover(<r,&rtr);
if(tree[ltr-1].get_k()>1 && tree[ltr].get_k()>1 && ltr!=old_node->ltr && old_node->AMP.ptr[ltr-1]!=NULL && old_node->AMP.ptr[ltr]!=NULL)
++nrecWatt[ltr-1];
else if(tree[rtr-1].get_k()>1 && tree[rtr].get_k()>1 && rtr!=old_node->rtr && old_node->AMP.ptr[rtr-1]!=NULL && old_node->AMP.ptr[rtr]!=NULL)
++nrecWatt[rtr-1];
rtype=2;
++nrecTypeII;
}
else
{
double swap_yn,rnum3,single_yn;
rnum3 = ran->U() * old_node->rlen;
swap_yn = (old_node_flag == (int)ap_node::FIXED_NODE) ? 0.5 * con->r/con->lambda*pow(1.-con->lambda,(double)(old_node->L-1)) : 0.0;
/* Before 11.08.06 swap_yn = (old_node_flag == (int)ap_node::FIXED_NODE) ? con->r/con->lambda*pow(1.-con->lambda,(double)(old_node->L-1)) : 0.0;*/
if (rnum3<=swap_yn)
{
//It's a swap!
//In which case all of the recipient's genome is
//ancestral except for the locus of interest
//ltr and rtr do not need modifying
rtype=1;
++nrecTypeI;
}
else
{
rnum3 -= swap_yn;
/*Is it a single cross-over?*/
//single_yn = (1-a)/c;
//rnum3 -= swap_yn;
/* The following line was the same before 11.08.06, but the changes in calc_node_rlen
imply that the relative probability of double crossovers are altered as a result. */
single_yn = con->r/con->lambda*(1.-pow(1.-con->lambda,(double)(old_node->L-1)));
if (rnum3<=single_yn)
{
/*It's a single cross-over!*/
perform_single_crossover(<r,&rtr);
rtype=2;
++nrecTypeII;
if(tree[ltr-1].get_k()>1 && tree[ltr].get_k()>1 && ltr!=old_node->ltr && old_node->AMP.ptr[ltr-1]!=NULL && old_node->AMP.ptr[ltr]!=NULL)
++nrecWatt[ltr-1];
else if(tree[rtr-1].get_k()>1 && tree[rtr].get_k()>1 && rtr!=old_node->rtr && old_node->AMP.ptr[rtr-1]!=NULL && old_node->AMP.ptr[rtr]!=NULL)
++nrecWatt[rtr-1];
}
else
{
/*It's a double cross-over!*/
perform_double_crossover(<r,&rtr);
rtype=3;
++nrecTypeIII;
//++nrecWatt[ltr-1];
//++nrecWatt[rtr-1];
}
}
}
/*new_node1 is always the recipient
int found_fnode = 0;
int a;
for(a=0;aflag==ap_node::FIXED_NODE && found_fnode!=1) error("coalescent::conditionally_recombine(): problem finding FIXED_NODE");*/
/*Copy the relevant parts of AMP*/
int i,pos;
for(i=0,pos=(*segregating_tree)[0];(posAMP.assign(old_node->AMP.ptr[pos],pos);
new_node2->AMP.assign(NULL,pos);
}
for(;(posAMP.assign(old_node->AMP.ptr[pos],pos);
new_node1->AMP.assign(NULL,pos);
}
for(;iAMP.assign(old_node->AMP.ptr[pos],pos);
new_node2->AMP.assign(NULL,pos);
}
/*Recalculate rlen*/
calc_rlen(new_node1,new_node2);
return *this;
}
coalescent& migrate_coalesce(double *time)
{
++nco;
/*First choose deme for coalescence*/
double rdeme = ran->U() * rate_coal;
int deme;
for(deme=0;demendemes;deme++) {
if(rdeme <= coal_deme[deme]/2.) break;
else rdeme -= coal_deme[deme]/2.;
}
if(deme==con->ndemes) error("migrate_coalesce(): deme chosen incorrectly");
/*Create new lineage in the ARG*/
class ap_node *new_node=create_node(time);
int lin1,lin2;
class ap_node *ap_node1,*ap_node2;
lin1 = ran->discrete(0,k_deme[deme]-1);
ap_node1 = ptr_deme[deme][lin1];
if(ap_node1->deme!=deme) error("migrate_coalesce(): node 1 deme not right deme");
SWAP(ptr_deme[deme][lin1],ptr_deme[deme][k_deme[deme]-1]);
--k_deme[deme];
deactivate_node(ap_node1->active_id);
lin2 = ran->discrete(0,k_deme[deme]-1);
ap_node2 = ptr_deme[deme][lin2];
if(ap_node2->deme!=deme) error("migrate_coalesce(): node 2 deme not right deme");
ptr_deme[deme][lin2] = new_node;
deactivate_node(ap_node2->active_id);
new_node->deme = deme;
if((new_node->id==ap_node1->id)||(new_node->id==ap_node2->id)
||(ap_node1->id==ap_node2->id))error("migrate_coalesce(): nodes not chosen correctly");
/*Perform copying and coalescing*/
int imax=n_segregating;
int i;
mt_node *ptr; double last_update;
for(i=0;iAMP.ptr[tree_id]==NULL)
{
/*Rule 2.ii */
if(ap_node2->AMP.ptr[tree_id]==NULL)
{ ++ncoI;
new_node->AMP.assign(NULL,tree_id);}
/*Rule 2.i */
else
{ ++ncoIIa;
new_node->AMP.assign(ap_node2->AMP.ptr[tree_id],tree_id);}
}
else
{
/*Rule 2.ii */
if(ap_node2->AMP.ptr[tree_id]==NULL)
{ ++ncoIIb;
new_node->AMP.assign(ap_node1->AMP.ptr[tree_id],tree_id);}
/*Rule 2.iii */
else
{
++ncoIII;
/*** Structured coalescent stuff ***/
ptr = ap_node1->AMP.ptr[tree_id];
last_update = ptr->last_update;
ptr->edge_time += (*time-last_update) * con->N_deme_over_D[deme];
ptr->last_update = *time;
ptr = ap_node2->AMP.ptr[tree_id];
last_update = ptr->last_update;
ptr->edge_time += (*time-last_update) * con->N_deme_over_D[deme];
ptr->last_update = *time;
/***********************************/
new_node->AMP.assign(tree[tree_id].migrate_coalesce(*time,ap_node1->AMP.ptr[tree_id]->id,ap_node2->AMP.ptr[tree_id]->id),tree_id);
}
}
}
if(!samples_waiting)
{
//deactivate_trees2();
i=0;
while(irlen / con->N_deme_over_D[deme];
rho_deme[deme] -= ap_node2->rlen / con->N_deme_over_D[deme];
calc_node_rlen(new_node);
rho_deme[deme] += new_node->rlen / con->N_deme_over_D[deme];
rate_recn += rho_deme[deme];
rate_coal -= k_deme[deme] / con->N_deme_over_D[deme];
coal_deme[deme] -= k_deme[deme] / con->N_deme_over_D[deme];
rate_mign -= sum_mig[deme];*/
return *this;
}
coalescent& migrate_recombine(double *time)
{
++nrec;
int rtype=-1;
/*First choose deme*/
double rdeme = ran->U() * rate_recn;
int deme;
for(deme=0;demendemes;deme++) {
if(rdeme <= rho_deme[deme]/2.) break;
else rdeme -= rho_deme[deme]/2.;
}
if(deme==con->ndemes) error("migrate_recombine(): deme not chosen correctly");
/*Create new lineages in the ARG*/
class ap_node *new_node1=create_node(time);
class ap_node *new_node2=create_node(time);
/*First choose the lineage*/
double rnum1=ran->U() * rho_deme[deme] / 2.0 * con->N_deme_over_D[deme];
class ap_node *old_node;
int lin;
for(lin=0;linrlen) break;
else rnum1 -= old_node->rlen;
}
if(lin>=k_deme[deme]) error("migrate_recombine(): lineage not chosen correctly");
if(old_node->deme!=deme) error("migrate_recombine(): lineage deme not right deme");
new_node1->deme = new_node2->deme = deme;
ptr_deme[deme][lin] = new_node1;
++k_deme[deme];
ptr_deme[deme][k_deme[deme]-1] = new_node2;
/*new_node1 is always the recipient*/
deactivate_node(old_node->active_id);
if(new_node1==old_node)error("Aah!");
if(new_node2==old_node)error("Aah!");
/*Determine the number of breakpoints*/
if(old_node->L==0.0)error("recombine(): recombination at an empty locus");
int ltr=old_node->ltr;
int rtr=old_node->rtr;
/*Is it a swap?*/
if(no_gene_conversion)
{
//error("coalescent::conditionally_recombine(): only donor-recipient style rec defined");
perform_single_crossover(<r,&rtr);
if(tree[ltr-1].get_k()>1 && tree[ltr].get_k()>1 && ltr!=old_node->ltr && old_node->AMP.ptr[ltr-1]!=NULL && old_node->AMP.ptr[ltr]!=NULL)
++nrecWatt[ltr-1];
else if(tree[rtr-1].get_k()>1 && tree[rtr].get_k()>1 && rtr!=old_node->rtr && old_node->AMP.ptr[rtr-1]!=NULL && old_node->AMP.ptr[rtr]!=NULL)
++nrecWatt[rtr-1];
rtype=2;
++nrecTypeII;
}
else
{
double swap_yn,rnum3,single_yn;
rnum3 = ran->U() * old_node->rlen;
swap_yn = con->r/con->lambda*pow(1.-con->lambda,(double)(old_node->L-1));
if (rnum3<=swap_yn)
{
//It's a swap!
//In which case all of the recipient's genome is
//ancestral except for the locus of interest
//ltr and rtr do not need modifying
rtype=1;
++nrecTypeI;
}
else
{
rnum3 -= swap_yn;
/*Is it a single cross-over?*/
//single_yn = (1-a)/c;
//rnum3 -= swap_yn;
single_yn = con->r/con->lambda*(1.-pow(1.-con->lambda,(double)(old_node->L-1)));
if (rnum3<=single_yn)
{
/*It's a single cross-over!*/
perform_single_crossover(<r,&rtr);
rtype=2;
++nrecTypeII;
if(tree[ltr-1].get_k()>1 && tree[ltr].get_k()>1 && ltr!=old_node->ltr && old_node->AMP.ptr[ltr-1]!=NULL && old_node->AMP.ptr[ltr]!=NULL)
++nrecWatt[ltr-1];
else if(tree[rtr-1].get_k()>1 && tree[rtr].get_k()>1 && rtr!=old_node->rtr && old_node->AMP.ptr[rtr-1]!=NULL && old_node->AMP.ptr[rtr]!=NULL)
++nrecWatt[rtr-1];
}
else
{
/*It's a double cross-over!*/
perform_double_crossover(<r,&rtr);
rtype=3;
++nrecTypeIII;
//++nrecWatt[ltr-1];
//++nrecWatt[rtr-1];
}
}
}
/*Copy the relevant parts of AMP*/
int i,pos;
for(i=0,pos=(*segregating_tree)[0];(posAMP.assign(old_node->AMP.ptr[pos],pos);
new_node2->AMP.assign(NULL,pos);
}
for(;(posAMP.assign(old_node->AMP.ptr[pos],pos);
new_node1->AMP.assign(NULL,pos);
}
for(;iAMP.assign(old_node->AMP.ptr[pos],pos);
new_node2->AMP.assign(NULL,pos);
}
/*Recalculate rlen*/
migrate_calc_rlen(new_node1,new_node2);
/*Recalculate rates*
rate_recn -= rho_deme[deme];
rho_deme[deme] -= old_node->rlen / con->N_deme_over_D[deme];
calc_node_rlen(new_node1);
calc_node_rlen(new_node2);
rho_deme[deme] += new_node1->rlen / con->N_deme_over_D[deme];
rho_deme[deme] += new_node2->rlen / con->N_deme_over_D[deme];
rate_recn += rho_deme[deme];
rate_coal += (double)(k_deme[deme]-1) / con->N_deme_over_D[deme];
coal_deme[deme] += (double)(k_deme[deme]-1) / con->N_deme_over_D[deme];
rate_mign += sum_mig[deme];*/
return *this;
}
coalescent& migrate_migrate(double *time) {
/*Choose source deme*/
int source;
double rdeme = ran->U() * rate_mign;
for(source=0;sourcendemes;source++) {
if(rdeme <= k_deme[source]*sum_mig[source]/2.) break;
else rdeme -= k_deme[source]*sum_mig[source]/2.;
}
if(source>=con->ndemes) error("migrate_migrate(): source deme not chosen correctly");
/*Choose target deme*/
int target;
rdeme = ran->U() * sum_mig[source];
for(target=0;targetndemes;target++) {
if(rdeme <= con->mig[source][target]) break;
else rdeme -= con->mig[source][target];
}
if(target>=con->ndemes) error("migrate_migrate(): target deme not chosen correctly");
/*Choose lineage*/
int lin = ran->discrete(0,k_deme[source]-1);
ap_node *old_node = ptr_deme[source][lin];
if(old_node->deme!=source) error("migrate_migrate(): lineage belongs to wrong deme");
/*Perform migration*/
if(old_node->deme!=target) {
SWAP(ptr_deme[source][lin],ptr_deme[source][k_deme[source]-1]);
--k_deme[source];
++k_deme[target];
ptr_deme[target][k_deme[target]-1] = old_node;
old_node->deme = target;
}
/*Update edge_time for migrating node*/
int i,pos;
mt_node *ptr;
double last_update;
for(i=0;iAMP.ptr[pos];
if(ptr!=NULL) {
last_update = ptr->last_update;
ptr->edge_time += (*time-last_update) * con->N_deme_over_D[source];
ptr->last_update = *time;
}
}
/*Recalculate rlen*/
migrate_calc_rlen();
/*Recalculate rates*
rate_recn -= rho_deme[source] + rho_deme[target];
rho_deme[source] -= old_node->rlen / con->N_deme_over_D[source];
rho_deme[target] += old_node->rlen / con->N_deme_over_D[target];
rate_recn += rho_deme[source] + rho_deme[target];
rate_coal -= coal_deme[source] + coal_deme[target];
coal_deme[source] -= (double)k_deme[source] / con->N_deme_over_D[source];
coal_deme[target] += (double)(k_deme[target]-1) / con->N_deme_over_D[target];
rate_coal += coal_deme[source] + coal_deme[target];
rate_mign += sum_mig[target] - sum_mig[source];*/
return *this;
}
double add_next_sample()
{
double samptime=*ntimes_itr;
double currenttime=samptime;
class ap_node* new_node;
class mt_node* new_tree_node;
while((currenttime==*ntimes_itr)&&(ntimes_itr!=con->ntimes.end())) //relies on ordering of ntimes
{
//add the new node
++naddbase;
new_node=create_node(&(*ntimes_itr));
int i;
for(i=0;iAMP.assign(new_tree_node,i);
}
calc_node_rlen(new_node);
if(con->ndemes>0) {
int deme = con->deme_config[next_waiting_sample];
new_node->deme = deme;
++k_deme[deme];
ptr_deme[deme][k_deme[deme]-1] = new_node;
/*rho_deme[deme] += new_node->rlen / con->N_deme_over_D[deme];
rate_recn += new_node->rlen / con->N_deme_over_D[deme];
rate_coal += (double)(k_deme[deme]-1) / con->N_deme_over_D[deme];
coal_deme[deme] += (double)(k_deme[deme]-1) / con->N_deme_over_D[deme];
rate_mign += sum_mig[deme];*/
}
++next_waiting_sample;
//++ARG_k;
++ntimes_itr;
}
if(ntimes_itr==con->ntimes.end()) samples_waiting=false;
else time_next_sample=*ntimes_itr;
if(con->ndemes>0) {
migrate_calc_rlen();
}
else calc_rlen();
return currenttime;
}
double add_conditional_event(class marginal_tree &ctree)
{
double samptime=*ntimes_itr;
double currenttime=samptime;
class ap_node* new_node;
class mt_node* new_tree_node;
int i;
class mt_node* conditional_event;
while((currenttime==*ntimes_itr)&&(ntimes_itr!=con->ntimes.end())) //relies on ordering of ntimes
{
conditional_event = &(ctree.node[next_waiting_sample]);
if(conditional_event->descendant[0]==NULL) { // add a base node
++naddbase;
new_node = create_node(&(*ntimes_itr));
for(i=0;iAMP.assign(new_tree_node,i);
}
fnode[next_waiting_sample] = new_node;
new_node->flag = ap_node::FIXED_NODE;
new_node->ctree_id = next_waiting_sample;
calc_node_rlen(new_node);
++ARG_k_fixed;
}
else { // add a coalescence
//fnode[conditional_event->id] = coalesce(fnode[conditional_event->descendant[0]->id],fnode[conditional_event->descendant[1]->id]);
class ap_node *new_node = create_node(&(*ntimes_itr));
class ap_node *ap_node1 = fnode[conditional_event->descendant[0]->id];
deactivate_node(ap_node1->active_id);
class ap_node *ap_node2 = fnode[conditional_event->descendant[1]->id];
if(ap_node1==ap_node2) error("add_conditional_event(): lineage cannot coalesce with itself");
deactivate_node(ap_node2->active_id);
if((new_node->id==ap_node1->id)||(new_node->id==ap_node2->id)
||(ap_node1->id==ap_node2->id))error("add_conditional_event(): nodes not chosen correctly");
fnode[conditional_event->id] = new_node;
fnode[conditional_event->descendant[0]->id] = NULL;
fnode[conditional_event->descendant[1]->id] = NULL;
/* give node FIXED_NODE status only if it is not the mrca */
if(conditional_event->idflag = ap_node::FIXED_NODE;
--ARG_k_fixed;
}
else ARG_k_fixed -= 2;
new_node->ctree_id = conditional_event->id;
/*Perform copying and coalescing*/
int imax=n_segregating;
for(i=0;iAMP.ptr[tree_id]==NULL)
{
/*Rule 2.ii */
if(ap_node2->AMP.ptr[tree_id]==NULL)
{ ++ncoI;
new_node->AMP.assign(NULL,tree_id);}
/*Rule 2.i */
else
{ ++ncoIIa;
new_node->AMP.assign(ap_node2->AMP.ptr[tree_id],tree_id);}
}
else
{
/*Rule 2.ii */
if(ap_node2->AMP.ptr[tree_id]==NULL)
{ ++ncoIIb;
new_node->AMP.assign(ap_node1->AMP.ptr[tree_id],tree_id);}
/*Rule 2.iii */
else
{
++ncoIII;
new_node->AMP.assign(tree[tree_id].coalesce(*ntimes_itr,ap_node1->AMP.ptr[tree_id]->id,ap_node2->AMP.ptr[tree_id]->id),tree_id);
}
}
}
if(!samples_waiting)
{
//deactivate_trees2();
i=0;
while(i1 && samples_waiting==false) error("add_conditional_event(): not all fixed events completed");
calc_rlen();
return currenttime;
}
double constant_size_model(const double mean)
{
double time=ran->exponential(1.0);
time *= mean;
return time;
}
coalescent& deactivate_node(const int id)
{
inactive_node[n_inactive]=active_node[id];
inactive_node[n_inactive]->recycle();
++n_inactive;
active_node[id]=active_node[ARG_k-1];
active_node[id]->active_id = id;
active_node[ARG_k-1]=NULL;
--ARG_k;
/*NB no memory reallocation occurs*/
return *this;
}
/*coalescent& deactivate_node(ap_node *id)
{
int lin1 = 0;
while(active_node[lin1]!=id) ++lin1;
return deactivate_node(lin1);
}*/
class ap_node* create_node(double *time)
{
if(ARG_k==nodes_reserved)reserve_nodes(2*(ARG_k+1));
active_node[ARG_k]=inactive_node[n_inactive-1];
active_node[ARG_k]->activate(time);
active_node[ARG_k]->active_id = ARG_k;
inactive_node[n_inactive-1]=NULL;
++ARG_k;
--n_inactive;
return active_node[ARG_k-1];
}
coalescent& deactivate_trees()
{
int new_seg_tree_id=1-seg_tree_id;
int i,j;
for(i=0,j=0;iL;
calc_node_rlen(active_node[i]);
after = active_node[i]->L;
if(before!=after) {
warning("weird");
}
}
calc_rlen();
}*/
n_segregating = new_n_segregating;
seg_tree_id=new_seg_tree_id;
segregating_tree=&(internal_seg_tree[seg_tree_id]);
return *this;
}
coalescent& deactivate_trees2()
{
int new_seg_tree_id=seg_tree_id;
int i,j;
for(i=0,j=0;iL;
calc_node_rlen(active_node[i]);
after = active_node[i]->L;
if(before!=after) {
warning("weird");
}
}
calc_rlen();
}*/
n_segregating = new_n_segregating;
seg_tree_id=new_seg_tree_id;
segregating_tree=&(internal_seg_tree[seg_tree_id]);
return *this;
}
coalescent& deactivate_tree(const int id)
{
int new_seg_tree_id=1-seg_tree_id;
//segregating_tree[id]=segregating_tree[n_segregating-1];
int j=0;
int i;
for(i=0;iAMP.ptr[left]!=NULL)break;
}
/*right is the first non-NULL seg site from the right*/
for(i=n_segregating-1;i>=0;i--)
{
right=(*segregating_tree)[i];
if(id->AMP.ptr[right]!=NULL)break;
}
if(i<0)/*This occurs when there are no non-NULL seg sites*/
{
id->rlen=0.0;
id->L=0.0;
id->ltr=0;
id->rtr=0;
}
else
{
/*L is the total number of sites bounded by non-NULL seg sites*/
id->L = (double)(right - left + 1);
if(no_gene_conversion)
id->rlen = con->r * (double)(id->L - 1);
else {
id->rlen = 0.5 * con->r * ((double)(id->L - 1) + 1./con->lambda * (1. - pow(1.-con->lambda,(double)(id->L-1))));
if(id->flag == ap_node::FIXED_NODE && id->L>0) id->rlen += 0.5 * con->r/con->lambda*pow(1.-con->lambda,(double)(id->L-1));
/* Before 11.08.06,
id->rlen = con->r * (double)(id->L - 1);
if(id->flag == ap_node::FIXED_NODE && id->L>0) id->rlen += con->r/con->lambda*pow(1.-con->lambda,(double)(id->L-1));*/
/* Even earlier, id->rlen = con->r*con->lambda*(1.-pow(1.-1./con->lambda,(double)(id->L-1))); */
}
// + (con->r)/(con->lambda) * exp(-con->lambda * (double)id->L);
// if((id->L==0.0)&&(con->r!=0.0))
// {
// error("calc_rlen: non-zero rlen value when L=0");
// }
id->ltr = left;
id->rtr = right+1;
}
return *this;
}
coalescent& calc_rlen()
{
total_rlen=0.0;
int i;
for(i=0;irlen;
rho=2.0*total_rlen/(double)ARG_k;
return *this;
}
coalescent& calc_rlen(class ap_node* id)
{
calc_node_rlen(id);
total_rlen=0.0;
int i;
for(i=0;irlen;
rho=2.0*total_rlen/(double)ARG_k;
return *this;
}
coalescent& calc_rlen(class ap_node* id1, class ap_node* id2)
{
calc_node_rlen(id1);
calc_node_rlen(id2);
total_rlen=0.0;
int i;
for(i=0;irlen;
rho=2.0*total_rlen/(double)ARG_k;
return *this;
}
coalescent& migrate_calc_rlen()
{
total_rlen=0.0;
int i;
for(i=0;indemes;i++) rho_deme[i] = 0.0;
for(i=0;irlen;
rho_deme[active_node[i]->deme] += active_node[i]->rlen;
}
rho=2.0*total_rlen/(double)ARG_k;
for(i=0;indemes;i++) rho_deme[i] *= 2.0 / con->N_deme_over_D[i];
return *this;
}
coalescent& migrate_calc_rlen(class ap_node* id)
{
calc_node_rlen(id);
total_rlen=0.0;
int i;
for(i=0;indemes;i++) rho_deme[i] = 0.0;
for(i=0;irlen;
rho_deme[active_node[i]->deme] += active_node[i]->rlen;
}
rho=2.0*total_rlen/(double)ARG_k;
for(i=0;indemes;i++) rho_deme[i] *= 2.0 / con->N_deme_over_D[i];
return *this;
}
coalescent& migrate_calc_rlen(class ap_node* id1, class ap_node* id2)
{
calc_node_rlen(id1);
calc_node_rlen(id2);
total_rlen=0.0;
int i;
for(i=0;indemes;i++) rho_deme[i] = 0.0;
for(i=0;irlen;
rho_deme[active_node[i]->deme] += active_node[i]->rlen;
}
rho=2.0*total_rlen/(double)ARG_k;
for(i=0;indemes;i++) rho_deme[i] *= 2.0 / con->N_deme_over_D[i];
return *this;
}
coalescent& perform_single_crossover(int *ltr, int *rtr)
{
/*ltr and rtr are modified so that when they are */
/*returned they dictate the recombination boundaries */
/*Fragment length, 1<=f<=L-1, where L=rtr-ltr */
/*Simulate X=(f-1) Truncated exponential, mean=1/lambda,*/
/*truncation point=L-1 s.t. Pr(L-1)=0. */
//printf("\nLTR: %3d RTR: %3d ",*ltr,*rtr);
int L = (*rtr)-(*ltr);
int X;
if(no_gene_conversion) X = ran->discrete(0,L-2);
else
{
//double mean = 1.0/(con->lambda);
//X = floor(ran->trunc_exponential(mean,L-1));
X = ran->trunc_geometric(con->lambda,L-1) - 1;
}
/*Implement it according to direction*/
bool dir = ran->bernoulliTF(0.5);
if (dir) /*left to right*/
{
(*rtr) = (*ltr) + (X+1);
}
else /*right to left*/
{
(*ltr) = (*rtr) - (X+1);
}
//printf("X: %3d Dir: %d LTR: %3d RTR: %3d\n",X,dir,*ltr,*rtr);
return *this;
}
coalescent& perform_double_crossover(int *ltr, int *rtr)
{
/*First part as for single cross-over */
int L = (*rtr)-(*ltr);
//double mean = 1.0/(con->lambda);
//int X = floor(ran->trunc_exponential(mean,L-1));
int X = ran->trunc_geometric(con->lambda,L-1) - 1;
/*Implement it according to direction*/
int dir = ran->discrete(0,1);
if (dir) /*left to right*/
{
(*ltr) += X+1; /*except now this is ltr*/
}
else /*right to left*/
{
(*rtr) -= (X+1); /*and this is now rtr */
}
/*And repeat with re-defined boundaries */
L = (*rtr)-(*ltr);
//X = floor(ran->trunc_exponential(mean,L-1));
X = ran->trunc_geometric(con->lambda,L-1) - 1;
if (dir) /*left to right*/
{
(*rtr) = (*ltr)+X+1;
}
else /*right to left*/
{
(*ltr) = (*rtr)-X-1;
}
return *this;
}
coalescent& mutate_tree(const int tid, const int nid, const int state)
{
int my_state=mutate_edge(state,tree[tid].node[nid].edge_time);
if(tree[tid].node[nid].descendant[0]==NULL)
{ /*I.e. a base node*/
if(tree[tid].node[nid].descendant[0]!=NULL)error("mutate_tree() err1: node has one, not two descendants");
genotype.element[nid][tid]=my_state;
}
else
{
if(tree[tid].node[nid].descendant[1]==NULL)error("mutate_tree() err2: node has one, not two descendants");
int desc=tree[tid].node[nid].descendant[0]->id;
mutate_tree(tid, desc, my_state);
desc=tree[tid].node[nid].descendant[1]->id;
mutate_tree(tid, desc, my_state);
}
return *this;
}
coalescent& mutate_tree(const int tid, const int nid, const int state, Mutation_Matrix *M)
{
int my_state=mutate_edge(state,tree[tid].node[nid].edge_time,M);
if(tree[tid].node[nid].descendant[0]==NULL)
{ /*I.e. a base node*/
if(tree[tid].node[nid].descendant[0]!=NULL)error("mutate_tree() err1: node has one, not two descendants");
genotype.element[nid][tid]=my_state;
}
else
{
if(tree[tid].node[nid].descendant[1]==NULL)error("mutate_tree() err2: node has one, not two descendants");
int desc=tree[tid].node[nid].descendant[0]->id;
mutate_tree(tid, desc, my_state, M);
desc=tree[tid].node[nid].descendant[1]->id;
mutate_tree(tid, desc, my_state, M);
}
return *this;
}
coalescent& mutate_tree_and_record(const int tid, const int nid, const int state, Mutation_Matrix *M, vector &mutLog)
{
int my_state=mutate_edge_and_record(state,tree[tid].node[nid].edge_time,M,mutLog);
if(tree[tid].node[nid].descendant[0]==NULL)
{ /*I.e. a base node*/
if(tree[tid].node[nid].descendant[0]!=NULL)error("mutate_tree_and_record() err1: node has one, not two descendants");
genotype.element[nid][tid]=my_state;
}
else
{
if(tree[tid].node[nid].descendant[1]==NULL)error("mutate_tree_and_record() err2: node has one, not two descendants");
int desc=tree[tid].node[nid].descendant[0]->id;
mutate_tree_and_record(tid, desc, my_state, M, mutLog);
desc=tree[tid].node[nid].descendant[1]->id;
mutate_tree_and_record(tid, desc, my_state, M, mutLog);
}
return *this;
}
int mutate_mrca()
{
double rnum1 = ran->U();
int i;
for(i=0;in_states;i++)
{
if (rnum1<=con->state_freq[i]) break;
rnum1 -= con->state_freq[i];
}
if (i>=con->n_states) error("mutate_mrca(): initial state chosen incorrectly");
//It's important state_freq sums to one
return i;
}
int mutate_edge(const int state, const double edge_time)
{
int gt=state;
if (gt==-1)
{
error("mutate_edge(): genotype does not exist");
}
double time_left=edge_time;
double next_mut=ran->exponential(con->state_M[gt]);
while (next_mutU();
int i;
for(i=0;in_states;i++)
{
if(rnum1<=con->mut_matrix.element[gt][i])
break;
rnum1-=con->mut_matrix.element[gt][i];
}
if(i>=con->n_states)
{
printf("\nCurrent state: %d Random uniform[0,1] deviate: %g",gt,rnum1);
printf("\nError by-passed, mutation anulled\n");
//error("mutate_edge(): transition incorrectly chosen");
i=gt;
}
//node[st_node]->genotype[site]=i;
gt=i;
++nmut;
//++mutation_spectrum[count_descendants(site,st_node)];
time_left-=next_mut;
next_mut=ran->exponential(con->state_M[gt]);
}
/*Make descendants inherit state*/
//inherit(site,st_node);
return gt;
}
int mutate_edge(const int state, const double edge_time, Mutation_Matrix *M)
{
int gt=state;
if (gt<0||gt>=M->n_states)
{
error("mutate_edge(): genotype does not exist");
}
double time_left=edge_time;
double next_mut=ran->exponential(M->mutation_mean[gt]);
double rp;
while (next_mutU();
int i;
for(i=0;in_states-1;i++)
{
rp = M->D[gt][i];
if(rnum1 <= rp)
break;
rnum1 -= rp;
}
gt=i;
++nmut;
time_left-=next_mut;
next_mut=ran->exponential(M->mutation_mean[gt]);
}
return gt;
}
int mutate_edge_and_record(const int state, const double edge_time, Mutation_Matrix *M, vector &mutLog)
{
int gt=state;
if (gt<0||gt>=M->n_states)
{
error("mutate_edge(): genotype does not exist");
}
double time_left=edge_time;
double next_mut=ran->exponential(M->mutation_mean[gt]);
double rp;
while (next_mutU();
int i;
for(i=0;in_states-1;i++)
{
rp = M->D[gt][i];
if(rnum1 <= rp)
break;
rnum1 -= rp;
}
gt=i;
++nmut;
mutLog.push_back(gt);
time_left-=next_mut;
next_mut=ran->exponential(M->mutation_mean[gt]);
}
return gt;
}
public:
/* Number of segregating sites */
double S() {
double result = 0.0;
if(con->nsamp==0) return 0.0;
int i,j;
for(j=0;jseq_len;j++) {
double hap = genotype[0][j];
for(i=1;insamp;i++)
if(genotype[i][j]!=hap) {
++result;
break;
}
}
return result;
}
/* Number of unique haplotypes */
double H() {
int result = 1;
if(con->nsamp==0) return 0.0;
_uniqueHaps = vector(con->nsamp,-1);
_uniqueHaps[0] = 0;
int i,ii,j;
bool unique;
for(i=1;insamp;i++) {
unique = true;
for(ii=0;iiseq_len;j++) {
if(genotype[i][j]!=genotype[_uniqueHaps[ii]][j]) break;
}
if(j==con->seq_len) unique = false;
}
if(unique==true) {
_uniqueHaps[result] = i;
++result;
}
}
return (double)result;
}
/* Average number of pairwise differences */
double pi() {
double result = 0.0;
int i,j,k;
for(i=0;insamp;i++)
for(j=0;jseq_len;k++)
result += (genotype[i][k]==genotype[j][k]) ? 0.0 : 1.0;
result *= 2.0/(double)(con->nsamp)/(double)(con->nsamp-1);
return result;
}
/* Variance in number of pairwise differences */
double Varpi() {
double E,EE,pi;
int i,j,k;
E = EE = 0.0;
for(i=0;insamp;i++)
for(j=0;jseq_len;k++)
pi += (genotype[i][k]==genotype[j][k]) ? 0.0 : 1.0;
E += pi;
EE += pi*pi;
}
E *= 2.0/(double)(con->nsamp)/(double)(con->nsamp-1);
EE *= 2.0/(double)(con->nsamp)/(double)(con->nsamp-1);
double result = EE - E*E;
return result;
}
double Tajima() {
double D = 0.0;
int i,j,k,n,L;
n = con->nsamp;
L = con->seq_len;
double a1,a2,b1,b2,c1,c2,e1,e2,khat,S;
bool segregating;
khat = S = 0.0;
for(k=0;k &diff) {
double result = 0.0;
int i,j,k;
for(i=0;insamp;i++)
for(j=0;jseq_len;k++)
result += (diff[(int)genotype[i][k]][(int)genotype[j][k]]==0);
result *= 2.0/(double)(con->nsamp)/(double)(con->nsamp-1);
return result;
}
/* Hudson and Kaplan's Rm, the minimum # recombinations. See Myers and Griffiths(2003)*/
double Rm() {
if(con->nsamp==0) return 0.0;
if(con->seq_len==0) return 0.0;
/* Determine which sites are biallelic segregating */
_sites = vector(con->seq_len,0);
int i,j,k;
int S = 0;
double hap0,hap1;
bool segregating;
for(j=0;jseq_len;j++) {
segregating = false;
hap0 = genotype[0][j];
for(i=1;insamp;i++) {
if(!segregating && genotype[i][j]!=hap0) {
segregating = true;
hap1 = genotype[i][j];
}
else if(segregating && genotype[i][j]!=hap0 && genotype[i][j]!=hap1) {
segregating = false; // define segregating only for biallelic sites
break;
}
}
if(segregating) {
_sites[S] = j;
++S;
}
}
if(S<2) return 0.0;
/* Calculate the compatibility matrix */
____B = LowerTriangularMatrix(S,0); // so j>=k always
// ____B[j][k] = 0 for compatible, 1 for incompatible
bool comb[3];
for(j=0;jnsamp;i++) {
if(genotype[i][_sites[j]]==hap0 && genotype[i][_sites[k]]!=hap1) comb[0] = true;
if(genotype[i][_sites[j]]!=hap0 && genotype[i][_sites[k]]==hap1) comb[1] = true;
if(genotype[i][_sites[j]]!=hap0 && genotype[i][_sites[k]]!=hap1) comb[2] = true;
if(comb[0] && comb[1] && comb[2]) break;
}
____B[j][k] = (comb[0] && comb[1] && comb[2]) ? 1 : 0;
}
/* Calculate the dynamic programming partition matrix */
_M = vector(S,0);
int maxM = 0;
_M[S-1] = 0;
_M[S-2] = ____B[S-1][S-2];
for(i=S-3;i>=0;i--) {
_M[i] = ____B[i+1][i] + _M[i+1];
for(k=i+2;k_M[i]) _M[i] = ____B[k][i]+_M[k];
}
return (double)_M[0];
}
void RecCorrelations(double* result) {
RecCorrelations(result,true);
}
void RecCovariances(double* result) {
RecCorrelations(result,false);
}
void RecCorrelations(double* result, bool normalize) {
result[0] = result[1] = result[2] = 0.0;
if(con->nsamp==0) return;
if(con->seq_len==0) return;
/* Determine which sites are biallelic segregating */
_sites = vector(con->seq_len,0);
int i,j,k;
int S = 0;
double hap0,hap1;
bool segregating;
for(j=0;jseq_len;j++) {
segregating = false;
hap0 = genotype[0][j];
for(i=1;insamp;i++) {
if(!segregating && genotype[i][j]!=hap0) {
segregating = true;
hap1 = genotype[i][j];
}
else if(segregating && genotype[i][j]!=hap0 && genotype[i][j]!=hap1) {
segregating = false; // define segregating only for biallelic sites
break;
}
}
if(segregating) {
_sites[S] = j;
++S;
}
}
if(S<3) return;
/* Calculate frequency statistics */
_F = vector(S,1.0); /* _F is the marginal frequency of hap0 at site j */
for(j=0;jnsamp;i++)
if(genotype[i][_sites[j]]==hap0) _F[j]++;
_F[j] /= (double)con->nsamp;
}
_four = vector(4,0.0); /* _G[j][k] is the frequency of AB (_G[j][k][0]), */
_G = LowerTriangularMatrix< vector >(S,_four); /* Ab (1), aB (2), ab (3) for sites j and k */
for(j=0;jnsamp;i++) {
if(genotype[i][_sites[j]]==hap0 && genotype[i][_sites[k]]==hap1) ++_G[j][k][0];
else if(genotype[i][_sites[j]]==hap0 && genotype[i][_sites[k]]!=hap1) ++_G[j][k][1];
else if(genotype[i][_sites[j]]!=hap0 && genotype[i][_sites[k]]==hap1) ++_G[j][k][2];
else if(genotype[i][_sites[j]]!=hap0 && genotype[i][_sites[k]]!=hap1) ++_G[j][k][3];
else warning("Unexpected choice");
}
for(i=0;i<4;i++) _G[j][k][i] /= (double)con->nsamp;
}
/* Calculate LD statistics for pairs of sites */
_A = LowerTriangularMatrix(S,0.0); // rsq
___B = LowerTriangularMatrix(S,0.0); // Dprime
___C = LowerTriangularMatrix(S,0.0); // G4
_D = Matrix(S,S,0.0);
double temp;
for(i=0;i0.0 && _G[i][j][1]>0.0 && _G[i][j][2]>0.0 && _G[i][j][3]>0.0) ? 1.0 : 0.0;
_D[i][j] = _D[j][i] = _sites[i] - _sites[j];
}
}
double E[4] = {0.0,0.0,0.0,0.0};
double EE[4] = {0.0,0.0,0.0,0.0};
double ED[3] = {0.0,0.0,0.0};
int ctr;
// ofstream out("ld.txt");
for(i=0,ctr=0;i.
*/
/************************************************/
/* control_wizard.h 23rd February 2005 */
/* (c) Danny Wilson. */
/* www.danielwilson.me.uk */
/************************************************/
#ifndef _CONTROL_WIZARD_H_
#define _CONTROL_WIZARD_H_
#pragma warning(disable: 4786)
#include
#include