u8 init_simulation(command* cmd, simulation* sim, timer* t, ocrGuid_t** list) { sim->step = 0; sim->steps = cmd->steps; sim->period = cmd->period; sim->dt = cmd->dt; sim->e_potential = 0.0; sim->e_kinetic = 0.0; u8 insane = 0; if(cmd->doeam) insane = init_eam(cmd->pot_dir, cmd->pot_name, cmd->pot_type, &sim->pot, sim->dt); else init_lj(&sim->pot, sim->dt); if(insane) return insane; real_t lattice_const = cmd->lat; if(cmd->lat < 0.0) lattice_const = sim->pot.lat; insane = sanity_checks(cmd, sim->pot.cutoff, lattice_const, sim->pot.lattice_type); if(insane) return insane; ocrGuid_t box_tmp; box** box_ptr = init_lattice(sim, cmd, lattice_const, list, &box_tmp); profile_start(redistribute_timer,t); redistribute_atoms(sim, box_ptr, sim->bxs.boxes_num); profile_stop(redistribute_timer,t); ocrDbDestroy(box_tmp); return 0; }
int main(int argc, char **argv) { /* Initialize the random number generator */ rlxd_init(2, 12345); /* Initialize the lattice geometry */ init_lattice(X1, X2); //Testing the hermiticity of gam5D_wilson //Operator is Hermitian if for any vectors x and y (y, Ax) = (Ay, x) //1. Write the procedure which fills a spinor field with gaussian-distributed complex random numbers such that <z z*> = 1 //2. Initialize two random spinor fields X and Y (arrays of type spinor and size GRIDPOINTS) //3. Check that (y, Ax) = (Ay, x) spinor X[GRIDPOINTS], Y[GRIDPOINTS], tmp[GRIDPOINTS]; rand_spinor(X); rand_spinor(Y); //Calculating p1 = (y, Ax) gam5D_wilson(tmp, X); complex double p1 = scalar_prod(Y, tmp); //Calculating p2 = (Ax, y) gam5D_wilson(tmp, Y); complex double p2 = scalar_prod(tmp, X); //Check that p1 and p2 are equal double epsilon = cabs(p1 - p2); printf("\n\n\t Hermiticity check: |p1 - p2| = %2.2E - %s \n\n", epsilon, (epsilon < 1E-14)? "OK":"No"); //Testing the performance of the Conjugate Gradient Solver //1. In order to monitor the progress of the solver, #define MONITOR_CG_PROGRESS in linalg.h // This will print the squared norm of the residue at each iteration to the screen //2. Initialize the gauge fields with the coldstart() procedure //3. Generate a random spinor field Y and use cg(X, Y, ITER_MAX, DELTACG, &gam5D_SQR_wilson) // to solve the equation (gamma_5 D)^2 X = Y // (gamma_5 D)^2 is implemented as gam5D_SQR_wilson(out, temp, in), see Dirac.h //4. Now apply gam5D_SQR_wilson to X, subtract Y and calculate the norm of the result //5. Do the same with hotstart() and see how the number of CG iterations changes coldstart(); spinor Y1[GRIDPOINTS]; rand_spinor(Y); cg(X, Y, ITER_MAX, DELTACG, &gam5D_SQR_wilson); gam5D_SQR_wilson(Y1, tmp, X); diff(tmp, Y1, Y); epsilon = sqrt(square_norm(tmp)); printf("\n\n\t Test of CG inverter: |Q X - Y| = %2.2E - %s \n\n", epsilon, (epsilon < 1E-6)? "OK":"No"); free(left1); free(left2); free(right1); free(right2); system("PAUSE"); return 0; }
void static_load_arrays() { init_lattice(); load_vs(); load_omega(0.50,0); load_omega(0.45,1); load_omega(0.40,2); load_omega(0.35,3); load_omega(0.30,4); load_omega(0.25,5); load_omega(0.20,6); load_omega(0.15,7); }
int main(int argc, char **argv) { int i, l; int accepted = 0; //Total number of accepted configurations int total_updates = 0; //Total number of updates clock_t begin, end; /* Initialize the random number generator */ rlxd_init(2, time(NULL)); /* Initialize the lattice geometry */ init_lattice(Lx, Ly, Lt); /* Initialize the fields */ hotstart(); /* Print out the run parameters */ echo_sim_params(); mc_init(); /* thermalization */ mc_iter = 0; //Counts the total number of calls to the update() routine printf("\n Thermalization: \n\n"); //begin = clock(); for(i=0; i<g_thermalize; i++) { mc_update(); //printf("\t Step %04i\n", i); }; //end = clock(); //printf("Time for one MC update: %f\n", (double)(end - begin) / CLOCKS_PER_SEC); /* measure the iterations only during real simulation, not thermalization */ R = 0; //Counts the total number of accepted configurations mc_iter = 0; //Counts the total number of calls to the update() routine printf("\n Generation: \n\n"); measurement_init(); measure(); printf("Average density: \t %.5f %.5f\n", creal(m_density[measure_iter]), cimag(m_density[measure_iter])); printf("Wilson plaquette: \t %.5f\n", mean_plaq()); for(i=0; i<g_measurements; i++) { /* do g_intermediate updates before measurement */ for (l=0; l<g_intermediate; l++) { mc_update(); }; mc_update(); /* doing measurement */ measure(); printf("Average density: \t %.5f %.5f\n", creal(m_density[measure_iter]), cimag(m_density[measure_iter])); printf("Wilson plaquette: \t %.5f\n", mean_plaq()); fflush(stdout); }; printf("Wrapping up...\n"); output_measurement(); measurement_finish(); /* Some output for diagnostics */ total_updates = g_measurements*(g_intermediate + 1)*GRIDPOINTS; printf("\n\n Algorithm performance:\n"); printf("\t Acceptance rate: %.4f\n", (double)R/(double)total_updates); return 0; }
void Decoder::decode(Instance * inst) { init_lattice(inst); viterbi_decode(inst); get_result(inst); free_lattice(); }
int main(int argc, char ** argv){ int *lattice; int neigh[4]; int n_side; int i_flip=0; int i,j; double r; double delta_E; double T = atof(argv[2]); double beta = 1.0/T; double E; double M; double alpha; double h; int n_steps; double average_m = 0.0; double average_E = 0.0; double average_E2 = 0.0; n_side = atoi(argv[1]); lattice = init_lattice(n_side); E = compute_energy(lattice, n_side); M = compute_magnetiza(lattice, n_side); /*printf("%f %f\n", E, M);*/ n_steps = n_side * n_side * 10; for(i=0;i<n_steps;i++){ i_flip = random_between(0,n_side*n_side-1); get_neighbors(lattice, n_side, i_flip, neigh); h = 0.0; for(j=0;j<4;j++){ h += lattice[neigh[j]]; } delta_E = 2.0 * h * lattice[i_flip]; r = MIN(1.0, exp(-beta * delta_E)); alpha = drand48(); if(alpha < r){ lattice[i_flip] = -lattice[i_flip]; E = E + delta_E; } M = compute_magnetiza(lattice, n_side); /*printf("%f %f\n", E, M);*/ if(i>30000){ average_m += fabs(M)/(n_side*n_side); average_E += E; average_E2 += E*E; } } average_m = average_m/(n_steps-30000); average_E = average_E/(n_steps-30000); average_E2 = average_E2/(n_steps-30000); double varE = average_E2 - average_E*average_E; printf("%f %f %f\n", T, average_m, varE); return 0; }