double NumFeatureDistance(Features_p f1, Features_p f2, double pred_w,
double func_w, double* weights)
{
double res, norm, dist, wsq;
int i;
dist = arity_distr_distance(f1->pred_distrib, f2->pred_distrib,
MAX(f1->pred_max_arity,
f2->pred_max_arity));
wsq = pred_w*pred_w;
res = dist*dist*wsq;
norm = wsq;
dist = arity_distr_distance(f1->func_distrib, f2->func_distrib,
MAX(f1->func_max_arity,
f2->func_max_arity));
wsq = func_w*func_w;
res += dist*dist*wsq;
norm += wsq;
for(i=0; i<FEATURE_NUMBER; i++)
{
dist = relative_difference(f1->features[i],f2->features[i]);
wsq = weights[i] * weights[i];
res += dist*dist*wsq;
norm += wsq;
}
res = res/norm;
return sqrt(res);
}
inline typename boost::math::tools::promote_args<T, U>::type epsilon_difference(const T& arg_a, const U& arg_b)
{
typedef typename boost::math::tools::promote_args<T, U>::type result_type;
result_type r = relative_difference(arg_a, arg_b);
if(tools::max_value<result_type>() * boost::math::tools::epsilon<result_type>() < r)
return tools::max_value<result_type>();
return r / boost::math::tools::epsilon<result_type>();
}
static double arity_distr_distance(PDArray_p d1, PDArray_p d2, int
maxarity)
{
int i, val1, val2;
double res = 0;
assert(maxarity >= -1);
if(maxarity == -1)
{
return 0.0;
}
for(i=0; i<=maxarity; i++)
{
val1 = PDArrayElementInt(d1, i);
val2 = PDArrayElementInt(d2, i);
res += relative_difference(val1,val2)*
relative_difference(val1,val2);
}
return sqrt(res)/(double)(maxarity+1);
}
static void compute_linf_norms(MPI_Comm comm,
real_t* x,
real_t* y,
int N,
real_t* rel_norm,
real_t* abs_norm)
{
real_t abs = 0.0, rel = 0.0;
for (int i = 0; i < N; ++i)
{
real_t xi = x[i], yi = y[i];
real_t rel_diff = relative_difference(xi, yi);
real_t abs_diff = fabs(xi-yi);
rel = MAX(rel, rel_diff);
abs = MAX(abs, abs_diff);
}
real_t norms[2] = {rel, abs};
MPI_Allreduce(MPI_IN_PLACE, norms, 2, MPI_REAL_T, MPI_MAX, comm);
*rel_norm = norms[0];
*abs_norm = norms[1];
}
static void compute_l2_norms(MPI_Comm comm,
real_t* x,
real_t* y,
int N,
real_t* rel_norm,
real_t* abs_norm)
{
real_t abs = 0.0, rel = 0.0;
for (int i = 0; i < N; ++i)
{
real_t xi = x[i], yi = y[i];
real_t rel_diff = relative_difference(xi, yi);
real_t abs_diff = fabs(xi-yi);
rel += rel_diff*rel_diff;
abs += abs_diff*abs_diff;
}
real_t norms[2] = {rel, abs};
MPI_Allreduce(MPI_IN_PLACE, norms, 2, MPI_REAL_T, MPI_SUM, comm);
*rel_norm = sqrt(norms[0]);
*abs_norm = sqrt(norms[1]);
}
int get_owner_element(e *E, double *pos){
int i;
int max_its;
int element;
int element_new;
int x_element;
int y_element;
double point;
double interval_size;
int check = 1;
max_its = 20;
// search over elements to determine which element contains this position
// apply a binary search method on the elements
// search in x
i=0;
element = (double)E->nx/2.0;
element_new = 0;
interval_size = E->nx/2.0;
do{
if( (relative_difference(pos[0],E->msh.x[element+1])<=TOLERANCE) || (relative_difference(pos[0],E->msh.x[element])<=TOLERANCE)
||
(pos[0] <= E->msh.x[element+1]) && (pos[0] >= E->msh.x[element]) ){
// found it
element = element;
break;
}
else if( E->msh.x[element] >= pos[0] ){ // means that the pos point is on the left of our current index
element_new = ( (double)element - ceil(interval_size/2.0) );
if(element_new < 0) element_new=0;
}
else{ // means that the pos point is on the right of our current index
element_new = ceil( (double)element + (interval_size/2.0) );
if(element_new >= E->nx){
element_new=E->nx-1;
}
}
interval_size = fabs(element_new - element);
element = element_new;
i++;
}while(i<max_its);
if(i>=max_its){
printf("x get owner failed!\n");
printf("pos = %f, %f\n", pos[0], pos[1]);
printf("element = %d\n", element);
printf("its = %d\n", i);
printf(" (%.5f, %.5f) --------- (%.5f, %.5f)\n", E->ele[element].node_coord[3][0], E->ele[element].node_coord[3][1],
E->ele[element].node_coord[2][0], E->ele[element].node_coord[2][1]);
printf(" | |\n");
printf(" | |\n");
printf(" | |\n");
printf(" | |\n");
printf(" (%.5f, %.5f) --------- (%.5f, %.5f)\n\n", E->ele[element].node_coord[0][0], E->ele[element].node_coord[0][1],
E->ele[element].node_coord[1][0], E->ele[element].node_coord[1][1]);
exit(1);
}
// x_element stores the column that this point will be in
// lets use this information to constrain our search in y
x_element = element;
element = ceil((double)E->ny/2.0);
element_new = 0;//(double)E->ny/2.0;
interval_size = E->ny/2.0;
// now search in y
i=0;
do{
if( (relative_difference(pos[1],E->msh.y[element+1])<=TOLERANCE) || (relative_difference(pos[1],E->msh.y[element])<=TOLERANCE)
||
(pos[1] <= E->msh.y[element+1]) && (pos[1] >= E->msh.y[element]) ){
// found it
break;
}
if( (E->msh.y[element] >= pos[1]) ){
element_new = ( (double)element - ceil(interval_size/2.0) ) ;
if(element_new < 0) element_new=0;
}
else{
element_new = ( (double)element + ceil(interval_size/2.0) );
if(element_new >= E->ny) {
element_new=E->ny-1;
}
}
interval_size = fabs(element_new - element);
element = element_new;
i++;
}while(i<max_its);
if(i>=max_its){
printf("y get owner failed!\n");
printf("pos = %f, %f\n", pos[0], pos[1]);
printf("its = %d\n", i);
printf(" (%.5f, %.5f) --------- (%.5f, %.5f)\n", E->ele[element].node_coord[3][0], E->ele[element].node_coord[3][1],
E->ele[element].node_coord[2][0], E->ele[element].node_coord[2][1]);
printf(" | |\n");
printf(" | |\n");
printf(" | |\n");
printf(" | |\n");
printf(" (%.5f, %.5f) --------- (%.5f, %.5f)\n\n", E->ele[element].node_coord[0][0], E->ele[element].node_coord[0][1],
E->ele[element].node_coord[1][0], E->ele[element].node_coord[1][1]);
exit(1);
}
// the owner element for this point is element * x_element
element = (element*(E->nx)) + x_element;
/*
printf("get owner finished\n");
printf("pos = %f, %f\n", pos[0], pos[1]);
printf("its = %d\n", i);
printf(" (%.5f, %.5f) --------- (%.5f, %.5f)\n", E->ele[element].node_coord[3][0], E->ele[element].node_coord[3][1],
E->ele[element].node_coord[2][0], E->ele[element].node_coord[2][1]);
printf(" | |\n");
printf(" | |\n");
printf(" | |\n");
printf(" | |\n");
printf(" (%.5f, %.5f) --------- (%.5f, %.5f)\n\n", E->ele[element].node_coord[0][0], E->ele[element].node_coord[0][1],
E->ele[element].node_coord[1][0], E->ele[element].node_coord[1][1]);
*/
return element;
}
void three_body_system::competitive_loop(){
int channel_0 = 3;
int cind = channel_index(channel_0);
if (cont->use_saved_states){
string state_input_name = name + ".states";
if (only_2body) state_input_name += "_2body";
ifstream state_input(state_input_name);
string line;
while (getline(state_input, line)){
string line_temp = line;
if (line_temp.find("Fin") == std::string::npos)
states.push_back(state_full(line, ang));
}
cout << "Successfully read states from file." << endl;
}
if (states.size() == 0){
states.push_back(
state_full(0, &ang->states[0],
scale_factor_r[cind], scale_factor_rho[cind], scale_factor_com[cind],
channel_0)
);
string state_output_name = name + ".states";
if (only_2body) state_output_name += "_2body";
ofstream state_output(state_output_name, ios_base::app);
state_output << states.back();
}
regenerate_matrices();
diagonalise();
// determine what mode we're in initially...
int current_mode = 0;
int state_counter = states.size();
for (auto mode_size : cont->max_states){
if (state_counter >= mode_size){
current_mode++;
state_counter -= mode_size;
}
else{
break;
}
}
int end_test_counter = 0;
int fail_counter = 0;
int fail_limit = 2;
double energy_old = evals[0];
double convtol = 1E-6;
string energy_output_name = name + ".energies";
if (only_2body){
energy_output_name = name + ".2body";
}
ofstream energy_output(energy_output_name, ios_base::app);
for (; current_mode < int(cont->max_states.size()); current_mode++){
int mode_size = cont->max_states[current_mode];
int fail_counter = 0;
cout << "sc = " << state_counter << endl;
while (state_counter++ <= mode_size){
if (select_new_state_competitive(1000, current_mode)){
if (relative_difference(energy_old, evals[0]) < convtol){
fail_counter++;
}
else{
cout << energy_old << " " << evals[0] << " " << relative_difference(energy_old, evals[0]) << endl;
energy_old = evals[0];
fail_counter = 0;
energy_output << states.size() << ": " << flush;
for (unsigned int i=0; i<10; i++){
if (i < evals.size()){
energy_output << evals[i] << " ";
}
}
energy_output << endl;
//break;
}
}
else fail_counter++;
if (fail_counter != 0) cout << "fails = " << fail_counter << endl;
if (fail_counter >= fail_limit){
cout << "Cannot find new states, ending simulation..." << endl;
break;
}
}
state_counter = 0;
cout << "Completed mode " << current_mode << endl;
cout << "state_counter = " << state_counter << endl;
cout << "mode_size = " << mode_size << endl;
}
//print_matrix_to_file(&S[0], basis_size, name + ".S");
//print_matrix_to_file(&H[0], basis_size, name + ".H");
}
bool three_body_system::competitive_end_test(double eval_old, double eval_new){
double diff_abs = abs(eval_old - eval_new);
double diff_rel = relative_difference(eval_old, eval_new);
return (diff_abs < 0.0001 && diff_rel < 0.0001);
}
