void quad_write(codefile_t* codes, quadfile_t* quads,
unsigned int* quad, startree_t* starkd,
int dimquads, int dimcodes) {
double code[DCMAX];
quad_compute_code(quad, dimquads, starkd, code);
quad_enforce_invariants(quad, code, dimquads, dimcodes);
codefile_write_code(codes, code);
quadfile_write_quad(quads, quad);
}
int unpermute_stars(startree_t* treein, quadfile_t* qfin,
startree_t** p_treeout, quadfile_t* qfout,
anbool dosweeps, anbool check,
char** args, int argc) {
startree_t* treeout;
int i;
int N;
int healpix = -1;
int hpnside = 0;
int starhp = -1;
int lastgrass;
qfits_header* qouthdr;
qfits_header* qinhdr;
anbool allsky;
assert(p_treeout);
N = startree_N(treein);
allsky = qfits_header_getboolean(startree_header(treein), "ALLSKY", 0);
if (allsky)
logverb("Star kd-tree is all-sky\n");
else {
starhp = qfits_header_getint(startree_header(treein), "HEALPIX", -1);
if (starhp == -1)
ERROR("Warning, input star kdtree didn't have a HEALPIX header.\n");
hpnside = qfits_header_getint(startree_header(treein), "HPNSIDE", 1);
healpix = starhp;
logverb("Star kd-tree covers healpix %i, nside %i\n", healpix, hpnside);
}
qfout->healpix = healpix;
qfout->hpnside = hpnside;
qfout->numstars = qfin->numstars;
qfout->dimquads = qfin->dimquads;
qfout->index_scale_upper = qfin->index_scale_upper;
qfout->index_scale_lower = qfin->index_scale_lower;
qfout->indexid = qfin->indexid;
qouthdr = quadfile_get_header(qfout);
qinhdr = quadfile_get_header(qfin);
an_fits_copy_header(qinhdr, qouthdr, "ALLSKY");
BOILERPLATE_ADD_FITS_HEADERS(qouthdr);
qfits_header_add(qouthdr, "HISTORY", "This file was created by the program \"unpermute-stars\".", NULL, NULL);
qfits_header_add(qouthdr, "HISTORY", "unpermute-stars command line:", NULL, NULL);
fits_add_args(qouthdr, args, argc);
qfits_header_add(qouthdr, "HISTORY", "(end of unpermute-stars command line)", NULL, NULL);
qfits_header_add(qouthdr, "HISTORY", "** unpermute-stars: history from input:", NULL, NULL);
fits_copy_all_headers(qinhdr, qouthdr, "HISTORY");
qfits_header_add(qouthdr, "HISTORY", "** unpermute-stars: end of history from input.", NULL, NULL);
qfits_header_add(qouthdr, "COMMENT", "** unpermute-stars: comments from input:", NULL, NULL);
fits_copy_all_headers(qinhdr, qouthdr, "COMMENT");
qfits_header_add(qouthdr, "COMMENT", "** unpermute-stars: end of comments from input.", NULL, NULL);
if (quadfile_write_header(qfout)) {
ERROR("Failed to write quadfile header.\n");
return -1;
}
logmsg("Writing quads...\n");
startree_compute_inverse_perm(treein);
if (check) {
logmsg("Running quadfile_check()...\n");
if (quadfile_check(qfin)) {
ERROR("quadfile_check() failed");
return -1;
}
logmsg("Check passed.\n");
logmsg("Checking inverse permutation...\n");
if (startree_check_inverse_perm(treein)) {
ERROR("check failed!");
return -1;
}
logmsg("Running startree kdtree_check()...\n");
if (kdtree_check(treein->tree)) {
ERROR("kdtree_check() failed");
return -1;
}
logmsg("Check passed.\n");
}
lastgrass = 0;
for (i=0; i<qfin->numquads; i++) {
int j;
unsigned int stars[qfin->dimquads];
if (i*80/qfin->numquads != lastgrass) {
logmsg(".");
fflush(stdout);
lastgrass = i*80/qfin->numquads;
}
if (quadfile_get_stars(qfin, i, stars)) {
ERROR("Failed to read quadfile entry.\n");
return -1;
}
for (j=0; j<qfin->dimquads; j++)
stars[j] = treein->inverse_perm[stars[j]];
if (quadfile_write_quad(qfout, stars)) {
ERROR("Failed to write quadfile entry.\n");
return -1;
}
}
logmsg("\n");
if (quadfile_fix_header(qfout)) {
ERROR("Failed to fix quadfile header");
return -1;
}
treeout = startree_new();
treeout->tree = malloc(sizeof(kdtree_t));
memcpy(treeout->tree, treein->tree, sizeof(kdtree_t));
treeout->tree->perm = NULL;
an_fits_copy_header(startree_header(treein), startree_header(treeout), "HEALPIX");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "HPNSIDE");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "ALLSKY");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "JITTER");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "CUTNSIDE");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "CUTMARG");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "CUTBAND");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "CUTDEDUP");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "CUTNSWEP");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "CUTMINMG");
an_fits_copy_header(startree_header(treein), startree_header(treeout), "CUTMAXMG");
qfits_header_add(startree_header(treeout), "HISTORY", "unpermute-stars command line:", NULL, NULL);
fits_add_args(startree_header(treeout), args, argc);
qfits_header_add(startree_header(treeout), "HISTORY", "(end of unpermute-stars command line)", NULL, NULL);
qfits_header_add(startree_header(treeout), "HISTORY", "** unpermute-stars: history from input:", NULL, NULL);
fits_copy_all_headers(startree_header(treein), startree_header(treeout), "HISTORY");
qfits_header_add(startree_header(treeout), "HISTORY", "** unpermute-stars: end of history from input.", NULL, NULL);
qfits_header_add(startree_header(treeout), "COMMENT", "** unpermute-stars: comments from input:", NULL, NULL);
fits_copy_all_headers(startree_header(treein), startree_header(treeout), "COMMENT");
qfits_header_add(startree_header(treeout), "COMMENT", "** unpermute-stars: end of comments from input.", NULL, NULL);
if (dosweeps) {
// copy sweepX headers.
for (i=1;; i++) {
char key[16];
int n;
sprintf(key, "SWEEP%i", i);
n = qfits_header_getint(treein->header, key, -1);
if (n == -1)
break;
an_fits_copy_header(treein->header, treeout->header, key);
}
// compute sweep array.
treeout->sweep = malloc(N * sizeof(uint8_t));
for (i=0; i<N; i++) {
int ind = treein->tree->perm[i];
// Stars are sorted first by sweep and then by brightness within
// the sweep. Instead of just storing the sweep number, we can
// store a quantization of the total-ordered rank.
treeout->sweep[i] = (uint8_t)floor((float)256.0 * (float)ind / (float)N);
}
}
*p_treeout = treeout;
return 0;
}
int unpermute_quads(quadfile* quadin, codetree* treein,
quadfile* quadout, codetree** p_treeout,
char** args, int argc) {
int i;
qfits_header* codehdr;
qfits_header* hdr;
int healpix;
int hpnside;
int codehp = -1;
qfits_header* qouthdr;
qfits_header* qinhdr;
codetree* treeout;
anbool allsky;
codehdr = codetree_header(treein);
healpix = quadin->healpix;
hpnside = quadin->hpnside;
allsky = qfits_header_getboolean(codehdr, "ALLSKY", 0);
if (allsky)
logverb("Index is all-sky\n");
else {
codehp = qfits_header_getint(codehdr, "HEALPIX", -1);
if (codehp == -1)
ERROR("Warning, input code kdtree didn't have a HEALPIX header");
else if (codehp != healpix) {
ERROR("Quadfile says it's healpix %i, but code kdtree says %i",
healpix, codehp);
return -1;
}
}
quadout->healpix = healpix;
quadout->hpnside = hpnside;
quadout->indexid = quadin->indexid;
quadout->numstars = quadin->numstars;
quadout->dimquads = quadin->dimquads;
quadout->index_scale_upper = quadin->index_scale_upper;
quadout->index_scale_lower = quadin->index_scale_lower;
qouthdr = quadfile_get_header(quadout);
qinhdr = quadfile_get_header(quadin);
boilerplate_add_fits_headers(qouthdr);
qfits_header_add(qouthdr, "HISTORY", "This file was created by the program \"unpermute-quads\".", NULL, NULL);
qfits_header_add(qouthdr, "HISTORY", "unpermute-quads command line:", NULL, NULL);
fits_add_args(qouthdr, args, argc);
qfits_header_add(qouthdr, "HISTORY", "(end of unpermute-quads command line)", NULL, NULL);
qfits_header_add(qouthdr, "HISTORY", "** unpermute-quads: history from input:", NULL, NULL);
fits_copy_all_headers(qinhdr, qouthdr, "HISTORY");
qfits_header_add(qouthdr, "HISTORY", "** unpermute-quads end of history from input.", NULL, NULL);
qfits_header_add(qouthdr, "COMMENT", "** unpermute-quads: comments from input:", NULL, NULL);
fits_copy_all_headers(qinhdr, qouthdr, "COMMENT");
qfits_header_add(qouthdr, "COMMENT", "** unpermute-quads: end of comments from input.", NULL, NULL);
fits_copy_header(qinhdr, qouthdr, "CXDX");
fits_copy_header(qinhdr, qouthdr, "CXDXLT1");
fits_copy_header(qinhdr, qouthdr, "CIRCLE");
fits_copy_header(qinhdr, qouthdr, "ALLSKY");
if (quadfile_write_header(quadout)) {
ERROR("Failed to write quadfile header");
return -1;
}
for (i=0; i<codetree_N(treein); i++) {
unsigned int stars[quadin->dimquads];
int ind = codetree_get_permuted(treein, i);
if (quadfile_get_stars(quadin, ind, stars)) {
ERROR("Failed to read quad entry");
return -1;
}
if (quadfile_write_quad(quadout, stars)) {
ERROR("Failed to write quad entry");
return -1;
}
}
if (quadfile_fix_header(quadout)) {
ERROR("Failed to fix quadfile header");
return -1;
}
treeout = codetree_new();
treeout->tree = malloc(sizeof(kdtree_t));
memcpy(treeout->tree, treein->tree, sizeof(kdtree_t));
treeout->tree->perm = NULL;
hdr = codetree_header(treeout);
fits_copy_header(qinhdr, hdr, "HEALPIX");
fits_copy_header(qinhdr, hdr, "HPNSIDE");
fits_copy_header(qinhdr, hdr, "ALLSKY");
boilerplate_add_fits_headers(hdr);
qfits_header_add(hdr, "HISTORY", "This file was created by the program \"unpermute-quads\".", NULL, NULL);
qfits_header_add(hdr, "HISTORY", "unpermute-quads command line:", NULL, NULL);
fits_add_args(hdr, args, argc);
qfits_header_add(hdr, "HISTORY", "(end of unpermute-quads command line)", NULL, NULL);
qfits_header_add(hdr, "HISTORY", "** unpermute-quads: history from input ckdt:", NULL, NULL);
fits_copy_all_headers(codehdr, hdr, "HISTORY");
qfits_header_add(hdr, "HISTORY", "** unpermute-quads end of history from input ckdt.", NULL, NULL);
qfits_header_add(hdr, "COMMENT", "** unpermute-quads: comments from input ckdt:", NULL, NULL);
fits_copy_all_headers(codehdr, hdr, "COMMENT");
qfits_header_add(hdr, "COMMENT", "** unpermute-quads: end of comments from input ckdt.", NULL, NULL);
fits_copy_header(codehdr, hdr, "CXDX");
fits_copy_header(codehdr, hdr, "CXDXLT1");
fits_copy_header(codehdr, hdr, "CIRCLE");
*p_treeout = treeout;
return 0;
}
