nomad_fits* nomad_fits_open_for_writing(char* fn) {
nomad_fits* cat;
qfits_header* hdr;
cat = fitstable_open_for_writing(fn);
if (!cat)
return NULL;
add_columns(cat, TRUE);
hdr = fitstable_get_primary_header(cat);
qfits_header_add(hdr, "NOMAD", "T", "This is a NOMAD 1.0 catalog.", NULL);
qfits_header_add(hdr, "AN_FILE", AN_FILETYPE_NOMAD, "Astrometry.net file type", NULL);
qfits_header_add(hdr, "COMMENT", "The FLAGS variable is composed of 15 boolean values packed into 2 bytes.", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " Byte 0:", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x80: UBBIT / usnob_fail", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x40: TMBIT / twomass_fail", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x20: TYBIT / tycho_astrometry", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x10: XRBIT / alt_radec", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x08: IUCBIT / alt_ucac", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x04: ITYBIT / alt_tycho", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x02: OMAGBIT / blue_o", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x01: EMAGBIT / red_e", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " Byte 1:", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x80: TMONLY / twomass_only", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x40: HIPAST / hipp_astrometry", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x20: SPIKE / diffraction", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x10: TYCONF / confusion", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x08: BSCONF / bright_confusion", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x04: BSART / bright_artifact", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x02: USEME / standard", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " 0x01: unused", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " Note that the ITMBIT and EXCAT bits were not set for any entry in the ", NULL, NULL);
qfits_header_add(hdr, "COMMENT", " released NOMAD catalog, so were not included here.", NULL, NULL);
return cat;
}
matchfile* matchfile_open_for_writing(char* fn) {
matchfile* mf;
qfits_header* hdr;
mf = fitstable_open_for_writing(fn);
if (!mf)
return NULL;
add_columns(mf, TRUE);
hdr = fitstable_get_primary_header(mf);
qfits_header_add(hdr, "AN_FILE", AN_FILETYPE_MATCH, "Astrometry.net file type", NULL);
return mf;
}
int uniformize_catalog(fitstable_t* intable, fitstable_t* outtable,
const char* racol, const char* deccol,
const char* sortcol, anbool sort_ascending,
double sort_min_cut,
// ? Or do this cut in a separate process?
int bighp, int bignside,
int nmargin,
// uniformization nside.
int Nside,
double dedup_radius,
int nsweeps,
char** args, int argc) {
anbool allsky;
intmap_t* starlists;
int NHP;
anbool dense = FALSE;
double dedupr2 = 0.0;
tfits_type dubl;
int N;
int* inorder = NULL;
int* outorder = NULL;
int outi;
double *ra = NULL, *dec = NULL;
il* myhps = NULL;
int i,j,k;
int nkeep = nsweeps;
int noob = 0;
int ndup = 0;
struct oh_token token;
int* npersweep = NULL;
qfits_header* outhdr = NULL;
double *sortval = NULL;
if (bignside == 0)
bignside = 1;
allsky = (bighp == -1);
if (Nside % bignside) {
ERROR("Fine healpixelization Nside must be a multiple of the coarse healpixelization Nside");
return -1;
}
if (Nside > HP_MAX_INT_NSIDE) {
ERROR("Error: maximum healpix Nside = %i", HP_MAX_INT_NSIDE);
return -1;
}
NHP = 12 * Nside * Nside;
logverb("Healpix Nside: %i, # healpixes on the whole sky: %i\n", Nside, NHP);
if (!allsky) {
logverb("Creating index for healpix %i, nside %i\n", bighp, bignside);
logverb("Number of healpixes: %i\n", ((Nside/bignside)*(Nside/bignside)));
}
logverb("Healpix side length: %g arcmin.\n", healpix_side_length_arcmin(Nside));
dubl = fitscolumn_double_type();
if (!racol)
racol = "RA";
ra = fitstable_read_column(intable, racol, dubl);
if (!ra) {
ERROR("Failed to find RA column (%s) in table", racol);
return -1;
}
if (!deccol)
deccol = "DEC";
dec = fitstable_read_column(intable, deccol, dubl);
if (!dec) {
ERROR("Failed to find DEC column (%s) in table", deccol);
free(ra);
return -1;
}
N = fitstable_nrows(intable);
logverb("Have %i objects\n", N);
// FIXME -- argsort and seek around the input table, and append to
// starlists in order; OR read from the input table in sequence and
// sort in the starlists?
if (sortcol) {
logverb("Sorting by %s...\n", sortcol);
sortval = fitstable_read_column(intable, sortcol, dubl);
if (!sortval) {
ERROR("Failed to read sorting column \"%s\"", sortcol);
free(ra);
free(dec);
return -1;
}
inorder = permuted_sort(sortval, sizeof(double),
sort_ascending ? compare_doubles_asc : compare_doubles_desc,
NULL, N);
if (sort_min_cut > -HUGE_VAL) {
logverb("Cutting to %s > %g...\n", sortcol, sort_min_cut);
// Cut objects with sortval < sort_min_cut.
if (sort_ascending) {
// skipped objects are at the front -- find the first obj
// to keep
for (i=0; i<N; i++)
if (sortval[inorder[i]] > sort_min_cut)
break;
// move the "inorder" indices down.
if (i)
memmove(inorder, inorder+i, (N-i)*sizeof(int));
N -= i;
} else {
// skipped objects are at the end -- find the last obj to keep.
for (i=N-1; i>=0; i--)
if (sortval[inorder[i]] > sort_min_cut)
break;
N = i+1;
}
logverb("Cut to %i objects\n", N);
}
//free(sortval);
}
token.nside = bignside;
token.finenside = Nside;
token.hp = bighp;
if (!allsky && nmargin) {
int bigbighp, bighpx, bighpy;
//int ninside;
il* seeds = il_new(256);
logverb("Finding healpixes in range...\n");
healpix_decompose_xy(bighp, &bigbighp, &bighpx, &bighpy, bignside);
//ninside = (Nside/bignside)*(Nside/bignside);
// Prime the queue with the fine healpixes that are on the
// boundary of the big healpix.
for (i=0; i<((Nside / bignside) - 1); i++) {
// add (i,0), (i,max), (0,i), and (0,max) healpixes
int xx = i + bighpx * (Nside / bignside);
int yy = i + bighpy * (Nside / bignside);
int y0 = bighpy * (Nside / bignside);
// -1 prevents us from double-adding the corners.
int y1 =(1 + bighpy)* (Nside / bignside) - 1;
int x0 = bighpx * (Nside / bignside);
int x1 =(1 + bighpx)* (Nside / bignside) - 1;
assert(xx < Nside);
assert(yy < Nside);
assert(x0 < Nside);
assert(x1 < Nside);
assert(y0 < Nside);
assert(y1 < Nside);
il_append(seeds, healpix_compose_xy(bigbighp, xx, y0, Nside));
il_append(seeds, healpix_compose_xy(bigbighp, xx, y1, Nside));
il_append(seeds, healpix_compose_xy(bigbighp, x0, yy, Nside));
il_append(seeds, healpix_compose_xy(bigbighp, x1, yy, Nside));
}
logmsg("Number of boundary healpixes: %zu (Nside/bignside = %i)\n", il_size(seeds), Nside/bignside);
myhps = healpix_region_search(-1, seeds, Nside, NULL, NULL,
outside_healpix, &token, nmargin);
logmsg("Number of margin healpixes: %zu\n", il_size(myhps));
il_free(seeds);
il_sort(myhps, TRUE);
// DEBUG
il_check_consistency(myhps);
il_check_sorted_ascending(myhps, TRUE);
}
dedupr2 = arcsec2distsq(dedup_radius);
starlists = intmap_new(sizeof(int32_t), nkeep, 0, dense);
logverb("Placing stars in grid cells...\n");
for (i=0; i<N; i++) {
int hp;
bl* lst;
int32_t j32;
anbool oob;
if (inorder) {
j = inorder[i];
//printf("Placing star %i (%i): sort value %s = %g, RA,Dec=%g,%g\n", i, j, sortcol, sortval[j], ra[j], dec[j]);
} else
j = i;
hp = radecdegtohealpix(ra[j], dec[j], Nside);
//printf("HP %i\n", hp);
// in bounds?
oob = FALSE;
if (myhps) {
oob = (outside_healpix(hp, &token) && !il_sorted_contains(myhps, hp));
} else if (!allsky) {
oob = (outside_healpix(hp, &token));
}
if (oob) {
//printf("out of bounds.\n");
noob++;
continue;
}
lst = intmap_find(starlists, hp, TRUE);
/*
printf("list has %i existing entries.\n", bl_size(lst));
for (k=0; k<bl_size(lst); k++) {
bl_get(lst, k, &j32);
printf(" %i: index %i, %s = %g\n", k, j32, sortcol, sortval[j32]);
}
*/
// is this list full?
if (nkeep && (bl_size(lst) >= nkeep)) {
// Here we assume we're working in sorted order: once the list is full we're done.
//printf("Skipping: list is full.\n");
continue;
}
if ((dedupr2 > 0.0) &&
is_duplicate(hp, ra[j], dec[j], Nside, starlists, ra, dec, dedupr2)) {
//printf("Skipping: duplicate\n");
ndup++;
continue;
}
// Add the new star (by index)
j32 = j;
bl_append(lst, &j32);
}
logverb("%i outside the healpix\n", noob);
logverb("%i duplicates\n", ndup);
il_free(myhps);
myhps = NULL;
free(inorder);
inorder = NULL;
free(ra);
ra = NULL;
free(dec);
dec = NULL;
outorder = malloc(N * sizeof(int));
outi = 0;
npersweep = calloc(nsweeps, sizeof(int));
for (k=0; k<nsweeps; k++) {
int starti = outi;
int32_t j32;
for (i=0;; i++) {
bl* lst;
int hp;
if (!intmap_get_entry(starlists, i, &hp, &lst))
break;
if (bl_size(lst) <= k)
continue;
bl_get(lst, k, &j32);
outorder[outi] = j32;
//printf("sweep %i, cell #%i, hp %i, star %i, %s = %g\n", k, i, hp, j32, sortcol, sortval[j32]);
outi++;
}
logmsg("Sweep %i: %i stars\n", k+1, outi - starti);
npersweep[k] = outi - starti;
if (sortcol) {
// Re-sort within this sweep.
permuted_sort(sortval, sizeof(double),
sort_ascending ? compare_doubles_asc : compare_doubles_desc,
outorder + starti, npersweep[k]);
/*
for (i=0; i<npersweep[k]; i++) {
printf(" within sweep %i: star %i, j=%i, %s=%g\n",
k, i, outorder[starti + i], sortcol, sortval[outorder[starti + i]]);
}
*/
}
}
intmap_free(starlists);
starlists = NULL;
//////
free(sortval);
sortval = NULL;
logmsg("Total: %i stars\n", outi);
N = outi;
outhdr = fitstable_get_primary_header(outtable);
if (allsky)
qfits_header_add(outhdr, "ALLSKY", "T", "All-sky catalog.", NULL);
BOILERPLATE_ADD_FITS_HEADERS(outhdr);
qfits_header_add(outhdr, "HISTORY", "This file was generated by the command-line:", NULL, NULL);
fits_add_args(outhdr, args, argc);
qfits_header_add(outhdr, "HISTORY", "(end of command line)", NULL, NULL);
fits_add_long_history(outhdr, "uniformize-catalog args:");
fits_add_long_history(outhdr, " RA,Dec columns: %s,%s", racol, deccol);
fits_add_long_history(outhdr, " sort column: %s", sortcol);
fits_add_long_history(outhdr, " sort direction: %s", sort_ascending ? "ascending" : "descending");
if (sort_ascending)
fits_add_long_history(outhdr, " (ie, for mag-like sort columns)");
else
fits_add_long_history(outhdr, " (ie, for flux-like sort columns)");
fits_add_long_history(outhdr, " uniformization nside: %i", Nside);
fits_add_long_history(outhdr, " (ie, side length ~ %g arcmin)", healpix_side_length_arcmin(Nside));
fits_add_long_history(outhdr, " deduplication scale: %g arcsec", dedup_radius);
fits_add_long_history(outhdr, " number of sweeps: %i", nsweeps);
fits_header_add_int(outhdr, "NSTARS", N, "Number of stars.");
fits_header_add_int(outhdr, "HEALPIX", bighp, "Healpix covered by this catalog, with Nside=HPNSIDE");
fits_header_add_int(outhdr, "HPNSIDE", bignside, "Nside of HEALPIX.");
fits_header_add_int(outhdr, "CUTNSIDE", Nside, "uniformization scale (healpix nside)");
fits_header_add_int(outhdr, "CUTMARG", nmargin, "margin size, in healpixels");
//qfits_header_add(outhdr, "CUTBAND", cutband, "band on which the cut was made", NULL);
fits_header_add_double(outhdr, "CUTDEDUP", dedup_radius, "deduplication radius [arcsec]");
fits_header_add_int(outhdr, "CUTNSWEP", nsweeps, "number of sweeps");
//fits_header_add_double(outhdr, "CUTMINMG", minmag, "minimum magnitude");
//fits_header_add_double(outhdr, "CUTMAXMG", maxmag, "maximum magnitude");
for (k=0; k<nsweeps; k++) {
char key[64];
sprintf(key, "SWEEP%i", (k+1));
fits_header_add_int(outhdr, key, npersweep[k], "# stars added");
}
free(npersweep);
if (fitstable_write_primary_header(outtable)) {
ERROR("Failed to write primary header");
return -1;
}
// Write output.
fitstable_add_fits_columns_as_struct2(intable, outtable);
if (fitstable_write_header(outtable)) {
ERROR("Failed to write output table header");
return -1;
}
logmsg("Writing output...\n");
logverb("Row size: %i\n", fitstable_row_size(intable));
if (fitstable_copy_rows_data(intable, outorder, N, outtable)) {
ERROR("Failed to copy rows from input table to output");
return -1;
}
if (fitstable_fix_header(outtable)) {
ERROR("Failed to fix output table header");
return -1;
}
free(outorder);
return 0;
}
startree_t* startree_build(fitstable_t* intable,
const char* racol, const char* deccol,
// keep RA,Dec in the tag-along table?
//anbool keep_radec,
// KDT_DATA_*, KDT_TREE_*
int datatype, int treetype,
// KD_BUILD_*
int buildopts,
int Nleaf,
char** args, int argc) {
double* ra = NULL;
double* dec = NULL;
double* xyz = NULL;
int N;
startree_t* starkd = NULL;
int tt;
int d;
double low[3];
double high[3];
qfits_header* hdr;
qfits_header* inhdr;
int i;
if (!racol)
racol = "RA";
if (!deccol)
deccol = "DEC";
if (!datatype)
datatype = KDT_DATA_U32;
if (!treetype)
treetype = KDT_TREE_U32;
if (!buildopts)
buildopts = KD_BUILD_SPLIT;
if (!Nleaf)
Nleaf = 25;
ra = fitstable_read_column(intable, racol, TFITS_BIN_TYPE_D);
if (!ra) {
ERROR("Failed to read RA from column %s", racol);
goto bailout;
}
dec = fitstable_read_column(intable, deccol, TFITS_BIN_TYPE_D);
if (!dec) {
ERROR("Failed to read RA from column %s", racol);
goto bailout;
}
N = fitstable_nrows(intable);
xyz = malloc(N * 3 * sizeof(double));
if (!xyz) {
SYSERROR("Failed to malloc xyz array to build startree");
goto bailout;
}
radecdeg2xyzarrmany(ra, dec, xyz, N);
free(ra);
ra = NULL;
free(dec);
dec = NULL;
starkd = startree_new();
if (!starkd) {
ERROR("Failed to allocate startree");
goto bailout;
}
tt = kdtree_kdtypes_to_treetype(KDT_EXT_DOUBLE, treetype, datatype);
starkd->tree = kdtree_new(N, 3, Nleaf);
for (d=0; d<3; d++) {
low[d] = -1.0;
high[d] = 1.0;
}
kdtree_set_limits(starkd->tree, low, high);
logverb("Building star kdtree...\n");
starkd->tree = kdtree_build(starkd->tree, xyz, N, 3, Nleaf, tt, buildopts);
if (!starkd->tree) {
ERROR("Failed to build star kdtree");
startree_close(starkd);
starkd = NULL;
goto bailout;
}
starkd->tree->name = strdup(STARTREE_NAME);
inhdr = fitstable_get_primary_header(intable);
hdr = startree_header(starkd);
an_fits_copy_header(inhdr, hdr, "HEALPIX");
an_fits_copy_header(inhdr, hdr, "HPNSIDE");
an_fits_copy_header(inhdr, hdr, "ALLSKY");
an_fits_copy_header(inhdr, hdr, "JITTER");
an_fits_copy_header(inhdr, hdr, "CUTNSIDE");
an_fits_copy_header(inhdr, hdr, "CUTMARG");
an_fits_copy_header(inhdr, hdr, "CUTDEDUP");
an_fits_copy_header(inhdr, hdr, "CUTNSWEP");
//fits_copy_header(inhdr, hdr, "CUTBAND");
//fits_copy_header(inhdr, hdr, "CUTMINMG");
//fits_copy_header(inhdr, hdr, "CUTMAXMG");
BOILERPLATE_ADD_FITS_HEADERS(hdr);
qfits_header_add(hdr, "HISTORY", "This file was created by the command-line:", NULL, NULL);
fits_add_args(hdr, args, argc);
qfits_header_add(hdr, "HISTORY", "(end of command line)", NULL, NULL);
qfits_header_add(hdr, "HISTORY", "** History entries copied from the input file:", NULL, NULL);
fits_copy_all_headers(inhdr, hdr, "HISTORY");
qfits_header_add(hdr, "HISTORY", "** End of history entries.", NULL, NULL);
for (i=1;; i++) {
char key[16];
int n;
sprintf(key, "SWEEP%i", i);
n = qfits_header_getint(inhdr, key, -1);
if (n == -1)
break;
an_fits_copy_header(inhdr, hdr, key);
}
bailout:
if (ra)
free(ra);
if (dec)
free(dec);
if (xyz)
free(xyz);
return starkd;
}
int
loadphotondata(char *filename, char *passfile) {
fitstable_t* tab;
qfits_header* hdr;
tfits_type flt = fitscolumn_float_type(), chtype = fitscolumn_char_type(), dbltype=fitscolumn_double_type();
float *localphotondata[NPHOTON_LOADDATA], *galdisrsp=NULL, *isodisrsp=NULL;
double *localphotontime;
char *conversion_type=NULL;
char buffer[255];
int i, j, ncurr, ndiff, nresp=0, conv_type, psf_cnt, psf_ind;
double rmax2, ehold, rad, r2hold;
if ( (tab = fitstable_open(filename))==NULL) {
printf("# Cannot open %s in loadphotondata() %s:%d\n",filename,__FILE__,__LINE__);
return -1;
}
hdr = fitstable_get_primary_header(tab);
hdr = fitstable_get_header(tab);
ncurr = fitstable_nrows(tab);
if (debug) printf("# filename= %s ncurr= %d\n",filename,ncurr);
/* load in the energy, theta, ra and dec */
for (i=0; i<NPHOTON_LOADDATA; i++) {
if ( (localphotondata[i]=
(float *) fitstable_read_column_array(tab,
photon_colname[i], flt))==NULL) {
printf("# vector for %s is NULL in loadphotondata() %s:%d\n",photon_colname[i],__FILE__,__LINE__);
for (j=0; j<i; j++) {
SAFEFREE( localphotondata[i]);
}
fitstable_close(tab);
return -1;
}
}
/* load in conversion type */
if ( (conversion_type= (char *) fitstable_read_column(tab, "CONVERSION_TYPE", chtype))==NULL) {
printf("# array for conversion_type is NULL in loadphotondata() %s:%d\n",__FILE__,__LINE__);
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE( localphotondata[i]);
}
fitstable_close(tab);
return -1;
}
/* load in photon arrival time */
if ( (localphotontime= (double *) fitstable_read_column(tab, "TIME", dbltype))==NULL) {
printf("# array for localphotontime is NULL in loadphotondata() %s:%d\n",__FILE__,__LINE__);
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE( localphotondata[i]);
}
SAFEFREE( conversion_type);
fitstable_close(tab);
return -1;
}
/* load in the diffuse response functions that match the passfile */
ndiff = qfits_header_getint(hdr, "NDIFRSP",-1);
for (i=0; i<ndiff; i++) {
sprintf(buffer,"DIFRSP%d",i);
char *respname = qfits_header_getstr(hdr, buffer);
if (debug) printf("# %d %s = %s\n",i,buffer,respname);
if (strcasestr(respname,passfile)) {
if (strcasestr(respname,"gll")) {
if (debug) printf("# galactic is %s\n",buffer);
if ( (galdisrsp=
(float *) fitstable_read_column_array(tab,
buffer, flt))==NULL) {
printf("# array for %s is NULL in loadphotondata() %s:%d\n",buffer,__FILE__,__LINE__);
for (j=0; j<i; j++) {
SAFEFREE( localphotondata[i]);
}
SAFEFREE( conversion_type);
SAFEFREE(localphotontime);
SAFEFREE( galdisrsp);
SAFEFREE( isodisrsp);
fitstable_close(tab);
return -1;
}
nresp++;
}
if (strcasestr(respname,"iso")) {
if (debug) printf("# iso is %s\n",buffer);
if ( (isodisrsp=
(float *) fitstable_read_column_array(tab,
buffer, flt))==NULL) {
printf("# array for %s is NULL in loadphotondata() %s:%d\n",buffer,__FILE__,__LINE__);
for (j=0; j<i; j++) {
SAFEFREE( localphotondata[i]);
}
SAFEFREE( conversion_type);
SAFEFREE(localphotontime);
SAFEFREE( galdisrsp);
SAFEFREE( isodisrsp);
fitstable_close(tab);
return -1;
}
nresp++;
}
}
}
if (nresp<2) {
printf("Could not find the matching response functions in loadphotondata() %s:%d.\n",__FILE__,__LINE__);
return -1;
}
if (alloc_globals(ncurr+ntot)) {
SAFEFREE(localphotontime);
SAFEFREE(conversion_type);
SAFEFREE(data);
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE(localphotondata[i]);
}
return -1;
}
fitstable_close(tab);
j=0;
for (i=0; i<ncurr; i++) {
ehold=localphotondata[ENERGY][i];
if (ehold>=e0 && ehold<=e1) {
double ra, dec;
__sincospi((ra=localphotondata[RA][i])/180.0,data+d*(j+ntot)+1,data+d*(j+ntot));
__sincospi((dec=localphotondata[DEC][i])/180.0,data+d*(j+ntot)+2,&rad);
data[d*(ntot+j)]*=rad;
data[d*(ntot+j)+1]*=rad;
if (ehold<energy_min) energy_min=ehold;
/* calculate RMAX2 for this photon */
conv_type=conversion_type[i];
rmax2=photondata[COSTHETA][j+ntot]=cos(localphotondata[THETA][i]*M_PI/180.0);
if (debug>3) printf("# costheta= %g\n",rmax2);
#if 1
/* fast way --- evenly spaced in log energy and costheta -- no interpolation */
// rmax2=psfds.psfdata[conv_type][RMAX2][(int) ((rmax2-psfds.mumin)/psfds.mustep)*psfds.nE + (int) ((log10(ehold)-psfds.lemin)/psfds.lestep)];
rmax2=rmax2_funk(psfds,conv_type,rmax2,ehold);
#else
/* slow way --- find the right bin -- no interpolation */
for (psf_cnt=0; psf_cnt<psfds.nE; psf_cnt++) {
if (ehold>psfds.psfdata[conv_type][ENERG_LO][psf_cnt] && ehold<=psfds.psfdata[conv_type][ENERG_HI][psf_cnt]) {
psf_ind=psf_cnt;
break;
}
}
for (psf_cnt=0; psf_cnt<psfds.nMu; psf_cnt++) {
if (rmax2>psfds.psfdata[conv_type][CTHETA_LO][psf_cnt] && rmax2<=psfds.psfdata[conv_type][CTHETA_HI][psf_cnt]) {
psf_ind+=psf_cnt*psfds.nE;
break;
}
}
rmax2=psfds.psfdata[conv_type][RMAX2][psf_ind];
#endif
if (debug>3) printf("# rmax2= %g\n",rmax2);
if (conv_type) {
/* back conversion */
r2hold=SPE_squared_back(ehold)*rmax2;
data[d*(ntot+j)+3]=-(r2hold>4 ? 4 : r2hold);
} else {
/* front conversion */
r2hold=SPE_squared_front(ehold)*rmax2;
data[d*(ntot+j)+3]=(r2hold>4 ? 4 : r2hold);
}
if (debug>3) printf("# %g rmax2= %g %g %g\n",ehold,data[d*(ntot+j)+3],SPE_squared_front(ehold),localphotondata[THETA][i]);
photondata[ENERGY][j+ntot]=ehold;
photondata[DIFRSP_GAL][j+ntot]=galdisrsp[i];
photondata[DIFRSP_ISO][j+ntot]=isodisrsp[i];
r2hold=aeffds.aeffdata[conv_type][AEFF_EFF_AREA]
[(int) ((photondata[COSTHETA][j+ntot]-aeffds.mumin)/aeffds.mustep)*aeffds.nE + (int) ((log10(ehold)-aeffds.lemin)/aeffds.lestep)];
if (r2hold<EFFAREAMIN) r2hold=EFFAREAMIN;
photondata[EFFAREA][j+ntot]=r2hold;
/* calculate the effective area integral */
r2hold=calcefft(ra,dec,ehold,&aeffds,<cubeds);
if (r2hold<EFFAREATMIN) r2hold=EFFAREATMIN;
photondata[EFFAREAT][j+ntot]=r2hold;
photontime[j+ntot]=localphotontime[i];
j++;
}
}
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE(localphotondata[i]);
}
SAFEFREE( galdisrsp);
SAFEFREE( isodisrsp);
SAFEFREE(conversion_type);
SAFEFREE(localphotontime);
ntot+=j;
if (debug) printf("# ntot= %d j= %d\n",ntot,j);
if (j!=ncurr) {
if (alloc_globals(ncurr+ntot)) {
SAFEFREE(data);
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE(localphotondata[i]);
}
return -1;
}
}
return 0;
}
int
loadpsffile(char *passfile, PSF_DATA_STRUCT *psfds, float f_cutoff) {
char filename[2][255]={"front.fits","back.fits"};
char buffer[255];
int i, j, f, ncurr;
float *psfscale;
fitstable_t* tab;
qfits_header* hdr;
tfits_type flt = fitscolumn_float_type();
float ***psfdata;
int nE, nMu;
if ( !(psfdata=(float ***) calloc(2,sizeof(float **))) ) {
printf("# Cannot allocate psfdata in loadpsffile() %s:%d\n",__FILE__,__LINE__);
return -1;
}
if ( !(psfdata[0]=(float **) calloc(NPSF_DATA,sizeof(float *))) ) {
printf("# Cannot allocate psfdata[0] in loadpsffile() %s:%d\n",__FILE__,__LINE__);
return -1;
}
if ( !(psfdata[1]=(float **) calloc(NPSF_DATA,sizeof(float *))) ) {
printf("# Cannot allocate psfdata[1] in loadpsffile() %s:%d\n",__FILE__,__LINE__);
return -1;
}
psfds->psfdata=psfdata;
psfds->f_cutoff=f_cutoff;
if (debug>2) {
printf(" ");
for (i=0;i<NPSF_DATA;i++) {
printf(" %10s",psf_colname[i]);
}
printf("\n");
}
for (f=0;f<2;f++) {
sprintf(buffer,"psf_%s_%s",passfile,filename[f]);
printf("# loading PSF file: %s\n",buffer);
if ( (tab = fitstable_open(buffer))==NULL) {
printf("# Cannot open %s in loadpsffile() %s:%d\n",buffer,__FILE__,__LINE__);
return -1;
}
hdr = fitstable_get_primary_header(tab);
ncurr = fitstable_nrows(tab);
for (i=ENERG_LO;i<=GTAIL;i++) {
if ( (psfdata[f][i]= (float *) fitstable_read_column_array(tab, psf_colname[i], flt))==NULL) {
printf("# Cannot file column %s (file=%s) in loadpsffile() %s:%d\n",psf_colname[i],buffer,__FILE__,__LINE__);
fitstable_close(tab);
return -1;
}
}
int D = fitstable_get_array_size(tab, psf_colname[NTAIL]);
psfds->nE = nE = fitstable_get_array_size(tab, psf_colname[ENERG_LO]);
psfds->nMu = nMu = fitstable_get_array_size(tab, psf_colname[CTHETA_LO]);
for (i=FCORE;i<=RMAX2;i++) {
if (!(psfdata[f][i]=(float *) calloc(D,sizeof(float)))) {
printf("# Cannot allocate psfdata[%d][%d] in loadpsffile() %s:%d\n",f,i,__FILE__,__LINE__);
return -1;
}
}
for (j=0;j<D;j++) {
if (debug>2) printf("[%2d] %2d",f,j);
score_g=psfdata[f][SCORE][j];
gcore_g=psfdata[f][GCORE][j];
stail_g=psfdata[f][STAIL][j];
gtail_g=psfdata[f][GTAIL][j];
psfdata[f][FACTORTAIL][j]=factortail_g=gtail_g*stail_g*stail_g*2;
psfdata[f][FACTORCORE][j]=factorcore_g=gcore_g*score_g*score_g*2;
fcore_g=stail_g/score_g;
psfdata[f][FCORE][j]=fcore_g=1/(1+psfdata[f][NTAIL][j]*fcore_g*fcore_g);
psfdata[f][NORMCORE][j]=fcore_g/(2*M_PI*score_g*score_g)*(1-1/gcore_g);
psfdata[f][NORMTAIL][j]=(1-fcore_g)/(2*M_PI*stail_g*stail_g)*(1-1/gtail_g); ;
psfdata[f][RMAX2][j]=root(f_cutoff);
if (debug>2) {
for (i=0;i<2;i++) {
printf(" %10g",log10(psfdata[f][i][j%nE]));
}
for (i=2;i<4;i++) {
printf(" %10g",psfdata[f][i][(j/nE)%nMu]);
}
for (i=4;i<NPSF_DATA;i++) {
printf(" %10g",psfdata[f][i][j]);
}
printf(" %10g\n",ickingfunk(psfdata[f][RMAX2][j]));
}
}
if (f==0) {
psfds->lemin=log10(psfdata[f][ENERG_LO][0]);
psfds->lestep=log10(psfdata[f][ENERG_HI][0])-log10(psfdata[f][ENERG_LO][0]);
psfds->mumin=psfdata[f][CTHETA_LO][0];
psfds->mustep=psfdata[f][CTHETA_HI][0]-psfdata[f][CTHETA_LO][0];
fitstable_open_next_extension(tab);
hdr = fitstable_get_primary_header(tab);
ncurr = fitstable_nrows(tab);
if ( (psfscale= (float *) fitstable_read_column_array(tab, "PSFSCALE", flt))==NULL) {
printf("# Cannot read PSFSCALE (file=%s) in loadpsffile() %s:%d\n",buffer,__FILE__,__LINE__);
fitstable_close(tab);
return -1;
}
c0front2=psfscale[0]*psfscale[0];
c1front2=psfscale[1]*psfscale[1];
c0back2=psfscale[2]*psfscale[2];
c1back2=psfscale[3]*psfscale[3];
minus2beta=2*psfscale[4];
if (debug>1) { printf("# %g %g %g %g %g\n",c0front2,c1front2,c0back2,c1back2,minus2beta); }
}
fitstable_close(tab);
}
free((void *) psfscale);
return 0;
}
