int main()
{
int numClients = 2;
// client settings
float minClientActionDelay = 0.2f; // min wait time for a client before starting new actions
float maxClientActionDelay = 0.4f; // max wait time for a client before it has to complete a new action
float clientQueryWeight = 30.0f; // possibility of a query to happen
float clientReplyWeight = 30.0f; // possibility of a reply to happen
float clientPostWeight = 40.0f; // possibility of a new post (update) to happen
// set the global MPI variabes
gRank = gWorld.rank();
gNumFE = numClients;
gNumRM = gWorld.size() - numClients;
// early out if there are not enough nodes for at least one RM
if(numClients + 1 > gWorld.size() && gWorld.rank() == 0) {
std::cout << "ERROR: there are not enough nodes for at least 1 RM, please increase the number of nodes" << std::endl;
exit(-1);
}
if (gWorld.rank() == 0) {
std::cout << " num RM: " << gNumRM << " num FE: " << gNumFE << std::endl;
}
Log::singleton().open("Bulletin_" + std::to_string(gRank) + ".log"); // set log file
Log::singleton().setVerbosity(LV_Normal);
//the last 'numClients' ranks are front ends
if (gWorld.rank() >= gWorld.size() - numClients) {
std::cout << "P" << gWorld.rank() << ": assigned as a client" << std::endl;
// create client instance
Client client;
// set client variables as defined above
client.setMinActionDelay(minClientActionDelay);
client.setMaxActionDelay(maxClientActionDelay);
client.setQueryWeight(clientQueryWeight);
client.setReplyWeight(clientReplyWeight);
client.setPostWeight(clientPostWeight);
// run the client
// the client will now call the Frontend classes specific functions
// whenever it wants to complete an action.
client.run();
}
else
{
std::cout << "P" << gWorld.rank() << ": assigned as a replicator" << std::endl;
ReplicaManager RM;
RM.run();
}
return 0;
}
void collect_data(mpi::communicator local, mpi::communicator world)
{
// The rank of the collector within the world communicator
int master_collector = world.size() - local.size();
if (world.rank() == master_collector) {
while (true) {
// Wait for a message
mpi::status msg = world.probe();
if (msg.tag() == msg_data_packet) {
// Receive the packet of data
std::vector<int> data;
world.recv(msg.source(), msg.tag(), data);
// Tell each of the collectors that we'll be broadcasting some data
for (int dest = 1; dest < local.size(); ++dest)
local.send(dest, msg_broadcast_data, msg.source());
// Broadcast the actual data.
broadcast(local, data, 0);
} else if (msg.tag() == msg_finished) {
// Receive the message
world.recv(msg.source(), msg.tag());
// Tell each of the collectors that we're finished
for (int dest = 1; dest < local.size(); ++dest)
local.send(dest, msg_finished);
break;
}
}
} else {
while (true) {
// Wait for a message from the master collector
mpi::status msg = local.probe();
if (msg.tag() == msg_broadcast_data) {
// Receive the broadcast message
int originator;
local.recv(msg.source(), msg.tag(), originator);
// Receive the data broadcasted from the master collector
std::vector<int> data;
broadcast(local, data, 0);
std::cout << "Collector #" << local.rank()
<< " is processing data from generator #" << originator
<< "." << std::endl;
} else if (msg.tag() == msg_finished) {
// Receive the message
local.recv(msg.source(), msg.tag());
break;
}
}
}
}
void TwoParticleGFContainer::computeAll_split(bool clearTerms, const boost::mpi::communicator & comm)
{
// split communicator
size_t ncomponents = NonTrivialElements.size();
size_t ncolors = std::min(int(comm.size()), int(NonTrivialElements.size()));
RealType color_size = 1.0*comm.size()/ncolors;
std::map<int,int> proc_colors;
std::map<int,int> elem_colors;
std::map<int,int> color_roots;
bool calc = false;
for (size_t p=0; p<comm.size(); p++) {
int color = int (1.0*p / color_size);
proc_colors[p] = color;
color_roots[color]=p;
}
for (size_t i=0; i<ncomponents; i++) {
int color = i*ncolors/ncomponents;
elem_colors[i] = color;
};
if (!comm.rank()) {
INFO("Splitting " << ncomponents << " components in " << ncolors << " communicators");
for (size_t i=0; i<ncomponents; i++)
INFO("2pgf " << i << " color: " << elem_colors[i] << " color_root: " << color_roots[elem_colors[i]]);
};
comm.barrier();
int comp = 0;
boost::mpi::communicator comm_split = comm.split(proc_colors[comm.rank()]);
for(std::map<IndexCombination4, boost::shared_ptr<TwoParticleGF> >::iterator iter = NonTrivialElements.begin(); iter != NonTrivialElements.end(); iter++, comp++) {
bool calc = (elem_colors[comp] == proc_colors[comm.rank()]);
if (calc) {
INFO("C" << elem_colors[comp] << "p" << comm.rank() << ": computing 2PGF for " << iter->first);
if (calc) static_cast<TwoParticleGF&>(*(iter->second)).compute(clearTerms, comm_split);
};
};
comm.barrier();
// distribute data
if (!comm.rank()) INFO_NONEWLINE("Distributing 2PGF container...");
comp = 0;
for(std::map<IndexCombination4, boost::shared_ptr<TwoParticleGF> >::iterator iter = NonTrivialElements.begin(); iter != NonTrivialElements.end(); iter++, comp++) {
int sender = color_roots[elem_colors[comp]];
TwoParticleGF& chi = *((iter)->second);
for (size_t p = 0; p<chi.parts.size(); p++) {
// if (comm.rank() == sender) INFO("P" << comm.rank() << " 2pgf " << p << " " << chi.parts[p]->NonResonantTerms.size());
boost::mpi::broadcast(comm, chi.parts[p]->NonResonantTerms, sender);
boost::mpi::broadcast(comm, chi.parts[p]->ResonantTerms, sender);
if (comm.rank() != sender) {
chi.setStatus(TwoParticleGF::Computed);
};
};
}
comm.barrier();
if (!comm.rank()) INFO("done.");
}
// Posle pozadavek o praci nahodne vybranemu procesu
void sendRequest() {
int pn = rand() % com.size();
srand(time(NULL));
// Pokud by se nahodne cislo trefilo na moje cislo, generuj nove
if (pn == com.rank()) {
pn = rand() % com.size();
}
//cout << "Sending WORK_REQUEST to " << pn << endl;
com.send(pn, WORK_REQUEST);
}
void DocumentDecoder::manageTranslators(
boost::mpi::communicator comm,
NistXmlCorpus &testset
) {
namespace mpi = boost::mpi;
mpi::request reqs[2];
int stopped = 0;
NumberedOutputDocument translation;
reqs[0] = comm.irecv(mpi::any_source, TAG_COLLECT, translation);
reqs[1] = comm.irecv(mpi::any_source, TAG_STOP_COLLECTING);
NistXmlCorpus::const_iterator it = testset.begin();
uint docno = 0;
for(int i = 0; i < comm.size() && it != testset.end(); ++i, ++docno, ++it) {
LOG(logger_, debug, "S: Sending document " << docno << " to translator " << i);
comm.send(i, TAG_TRANSLATE, std::make_pair(docno, *(*it)->asMMAXDocument()));
}
for(;;) {
std::pair<mpi::status, mpi::request *> wstat = mpi::wait_any(reqs, reqs + 2);
if(wstat.first.tag() == TAG_STOP_COLLECTING) {
stopped++;
LOG(logger_, debug, "C: Received STOP_COLLECTING from translator "
<< wstat.first.source() << ", now " << stopped << " stopped translators.");
if(stopped == comm.size()) {
reqs[0].cancel();
return;
}
*wstat.second = comm.irecv(mpi::any_source, TAG_STOP_COLLECTING);
} else {
LOG(logger_, debug, "C: Received translation of document " <<
translation.first << " from translator " << wstat.first.source());
reqs[0] = comm.irecv(mpi::any_source, TAG_COLLECT, translation);
if(it != testset.end()) {
LOG(logger_, debug, "S: Sending document " << docno <<
" to translator " << wstat.first.source());
comm.send(wstat.first.source(), TAG_TRANSLATE,
std::make_pair(docno, *(*it)->asMMAXDocument()));
++docno; ++it;
} else {
LOG(logger_, debug,
"S: Sending STOP_TRANSLATING to translator " << wstat.first.source());
comm.send(wstat.first.source(), TAG_STOP_TRANSLATING);
}
testset[translation.first]->setTranslation(translation.second);
}
}
}
void generate_data(mpi::communicator local, mpi::communicator world)
{
using std::srand;
using std::rand;
// The rank of the collector within the world communicator
int master_collector = local.size();
srand(time(0) + world.rank());
// Send out several blocks of random data to the collectors.
int num_data_blocks = rand() % 3 + 1;
for (int block = 0; block < num_data_blocks; ++block) {
// Generate some random data
int num_samples = rand() % 1000;
std::vector<int> data;
for (int i = 0; i < num_samples; ++i) {
data.push_back(rand());
}
// Send our data to the master collector process.
std::cout << "Generator #" << local.rank() << " sends some data..."
<< std::endl;
world.send(master_collector, msg_data_packet, data);
}
// Wait for all of the generators to complete
(local.barrier)();
// The first generator will send the message to the master collector
// indicating that we're done.
if (local.rank() == 0)
world.send(master_collector, msg_finished);
}
void
printit(const boost::mpi::communicator& comm,
const std::vector<T>& things,
const std::string& caption)
{
if (!caption.empty() && comm.rank() == 0) {
std::cout << caption << std::endl;
std::cout.flush();
}
for (int p = 0; p < comm.size(); ++p) {
if (comm.rank() == p) {
std::cout << p << ": ";
std::copy(things.begin(), things.end(),
std::ostream_iterator<T>(std::cout, ","));
std::cout << std::endl;
std::cout.flush();
}
comm.barrier();
}
comm.barrier();
size_t global_size;
boost::mpi::reduce(comm, things.size(), global_size, std::plus<size_t>(), 0);
if (comm.rank() == 0) {
if (!caption.empty()) {
std::cout << caption;
}
std::cout << "Number of things: " << global_size << std::endl;
}
comm.barrier();
std::cout << comm.rank() << ": leaving printit()" << std::endl;
}
void TwoParticleGF::compute(bool clear, const boost::mpi::communicator & comm)
{
if (Status < Prepared) throw (exStatusMismatch());
if (Status >= Computed) return;
if (!Vanishing) {
// Create a "skeleton" class with pointers to part that can call a compute method
pMPI::mpi_skel<ComputeAndClearWrap> skel;
bool fill_container = m_data_.NBosonic() > 0 && m_data_.NFermionic() > 0;
skel.parts.reserve(parts.size());
for (size_t i=0; i<parts.size(); i++) {
skel.parts.push_back(ComputeAndClearWrap(&m_data_, parts[i], clear, fill_container, 1));
};
std::map<pMPI::JobId, pMPI::WorkerId> job_map = skel.run(comm, true); // actual running - very costly
int rank = comm.rank();
int comm_size = comm.size();
// Start distributing data
//DEBUG(comm.rank() << getIndex(0) << getIndex(1) << getIndex(2) << getIndex(3) << " Start distributing data");
comm.barrier();
if (!clear) {
for (size_t p = 0; p<parts.size(); p++) {
boost::mpi::broadcast(comm, parts[p]->NonResonantTerms, job_map[p]);
boost::mpi::broadcast(comm, parts[p]->ResonantTerms, job_map[p]);
if (rank == job_map[p]) {
parts[p]->Status = TwoParticleGFPart::Computed;
};
};
comm.barrier();
}
};
Status = Computed;
}
void
all_gatherv_test(const mpi::communicator& comm, Generator generator,
std::string kind)
{
typedef typename Generator::result_type value_type;
using boost::mpi::all_gatherv;
std::vector<value_type> myvalues, expected, values;
std::vector<int> sizes;
for(int r = 0; r < comm.size(); ++r) {
value_type value = generator(r);
sizes.push_back(r+1);
for (int k=0; k < r+1; ++k) {
expected.push_back(value);
if(comm.rank() == r) {
myvalues.push_back(value);
}
}
}
if (comm.rank() == 0) {
std::cout << "Gathering " << kind << "...";
std::cout.flush();
}
mpi::all_gatherv(comm, myvalues, values, sizes);
BOOST_CHECK(values == expected);
if (comm.rank() == 0 && values == expected)
std::cout << "OK." << std::endl;
(comm.barrier)();
}
void
broadcast_test(const mpi::communicator& comm, const T& bc_value,
std::string const& kind)
{
for (int root = 0; root < comm.size(); ++root) {
broadcast_test(comm, bc_value, kind, root);
}
}
void init(const mpi::communicator& comm)
{
PetscErrorCode ierr;
PetscInt lo, hi;
ierr = VecCreate(comm,&x); // CHKERRQ(ierr);
ierr = VecSetSizes(x, PETSC_DECIDE, 5*comm.size()); // CHKERRQ(ierr);
ierr = VecSetFromOptions(x); // CHKERRQ(ierr);
ierr = VecGetOwnershipRange(x, &lo, &hi);
for (PetscInt i = lo; i <= hi; ++i) {
std::complex<double> v(i, 5*comm.size() - i - 1);
ierr = VecSetValue(x, i, v, INSERT_VALUES);
}
ierr = VecAssemblyBegin(x); // CHKERRQ(ierr);
ierr = VecAssemblyEnd(x); // CHKERRQ(ierr);
}
void runMaster(mpi::communicator world, int size, int grid_dimension)
{
// Start timer and go.
boost::chrono::system_clock::time_point start = boost::chrono::system_clock::now();
// Send
Matrix A(Size(size, size));
Matrix result(Size(size, size));
for(int row = 0; row < A.size.rows; ++row){
for(int col = 0; col < A.size.cols; ++col){
A.data[row][col] = (row % 11) + (col % 11);
}
}
//cout << A << endl;
//cout << "\nProduct:\n" << A*A << endl;
// Do sequential
if (grid_dimension == 0)
A.square(result);
// Else parallel
else{
// Split matrix up and send to slaves
int slave_id = 1;
int sub_matrix_sizes = size / grid_dimension;
for(int i = 0; i < size; i += sub_matrix_sizes){
for(int j = 0; j < size; j += sub_matrix_sizes){
MatrixCrossSection cs = getCrossSection( A, i, j, sub_matrix_sizes);
world.send(slave_id, 0, cs);
slave_id ++;
}
}
// Recieve
std::vector<Matrix> saved;
int num_slaves = world.size() -1;
for(int i = 1; i <= num_slaves; ++i){
Matrix r;
world.recv(i, 0, r);
result.insertSubMatrix(r);
}
}
// Done
boost::chrono::duration<double> sec = boost::chrono::system_clock::now() - start;
cout << sec.count() << endl;
// Print Result
//cout << "\nResult:\n" << result << endl;
//assert ( result == A*A);
}
// Poslani zpravy vsem ostatnim procesum
void broadcastMessage(int msgType) {
for (int i = 0; i < com.size(); i++) {
// Sobe nic neposilam
if (i == com.rank()) { continue; }
// Pokud jsem nasel vysledek, poslu ho
if (msgType == FOUND || msgType == FOUND_BEST) {
//cout << "Sending (BEST)FOUND to " << i << endl;
com.send(i, msgType, myLongest);
}
// Pri oznameni konce vypoctu neni treba posilat zadna data
else if (msgType == END) {
//cout << "Sending end to " << i << endl;
com.send(i, msgType);
}
}
}
void
random_scattered_vector(const boost::mpi::communicator& comm,
const int& global_size,
std::vector<I>& local_values)
{
int me(comm.rank());
int nproc(comm.size());
std::vector< std::vector<I> > toscatter(nproc);
if (me == 0) {
for (int i = 0; i < global_size; ++i) {
boost::random::uniform_int_distribution<> dist(0, nproc-1);
int p(dist(gen));
toscatter[p].push_back(i);
}
}
scatter(comm, toscatter, local_values, 0);
}
static void master(mpi::communicator world){
int ntasks, rank;
vector<int> data;
int work;
int result;
for(int i = 0; i< 10; i++){
data.push_back(i);
}
const int size_work = (int)data.size();
rank = world.rank(); //int rank(ID) of processor
ntasks = world.size();//int total number of processors
for (rank = 1; rank < ntasks; ++rank) {
get_next_work_item(work,size_work,data);
world.send(rank,WORKTAG,work);
}
int ret = get_next_work_item(work,size_work,data);
while (ret == 0){
mpi::status status = world.recv(mpi::any_source,mpi::any_tag,result);
world.send(status.source(),WORKTAG,work);
ret = get_next_work_item(work,size_work,data);
}
for (rank = 1; rank < ntasks; ++rank) {
world.recv( mpi::any_source, mpi::any_tag,result);
}
for (rank = 1; rank < ntasks; ++rank) {
world.send(rank,DIETAG,0);
}
}
void
all_gather_test(const mpi::communicator& comm, Generator generator,
std::string kind)
{
typedef typename Generator::result_type value_type;
value_type value = generator(comm.rank());
std::vector<value_type> values;
if (comm.rank() == 0) {
std::cout << "Gathering " << kind << "...";
std::cout.flush();
}
mpi::all_gather(comm, value, values);
std::vector<value_type> expected_values;
for (int p = 0; p < comm.size(); ++p)
expected_values.push_back(generator(p));
BOOST_CHECK(values == expected_values);
if (comm.rank() == 0 && values == expected_values)
std::cout << "OK." << std::endl;
(comm.barrier)();
}
pair<Species_tree *,string > sim_init_LL_mpi(string tree_file,string sim_file,int outgroup,
const mpi::communicator world)
{
//########################## GLOBAL #########################
string S_tree_string;
tree_type* S;
int server = 0;
int rank = world.rank();
int size = world.size();
scalar_type delta,tau,lambda,omega,delta_var,tau_var,lambda_var,omega_var,noise;
int N;
long seed;
vector < vector <scalar_type> > gather_sim_O_counts;
vector < vector <scalar_type> > gather_sim_D_counts;
vector < vector <scalar_type> > gather_sim_T_counts;
vector < vector <scalar_type> > gather_sim_L_counts;
vector < vector <scalar_type> > gather_sim_O_profile;
//########################## GLOBAL #########################
if (rank==server)
{
seed=good_seed();
cout << "#SEED:" << seed <<endl;
}
broadcast(world,seed,server);
RandomTools::setSeed(seed*rank+rank);
if (rank == server)
{
string sim_file_name=sim_file;
string tree_file_name=tree_file;
vector <string> forest,codes;
string line;
int i=0;
ifstream file_stream (sim_file_name.c_str());
scalar_type alpha=0.5;
scalar_type rho=0.5;
scalar_type height=0.5;
noise=0;
omega=0.5;
delta_var=0.;
tau_var=0.;
lambda_var=0.;
omega_var=0.;
N=20;
if (file_stream.is_open()) // ########## read sim params ############
{
while (! file_stream.eof() )
{
getline (file_stream,line);
if (line.find("#N")!=line.npos)
{
vector<string> tokens;
Tokenize(line,tokens," ");
N=atoi(tokens[1].c_str());
}
if (line.find("#noise")!=line.npos)
{
vector<string> tokens;
Tokenize(line,tokens," ");
noise=atof(tokens[1].c_str());
}
if (line.find("#ALPHA")!=line.npos)
{
vector<string> tokens;
Tokenize(line,tokens," ");
alpha=atof(tokens[1].c_str());
}
if (line.find("#RHO")!=line.npos)
{
vector<string> tokens;
Tokenize(line,tokens," ");
rho=atof(tokens[1].c_str());
}
if (line.find("#HEIGHT")!=line.npos)
{
vector<string> tokens;
Tokenize(line,tokens," ");
height=atof(tokens[1].c_str());
}
if (line.find("#OMEGA")!=line.npos)
{
vector<string> tokens;
Tokenize(line,tokens," ");
omega=atof(tokens[1].c_str());
}
if (line.find('#VAR')!=line.npos)
{
vector<string> tokens;
Tokenize(line,tokens," ");
delta_var=atof(tokens[1].c_str());
tau_var=atof(tokens[1].c_str());
lambda_var=atof(tokens[1].c_str());
}
if (line.find("#OMEGAVAR")!=line.npos)
{
vector<string> tokens;
Tokenize(line,tokens," ");
omega_var=atof(tokens[1].c_str());
}
}
file_stream.close();
}
delta=(1-alpha)*(rho)*height;
tau=(alpha)*(rho)*height;
lambda=(1-rho)*height;
if (rank==server) cout <<"D,T,L,O,N: "<< delta << " " << tau << " " << lambda << " " << omega << " " << N <<endl;
if (rank==server) cout <<"Dv,Tv,Lv,Ov,NOISE: "<< delta_var << " " << tau_var << " " << lambda_var << " " << omega_var<<" " << noise<<endl;
string S_string="";
file_stream.open(tree_file_name.c_str());
if (file_stream.is_open()) // ########## read an input S tree ############
{
while (! file_stream.eof() )
{
getline (file_stream,line);
if (line.find('(')!=line.npos && S_string=="")
{
vector<string> tokens;
Tokenize(line,tokens," ");
for (int i=0;i<tokens.size();i++)
if (tokens[i].find('(')!=tokens[i].npos)
S_string=tokens[i];
}
}
file_stream.close();
}
//########################## DISTRIBUTE ######################
S_tree_string=S_string;
}
//########################## DISTRIBUTE ######################
// SERVER CHECK POINT 1 - client trees sent -
broadcast(world, N, server);
broadcast(world, delta, server);
broadcast(world, tau, server);
broadcast(world, lambda, server);
broadcast(world, omega, server);
broadcast(world, delta_var, server);
broadcast(world, tau_var, server);
broadcast(world, lambda_var, server);
broadcast(world, omega_var, server);
broadcast(world, noise, server);
broadcast(world, S_tree_string, server);
//########################## infer_tree init #######################
S = TreeTemplateTools::parenthesisToTree(S_tree_string);
tree_type * So=S->clone();
Node * root=So->getRootNode();
double stem_len=0.1;
if (outgroup || true)// ########## add outgroup to root of S tree ############
{
Node * new_root = new Node();
Node * out_group = new Node();
root->addSon(new_root);
new_root->addSon(out_group);
out_group->setDistanceToFather(1.+stem_len);
out_group -> setName("OUT_GROUP");
So->rootAt(new_root);
Node * root=So->getRootNode();
root->getSon(0)->setDistanceToFather(stem_len);
root->getSon(1)->setDistanceToFather(stem_len);
}
Species_tree * infer_tree = new Species_tree(So);
infer_tree->init_x();
//cout << "rank " << rank << " " << delta << " " << tau << " " << lambda << endl;
infer_tree->init_sim(0.1, delta, tau, lambda, delta_var*delta, tau_var*tau, lambda_var*lambda,omega,omega*omega_var,0.);
stringstream out;
out<< rank << "trees.trees";
ofstream trees_file(out.str().c_str());
infer_tree->event_stream=&trees_file;
vector <string> client_trees;
vector <string> client_codes;
vector <string> client_stream;
if (rank!=server)
{
infer_tree->emit_G_trees(N,&client_trees,&client_codes,&client_stream);
for (int i=0;i<client_trees.size();i++)
{
if (noise>0)
{
scalar_type p0 = exp(-noise);
scalar_type p=1;
int k=-1;
bool stop=false;
while(!stop)
{
k++;
scalar_type u = RandomTools::giveRandomNumberBetweenZeroAndEntry(1);
p*=u;
if (p<=p0)
stop=true;
}
for (int nni=0;nni<k;nni++)
{
vector <string> allnnis=all_NNIs(client_trees[i]);
client_trees[i]=allnnis[RandomTools::giveIntRandomNumberBetweenZeroAndEntry(allnnis.size())];
}
}
}
infer_tree->unrooted_register(client_trees);
for (int i=0;i<client_trees.size();i++)
infer_tree->codes[client_trees[i]]=client_codes[i];
}
//########################## infer_tree init #######################
if (noise==0)
{
infer_tree->world=world;
infer_tree->branchwise=1;
infer_tree->count_labels(client_trees);
scalar_type pea_count = sum_counts(infer_tree,world);
for (int i = 0;i<infer_tree->N_slices+infer_tree->tree->getNumberOfLeaves();i++)
{
infer_tree->sim_O_count[i]=infer_tree->O_counts[i];
infer_tree->sim_D_count[i]=infer_tree->D_counts[i];
infer_tree->sim_T_count[i]=infer_tree->T_counts[i];
infer_tree->sim_L_count[i]=infer_tree->branch_zero[i];
infer_tree->sim_branch_sum[i]=infer_tree->branch_sum[i];
infer_tree->sim_branch_count[i]=infer_tree->branch_count[i];
infer_tree->sim_branch_genome_size[i]=infer_tree->branch_genome_size[i];
}
}
vector < vector <string> > gather_trees;
gather(infer_tree->world, infer_tree->in_trees, gather_trees, server);
if (rank==server)
{
vector <string> forest;
//GG
for (int j=1;j<size;j++)
for (vector<string>::iterator tit=gather_trees[j].begin();tit!=gather_trees[j].end();tit++)
forest.push_back((*tit));
infer_tree->panj_string= PANJ(S_tree_string,forest);
cout << "#PANJ "<< infer_tree->panj_string <<endl;
cout << "#PANJ "<< TreeTools::robinsonFouldsDistance(*TreeTemplateTools::parenthesisToTree(S_tree_string),*TreeTemplateTools::parenthesisToTree(infer_tree->panj_string)) << endl;
}
pair<Species_tree *,string > return_pair;
return_pair.first=infer_tree;
return_pair.second=S_tree_string;
return return_pair;
//########################## CLIENT #########################
}
scalar_type LL_mpi(Species_tree * infer_tree,string Sstring,string mode,bool outgroup,scalar_type delta,scalar_type tau, scalar_type lambda)
{
const mpi::communicator world = infer_tree->world;
int server = 0;
int rank = world.rank();
int size = world.size();
scalar_type ll;
scalar_type return_ll;
if (rank==server) cout << mode << " " << Sstring <<endl;
broadcast(world, Sstring,server);
tree_type * S=TreeTemplateTools::parenthesisToTree(Sstring);
if (outgroup)
{
Node * root=S->getRootNode();
vector <Node*> nodes=S->getNodes();
for (vector<Node * > :: iterator it=nodes.begin();it!=nodes.end();it++)
if ((*it)->hasFather())
if ((*it)->getDistanceToFather()==0)
(*it)->setDistanceToFather(0.001);
infer_tree->node_makeclocklike_height((S->getRootNode()));
S->scaleTree(1./TreeTemplateTools::getDistanceBetweenAnyTwoNodes(*root,*(S->getLeaves()[0])));
double stem_len=0.1;
Node * new_root = new Node();
Node * out_group = new Node();
root->addSon(new_root);
new_root->addSon(out_group);
out_group->setDistanceToFather(1.+stem_len);
out_group -> setName("OUT_GROUP");
S->rootAt(new_root);
root=S->getRootNode();
if (root->getSon(0)->isLeaf())
root->getSon(1)->setDistanceToFather(stem_len);
else
root->getSon(0)->setDistanceToFather(stem_len);
//root->getSon(1)->setDistanceToFather(stem_len);
infer_tree->reconstruct(S);
}
vector <string> modes;
Tokenize(mode,modes,"_");
if (modes[0]=="clock" )
{
infer_tree->intp=0;
infer_tree->w=0.;
infer_tree->reset();
infer_tree->branchwise=0;
string clock_string=Sstring;
if (rank==server) cout << modes[0] << " " << modes[1] <<endl;
clock_string=DTL_clock(clock_string,infer_tree,modes[1]);
//ll=LL_mpi(infer_tree, clock_string, "Hest",outgroup,delta,tau, lambda);
ll=infer_tree->tmp_ll;
infer_tree->tmp_ll=ll;
delete S;
if (rank==server) cout <<"$$ "<< clock_string <<endl;
infer_tree->tmp_Sstring=clock_string;
infer_tree->tmp_ll=ll;
return ll;
}
if (mode=="Nest" )
{
infer_tree->intp=0;
infer_tree->w=0.;
infer_tree->reset(delta,tau,lambda);
infer_tree->branchwise=0;
ll=oLL(infer_tree,S,delta,tau,lambda,1,"estimate");
//ll=oLL(infer_tree,S,delta,tau,lambda,1,"intbck");
infer_tree->omega_avg=infer_tree->branchwise_omega[0]+infer_tree->branchwise_omega[1]+infer_tree->branchwise_omega[2];
delete S;
infer_tree->tmp_ll=ll;
return ll;
}
if (mode=="noestimate" )
{
ll= oLL(infer_tree,S,delta,tau,lambda,1,"noestimate") ;
delete S;
return ll;
}
if (mode=="Pest" )
{
infer_tree->intp=0.9;
infer_tree->w=0.;
// !! no T
infer_tree->reset();
infer_tree->branchwise=0;
ll=oLL(infer_tree,S,delta,tau,lambda,1,"intbck");
scalar_type pea_count = sum_counts(infer_tree,world);
delete S;
infer_tree->tmp_ll=ll;
return ll;
}
if (mode=="Test" )
{
infer_tree->intp=0.9;
infer_tree->w=0.;
// !! no T
infer_tree->reset();
infer_tree->branchwise=0;
ll=oLL(infer_tree,S,delta,tau,lambda,1,"intbck");
scalar_type pea_count = sum_counts(infer_tree,world);
delete S;
scalar_type Tll=0;
for (int i = 0;i<infer_tree->N_slices+infer_tree->tree->getNumberOfLeaves()-1;i++)
Tll+=infer_tree->T_counts[i];
infer_tree->tmp_ll=-Tll;
return -Tll;
}
if (mode=="FASTest" )
{
infer_tree->intp=0.9;
infer_tree->w=0.;
// !! no T
infer_tree->reset();
infer_tree->branchwise=0;
ll=oLL(infer_tree,S,delta,tau,lambda,1,"intbck");
scalar_type pea_count = sum_counts(infer_tree,world);
infer_tree->apparent_rates(pea_count,true,true);
//if (rank==server) cout<<"#p "<< ll << " " << " "<< infer_tree->delta_avg << " " << infer_tree->tau_avg << " " << infer_tree->lambda_avg<< " " << infer_tree->omega_avg << endl ;
ll=oLL(infer_tree,S,delta,tau,lambda,1,"estimate");
infer_tree->tmp_ll=ll;
infer_tree->omega_avg=infer_tree->branchwise_omega[0]+infer_tree->branchwise_omega[1]+infer_tree->branchwise_omega[2];
delete S;
return ll;
}
if (mode=="Hest" || mode=="IHest")
{
if (mode=="Hest")
infer_tree->nclasses=5;
// !! no T
//tau=1e-30;
//infer_tree->reset(0.01,1e-30,0.01);
infer_tree->reset();
infer_tree->intp=0.9;
infer_tree->w=0.;
infer_tree->branchwise=0;
ll=oLL(infer_tree,S,delta,tau,lambda,1,"intbck");
infer_tree->tmp_ll=ll;
scalar_type pea_count = sum_counts(infer_tree,world);
if (rank==server) cout<<"#p "<< ll << " " << " "<< infer_tree->delta_avg << " " << infer_tree->tau_avg << " " << infer_tree->lambda_avg<< " " << infer_tree->omega_avg <<" "<<pea_count << endl ;
infer_tree->apparent_rates(pea_count,mode=="Hest",true);
//if (rank==server) infer_tree->print_rates();
// ### sum events
scalar_type ll2=ll-2;
while (ll>ll2 && abs(ll-ll2)>1 )
{
ll2=ll;
// given rates estimate p_omega
ll=oLL(infer_tree,S,delta,tau,lambda,1,"estimate");
infer_tree->tmp_ll=ll;
if (ll2>ll)
{
infer_tree->recall_rates();
//scalar_type re_ll=oLL(infer_tree,S,delta,tau,lambda,1,"noestimate") ;
ll=ll2;
break;
}
infer_tree->omega_avg=infer_tree->branchwise_omega[0]+infer_tree->branchwise_omega[1]+infer_tree->branchwise_omega[2];
// given p_omega estimate rates
// formal position of remember
oLL(infer_tree,S,delta,tau,lambda,1,"intbck");
scalar_type pea_count = sum_counts(infer_tree,world);
infer_tree->apparent_rates(pea_count,mode=="Hest",true);
if (rank==server) cout<<"#e "<< ll << " " << " "<< infer_tree->delta_avg << " " << infer_tree->tau_avg << " " << infer_tree->lambda_avg<< " " << infer_tree->omega_avg << endl ;
// ### sum events
}
return_ll=ll;
infer_tree->tmp_ll=ll;
delete S;
return return_ll;
}
}
pair<Species_tree *,string > init_LL_mpi(string tree_file,string forest_file,int outgroup,
const mpi::communicator world)
{
//########################## GLOBAL #########################
tree_type * S;
string S_tree_string;
string panj_string;
int server = 0;
int rank = world.rank();
int size = world.size();
vector <string> client_trees;
vector <string> client_codes;
vector < vector <string> > scatter_trees;
vector < vector <string> > scatter_codes;
//########################## GLOBAL #########################
if (rank == server)
{
//########################## SERVER #########################
string forest_file_name=forest_file;
string tree_file_name=tree_file;
vector <string> forest,codes;
string line;
int i=0;
ifstream file_stream (forest_file_name.c_str());
if (file_stream.is_open()) // ########## read a forest ############
{
while (! file_stream.eof() )
{
getline (file_stream,line);
if (line.find('(')!=line.npos)
{
i++;
forest.push_back(line);
}
else if (line.find('#')!=line.npos)
codes.push_back(line);
}
file_stream.close();
}
string S_string="";
file_stream.open(tree_file_name.c_str());
if (file_stream.is_open()) // ########## read an input S tree ############
{
while (! file_stream.eof() )
{
getline (file_stream,line);
if (line.find('(')!=line.npos && S_string=="")
{
vector<string> tokens;
Tokenize(line,tokens," ");
for (int i=0;i<tokens.size();i++)
if (tokens[i].find('(')!=tokens[i].npos)
S_string=tokens[i];
}
}
file_stream.close();
}
//########################## DISTRIBUTE ######################
/// SAMPLE
vector <int> lottery;
for (int i=0;i<forest.size();i++)
lottery.push_back(i);
vector <int> winners;
winners.resize(forest.size()/10.);
RandomTools::getSample(lottery,winners);
vector<string> sample_forest;
vector<string> sample_codes;
for (int i=0;i<winners.size();i++)
{
int j=winners[i];
sample_forest.push_back(forest[j]);
sample_codes.push_back(codes[j]);
}
forest.clear();
codes.clear();
for (int i=0;i<winners.size();i++)
{
forest.push_back(sample_forest[i]);
codes.push_back(sample_codes[i]);
}
/// SAMPLE
S_tree_string=S_string;
panj_string= PANJ(S_string,forest);
cout << "#PANJ "<<panj_string <<endl;
cout << "#PANJ "<< TreeTools::robinsonFouldsDistance(*TreeTemplateTools::parenthesisToTree(S_string),*TreeTemplateTools::parenthesisToTree(panj_string)) << endl;
map <scalar_type,string> sort_trees;
map <scalar_type,string> sort_codes;
for (int i=0;i<forest.size();i++)
{
tree_type * S=TreeTemplateTools::parenthesisToTree(forest[i]);
scalar_type treesize=S->getNumberOfLeaves();
while ( sort_trees.count(treesize) )
treesize+=RandomTools::giveRandomNumberBetweenZeroAndEntry(1e-2);
sort_trees[treesize]=forest[i];
sort_codes[treesize]=codes[i];
delete S;
}
int new_i=0;
for ( map <scalar_type,string> ::iterator it=sort_trees.begin();it!=sort_trees.end();it++)
{
forest[new_i]=it->second;
codes[new_i]=sort_codes[it->first];
new_i+=1;
}
map <int,int> large_trees;
for (int i=0;i<forest.size();i++)
{
tree_type * S=TreeTemplateTools::parenthesisToTree(forest[i]);
if (S->getNumberOfLeaves()>150)
{
large_trees[i]=S->getNumberOfLeaves();
}
//large_trees[S->getNumberOfLeaves()]++;
delete S;
}
//int cum=0;
//for ( map <int,int> ::iterator it=large_trees.begin();it!=large_trees.end();it++)
// {
// cum+=(*it).second;
// cout << (*it).first << " " << (*it).second << " " << cum << endl;
// }
map <int,int> scatter_sizes;
for (int j=0;j<size;j++)
{
vector <string> tmp;
scatter_trees.push_back(tmp);
vector <string> tmp2;
scatter_codes.push_back(tmp2);
}
//cout << "distribute" <<endl;
for (int i=0;i<forest.size();i++)
{
int j = i%(size-1);
if (large_trees.count(i)==0)
{
scatter_trees[j+1].push_back(forest[i]);
scatter_codes[j+1].push_back(codes[i]);
tree_type * S=TreeTemplateTools::parenthesisToTree(forest[i]);
scatter_sizes[j]+=S->getNumberOfLeaves();
delete S;
}
}
for ( map <int,int> ::iterator it=scatter_sizes.begin();it!=scatter_sizes.end();it++)
cout << it->first << " " << it->second << endl;
//cout << "distribute" <<endl;
//.optimization could come here
//########################## DISTRIBUTE ######################
// SERVER CHECK POINT 1 - client trees sent -
broadcast(world, S_tree_string, server);
broadcast(world, panj_string, server);
scatter(world, scatter_trees, client_trees, server);
scatter(world, scatter_codes, client_codes, server);
//########################## count_tree init #######################
S = TreeTemplateTools::parenthesisToTree(S_tree_string);
tree_type * So=S->clone();
Node * root=So->getRootNode();
double stem_len=0.1;
//!!
if (outgroup || true)// ########## add outgroup to root of S tree ############
{
Node * new_root = new Node();
Node * out_group = new Node();
root->addSon(new_root);
new_root->addSon(out_group);
out_group->setDistanceToFather(1.+stem_len);
out_group -> setName("OUT_GROUP");
So->rootAt(new_root);
Node * root=So->getRootNode();
if (root->getSon(0)->isLeaf())
root->getSon(1)->setDistanceToFather(stem_len);
else
root->getSon(0)->setDistanceToFather(stem_len);
}
Species_tree * count_tree = new Species_tree(So);
count_tree->panj_string=panj_string;
count_tree->init_x();
//########################## count_tree init #######################
// SERVER CHECK POINT 1 - client trees sent -
count_tree->world=world;
pair<Species_tree *,string > return_pair;
return_pair.first=count_tree;
return_pair.second=S_tree_string;
return return_pair;
//########################## SERVER #########################
}
else
{
//########################## CLIENT #########################
// CLIENT CHECK POINT 1 - client trees recived -
broadcast(world, S_tree_string, server);
broadcast(world, panj_string, server);
scatter(world, scatter_trees, client_trees, server);
scatter(world, scatter_codes, client_codes, server);
//########################## infer_tree init #######################
S = TreeTemplateTools::parenthesisToTree(S_tree_string);
tree_type * So=S->clone();
Node * root=So->getRootNode();
double stem_len=0.1;
if (outgroup || true)// ########## add outgroup to root of S tree ############
{
Node * new_root = new Node();
Node * out_group = new Node();
root->addSon(new_root);
new_root->addSon(out_group);
out_group->setDistanceToFather(1.+stem_len);
out_group -> setName("OUT_GROUP");
So->rootAt(new_root);
Node * root=So->getRootNode();
root->getSon(0)->setDistanceToFather(stem_len);
root->getSon(1)->setDistanceToFather(stem_len);
}
Species_tree * infer_tree = new Species_tree(So);
infer_tree->panj_string=panj_string;
infer_tree->init_x();
infer_tree->unrooted_register(client_trees);
for (int i=0;i<client_trees.size();i++)
infer_tree->codes[client_trees[i]]=client_codes[i];
//########################## infer_tree init #######################
// CLIENT CHECK POINT 1 - client trees recived -
infer_tree->world=world;
pair<Species_tree *,string > return_pair;
return_pair.first=infer_tree;
return_pair.second=S_tree_string;
return return_pair;
//########################## CLIENT #########################
}
}
MCCResults mccrun_master(
const Options& opts, const Eigen::VectorXd& vpar, unsigned int num_bins,
const set<observables_t>& obs, const mpi::communicator& mpicomm )
{
cout << "========== NEW MONTE CARLO CYCLE ==========" << endl;
cout << ":: Preparing the simulation" << endl;
HubbardModelVMC model = prepare_model( opts, vpar, mpicomm );
vector< unique_ptr<Observable> > obscalc = prepare_obscalcs( obs, opts );
ObservableCache obscache;
unsigned int finished_workers = 0;
unsigned int scheduled_bins = 0;
unsigned int completed_bins = 0;
unsigned int enqueued_bins = num_bins;
// define procedure to query the slaves for new work requests
function<void()> mpiquery_work_requests( [&]() {
while ( boost::optional<mpi::status> status
= mpicomm.iprobe( mpi::any_source, MSGTAG_S_M_REQUEST_BINS ) ) {
// receive the request and hand out new bins to the source
mpicomm.recv( status->source(), MSGTAG_S_M_REQUEST_BINS );
if ( enqueued_bins > 0 ) {
mpicomm.send( status->source(), MSGTAG_M_S_DISPATCHED_BINS, 1 );
scheduled_bins += 1;
enqueued_bins -= 1;
} else {
mpicomm.send( status->source(), MSGTAG_M_S_DISPATCHED_BINS, 0 );
++finished_workers;
}
}
} );
// define procedure to query the slaves for finished work
function<void()> mpiquery_finished_work( [&]() {
while ( boost::optional<mpi::status> status
= mpicomm.iprobe( mpi::any_source, 2 ) ) {
mpicomm.recv( status->source(), 2 );
--scheduled_bins;
++completed_bins;
}
} );
cout << ":: Equilibrating the system" << endl;
for (
unsigned int mcs = 0;
mcs < opts["calc.num-mcs-equil"].as<unsigned int>();
++mcs ) {
// take care of the slaves
mpiquery_finished_work();
mpiquery_work_requests();
// perform a Monte Carlo step
model.mcs();
}
unsigned int completed_bins_master = 0;
cout << ":: Performing Monte Carlo cycle" << endl;
cout << endl;
cout << " Progress:" << endl;
while ( enqueued_bins > 0 ) {
cout << '\r' << " Bin "
<< completed_bins << "/" << num_bins;
cout.flush();
--enqueued_bins;
++scheduled_bins;
for (
unsigned int mcs = 0;
mcs < opts["calc.num-binmcs"].as<unsigned int>();
++mcs ) {
// take care of the slaves
mpiquery_finished_work();
mpiquery_work_requests();
// perform a Monte Carlo step
model.mcs();
// measure observables
for ( const unique_ptr<Observable>& o : obscalc ) {
o->measure( model, obscache );
}
obscache.clear();
}
// tell the observables that a bin has been completed
for ( const unique_ptr<Observable>& o : obscalc ) {
o->completebin();
}
--scheduled_bins;
++completed_bins_master;
++completed_bins;
}
++finished_workers;
while ( completed_bins != num_bins ||
static_cast<int>( finished_workers ) < mpicomm.size() ) {
if ( boost::optional<mpi::status> status
= mpicomm.iprobe( mpi::any_source, MSGTAG_S_M_FINISHED_BINS ) ) {
mpicomm.recv( status->source(), MSGTAG_S_M_FINISHED_BINS );
--scheduled_bins;
++completed_bins;
cout << '\r' << " Bin " << completed_bins << "/" << num_bins;
cout.flush();
}
if ( boost::optional<mpi::status> status
= mpicomm.iprobe( mpi::any_source, MSGTAG_S_M_REQUEST_BINS ) ) {
// receive the request for more work
mpicomm.recv( status->source(), MSGTAG_S_M_REQUEST_BINS );
// tell him there is no more work
mpicomm.send( status->source(), MSGTAG_M_S_DISPATCHED_BINS, 0 );
++finished_workers;
}
}
assert( enqueued_bins == 0 );
assert( scheduled_bins == 0 );
cout << '\r' << " Bin " << completed_bins << "/" << num_bins << endl;
cout.flush();
// check for floating point precision problems
cout << endl;
cout << " Floating point precision control" << endl;
vector<FPDevStat> W_devstats;
assert( mpicomm.rank() == 0 );
mpi::gather( mpicomm, model.get_W_devstat(), W_devstats, 0 );
FPDevStat W_devstat_combined =
accumulate(
W_devstats.begin(), W_devstats.end(),
FPDevStat( opts["fpctrl.W-deviation-target"].as<double>() )
);
cout << " W: " << W_devstat_combined.recalcs
<< "/" << W_devstat_combined.misses
<< "/" << W_devstat_combined.mag1_misses << endl;
vector<FPDevStat> T_devstats;
assert( mpicomm.rank() == 0 );
mpi::gather( mpicomm, model.get_T_devstat(), T_devstats, 0 );
FPDevStat T_devstat_combined =
accumulate(
T_devstats.begin(), T_devstats.end(),
FPDevStat( opts["fpctrl.T-deviation-target"].as<double>() )
);
cout << " T: " << T_devstat_combined.recalcs
<< "/" << T_devstat_combined.misses
<< "/" << T_devstat_combined.mag1_misses << endl;
if ( W_devstat_combined.mag1_misses > 0 ||
T_devstat_combined.mag1_misses > 0 ) {
cout << " Precision targets missed by more than an order of magnitude!" << endl
<< " WARNING: Your results might be unreliable!!!" << endl << endl;
} else if ( W_devstat_combined.misses > 0 ||
T_devstat_combined.misses > 0 ) {
cout << " Some precision targets were missed, but your results should be fine."
<< endl << endl;
} else {
cout << " No missed precision targets." << endl << endl;
}
// collect results from the slaves and return results the scheduler
MCCResults results;
for ( const unique_ptr<Observable>& o : obscalc ) {
o->collect_and_write_results( mpicomm, results );
}
results.success = true;
return results;
}
string clock_root(Species_tree * infer_tree,string Sstring,string mode)
{
const mpi::communicator world = infer_tree->world;
int server = 0;
int mpi_rank = world.rank();
int size = world.size();
broadcast(world, Sstring,server);
tree_type * S=TreeTemplateTools::parenthesisToTree(Sstring);
map < Node*,int > do_01;
map < Node*,int > do_12;
map < Node*,int > do_02;
map < pair <Node*,Node*>,int > dnodes;
vector< pair <Node*,Node*> > seen;
map < pair <node_type*,node_type*>, pair <node_type*,node_type*> > root_dnodes;
map < pair <Node*,Node*>,int > roots;
S->unroot();
vector <Node *> S_leaves=S->getLeaves();
vector<Node*>::iterator it,jt;
vector <pair <Node*,Node*> > roots_vec;
for (it = S_leaves.begin(); it!=S_leaves.end(); it++ )
{
Node * node = (*it);
Node * head = node->getFather();
if (S_leaves.size()==2)
if (S_leaves[0]==(*it))
head=S_leaves[1];
else
head=S_leaves[0];
pair <Node*,Node*> tmp_pair(node,head);
if (node->getId()>head->getId())
{tmp_pair.first=head;tmp_pair.second=node;}
roots[tmp_pair]++;
if (roots[tmp_pair]==2)
{
Node* a_root=new Node();
//a_root->setName(tmp_pair.first->getName() + " -0- " + tmp_pair.second->getName());
pair <Node*,Node*> root_dnode(a_root,a_root);
pair <Node*,Node*> left_pair(tmp_pair.first,tmp_pair.second);
pair <Node*,Node*> right_pair(tmp_pair.second,tmp_pair.first);
root_dnodes[root_dnode]=tmp_pair;
roots_vec.push_back(root_dnode);
}
vector <Node*> neigbours = head->getSons();
if (head->hasFather())
neigbours.push_back(head->getFather());
int node_id;
if (node==neigbours[0])
{
node_id=0;
do_01[head]++;
do_02[head]++;
}
else if (node==neigbours[1])
{
node_id=1;
do_01[head]++;
do_12[head]++;
}
else if (node==neigbours[2])
{
node_id=2;
do_12[head]++;
do_02[head]++;
}
pair <Node*,Node*> left_pair(node,head);
pair <Node*,Node*> right_pair(node,head);
if ((node_id==0 || node_id==1) && do_01[head]==2)
{
pair <Node*,Node*> head_pair(head,neigbours[2]);
if (node_id==0)
right_pair.first=neigbours[1];
else
right_pair.first=neigbours[0];
}
if ((node_id==1 || node_id==2) && do_12[head]==2)
{
pair <Node*,Node*> head_pair(head,neigbours[0]);
if (node_id==1)
right_pair.first=neigbours[2];
else
right_pair.first=neigbours[1];
}
if ((node_id==0 || node_id==2) && do_02[head]==2)
{
pair <Node*,Node*> head_pair(head,neigbours[1]);
if (node_id==0)
right_pair.first=neigbours[2];
else
right_pair.first=neigbours[0];
}
for (jt=neigbours.begin();jt!=neigbours.end();jt++)
if (node!=(*jt))
{
pair <Node*,Node*> dnode (head,(*jt));
dnodes[dnode]++;
}
neigbours.clear();
}
while(1)
{
for (map < pair <Node*,Node*>,int >::iterator dit=dnodes.begin(); dit!=dnodes.end(); dit++)
if ((*dit).second==2)
{
Node * node = (*dit).first.first;
Node * head = (*dit).first.second;
pair <Node*,Node*> tmp_pair(node,head);
if (node->getId()>head->getId())
{tmp_pair.first=head;tmp_pair.second=node;}
roots[tmp_pair]++;
if (roots[tmp_pair]==2)
{
Node* a_root=new Node();
//a_root->setName(tmp_pair.first->getName() + " -0- " + tmp_pair.second->getName());
pair <Node*,Node*> root_dnode(a_root,a_root);
pair <Node*,Node*> left_pair(tmp_pair.first,tmp_pair.second);
pair <Node*,Node*> right_pair(tmp_pair.second,tmp_pair.first);
root_dnodes[root_dnode]=tmp_pair;
roots_vec.push_back(root_dnode);
}
vector <Node*> neigbours = head->getSons();
if (head->hasFather())
neigbours.push_back(head->getFather());
int node_id;
if (node==neigbours[0])
{
node_id=0;
do_01[head]++;
do_02[head]++;
}
else if (node==neigbours[1])
{
node_id=1;
do_01[head]++;
do_12[head]++;
}
else if (node==neigbours[2])
{
node_id=2;
do_12[head]++;
do_02[head]++;
}
pair <Node*,Node*> left_pair(node,head);
pair <Node*,Node*> right_pair(node,head);
if ((node_id==0 || node_id==1) && do_01[head]==2)
{
pair <Node*,Node*> head_pair(head,neigbours[2]);
if (node_id==0)
right_pair.first=neigbours[1];
else
right_pair.first=neigbours[0];
}
if ((node_id==1 || node_id==2) && do_12[head]==2)
{
pair <Node*,Node*> head_pair(head,neigbours[0]);
if (node_id==1)
right_pair.first=neigbours[2];
else
right_pair.first=neigbours[1];
}
if ((node_id==0 || node_id==2) && do_02[head]==2)
{
pair <Node*,Node*> head_pair(head,neigbours[1]);
if (node_id==0)
right_pair.first=neigbours[2];
else
right_pair.first=neigbours[0];
}
for (jt=neigbours.begin();jt!=neigbours.end();jt++)
if (node!=(*jt))
{
pair <Node*,Node*> dnode (head,(*jt));
dnodes[dnode]++;
}
seen.push_back((*dit).first);
}
if (seen.size()==0)
break;
for (vector< pair <Node*,Node*> >::iterator sit=seen.begin();sit!=seen.end();sit++)
dnodes.erase((*sit));
seen.clear();
}
int root_i=0;
string max_S;
scalar_type max_ll=-1e30;
for (map < pair <node_type*,node_type*>, pair <node_type*,node_type*> >::iterator rt=root_dnodes.begin();rt!=root_dnodes.end();rt++)
{
root_i+=1;
Node* head=(*rt).second.first;
Node* node=(*rt).second.second;
vector <Node*> head_neigbours = head->getSons();
if (head->hasFather())
head_neigbours.push_back(head->getFather());
vector <Node*> node_neigbours = node->getSons();
if (head->hasFather())
node_neigbours.push_back(node->getFather());
int node_id=-1;
if (node==head_neigbours[0])
node_id=0;
else if (node==head_neigbours[1])
node_id=1;
else if (node==head_neigbours[2])
node_id=2;
int did;
Node * new_root = new Node();
new_root->setName("R");
if (( node_id==2 && head->hasFather() ) || head->isLeaf())
{
did=1;
node->removeSon(head);
node->addSon(new_root);
new_root->addSon(head);
new_root->setDistanceToFather(1);
head->setDistanceToFather(1);
}
else
{
did=0;
head->removeSon(node);
head->addSon(new_root);
new_root->addSon(node);
new_root->setDistanceToFather(1);
node->setDistanceToFather(1);
}
S->rootAt(new_root);
//stringstream out;
//out << root_i;
//string fname=forest_file_name+".root"+out.str();
//tree_stream.open(fname.c_str());
vector <node_type*> tmp=S->getNodes();
for (vector <node_type*>::iterator it=tmp.begin();it!=tmp.end();it++)
if ((*it)->hasFather())
{
scalar_type d=(*it)->getDistanceToFather();
(*it)->setDistanceToFather(1);
}
string clock_S =DTL_clock(TreeTemplateTools::treeToParenthesis(*S),infer_tree);
scalar_type ll=LL_mpi(infer_tree,clock_S,mode);
if (max_ll<ll)
{
max_S=clock_S;
max_ll=ll;
}
//tree_stream<<TreeTemplateTools::treeToParenthesis(*S);
//tree_stream.close();
}
return max_S;
}
scalar_type sum_counts(Species_tree * infer_tree,const mpi::communicator world)
{
//########################## GLOBAL #########################
int server = 0;
int rank = world.rank();
int size = world.size();
scalar_type client_ll,broadcast_ll;
vector<scalar_type> gather_ll;
scalar_type client_pea_count;
scalar_type broadcast_pea_count;
vector<scalar_type> gather_pea_count;
scatter_scalar gather_O_counts;
scatter_scalar gather_D_counts;
scatter_scalar gather_T_counts;
scatter_scalar gather_L_counts;
scatter_scalar gather_B_counts;
scatter_scalar gather_S_counts;
scatter_scalar gather_F_counts;
scatter_scalar gather_G_counts;
//vector< vector< vector<scalar_type> > > gather_Ttf;
vector<scalar_type> broadcast_O_counts;
vector<scalar_type> broadcast_D_counts;
vector<scalar_type> broadcast_T_counts;
vector<scalar_type> broadcast_branch_zero;
vector<scalar_type> broadcast_branch_count;
vector<scalar_type> broadcast_branch_sum;
vector<scalar_type> broadcast_from_count;
vector<scalar_type> broadcast_genome_size;
int start=1;
//########################## GLOBAL #########################
//########################## SERVER #########################
//########################## SERVER #########################
if (rank != server)
{
//########################## CLIENT #########################
client_pea_count=infer_tree->tmp_pea_sum;
client_ll=infer_tree->tmp_ll;
//########################## CLIENT #########################
}
//########################## COMMON #########################
gather(world, infer_tree->O_counts, gather_O_counts, server);
gather(world, infer_tree->D_counts, gather_D_counts, server);
gather(world, infer_tree->T_counts, gather_T_counts, server);
gather(world, infer_tree->branch_zero, gather_L_counts, server);
gather(world, infer_tree->branch_count, gather_B_counts, server);
gather(world, infer_tree->branch_sum, gather_S_counts, server);
gather(world, infer_tree->from_count, gather_F_counts, server);
gather(world, infer_tree->branch_genome_size, gather_G_counts, server);
//TTF
// gather(world, infer_tree->Ttf, gather_Ttf, server);
gather(world, client_pea_count, gather_pea_count, server);
gather(world, client_ll, gather_ll, server);
//########################## COMMON #########################
if (rank == server)
{
//########################## SERVER #########################
for (int i = 0;i<infer_tree->N_slices+infer_tree->tree->getNumberOfLeaves()-1;i++)
{
broadcast_O_counts.push_back(0);
broadcast_D_counts.push_back(0);
broadcast_T_counts.push_back(0);
broadcast_branch_zero.push_back(0);
broadcast_branch_count.push_back(0);
broadcast_branch_sum.push_back(0);
broadcast_from_count.push_back(0);
broadcast_genome_size.push_back(0);
}
scalar_type tmp_O=0;
scalar_type tmp_D=0;
scalar_type tmp_T=0;
scalar_type tmp_z=0;
scalar_type tmp_c=0;
scalar_type tmp_s=0;
scalar_type tmp_f=0;
//cout << " start summing - sum " <<endl;
//for (int i = 0;i<infer_tree->N_slices+infer_tree->tree->getNumberOfLeaves()-1;i++)
// for (int k = 0;k<infer_tree->N_slices+infer_tree->tree->getNumberOfLeaves()-1;k++)
// infer_tree->Ttf[i][k]=0;
for (int j=1;j<size;j++)
{
for (int i = 0;i<infer_tree->N_slices+infer_tree->tree->getNumberOfLeaves()-1;i++)
{
//for (int k = 0;k<infer_tree->N_slices+infer_tree->tree->getNumberOfLeaves()-1;k++)
// infer_tree->Ttf[i][k]+=gather_Ttf[j][i][k];
broadcast_O_counts[i]+=gather_O_counts[j][i];
broadcast_D_counts[i]+=gather_D_counts[j][i];
broadcast_T_counts[i]+=gather_T_counts[j][i];
broadcast_branch_zero[i]+=gather_L_counts[j][i];
broadcast_branch_count[i]+=gather_B_counts[j][i];
broadcast_branch_sum[i]+=gather_S_counts[j][i];
broadcast_from_count[i]+=gather_F_counts[j][i];
broadcast_genome_size[i]+=gather_G_counts[j][i];
tmp_O+=gather_O_counts[j][i];
tmp_D+=gather_D_counts[j][i];
tmp_T+=gather_T_counts[j][i];
tmp_z+=gather_L_counts[j][i];
tmp_c+=gather_B_counts[j][i];
tmp_s+=gather_S_counts[j][i];
tmp_f+=gather_F_counts[j][i];
}
}
/*
for (int i = 0;i<infer_tree->N_slices+infer_tree->tree->getNumberOfLeaves()-1;i++)
{
cout << "tag "<<i;
cout << " " << broadcast_O_counts[i];
cout << " " << broadcast_D_counts[i];
cout << " " << broadcast_T_counts[i];
cout << " " << broadcast_branch_zero[i];
cout << " " << broadcast_branch_sum[i];
cout << " " << broadcast_branch_count[i];
cout << " " << broadcast_from_count[i];
cout << endl;
}
*/
//if (rank==server) cout << rank << " : "<<tmp_O << " " << tmp_D << " " << tmp_T << " " << tmp_z << " " << tmp_c << " " << tmp_s << " " << tmp_f << endl;
broadcast_pea_count=0.;
broadcast_ll=0.;
//cout << " start summing - llsum " << endl;
for (int j=1;j<size;j++)
{
broadcast_pea_count+=gather_pea_count[j];
broadcast_ll+=gather_ll[j];
}
// ### sum events
//########################## SERVER #########################
//cout << " end summing" << endl;
}
//########################## CLIENT #########################
//########################## CLIENT #########################
//########################## COMMON #########################
broadcast(world, broadcast_O_counts,server);
broadcast(world, broadcast_D_counts,server);
broadcast(world, broadcast_T_counts,server);
broadcast(world, broadcast_branch_zero,server);
broadcast(world, broadcast_branch_count,server);
broadcast(world, broadcast_branch_sum,server);
broadcast(world, broadcast_from_count,server);
broadcast(world, broadcast_genome_size,server);
broadcast(world, broadcast_pea_count,server);
broadcast(world, broadcast_ll,server);
//########################## COMMON #########################
//########################## SEVER #########################
//########################## CLIENT #########################
// if (rank==server)
// {
for (int i = 0;i<infer_tree->N_slices+infer_tree->tree->getNumberOfLeaves()-1;i++)
{
infer_tree->O_counts[i]=broadcast_O_counts[i];
infer_tree->D_counts[i]=broadcast_D_counts[i];
infer_tree->T_counts[i]=broadcast_T_counts[i];
infer_tree->branch_zero[i]=broadcast_branch_zero[i];
infer_tree->branch_count[i]=broadcast_branch_count[i];
infer_tree->branch_sum[i]=broadcast_branch_sum[i];
infer_tree->from_count[i]=broadcast_from_count[i];
infer_tree->branch_genome_size[i]=broadcast_genome_size[i];
}
//infer_tree->remember_rates();
// }
//infer_tree->apparent_rates(broadcast_pea_count,true,true);
//########################## CLIENT #########################
//########################## SERVER #########################
gather_ll.clear();
gather_pea_count.clear();
for (scatter_scalar::iterator it=gather_O_counts.begin();it!=gather_O_counts.end();it++) (*it).clear();
gather_O_counts.clear();
for (scatter_scalar::iterator it=gather_D_counts.begin();it!=gather_D_counts.end();it++) (*it).clear();
gather_D_counts.clear();
for (scatter_scalar::iterator it=gather_T_counts.begin();it!=gather_T_counts.end();it++) (*it).clear();
gather_T_counts.clear();
for (scatter_scalar::iterator it=gather_L_counts.begin();it!=gather_L_counts.end();it++) (*it).clear();
gather_L_counts.clear();
for (scatter_scalar::iterator it=gather_B_counts.begin();it!=gather_B_counts.end();it++) (*it).clear();
gather_B_counts.clear();
for (scatter_scalar::iterator it=gather_S_counts.begin();it!=gather_S_counts.end();it++) (*it).clear();
gather_S_counts.clear();
for (scatter_scalar::iterator it=gather_F_counts.begin();it!=gather_F_counts.end();it++) (*it).clear();
gather_F_counts.clear();
for (scatter_scalar::iterator it=gather_G_counts.begin();it!=gather_G_counts.end();it++) (*it).clear();
gather_G_counts.clear();
broadcast_O_counts.clear();
broadcast_D_counts.clear();
broadcast_T_counts.clear();
broadcast_branch_zero.clear();
broadcast_branch_count.clear();
broadcast_branch_sum.clear();
broadcast_from_count.clear();
broadcast_genome_size.clear();
return broadcast_pea_count;
}
WorkerProcess(mpi::communicator& c) :
com(c), data(), myLongest("") {
token = NO_TOKEN;
nextHop = (com.rank() + 1) % com.size();
isWhiteProcess = true;
}
pair < scalar_type,string> ML_nni_step(Species_tree * infer_tree,string Sstring,string mode,bool greedy)
{
const mpi::communicator world = infer_tree->world;
int server = 0;
int mpi_rank = world.rank();
int size = world.size();
broadcast(world, Sstring,server);
tree_type * S=TreeTemplateTools::parenthesisToTree(Sstring);
// get inital set up from branch lengts
Node * root = S->getRootNode();
//vector<Node * > nodes_tmp = S->getNodes();
vector<Node * > nodes= S->getNodes();
//RandomTools::getSample(nodes_tmp,nodes);
map <scalar_type,Node * > times;
for (vector<Node * > :: iterator ni = nodes.begin(); ni != nodes.end(); ni++ )
if (!(*ni)->isLeaf())
{
scalar_type h=TreeTemplateTools::getDistanceBetweenAnyTwoNodes(*(*ni),*root);
if (times.count(h))
h+=1e-20;
times[h]=(*ni);
}
// register ranks
map <Node *,int> node_2_rank;
map <int,Node *> rank_2_node;
map <int,int> id_2_rank;
map <int,int> rank_2_id;
vector <pair <int,int> > moves;
int rank=0;
for (map < scalar_type,Node *> :: iterator hi = times.begin(); hi != times.end(); hi++ )
{
rank++;
rank_2_node[rank]=(*hi).second;
node_2_rank[(*hi).second]=rank;
rank_2_id[rank]=(*hi).second->getId();
id_2_rank[(*hi).second->getId()]=rank;
stringstream out;out<<rank;
(*hi).second->setBranchProperty("ID",BppString(out.str()));
}
// set branch lengths according to ranks
for (vector<Node * > :: iterator ni = nodes.begin(); ni != nodes.end(); ni++ )
if ((*ni)->isLeaf() )
(*ni)->setDistanceToFather( rank+1 - node_2_rank[(*ni)->getFather()] );
else if ((*ni)!=root)
(*ni)->setDistanceToFather( node_2_rank[(*ni)] - node_2_rank[(*ni)->getFather()] );
scalar_type max_dLL=-1e30;
/*
// find moves
for (map <int,Node *> :: iterator nri = rank_2_node.begin(); nri != rank_2_node.end(); nri++ )
if ((*nri).first!=1)
{
Node * node=(*nri).second;
int r=(*nri).first;
if (rank_2_node[r-1]->getSon(0)!=node && rank_2_node[r-1]->getSon(1)!=node)
{
pair <int,int> move;
move.first=r-1;
move.second=r;
moves.push_back(move);
}
}
//cout << TreeTemplateTools::treeToParenthesis(*S,false,"ID");
scalar_type oLL=LL_mpi(infer_tree,S,mode);
//XX
//cout << oLL << endl;
TreeTemplate<Node> * max_dS;
vector<pair<int,int> > good_moves;
map <scalar_type, TreeTemplate<Node> * > move_trees;
nodes = S->getNodes();
root=S->getRootNode();
// preform moves
for (vector <pair <int,int> > :: iterator mi = moves.begin(); mi != moves.end(); mi++ )
{
//TreeTemplate<Node> * dS=S->clone();
//vector<Node * > dS_nodes = dS->getNodes();
//Node * dS_root=dS->getRootNode();
id_2_rank[rank_2_id[(*mi).first]] = (*mi).second;
id_2_rank[rank_2_id[(*mi).second]] = (*mi).first;
for (vector<Node * > :: iterator ni = nodes.begin(); ni != nodes.end(); ni++ )
if ((*ni)->isLeaf() )
(*ni)->setDistanceToFather( rank+1 - id_2_rank[(*ni)->getFather()->getId()] );
else if ((*ni)!=root)
(*ni)->setDistanceToFather( id_2_rank[(*ni)->getId()] - id_2_rank[(*ni)->getFather()->getId()] );
scalar_type dLL = LL_mpi(infer_tree,S,mode)-oLL;
//cout << (*mi).first << " <-> " << (*mi).second << endl;
//cout << dLL <<endl;
id_2_rank[rank_2_id[(*mi).first]] = (*mi).first;
id_2_rank[rank_2_id[(*mi).second]] = (*mi).second;
for (vector<Node * > :: iterator ni = nodes.begin(); ni != nodes.end(); ni++ )
if ((*ni)->isLeaf() )
(*ni)->setDistanceToFather( rank+1 - id_2_rank[(*ni)->getFather()->getId()] );
else if ((*ni)!=root)
(*ni)->setDistanceToFather( id_2_rank[(*ni)->getId()] - id_2_rank[(*ni)->getFather()->getId()] );
if (dLL>max_dLL)
{
max_dLL=dLL;
//max_dS=dS;
}
if(dLL>0)
good_moves.push_back((*mi));
}
//cout << max_dLL << endl;
map<int,int> moved;
for (vector <pair <int,int> > :: iterator mi = good_moves.begin(); mi != good_moves.end(); mi++ )
{
if (moved.count((*mi).first)==0 && moved.count((*mi).first)==0)
{
//cout << (*mi).first << " <-G-> " << (*mi).second << endl;
id_2_rank[rank_2_id[(*mi).first]] = (*mi).second;
id_2_rank[rank_2_id[(*mi).second]] = (*mi).first;
moved[(*mi).first]=1;
moved[(*mi).second]=1;
}
}
for (vector<Node * > :: iterator ni = nodes.begin(); ni != nodes.end(); ni++ )
if ((*ni)->isLeaf() )
(*ni)->setDistanceToFather( rank+1 - id_2_rank[(*ni)->getFather()->getId()] );
else if ((*ni)!=root)
(*ni)->setDistanceToFather( id_2_rank[(*ni)->getId()] - id_2_rank[(*ni)->getFather()->getId()] );
*/
if (mpi_rank==server) cout << Sstring<<endl;
if (mpi_rank==server) cout << TreeTemplateTools::treeToParenthesis(*S)<<endl;
if (mpi_rank==server) cout << can_order(S)<<endl;
scalar_type oLL=LL_mpi(infer_tree,can_order(S),mode);
if (mpi_rank==server) cout << "oLL " << oLL << endl;
scalar_type maxdLL=0;
int max_id=-1;
int max_father_id=-1;
//TreeTemplate<Node> * maxdS;
string maxdS;
root=S->getRootNode();
for (vector < Node *> :: iterator ni=nodes.begin();ni!=nodes.end(); ni++)
if (!((*ni)==root) && !((*ni)->isLeaf()) )
{
Node * node0=(*ni)->getSon(0);
Node * node1=(*ni)->getSon(1);
Node * father=(*ni)->getFather();
Node * node2;
if (father->getSon(0)==(*ni))
node2=father->getSon(1);
else
node2=father->getSon(0);
//disolve
(*ni)->removeSons();
father->removeSons();
//NNI 1.
(*ni)->addSon(node0);
(*ni)->addSon(node2);
father->addSon((*ni));
father->addSon(node1);
//clone out
int old_rank=id_2_rank[(*ni)->getId()];
for (map<int,int> :: iterator ii = id_2_rank.begin(); ii != id_2_rank.end(); ii++ )
if ((*ii).second<id_2_rank[(*ni)->getId()] && (*ii).second>id_2_rank[father->getId()])
(*ii).second+=1;
id_2_rank[(*ni)->getId()]=id_2_rank[(*ni)->getFather()->getId()]+1;
vector<Node * > dS_nodes = S->getNodes();
Node * dS_root=S->getRootNode();
for (vector<Node * > :: iterator nii = dS_nodes.begin(); nii != dS_nodes.end(); nii++ )
if ((*nii)->isLeaf() )
(*nii)->setDistanceToFather( rank+1 - id_2_rank[(*nii)->getFather()->getId()] );
else if ((*nii)!=dS_root)
(*nii)->setDistanceToFather( id_2_rank[(*nii)->getId()] - id_2_rank[(*nii)->getFather()->getId()] );
//TreeTemplate<Node> * dS=S->clone();
string nni_string=can_order(S);
scalar_type dLL = LL_mpi(infer_tree,nni_string,mode)-oLL;
//cout << get_name(node0) << " ^ " << get_name(node2) << " -- " << get_name(node1) <<endl;
if (dLL>maxdLL)
{
maxdLL=dLL;
maxdS=nni_string;//S->clone();
max_id=(*ni)->getId();
max_father_id=father->getId();
if (mpi_rank==server) cout << dLL << " " << oLL << endl;
if (mpi_rank==server) cout << nni_string << endl;
if (greedy) break;
}
//disolve
(*ni)->removeSons();
father->removeSons();
for (map<int,int> :: iterator ii = id_2_rank.begin(); ii != id_2_rank.end(); ii++ )
if ((*ii).second<old_rank+1 && (*ii).second>id_2_rank[father->getId()])
(*ii).second-=1;
id_2_rank[(*ni)->getId()]=old_rank;
//NNI 2.
(*ni)->addSon(node1);
(*ni)->addSon(node2);
father->addSon((*ni));
father->addSon(node0);
//clone out
old_rank=id_2_rank[(*ni)->getId()];
for (map<int,int> :: iterator ii = id_2_rank.begin(); ii != id_2_rank.end(); ii++ )
if ((*ii).second<id_2_rank[(*ni)->getId()] && (*ii).second>id_2_rank[father->getId()])
(*ii).second+=1;
id_2_rank[(*ni)->getId()]=id_2_rank[(*ni)->getFather()->getId()]+1;
dS_nodes = S->getNodes();
dS_root=S->getRootNode();
for (vector<Node * > :: iterator nii = dS_nodes.begin(); nii != dS_nodes.end(); nii++ )
if ((*nii)->isLeaf() )
(*nii)->setDistanceToFather( rank+1 - id_2_rank[(*nii)->getFather()->getId()] );
else if ((*nii)!=dS_root)
(*nii)->setDistanceToFather( id_2_rank[(*nii)->getId()] - id_2_rank[(*nii)->getFather()->getId()] );
//dS
nni_string=can_order(S);
dLL = LL_mpi(infer_tree,nni_string,mode)-oLL;
//cout << dLL << "nni move"<<endl;
//cout << get_name(node1) << " ^ " << get_name(node2) << " -- " << get_name(node0) <<endl;
if (dLL>maxdLL)
{
maxdLL=dLL;
maxdS=nni_string;//S->clone();;
max_id=(*ni)->getId();
max_father_id=father->getId();
if (mpi_rank==server) cout << dLL << " ."<< endl;
if (mpi_rank==server) cout << nni_string << endl;
if (greedy) break;
}
//disolve
(*ni)->removeSons();
father->removeSons();
for (map<int,int> :: iterator ii = id_2_rank.begin(); ii != id_2_rank.end(); ii++ )
if ((*ii).second<old_rank+1 && (*ii).second>id_2_rank[father->getId()])
(*ii).second-=1;
id_2_rank[(*ni)->getId()]=old_rank;
//restore
(*ni)->addSon(node0);
(*ni)->addSon(node1);
father->addSon((*ni));
father->addSon(node2);
}
times.clear();
nodes.clear();
node_2_rank.clear();
rank_2_node.clear();
id_2_rank.clear();
rank_2_id.clear();
moves.clear();
pair < scalar_type,string> ML_step;
delete S;
ML_step.first=maxdLL;
if (maxdLL>0)
ML_step.second=maxdS;
else
ML_step.second=Sstring;
return ML_step;
/* if (maxdLL>0)
{
S=maxdS;
max_dLL=maxdLL;
int old_rank=id_2_rank[max_id];
for (map<int,int> :: iterator ii = id_2_rank.begin(); ii != id_2_rank.end(); ii++ )
if ((*ii).second<id_2_rank[max_id] && (*ii).second>id_2_rank[max_father_id])
(*ii).second+=1;
id_2_rank[max_id]=id_2_rank[max_father_id]+1;
}
nodes = S->getNodes();
root=S->getRootNode();
for (vector<Node * > :: iterator ni = nodes.begin(); ni != nodes.end(); ni++ )
if ((*ni)->isLeaf() )
(*ni)->setDistanceToFather( rank+1 - id_2_rank[(*ni)->getFather()->getId()] );
else if ((*ni)!=root)
(*ni)->setDistanceToFather( id_2_rank[(*ni)->getId()] - id_2_rank[(*ni)->getFather()->getId()] );
pair < scalar_type,string> ML_step;
ML_step.first=max_dLL;
ML_step.second=can_order(S);
//ML_step.second=maxdS;
return ML_step;
*/
}
