void
SymbolTreeBuilder::visit(ConstantNode& node)
{
node.setScope(currentScope());
// check module if a constant that matches this value is available
if (!node.constantValue().valueFitsInByteCode())
{
ModuleConstant* mod_constant = _parserState->module.constant(node.constantValue());
if (!mod_constant)
{
_parserState->module.addConstant(new ModuleConstant(node.constantValue()));
}
}
Symbol* tmp_sym = _curScope->declareTemporarySymbol(node.constantType());
YAL_ASSERT(tmp_sym);
_curStatment->addSymbolToScope(tmp_sym);
_expResult = ExpressionResult(node.constantType(), tmp_sym);
node.setNodeType(_expResult.type);
node.setExpressionResult(_expResult);
}
bool TestGtrGammaLikelihood::run( void ) {
/* First, we read in the data */
// the matrix
NclReader reader = NclReader();
std::vector<AbstractCharacterData*> data = reader.readMatrices(alignmentFilename);
AbstractDiscreteCharacterData *discrD = dynamic_cast<AbstractDiscreteCharacterData* >(data[0]);
std::cout << "Read " << data.size() << " matrices." << std::endl;
std::vector<TimeTree*> trees = NclReader().readTimeTrees( treeFilename );
std::cout << "Read " << trees.size() << " trees." << std::endl;
std::cout << trees[0]->getNewickRepresentation() << std::endl;
/* set up the model graph */
//////////////////////
// first the priors //
//////////////////////
// then the parameters
ConstantNode<RbVector<double> > *pi = new ConstantNode<RbVector<double> >( "pi", new RbVector<double>(4, 1.0/4.0) );
ConstantNode<RbVector<double> > *er = new ConstantNode<RbVector<double> >( "er", new RbVector<double>(6, 1.0/6.0) );
//Rate heterogeneity
ConstantNode<double> *alpha = new ConstantNode<double>("alpha", new double(0.5) );
std::cout << "alpha:\t" << alpha->getValue() << std::endl;
ConstantNode<double> *q1 = new ConstantNode<double>("q1", new double(0.125) );
DeterministicNode<double> *q1_value = new DeterministicNode<double>("q1_value", new QuantileFunction(q1, new GammaDistribution(alpha, alpha) ) );
ConstantNode<double> *q2 = new ConstantNode<double>("q2", new double(0.375) );
DeterministicNode<double> *q2_value = new DeterministicNode<double>("q2_value", new QuantileFunction(q2, new GammaDistribution(alpha, alpha) ) );
ConstantNode<double> *q3 = new ConstantNode<double>("q3", new double(0.625) );
DeterministicNode<double> *q3_value = new DeterministicNode<double>("q3_value", new QuantileFunction(q3, new GammaDistribution(alpha, alpha) ) );
ConstantNode<double> *q4 = new ConstantNode<double>("q4", new double(0.875) );
DeterministicNode<double> *q4_value = new DeterministicNode<double>("q4_value", new QuantileFunction(q4, new GammaDistribution(alpha, alpha) ) );
// ConstantNode<double> *q1_value = new ConstantNode<double>("q1_value", new double(1.0) );
// ConstantNode<double> *q2_value = new ConstantNode<double>("q2_value", new double(1.0) );
// ConstantNode<double> *q3_value = new ConstantNode<double>("q3_value", new double(1.0) );
// ConstantNode<double> *q4_value = new ConstantNode<double>("q4_value", new double(1.0) );
std::vector<const TypedDagNode<double>* > gamma_rates = std::vector<const TypedDagNode<double>* >();
gamma_rates.push_back(q1_value);
gamma_rates.push_back(q2_value);
gamma_rates.push_back(q3_value);
gamma_rates.push_back(q4_value);
DeterministicNode<RbVector<double> > *site_rates = new DeterministicNode<RbVector<double> >( "site_rates", new VectorFunction<double>(gamma_rates) );
ConstantNode<double> *sumNV = new ConstantNode<double>("sumnv", new double(1.0) );
// ConstantNode<std::vector<double> > *site_rate_probs = new ConstantNode<std::vector<double> >( "site_rate_probs", new std::vector<double>(4,1.0/4.0) );
// std::cout << "pi:\t" << pi->getValue() << std::endl;
// std::cout << "er:\t" << er->getValue() << std::endl;
std::cout << "rates:\t" << site_rates->getValue() << std::endl;
DeterministicNode<RbVector<double> > *site_rates_norm = new DeterministicNode<RbVector<double> >( "site_rates_norm", new NormalizeVectorFunction(site_rates, sumNV) );
std::cout << "rates:\t" << site_rates_norm->getValue() << std::endl;
DeterministicNode<RateMatrix> *q = new DeterministicNode<RateMatrix>( "Q", new GtrRateMatrixFunction(er, pi) );
std::cout << "Q:\t" << q->getValue() << std::endl;
ConstantNode<TimeTree> *tau = new ConstantNode<TimeTree>( "tau", new TimeTree( *trees[0] ) );
std::cout << "tau:\t" << tau->getValue() << std::endl;
// and the character model
size_t numChar = data[0]->getNumberOfCharacters();
// GeneralBranchHeterogeneousCharEvoModel<DnaState, TimeTree> *charModel = new GeneralBranchHeterogeneousCharEvoModel<DnaState, TimeTree>(tau, 4, true, numChar );
PhyloCTMCSiteHomogeneousNucleotide<DnaState, TimeTree> *charModel = new PhyloCTMCSiteHomogeneousNucleotide<DnaState, TimeTree>(tau, true, numChar );
charModel->setRateMatrix( q );
charModel->setSiteRates( site_rates_norm );
// charModel->setClockRate( clockRate );
StochasticNode< AbstractDiscreteCharacterData > *charactermodel = new StochasticNode< AbstractDiscreteCharacterData >("S", charModel );
charactermodel->clamp( discrD );
std::cout << "BEAST LnL:\t\t\t\t" << -6281.4026 << std::endl;
std::cout << "RevBayes LnL:\t\t" << charactermodel->getLnProbability() << std::endl;
std::cout << "Finished GTR+Gamma model test." << std::endl;
return true;
}
bool TestAutocorrelatedBranchHeterogeneousGtrModel::run( void ) {
// fix the rng seed
std::vector<unsigned int> seed;
seed.push_back(25);
seed.push_back(42);
GLOBAL_RNG->setSeed(seed);
/* First, we read in the data */
// the matrix
std::vector<AbstractCharacterData*> data = NclReader::getInstance().readMatrices(alignmentFilename);
std::cout << "Read " << data.size() << " matrices." << std::endl;
std::cout << data[0] << std::endl;
std::vector<TimeTree*> trees = NclReader::getInstance().readTimeTrees( treeFilename );
std::cout << "Read " << trees.size() << " trees." << std::endl;
std::cout << trees[0]->getNewickRepresentation() << std::endl;
/* set up the model graph */
//////////////////////
// first the priors //
//////////////////////
// birth-death process priors
StochasticNode<double> *div = new StochasticNode<double>("diversification", new UniformDistribution(new ConstantNode<double>("div_lower", new double(0.0)), new ConstantNode<double>("div_upper", new double(100.0)) ));
ConstantNode<double> *turn = new ConstantNode<double>("turnover", new double(0.0));
ConstantNode<double> *rho = new ConstantNode<double>("rho", new double(1.0));
// gtr model priors
ConstantNode<std::vector<double> > *bf = new ConstantNode<std::vector<double> >( "bf", new std::vector<double>(4,1.0) );
ConstantNode<std::vector<double> > *e = new ConstantNode<std::vector<double> >( "e", new std::vector<double>(6,1.0) );
//Root frequencies
StochasticNode<std::vector<double> > *rf = new StochasticNode<std::vector<double> >( "rf", new DirichletDistribution(bf) );
StochasticNode<std::vector<double> > * er = new StochasticNode<std::vector<double> >( "er", new DirichletDistribution(e) ) ;
std::cout << "bf:\t" << bf->getValue() << std::endl;
std::cout << "e:\t" << e->getValue() << std::endl;
std::vector<std::string> names = data[0]->getTaxonNames();
ConstantNode<double>* origin = new ConstantNode<double>( "origin", new double( trees[0]->getRoot().getAge()*2.0 ) );
std::vector<RevBayesCore::Taxon> taxa;
for (size_t i = 0; i < names.size(); ++i)
{
taxa.push_back( Taxon( names[i] ) );
}
StochasticNode<TimeTree> *tau = new StochasticNode<TimeTree>( "tau", new ConstantRateBirthDeathProcess(origin, NULL, div, turn, rho, "uniform", "survival", taxa, std::vector<Clade>()) );
tau->setValue( trees[0] );
std::cout << "tau:\t" << tau->getValue() << std::endl;
std::vector<StochasticNode < std::vector<double> >* > pis;
// std::vector<StochasticNode < std::vector<double> >* > ers;
std::vector< const TypedDagNode < RateMatrix>* > qs;
ConstantNode<double> *alpha_prior_shape = new ConstantNode< double >("alpha_prior_shape", new double( 5.0 ) );
ConstantNode<double> *alpha_prior_rate = new ConstantNode< double >("alpha_prior_rtae", new double( 0.5 ) );
StochasticNode<double> *alpha = new StochasticNode<double>("alpha", new GammaDistribution( alpha_prior_shape, alpha_prior_rate ) );
ConstantNode<double> *beta_prior_shape1 = new ConstantNode< double >("beta_prior_shape1", new double( 2.0 ) );
ConstantNode<double> *beta_prior_shape2 = new ConstantNode< double >("beta_prior_shape2", new double( 5.0 ) );
StochasticNode<double> *beta = new StochasticNode<double>("beta", new BetaDistribution( beta_prior_shape1, beta_prior_shape2 ) );
StochasticNode< RbVector<RateMatrix> > *perBranchQ = new StochasticNode< RbVector< RateMatrix > >( "autocorrBranchRate", new AutocorrelatedBranchMatrixDistribution( tau, beta, rf, er, alpha ) );
// StochasticNode< std::vector<RateMatrix> > *perBranchQ = new StochasticNode< std::vector< RateMatrix > >( "autocorrBranchRate", new DPP< RateMatrix >( tau, ... ) );
//
// for (unsigned int i = 0 ; i < numBranches ; i++ ) {
// std::ostringstream pi_name;
// pi_name << "pi(" << i << ")";
// pis.push_back(new StochasticNode<std::vector<double> >( pi_name.str(), new DirichletDistribution(bf) ) );
// // ers.push_back(new StochasticNode<std::vector<double> >( "er", new DirichletDistribution(e) ) );
// std::ostringstream q_name;
// q_name << "q(" << i << ")";
// qs.push_back(new DeterministicNode<RateMatrix>( q_name.str(), new GtrRateMatrixFunction(er, pis[i]) ));
// std::cout << "Q:\t" << qs[i]->getValue() << std::endl;
// }
// and the character model
GeneralBranchHeterogeneousCharEvoModel<DnaState, TimeTree> *phyloCTMC = new GeneralBranchHeterogeneousCharEvoModel<DnaState, TimeTree>(tau, 4, true, data[0]->getNumberOfCharacters());
phyloCTMC->setRootFrequencies( rf );
phyloCTMC->setRateMatrix( perBranchQ );
StochasticNode< AbstractCharacterData > *charactermodel = new StochasticNode< AbstractCharacterData >("S", phyloCTMC );
charactermodel->clamp( data[0] );
/* add the moves */
RbVector<Move> moves;
moves.push_back( new MetropolisHastingsMove( new ScaleProposal(div, 1.0), 2, true ) );
moves.push_back( new NearestNeighborInterchange( tau, 5.0 ) );
moves.push_back( new NarrowExchange( tau, 10.0 ) );
moves.push_back( new FixedNodeheightPruneRegraft( tau, 2.0 ) );
moves.push_back( new SubtreeScale( tau, 5.0 ) );
// moves.push_back( new TreeScale( tau, 1.0, true, 2.0 ) );
moves.push_back( new NodeTimeSlideUniform( tau, 30.0 ) );
moves.push_back( new RootTimeSlide( tau, 1.0, true, 2.0 ) );
moves.push_back( new SimplexMove( er, 10.0, 1, 0, true, 2.0 ) );
moves.push_back( new SimplexMove( er, 100.0, 6, 0, true, 2.0 ) );
moves.push_back( new SimplexMove( rf, 10.0, 1, 0, true, 2.0 ) );
moves.push_back( new SimplexMove( rf, 100.0, 4, 0, true, 2.0 ) );
// for (unsigned int i = 0 ; i < numBranches ; i ++ ) {
// // moves.push_back( new SimplexMove( ers[i], 10.0, 1, true, 2.0 ) );
// moves.push_back( new SimplexMove( pis[i], 10.0, 1, true, 2.0 ) );
// // moves.push_back( new SimplexMove( ers[i], 100.0, 6, true, 2.0 ) );
// moves.push_back( new SimplexMove( pis[i], 100.0, 4, true, 2.0 ) );
// }
// add some tree stats to monitor
DeterministicNode<double> *treeHeight = new DeterministicNode<double>("TreeHeight", new TreeHeightStatistic(tau) );
/* add the monitors */
RbVector<Monitor> monitors;
std::set<DagNode*> monitoredNodes;
// monitoredNodes.insert( er );
// monitoredNodes.insert( pi );
monitoredNodes.insert( div );
monitors.push_back( new FileMonitor( monitoredNodes, 10, "TestAutocorrelatedBranchHeterogeneousGtrModel.log", "\t" ) );
std::set<DagNode*> monitoredNodes1;
monitoredNodes1.insert( er );
/* for (unsigned int i = 0 ; i < numBranches ; i ++ ) {
monitoredNodes1.insert( pis[i] );
}*/
monitoredNodes1.insert( rf );
monitoredNodes1.insert( treeHeight );
monitors.push_back( new FileMonitor( monitoredNodes1, 10, "TestAutocorrelatedBranchHeterogeneousGtrModelSubstRates.log", "\t" ) );
monitors.push_back( new ScreenMonitor( monitoredNodes1, 10, "\t" ) );
std::set<DagNode*> monitoredNodes2;
monitoredNodes2.insert( tau );
monitors.push_back( new FileMonitor( monitoredNodes2, 10, "TestAutocorrelatedBranchHeterogeneousGtrModel.tree", "\t", false, false, false ) );
/* instantiate the model */
Model myModel = Model( tau );
std::vector<DagNode*> &nodes = myModel.getDagNodes();
for (std::vector<DagNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
std::cerr << (*it)->getName() << std::endl;
}
/* instiate and run the MCMC */
Mcmc myMcmc = Mcmc( myModel, moves, monitors );
myMcmc.run(mcmcGenerations);
myMcmc.printOperatorSummary();
/* clean up */
// for (size_t i = 0; i < 10; ++i) {
// delete x[i];
// }
// delete [] x;
delete div;
// delete sigma;
// delete a;
// delete b;
// delete c;
std::cout << "Finished Autocorrelated Branch Heterogeneous GTR model test." << std::endl;
return true;
}
bool TestGtrGammaModel::run( void ) {
/* First, we read in the data */
// the matrix
NclReader& reader = NclReader::getInstance();
std::vector<AbstractCharacterData*> data = reader.readMatrices(alignmentFilename);
std::cout << "Read " << data.size() << " matrices." << std::endl;
std::vector<TimeTree*> trees = NclReader::getInstance().readTimeTrees( treeFilename );
std::cout << "Read " << trees.size() << " trees." << std::endl;
std::cout << trees[0]->getNewickRepresentation() << std::endl;
/* set up the model graph */
//////////////////////
// first the priors //
//////////////////////
// birth-death process priors
StochasticNode<double> *div = new StochasticNode<double>("diversification", new UniformDistribution(new ConstantNode<double>("", new double(0.0)), new ConstantNode<double>("", new double(100.0)) ));
ConstantNode<double> *turn = new ConstantNode<double>("turnover", new double(0.0));
ConstantNode<double> *rho = new ConstantNode<double>("rho", new double(1.0));
// gtr model priors
ConstantNode<std::vector<double> > *bf = new ConstantNode<std::vector<double> >( "bf", new std::vector<double>(4,1.0) );
ConstantNode<std::vector<double> > *e = new ConstantNode<std::vector<double> >( "e", new std::vector<double>(6,1.0) );
std::cout << "bf:\t" << bf->getValue() << std::endl;
std::cout << "e:\t" << e->getValue() << std::endl;
// then the parameters
StochasticNode<std::vector<double> > *pi = new StochasticNode<std::vector<double> >( "pi", new DirichletDistribution(bf) );
StochasticNode<std::vector<double> > *er = new StochasticNode<std::vector<double> >( "er", new DirichletDistribution(e) );
//Rate heterogeneity
ConstantNode<double> *alpha_prior = new ConstantNode<double>("alpha_prior", new double(0.5) );
ContinuousStochasticNode *alpha = new ContinuousStochasticNode("alpha", new ExponentialDistribution(alpha_prior) );
alpha->setValue( new double(0.5) );
std::cout << "alpha:\t" << alpha->getValue() << std::endl;
ConstantNode<double> *q1 = new ConstantNode<double>("q1", new double(0.125) );
DeterministicNode<double> *q1_value = new DeterministicNode<double>("q1_value", new QuantileFunction(q1, new GammaDistribution(alpha, alpha) ) );
// StochasticNode<double> *q1_value = new StochasticNode<double>("q1_value", new GammaDistribution(alpha, alpha) );
ConstantNode<double> *q2 = new ConstantNode<double>("q2", new double(0.375) );
DeterministicNode<double> *q2_value = new DeterministicNode<double>("q2_value", new QuantileFunction(q2, new GammaDistribution(alpha, alpha) ) );
// StochasticNode<double> *q2_value = new StochasticNode<double>("q2_value", new GammaDistribution(alpha, alpha) );
ConstantNode<double> *q3 = new ConstantNode<double>("q3", new double(0.625) );
DeterministicNode<double> *q3_value = new DeterministicNode<double>("q3_value", new QuantileFunction(q3, new GammaDistribution(alpha, alpha) ) );
// StochasticNode<double> *q3_value = new StochasticNode<double>("q3_value", new GammaDistribution(alpha, alpha) );
ConstantNode<double> *q4 = new ConstantNode<double>("q4", new double(0.875) );
DeterministicNode<double> *q4_value = new DeterministicNode<double>("q4_value", new QuantileFunction(q4, new GammaDistribution(alpha, alpha) ) );
// StochasticNode<double> *q4_value = new StochasticNode<double>("q4_value", new GammaDistribution(alpha, alpha) );
std::vector<const TypedDagNode<double>* > gamma_rates = std::vector<const TypedDagNode<double>* >();
gamma_rates.push_back(q1_value);
gamma_rates.push_back(q2_value);
gamma_rates.push_back(q3_value);
gamma_rates.push_back(q4_value);
DeterministicNode<std::vector<double> > *site_rates = new DeterministicNode<std::vector<double> >( "site_rates", new VectorFunction<double>(gamma_rates) );
// currently unused
// ConstantNode<std::vector<double> > *site_rate_probs = new ConstantNode<std::vector<double> >( "site_rate_probs", new std::vector<double>(4,1.0/4.0) );
DeterministicNode<std::vector<double> > *site_rates_norm = new DeterministicNode<std::vector<double> >( "site_rates_norm", new NormalizeVectorFunction(site_rates) );
pi->setValue( new std::vector<double>(4,1.0/4.0) );
er->setValue( new std::vector<double>(6,1.0/6.0) );
std::cout << "pi:\t" << pi->getValue() << std::endl;
std::cout << "er:\t" << er->getValue() << std::endl;
std::cout << "rates:\t" << site_rates->getValue() << std::endl;
std::cout << "rates:\t" << site_rates_norm->getValue() << std::endl;
DeterministicNode<RateMatrix> *q = new DeterministicNode<RateMatrix>( "Q", new GtrRateMatrixFunction(er, pi) );
std::cout << "Q:\t" << q->getValue() << std::endl;
std::vector<std::string> names = data[0]->getTaxonNames();
ConstantNode<double>* origin = new ConstantNode<double>( "origin", new double( trees[0]->getRoot().getAge()*2.0 ) );
std::vector<RevBayesCore::Taxon> taxa;
for (size_t i = 0; i < names.size(); ++i)
{
taxa.push_back( Taxon( names[i] ) );
}
StochasticNode<TimeTree> *tau = new StochasticNode<TimeTree>( "tau", new ConstantRateBirthDeathProcess(origin, NULL, div, turn, rho, "uniform", "survival", taxa, std::vector<Clade>()) );
tau->setValue( trees[0] );
std::cout << "tau:\t" << tau->getValue() << std::endl;
// and the character model
// (unused) size_t numChar = data[0]->getNumberOfCharacters();
GeneralBranchHeterogeneousCharEvoModel<DnaState, TimeTree> *phyloCTMC = new GeneralBranchHeterogeneousCharEvoModel<DnaState, TimeTree>(tau, 4, true, data[0]->getNumberOfCharacters());
phyloCTMC->setSiteRates( site_rates_norm );
phyloCTMC->setRateMatrix( q );
StochasticNode< AbstractCharacterData > *charactermodel = new StochasticNode< AbstractCharacterData >("S", phyloCTMC );
charactermodel->clamp( static_cast<DiscreteCharacterData<DnaState> *>( data[0] ) );
std::cout << "LnL:\t\t" << charactermodel->getLnProbability() << std::endl;
/* add the moves */
RbVector<Move> moves;
// moves.push_back( new ScaleMove(div, 1.0, true, 2.0) );
// moves.push_back( new NearestNeighborInterchange( tau, 5.0 ) );
// moves.push_back( new NarrowExchange( tau, 10.0 ) );
// moves.push_back( new FixedNodeheightPruneRegraft( tau, 2.0 ) );
// moves.push_back( new SubtreeScale( tau, 5.0 ) );
// moves.push_back( new TreeScale( tau, 1.0, true, 2.0 ) );
// moves.push_back( new NodeTimeSlideUniform( tau, 30.0 ) );
// moves.push_back( new RootTimeSlide( tau, 1.0, true, 2.0 ) );
// moves.push_back( new SimplexMove( er, 10.0, 1, 0, true, 2.0 ) );
// moves.push_back( new SimplexMove( pi, 10.0, 1, 0, true, 2.0 ) );
// moves.push_back( new SimplexMove( er, 100.0, 6, 0, true, 2.0 ) );
// moves.push_back( new SimplexMove( pi, 100.0, 4, 0, true, 2.0 ) );
moves.push_back( new MetropolisHastingsMove( new ScaleProposal(alpha, 1.0), 1, true) );
// moves.push_back( new ScaleMove(q1_value, 1.0, true, 2.0) );
// moves.push_back( new ScaleMove(q2_value, 1.0, true, 2.0) );
// moves.push_back( new ScaleMove(q3_value, 1.0, true, 2.0) );
// moves.push_back( new ScaleMove(q4_value, 1.0, true, 2.0) );
// add some tree stats to monitor
DeterministicNode<double> *treeHeight = new DeterministicNode<double>("TreeHeight", new TreeHeightStatistic(tau) );
/* add the monitors */
RbVector<Monitor> monitors;
std::set<DagNode*> monitoredNodes;
// monitoredNodes.insert( er );
// monitoredNodes.insert( pi );
// monitoredNodes.insert( q );
// monitoredNodes.insert( q1_value );
// monitoredNodes.insert( q2_value );
// monitoredNodes.insert( q3_value );
// monitoredNodes.insert( q4_value );
monitoredNodes.insert( site_rates_norm );
monitoredNodes.insert( alpha );
monitoredNodes.insert( treeHeight );
monitors.push_back( new FileMonitor( monitoredNodes, 1000, "TestGtrGammaModelSubstRates.log", "\t" ) );
monitors.push_back( new ScreenMonitor( monitoredNodes, 1000, "\t" ) );
std::set<DagNode*> monitoredNodes2;
monitoredNodes2.insert( tau );
monitors.push_back( new FileMonitor( monitoredNodes2, 1000, "TestGtrGammaModel.tree", "\t", false, false, false ) );
/* instantiate the model */
Model myModel = Model(q);
/* instiate and run the MCMC */
Mcmc myMcmc = Mcmc( myModel, moves, monitors );
myMcmc.run(mcmcGenerations);
myMcmc.printOperatorSummary();
/* clean up */
// for (size_t i = 0; i < 10; ++i) {
// delete x[i];
// }
// delete [] x;
delete div;
// delete sigma;
// delete a;
// delete b;
// delete c;
std::cout << "Finished GTR+Gamma model test." << std::endl;
return true;
}
bool TestFilteredStandardLikelihood::run( void ) {
std::cerr << " starting TestFilteredStandardLikelihood...\n" ;
/* First, we read in the data */
// the matrix
NclReader reader = NclReader();
std::vector<AbstractCharacterData*> data = reader.readMatrices(alignmentFilename);
AbstractDiscreteCharacterData * discrD = dynamic_cast<AbstractDiscreteCharacterData *>(data[0]);
# if defined(USE_TIME_TREE)
std::vector<TimeTree*> trees = reader.readTimeTrees( treeFilename );
ConstantNode<TimeTree> *tau = new ConstantNode<TimeTree>( "tau", new TimeTree( *trees[0] ) );
# else
std::vector<BranchLengthTree*> *trees = reader.readBranchLengthTrees( treeFilename );
ConstantNode<BranchLengthTree> *tau = new ConstantNode<BranchLengthTree>( "tau", new BranchLengthTree( *(*trees)[0] ) );
# endif
std::cout << "tau:\t" << tau->getValue() << std::endl;
# if defined(USE_3_STATES)
const size_t numStates = 3;
# else
const size_t numStates = 4;
# endif
size_t numChar = discrD->getNumberOfCharacters();
# if defined(USE_RATE_HET)
ConstantNode<double>* shape = new ConstantNode<double>("alpha", new double(0.5) );
ConstantNode<double>* rate = new ConstantNode<double>("", new double(0.5) );
ConstantNode<int>* numCats = new ConstantNode<int>("ncat", new int(4) );
DiscretizeGammaFunction *dFunc = new DiscretizeGammaFunction( shape, rate, numCats, false );
DeterministicNode<RbVector<double> > *site_rates_norm_2 = new DeterministicNode<RbVector<double> >( "site_rates_norm", dFunc );
std::cout << "rates:\t" << site_rates_norm_2->getValue() << std::endl;
# endif
#if defined(USE_3_STATES) && defined(USE_NUCLEOTIDE)
#error "cannot use 3 state and nucleotide type"
#endif
#if defined(USE_3_STATES) && defined(USE_GTR_RATE_MAT)
#error "cannot use 3 state and USE_GTR_RATE_MAT"
#endif
# if defined(USE_GTR_RATE_MAT)
ConstantNode<RbVector<double> > *pi = new ConstantNode<RbVector<double> >( "pi", new RbVector<double>(4, 1.0/4.0) );
ConstantNode<RbVector<double> > *er = new ConstantNode<RbVector<double> >( "er", new RbVector<double>(6, 1.0/6.0) );
DeterministicNode<RateMatrix> *q = new DeterministicNode<RateMatrix>( "Q", new GtrRateMatrixFunction(er, pi) );
std::cout << "Q:\t" << q->getValue() << std::endl;
# if defined (USE_NUCLEOTIDE)
# if defined(USE_TIME_TREE)
PhyloCTMCSiteHomogeneousNucleotide<DnaState, TimeTree> *charModel = new PhyloCTMCSiteHomogeneousNucleotide<DnaState, TimeTree>(tau, false, numChar);
# else
PhyloCTMCSiteHomogeneousNucleotide<DnaState, BranchLengthTree> *charModel = new PhyloCTMCSiteHomogeneousNucleotide<DnaState, BranchLengthTree>(tau, false, numChar );
# endif
# else
# if defined(USE_TIME_TREE)
PhyloCTMCSiteHomogeneous<DnaState, TimeTree> *charModel = new PhyloCTMCSiteHomogeneous<DnaState, TimeTree>(tau, 4, false, numChar);
# else
PhyloCTMCSiteHomogeneous<DnaState, BranchLengthTree> *charModel = new PhyloCTMCSiteHomogeneous<DnaState, BranchLengthTree>(tau, 4, false, numChar );
# endif
# endif
# else
DeterministicNode<RateMatrix> *q = new DeterministicNode<RateMatrix>( "Q", new JcRateMatrixFunction(numStates));
# if defined (USE_NUCLEOTIDE)
# if defined(USE_TIME_TREE)
PhyloCTMCSiteHomogeneousNucleotide<StandardState, TimeTree> *charModel = new PhyloCTMCSiteHomogeneousNucleotide<StandardState, TimeTree>(tau, false, numChar);
# else
PhyloCTMCSiteHomogeneousNucleotide<StandardState, BranchLengthTree> *charModel = new PhyloCTMCSiteHomogeneousNucleotide<StandardState, BranchLengthTree>(tau, false, numChar );
# endif
# else
# if defined(USE_TIME_TREE)
PhyloCTMCSiteHomogeneous<StandardState, TimeTree> *charModel = new PhyloCTMCSiteHomogeneous<StandardState, TimeTree>(tau, numStates, false, numChar);
# else
PhyloCTMCSiteHomogeneous<StandardState, BranchLengthTree> *charModel = new PhyloCTMCSiteHomogeneous<StandardState, BranchLengthTree>(tau, numStates, false, numChar );
# endif
# endif
# endif
# if defined(USE_RATE_HET)
charModel->setSiteRates( site_rates_norm_2 );
# endif
charModel->setRateMatrix( q );
StochasticNode< AbstractDiscreteCharacterData > *charactermodel = new StochasticNode< AbstractDiscreteCharacterData >("S", charModel);
charactermodel->clamp( discrD );
double lnp = charactermodel->getLnProbability();
std::cerr << " lnProb = " << lnp << std::endl;
# if defined(USE_3_STATES)
# if defined(USE_RATE_HET)
const double paupLnL = lnp; // can't check this against paup....
# else
const double paupLnL = -813.23060;
# endif
# else
# if defined(USE_RATE_HET)
const double paupLnL = -900.9122;
# else
const double paupLnL = -892.5822;
# endif
# endif
const double tol = 0.01;
if (fabs(lnp - paupLnL) > tol) {
std::cerr << " deviates too much from the likelihood from PAUP* of " << paupLnL << std::endl;
return false;
}
if (lnp >= 0.0) {
std::cerr << " lnProb is too high!" << std::endl;
return false;
}
std::cout << "RevBayes LnL:\t\t" << charactermodel->getLnProbability() << std::endl;
std::cout << "Finished GTR+Gamma model test." << std::endl;
return true;
}
