void T92GCBranchTree::recursiveUpdate(const RevBayesCore::TopologyNode &from) {
size_t index = from.getIndex();
double gc = 0.5;
if (from.isRoot()) {
gc = rootgc->getValue();
}
else {
gc = gctree->getValue()[index];
}
RateMatrix_HKY& matrix = static_cast<RateMatrix_HKY&>( (*value)[index] );
std::vector<double> v(4);
v[0] = v[3] = 0.5 * (1 - gc);
v[1] = v[2] = 0.5 * gc;
matrix.setStationaryFrequenciesByCopy(v);
matrix.setKappa(kappa->getValue());
// simulate the val for each child (if any)
size_t numChildren = from.getNumberOfChildren();
for (size_t i = 0; i < numChildren; ++i) {
const TopologyNode& child = from.getChild(i);
recursiveUpdate(child);
}
}
void BranchLengthTree::reverseParentChild(RevBayesCore::TopologyNode &n)
{
if ( !n.isRoot() )
{
TopologyNode &p = n.getParent();
reverseParentChild( p );
p.removeChild( &n );
p.setParent( &n );
n.addChild( &p );
// swap branch lengths
double parent_branch_length = branchLengths[p.getIndex()];
double child_branch_length = branchLengths[n.getIndex()];
branchLengths[p.getIndex()] = child_branch_length;
branchLengths[n.getIndex()] = parent_branch_length;
}
}
void BranchLengthTree::reroot(RevBayesCore::TopologyNode &n)
{
// reset parent/child relationships
reverseParentChild( n.getParent() );
n.getParent().setParent( NULL );
// get copies of the nodes and branchLengths
std::vector<double> old_branchLengths = branchLengths;
std::vector<TopologyNode*> nodes = getNodes();
// set the new root
topology->setRoot( &n.getParent() );
// reset the branch lengths
for (size_t i = 0; i < branchLengths.size(); ++i)
{
branchLengths[nodes[i]->getIndex()] = old_branchLengths[i];
}
}
void Func_simTree::simulateBalancedTree( size_t n, std::vector<RevBayesCore::TopologyNode*> &nodes )
{
// check if the number of taxa is divideable by two
size_t half = n / 2;
if ( (half+half) != n )
{
throw RbException("Bad number of taxa.");
}
std::vector<RevBayesCore::TopologyNode*> children;
for (size_t i = 0; i < nodes.size(); ++i)
{
RevBayesCore::TopologyNode *parent = nodes[i];
// add a left child
RevBayesCore::TopologyNode* leftChild = new RevBayesCore::TopologyNode(0);
parent->addChild(leftChild);
leftChild->setParent(parent);
children.push_back(leftChild);
// add a right child
RevBayesCore::TopologyNode* rightChild = new RevBayesCore::TopologyNode(0);
parent->addChild(rightChild);
rightChild->setParent(parent);
children.push_back(rightChild);
}
if ( half == 1 )
{
// we are done with the recursion
for (size_t i = 0; i < children.size(); ++i)
{
RevBayesCore::TopologyNode *node = children[i];
std::string name = "Taxon_" + StringUtilities::to_string(i+1);
node->setName(name);
}
}
else
{
simulateBalancedTree(half, children);
}
}
void Func_simTree::simulateCaterpillarTree( size_t n, RevBayesCore::TopologyNode* node )
{
// add a left child
RevBayesCore::TopologyNode* leftChild = new RevBayesCore::TopologyNode(0);
node->addChild(leftChild);
leftChild->setParent(node);
// add a right child
RevBayesCore::TopologyNode* rightChild = new RevBayesCore::TopologyNode(0);
node->addChild(rightChild);
rightChild->setParent(node);
std::string name = "Taxon_" + StringUtilities::to_string(n);
rightChild->setName(name);
if ( n > 2 )
{
simulateCaterpillarTree(n-1, leftChild);
}
else
{
std::string name = "Taxon_" + StringUtilities::to_string(n-1);
leftChild->setName(name);
}
}
void Func_simTree::setAges(RevBayesCore::TimeTree *t, RevBayesCore::TopologyNode &n)
{
if ( n.isTip() )
{
t->setAge(n.getIndex(), 0.0);
}
else
{
RevBayesCore::TopologyNode &left = n.getChild( 0 );
setAges(t, left);
RevBayesCore::TopologyNode &right = n.getChild( 1 );
setAges(t, right);
double a = t->getAge(left.getIndex());
double b = t->getAge(right.getIndex());
double max = (a > b ? a : b);
t->setAge(n.getIndex(), max + 1.0);
}
}
void HeterogeneousRateBirthDeath::computeNodeProbability(const RevBayesCore::TopologyNode &node, size_t node_index)
{
// check for recomputation
if ( dirty_nodes[node_index] || true )
{
// mark as computed
dirty_nodes[node_index] = false;
const BranchHistory& bh = branch_histories[ node_index ];
const std::multiset<CharacterEvent*,CharacterEventCompare>& hist = bh.getHistory();
// const std::vector<CharacterEvent*> child_states = bh.getChildCharacters();
// size_t start_index = child_states[0]->getState();
size_t state_index_tipwards = computeStartIndex( node_index );
size_t state_index_rootwards = computeStartIndex( node.getParent().getIndex() );
std::vector<double> initialState = std::vector<double>(1+num_rate_categories,0);
if ( node.isTip() )
{
// this is a tip node
double samplingProbability = rho->getValue();
for (size_t i=0; i<num_rate_categories; ++i)
{
initialState[i] = 1.0 - samplingProbability;
}
initialState[num_rate_categories] = samplingProbability;
}
else
{
// this is an internal node
const TopologyNode &left = node.getChild(0);
size_t left_index = left.getIndex();
computeNodeProbability( left, left_index );
const TopologyNode &right = node.getChild(1);
size_t right_index = right.getIndex();
computeNodeProbability( right, right_index );
// now compute the likelihoods of this internal node
const std::vector<double> &leftStates = nodeStates[left_index][activeLikelihood[left_index]];
const std::vector<double> &rightStates = nodeStates[right_index][activeLikelihood[right_index]];
const RbVector<double> &birthRate = speciation->getValue();
for (size_t i=0; i<num_rate_categories; ++i)
{
initialState[i] = leftStates[i];
}
initialState[num_rate_categories] = leftStates[num_rate_categories]*rightStates[num_rate_categories]*birthRate[ state_index_tipwards ];
}
const RbVector<double> &s = speciation->getValue();
const RbVector<double> &e = extinction->getValue();
double r = event_rate->getValue();
double beginAge = node.getAge();
// remember that we go back in time (rootwards)
double begin_time = 0.0;
double branch_length = node.getBranchLength();
// set the previous state to an impossible state
// we need this for checking if the states were different
size_t previous_state = num_rate_categories;
for (std::multiset<CharacterEvent*,CharacterEventCompare>::const_iterator it=hist.begin(); it!=hist.end(); ++it)
{
CharacterEvent* event = *it;
double end_time = event->getTime();
double time_interval = end_time - begin_time;
// we need to set the current rate category
size_t current_state = event->getState();
// check that we got a distinct new state
if ( previous_state == current_state )
{
shift_same_category = true;
}
updateBranchProbabilitiesNumerically(initialState, beginAge, beginAge+time_interval, s, e, r, current_state);
initialState[num_rate_categories] = initialState[num_rate_categories]*event_rate->getValue()* (1.0/num_rate_categories);
begin_time = end_time;
beginAge += time_interval;
previous_state = current_state;
}
// check that we got a distinct new state
if ( previous_state == state_index_rootwards )
{
shift_same_category = true;
}
double time_interval = branch_length - begin_time;
updateBranchProbabilitiesNumerically(initialState, beginAge, beginAge+time_interval, s, e, r, state_index_rootwards);
// rescale the states
double max = initialState[num_rate_categories];
initialState[num_rate_categories] = 1.0;
// totalScaling -= scalingFactors[node_index][activeLikelihood[node_index]];
// scalingFactors[node_index][activeLikelihood[node_index]] = log(max);
// totalScaling += scalingFactors[node_index][activeLikelihood[node_index]] - scalingFactors[node_index][activeLikelihood[node_index]^1];
// totalScaling += scalingFactors[node_index][activeLikelihood[node_index]];
totalScaling += log(max);
// store the states
nodeStates[node_index][activeLikelihood[node_index]] = initialState;
}
}
void CharacterDependentCladoBirthDeathProcess::computeNodeProbability(const RevBayesCore::TopologyNode &node, size_t node_index) const
{
// check for recomputation
if ( dirty_nodes[node_index] || true )
{
// mark as computed
dirty_nodes[node_index] = false;
// get cladogenesis event map (sparse speciation rate matrix)
const DeterministicNode<MatrixReal>* cpn = static_cast<const DeterministicNode<MatrixReal>* >( cladogenesis_matrix );
const TypedFunction<MatrixReal>& tf = cpn->getFunction();
const AbstractCladogenicStateFunction* csf = dynamic_cast<const AbstractCladogenicStateFunction*>( &tf );
std::map<std::vector<unsigned>, double> eventMap = csf->getEventMap();
state_type node_likelihood = std::vector<double>(2*num_states,0);
if ( node.isTip() )
{
// this is a tip node
double samplingProbability = rho->getValue();
const DiscreteCharacterState &state = static_cast<TreeDiscreteCharacterData*>( this->value )->getCharacterData().getTaxonData( node.getTaxon().getName() )[0];
const RbBitSet &obs_state = state.getState();
for (size_t j = 0; j < num_states; ++j)
{
node_likelihood[j] = 1.0 - samplingProbability;
if ( obs_state.isSet( j ) == true || state.isMissingState() == true || state.isGapState() == true )
{
node_likelihood[num_states+j] = samplingProbability;
}
else
{
node_likelihood[num_states+j] = 0.0;
}
}
}
else
{
// this is an internal node
const TopologyNode &left = node.getChild(0);
size_t left_index = left.getIndex();
computeNodeProbability( left, left_index );
const TopologyNode &right = node.getChild(1);
size_t right_index = right.getIndex();
computeNodeProbability( right, right_index );
// get the likelihoods of descendant nodes
const state_type &left_likelihoods = partial_likelihoods[left_index];
const state_type &right_likelihoods = partial_likelihoods[right_index];
// merge descendant likelihoods
for (size_t i=1; i<num_states; ++i)
{
node_likelihood[i] = left_likelihoods[i];
double like_sum = 0.0;
std::map<std::vector<unsigned>, double>::iterator it;
for (it = eventMap.begin(); it != eventMap.end(); it++)
{
const std::vector<unsigned>& states = it->first;
double speciation_rate = it->second;
if (i == states[0])
{
double likelihoods = left_likelihoods[num_states + states[1]] * right_likelihoods[num_states + states[2]];
like_sum += speciation_rate * likelihoods;
}
}
node_likelihood[num_states + i] = like_sum;
}
}
// calculate likelihood for this branch
CDCladoSE ode = CDCladoSE(extinction_rates, &Q->getValue(), eventMap, rate->getValue());
double beginAge = node.getAge();
double endAge = node.getParent().getAge();
double dt = root_age->getValue() / NUM_TIME_SLICES;
// boost::numeric::odeint::runge_kutta4< state_type > stepper;
// boost::numeric::odeint::integrate_const( stepper, ode , node_likelihood , beginAge , endAge, dt );
boost::numeric::odeint::bulirsch_stoer< state_type > stepper(1E-8, 0.0, 0.0, 0.0);
boost::numeric::odeint::integrate_adaptive( stepper, ode , node_likelihood , beginAge , endAge, dt );
// store the likelihoods
partial_likelihoods[node_index] = node_likelihood;
}
}
void StateDependentSpeciationExtinctionProcess::computeNodeProbability(const RevBayesCore::TopologyNode &node, size_t node_index) const
{
// check for recomputation
// if ( dirty_nodes[node_index] == true )
if ( true )
{
// mark as computed
dirty_nodes[node_index] = false;
std::vector<double> node_likelihood = std::vector<double>(2 * num_states, 0);
if ( node.isTip() == true )
{
// this is a tip node
double samplingProbability = rho->getValue();
const DiscreteCharacterState &state = static_cast<TreeDiscreteCharacterData*>( this->value )->getCharacterData().getTaxonData( node.getTaxon().getName() )[0];
const RbBitSet &obs_state = state.getState();
for (size_t j = 0; j < num_states; ++j)
{
node_likelihood[j] = 1.0 - samplingProbability;
if ( obs_state.isSet( j ) == true || state.isMissingState() == true || state.isGapState() == true )
{
node_likelihood[num_states+j] = samplingProbability;
}
else
{
node_likelihood[num_states+j] = 0.0;
}
}
}
else
{
// this is an internal node
const TopologyNode &left = node.getChild(0);
size_t left_index = left.getIndex();
computeNodeProbability( left, left_index );
const TopologyNode &right = node.getChild(1);
size_t right_index = right.getIndex();
computeNodeProbability( right, right_index );
// get the likelihoods of descendant nodes
const std::vector<double> &left_likelihoods = partial_likelihoods[left_index][active_likelihood[left_index]];
const std::vector<double> &right_likelihoods = partial_likelihoods[right_index][active_likelihood[right_index]];
std::map<std::vector<unsigned>, double> eventMap;
std::vector<double> speciation_rates;
if ( use_cladogenetic_events == true )
{
// get cladogenesis event map (sparse speciation rate matrix)
const DeterministicNode<MatrixReal>* cpn = static_cast<const DeterministicNode<MatrixReal>* >( cladogenesis_matrix );
const TypedFunction<MatrixReal>& tf = cpn->getFunction();
const AbstractCladogenicStateFunction* csf = dynamic_cast<const AbstractCladogenicStateFunction*>( &tf );
eventMap = csf->getEventMap();
}
else
{
speciation_rates = lambda->getValue();
}
// merge descendant likelihoods
for (size_t i=0; i<num_states; ++i)
{
node_likelihood[i] = left_likelihoods[i];
if ( use_cladogenetic_events == true )
{
double like_sum = 0.0;
std::map<std::vector<unsigned>, double>::iterator it;
for (it = eventMap.begin(); it != eventMap.end(); it++)
{
const std::vector<unsigned>& states = it->first;
double speciation_rate = it->second;
if (i == states[0])
{
double likelihoods = left_likelihoods[num_states + states[1]] * right_likelihoods[num_states + states[2]];
like_sum += speciation_rate * likelihoods;
}
}
node_likelihood[num_states + i] = like_sum;
}
else
{
node_likelihood[num_states + i] = left_likelihoods[num_states + i] * right_likelihoods[num_states + i] * speciation_rates[i];
}
}
}
// calculate likelihood for this branch
double begin_age = node.getAge();
double end_age = node.getParent().getAge();
numericallyIntegrateProcess(node_likelihood, begin_age, end_age, true, false);
// rescale the states
double max = 0.0;
for (size_t i=0; i<num_states; ++i)
{
if ( node_likelihood[num_states+i] > max )
{
max = node_likelihood[num_states+i];
}
}
for (size_t i=0; i<num_states; ++i)
{
node_likelihood[num_states+i] /= max;
}
scaling_factors[node_index][active_likelihood[node_index]] = log(max);
total_scaling += scaling_factors[node_index][active_likelihood[node_index]] - scaling_factors[node_index][active_likelihood[node_index]^1];
// store the likelihoods
partial_likelihoods[node_index][active_likelihood[node_index]] = node_likelihood;
}
}
void MultiRateBirthDeathProcess::computeNodeProbability(const RevBayesCore::TopologyNode &node, size_t node_index) const
{
// check for recomputation
if ( dirty_nodes[node_index] || true )
{
// mark as computed
dirty_nodes[node_index] = false;
state_type initialState = std::vector<double>(2*numRateCategories,0);
if ( node.isTip() )
{
// this is a tip node
double samplingProbability = rho->getValue();
for (size_t i=0; i<numRateCategories; ++i)
{
initialState[i] = 1.0 - samplingProbability;
initialState[numRateCategories+i] = samplingProbability;
}
}
else
{
// this is an internal node
const TopologyNode &left = node.getChild(0);
size_t left_index = left.getIndex();
computeNodeProbability( left, left_index );
const TopologyNode &right = node.getChild(1);
size_t right_index = right.getIndex();
computeNodeProbability( right, right_index );
// now compute the likelihoods of this internal node
const state_type &leftStates = nodeStates[left_index][activeLikelihood[left_index]];
const state_type &rightStates = nodeStates[right_index][activeLikelihood[right_index]];
const RbVector<double> &birthRate = lambda->getValue();
for (size_t i=0; i<numRateCategories; ++i)
{
initialState[i] = leftStates[i];
initialState[numRateCategories+i] = leftStates[numRateCategories+i]*rightStates[numRateCategories+i]*birthRate[i];
}
}
CDSE ode = CDSE(lambda->getValue(), mu->getValue(), &Q->getValue(), rate->getValue());
double beginAge = node.getAge();
double endAge = node.getParent().getAge();
double dt = root_age->getValue() / NUM_TIME_SLICES;
boost::numeric::odeint::runge_kutta4< state_type > stepper;
boost::numeric::odeint::integrate_const( stepper, ode , initialState , beginAge , endAge, dt );
// rescale the states
double max = 0.0;
for (size_t i=0; i<numRateCategories; ++i)
{
if ( initialState[numRateCategories+i] > max )
{
max = initialState[numRateCategories+i];
}
}
// max = 1.0;
for (size_t i=0; i<numRateCategories; ++i)
{
initialState[numRateCategories+i] /= max;
}
scalingFactors[node_index][activeLikelihood[node_index]] = log(max);
totalScaling += scalingFactors[node_index][activeLikelihood[node_index]] - scalingFactors[node_index][activeLikelihood[node_index]^1];
// store the states
nodeStates[node_index][activeLikelihood[node_index]] = initialState;
}
}
