//insert a new node between fatherNode and sonNode
tree::nodeP makeNodeBetweenTwoNodes(tree& et,
tree::nodeP fatherNode,
tree::nodeP sonNode,
const string &interName){
//make sure that fatherNode is indeed the father and sonNode is the son (and not the opposite).
if (fatherNode->father() == sonNode) {
tree::nodeP tmp = fatherNode;
fatherNode = sonNode;
sonNode = tmp;
}
else if (sonNode->father() != fatherNode) {
errorMsg::reportError("Error in function 'cut_tree_in_two'. the two nodes are not neighbours ");
}
tree::nodeP theNewNodePTR = new tree::TreeNode(et.getNodesNum());
//fix the tree information for the new node.
theNewNodePTR->setName(interName);
MDOUBLE tmpLen = sonNode->dis2father() * 0.5;
theNewNodePTR->setDisToFather(tmpLen);
theNewNodePTR->setFather(fatherNode);
theNewNodePTR->setSon(sonNode);
//fix the tree information for the father node.
fatherNode->removeSon(sonNode);
fatherNode->setSon(theNewNodePTR);
//fix the tree information for the sonNode.
sonNode->setFather(theNewNodePTR);
sonNode->setDisToFather(tmpLen);
return theNewNodePTR;
}
void computeMarginalAlg::fillComputeMarginal(const tree& et,
const sequenceContainer& sc,
const stochasticProcess& sp,
const int pos,
const computePijHom& pi,
suffStatGlobalHomPos& ssc,
const suffStatGlobalHomPos& cup,
const suffStatGlobalHomPos& cdown,
doubleRep & posProb){
// filling the exact probs.
tree::nodeP mynode = NULL;
ssc.allocatePlace(et.getNodesNum(),pi.alphabetSize());
treeIterTopDownConst tIt(et);
for (mynode = tIt.first(); mynode != tIt.end(); mynode = tIt.next()) {
assert (mynode != NULL);
int letter;
if (mynode->isLeaf()) {
for(letter=0; letter<pi.alphabetSize();letter++) {
doubleRep val=convert(cup.get(mynode->id(),letter))?1.0:0.0;
ssc.set(mynode->id(),letter,val);
}
continue;
}
doubleRep sumProb =0;
for(letter=0; letter<pi.alphabetSize();letter++) {
doubleRep prob=0.0;
if (mynode->father()==NULL) prob=1.0; // special case of the root.
else {
for(int letter_in_f=0; letter_in_f<pi.alphabetSize();letter_in_f++) {
prob +=cdown.get(mynode->id(),letter_in_f)*
pi.getPij(mynode->id(),letter,letter_in_f);
}
}
prob = prob*sp.freq(letter)*
cup.get(mynode->id(),letter);
ssc.set(mynode->id(),letter,prob);
sumProb += prob;
}
for(letter=0; letter<pi.alphabetSize();letter++) {
doubleRep getV = ssc.get(mynode->id(),letter);
ssc.set(mynode->id(),letter,getV/sumProb);
}
// CHECKING:
/* LOG(5,<<" checking marginal of node: "<<mynode->name()<<endl);
MDOUBLE SSum =0;
for (int u=0; u < pi.alphabetSize(); ++u) {
LOG(5,<<ssc.get(mynode->id(),u)<<" ");
SSum +=ssc.get(mynode->id(),u);
}
LOG(5,<<"\nsum of marginals = "<<SSum<<endl);
*/
if (mynode->isRoot()) posProb = convert(sumProb);
}
}
bool sameTreeTolopogy(tree t1, tree t2){
if (t1.getNodesNum() != t2.getNodesNum()) {
errorMsg::reportError("error in function same tree topology (1)");
}
tree::nodeP x = t2.getRoot();
while (x->getNumberOfSons() > 0) x= x->getSon(0);
t1.rootAt(t1.findNodeByName(x->name())->father()); // now they have the same root
t2.rootAt(t2.findNodeByName(x->name())->father()); // now they have the same root
map<int,string> names1;
treeIterDownTopConst tit1(t1);
for (tree::nodeP nodeM = tit1.first(); nodeM != tit1.end(); nodeM = tit1.next()) {
vector<string> nameOfChild;
for (int i=0; i < nodeM->getNumberOfSons();++i) {
nameOfChild.push_back(names1[nodeM->getSon(i)->id()]);
}
if (nodeM->getNumberOfSons()==0) nameOfChild.push_back(nodeM->name());
sort(nameOfChild.begin(),nameOfChild.end());
string res = "(";
for (int k=0; k < nameOfChild.size(); ++k) {
res += nameOfChild[k];
}
res += ")";
names1[nodeM->id()] = res;
}
map<int,string> names2;
treeIterDownTopConst tit2(t2);
for (tree::nodeP nodeM2 = tit2.first(); nodeM2 != tit2.end(); nodeM2 = tit2.next()) {
vector<string> nameOfChild;
for (int i=0; i < nodeM2->getNumberOfSons();++i) {
nameOfChild.push_back(names2[nodeM2->getSon(i)->id()]);
}
if (nodeM2->getNumberOfSons()==0) nameOfChild.push_back(nodeM2->name());
sort(nameOfChild.begin(),nameOfChild.end());
string res = "(";
for (int k=0; k < nameOfChild.size(); ++k) {
res += nameOfChild[k];
}
res += ")";
names2[nodeM2->id()] = res;
}
return names1[t1.getRoot()->id()] == names2[t2.getRoot()->id()];
}
void computeUpAlg::fillComputeUpWithFactors(const tree& et,
const sequenceContainer& sc,
const int pos,
const stochasticProcess& sp,
suffStatGlobalHomPos& ssc,
vector<MDOUBLE>& factors) {
factors.resize(et.getNodesNum(),0.0);
seqContainerTreeMap sctm(sc,et);
ssc.allocatePlace(et.getNodesNum(),sp.alphabetSize());
treeIterDownTopConst tIt(et);
for (tree::nodeP mynode = tIt.first(); mynode != tIt.end(); mynode = tIt.next()) {
int letter;
if (mynode->getNumberOfSons() == 0) {// leaf
for(letter=0; letter<sp.alphabetSize();letter++) {
const int seqID = sctm.seqIdOfNodeI(mynode->id());
doubleRep val = sc.getAlphabet()->relations(sc[seqID][pos],letter);
ssc.set(mynode->id(),letter,val);
}
computeNodeFactorAndSetSsc(factors[mynode->id()],ssc,mynode->id(),sp.alphabetSize());
}
else {
for(letter=0; letter<sp.alphabetSize();letter++) {
doubleRep total_prob=1.0;
for(int i=0; i < mynode->getNumberOfSons();++i){
doubleRep prob=0.0;
for(int letInSon=0; letInSon<sp.alphabetSize();letInSon++) {
prob += ssc.get(mynode->getSon(i)->id(),letInSon)*
sp.Pij_t(letter,letInSon,mynode->getSon(i)->dis2father()*sp.getGlobalRate());// taking care of the glubal is new.
}
assert(prob>=0);
total_prob*=prob;
}
ssc.set(mynode->id(),letter,total_prob);
}
computeNodeFactorAndSetSsc(factors[mynode->id()],ssc,mynode->id(),sp.alphabetSize());
for(int k=0; k < mynode->getNumberOfSons();++k) {
factors[mynode->id()]+=factors[mynode->getSon(k)->id()];
}
}
}
}
// bigTree is passed by value and not by reference. Therefore, this method doens't change the original bigTree,
// but allocates a new bigTree to be split.
bool cutTreeToTwo(tree bigTree,
const string& nameOfNodeToCut,
tree &small1,
tree &small2){// cutting above the NodeToCut.
// we want to cut the tree in two.
// first step: we make a new node between the two nodes that have to be splited,
tree::nodeP node2splitOnNewTree = bigTree.findNodeByName(nameOfNodeToCut);
string interNode = "interNode";
if (node2splitOnNewTree->father() == NULL) return(false);
// assert(node2splitOnNewTree->father() != NULL);
tree::nodeP tmp = makeNodeBetweenTwoNodes(bigTree,node2splitOnNewTree->father(),node2splitOnNewTree, interNode);
bigTree.rootAt(tmp); // tmp is the interNode and it's now the root of the tree. Its sons are node2splitOnNewTree and its father.
string allNodes = "Runs/testBifurcating/beforeCut.tree";
bigTree.output(allNodes, tree::PHYLIP, true);
cutTreeToTwoSpecial(bigTree,tmp, small1,small2);
if (small1.getNodesNum() < 5 || small2.getNodesNum() < 5) return (false);
LOGDO(15,small1.output(myLog::LogFile(),tree::ANCESTORID));
LOGDO(15,small2.output(myLog::LogFile(),tree::ANCESTORID));
tree::nodeP toDel1 = small1.findNodeByName(interNode);
small1.removeLeaf(toDel1);
tree::nodeP toDel2 = small2.findNodeByName(interNode);
small2.removeLeaf(toDel2);
// this part fix the ids.
treeIterTopDown tIt(small1);
int newId =0;
for (tree::nodeP mynode = tIt.first(); mynode != tIt.end(); mynode = tIt.next()) {
mynode->setID(newId);
newId++;
}
treeIterTopDown tIt2(small2);
int newId2 =0;
for (tree::nodeP mynode2 = tIt2.first(); mynode2 != tIt2.end(); mynode2 = tIt2.next()) {
mynode2->setID(newId2);
newId2++;
}
return (true); // successes!
};
void BBfillComputeDown(const tree& et,
const sequenceContainer& sc,
const int pos,
const computePijHom& pi,
suffStatGlobalHomPos& ssc,
const suffStatGlobalHomPos& cup,
const vector<sequence>& ancS){
ssc.allocatePlace(et.getNodesNum(), pi.alphabetSize());
treeIterTopDownConst tIt(et);
for (tree::nodeP mynode = tIt.first(); mynode != tIt.end(); mynode = tIt.next()) {
int letter,letterInFather,bro,letterInSon;
if (mynode->father()==NULL) {// if root
for(letter=0; letter<pi.alphabetSize();letter++) {
ssc.set(mynode->id(),letter,1.0);
}
mynode = tIt.next(); //continue
}
tree::nodeP fatherNode=mynode->father();
const int n_bro=fatherNode->getNumberOfSons();
for(letter=0; letter<pi.alphabetSize();letter++) {
if ((ancS[mynode->father()->id()][pos]!=-2)&&(ancS[mynode->father()->id()][pos]!=letter)){
ssc.set(mynode->id(),letter,0);
continue;
} // this if takes care of internal node assignments...
doubleRep totalProb=1.0;
doubleRep fatherTerm=0;
if (fatherNode->father()!=NULL) {
for(letterInFather=0; letterInFather<pi.alphabetSize();letterInFather++)
fatherTerm += pi.getPij(fatherNode->id(),letter,letterInFather)*
ssc.get(fatherNode->id(),letterInFather);
}
else {
fatherTerm=1.0;
}
doubleRep brotherTerm=1.0;
for(bro = 0; bro < n_bro; bro++) {
tree::nodeP brother = fatherNode->getSon(bro);
if (brother != mynode) {
doubleRep tmp_bro=0.0;
for(letterInSon=0; letterInSon<pi.alphabetSize();letterInSon++) {
tmp_bro+=pi.getPij(fatherNode->getSon(bro)->id(),letter,letterInSon)*
cup.get(brother->id(),letterInSon);
}
brotherTerm *=tmp_bro;
}
}
totalProb = fatherTerm * brotherTerm;
ssc.set(mynode->id(),letter,totalProb);
}
}
}
void computePijHom::fillPij(const tree& et, const stochasticProcess& sp, int derivationOrder, bool isReversible) {
_V.resize(et.getNodesNum());
treeIterTopDownConst tIt(et);
tree::nodeP myNode = tIt.first();
{// skipping the root, but allocating place for the root pij even if they are not use
// to maintain that all arrays have the same size.
_V[myNode->id()].resize(sp.alphabetSize());
}
LOGDO(50,et.output(myLog::LogFile(),tree::ANCESTOR));
LOGDO(50,et.output(myLog::LogFile(),tree::PHYLIP));
for (; myNode != tIt.end(); myNode = tIt.next()) {
if (!(myNode->isRoot()))
_V[myNode->id()].fillPij(myNode->dis2father()*sp.getGlobalRate(),sp,derivationOrder,isReversible);
// else
// myLog::LogFile()<<"ROOT IS "<<myNode->name()<<endl;
}
}
void splitSonsFromNode(tree & et, tree::nodeP fatherNode, vector<tree::nodeP> & son2split)
{
for (int k=0; k < son2split.size(); ++k) {
if (son2split[k]->father() != fatherNode )
errorMsg::reportError(" error in function bootstrap::splitSonsFromNode - nodes don't have the same father");
}
// if the split allready exists, we do not need to do anything.
if (son2split.size()==fatherNode->getNumberOfSons() // the branch above us is the required split
|| son2split.size() <=1 // the branch below us is it
|| (fatherNode->father()==NULL && son2split.size()==fatherNode->getNumberOfSons()-1)
// the branch above us is the required split
)
return;
tree::nodeP theNewNode = et.createNode(fatherNode,et.getNodesNum());
theNewNode->setName("N"+int2string(theNewNode->id()));
for (int i=0; i < son2split.size(); ++i) {
son2split[i]->setFather(theNewNode);
theNewNode->setSon(son2split[i]);
// remove from son list of father node.
fatherNode->removeSon(son2split[i]);
}
}
void computeUpAlg::fillComputeUpSpecificGlobalRateFactors(const tree& et,
const sequenceContainer& sc,
const int pos,
const stochasticProcess& sp,
suffStatGlobalHomPos& ssc,
const MDOUBLE gRate,
vector<MDOUBLE>& factors) {
factors.resize(et.getNodesNum(),0.0);
seqContainerTreeMap sctm(sc,et);
ssc.allocatePlace(et.getNodesNum(),sp.alphabetSize());
treeIterDownTopConst tIt(et);
for (tree::nodeP mynode = tIt.first(); mynode != tIt.end(); mynode = tIt.next()) {
#ifdef VERBOS
LOG(5,<<endl<<endl<<"doing node: "<<mynode->name()<<endl);
#endif
int letter;
if (mynode->getNumberOfSons() == 0) {// leaf
for(letter=0; letter<sp.alphabetSize();letter++) {
const int seqID = sctm.seqIdOfNodeI(mynode->id());
doubleRep val = sc.getAlphabet()->relations(sc[seqID][pos],letter);
ssc.set(mynode->id(),letter,val);
}
computeNodeFactorAndSetSsc(factors[mynode->id()],ssc,mynode->id(),sp.alphabetSize());
}
else {
int letterWithTotalProbEqZero =0;
for(letter=0; letter<sp.alphabetSize();letter++) {
doubleRep total_prob=1.0;
for(int i=0; i < mynode->getNumberOfSons();++i){
doubleRep prob=0.0;
for(int letInSon=0; letInSon<sp.alphabetSize();letInSon++) {
assert(ssc.get(mynode->getSon(i)->id(),letInSon)>=0);
assert(sp.Pij_t(letter,letInSon,mynode->getSon(i)->dis2father()*gRate)>=0);
prob += ssc.get(mynode->getSon(i)->id(),letInSon)*
sp.Pij_t(letter,letInSon,mynode->getSon(i)->dis2father()*gRate);
}
assert(prob>=0);
total_prob*=prob;
}
if (total_prob ==0) ++letterWithTotalProbEqZero;
ssc.set(mynode->id(),letter,total_prob);
} // end of else
computeNodeFactorAndSetSsc(factors[mynode->id()],ssc,mynode->id(),sp.alphabetSize());
for(int k=0; k < mynode->getNumberOfSons();++k) {
factors[mynode->id()]+=factors[mynode->getSon(k)->id()];
}
if (letterWithTotalProbEqZero == sp.alphabetSize() && (mynode->getNumberOfSons() > 0)) {
LOG(5,<<" total prob =0");
for (int z=0; z <mynode->getNumberOfSons(); ++z) {
LOG(5,<<"son "<<z<<" is "<<mynode->getSon(z)->name()<<endl);
LOG(5,<<"dis2father is "<<mynode->getSon(z)->dis2father()<<endl);
for(int letInSon=0; letInSon<sp.alphabetSize();letInSon++) {
LOG(5,<<"let = "<<letInSon<<endl);
LOG(5,<<"ssc.get(mynode->sons[z]->id(),letInSon) = "<<convert(ssc.get(mynode->getSon(z)->id(),letInSon))<<endl);
// LOG(5,<<"sp.Pij_t(letter,letInSon,mynode->getSon(i)->dis2father()*gRate) = "<<sp.Pij_t(letter,letInSon,mynode->sons[i]->dis2father()*gRate)<<endl);
// LOG(5,<<"mynode->getSon(i)->dis2father() = "<<mynode->getSon(i)->dis2father()<<endl);
}
}
exit(3);
}
}
}