void testit(int* wanted, int Nwanted, int dimquads, int (*compar)(const void *, const void *),
anbool cxdx) {
int i;
solver_t* solver;
index_t index;
starxy_t* starxy;
starxy = field1();
quadlist = bl_new(16, dimquads*sizeof(int));
ninv = 0;
solver = solver_new();
memset(&index, 0, sizeof(index_t));
index.index_scale_lower = 1;
index.index_scale_upper = 10;
index.dimquads = dimquads;
index.cx_less_than_dx = index.meanx_less_than_half = cxdx;
solver->funits_lower = 0.1;
solver->funits_upper = 10;
solver_add_index(solver, &index);
solver_set_field(solver, starxy);
solver_preprocess_field(solver);
printf("Found:\n");
solver_run(solver);
printf("\n");
fflush(NULL);
solver_free_field(solver);
solver_free(solver);
//
bl_sort(quadlist, compar);
qsort(wanted, Nwanted, dimquads*sizeof(int), compar);
printf("\n\n");
printf("Wanted:\n");
for (i=0; i<Nwanted; i++) {
int j;
printf("{");
for (j=0; j<dimquads; j++)
printf("%s%i", (j?",":""), wanted[i*dimquads+j]);
printf("}, ");
}
printf("\n");
printf("N found: %i; N wanted: %i\n", bl_size(quadlist), Nwanted);
printf("N obeying invariants: %i\n", ninv);
assert(bl_size(quadlist) == Nwanted);
for (i=0; i<bl_size(quadlist); i++) {
//int* i1 = bl_access(quadlist, i);
//int* i2 = wanted[i];
//printf("[%i, %i, %i] vs [%i, %i, %i]\n", i1[0],i1[1],i1[2], i2[0],i2[1],i2[2]);
assert(compar(bl_access(quadlist, i), wanted+i*dimquads) == 0);
}
bl_free(quadlist);
}
int main(int argc, char *argv[])
{
PetscErrorCode ierr;
int i;
grid *grd;
MPI_Init(&argc,&argv);
option options = parse_options(argc, argv);
if (options.problem == JUMP) {
grd = grid_create(-1, 1, options.nx,
-1, 1, options.ny,
-1, 1, options.nz);
} else {
grd = grid_create(0, 1, options.nx,
0, 1, options.ny,
0, 1, options.nz);
}
if (options.periodic > -1) grd->periodic[options.periodic] = 1;
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (rank == 0) print_intro(&options);
map *mp = map_create(options.map);
grid_apply_map(grd, mp);
problem *pb = problem_create(options.problem, grd->nd, mp->id);
solver *sol = solver_create(grd, pb);
ierr = solver_init(sol, grd);CHKERRQ(ierr);
ierr = solver_run(sol);CHKERRQ(ierr);
double *u = (double*) malloc(grd->num_pts*sizeof(double));
double *diff = (double*) malloc(grd->num_pts*sizeof(double));
grid_eval(grd, pb->sol, u);
for (i = 0; i < grd->num_pts; i++)
diff[i] = sol->state->phi[i] - u[i];
print_norm(diff, grd->num_pts);
free(u); free(diff);
grid_destroy(grd); free(grd);
map_destroy(mp); free(mp);
problem_destroy(pb); free(pb);
ierr = solver_destroy(sol);CHKERRQ(ierr); free(sol);
if (options.eig && rank == 0) {
system("./python/plot.py");
}
MPI_Finalize();
return 0;
}
void test_solve_multiindex(CuTest* ct) {
sl* fns;
multiindex_t* mi;
int i;
solver_t* s = NULL;
starxy_t* field = NULL;
MatchObj* mo = NULL;
xylist_t* xy = NULL;
log_init(LOG_VERB);
fns = sl_new(4);
sl_append(fns, "../util/t10.ind");
sl_append(fns, "../util/t11.ind");
sl_append(fns, "../util/t12.ind");
mi = multiindex_open("../util/t10.skdt", fns, 0);
printf("Got %i indices\n", multiindex_n(mi));
for (i=0; i<multiindex_n(mi); i++) {
index_t* ind = multiindex_get(mi, i);
printf(" %i: %s, %i stars, %i quads (%g to %g arcmin)\n",
i, ind->indexname, index_nquads(ind), index_nstars(ind),
ind->index_scale_lower/60., ind->index_scale_upper/60.);
}
s = solver_new();
// 10.8
s->funits_lower = 5.0;
s->funits_upper = 15.0;
xy = xylist_open("../util/t1.xy");
if (!xy) {
ERROR("Failed to open xylist\n");
CuFail(ct, "xylist");
}
field = xylist_read_field(xy, NULL);
solver_set_field(s, field);
solver_set_field_bounds(s, 0, 1000, 0, 1000);
for (i=0; i<multiindex_n(mi); i++) {
index_t* ind = multiindex_get(mi, i);
solver_add_index(s, ind);
}
solver_run(s);
if (solver_did_solve(s)) {
mo = solver_get_best_match(s);
matchobj_print(mo, LOG_MSG);
// HACK -- ugly!!
verify_free_matchobj(mo);
}
xylist_close(xy);
solver_cleanup_field(s);
solver_free(s);
multiindex_free(mi);
sl_free2(fns);
}
void test2() {
int i;
solver_t* solver;
index_t index;
starxy_t* starxy;
int wanted[][3] = { { 0, 1, 3 },
{ 0, 1, 4 },
{ 0, 1, 5 },
{ 0, 2, 3 },
{ 0, 2, 4 },
{ 0, 3, 4 },
{ 0, 5, 4 },
{ 0, 6, 4 },
{ 0, 6, 5 },
{ 1, 2, 3 },
{ 1, 2, 4 },
{ 1, 3, 4 },
{ 1, 5, 4 },
{ 1, 6, 4 },
{ 1, 6, 5 },
{ 2, 4, 3 },
{ 2, 5, 0 },
{ 2, 5, 1 },
{ 2, 5, 3 },
{ 2, 5, 4 },
{ 2, 6, 0 },
{ 2, 6, 1 },
{ 2, 6, 3 },
{ 2, 6, 4 },
{ 2, 6, 5 },
{ 3, 5, 4 },
{ 3, 6, 0 },
{ 3, 6, 1 },
{ 3, 6, 4 },
{ 3, 6, 5 },
{ 4, 6, 5 },
};
starxy = field1();
quadlist = bl_new(16, 3*sizeof(uint));
solver = solver_new();
memset(&index, 0, sizeof(index_t));
index.index_scale_lower = 1;
index.index_scale_upper = 10;
index.dimquads = 3;
solver->funits_lower = 0.1;
solver->funits_upper = 10;
solver_add_index(solver, &index);
solver_set_field(solver, starxy);
solver_preprocess_field(solver);
solver_run(solver);
solver_free_field(solver);
solver_free(solver);
//
assert(bl_size(quadlist) == (sizeof(wanted) / (3*sizeof(uint))));
bl_sort(quadlist, compare_tri);
for (i=0; i<bl_size(quadlist); i++) {
assert(compare_tri(bl_access(quadlist, i), wanted[i]) == 0);
}
bl_free(quadlist);
}
