void three_body_system::generate_states_geometric(){
vector<double> alphas_r, alphas_rho, alphas_com;
int channel = 3;
int cind = channel_index(channel);
double minimum = cont->scale_min_to_r0_r ? cont->basis_min_r * r0_unlike : cont->basis_min_r;
double maximum = cont->basis_max_r * pow(trapping[cind][0][0] / kinetic[cind][0][0], -0.125);
cout << cont->basis_max_r << " " << pow(trapping[cind][0][0] / kinetic[cind][0][0], -0.125) << endl;
geometric_series(alphas_r, minimum, maximum, 2);
minimum = cont->scale_min_to_r0_rho ? cont->basis_min_rho * r0_unlike : cont->basis_min_rho;
maximum = cont->basis_max_rho * pow(trapping[cind][1][1] / kinetic[cind][1][1], -0.125);
geometric_series(alphas_rho, minimum, maximum, 2);
if (1 == 1){
//alphas_com.push_back(pow(trapping[2][2] / kinetic[2][2], 0.25));
alphas_com.push_back(1.0/kinetic[cind][2][2]);
}
else{
minimum = cont->scale_min_to_r0_com ? cont->basis_min_com * r0_unlike : cont->basis_min_com;
maximum = cont->basis_max_com * pow(trapping[cind][2][2] / kinetic[cind][2][2], -0.125);
geometric_series(alphas_com, minimum, maximum, 1);
}
states = vector<state_full>();
int index = 0;
for (auto & alpha_com : alphas_com){
for (auto & alpha_rho : alphas_rho){
for (auto & alpha_r : alphas_r){
for (auto & angular: ang->states){
states.push_back(
state_full(index++, &angular, alpha_r, alpha_rho, alpha_com, 3));
}
}
}
}
cout << "Generated geometric series states, total: " << alphas_r.size() << " x " << alphas_rho.size() << " x " << alphas_com.size() << " x " << ang->states.size() << " = " << states.size() << endl;
if (true){
print_vector_to_file(alphas_r, name + ".info.alphas_r");
print_vector_to_file(alphas_rho, name + ".info.alphas_rho");
print_vector_to_file(alphas_com, name + ".info.alphas_com");
}
}
int reverse_tree_direct_children(int rank, int num_nodes, int width,
int depth, int *children)
{
int current, child_distance;
int max_depth, sub_depth, max_rank_children;
int i;
max_depth = dep(num_nodes, width);
sub_depth = max_depth - depth;
if( sub_depth == 0 ){
return 0;
}
max_rank_children = geometric_series(width, sub_depth);
current = rank + 1;
child_distance = (max_rank_children / width);
for (i = 0; i < width && current < num_nodes; i++) {
children[i] = current;
current += child_distance;
}
return i;
}
void
reverse_tree_info(int rank, int num_nodes, int width,
int *parent, int *num_children,
int *depth, int *max_depth)
{
int max_children;
int p, c;
/* sanity check */
if (rank >= num_nodes) {
*parent = -1;
*num_children = -1;
*depth = -1;
*max_depth = -1;
return;
}
*max_depth = dep(num_nodes, width);
if (rank == 0) {
*parent = -1;
*num_children = num_nodes - 1;
*depth = 0;
return;
}
max_children = geometric_series(width, *max_depth);
*depth = 0;
search_tree(rank, 0, max_children, width, &p, &c, depth);
if ((rank + c) >= num_nodes)
c = num_nodes - rank - 1;
*parent = p;
*num_children = c;
return;
}
