int resort_xylist(const char* infn, const char* outfn, const char* fluxcol, const char* backcol, anbool ascending) { FILE* fin = NULL; FILE* fout = NULL; double *flux = NULL, *back = NULL; int *perm1 = NULL, *perm2 = NULL; anbool *used = NULL; int start, size, nextens, ext; int (*compare)(const void*, const void*); fitstable_t* tab = NULL; anqfits_t* anq = NULL; if (ascending) compare = compare_doubles_asc; else compare = compare_doubles_desc; if (!fluxcol) fluxcol = "FLUX"; if (!backcol) backcol = "BACKGROUND"; fin = fopen(infn, "rb"); if (!fin) { SYSERROR("Failed to open input file %s", infn); return -1; } fout = fopen(outfn, "wb"); if (!fout) { SYSERROR("Failed to open output file %s", outfn); goto bailout; } // copy the main header exactly. anq = anqfits_open(infn); if (!anq) { ERROR("Failed to open file \"%s\"", infn); goto bailout; } start = anqfits_header_start(anq, 0); size = anqfits_header_size (anq, 0); if (pipe_file_offset(fin, start, size, fout)) { ERROR("Failed to copy primary FITS header."); goto bailout; } nextens = anqfits_n_ext(anq); tab = fitstable_open(infn); if (!tab) { ERROR("Failed to open FITS table in file %s", infn); goto bailout; } for (ext=1; ext<nextens; ext++) { int hdrstart, hdrsize, datstart; int i, N; int rowsize; hdrstart = anqfits_header_start(anq, ext); hdrsize = anqfits_header_size (anq, ext); datstart = anqfits_data_start (anq, ext); if (!anqfits_is_table(anq, ext)) { ERROR("Extention %i isn't a table. Skipping", ext); continue; } // Copy the header as-is. if (pipe_file_offset(fin, hdrstart, hdrsize, fout)) { ERROR("Failed to copy the header of extension %i", ext); goto bailout; } if (fitstable_read_extension(tab, ext)) { ERROR("Failed to read FITS table from extension %i", ext); goto bailout; } rowsize = fitstable_row_size(tab); // read FLUX column as doubles. flux = fitstable_read_column(tab, fluxcol, TFITS_BIN_TYPE_D); if (!flux) { ERROR("Failed to read FLUX column from extension %i", ext); goto bailout; } // BACKGROUND back = fitstable_read_column(tab, backcol, TFITS_BIN_TYPE_D); if (!back) { ERROR("Failed to read BACKGROUND column from extension %i", ext); goto bailout; } debug("First 10 rows of input table:\n"); for (i=0; i<10; i++) debug("flux %g, background %g\n", flux[i], back[i]); N = fitstable_nrows(tab); // set back = flux + back (ie, non-background-subtracted flux) for (i=0; i<N; i++) back[i] += flux[i]; // Sort by flux... perm1 = permuted_sort(flux, sizeof(double), compare, NULL, N); // Sort by non-background-subtracted flux... perm2 = permuted_sort(back, sizeof(double), compare, NULL, N); used = malloc(N * sizeof(anbool)); memset(used, 0, N * sizeof(anbool)); // Check sort... for (i=0; i<N-1; i++) { if (ascending) { assert(flux[perm1[i]] <= flux[perm1[i+1]]); assert(back[perm2[i]] <= back[perm2[i+1]]); } else { assert(flux[perm1[i]] >= flux[perm1[i+1]]); assert(back[perm2[i]] >= back[perm2[i+1]]); } } for (i=0; i<N; i++) { int j; int inds[] = { perm1[i], perm2[i] }; for (j=0; j<2; j++) { int index = inds[j]; assert(index < N); if (used[index]) continue; used[index] = TRUE; debug("adding index %i: %s %g\n", index, j==0 ? "flux" : "bgsub", j==0 ? flux[index] : back[index]); if (pipe_file_offset(fin, datstart + index * rowsize, rowsize, fout)) { ERROR("Failed to copy row %i", index); goto bailout; } } } for (i=0; i<N; i++) assert(used[i]); if (fits_pad_file(fout)) { ERROR("Failed to add padding to extension %i", ext); goto bailout; } free(flux); flux = NULL; free(back); back = NULL; free(perm1); perm1 = NULL; free(perm2); perm2 = NULL; free(used); used = NULL; } fitstable_close(tab); tab = NULL; if (fclose(fout)) { SYSERROR("Failed to close output file %s", outfn); return -1; } fclose(fin); return 0; bailout: if (tab) fitstable_close(tab); if (fout) fclose(fout); if (fin) fclose(fin); free(flux); free(back); free(perm1); free(perm2); free(used); return -1; }
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; }
int loadltcube(char *filename, LTCUBE_DATA_STRUCT *ltcubeds) { fitstable_t* tab; qfits_header* hdr; tfits_type flt = fitscolumn_float_type(); if ( (tab = fitstable_open(filename))==NULL) { printf("# Cannot open %s in loadltcube() %s:%d\n",filename,__FILE__,__LINE__); return -1; } fitstable_open_next_extension(tab); hdr = fitstable_get_header(tab); strncpy(ltcubeds->ordering,qfits_header_getstr(hdr, "ORDERING"),sizeof(ltcubeds->ordering)); strncpy(ltcubeds->coordsys,qfits_header_getstr(hdr, "COORDSYS"),sizeof(ltcubeds->coordsys)); strncpy(ltcubeds->thetabin,qfits_header_getstr(hdr, "THETABIN"),sizeof(ltcubeds->thetabin)); ltcubeds->nside=qfits_header_getint(hdr,"NSIDE",-1); ltcubeds->firstpix=qfits_header_getint(hdr,"FIRSTPIX",-1); ltcubeds->lastpix=qfits_header_getint(hdr,"LASTPIX",-1); if (debug) { printf("ORDERING= %s; COORDSYS= %s; THETABIN= %s; NSIDE= %d FIRSTPIX= %d LASTPIX= %d\n", ltcubeds->ordering, ltcubeds->coordsys, ltcubeds->thetabin, ltcubeds->nside, ltcubeds->firstpix, ltcubeds->lastpix); } /* load in livetime cube data */ ltcubeds->nMu = fitstable_get_array_size(tab, "COSBINS"); ltcubeds->ncosbins = fitstable_nrows(tab); printf("# nrows= %d\n",ltcubeds->ncosbins); if ( (ltcubeds->cosbins= (float *) fitstable_read_column_array(tab, "COSBINS", flt))==NULL) { printf("# cannot load vector COSBINS from %s in loadltcude() %s:%d\n",filename,__FILE__,__LINE__); fitstable_close(tab); return -1; } fitstable_open_next_extension(tab); if ( (ltcubeds->cthetamin= (float *) fitstable_read_column(tab, "CTHETA_MIN", flt))==NULL) { printf("# cannot load vector CTHETA_MIN from %s in loadltcude() %s:%d\n",filename,__FILE__,__LINE__); fitstable_close(tab); return -1; } if ( (ltcubeds->cthetamax= (float *) fitstable_read_column(tab, "CTHETA_MAX", flt))==NULL) { printf("# cannot load vector CTHETA_MAX from %s in loadltcude() %s:%d\n",filename,__FILE__,__LINE__); fitstable_close(tab); return -1; } if ( (ltcubeds->aeffmubin = (int *) calloc(ltcubeds->nMu,sizeof(int)))==NULL) { printf("# cannot allocate vector AEFFMUBIN in loadltcude() %s:%d\n",__FILE__,__LINE__); fitstable_close(tab); return -1; } ltcubeds->aeffmubin[0]=-99; if (debug>2) { int i, j; printf("# nMu= %d\n",ltcubeds->nMu); for (i=0;i<ltcubeds->nMu;i++) { printf("%3d %10g %10g\n",i,ltcubeds->cthetamin[i],ltcubeds->cthetamax[i]); } for (j=0;j<10;j++) { printf("j= %d",j); for (i=0;i<ltcubeds->nMu;i++) { printf(" %10g",ltcubeds->cosbins[j*ltcubeds->nMu+i]); } printf("\n"); } } printf("# loaded %s\n",filename); 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; }