Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/include/addstar.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/include/addstar.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/include/addstar.h (revision 37067) @@ -41,6 +41,7 @@ typedef struct { - Average average; - Measure measure; + Average average; + Measure measure; + Lensing *lensing; // optionally carry out the lensing measurements int found; } Stars; @@ -250,10 +251,14 @@ void update_coords PROTO((Average *average, Measure *measure, off_t *next)); off_t *init_measure_links PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure)); +off_t *init_lensing_links PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing)); off_t *init_missing_links PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing)); off_t add_meas_link PROTO((Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE)); off_t add_miss_link PROTO((Average *average, off_t *next_miss, off_t Nmissing)); +off_t add_lens_link PROTO((Average *average, off_t *next_lens, off_t Nlensing, off_t NLENSING)); off_t *build_measure_links PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure)); +off_t *build_lensing_links PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing)); Measure *sort_measure PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas)); Missing *sort_missing PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss)); +Lensing *sort_lensing PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next_lens)); int ImageOptions PROTO((AddstarClientOptions *options, Image *images, off_t Nimages)); int GetFileMode PROTO((Header *header)); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/FilterStars.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/FilterStars.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/FilterStars.c (revision 37067) @@ -99,4 +99,10 @@ stars[N].measure.dFluxKron /= image[0].exptime; } + if (!isnan(stars[N].measure.FluxAp)) { + stars[N].measure.FluxAp /= image[0].exptime; + } + if (!isnan(stars[N].measure.dFluxAp)) { + stars[N].measure.dFluxAp /= image[0].exptime; + } // the external ID is supplied, but do we trust it? Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/GetFileMode.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/GetFileMode.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/GetFileMode.c (revision 37067) @@ -10,7 +10,8 @@ int havePHOT_VER, haveTARG_VER; + // NOTE target of %t must be int length gfits_scan_alt (header, "SIMPLE", "%t", 1, &simple); int haveNaxis = gfits_scan (header, "NAXIS", "%d", 1, &Naxis); - int haveCTYPE = gfits_scan (header, "CTYPE1", "%s", 1, ctype); + int haveCTYPE = gfits_scan (header, "CTYPE2", "%s", 1, ctype); gfits_scan_alt (header, "EXTEND", "%t", 1, &extend); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/LoadDataPMM.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/LoadDataPMM.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/LoadDataPMM.c (revision 37067) @@ -193,5 +193,5 @@ // XXX for now, we define a totally fake coordinate system centered on the plate center - strcpy (image[0].coords.ctype, "RA---TAN"); + strcpy (image[0].coords.ctype, "DEC--TAN"); image[0].coords.crval1 = pmm_get_ra (RA); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/MatchHeaders.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/MatchHeaders.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/MatchHeaders.c (revision 37067) @@ -59,9 +59,14 @@ if (!strcmp (exttype, "PS1_V3")) goto keep; if (!strcmp (exttype, "PS1_V4")) goto keep; + if (!strcmp (exttype, "PS1_V5")) goto keep; + if (!strcmp (exttype, "PS1_SV1")) goto keep; if (!strcmp (exttype, "PS1_SV2")) goto keep; - if (!strcmp (exttype, "PS1_DV3")) { - goto keep; - } + if (!strcmp (exttype, "PS1_SV3")) goto keep; + + if (!strcmp (exttype, "PS1_DV1")) goto keep; + if (!strcmp (exttype, "PS1_DV2")) goto keep; + if (!strcmp (exttype, "PS1_DV3")) goto keep; + if (!strcmp (exttype, "PS1_DV4")) goto keep; continue; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadImageHeader.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadImageHeader.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadImageHeader.c (revision 37067) @@ -44,4 +44,7 @@ image[0].NX = Nx; image[0].NY = Ny; + + image[0].refColorBlue = NAN; + image[0].refColorRed = NAN; if (!gfits_scan (header, "TZERO", "%d", 1, &image[0].tzero) && !ACCEPT_TIME) { @@ -133,5 +136,6 @@ tmp = 0; - gfits_scan (header, "FLIMIT", "%lf", 1, &tmp); + // gfits_scan (header, "FLIMIT", "%lf", 1, &tmp); + gfits_scan (header, "DETEFF.MAGREF", "%lf", 1, &tmp); image[0].detection_limit = tmp * 10.0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadStarsFITS.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadStarsFITS.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadStarsFITS.c (revision 37067) @@ -12,8 +12,12 @@ Stars *Convert_PS1_V3 PROTO((FTable *table, unsigned int *nstars)); Stars *Convert_PS1_V4 PROTO((FTable *table, unsigned int *nstars)); +Stars *Convert_PS1_V5 PROTO((FTable *table, unsigned int *nstars)); +Stars *Convert_PS1_V5_Lensing PROTO((FTable *table, unsigned int *nstars)); Stars *Convert_PS1_SV1 PROTO((FTable *table, unsigned int *nstars)); Stars *Convert_PS1_SV1_Alt PROTO((FTable *table, unsigned int *nstars)); Stars *Convert_PS1_SV2 PROTO((FTable *table, unsigned int *nstars)); +Stars *Convert_PS1_SV3 PROTO((FTable *table, unsigned int *nstars)); Stars *Convert_PS1_DV3 PROTO((FTable *table, unsigned int *nstars)); +Stars *Convert_PS1_DV4 PROTO((FTable *table, unsigned int *nstars)); // given a file with the pointer at the start of the table block and the @@ -73,4 +77,11 @@ stars = Convert_PS1_V4 (&table, &Nstars); } + if (!strcmp (type, "PS1_V5")) { + if (table.header[0].Naxis[0] == 312) { + stars = Convert_PS1_V5_Lensing (&table, &Nstars); + } else { + stars = Convert_PS1_V5 (&table, &Nstars); + } + } if (!strcmp (type, "PS1_SV1")) { stars = Convert_PS1_SV1 (&table, &Nstars); @@ -79,7 +90,13 @@ stars = Convert_PS1_SV2 (&table, &Nstars); } + if (!strcmp (type, "PS1_SV3")) { + stars = Convert_PS1_SV3 (&table, &Nstars); + } if (!strcmp (type, "PS1_DV3")) { stars = Convert_PS1_DV3 (&table, &Nstars); } + if (!strcmp (type, "PS1_DV4")) { + stars = Convert_PS1_DV4 (&table, &Nstars); + } if (stars == NULL) { fprintf (stderr, "invalid table type %s\n", type); @@ -91,4 +108,21 @@ return stars; +} + +float GetFluxFromFluxOrMag (float flux, float mag) { + + if (isnan(mag) && isnan(flux)) return NAN; + + if (isnan(flux)) return pow(10.0,-0.4*mag); + return flux; +} + +float GetFluxErrFromFluxOrMag (float dFlux, float flux, float dMag) { + + if (isnan(dMag) && isnan(dFlux)) return NAN; + if (isnan(dFlux) && isnan(flux)) return NAN; + + if (isnan(dFlux)) return (fabs(dMag * flux)); + return dFlux; } @@ -360,4 +394,5 @@ stars[i].measure.dMcal = ps1data[i].dMcal; stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = ps1data[i].dM; // a proxy measure stars[i].measure.Mkron = NAN; // not provided by PS1_V1: @@ -445,4 +480,5 @@ stars[i].measure.dMcal = ps1data[i].dMcal; stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = ps1data[i].dM; // a proxy measure stars[i].measure.Mkron = NAN; // not provided by PS1_V1_Alt: @@ -522,4 +558,5 @@ stars[i].measure.dMcal = ps1data[i].dMcal; stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = ps1data[i].dM; // a proxy measure stars[i].measure.Mkron = NAN; // not provided by PS1_V2: @@ -595,4 +632,5 @@ stars[i].measure.dMcal = ps1data[i].dMcal; stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = ps1data[i].dM; // a proxy measure stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; @@ -600,8 +638,10 @@ // these fluxes are converted from counts to counts/sec in FilterStars.c - stars[i].measure.FluxPSF = ps1data[i].Flux; - stars[i].measure.dFluxPSF = ps1data[i].dFlux; + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); stars[i].measure.FluxKron = ps1data[i].kronFlux; stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (NAN, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (NAN, stars[i].measure.FluxAp, stars[i].measure.dMap); stars[i].measure.Sky = ps1data[i].sky; @@ -676,4 +716,5 @@ stars[i].measure.dMcal = ps1data[i].dMcal; stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN; stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; @@ -681,8 +722,10 @@ // these fluxes are converted from counts to counts/sec in FilterStars.c - stars[i].measure.FluxPSF = ps1data[i].Flux; - stars[i].measure.dFluxPSF = ps1data[i].dFlux; + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); stars[i].measure.FluxKron = ps1data[i].kronFlux; stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap); stars[i].measure.Sky = ps1data[i].sky; @@ -724,5 +767,5 @@ } -Stars *Convert_PS1_SV1 (FTable *table, unsigned int *nstars) { +Stars *Convert_PS1_V5 (FTable *table, unsigned int *nstars) { off_t Nstars; @@ -730,12 +773,7 @@ double ZeroPt; Stars *stars; - CMF_PS1_SV1 *ps1data; - - if (table[0].header[0].Naxis[0] == 196) { - stars = Convert_PS1_SV1_Alt (table, nstars); - return (stars); - } - - ps1data = gfits_table_get_CMF_PS1_SV1 (table, &Nstars, NULL); + CMF_PS1_V5 *ps1data; + + ps1data = gfits_table_get_CMF_PS1_V5 (table, &Nstars, NULL); if (!ps1data) { fprintf (stderr, "skipping inconsistent entry\n"); @@ -763,13 +801,16 @@ stars[i].measure.dMcal = ps1data[i].dMcal; stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN; stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; stars[i].measure.dMkron = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN; - + // these fluxes are converted from counts to counts/sec in FilterStars.c - stars[i].measure.FluxPSF = ps1data[i].Flux; - stars[i].measure.dFluxPSF = ps1data[i].dFlux; + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); stars[i].measure.FluxKron = ps1data[i].kronFlux; stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap); stars[i].measure.Sky = ps1data[i].sky; @@ -799,6 +840,9 @@ // the Average fields and the following Measure fields are set in FilterStars after - // the image metadata is in hand: dR, dD, Mcal, dt, airmass, az, t, imageID, extID, - // averef is set in find_matches, dbFlags is zero on ingest. + // the image metadata is in hand: dR, dD, Mcal, dt, airmass, az, t, imageID, extID. + + // averef is set in find_matches + + // dbFlags is zero on ingest. // the following fields are currently not being set anywhere: t_msec @@ -808,5 +852,5 @@ } -Stars *Convert_PS1_SV1_Alt (FTable *table, unsigned int *nstars) { +Stars *Convert_PS1_V5_Lensing (FTable *table, unsigned int *nstars) { off_t Nstars; @@ -814,9 +858,7 @@ double ZeroPt; Stars *stars; - CMF_PS1_SV1 *ps1data; - - // some test output files were produced called CMF_PS1_SV1 but with mismatch byte boundaries - - ps1data = gfits_table_get_CMF_PS1_SV1_Alt (table, &Nstars, NULL); + CMF_PS1_V5_Lensing *ps1data; + + ps1data = gfits_table_get_CMF_PS1_V5_Lensing (table, &Nstars, NULL); if (!ps1data) { fprintf (stderr, "skipping inconsistent entry\n"); @@ -844,13 +886,230 @@ stars[i].measure.dMcal = ps1data[i].dMcal; stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN; stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; stars[i].measure.dMkron = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN; - + // these fluxes are converted from counts to counts/sec in FilterStars.c - stars[i].measure.FluxPSF = ps1data[i].Flux; - stars[i].measure.dFluxPSF = ps1data[i].dFlux; + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); stars[i].measure.FluxKron = ps1data[i].kronFlux; stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap); + + stars[i].measure.Sky = ps1data[i].sky; + stars[i].measure.dSky = ps1data[i].dSky; + + stars[i].measure.psfChisq = ps1data[i].psfChisq; + stars[i].measure.psfQF = ps1data[i].psfQF; + stars[i].measure.psfQFperf = ps1data[i].psfQFperf; + + stars[i].measure.psfNdof = ps1data[i].psfNdof; + stars[i].measure.psfNpix = ps1data[i].psfNpix; + stars[i].measure.crNsigma = ps1data[i].crNsigma; + stars[i].measure.extNsigma = ps1data[i].extNsigma; + + stars[i].measure.FWx = ToShortPixels(ps1data[i].fx); + stars[i].measure.FWy = ToShortPixels(ps1data[i].fy); + stars[i].measure.theta = ToShortDegrees(ps1data[i].df); + + stars[i].measure.Mxx = ToShortPixels(ps1data[i].Mxx); + stars[i].measure.Mxy = ToShortPixels(ps1data[i].Mxy); + stars[i].measure.Myy = ToShortPixels(ps1data[i].Myy); + + stars[i].measure.photFlags = ps1data[i].flags; + + // this is may optionally be replaced by the internal sequence (see FilterStars.c) + stars[i].measure.detID = ps1data[i].detID; + + ALLOCATE (stars[i].lensing, Lensing, 1); + dvo_lensing_init (stars[i].lensing); + + stars[i].lensing->X11_sm_obj = ps1data[i].X11_sm_obj; + stars[i].lensing->X12_sm_obj = ps1data[i].X12_sm_obj; + stars[i].lensing->X22_sm_obj = ps1data[i].X22_sm_obj; + stars[i].lensing->E1_sm_obj = ps1data[i].E1_sm_obj; + stars[i].lensing->E2_sm_obj = ps1data[i].E2_sm_obj; + + stars[i].lensing->X11_sh_obj = ps1data[i].X11_sh_obj; + stars[i].lensing->X12_sh_obj = ps1data[i].X12_sh_obj; + stars[i].lensing->X22_sh_obj = ps1data[i].X22_sh_obj; + stars[i].lensing->E1_sh_obj = ps1data[i].E1_sh_obj; + stars[i].lensing->E2_sh_obj = ps1data[i].E2_sh_obj; + + stars[i].lensing->X11_sm_psf = ps1data[i].X11_sm_psf; + stars[i].lensing->X12_sm_psf = ps1data[i].X12_sm_psf; + stars[i].lensing->X22_sm_psf = ps1data[i].X22_sm_psf; + stars[i].lensing->E1_sm_psf = ps1data[i].E1_sm_psf; + stars[i].lensing->E2_sm_psf = ps1data[i].E2_sm_psf; + + stars[i].lensing->X11_sh_psf = ps1data[i].X11_sh_psf; + stars[i].lensing->X12_sh_psf = ps1data[i].X12_sh_psf; + stars[i].lensing->X22_sh_psf = ps1data[i].X22_sh_psf; + stars[i].lensing->E1_sh_psf = ps1data[i].E1_sh_psf; + stars[i].lensing->E2_sh_psf = ps1data[i].E2_sh_psf; + + // stars[i].lensing->F_ApR5 = ps1data[i].F_ApR5; + // stars[i].lensing->dF_ApR5 = ps1data[i].dF_ApR5; + // stars[i].lensing->sF_ApR5 = ps1data[i].sF_ApR5; + // stars[i].lensing->fF_ApR5 = ps1data[i].fF_ApR5; + // + // stars[i].lensing->F_ApR6 = ps1data[i].F_ApR6; + // stars[i].lensing->dF_ApR6 = ps1data[i].dF_ApR6; + // stars[i].lensing->sF_ApR6 = ps1data[i].sF_ApR6; + // stars[i].lensing->fF_ApR6 = ps1data[i].fF_ApR6; + + // this is may optionally be replaced by the internal sequence (see FilterStars.c) + stars[i].lensing->detID = ps1data[i].detID; + + // the Average fields and the following Measure fields are set in FilterStars after + // the image metadata is in hand: dR, dD, Mcal, dt, airmass, az, t, imageID, extID. + + // averef is set in find_matches + + // dbFlags is zero on ingest. + + // the following fields are currently not being set anywhere: t_msec + } + *nstars = Nstars; + return (stars); +} + +Stars *Convert_PS1_SV1 (FTable *table, unsigned int *nstars) { + + off_t Nstars; + unsigned int i; + double ZeroPt; + Stars *stars; + CMF_PS1_SV1 *ps1data; + + if (table[0].header[0].Naxis[0] == 196) { + stars = Convert_PS1_SV1_Alt (table, nstars); + return (stars); + } + + ps1data = gfits_table_get_CMF_PS1_SV1 (table, &Nstars, NULL); + if (!ps1data) { + fprintf (stderr, "skipping inconsistent entry\n"); + return (NULL); + } + ZeroPt = GetZeroPoint(); + + ALLOCATE (stars, Stars, Nstars); + for (i = 0; i < Nstars; i++) { + InitStar (&stars[i]); + stars[i].measure.Xccd = ps1data[i].X; + stars[i].measure.Yccd = ps1data[i].Y; + stars[i].measure.dXccd = ToShortPixels(ps1data[i].dX); + stars[i].measure.dYccd = ToShortPixels(ps1data[i].dY); + + stars[i].measure.posangle = ToShortDegrees(ps1data[i].posangle); + stars[i].measure.pltscale = ps1data[i].pltscale; + + if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) { + stars[i].measure.M = NAN; + } else { + stars[i].measure.M = ps1data[i].M + ZeroPt; + } + stars[i].measure.dM = ps1data[i].dM; + stars[i].measure.dMcal = ps1data[i].dMcal; + stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = ps1data[i].dM; // a proxy measure + + stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; + stars[i].measure.dMkron = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN; + + // these fluxes are converted from counts to counts/sec in FilterStars.c + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); + stars[i].measure.FluxKron = ps1data[i].kronFlux; + stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (NAN, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (NAN, stars[i].measure.FluxAp, stars[i].measure.dMap); + + stars[i].measure.Sky = ps1data[i].sky; + stars[i].measure.dSky = ps1data[i].dSky; + + stars[i].measure.psfChisq = ps1data[i].psfChisq; + stars[i].measure.psfQF = ps1data[i].psfQF; + stars[i].measure.psfQFperf = ps1data[i].psfQFperf; + + stars[i].measure.psfNdof = ps1data[i].psfNdof; + stars[i].measure.psfNpix = ps1data[i].psfNpix; + stars[i].measure.crNsigma = ps1data[i].crNsigma; + stars[i].measure.extNsigma = ps1data[i].extNsigma; + + stars[i].measure.FWx = ToShortPixels(ps1data[i].fx); + stars[i].measure.FWy = ToShortPixels(ps1data[i].fy); + stars[i].measure.theta = ToShortDegrees(ps1data[i].df); + + stars[i].measure.Mxx = ToShortPixels(ps1data[i].Mxx); + stars[i].measure.Mxy = ToShortPixels(ps1data[i].Mxy); + stars[i].measure.Myy = ToShortPixels(ps1data[i].Myy); + + stars[i].measure.photFlags = ps1data[i].flags; + + // this is may optionally be replaced by the internal sequence (see FilterStars.c) + stars[i].measure.detID = ps1data[i].detID; + + // the Average fields and the following Measure fields are set in FilterStars after + // the image metadata is in hand: dR, dD, Mcal, dt, airmass, az, t, imageID, extID, + // averef is set in find_matches, dbFlags is zero on ingest. + + // the following fields are currently not being set anywhere: t_msec + } + *nstars = Nstars; + return (stars); +} + +Stars *Convert_PS1_SV1_Alt (FTable *table, unsigned int *nstars) { + + off_t Nstars; + unsigned int i; + double ZeroPt; + Stars *stars; + CMF_PS1_SV1 *ps1data; + + // some test output files were produced called CMF_PS1_SV1 but with mismatch byte boundaries + + ps1data = gfits_table_get_CMF_PS1_SV1_Alt (table, &Nstars, NULL); + if (!ps1data) { + fprintf (stderr, "skipping inconsistent entry\n"); + return (NULL); + } + ZeroPt = GetZeroPoint(); + + ALLOCATE (stars, Stars, Nstars); + for (i = 0; i < Nstars; i++) { + InitStar (&stars[i]); + stars[i].measure.Xccd = ps1data[i].X; + stars[i].measure.Yccd = ps1data[i].Y; + stars[i].measure.dXccd = ToShortPixels(ps1data[i].dX); + stars[i].measure.dYccd = ToShortPixels(ps1data[i].dY); + + stars[i].measure.posangle = ToShortDegrees(ps1data[i].posangle); + stars[i].measure.pltscale = ps1data[i].pltscale; + + if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) { + stars[i].measure.M = NAN; + } else { + stars[i].measure.M = ps1data[i].M + ZeroPt; + } + stars[i].measure.dM = ps1data[i].dM; + stars[i].measure.dMcal = ps1data[i].dMcal; + stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = ps1data[i].dM; // a proxy measure + + stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; + stars[i].measure.dMkron = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN; + + // these fluxes are converted from counts to counts/sec in FilterStars.c + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); + stars[i].measure.FluxKron = ps1data[i].kronFlux; + stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (NAN, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (NAN, stars[i].measure.FluxAp, stars[i].measure.dMap); stars[i].measure.Sky = ps1data[i].sky; @@ -921,4 +1180,5 @@ stars[i].measure.dMcal = ps1data[i].dMcal; stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN; stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; @@ -926,8 +1186,10 @@ // these fluxes are converted from counts to counts/sec in FilterStars.c - stars[i].measure.FluxPSF = ps1data[i].Flux; - stars[i].measure.dFluxPSF = ps1data[i].dFlux; + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); stars[i].measure.FluxKron = ps1data[i].kronFlux; stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap); stars[i].measure.Sky = ps1data[i].sky; @@ -966,5 +1228,5 @@ } -Stars *Convert_PS1_DV3 (FTable *table, unsigned int *nstars) { +Stars *Convert_PS1_SV3 (FTable *table, unsigned int *nstars) { off_t Nstars; @@ -972,7 +1234,7 @@ double ZeroPt; Stars *stars; - CMF_PS1_DV3 *ps1data; - - ps1data = gfits_table_get_CMF_PS1_DV3 (table, &Nstars, NULL); + CMF_PS1_SV3 *ps1data; + + ps1data = gfits_table_get_CMF_PS1_SV3 (table, &Nstars, NULL); if (!ps1data) { fprintf (stderr, "skipping inconsistent entry\n"); @@ -1000,13 +1262,98 @@ stars[i].measure.dMcal = ps1data[i].dMcal; stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN; stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; stars[i].measure.dMkron = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN; - + // these fluxes are converted from counts to counts/sec in FilterStars.c - stars[i].measure.FluxPSF = ps1data[i].Flux; - stars[i].measure.dFluxPSF = ps1data[i].dFlux; + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); stars[i].measure.FluxKron = ps1data[i].kronFlux; stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap); + + stars[i].measure.Sky = ps1data[i].sky; + stars[i].measure.dSky = ps1data[i].dSky; + + stars[i].measure.psfChisq = ps1data[i].psfChisq; + stars[i].measure.psfQF = ps1data[i].psfQF; + stars[i].measure.psfQFperf = ps1data[i].psfQFperf; + + stars[i].measure.psfNdof = ps1data[i].psfNdof; + stars[i].measure.psfNpix = ps1data[i].psfNpix; + stars[i].measure.crNsigma = ps1data[i].crNsigma; + stars[i].measure.extNsigma = ps1data[i].extNsigma; + + stars[i].measure.FWx = ToShortPixels(ps1data[i].fx); + stars[i].measure.FWy = ToShortPixels(ps1data[i].fy); + stars[i].measure.theta = ToShortDegrees(ps1data[i].df); + + stars[i].measure.Mxx = ToShortPixels(ps1data[i].Mxx); + stars[i].measure.Mxy = ToShortPixels(ps1data[i].Mxy); + stars[i].measure.Myy = ToShortPixels(ps1data[i].Myy); + + stars[i].measure.photFlags = ps1data[i].flags; + + // this is may optionally be replaced by the internal sequence (see FilterStars.c) + stars[i].measure.detID = ps1data[i].detID; + + // the Average fields and the following Measure fields are set in FilterStars after + // the image metadata is in hand: dR, dD, Mcal, dt, airmass, az, t, imageID, extID, + // averef is set in find_matches, dbFlags is zero on ingest. + + // the following fields are currently not being set anywhere: t_msec + } + *nstars = Nstars; + return (stars); +} + +Stars *Convert_PS1_DV3 (FTable *table, unsigned int *nstars) { + + off_t Nstars; + unsigned int i; + double ZeroPt; + Stars *stars; + CMF_PS1_DV3 *ps1data; + + ps1data = gfits_table_get_CMF_PS1_DV3 (table, &Nstars, NULL); + if (!ps1data) { + fprintf (stderr, "skipping inconsistent entry\n"); + return (NULL); + } + ZeroPt = GetZeroPoint(); + + ALLOCATE (stars, Stars, Nstars); + for (i = 0; i < Nstars; i++) { + InitStar (&stars[i]); + stars[i].measure.Xccd = ps1data[i].X; + stars[i].measure.Yccd = ps1data[i].Y; + stars[i].measure.dXccd = ToShortPixels(ps1data[i].dX); + stars[i].measure.dYccd = ToShortPixels(ps1data[i].dY); + + stars[i].measure.posangle = ToShortDegrees(ps1data[i].posangle); + stars[i].measure.pltscale = ps1data[i].pltscale; + + if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) { + stars[i].measure.M = NAN; + } else { + stars[i].measure.M = ps1data[i].M + ZeroPt; + } + stars[i].measure.dM = ps1data[i].dM; + stars[i].measure.dMcal = ps1data[i].dMcal; + stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN; + + stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; + stars[i].measure.dMkron = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN; + + // these fluxes are converted from counts to counts/sec in FilterStars.c + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); + stars[i].measure.FluxKron = ps1data[i].kronFlux; + stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap); stars[i].measure.Sky = ps1data[i].sky; @@ -1047,4 +1394,90 @@ } - - +Stars *Convert_PS1_DV4 (FTable *table, unsigned int *nstars) { + + off_t Nstars; + unsigned int i; + double ZeroPt; + Stars *stars; + CMF_PS1_DV4 *ps1data; + + ps1data = gfits_table_get_CMF_PS1_DV4 (table, &Nstars, NULL); + if (!ps1data) { + fprintf (stderr, "skipping inconsistent entry\n"); + return (NULL); + } + ZeroPt = GetZeroPoint(); + + fprintf (stderr, "WARNING: Convert_PS1_DV4 not yet updated to match real format\n"); + + ALLOCATE (stars, Stars, Nstars); + for (i = 0; i < Nstars; i++) { + InitStar (&stars[i]); + stars[i].measure.Xccd = ps1data[i].X; + stars[i].measure.Yccd = ps1data[i].Y; + stars[i].measure.dXccd = ToShortPixels(ps1data[i].dX); + stars[i].measure.dYccd = ToShortPixels(ps1data[i].dY); + + stars[i].measure.posangle = ToShortDegrees(ps1data[i].posangle); + stars[i].measure.pltscale = ps1data[i].pltscale; + + if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) { + stars[i].measure.M = NAN; + } else { + stars[i].measure.M = ps1data[i].M + ZeroPt; + } + stars[i].measure.dM = ps1data[i].dM; + stars[i].measure.dMcal = ps1data[i].dMcal; + stars[i].measure.Map = ps1data[i].Map + ZeroPt; + stars[i].measure.dMap = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN; + + stars[i].measure.Mkron = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN; + stars[i].measure.dMkron = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN; + + // these fluxes are converted from counts to counts/sec in FilterStars.c + stars[i].measure.FluxPSF = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); + stars[i].measure.dFluxPSF = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM); + stars[i].measure.FluxKron = ps1data[i].kronFlux; + stars[i].measure.dFluxKron = ps1data[i].kronFluxErr; + stars[i].measure.FluxAp = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); + stars[i].measure.dFluxAp = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap); + + stars[i].measure.Sky = ps1data[i].sky; + stars[i].measure.dSky = ps1data[i].dSky; + + stars[i].measure.psfChisq = ps1data[i].psfChisq; + stars[i].measure.psfQF = ps1data[i].psfQF; + stars[i].measure.psfQFperf = ps1data[i].psfQFperf; + stars[i].measure.psfNdof = ps1data[i].psfNdof; + stars[i].measure.psfNpix = ps1data[i].psfNpix; + stars[i].measure.crNsigma = ps1data[i].crNsigma; + stars[i].measure.extNsigma = ps1data[i].extNsigma; + + stars[i].measure.FWx = ToShortPixels(ps1data[i].fx); + stars[i].measure.FWy = ToShortPixels(ps1data[i].fy); + stars[i].measure.theta = ToShortDegrees(ps1data[i].df); + + stars[i].measure.Mxx = ToShortPixels(ps1data[i].Mxx); + stars[i].measure.Mxy = ToShortPixels(ps1data[i].Mxy); + stars[i].measure.Myy = ToShortPixels(ps1data[i].Myy); + + stars[i].measure.photFlags = ps1data[i].flags; + + // this is may optionally be replaced by the internal sequence (see FilterStars.c) + stars[i].measure.detID = ps1data[i].detID; + + // the Average fields and the following Measure fields are set in FilterStars after + // the image metadata is in hand: dR, dD, Mcal, dt, airmass, az, t, imageID, extID. + + // averef is set in find_matches + + // dbFlags is zero on ingest. + + // the following fields are currently not being set anywhere: t_msec + } + *nstars = Nstars; + return (stars); +} + + + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadStarsSDSS.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadStarsSDSS.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadStarsSDSS.c (revision 37067) @@ -201,5 +201,5 @@ // XXX for now, we define a totally fake coordinate system centered on the first listed star - strcpy (images[N].coords.ctype, "RA---TAN"); + strcpy (images[N].coords.ctype, "DEC--TAN"); images[N].coords.crval1 = stars[0].average.R; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/SEDfit.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/SEDfit.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/SEDfit.c (revision 37067) @@ -162,9 +162,12 @@ } + double R = incat[0].average[i].R; + double D = incat[0].average[i].D; + for (j = 0; valid && (j < Nmodel); j++) { n = modelRow[j]; dvo_measure_init (&outcat[0].measure[Nmeas]); - outcat[0].measure[Nmeas].dR = 0.0; - outcat[0].measure[Nmeas].dD = 0.0; + outcat[0].measure[Nmeas].R = R; + outcat[0].measure[Nmeas].D = D; outcat[0].measure[Nmeas].M = table[0].row[minFit.row][0].mags[n] + minFit.Md; outcat[0].measure[Nmeas].dM = 0.0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/StarOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/StarOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/StarOps.c (revision 37067) @@ -8,4 +8,5 @@ star[0].found = -1; // found == -1 -> not yet found (use enums?) + star[0].lensing = NULL; // we only populate this if needed return TRUE; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/addstar.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/addstar.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/addstar.c (revision 37067) @@ -7,5 +7,5 @@ int Nmatch, status, loadObjects; off_t i, Nimages; - off_t Naverage, Nmeasure; + off_t Naverage, Nmeasure, Nlensing; Stars *stars, **subset; Image *images; @@ -100,5 +100,5 @@ /* match stars to existing catalog data (or otherwise manipulate catalog data) */ - Nmatch = Naverage = Nmeasure = 0; + Nmatch = Naverage = Nmeasure = Nlensing = 0; for (i = 0; loadObjects && (i < skylist[0].Nregions); i++) { @@ -107,5 +107,5 @@ catalog.catformat = dvo_catalog_catformat (CATFORMAT); // set the default catformat from config data catalog.catmode = dvo_catalog_catmode (CATMODE); // set the default catmode from config data - catalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF; + catalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF | LOAD_LENSING; catalog.Nsecfilt = GetPhotcodeNsecfilt (); @@ -182,4 +182,5 @@ Naverage += catalog.Naverage; Nmeasure += catalog.Nmeasure; + Nlensing += catalog.Nlensing; // write out catalog, if appropriate @@ -187,5 +188,5 @@ SetProtect (TRUE); if (options.update) { - catalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF; + catalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF | LOAD_LENSING; dvo_catalog_update (&catalog, VERBOSE); } else { @@ -231,5 +232,5 @@ gettimeofday (&stop, NULL); dtime = DTIME (stop, start); - fprintf (stderr, "SUCCESS: elapsed time %9.4f sec for %5d stars (%5d matches), "OFF_T_FMT" average, "OFF_T_FMT" measure\n", dtime, Nstars, Nmatch, Naverage, Nmeasure); + fprintf (stderr, "SUCCESS: elapsed time %9.4f sec for %5d stars (%5d matches), "OFF_T_FMT" average, "OFF_T_FMT" measure, "OFF_T_FMT" lensing\n", dtime, Nstars, Nmatch, Naverage, Nmeasure, Nlensing); exit (0); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/build_links.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/build_links.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/build_links.c (revision 37067) @@ -225,2 +225,141 @@ } +/*******************************************************************************************/ + +/* build the initial links assuming the table is sorted, + not partial, and has a correct set of average[].lensingOffset,Nlensing values */ +off_t *init_lensing_links (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing) { + + off_t i, j, N; + off_t *next_lens; + + N = 0; + + ALLOCATE (next_lens, off_t, Nlensing); + for (i = 0; i < Naverage; i++) { + if (!average[i].Nlensing) continue; + for (j = 0; j < average[i].Nlensing - 1; j++, N++) { + next_lens[N] = N + 1; + if (N >= Nlensing) { + fprintf (stderr, "WARNING: N out of bounds (1)\n"); + } + } + next_lens[N] = -1; + if (N >= Nlensing) { + fprintf (stderr, "WARNING: N out of bounds (2)\n"); + } + + if (N >= Nlensing) { + fprintf (stderr, "overflow in init_lensing_links\n"); + abort (); + } + N++; + } + return (next_lens); +} + +/* construct lensing links which are valid FOR THIS LOAD + * - if we have a full load, we will get links which can + * be used by other programs (eg, relphot, etc) + * - if we have a partial load, the links are only valid + * for that partial load + */ + +off_t *build_lensing_links (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing) { + + off_t i, m, k, Nm, averef; + off_t *next_lens; + + ALLOCATE (next_lens, off_t, Nlensing); + + /* reset the Nm, offset values for average */ + for (i = 0; i < Naverage; i++) { + average[i].lensingOffset = -1; + average[i].Nlensing = 0; + } + + for (Nm = 0; Nm < Nlensing; Nm++) { + averef = lensing[Nm].averef; + m = average[averef].lensingOffset; + next_lens[Nm] = -1; + + if (m == -1) { /* no links yet for source */ + average[averef].lensingOffset = Nm; + average[averef].Nlensing = 1; + continue; + } + + for (k = 0; next_lens[m] != -1; k++) { + m = next_lens[m]; + if (m >= Nlensing) { + fprintf (stderr, "WARNING: m out of bounds (1)\n"); + } + } + + average[averef].Nlensing = k + 2; + next_lens[m] = Nm; + if (m >= Nlensing) { + fprintf (stderr, "WARNING: m out of bounds (2)\n"); + } + } + return (next_lens); +} + +/* average[].lensingOffset, average[].Nlensing are valid within an addstar run */ +off_t add_lens_link (Average *average, off_t *next_lens, off_t Nlensing, off_t NLENSING) { + + off_t k, m; + + /* if we have trouble, check validity of next_lens[m] : m < Nlensing */ + m = average[0].lensingOffset; + + for (k = 0; k < average[0].Nlensing - 1; k++) { + m = next_lens[m]; + if (m >= NLENSING) { + fprintf (stderr, "WARNING: m out of bounds (3)\n"); + } + } + + /* set up references */ + next_lens[Nlensing] = -1; + if (Nlensing >= NLENSING) { + fprintf (stderr, "WARNING: Nlensing out of bounds (1)\n"); + } + + if (m == -1) { + average[0].lensingOffset = Nlensing; + } else { + next_lens[m] = Nlensing; + if (m >= NLENSING) { + fprintf (stderr, "WARNING: m out of bounds (4)\n"); + } + } + + return (TRUE); +} + +Lensing *sort_lensing (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next_lens) { + + off_t i, k, n, N; + Lensing *tmplensing; + + /* fix order of Lensing (memory intensive, but fast) */ + N = 0; + ALLOCATE (tmplensing, Lensing, Nlensing); + for (i = 0; i < Naverage; i++) { + if (!average[i].Nlensing) continue; + n = average[i].lensingOffset; + average[i].lensingOffset = N; + for (k = 0; k < average[i].Nlensing; k++, N++) { + if (n == -1) abort(); + tmplensing[N] = lensing[n]; + if (lensing[n].averef != i) abort(); + tmplensing[N].averef = i; + n = next_lens[n]; + } + } + free (lensing); + return (tmplensing); +} + + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/fakeimage.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/fakeimage.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/fakeimage.c (revision 37067) @@ -6,5 +6,4 @@ double pltscale, pixscale; double Rmin, Rmax, Dmin, Dmax; - // double Xmin, Xmax, Ymin, Ymax; double dX, dY, r, d; char chipname[80], chipdata[256], name[80]; @@ -34,5 +33,5 @@ /* create a mosaic distortion structure */ - strcpy (MOSAIC.ctype, "RA---DIS"); + strcpy (MOSAIC.ctype, "DEC--DIS"); MOSAIC.crval1 = FAKE_RA; MOSAIC.crval2 = FAKE_DEC; @@ -86,5 +85,5 @@ strcpy (image[i+1].name, name); - strcpy (image[i+1].coords.ctype, "RA---WRP"); + strcpy (image[i+1].coords.ctype, "DEC--WRP"); image[i+1].coords.crval1 = dX*pixscale; @@ -168,6 +167,4 @@ image[0].cerror = 0.0; - // RD_to_XY (&Xmax, &Ymax, Rmax, Dmax, MOSAIC); - // RD_to_XY (&Xmin, &Ymin, Rmin, Dmin, MOSAIC); image[0].NX = Rmax - Rmin; image[0].NY = Dmax - Dmin; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches.c (revision 37067) @@ -14,6 +14,6 @@ if (NSTAR_GROUP <= 0) { - fprintf (stderr, "ERROR: NSTAR_GROUP NOT SET!\n"); - exit (1); + fprintf (stderr, "ERROR: NSTAR_GROUP NOT SET!\n"); + exit (1); } @@ -36,5 +36,5 @@ ALLOCATE (Y2, double, NAVE); ALLOCATE (N2, off_t, NAVE); - ALLOCATE (catalog[0].found, off_t, NAVE); + ALLOCATE (catalog[0].found_t, off_t, NAVE); /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */ @@ -65,5 +65,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 1; - strcpy (tcoords.ctype, "RA---ARC"); + strcpy (tcoords.ctype, "DEC--ARC"); /* build spatial index (RA sort) referencing input array sequence */ @@ -77,5 +77,4 @@ if (Nstars < 1) { if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", catalog[0].filename); - free (catalog[0].found); free (X1); free (Y1); @@ -92,5 +91,5 @@ RD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords); N2[i] = i; - catalog[0].found[N2[i]] = -1; + catalog[0].found_t[N2[i]] = -1; } if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave); @@ -160,6 +159,6 @@ // the following measure elements cannot be set until here: - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R); - catalog[0].measure[Nmeas].dD = 3600.0*(catalog[0].average[n].D - stars[N].average.D); + catalog[0].measure[Nmeas].R = stars[N].average.R; + catalog[0].measure[Nmeas].D = stars[N].average.D; catalog[0].measure[Nmeas].dbFlags = 0; catalog[0].measure[Nmeas].averef = n; // this must be an absolute sequence number, if partial average is loaded @@ -167,16 +166,21 @@ catalog[0].measure[Nmeas].catID = catalog[0].catID; - // rationalize dR: - if (catalog[0].measure[Nmeas].dR > +180.0*3600.0) { - // average on high end of boundary, move star up - stars[N].average.R += 360.0; - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R); - } - if (catalog[0].measure[Nmeas].dR < -180.0*3600.0) { - // average on low end of boundary, move star down - stars[N].average.R -= 360.0; - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R); - } - if (fabs(catalog[0].measure[Nmeas].dR) > 10*RADIUS) { + float dRoff = dvoOffsetR(&catalog[0].measure[Nmeas], &catalog[0].average[n]); + + // rationalize R: + if (dRoff > +180.0*3600.0) { + // average on high end of boundary, move star up + catalog[0].measure[Nmeas].R += 360.0; + dRoff -= 360.0*3600.0; + } + if (dRoff < -180.0*3600.0) { + // average on low end of boundary, move star down + catalog[0].measure[Nmeas].R -= 360.0; + dRoff += 360.0*3600.0; + } + if (fabs(dRoff) > 10*RADIUS) { + // take declination into account and check again. + double cosD = cos(RAD_DEG*catalog[0].average[n].D); + if (fabs(dRoff*cosD) > 10*RADIUS) { fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n", catalog[0].average[n].R, catalog[0].average[n].D, @@ -184,4 +188,5 @@ X1[i], X2[J], Y1[i], Y2[J]); + } } @@ -196,5 +201,5 @@ if (Nsec > -1) { if (isnan(catalog[0].secfilt[n*Nsecfilt+Nsec].M)) { - catalog[0].secfilt[n*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas]); + catalog[0].secfilt[n*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas], MAG_CLASS_PSF); } } @@ -213,9 +218,9 @@ } /* this catalog star matches more than one image star */ - if (catalog[0].found[n] > -1) { - catalog[0].measure[catalog[0].found[n]].dbFlags |= ID_MEAS_BLEND_OBJ; + if (catalog[0].found_t[n] > -1) { + catalog[0].measure[catalog[0].found_t[n]].dbFlags |= ID_MEAS_BLEND_OBJ; catalog[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_OBJ; } else { - catalog[0].found[n] = Nmeas; + catalog[0].found_t[n] = Nmeas; } /* Nm is updated, but not written out in -update mode (for existing entries) @@ -232,6 +237,6 @@ } - /* incorporate unmatched image stars, if this star is in field of this catalog */ - /* these new entries are all written out in UPDATE mode */ +/* incorporate unmatched image stars, if this star is in field of this catalog */ +/* these new entries are all written out in UPDATE mode */ for (i = 0; (i < Nstars) && !options.only_match; i += NSTAR_GROUP) { /* make sure there is space for next entry */ @@ -260,5 +265,5 @@ if (PSPS_ID) { - catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R, catalog[0].average[Nave].D); + catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R, catalog[0].average[Nave].D); } @@ -274,6 +279,6 @@ // the following measure elements cannot be set until here: - catalog[0].measure[Nmeas].dR = 0.0; - catalog[0].measure[Nmeas].dD = 0.0; + catalog[0].measure[Nmeas].R = stars[i].average.R; + catalog[0].measure[Nmeas].D = stars[i].average.D; catalog[0].measure[Nmeas].dbFlags = 0; catalog[0].measure[Nmeas].averef = Nave; // XXX EAM : must be absolute Nave if partial read @@ -284,9 +289,9 @@ /* in UPDATE mode, this value is not saved; use relphot to recalculate */ if (Nsec > -1) { - catalog[0].secfilt[Nave*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas]); + catalog[0].secfilt[Nave*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas], MAG_CLASS_PSF); } /* next[Nmeas] should always be -1 in this context (it is always the only - measurement for the star) */ + measurement for the star) */ stars[i].found = Nmeas; next_meas[Nmeas] = -1; // initial value here update below @@ -309,5 +314,5 @@ } - /* note stars which have been found in this catalog */ +/* note stars which have been found in this catalog */ for (i = 0; i < NstarsIn; i++) { if (stars[i].found > -1) { @@ -316,5 +321,5 @@ } - /* check if the catalog has changed? if no change, no need to write */ +/* check if the catalog has changed? if no change, no need to write */ catalog[0].objID = objID; // new max value, save on catalog close catalog[0].Naverage = Nave; @@ -323,5 +328,4 @@ if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n", Nstars, Nave, Nmeas, Nmatch); - free (catalog[0].found); free (X1); free (Y1); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_closest.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_closest.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_closest.c (revision 37067) @@ -7,6 +7,6 @@ double *X1, *Y1, *X2, *Y2; double dX, dY, dR; - off_t *N1, *N2, *next_meas; - off_t Nave, NAVE, Nmeas, NMEAS, Nmatch; + off_t *N1, *N2, *next_meas, *next_lens; + off_t Nave, NAVE, Nmeas, NMEAS, Nmatch, Nlens, NLENS; int Nsecfilt, Nsec; unsigned int objID, catID; @@ -36,5 +36,5 @@ ALLOCATE (Y2, double, NAVE); ALLOCATE (N2, off_t, NAVE); - ALLOCATE (catalog[0].found, off_t, NAVE); + ALLOCATE (catalog[0].found_t, off_t, NAVE); /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */ @@ -42,4 +42,5 @@ Nmatch = 0; NMEAS = Nmeas = catalog[0].Nmeasure; + NLENS = Nlens = catalog[0].Nlensing; // current max obj ID for this catalog @@ -64,5 +65,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 1; - strcpy (tcoords.ctype, "RA---ARC"); + strcpy (tcoords.ctype, "DEC--ARC"); /* build spatial index (RA sort) referencing input array sequence */ @@ -76,5 +77,4 @@ if (Nstars < 1) { if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", catalog[0].filename); - free (catalog[0].found); free (X1); free (Y1); @@ -91,5 +91,5 @@ RD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords); N2[i] = i; - catalog[0].found[N2[i]] = -1; + catalog[0].found_t[N2[i]] = -1; } if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave); @@ -100,6 +100,8 @@ // is sorted while processed next_meas = init_measure_links (catalog[0].average, Nave, catalog[0].measure, Nmeas); + next_lens = init_lensing_links (catalog[0].average, Nave, catalog[0].lensing, Nlens); } else { next_meas = build_measure_links (catalog[0].average, Nave, catalog[0].measure, Nmeas); + next_lens = build_lensing_links (catalog[0].average, Nave, catalog[0].lensing, Nlens); } @@ -177,4 +179,9 @@ REALLOCATE (catalog[0].measure, Measure, NMEAS); } + if (Nlens >= NLENS) { + NLENS = Nlens + 1000; + REALLOCATE (next_lens, off_t, NLENS); + REALLOCATE (catalog[0].lensing, Lensing, NLENS); + } /* add to end of measurement list */ @@ -186,7 +193,8 @@ catalog[0].measure[Nmeas] = stars[N].measure; - /** dR,dD now represent arcsec **/ - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R); - catalog[0].measure[Nmeas].dD = 3600.0*(catalog[0].average[n].D - stars[N].average.D); + // measure now carries R,D (not dR,dD) + // note that ReadStarsFITS does not set measure.R,D and average.R,D + catalog[0].measure[Nmeas].R = stars[N].average.R; + catalog[0].measure[Nmeas].D = stars[N].average.D; catalog[0].measure[Nmeas].dbFlags = 0; catalog[0].measure[Nmeas].averef = n; @@ -194,22 +202,40 @@ catalog[0].measure[Nmeas].catID = catalog[0].catID; + float dRoff = dvoOffsetR(&catalog[0].measure[Nmeas], &catalog[0].average[n]); + // rationalize dR - if (catalog[0].measure[Nmeas].dR > +180.0*3600.0) { + if (dRoff > +180.0*3600.0) { // average on high end of boundary, move star up - stars[N].average.R += 360.0; - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R); - } - if (catalog[0].measure[Nmeas].dR < -180.0*3600.0) { + catalog[0].measure[Nmeas].R += 360.0; + dRoff -= 360.0*3600.0; + } + if (dRoff < -180.0*3600.0) { // average on low end of boundary, move star down - stars[N].average.R -= 360.0; - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R); - } - if (fabs(catalog[0].measure[Nmeas].dR) > 10*RADIUS) { - fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n", - catalog[0].average[n].R, catalog[0].average[n].D, - stars[N].average.R, stars[N].average.D, - X1[i], X2[Jmin], - Y1[i], Y2[Jmin]); - // XXX abort on this? -- this is a bad failure... + catalog[0].measure[Nmeas].R -= 360.0; + dRoff += 360.0*3600.0; + } + if (fabs(dRoff) > 10*RADIUS) { + // take declination into account and check again. + double cosD = cos(RAD_DEG*catalog[0].average[n].D); + if (fabs(dRoff*cosD) > 10*RADIUS) { + fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n", + catalog[0].average[n].R, catalog[0].average[n].D, + stars[N].average.R, stars[N].average.D, + X1[i], X2[Jmin], + Y1[i], Y2[Jmin]); + // XXX abort on this? -- this is a bad failure... + } + } + + // add the lensing values if they exist + if (stars[N].lensing) { + add_lens_link (&catalog[0].average[n], next_lens, Nlens, NLENS); // ? + catalog[0].lensing[Nlens] = stars[N].lensing[0]; + + catalog[0].lensing[Nlens].averef = n; + catalog[0].lensing[Nlens].objID = catalog[0].average[n].objID; + catalog[0].lensing[Nlens].catID = catalog[0].catID; + catalog[0].average[n].Nlensing ++; + Nlens ++; } @@ -224,5 +250,5 @@ if (Nsec > -1) { if (isnan(catalog[0].secfilt[n*Nsecfilt+Nsec].M)) { - catalog[0].secfilt[n*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas]); + catalog[0].secfilt[n*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas], MAG_CLASS_PSF); } } @@ -234,5 +260,5 @@ Nm is recalculated in build_meas_links if loaded table is not sorted */ stars[N].found = Nmeas; - catalog[0].found[n] = Nmeas; + catalog[0].found_t[n] = Nmeas; catalog[0].average[n].Nmeasure ++; Nmeas ++; @@ -249,4 +275,9 @@ REALLOCATE (catalog[0].measure, Measure, NMEAS); } + if (Nlens >= NLENS - NSTAR_GROUP) { + NLENS = Nlens + 1000; + REALLOCATE (next_lens, off_t, NLENS); + REALLOCATE (catalog[0].lensing, Lensing, NLENS); + } if (Nave >= NAVE) { NAVE = Nave + 1000; @@ -278,30 +309,54 @@ for (j = 0; j < NSTAR_GROUP; j++) { - // supply the measurments from this detection - catalog[0].measure[Nmeas] = stars[i + j].measure; - - // the following measure elements cannot be set until here: - catalog[0].measure[Nmeas].dR = 0.0; // astrometric offset, not error - catalog[0].measure[Nmeas].dD = 0.0; // astrometric offset, not error - catalog[0].measure[Nmeas].dbFlags = 0; - catalog[0].measure[Nmeas].averef = Nave; - catalog[0].measure[Nmeas].objID = catalog[0].average[Nave].objID; - catalog[0].measure[Nmeas].catID = catalog[0].catID; - - /* set the average magnitude if not already set and the photcode.equiv is not 0 */ - /* in UPDATE mode, this value is not saved; use relphot to recalculate */ - if (Nsec > -1) { - catalog[0].secfilt[Nave*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas]); - } - - /* next[Nmeas] should always be -1 in this context (it is always the only - measurement for the star) */ - stars[i+j].found = Nmeas; - next_meas[Nmeas] = -1; // inital value here update below - Nmeas ++; + // supply the measurments from this detection + dvo_measure_init (&catalog[0].measure[Nmeas]); + catalog[0].measure[Nmeas] = stars[i + j].measure; + + // the following measure elements cannot be set until here: + catalog[0].measure[Nmeas].R = stars[i].average.R; + catalog[0].measure[Nmeas].D = stars[i].average.D; + catalog[0].measure[Nmeas].dbFlags = 0; + catalog[0].measure[Nmeas].averef = Nave; + catalog[0].measure[Nmeas].objID = catalog[0].average[Nave].objID; + catalog[0].measure[Nmeas].catID = catalog[0].catID; + + /* set the average magnitude if not already set and the photcode.equiv is not 0 */ + /* in UPDATE mode, this value is not saved; use relphot to recalculate */ + if (Nsec > -1) { + catalog[0].secfilt[Nave*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas], MAG_CLASS_PSF); + } + + /* next[Nmeas] should always be -1 in this context (it is always the only + measurement for the star) */ + stars[i+j].found = Nmeas; + next_meas[Nmeas] = -1; // inital value here update below + Nmeas ++; } for (j = 0; j < NSTAR_GROUP - 1; j++) { - next_meas[Nmeas - NSTAR_GROUP + j] = Nmeas - NSTAR_GROUP + j + 1; - } + next_meas[Nmeas - NSTAR_GROUP + j] = Nmeas - NSTAR_GROUP + j + 1; + } + + // if we have lensing data, insert that as well + if (stars[i].lensing) { + catalog[0].average[Nave].Nlensing = NSTAR_GROUP; + catalog[0].average[Nave].lensingOffset = Nlens; + for (j = 0; j < NSTAR_GROUP; j++) { + // add the lensing values if they exist + if (stars[i + j].lensing) { + dvo_lensing_init (&catalog[0].lensing[Nlens]); + catalog[0].lensing[Nlens] = stars[i + j].lensing[0]; + + catalog[0].lensing[Nlens].averef = Nave; + catalog[0].lensing[Nlens].objID = catalog[0].average[Nave].objID; + catalog[0].lensing[Nlens].catID = catalog[0].catID; + next_lens[Nlens] = -1; + Nlens ++; + } + } + for (j = 0; j < NSTAR_GROUP - 1; j++) { + next_lens[Nlens - NSTAR_GROUP + j] = Nlens - NSTAR_GROUP + j + 1; + } + } + Nave ++; } @@ -309,4 +364,5 @@ REALLOCATE (catalog[0].average, Average, Nave); REALLOCATE (catalog[0].measure, Measure, Nmeas); + REALLOCATE (catalog[0].lensing, Lensing, Nlens); if (options.nosort) { @@ -315,4 +371,5 @@ catalog[0].sorted = TRUE; catalog[0].measure = sort_measure (catalog[0].average, Nave, catalog[0].measure, Nmeas, next_meas); + catalog[0].lensing = sort_lensing (catalog[0].average, Nave, catalog[0].lensing, Nlens, next_lens); } @@ -328,8 +385,8 @@ catalog[0].Naverage = Nave; catalog[0].Nmeasure = Nmeas; + catalog[0].Nlensing = Nlens; catalog[0].Nsecf_mem = Nave*Nsecfilt; - if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n", Nstars, Nave, Nmeas, Nmatch); - - free (catalog[0].found); + if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas, Nlens: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n", Nstars, Nave, Nmeas, Nlens, Nmatch); + free (X1); free (Y1); @@ -339,4 +396,5 @@ free (Y2); free (next_meas); + free (next_lens); return (Nmatch); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_closest_refstars.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_closest_refstars.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_closest_refstars.c (revision 37067) @@ -31,5 +31,5 @@ ALLOCATE (Y2, double, NAVE); ALLOCATE (N2, off_t, NAVE); - ALLOCATE (catalog[0].found, off_t, NAVE); + ALLOCATE (catalog[0].found_t, off_t, NAVE); /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */ @@ -59,5 +59,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 0; - strcpy (tcoords.ctype, "RA---ARC"); + strcpy (tcoords.ctype, "DEC--ARC"); /* build spatial index (RA sort) referencing input array sequence */ @@ -71,5 +71,4 @@ if (Nstars < 1) { if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", catalog[0].filename); - free (catalog[0].found); free (X1); free (Y1); @@ -86,5 +85,5 @@ RD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords); N2[i] = i; - catalog[0].found[N2[i]] = -1; + catalog[0].found_t[N2[i]] = -1; } if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave); @@ -180,6 +179,6 @@ /** *** dR,dD now in arcsec *** **/ - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N][0].average.R); - catalog[0].measure[Nmeas].dD = 3600.0*(catalog[0].average[n].D - stars[N][0].average.D); + catalog[0].measure[Nmeas].R = stars[N][0].average.R; + catalog[0].measure[Nmeas].D = stars[N][0].average.D; catalog[0].measure[Nmeas].dbFlags = 0; catalog[0].measure[Nmeas].averef = n; @@ -187,14 +186,16 @@ catalog[0].measure[Nmeas].catID = catalog[0].catID; + float dRoff = dvoOffsetR(&catalog[0].measure[Nmeas], &catalog[0].average[n]); + // rationalize dR: - if (catalog[0].measure[Nmeas].dR > +180.0*3600.0) { + if (dRoff > +180.0*3600.0) { // average on high end of boundary, move star up - stars[N][0].average.R += 360.0; - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N][0].average.R); - } - if (catalog[0].measure[Nmeas].dR < -180.0*3600.0) { + catalog[0].measure[Nmeas].R += 360.0; + dRoff -= 360.0*3600.0; + } + if (dRoff < -180.0*3600.0) { // average on low end of boundary, move star down - stars[N][0].average.R -= 360.0; - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N][0].average.R); + catalog[0].measure[Nmeas].R -= 360.0; + dRoff += 360.0*3600.0; } @@ -218,9 +219,9 @@ /* this catalog star matches more than one image star */ // XXX should this be an average flag? - if (catalog[0].found[n] > -1) { - catalog[0].measure[catalog[0].found[n]].dbFlags |= ID_MEAS_BLEND_OBJ; + if (catalog[0].found_t[n] > -1) { + catalog[0].measure[catalog[0].found_t[n]].dbFlags |= ID_MEAS_BLEND_OBJ; catalog[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_OBJ; } else { - catalog[0].found[n] = Nmeas; + catalog[0].found_t[n] = Nmeas; } @@ -290,6 +291,6 @@ catalog[0].measure[Nmeas] = stars[N][0].measure; - catalog[0].measure[Nmeas].dR = 0.0; // astrometric offset, not error - catalog[0].measure[Nmeas].dD = 0.0; // astrometric offset, not error + catalog[0].measure[Nmeas].R = catalog[0].average[Nave].R; + catalog[0].measure[Nmeas].D = catalog[0].average[Nave].D; catalog[0].measure[Nmeas].dbFlags = 0; catalog[0].measure[Nmeas].averef = Nave; @@ -329,5 +330,4 @@ if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n", Nstars, Nave, Nmeas, Nmatch); - free (catalog[0].found); free (X1); free (Y1); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_refstars.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_refstars.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_refstars.c (revision 37067) @@ -37,5 +37,5 @@ ALLOCATE (Y2, double, NAVE); ALLOCATE (N2, off_t, NAVE); - ALLOCATE (catalog[0].found, off_t, NAVE); + ALLOCATE (catalog[0].found_t, off_t, NAVE); REALLOCATE (catalog[0].average, Average, NAVE); REALLOCATE (catalog[0].secfilt, SecFilt, NAVE*catalog[0].Nsecfilt); @@ -57,5 +57,5 @@ tcoords.pc1_1 = tcoords.pc2_2 = 1.0; tcoords.pc1_2 = tcoords.pc2_1 = 0.0; - strcpy (tcoords.ctype, "RA---ZEA"); + strcpy (tcoords.ctype, "DEC--ZEA"); tcoords.Npolyterms = 0; @@ -69,5 +69,5 @@ RD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords); N2[i] = i; - catalog[0].found[N2[i]] = -1; + catalog[0].found_t[N2[i]] = -1; } if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave); @@ -141,7 +141,7 @@ catalog[0].measure[Nmeas] = stars[N][0].measure; - /** *** dR,dD now in arcsec *** **/ - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N][0].average.R); - catalog[0].measure[Nmeas].dD = 3600.0*(catalog[0].average[n].D - stars[N][0].average.D); + /** measure now stores R,D **/ + catalog[0].measure[Nmeas].R = stars[N][0].average.R; + catalog[0].measure[Nmeas].D = stars[N][0].average.D; catalog[0].measure[Nmeas].dbFlags = 0; catalog[0].measure[Nmeas].averef = n; @@ -149,14 +149,16 @@ catalog[0].measure[Nmeas].catID = catalog[0].catID; + float dRoff = dvoOffsetR(&catalog[0].measure[Nmeas], &catalog[0].average[n]); + // rationalize dR: - if (catalog[0].measure[Nmeas].dR > +180.0*3600.0) { + if (dRoff > +180.0*3600.0) { // average on high end of boundary, move star up - stars[N][0].average.R += 360.0; - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N][0].average.R); - } - if (catalog[0].measure[Nmeas].dR < -180.0*3600.0) { + catalog[0].measure[Nmeas].R += 360.0; + dRoff -= 360.0*3600.0; + } + if (dRoff < -180.0*3600.0) { // average on low end of boundary, move star down - stars[N][0].average.R -= 360.0; - catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N][0].average.R); + catalog[0].measure[Nmeas].R -= 360.0; + dRoff += 360.0*3600.0; } @@ -188,9 +190,9 @@ } /* this catalog star matches more than one image star */ - if (catalog[0].found[n] > -1) { - catalog[0].measure[catalog[0].found[n]].dbFlags |= ID_MEAS_BLEND_OBJ; + if (catalog[0].found_t[n] > -1) { + catalog[0].measure[catalog[0].found_t[n]].dbFlags |= ID_MEAS_BLEND_OBJ; catalog[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_OBJ; } else { - catalog[0].found[n] = Nmeas; + catalog[0].found_t[n] = Nmeas; } @@ -262,6 +264,6 @@ catalog[0].measure[Nmeas] = stars[N][0].measure; - catalog[0].measure[Nmeas].dR = 0.0; - catalog[0].measure[Nmeas].dD = 0.0; + catalog[0].measure[Nmeas].R = stars[N][0].average.R; + catalog[0].measure[Nmeas].D = stars[N][0].average.D; catalog[0].measure[Nmeas].t = (stars[N][0].measure.t == 0) ? TIMEREF : stars[N][0].measure.t; /** careful : time_t vs e_time **/ @@ -303,5 +305,4 @@ if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n", Nstars, Nave, Nmeas, Nmatch); - free (catalog[0].found); free (X1); free (Y1); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/findskycell.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/findskycell.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/findskycell.c (revision 37067) @@ -12,8 +12,10 @@ // in an even more specific case, RA[i,zone] = RA_origin[zone] + RA_offset[zone] -enum {TREE_NONE, TREE_MAKE, TREE_USE}; +enum {TREE_NONE, TREE_MAKE, TREE_LOCAL, TREE_USE}; +enum {REGION_NONE, REGION_USER, REGION_MIN, REGION_MAX}; void usage (void) { fprintf (stderr, "USAGE: findcell -mktree (tree) (catdir) [-nx Nx] [-ny Ny]\n"); + fprintf (stderr, "USAGE: findcell -mklocal (file) (catdir) [-nx Nx] [-ny Ny]\n"); fprintf (stderr, "USAGE: findcell -tree (tree) (datafile)\n"); fprintf (stderr, " (datafile) should contain a list of RA,DEC pairs\n"); @@ -22,4 +24,5 @@ int mktree (char *treefile, char *catdir); +int mklocal (char *treefile, char *catdir); int apply_tree (char *treefile, char *datafile); @@ -28,4 +31,16 @@ int NY_SUB = 1; +double R_MIN = 0.0; +double R_MAX = 0.0; +double D_MIN = 0.0; +double D_MAX = 0.0; +int REGION_OPTION = REGION_NONE; + +char *BASENAME = NULL; +int projectIDoff = -1; +int skycellIDoff = -1; + +int APPEND = FALSE; + int main (int argc, char **argv) { @@ -42,5 +57,4 @@ if (get_argument (argc, argv, "-h")) usage (); - NX_SUB = NY_SUB = 1; if ((N = get_argument (argc, argv, "-nx"))) { remove_argument (N, &argc, argv); @@ -55,8 +69,55 @@ /* pixel scale (arcsec/pixel) */ - SCALE = 1.0; if ((N = get_argument (argc, argv, "-scale"))) { remove_argument (N, &argc, argv); SCALE = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + /* pixel scale (arcsec/pixel) */ + if ((N = get_argument (argc, argv, "-append"))) { + remove_argument (N, &argc, argv); + APPEND = TRUE; + } + + // user-specified region + R_MIN = NAN; + R_MAX = NAN; + D_MIN = NAN; + D_MAX = NAN; + if ((N = get_argument (argc, argv, "-region"))) { + remove_argument (N, &argc, argv); + if (N > argc - 4) { + fprintf (stderr, "USAGE: -region requires 4 arguments (Rmin Rmax Dmin Dmax)\n"); + exit (1); + } + R_MIN = atof (argv[N]); remove_argument (N, &argc, argv); + R_MAX = atof (argv[N]); remove_argument (N, &argc, argv); + D_MIN = atof (argv[N]); remove_argument (N, &argc, argv); + D_MAX = atof (argv[N]); remove_argument (N, &argc, argv); + REGION_OPTION = REGION_USER; + } + + if ((N = get_argument (argc, argv, "-region-min"))) { + remove_argument (N, &argc, argv); + REGION_OPTION = REGION_MIN; + } + + if ((N = get_argument (argc, argv, "-region-max"))) { + remove_argument (N, &argc, argv); + REGION_OPTION = REGION_MAX; + } + + if ((N = get_argument (argc, argv, "-basename"))) { + remove_argument (N, &argc, argv); + if (N > argc - 3) { + fprintf (stderr, "USAGE: -basename (name) (proj_offset) (skycell_offset)\n"); + exit (1); + } + BASENAME = strcreate (argv[N]); + remove_argument (N, &argc, argv); + projectIDoff = atoi(argv[N]); + remove_argument (N, &argc, argv); + skycellIDoff = atoi(argv[N]); remove_argument (N, &argc, argv); } @@ -70,4 +131,10 @@ remove_argument (N, &argc, argv); } + if ((N = get_argument (argc, argv, "-mklocal"))) { + MODE = TREE_LOCAL; + remove_argument (N, &argc, argv); + treefile = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } if ((N = get_argument (argc, argv, "-tree"))) { MODE = TREE_USE; @@ -86,13 +153,12 @@ } + if (MODE == TREE_LOCAL) { + mklocal (treefile, argv[1]); + exit (0); + } + apply_tree (treefile, argv[1]); exit (0); } - -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); \ - fprintf (stderr, MSG, __VA_ARGS__); } int mktree (char *treefile, char *catdir) { @@ -330,6 +396,5 @@ } - struct timeval start, stop; - gettimeofday (&start, (void *) NULL); + INITTIME; int Npts = 10000000; @@ -348,5 +413,29 @@ MARKTIME("-- test %d pts: %f sec\n", Npts, dtime); - BoundaryTreeSave (treefile, &tree); + if (APPEND) { + int Ntess = 0; + TessellationTable *tess = TessellationTableLoad (treefile, &Ntess); + REALLOCATE (tess, TessellationTable, Ntess + 1); + TessellationTableInit (&tess[Ntess], 1); + tess[Ntess].tree = &tree; + tess[Ntess].type = TESS_RINGS; + tess[Ntess].Rmin = 0; + tess[Ntess].Rmax = 360; + tess[Ntess].Dmin = -90; + tess[Ntess].Dmax = +90; + + if (BASENAME) { + tess[Ntess].Nbasename = strlen(BASENAME); + tess[Ntess].basename = strcreate(BASENAME); + tess[Ntess].projectIDoff = projectIDoff; + tess[Ntess].skycellIDoff = skycellIDoff; + } + + // add basename an related here... + Ntess ++; + TessellationTableSave (treefile, tess, Ntess); + } else { + BoundaryTreeSave (treefile, &tree); + } return TRUE; @@ -354,4 +443,36 @@ int apply_tree (char *treefile, char *datafile) { + + int Ntess = 0; + TessellationTable *tess = TessellationTableLoad (treefile, &Ntess); + if (!tess) { + fprintf (stderr, "error loading tessellation table file %s\n", treefile); + exit (2); + } + + FILE *f = fopen (datafile, "r"); + if (!f) { + fprintf (stderr, "error opening data file %s\n", datafile); + exit (3); + } + + double ra, dec; + int Nvalue = 0; + while ((Nvalue = fscanf (f, "%lf %lf", &ra, &dec)) != EOF) { + + int tessID, projID, skycellID; + + if (!TessellationPrimaryCellIDs (tess, Ntess, &tessID, &projID, &skycellID, ra, dec)) { + fprintf (stderr, "error finding cell for %f,%f\n", ra, dec); + continue; + } + + fprintf (stdout, "%10.6f %10.6f : %2d %04d %03d : %s\n", ra, dec, tessID, projID, skycellID, tess[tessID].basename); + } + + exit (0); +} + +int apply_tree_old (char *treefile, char *datafile) { BoundaryTree *tree = BoundaryTreeLoad (treefile); @@ -405,2 +526,128 @@ } +// a given tess is defined by a catdir (more than one per catdir?) +// this function takes a catdir and generates an extension for a tess file for a local tess. + +/* + + LOCAL projections are defined by single projection cells. should I be supplying the info on + the cmd line or figure out the bounds from the catdir? + + */ + +int mklocal (char *treefile, char *catdir) { + + int i, j, status; + FITS_DB db; + Image *image; + off_t Nimage; + double x, y, ra, dec; + + if (REGION_OPTION == REGION_NONE) { + fprintf (stderr, "ERROR: need to define bounding region (-region Rmin Rmax Dmin Dmax | -region-min | -region-max)\n"); + exit (2); + } + + if (!BASENAME) { + fprintf (stderr, "ERROR: need to define BASENAME -basename (name) (proj_offset) (skycell_offset)\n"); + exit (2); + } + + char imagefile[DVO_MAX_PATH]; + snprintf (imagefile, DVO_MAX_PATH, "%s/Images.dat", catdir); + + status = dvo_image_lock (&db, imagefile, 2.0, LCK_XCLD); + if (!status) Shutdown ("ERROR: failure to lock image catalog %s", db.filename); + + /* load or create the image table */ + if (db.dbstate == LCK_EMPTY) Shutdown ("can't read image catalog %s", db.filename); + + if (!dvo_image_load (&db, TRUE, FALSE)) Shutdown ("can't read image catalog %s", db.filename); + + // convert database table to internal structure (binary to Image) + // 'image' points to the same memory as db->ftable->buffer + image = gfits_table_get_Image (&db.ftable, &Nimage, &db.swapped); + if (!image) { + fprintf (stderr, "ERROR: failed to read images\n"); + exit (2); + } + + // generate an empty BoundaryTree + TessellationTable *tess = NULL; + + int NtessDisk = 0; + if (APPEND) { + tess = TessellationTableLoad (treefile, &NtessDisk); + REALLOCATE (tess, TessellationTable, Nimage + NtessDisk); + } else { + ALLOCATE (tess, TessellationTable, Nimage + NtessDisk); + } + + TessellationTableInit (&tess[NtessDisk], Nimage); + + // find the RA,DEC of the image centers & assign to cells + int Ntess = NtessDisk; + for (i = 0; i < Nimage; i++) { + // user supplied values, do not try to derive from Image.dat + tess[Ntess].NX_SUB = NX_SUB; + tess[Ntess].NY_SUB = NY_SUB; + tess[Ntess].dPix = SCALE/3600.0; + + x = 0.5*image[i].NX; + y = 0.5*image[i].NY; + XY_to_RD (&ra, &dec, x, y, &image[i].coords); + + tess[Ntess].Ro = ra; + tess[Ntess].Do = dec; + tess[Ntess].Xo = x; + tess[Ntess].Yo = y; + tess[Ntess].dX = image[i].NX / NX_SUB; + tess[Ntess].dY = image[i].NY / NY_SUB; + + // find the minimum or maximum containing region + if ((REGION_OPTION == REGION_MIN) || (REGION_OPTION == REGION_MAX)) { + // XXX short cut for now : if the projection cell bounds the equator or 0,360 boundary, this will fail: + double R[4], D[4]; + XY_to_RD (&R[0], &D[0], 0, 0, &image[i].coords); + XY_to_RD (&R[1], &D[1], image[i].NX, 0, &image[i].coords); + XY_to_RD (&R[2], &D[2], 0, image[i].NY, &image[i].coords); + XY_to_RD (&R[3], &D[3], image[i].NX, image[i].NY, &image[i].coords); + + if (REGION_OPTION == REGION_MIN) { + for (j = 0; j < 4; j++) { + R_MIN = (R[j] < ra) ? (isfinite(R_MIN) ? MAX(R_MIN, R[j]) : R[j]) : R_MIN; + R_MAX = (R[j] > ra) ? (isfinite(R_MAX) ? MIN(R_MAX, R[j]) : R[j]) : R_MAX; + D_MIN = (D[j] < dec) ? (isfinite(D_MIN) ? MAX(D_MIN, D[j]) : D[j]) : D_MIN; + D_MAX = (D[j] > dec) ? (isfinite(D_MAX) ? MIN(D_MAX, D[j]) : D[j]) : D_MAX; + } + } else { + for (j = 0; j < 4; j++) { + R_MIN = (R[j] < ra) ? (isfinite(R_MIN) ? MIN(R_MIN, R[j]) : R[j]) : R_MIN; + R_MAX = (R[j] > ra) ? (isfinite(R_MAX) ? MAX(R_MAX, R[j]) : R[j]) : R_MAX; + D_MIN = (D[j] < dec) ? (isfinite(D_MIN) ? MIN(D_MIN, D[j]) : D[j]) : D_MIN; + D_MAX = (D[j] > dec) ? (isfinite(D_MAX) ? MAX(D_MAX, D[j]) : D[j]) : D_MAX; + } + } + } + tess[Ntess].Rmin = R_MIN; + tess[Ntess].Rmax = R_MAX; + tess[Ntess].Dmin = D_MIN; + tess[Ntess].Dmax = D_MAX; + + tess[Ntess].type = TESS_LOCAL; + + // XXX I don't really want to do the work of discovering the rule... + tess[Ntess].Nbasename = strlen(BASENAME); + tess[Ntess].basename = strcreate(BASENAME); + + tess[Ntess].projectIDoff = projectIDoff; + tess[Ntess].skycellIDoff = skycellIDoff; + + Ntess ++; + } + + TessellationTableSave (treefile, tess, Ntess); + + return TRUE; +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/load2mass_catalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/load2mass_catalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/load2mass_catalog.c (revision 37067) @@ -17,10 +17,13 @@ for (i = 0; i < Nstars; i+=3) { + double R = stars[i].average.R; + double D = stars[i].average.D; + // construct an average object for this object // XXX for now, the output objects will have limited astrometric interpretation... // XXX every 3 stars represents 3 measurements and 1 average dvo_average_init (&catalog[0].average[Nave]); - catalog[0].average[Nave].R = stars[i].average.R; - catalog[0].average[Nave].D = stars[i].average.D; + catalog[0].average[Nave].R = R; + catalog[0].average[Nave].D = D; catalog[0].average[Nave].measureOffset = Nmeas; @@ -33,6 +36,6 @@ catalog[0].measure[Nmeas] = stars[i+j].measure; - catalog[0].measure[Nmeas].dR = 0.0; - catalog[0].measure[Nmeas].dD = 0.0; + catalog[0].measure[Nmeas].R = R; + catalog[0].measure[Nmeas].D = D; catalog[0].measure[Nmeas].dt = NAN_S_SHORT; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/loadsupercos_ops.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/loadsupercos_ops.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/loadsupercos_ops.c (revision 37067) @@ -1,7 +1,4 @@ # include "addstar.h" # include "supercos.h" - -// this is defined in libohana/src/string.c but not generally exposed -char *_parse_nextword_csv (char *string); int loadsupercos_getFilterInfo (char *line, char *emulsion, char *filterID) { @@ -13,5 +10,5 @@ // emulsion is field 11, filterID is field 12 for (i = 1; i < 11; i++) { - p1 = _parse_nextword_csv (p1); + p1 = parse_nextword_csv (p1); if (!p1) { fprintf (stderr, "error parsing filter info for line %s\n", line); @@ -24,5 +21,5 @@ } - char *p2 = _parse_nextword_csv (p1); + char *p2 = parse_nextword_csv (p1); if (!p2) { fprintf (stderr, "error parsing filter info for line %s\n", line); @@ -34,5 +31,5 @@ } - char *p3 = _parse_nextword_csv (p2); + char *p3 = parse_nextword_csv (p2); if (!p3) { fprintf (stderr, "error parsing filter info for line %s\n", line); @@ -60,5 +57,5 @@ // lstObs is field 20 for (i = 1; i < 20; i++) { - p1 = _parse_nextword_csv (p1); + p1 = parse_nextword_csv (p1); if (!p1) { fprintf (stderr, "error parsing filter info for line %s\n", line); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/loadsupercos_plates.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/loadsupercos_plates.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/loadsupercos_plates.c (revision 37067) @@ -118,5 +118,5 @@ // for now, we define a fake coordinate system based on the boresite center - strcpy (image[Nimage].coords.ctype, "RA---TAN"); + strcpy (image[Nimage].coords.ctype, "DEC--TAN"); image[Nimage].coords.crval1 = RAo; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/mkcmf.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/mkcmf.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/mkcmf.c (revision 37067) @@ -1,4 +1,5 @@ # include "mkcmf.h" +# define ZERO_POINT 25.0 # define SKY 100.0 # define DSKY 2.0 @@ -14,8 +15,11 @@ void gauss_init (int Nbin); double rnd_gauss (double mean, double sigma); +void writeStars_PS1_V5_Lensing (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars); +void writeStars_PS1_V5 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars); void writeStars_PS1_V4 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars); void writeStars_PS1_V3 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars); void writeStars_PS1_V2 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars); void writeStars_PS1_V1 (FTable *ftable, double *X, double *Y, double *M, int Nstars); +void writeStars_PS1_SV3 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars); void writeStars_PS1_DEV_1 (FTable *ftable, double *X, double *Y, double *M, int Nstars); void writeStars_PS1_DEV_0 (FTable *ftable, double *X, double *Y, double *M, int Nstars); @@ -23,4 +27,7 @@ int ADDNOISE = TRUE; float BAD_PSFQF_FRAC = 0.0; + +static float exptime = 1.0; +static Coords coords; int main (int argc, char **argv) { @@ -38,5 +45,4 @@ Matrix matrix; FTable ftable; - Coords coords; int APPEND = FALSE; @@ -105,5 +111,4 @@ } - float exptime = 1.0; if ((N = get_argument (argc, argv, "-exptime"))) { remove_argument (N, &argc, argv); @@ -288,5 +293,5 @@ gfits_modify (&header, "UTC-OBS", "%s", 1, time); } - gfits_modify (&header, "ZERO_PT", "%lf", 1, 25.0); + gfits_modify (&header, "ZERO_PT", "%lf", 1, ZERO_POINT); gfits_modify (&header, "EXPTIME", "%lf", 1, exptime); gfits_modify (&header, "AIRMASS", "%lf", 1, airmass); @@ -327,4 +332,16 @@ if (!strcmp(type, "PS1_V4")) { writeStars_PS1_V4 (&ftable, X, Y, M, Flag, Nstars); + found = TRUE; + } + if (!strcmp(type, "PS1_V5")) { + writeStars_PS1_V5 (&ftable, X, Y, M, Flag, Nstars); + found = TRUE; + } + if (!strcmp(type, "PS1_V5_Lensing")) { + writeStars_PS1_V5_Lensing (&ftable, X, Y, M, Flag, Nstars); + found = TRUE; + } + if (!strcmp(type, "PS1_SV3")) { + writeStars_PS1_SV3 (&ftable, X, Y, M, Flag, Nstars); found = TRUE; } @@ -764,2 +781,353 @@ } +void writeStars_PS1_V5 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars) { + + int i; + CMF_PS1_V5 *stars; + float flux, fSN; + + // XXX add gaussian-distributed noise based on counts + // this needs to make different output 'stars' entries depending on the desired type + ALLOCATE (stars, CMF_PS1_V5, Nstars); + for (i = 0; i < Nstars; i++) { + + flux = pow (10.0, -0.4*M[i]); + fSN = 1.0 / sqrt(flux); + + stars[i].detID = i; + stars[i].X = X[i]; + stars[i].Y = Y[i]; + stars[i].dX = FX * fSN; + stars[i].dY = FY * fSN; + + stars[i].posangle = 10.0; + stars[i].pltscale = 0.25; + + stars[i].M = M[i]; + stars[i].dM = fSN; + + stars[i].Flux = flux; + stars[i].dFlux = flux * fSN; + + stars[i].Map = M[i] - 0.05; + stars[i].MapRaw = M[i] - 0.10; + + stars[i].apRadius = 8.0; + + stars[i].apFlux = pow(10.0, -0.4*stars[i].Map); + stars[i].apFluxErr = stars[i].apFlux * fSN; + + stars[i].Mcalib = M[i] + ZERO_POINT + 2.5*log10(exptime); + stars[i].dMcal = 0.05; + + XY_to_RD (&stars[i].RA, &stars[i].DEC, X[i], Y[i], &coords); + stars[i].apNpix = 3.14*8.0*8.0; + + stars[i].Mpeak = M[i] + 1.0; + stars[i].sky = SKY; + stars[i].dSky = DSKY; + stars[i].psfChisq = PSFCHI; + stars[i].crNsigma = CRN; + stars[i].extNsigma = EXTN; + stars[i].fx = FX; + stars[i].fy = FY; + stars[i].df = DF; + + stars[i].k = 1.0; + stars[i].fwhmMaj = FX*2.8; + stars[i].fwhmMin = FY*2.8; + + // randomly give poor PSFQF values + if ((BAD_PSFQF_FRAC > 0.0) && (drand48() < BAD_PSFQF_FRAC)) { + stars[i].psfQF = 0.25; + stars[i].psfQFperf = 0.24; + } else { + stars[i].psfQF = PSFQUAL; + stars[i].psfQFperf = MAX(PSFQUAL - 0.01, 0.0); + } + + stars[i].psfNdof = 1; + stars[i].psfNpix = 2; + + stars[i].Mxx = FX; + stars[i].Mxy = 0.01; + stars[i].Myy = FX; + stars[i].M3c = FX; + stars[i].M3s = FX; + stars[i].M4c = FX; + stars[i].M4s = FX; + stars[i].Mr1 = FX; + stars[i].Mrh = FX; + + stars[i].kronFlux = flux * 1.25; + stars[i].kronFluxErr = fSN * flux * 1.25; + + stars[i].kronInner = fSN * flux * 0.9; + stars[i].kronOuter = fSN * flux * 1.5; + + stars[i].skyLimitRad = 1; + stars[i].skyLimitFlux = 2; + stars[i].skyLimitSlope = 0.2; + + stars[i].flags = Flag[i]; + stars[i].flags2 = 0x80; + + stars[i].nFrames = 1; + + if (ADDNOISE) { + stars[i].X += FX * fSN * rnd_gauss(0.0, 1.0); + stars[i].Y += FY * fSN * rnd_gauss(0.0, 1.0); + float Moff = fSN*rnd_gauss(0.0, 1.0); + stars[i].M += Moff; + stars[i].Map += Moff; + stars[i].MapRaw += Moff; + stars[i].Mcalib += Moff; + } + } + + gfits_table_set_CMF_PS1_V5 (ftable, stars, Nstars); + gfits_modify (ftable->header, "EXTTYPE", "%s", 1, "PS1_V5"); +} + +void writeStars_PS1_SV3 (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars) { + + int i; + CMF_PS1_SV3 *stars; + float flux, fSN; + + // XXX add gaussian-distributed noise based on counts + // this needs to make different output 'stars' entries depending on the desired type + ALLOCATE (stars, CMF_PS1_SV3, Nstars); + for (i = 0; i < Nstars; i++) { + + flux = pow (10.0, -0.4*M[i]); + fSN = 1.0 / sqrt(flux); + + stars[i].detID = i; + stars[i].X = X[i]; + stars[i].Y = Y[i]; + stars[i].dX = FX * fSN; + stars[i].dY = FY * fSN; + + stars[i].posangle = 10.0; + stars[i].pltscale = 0.25; + + stars[i].M = M[i]; + stars[i].dM = fSN; + + stars[i].Flux = flux; + stars[i].dFlux = flux * fSN; + + stars[i].Map = M[i] - 0.05; + stars[i].MapRaw = M[i] - 0.10; + + stars[i].apRadius = 8.0; + + stars[i].apFlux = pow(10.0, -0.4*stars[i].Map); + stars[i].apFluxErr = stars[i].apFlux * fSN; + + stars[i].Mcalib = M[i] + ZERO_POINT + 2.5*log10(exptime); + stars[i].dMcal = 0.05; + + XY_to_RD (&stars[i].RA, &stars[i].DEC, X[i], Y[i], &coords); + stars[i].apNpix = 3.14*8.0*8.0; + + stars[i].Mpeak = M[i] + 1.0; + stars[i].sky = SKY; + stars[i].dSky = DSKY; + stars[i].psfChisq = PSFCHI; + stars[i].crNsigma = CRN; + stars[i].extNsigma = EXTN; + stars[i].fx = FX; + stars[i].fy = FY; + stars[i].df = DF; + + stars[i].k = 1.0; + stars[i].fwhmMaj = FX*2.8; + stars[i].fwhmMin = FY*2.8; + + // randomly give poor PSFQF values + if ((BAD_PSFQF_FRAC > 0.0) && (drand48() < BAD_PSFQF_FRAC)) { + stars[i].psfQF = 0.25; + stars[i].psfQFperf = 0.24; + } else { + stars[i].psfQF = PSFQUAL; + stars[i].psfQFperf = MAX(PSFQUAL - 0.01, 0.0); + } + + stars[i].psfNdof = 1; + stars[i].psfNpix = 2; + + stars[i].Mxx = FX; + stars[i].Mxy = 0.01; + stars[i].Myy = FX; + stars[i].M3c = FX; + stars[i].M3s = FX; + stars[i].M4c = FX; + stars[i].M4s = FX; + stars[i].Mr1 = FX; + stars[i].Mrh = FX; + + stars[i].kronFlux = flux * 1.25; + stars[i].kronFluxErr = fSN * flux * 1.25; + + stars[i].kronInner = fSN * flux * 0.9; + stars[i].kronOuter = fSN * flux * 1.5; + + // stars[i].skyLimitRad = 1; + // stars[i].skyLimitFlux = 2; + // stars[i].skyLimitSlope = 0.2; + + stars[i].flags = Flag[i]; + stars[i].flags2 = 0x80; + + stars[i].nFrames = 1; + + if (ADDNOISE) { + stars[i].X += FX * fSN * rnd_gauss(0.0, 1.0); + stars[i].Y += FY * fSN * rnd_gauss(0.0, 1.0); + float Moff = fSN*rnd_gauss(0.0, 1.0); + stars[i].M += Moff; + stars[i].Map += Moff; + stars[i].MapRaw += Moff; + stars[i].Mcalib += Moff; + } + } + + gfits_table_set_CMF_PS1_SV3 (ftable, stars, Nstars); + gfits_modify (ftable->header, "EXTTYPE", "%s", 1, "PS1_SV3"); +} + +void writeStars_PS1_V5_Lensing (FTable *ftable, double *X, double *Y, double *M, unsigned int *Flag, int Nstars) { + + int i; + CMF_PS1_V5_Lensing *stars; + float flux, fSN; + + // XXX add gaussian-distributed noise based on counts + // this needs to make different output 'stars' entries depending on the desired type + ALLOCATE (stars, CMF_PS1_V5_Lensing, Nstars); + for (i = 0; i < Nstars; i++) { + + flux = pow (10.0, -0.4*M[i]); + fSN = 1.0 / sqrt(flux); + + stars[i].detID = i; + stars[i].X = X[i]; + stars[i].Y = Y[i]; + stars[i].dX = FX * fSN; + stars[i].dY = FY * fSN; + + stars[i].posangle = 10.0; + stars[i].pltscale = 0.25; + + stars[i].M = M[i]; + stars[i].dM = fSN; + + stars[i].Flux = flux; + stars[i].dFlux = flux * fSN; + + stars[i].Map = M[i] - 0.05; + stars[i].MapRaw = M[i] - 0.10; + + stars[i].apRadius = 8.0; + + stars[i].apFlux = pow(10.0, -0.4*stars[i].Map); + stars[i].apFluxErr = stars[i].apFlux * fSN; + + stars[i].Mcalib = M[i] + ZERO_POINT + 2.5*log10(exptime); + stars[i].dMcal = 0.05; + + XY_to_RD (&stars[i].RA, &stars[i].DEC, X[i], Y[i], &coords); + stars[i].apNpix = 3.14*8.0*8.0; + + stars[i].Mpeak = M[i] + 1.0; + stars[i].sky = SKY; + stars[i].dSky = DSKY; + stars[i].psfChisq = PSFCHI; + stars[i].crNsigma = CRN; + stars[i].extNsigma = EXTN; + stars[i].fx = FX; + stars[i].fy = FY; + stars[i].df = DF; + + stars[i].k = 1.0; + stars[i].fwhmMaj = FX*2.8; + stars[i].fwhmMin = FY*2.8; + + // randomly give poor PSFQF values + if ((BAD_PSFQF_FRAC > 0.0) && (drand48() < BAD_PSFQF_FRAC)) { + stars[i].psfQF = 0.25; + stars[i].psfQFperf = 0.24; + } else { + stars[i].psfQF = PSFQUAL; + stars[i].psfQFperf = MAX(PSFQUAL - 0.01, 0.0); + } + + stars[i].psfNdof = 1; + stars[i].psfNpix = 2; + + stars[i].Mxx = FX; + stars[i].Mxy = 0.01; + stars[i].Myy = FX; + stars[i].M3c = FX; + stars[i].M3s = FX; + stars[i].M4c = FX; + stars[i].M4s = FX; + stars[i].Mr1 = FX; + stars[i].Mrh = FX; + + stars[i].X11_sm_obj = FX; + stars[i].X12_sm_obj = FX; + stars[i].X22_sm_obj = FY; + stars[i].E1_sm_obj = FX; + stars[i].E2_sm_obj = FX; + + stars[i].X11_sh_obj = FX; + stars[i].X12_sh_obj = 0.2; + stars[i].X22_sh_obj = FY; + stars[i].E1_sh_obj = FX*0.9; + stars[i].E2_sh_obj = FX*0.8; + + stars[i].X11_sm_psf = FX; + stars[i].X12_sm_psf = FX; + stars[i].X22_sm_psf = FX; + stars[i].E1_sm_psf = FX; + stars[i].E2_sm_psf = FX; + + stars[i].X11_sh_psf = FX; + stars[i].X12_sh_psf = FX; + stars[i].X22_sh_psf = FX; + stars[i].E1_sh_psf = FX; + stars[i].E2_sh_psf = FX; + + stars[i].kronFlux = flux * 1.25; + stars[i].kronFluxErr = fSN * flux * 1.25; + + stars[i].kronInner = fSN * flux * 0.9; + stars[i].kronOuter = fSN * flux * 1.5; + + stars[i].skyLimitRad = 1; + stars[i].skyLimitFlux = 2; + stars[i].skyLimitSlope = 0.2; + + stars[i].flags = Flag[i]; + stars[i].flags2 = 0x80; + + stars[i].nFrames = 1; + + if (ADDNOISE) { + stars[i].X += FX * fSN * rnd_gauss(0.0, 1.0); + stars[i].Y += FY * fSN * rnd_gauss(0.0, 1.0); + float Moff = fSN*rnd_gauss(0.0, 1.0); + stars[i].M += Moff; + stars[i].Map += Moff; + stars[i].MapRaw += Moff; + stars[i].Mcalib += Moff; + } + } + + gfits_table_set_CMF_PS1_V5_Lensing (ftable, stars, Nstars); + gfits_modify (ftable->header, "EXTTYPE", "%s", 1, "PS1_V5"); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/replace_match.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/replace_match.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/replace_match.c (revision 37067) @@ -12,6 +12,6 @@ j = i + m; if (measure[j].photcode != star[0].measure.photcode) continue; - measure[j].dR = 3600.0*(average[0].R - star[0].average.R); - measure[j].dD = 3600.0*(average[0].D - star[0].average.D); + measure[j].R = star[0].average.R; + measure[j].D = star[0].average.D; measure[j].M = star[0].measure.M; measure[j].dM = star[0].measure.dM; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_catalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_catalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_catalog.c (revision 37067) @@ -1,3 +1,7 @@ # include "addstar.h" + +void SortAveMatch (off_t *MEAS, off_t *AVE, off_t N); +void resort_catalog_measure (Catalog *catalog); +void resort_catalog_lensing (Catalog *catalog); void resort_catalog_old (Catalog *catalog) { @@ -5,10 +9,8 @@ off_t *next_meas; off_t Naves, Nmeas; - double dtime; - struct timeval start, stop; if (catalog[0].sorted == TRUE) return; - gettimeofday (&start, NULL); + INITTIME; /* internal counters */ @@ -22,34 +24,18 @@ catalog[0].measure = sort_measure (catalog[0].average, Naves, catalog[0].measure, Nmeas, next_meas); - gettimeofday (&stop, NULL); - dtime = DTIME (stop, start); - fprintf (stderr, " match time %9.4f sec for %7lld measures, %6lld average\n", dtime, (long long) Nmeas, (long long) Naves); + MARKTIME (" match time %9.4f sec for %7lld measures, %6lld average\n", dtime, (long long) Nmeas, (long long) Naves); return; } -// sort the measure Sequence based on the average Sequence entries -void SortAveMeasMatch (off_t *MEAS, off_t *AVE, off_t N) { - -# define SWAPFUNC(A,B){ off_t tmp_meas; off_t tmp_ave; \ - tmp_meas = MEAS[A]; MEAS[A] = MEAS[B]; MEAS[B] = tmp_meas; \ - tmp_ave = AVE[A]; AVE[A] = AVE[B]; AVE[B] = tmp_ave; \ - } -# define COMPARE(A,B)(AVE[A] < AVE[B]) - OHANA_SORT (N, COMPARE, SWAPFUNC); -# undef SWAPFUNC -# undef COMPARE -} - -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); start = stop; \ - fprintf (stderr, MSG, __VA_ARGS__); } - -// XXX : where is the time going? perhaps the ALLOCATE? -// XXX : I don't thnk his is getting the right answer yet. - void resort_catalog (Catalog *catalog) { + + if (catalog[0].sorted == TRUE) return; + + resort_catalog_measure (catalog); + resort_catalog_lensing (catalog); +} + +void resort_catalog_measure (Catalog *catalog) { off_t Naverage, Nmeasure; @@ -62,6 +48,4 @@ Measure *measureTMP = NULL; - if (catalog[0].sorted == TRUE) return; - // struct timeval start, stop; // gettimeofday (&start, NULL); @@ -70,4 +54,6 @@ Nmeasure = catalog[0].Nmeasure; Naverage = catalog[0].Naverage; + + if (!Nmeasure) return; measure = catalog[0].measure; @@ -113,5 +99,5 @@ // fprintf (stderr, "\n"); - SortAveMeasMatch(measureSeq, averageSeq, Nmeasure); + SortAveMatch(measureSeq, averageSeq, Nmeasure); // MARKTIME("sort : %f sec\n", dtime); @@ -188,2 +174,152 @@ } +void resort_catalog_lensing (Catalog *catalog) { + + off_t Naverage, Nlensing; + Lensing *lensing; + Average *average; + off_t i, j, N, currentAve; + + off_t *lensingSeq = NULL; + off_t *averageSeq = NULL; + Lensing *lensingTMP = NULL; + + // struct timeval start, stop; + // gettimeofday (&start, NULL); + + /* internal counters */ + Nlensing = catalog[0].Nlensing; + Naverage = catalog[0].Naverage; + + if (!Nlensing) return; + + lensing = catalog[0].lensing; + average = catalog[0].average; + + // we have a table of average objects and an unsorted table of measurements. each measurement + // has a reference to the average object sequence (as well as an ID) + // lensing[i].averef -> average[averef] + // lensing[i].objID = average[averef].objID + // lensing[i].catID = average[averef].catID + + // we want a sorted lensing array with all averef entries in sequence + + ALLOCATE (lensingSeq, off_t, Nlensing); + ALLOCATE (averageSeq, off_t, Nlensing); + + for (i = 0; i < Nlensing; i++) { + lensingSeq[i] = i; + averageSeq[i] = lensing[i].averef; + + if (catalog[0].catformat >= DVO_FORMAT_PS1_V1) { + // earlier formats did not carry the objID or catID, so they are not available (we could assign on load, but we don't) + myAssert(average[averageSeq[i]].catID == lensing[lensingSeq[i]].catID, "object / detection mismatch"); +# if (1) + myAssert(average[averageSeq[i]].objID == lensing[lensingSeq[i]].objID, "object / detection mismatch"); +# else + // for reasons I do not understand, the mini dvodbs generated on stsci1X had a handful of detections with an inconsistency between averef and objID. + // this happened for 28 detections in the dbs on /data/stsci1?.0/eugene/dvo3pi.20130616, but not at all (as far as I know) in the rest of LAP DVO + if (average[averageSeq[i]].objID != lensing[lensingSeq[i]].objID) { + fprintf (stderr, "R"); + lensing[lensingSeq[i]].objID = average[averageSeq[i]].objID; // XXX I don't really like this... + } +# endif + } + } + + // check that averageSeq is now in order + // for (i = 1; i < Nlensing; i++) { + // if (averageSeq[i] < averageSeq[i-1]) { + // fprintf (stderr, "%d ", (int) i); + // } + // } + // fprintf (stderr, "\n"); + + SortAveMatch(lensingSeq, averageSeq, Nlensing); + // MARKTIME("sort : %f sec\n", dtime); + + // check that averageSeq is now in order + // for (i = 1; i < Nlensing; i++) { + // if (averageSeq[i] < averageSeq[i-1]) { + // fprintf (stderr, "%d ", (int) i); + // } + // } + // fprintf (stderr, "\n"); + + // copy the lensing entries in the sorted order + ALLOCATE (lensingTMP, Lensing, Nlensing); + for (i = 0; i < Nlensing; i++) { + j = lensingSeq[i]; + lensingTMP[i] = lensing[j]; + } + // MARKTIME("assign lensing : %f sec\n", dtime); + + // update the values of average.lensingOffset and average.Nlensing + FREE(lensing); + catalog[0].lensing = lensingTMP; + + N = 0; + currentAve = averageSeq[0]; + average[currentAve].lensingOffset = 0; + for (i = 0; i < Nlensing; i++) { + if (averageSeq[i] != currentAve) { + // we have hit the next entry in the list + average[currentAve].Nlensing = N; + N = 0; + currentAve = averageSeq[i]; + average[currentAve].lensingOffset = i; + } + N++; + } + // N++; + average[currentAve].Nlensing = N; + // MARKTIME("update Nlensing : %f sec\n", dtime); + + int NlensingTotal = 0; + int lensingOffsetOK = TRUE; + for (i = 0; i < Naverage; i++) { + NlensingTotal += catalog[0].average[i].Nlensing; + if (VERBOSE && !(NlensingTotal <= catalog[0].Nlensing)) { + fprintf (stderr, "too few lensing: %d %d %d\n", (int) i, NlensingTotal, (int) catalog[0].Nlensing); + } + lensingOffsetOK &= (catalog[0].average[i].lensingOffset < catalog[0].Nlensing); + if (VERBOSE && !(catalog[0].average[i].lensingOffset < catalog[0].Nlensing)) { + fprintf (stderr, "offset too large: %d %d %d\n", (int) i, catalog[0].average[i].Nlensing, (int) catalog[0].Nlensing); + } + lensingOffsetOK &= (catalog[0].average[i].lensingOffset + catalog[0].average[i].Nlensing <= catalog[0].Nlensing); + if (VERBOSE && !(catalog[0].average[i].lensingOffset + catalog[0].average[i].Nlensing <= catalog[0].Nlensing)) { + fprintf (stderr, "orrset + Nlensing too large: %d + %d > %d %d\n", (int) i, catalog[0].average[i].lensingOffset, catalog[0].average[i].Nlensing, (int) catalog[0].Nlensing); + } + } + + if (!lensingOffsetOK) { + fprintf (stderr, "ERROR: catalog %s has an invalid lensingOffset\n", catalog[0].filename); + } + + if (NlensingTotal != catalog[0].Nlensing) { + fprintf (stderr, "ERROR: catalog %s has an invalid Nlensing\n", catalog[0].filename); + } + + // MARKTIME(" match time %9.4f sec for %7lld lensings, %6lld average\n", dtime, (long long) Nlensing, (long long) Naverage); + + catalog[0].sorted = TRUE; + + FREE (lensingSeq); + FREE (averageSeq); + + return; +} + +// sort the measure or lensing Sequence based on the average Sequence entries +void SortAveMatch (off_t *MEAS, off_t *AVE, off_t N) { + +# define SWAPFUNC(A,B){ off_t tmp_meas; off_t tmp_ave; \ + tmp_meas = MEAS[A]; MEAS[A] = MEAS[B]; MEAS[B] = tmp_meas; \ + tmp_ave = AVE[A]; AVE[A] = AVE[B]; AVE[B] = tmp_ave; \ + } +# define COMPARE(A,B)(AVE[A] < AVE[B]) + OHANA_SORT (N, COMPARE, SWAPFUNC); +# undef SWAPFUNC +# undef COMPARE +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_threaded.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_threaded.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_threaded.c (revision 37067) @@ -41,5 +41,5 @@ catalog.catformat = dvo_catalog_catformat (CATFORMAT); // set the default catformat from config data catalog.catmode = dvo_catalog_catmode (CATMODE); // set the default catmode from config data - catalog.catflags = LOAD_AVES | LOAD_MEAS; + catalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_LENSING; catalog.Nsecfilt = GetPhotcodeNsecfilt (); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_unthreaded_catalogs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_unthreaded_catalogs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_unthreaded_catalogs.c (revision 37067) @@ -30,5 +30,5 @@ catalog.catformat = dvo_catalog_catformat (CATFORMAT); // set the default catformat from config data catalog.catmode = dvo_catalog_catmode (CATMODE); // set the default catmode from config data - catalog.catflags = LOAD_AVES | LOAD_MEAS; + catalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_LENSING; catalog.Nsecfilt = GetPhotcodeNsecfilt (); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/sky_tessalation.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/sky_tessalation.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/sky_tessalation.c (revision 37067) @@ -1106,5 +1106,5 @@ refcoords[0].Npolyterms = 0; memset (refcoords[0].polyterms, 0, 14*sizeof(float)); - strcpy (refcoords[0].ctype, "RA---TAN"); + strcpy (refcoords[0].ctype, "DEC--TAN"); return (TRUE); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/update_coords.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/update_coords.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/update_coords.c (revision 37067) @@ -19,6 +19,6 @@ continue; } - R = measure[m].dR; - D = measure[m].dD; + R = measure[m].R; + D = measure[m].D; r += R; d += D; @@ -33,13 +33,8 @@ r = r / Npt; /* these are corrections in 1/100 arcsec to RA and DEC */ d = d / Npt; - average[0].R -= r / 3600.0; - average[0].D -= d / 3600.0; + average[0].R = r; + average[0].D = d; m = average[0].measureOffset; /* first measurement of this star */ - for (i = 0; i < average[0].Nmeasure; i++) { - measure[m].dR -= r; - measure[m].dD -= d; - m = next[m]; - } - + /* measure scatter, if possible */ if (Npt < 2) return; @@ -47,5 +42,5 @@ dR2 = r2 / Npt - r*r; dD2 = d2 / Npt - d*d; - average[0].ChiSqAve = sqrt (dD2 + dR2 / SQ(cos(d*RAD_DEG))); + average[0].ChiSqAve = 3600.0*sqrt (dD2 + dR2 / SQ(cos(d*RAD_DEG))); /* ChiSqAve is supposed to be a chisq */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/test/simple.dvo =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/test/simple.dvo (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/test/simple.dvo (revision 37067) @@ -7,30 +7,34 @@ test.fields PS1_DEV_0 PS1_V1 test.fields PS1_DEV_1 PS1_V1 - test.fields PS1_V1 PS1_V1 - test.fields PS1_V2 PS1_V1 - test.fields PS1_V3 PS1_V1 - test.fields PS1_V4 PS1_V1 + test.fields PS1_V1 PS1_V1 + test.fields PS1_V2 PS1_V1 + test.fields PS1_V3 PS1_V1 + test.fields PS1_V4 PS1_V1 test.fields PS1_DEV_0 PS1_V2 test.fields PS1_DEV_1 PS1_V2 - test.fields PS1_V1 PS1_V2 - test.fields PS1_V2 PS1_V2 - test.fields PS1_V3 PS1_V2 - test.fields PS1_V4 PS1_V4 + test.fields PS1_V1 PS1_V2 + test.fields PS1_V2 PS1_V2 + test.fields PS1_V3 PS1_V2 + test.fields PS1_V4 PS1_V4 test.fields PS1_DEV_0 PS1_V3 test.fields PS1_DEV_1 PS1_V3 - test.fields PS1_V1 PS1_V3 - test.fields PS1_V2 PS1_V3 - test.fields PS1_V3 PS1_V3 - test.fields PS1_V4 PS1_V4 + test.fields PS1_V1 PS1_V3 + test.fields PS1_V2 PS1_V3 + test.fields PS1_V3 PS1_V3 + test.fields PS1_V4 PS1_V4 test.fields PS1_DEV_0 PS1_V4 test.fields PS1_DEV_1 PS1_V4 - test.fields PS1_V1 PS1_V4 - test.fields PS1_V2 PS1_V4 - test.fields PS1_V3 PS1_V4 - test.fields PS1_V4 PS1_V4 + test.fields PS1_V1 PS1_V4 + test.fields PS1_V2 PS1_V4 + test.fields PS1_V3 PS1_V4 + test.fields PS1_V4 PS1_V4 end + +if (not($?NO_NOISE)) + $NO_NOISE = "" +end # create a populated catdir with a single cmf -- test each field @@ -50,9 +54,11 @@ mkinput - exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 01:00:00 -radec $RA $DEC -type $1 + echo mkcmf test.in.txt test.cmf -date 2008/1/1 -time 01:00:00 -radec $RA $DEC -type $1 $NO_NOISE + exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 01:00:00 -radec $RA $DEC -type $1 $NO_NOISE if ($TAP_VERBOSE) echo exec addstar -D CATDIR catdir.test -D CAMERA simtest test.cmf -D CATFORMAT $2 -quick-airmass exec addstar -D CATDIR catdir.test -D CAMERA simtest test.cmf -D CATFORMAT $2 -quick-airmass else + echo addstar -D CATDIR catdir.test -D CAMERA simtest test.cmf -D CATFORMAT $2 -quick-airmass exec addstar -D CATDIR catdir.test -D CAMERA simtest test.cmf -D CATFORMAT $2 -quick-airmass >& tmp.log end @@ -112,9 +118,17 @@ # some fields require arithmetic manipulations - if ("$name:0" == "KRON_FLUX") - set v1 = -2.5*log(v1) - end - if ("$name:0" == "KRON_FLUX_ERR") - set v1 = KRON_FLUX_ERR / KRON_FLUX + ## if ("$name:0" == "KRON_FLUX") + ## set v1 = -2.5*log(v1) + ## end + ## if ("$name:0" == "KRON_FLUX_ERR") + ## set v1 = KRON_FLUX_ERR / KRON_FLUX + ## end + if (("$name:0" == "X_PSF_SIG") || ("$name:0" == "Y_PSF_SIG")) + set v1 = int(100*(v1)) + set v2 = int(100*(v2 + 0.0001)) + end + if ("$name:0" == "POSANGLE") + set v1 = int((0xffff/360.0)*(v1)) + set v2 = int((0xffff/360.0)*(v2 + 0.0028)) end @@ -206,7 +220,7 @@ # this list is good for PS1_V1 list testfields_PS1_V1 - IPP_IDET : detid - X_PSF : xccd - Y_PSF : yccd + IPP_IDET : detid + X_PSF : xccd + Y_PSF : yccd X_PSF_SIG : xccd:err # FAIL Y_PSF_SIG : yccd:err # FAIL @@ -215,6 +229,6 @@ POSANGLE : SKIP # astrometry is not calibrated in the cmf PLTSCALE : SKIP # astrometry is not calibrated in the cmf - PSF_INST_MAG : mag:inst - PSF_INST_MAG_SIG : mag:err + PSF_INST_MAG : mag:inst + PSF_INST_MAG_SIG : mag:err AP_MAG_STANDARD : mag:ap # FAIL AP_MAG_RADIUS : SKIP # no accessor @@ -222,13 +236,13 @@ CAL_PSF_MAG : SKIP # photometry is not calibrated in the cmf CAL_PSF_MAG_SIG : SKIP # photometry is not calibrated in the cmf - SKY : sky - SKY_SIG : sky_err - PSF_CHISQ : psf_chisq - CR_NSIGMA : cr_nsigma + SKY : sky + SKY_SIG : sky_err + PSF_CHISQ : psf_chisq + CR_NSIGMA : cr_nsigma EXT_NSIGMA : ext_nsigma - PSF_MAJOR : FWHM_MAJ - PSF_MINOR : FWHM_MIN + PSF_MAJOR : FWHM_MAJ + PSF_MINOR : FWHM_MIN PSF_THETA : THETA # FAIL - PSF_QF : PSF_QF + PSF_QF : PSF_QF PSF_NDOF : SKIP # no accessor PSF_NPIX : SKIP # no accessor @@ -237,12 +251,12 @@ MOMENTS_YY : SKIP # no accessor FLAGS : phot_flags - N_FRAMES : SKIP # no accessor + N_FRAMES : SKIP # no accessor end # this list is good for PS1_V2 list testfields_PS1_V2 - IPP_IDET : detid - X_PSF : xccd - Y_PSF : yccd + IPP_IDET : detid + X_PSF : xccd + Y_PSF : yccd X_PSF_SIG : xccd:err # FAIL Y_PSF_SIG : yccd:err # FAIL @@ -251,6 +265,6 @@ POSANGLE : SKIP # astrometry is not calibrated in the cmf PLTSCALE : SKIP # astrometry is not calibrated in the cmf - PSF_INST_MAG : mag:inst - PSF_INST_MAG_SIG : mag:err + PSF_INST_MAG : mag:inst + PSF_INST_MAG_SIG : mag:err AP_MAG_STANDARD : mag:ap # FAIL AP_MAG_RADIUS : SKIP # no accessor @@ -258,13 +272,13 @@ CAL_PSF_MAG : SKIP # photometry is not calibrated in the cmf CAL_PSF_MAG_SIG : SKIP # photometry is not calibrated in the cmf - SKY : sky - SKY_SIG : sky_err - PSF_CHISQ : psf_chisq - CR_NSIGMA : cr_nsigma + SKY : sky + SKY_SIG : sky_err + PSF_CHISQ : psf_chisq + CR_NSIGMA : cr_nsigma EXT_NSIGMA : ext_nsigma - PSF_MAJOR : FWHM_MAJ - PSF_MINOR : FWHM_MIN + PSF_MAJOR : FWHM_MAJ + PSF_MINOR : FWHM_MIN PSF_THETA : THETA # FAIL - PSF_QF : PSF_QF + PSF_QF : PSF_QF PSF_NDOF : SKIP # no accessor PSF_NPIX : SKIP # no accessor @@ -273,18 +287,18 @@ MOMENTS_YY : SKIP # no accessor FLAGS : phot_flags - N_FRAMES : SKIP # no accessor + N_FRAMES : SKIP # no accessor end # this list is good for PS1_V3 list testfields_PS1_V3 - IPP_IDET : detid - X_PSF : xccd - Y_PSF : yccd + IPP_IDET : detid + X_PSF : xccd + Y_PSF : yccd X_PSF_SIG : xccd:err # FAIL Y_PSF_SIG : yccd:err # FAIL POSANGLE : SKIP # astrometry is not calibrated in the cmf PLTSCALE : SKIP # astrometry is not calibrated in the cmf - PSF_INST_MAG : mag:inst - PSF_INST_MAG_SIG : mag:err + PSF_INST_MAG : mag:inst + PSF_INST_MAG_SIG : mag:err PSF_INST_FLUX : SKIP # not ingested into DVO PSF_INST_FLUX_SIG : SKIP # not ingested into DVO @@ -297,13 +311,13 @@ DEC_PSF : SKIP # astrometry is not calibrated in the cmf PEAK_FLUX_AS_MAG : SKIP # not ingested into DVO - SKY : sky - SKY_SIG : sky_err - PSF_CHISQ : psf_chisq - CR_NSIGMA : cr_nsigma + SKY : sky + SKY_SIG : sky_err + PSF_CHISQ : psf_chisq + CR_NSIGMA : cr_nsigma EXT_NSIGMA : ext_nsigma - PSF_MAJOR : FWHM_MAJ - PSF_MINOR : FWHM_MIN + PSF_MAJOR : FWHM_MAJ + PSF_MINOR : FWHM_MIN PSF_THETA : THETA # FAIL - PSF_QF : PSF_QF + PSF_QF : PSF_QF PSF_QF_PERFECT : SKIP # not ingested into DVO PSF_NDOF : PSF_NDOF @@ -326,51 +340,118 @@ end -# this list is good for PS1_V4 -list testfields_PS1_V4 - IPP_IDET : detid - X_PSF : xccd - Y_PSF : yccd - X_PSF_SIG : xccd:err # FAIL - Y_PSF_SIG : yccd:err # FAIL - POSANGLE : SKIP # astrometry is not calibrated in the cmf - PLTSCALE : SKIP # astrometry is not calibrated in the cmf - PSF_INST_MAG : mag:inst - PSF_INST_MAG_SIG : mag:err - PSF_INST_FLUX : SKIP # not ingested into DVO - PSF_INST_FLUX_SIG : SKIP # not ingested into DVO - AP_MAG : mag:aperinst # FAIL +# this list is good for PS1_V5 +list testfields_PS1_V5 + IPP_IDET : detid + X_PSF : xccd + Y_PSF : yccd + X_PSF_SIG : xccd:err + Y_PSF_SIG : yccd:err + POSANGLE : posangle + PLTSCALE : platescale + PSF_INST_MAG : mag:inst + PSF_INST_MAG_SIG : mag:err + PSF_INST_FLUX : flux:inst + PSF_INST_FLUX_SIG : flux:inst:err + AP_MAG : mag:aper:inst AP_MAG_RAW : SKIP # not ingested into DVO AP_MAG_RADIUS : SKIP # not ingested into DVO - CAL_PSF_MAG : SKIP # photometry is not calibrated in the cmf - CAL_PSF_MAG_SIG : SKIP # photometry is not calibrated in the cmf - RA_PSF : SKIP # astrometry is not calibrated in the cmf - DEC_PSF : SKIP # astrometry is not calibrated in the cmf - PEAK_FLUX_AS_MAG : SKIP # not ingested into DVO - SKY : sky - SKY_SIGMA : sky_err - PSF_CHISQ : psf_chisq - CR_NSIGMA : cr_nsigma - EXT_NSIGMA : ext_nsigma - PSF_MAJOR : FWHM_MAJ - PSF_MINOR : FWHM_MIN - PSF_THETA : THETA # FAIL - PSF_QF : PSF_QF - PSF_QF_PERFECT : SKIP # not ingested into DVO - PSF_NDOF : PSF_NDOF - PSF_NPIX : PSF_NPIX - MOMENTS_XX : MXX - MOMENTS_XY : MXY - MOMENTS_YY : MYY - MOMENTS_M3C : SKIP # not ingested into DVO - MOMENTS_M3S : SKIP # not ingested into DVO - MOMENTS_M4C : SKIP # not ingested into DVO - MOMENTS_M4S : SKIP # not ingested into DVO - MOMENTS_R1 : SKIP # not ingested into DVO - MOMENTS_RH : SKIP # not ingested into DVO - KRON_FLUX : mag:kroninst - KRON_FLUX_ERR : mag:kronerr - KRON_FLUX_INNER : SKIP # not ingested into DVO - KRON_FLUX_OUTER : SKIP # not ingested into DVO - FLAGS : phot_flags - N_FRAMES : SKIP # not ingested into DVO -end + AP_FLUX : flux:aper:inst + AP_FLUX_SIG : flux:aper:inst:err + CAL_PSF_MAG : mag:cal + CAL_PSF_MAG_SIG : mag:cal:err + RA_PSF : ra + DEC_PSF : dec + AP_NPIX : SKIP # not ingested into DVO + PEAK_FLUX_AS_MAG : SKIP # not ingested into DVO + SKY : sky + SKY_SIGMA : sky_err + PSF_CHISQ : psf_chisq + CR_NSIGMA : cr_nsigma + EXT_NSIGMA : ext_nsigma + PSF_MAJOR : fwhm_maj # XXX technically, this is not FWHM but Sigma + PSF_MINOR : fwhm_min # XXX technically, this is not FWHM but Sigma + PSF_THETA : theta # FAIL + PSF_CORE : SKIP # not ingested into DVO + PSF_FWHM_MAJ : SKIP # not ingested into DVO + PSF_FWHM_MIN : SKIP # not ingested into DVO + PSF_QF : psf_qf + PSF_QF_PERFECT : SKIP # not ingested into DVO + PSF_NDOF : psf_ndof + PSF_NPIX : psf_npix + MOMENTS_XX : Mxx + MOMENTS_XY : Mxy + MOMENTS_YY : Myy + MOMENTS_M3C : SKIP # not ingested into DVO + MOMENTS_M3S : SKIP # not ingested into DVO + MOMENTS_M4C : SKIP # not ingested into DVO + MOMENTS_M4S : SKIP # not ingested into DVO + MOMENTS_R1 : SKIP # not ingested into DVO + MOMENTS_RH : SKIP # not ingested into DVO + KRON_FLUX : flux:kron:inst + KRON_FLUX_ERR : flux:kron:inst:err + KRON_FLUX_INNER : SKIP # not ingested into DVO + KRON_FLUX_OUTER : SKIP # not ingested into DVO + SKY_LIMIT_RAD : SKIP # not ingested into DVO + SKY_LIMIT_FLUX : SKIP # not ingested into DVO + SKY_LIMIT_SLOPE : SKIP # not ingested into DVO + FLAGS : phot_flags + FLAGS2 : SKIP # not ingested into DVO + N_FRAMES : SKIP # not ingested into DVO +end + +# this list is good for PS1_SV3 +list testfields_PS1_SV3 + IPP_IDET : detid + X_PSF : xccd + Y_PSF : yccd + X_PSF_SIG : xccd:err + Y_PSF_SIG : yccd:err + POSANGLE : posangle + PLTSCALE : platescale + PSF_INST_MAG : mag:inst + PSF_INST_MAG_SIG : mag:err + PSF_INST_FLUX : flux:inst + PSF_INST_FLUX_SIG : flux:inst:err + AP_MAG : mag:aper:inst + AP_MAG_RAW : SKIP # not ingested into DVO + AP_MAG_RADIUS : SKIP # not ingested into DVO + AP_FLUX : flux:aper:inst + AP_FLUX_SIG : flux:aper:inst:err + CAL_PSF_MAG : mag:cal + CAL_PSF_MAG_SIG : mag:cal:err + RA_PSF : ra + DEC_PSF : dec + AP_NPIX : SKIP # not ingested into DVO + PEAK_FLUX_AS_MAG : SKIP # not ingested into DVO + SKY : sky + SKY_SIGMA : sky_err + PSF_CHISQ : psf_chisq + CR_NSIGMA : cr_nsigma + EXT_NSIGMA : ext_nsigma + PSF_MAJOR : fwhm_maj # XXX technically, this is not FWHM but Sigma + PSF_MINOR : fwhm_min # XXX technically, this is not FWHM but Sigma + PSF_THETA : theta # FAIL + PSF_CORE : SKIP # not ingested into DVO + PSF_FWHM_MAJ : SKIP # not ingested into DVO + PSF_FWHM_MIN : SKIP # not ingested into DVO + PSF_QF : psf_qf + PSF_QF_PERFECT : SKIP # not ingested into DVO + PSF_NDOF : psf_ndof + PSF_NPIX : psf_npix + MOMENTS_XX : Mxx + MOMENTS_XY : Mxy + MOMENTS_YY : Myy + MOMENTS_M3C : SKIP # not ingested into DVO + MOMENTS_M3S : SKIP # not ingested into DVO + MOMENTS_M4C : SKIP # not ingested into DVO + MOMENTS_M4S : SKIP # not ingested into DVO + MOMENTS_R1 : SKIP # not ingested into DVO + MOMENTS_RH : SKIP # not ingested into DVO + KRON_FLUX : flux:kron:inst + KRON_FLUX_ERR : flux:kron:inst:err + KRON_FLUX_INNER : SKIP # not ingested into DVO + KRON_FLUX_OUTER : SKIP # not ingested into DVO + FLAGS : phot_flags + FLAGS2 : SKIP # not ingested into DVO + N_FRAMES : SKIP # not ingested into DVO +end Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/Makefile (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/Makefile (revision 37067) @@ -0,0 +1,57 @@ +default: checkastro checkastro_client +help: + @echo "make options: checkastro (default)" + +include ../../Makefile.System +HOME = $(ROOT)/src/checkastro +BIN = $(HOME)/bin +LIB = $(HOME)/lib +SRC = $(HOME)/src +MAN = $(HOME)/doc +INC = $(HOME)/include +include ../../Makefile.Common + +# programs may add their own internal requirements here +FULL_CFLAGS = $(BASE_CFLAGS) +FULL_CPPFLAGS = $(BASE_CPPFLAGS) +FULL_LDFLAGS = -lkapa -ldvo -lFITS -lohana $(BASE_LDFLAGS) + +checkastro: $(BIN)/checkastro.$(ARCH) +checkastro_client: $(BIN)/checkastro_client.$(ARCH) + +install: $(DESTBIN)/checkastro $(DESTBIN)/checkastro_client $(DESTBIN)/testparallax + +CHECKASTRO = \ +$(SRC)/ConfigInit.$(ARCH).o \ +$(SRC)/ImageOps.$(ARCH).o \ +$(SRC)/SetSignals.$(ARCH).o \ +$(SRC)/Shutdown.$(ARCH).o \ +$(SRC)/args.$(ARCH).o \ +$(SRC)/bcatalog.$(ARCH).o \ +$(SRC)/initialize.$(ARCH).o \ +$(SRC)/load_catalogs.$(ARCH).o \ +$(SRC)/load_images.$(ARCH).o \ +$(SRC)/select_images.$(ARCH).o \ +$(SRC)/checkastro.$(ARCH).o \ +$(SRC)/checkastro_images.$(ARCH).o \ +$(SRC)/MeasFilterTest.$(ARCH).o \ +$(SRC)/BrightCatalog.$(ARCH).o + +$(CHECKASTRO): $(INC)/checkastro.h +$(BIN)/checkastro.$(ARCH): $(CHECKASTRO) + +CHECKASTRO_CLIENT = \ +$(SRC)/ConfigInit.$(ARCH).o \ +$(SRC)/SetSignals.$(ARCH).o \ +$(SRC)/Shutdown.$(ARCH).o \ +$(SRC)/args.$(ARCH).o \ +$(SRC)/bcatalog.$(ARCH).o \ +$(SRC)/initialize.$(ARCH).o \ +$(SRC)/load_catalogs.$(ARCH).o \ +$(SRC)/checkastro_client.$(ARCH).o \ +$(SRC)/MeasFilterTest.$(ARCH).o \ +$(SRC)/BrightCatalog.$(ARCH).o + +$(CHECKASTRO_CLIENT): $(INC)/checkastro.h +$(BIN)/checkastro_client.$(ARCH): $(CHECKASTRO_CLIENT) + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/include/checkastro.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/include/checkastro.h (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/include/checkastro.h (revision 37067) @@ -0,0 +1,145 @@ +# include +# include +# include +# include +# include +# include + +// choose off_t or int depending on full-scale relphot analysis resources +// # define IDX_T off_t +# define IDX_T int + +typedef struct { + Average *average; // array of (minimal) average data + MeasureTiny *measure; // array of (minimal) measure data + SecFilt *secfilt; // array of secfilt data (matched to average by Nsecfilt) + off_t Naverage; + off_t Nmeasure; +} BrightCatalog; + +typedef struct { + Catalog *catalog; // array of catalogs generated + int NCATALOG; // number of catalogs allocated + int Ncatalog; // number of catalogs generated + int Nsecfilt; // number of catalogs generated + off_t *NAVERAGE; // allocated Averages per catalog + off_t *NMEASURE; // allocated Measures per catalog + int *index; // lookup table catID -> catalog[i] + int *catIDs; // lookup table catID <- catalog[i] + int maxID; // max catID value to date +} CatalogSplitter; + +/* global variables set in parameter file */ +# define DVO_MAX_PATH 1024 +char ImageCat[DVO_MAX_PATH]; +char GSCFILE[DVO_MAX_PATH]; +char CATDIR[DVO_MAX_PATH]; + +char CATMODE[16]; /* raw, mef, split, mysql */ +char CATFORMAT[16]; /* internal, elixir, loneos, panstarrs */ +char SKY_TABLE[DVO_MAX_PATH]; +int SKY_DEPTH; /** XXX EAM : depth of catalog tables, fix usage */ + +int HOST_ID; +char *HOSTDIR; +char *BCATALOG; + +unsigned int OBJ_ID_SRC; +unsigned int CAT_ID_SRC; +unsigned int OBJ_ID_DST; +unsigned int CAT_ID_DST; + +double SIGMA_LIM; +int SRC_MEAS_TOOFEW; //catalog objects wich fewer detections then this are ignored +double MIN_ERROR; + +int PARALLEL; +int PARALLEL_MANUAL; +int PARALLEL_SERIAL; + +int VERBOSE; +int VERBOSE2; + +int MaxDensityUse; +double MaxDensityValue; + +char *PHOTCODE_KEEP_LIST, *PHOTCODE_SKIP_LIST, *PHOTCODE_RESET_LIST; +int NphotcodesKeep, NphotcodesSkip, NphotcodesReset; +PhotCode **photcodesKeep, **photcodesSkip, **photcodesReset; + +int ImagSelect; +double ImagMin, ImagMax; + +int PhotFlagSelect, PhotFlagPoor, PhotFlagBad; + +float MinBadQF; + +int TimeSelect; +time_t TSTART, TSTOP; + +SkyRegion UserPatch; + +/*** relphot prototypes ***/ +void ConfigInit PROTO((int *argc, char **argv)); +void GetConfig PROTO((char *config, char *field, char *format, int N, void *ptr)); + +int args PROTO((int argc, char **argv)); +int args_client PROTO((int argc, char **argv)); +int bcatalog PROTO((Catalog *subcatalog, Catalog *catalog)); + +void findImages PROTO((Catalog *catalog, int Ncatalog)); +int findMosaics PROTO((Catalog *catalog, int Ncatalog)); + +void set_db PROTO((FITS_DB *in)); +int Shutdown PROTO((char *format, ...)) OHANA_FORMAT(printf, 1, 2); +void TrapSignal PROTO((int sig)); +void SetProtect PROTO((int mode)); +int SetSignals PROTO((void)); + +void freeImageBins PROTO((int Ncatalog)); +void free_catalogs PROTO((Catalog *catalog, int Ncatalog)); + +void initImageBins PROTO((Catalog *catalog, int Ncatalog)); +void initImages PROTO((Image *input, off_t *line_number, off_t N)); + +void initialize PROTO((int argc, char **argv)); +void initialize_client PROTO((int argc, char **argv)); + +Catalog *load_catalogs PROTO((SkyList *skylist, int *Ncatalog, int subselect, int hostID, char *hostpath)); +int load_images PROTO((FITS_DB *db, SkyList *skylist)); +Image *select_images PROTO((SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage)); + +void check_permissions (char *basefile); +void lock_image_db (FITS_DB *db, char *filename); +void unlock_image_db (FITS_DB *db); +void create_image_db (FITS_DB *db); +void save_catalogs (Catalog *catalog, int Ncatalog); + +int reload_images (FITS_DB *db); + +int main PROTO((int argc, char **argv)); + +void matchImage PROTO((Catalog *catalog, off_t meas, int cat)); + +void set_ZP PROTO((double ZERO)); + +off_t getImageByID (off_t ID); + +int checkastro_objects (SkyList *skylist, int hostID, char *hostpath); +int checkastro_images (SkyList *skylist); + +int LimitDensityCatalog_ByNmeasure (Catalog *subcatalog, Catalog *catalog); +int LimitDensityCatalog_RandomSample (Catalog *subcatalog, Catalog *catalog); + +BrightCatalog *BrightCatalogLoad(char *filename); +int BrightCatalogSave(char *filename, BrightCatalog *catalog); +BrightCatalog *BrightCatalogMerge (Catalog *catalog, int Ncatalog); +CatalogSplitter *BrightCatalogSplitInit (int Nsecfilt); +int BrightCatalogSplit (CatalogSplitter *catalogs, BrightCatalog *bcatalog); +int BrightCatalogSplitFree (CatalogSplitter *catalogs); + +Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog); +void bcatalog_show_skips (); + +int MeasFilterTestTiny(MeasureTiny *measure, int applySigmaLim); +int MeasFilterTest(Measure *measure, int applySigmaLim); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/BrightCatalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/BrightCatalog.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/BrightCatalog.c (revision 37067) @@ -0,0 +1,906 @@ +# include "checkastro.h" + +// NOTE: this file is nearly identical to relphot/src/BrightCatalog.c, but here we use Average, not AverageTiny + +// checkastro_client -load reads from the local catalogs and generates a set of bright, subset catalogs +// we are going to save these as a single big FITS file, with only 3 extensions: + +// measure, average, secfilt. these only need to contain the fields relevant to the +// MeasureTiny, Average, and Secfilt tables, but with cat_id appended to each row so we can +// reassign correctly on read + +# define GET_COLUMN(OUT,NAME,TYPE) \ + TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \ + myAssert (!strcmp(type, #TYPE), "wrong column type"); + +// XXX double check the header extname values for each table +// XXX make sure we free things as we can +// XXX make sure we close files as we can +// XXX handle free and close on error return as well +BrightCatalog *BrightCatalogLoad(char *filename) { + + int i, Ncol; + off_t Nrow; + char type[16]; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + header.buffer = NULL; + matrix.buffer = NULL; + ftable.buffer = NULL; + theader.buffer = NULL; + BrightCatalog *catalog = NULL; + + FILE *f = fopen (filename, "r"); + if (!f) { + fprintf (stderr, "ERROR: cannot open image subset file %s\n", filename); + goto escape; + } + + /* load in PHU segment (ignore) */ + if (!gfits_fread_header (f, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset header\n"); + fclose (f); + goto escape; + } + if (!gfits_fread_matrix (f, &matrix, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset matrix\n"); + gfits_free_header (&header); + fclose (f); + goto escape; + } + + ALLOCATE (catalog, BrightCatalog, 1); + catalog->Naverage = 0; + catalog->Nmeasure = 0; + + ftable.header = &theader; + + // *** Measure Data *** + { + // load data for this header + if (!gfits_load_header (f, &theader)) goto escape; + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftable, FALSE)) goto escape; + + // need to create and assign to flat-field correction + GET_COLUMN(dR, "RA_OFF", float); + GET_COLUMN(dD, "DEC_OFF", float); + GET_COLUMN(M, "MAG_SYS", float); + GET_COLUMN(Mcal, "MAG_CAL", float); + GET_COLUMN(dM, "MAG_ERR", float); + GET_COLUMN(airmass, "AIRMASS", float); + GET_COLUMN(Xccd, "X_CCD", float); + GET_COLUMN(Yccd, "Y_CCD", float); + GET_COLUMN(Xfix, "X_FIX", float); + GET_COLUMN(Yfix, "Y_FIX", float); + GET_COLUMN(dt, "EXPTIME", float); + GET_COLUMN(t, "TIME", int); + GET_COLUMN(averef, "AVE_REF", int); // XXX signed vs unsigned? + GET_COLUMN(imageID, "IMAGE_ID", int); + GET_COLUMN(dbFlags, "DB_FLAGS", int); + GET_COLUMN(photFlags, "PHOT_FLAGS", int); + GET_COLUMN(catID, "CAT_ID", int); + GET_COLUMN(photcode, "PHOTCODE", short); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + MeasureTiny *measure = NULL; + ALLOCATE (measure, MeasureTiny, Nrow); + for (i = 0; i < Nrow; i++) { + measure[i].dR = dR[i]; + measure[i].dD = dD[i]; + measure[i].M = M[i]; + measure[i].Mcal = Mcal[i]; + measure[i].dM = dM[i]; + measure[i].airmass = airmass[i]; + measure[i].Xccd = Xccd[i]; + measure[i].Yccd = Yccd[i]; + measure[i].Xfix = Xfix[i]; + measure[i].Yfix = Yfix[i]; + measure[i].dt = dt[i]; + measure[i].t = t[i]; + measure[i].averef = averef[i]; + measure[i].imageID = imageID[i]; + measure[i].dbFlags = dbFlags[i]; + measure[i].photFlags = photFlags[i]; + measure[i].catID = catID[i]; + measure[i].photcode = photcode[i]; + } + // fprintf (stderr, "loaded data for %lld measures\n", (long long) Nrow); + + free (dR ); + free (dD ); + free (M ); + free (Mcal ); + free (dM ); + free (airmass ); + free (Xccd ); + free (Yccd ); + free (Xfix ); + free (Yfix ); + free (dt ); + free (t ); + free (averef ); + free (imageID ); + free (dbFlags ); + free (photFlags ); + free (catID ); + free (photcode); + + catalog->measure = measure; + catalog->Nmeasure = Nrow; + } + + /*** load Average values ***/ + { + + // load data for this header + if (!gfits_load_header (f, &theader)) goto escape; + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftable, FALSE)) goto escape; + + GET_COLUMN(R, "RA", double); + GET_COLUMN(D, "DEC", double); + GET_COLUMN(dR, "RA_ERR", float); + GET_COLUMN(dD, "DEC_ERR", float); + GET_COLUMN(uR, "U_RA", float); + GET_COLUMN(uD, "U_DEC", float); + GET_COLUMN(duR, "V_RA_ERR", float); + GET_COLUMN(duD, "V_DEC_ERR", float); + GET_COLUMN(P, "PAR", float); + GET_COLUMN(dP, "PAR_ERR", float); + GET_COLUMN(ChiSqAve, "CHISQ_POS", float); + GET_COLUMN(ChiSqPM, "CHISQ_PM", float); + GET_COLUMN(ChiSqPar, "CHISQ_PAP", float); + GET_COLUMN(Tmean, "MEAN_EPOCH", int); + GET_COLUMN(Trange, "TIME_RANGE", int); + GET_COLUMN(stargal, "STARGAL_SEP", float); + GET_COLUMN(Npos, "NUMBER_POS", short); + GET_COLUMN(Nmeasure, "NMEASURE", short); + GET_COLUMN(Nmissing, "NMISSING", short); + GET_COLUMN(Nextend, "NEXTEND", short); + GET_COLUMN(measureOffset, "OFF_MEASURE", int); + GET_COLUMN(missingOffset, "OFF_MISSING", int); + GET_COLUMN(refColor, "REF_COLOR", float); + GET_COLUMN(flags, "FLAGS", int); + GET_COLUMN(photFlagsUpper, "PHOTFLAGS_U", int); + GET_COLUMN(photFlagsLower, "PHOTFLAGS_L", int); + GET_COLUMN(objID, "OBJ_ID", int); + GET_COLUMN(catID, "CAT_ID", int); + GET_COLUMN(extID, "EXT_ID", int64_t); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + Average *average = NULL; + ALLOCATE (average, Average, Nrow); + for (i = 0; i < Nrow; i++) { + average[i].R = R[i] ; + average[i].D = D[i] ; + average[i].dR = dR[i] ; + average[i].dD = dD[i] ; + average[i].uR = uR[i] ; + average[i].uD = uD[i] ; + average[i].duR = duR[i] ; + average[i].duD = duD[i] ; + average[i].P = P[i] ; + average[i].dP = dP[i] ; + average[i].ChiSqAve = ChiSqAve[i] ; + average[i].ChiSqPM = ChiSqPM[i] ; + average[i].ChiSqPar = ChiSqPar[i] ; + average[i].Tmean = Tmean[i] ; + average[i].Trange = Trange[i] ; + average[i].stargal = stargal[i] ; + average[i].Npos = Npos[i] ; + average[i].Nmeasure = Nmeasure[i] ; + average[i].Nmissing = Nmissing[i] ; + average[i].Nextend = Nextend[i] ; + average[i].measureOffset = measureOffset[i] ; + average[i].missingOffset = missingOffset[i] ; + average[i].refColor = refColor[i] ; + average[i].flags = flags[i] ; + average[i].photFlagsUpper = photFlagsUpper[i] ; + average[i].photFlagsLower = photFlagsLower[i] ; + average[i].objID = objID[i] ; + average[i].catID = catID[i] ; + average[i].extID = extID[i] ; + } + fprintf (stderr, "loaded data for %lld averages\n", (long long) Nrow); + + free (R); + free (D); + free (dR); + free (dD); + free (uR); + free (uD); + free (duR); + free (duD); + free (P); + free (dP); + free (ChiSqAve); + free (ChiSqPM); + free (ChiSqPar); + free (Tmean); + free (Trange); + free (stargal); + free (Npos); + free (Nmeasure); + free (Nmissing); + free (Nextend); + free (measureOffset); + free (missingOffset); + free (refColor); + free (flags); + free (photFlagsUpper); + free (photFlagsLower); + free (objID); + free (catID); + free (extID); + + catalog->average = average; + catalog->Naverage = Nrow; + } + + /*** load Secfilt values ***/ + { + + // load data for this header + if (!gfits_load_header (f, &theader)) goto escape; + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftable, FALSE)) goto escape; + + // need to create and assign to flat-field correction + GET_COLUMN(M, "MAG", float); + GET_COLUMN(dM, "MAG_ERR", float); + GET_COLUMN(Mchisq,"MAG_CHI", float); + GET_COLUMN(flags, "FLAGS", int); + GET_COLUMN(Ncode, "NCODE", short); + GET_COLUMN(Nused, "NUSED", short); + GET_COLUMN(M_20, "MAG_20", short); + GET_COLUMN(M_80, "MAG_80", short); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + SecFilt *secfilt = NULL; + ALLOCATE (secfilt, SecFilt, Nrow); + for (i = 0; i < Nrow; i++) { + secfilt[i].M = M[i]; + secfilt[i].dM = dM[i]; + secfilt[i].Mchisq= Mchisq[i]; + secfilt[i].flags = flags[i]; + secfilt[i].Ncode = Ncode[i]; + secfilt[i].Nused = Nused[i]; + secfilt[i].M_20 = M_20[i]; + secfilt[i].M_80 = M_80[i]; + } + fprintf (stderr, "loaded data for %lld averages\n", (long long) Nrow); + + free (M ); + free (dM ); + free (Mchisq); + free (flags ); + free (Ncode ); + free (Nused ); + free (M_20 ); + free (M_80 ); + catalog->secfilt = secfilt; + // assert Nsecfilt * Naverage = Nrow? + } + + + gfits_free_header (&header); + gfits_free_matrix (&matrix); + fclose (f); + + return catalog; + +escape: + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + if (catalog) free (catalog); + + fclose (f); + return NULL; +} + +// we are passed a BrightCatalog structure, write it to a FITS table (3 ext) +int BrightCatalogSave(char *filename, BrightCatalog *catalog) { + + int i; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + gfits_init_header (&header); + header.extend = TRUE; + gfits_create_header (&header); + gfits_create_matrix (&header, &matrix); + + FILE *f = fopen (filename, "w"); + if (!f) { + fprintf (stderr, "ERROR: cannot open image subset file for output %s\n", filename); + return FALSE; + } + + gfits_fwrite_header (f, &header); + gfits_fwrite_matrix (f, &matrix); + gfits_free_header (&header); + gfits_free_matrix (&matrix); + + /*** MeasureTiny ***/ + { + gfits_create_table_header (&theader, "BINTABLE", "MEASURE_TINY"); + + gfits_define_bintable_column (&theader, "E", "RA_OFF", "ra offset", "arcsec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "DEC_OFF", "dec offset", "arcsec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_SYS", "magnitude (sys)", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_CAL", "magnitude (cal)", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_ERR", "magnitude (err)", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "AIRMASS", "airmass", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "X_CCD", "ccd x raw coord", "pix", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "Y_CCD", "ccd y raw coord", "pix", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "X_FIX", "ccd x fixed coord", "pix", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "Y_FIX", "ccd y fiex coord", "pix", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "EXPTIME", "-2.5 * log (exposure time)", "sec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "TIME", "time of exp", "sec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "AVE_REF", "pointer to average table", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "DB_FLAGS", "flags", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "PHOT_FLAGS", "photflags", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "CAT_ID", "catalog", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "PHOTCODE", "photcode", NULL, 1.0, 0.0); + + // generate the output array that carries the data + gfits_create_table (&theader, &ftable); + + // create intermediate storage arrays + float *dR ; ALLOCATE (dR , float, catalog->Nmeasure); + float *dD ; ALLOCATE (dD , float, catalog->Nmeasure); + float *M ; ALLOCATE (M , float, catalog->Nmeasure); + float *Mcal ; ALLOCATE (Mcal , float, catalog->Nmeasure); + float *dM ; ALLOCATE (dM , float, catalog->Nmeasure); + float *airmass ; ALLOCATE (airmass , float, catalog->Nmeasure); + float *Xccd ; ALLOCATE (Xccd , float, catalog->Nmeasure); + float *Yccd ; ALLOCATE (Yccd , float, catalog->Nmeasure); + float *Xfix ; ALLOCATE (Xfix , float, catalog->Nmeasure); + float *Yfix ; ALLOCATE (Yfix , float, catalog->Nmeasure); + float *dt ; ALLOCATE (dt , float, catalog->Nmeasure); + int *t ; ALLOCATE (t , int , catalog->Nmeasure); + int *averef ; ALLOCATE (averef , int , catalog->Nmeasure); + int *imageID ; ALLOCATE (imageID , int , catalog->Nmeasure); + int *dbFlags ; ALLOCATE (dbFlags , int , catalog->Nmeasure); + int *photFlags ; ALLOCATE (photFlags, int , catalog->Nmeasure); + int *catID ; ALLOCATE (catID , int , catalog->Nmeasure); + short *photcode ; ALLOCATE (photcode , short, catalog->Nmeasure); + + // assign the storage arrays + MeasureTiny *measure = catalog->measure; + for (i = 0; i < catalog->Nmeasure; i++) { + dR[i] = measure[i].dR ; + dD[i] = measure[i].dD ; + M[i] = measure[i].M ; + Mcal[i] = measure[i].Mcal ; + dM[i] = measure[i].dM ; + airmass[i] = measure[i].airmass ; + Xccd[i] = measure[i].Xccd ; + Yccd[i] = measure[i].Yccd ; + Xfix[i] = measure[i].Xfix ; + Yfix[i] = measure[i].Yfix ; + dt[i] = measure[i].dt ; + t[i] = measure[i].t ; + averef[i] = measure[i].averef ; + catID[i] = measure[i].catID ; + imageID[i] = measure[i].imageID ; + dbFlags[i] = measure[i].dbFlags ; + photFlags[i]= measure[i].photFlags; + photcode[i] = measure[i].photcode ; + } + + // add the columns to the output array + gfits_set_bintable_column (&theader, &ftable, "RA_OFF", dR, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "DEC_OFF", dD, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "MAG_SYS", M, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "MAG_CAL", Mcal, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "MAG_ERR", dM, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "AIRMASS", airmass, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "X_CCD", Xccd, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "Y_CCD", Yccd, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "X_FIX", Xfix, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "Y_FIX", Yfix, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "EXPTIME", dt, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "TIME", t, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "AVE_REF", averef, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "IMAGE_ID", imageID, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "DB_FLAGS", dbFlags, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "PHOT_FLAGS", photFlags, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "CAT_ID", catID, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "PHOTCODE", photcode, catalog->Nmeasure); + + free (dR ); + free (dD ); + free (M ); + free (Mcal ); + free (dM ); + free (airmass ); + free (Xccd ); + free (Yccd ); + free (Xfix ); + free (Yfix ); + free (dt ); + free (t ); + free (averef ); + free (imageID ); + free (dbFlags ); + free (photFlags ); + free (catID ); + free (photcode); + + gfits_fwrite_Theader (f, &theader); + gfits_fwrite_table (f, &ftable); + gfits_free_header (&theader); + gfits_free_table (&ftable); + } + + /*** Average ***/ + { + gfits_create_table_header (&theader, "BINTABLE", "AVERAGE"); + + gfits_define_bintable_column (&theader, "D", "RA", "RA", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "DEC", "DEC", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "RA_ERR", "RA error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "DEC_ERR", "DEC error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "U_RA", "RA*cos(D) proper-motion", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "U_DEC", "DEC proper-motion", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "V_RA_ERR", "RA*cos(D) p-m error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "V_DEC_ERR", "DEC p-m error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "PAR", "parallax", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "PAR_ERR", "parallax error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CHISQ_POS", "astrometry analysis chisq", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CHISQ_PM", "astrometry analysis chisq", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CHISQ_PAP", "astrometry analysis chisq", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "MEAN_EPOCH", "mean epoch (PM-PAR ref)", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "TIME_RANGE", "mean epoch (PM-PAR ref)", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "STARGAL_SEP", "star/galaxy separator", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NUMBER_POS", "number of detections used for astrometry", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NMEASURE", "number of psf measurements", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NMISSING", "number of missings", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NEXTEND", "number of extended measurements", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "OFF_MEASURE", "offset to first psf measurement", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "OFF_MISSING", "offset to first missing obs", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "OFF_EXTEND", "offset to first extended measurement", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "FLAGS", "average object flags (star; ghost; etc)", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "PHOTFLAGS_U", "upper bit of 2 bit summary of per-measure photflags", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "PHOTFLAGS_L", "lower bit of 2 bit summary of per-measure photflags", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "OBJ_ID", "unique ID for object in table", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "CAT_ID", "unique ID for table in which object was first realized", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "K", "EXT_ID", "external ID for object (eg PSPS objID)", "", 1.0, 0.0); + + // generate the output array that carries the data + gfits_create_table (&theader, &ftable); + + // create intermediate storage arrays + double *R ; ALLOCATE (R , double , catalog->Naverage); + double *D ; ALLOCATE (D , double , catalog->Naverage); + float *dR ; ALLOCATE (dR , float , catalog->Naverage); + float *dD ; ALLOCATE (dD , float , catalog->Naverage); + float *uR ; ALLOCATE (uR , float , catalog->Naverage); + float *uD ; ALLOCATE (uD , float , catalog->Naverage); + float *duR ; ALLOCATE (duR , float , catalog->Naverage); + float *duD ; ALLOCATE (duD , float , catalog->Naverage); + float *P ; ALLOCATE (P , float , catalog->Naverage); + float *dP ; ALLOCATE (dP , float , catalog->Naverage); + float *ChiSqAve ; ALLOCATE (ChiSqAve , float , catalog->Naverage); + float *ChiSqPM ; ALLOCATE (ChiSqPM , float , catalog->Naverage); + float *ChiSqPar ; ALLOCATE (ChiSqPar , float , catalog->Naverage); + int *Tmean ; ALLOCATE (Tmean , int , catalog->Naverage); + int *Trange ; ALLOCATE (Trange , int , catalog->Naverage); + float *stargal ; ALLOCATE (stargal , float , catalog->Naverage); + short *Npos ; ALLOCATE (Npos , short , catalog->Naverage); + short *Nmeasure ; ALLOCATE (Nmeasure , short , catalog->Naverage); + short *Nmissing ; ALLOCATE (Nmissing , short , catalog->Naverage); + short *Nextend ; ALLOCATE (Nextend , short , catalog->Naverage); + int *measureOffset ; ALLOCATE (measureOffset , int , catalog->Naverage); + int *missingOffset ; ALLOCATE (missingOffset , int , catalog->Naverage); + int *refColor ; ALLOCATE (refColor , float , catalog->Naverage); + int *flags ; ALLOCATE (flags , int , catalog->Naverage); + int *photFlagsUpper; ALLOCATE (photFlagsUpper, int , catalog->Naverage); + int *photFlagsLower; ALLOCATE (photFlagsLower, int , catalog->Naverage); + int *objID ; ALLOCATE (objID , int , catalog->Naverage); + int *catID ; ALLOCATE (catID , int , catalog->Naverage); + uint64_t *extID ; ALLOCATE (extID , uint64_t, catalog->Naverage); + + // assign the storage arrays + Average *average = catalog->average; + for (i = 0; i < catalog->Naverage; i++) { + R[i] = average[i].R ; + D[i] = average[i].D ; + dR[i] = average[i].dR ; + dD[i] = average[i].dD ; + uR[i] = average[i].uR ; + uD[i] = average[i].uD ; + duR[i] = average[i].duR ; + duD[i] = average[i].duD ; + P[i] = average[i].P ; + dP[i] = average[i].dP ; + ChiSqAve[i] = average[i].ChiSqAve ; + ChiSqPM[i] = average[i].ChiSqPM ; + ChiSqPar[i] = average[i].ChiSqPar ; + Tmean[i] = average[i].Tmean ; + Trange[i] = average[i].Trange ; + stargal[i] = average[i].stargal ; + Npos[i] = average[i].Npos ; + Nmeasure[i] = average[i].Nmeasure ; + Nmissing[i] = average[i].Nmissing ; + Nextend[i] = average[i].Nextend ; + measureOffset[i] = average[i].measureOffset ; + missingOffset[i] = average[i].missingOffset ; + refColor[i] = average[i].refColor ; + flags[i] = average[i].flags ; + photFlagsUpper[i] = average[i].photFlagsUpper ; + photFlagsLower[i] = average[i].photFlagsLower ; + objID[i] = average[i].objID ; + catID[i] = average[i].catID ; + extID[i] = average[i].extID ; + } + + // add the columns to the output array + gfits_set_bintable_column (&theader, &ftable, "RA", R, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "DEC", D, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "RA_ERR", dR, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "DEC_ERR", dD, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "U_RA", uR, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "U_DEC", uD, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "V_RA_ERR", duR, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "V_DEC_ERR", duD, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "PAR", P, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "PAR_ERR", dP, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "CHISQ_POS", ChiSqAve, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "CHISQ_PM", ChiSqPM, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "CHISQ_PAP", ChiSqPar, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "MEAN_EPOCH", Tmean, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "TIME_RANGE", Trange, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "STARGAL_SEP", stargal, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "NUMBER_POS", Npos, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "NMEASURE", Nmeasure, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "NMISSING", Nmissing, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "NEXTEND", Nextend, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "OFF_MEASURE", measureOffset, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "OFF_MISSING", missingOffset, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "REF_COLOR", refColor, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "PHOTFLAGS_U", photFlagsUpper, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "PHOTFLAGS_L", photFlagsLower, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "OBJ_ID", objID, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "CAT_ID", catID, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "EXT_ID", extID, catalog->Naverage); + + free (R); + free (D); + free (dR); + free (dD); + free (uR); + free (uD); + free (duR); + free (duD); + free (P); + free (dP); + free (ChiSqAve); + free (ChiSqPM); + free (ChiSqPar); + free (Tmean); + free (Trange); + free (stargal); + free (Npos); + free (Nmeasure); + free (Nmissing); + free (Nextend); + free (measureOffset); + free (missingOffset); + free (refColor); + free (flags); + free (photFlagsUpper); + free (photFlagsLower); + free (objID); + free (catID); + free (extID); + + gfits_fwrite_Theader (f, &theader); + gfits_fwrite_table (f, &ftable); + gfits_free_header (&theader); + gfits_free_table (&ftable); + } + + /*** SecFilt ***/ + { + gfits_create_table_header (&theader, "BINTABLE", "SECFILT"); + + gfits_define_bintable_column (&theader, "E", "MAG", "ra offset", "arcsec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_ERR", "dec offset", "arcsec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_CHI", "magnitude (sys)", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "FLAGS", "magnitude (cal)", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NCODE", "magnitude (err)", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NUSED", "airmass", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "MAG_20", "ccd x coord", "pix", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "MAG_80", "ccd y coord", "pix", 1.0, 0.0); + + // generate the output array that carries the data + gfits_create_table (&theader, &ftable); + + // Nsecfilt is number of average filters, Nsec is total number of values + int Nsecfilt = GetPhotcodeNsecfilt(); + int Nsec = Nsecfilt * catalog->Naverage; + + // create intermediate storage arrays + float *M ; ALLOCATE (M , float, Nsec); + float *dM ; ALLOCATE (dM , float, Nsec); + float *Mchisq ; ALLOCATE (Mchisq , float, Nsec); + int *flags ; ALLOCATE (flags , int, Nsec); + short *Ncode ; ALLOCATE (Ncode , short, Nsec); + short *Nused ; ALLOCATE (Nused , short, Nsec); + short *M_20 ; ALLOCATE (M_20 , short, Nsec); + short *M_80 ; ALLOCATE (M_80 , short, Nsec); + + // assign the storage arrays + SecFilt *secfilt = catalog->secfilt; + for (i = 0; i < Nsec; i++) { + M [i] = secfilt[i].M ; + dM [i] = secfilt[i].dM ; + Mchisq[i] = secfilt[i].Mchisq ; + flags [i] = secfilt[i].flags ; + Ncode [i] = secfilt[i].Ncode ; + Nused [i] = secfilt[i].Nused ; + M_20 [i] = secfilt[i].M_20 ; + M_80 [i] = secfilt[i].M_80 ; + } + + // add the columns to the output array + gfits_set_bintable_column (&theader, &ftable, "MAG", M , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_ERR", dM , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_CHI", Mchisq, Nsec); + gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags , Nsec); + gfits_set_bintable_column (&theader, &ftable, "NCODE", Ncode , Nsec); + gfits_set_bintable_column (&theader, &ftable, "NUSED", Nused , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_20", M_20 , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_80", M_80 , Nsec); + + free (M ); + free (dM ); + free (Mchisq ); + free (flags ); + free (Ncode ); + free (Nused ); + free (M_20 ); + free (M_80 ); + + gfits_fwrite_Theader (f, &theader); + gfits_fwrite_table (f, &ftable); + gfits_free_header (&theader); + gfits_free_table (&ftable); + } + return TRUE; +} + +// merge a list of catalogs into a single BrightCatalog array set +BrightCatalog *BrightCatalogMerge (Catalog *catalog, int Ncatalog) { + + off_t i, j, k; + + BrightCatalog *bcatalog = NULL; + ALLOCATE (bcatalog, BrightCatalog, 1); + + int Nmeas = 0; + int Naves = 0; + for (i = 0; i < Ncatalog; i++) { + Nmeas += catalog[i].Nmeasure; + Naves += catalog[i].Naverage; + } + + // XXX this prevents different catalogs from having different Nsecfilt values + int Nsecfilt = GetPhotcodeNsecfilt(); + + ALLOCATE (bcatalog[0].measure, MeasureTiny, Nmeas); + ALLOCATE (bcatalog[0].average, Average, Naves); + ALLOCATE (bcatalog[0].secfilt, SecFilt, Naves*Nsecfilt); + + int Nm = 0; + int Na = 0; + for (i = 0; i < Ncatalog; i++) { + if (!catalog[i].Naverage) continue; + for (j = 0; j < catalog[i].Naverage; j++) { + bcatalog[0].average[Na] = catalog[i].average[j]; + for (k = 0; k < Nsecfilt; k++) { + bcatalog[0].secfilt[Nsecfilt*Na + k] = catalog[i].secfilt[Nsecfilt*j + k]; + } + Na++; + assert (Na <= Naves); + } + for (j = 0; j < catalog[i].Nmeasure; j++) { + bcatalog[0].measure[Nm] = catalog[i].measureT[j]; + Nm++; + assert (Nm <= Nmeas); + } + } + bcatalog->Naverage = Na; + bcatalog->Nmeasure = Nm; + return bcatalog; +} + +// distribute a bright catalog across separate catalogs +CatalogSplitter *BrightCatalogSplitInit (int Nsecfilt) { + + int i; + + CatalogSplitter *catalogs = NULL; + + ALLOCATE (catalogs, CatalogSplitter, 1); + + // as we see new BrightCatalogs, we will update maxID and extend this array + catalogs->maxID = 0; + ALLOCATE (catalogs->index, int, catalogs->maxID + 1); + for (i = 0; i <= catalogs->maxID; i++) catalogs->index[i] = -1; + + catalogs->Nsecfilt = Nsecfilt; + + catalogs->Ncatalog = 0; + catalogs->NCATALOG = 16; + catalogs->catalog = NULL; + ALLOCATE (catalogs->catalog, Catalog, catalogs->NCATALOG); + + ALLOCATE (catalogs->catIDs, int, catalogs->NCATALOG); + ALLOCATE (catalogs->NAVERAGE, off_t, catalogs->NCATALOG); + ALLOCATE (catalogs->NMEASURE, off_t, catalogs->NCATALOG); + + for (i = 0; i < catalogs->NCATALOG; i++) { + dvo_catalog_init (&catalogs->catalog[i], TRUE); + catalogs->catIDs[i] = 0; + catalogs->NAVERAGE[i] = 100; + catalogs->NMEASURE[i] = 100; + catalogs->catalog[i].Naverage = 0; + catalogs->catalog[i].Nmeasure = 0; + ALLOCATE (catalogs->catalog[i].average, Average, catalogs->NAVERAGE[i]); + ALLOCATE (catalogs->catalog[i].measureT, MeasureTiny, catalogs->NMEASURE[i]); + ALLOCATE (catalogs->catalog[i].secfilt, SecFilt, catalogs->NAVERAGE[i]*Nsecfilt); + } + return catalogs; +} + +// distribute a bright catalog across separate catalogs +int BrightCatalogSplitFree (CatalogSplitter *catalogs) { + + free (catalogs->catIDs); + free (catalogs->NAVERAGE); + free (catalogs->NMEASURE); + free (catalogs->index); + free (catalogs); + return TRUE; +} + +// distribute a bright catalog across separate catalogs +int BrightCatalogSplit (CatalogSplitter *catalogs, BrightCatalog *bcatalog) { + + int i; + + int Nsecfilt = catalogs->Nsecfilt; + + // find the max value of catID in this BrightCatalog + int catIDmax = 0; + for (i = 0; i < bcatalog->Naverage; i++) { + catIDmax = MAX(catIDmax, bcatalog->average[i].catID); + } + // XXX validate the measure ID range here + + int maxIDold = catalogs->maxID; + catalogs->maxID = MAX (maxIDold, catIDmax); + + // extend the index array and init + REALLOCATE (catalogs->index, int, catalogs->maxID + 1); + for (i = maxIDold + 1; i <= catalogs->maxID; i++) catalogs->index[i] = -1; + + // identify the new catID values + for (i = 0; i < bcatalog->Naverage; i++) { + int catID = bcatalog->average[i].catID; + assert (catID > 0); + assert (catID < catalogs->maxID + 1); + int idx = catalogs->index[catID]; + if (idx != -1) continue; // already have seen this one + + // a new catID value + int Ncat = catalogs->Ncatalog; // the next available slot + catalogs->catIDs[Ncat] = catID; + assert (Ncat >= 0); + assert (Ncat < catalogs->NCATALOG); + + catalogs->catalog[Ncat].Nsecfilt = Nsecfilt; + catalogs->catalog[Ncat].catID = catID; + + catalogs->index[catID] = Ncat; + assert (catID > 0); + assert (catID < catalogs->maxID + 1); + + catalogs->Ncatalog ++; + + if (catalogs->Ncatalog >= catalogs->NCATALOG) { + catalogs->NCATALOG += 16; + // fprintf (stderr, "realloc catalogs->catalog: old: %llx ", (long long) catalogs->catalog); + REALLOCATE (catalogs->catalog, Catalog, catalogs->NCATALOG); + // fprintf (stderr, "new: %llx - %llx\n", (long long) catalogs->catalog, (long long) (catalogs->catalog + sizeof(Catalog)*catalogs->NCATALOG)); + + // fprintf (stderr, "realloc catalogs->NAVERAGE: old: %llx ", (long long) catalogs->NAVERAGE); + REALLOCATE (catalogs->NAVERAGE, off_t, catalogs->NCATALOG); + // fprintf (stderr, "new: %llx - %llx\n", (long long) catalogs->NAVERAGE, (long long) (catalogs->NAVERAGE + sizeof(off_t)*catalogs->NCATALOG)); + + // fprintf (stderr, "realloc catalogs->NMEASURE: old: %llx ", (long long) catalogs->NMEASURE); + REALLOCATE (catalogs->NMEASURE, off_t, catalogs->NCATALOG); + // fprintf (stderr, "new: %llx - %llx\n", (long long) catalogs->NMEASURE, (long long) (catalogs->NMEASURE + sizeof(off_t)*catalogs->NCATALOG)); + + REALLOCATE (catalogs->catIDs, int, catalogs->NCATALOG); + + int j; + for (j = catalogs->NCATALOG - 16; j < catalogs->NCATALOG; j++) { + dvo_catalog_init (&catalogs->catalog[j], TRUE); + catalogs->catIDs[j] = 0; + catalogs->NAVERAGE[j] = 100; + catalogs->NMEASURE[j] = 100; + catalogs->catalog[j].Naverage = 0; + catalogs->catalog[j].Nmeasure = 0; + ALLOCATE (catalogs->catalog[j].average, Average, catalogs->NAVERAGE[j]); + ALLOCATE (catalogs->catalog[j].measureT, MeasureTiny, catalogs->NMEASURE[j]); + ALLOCATE (catalogs->catalog[j].secfilt, SecFilt, catalogs->NAVERAGE[j]*Nsecfilt); + } + } + } + + // each bcatalog (from each host) has a different set of catID ranges + // they also (probably) have contiguous ranges. But, it is a bit tricky to be sure I + // can use that info, so perhaps ignore it + + // assign the averages to the corresponding catalog + for (i = 0; i < bcatalog->Naverage; i++) { + int ID = bcatalog->average[i].catID; + int Nc = catalogs->index[ID]; + assert (Nc > -1); + assert (Nc < catalogs->NCATALOG); + + int Na = catalogs->catalog[Nc].Naverage; + catalogs->catalog[Nc].average[Na] = bcatalog->average[i]; + + // secfilt entries are grouped in blocks for each average + int k; + for (k = 0; k < Nsecfilt; k++) { + catalogs->catalog[Nc].secfilt[Na*Nsecfilt + k] = bcatalog->secfilt[i*Nsecfilt + k]; + } + + catalogs->catalog[Nc].Naverage ++; + if (catalogs->catalog[Nc].Naverage >= catalogs->NAVERAGE[Nc]) { + catalogs->NAVERAGE[Nc] += 100; + REALLOCATE (catalogs->catalog[Nc].average, Average, catalogs->NAVERAGE[Nc]); + REALLOCATE (catalogs->catalog[Nc].secfilt, SecFilt, catalogs->NAVERAGE[Nc]*Nsecfilt); + } + } + + // assign the measures to the corresponding catalog + // XXX what about averef and related links? Do I need them? + for (i = 0; i < bcatalog->Nmeasure; i++) { + int ID = bcatalog->measure[i].catID; + int Nc = catalogs->index[ID]; + assert (Nc > -1); + assert (Nc < catalogs->NCATALOG); + int Na = catalogs->catalog[Nc].Nmeasure; + catalogs->catalog[Nc].measureT[Na] = bcatalog->measure[i]; + catalogs->catalog[Nc].Nmeasure ++; + if (catalogs->catalog[Nc].Nmeasure >= catalogs->NMEASURE[Nc]) { + catalogs->NMEASURE[Nc] += 100; + REALLOCATE (catalogs->catalog[Nc].measureT, MeasureTiny, catalogs->NMEASURE[Nc]); + } + } + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/ConfigInit.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/ConfigInit.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/ConfigInit.c (revision 37067) @@ -0,0 +1,72 @@ +# include "checkastro.h" + +void ConfigInit (int *argc, char **argv) { + + char *config, *file; + char CatdirPhotcodeFile[256]; + struct stat filestat; + int status; + + /*** load configuration info ***/ + file = SelectConfigFile (argc, argv, "ptolemy"); + config = LoadConfigFile (file); + if (config == (char *) NULL) { + fprintf (stderr, "ERROR: can't find configuration file %s\n", file); + if (file != (char *) NULL) free (file); + exit (0); + } + if (VERBOSE) fprintf (stderr, "loaded config file: %s\n", file); + + // set defaults for all of these if they are not used by parallel / remote clients + if (!ScanConfig (config, "RELASTRO_SIGMA_LIM", "%lf", 0, &SIGMA_LIM)) SIGMA_LIM = 0.01; + if (!ScanConfig (config, "RELASTRO_SRC_MEAS_TOOFEW", "%d", 0, &SRC_MEAS_TOOFEW)) SRC_MEAS_TOOFEW = 3; + + // force CATDIR to be absolute (so parallel mode will work) + GetConfig (config, "CATDIR", "%s", 0, CATDIR); + char *tmpcatdir = abspath (CATDIR, DVO_MAX_PATH); + strcpy (CATDIR, tmpcatdir); + free (tmpcatdir); + + // GetConfig (config, "GSCFILE", "%s", 0, GSCFILE); + ScanConfig(config, "CATMODE", "%s", 0, CATMODE); + ScanConfig(config, "CATFORMAT", "%s", 0, CATFORMAT); + + sprintf (ImageCat, "%s/Images.dat", CATDIR); + + if (!ScanConfig (config, "SKY_DEPTH", "%d", 0, &SKY_DEPTH)) SKY_DEPTH = 2; + if (!ScanConfig (config, "SKY_TABLE", "%s", 0, SKY_TABLE)) SKY_TABLE[0] = 0; + + if (*CATMODE == 0) strcpy (CATMODE, "RAW"); + if (*CATFORMAT == 0) strcpy (CATFORMAT, "ELIXIR"); + + // check for existence of CATDIR + status = stat (CATDIR, &filestat); + if (status == -1) { + fprintf (stderr, "directory %s does not exist, giving up\n", CATDIR); + exit (1); + } + + /* update master photcode table if not defined */ + sprintf (CatdirPhotcodeFile, "%s/Photcodes.dat", CATDIR); + if (!LoadPhotcodes (CatdirPhotcodeFile, NULL, FALSE)) { + fprintf (stderr, "error loading photcode table %s\n", CatdirPhotcodeFile); + exit (1); + } + SetZeroPoint (25.0); + + free (config); + free (file); + +} + +void GetConfig (char *config, char *field, char *format, int N, void *ptr) { + + char *status; + + status = ScanConfig (config, field, format, N, ptr); + if (status == NULL) { + fprintf (stderr, "error in config, cannot find %s\n", field); + exit (1); + } + return; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/ImageOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/ImageOps.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/ImageOps.c (revision 37067) @@ -0,0 +1,253 @@ +# include "checkastro.h" + +// we have an array of images: image[ImageIndex] (ImageIndex : 0 < Nimage) +static Image *image; // list of available images +static off_t Nimage; // number of available images + +// if we read only a subset of the rows from the Image FITS, LineNumber tells us to which row +// each image belongs +static off_t *LineNumber; // match of subset to full image table + +static off_t *N_onImage; // number of measurements on image +static off_t *N_ONIMAGE; // allocated number of measurements on image +static off_t *Nref_onImage; // number of reference measurements on image + +static IDX_T **MeasureToImage; // link from catalog,measure to image +static IDX_T **ImageToCatalog; // catalog which supplied measurement on image +static IDX_T **ImageToMeasure; // measure reference for measurement on image + +// to search by image ID, we sort (imageIDs, imageIdx) by imageIDs for an index +static off_t *imageIDs; // list of all image IDs +static off_t *imageIdx; // list of index for image IDs + +// generate the image ID index (for imageID -> image[i] lookups) +void initImages (Image *input, off_t *line_number, off_t N) { + + off_t i; + + image = input; + LineNumber = line_number; + Nimage = N; + + ALLOCATE (imageIDs, off_t, Nimage); + ALLOCATE (imageIdx, off_t, Nimage); + + for (i = 0; i < Nimage; i++) { + imageIdx[i] = i; + imageIDs[i] = image[i].imageID; + } + llsortpair (imageIDs, imageIdx, Nimage); +} + +off_t getImageByID (off_t ID) { + + // we have a pair of vectors (imageIDs, imageIdx) sorted by imageIDs + // use bisection to find the specified image ID + + off_t Nlo, Nhi, N; + + Nlo = 0; Nhi = Nimage; + while (Nhi - Nlo > 10) { + N = 0.5*(Nlo + Nhi); + if (imageIDs[N] < ID) { + Nlo = MAX(N, 0); + } else { + Nhi = MIN(N + 1, Nimage); + } + } + + for (N = Nlo; N < Nhi; N++) { + if (imageIDs[N] == ID) + return (imageIdx[N]); + } + + return (-1); +} + +// these are really image & catalog indexes +void initImageBins (Catalog *catalog, int Ncatalog) { + + off_t i, j; + + ALLOCATE (MeasureToImage, IDX_T *, Ncatalog); + for (i = 0; i < Ncatalog; i++) { + ALLOCATE (MeasureToImage[i], IDX_T, MAX (catalog[i].Nmeasure, 1)); + for (j = 0; j < catalog[i].Nmeasure; j++) MeasureToImage[i][j] = -1; + } + + ALLOCATE (N_onImage, off_t, Nimage); + ALLOCATE (N_ONIMAGE, off_t, Nimage); + ALLOCATE (Nref_onImage, off_t, Nimage); + ALLOCATE (ImageToCatalog, IDX_T *, Nimage); + ALLOCATE (ImageToMeasure, IDX_T *, Nimage); + + for (i = 0; i < Nimage; i++) { + N_onImage[i] = 0; + N_ONIMAGE[i] = 30; + Nref_onImage[i] = 0; + ImageToCatalog[i] = NULL; // we allocate these iff they are needed in matchImage + ImageToMeasure[i] = NULL; // we allocate these iff they are needed in matchImage + } +} + +void freeImageBins (int Ncatalog) { + + off_t i; + + for (i = 0; i < Ncatalog; i++) { + free (MeasureToImage[i]); + } + free (MeasureToImage); + for (i = 0; i < Nimage; i++) { + if (ImageToCatalog[i]) { free (ImageToCatalog[i]); } + if (ImageToMeasure[i]) { free (ImageToMeasure[i]); } + } + free (ImageToCatalog); + free (ImageToMeasure); + free (N_onImage); + free (N_ONIMAGE); +} + +/* match measurements to images */ +void findImages (Catalog *catalog, int Ncatalog) { + + off_t i, j; + char *name; + + for (i = 0; i < Ncatalog; i++) { + for (j = 0; j < catalog[i].Nmeasure; j++) { + if (NphotcodesSkip > 0) { + int k; + int found = FALSE; + for (k = 0; (k < NphotcodesSkip) && !found; k++) { + if (photcodesSkip[k][0].code == catalog[i].measureT[j].photcode) found = TRUE; + if (photcodesSkip[k][0].code == GetPhotcodeEquivCodebyCode(catalog[i].measureT[j].photcode)) found = TRUE; + } + if (found) continue; + } + matchImage (catalog, j, i); + } + } + + BuildChipMatch (image, Nimage); + + char output[128]; + snprintf (output, 128, "checkastrom.%+3.0f.%+3.0f.%03.0f.%03.0f.dat", UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax); + FILE *f = fopen (output, "w"); + if (!f) { + fprintf (stderr, "problem opening %s for output\n", output); + } + + // watch for chips with few stars + int Nfew = 0; + int Nbad = 0; + for (i = 0; i < Nimage; i++) { + // ignore the PHU entries + if (!strcmp(&image[i].coords.ctype[4], "-DIS")) continue; + + name = GetPhotcodeNamebyCode (image[i].photcode); + + off_t myMosaic = FindMosaicForImage (image, Nimage, i); + + /* only check exposure center */ + double Rexp = NAN, Dexp = NAN, Rccd = NAN, Dccd = NAN; + + if (myMosaic) { + myMosaic --; + XY_to_RD (&Rccd, &Dccd, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords); + XY_to_RD (&Rexp, &Dexp, 0.0, 0.0, &image[myMosaic].coords); + } + + char *date = ohana_sec_to_date(image[i].tzero); + FILE *outfile = f ? f : stderr; + fprintf (outfile, "%d %s : %10.6f %10.6f : %10.6f %10.6f "OFF_T_FMT" "OFF_T_FMT" %d %s %s\n", + image[i].imageID, image[i].name, Rccd, Dccd, Rexp, Dexp, N_onImage[i], Nref_onImage[i], image[i].nstar, + date, name); + free (date); + + if (N_onImage[i] < 20) { + Nfew ++; + } + if (N_onImage[i] < 15) { + Nbad ++; + } + } + if (f) { fclose (f); } + fprintf (stderr, OFF_T_FMT" total images, %d with < 20 measurements, %d with < 15\n", Nimage, Nfew, Nbad); +} + +// this is the imageID-based match +void matchImage (Catalog *catalog, off_t meas, int cat) { + + off_t idx, ID; + MeasureTiny *measure; + + measure = &catalog[cat].measureT[meas]; + unsigned int averef = measure->averef; + Average *average = &catalog[cat].average[averef]; + assert (meas >= average->measureOffset); + assert (meas < average->measureOffset + average->Nmeasure); + + ID = measure[0].imageID; + + if (catalog[cat].measure) { + Measure *measureBig = &catalog[cat].measure[meas]; + int TESTPT = FALSE; + TESTPT |= CAT_ID_SRC && OBJ_ID_SRC && (measureBig->imageID == CAT_ID_SRC) && (measureBig->detID == OBJ_ID_SRC); + TESTPT |= CAT_ID_DST && OBJ_ID_DST && (measureBig->imageID == CAT_ID_DST) && (measureBig->detID == OBJ_ID_DST); + if (TESTPT) { + fprintf (stderr, "got test det\n"); + } + } + + idx = getImageByID (ID); + if (idx == -1) { + if (VERBOSE2) fprintf (stderr, "can't match detection to image?\n"); + return; + } + + // index for (catalog, measure) -> image + MeasureToImage[cat][meas] = idx; + + // if we need to allocate an image index table, do so here + if (!ImageToCatalog[idx]) { + ALLOCATE (ImageToCatalog[idx], IDX_T, N_ONIMAGE[idx]); + } + if (!ImageToMeasure[idx]) { + ALLOCATE (ImageToMeasure[idx], IDX_T, N_ONIMAGE[idx]); + } + + // index for image, Nentry -> catalog + ImageToCatalog[idx][N_onImage[idx]] = cat; + + // index for image, Nentry -> measure + ImageToMeasure[idx][N_onImage[idx]] = meas; + + // in bcatalog, we set this flag if the object includes a reference photcode + if (average->flags & 0x10) { + Nref_onImage[idx] ++; + } + + // count the number of measurements on this image: + N_onImage[idx] ++; + + if (N_onImage[idx] == N_ONIMAGE[idx]) { + N_ONIMAGE[idx] += 30; + REALLOCATE (ImageToCatalog[idx], IDX_T, N_ONIMAGE[idx]); + REALLOCATE (ImageToMeasure[idx], IDX_T, N_ONIMAGE[idx]); + } + + return; +} + +void dump_measures (Average *average, Measure *measure) { + + off_t j, off; + + for (j = 0; j < average[0].Nmeasure; j++) { + off = average[0].measureOffset + j; + fprintf (stderr, "dR, dD, mag, dMag: %f, %f, %f, %f\n", measure[off].dR, measure[off].dD, measure[off].M, measure[off].dM); + } + return; +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/MeasFilterTest.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/MeasFilterTest.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/MeasFilterTest.c (revision 37067) @@ -0,0 +1,133 @@ +# include "checkastro.h" + +/** Determine whether a measurement should be included in the analysis, based on supplied filter criteria */ +// we only optionally apply the sigma limit: for object averages, this should not be used (should it?) +int MeasFilterTestTiny(MeasureTiny *measure, int applySigmaLim) { + int found, k; + long mask; + PhotCode *code; + float mag; + + if (!finite(measure[0].dR) || !finite(measure[0].dD)) return FALSE; + if (!finite(measure[0].M)) return FALSE; //XXX is this necessary for all checkastro tasks? + if (!finite(measure[0].dM)) return FALSE; //XXX is this necessary for all checkastro tasks? + + /* select measurements by photcode, or equiv photcode, if specified */ + if (NphotcodesKeep > 0) { + found = FALSE; + for (k = 0; (k < NphotcodesKeep) && !found; k++) { + if (photcodesKeep[k][0].code == measure[0].photcode) found = TRUE; + if (photcodesKeep[k][0].code == GetPhotcodeEquivCodebyCode(measure[0].photcode)) found = TRUE; + } + if (!found) return FALSE; + } + + if (NphotcodesSkip > 0) { + found = FALSE; + for (k = 0; (k < NphotcodesSkip) && !found; k++) { + if (photcodesSkip[k][0].code == measure[0].photcode) found = TRUE; + if (photcodesSkip[k][0].code == GetPhotcodeEquivCodebyCode(measure[0].photcode)) found = TRUE; + } + if (found) return FALSE; + } + + // if (MinBadQF > 0.0) { + // if (measure[0].psfQF < MinBadQF) return FALSE; + // } + + /* select measurements by time */ + if (TimeSelect) { + if (measure[0].t < TSTART) return FALSE; + if (measure[0].t > TSTOP) return FALSE; + } + + /* select measurements by quality */ + if (PhotFlagSelect) { + if (PhotFlagBad) { + mask = PhotFlagBad; + } else { + code = GetPhotcodebyCode (measure[0].photcode); + mask = code[0].astromBadMask; + } + if (mask & measure[0].photFlags) return FALSE; + } + + /* select measurements by measurement error */ + if (applySigmaLim && (SIGMA_LIM > 0) && (measure[0].dM > SIGMA_LIM)) { + return FALSE; + } + + /* select measurements by mag limit */ + if (ImagSelect) { + mag = PhotInstTiny (measure); + if (mag < ImagMin || mag > ImagMax) return FALSE; + } + + return TRUE; +} + +/** Determine whether a measurement should be included in the analysis, based on supplied filter criteria */ +// we only optionally apply the sigma limit: for object averages, this should not be used (should it?) +int MeasFilterTest(Measure *measure, int applySigmaLim) { + int found, k; + long mask; + PhotCode *code; + float mag; + + if (!finite(measure[0].dR) || !finite(measure[0].dD)) return FALSE; + if (!finite(measure[0].M)) return FALSE; //XXX is this necessary for all checkastro tasks? + if (!finite(measure[0].dM)) return FALSE; //XXX is this necessary for all checkastro tasks? + + /* select measurements by photcode, or equiv photcode, if specified */ + if (NphotcodesKeep > 0) { + found = FALSE; + for (k = 0; (k < NphotcodesKeep) && !found; k++) { + if (photcodesKeep[k][0].code == measure[0].photcode) found = TRUE; + if (photcodesKeep[k][0].code == GetPhotcodeEquivCodebyCode(measure[0].photcode)) found = TRUE; + } + if (!found) return FALSE; + } + + if (NphotcodesSkip > 0) { + found = FALSE; + for (k = 0; (k < NphotcodesSkip) && !found; k++) { + if (photcodesSkip[k][0].code == measure[0].photcode) found = TRUE; + if (photcodesSkip[k][0].code == GetPhotcodeEquivCodebyCode(measure[0].photcode)) found = TRUE; + } + if (found) return FALSE; + } + + if (MinBadQF > 0.0) { + if (measure[0].psfQF < MinBadQF) return FALSE; + } + + /* select measurements by time */ + if (TimeSelect) { + if (measure[0].t < TSTART) return FALSE; + if (measure[0].t > TSTOP) return FALSE; + } + + /* select measurements by quality */ + if (PhotFlagSelect) { + if (PhotFlagBad) { + mask = PhotFlagBad; + } else { + code = GetPhotcodebyCode (measure[0].photcode); + mask = code[0].astromBadMask; + } + if (mask & measure[0].photFlags) return FALSE; + } + + /* select measurements by measurement error */ + if (applySigmaLim && (SIGMA_LIM > 0) && (measure[0].dM > SIGMA_LIM)) { + return FALSE; + } + + /* select measurements by mag limit */ + if (ImagSelect) { + mag = PhotInst (measure); + if (mag < ImagMin || mag > ImagMax) return FALSE; + } + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/SetSignals.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/SetSignals.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/SetSignals.c (revision 37067) @@ -0,0 +1,122 @@ +# include "checkastro.h" + +static int Protect = FALSE; +static int Trapped = FALSE; + +void TrapSignal (int sig) { + fprintf (stderr, "trapped signal %d\n", sig); + if (sig == 11) { + fprintf (stderr, "seg fault\n"); + exit (1); + } + if (Protect) { + Trapped = TRUE; + fprintf (stderr, "blocking until protected sections are clear\n"); + return; + } + Shutdown ("halted by signal (trapped)"); +} + +void SetProtect (int mode) { + Protect = mode; + if (Trapped && !Protect) Shutdown ("halted by signal (protect)"); +} + +int SetSignals () { + + int i; + + /* disable almost all signal interrupts */ + for (i = 0; i < 36; i++) { + switch (i) { + /* can't redirect this signals */ + case SIGKILL: /* kill -9: cannot be caught or ignored */ + case SIGSTOP: /* SIGSTOP: cannot be caught or ignored */ + /* ignore these signals */ + case SIGCHLD: /* child halted: ignore */ + case SIGCONT: /* continue - maintain this action */ + case SIGTSTP: /* stop signal sent from tty - why ignore? */ + case SIGURG: /* socket signal, ignore this */ +# ifdef SIGPWR + case SIGPWR: /* power failure - why ignore this? (Sys V) */ +# endif +# ifdef SIGWINCH + case SIGWINCH: /* window resized (4.3BSD) */ +# endif + break; + + default: + signal (i, TrapSignal); + } + } + return (TRUE); +} +/* + + Signal Value Action Comment + ------------------------------------------------------------------------- + SIGHUP 1 A Hangup detected on controlling terminal + or death of controlling process + SIGINT 2 A Interrupt from keyboard + SIGQUIT 3 A Quit from keyboard + SIGILL 4 A Illegal Instruction + SIGABRT 6 C Abort signal from abort(3) + SIGFPE 8 C Floating point exception + SIGKILL 9 AEF Kill signal + SIGSEGV 11 C Invalid memory reference + SIGPIPE 13 A Broken pipe: write to pipe with no readers + SIGALRM 14 A Timer signal from alarm(2) + SIGTERM 15 A Termination signal + SIGUSR1 30,10,16 A User-defined signal 1 + SIGUSR2 31,12,17 A User-defined signal 2 + SIGCHLD 20,17,18 B Child stopped or terminated + SIGCONT 19,18,25 Continue if stopped + SIGSTOP 17,19,23 DEF Stop process + SIGTSTP 18,20,24 D Stop typed at tty + SIGTTIN 21,21,26 D tty input for background process + SIGTTOU 22,22,27 D tty output for background process + + Next various other signals. + + Signal Value Action Comment + --------------------------------------------------------------------- + SIGTRAP 5 CG Trace/breakpoint trap + SIGIOT 6 CG IOT trap. A synonym for SIGABRT + SIGEMT 7,-,7 G + SIGBUS 10,7,10 AG Bus error + SIGSYS 12,-,12 G Bad argument to routine (SVID) + SIGSTKFLT -,16,- AG Stack fault on coprocessor + SIGURG 16,23,21 BG Urgent condition on socket (4.2 BSD) + SIGIO 23,29,22 AG I/O now possible (4.2 BSD) + SIGPOLL AG A synonym for SIGIO (System V) + SIGCLD -,-,18 G A synonym for SIGCHLD + SIGXCPU 24,24,30 AG CPU time limit exceeded (4.2 BSD) + SIGXFSZ 25,25,31 AG File size limit exceeded (4.2 BSD) + SIGVTALRM 26,26,28 AG Virtual alarm clock (4.2 BSD) + SIGPROF 27,27,29 AG Profile alarm clock + SIGPWR 29,30,19 AG Power failure (System V) + SIGINFO 29,-,- G A synonym for SIGPWR + SIGLOST -,-,- AG File lock lost + SIGWINCH 28,28,20 BG Window resize signal (4.3 BSD, Sun) + SIGUNUSED -,31,- AG Unused signal + (Here - denotes that a signal is absent; there where three values are given, the first one is usually valid for alpha and + sparc, the middle one for i386 and ppc, the last one for mips. Signal 29 is SIGINFO / SIGPWR on an alpha but SIGLOST on a + sparc.) + + The letters in the "Action" column have the following meanings: + + A Default action is to terminate the process. + + B Default action is to ignore the signal. + + C Default action is to dump core. + + D Default action is to stop the process. + + E Signal cannot be caught. + + F Signal cannot be ignored. + + G Not a POSIX.1 conformant signal. + +*/ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/Shutdown.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/Shutdown.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/Shutdown.c (revision 37067) @@ -0,0 +1,30 @@ +# include "checkastro.h" + +static FITS_DB *db; + +void set_db (FITS_DB *in) { + db = in; +} + +/* clean up open / locked ImageCat before shutting down */ +int Shutdown (char *format, ...) { + va_list argp; + char *formatplus; + + ALLOCATE (formatplus, char, strlen(format)); + strcpy (formatplus, format); + strcat (formatplus, "\n"); + + va_start (argp, format); + vfprintf (stderr, formatplus, argp); + free (formatplus); + va_end (argp); + + SetProtect (TRUE); + gfits_db_close (db); + fprintf (stderr, "ERROR: addstar halted\n"); + exit (1); +} + + +/* XXX this is probably not needed anymore : just protect the write statements */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/args.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/args.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/args.c (revision 37067) @@ -0,0 +1,433 @@ +# include "checkastro.h" +void usage (void); +void usage_client (void); +void usage_merge_source (void); +void usage_merge_source_id (char *name); + +int args (int argc, char **argv) { + + int N; + double trange; + + /* specify portion of the sky : allow default of all sky? */ + UserPatch.Rmin = 0; + UserPatch.Rmax = 360; + UserPatch.Dmin = -90; + UserPatch.Dmax = +90; + if ((N = get_argument (argc, argv, "-region"))) { + remove_argument (N, &argc, argv); + UserPatch.Rmin = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Rmax = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Dmin = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Dmax = atof (argv[N]); + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-catalog"))) { + remove_argument (N, &argc, argv); + UserPatch.Rmin = atof (argv[N]); + UserPatch.Rmax = UserPatch.Rmin + 0.001; + remove_argument (N, &argc, argv); + UserPatch.Dmin = atof (argv[N]); + UserPatch.Dmax = UserPatch.Dmin + 0.001; + remove_argument (N, &argc, argv); + } + + // XXX for the moment, make this selection manual. it needs to be automatic + // based on the state of the SkyTable + PARALLEL = FALSE; + if ((N = get_argument (argc, argv, "-parallel"))) { + PARALLEL = TRUE; + remove_argument (N, &argc, argv); + } + // this is a test mode : rather than launching the remote jobs and waiting for completion, + // checkastro will simply list the remote command and wait for the user to signal completion + PARALLEL_MANUAL = FALSE; + if ((N = get_argument (argc, argv, "-parallel-manual"))) { + PARALLEL = TRUE; // -parallel-manual implies -parallel + PARALLEL_MANUAL = TRUE; + remove_argument (N, &argc, argv); + } + // this is a test mode : rather than launching the checkastro_client jobs remotely, they are + // run in serial via 'system' + PARALLEL_SERIAL = FALSE; + if ((N = get_argument (argc, argv, "-parallel-serial"))) { + if (PARALLEL_MANUAL) { + fprintf (stderr, "ERROR: cannot mix -parallel-manual and -parallel-serial\n"); + exit (1); + } + PARALLEL = TRUE; // -parallel-serial implies -parallel + PARALLEL_SERIAL = TRUE; + remove_argument (N, &argc, argv); + } + + MaxDensityUse = FALSE; + if ((N = get_argument (argc, argv, "-max-density"))) { + remove_argument (N, &argc, argv); + MaxDensityValue = atof(argv[N]); + remove_argument (N, &argc, argv); + MaxDensityUse = TRUE; + } + + /* define time */ + TimeSelect = FALSE; + if ((N = get_argument (argc, argv, "-time"))) { + remove_argument (N, &argc, argv); + if (!ohana_str_to_time (argv[N], &TSTART)) { + fprintf (stderr, "ERROR: syntax error\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + if (!ohana_str_to_dtime (argv[N], &trange)) { + if (!ohana_str_to_time (argv[N], &TSTOP)) { + fprintf (stderr, "ERROR: syntax error\n"); + return (FALSE); + } + } else { + if (trange < 0) { + trange = fabs (trange); + TSTOP = TSTART; + TSTART -= trange; + } else { + TSTOP = TSTART + trange; + } + } + remove_argument (N, &argc, argv); + TimeSelect = TRUE; + } + + PHOTCODE_RESET_LIST = NULL; + if ((N = get_argument (argc, argv, "-reset-to-photcode"))) { + remove_argument (N, &argc, argv); + PHOTCODE_RESET_LIST = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + + PHOTCODE_KEEP_LIST = NULL; + if ((N = get_argument (argc, argv, "+photcode"))) { + remove_argument (N, &argc, argv); + PHOTCODE_KEEP_LIST = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + + PHOTCODE_SKIP_LIST = strcreate("SCOS.103a.E,SCOS.4414.OG590,SCOS.4415.OG590,SCOS.IIIaF.OG590,SCOS.IIIaF.RG610,SCOS.IIIaF.RG630,SCOS.IIIaJ.GG385,SCOS.IIIaJ.GG395,SCOS.IVN.RG715,SCOS.IVN.RG9"); + if ((N = get_argument (argc, argv, "-photcode"))) { + remove_argument (N, &argc, argv); + char *tmp1 = strcreate(argv[N]); + + int Ntotal = strlen(tmp1) + strlen(PHOTCODE_SKIP_LIST) + 5; + + char *tmp2 = NULL; + ALLOCATE (tmp2, char, Ntotal); + snprintf (tmp2, Ntotal, "%s,%s", PHOTCODE_SKIP_LIST, tmp1); + + free (tmp1); + free (PHOTCODE_SKIP_LIST); + + PHOTCODE_SKIP_LIST = tmp2; + remove_argument (N, &argc, argv); + } + + VERBOSE = VERBOSE2 = FALSE; + if ((N = get_argument (argc, argv, "-v"))) { + VERBOSE = TRUE; + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-vv"))) { + VERBOSE = VERBOSE2 = TRUE; + remove_argument (N, &argc, argv); + } + + /* XXX update this */ + MIN_ERROR = 0.001; + if ((N = get_argument (argc, argv, "-minerror"))) { + remove_argument (N, &argc, argv); + MIN_ERROR = atof (argv[N]); + remove_argument (N, &argc, argv); + /* require MIN_ERROR > 0 */ + } + + ImagSelect = FALSE; + if ((N = get_argument (argc, argv, "-instmag"))) { + remove_argument (N, &argc, argv); + ImagMin = atof (argv[N]); + remove_argument (N, &argc, argv); + ImagMax = atof (argv[N]); + remove_argument (N, &argc, argv); + ImagSelect = TRUE; + } + + // for now, make the default to ignore the photflags + // XXX make it true by default instead? + PhotFlagSelect = FALSE; + if ((N = get_argument (argc, argv, "+photflags"))) { + remove_argument (N, &argc, argv); + PhotFlagSelect = TRUE; + } + + PhotFlagBad = 0; + if ((N = get_argument (argc, argv, "-photflagbad"))) { + remove_argument (N, &argc, argv); + PhotFlagBad = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + + PhotFlagPoor = 0; + if ((N = get_argument (argc, argv, "-photflagpoor"))) { + remove_argument (N, &argc, argv); + PhotFlagPoor = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + + MinBadQF = 0.0; + if ((N = get_argument (argc, argv, "-min-bad-psfqf"))) { + remove_argument (N, &argc, argv); + MinBadQF = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + if (argc != 1) usage (); + return TRUE; +} + +int args_client (int argc, char **argv) { + + int N; + double trange; + + /* possible operations */ + // by definition, the client is not parallel + PARALLEL = FALSE; + PARALLEL_MANUAL = FALSE; + PARALLEL_SERIAL = FALSE; + + BCATALOG = NULL; + + HOST_ID = 0; + if ((N = get_argument (argc, argv, "-hostID"))) { + remove_argument (N, &argc, argv); + HOST_ID = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + if (!HOST_ID) usage_client(); + + HOSTDIR = NULL; + if ((N = get_argument (argc, argv, "-hostdir"))) { + remove_argument (N, &argc, argv); + HOSTDIR = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + if (!HOSTDIR) usage_client(); + + if ((N = get_argument (argc, argv, "-load-objects"))) { + remove_argument (N, &argc, argv); + BCATALOG = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + + /* specify portion of the sky : allow default of all sky? */ + UserPatch.Rmin = 0; + UserPatch.Rmax = 360; + UserPatch.Dmin = -90; + UserPatch.Dmax = +90; + if ((N = get_argument (argc, argv, "-region"))) { + remove_argument (N, &argc, argv); + UserPatch.Rmin = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Rmax = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Dmin = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Dmax = atof (argv[N]); + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-catalog"))) { + remove_argument (N, &argc, argv); + UserPatch.Rmin = atof (argv[N]); + UserPatch.Rmax = UserPatch.Rmin + 0.001; + remove_argument (N, &argc, argv); + UserPatch.Dmin = atof (argv[N]); + UserPatch.Dmax = UserPatch.Dmin + 0.001; + remove_argument (N, &argc, argv); + } + + MaxDensityUse = FALSE; + if ((N = get_argument (argc, argv, "-max-density"))) { + remove_argument (N, &argc, argv); + MaxDensityValue = atof(argv[N]); + remove_argument (N, &argc, argv); + MaxDensityUse = TRUE; + } + + /* define time */ + TimeSelect = FALSE; + if ((N = get_argument (argc, argv, "-time"))) { + remove_argument (N, &argc, argv); + if (!ohana_str_to_time (argv[N], &TSTART)) { + fprintf (stderr, "ERROR: syntax error\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + if (!ohana_str_to_dtime (argv[N], &trange)) { + if (!ohana_str_to_time (argv[N], &TSTOP)) { + fprintf (stderr, "ERROR: syntax error\n"); + return (FALSE); + } + } else { + if (trange < 0) { + trange = fabs (trange); + TSTOP = TSTART; + TSTART -= trange; + } else { + TSTOP = TSTART + trange; + } + } + remove_argument (N, &argc, argv); + TimeSelect = TRUE; + } + + PHOTCODE_RESET_LIST = NULL; + if ((N = get_argument (argc, argv, "-reset-to-photcode"))) { + remove_argument (N, &argc, argv); + PHOTCODE_RESET_LIST = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + + PHOTCODE_KEEP_LIST = NULL; + if ((N = get_argument (argc, argv, "+photcode"))) { + remove_argument (N, &argc, argv); + PHOTCODE_KEEP_LIST = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + + PHOTCODE_SKIP_LIST = NULL; + if ((N = get_argument (argc, argv, "-photcode"))) { + remove_argument (N, &argc, argv); + PHOTCODE_SKIP_LIST = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + + VERBOSE = VERBOSE2 = FALSE; + if ((N = get_argument (argc, argv, "-v"))) { + VERBOSE = TRUE; + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-vv"))) { + VERBOSE = VERBOSE2 = TRUE; + remove_argument (N, &argc, argv); + } + + ImagSelect = FALSE; + if ((N = get_argument (argc, argv, "-instmag"))) { + remove_argument (N, &argc, argv); + ImagMin = atof (argv[N]); + remove_argument (N, &argc, argv); + ImagMax = atof (argv[N]); + remove_argument (N, &argc, argv); + ImagSelect = TRUE; + } + + // for now, make the default to ignore the photflags + // XXX make it true by default instead? + PhotFlagSelect = FALSE; + if ((N = get_argument (argc, argv, "+photflags"))) { + remove_argument (N, &argc, argv); + PhotFlagSelect = TRUE; + } + + PhotFlagBad = 0; + if ((N = get_argument (argc, argv, "-photflagbad"))) { + remove_argument (N, &argc, argv); + PhotFlagBad = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + + PhotFlagPoor = 0; + if ((N = get_argument (argc, argv, "-photflagpoor"))) { + remove_argument (N, &argc, argv); + PhotFlagPoor = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + + MinBadQF = 0.0; + if ((N = get_argument (argc, argv, "-min-bad-psfqf"))) { + remove_argument (N, &argc, argv); + MinBadQF = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + if (argc != 1) usage_client (); + return TRUE; +} + +void usage () { + fprintf (stderr, "ERROR: USAGE: checkastro [options]\n"); + fprintf (stderr, " options: \n"); + fprintf (stderr, " -region RA RA DEC DEC\n"); + fprintf (stderr, " -catalog (ra) (dec)\n\n"); + fprintf (stderr, " -time (start)(stop)\n"); + fprintf (stderr, " +photcode (code)[,code,code...]\n"); + fprintf (stderr, " -photcode (code)[,code,code...]\n"); + fprintf (stderr, " -reset-to-photcode (code)[,code,code...]\n"); + fprintf (stderr, " -max-density (rho)\n"); + fprintf (stderr, " -minerror\n"); + fprintf (stderr, " -minerror\n"); + fprintf (stderr, " -instmag min max\n\n"); + fprintf (stderr, " +photflags\n"); + fprintf (stderr, " -photflagbad\n"); + fprintf (stderr, " -photflagpoor\n"); + fprintf (stderr, " -v\n"); + fprintf (stderr, " -vv\n"); + fprintf (stderr, " -parallel\n"); + fprintf (stderr, " -parallel-manual\n"); + fprintf (stderr, " -parallel-serial\n"); + fprintf (stderr, " \n"); + exit (2); +} + +void usage_client () { + fprintf (stderr, "ERROR: USAGE: checkastro_client -load\n"); + fprintf (stderr, " OR: checkastro_client -update-offsets\n"); + fprintf (stderr, " OR: checkastro_client -update-objects\n"); + fprintf (stderr, " OR: checkastro_client -high-speed\n\n"); + + fprintf (stderr, " specify one of the following modes: \n"); + fprintf (stderr, " -load : load the bright source detections for analysis\n"); + fprintf (stderr, " -update-offsets : apply the updated image parameters\n"); + fprintf (stderr, " -update-objects : calculate average astrometric properties of objects\n"); + fprintf (stderr, " -high-speed (code[,code,code]) (code[,code,code]) (radius) (output catdir)\n"); + fprintf (stderr, " support for the special high-speed mode\n"); + + fprintf (stderr, " additional options: \n"); + fprintf (stderr, " -pm : calculate proper motions\n"); + fprintf (stderr, " -par : calculate parallaxes\n"); + fprintf (stderr, " -pmpar : calculate motions and parallaxes\n"); + fprintf (stderr, " -region Rmin Rmax Dmin Dmax"); + fprintf (stderr, " -catalog RA DEC"); + fprintf (stderr, " -time (start)(stop)\n"); + fprintf (stderr, " +photcode (code)[,code,code...]\n"); + fprintf (stderr, " -photcode (code)[,code,code...]\n"); + fprintf (stderr, " -statmode (mode)\n"); + fprintf (stderr, " -reset\n"); + fprintf (stderr, " -minerror\n"); + fprintf (stderr, " -instmag min max\n\n"); + fprintf (stderr, " +photflags\n"); + fprintf (stderr, " -photflagbad\n"); + fprintf (stderr, " -photflagpoor\n"); + fprintf (stderr, " -v\n"); + fprintf (stderr, " \n"); + exit (2); +} + +void usage_merge_source_id (char *name) { + + fprintf (stderr, "ERROR: invalid ID %s (remember to prefix 0x to hex IDs)\n", name); + exit (2); +} + +void usage_merge_source () { + fprintf (stderr, "ERROR: USAGE: checkastro -merge-source (objID) (catID) into (objID) (catID)\n"); + exit (2); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/bcatalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/bcatalog.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/bcatalog.c (revision 37067) @@ -0,0 +1,620 @@ +# include "checkastro.h" + +static int Nkeep1 = 0; +static int Nkeep2 = 0; +static int Nskip1 = 0; +static int Nskip2 = 0; + +// test image: 2013/06/15,13:25:51, GPC1.r.XY50 +static int CHECK_TEST_IMAGE = TRUE; +// static unsigned int Tref = 1378812312; +// static short Cref = 10001; + +static unsigned int Tref = 1379570672; +static short Cref = 10341; + +int LimitDensityCatalog_ByNmeasureGrid (Catalog *subcatalog, Catalog *oldcatalog); + +int bcatalog (Catalog *subcatalog, Catalog *catalog) { + + off_t i, j, offset; + off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nm; + int Nsecfilt; + + // XXX in the future, use catalog[0].Nsecfilt only? allow catalogs to have variable Nsecfilt? + Nsecfilt = GetPhotcodeNsecfilt (); + assert (catalog[0].Nsecfilt == Nsecfilt); + + /* we are moving only the subset of measurements from catalog[0] to subcatalog[0] */ + memset(subcatalog, 0, sizeof(Catalog)); + NAVERAGE = 50; + NMEASURE = 1000; + ALLOCATE (subcatalog[0].average, Average, NAVERAGE); + ALLOCATE (subcatalog[0].secfilt, SecFilt, NAVERAGE*Nsecfilt); + ALLOCATE (subcatalog[0].measureT, MeasureTiny, NMEASURE); + Nmeasure = Naverage = 0; + + /* exclude stars not in range or with too few measurements */ + for (i = 0; i < catalog[0].Naverage; i++) { + if (catalog[0].average[i].Nmeasure <= SRC_MEAS_TOOFEW) continue; + + /* start with all stars good */ + subcatalog[0].average[Naverage] = catalog[0].average[i]; + subcatalog[0].average[Naverage].measureOffset = Nmeasure; + for (j = 0; j < Nsecfilt; j++) { + subcatalog[0].secfilt[Nsecfilt*Naverage+j] = catalog[0].secfilt[Nsecfilt*i+j]; + } + + int foundRef = FALSE; + + Nm = 0; + for (j = 0; j < catalog[0].average[i].Nmeasure; j++) { + + offset = catalog[0].average[i].measureOffset + j; + + // filter objects based on user supplied criteria, including SIGMA_LIM + if (!MeasFilterTest(&catalog[0].measure[offset], TRUE)) { + catalog[0].measure[offset].dbFlags &= ~ID_MEAS_USED_CHIP; + if (CHECK_TEST_IMAGE && (abs(catalog[0].measure[offset].t - Tref) < 10) && (catalog[0].measure[offset].photcode == Cref)) { + Nskip1 ++; + } + continue; + } + if (CHECK_TEST_IMAGE && (abs(catalog[0].measure[offset].t - Tref) < 10) && (catalog[0].measure[offset].photcode == Cref)) { + Nkeep1 ++; + } + + // does this measurement match any of the reference photcodes? + if (!foundRef && NphotcodesReset) { + int m, found = FALSE; + for (m = 0; (m < NphotcodesReset) && !found; m++) { + if (catalog[0].measure[offset].photcode == photcodesReset[m][0].code) { + found = TRUE; + } + } + if (found) { + foundRef = TRUE; + } + } + + // subcatalog[0].measure[Nmeasure] = catalog[0].measure[offset]; + CopyMeasureToTiny (&subcatalog[0].measureT[Nmeasure], &catalog[0].measure[offset]); + subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_SKIP_ASTROM; + subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_NOCAL; + subcatalog[0].measureT[Nmeasure].averef = Naverage; + + Nmeasure ++; + Nm ++; + if (Nmeasure == NMEASURE) { + NMEASURE += 1000; + REALLOCATE (subcatalog[0].measureT, MeasureTiny, NMEASURE); + } + } + if (foundRef) { + subcatalog[0].average[Naverage].flags |= 0x10; + } + subcatalog[0].average[Naverage].Nmeasure = Nm; + Naverage ++; + if (Naverage == NAVERAGE) { + NAVERAGE += 50; + REALLOCATE (subcatalog[0].average, Average, NAVERAGE); + REALLOCATE (subcatalog[0].secfilt, SecFilt, NAVERAGE*Nsecfilt); + } + } + REALLOCATE (subcatalog[0].average, Average, MAX (Naverage, 1)); + REALLOCATE (subcatalog[0].measureT, MeasureTiny, MAX (Nmeasure, 1)); + REALLOCATE (subcatalog[0].secfilt, SecFilt, MAX (Naverage, 1)*Nsecfilt); + subcatalog[0].Naverage = Naverage; + subcatalog[0].Nmeasure = Nmeasure; + subcatalog[0].Nsecfilt = catalog[0].Nsecfilt; + subcatalog[0].Nsecfilt = catalog[0].Nsecfilt; + subcatalog[0].catID = catalog[0].catID; + assert (Nsecfilt == catalog[0].Nsecfilt); + + // limit the total number of stars in the catalog + if (MaxDensityUse) { + LimitDensityCatalog_ByNmeasureGrid (subcatalog, catalog); + } else { + if (VERBOSE2) { + char *basename = filebasename (catalog[0].filename); + fprintf (stderr, "subset of "OFF_T_FMT" ("OFF_T_FMT" total) stars, "OFF_T_FMT" ("OFF_T_FMT" total) measures for catalog %s\n", + subcatalog[0].Naverage, catalog[0].Naverage, subcatalog[0].Nmeasure, catalog[0].Nmeasure, basename); + free (basename); + } + } + if (CHECK_TEST_IMAGE && (Nkeep1 + Nkeep2 + Nskip1 + Nskip2 > 0)) { + fprintf (stderr, "kept %d %d, skipped %d %d\n", Nkeep1, Nkeep2, Nskip1, Nskip2); + } + + return (TRUE); +} + +void bcatalog_show_skips () { + fprintf (stderr, "Nskip: %d, %d\n", Nskip1, Nskip2); + fprintf (stderr, "Nkeep: %d, %d\n", Nkeep1, Nkeep2); +} + +// sort by decreasing Nmeasure (X) +void sort_by_Nmeasure (int *X, off_t *Y, off_t N) { + +# define SWAPFUNC(A,B){ int tmpI; off_t tmpT; \ + tmpI = X[A]; X[A] = X[B]; X[B] = tmpI; \ + tmpT = Y[A]; Y[A] = Y[B]; Y[B] = tmpT; \ +} +# define COMPARE(A,B)(X[A] > X[B]) + + OHANA_SORT (N, COMPARE, SWAPFUNC); + +# undef SWAPFUNC +# undef COMPARE + +} + +/* generate a grid in a locally-projected coordinate system, try to select average entries + from each grid cell in decending Nmeasure order. + */ +int LimitDensityCatalog_ByNmeasureGrid (Catalog *subcatalog, Catalog *oldcatalog) { + + off_t i, j; + int ix, iy; + + Catalog tmpcatalog; + + double Rmin, Rmax, Dmin, Dmax; + + int Nsecfilt = GetPhotcodeNsecfilt (); + + gfits_scan (&oldcatalog[0].header, "RA0", "%lf", 1, &Rmin); + gfits_scan (&oldcatalog[0].header, "DEC0", "%lf", 1, &Dmin); + gfits_scan (&oldcatalog[0].header, "RA1", "%lf", 1, &Rmax); + gfits_scan (&oldcatalog[0].header, "DEC1", "%lf", 1, &Dmax); + + if (VERBOSE2) fprintf (stderr, "extracting from catalog covering region %f,%f to %f,%f\n", Rmin, Dmin, Rmax, Dmax); + + float AREA = fabs(Dmax - Dmin) * fabs(Rmax - Rmin) * cos (0.5*RAD_DEG*(Dmax + Dmin)); + assert (AREA > 0); + + off_t Nmax = MaxDensityValue * AREA; + if (subcatalog[0].Naverage <= Nmax) { + if (VERBOSE) { + fprintf (stderr, "subcatalog has less than the max density\n"); + } + return (TRUE); + } + + off_t Naverage = subcatalog[0].Naverage; + + // generate a grid in locally projected space + double Rc = 0.5*(Rmin + Rmax); + double Dc = 0.5*(Dmin + Dmax); + + /* project coordinates to a plane centered on the object with units of arcsec */ + Coords coords; + coords.crval1 = Rc; + coords.crval2 = Dc; + coords.crpix1 = 0; + coords.crpix2 = 0; + coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0; + coords.pc1_1 = coords.pc2_2 = 1.0; + coords.pc1_2 = coords.pc2_1 = 0.0; + coords.Npolyterms = 1; + strcpy (coords.ctype, "DEC--SIN"); + + // convert all average R,D values to X,Y: + double *X, *Y; + ALLOCATE (X, double, Naverage); + ALLOCATE (Y, double, Naverage); + float Xmin = +10000.0, Ymin = +10000.0; + float Xmax = -10000.0, Ymax = -10000.0; + for (i = 0; i < Naverage; i++) { + X[i] = NAN; + Y[i] = NAN; + // skip any stars which are outside of nominal catalog range + if (subcatalog[0].average[i].R < Rmin) continue; + if (subcatalog[0].average[i].R > Rmax) continue; + if (subcatalog[0].average[i].D < Dmin) continue; + if (subcatalog[0].average[i].D > Dmax) continue; + RD_to_XY (&X[i], &Y[i], subcatalog[0].average[i].R, subcatalog[0].average[i].D, &coords); + Xmin = MIN (Xmin, X[i]); + Xmax = MAX (Xmax, X[i]); + Ymin = MIN (Ymin, Y[i]); + Ymax = MAX (Ymax, Y[i]); + } + + // how many grid cells? what is the grid spacing? + float dX = Xmax - Xmin; + float dY = Ymax - Ymin; + + // *** XXX for the moment, I'm using a hard-wired cell size (200 arcsec ~ 3.3 arcmin) + int NX = (int)(dX / 200) + 1; + int NY = (int)(dY / 200) + 1; + // fprintf (stderr, "Density Grid: %d x %d\n", NX, NY); + // XXX check that NX,NY are sensible (5 degrees / 200 arcsec seems like the absolute max) + if (NX > 1000) { + fprintf (stderr, "serious problem with %s: NX = %d\n", subcatalog[0].filename, NX); + exit (3); + } + if (NY > 1000) { + fprintf (stderr, "serious problem with %s: NY = %d\n", subcatalog[0].filename, NY); + exit (3); + } + + // kind of ugly : generate a grid of index, Nmeasure arrays + // to be filled below (I also need NN and Nn to track the number of + // entries in each). + int **NN_grid; + int **Nn_grid; + int ***Nm_grid; + off_t ***idxgrid; + ALLOCATE (NN_grid, int *, NX); + ALLOCATE (Nn_grid, int *, NX); + ALLOCATE (Nm_grid, int **, NX); + ALLOCATE (idxgrid, off_t **, NX); + + for (ix = 0; ix < NX; ix++) { + ALLOCATE (NN_grid[ix], int, NY); + ALLOCATE (Nn_grid[ix], int, NY); + ALLOCATE (Nm_grid[ix], int *, NY); + ALLOCATE (idxgrid[ix], off_t *, NY); + for (iy = 0; iy < NY; iy++) { + Nn_grid[ix][iy] = 0; + NN_grid[ix][iy] = 100; + ALLOCATE (Nm_grid[ix][iy], int, NN_grid[ix][iy]); + ALLOCATE (idxgrid[ix][iy], off_t, NN_grid[ix][iy]); + } + } + + // assign all of the average entries to a grid cell + for (i = 0; i < Naverage; i++) { + if (isnan(X[i])) continue; + if (isnan(Y[i])) continue; + ix = (X[i] - Xmin) / 200.0; + iy = (Y[i] - Ymin) / 200.0; + int Nn = Nn_grid[ix][iy]; + Nm_grid[ix][iy][Nn] = subcatalog[0].average[i].Nmeasure; + + // if we are resetting to a given photcode, we need to have that photcode... + // XXX this is not relevant for the check... + if (FALSE && NphotcodesReset) { + int k; + int foundReset = FALSE; + int m = subcatalog[0].average[i].measureOffset; + MeasureTiny *measure = &subcatalog[0].measureT[m]; + for (j = 0; (j < subcatalog[0].average[i].Nmeasure) && !foundReset; j++) { + if (CHECK_TEST_IMAGE && (abs(measure[j].t - Tref) < 10) && (measure[j].photcode == Cref)) { + fprintf (stderr, "."); + } + for (k = 0; (k < NphotcodesReset) && !foundReset; k++) { + if (photcodesReset[k][0].code == measure[j].photcode) foundReset = TRUE; + } + } + if (!foundReset) { + Nm_grid[ix][iy][Nn] = 0; + } + } + + idxgrid[ix][iy][Nn] = i; + Nn_grid[ix][iy] ++; + if (Nn_grid[ix][iy] >= NN_grid[ix][iy]) { + NN_grid[ix][iy] += 100; + REALLOCATE (Nm_grid[ix][iy], int, NN_grid[ix][iy]); + REALLOCATE (idxgrid[ix][iy], off_t, NN_grid[ix][iy]); + } + } + + // sort all of the grid cells + for (ix = 0; ix < NX; ix++) { + for (iy = 0; iy < NY; iy++) { + sort_by_Nmeasure (Nm_grid[ix][iy], idxgrid[ix][iy], Nn_grid[ix][iy]); + NN_grid[ix][iy] = 0; // I'm going to use this array to track which element I've already selected + } + } + + // cycle over the grid until we ready Nmax + off_t *keepidx = NULL; + ALLOCATE (keepidx, off_t, Naverage); + memset (keepidx, 0, Naverage*sizeof(off_t)); + int Nkeep = 0; + + for (i = 0; (i < 20) && (Nkeep < Nmax); i++) { + for (ix = 0; (ix < NX) && (Nkeep < Nmax); ix++) { + for (iy = 0; (iy < NY) && (Nkeep < Nmax); iy++) { + if (NN_grid[ix][iy] >= Nn_grid[ix][iy]) continue; // all used up! + int Nn = NN_grid[ix][iy]; + keepidx[Nkeep] = idxgrid[ix][iy][Nn]; + Nkeep ++; + NN_grid[ix][iy] ++; + } + } + } + + // count the number of measurements this selection will yield + off_t ave, NMEASURE = 0; + for (i = 0; i < Nkeep; i++) { + ave = keepidx[i]; + NMEASURE += subcatalog[0].average[ave].Nmeasure; + } + + // test catID : 37262 37261 37257 37258 + int dumpit = FALSE; + dumpit |= (oldcatalog[0].catID == 37007); + // dumpit |= (oldcatalog[0].catID == 37261); + // dumpit |= (oldcatalog[0].catID == 37257); + // dumpit |= (oldcatalog[0].catID == 37258); + if (dumpit) { + char name[64]; + snprintf (name, 64, "cat.%05d.dump.dat", oldcatalog[0].catID); + FILE *fdump = fopen (name, "w"); + for (i = 0; i < Nkeep; i++) { + ave = keepidx[i]; + fprintf (fdump, "%10.6f %10.6f %d\n", subcatalog[0].average[ave].R, subcatalog[0].average[ave].D, subcatalog[0].average[ave].Nmeasure); + } + fclose (fdump); + } + + // allocate the output data + ALLOCATE (tmpcatalog.average, Average, Nkeep); + ALLOCATE (tmpcatalog.measureT, MeasureTiny, NMEASURE); + ALLOCATE (tmpcatalog.secfilt, SecFilt, Nkeep * Nsecfilt); + + off_t Nmeasure = 0; + + // copy the Nkeep selected entries from subcatalog to tmpcatalog (adjusting links) + for (i = 0; i < Nkeep; i++) { + ave = keepidx[i]; + tmpcatalog.average[i] = subcatalog[0].average[ave]; + tmpcatalog.average[i].measureOffset = Nmeasure; + for (j = 0; j < tmpcatalog.average[i].Nmeasure; j++) { + off_t offset = subcatalog[0].average[ave].measureOffset + j; + tmpcatalog.measureT[Nmeasure] = subcatalog[0].measureT[offset]; + tmpcatalog.measureT[Nmeasure].averef = i; + Nmeasure ++; + } + for (j = 0; j < Nsecfilt; j++) { + tmpcatalog.secfilt[i*Nsecfilt + j] = subcatalog[0].secfilt[ave*Nsecfilt + j]; + } + } + + if (VERBOSE2) { + char *basename = filebasename (oldcatalog[0].filename); + fprintf (stderr, "limited to %d ("OFF_T_FMT" subset, "OFF_T_FMT" total) stars, "OFF_T_FMT" ("OFF_T_FMT" subset, "OFF_T_FMT" total) measures for catalog %s\n", + Nkeep, subcatalog[0].Naverage, oldcatalog[0].Naverage, Nmeasure, subcatalog[0].Nmeasure, oldcatalog[0].Nmeasure, basename); + free (basename); + } + + free (X); + free (Y); + + for (ix = 0; ix < NX; ix++) { + for (iy = 0; iy < NY; iy++) { + free (Nm_grid[ix][iy]); + free (idxgrid[ix][iy]); + } + free (NN_grid[ix]); + free (Nn_grid[ix]); + free (Nm_grid[ix]); + free (idxgrid[ix]); + } + free (NN_grid); + free (Nn_grid); + free (Nm_grid); + free (idxgrid); + + free (keepidx); + + free (subcatalog[0].average); + free (subcatalog[0].measureT); + free (subcatalog[0].secfilt); + + subcatalog[0].average = tmpcatalog.average; + subcatalog[0].measureT = tmpcatalog.measureT; + subcatalog[0].secfilt = tmpcatalog.secfilt; + subcatalog[0].Naverage = Nkeep; + subcatalog[0].Nmeasure = Nmeasure; + subcatalog[0].Nsecfilt = oldcatalog[0].Nsecfilt; + subcatalog[0].Nsecf_mem = Naverage * oldcatalog[0].Nsecfilt; + + return (TRUE); +} + +/* this version does NOT use AverageTiny, MeasureTiny */ +int LimitDensityCatalog_ByNmeasure (Catalog *subcatalog, Catalog *oldcatalog) { + + Catalog tmpcatalog; + + double Rmin, Rmax, Dmin, Dmax; + + int Nsecfilt = GetPhotcodeNsecfilt (); + + gfits_scan (&oldcatalog[0].header, "RA0", "%lf", 1, &Rmin); + gfits_scan (&oldcatalog[0].header, "DEC0", "%lf", 1, &Dmin); + gfits_scan (&oldcatalog[0].header, "RA1", "%lf", 1, &Rmax); + gfits_scan (&oldcatalog[0].header, "DEC1", "%lf", 1, &Dmax); + + if (VERBOSE2) fprintf (stderr, "extracting from catalog covering region %f,%f to %f,%f\n", Rmin, Dmin, Rmax, Dmax); + + float AREA = fabs(Dmax - Dmin) * fabs(Rmax - Rmin) * cos (0.5*RAD_DEG*(Dmax + Dmin)); + assert (AREA > 0); + + off_t Nmax = MaxDensityValue * AREA; + if (subcatalog[0].Naverage <= Nmax) { + if (VERBOSE) { + fprintf (stderr, "subcatalog has less than the max density\n"); + } + return (TRUE); + } + + off_t Naverage = subcatalog[0].Naverage; + + // select a random subset of Nmax stars from subcatalog using Fisher-Yates + + // we are going to select Nmax entries by choosing the brightest objects + int *value; + off_t *index, i, j, ave; + ALLOCATE (index, off_t, Naverage); + ALLOCATE (value, int, Naverage); + for (i = 0; i < Naverage; i++) { + index[i] = i; + value[i] = subcatalog[0].average[i].Nmeasure; + } + sort_by_Nmeasure (value, index, Naverage); + + // count the number of measurements this selection will yield + off_t NMEASURE = 0; + for (i = 0; i < Nmax; i++) { + ave = index[i]; + NMEASURE += subcatalog[0].average[ave].Nmeasure; + } + +# if (0) + if (oldcatalog[0].catID == 59962) { + FILE *fdump = fopen ("cat.dump.dat", "w"); + for (i = 0; i < Nmax; i++) { + ave = index[i]; + fprintf (fdump, "%10.6f %10.6f %d\n", subcatalog[0].average[ave].R, subcatalog[0].average[ave].D, subcatalog[0].average[ave].Nmeasure); + } + fclose (fdump); + } +# endif + + // allocate the output data + ALLOCATE (tmpcatalog.average, Average, Nmax); + ALLOCATE (tmpcatalog.measureT, MeasureTiny, NMEASURE); + ALLOCATE (tmpcatalog.secfilt, SecFilt, Nmax * Nsecfilt); + + off_t Nmeasure = 0; + + // copy the Nmax selected entries from subcatalog to tmpcatalog (adjusting links) + for (i = 0; i < Nmax; i++) { + ave = index[i]; + tmpcatalog.average[i] = subcatalog[0].average[ave]; + tmpcatalog.average[i].measureOffset = Nmeasure; + for (j = 0; j < tmpcatalog.average[i].Nmeasure; j++) { + off_t offset = subcatalog[0].average[ave].measureOffset + j; + tmpcatalog.measureT[Nmeasure] = subcatalog[0].measureT[offset]; + tmpcatalog.measureT[Nmeasure].averef = i; + Nmeasure ++; + } + for (j = 0; j < Nsecfilt; j++) { + tmpcatalog.secfilt[i*Nsecfilt + j] = subcatalog[0].secfilt[ave*Nsecfilt + j]; + } + } + + if (VERBOSE2) { + char *basename = filebasename (oldcatalog[0].filename); + fprintf (stderr, "limited to "OFF_T_FMT" ("OFF_T_FMT" subset, "OFF_T_FMT" total) stars, "OFF_T_FMT" ("OFF_T_FMT" subset, "OFF_T_FMT" total) measures for catalog %s\n", + Nmax, subcatalog[0].Naverage, oldcatalog[0].Naverage, Nmeasure, subcatalog[0].Nmeasure, oldcatalog[0].Nmeasure, basename); + free (basename); + } + + free (index); + free (value); + free (subcatalog[0].average); + free (subcatalog[0].measureT); + free (subcatalog[0].secfilt); + + subcatalog[0].average = tmpcatalog.average; + subcatalog[0].measureT = tmpcatalog.measureT; + subcatalog[0].secfilt = tmpcatalog.secfilt; + subcatalog[0].Naverage = Nmax; + subcatalog[0].Nmeasure = Nmeasure; + subcatalog[0].Nsecfilt = oldcatalog[0].Nsecfilt; + subcatalog[0].Nsecf_mem = Naverage * oldcatalog[0].Nsecfilt; + + return (TRUE); +} + +/* this version does NOT use AverageTiny, MeasureTiny */ +int LimitDensityCatalog_RandomSample (Catalog *subcatalog, Catalog *catalog) { + + Catalog tmpcatalog; + + double Rmin, Rmax, Dmin, Dmax; + + int Nsecfilt = GetPhotcodeNsecfilt (); + + gfits_scan (&catalog[0].header, "RA0", "%lf", 1, &Rmin); + gfits_scan (&catalog[0].header, "DEC0", "%lf", 1, &Dmin); + gfits_scan (&catalog[0].header, "RA1", "%lf", 1, &Rmax); + gfits_scan (&catalog[0].header, "DEC1", "%lf", 1, &Dmax); + + if (VERBOSE2) fprintf (stderr, "extracting from catalog covering region %f,%f to %f,%f\n", Rmin, Dmin, Rmax, Dmax); + + float AREA = fabs(Dmax - Dmin) * fabs(Rmax - Rmin) * cos (0.5*RAD_DEG*(Dmax + Dmin)); + assert (AREA > 0); + + off_t Nmax = MaxDensityValue * AREA; + if (subcatalog[0].Naverage <= Nmax) { + if (VERBOSE2) { + fprintf (stderr, "subcatalog has less than the max density\n"); + } + return (TRUE); + } + + off_t Naverage = subcatalog[0].Naverage; + + // select a random subset of Nmax stars from subcatalog using Fisher-Yates + + // we are going to select Nmax entries by generating a random-sorted index list + off_t *index, tmp, i, j, ave; + ALLOCATE (index, off_t, Naverage); + for (i = 0; i < Naverage; i++) { + index[i] = i; + } + for (i = 0; i < Naverage; i++) { + j = (Naverage - i) * drand48() + i; // a number between i and Naverage + tmp = index[j]; + index[j] = index[i]; + index[i] = tmp; + } + + // count the number of measurements this selection will yield + off_t NMEASURE = 0; + for (i = 0; i < Nmax; i++) { + ave = index[i]; + NMEASURE += subcatalog[0].average[ave].Nmeasure; + } + + // allocate the output data + ALLOCATE (tmpcatalog.average, Average, Nmax); + ALLOCATE (tmpcatalog.measureT, MeasureTiny, NMEASURE); + ALLOCATE (tmpcatalog.secfilt, SecFilt, Nmax * Nsecfilt); + + off_t Nmeasure = 0; + + // copy the Nmax selected entries from subcatalog to tmpcatalog (adjusting links) + for (i = 0; i < Nmax; i++) { + ave = index[i]; + tmpcatalog.average[i] = subcatalog[0].average[ave]; + tmpcatalog.average[i].measureOffset = Nmeasure; + for (j = 0; j < tmpcatalog.average[i].Nmeasure; j++) { + off_t offset = subcatalog[0].average[ave].measureOffset + j; + tmpcatalog.measureT[Nmeasure] = subcatalog[0].measureT[offset]; + tmpcatalog.measureT[Nmeasure].averef = i; + Nmeasure ++; + } + for (j = 0; j < Nsecfilt; j++) { + tmpcatalog.secfilt[i*Nsecfilt + j] = subcatalog[0].secfilt[ave*Nsecfilt + j]; + } + } + + if (VERBOSE2) { + fprintf (stderr, "limited to "OFF_T_FMT" of "OFF_T_FMT" stars ("OFF_T_FMT" of "OFF_T_FMT" measures) for catalog %s\n", + Nmax, subcatalog[0].Naverage, Nmeasure, subcatalog[0].Nmeasure, catalog[0].filename); + } + + free (subcatalog[0].average); + free (subcatalog[0].measureT); + free (subcatalog[0].secfilt); + + subcatalog[0].average = tmpcatalog.average; + subcatalog[0].measureT = tmpcatalog.measureT; + subcatalog[0].secfilt = tmpcatalog.secfilt; + subcatalog[0].Naverage = Nmax; + subcatalog[0].Nmeasure = Nmeasure; + subcatalog[0].Nsecfilt = catalog[0].Nsecfilt; + subcatalog[0].Nsecf_mem = Naverage * catalog[0].Nsecfilt; + + return (TRUE); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/checkastro.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/checkastro.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/checkastro.c (revision 37067) @@ -0,0 +1,14 @@ +# include "checkastro.h" + +int main (int argc, char **argv) { + + /* get configuration info, args */ + initialize (argc, argv); + + SkyTable *sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, TRUE, SKY_DEPTH, VERBOSE); + SkyTableSetFilenames (sky, CATDIR, "cpt"); + SkyList *skylist = SkyListByPatch (sky, -1, &UserPatch); + + checkastro_images (skylist); + exit (0); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/checkastro_client.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/checkastro_client.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/checkastro_client.c (revision 37067) @@ -0,0 +1,36 @@ +# include "checkastro.h" + +// checkastro_client is run on a remote host and is responsible for updating the catalogs +// owned by that host. + +// there are four modes: + +// checkastro_client -load-objects : extract the bright catalog subset from the client's +// tables and save to a local FITS table for checkastro to +// load and used + +int main (int argc, char **argv) { + + // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, etc) + initialize_client (argc, argv); + + SkyTable *sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, TRUE, SKY_DEPTH, VERBOSE); + SkyTableSetFilenames (sky, CATDIR, "cpt"); + SkyList *skylist = SkyListByPatch (sky, -1, &UserPatch); + + // USAGE: checkastro_client -load-objects + int Ncatalog; + Catalog *catalog = load_catalogs (skylist, &Ncatalog, TRUE, HOST_ID, HOSTDIR); + if (!catalog) { + fprintf (stderr, "ERROR loading catalogs from %s\n", CATDIR); + exit (2); + } + + BrightCatalog *bcatalog = BrightCatalogMerge (catalog, Ncatalog); + if (!BrightCatalogSave (BCATALOG, bcatalog)) { + fprintf (stderr, "ERROR saving bright catalog from %s\n", CATDIR); + exit (2); + } + + exit (0); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/checkastro_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/checkastro_images.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/checkastro_images.c (revision 37067) @@ -0,0 +1,48 @@ +# include "checkastro.h" + +int checkastro_images (SkyList *skylist) { + + int status, Ncatalog; + Catalog *catalog; + FITS_DB db; + + INITTIME; + + /* register database handle with shutdown procedure */ + set_db (&db); + + /* lock and load the image db table */ + status = dvo_image_lock (&db, ImageCat, 60.0, LCK_SOFT); + if (!status) Shutdown ("ERROR: failure to lock image catalog %s", db.filename); + if (db.dbstate == LCK_EMPTY) Shutdown ("ERROR: No images in catalog %s (1)", db.filename); + if (!dvo_image_load (&db, VERBOSE, FALSE)) Shutdown ("can't read image catalog %s", db.filename); + MARKTIME("load image data: %f sec\n", dtime); + + /* load regions and images based on specified sky patch (default depth) (require full overlap) */ + load_images (&db, skylist); + MARKTIME("load images: %f sec\n", dtime); + + // photcodesKeep is used here to allow measurements from the images being calibrated + // note if -reset-to-photcode is selected, photocodesKeep is replaced with below with photcodesReset + catalog = load_catalogs (skylist, &Ncatalog, TRUE, 0, NULL); + MARKTIME("load catalog data: %f sec\n", dtime); + + if (photcodesReset) { + photcodesKeep = photcodesReset; + NphotcodesKeep = NphotcodesReset; + } + + if (Ncatalog == 0) { + fprintf (stderr, "ERROR: no valid data for checkastro, exiting\n"); + exit (2); + } + + /* match measurements with images */ + initImageBins (catalog, Ncatalog); + MARKTIME("make image bins: %f sec\n", dtime); + + findImages (catalog, Ncatalog); + MARKTIME("set up image indexes: %f sec\n", dtime); + + exit (0); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/initialize.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/initialize.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/initialize.c (revision 37067) @@ -0,0 +1,29 @@ +# include "checkastro.h" + +void initialize (int argc, char **argv) { + + ConfigInit (&argc, argv); + args (argc, argv); + + if (PHOTCODE_KEEP_LIST) fprintf (stderr, "PHOTCODE_KEEP_LIST: %s\n", PHOTCODE_KEEP_LIST); + if (PHOTCODE_SKIP_LIST) fprintf (stderr, "PHOTCODE_SKIP_LIST: %s\n", PHOTCODE_SKIP_LIST); + if (PHOTCODE_RESET_LIST) fprintf (stderr, "PHOTCODE_RESET_LIST: %s\n", PHOTCODE_RESET_LIST); + + photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE); + photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE); + photcodesReset = ParsePhotcodeList (PHOTCODE_RESET_LIST, &NphotcodesReset, FALSE); +} + +void initialize_client (int argc, char **argv) { + + ConfigInit (&argc, argv); + args_client (argc, argv); + + if (PHOTCODE_KEEP_LIST) fprintf (stderr, "PHOTCODE_KEEP_LIST: %s\n", PHOTCODE_KEEP_LIST); + if (PHOTCODE_SKIP_LIST) fprintf (stderr, "PHOTCODE_SKIP_LIST: %s\n", PHOTCODE_SKIP_LIST); + if (PHOTCODE_RESET_LIST) fprintf (stderr, "PHOTCODE_RESET_LIST: %s\n", PHOTCODE_RESET_LIST); + + photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE); + photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE); + photcodesReset = ParsePhotcodeList (PHOTCODE_RESET_LIST, &NphotcodesReset, FALSE); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/load_catalogs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/load_catalogs.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/load_catalogs.c (revision 37067) @@ -0,0 +1,215 @@ +# include "checkastro.h" + +Catalog *load_catalogs (SkyList *skylist, int *Ncatalog, int subselect, int hostID, char *hostpath) { + + int i, Nstar; + Catalog *catalog, *pcatalog, tcatalog; + + // XXX need to decide how to determine PARALLEL mode... + if (PARALLEL && !hostID) { + catalog = load_catalogs_parallel (skylist, Ncatalog); + return catalog; + } + + if (VERBOSE) fprintf (stderr, "loading catalog data\n"); + + ALLOCATE (catalog, Catalog, skylist[0].Nregions); + + // load data from each region file, only use bright stars + int Ncat = 0; + for (i = 0; i < skylist[0].Nregions; i++) { + + // does this host ID match the desired location for the table? + if (!HostTableTestHost(skylist[0].regions[i], hostID)) continue; + + // we only allow output if we do not use a subset. in this case, + // the output parameters are correctly set for catalog[i] via pcatalog + pcatalog = subselect ? &tcatalog : &catalog[i]; + + // define the catalog file name + char hostfile[1024]; + snprintf (hostfile, 1024, "%s/%s.cpt", hostpath, skylist[0].regions[i]->name); + pcatalog->filename = hostID ? hostfile : skylist[0].filename[i]; + + // set up the basic catalog info + pcatalog->catformat = dvo_catalog_catformat (CATFORMAT); // set the default catformat from config data + pcatalog->catmode = dvo_catalog_catmode (CATMODE); // set the default catmode from config data + pcatalog->catflags = LOAD_AVES | LOAD_MEAS | LOAD_SECF; // don't need to load all data at this point + pcatalog->Nsecfilt = GetPhotcodeNsecfilt (); + + // loads Average, Measure, SecFilt + if (!dvo_catalog_open (pcatalog, skylist[0].regions[i], VERBOSE2, "w")) { + fprintf (stderr, "ERROR: failure reading catalog %s\n", pcatalog[0].filename); + exit (1); + } + if (!pcatalog[0].Naves_disk) { + if (VERBOSE2) fprintf (stderr, "no data in %s, skipping\n", pcatalog[0].filename); + dvo_catalog_unlock (pcatalog); + dvo_catalog_free (pcatalog); + continue; + } + + if (!pcatalog->sorted) { + fprintf (stderr, "this database is not sorted. please sort using addstar -resort\n"); + exit (1); + } + + // select only the brighter stars + if (subselect) { + // results are in Average, Secfilt, and MeasureTiny + // Ncat tracks the actually used catalogs + bcatalog (&catalog[Ncat], &tcatalog); + dvo_catalog_unlock (&tcatalog); + dvo_catalog_free (&tcatalog); + } + Ncat ++; + } + + // XXX TEST : bcatalog_show_skips(); + + Nstar = 0; + for (i = 0; i < Ncat; i++) { + Nstar += catalog[i].Naverage; + if ((sizeof(IDX_T) == 8) && (catalog[i].Nmeasure > 0xffffffff)) { + fprintf (stderr, "ERROR: using small-sized IDX_T on data with more than 2G detections per table will cause errors\n"); + fprintf (stderr, " If you need to do this, and you can afford the RAM, rebuild with IDX_T set to off_t (see checkastro.h, ImagesOps.c)\n"); + exit (3); + } + } + if (Nstar < 2) { + fprintf (stderr, "warning: insufficient stars %d\n", Nstar); + } + + // only return the populated catalogs + REALLOCATE (catalog, Catalog, Ncat); + *Ncatalog = Ncat; + return (catalog); +} + +/* this function loads all relevant catalog files for the first pass. it currently loads the data + read only (SOFT lock) since it assumes the image table has been locked. if we go to the new + addstar locking paradigm, in which the images and catalogs are updated independently, then we may + need to use an XCLD lock here. +*/ + +// CATDIR is supplied globally +# define DEBUG 1 +Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog) { + + char uniquer[12]; + int TIME = time(NULL); + int PID = getpid(); + snprintf (uniquer, 12, "%05d.%05d", PID, TIME % 100000); + + // load the list of hosts + HostTable *table = HostTableLoad (CATDIR, sky->hosts); + if (!table) { + fprintf (stderr, "ERROR: failure reading Host Table %s for database %s\n", sky->hosts, CATDIR); + exit (1); + } + + int i; + for (i = 0; i < table->Nhosts; i++) { + + // ensure that the paths are absolute path names + char *tmppath = abspath (table->hosts[i].pathname, DVO_MAX_PATH); + free (table->hosts[i].pathname); + table->hosts[i].pathname = tmppath; + + ALLOCATE (table->hosts[i].results, char, 1024); + snprintf (table->hosts[i].results, 1024, "%s/checkastro.catalog.%s.dat", table->hosts[i].pathname, uniquer); + + char command[1024]; + snprintf (command, 1024, "checkastro_client -load-objects %s -hostID %d -D CATDIR %s -hostdir %s -region %f %f %f %f -D RELASTRO_SIGMA_LIM %f", + table->hosts[i].results, table->hosts[i].hostID, CATDIR, table->hosts[i].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, SIGMA_LIM); + + char tmpline[1024]; + + if (VERBOSE) { snprintf (tmpline, 1024, "%s -v", command); strcpy (command, tmpline); } + if (VERBOSE2) { snprintf (tmpline, 1024, "%s -vv", command); strcpy (command, tmpline); } + if (MaxDensityUse) { snprintf (tmpline, 1024, "%s -max-density %f", command, MaxDensityValue); strcpy (command, tmpline); } + if (ImagSelect) { snprintf (tmpline, 1024, "%s -instmag %f %f", command, ImagMin, ImagMax); strcpy (command, tmpline); } + + if (PHOTCODE_KEEP_LIST) { snprintf (tmpline, 1024, "%s +photcode %s", command, PHOTCODE_KEEP_LIST); strcpy (command, tmpline); } + if (PHOTCODE_SKIP_LIST) { snprintf (tmpline, 1024, "%s -photcode %s", command, PHOTCODE_SKIP_LIST); strcpy (command, tmpline); } + if (PHOTCODE_RESET_LIST) { snprintf (tmpline, 1024, "%s -reset-to-photcode %s", command, PHOTCODE_RESET_LIST); strcpy (command, tmpline); } + if (PhotFlagSelect) { snprintf (tmpline, 1024, "%s +photflags", command); strcpy (command, tmpline); } + if (PhotFlagBad) { snprintf (tmpline, 1024, "%s +photflagbad %d", command, PhotFlagBad); strcpy (command, tmpline); } + if (PhotFlagPoor) { snprintf (tmpline, 1024, "%s +photflagpoor %d", command, PhotFlagPoor); strcpy (command, tmpline); } + // XXX note that the above pass in the flag as decimal -- also note that args.c cannot handle 0xHEX values + + if (TimeSelect) { + char *tstart = ohana_sec_to_date (TSTART); + char *tstop = ohana_sec_to_date (TSTOP); + snprintf (tmpline, 1024, "%s -time %s %s", command, tstart, tstop); + free (tstart); + free (tstop); + strcpy (command, tmpline); + } + + fprintf (stderr, "command: %s\n", command); + + if (PARALLEL_MANUAL) continue; + + if (PARALLEL_SERIAL) { + int status = system (command); + if (status) { + fprintf (stderr, "ERROR running checkastro_client\n"); + exit (2); + } + } else { + // launch the job on the remote machine (no handshake) + int errorInfo = 0; + int pid = rconnect ("ssh", table->hosts[i].hostname, command, table->hosts[i].stdio, &errorInfo, FALSE); + if (!pid) { + if (DEBUG) fprintf (stderr, "failure to start %s (error %d)\n", table->hosts[i].hostname, errorInfo); + exit (1); + } + table->hosts[i].pid = pid; // save for future reference + } + } + + if (PARALLEL_MANUAL) { + fprintf (stderr, "run the checkastro_client commands above. when these are done, hit return\n"); + getchar(); + } + if (!PARALLEL_MANUAL && !PARALLEL_SERIAL) { + HostTableWaitJobsGetIO (table, __FILE__, __LINE__, VERBOSE); + } + + // each host generates a BrightCatalog structure, with the measure, average, etc value + // loaded into a single set of arrays (of MeasureTiny, AverageTiny, Secfilt). I need to + // split out the per-catalog measurements into separate catalog entries. + + // set up an initial array of catalogs + int Nsecfilt = GetPhotcodeNsecfilt (); + CatalogSplitter *catalogs = BrightCatalogSplitInit (Nsecfilt); + + for (i = 0; i < table->Nhosts; i++) { + + BrightCatalog *bcatalog = BrightCatalogLoad (table->hosts[i].results); + assert (bcatalog); + + BrightCatalogSplit (catalogs, bcatalog); + + free (bcatalog->average); + free (bcatalog->measure); + free (bcatalog->secfilt); + free (bcatalog); + } + + Catalog *catalog = catalogs->catalog; + *Ncatalog = catalogs->Ncatalog; + BrightCatalogSplitFree (catalogs); + + int Nmeasure = 0; + int Naverage = 0; + for (i = 0; i < catalogs->Ncatalog; i++) { + Nmeasure += catalogs->catalog[i].Nmeasure; + Naverage += catalogs->catalog[i].Naverage; + } + + fprintf (stderr, "loaded %d catalogs, using a total of %d stars (%d measures)\n", catalogs->Ncatalog, Naverage, Nmeasure); + + return (catalog); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/load_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/load_images.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/load_images.c (revision 37067) @@ -0,0 +1,34 @@ +# include "checkastro.h" + +int load_images (FITS_DB *db, SkyList *skylist) { + + Image *image, *subset; + off_t Nimage, Nsubset; + off_t *LineNumber; + + INITTIME; + + // convert database table to internal structure + image = gfits_table_get_Image (&db[0].ftable, &Nimage, &db[0].swapped); + if (!image) { + fprintf (stderr, "ERROR: failed to read images\n"); + exit (2); + } + MARKTIME(" convert image table: %f sec\n", dtime); + + // select the images which overlap the selected sky regions + subset = select_images (skylist, image, Nimage, &LineNumber, &Nsubset); + MARKTIME(" select images: %f sec\n", dtime); + + fprintf (stderr, "%llx\n", (long long) subset); + + initImages (subset, LineNumber, Nsubset); + MARKTIME(" init images: %f sec\n", dtime); + + // unlock, if we can (else, unlocked below) + int unlockImages = TRUE; + if (unlockImages) dvo_image_unlock (db); + + return TRUE; +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/select_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/select_images.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/checkastro/src/select_images.c (revision 37067) @@ -0,0 +1,132 @@ +# include "checkastro.h" + +/* this function returns a list of all images which overlap the given SkyList (set of + SkyRegions). All images in the image catalog are tested once, so there is no check that an + image already has been included. LineNum stores the locations in the Image database of the + list of images */ + +Image *select_images (SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage) { + + Image *image; + off_t i, k, nimage, NIMAGE, D_NIMAGE; + off_t *line_number; + int found; + double Rexp, Dexp; + + double RmaxSkyRegion, RminSkyRegion, RmidSkyRegion, DminSkyRegion, DmaxSkyRegion; + + if (skylist[0].Nregions < 1) { + *Nimage = 0; + *LineNumber = NULL; + if (VERBOSE) fprintf (stderr, "no matching sky regions\n"); + return NULL; + } + + INITTIME; + + RminSkyRegion = +360.0; + RmaxSkyRegion = -360.0; + DminSkyRegion = +90.0; + DmaxSkyRegion = -90.0; + + D_NIMAGE = 6000; + + /* compare with each region file */ + for (i = 0; i < skylist[0].Nregions; i++) { + RminSkyRegion = MIN(RminSkyRegion, skylist[0].regions[i][0].Rmin); + RmaxSkyRegion = MAX(RmaxSkyRegion, skylist[0].regions[i][0].Rmax); + DminSkyRegion = MIN(DminSkyRegion, skylist[0].regions[i][0].Dmin); + DmaxSkyRegion = MAX(DmaxSkyRegion, skylist[0].regions[i][0].Dmax); + } + RmidSkyRegion = 0.5*(RminSkyRegion + RmaxSkyRegion); + MARKTIME("define sky region: %f sec\n", dtime); + + if (VERBOSE) fprintf (stderr, "finding images\n"); + BuildChipMatch (timage, Ntimage); + MARKTIME("build chip match: %f sec\n", dtime); + + nimage = 0; + NIMAGE = D_NIMAGE; + ALLOCATE (image, Image, NIMAGE); + ALLOCATE (line_number, off_t, NIMAGE); + + // we now have a region of interest: RminSkyRegion - RmaxSkyRegion, DminSkyRegion - DmaxSkyRegion, + // we now want to find all gpc1 chips (WRP) for which the exposure center (DIS) is in this region, + + // go through the complete list of images, selecting ones which overlap the region + for (i = 0; i < Ntimage; i++) { + + /* select images by photcode, or equiv photcode, if specified */ + if (NphotcodesKeep > 0) { + found = FALSE; + // we have to keep DIS mosaics explicitly (photcode = 0) + if (!strcmp(&timage[i].coords.ctype[4], "-DIS")) found = TRUE; + for (k = 0; (k < NphotcodesKeep) && !found; k++) { + if (photcodesKeep[k][0].code == timage[i].photcode) found = TRUE; + if (photcodesKeep[k][0].code == GetPhotcodeEquivCodebyCode(timage[i].photcode)) found = TRUE; + } + if (!found) continue; + } + if (NphotcodesSkip > 0) { + found = FALSE; + for (k = 0; (k < NphotcodesSkip) && !found; k++) { + if (photcodesSkip[k][0].code == timage[i].photcode) found = TRUE; + if (photcodesSkip[k][0].code == GetPhotcodeEquivCodebyCode(timage[i].photcode)) found = TRUE; + } + if (found) continue; + } + + /* exclude images by time */ + if (TimeSelect) { + if (timage[i].tzero < TSTART) continue; + if (timage[i].tzero > TSTOP) continue; + } + + // this adds 1.3 sec for 3M images + off_t myMosaic = FindMosaicForImage (timage, Ntimage, i); + if (!myMosaic) { + fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i); + continue; + } + myMosaic --; + + /* only check exposure center */ + if (!strcmp(&timage[i].coords.ctype[4], "-DIS")) { + XY_to_RD (&Rexp, &Dexp, 0.0, 0.0, &timage[i].coords); + } else { + XY_to_RD (&Rexp, &Dexp, 0.0, 0.0, &timage[myMosaic].coords); + } + Rexp = ohana_normalize_angle_to_midpoint (Rexp, RmidSkyRegion); + + // check that this image is even in range of the searched region + if (Dexp + 1.5 > UserPatch.Dmax) continue; + if (Dexp - 1.5 < UserPatch.Dmin) continue; + + // the sky region RA is defined to be 0 - 360.0 + if ((Dexp < 88) && (Dexp > -88)) { + if (Rexp + 1.5/cos(Dexp*RAD_DEG) > UserPatch.Rmax) continue; + if (Rexp - 1.5/cos(Dexp*RAD_DEG) < UserPatch.Rmin) continue; + } + + image[nimage] = timage[i]; + line_number[nimage] = i; + nimage ++; + if (nimage == NIMAGE) { + NIMAGE += D_NIMAGE; + D_NIMAGE = MAX (100000, D_NIMAGE * 1.5); + REALLOCATE (image, Image, NIMAGE); + REALLOCATE (line_number, off_t, NIMAGE); + } + } + MARKTIME("finish image selection: %f sec\n", dtime); + + if (VERBOSE) fprintf (stderr, "found "OFF_T_FMT" images\n", nimage); + + REALLOCATE (image, Image, MAX (nimage, 1)); + REALLOCATE (line_number, off_t, MAX (nimage, 1)); + + *Nimage = nimage; + *LineNumber = line_number; + return (image); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/include/delstar.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/include/delstar.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/include/delstar.h (revision 37067) @@ -67,4 +67,5 @@ int UPDATE; int IMAGE_DETAILS; +int IMAGE_DUPLICATES_BY_OBSTIME; int IMAGE_ONLY; int ORPHAN; @@ -138,5 +139,5 @@ void SortAveMeasMatch (off_t *MEAS, off_t *AVE, off_t N); -int delete_photcodes (); +int delete_photcodes (void); int delete_photcodes_parallel (SkyList *sky); int delete_photcodes_catalog (Catalog *catalog, PhotCode **photcodes, int Nphotcodes); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/ImageOpsFixLAP.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/ImageOpsFixLAP.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/ImageOpsFixLAP.c (revision 37067) @@ -1,4 +1,3 @@ # include "delstar.h" -# define FT_BZERO_INT32 1.0*0x80000000 off_t Nimage = 0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/ImageSubsetFixLAP.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/ImageSubsetFixLAP.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/ImageSubsetFixLAP.c (revision 37067) @@ -1,5 +1,3 @@ # include "delstar.h" -# define FT_BZERO_INT16 1.0*0x8000 -# define FT_BZERO_INT32 1.0*0x80000000 # define GET_COLUMN(OUT,NAME,TYPE) \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/MeasureEdgeOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/MeasureEdgeOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/MeasureEdgeOps.c (revision 37067) @@ -1,4 +1,3 @@ # include "delstar.h" -# define FT_BZERO_INT32 1.0*0x80000000 # define GET_COLUMN(OUT,NAME,TYPE) \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/args.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/args.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/args.c (revision 37067) @@ -18,4 +18,6 @@ fprintf (stderr, " -image-details : list info about the deleted images (-dup-images only)\n"); fprintf (stderr, " -image-only : only examine the image table (changes are NOT saved; -dup-images only)\n"); + fprintf (stderr, " -image-only-force : modify only the image table (-dup-images only)\n"); + fprintf (stderr, " -image-by-obstime : use date/time and photcode (not externID) to find duplicates\n"); fprintf (stderr, " -region Rmin Rmax Dmin Dmax : apply changes to this part of the sky\n"); @@ -68,4 +70,10 @@ if ((N = get_argument (argc, argv, "-image-details"))) { IMAGE_DETAILS = TRUE; + remove_argument (N, &argc, argv); + } + + IMAGE_DUPLICATES_BY_OBSTIME = FALSE; + if ((N = get_argument (argc, argv, "-image-by-obstime"))) { + IMAGE_DUPLICATES_BY_OBSTIME = TRUE; remove_argument (N, &argc, argv); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/delete_duplicate_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/delete_duplicate_images.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/delete_duplicate_images.c (revision 37067) @@ -1,3 +1,8 @@ # include "delstar.h" + +IndexArray *find_duplicates_obstime (Image *image, off_t Nimage, off_t *Nduplicates); +off_t find_obstime_range (Image *image, off_t Nimage, off_t firstEntry); +void sort_by_obstime (e_time *T, short *P, off_t *I, off_t N); +void sort_by_photcode (short *P, off_t *I, off_t N); // this function identifies the images to be deleted based on duplication of the @@ -18,5 +23,11 @@ off_t Nduplicates = 0; - IndexArray *imageID = find_duplicates (image, Nimage, &Nduplicates); + IndexArray *imageID = NULL; + + if (IMAGE_DUPLICATES_BY_OBSTIME) { + imageID = find_duplicates_obstime (image, Nimage, &Nduplicates); + } else { + imageID = find_duplicates (image, Nimage, &Nduplicates); + } if (Nduplicates == 0) { @@ -494,4 +505,209 @@ } +// sort by increasing obstime +void sort_by_obstime (e_time *T, short *P, off_t *I, off_t N) { + +# define SWAPFUNC(A,B){ e_time tmpT; short tmpP; off_t tmpI; \ + tmpT = T[A]; T[A] = T[B]; T[B] = tmpT; \ + tmpP = P[A]; P[A] = P[B]; P[B] = tmpP; \ + tmpI = I[A]; I[A] = I[B]; I[B] = tmpI; \ +} +# define COMPARE(A,B)(T[A] < T[B]) + + OHANA_SORT (N, COMPARE, SWAPFUNC); + +# undef SWAPFUNC +# undef COMPARE + +} + +// sort by increasing photcode +void sort_by_photcode (short *P, off_t *I, off_t N) { + +# define SWAPFUNC(A,B){ short tmpP; off_t tmpI; \ + tmpP = P[A]; P[A] = P[B]; P[B] = tmpP; \ + tmpI = I[A]; I[A] = I[B]; I[B] = tmpI; \ +} +# define COMPARE(A,B)(P[A] < P[B]) + + OHANA_SORT (N, COMPARE, SWAPFUNC); + +# undef SWAPFUNC +# undef COMPARE + +} + +static e_time *obstime = NULL; +static short *photcode = NULL; +static off_t *primary = NULL; +static off_t *idx = NULL; +static char *keep = NULL; + +static short *photcode_subset = NULL; +static off_t *idx_subset = NULL; + +static off_t Nsubset = 0; +static off_t NSUBSET = 300; + +off_t find_obstime_range (Image *image, off_t Nimage, off_t firstEntry) { + + Nsubset = 0; + + // find all entries with the same obstime: + e_time firstTime = obstime[firstEntry]; + + idx_subset[Nsubset] = idx[firstEntry]; + photcode_subset[Nsubset] = photcode[firstEntry]; + Nsubset++; + + off_t i = firstEntry + Nsubset; + while ((i < Nimage) && (obstime[i] == firstTime)) { + idx_subset[Nsubset] = idx[i]; + photcode_subset[Nsubset] = photcode[i]; + Nsubset++; + i++; + if (Nsubset >= NSUBSET) { + NSUBSET += 1000; + REALLOCATE (photcode_subset, short, NSUBSET); + REALLOCATE (idx_subset, off_t, NSUBSET); + } + } + + sort_by_photcode (photcode_subset, idx_subset, Nsubset); + + return i; +} + +// alternative version to find duplicates based on obstime and photcode +IndexArray *find_duplicates_obstime (Image *image, off_t Nimage, off_t *Nduplicates) { + + if (Nimage < 1) return NULL; + + // how to find duplicates: + // generate a set of arrays (idx, obstime, photcode, keep) + // sort the arrays by obstime + // loop over obstime. + // for a given new obstime, scan through the entries with the same value + // create a sub-array of photcodes, idx + // sort by photcode + // loop over entries + // find matching photcodes + // mark duplicate enties + + ALLOCATE (obstime, e_time, Nimage); + ALLOCATE (photcode, short, Nimage); + ALLOCATE (primary, off_t, Nimage); + ALLOCATE (idx, off_t, Nimage); + ALLOCATE (keep, char, Nimage); + + off_t i; + + INITTIME; + + // skip entries with photcode == 0? + for (i = 0; i < Nimage; i++) { + idx[i] = i; + primary[i] = -1; // only duplicates get a value for primary + keep[i] = TRUE; + obstime[i] = image[i].tzero; + photcode[i] = image[i].photcode; + } + MARKTIME(" generate index arrays: %f sec\n", dtime); + + // sort the 4 arrays + sort_by_obstime (obstime, photcode, idx, Nimage); + MARKTIME(" sort index arrays: %f sec\n", dtime); + + // image[idx[i]].tzero = obstime[i] + // keep[i] -> keep image[i] ('keep' is NOT resorted) + + // allocate arrays to store the subsets (these are global static) + // These get reallocated if necessary in find_obstime_range() + ALLOCATE (photcode_subset, short, NSUBSET); + ALLOCATE (idx_subset, off_t, NSUBSET); + + // entries of idx_subset correspond to the original image sequence: + // image[idx_subset[i]].tzero = obstime[i] + + off_t firstEntry = 0; + off_t nextEntry = 0; + + while (nextEntry < Nimage) { + if (firstEntry >= Nimage) { + fprintf (stderr, "error, too far?\n"); + } + + // generate photcode_subset, idx_subset in order of photcode for this unique obstime[firstEntry] + // returned value is the first value of the next entry + nextEntry = find_obstime_range (image, Nimage, firstEntry); + + // step through the photcodes and find duplicates + int j; + int firstCodeEntry = 0; + short firstCode = photcode_subset[firstCodeEntry]; + for (j = 1; j < Nsubset; j++) { + if (photcode_subset[j] == firstCode) { + // mark as duplicate + off_t dupIndex = idx_subset[j]; + keep[dupIndex] = FALSE; + primary[dupIndex] = idx_subset[firstCodeEntry]; + } else { + // new value of photcode, call if the first one + firstCodeEntry = j; + firstCode = photcode_subset[firstCodeEntry]; + } + } + firstEntry = nextEntry; + } + MARKTIME(" find duplicates: %f sec\n", dtime); + + IndexArray *imageID = make_index_array (image, Nimage, IMAGE_ID); + MARKTIME(" make index array: %f sec\n", dtime); + + // set imageID->value to TRUE for images we want to delete + off_t Ndup = 0; + for (i = 0; i < Nimage; i++) { + if (keep[i]) continue; + off_t Ni = image[i].imageID - imageID->minID; + myAssert (Ni >= 0, "oops"); + myAssert (Ni < imageID->range, "oops"); + imageID->value[Ni] = TRUE; + Ndup ++; + } + MARKTIME(" mark duplicates: %f sec\n", dtime); + + for (i = 0; IMAGE_DETAILS && (i < Nimage); i++) { + off_t Ni = image[i].imageID - imageID->minID; + if (!imageID->value[Ni]) continue; + + char *date = NULL; + date = ohana_sec_to_date (image[i].tzero); + fprintf (stderr, "delete image : (" OFF_T_FMT "), extID = %d : %30s : %20s %5d == ", i, image[i].externID, image[i].name, date, image[i].photcode); + free (date); + + off_t myPrimary = primary[i]; + if (myPrimary < 0) { + fprintf (stderr, "ERROR: this should never happen\n"); + abort(); + } + date = ohana_sec_to_date (image[myPrimary].tzero); + fprintf (stderr, "parent image : (" OFF_T_FMT "), extID = %d : %30s : %20s %5d\n", myPrimary, image[myPrimary].externID, image[myPrimary].name, date, image[myPrimary].photcode); + free (date); + } + + *Nduplicates = Ndup; + + free (photcode_subset); + free (idx_subset); + + free (obstime); + free (photcode); + free (primary); + free (idx); + free (keep); + + return imageID;; +} + // find the min & max values of the given ID (externID or imageID) // construct an empty array with length needed to fit IDs Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/delete_fix_LAP_edges.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/delete_fix_LAP_edges.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/delete_fix_LAP_edges.c (revision 37067) @@ -206,4 +206,6 @@ double Dgapmin = Dmin + dD; double Dgapmax = Dmax - dD; + + float cosDec = cos(RAD_DEG * 0.5 * (Dmin + Dmax)); // XXX should deal with pole, but not yet... @@ -218,7 +220,9 @@ float maxOff = 0.0; m = catalog[0].average[i].measureOffset; + for (j = 0; j < catalog[0].average[i].Nmeasure; j++) { - float dRoff = catalog[0].measure[m+j].dR * cos(RAD_DEG * 0.5 * (Dmin + Dmax)); - float dDoff = catalog[0].measure[m+j].dD; + + float dRoff = dvoOffsetR(&catalog[0].measure[m+j], &catalog[0].average[i])*cosDec; + float dDoff = dvoOffsetD(&catalog[0].measure[m+j], &catalog[0].average[i]); float dOff = hypot (dRoff, dDoff); maxOff = MAX (maxOff, dOff); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/IDmapIO.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/IDmapIO.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/IDmapIO.c (revision 37067) @@ -27,6 +27,6 @@ gfits_create_table_header (&theader, "BINTABLE", "IMAGE_ID_MAP"); - gfits_define_bintable_column (&theader, "J", "OLD_IDS", "old image IDs", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "NEW_IDS", "new image IDs", NULL, 1.0, 1.0*0x8000); + gfits_define_bintable_column (&theader, "J", "OLD_IDS", "old image IDs", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "NEW_IDS", "new image IDs", NULL, 1.0, FT_BZERO_INT32); // generate the output array that carries the data Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvo_image_merge_dbs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvo_image_merge_dbs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvo_image_merge_dbs.c (revision 37067) @@ -167,14 +167,27 @@ off_t i, oldID, newID; + if (!IDmap->old) { + fprintf (stderr, "input database has image IDs, but no Image table\n"); + return FALSE; + } + + if (!IDmap->Nmap) { + fprintf (stderr, "input database has image IDs, but no Image table\n"); + return FALSE; + } + + off_t lastID = IDmap->old[IDmap->Nmap-1]; + for (i = 0; i < catalog[0].Nmeasure; i++) { oldID = catalog[0].measure[i].imageID; if (oldID == 0) continue; - if (!IDmap->old) { - fprintf (stderr, "input database has image IDs, but no Image table\n"); - } - newID = dvo_map_image_ID (IDmap, oldID); if (newID == 0) { + if (oldID > lastID) { + fprintf (stderr, "problem with image IDs : input out of range\n"); + fprintf (stderr, "old ID: "OFF_T_FMT", last ID: "OFF_T_FMT"\n", oldID, lastID); + exit (2); + } if (!IDmap->notFound[oldID]) { fprintf (stderr, "cannot find image ID "OFF_T_FMT"\n", oldID); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeImageIDs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeImageIDs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeImageIDs.c (revision 37067) @@ -18,4 +18,6 @@ if (inDB.dbstate == LCK_EMPTY) { dvo_image_unlock (&inDB); // unlock input + IDmap->old = NULL; + IDmap->new = NULL; IDmap->Nmap = 0; return TRUE; @@ -99,4 +101,6 @@ if (inDB.dbstate == LCK_EMPTY) { dvo_image_unlock (&inDB); // unlock input + IDmap->old = NULL; + IDmap->new = NULL; IDmap->Nmap = 0; return TRUE; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeUpdate.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeUpdate.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeUpdate.c (revision 37067) @@ -111,5 +111,5 @@ SetPhotcodeTable(NULL); - dvomergeUpdate_catalogs (input, output, outsky, inlist, NsecfiltInput, NsecfiltOutput, &IDmap, secfiltMap); + int status = dvomergeUpdate_catalogs (input, output, outsky, inlist, NsecfiltInput, NsecfiltOutput, &IDmap, secfiltMap); // save the output sky table copy @@ -123,6 +123,11 @@ gettimeofday (&stop, NULL); dtime = DTIME (stop, start); + + if (!status) { + fprintf (stderr, "ERROR: elapsed time %9.4f sec\n", dtime); + exit (3); + } + fprintf (stderr, "SUCCESS: elapsed time %9.4f sec\n", dtime); - exit (0); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeUpdate_catalogs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeUpdate_catalogs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeUpdate_catalogs.c (revision 37067) @@ -140,4 +140,11 @@ } + if (!incatalog.sorted) { + fprintf (stderr, "ERROR: input catalog %s is not sorted (and must be for dvomerge)\n", filename_input); + exit (1); + } + + dvo_update_image_IDs (IDmap, &incatalog); + // merge input into the appropriate output tables for (j = 0; j < outlist[0].Nregions; j++) { @@ -156,10 +163,9 @@ LoadCatalog (&outcatalog, outlist[0].regions[j], outcatalog.filename, "w", NsecfiltOutput); - dvo_update_image_IDs (IDmap, &incatalog); merge_catalogs_old (outlist[0].regions[j], &outcatalog, &incatalog, RADIUS, secfiltMap); outcatalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF; - if (outstat[i].missed) { + if (outstat[j].missed) { dmhObjectAdd (outstat[j].history, &outcatalog.header, inStats); } @@ -248,4 +254,9 @@ if (FORCE_MERGE) { snprintf (tmpline, DVO_MAX_PATH, "%s -force-merge", command); strcpy (command, tmpline); } + // add some config variables: + snprintf (tmpline, DVO_MAX_PATH, "%s -D CATMODE %s", command, CATMODE); strcpy (command, tmpline); + snprintf (tmpline, DVO_MAX_PATH, "%s -D CATFORMAT %s", command, CATFORMAT); strcpy (command, tmpline); + snprintf (tmpline, DVO_MAX_PATH, "%s -D SKY_DEPTH %d", command, SKY_DEPTH); strcpy (command, tmpline); + fprintf (stderr, "command: %s\n", command); @@ -275,5 +286,9 @@ } if (!PARALLEL_MANUAL && !PARALLEL_SERIAL) { - HostTableWaitJobsGetIO (table, __FILE__, __LINE__, VERBOSE); + int status = HostTableWaitJobsGetIO (table, __FILE__, __LINE__, VERBOSE); + if (!status) { + fprintf (stderr, "error running one of the remote clients\n"); + return status; + } } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepair.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepair.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepair.c (revision 37067) @@ -2,4 +2,8 @@ int main (int argc, char **argv) { + + fprintf (stderr, "this program needs to be updated to load old format Measure tables (pre PV1_V5) in which dR,dD are saved, not R,D\n"); + fprintf (stderr, "reminder: relastro can re-construct R,D from X,Y; FtableToMeasure and vice versa could just NAN those values\n"); + exit (2); dvorepair_help(argc, argv); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairCPT.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairCPT.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairCPT.c (revision 37067) @@ -76,5 +76,5 @@ } - measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat); + measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat); myAssert(measure, "failed to convert ftable to measure data"); @@ -126,5 +126,6 @@ average[Nave].measureOffset = -1; average[Nave].missingOffset = -1; - average[Nave].extendOffset = -1; + average[Nave].refColorBlue = NAN; + average[Nave].refColorRed = NAN; average[Nave].objID = measure[i].objID; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairDeleteImageList.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairDeleteImageList.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairDeleteImageList.c (revision 37067) @@ -250,5 +250,5 @@ gfits_scan(&cpmHeaderTBL, "NAXIS1", "%d", 1, &NbytesPerRow); - measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat); + measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat); myAssert(measure, "failed to convert ftable to measure data"); @@ -288,5 +288,5 @@ // convert internal to external format - if (!MeasureToFtable (&cpmFtable, measureNew, NmeasureNew, catformat)) { + if (!MeasureToFtable (&cpmFtable, NULL, measureNew, NmeasureNew, catformat)) { myAbort("trouble converting format"); } @@ -411,5 +411,6 @@ average[Nave].measureOffset = -1; average[Nave].missingOffset = -1; - average[Nave].extendOffset = -1; + average[Nave].refColorBlue = NAN; + average[Nave].refColorRed = NAN; average[Nave].objID = measure[i].objID; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairFixCPT.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairFixCPT.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairFixCPT.c (revision 37067) @@ -120,5 +120,5 @@ } - measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat); + measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat); myAssert(measure, "failed to convert ftable to measure data"); @@ -127,5 +127,5 @@ // convert internal to external format - if (!MeasureToFtable (&cpmFtable, measure, Nmeasure, catformat)) { + if (!MeasureToFtable (&cpmFtable, NULL, measure, Nmeasure, catformat)) { myAbort("trouble converting format"); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairFixTables.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairFixTables.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairFixTables.c (revision 37067) @@ -103,5 +103,5 @@ // convert internal to external format - if (!MeasureToFtable (&cpmFtable, measureNew, NmeasureNew, catformat)) { + if (!MeasureToFtable (&cpmFtable, NULL, measureNew, NmeasureNew, catformat)) { myAbort("trouble converting format"); } @@ -183,5 +183,5 @@ gfits_scan(&cpmHeaderTBL, "NAXIS2", "%d", 1, &Nrows); - measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat); + measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat); myAssert(measure, "failed to convert ftable to measure data"); @@ -266,5 +266,6 @@ average[Nave].measureOffset = -1; average[Nave].missingOffset = -1; - average[Nave].extendOffset = -1; + average[Nave].refColorBlue = NAN; + average[Nave].refColorRef = NAN; average[Nave].objID = measure[i].objID; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairImageVsMeasure.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairImageVsMeasure.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairImageVsMeasure.c (revision 37067) @@ -128,5 +128,5 @@ gfits_scan(&cpmHeaderTBL, "NAXIS1", "%d", 1, &NbytesPerRow); - measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat); + measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat); myAssert(measure, "failed to convert ftable to measure data"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairImagesVsMeasures.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairImagesVsMeasures.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairImagesVsMeasures.c (revision 37067) @@ -134,5 +134,5 @@ gfits_scan(&cpmHeaderTBL, "NAXIS1", "%d", 1, &NbytesPerRow); - measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat); + measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat); myAssert(measure, "failed to convert ftable to measure data"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/merge_catalogs_old.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/merge_catalogs_old.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/merge_catalogs_old.c (revision 37067) @@ -1,12 +1,4 @@ # include "dvomerge.h" # define PSPS_ID TRUE - -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); \ - fprintf (stderr, MSG, __VA_ARGS__); \ - gettimeofday (&start, (void *) NULL); \ - } # define IN_REGION(R,D) ( \ @@ -19,5 +11,5 @@ off_t i, j, k, Nin, offset, J, Jmin, status, Nstars; - double RADIUS2, Rmin, Rin, Din; + double RADIUS2, Rmin; double *X1, *Y1, *X2, *Y2; double dX, dY, dR; @@ -29,6 +21,5 @@ Coords tcoords; - // struct timeval start, stop; - // gettimeofday (&start, (void *) NULL); + // INITTIME; NsecfiltOut = output[0].Nsecfilt; @@ -40,5 +31,9 @@ ALLOCATE (Y1, double, input[0].Naverage); ALLOCATE (N1, off_t, input[0].Naverage); - ALLOCATE (input[0].found, off_t, input[0].Naverage); + if (!input[0].found_t) { + ALLOCATE (input[0].found_t, off_t, input[0].Naverage); + } else { + REALLOCATE (input[0].found_t, off_t, input[0].Naverage); + } /** allocate local arrays (catalog) **/ @@ -47,5 +42,9 @@ ALLOCATE (Y2, double, NAVE); ALLOCATE (N2, off_t, NAVE); - ALLOCATE (output[0].found, off_t, NAVE); + if (!output[0].found_t) { + ALLOCATE (output[0].found_t, off_t, NAVE); + } else { + REALLOCATE (output[0].found_t, off_t, NAVE); + } /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */ @@ -76,5 +75,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 1; - strcpy (tcoords.ctype, "RA---ARC"); + strcpy (tcoords.ctype, "DEC--ARC"); if (VERBOSE) fprintf (stderr, "merging %s into %s\n", input[0].filename, output[0].filename); @@ -87,10 +86,8 @@ N1[Nstars] = i; Nstars ++; - input[0].found[i] = -1; + input[0].found_t[i] = -1; } if (Nstars < 1) { if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", output[0].filename); - free (output[0].found); - free (input[0].found); free (X1); free (Y1); @@ -106,5 +103,5 @@ for (i = 0; i < Nave; i++) { RD_to_XY (&X2[i], &Y2[i], output[0].average[i].R, output[0].average[i].D, &tcoords); - output[0].found[i] = -1; + output[0].found_t[i] = -1; N2[i] = i; } @@ -196,5 +193,5 @@ int Mout = output[0].average[n].measureOffset; if (replace_match(&output[0].average[n], &output[0].measure[Mout], &input[0].average[N], &input[0].measure[offset])) { - input[0].found[N] = Mout; + input[0].found_t[N] = Mout; continue; } @@ -206,10 +203,11 @@ output[0].measure[Nmeas] = input[0].measure[offset]; - Rin = input[0].average[N].R - input[0].measure[offset].dR / 3600.0; - Din = input[0].average[N].D - input[0].measure[offset].dD / 3600.0; - - /** dR,dD now represent arcsec **/ - output[0].measure[Nmeas].dR = 3600.0*(output[0].average[n].R - Rin); // XXX update these based on choice of astromety - output[0].measure[Nmeas].dD = 3600.0*(output[0].average[n].D - Din); // XXX update these based on choice of astromety + // old code: find R,D using average_in[0], the get offset relative to average_out[0]. no longer + // needed since we carry around R,D + // Rin = input[0].average[N].R - input[0].measure[offset].dR / 3600.0; + // Din = input[0].average[N].D - input[0].measure[offset].dD / 3600.0; + // output[0].measure[Nmeas].dR = 3600.0*(output[0].average[n].R - Rin); + // output[0].measure[Nmeas].dD = 3600.0*(output[0].average[n].D - Din); + output[0].measure[Nmeas].dbFlags = 0; // XXX why reset these? output[0].measure[Nmeas].averef = n; @@ -221,28 +219,29 @@ // fprintf (stderr, "Nave : "OFF_T_FMT", Nmeas : "OFF_T_FMT", dR: %f, dD: %f, catID: %d\n", n, Nmeas, output[0].measure[Nmeas].dR, output[0].measure[Nmeas].dD, output[0].measure[i].catID); - // rationalize dR - if (output[0].measure[Nmeas].dR > +180.0*3600.0) { + float dRoff = dvoOffsetR(&output[0].measure[Nmeas], &output[0].average[n]); + + // rationalize R + if (dRoff > +180.0*3600.0) { // average on high end of boundary, move star up - Rin += 360.0; - output[0].measure[Nmeas].dR = 3600.0*(output[0].average[n].R - Rin); - } - if (output[0].measure[Nmeas].dR < -180.0*3600.0) { + output[0].measure[Nmeas].R += 360.0; + dRoff -= 360.0*3600.0; + } + if (dRoff < -180.0*3600.0) { // average on low end of boundary, move star down - Rin -= 360.0; - output[0].measure[Nmeas].dR = 3600.0*(output[0].average[n].R - Rin); - } - if (fabs(output[0].measure[Nmeas].dR) > 10*RADIUS) { - // ok take declination into account and check again. - double cosD = cos(RAD_DEG*Din); - if (fabs(output[0].measure[Nmeas].dR*cosD) > 10*RADIUS) { - - fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n", - output[0].average[n].R, output[0].average[n].D, Rin, Din, - X1[i], X2[Jmin], Y1[i], Y2[Jmin]); - - // XXX abort on this? -- this is a bad failure... + output[0].measure[Nmeas].R -= 360.0; + dRoff += 360.0*3600.0; + } + if (fabs(dRoff) > 10*RADIUS) { + // take declination into account and check again. + double cosD = cos(RAD_DEG*output[0].average[n].D); + if (fabs(dRoff*cosD) > 10*RADIUS) { + fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n", + output[0].average[n].R, output[0].average[n].D, + output[0].measure[Nmeas].R, output[0].measure[Nmeas].D, + X1[i], X2[Jmin], Y1[i], Y2[Jmin]); + // XXX abort on this? -- this is a bad failure... } } - input[0].found[N] = Nmeas; + input[0].found_t[N] = Nmeas; output[0].average[n].Nmeasure ++; Nmeas ++; @@ -273,5 +272,5 @@ /* Nm is updated, but not written out in -update mode (for existing entries) Nm is recalculated in build_meas_links if loaded table is not sorted */ - output[0].found[n] = Nmeas; + output[0].found_t[n] = Nmeas; i++; } @@ -295,5 +294,5 @@ } - if (input[0].found[N] >= 0) continue; + if (input[0].found_t[N] >= 0) continue; if (!IN_REGION (input[0].average[N].R, input[0].average[N].D)) continue; @@ -348,5 +347,5 @@ /* we set next[Nmeas] to -1 here, and update correctly below */ - input[0].found[N] = Nmeas; + input[0].found_t[N] = Nmeas; next_meas[Nmeas] = -1; Nmeas ++; @@ -374,8 +373,8 @@ /* note stars which have been found in this catalog */ for (i = 0; i < input[0].Naverage; i++) { - if (input[0].found[i] > -1) { - input[0].found[i] = -2; + if (input[0].found_t[i] > -1) { + input[0].found_t[i] = -2; } else { - input[0].found[i] = -3; + input[0].found_t[i] = -3; } } @@ -390,9 +389,7 @@ free (next_meas); - free (output[0].found); free (X2); free (Y2); free (N2); - free (input[0].found); free (X1); free (Y1); @@ -411,5 +408,5 @@ images have boundaries which are lines in pixels coords, but curve in RA and DEC - output[0].found[Ncat] but stars[Nstar].found + output[0].found_t[Ncat] but stars[Nstar].found */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/replace_match.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/replace_match.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/replace_match.c (revision 37067) @@ -7,5 +7,4 @@ unsigned int averef; unsigned int catID; - double Rin, Din; // find the matching photcode in the object's list of measurements @@ -18,10 +17,11 @@ measure_out[Nout] = measure_in[0]; - Rin = average_in[0].R - measure_in[0].dR / 3600.0; - Din = average_in[0].D - measure_in[0].dD / 3600.0; + // old code: find R,D using average_in[0], the get offset relative to average_out[0]. no longer + // needed since we carry around R,D + // double Rin = average_in[0].R - measure_in[0].dR / 3600.0; + // double Din = average_in[0].D - measure_in[0].dD / 3600.0; + // measure_out[Nout].dR = 3600.0*(average_out[0].R - Rin); + // measure_out[Nout].dD = 3600.0*(average_out[0].D - Din); - /** dR,dD now represent arcsec **/ - measure_out[Nout].dR = 3600.0*(average_out[0].R - Rin); - measure_out[Nout].dD = 3600.0*(average_out[0].D - Din); measure_out[Nout].dbFlags = 0; // XXX why reset these? measure_out[Nout].averef = averef; @@ -29,24 +29,25 @@ measure_out[Nout].catID = catID; + float dRoff = dvoOffsetR(&measure_out[Nout], average_out); + // rationalize dR - if (measure_out[Nout].dR > +180.0*3600.0) { + if (dRoff > +180.0*3600.0) { // average on high end of boundary, move star up - Rin += 360.0; - measure_out[Nout].dR = 3600.0*(average_out[0].R - Rin); + measure_out[Nout].R += 360.0; + dRoff -= 360.0*3600.0; } - if (measure_out[Nout].dR < -180.0*3600.0) { + if (dRoff < -180.0*3600.0) { // average on low end of boundary, move star down - Rin -= 360.0; - measure_out[Nout].dR = 3600.0*(average_out[0].R - Rin); + measure_out[Nout].R -= 360.0; + dRoff += 360.0*3600.0; } // warn on surprisingly distant detections - if (fabs(measure_out[Nout].dR) > 10*RADIUS) { + if (fabs(dRoff) > 10*RADIUS) { // ok take declination into account and check again. - double cosD = cos(RAD_DEG*Din); - if (fabs(measure_out[Nout].dR*cosD) > 10*RADIUS) { - + double cosD = cos(RAD_DEG*average_out[0].D); + if (fabs(dRoff*cosD) > 10*RADIUS) { fprintf (stderr, "surprisingly distant detection: %10.6f,%10.6f vs %10.6f,%10.6f\n", - average_out[0].R, average_out[0].D, Rin, Din); + average_out[0].R, average_out[0].D, measure_out[Nout].R, measure_out[Nout].D); } } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/include/dvopsps.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/include/dvopsps.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/include/dvopsps.h (revision 37067) @@ -3,4 +3,5 @@ # include # include "mysql.h" +# include "limits.h" # define DVO_MAX_PATH 1024 @@ -38,4 +39,10 @@ int PARALLEL_MANUAL; int PARALLEL_SERIAL; + +char *TIME_START; +char *TIME_END; + +int PHOTCODE_START; +int PHOTCODE_END; char *SINGLE_CPT; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/initialize_dvopsps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/initialize_dvopsps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/initialize_dvopsps.c (revision 37067) @@ -2,5 +2,5 @@ void usage_dvopsps () { - fprintf (stderr, "USAGE: dvopsps (mode) [dbinfo] (mode) [options]\n"); + fprintf (stderr, "USAGE: dvopsps (mode) [dbinfo] [options]\n"); fprintf (stderr, " mysql database info is supplied with these:\n"); fprintf (stderr, " -dbhost : database host machine\n"); @@ -11,9 +11,22 @@ fprintf (stderr, " -v : verbose mode\n"); fprintf (stderr, " -region Rmin Rmax Dmin Dmax\n"); + fprintf (stderr, " -cpt n0000/0000.00 : limit to the named cpt file\n"); fprintf (stderr, " -parallel : run in parallel mode\n"); + fprintf (stderr, " -insert-remote : in parallel mode, the client sends the data to the dbhost\n"); + fprintf (stderr, " -time-start YYYY/MM/DD,hh:mm:ss : limit detections to >= this time\n"); + fprintf (stderr, " -time-end YYYY/MM/DD,hh:mm:ss : limit detections to < this time\n"); + + fprintf (stderr, " -photcode-start NN : limit detections to >= this photcode number\n"); + fprintf (stderr, " -photcode-end NN : limit detections to < this photcode number\n"); + fprintf (stderr, "\n"); + + fprintf (stderr, " (mode) is one of detections, objects, skytable\n"); + + fprintf (stderr, "\n"); fprintf (stderr, " -h : this help list\n"); fprintf (stderr, " -help : this help list\n"); fprintf (stderr, " --h : this help list\n"); fprintf (stderr, " --help : this help list\n"); + fprintf (stderr, " Note that the dvo db can be specified by -D CATDIR (directory)\n"); exit (2); @@ -110,4 +123,42 @@ if ((N = get_argument (argc, argv, "-insert-remote"))) { SAVE_REMOTE = FALSE; + remove_argument (N, &argc, argv); + } + + TIME_START = NULL; + if ((N = get_argument (argc, argv, "-time-start"))) { + remove_argument (N, &argc, argv); + TIME_START = strcreate(argv[N]); + remove_argument (N, &argc, argv); + time_t TIME_START_SEC; + if (!ohana_str_to_time (TIME_START, &TIME_START_SEC)) { + fprintf (stderr, "error with starting time given by -time-start: %s\n", TIME_START); + exit (2); + } + } + + TIME_END = NULL; + if ((N = get_argument (argc, argv, "-time-end"))) { + remove_argument (N, &argc, argv); + TIME_END = strcreate(argv[N]); + remove_argument (N, &argc, argv); + time_t TIME_END_SEC; + if (!ohana_str_to_time (TIME_END, &TIME_END_SEC)) { + fprintf (stderr, "error with starting time given by -time-end: %s\n", TIME_END); + exit (2); + } + } + + PHOTCODE_START = 0; + if ((N = get_argument (argc, argv, "-photcode-start"))) { + remove_argument (N, &argc, argv); + PHOTCODE_START = atoi(argv[N]); + remove_argument (N, &argc, argv); + } + + PHOTCODE_END = INT_MAX; + if ((N = get_argument (argc, argv, "-photcode-end"))) { + remove_argument (N, &argc, argv); + PHOTCODE_END = atoi(argv[N]); remove_argument (N, &argc, argv); } @@ -260,4 +311,42 @@ } + TIME_START = NULL; + if ((N = get_argument (argc, argv, "-time-start"))) { + remove_argument (N, &argc, argv); + TIME_START = strcreate(argv[N]); + remove_argument (N, &argc, argv); + time_t TIME_START_SEC; + if (!ohana_str_to_time (TIME_START, &TIME_START_SEC)) { + fprintf (stderr, "error with starting time given by -time-start: %s\n", TIME_START); + exit (2); + } + } + + TIME_END = NULL; + if ((N = get_argument (argc, argv, "-time-end"))) { + remove_argument (N, &argc, argv); + TIME_END = strcreate(argv[N]); + remove_argument (N, &argc, argv); + time_t TIME_END_SEC; + if (!ohana_str_to_time (TIME_END, &TIME_END_SEC)) { + fprintf (stderr, "error with starting time given by -time-end: %s\n", TIME_END); + exit (2); + } + } + + PHOTCODE_START = 0; + if ((N = get_argument (argc, argv, "-photcode-start"))) { + remove_argument (N, &argc, argv); + PHOTCODE_START = atoi(argv[N]); + remove_argument (N, &argc, argv); + } + + PHOTCODE_END = INT_MAX; + if ((N = get_argument (argc, argv, "-photcode-end"))) { + remove_argument (N, &argc, argv); + PHOTCODE_END = atoi(argv[N]); + remove_argument (N, &argc, argv); + } + VERBOSE = FALSE; if ((N = get_argument (argc, argv, "-v"))) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_detections_dvopsps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_detections_dvopsps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_detections_dvopsps.c (revision 37067) @@ -2,10 +2,4 @@ # define USE_MYSQL 1 // # define SAVE_REMOTE 1 - -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); \ - fprintf (stderr, MSG, __VA_ARGS__); } // we have two ways of writing to the mysql database: @@ -153,4 +147,11 @@ if (SAVE_REMOTE) { snprintf (tmpline, 1024, "%s -save %s", command, table->hosts[i].results); strcpy (command, tmpline); } + // some filters -- these are the detections we skip + if (TIME_START) { snprintf (tmpline, 1024, "%s -time-start %s", command, TIME_START); strcpy (command, tmpline); } + if (TIME_END) { snprintf (tmpline, 1024, "%s -time-end %s", command, TIME_END); strcpy (command, tmpline); } + + if (PHOTCODE_START > 0) { snprintf (tmpline, 1024, "%s -photcode-start %d", command, PHOTCODE_START); strcpy (command, tmpline); } + if (PHOTCODE_END <= INT_MAX) { snprintf (tmpline, 1024, "%s -photcode-end %d", command, PHOTCODE_END); strcpy (command, tmpline); } + fprintf (stderr, "command: %s\n", command); @@ -238,6 +239,4 @@ buffer.Nalloc = 0; - struct timeval start, stop; - if (Ndetections == 0) return TRUE; @@ -247,5 +246,5 @@ int Ninsert = 0; - gettimeofday (&start, (void *) NULL); + INITTIME; for (i = 0; i < Ndetections; i++) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_detections_dvopsps_catalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_detections_dvopsps_catalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_detections_dvopsps_catalog.c (revision 37067) @@ -1,10 +1,4 @@ # include "dvopsps.h" # define DEBUG 0 - -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); \ - fprintf (stderr, MSG, __VA_ARGS__); } int Ndetections = 0; @@ -29,4 +23,9 @@ } + time_t TIME_START_SEC = 0; + time_t TIME_END_SEC = 0; + if (TIME_START) ohana_str_to_time (TIME_START, &TIME_START_SEC); // we validate this in the args.c + if (TIME_END) ohana_str_to_time (TIME_END, &TIME_END_SEC); // we validate this in the args.c + for (i = 0; i < catalog[0].Naverage; i++) { @@ -40,4 +39,12 @@ Average *average = &catalog->average[i]; Measure *measure = &catalog->measure[m + j]; + + // some filters -- these are the detections we skip + if (TIME_START && (measure->t < TIME_START_SEC)) continue; + if (TIME_END && (measure->t >= TIME_END_SEC)) continue; + + if (measure->photcode < PHOTCODE_START) continue; + if (measure->photcode >= PHOTCODE_END) continue; + PhotCode *code = GetPhotcodebyCode(measure->photcode); @@ -55,6 +62,6 @@ detections[Ndetections].airMass = measure->airmass; detections[Ndetections].expTime = pow(10.0, 0.4 * measure->dt); // expTime - detections[Ndetections].ra = average->R - measure->dR / 3600.; // ra - detections[Ndetections].dec = average->D - measure->dD / 3600.; // dec + detections[Ndetections].ra = measure->R; // ra + detections[Ndetections].dec = measure->D; // dec detections[Ndetections].raErr = measure->dXccd * 0.01 * fabs(measure->pltscale); // estimate of raErr detections[Ndetections].decErr = measure->dYccd * 0.01 * fabs(measure->pltscale); // estimate of decErr @@ -87,9 +94,11 @@ } +time_t TIME_START_SEC = 0; +time_t TIME_END_SEC = INT_MAX; + int insert_detections_dvopsps_catalog (Catalog *catalog, MYSQL *mysql) { off_t i, j; int missingID = 0; - struct timeval start, stop; IOBuffer buffer; @@ -101,5 +110,5 @@ off_t found = 0; - gettimeofday (&start, (void *) NULL); + INITTIME; insert_detections_mysql_init (&buffer); int Ninsert = 0; @@ -108,4 +117,7 @@ int status = TRUE; + if (TIME_START) ohana_str_to_time (TIME_START, &TIME_START_SEC); // we validate this in the args.c + if (TIME_END) ohana_str_to_time (TIME_END, &TIME_END_SEC); // we validate this in the args.c + // NOTE for testing, just do a few objects if (!mysql) { @@ -121,6 +133,15 @@ for (j = 0; j < average[i].Nmeasure; j++) { + off_t Nmeas = m + j; + + // some filters -- these are the detections we skip (not an error, just skipped) + if (TIME_START && (measure[Nmeas].t < TIME_START_SEC)) continue; + if (TIME_END && (measure[Nmeas].t >= TIME_END_SEC)) continue; + + if (measure[Nmeas].photcode < PHOTCODE_START) continue; + if (measure[Nmeas].photcode >= PHOTCODE_END) continue; + // XXX check return status - if (!insert_detections_mysql_value (&buffer, &average[i], &measure[m+j])) { + if (!insert_detections_mysql_value (&buffer, &average[i], &measure[Nmeas])) { fprintf (stderr, "failure to insert detections in mysql\n"); status = FALSE; @@ -198,6 +219,6 @@ float zp = code->C * 0.001 + code->K * (measure->airmass - 1) - measure->Mcal; float exptime = pow(10.0, 0.4 * measure->dt); - double ra = average->R - measure->dR / 3600.0; - double dec = average->D - measure->dD / 3600.0; + double ra = measure->R; + double dec = measure->D; double dR = measure->dXccd * 0.01 * fabs(measure->pltscale); double dD = measure->dYccd * 0.01 * fabs(measure->pltscale); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_objects_dvopsps_catalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_objects_dvopsps_catalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_objects_dvopsps_catalog.c (revision 37067) @@ -2,15 +2,8 @@ # define DEBUG 0 -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); \ - fprintf (stderr, MSG, __VA_ARGS__); } - int insert_objects_dvopsps_catalog (Catalog *catalog, char *basename, MYSQL *mysql) { off_t i; int missingID = 0; - struct timeval start, stop; IOBuffer ave_buffer, sec_buffer; @@ -31,5 +24,5 @@ insert_objects_mysql_create_tables (cleanname, mysql); - gettimeofday (&start, (void *) NULL); + INITTIME; insert_objects_mysql_init (&ave_buffer, &sec_buffer, cleanname); int Ninsert = 0; @@ -292,5 +285,5 @@ PrintIOBuffer (ave_buffer, "%d, ", average->measureOffset); PrintIOBuffer (ave_buffer, "%d, ", average->missingOffset); - PrintIOBuffer (ave_buffer, "%d, ", average->extendOffset); + PrintIOBuffer (ave_buffer, "%d, ", 0); // was : average->extendOffset); PrintIOBuffer (ave_buffer, "%u, ", average->flags); PrintIOBuffer (ave_buffer, "%u, ", average->photFlagsUpper); @@ -323,9 +316,9 @@ float stackPSFMag = -999.0; float stackPSFMagErr = -999.0; - if (isfinite(secfilt->dFluxPSF) && isfinite(secfilt->FluxPSF) && (secfilt->dFluxPSF > 0.0)) { - float SN = secfilt->FluxPSF / secfilt->dFluxPSF; + if (isfinite(secfilt->dFpsfStk) && isfinite(secfilt->FpsfStk) && (secfilt->dFpsfStk > 0.0)) { + float SN = secfilt->FpsfStk / secfilt->dFpsfStk; if (SN > 3.0) { - stackPSFMag = -2.5 * log10(secfilt->FluxPSF) + 8.9; - stackPSFMagErr = secfilt->dFluxPSF / secfilt->FluxPSF; + stackPSFMag = -2.5 * log10(secfilt->FpsfStk) + 8.9; + stackPSFMagErr = secfilt->dFpsfStk / secfilt->FpsfStk; } } @@ -333,9 +326,9 @@ float stackKronMag = -999.0; float stackKronMagErr = -999.0; - if (isfinite(secfilt->dFluxKron) && isfinite(secfilt->FluxKron) && (secfilt->dFluxKron > 0.0)) { - float SN = secfilt->FluxKron / secfilt->dFluxKron; + if (isfinite(secfilt->dFkronStk) && isfinite(secfilt->FkronStk) && (secfilt->dFkronStk > 0.0)) { + float SN = secfilt->FkronStk / secfilt->dFkronStk; if (SN > 3.0) { - stackKronMag = -2.5 * log10(secfilt->FluxKron) + 8.9; - stackKronMagErr = secfilt->dFluxKron / secfilt->FluxKron; + stackKronMag = -2.5 * log10(secfilt->FkronStk) + 8.9; + stackKronMagErr = secfilt->dFkronStk / secfilt->FkronStk; } } @@ -347,16 +340,16 @@ PRINT_FLOAT(sec_buffer, meanKronMagErr, "%.6f, "); // umag precision PRINT_FLOAT(sec_buffer, meanPSFMagErr, "%.6f, "); // umag precision - PRINT_FLOAT(sec_buffer, secfilt->Xm, "%.6f, "); + PRINT_FLOAT(sec_buffer, secfilt->Mchisq, "%.6f, "); PRINT_FLOAT(sec_buffer, stackPSFMag, "%.6f, "); // umag precision PRINT_FLOAT(sec_buffer, stackPSFMagErr, "%.6f, "); // umag precision PRINT_FLOAT(sec_buffer, stackKronMag, "%.6f, "); // umag precision PRINT_FLOAT(sec_buffer, stackKronMagErr, "%.6f, "); // 0.36 umag precision - PrintIOBuffer (sec_buffer, "%u, ", secfilt->flags); - PrintIOBuffer (sec_buffer, "%hd, ", secfilt->Ncode); - PrintIOBuffer (sec_buffer, "%hd, ", secfilt->Nused); - PrintIOBuffer (sec_buffer, "%hd, ", secfilt->M_20); - PrintIOBuffer (sec_buffer, "%hd, ", secfilt->M_80); + PrintIOBuffer (sec_buffer, "%u, ", secfilt->flags); + PrintIOBuffer (sec_buffer, "%hd, ", secfilt->Ncode); + PrintIOBuffer (sec_buffer, "%hd, ", secfilt->Nused); + PrintIOBuffer (sec_buffer, "%.6f, ", secfilt->Mmin); + PrintIOBuffer (sec_buffer, "%.6f, ", secfilt->Mmax); PrintIOBuffer (sec_buffer, "%hd, ", secfilt->ubercalDist); - PrintIOBuffer (sec_buffer, "%hd, ", secfilt->Mstdev); + PrintIOBuffer (sec_buffer, "%.6f, ", secfilt->Mstdev); PrintIOBuffer (sec_buffer, "%lu ", secfilt->stackDetectID); PrintIOBuffer (sec_buffer, "),\n"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_skytable.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_skytable.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_skytable.c (revision 37067) @@ -2,10 +2,4 @@ # define DEBUG 1 # define USE_MYSQL 1 - -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); \ - fprintf (stderr, MSG, __VA_ARGS__); } // determine the relevant catalogs, launch parallel clients if desired @@ -13,5 +7,4 @@ off_t i; - struct timeval start, stop; SkyTable *sky = NULL; @@ -34,5 +27,6 @@ # endif - gettimeofday (&start, (void *) NULL); + INITTIME; + insert_skytable_mysql_init (&buffer); int Ninsert = 0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/dvosplit.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/dvosplit.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/dvosplit.c (revision 37067) @@ -16,4 +16,12 @@ ConfigInit (&argc, argv); args (argc, argv); + + /* + fprintf (stderr, + "this program has the ability to split dvo catalogs one file (cpt, cpm, etc) at a time. + however, new updates to the cpm format requires the average RA,DEC coords to load the + measures. update the code to handle that first"); + exit (2); + */ CATDIR = strcreate (argv[1]); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/split_averages.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/split_averages.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/split_averages.c (revision 37067) @@ -1,4 +1,4 @@ # include "dvosplit.h" -# define NROWS 100000 /* ~10MB per block for measures */ +# define NROWS 1000000 /* ~10MB per block for measures */ # define DNOUT 1000 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/split_measures.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/split_measures.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/split_measures.c (revision 37067) @@ -1,4 +1,4 @@ # include "dvosplit.h" -# define NROWS 100000 /* ~10MB per row for measures */ +# define NROWS 1000000 /* ~10MB per row for measures */ # define DNOUT 1000 @@ -19,5 +19,6 @@ // split out the measure entries: - incatalog[0].catflags = LOAD_MEAS; + incatalog[0].catflags = LOAD_MEAS | LOAD_AVES | LOAD_SECF; + // if ((incatalog[0].catformat == DVO_FORMAT_ELIXIR) || (incatalog[0].catformat == DVO_FORMAT_LONEOS)) { // // for these two formats, we need the average and secfilt values around until we do the measures... Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/fixcat/src/gcatstats.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/fixcat/src/gcatstats.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/fixcat/src/gcatstats.c (revision 37067) @@ -52,5 +52,5 @@ catstats[0].coords.pc1_1 = catstats[0].coords.pc2_2 = 1.0; catstats[0].coords.pc1_2 = catstats[0].coords.pc2_1 = 0.0; - strcpy (catstats[0].coords.ctype, "RA---TAN"); + strcpy (catstats[0].coords.ctype, "DEC--TAN"); X1 = catstats[0].X; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro/src/gstars.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro/src/gstars.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro/src/gstars.c (revision 37067) @@ -79,5 +79,5 @@ if (!strcasecmp (ROUGH_ASTROMETRY, "config")) { /* default values for coords */ - strcpy (coords[0].ctype, "RA---TAN"); + strcpy (coords[0].ctype, "DEC--TAN"); coords[0].pc1_1 = CCD_PC1_1; coords[0].pc1_2 = CCD_PC1_2; coords[0].pc2_1 = CCD_PC2_1; coords[0].pc2_2 = CCD_PC2_2; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro2/src/coordtest.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro2/src/coordtest.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro2/src/coordtest.c (revision 37067) @@ -85,5 +85,5 @@ fit_eval (); - strcpy (coords.ctype, "RA---PLY"); + strcpy (coords.ctype, "DEC--PLY"); coords.crval1 = 0.0; coords.crval2 = 0.0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro2/src/gstars2.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro2/src/gstars2.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro2/src/gstars2.c (revision 37067) @@ -28,5 +28,5 @@ /* default values for coords */ - strcpy (Target[0].coords.ctype, "RA---TAN"); + strcpy (Target[0].coords.ctype, "DEC--TAN"); Target[0].coords.pc1_1 = CCD_PC1_1; Target[0].coords.pc1_2 = CCD_PC1_2; Target[0].coords.pc2_1 = CCD_PC2_1; Target[0].coords.pc2_2 = CCD_PC2_2; @@ -125,5 +125,5 @@ /* read from FITS table or from text table */ /* Is NAXIS == 0 a better test?? */ - gfits_scan_alt (&Target[0].header, "NAXIS", "%t", 1, &naxis); + gfits_scan_alt (&Target[0].header, "NAXIS", "%d", 1, &naxis); if ((naxis == 0) && !TEXTMODE) { Nskip = gfits_data_size (&Target[0].header); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/GetFileMode.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/GetFileMode.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/GetFileMode.c (revision 37067) @@ -8,7 +8,8 @@ int simple, extend, haveNaxis, haveCTYPE; + // NOTE target of %t must be int length gfits_scan_alt (header, "SIMPLE", "%t", 1, &simple); haveNaxis = gfits_scan (header, "NAXIS", "%d", 1, &Naxis); - haveCTYPE = gfits_scan (header, "CTYPE1", "%s", 1, ctype); + haveCTYPE = gfits_scan (header, "CTYPE2", "%s", 1, ctype); gfits_scan_alt (header, "EXTEND", "%t", 1, &extend); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/MatchImages.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/MatchImages.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/MatchImages.c (revision 37067) @@ -36,5 +36,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 1; - strcpy (tcoords.ctype, "RA---TAN"); + strcpy (tcoords.ctype, "DEC--TAN"); /* register so image->sky conversions below have correct mosaic */ } else { @@ -44,5 +44,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 1; - strcpy (tcoords.ctype, "RA---TAN"); + strcpy (tcoords.ctype, "DEC--TAN"); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/ReadImageFiles.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/ReadImageFiles.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/ReadImageFiles.c (revision 37067) @@ -138,5 +138,7 @@ !strcmp (tmpword, "PS1_V1") || !strcmp (tmpword, "PS1_V2") || - !strcmp (tmpword, "PS1_V3")) { + !strcmp (tmpword, "PS1_V3") || + !strcmp (tmpword, "PS1_V4") || + !strcmp (tmpword, "PS1_V5")) { exttype[Nimage] = strcreate (tmpword); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/select_by_region.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/select_by_region.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/select_by_region.c (revision 37067) @@ -73,5 +73,5 @@ for (m = 0; m < catalog[0].average[i].Nmeasure; m++) { if (catalog[0].measure[offset + m].photcode == code) { - mag = PhotRel (&catalog[0].measure[offset + m], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]); + mag = PhotRel (&catalog[0].measure[offset + m], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } @@ -126,5 +126,5 @@ for (m = 0; m < catalog[0].average[i].Nmeasure; m++) { if (catalog[0].measure[offset + m].photcode == code) { - mag = PhotRel (&catalog[0].measure[offset + m], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]); + mag = PhotRel (&catalog[0].measure[offset + m], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_0.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_0.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_0.c (revision 37067) @@ -61,5 +61,5 @@ for (m = 0; m < average[i].Nmeasure; m++) { if (measure[offset + m].photcode == code_c0) { - output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]); + output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } @@ -75,5 +75,5 @@ for (m = 0; m < average[i].Nmeasure; m++) { if (measure[offset + m].photcode == code_c1) { - output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]); + output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } @@ -89,5 +89,5 @@ for (m = 0; m < average[i].Nmeasure; m++) { if (measure[offset + m].photcode == code_c2) { - output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]); + output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_1.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_1.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_1.c (revision 37067) @@ -64,5 +64,5 @@ for (m = 0; m < average[i].Nmeasure; m++) { if (measure[offset + m].photcode == code_c0) { - output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]); + output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } @@ -78,5 +78,5 @@ for (m = 0; m < average[i].Nmeasure; m++) { if (measure[offset + m].photcode == code_c1) { - output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]); + output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } @@ -92,5 +92,5 @@ for (m = 0; m < average[i].Nmeasure; m++) { if (measure[offset + m].photcode == code_c2) { - output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]); + output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_2.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_2.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_2.c (revision 37067) @@ -70,5 +70,5 @@ for (m = 0; m < average[i].Nmeasure; m++) { if (measure[offset + m].photcode == code_c0) { - output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]); + output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } @@ -84,5 +84,5 @@ for (m = 0; m < average[i].Nmeasure; m++) { if (measure[offset + m].photcode == code_c1) { - output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]); + output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } @@ -98,5 +98,5 @@ for (m = 0; m < average[i].Nmeasure; m++) { if (measure[offset + m].photcode == code_c2) { - output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]); + output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF); break; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/include/constants.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/include/constants.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/include/constants.h (revision 37067) @@ -15,5 +15,5 @@ // XXX for the moment, this is set to match the values in SetColorScale3D_CC # define NPIXELS_STATIC 128 -// # define NPIXELS_STATIC 1000 +// # define NPIXELS_STATIC 4600 -- if we want fullcolor to work, need this # define PAD1 3 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/CheckPipe.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/CheckPipe.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/CheckPipe.c (revision 37067) @@ -1,3 +1,4 @@ # include "Ximage.h" +# include # define STRCONST(A) ((int)(0x1000000*A[0] + 0x10000*A[1] + 0x100*A[2] + 0x1*A[3])) @@ -41,6 +42,11 @@ word[4] = 0; switch (status) { - case -1: /* no input from pipe: continue */ - return (TRUE); + case -1: + if (errno == EAGAIN) { + /* no input from pipe: continue */ + return (TRUE); + } + perror ("exiting due to problem with socket connection in CheckPipe"); + return (FALSE); break; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/DrawObjects.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/DrawObjects.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/DrawObjects.c (revision 37067) @@ -608,4 +608,26 @@ } } + if (object[0].ptype == 12) { /* filled triangle (down) */ + XPoint points[4]; + for (i = 0; i < object[0].Npts; i++) { + if (!(finite(x[i]) && finite(y[i]))) continue; + sx = x[i]*mxi + y[i]*mxj + bx + XCENTER; + sy = x[i]*myi + y[i]*myj + by + YCENTER; + if ((sx > graph[0].axis[0].fx) && (sx < graph[0].axis[0].fx + graph[0].axis[0].dfx) && + (sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy)) { + if (scaleColor) { + if (!finite(z[i])) continue; + int pixel = MIN (graphic->Npixels - 2, MAX (0, z[i]*(graphic->Npixels - 1))); + XSetForeground (graphic->display, graphic->gc, graphic->cmap[pixel].pixel); + } + D = scaleSize ? dz*z[i] : ds; + points[0].x = sx - D; points[0].y = sy - 0.58*D; + points[1].x = sx + D; points[1].y = sy - 0.58*D; + points[2].x = sx; points[2].y = sy + 1.15*D; + points[3].x = sx - D; points[3].y = sy - 0.58*D; + XFillPolygon (graphic->display, graphic->window, graphic->gc, points, 4, Convex, CoordModeOrigin); + } + } + } if (object[0].ptype == 100) { /* connect a pair of points */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/EventLoop.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/EventLoop.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/EventLoop.c (revision 37067) @@ -1,3 +1,4 @@ # include "Ximage.h" +# define DEBUG 0 /* list events being selected below, all other masks are ignored */ @@ -6,9 +7,27 @@ int LastEvent (Display *display, int type, XEvent *event) { - int found; + int found, Nfound; found = FALSE; + Nfound = 0; while (XCheckTypedEvent (display, type, event)) { + // If the link is slow, then I should wait a little while for some config events to + // build up (typically, the window is being dragged around, so we get a whole series of + // config events. the flush / sync time is slow on a slow link, so we should try to wait + // for the config events to stop, but on a timescale deteremined by the flush/sync time + // if (type == ConfigureNotify) fprintf (stderr, "config (%d)\n", Nfound); + Nfound ++; found = TRUE; + } + if (DEBUG && found) { + if (type == ConfigureNotify) fprintf (stderr, "config (%d)\n", Nfound); + if (type == CirculateNotify) fprintf (stderr, "circul (%d)\n", Nfound); + if (type == Expose) fprintf (stderr, "expose (%d)\n", Nfound); + } + + // if I have a ConfigureNotify event, I should purge all Expose events as well: + if (found && (type == ConfigureNotify)) { + XEvent discard; + while (XCheckTypedEvent (display, Expose, &discard)); } return (found); @@ -38,13 +57,14 @@ if (XEventsQueued (display, QueuedAfterFlush) < 1) { - /* fprintf (stderr, "."); */ usleep (50000); continue; } + // If I have a config event, I want to also purge all expose events + /* grab the last entry for these events */ - if (LastEvent (display, ConfigureNotify, &event)) Reconfig (&event); - if (LastEvent (display, CirculateNotify, &event)) Reconfig (&event); - if (LastEvent (display, Expose, &event)) Refresh (); + if (LastEvent (display, ConfigureNotify, &event)) { Reconfig (&event); continue; } + if (LastEvent (display, CirculateNotify, &event)) { Reconfig (&event); continue; } + if (LastEvent (display, Expose, &event)) { Refresh (); continue; } if (LastEvent (display, MappingNotify, &event)) XRefreshKeyboardMapping ((XMappingEvent *) &event); if (LastEvent (display, MotionNotify, &event)) UpdatePointer (graphic, (XMotionEvent *) &event); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/FlushDisplay.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/FlushDisplay.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/FlushDisplay.c (revision 37067) @@ -30,5 +30,7 @@ if (flush) { - XFlush (graphic->display); + // I changed XFlush to XSync to avoid lag + // of the display (build up of config events) + XSync (graphic->display, FALSE); reftime = now; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Graphs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Graphs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Graphs.c (revision 37067) @@ -64,5 +64,5 @@ graph[0].data.coords.crpix2 = 0.0; graph[0].data.coords.cdelt1 = graph[0].data.coords.cdelt2 = 1.0; - strcpy (graph[0].data.coords.ctype, "RA---LIN"); + strcpy (graph[0].data.coords.ctype, "DEC--LIN"); strcpy (graph[0].data.axis, "2222"); strcpy (graph[0].data.ticks, "2222"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Image.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Image.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Image.c (revision 37067) @@ -18,5 +18,5 @@ channel->coords.crpix2 = 0.0; channel->coords.cdelt1 = channel->coords.cdelt2 = 1.0; - strcpy (channel->coords.ctype, "RA---LIN"); + strcpy (channel->coords.ctype, "DEC--LIN"); channel->coords.Npolyterms = 0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Refresh.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Refresh.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Refresh.c (revision 37067) @@ -47,5 +47,4 @@ Y0 = graphic[0].dy - graphic[0].dy * section[0].y - dY; X0 = graphic[0].dx * section[0].x; - // fprintf (stderr, "section: (%s) %d %d - %d %d\n", section[0].name, X0, Y0, dX, dY); XFillRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, X0, Y0, dX, dY); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/bDrawObjects.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/bDrawObjects.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/bDrawObjects.c (revision 37067) @@ -315,4 +315,5 @@ D = scaleSize ? dz*z[i] : ds; FillRectangle (buffer, sx, sy, 2*D, 2*D); + // plot range saturated by bDrawRectFill } } @@ -335,4 +336,5 @@ D = scaleSize ? dz*z[i] : ds; DrawRectangle (buffer, sx, sy, 2*D, 2*D); + // plot range saturated by bDrawRectOpen } } @@ -356,4 +358,5 @@ DrawLine (buffer, sx - D, sy, sx + D, sy); DrawLine (buffer, sx, sy - D, sx, sy + D); + // out-of-range points skipped by bDrawPoint } } @@ -377,4 +380,5 @@ DrawLine (buffer, sx + D, sy - D, sx - D, sy + D); DrawLine (buffer, sx - D, sy - D, sx + D, sy + D); + // out-of-range points skipped by bDrawPoint } } @@ -398,4 +402,5 @@ // FillTriangle (buffer, sx - D, sy - 0.58*D, sx + D, sy - 0.58*D, sx, sy + 1.15*D); FillTriangle (buffer, sx, sy + 0.58*D, D, -1.73*D); + // out-of-range points skipped by bDrawPoint } } @@ -418,4 +423,5 @@ D = scaleSize ? dz*z[i] : ds; OpenTriangle (buffer, sx - D, sy + 0.58*D, sx + D, sy + 0.58*D, sx, sy - 1.15*D); + // out-of-range points skipped by bDrawPoint } } @@ -440,4 +446,5 @@ DrawLine (buffer, sx, sy, sx + D, sy - 0.58*D); DrawLine (buffer, sx, sy, sx, sy + 1.15*D); + // out-of-range points skipped by bDrawPoint } } @@ -460,4 +467,5 @@ D = scaleSize ? dz*z[i] : ds; DrawCircle (buffer, sx, sy, D); + // out-of-range points skipped by bDrawPoint } } @@ -484,4 +492,5 @@ DrawLine (buffer, sx - 0.58*D, sy + 0.81*D, sx - 0.95*D, sy - 0.31*D); DrawLine (buffer, sx - 0.95*D, sy - 0.31*D, sx + 0.00*D, sy - 1.00*D); + // out-of-range points skipped by bDrawPoint } } @@ -509,4 +518,5 @@ DrawLine (buffer, sx + 0.50*D, sy - 0.87*D, sx - 0.50*D, sy - 0.87*D); DrawLine (buffer, sx - 0.50*D, sy - 0.87*D, sx - D, sy); + // out-of-range points skipped by bDrawPoint } } @@ -529,4 +539,27 @@ D = scaleSize ? dz*z[i] : ds; FillCircle (buffer, sx, sy, D); + // out-of-range points skipped by bDrawLineHorizontal + } + } + } + if (object[0].ptype == 12) { /* filled triangle (down) */ + for (i = 0; i < object[0].Npts; i++) { + if (!(finite(x[i]) && finite(y[i]))) continue; + sx = x[i]*mxi + y[i]*mxj + bx; + sy = x[i]*myi + y[i]*myj + by; + if ((sx > graph[0].axis[0].fx) && (sx < graph[0].axis[0].fx + graph[0].axis[0].dfx) && + (sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy)) + { + if (scaleColor) { + if (!finite(z[i])) continue; + int pixel = MIN (graphic->Npixels - 2, MAX (0, z[i]*(graphic->Npixels - 1))); + buffer->bColor_R = pixel1[pixel]; + buffer->bColor_G = pixel2[pixel]; + buffer->bColor_B = pixel3[pixel]; + } + D = scaleSize ? dz*z[i] : ds; + // FillTriangle (buffer, sx - D, sy - 0.58*D, sx + D, sy - 0.58*D, sx, sy + 1.15*D); + FillTriangle (buffer, sx, sy + 0.58*D, D, 1.73*D); + // out-of-range points skipped by bDrawPoint } } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/Makefile.Targets =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/Makefile.Targets (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/Makefile.Targets (revision 37067) @@ -12,4 +12,5 @@ $(ASRC)/average-ps1-v3.$(ARCH).o \ $(ASRC)/average-ps1-v4.$(ARCH).o \ +$(ASRC)/average-ps1-v5.$(ARCH).o \ $(ASRC)/average-ps1-ref.$(ARCH).o \ $(ASRC)/secfilt.$(ARCH).o \ @@ -24,4 +25,5 @@ $(ASRC)/secfilt-ps1-v3.$(ARCH).o \ $(ASRC)/secfilt-ps1-v4.$(ARCH).o \ +$(ASRC)/secfilt-ps1-v5.$(ARCH).o \ $(ASRC)/secfilt-ps1-ref.$(ARCH).o \ $(ASRC)/measure.$(ARCH).o \ @@ -36,5 +38,10 @@ $(ASRC)/measure-ps1-v3.$(ARCH).o \ $(ASRC)/measure-ps1-v4.$(ARCH).o \ +$(ASRC)/measure-ps1-v5.$(ARCH).o \ $(ASRC)/measure-ps1-ref.$(ARCH).o \ +$(ASRC)/lensing.$(ARCH).o \ +$(ASRC)/lensing-ps1-v5.$(ARCH).o \ +$(ASRC)/lensobj.$(ARCH).o \ +$(ASRC)/lensobj-ps1-v5.$(ARCH).o \ $(ASRC)/missing.$(ARCH).o \ $(ASRC)/photcode.$(ARCH).o \ @@ -47,4 +54,5 @@ $(ASRC)/photcode-ps1-v3.$(ARCH).o \ $(ASRC)/photcode-ps1-v4.$(ARCH).o \ +$(ASRC)/photcode-ps1-v5.$(ARCH).o \ $(ASRC)/photcode-ps1-ref.$(ARCH).o \ $(ASRC)/image.$(ARCH).o \ @@ -60,4 +68,5 @@ $(ASRC)/image-ps1-v3.$(ARCH).o \ $(ASRC)/image-ps1-v4.$(ARCH).o \ +$(ASRC)/image-ps1-v5.$(ARCH).o \ $(ASRC)/image-ps1-ref.$(ARCH).o \ $(ASRC)/regimage.$(ARCH).o \ @@ -73,4 +82,5 @@ $(ASRC)/cmf-ps1-sv1.$(ARCH).o \ $(ASRC)/cmf-ps1-sv2.$(ARCH).o \ +$(ASRC)/cmf-ps1-dv4.$(ARCH).o \ $(ASRC)/cmf-smpdata.$(ARCH).o \ $(ASRC)/getstar-ps1-dev-0.$(ARCH).o \ @@ -84,4 +94,6 @@ $(ASRC)/FlatCorrectionImage.$(ARCH).o \ $(ASRC)/FlatCorrection.$(ARCH).o + +# $(ASRC)/cmf-ps1-sv3.$(ARCH).o AINCS = \ @@ -98,4 +110,5 @@ $(AINC)/average-ps1-v3.h \ $(AINC)/average-ps1-v4.h \ +$(AINC)/average-ps1-v5.h \ $(AINC)/average-ps1-ref.h \ $(AINC)/secfilt.h \ @@ -110,4 +123,5 @@ $(AINC)/secfilt-ps1-v3.h \ $(AINC)/secfilt-ps1-v4.h \ +$(AINC)/secfilt-ps1-v5.h \ $(AINC)/secfilt-ps1-ref.h \ $(AINC)/measure.h \ @@ -122,5 +136,10 @@ $(AINC)/measure-ps1-v3.h \ $(AINC)/measure-ps1-v4.h \ +$(AINC)/measure-ps1-v5.h \ $(AINC)/measure-ps1-ref.h \ +$(AINC)/lensing.h \ +$(AINC)/lensing-ps1-v5.h \ +$(AINC)/lensobj.h \ +$(AINC)/lensobj-ps1-v5.h \ $(AINC)/missing.h \ $(AINC)/photcode.h \ @@ -133,4 +152,5 @@ $(AINC)/photcode-ps1-v3.h \ $(AINC)/photcode-ps1-v4.h \ +$(AINC)/photcode-ps1-v5.h \ $(AINC)/photcode-ps1-ref.h \ $(AINC)/image.h \ @@ -146,4 +166,5 @@ $(AINC)/image-ps1-v3.h \ $(AINC)/image-ps1-v4.h \ +$(AINC)/image-ps1-v5.h \ $(AINC)/image-ps1-ref.h \ $(AINC)/regimage.h \ @@ -159,4 +180,5 @@ $(AINC)/cmf-ps1-sv1.h \ $(AINC)/cmf-ps1-sv2.h \ +$(AINC)/cmf-ps1-dv4.h \ $(AINC)/cmf-smpdata.h \ $(AINC)/getstar-ps1-dev-0.h \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-dev-2.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-dev-2.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-dev-2.d (revision 37067) @@ -25,5 +25,5 @@ FIELD measureOffset, OFF_MEASURE, int, offset to first psf measurement FIELD missingOffset, OFF_MISSING, int, offset to first missing obs -FIELD extendOffset, OFF_EXTEND, int, offset to first extended measurement +FIELD refColor, REF_COLOR, float, color of astrometry ref stars FIELD code, code, unsigned short, ID code (star; ghost; etc) Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v1.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v1.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v1.d (revision 37067) @@ -30,5 +30,5 @@ FIELD measureOffset, OFF_MEASURE, uint32_t, offset to first psf measurement FIELD missingOffset, OFF_MISSING, uint32_t, offset to first missing obs -FIELD extendOffset, OFF_EXTEND, uint32_t, offset to first extended measurement +FIELD refColor, REF_COLOR, float, color of astrometry ref stars # 'flags' was called 'code' prior to 2009.02.07 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v2.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v2.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v2.d (revision 37067) @@ -35,5 +35,5 @@ FIELD measureOffset, OFF_MEASURE, uint32_t, offset to first psf measurement FIELD missingOffset, OFF_MISSING, uint32_t, offset to first missing obs -FIELD extendOffset, OFF_EXTEND, uint32_t, offset to first extended measurement +FIELD refColor, REF_COLOR, float, color of astrometry ref stars # 'flags' was called 'code' prior to 2009.02.07 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v3.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v3.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v3.d (revision 37067) @@ -35,5 +35,5 @@ FIELD measureOffset, OFF_MEASURE, uint32_t, offset to first psf measurement FIELD missingOffset, OFF_MISSING, uint32_t, offset to first missing obs -FIELD extendOffset, OFF_EXTEND, uint32_t, offset to first extended measurement +FIELD refColor, REF_COLOR, float, color of astrometry ref stars # 'flags' was called 'code' prior to 2009.02.07 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v4.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v4.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v4.d (revision 37067) @@ -38,5 +38,5 @@ FIELD measureOffset, OFF_MEASURE, uint32_t, offset to first psf measurement FIELD missingOffset, OFF_MISSING, uint32_t, offset to first missing obs -FIELD extendOffset, OFF_EXTEND, uint32_t, offset to first extended measurement +FIELD refColor, REF_COLOR, float, color of reference stars # 'flags' was called 'code' prior to 2009.02.07 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v5.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v5.d (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v5.d (revision 37067) @@ -0,0 +1,81 @@ +STRUCT Average_PS1_V5 +EXTNAME DVO_AVERAGE_PS1_V5 +TYPE BINTABLE +SIZE 184 +DESCRIPTION DVO Average Object Table + +# elements of data structure / FITS table + +FIELD R, RA, double, RA, decimal degrees +FIELD D, DEC, double, DEC, decimal degrees +FIELD dR, RA_ERR, float, RA error, arcsec +FIELD dD, DEC_ERR, float, DEC error, arcsec + +FIELD uR, U_RA, float, RA*cos(D) proper-motion, arcsec/year +FIELD uD, U_DEC, float, DEC proper-motion, arcsec/year +FIELD duR, V_RA_ERR, float, RA*cos(D) p-m error, arcsec/year +FIELD duD, V_DEC_ERR, float, DEC p-m error, arcsec/year +FIELD P, PAR, float, parallax, arcsec +FIELD dP, PAR_ERR, float, parallax error, arcsec + +FIELD Rstk, RA_STK, double, RA on stack, decimal degrees +FIELD Dstk, DEC_STK, double, DEC on stack, decimal degrees +FIELD dRstk, RA_STK_ERR, float, RA error on stack, arcsec +FIELD dDstk, DEC_STK_ERR, float, DEC error on stack, arcsec + +FIELD ChiSqAve, CHISQ_POS, float, astrometry analysis chisq +FIELD ChiSqPM, CHISQ_PM, float, astrometry analysis chisq +FIELD ChiSqPar, CHISQ_PAP, float, astrometry analysis chisq +FIELD Tmean, MEAN_EPOCH, int, mean epoch (PM,PAR ref), unix time seconds +FIELD Trange, TIME_RANGE, int, mean epoch (PM,PAR ref), unix time seconds + +FIELD psfQF, PSF_QF, float, psf coverage (bad masks) +FIELD psfQFperf, PSF_QF_PERF, float, psf coverage (all masks) + +FIELD stargal, STARGAL_SEP, float, star / galaxy separator, 1/100 arcsec +FIELD Npos, NUMBER_POS, unsigned short, number of detections used for astrometry + +# this limits us to a max of 64k measurements per object +FIELD Nmeasure, NMEASURE, unsigned short, number of psf measurements +FIELD Nmissing, NMISSING, unsigned short, number of missings +FIELD Nlensing, NLENSING, unsigned short, number of lensing measurements +FIELD Nlensobj, NLENSOBJ, unsigned short, number of lensing measurements +FIELD Nextend, NEXTEND, unsigned short, number of extended measurements + +FIELD measureOffset, OFF_MEASURE, int, offset to first psf measurement +FIELD missingOffset, OFF_MISSING, int, offset to first missing obs +FIELD lensingOffset, OFF_LENSING, int, offset to first lensing obs +FIELD lensobjOffset, OFF_LENSOBJ, int, offset to mean lensing data +FIELD extendOffset, OFF_EXTEND, int, offset to extended object entry +FIELD paramsOffset, OFF_PARAMS, int, offset to stellar parameter data + +FIELD refColorBlue, REF_COLOR_BLUE, float, color of astrometry ref stars +FIELD refColorRed, REF_COLOR_RED, float, color of astrometry ref stars + +# 'flags' was called 'code' prior to 2009.02.07 +FIELD flags, FLAGS, uint32_t, average object flags (star; ghost; etc) +FIELD photFlagsUpper, PHOTFLAGS_U, uint32_t, upper bit of 2 bit summary of per-measure photflags +FIELD photFlagsLower, PHOTFLAGS_L, uint32_t, lower bit of 2 bit summary of per-measure photflags + +# objID + catID gives a unique ID for all objects in the database +FIELD objID, OBJ_ID, unsigned int, unique ID for object in table +FIELD catID, CAT_ID, unsigned int, unique ID for table in which object was first realized +FIELD extID, EXT_ID, uint64_t, external ID for object (eg PSPS objID) +FIELD extIDgc, EXT_ID_GC, uint64_t, external ID for object in galactic coords + +# 4 double, 2 uint64_t, 17 float, 12 int, 6 short +# 4*8 + 2*8 + 17*4 + 12*4 + 6*2 = 176 +# for 5G objects, expect 840G + +# photflagsUpper & photflagsLower: we have Nmeasures of a given source +# using psphot. each of these as a photFlag field, with bits +# describing the detection quality. photflagsUpper and photFlagsLower +# represent a 2 bit value (0-3) which defines the frequency of a given +# bit in the measurements: +# for a given bit, if that bit is raised for these percentile ranges, +# the following bits are set: +# min | max | L | U +# 0% | 25% | 0 | 0 +# 25% | 50% | 1 | 0 +# 50% | 75% | 0 | 1 +# 75% | 100% | 1 | 1 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average.d (revision 37067) @@ -2,5 +2,5 @@ EXTNAME DVO_AVERAGE TYPE BINTABLE -SIZE 128 +SIZE 184 DESCRIPTION DVO Average Object Table @@ -19,4 +19,9 @@ FIELD dP, PAR_ERR, float, parallax error, arcsec +FIELD Rstk, RA_STK, double, RA on stack, decimal degrees +FIELD Dstk, DEC_STK, double, DEC on stack, decimal degrees +FIELD dRstk, RA_STK_ERR, float, RA error on stack, arcsec +FIELD dDstk, DEC_STK_ERR, float, DEC error on stack, arcsec + FIELD ChiSqAve, CHISQ_POS, float, astrometry analysis chisq FIELD ChiSqPM, CHISQ_PM, float, astrometry analysis chisq @@ -34,9 +39,17 @@ FIELD Nmeasure, NMEASURE, unsigned short, number of psf measurements FIELD Nmissing, NMISSING, unsigned short, number of missings +FIELD Nlensing, NLENSING, unsigned short, number of lensing measurements +FIELD Nlensobj, NLENSOBJ, unsigned short, number of lensing measurements FIELD Nextend, NEXTEND, unsigned short, number of extended measurements FIELD measureOffset, OFF_MEASURE, int, offset to first psf measurement FIELD missingOffset, OFF_MISSING, int, offset to first missing obs -FIELD extendOffset, OFF_EXTEND, int, offset to first extended measurement +FIELD lensingOffset, OFF_LENSING, int, offset to first lensing obs +FIELD lensobjOffset, OFF_LENSOBJ, int, offset to mean lensing data +FIELD extendOffset, OFF_EXTEND, int, offset to extended object entry +FIELD paramsOffset, OFF_PARAMS, int, offset to stellar parameter data + +FIELD refColorBlue, REF_COLOR_BLUE, float, color of astrometry ref stars +FIELD refColorRed, REF_COLOR_RED, float, color of astrometry ref stars # 'flags' was called 'code' prior to 2009.02.07 @@ -49,4 +62,5 @@ FIELD catID, CAT_ID, unsigned int, unique ID for table in which object was first realized FIELD extID, EXT_ID, uint64_t, external ID for object (eg PSPS objID) +FIELD extIDgc, EXT_ID_GC, uint64_t, external ID for object in galactic coords # this structure should only be used for internal representations @@ -56,7 +70,6 @@ # *** 20090206 : new fields : ChiSq, Npos, flags (was code, uint16_t), extID - # *** 20100331 : new fields needed to assess astrometry analysis quality: - +# *** 20140617 : new fields : Rstk, Dstk, dRstk,dDstk, Nlensing, Nlensobj, lensingOffset, lensobjOffset, refColor # photflagsUpper & photflagsLower: we have Nmeasures of a given source Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/cmf-ps1-dv4.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/cmf-ps1-dv4.d (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/cmf-ps1-dv4.d (revision 37067) @@ -0,0 +1,65 @@ +# name of structure type +STRUCT CMF_PS1_DV4 +EXTNAME CMF_PS1_DV4 +TYPE BINTABLE +SIZE 224 + +# elements of data structure / FITS table +FIELD detID, IPP_IDET, unsigned int, detection ID +FIELD X, X_PSF, float, x coord, pixels +FIELD Y, Y_PSF, float, y coord, pixels +FIELD dX, X_PSF_SIG, float, x coord error, pixels +FIELD dY, Y_PSF_SIG, float, y coord error, pixels +FIELD posangle, POSANGLE, float, Posangle at source, degrees +FIELD pltscale, PLTSCALE, float, Plate Scale at source, arcsec/pixel +FIELD M, PSF_INST_MAG, float, inst mags, mags +FIELD dM, PSF_INST_MAG_SIG, float, inst mag error, mags +FIELD Flux, PSF_INST_FLUX, float, psf flux, counts +FIELD dFlux, PSF_INST_FLUX_SIG, float, psf flux error, counts +FIELD Map, AP_MAG, float, standard aperture mag, mags +FIELD MapRaw, AP_MAG_RAW, float, raw aperture mag, mags +FIELD apRadius, AP_MAG_RADIUS, float, radius used for fit, pixels +FIELD apFlux, AP_FLUX, float, ap flux +FIELD apFluxErr, AP_FLUX_SIG, float, ap flux err +FIELD Mpeak, PEAK_FLUX_AS_MAG, float, peak flux as a mag, mags +FIELD Mcalib, CAL_PSF_MAG, float, calibrated psf mag, mags +FIELD dMcal, CAL_PSF_MAG_SIG, float, zero point scatter, mags + +# NOTE: RA & DEC (both double) need to be on an 8-byte boundary... +FIELD RA, RA_PSF, double, PSF RA coord, degrees +FIELD DEC, DEC_PSF, double, PSF DEC coord, degrees + +FIELD sky, SKY, float, sky flux, cnts/sec +FIELD dSky, SKY_SIGMA, float, sky flux error, cnts/sec +FIELD psfChisq, PSF_CHISQ, float, psf fit chisq +FIELD crNsigma, CR_NSIGMA, float, Nsigma deviations from PSF to CF +FIELD extNsigma, EXT_NSIGMA, float, Nsigma deviations from PSF to EXT +FIELD fx, PSF_MAJOR, float, psf fit major axis, pixels +FIELD fy, PSF_MINOR, float, psf fit minor axis, pixels +FIELD df, PSF_THETA, float, ellipse angle, degrees +FIELD psfQF, PSF_QF, float, quality factor +FIELD psfQFperf, PSF_QF_PERFECT, float, quality factor perfect +FIELD psfNdof, PSF_NDOF, int, psf degrees of freedom +FIELD psfNpix, PSF_NPIX, int, psf number of pixels +FIELD Mxx, MOMENTS_XX, float, second moment X, pixels^2 +FIELD Mxy, MOMENTS_XY, float, second moment Y, pixels^2 +FIELD Myy, MOMENTS_YY, float, second moment XY, pixels^2 +FIELD Mr1, MOMENTS_R1, float, first radial moment, pixels +FIELD Mrh, MOMENTS_RH, float, half radial moment, pixels^1/2 +FIELD kronFlux, KRON_FLUX, float, kron flux, counts +FIELD kronFluxErr, KRON_FLUX_ERR, float, kron flux error, counts +FIELD kronInner, KRON_FLUX_INNER, float, kron flux 1 R,D (removed dependence on average.R,D) + added: dMap, FluxAp, dFluxAp, (X,Y)off(KH,DCR,GAL) + # XXX unsigned int values are probably not being saved in the FITS file correctly: no BZERO, BSCALE Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v2.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v2.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v2.d (revision 37067) @@ -22,9 +22,9 @@ FIELD astromErrScale, ASTROM_ERR_SCALE, float, astrometric error scale FIELD astromErrMagScale, ASTROM_ERR_MAG_SCALE, float, astrometric error / mag error scale -FIELD astromPoorMask, ASTROM_POOR_MASK, short, detections matching this mask should only be used in emergencies -FIELD astromBadMask, ASTROM_BAD_MASK, short, detections matching this mask should not be used +FIELD astromPoorMask, ASTROM_POOR_MASK, unsigned short, detections matching this mask should only be used in emergencies +FIELD astromBadMask, ASTROM_BAD_MASK, unsigned short, detections matching this mask should not be used FIELD photomErrSys, PHOTOM_ERR_SYS, float, systematic photometric error -FIELD photomPoorMask, PHOTOM_POOR_MASK, short, detections matching this mask should only be used in emergencies -FIELD photomBadMask, PHOTOM_BAD_MASK, short, detections matching this mask should not be used +FIELD photomPoorMask, PHOTOM_POOR_MASK, unsigned short, detections matching this mask should only be used in emergencies +FIELD photomBadMask, PHOTOM_BAD_MASK, unsigned short, detections matching this mask should not be used # dR_total^2 = dR_sys^2 + AS * dR_obs^2 + MS * dM_obs^2 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v3.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v3.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v3.d (revision 37067) @@ -22,9 +22,9 @@ FIELD astromErrScale, ASTROM_ERR_SCALE, float, astrometric error scale FIELD astromErrMagScale, ASTROM_ERR_MAG_SCALE, float, astrometric error / mag error scale -FIELD astromPoorMask, ASTROM_POOR_MASK, int, detections matching this mask should only be used in emergencies -FIELD astromBadMask, ASTROM_BAD_MASK, int, detections matching this mask should not be used +FIELD astromPoorMask, ASTROM_POOR_MASK, unsigned int, detections matching this mask should only be used in emergencies +FIELD astromBadMask, ASTROM_BAD_MASK, unsigned int, detections matching this mask should not be used FIELD photomErrSys, PHOTOM_ERR_SYS, float, systematic photometric error -FIELD photomPoorMask, PHOTOM_POOR_MASK, int, detections matching this mask should only be used in emergencies -FIELD photomBadMask, PHOTOM_BAD_MASK, int, detections matching this mask should not be used +FIELD photomPoorMask, PHOTOM_POOR_MASK, unsigned int, detections matching this mask should only be used in emergencies +FIELD photomBadMask, PHOTOM_BAD_MASK, unsigned int, detections matching this mask should not be used # dR_total^2 = dR_sys^2 + AS * dR_obs^2 + MS * dM_obs^2 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v4.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v4.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v4.d (revision 37067) @@ -22,9 +22,9 @@ FIELD astromErrScale, ASTROM_ERR_SCALE, float, astrometric error scale FIELD astromErrMagScale, ASTROM_ERR_MAG_SCALE, float, astrometric error / mag error scale -FIELD astromPoorMask, ASTROM_POOR_MASK, int, detections matching this mask should only be used in emergencies -FIELD astromBadMask, ASTROM_BAD_MASK, int, detections matching this mask should not be used +FIELD astromPoorMask, ASTROM_POOR_MASK, unsigned int, detections matching this mask should only be used in emergencies +FIELD astromBadMask, ASTROM_BAD_MASK, unsigned int, detections matching this mask should not be used FIELD photomErrSys, PHOTOM_ERR_SYS, float, systematic photometric error -FIELD photomPoorMask, PHOTOM_POOR_MASK, int, detections matching this mask should only be used in emergencies -FIELD photomBadMask, PHOTOM_BAD_MASK, int, detections matching this mask should not be used +FIELD photomPoorMask, PHOTOM_POOR_MASK, unsigned int, detections matching this mask should only be used in emergencies +FIELD photomBadMask, PHOTOM_BAD_MASK, unsigned int, detections matching this mask should not be used # dR_total^2 = dR_sys^2 + AS * dR_obs^2 + MS * dM_obs^2 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v5.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v5.d (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v5.d (revision 37067) @@ -0,0 +1,33 @@ +STRUCT PhotCode_PS1_V5 +EXTNAME DVO_PHOTCODE_PS1_V5 +TYPE BINTABLE +SIZE 112 +DESCRIPTION DVO Photcode Description Table + +# elements of data structure / FITS table +FIELD code, CODE, unsigned short, code number (stored in Measure.source) +FIELD name, NAME, char[32], name for filter combination +FIELD type, TYPE, char, PRI/SEC/DEP/REF +FIELD dummy, DUMMY, char[3], padding +FIELD C, C_LAM, short, primary phot calibration terms (millimags) +FIELD dC, C_LAM_ERR, short, primary phot calibration terms (millimags) +FIELD dX, X_ERR, short, primary phot calibration terms (millimags) +FIELD K, K, float, secondary phot calibration terms (millimags) +FIELD c1, C1, int, color is average.M[c1] - average.M[c2] +FIELD c2, C2, int, color is average.M[c1] - average.M[c2] +FIELD equiv, EQUIV, int, this dependent filter is equivalent to equiv PRI/SEC +FIELD Nc, NC, int, number of color terms +FIELD X, X, float[4], color terms $X[0]*mc + X[1]*mc^2 + X[2]*mc^3$, etc +FIELD astromErrSys, ASTROM_ERR_SYS, float, systematic astrometry error (arcsec) +FIELD astromErrScale, ASTROM_ERR_SCALE, float, astrometric error scale +FIELD astromErrMagScale, ASTROM_ERR_MAG_SCALE, float, astrometric error / mag error scale +FIELD astromPoorMask, ASTROM_POOR_MASK, unsigned int, detections matching this mask should only be used in emergencies +FIELD astromBadMask, ASTROM_BAD_MASK, unsigned int, detections matching this mask should not be used +FIELD photomErrSys, PHOTOM_ERR_SYS, float, systematic photometric error +FIELD photomPoorMask, PHOTOM_POOR_MASK, unsigned int, detections matching this mask should only be used in emergencies +FIELD photomBadMask, PHOTOM_BAD_MASK, unsigned int, detections matching this mask should not be used + +# dR_total^2 = dR_sys^2 + AS * dR_obs^2 + MS * dM_obs^2 +# dR_sys : systematicAstrometryError +# AS : astrometryErrorScale +# MS : astrometryErrorMagScale Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode.d (revision 37067) @@ -22,9 +22,9 @@ FIELD astromErrScale, ASTROM_ERR_SCALE, float, astrometric error scale FIELD astromErrMagScale, ASTROM_ERR_MAG_SCALE, float, astrometric error / mag error scale -FIELD astromPoorMask, ASTROM_POOR_MASK, int, detections matching this mask should only be used in emergencies -FIELD astromBadMask, ASTROM_BAD_MASK, int, detections matching this mask should not be used +FIELD astromPoorMask, ASTROM_POOR_MASK, unsigned int, detections matching this mask should only be used in emergencies +FIELD astromBadMask, ASTROM_BAD_MASK, unsigned int, detections matching this mask should not be used FIELD photomErrSys, PHOTOM_ERR_SYS, float, systematic photometric error -FIELD photomPoorMask, PHOTOM_POOR_MASK, int, detections matching this mask should only be used in emergencies -FIELD photomBadMask, PHOTOM_BAD_MASK, int, detections matching this mask should not be used +FIELD photomPoorMask, PHOTOM_POOR_MASK, unsigned int, detections matching this mask should only be used in emergencies +FIELD photomBadMask, PHOTOM_BAD_MASK, unsigned int, detections matching this mask should not be used # dR_total^2 = dR_sys^2 + AS * dR_obs^2 + MS * dM_obs^2 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v1.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v1.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v1.d (revision 37067) @@ -6,9 +6,9 @@ # elements of data structure / FITS table -FIELD M, MAG, float, average mag in this band, mags -FIELD dM, MAG_ERR, float, error on average mag, mags -FIELD Xm, MAG_CHI, float, chisq on average mag, [100*log(value)] -FIELD Ncode, NCODE, short, number of detections in band -FIELD Nused, NUSED, short, number of detections used in average -FIELD M_20, MAG_20, short, lower 20percent mag, millimags -FIELD M_80, MAG_80, short, upper 20percent mag, millimags +FIELD M, MAG, float, average mag in this band, mags +FIELD dM, MAG_ERR, float, error on average mag, mags +FIELD Mchisq, MAG_CHI, float, chisq on average mag, value +FIELD Ncode, NCODE, short, number of detections in band +FIELD Nused, NUSED, short, number of detections used in average +FIELD M_20, MAG_20, short, lower 20percent mag, millimags +FIELD M_80, MAG_80, short, upper 20percent mag, millimags Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v2.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v2.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v2.d (revision 37067) @@ -6,10 +6,10 @@ # elements of data structure / FITS table -FIELD M, MAG, float, average mag in this band, mags -FIELD dM, MAG_ERR, float, error on average mag, mags -FIELD Xm, MAG_CHI, float, chisq on average mag, [100*log(value)] -FIELD flags, FLAGS, uint32_t, photometry flags -FIELD Ncode, NCODE, short, number of detections in band -FIELD Nused, NUSED, short, number of detections used in average -FIELD M_20, MAG_20, short, lower 20percent mag, millimags -FIELD M_80, MAG_80, short, upper 20percent mag, millimags +FIELD M, MAG, float, average mag in this band, mags +FIELD dM, MAG_ERR, float, error on average mag, mags +FIELD Mchisq, MAG_CHI, float, chisq on average mag, value +FIELD flags, FLAGS, uint32_t, photometry flags +FIELD Ncode, NCODE, short, number of detections in band +FIELD Nused, NUSED, short, number of detections used in average +FIELD M_20, MAG_20, short, lower 20percent mag, millimags +FIELD M_80, MAG_80, short, upper 20percent mag, millimags Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v3.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v3.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v3.d (revision 37067) @@ -9,5 +9,5 @@ FIELD Map, MAG_AP, float, ave aperture mag in this band, mags FIELD dM, MAG_ERR, float, formal error on average mag, mags -FIELD Xm, MAG_CHI, float, chisq on average mag, [100*log(value)] +FIELD Mchisq, MAG_CHI, float, chisq on average mag, value FIELD flags, FLAGS, uint32_t, photometry flags FIELD Ncode, NCODE, short, number of detections in band Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v4.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v4.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v4.d (revision 37067) @@ -11,5 +11,5 @@ FIELD dMkron, MAG_KRON_ERR, float, formal error on average kron mag, mags FIELD dM, MAG_ERR, float, formal error on average mag, mags -FIELD Xm, MAG_CHI, float, chisq on average mag, [100*log(value)] +FIELD Mchisq, MAG_CHI, float, chisq on average mag, value FIELD FluxPSF, FLUX_PSF, float, mean flux psf fit (PS1: stack) FIELD dFluxPSF, FLUX_PSF_ERR, float, mean flux psf error Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v5.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v5.d (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v5.d (revision 37067) @@ -0,0 +1,71 @@ +STRUCT SecFilt_PS1_V5 +EXTNAME DVO_SECFILT_PS1_V5 +TYPE BINTABLE +SIZE 160 +DESCRIPTION DVO SecFilt : Secondary Filter Data + +## *** this section is for per-exposure mean values *** (unlabled values are implicitly PSF values) +FIELD M, MAG, float, average mag in this band, mags +FIELD dM, MAG_ERR, float, formal error on average mag, mags +FIELD Map, MAG_AP, float, ave aperture mag in this band, mags +FIELD dMap, MAG_AP_ERR, float, ave aperture mag in this band, mags +FIELD sMap, MAG_AP_STDEV, float, standard deviation of ap mags, mags +FIELD Mkron, MAG_KRON, float, ave kron mag in this band, mags +FIELD dMkron, MAG_KRON_ERR, float, formal error on average kron mag, mags +FIELD sMkron, MAG_KRON_STDEV, float, standard deviation of kron mags, mags + +# these statistics are PSF-specific +FIELD Mstdev, MAG_STDEV, float, standard deviation of measurements, mags +FIELD Mmin, MAG_MIN, float, min accepted mag, mags +FIELD Mmax, MAG_MAX, float, max accepted mag, mags +FIELD Mchisq, MAG_CHI, float, chisq on average mag, value + +FIELD Ncode, NCODE, short, number of detections in band +FIELD Nused, NUSED, short, number of detections used in average +FIELD NusedKron, NUSED_KRON, short, number of detections used in average +FIELD NusedAp, NUSED_AP, short, number of detections used in average + +FIELD flags, FLAGS, uint32_t, photometry flags + +## *** this section is for stack values *** + +FIELD MpsfStk, MAG_PSF_STK, float, magnitude from stack (primary if available) +FIELD FpsfStk, FLUX_PSF_STK, float, flux from stack (primary if available) +FIELD dFpsfStk, FLUX_PSF_STK_ERR, float, mean flux psf error + +FIELD MkronStk, MAG_KRON_STK, float, magnitude from stack (primary if available) +FIELD FkronStk, FLUX_KRON_STK, float, flux from stack (primary if available) +FIELD dFkronStk, FLUX_KRON_STK_ERR, float, mean flux kron error + +FIELD MapStk, MAG_AP_STK, float, magnitude from stack (primary if available) +FIELD FapStk, FLUX_AP_STK, float, flux from stack (primary if available) +FIELD dFapStk, FLUX_AP_STK_ERR, float, mean flux ap error + +## need an 8-byte boundary here ## +FIELD stackDetectID, STACK_DETECT_ID, uint64_t, detection ID on stack used for fluxes (if any) + +## *** this section is for forced-warp mean values *** + +FIELD MpsfWrp, MAG_PSF_WRP, float, psf magnitude from stack (primary if available) +FIELD FpsfWrp, FLUX_PSF_WRP, float, psf flux from stack (primary if available) +FIELD dFpsfWrp, FLUX_PSF_WRP_ERR, float, mean flux psf error +FIELD sFpsfWrp, FLUX_PSF_WRP_STD, float, mean flux psf stdev + +FIELD MkronWrp, MAG_KRON_WRP, float, kron magnitude from stack (primary if available) +FIELD FkronWrp, FLUX_KRON_WRP, float, kron flux from stack (primary if available) +FIELD dFkronWrp, FLUX_KRON_WRP_ERR, float, mean flux kron error +FIELD sFkronWrp, FLUX_KRON_WRP_STD, float, mean flux kron stdev + +FIELD MapWrp, MAG_AP_WRP, float, aper magnitude from stack (primary if available) +FIELD FapWrp, FLUX_AP_WRP, float, aper flux from stack (primary if available) +FIELD dFapWrp, FLUX_AP_WRP_ERR, float, mean flux ap error +FIELD sFapWrp, FLUX_AP_WRP_STD, float, mean flux ap stdev + +FIELD NusedWrp, NUSED_WRP, short, number of detections used in average +FIELD NusedKronWrp, NUSED_KRON_WRP, short, number of detections used in average +FIELD NusedApWrp, NUSED_AP_WRP, short, number of detections used in average + +FIELD ubercalDist, UBERCAL_DIST, short, number of images from an ubercal-image + +# 31*float + uint32_t + uint64_t + 8*short = 152 bytes / object / photcode +# for 5G objects, expect ~6TB total (over 60 machines, this is 100G) Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt.d =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt.d (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt.d (revision 37067) @@ -2,28 +2,75 @@ EXTNAME DVO_SECFILT TYPE BINTABLE -SIZE 64 +SIZE 160 DESCRIPTION DVO SecFilt : Secondary Filter Data -# elements of data structure / FITS table +## *** this section is for per-exposure mean values *** (unlabled values are implicitly PSF values) FIELD M, MAG, float, average mag in this band, mags +FIELD dM, MAG_ERR, float, formal error on average mag, mags FIELD Map, MAG_AP, float, average mag in this band, mags +FIELD dMap, MAG_AP_ERR, float, formal error on average mag, mags +FIELD sMap, MAG_AP_STDEV, float, standard deviation of ap mags, mags FIELD Mkron, MAG_KRON, float, ave kron mag in this band, mags FIELD dMkron, MAG_KRON_ERR, float, formal error on average kron mag, mags -FIELD dM, MAG_ERR, float, formal error on average mag, mags -FIELD Xm, MAG_CHI, float, chisq on average mag, [100*log(value)] -FIELD FluxPSF, FLUX_PSF, float, mean flux psf fit (PS1: stack) -FIELD dFluxPSF, FLUX_PSF_ERR, float, mean flux psf error -FIELD FluxKron, FLUX_KRON, float, mean flux kron ap (PS1: stack) -FIELD dFluxKron, FLUX_KRON_ERR, float, mean flux kron err -FIELD flags, FLAGS, uint32_t, photometry flags +FIELD sMkron, MAG_KRON_STDEV, float, standard deviation of kron mags, mags + +# these statistics are PSF-specific +FIELD Mstdev, MAG_STDEV, float, standard deviation of measurements, mags +FIELD Mmin, MAG_MIN, float, minimum accepted mag, mags +FIELD Mmax, MAG_MAX, float, maximum accepted mag, mags +FIELD Mchisq, MAG_CHI, float, chisq on average mag, value + FIELD Ncode, NCODE, short, number of detections in band FIELD Nused, NUSED, short, number of detections used in average -FIELD M_20, MAG_20, short, lower 20percent mag, millimags -FIELD M_80, MAG_80, short, upper 20percent mag, millimags +FIELD NusedKron, NUSED_KRON, short, number of detections used in average +FIELD NusedAp, NUSED_AP, short, number of detections used in average + +FIELD flags, FLAGS, uint32_t, photometry flags + +## *** this section is for stack values *** + +FIELD MpsfStk, MAG_PSF_STK, float, magnitude from stack (primary if available) +FIELD FpsfStk, FLUX_PSF_STK, float, flux from stack (primary if available) +FIELD dFpsfStk, FLUX_PSF_STK_ERR, float, mean flux psf error + +FIELD MkronStk, MAG_KRON_STK, float, magnitude from stack (primary if available) +FIELD FkronStk, FLUX_KRON_STK, float, flux from stack (primary if available) +FIELD dFkronStk, FLUX_KRON_STK_ERR, float, mean flux kron error + +FIELD MapStk, MAG_AP_STK, float, magnitude from stack (primary if available) +FIELD FapStk, FLUX_AP_STK, float, flux from stack (primary if available) +FIELD dFapStk, FLUX_AP_STK_ERR, float, mean flux ap error + +## need an 8-byte boundary here ## +FIELD stackDetectID, STACK_DETECT_ID, uint64_t, detection ID on stack used for fluxes (if any) + +## *** this section is for forced-warp mean values *** + +FIELD MpsfWrp, MAG_PSF_WRP, float, psf magnitude from stack (primary if available) +FIELD FpsfWrp, FLUX_PSF_WRP, float, psf flux from stack (primary if available) +FIELD dFpsfWrp, FLUX_PSF_WRP_ERR, float, mean flux psf error +FIELD sFpsfWrp, FLUX_PSF_WRP_STD, float, mean flux psf stdev + +FIELD MkronWrp, MAG_KRON_WRP, float, kron magnitude from stack (primary if available) +FIELD FkronWrp, FLUX_KRON_WRP, float, kron flux from stack (primary if available) +FIELD dFkronWrp, FLUX_KRON_WRP_ERR, float, mean flux kron error +FIELD sFkronWrp, FLUX_KRON_WRP_STD, float, mean flux kron stdev + +FIELD MapWrp, MAG_AP_WRP, float, aper magnitude from stack (primary if available) +FIELD FapWrp, FLUX_AP_WRP, float, aper flux from stack (primary if available) +FIELD dFapWrp, FLUX_AP_WRP_ERR, float, mean flux ap error +FIELD sFapWrp, FLUX_AP_WRP_STD, float, mean flux ap stdev + +FIELD NusedWrp, NUSED_WRP, short, number of detections used in average +FIELD NusedKronWrp, NUSED_KRON_WRP, short, number of detections used in average +FIELD NusedApWrp, NUSED_AP_WRP, short, number of detections used in average + FIELD ubercalDist, UBERCAL_DIST, short, number of images from an ubercal-image -FIELD Mstdev, MAG_STDEV, short, standard deviation of measurements, millimags -FIELD stackDetectID, STACK_DETECT_ID, uint64_t, detection ID on stack used for fluxes (if any) # *** 20090206 : new fields : M_20, M_80; dropped dummy # *** 20120302 : new fields : ubercalDist, Map, Mstdev # *** 20120710 : new fields : Mkron, dMkron, FluxPSF, dFluxPSF, FluxKron, dFluxKron, stackID + +# *** 20140617 : added : dMap, NusedKron, NusedAp, MpsfStk, MkronStk, MapStk, *Wrp + : changed : Mstdev, M_20 (to Mmin,short:float),M_80 (to Mmax,short:float), + : rename : FpsfStk, dFpsfStk, FkronStk, dFronStk (were FluxPSF, dFluxPSF, FluxKron, dFluxKron) Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/doc/sizes.ps1-v5.txt =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/doc/sizes.ps1-v5.txt (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/doc/sizes.ps1-v5.txt (revision 37067) @@ -0,0 +1,13 @@ + +Here are the expected totals for PV1_V5 (LAP PV2): + +Camera detections : 122G [measured from gpc1 database directly, removing factor of 2 error] +Stack objects: 2.5G [measured from a random sample of skycells] +Total objects: 5.0G [generous guess] + +average: 168 byte / object * 5G = 840G +secfilt: 152 byte / object / photcode * 9 (grizywJHK) * 5G = 6840G +measure: 232 byte / detect * 122G det [camera] = 28304G + 232 byte / detect * 2.5G obj * 85 det [warp] = 49300G +lensing: 128 byte / detect * 2.5G obj * 85 det [warp] = 27200G +lensobj: 136 byte / object / photcode * 2.5G obj * 5 (grizy) = 1700G Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/Makefile (revision 37067) @@ -36,6 +36,10 @@ $(DESTINC)/ps1_v3_defs.h \ $(DESTINC)/ps1_v4_defs.h \ +$(DESTINC)/ps1_v5_defs.h \ $(DESTINC)/ps1_ref_defs.h \ -$(DESTINC)/cmf-ps1-dv3.h +$(DESTINC)/cmf-ps1-dv3.h \ +$(DESTINC)/cmf-ps1-v5.h \ +$(DESTINC)/cmf-ps1-sv3.h \ +$(DESTINC)/cmf-ps1-v5-lensing.h INCS = $(DEFS) $(DESTINC)/dvo.h $(DESTINC)/autocode.h $(DESTINC)/dvo_util.h $(DESTINC)/dvodb.h $(DESTINC)/libdvo_astro.h $(DESTINC)/convert.h $(DESTINC)/get_graphdata.h @@ -76,4 +80,5 @@ $(SRC)/dvo_convert_PS1_V3.$(ARCH).o \ $(SRC)/dvo_convert_PS1_V4.$(ARCH).o \ +$(SRC)/dvo_convert_PS1_V5.$(ARCH).o \ $(SRC)/dvo_convert_PS1_REF.$(ARCH).o \ $(SRC)/flatcorr_io.$(ARCH).o \ @@ -86,4 +91,7 @@ $(SRC)/cmf-ps1-sv1-alt.$(ARCH).o \ $(SRC)/cmf-ps1-dv3.$(ARCH).o \ +$(SRC)/cmf-ps1-sv3.$(ARCH).o \ +$(SRC)/cmf-ps1-v5.$(ARCH).o \ +$(SRC)/cmf-ps1-v5-lensing.$(ARCH).o \ $(SRC)/dvo_util.$(ARCH).o \ $(SRC)/dbBooleanCond.$(ARCH).o \ @@ -103,10 +111,11 @@ $(SRC)/ImageMetadata.$(ARCH).o \ $(SRC)/ImageOps.$(ARCH).o \ +$(SRC)/RegionHostTable.$(ARCH).o \ $(SRC)/match_image.$(ARCH).o \ $(SRC)/db_utils.$(ARCH).o \ $(SRC)/convert.$(ARCH).o \ $(SRC)/HostTable.$(ARCH).o \ -$(SRC)/BoundaryTree.$(ARCH).o - +$(SRC)/BoundaryTree.$(ARCH).o \ +$(SRC)/TessellationTable.$(ARCH).o # $(SRC)/dvo_convert_panstarrs.$(ARCH).o Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/doc/notes.ps1v5.txt =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/doc/notes.ps1v5.txt (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/doc/notes.ps1v5.txt (revision 37067) @@ -0,0 +1,27 @@ + +changes to make: + +Average: add: Rstk, Dstk, dRstk,dDstk, Nlensing, Nlensobj, lensingOffset, lensobjOffset, refColor +Measure: mod: dR,dD -> R,D (change Measure_*_ToInteral to pass Average) + add: dMap, FluxAp, dFluxAp, (X,Y)off(KH,DCR,GAL) +SecFilt: add: dMap, NusedKron, NusedAp, MpsfStk, MkronStk, MapStk, *Wrp + mod: Mstdev, M_20 (to Mmin,short:float),M_80 (to Mmax,short:float), + mod: FpsfStk, dFpsfStk, FkronStk, dFronStk (were FluxPSF, dFluxPSF, FluxKron, dFluxKron) + +name changes: +Measure: +dR,dD -> R,D (done) +SecFilt + out[i].FpsfStk = in[i].FluxPSF; + out[i].dFpsfStk = in[i].dFluxPSF; + out[i].FkronStk = in[i].FluxKron; + out[i].dFkronStk = in[i].dFluxKron; + out[i].Mmin = in[i].M_20*0.001; + out[i].Mmax = in[i].M_80*0.001; + + out[i].FluxPSF = in[i].FpsfStk; + out[i].dFluxPSF = in[i].dFpsfStk; + out[i].FluxKron = in[i].FkronStk; + out[i].dFluxKron = in[i].dFkronStk; + out[i].M_20 = in[i].Mmin*1000.0; + out[i].M_80 = in[i].Mmax*1000.0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/cmf-ps1-sv3.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/cmf-ps1-sv3.h (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/cmf-ps1-sv3.h (revision 37067) @@ -0,0 +1,66 @@ + +/** STRUCT DEFINITION **/ +typedef struct { + unsigned int detID; // detection ID + float X; // x coord (pixels) + float Y; // y coord (pixels) + float dX; // x coord error (pixels) + float dY; // y coord error (pixels) + float posangle; // Posangle at source (degrees) + float pltscale; // Plate Scale at source (arcsec/pixel) + float M; // inst mags (mags) + float dM; // inst mag error (mags) + float Flux; // psf flux (counts) + float dFlux; // psf flux error (counts ) + float Map; // standard aperture mag (mags) + float MapRaw; // raw aperture mag (mags) + float apRadius; // radius used for fit (pixels) + float apFlux; // aperture flux (counts) + float apFluxErr; // error on ap flux (counts) + int apNpix; // pixels used for aper + float Mcalib; // calibrated psf mag (mags) + float dMcal; // zero point scatter (mags) + float Mpeak; // peak flux as a mag (mags) + double RA; // PSF RA coord (degrees) + double DEC; // PSF DEC coord (degrees) + float sky; // sky flux (cnts/sec) + float dSky; // sky flux error (cnts/sec) + float psfChisq; // psf fit chisq + float crNsigma; // Nsigma deviations from PSF to CF + float extNsigma; // Nsigma deviations from PSF to EXT + float fx; // psf fit major axis (pixels) + float fy; // psf fit minor axis (pixels) + float df; // ellipse angle (degrees) + float k; // extra PSF parameter (unitless) + float fwhmMaj; // true fwhm of psf (pixels) + float fwhmMin; // true fwhm (minor) (pixels) + float psfQF; // quality factor + float psfQFperf; // quality factor perfect + int psfNdof; // psf degrees of freedom + int psfNpix; // psf number of pixels + float Mxx; // second moment X (pixels^2) + float Mxy; // second moment Y (pixels^2) + float Myy; // second moment XY (pixels^2) + float M3c; // third moment cos(t) (pixels^3) + float M3s; // third moment sin(t) (pixels^3) + float M4c; // fourth moment cos(t) (pixels^4) + float M4s; // fourth moment sin(t) (pixels^4) + float Mr1; // first radial moment (pixels) + float Mrh; // half radial moment (pixels^1/2) + float kronFlux; // kron flux (counts) + float kronFluxErr; // kron flux error (counts) + float kronInner; // kron flux 1= Rmin + double Rmax; // this tessellation is valid only for RA < Rmax + double Dmin; // this tessellation is valid only for DEC >= Dmin + double Dmax; // this tessellation is valid only for DEC < Dmax + + double Xo; + double Yo; + double Ro; + double Do; + double dPix; + int dX; + int dY; + + int NX_SUB; + int NY_SUB; + + char *basename; + int Nbasename; + int projectIDoff; + int skycellIDoff; + + TessType type; // + BoundaryTree *tree; +} TessellationTable; // a reduced-subset structure for relphot @@ -360,10 +434,12 @@ uint32_t flags; int catID; + int objID; + int nOwn; } AverageTiny; // a reduced-subset structure for relphot & relastro typedef struct { - float dR; - float dD; + double R; + double D; float M; float Mcal; @@ -385,5 +461,101 @@ short dYccd; short dRsys; + char myDet; } MeasureTiny; + +/** STRUCT DEFINITION **/ +typedef struct { + double R; // RA (decimal degrees ) + double D; // DEC (decimal degrees ) + float dR; // RA error (arcsec) + float dD; // DEC error (arcsec) + float uR; // RA*cos(D) proper-motion (arcsec/year) + float uD; // DEC proper-motion (arcsec/year) + float duR; // RA*cos(D) p-m error (arcsec/year) + float duD; // DEC p-m error (arcsec/year) + float P; // parallax (arcsec) + float dP; // parallax error (arcsec) + float ChiSqAve; // astrometry analysis chisq + float ChiSqPM; // astrometry analysis chisq + float ChiSqPar; // astrometry analysis chisq + int Tmean; // mean epoch (PM,PAR ref) (unix time seconds) + int Trange; // mean epoch (PM,PAR ref) (unix time seconds) + float Xp; // unused + unsigned short Npos; // number of detections used for astrometry + unsigned short Nmeasure; // number of psf measurements + unsigned short Nmissing; // number of missings + unsigned short Nextend; // number of extended measurements + uint32_t measureOffset; // offset to first psf measurement + uint32_t missingOffset; // offset to first missing obs + float refColor; // offset to first extended measurement + uint32_t flags; // average object flags (star; ghost; etc) + uint32_t photFlagsUpper; // upper bit of 2 bit summary of per-measure photflags + uint32_t photFlagsLower; // lower bit of 2 bit summary of per-measure photflags + unsigned int objID; // unique ID for object in table + unsigned int catID; // unique ID for table in which object was first realized + uint64_t extID; // external ID for object (eg PSPS objID) +} Average_PS1_V4alt; + +Average_PS1_V4alt *gfits_table_get_Average_PS1_V4alt (FTable *table, off_t *Ndata, char *swapped); +Average *Average_PS1_V4alt_ToInternal (Average_PS1_V4alt *in, off_t Nvalues); + +/** STRUCT DEFINITION **/ +typedef struct { + float dR; // RA offset (arcsec) + float dD; // DEC offset (arcsec) + float M; // catalog mag (mag) + float Mcal; // image cal mag (mag) + float Map; // aperture mag (mag) + float Mkron; // kron magnitude (mag) + float dMkron; // kron magnitude error (mag) + float dM; // mag error (mag) + float dMcal; // systematic calibration error (mag) + float dt; // exposure time (2.5*log(exptime)) + float FluxPSF; // flux from psf fit (counts/sec?) + float dFluxPSF; // error on psf flux (counts/sec?) + float FluxKron; // flux from kron ap (counts/sec?) + float dFluxKron; // error on kron flux (counts/sec?) + float airmass; // (airmass - 1) (airmass) + float az; // telescope azimuth + float Xccd; // X coord on chip (raw value) (pixels) + float Yccd; // Y coord on chip (raw value) (pixels) + float Sky; // local estimate of sky flux (counts/sec) + float dSky; // local estimate of sky flux (counts/sec) + int t; // time in seconds (UNIX) + unsigned int averef; // reference to average entry + unsigned int detID; // detection ID + unsigned int imageID; // reference to DVO image ID + unsigned int objID; // unique ID for object in table + unsigned int catID; // unique ID for table in which object was first realized + uint64_t extID; // external ID (eg PSPS detID) + float psfQF; // psf coverage/quality factor + float psfQFperf; // psf coverage / quality factor (all mask bits) + float psfChisq; // psf fit chisq + int psfNdof; // psf degrees of freedom + int psfNpix; // psf number of pixels + float crNsigma; // Nsigma deviation towards CR + float extNsigma; // Nsigma deviation towards EXT + short FWx; // object fwhm major axis (1/100 of pixels) + short FWy; // object fwhm minor axis (1/100 of pixels ) + short theta; // angle wrt ccd X dir ((0xffff/360) deg) + short Mxx; // second moments in pixel coords (1/100 of pixels) + short Mxy; // second moments in pixel coords (1/100 of pixels) + short Myy; // second moments in pixel coords (1/100 of pixels) + unsigned short t_msec; // time fraction of second (milliseconds) + unsigned short photcode; // photcode + short dXccd; // X coord error on chip (1/100 of pixels) + short dYccd; // Y coord error on chip (1/100 of pixels) + short dRsys; // systematic error from astrom (1/100 of pixels) + short posangle; // position angle sky to chip ((0xffff/360) deg) + float pltscale; // plate scale (arcsec/pixel) + unsigned int dbFlags; // flags supplied by analysis in database + unsigned int photFlags; // flags supplied by photometry program +} Measure_PS1_V4alt; + +Measure_PS1_V4alt *gfits_table_get_Measure_PS1_V4alt (FTable *table, off_t *Ndata, char *swapped); +Measure *Measure_PS1_V4alt_ToInternal (Average *ave, Measure_PS1_V4alt *in, off_t Nvalues); + +/* for some reason I have merged the set of tables and the file description, + so I need to have an internal structure to point to the separate files */ /* a catalog contains this data */ @@ -399,8 +571,12 @@ SecFilt *secfilt; + // lensing data (optional?) + Lensing *lensing; + Lensobj *lensobj; + int Nsecfilt; /* number of secfilt entries for each average entry */ - off_t Naverage, Nmeasure, Nmissing, Nsecf_mem; /* current number of each component in memory */ - off_t Naves_disk, Nmeas_disk, Nmiss_disk, Nsecf_disk; /* current number of each component on disk */ - off_t Naves_off, Nmeas_off, Nmiss_off, Nsecf_off; /* index of first loaded data value */ + off_t Naverage, Nmeasure, Nmissing, Nlensing, Nlensobj, Nsecf_mem; /* current number of each component in memory */ + off_t Naves_disk, Nmeas_disk, Nmiss_disk, Nlensing_disk, Nlensobj_disk, Nsecf_disk; /* current number of each component on disk */ + off_t Naves_off, Nmeas_off, Nmiss_off, Nlensing_off, Nlensobj_off, Nsecf_off; /* index of first loaded data value */ // note that we use these for the full-sky relphot analysis @@ -421,4 +597,6 @@ struct Catalog *missing_catalog; /* missing catalog data (split) */ struct Catalog *secfilt_catalog; /* secfilt catalog data (split) */ + struct Catalog *lensing_catalog; /* lensing catalog data (split) */ + struct Catalog *lensobj_catalog; /* lensobj catalog data (split) */ unsigned int objID; @@ -429,13 +607,16 @@ char catmode; /* storage mode (raw, mef, split, mysql) */ char catformat; /* storage format (elixir, panstarrs, etc) */ - char catflags; /* choices to be loaded */ - char sorted; /* is measure table average-sorted? */ + int sorted; /* is measure table average-sorted? (NOTE this is an int only because gfits_scan %t requires it) */ + short catflags; /* choices to be loaded */ + /* pointers for data manipulation */ - off_t *found; - off_t *image; - off_t *mosaic; - float *X; - float *Y; + off_t *found_t; + off_t *foundWarp_t; +// off_t *image_t; +// off_t *mosaic_t; +// float *X_t; +// float *Y_t; + int *nOwn_t; // relastro uses this to count owned detections per object } Catalog; @@ -497,30 +678,43 @@ char *GetPhotcodeNamebyCode (int code); -float PhotInst (Measure *measure); -float PhotCat (Measure *measure); -float PhotAper (Measure *measure); -float PhotKron (Measure *measure); -float PhotSys (Measure *measure, Average *average, SecFilt *secfilt); -float PhotRel (Measure *measure, Average *average, SecFilt *secfilt); -float PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code); -float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt); -float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure); +float PhotInst (Measure *measure, dvoMagClassType class); +float PhotCat (Measure *measure, dvoMagClassType class); +float PhotSys (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class); +float PhotRel (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class); +float PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code, dvoMagClassType class); +float PhotErr (Measure *measure, dvoMagClassType class); +float PhotCalErr (Measure *measure, dvoMagClassType class); + +float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source); +float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure, dvoMagClassType class, dvoMagSourceType source); +float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source); + +float PhotInstTiny (MeasureTiny *measure, dvoMagClassType class); +float PhotCatTiny (MeasureTiny *measure, dvoMagClassType class); +float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class); +float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class); +float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code, dvoMagClassType class); + +float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source); +float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, dvoMagClassType class, dvoMagSourceType source); + +float PhotFluxInst (Measure *measure, dvoMagClassType class); +float PhotFluxCat (Measure *measure, dvoMagClassType class); +float PhotFluxSys (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class); +float PhotFluxRel (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class); +float PhotFluxCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code, dvoMagClassType class); + +float PhotFluxAve (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source); +float PhotFluxRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure, dvoMagClassType class, dvoMagSourceType source); + +float PhotFluxInstErr (Measure *measure, dvoMagClassType class); +float PhotFluxCatErr (Measure *measure, dvoMagClassType class); + float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt); -float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt); - -float PhotAperInst (Measure *measure); -float PhotKronInst (Measure *measure); -float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt); -float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt); - float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt); -float PhotAveFluxPSF (PhotCode *code, Average *average, SecFilt *secfilt); -float PhotAvedFluxPSF (PhotCode *code, Average *average, SecFilt *secfilt); -float PhotAveFluxKron (PhotCode *code, Average *average, SecFilt *secfilt); -float PhotAvedFluxKron (PhotCode *code, Average *average, SecFilt *secfilt); float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt); -float PhotM20 (PhotCode *code, Average *average, SecFilt *secfilt); -float PhotM80 (PhotCode *code, Average *average, SecFilt *secfilt); +float PhotMmin (PhotCode *code, Average *average, SecFilt *secfilt); +float PhotMmax (PhotCode *code, Average *average, SecFilt *secfilt); float PhotUCdist (PhotCode *code, Average *average, SecFilt *secfilt); unsigned int PhotStackID (PhotCode *code, Average *average, SecFilt *secfilt); @@ -529,12 +723,4 @@ int PhotColor (Average *average, SecFilt *secfilt, Measure *measure, int c1, int c2, double *color); -float PhotInstTiny (MeasureTiny *measure); -float PhotCatTiny (MeasureTiny *measure); -float PhotAperTiny (MeasureTiny *measure); -float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt); -float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt); -float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code); -float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt); -float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure); float PhotXmTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt); float PhotdMTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt); @@ -607,8 +793,8 @@ /*** conversion functions / I/O conversions ***/ Average *ReadRawAverage (FILE *f, off_t Naverage, char format, SecFilt **primary); -Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format); +Measure *ReadRawMeasure (FILE *f, Average *average, off_t Nmeasure, char format); SecFilt *ReadRawSecFilt (FILE *f, off_t Nsecfilt, char format); int WriteRawAverage (FILE *f, Average *average, off_t Naverage, char format, SecFilt *primary); -int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format); +int WriteRawMeasure (FILE *f, Average *average, Measure *measure, off_t Nmeasure, char format); int WriteRawSecFilt (FILE *f, SecFilt *secfilt, off_t Nsecfilt, char format); @@ -616,11 +802,15 @@ Average *FtableToAverage (FTable *ftable, off_t *Naverage, char *format, SecFilt **primary); -Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format); +Measure *FtableToMeasure (FTable *ftable, Average *average, off_t *Nmeasure, char *format); SecFilt *FtableToSecFilt (FTable *ftable, off_t *Nsecfilt, char *format); +Lensing *FtableToLensing (FTable *ftable, off_t *Nlensing, char *format); +Lensobj *FtableToLensobj (FTable *ftable, off_t *Nlensobj, char *format); int FtableToImage (FTable *ftable, Header *theader, char *format); int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, char format, SecFilt *primary); -int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format); +int MeasureToFtable (FTable *ftable, Average *average, Measure *measure, off_t Nmeasure, char format); int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, char format); +int LensingToFtable (FTable *ftable, Lensing *lensing, off_t Nlensing, char format); +int LensobjToFtable (FTable *ftable, Lensobj *lensobj, off_t Nlensobj, char format); int ImageToFtable (FTable *ftable, Header *theader, char format); int ImageToVtable (VTable *vtable, Header *theader, char format); @@ -637,4 +827,5 @@ # include "ps1_v3_defs.h" # include "ps1_v4_defs.h" +# include "ps1_v5_defs.h" # include "ps1_ref_defs.h" @@ -696,4 +887,5 @@ void sort_coords_index (double *X, double *Y, off_t *S, off_t N); void sort_coords_indexonly (double *X, double *Y, off_t *S, off_t N); +void sort_IDs_indexonly (opihi_int *X, off_t *S, off_t N); void sort_regions (SkyRegion *region, off_t N); @@ -716,8 +908,22 @@ int free_tiny_values (Catalog *catalog); +BoundaryTree *BoundaryTreeLoad(char *filename); +BoundaryTree *BoundaryTreeRead(Header *headerPHU, Header *headerZone, FILE *f); + +int BoundaryTreeSave(char *filename, BoundaryTree *tree); +int BoundaryTreeWrite(FILE *f, BoundaryTree *tree); + int BoundaryTreeCellCoords (BoundaryTree *tree, int *zone, int *band, double ra, double dec); -int BoundaryTreeSave(char *filename, BoundaryTree *tree); -BoundaryTree *BoundaryTreeLoad(char *filename); int BoundaryTreeProjection (double *x, double *y, double r, double d, BoundaryTree *tree, int zone, int band); + +TessellationTable *TessellationTableLoad(char *filename, int *Ntess); +int TessellationTableSave(char *filename, TessellationTable *tess, int Ntess); +int TessellationPrimaryCellIDs (TessellationTable *tess, int Ntess, int *tessID, int *projID, int *skycellID, double ra, double dec); +void TessellationTableInit (TessellationTable *tess, int Ntess); + +float dvoOffsetR (Measure *measure, Average *average); +float dvoOffsetD (Measure *measure, Average *average); +double dvoMeanR (float dR, Average *average); +double dvoMeanD (float dD, Average *average); void dvo_average_init (Average *average); @@ -727,3 +933,14 @@ void dvo_measureT_init (MeasureTiny *measure); +void dvo_lensing_init (Lensing *lensing); +void dvo_lensobj_init (Lensobj *lensobj); + +void InitRegionHosts (RegionHostInfo *hosts, int Nhosts, int NHOSTS); +void FreeRegionHosts (RegionHostInfo *hosts, int Nhosts); +void FreeRegionHostTable (RegionHostTable *table); +RegionHostTable *RegionHostTableLoad (char *catdir, char *rootname); +int RegionHostTableWaitJobs (RegionHostTable *regionHosts, char *file, int lineno); +int RegionHostTableWaitJobsGetIO (RegionHostTable *regionHosts, char *file, int lineno, int VERBOSE); +int RegionHostFindNeighbors (RegionHostTable *table, int Nhost); + # endif // DVO_H Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/dvodb.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/dvodb.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/dvodb.h (revision 37067) @@ -22,33 +22,46 @@ /* magnitude types */ -enum {MAG_NONE, - MAG_INST, - MAG_CAT, - MAG_APER, - MAG_APER_INST, - MAG_KRON, - MAG_KRON_INST, - MAG_KRON_ERR, - MAG_SYS, - MAG_REL, - MAG_CAL, - MAG_AVE, - MAG_REF, - MAG_ERR, - MAG_STDEV, - MAG_AVE_ERR, - MAG_PHOT_FLAGS, - MAG_CHISQ, - MAG_NCODE, - MAG_NPHOT, - MAG_20, - MAG_80, - MAG_UC_DIST, - MAG_STACK_DET_ID, - MAG_FLUX_PSF, - MAG_FLUX_PSF_ERR, - MAG_FLUX_KRON, - MAG_FLUX_KRON_ERR, -}; + +typedef enum { + MAG_SRC_NONE, + MAG_SRC_CHP, + MAG_SRC_WRP, + MAG_SRC_STK, +} dvoMagSourceType; + +typedef enum { + MAG_LEVEL_NONE, // -2.5*log(DN) [ie, not DN/sec] + MAG_LEVEL_INST, // -2.5*log(DN) [ie, not DN/sec] + MAG_LEVEL_CAT, // MAG_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1) + MAG_LEVEL_SYS, // MAG_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode] + MAG_LEVEL_REL, // MAG_SYS - Mcal [specific zero point for image] + MAG_LEVEL_CAL, // MAG_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode] + MAG_LEVEL_AVE, + MAG_LEVEL_REF, +} dvoMagLevelType; + +typedef enum { + MAG_OPTION_NONE, + MAG_OPTION_MAG, + MAG_OPTION_ERR, + MAG_OPTION_FLUX, + MAG_OPTION_FLUX_ERR, + MAG_OPTION_STDEV, + MAG_OPTION_CHISQ, + MAG_OPTION_MIN, + MAG_OPTION_MAX, + MAG_OPTION_NCODE, + MAG_OPTION_NPHOT, // Nused + MAG_OPTION_UC_DIST, + MAG_OPTION_STACK_DET_ID, + MAG_OPTION_FLAGS, +} dvoMagOptionType; + +typedef enum { + MAG_CLASS_NONE, + MAG_CLASS_PSF, + MAG_CLASS_KRON, + MAG_CLASS_APER, +} dvoMagClassType; /* measure fields */ @@ -90,5 +103,5 @@ MEAS_OBJ_FLAGS, MEAS_SECFILT_FLAGS, - MEAS_MAG, + MEAS_PHOT, // photometry class of measurements MEAS_MINST, MEAS_MCAT, @@ -144,11 +157,8 @@ MEAS_EXTERN_ID, MEAS_EXPNAME_AS_INT, - MEAS_MCAL_OFFSET, + MEAS_MCAL_OFFSET, // make this a dvoMagOption? MEAS_FLAT, MEAS_CENTER_OFFSET, - MEAS_FLUX_PSF, - MEAS_FLUX_PSF_ERR, - MEAS_FLUX_KRON, - MEAS_FLUX_KRON_ERR, + MEAS_REF_COLOR, }; @@ -174,13 +184,11 @@ AVE_TMEAN, AVE_TRANGE, + AVE_PSF_QF, + AVE_PSF_QF_PERF, + AVE_STARGAL, AVE_Xp, AVE_NMEAS, AVE_NMISS, AVE_NPOS, - AVE_NPHOT, - AVE_NCODE, - AVE_MAG, - AVE_dMAG, - AVE_Xm, AVE_OBJ_FLAGS, AVE_TYPE, @@ -190,5 +198,13 @@ AVE_EXTID_HI, AVE_EXTID_LO, + AVE_REF_COLOR, + AVE_PHOT, // photometry class of values }; + +// AVE_NPHOT, +// AVE_NCODE, +// AVE_MAG, +// AVE_dMAG, +// AVE_Xm, enum {IMAGE_ZERO, @@ -257,5 +273,6 @@ IMAGE_NFIT_ASTROM, IMAGE_NLINK_PHOTOM, - IMAGE_NLINK_ASTROM + IMAGE_NLINK_ASTROM, + IMAGE_REF_COLOR }; @@ -277,5 +294,10 @@ int table; int ID; - int magMode; + + dvoMagSourceType magSource; // chip, (forced) warp, stack [only relevant for averages] + dvoMagLevelType magLevel; // inst, cat, sys, rel, ave, ref, err, min, max, stdev, nphot, chisq, + dvoMagOptionType magOption; // psf, kron, aper + dvoMagClassType magClass; + char type; PhotCode *photcode; @@ -339,5 +361,5 @@ int GetMagMode PROTO((char *string)); -PhotCode *ParsePhotcodeField PROTO((char *field, int *mode, int def)); +int ParsePhotcodeField PROTO((dbField *field, char *fieldName, int fieldID)); int ParseMeasureField PROTO((dbField *field, char *fieldName)); int ParseAverageField PROTO((dbField *field, char *fieldName)); @@ -372,5 +394,5 @@ // Some values used by code moved to libdvo from opihi. -enum {OPIHI_FLT, OPIHI_INT}; +enum {OPIHI_NOTYPE, OPIHI_FLT, OPIHI_INT}; #define opihi_flt double #define opihi_int int Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/elixir_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/elixir_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/elixir_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_Elixir_ToInternal (Average_Elixir *in, off_t Nvalues, SecFilt **primary); Average_Elixir *AverageInternalTo_Elixir (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_Elixir_ToInternal (Measure_Elixir *in, off_t Nvalues); -Measure_Elixir *MeasureInternalTo_Elixir (Measure *in, off_t Nvalues); +Measure *Measure_Elixir_ToInternal (Average *ave, Measure_Elixir *in, off_t Nvalues); +Measure_Elixir *MeasureInternalTo_Elixir (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_Elixir_ToInternal (SecFilt_Elixir *in, off_t Nvalues); SecFilt_Elixir *SecFiltInternalTo_Elixir (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/loneos_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/loneos_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/loneos_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_Loneos_ToInternal (Average_Loneos *in, off_t Nvalues, SecFilt **primary); Average_Loneos *AverageInternalTo_Loneos (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_Loneos_ToInternal (Measure_Loneos *in, off_t Nvalues); -Measure_Loneos *MeasureInternalTo_Loneos (Measure *in, off_t Nvalues); +Measure *Measure_Loneos_ToInternal (Average *ave, Measure_Loneos *in, off_t Nvalues); +Measure_Loneos *MeasureInternalTo_Loneos (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_Loneos_ToInternal (SecFilt_Loneos *in, off_t Nvalues); SecFilt_Loneos *SecFiltInternalTo_Loneos (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/panstarrs_dev_0_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/panstarrs_dev_0_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/panstarrs_dev_0_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_Panstarrs_DEV_0_ToInternal (Average_Panstarrs_DEV_0 *in, off_t Nvalues, SecFilt **primary); Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, off_t Nvalues); -Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, off_t Nvalues); +Measure *Measure_Panstarrs_DEV_0_ToInternal (Average *ave, Measure_Panstarrs_DEV_0 *in, off_t Nvalues); +Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_Panstarrs_DEV_0_ToInternal (SecFilt_Panstarrs_DEV_0 *in, off_t Nvalues); SecFilt_Panstarrs_DEV_0 *SecFiltInternalTo_Panstarrs_DEV_0 (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/panstarrs_dev_1_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/panstarrs_dev_1_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/panstarrs_dev_1_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_Panstarrs_DEV_1_ToInternal (Average_Panstarrs_DEV_1 *in, off_t Nvalues, SecFilt **primary); Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, off_t Nvalues); -Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, off_t Nvalues); +Measure *Measure_Panstarrs_DEV_1_ToInternal (Average *ave, Measure_Panstarrs_DEV_1 *in, off_t Nvalues); +Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_Panstarrs_DEV_1_ToInternal (SecFilt_Panstarrs_DEV_1 *in, off_t Nvalues); SecFilt_Panstarrs_DEV_1 *SecFiltInternalTo_Panstarrs_DEV_1 (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_dev_1_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_dev_1_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_dev_1_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_PS1_DEV_1_ToInternal (Average_PS1_DEV_1 *in, off_t Nvalues, SecFilt **primary); Average_PS1_DEV_1 *AverageInternalTo_PS1_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, off_t Nvalues); -Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Measure *in, off_t Nvalues); +Measure *Measure_PS1_DEV_1_ToInternal (Average *ave, Measure_PS1_DEV_1 *in, off_t Nvalues); +Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_PS1_DEV_1_ToInternal (SecFilt_PS1_DEV_1 *in, off_t Nvalues); SecFilt_PS1_DEV_1 *SecFiltInternalTo_PS1_DEV_1 (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_dev_2_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_dev_2_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_dev_2_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_PS1_DEV_2_ToInternal (Average_PS1_DEV_2 *in, off_t Nvalues, SecFilt **primary); Average_PS1_DEV_2 *AverageInternalTo_PS1_DEV_2 (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, off_t Nvalues); -Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Measure *in, off_t Nvalues); +Measure *Measure_PS1_DEV_2_ToInternal (Average *ave, Measure_PS1_DEV_2 *in, off_t Nvalues); +Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_PS1_DEV_2_ToInternal (SecFilt_PS1_DEV_2 *in, off_t Nvalues); SecFilt_PS1_DEV_2 *SecFiltInternalTo_PS1_DEV_2 (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_ref_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_ref_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_ref_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_PS1_REF_ToInternal (Average_PS1_REF *in, off_t Nvalues, SecFilt **primary); Average_PS1_REF *AverageInternalTo_PS1_REF (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, off_t Nvalues); -Measure_PS1_REF *MeasureInternalTo_PS1_REF (Measure *in, off_t Nvalues); +Measure *Measure_PS1_REF_ToInternal (Average *ave, Measure_PS1_REF *in, off_t Nvalues); +Measure_PS1_REF *MeasureInternalTo_PS1_REF (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_PS1_REF_ToInternal (SecFilt_PS1_REF *in, off_t Nvalues); SecFilt_PS1_REF *SecFiltInternalTo_PS1_REF (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v1_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v1_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v1_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_PS1_V1_ToInternal (Average_PS1_V1 *in, off_t Nvalues, SecFilt **primary); Average_PS1_V1 *AverageInternalTo_PS1_V1 (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, off_t Nvalues); -Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Measure *in, off_t Nvalues); +Measure *Measure_PS1_V1_ToInternal (Average *ave, Measure_PS1_V1 *in, off_t Nvalues); +Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_PS1_V1_ToInternal (SecFilt_PS1_V1 *in, off_t Nvalues); SecFilt_PS1_V1 *SecFiltInternalTo_PS1_V1 (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v2_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v2_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v2_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_PS1_V2_ToInternal (Average_PS1_V2 *in, off_t Nvalues, SecFilt **primary); Average_PS1_V2 *AverageInternalTo_PS1_V2 (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_PS1_V2_ToInternal (Measure_PS1_V2 *in, off_t Nvalues); -Measure_PS1_V2 *MeasureInternalTo_PS1_V2 (Measure *in, off_t Nvalues); +Measure *Measure_PS1_V2_ToInternal (Average *ave, Measure_PS1_V2 *in, off_t Nvalues); +Measure_PS1_V2 *MeasureInternalTo_PS1_V2 (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_PS1_V2_ToInternal (SecFilt_PS1_V2 *in, off_t Nvalues); SecFilt_PS1_V2 *SecFiltInternalTo_PS1_V2 (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v3_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v3_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v3_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_PS1_V3_ToInternal (Average_PS1_V3 *in, off_t Nvalues, SecFilt **primary); Average_PS1_V3 *AverageInternalTo_PS1_V3 (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_PS1_V3_ToInternal (Measure_PS1_V3 *in, off_t Nvalues); -Measure_PS1_V3 *MeasureInternalTo_PS1_V3 (Measure *in, off_t Nvalues); +Measure *Measure_PS1_V3_ToInternal (Average *ave, Measure_PS1_V3 *in, off_t Nvalues); +Measure_PS1_V3 *MeasureInternalTo_PS1_V3 (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_PS1_V3_ToInternal (SecFilt_PS1_V3 *in, off_t Nvalues); SecFilt_PS1_V3 *SecFiltInternalTo_PS1_V3 (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v4_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v4_defs.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v4_defs.h (revision 37067) @@ -3,6 +3,6 @@ Average *Average_PS1_V4_ToInternal (Average_PS1_V4 *in, off_t Nvalues, SecFilt **primary); Average_PS1_V4 *AverageInternalTo_PS1_V4 (Average *in, off_t Nvalues, SecFilt *primary); -Measure *Measure_PS1_V4_ToInternal (Measure_PS1_V4 *in, off_t Nvalues); -Measure_PS1_V4 *MeasureInternalTo_PS1_V4 (Measure *in, off_t Nvalues); +Measure *Measure_PS1_V4_ToInternal (Average *ave, Measure_PS1_V4 *in, off_t Nvalues); +Measure_PS1_V4 *MeasureInternalTo_PS1_V4 (Average *ave, Measure *in, off_t Nvalues); SecFilt *SecFilt_PS1_V4_ToInternal (SecFilt_PS1_V4 *in, off_t Nvalues); SecFilt_PS1_V4 *SecFiltInternalTo_PS1_V4 (SecFilt *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v5_defs.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v5_defs.h (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v5_defs.h (revision 37067) @@ -0,0 +1,16 @@ +Image *Image_PS1_V5_ToInternal (Image_PS1_V5 *in, off_t Nvalues, off_t Nalloc); +Image_PS1_V5 *ImageInternalTo_PS1_V5 (Image *in, off_t Nvalues); +Average *Average_PS1_V5_ToInternal (Average_PS1_V5 *in, off_t Nvalues, SecFilt **primary); +Average_PS1_V5 *AverageInternalTo_PS1_V5 (Average *in, off_t Nvalues, SecFilt *primary); +Measure *Measure_PS1_V5_ToInternal (Average *ave, Measure_PS1_V5 *in, off_t Nvalues); +Measure_PS1_V5 *MeasureInternalTo_PS1_V5 (Average *ave, Measure *in, off_t Nvalues); +SecFilt *SecFilt_PS1_V5_ToInternal (SecFilt_PS1_V5 *in, off_t Nvalues); +SecFilt_PS1_V5 *SecFiltInternalTo_PS1_V5 (SecFilt *in, off_t Nvalues); + +Lensing *Lensing_PS1_V5_ToInternal (Lensing_PS1_V5 *in, off_t Nvalues); +Lensing_PS1_V5 *LensingInternalTo_PS1_V5 (Lensing *in, off_t Nvalues); +Lensobj *Lensobj_PS1_V5_ToInternal (Lensobj_PS1_V5 *in, off_t Nvalues); +Lensobj_PS1_V5 *LensobjInternalTo_PS1_V5 (Lensobj *in, off_t Nvalues); + +PhotCode *PhotCode_PS1_V5_To_Internal (PhotCode_PS1_V5 *in, off_t Nvalues); +PhotCode_PS1_V5 *PhotCode_Internal_To_PS1_V5 (PhotCode *in, off_t Nvalues); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/BoundaryTree.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/BoundaryTree.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/BoundaryTree.c (revision 37067) @@ -1,10 +1,10 @@ # include "dvo.h" -# define GET_COLUMN_NEW(OUT,NAME,TYPE) \ - TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \ +# define GET_COLUMN_NEW(HEADER,FTABLE,OUT,NAME,TYPE) \ + TYPE *OUT = gfits_get_bintable_column_data (HEADER, FTABLE, NAME, type, &Nrow, &Ncol); \ myAssert (!strcmp(type, #TYPE), "wrong column type"); -# define GET_COLUMN_RAW(OUT,NAME,TYPE) \ - OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \ +# define GET_COLUMN_RAW(HEADER,FTABLE,OUT,NAME,TYPE) \ + OUT = gfits_get_bintable_column_data (HEADER, FTABLE, NAME, type, &Nrow, &Ncol); \ myAssert (!strcmp(type, #TYPE), "wrong column type"); @@ -12,159 +12,182 @@ BoundaryTree *BoundaryTreeLoad(char *filename) { + + Header header; + Header theader; + Matrix matrix; + + header.buffer = NULL; + matrix.buffer = NULL; + theader.buffer = NULL; + BoundaryTree *tree = NULL; + + FILE *f = fopen (filename, "r"); + if (!f) { + fprintf (stderr, "ERROR: cannot open boundary tree file %s\n", filename); + return NULL; + } + + /* load in PHU segment (ignore) */ + if (!gfits_fread_header (f, &header)) { + if (DEBUG) fprintf (stderr, "can't read boundary tree header\n"); + goto escape; + } + if (!gfits_fread_matrix (f, &matrix, &header)) { + if (DEBUG) fprintf (stderr, "can't read boundary tree matrix\n"); + goto escape; + } + + // load data for this header + if (!gfits_load_header (f, &theader)) { + if (DEBUG) fprintf (stderr, "can't read boundary tree zone table header\n"); + goto escape; + } + + tree = BoundaryTreeRead (&header, &theader, f); + +escape: + + gfits_free_header (&theader); + gfits_free_header (&header); + gfits_free_matrix (&matrix); + fclose (f); + + return tree; +} + +// assume we are pointing at the relevant table portion +BoundaryTree *BoundaryTreeRead(Header *headerPHU, Header *headerZone, FILE *f) { int i, j, nz, nb, Ncol; off_t Nrow; char type[16]; - Header header; - Header theader; - Matrix matrix; - FTable ftable; - - header.buffer = NULL; - matrix.buffer = NULL; - ftable.buffer = NULL; - theader.buffer = NULL; + + FTable ftableZone; + + Header headerCell; + FTable ftableCell; + + ftableZone.buffer = NULL; + ftableCell.buffer = NULL; + headerCell.buffer = NULL; + + // we must have already read in the Zone table header section + ftableZone.header = headerZone; + ftableCell.header = &headerCell; + BoundaryTree *tree = NULL; - FILE *f = fopen (filename, "r"); - if (!f) { - fprintf (stderr, "ERROR: cannot open image subset file %s\n", filename); - return NULL; - } - - /* load in PHU segment (ignore) */ - if (!gfits_fread_header (f, &header)) { - if (DEBUG) fprintf (stderr, "can't read image subset header\n"); - goto escape; - } - if (!gfits_fread_matrix (f, &matrix, &header)) { - if (DEBUG) fprintf (stderr, "can't read image subset matrix\n"); - goto escape; - } - ALLOCATE (tree, BoundaryTree, 1); - gfits_scan (&header, "DEC_ORI", "%lf", 1, &tree->DEC_origin); - gfits_scan (&header, "DEC_OFF", "%lf", 1, &tree->DEC_offset); - - gfits_scan (&header, "NX_SUB", "%d", 1, &tree->NX_SUB); - gfits_scan (&header, "NY_SUB", "%d", 1, &tree->NY_SUB); - gfits_scan (&header, "PIXSCALE", "%lf", 1, &tree->dPix); - - ftable.header = &theader; + // we need to read the boundary tree parameters from the correct header + // put them in the PHU header in any case? + gfits_scan (headerPHU, "DEC_ORI", "%lf", 1, &tree->DEC_origin); + gfits_scan (headerPHU, "DEC_OFF", "%lf", 1, &tree->DEC_offset); + gfits_scan (headerPHU, "NX_SUB", "%d", 1, &tree->NX_SUB); + gfits_scan (headerPHU, "NY_SUB", "%d", 1, &tree->NY_SUB); + gfits_scan (headerPHU, "PIXSCALE", "%lf", 1, &tree->dPix); /*** zone information table ***/ - { - // load data for this header - if (!gfits_load_header (f, &theader)) goto escape; - - // read the fits table bytes - if (!gfits_fread_ftable_data (f, &ftable, FALSE)) goto escape; + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftableZone, FALSE)) goto escape; - // need to create and assign to flat-field correction - GET_COLUMN_RAW(tree->Nband, "NBAND", int); - GET_COLUMN_RAW(tree->RA_origin, "RA_ORIGIN", double); - GET_COLUMN_RAW(tree->RA_offset, "RA_OFFSET", double); - GET_COLUMN_RAW(tree->DEC_min , "DEC_MIN", double); - GET_COLUMN_RAW(tree->DEC_max , "DEC_MAX", double); - GET_COLUMN_RAW(tree->DEC_min_raw, "DEC_MIN_RAW", double); - GET_COLUMN_RAW(tree->DEC_max_raw, "DEC_MAX_RAW", double); - gfits_free_header (&theader); - gfits_free_table (&ftable); - - fprintf (stderr, "loaded data for %lld zones\n", (long long) Nrow); - tree->Nzone = Nrow; - - // allocate the storage arrays - ALLOCATE (tree->ra, double *, tree->Nzone); - ALLOCATE (tree->dec, double *, tree->Nzone); - ALLOCATE (tree->Xo, double *, tree->Nzone); - ALLOCATE (tree->Yo, double *, tree->Nzone); - ALLOCATE (tree->dX, int *, tree->Nzone); - ALLOCATE (tree->dY, int *, tree->Nzone); - ALLOCATE (tree->cell, int *, tree->Nzone); - ALLOCATE (tree->projID, int *, tree->Nzone); - ALLOCATE (tree->name, char **, tree->Nzone); - for (i = 0; i < tree->Nzone; i++) { - ALLOCATE (tree->ra[i], double, tree->Nband[i]); - ALLOCATE (tree->dec[i], double, tree->Nband[i]); - ALLOCATE (tree->Xo[i], double, tree->Nband[i]); - ALLOCATE (tree->Yo[i], double, tree->Nband[i]); - ALLOCATE (tree->dX[i], int, tree->Nband[i]); - ALLOCATE (tree->dY[i], int, tree->Nband[i]); - ALLOCATE (tree->cell[i], int, tree->Nband[i]); - ALLOCATE (tree->projID[i], int, tree->Nband[i]); - ALLOCATE (tree->name[i], char *, tree->Nband[i]); - for (j = 0; j < tree->Nband[i]; j++) { - ALLOCATE (tree->name[i][j], char, BOUNDARY_TREE_NAME_LENGTH); - } + // need to create and assign to flat-field correction + GET_COLUMN_RAW(headerZone, &ftableZone, tree->Nband, "NBAND", int); + GET_COLUMN_RAW(headerZone, &ftableZone, tree->RA_origin, "RA_ORIGIN", double); + GET_COLUMN_RAW(headerZone, &ftableZone, tree->RA_offset, "RA_OFFSET", double); + GET_COLUMN_RAW(headerZone, &ftableZone, tree->DEC_min , "DEC_MIN", double); + GET_COLUMN_RAW(headerZone, &ftableZone, tree->DEC_max , "DEC_MAX", double); + GET_COLUMN_RAW(headerZone, &ftableZone, tree->DEC_min_raw, "DEC_MIN_RAW", double); + GET_COLUMN_RAW(headerZone, &ftableZone, tree->DEC_max_raw, "DEC_MAX_RAW", double); + gfits_free_table (&ftableZone); + + fprintf (stderr, "loaded data for %lld zones\n", (long long) Nrow); + tree->Nzone = Nrow; + + // allocate the storage arrays + ALLOCATE (tree->ra, double *, tree->Nzone); + ALLOCATE (tree->dec, double *, tree->Nzone); + ALLOCATE (tree->Xo, double *, tree->Nzone); + ALLOCATE (tree->Yo, double *, tree->Nzone); + ALLOCATE (tree->dX, int *, tree->Nzone); + ALLOCATE (tree->dY, int *, tree->Nzone); + ALLOCATE (tree->cell, int *, tree->Nzone); + ALLOCATE (tree->projID, int *, tree->Nzone); + ALLOCATE (tree->name, char **, tree->Nzone); + for (i = 0; i < tree->Nzone; i++) { + ALLOCATE (tree->ra[i], double, tree->Nband[i]); + ALLOCATE (tree->dec[i], double, tree->Nband[i]); + ALLOCATE (tree->Xo[i], double, tree->Nband[i]); + ALLOCATE (tree->Yo[i], double, tree->Nband[i]); + ALLOCATE (tree->dX[i], int, tree->Nband[i]); + ALLOCATE (tree->dY[i], int, tree->Nband[i]); + ALLOCATE (tree->cell[i], int, tree->Nband[i]); + ALLOCATE (tree->projID[i], int, tree->Nband[i]); + ALLOCATE (tree->name[i], char *, tree->Nband[i]); + for (j = 0; j < tree->Nband[i]; j++) { + ALLOCATE (tree->name[i][j], char, BOUNDARY_TREE_NAME_LENGTH); } } /*** cell information table ***/ - { - // load data for this header - if (!gfits_load_header (f, &theader)) goto escape; - - // read the fits table bytes - if (!gfits_fread_ftable_data (f, &ftable, FALSE)) goto escape; + + // load data for this header + if (!gfits_load_header (f, &headerCell)) goto escape; + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftableCell, FALSE)) goto escape; - // need to create and assign to flat-field correction - GET_COLUMN_NEW(R, "RA", double); - GET_COLUMN_NEW(D, "DEC", double); - GET_COLUMN_NEW(zone, "ZONE", int); - GET_COLUMN_NEW(band, "BAND", int); - GET_COLUMN_NEW(index, "INDEX", int); - GET_COLUMN_NEW(Xo, "X_CENT", double); - GET_COLUMN_NEW(Yo, "Y_CENT", double); - GET_COLUMN_NEW(dX, "X_GRID", int); - GET_COLUMN_NEW(dY, "Y_GRID", int); - GET_COLUMN_NEW(name, "NAME", char); // XXX how is this done? - gfits_free_header (&theader); - gfits_free_table (&ftable); - fprintf (stderr, "loaded data for %lld cells\n", (long long) Nrow); - - // assign the storage arrays - for (i = 0; i < Nrow; i++) { - nz = zone[i]; - nb = band[i]; - tree->ra[nz][nb] = R[i]; - tree->dec[nz][nb] = D[i]; - tree->Xo[nz][nb] = Xo[i]; - tree->Yo[nz][nb] = Yo[i]; - tree->dX[nz][nb] = dX[i]; - tree->dY[nz][nb] = dY[i]; - tree->cell[nz][nb] = i; // XXX ? - memcpy(tree->name[nz][nb], &name[i*BOUNDARY_TREE_NAME_LENGTH], BOUNDARY_TREE_NAME_LENGTH); - // XXX parse out the ID from the name (skycell.NNNN) - tree->projID[nz][nb] = atoi(&tree->name[nz][nb][8]); - } - - free (R ); - free (D ); - free (zone ); - free (band ); - free (Xo ); - free (Yo ); - free (dX ); - free (dY ); - free (index ); - free (name ); - } - - gfits_free_header (&header); - gfits_free_matrix (&matrix); - fclose (f); + // need to create and assign to flat-field correction + GET_COLUMN_NEW(&headerCell, &ftableCell, R, "RA", double); + GET_COLUMN_NEW(&headerCell, &ftableCell, D, "DEC", double); + GET_COLUMN_NEW(&headerCell, &ftableCell, zone, "ZONE", int); + GET_COLUMN_NEW(&headerCell, &ftableCell, band, "BAND", int); + GET_COLUMN_NEW(&headerCell, &ftableCell, index, "INDEX", int); + GET_COLUMN_NEW(&headerCell, &ftableCell, Xo, "X_CENT", double); + GET_COLUMN_NEW(&headerCell, &ftableCell, Yo, "Y_CENT", double); + GET_COLUMN_NEW(&headerCell, &ftableCell, dX, "X_GRID", int); + GET_COLUMN_NEW(&headerCell, &ftableCell, dY, "Y_GRID", int); + GET_COLUMN_NEW(&headerCell, &ftableCell, name, "NAME", char); // XXX how is this done? + gfits_free_header (&headerCell); + gfits_free_table (&ftableCell); + + fprintf (stderr, "loaded data for %lld cells\n", (long long) Nrow); + + // assign the storage arrays + for (i = 0; i < Nrow; i++) { + nz = zone[i]; + nb = band[i]; + tree->ra[nz][nb] = R[i]; + tree->dec[nz][nb] = D[i]; + tree->Xo[nz][nb] = Xo[i]; + tree->Yo[nz][nb] = Yo[i]; + tree->dX[nz][nb] = dX[i]; + tree->dY[nz][nb] = dY[i]; + tree->cell[nz][nb] = i; // XXX ? + memcpy(tree->name[nz][nb], &name[i*BOUNDARY_TREE_NAME_LENGTH], BOUNDARY_TREE_NAME_LENGTH); + // XXX parse out the ID from the name (skycell.NNNN) + tree->projID[nz][nb] = atoi(&tree->name[nz][nb][8]); + } + + free (R ); + free (D ); + free (zone ); + free (band ); + free (Xo ); + free (Yo ); + free (dX ); + free (dY ); + free (index ); + free (name ); return tree; escape: - gfits_free_header (&header); - gfits_free_matrix (&matrix); - gfits_free_header (&theader); - gfits_free_table (&ftable); + gfits_free_header (&headerCell); + gfits_free_table (&ftableCell); + gfits_free_table (&ftableZone); if (tree) free (tree); - fclose (f); return NULL; } @@ -173,9 +196,6 @@ int BoundaryTreeSave(char *filename, BoundaryTree *tree) { - int i, nz, nb; Header header; - Header theader; Matrix matrix; - FTable ftable; gfits_init_header (&header); @@ -202,4 +222,16 @@ gfits_free_header (&header); gfits_free_matrix (&matrix); + + BoundaryTreeWrite (f, tree); + fclose (f); + + return TRUE; +} + +int BoundaryTreeWrite(FILE *f, BoundaryTree *tree) { + + int i, nz, nb; + Header theader; + FTable ftable; /*** zone information table ***/ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/HostTable.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/HostTable.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/HostTable.c (revision 37067) @@ -86,4 +86,5 @@ FreeHosts (hosts, Nhosts); free (filename); + fclose (f); return NULL; } @@ -133,4 +134,5 @@ free (filename); + fclose (f); return table; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageMetadata.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageMetadata.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageMetadata.c (revision 37067) @@ -124,14 +124,14 @@ gfits_create_table_header (&theader, "BINTABLE", "IMAGE_SUBSET"); - gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "EXTERN_ID", "extern ID", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "EXPNAME_AS_INT", "expname as integer", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "D", "CRVAL1", "ra at center", "degrees", 1.0, 0.0); - gfits_define_bintable_column (&theader, "D", "CRVAL2", "dec at center", "degrees", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "THETA", "camera rot angle", "degrees", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "MCAL", "zero point offset", "magnitudes", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "SECZ", "airmass", "none", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "X_CENTER", "chip center", "none", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "Y_CENTER", "chip center", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "EXTERN_ID", "extern ID", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "EXPNAME_AS_INT", "expname as integer", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "D", "CRVAL1", "ra at center", "degrees", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "CRVAL2", "dec at center", "degrees", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "THETA", "camera rot angle", "degrees", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MCAL", "zero point offset", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "SECZ", "airmass", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "X_CENTER", "chip center", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "Y_CENTER", "chip center", "none", 1.0, 0.0); // generate the output array that carries the data Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageMetadataSelection.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageMetadataSelection.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageMetadataSelection.c (revision 37067) @@ -18,5 +18,5 @@ field.pc1_2 = field.pc2_1 = 0.0; field.Npolyterms = 0; - strcpy (field.ctype, "RA---SIN"); + strcpy (field.ctype, "DEC--SIN"); /* mosaic defines a frame with 0,0 at the mosaic center, and 1 arcsec / pixel */ @@ -26,5 +26,5 @@ mosaic.pc1_2 = mosaic.pc2_1 = 0.0; mosaic.Npolyterms = 0; - strcpy (mosaic.ctype, "RA---SIN"); + strcpy (mosaic.ctype, "DEC--SIN"); if ((image = ImageMetadataLoad (filename, &Nimage)) == NULL) return (FALSE); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageSelection.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageSelection.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageSelection.c (revision 37067) @@ -28,5 +28,5 @@ mosaic.pc1_2 = mosaic.pc2_1 = 0.0; mosaic.Npolyterms = 0; - strcpy (mosaic.ctype, "RA---SIN"); + strcpy (mosaic.ctype, "DEC--SIN"); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/LoadPhotcodesFITS.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/LoadPhotcodesFITS.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/LoadPhotcodesFITS.c (revision 37067) @@ -64,4 +64,5 @@ CONVERT_FORMAT("DVO_PHOTCODE_PS1_V3", PS1_V3); CONVERT_FORMAT("DVO_PHOTCODE_PS1_V4", PS1_V4); + CONVERT_FORMAT("DVO_PHOTCODE_PS1_V5", PS1_V5); table = GetPhotcodeTable (); @@ -100,4 +101,15 @@ // photcode.equiv of 0 means "undefined" for (i = 0; i < Ncode; i++) { + if (!strcasecmp(photcode[i].name, "MAG")) { + fprintf (stderr, "MAG is not an allowed photcode name (reserved to DVO internals)\n"); + free (photcode); + return FALSE; + } + if (!strcasecmp(photcode[i].name, "FLUX")) { + fprintf (stderr, "FLUX is not an allowed photcode name (reserved to DVO internals)\n"); + free (photcode); + return FALSE; + } + if (photcode[i].type == PHOT_DEP) { if (photcode[i].equiv == 0) continue; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/LoadPhotcodesText.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/LoadPhotcodesText.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/LoadPhotcodesText.c (revision 37067) @@ -108,4 +108,9 @@ } + if (!strcasecmp(name, "MAG")) { + fprintf (stderr, "MAG is not an allowed photcode name (reserved to DVO internals)\n"); + return FALSE; + } + photcode[Ncode].type = 0; memset(photcode[Ncode].dummy, 0, sizeof(photcode[Ncode].dummy)); @@ -137,8 +142,8 @@ photcode[Ncode].photomErrSys = atof (photomErrSys); - photcode[Ncode].astromPoorMask = strtol (astromPoorMask, NULL, 0); - photcode[Ncode].astromBadMask = strtol (astromBadMask, NULL, 0); - photcode[Ncode].photomPoorMask = strtol (photomPoorMask, NULL, 0); - photcode[Ncode].photomBadMask = strtol (photomBadMask, NULL, 0); + photcode[Ncode].astromPoorMask = strtoll (astromPoorMask, NULL, 0); + photcode[Ncode].astromBadMask = strtoll (astromBadMask, NULL, 0); + photcode[Ncode].photomPoorMask = strtoll (photomPoorMask, NULL, 0); + photcode[Ncode].photomBadMask = strtoll (photomBadMask, NULL, 0); switch (photcode[Ncode].type) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/RegionHostTable.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/RegionHostTable.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/RegionHostTable.c (revision 37067) @@ -0,0 +1,497 @@ +# include "dvo.h" +# include +# include + +void InitRegionHosts (RegionHostInfo *hosts, int Nhosts, int NHOSTS) { + + int i; + for (i = Nhosts; i < NHOSTS; i++) { + hosts[i].Rmin = NAN; + hosts[i].Rmax = NAN; + hosts[i].Dmin = NAN; + hosts[i].Dmax = NAN; + + hosts[i].RminCat = NAN; + hosts[i].RmaxCat = NAN; + hosts[i].DminCat = NAN; + hosts[i].DmaxCat = NAN; + + hosts[i].hostname = NULL; + hosts[i].stdio[HOST_STDIN] = -1; + hosts[i].stdio[HOST_STDOUT] = -1; + hosts[i].stdio[HOST_STDERR] = -1; + hosts[i].pid = 0; + + hosts[i].image = NULL; + hosts[i].imseq = NULL; + hosts[i].Nimage = 0; + hosts[i].NIMAGE = 0; + + hosts[i].neighbors = NULL; + hosts[i].Nneighbors = 0; + hosts[i].isNeighbor = FALSE; + } + return; +} + +void FreeRegionHosts (RegionHostInfo *hosts, int Nhosts) { + + int i; + for (i = 0; i < Nhosts; i++) { + free (hosts[i].hostname); + } + free (hosts); + return; +} + +void FreeRegionHostTable (RegionHostTable *table) { + + if (!table) return; + if (table->hosts) { + FreeRegionHosts (table->hosts, table->Nhosts); + } + if (table->index) free (table->index); + free (table); + return; +} + +RegionHostTable *RegionHostTableLoad (char *catdir, char *rootname) { + + int i, Nline; + + char *filename = NULL; + + ALLOCATE (filename, char, strlen(catdir) + strlen(rootname) + 2); // one slash and one EOL + sprintf (filename, "%s/%s", catdir, rootname); + + FILE *f = fopen (filename, "r"); + if (!f) { + fprintf (stderr, "failed to open host table %s\n", filename); + free (filename); + return NULL; + } + + // simple format: ID hostname pathname + + int NHOSTS = 16; + int Nhosts = 0; + RegionHostInfo *hosts = NULL; + ALLOCATE (hosts, RegionHostInfo, NHOSTS); + InitRegionHosts (hosts, Nhosts, NHOSTS); + + int maxID = 0; + + RegionHostTable *table = NULL; + ALLOCATE (table, RegionHostTable, 1); + table->Rmin = 360; + table->Rmax = 0; + table->Dmin = +90; + table->Dmax = -90; + + for (Nline = 0; TRUE; Nline ++) { + int ID; + char tmphost[1024]; + char line[1024]; + + // XXXX use this for safety: int status = scan_line_maxlen (f, line, 1024); + int status = scan_line (f, line); + if (status == EOF) break; + + // find first non-whitespace char & skip commented lines + for (i = 0; OHANA_WHITESPACE (line[i]); i++); + if (line[i] == '#') continue; + if (line[i] == 0) continue; + + double Rmin, Rmax, Dmin, Dmax; + status = sscanf (line, "%d %1023s %lf %lf %lf %lf", &ID, tmphost, &Rmin, &Rmax, &Dmin, &Dmax); + if (status != 6) { + fprintf (stderr, "error reading line %d of region host table %s\n", Nline, filename); + FreeRegionHosts (hosts, Nhosts); + free (filename); + fclose (f); + return NULL; + } + + // check the validity of ID (0 < ID < MAX_SHORT) + + if (ID < 1) { + fprintf (stderr, "invalid host ID %d\n", ID); + exit (1); + } + if (ID > 255) { + fprintf (stderr, "invalid host ID %d\n", ID); + exit (1); + } + maxID = MAX(maxID, ID); + + hosts[Nhosts].hostID = ID; + hosts[Nhosts].hostname = strcreate(tmphost); + + InitIOBuffer (&hosts[Nhosts].stdout, 1000); + InitIOBuffer (&hosts[Nhosts].stderr, 1000); + + hosts[Nhosts].Rmin = Rmin; + hosts[Nhosts].Rmax = Rmax; + hosts[Nhosts].Dmin = Dmin; + hosts[Nhosts].Dmax = Dmax; + + hosts[Nhosts].RminCat = Rmin; + hosts[Nhosts].RmaxCat = Rmax; + hosts[Nhosts].DminCat = Dmin; + hosts[Nhosts].DmaxCat = Dmax; + + table->Rmin = MIN(Rmin, table->Rmin); + table->Rmax = MAX(Rmax, table->Rmax); + table->Dmin = MIN(Dmin, table->Dmin); + table->Dmax = MAX(Dmax, table->Dmax); + + // InitIOBuffer (&hosts[Nhosts].stdout, 1000); + // InitIOBuffer (&hosts[Nhosts].stderr, 1000); + + Nhosts ++; + if (Nhosts >= NHOSTS) { + NHOSTS += 16; + REALLOCATE (hosts, RegionHostInfo, NHOSTS); + InitRegionHosts (hosts, Nhosts, NHOSTS); + } + } + + table->Nhosts = Nhosts; + table->hosts = hosts; + + ALLOCATE (table->index, short, maxID + 1); + for (i = 0; i <= maxID; i++) table->index[i] = -1; + + for (i = 0; i < table->Nhosts; i++) { + if (table->index[table->hosts[i].hostID] != -1) { + fprintf (stderr, "error: duplicate hostID %d\n", table->hosts[i].hostID); + exit (1); + } + table->index[table->hosts[i].hostID] = i; + } + + free (filename); + fclose (f); + return table; +} + +int RegionHostFindNeighbors (RegionHostTable *table, int Nhost) { + + int i; + + // given a specific host (by table sequence), find all of its neighbors + // (eg, (host->Rmin == althost->Rmax && (host->Dmin <= althost->Dmax) && (host->Dmax >= althost->Dmin) + + RegionHostInfo *myhost = &table->hosts[Nhost]; + myAssert (!myhost->neighbors, "myhost neighbors already allocated"); + myAssert (!myhost->Nneighbors, "myhost Nneighbors not zero?"); + ALLOCATE (myhost->neighbors, int, 1); // always allocate 1 extra + + for (i = 0; i < table->Nhosts; i++) { + + if (i == Nhost) continue; + RegionHostInfo *altHost = &table->hosts[i]; + + int onBorder; + + onBorder = + (myhost->Rmin == altHost->Rmax) && + (myhost->Dmin <= altHost->Dmax) && + (myhost->Dmax >= altHost->Dmin); + if (onBorder) goto add_neighbor; + + onBorder = + (myhost->Rmax == altHost->Rmin) && + (myhost->Dmin <= altHost->Dmax) && + (myhost->Dmax >= altHost->Dmin); + if (onBorder) goto add_neighbor; + + // handle the 0,360 boundary (Rmin,Rmax are in the range 0,360, but 0 == 360) + onBorder = + (myhost->Rmin == 0.0) && + (altHost->Rmax == 360.0) && + (myhost->Dmin <= altHost->Dmax) && + (myhost->Dmax >= altHost->Dmin); + if (onBorder) goto add_neighbor; + + onBorder = + (myhost->Rmax == 360.0) && + (altHost->Rmin == 0.0) && + (myhost->Dmin <= altHost->Dmax) && + (myhost->Dmax >= altHost->Dmin); + if (onBorder) goto add_neighbor; + + onBorder = + (myhost->Dmin == altHost->Dmax) && + (myhost->Rmin <= altHost->Rmax) && + (myhost->Rmax >= altHost->Rmin); + if (onBorder) goto add_neighbor; + + onBorder = + (myhost->Dmax == altHost->Dmin) && + (myhost->Rmin <= altHost->Rmax) && + (myhost->Rmax >= altHost->Rmin); + if (onBorder) goto add_neighbor; + + continue; + + add_neighbor: + myhost->neighbors[myhost->Nneighbors] = i; + myhost->Nneighbors ++; + REALLOCATE (myhost->neighbors, int, myhost->Nneighbors + 1); + altHost->isNeighbor = TRUE; + } + return TRUE; +} + +// wait for all children to complete, report output to stdout +int RegionHostTableWaitJobs (RegionHostTable *table, char *file, int lineno) { + + int i; + + // we have launched table->Nhosts jobs; wait for all of them to complete... + // if one (N) failed to launch, we will get an ECHILD error from the last (N) calls + int done = FALSE; + for (i = 0; !done && (i < table->Nhosts); i++) { + int status = 0; + + // XXX we'll need to pass in WNOHANG and keep retrying if we want to have a timeout... + int pid = waitpid (-1, &status, 0); + if (!pid) { + // this should only occur if we called waitpid with the WNOHANG option + fprintf (stderr, "programming error (1)? %s %d", file, lineno); + exit (2); + } + if (pid == -1) { + switch (errno) { + case ECHILD: + done = TRUE; + break; + default: + fprintf (stderr, "programming error (2)? %s %d", file, lineno); + exit (2); + } + } + + // when the host has finished, close the open sockets + + // find the host which has finished + int Nout, j; + int found = FALSE; + for (j = 0; j < table->Nhosts; j++) { + if (table->hosts[j].pid != pid) continue; + found = TRUE; + // check on the status of this and report any output? + fprintf (stderr, "job finished for %s (%d)\n", table->hosts[j].hostname, pid); + // read the stderr and stdout + IOBuffer buffer; + InitIOBuffer (&buffer, 100); + EmptyIOBuffer (&buffer, 100, table->hosts[j].stdio[HOST_STDOUT]); + fprintf (stderr, "--- stdout from %s ---\n", table->hosts[j].hostname); + Nout = write (STDOUT_FILENO, buffer.buffer, buffer.Nbuffer); + if (Nout != buffer.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); } + fprintf (stderr, "\n"); + + InitIOBuffer (&buffer, 100); + EmptyIOBuffer (&buffer, 100, table->hosts[j].stdio[HOST_STDERR]); + fprintf (stderr, "--- stderr from %s ---\n", table->hosts[j].hostname); + Nout = write (STDOUT_FILENO, buffer.buffer, buffer.Nbuffer); + if (Nout != buffer.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); } + fprintf (stderr, "\n"); + if (WIFEXITED(status)) { + fprintf (stderr, "normal completion, exit status is %d\n", WEXITSTATUS(status)); + table->hosts[j].status = WEXITSTATUS(status); + if (table->hosts[j].status) { + fprintf (stderr, "job failed on %s\n", table->hosts[j].hostname); + continue; + } + } else { + table->hosts[j].status = -1; + fprintf (stderr, "job exited abnormally on %s\n", table->hosts[j].hostname); + continue; + } + } + if (!found) { + fprintf (stderr, "Programming error: failed to matched finished job to known host!\n"); + exit (2); + } + } + return TRUE; +} + + +// wait for all children to complete, report output to stdout +int RegionHostTableWaitJobsGetIO (RegionHostTable *table, char *file, int lineno, int VERBOSE) { + + // we have launched table->Nhosts jobs; wait for all of them to complete... + // if one (N) failed to launch, we will get an ECHILD error from the last (N) calls + + // we need to read any data waiting on stderr or stdout from these jobs, or the overfull + // buffers can cause a problem. we alternate between 'select' and 'waitpid' calls with + // timeouts for both + + // add all hosts' sockets to the fd_sets + fd_set rdSet, wtSet; + FD_ZERO (&rdSet); + FD_ZERO (&wtSet); + + // XXX can I set the fd_sets once, since I am not actually closing the fd's? + + int globalStatus = TRUE; + + int i; + int Nmax = 0; + for (i = 0; i < table->Nhosts; i++) { + if (!table->hosts[i].pid) continue; // any unconnected hosts should be skipped + FD_SET (table->hosts[i].stdio[HOST_STDIN], &wtSet); + Nmax = MAX (Nmax, table->hosts[i].stdio[HOST_STDIN]); + FD_SET (table->hosts[i].stdio[HOST_STDOUT], &rdSet); + Nmax = MAX (Nmax, table->hosts[i].stdio[HOST_STDOUT]); + FD_SET (table->hosts[i].stdio[HOST_STDERR], &rdSet); + Nmax = MAX (Nmax, table->hosts[i].stdio[HOST_STDERR]); + } + Nmax ++; + + // need the list of connected hosts for exit test below + int Nrunning = 0; + for (i = 0; i < table->Nhosts; i++) { + if (!table->hosts[i].pid) continue; // any unconnected hosts should be skipped + Nrunning ++; + } + + int Nfound = 0; + + // this loop has 2 chunks: (a) check for I/O + (b) check for jobs done + while (1) { + + // Wait up to 0.5 second for host to provide I/O + // timeout gets mucked: need to reset before each select + struct timeval timeout; + timeout.tv_sec = 10; + timeout.tv_usec = 500000; + + int status = select (Nmax, NULL, &wtSet, NULL, &timeout); + if (status == -1) { + perror("select()"); + exit (2); + } + + // we have some sockets to check, check sockets for all hosts + for (i = 0; (status > 0) && (i < table->Nhosts); i++) { + if (!table->hosts[i].pid) continue; // any unconnected hosts should be skipped + + if (FALSE && FD_ISSET (table->hosts[i].stdio[HOST_STDIN], &wtSet)) { + // this host is waiting for input : this is an error, so exit + fprintf (stderr, "host %s is waiting for input\n", table->hosts[i].hostname); + abort(); + } + + if ((table->hosts[i].stdio[HOST_STDOUT] > 0) && FD_ISSET (table->hosts[i].stdio[HOST_STDOUT], &rdSet)) { + // this host has waiting output : read to buffer, and dump if necessary + ReadtoIOBuffer (&table->hosts[i].stdout, table->hosts[i].stdio[HOST_STDOUT]); + // if (table->hosts[i].stdout.Nbuffer > 0x10000) { + if (table->hosts[i].stdout.Nbuffer > 0x1000) { + int printHead = VERBOSE || (table->hosts[i].stdout.Nbuffer > 0); + if (printHead) fprintf (stdout, "--- stdout from %s --- (%d bytes, v1)\n", table->hosts[i].hostname, table->hosts[i].stdout.Nbuffer); + int Nout = write (STDOUT_FILENO, table->hosts[i].stdout.buffer, table->hosts[i].stdout.Nbuffer); + if (Nout != table->hosts[i].stdout.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); } + FlushIOBuffer (&table->hosts[i].stdout); + if (printHead) fprintf (stdout, "\n"); + } + } + + if ((table->hosts[i].stdio[HOST_STDERR] > 0) && FD_ISSET (table->hosts[i].stdio[HOST_STDERR], &rdSet)) { + // this host has waiting output : read to buffer, and dump if necessary + ReadtoIOBuffer (&table->hosts[i].stderr, table->hosts[i].stdio[HOST_STDERR]); + // if (table->hosts[i].stderr.Nbuffer > 0x10000) { + if (table->hosts[i].stderr.Nbuffer > 0x1000) { + int printHead = VERBOSE || (table->hosts[i].stderr.Nbuffer > 0); + if (printHead) fprintf (stdout, "--- stderr from %s --- (%d bytes, v1)\n", table->hosts[i].hostname, table->hosts[i].stderr.Nbuffer); + int Nout = write (STDOUT_FILENO, table->hosts[i].stderr.buffer, table->hosts[i].stderr.Nbuffer); + if (Nout != table->hosts[i].stderr.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); } + FlushIOBuffer (&table->hosts[i].stderr); + if (printHead) fprintf (stdout, "\n"); + } + } + } + + // now check if any children have finished... + while (TRUE) { + int status = 0; + int pid = waitpid (-1, &status, WNOHANG); + if (!pid) { + // fprintf (stderr, "no hosts to harvest\n"); + usleep (500000); + break; // no outstanding jobs have finished + } + if ((pid == -1) && (errno == ECHILD)) goto escape; // no more jobs on which to wait + if ((pid == -1) && (errno != ECHILD)) { + fprintf (stderr, "programming error (2)? %s %d", file, lineno); + exit (2); + } + + // find the host which has finished + int found = FALSE; + for (i = 0; (i < table->Nhosts) && !found; i++) { + if (table->hosts[i].pid != pid) continue; + found = TRUE; + + RegionHostInfo *host = &table->hosts[i]; + + // check on the status of this and report any output? + if (VERBOSE) fprintf (stdout, "job finished for %s (%d)\n", host->hostname, pid); + + // read stdout + int printHead; + printHead = VERBOSE || (host->stdout.Nbuffer > 0); + EmptyIOBuffer (&host->stdout, 100, host->stdio[HOST_STDOUT]); + if (printHead) fprintf (stdout, "--- stdout from %s --- (%d bytes, v2)\n", host->hostname, host->stdout.Nbuffer); + int Nout = write (STDOUT_FILENO, host->stdout.buffer, host->stdout.Nbuffer); + if (Nout != host->stdout.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); } + FlushIOBuffer (&host->stdout); + if (printHead) fprintf (stdout, "\n"); + + // read stderr + printHead = VERBOSE || (host->stderr.Nbuffer > 0); + EmptyIOBuffer (&host->stderr, 100, host->stdio[HOST_STDERR]); + if (printHead) fprintf (stdout, "--- stderr from %s --- (%d bytes, v2)\n", host->hostname, host->stderr.Nbuffer); + Nout = write (STDOUT_FILENO, host->stderr.buffer, host->stderr.Nbuffer); + if (Nout != host->stderr.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); } + FlushIOBuffer (&host->stderr); + if (printHead) fprintf (stdout, "\n"); + + if (WIFEXITED(status)) { + if (VERBOSE) fprintf (stdout, "normal completion, exit status is %d\n", WEXITSTATUS(status)); + host->status = WEXITSTATUS(status); + if (host->status) { + fprintf (stdout, "job failed on %s\n", host->hostname); + globalStatus = FALSE; + } + } else { + host->status = -1; + fprintf (stdout, "job exited abnormally on %s\n", host->hostname); + globalStatus = FALSE; + continue; + } + } + if (!found) { + fprintf (stderr, "Programming error: failed to matched finished job to known host!\n"); + exit (2); + } + Nfound ++; + if (Nfound == Nrunning) goto escape; // we've harvested all jobs + } + } + +escape: + + // close all opened connections + for (i = 0; i < table->Nhosts; i++) { + if (!table->hosts[i].pid) continue; // any unconnected hosts should be skipped + close (table->hosts[i].stdio[HOST_STDIN]); + close (table->hosts[i].stdio[HOST_STDOUT]); + close (table->hosts[i].stdio[HOST_STDERR]); + } + + return globalStatus; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/SavePhotcodesFITS.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/SavePhotcodesFITS.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/SavePhotcodesFITS.c (revision 37067) @@ -30,9 +30,9 @@ // for the moment, we simply support the latest photcode format for output // XXX update this as needed as new formats are defined - PhotCode_PS1_V4 *photcode_output = PhotCode_Internal_To_PS1_V4 (table[0].code, table[0].Ncode); + PhotCode_PS1_V5 *photcode_output = PhotCode_Internal_To_PS1_V5 (table[0].code, table[0].Ncode); /* convert FITS format data to internal format (byteswaps & EXTNAME) */ if (!gfits_db_create (&db)) return (FALSE); - if (!gfits_table_set_PhotCode_PS1_V4 (&db.ftable, photcode_output, table[0].Ncode)) return (FALSE); + if (!gfits_table_set_PhotCode_PS1_V5 (&db.ftable, photcode_output, table[0].Ncode)) return (FALSE); if (!gfits_db_save (&db)) return (FALSE); if (!gfits_db_close (&db)) return (FALSE); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/TessellationTable.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/TessellationTable.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/TessellationTable.c (revision 37067) @@ -0,0 +1,573 @@ +# include "dvo.h" + +# define GET_COLUMN_NEW(OUT,NAME,TYPE) \ + TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \ + myAssert (!strcmp(type, #TYPE), "wrong column type"); + +# define GET_COLUMN_RAW(OUT,NAME,TYPE) \ + OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \ + myAssert (!strcmp(type, #TYPE), "wrong column type"); + +# define DEBUG 0 + +void TessellationTableInit (TessellationTable *tess, int Ntess) { + + int i; + + for (i = 0; i < Ntess; i++) { + tess[i].Rmin = NAN; + tess[i].Rmax = NAN; + tess[i].Dmin = NAN; + tess[i].Dmax = NAN; + + tess[i].Xo = NAN; + tess[i].Yo = NAN; + tess[i].Ro = NAN; + tess[i].Do = NAN; + + tess[i].dPix = NAN; + + tess[i].dX = 0; + tess[i].dY = 0; + + tess[i].NX_SUB = 0; + tess[i].NY_SUB = 0; + + tess[i].basename = NULL; + tess[i].Nbasename = 0; + + tess[i].projectIDoff = 0; + tess[i].skycellIDoff = 0; + + tess[i].type = TESS_NONE; + tess[i].tree = NULL; + } + return; +} + +// backwards compatible load : if the first table is a BoundaryTree, not a TessellationTable, just load that. +TessellationTable *TessellationTableLoad(char *filename, int *Ntess) { + + int i, Ncol; + off_t Nrow; + char type[16]; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + header.buffer = NULL; + matrix.buffer = NULL; + ftable.buffer = NULL; + theader.buffer = NULL; + TessellationTable *tess = NULL; + *Ntess = 0; + + FILE *f = fopen (filename, "r"); + if (!f) { + fprintf (stderr, "ERROR: cannot open image subset file %s\n", filename); + return NULL; + } + + /* load in PHU segment (ignore) */ + if (!gfits_fread_header (f, &header)) { + if (DEBUG) fprintf (stderr, "can't read image subset header\n"); + goto escape; + } + if (!gfits_fread_matrix (f, &matrix, &header)) { + if (DEBUG) fprintf (stderr, "can't read image subset matrix\n"); + goto escape; + } + + ftable.header = &theader; + + // load data for this header + if (!gfits_load_header (f, &theader)) goto escape; + + // what kind of table have I just read (if any!) + char extname[64]; + gfits_scan (&theader, "EXTNAME", "%s", 1, extname); + + // is this a BoundaryTree? if so, it must be stand-alone: load just that and generate a + // containing TessellationTable. + if (!strcmp(extname, "ZONE_DATA")) { + BoundaryTree *tree = BoundaryTreeRead (&header, &theader, f); + gfits_free_header (&theader); + gfits_free_header (&header); + gfits_free_matrix (&matrix); + fclose (f); + + ALLOCATE (tess, TessellationTable, 1); + TessellationTableInit (tess, 1); + tess[0].tree = tree; + tess[0].type = TESS_RINGS; + tess[0].Rmin = 0; + tess[0].Rmax = 360; + tess[0].Dmin = -90; + tess[0].Dmax = +90; + *Ntess = 1; + return tess; + } + + if (strcmp(extname, "TESS_DATA")) { + fprintf (stderr, "header is neither ZONE_DATA nor TESS_DATA, problem with file\n"); + goto escape; + } + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftable, FALSE)) goto escape; + + // need to create and assign to flat-field correction + GET_COLUMN_NEW(Ro, "RA", double); + GET_COLUMN_NEW(Do, "DEC", double); + GET_COLUMN_NEW(Xo, "X_CENT", double); + GET_COLUMN_NEW(Yo, "Y_CENT", double); + GET_COLUMN_NEW(dX, "X_GRID", int); + GET_COLUMN_NEW(dY, "Y_GRID", int); + GET_COLUMN_NEW(Rmin, "R_MIN", double); + GET_COLUMN_NEW(Rmax, "R_MAX", double); + GET_COLUMN_NEW(Dmin, "D_MIN", double); + GET_COLUMN_NEW(Dmax, "D_MAX", double); + GET_COLUMN_NEW(dPix, "SCALE", double); + GET_COLUMN_NEW(NX_SUB, "NX_SUB", int); + GET_COLUMN_NEW(NY_SUB, "NY_SUB", int); + GET_COLUMN_NEW(TYPE, "TYPE", int); + + GET_COLUMN_NEW(PROJECT_ID_OFF, "PROJECT_ID_OFF", int); + GET_COLUMN_NEW(SKYCELL_ID_OFF, "SKYCELL_ID_OFF", int); + + GET_COLUMN_NEW(BASENAME, "BASENAME", char); + + *Ntess = Nrow; + ALLOCATE (tess, TessellationTable, *Ntess); + for (i = 0; i < *Ntess; i++) { + tess[i].Ro = Ro[i] ; + tess[i].Do = Do[i] ; + tess[i].Xo = Xo[i] ; + tess[i].Yo = Yo[i] ; + tess[i].dX = dX[i] ; + tess[i].dY = dY[i] ; + tess[i].Rmin = Rmin[i] ; + tess[i].Rmax = Rmax[i] ; + tess[i].Dmin = Dmin[i] ; + tess[i].Dmax = Dmax[i] ; + tess[i].dPix = dPix[i] ; + tess[i].NX_SUB = NX_SUB[i]; + tess[i].NY_SUB = NY_SUB[i]; + tess[i].type = TYPE[i]; + + tess[i].projectIDoff = PROJECT_ID_OFF[i]; + tess[i].skycellIDoff = SKYCELL_ID_OFF[i]; + + ALLOCATE (tess[i].basename, char, BOUNDARY_TREE_NAME_LENGTH); + memcpy (tess[i].basename, &BASENAME[i*BOUNDARY_TREE_NAME_LENGTH], BOUNDARY_TREE_NAME_LENGTH); + tess[i].Nbasename = strlen (tess[i].basename); + + tess[i].tree = NULL; + } + + free(Ro ); + free(Do ); + free(Xo ); + free(Yo ); + free(dX ); + free(dY ); + free(Rmin ); + free(Rmax ); + free(Dmin ); + free(Dmax ); + free(dPix ); + free(NX_SUB); + free(NY_SUB); + free(TYPE); + + free(PROJECT_ID_OFF); + free(SKYCELL_ID_OFF); + + gfits_free_header (&theader); + gfits_free_table (&ftable); + + // fprintf (stderr, "loaded data for %lld projection cell\n", (long long) *Ntess); + + /*** check for a RINGS entry ***/ + + // find the RINGS tessellation (if present) + TessellationTable *rings = NULL; + for (i = 0; i < *Ntess; i++) { + if (tess[i].type == TESS_LOCAL) continue; + if (tess[i].type != TESS_RINGS) continue; + rings = &tess[i]; + } + + if (!rings) { + fclose (f); + gfits_free_header (&header); + gfits_free_matrix (&matrix); + return (tess); + } + + // load data for this header, or exit + if (!gfits_load_header (f, &theader)) { + fprintf (stderr, "warning : RINGS tessellation listed in table but not present\n"); + gfits_free_header (&header); + gfits_free_matrix (&matrix); + return tess; + } + + // what kind of table have I just read (if any!) + gfits_scan (&theader, "EXTNAME", "%s", 1, extname); + + if (strcmp(extname, "ZONE_DATA")) { + fprintf (stderr, "warning : RINGS tessellation listed in table but not present\n"); + gfits_free_header (&theader); + gfits_free_header (&header); + gfits_free_matrix (&matrix); + return tess; + } + + // is this a BoundaryTree? if so, it must be stand-alone: load just that and generate a + // containing TessellationTable. + BoundaryTree *tree = BoundaryTreeRead (&header, &theader, f); + gfits_free_header (&theader); + gfits_free_header (&header); + gfits_free_matrix (&matrix); + fclose (f); + + rings->tree = tree; + return tess; + +escape: + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + if (tess) free (tess); + + fclose (f); + return NULL; +} + +// we are passed a TessellationTable structure, write it to a FITS table. +// if one of the tess entries is a RINGS tessellation, write it as a boundary tree +int TessellationTableSave(char *filename, TessellationTable *tess, int Ntess) { + + int i; + Header header; + Matrix matrix; + + gfits_init_header (&header); + header.extend = TRUE; + gfits_create_header (&header); + gfits_create_matrix (&header, &matrix); + + FILE *f = fopen (filename, "w"); + if (!f) { + fprintf (stderr, "ERROR: cannot open boundary tess file for output %s\n", filename); + return FALSE; + } + + // find the RINGS tessellation (if present) + BoundaryTree *rings = NULL; + for (i = 0; i < Ntess; i++) { + if (tess[i].type == TESS_LOCAL) continue; + if (tess[i].type != TESS_RINGS) continue; + rings = tess[i].tree; + } + + // if we have a RINGS entry, we need to save some information in the header to define the layout + if (rings) { + gfits_modify (&header, "DEC_ORI", "%lf", 1, rings->DEC_origin); + gfits_modify (&header, "DEC_OFF", "%lf", 1, rings->DEC_offset); + + gfits_modify (&header, "NX_SUB", "%d", 1, rings->NX_SUB); + gfits_modify (&header, "NY_SUB", "%d", 1, rings->NY_SUB); + gfits_modify (&header, "PIXSCALE", "%lf", 1, rings->dPix); + } + + gfits_fwrite_header (f, &header); + gfits_fwrite_matrix (f, &matrix); + gfits_free_header (&header); + gfits_free_matrix (&matrix); + + /** LOCAL tessellation table info **/ + Header theader; + FTable ftable; + + gfits_create_table_header (&theader, "BINTABLE", "TESS_DATA"); + + gfits_define_bintable_column (&theader, "D", "RA", "ra (J2000) of cell center", "degree", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "DEC", "dec (J2000) of cell center", "degree", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "X_CENT", "projection cell center pixel", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "Y_CENT", "projection cell center pixel", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "X_GRID", "skycell grid spacing", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "Y_GRID", "skycell grid spacing", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "R_MIN", "RA limit (lower)", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "R_MAX", "RA limit (upper)", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "D_MIN", "DEC limit (lower)", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "D_MAX", "DEC limit (upper)", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "SCALE", "pixel scale for projection cell", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "NX_SUB", "skycell subdivision in x", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "NY_SUB", "skycell subdivision in y", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "TYPE", "type of tessellation", "none", 1.0, 0.0); + + gfits_define_bintable_column (&theader, "J", "PROJECT_ID_OFF", "offset in image name to projection cell ID", "none", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "SKYCELL_ID_OFF", "offset in image name to skycell ID", "none", 1.0, 0.0); + + char fmt[16]; + snprintf (fmt, 16, "%dA", BOUNDARY_TREE_NAME_LENGTH); + gfits_define_bintable_column (&theader, fmt, "BASENAME", "image base name", "none", 1.0, 0.0); + + // generate the output array that carries the data + gfits_create_table (&theader, &ftable); + + // int Nout = (rings == NULL) ? Ntess : Ntess - 1; + int Nout = Ntess; + + // create intermediate storage arrays + // NOTE: we have to unroll the 2D arrays in tess into 1D arrays + double *Ro ; ALLOCATE (Ro , double, Nout); + double *Do ; ALLOCATE (Do , double, Nout); + double *Xo ; ALLOCATE (Xo , double, Nout); + double *Yo ; ALLOCATE (Yo , double, Nout); + int *dX ; ALLOCATE (dX , int, Nout); + int *dY ; ALLOCATE (dY , int, Nout); + double *Rmin ; ALLOCATE (Rmin , double, Nout); + double *Rmax ; ALLOCATE (Rmax , double, Nout); + double *Dmin ; ALLOCATE (Dmin , double, Nout); + double *Dmax ; ALLOCATE (Dmax , double, Nout); + double *dPix ; ALLOCATE (dPix , double, Nout); + int *NX_SUB ; ALLOCATE (NX_SUB, int, Nout); + int *NY_SUB ; ALLOCATE (NY_SUB, int, Nout); + int *TYPE ; ALLOCATE (TYPE, int, Nout); + + int *PROJECT_ID_OFF; ALLOCATE (PROJECT_ID_OFF, int, Nout); + int *SKYCELL_ID_OFF; ALLOCATE (SKYCELL_ID_OFF, int, Nout); + + char *BASENAME ; ALLOCATE (BASENAME, char, Nout*BOUNDARY_TREE_NAME_LENGTH); + memset (BASENAME, 0, Nout*BOUNDARY_TREE_NAME_LENGTH); + + // assign the storage arrays + // XXX I was not writing out the RINGS tess entry, but that probably is not useful (drop + // N vs i in future?) + int N = 0; + for (i = 0; i < Ntess; i++) { + // if (tess->type != TESS_LOCAL) continue; + Ro[N] = tess[i].Ro; + Do[N] = tess[i].Do; + Xo[N] = tess[i].Xo; + Yo[N] = tess[i].Yo; + dX[N] = tess[i].dX; + dY[N] = tess[i].dY; + Rmin[N] = tess[i].Rmin; + Rmax[N] = tess[i].Rmax; + Dmin[N] = tess[i].Dmin; + Dmax[N] = tess[i].Dmax; + dPix[N] = tess[i].dPix; + NX_SUB[N] = tess[i].NX_SUB; + NY_SUB[N] = tess[i].NY_SUB; + TYPE[N] = tess[i].type; + + PROJECT_ID_OFF[N] = tess[i].projectIDoff; + SKYCELL_ID_OFF[N] = tess[i].skycellIDoff; + + if (tess[i].basename) { + memcpy(&BASENAME[N*BOUNDARY_TREE_NAME_LENGTH], tess[i].basename, BOUNDARY_TREE_NAME_LENGTH); + } + + N++; + } + + // add the columns to the output array + gfits_set_bintable_column (&theader, &ftable, "RA", Ro, Nout); + gfits_set_bintable_column (&theader, &ftable, "DEC", Do, Nout); + gfits_set_bintable_column (&theader, &ftable, "X_CENT", Xo, Nout); + gfits_set_bintable_column (&theader, &ftable, "Y_CENT", Yo, Nout); + gfits_set_bintable_column (&theader, &ftable, "X_GRID", dX, Nout); + gfits_set_bintable_column (&theader, &ftable, "Y_GRID", dY, Nout); + gfits_set_bintable_column (&theader, &ftable, "R_MIN", Rmin, Nout); + gfits_set_bintable_column (&theader, &ftable, "R_MAX", Rmax, Nout); + gfits_set_bintable_column (&theader, &ftable, "D_MIN", Dmin, Nout); + gfits_set_bintable_column (&theader, &ftable, "D_MAX", Dmax, Nout); + gfits_set_bintable_column (&theader, &ftable, "SCALE", dPix, Nout); + gfits_set_bintable_column (&theader, &ftable, "NX_SUB", NX_SUB, Nout); + gfits_set_bintable_column (&theader, &ftable, "NY_SUB", NY_SUB, Nout); + gfits_set_bintable_column (&theader, &ftable, "TYPE", TYPE, Nout); + + gfits_set_bintable_column (&theader, &ftable, "PROJECT_ID_OFF", PROJECT_ID_OFF, Nout); + gfits_set_bintable_column (&theader, &ftable, "SKYCELL_ID_OFF", SKYCELL_ID_OFF, Nout); + gfits_set_bintable_column (&theader, &ftable, "BASENAME", BASENAME, Nout); + + free (Ro ); + free (Do ); + free (Xo ); + free (Yo ); + free (dX ); + free (dY ); + free (Rmin ); + free (Rmax ); + free (Dmin ); + free (Dmax ); + free (dPix ); + free (NX_SUB); + free (NY_SUB); + free (TYPE); + + free (PROJECT_ID_OFF); + free (SKYCELL_ID_OFF); + free (BASENAME); + + gfits_fwrite_Theader (f, &theader); + gfits_fwrite_table (f, &ftable); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + if (rings) { + BoundaryTreeWrite(f, rings); + } + + fclose (f); + + return TRUE; +} + +int TessellationLocalProjection (double *x, double *y, double r, double d, TessellationTable *tess) { + + double Xo = tess->Xo; + double Yo = tess->Yo; + double Ro = tess->Ro; + double Do = tess->Do; + double dPix = tess->dPix; + + // this block only depends on Ro, Do + + double sdp = sin(RAD_DEG*Do); + double cdp = cos(RAD_DEG*Do); + double salp = sin(RAD_DEG*(r - Ro)); + double calp = cos(RAD_DEG*(r - Ro)); + double sdel = sin(RAD_DEG*d); + double cdel = cos(RAD_DEG*d); + + double stht = sdel*sdp + cdel*cdp*calp; /* sin(theta) */ + double sphi = cdel*salp; /* = cos(theta)*sin(phi) */ + double cphi = cdel*sdp*calp - sdel*cdp; /* = cos(theta)*cos(phi) */ + + // defines the TAN projection (one of zenithal projections available, libdvo/src/coordops.c + // R = cot (theta) = cos(theta) / sin(theta) + double L, M; + if (stht == 0) { + double Rc = hypot(sphi, cphi); + L = 180.0 * sphi / Rc; + M = 180.0 * cphi / Rc; + } else { + L = +DEG_RAD * sphi / stht; + M = -DEG_RAD * cphi / stht; + } + + // scale, rotation, parity: + // rotation == 0.0 (pc1_1 == pc2_2 == 1.0, pc1_2 = pc2_1 = 0.0) + + // if there were rotation or parity: + // Ro = (coords[0].pc1_1*coords[0].pc2_2 - coords[0].pc1_2*coords[0].pc2_1); + // Xo = (coords[0].pc2_2*L - coords[0].pc1_2*M) / Ro; + // Yo = (coords[0].pc1_1*M - coords[0].pc2_1*L) / Ro; + + double X = L; + double Y = M; + + // scale is dPix + + *x = Xo - X / dPix; + *y = Yo + Y / dPix; + + return TRUE; +} + +static int Nfail = 0; + +// for the given ra,dec : find the valid tessellation and the containing projection / skycell IDs +int TessellationPrimaryCellIDs (TessellationTable *tess, int Ntess, int *tessID, int *projID, int *skycellID, double ra, double dec) { + + int i, zone, band; + + *tessID = -1; + *projID = -1; + *skycellID = -1; + + if (!tess) return FALSE; + + // find the tessellation which includes this location + int myTess = -1; + for (i = 0; i < Ntess; i++) { + if (ra < tess[i].Rmin) continue; + if (ra >= tess[i].Rmax) continue; + if (dec < tess[i].Dmin) continue; + if (dec >= tess[i].Dmax) continue; + myTess = i; + break; + } + if (myTess < 0) { + if (Nfail < 100) { + fprintf (stderr, "no matching tessellation @ %f,%f\n", ra, dec); + } + Nfail ++; + return FALSE; + } + + if (tess[myTess].type == TESS_NONE) { + if (Nfail < 100) { + fprintf (stderr, "tess has invalid type\n"); + Nfail ++; + } + return FALSE; + } + + if (tess[myTess].type == TESS_LOCAL) { + // I have ra, dec, and the primary projection cell. In order to choose the primary skycell, + // I just need to project to ra,dec to X,Y based on the center of the cell and then get the subdivision right. + + double x = 0.0; + double y = 0.0; + TessellationLocalProjection (&x, &y, ra, dec, &tess[myTess]); + + int xi = x / tess[myTess].dX; + int yi = y / tess[myTess].dY; + int N = xi + tess[myTess].NX_SUB * yi; + + *tessID = myTess; + *projID = 0; + *skycellID = N; + + // *projID = tess[myTess].projID :: NOTE : The projection cell may be non-zero like eg + // STS. However, I'm not certain we are going to implement it like this. + + return TRUE; + } + + if (tess[myTess].type == TESS_RINGS) { + if (!BoundaryTreeCellCoords (tess[myTess].tree, &zone, &band, ra, dec)) { + fprintf (stderr, "mismatch!\n"); + return FALSE; + } + + // I have ra, dec, and the primary projection cell. In order to choose the primary skycell, + // I just need to project to ra,dec to X,Y based on the center of the cell and then get the subdivision right. + + double x = 0.0; + double y = 0.0; + BoundaryTreeProjection (&x, &y, ra, dec, tess[myTess].tree, zone, band); + + int xi = x / tess[myTess].tree->dX[zone][band]; + int yi = y / tess[myTess].tree->dY[zone][band]; + int N = xi + tess[myTess].tree->NX_SUB * yi; + + *tessID = myTess; + *projID = tess[myTess].tree->projID[zone][band]; + *skycellID = N; + + return TRUE; + } + + fprintf (stderr, "invalid tessellation type!\n"); + return FALSE; +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/cmf-ps1-dv3.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/cmf-ps1-dv3.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/cmf-ps1-dv3.c (revision 37067) @@ -2,5 +2,5 @@ /*** note : this file is derived from the autocode version, but is modified because - the forma does not match with structure byte boundaries ***/ + the format does not match with structure byte boundaries ***/ /* if we are not correctly including the ohana headers, this will fail */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/cmf-ps1-sv3.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/cmf-ps1-sv3.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/cmf-ps1-sv3.c (revision 37067) @@ -0,0 +1,375 @@ +# include "dvo.h" + +// ST_SIZE is the size of the structure (must be modulo 8 bytes) +// FT_SIZE is the size of a row in the FITS table (inpt or output) +# define ST_SIZE 224 +# define FT_SIZE 220 + +// this function is based on the one generated by the autocode of cmf-ps1-v5.d +unsigned char *gfits_convert_CMF_PS1_SV3 (unsigned char *input, off_t size, off_t nitems, char toStruct) { + + off_t i; + unsigned char *byte = NULL; + unsigned char *output = NULL; + + if (size != ST_SIZE) { + fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_SV3: "OFF_T_FMT" vs %d\n", size, ST_SIZE); + return (NULL); + } + + /* provide initial values to avoid compiler warnings for non-BYTE_SWAP arch */ + i = 0; + + // BYTE & WORD swap below is valid for the structure, not the FITS buffer + if (toStruct) { + // allocate a new output data buffer + ALLOCATE (output, unsigned char, nitems*sizeof(CMF_PS1_SV3)); + unsigned char *inbyte = input; + unsigned char *otbyte = output; + + // the data in the input table does not line up with the output structure: copy carefully. + for (i = 0; i < nitems; i++, inbyte += FT_SIZE, otbyte += ST_SIZE) { + memcpy (&otbyte[ 0], &inbyte[ 0], 76); // IPP_IDET to CAL_PSF_MAG_SIG + memcpy (&otbyte[ 80], &inbyte[ 76], 16); // RA_PSF, DEC_PSF + memcpy (&otbyte[ 76], &inbyte[ 92], 8); // PEAK_FLUX_AS_MAG + memcpy (&otbyte[ 96], &inbyte[ 96], 124); // SKY to PADDING + memset (&otbyte[220], 0, 4); // PADDING2 + } + + // after we have moved around PEAK_FLUX_AS_MAG, RA_PSF, DEC_PSF, we can swap as needed for this platform + byte = output; + } else { + byte = input; + } + +# ifdef BYTE_SWAP + char tmp = 0; + for (i = 0; i < nitems; i++, byte += ST_SIZE) { + /** BYTE SWAP **/ + SWAP_WORD (0); // IPP_IDET + SWAP_WORD (4); // X_PSF + SWAP_WORD (8); // Y_PSF + SWAP_WORD (12); // X_PSF_SIG + SWAP_WORD (16); // Y_PSF_SIG + SWAP_WORD (20); // POSANGLE + SWAP_WORD (24); // PLTSCALE + SWAP_WORD (28); // PSF_INST_MAG + SWAP_WORD (32); // PSF_INST_MAG_SIG + SWAP_WORD (36); // PSF_INST_FLUX + SWAP_WORD (40); // PSF_INST_FLUX_SIG + SWAP_WORD (44); // AP_MAG + SWAP_WORD (48); // AP_MAG_RAW + SWAP_WORD (52); // AP_MAG_RADIUS + SWAP_WORD (56); // AP_FLUX + SWAP_WORD (60); // AP_FLUX_SIG + SWAP_WORD (64); // AP_NPIX + SWAP_WORD (68); // CAL_PSF_MAG + SWAP_WORD (72); // CAL_PSF_MAG_SIG + + // order in structure + SWAP_WORD (76); // PEAK_FLUX_AS_MAG + SWAP_DBLE (80); // RA_PSF + SWAP_DBLE (88); // DEC_PSF + + // order in FITS table + // SWAP_WORD (76); // RA_PSF + // SWAP_DBLE (84); // DEC_PSF + // SWAP_DBLE (92); // PEAK_FLUX_AS_MAG + + SWAP_WORD (96); // SKY + SWAP_WORD (100); // SKY_SIG + SWAP_WORD (104); // PSF_CHISQ + SWAP_WORD (108); // CR_NSIGMA + SWAP_WORD (112); // EXT_NSIGMA + SWAP_WORD (116); // PSF_MAJOR + SWAP_WORD (120); // PSF_MINOR + SWAP_WORD (124); // PSF_THETA + SWAP_WORD (128); // PSF_CORE + SWAP_WORD (132); // PSF_FWHM_MAJ + SWAP_WORD (136); // PSF_FWHM_MIN + SWAP_WORD (140); // PSF_QF + SWAP_WORD (144); // PSF_QF_PERFECT + SWAP_WORD (148); // PSF_NDOF + SWAP_WORD (152); // PSF_NPIX + SWAP_WORD (156); // MOMENTS_XX + SWAP_WORD (160); // MOMENTS_XY + SWAP_WORD (164); // MOMENTS_YY + SWAP_WORD (168); // MOMENTS_M3C + SWAP_WORD (172); // MOMENTS_M3S + SWAP_WORD (176); // MOMENTS_M4C + SWAP_WORD (180); // MOMENTS_M4S + SWAP_WORD (184); // MOMENTS_R1 + SWAP_WORD (188); // MOMENTS_RH + SWAP_WORD (192); // KRON_FLUX + SWAP_WORD (196); // KRON_FLUX_ERR + SWAP_WORD (200); // KRON_FLUX_INNER + SWAP_WORD (204); // KRON_FLUX_OUTER + SWAP_WORD (208); // FLAGS + SWAP_WORD (212); // FLAGS2 + SWAP_BYTE (216); // N_FRAMES + SWAP_BYTE (218); // PADDING + SWAP_WORD (220); // PADDING2 + } +# endif + + // BYTE & WORD swap below is valid for the structure, not the FITS buffer + if (!toStruct) { + // allocate a new output data buffer + ALLOCATE (output, unsigned char, nitems*FT_SIZE); + unsigned char *inbyte = input; + unsigned char *otbyte = output; + + // the data in the input table does not line up with the output structure: copy carefully. + for (i = 0; i < nitems; i++, inbyte += ST_SIZE, otbyte += FT_SIZE) { + memcpy (&otbyte[ 0], &inbyte[ 0], 76); // IPP_IDET to CAL_PSF_MAG_SIG + memcpy (&otbyte[ 76], &inbyte[ 80], 16); // RA_PSF, DEC_PSF + memcpy (&otbyte[ 92], &inbyte[ 76], 4); // PEAK_FLUX_AS_MAG + memcpy (&otbyte[ 96], &inbyte[ 96], 124); // SKY to PADDING + } + } + + return (output); +} + +int gfits_table_scale_storage_CMF_PS1_SV3 (CMF_PS1_SV3 *data, off_t Ndata) { + + off_t i; + for (i = 0; i < Ndata; i++) { + data[i].detID -= 0x80000000; + data[i].flags -= 0x80000000; + data[i].flags2 -= 0x80000000; + data[i].nFrames -= 0x8000; + } + return TRUE; +} + +/*** add test of EXTNAME and header-defined columns? ***/ +/* return internal structure representation */ +CMF_PS1_SV3 *gfits_table_get_CMF_PS1_SV3 (FTable *ftable, off_t *Ndata, char *swapped) { + + int Ncols; + CMF_PS1_SV3 *data; + + Ncols = ftable[0].header[0].Naxis[0]; + if (Ncols != FT_SIZE) { + fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, FT_SIZE); + return NULL; + } + + *Ndata = ftable[0].header[0].Naxis[1]; + data = (CMF_PS1_SV3 *) ftable[0].buffer; + if ((swapped == NULL) || (*swapped == FALSE)) { + unsigned char *newdata = gfits_convert_CMF_PS1_SV3 ((unsigned char *) data, sizeof (CMF_PS1_SV3), *Ndata, TRUE); + if (!newdata) return NULL; + free (ftable[0].buffer); + ftable[0].buffer = (char *) newdata; + data = (CMF_PS1_SV3 *) ftable[0].buffer; + gfits_table_scale_storage_CMF_PS1_SV3 (data, *Ndata); + if (swapped != NULL) *swapped = TRUE; + } + return (data); +} + +int gfits_table_set_CMF_PS1_SV3 (FTable *ftable, CMF_PS1_SV3 *data, off_t Ndata) { + + Header *header; + + header = ftable[0].header; + + /* create table header */ + if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_SV3")) return (FALSE); + + /* define table layout */ + /** TABLE DEFINITION **/ + gfits_define_bintable_column (header, "J", "IPP_IDET", "detection ID ", "", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "X_PSF", "x coord", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "Y_PSF", "y coord", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "X_PSF_SIG", "x coord error", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "Y_PSF_SIG", "y coord error", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "POSANGLE", "Posangle at source", "degrees", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PLTSCALE", "Plate Scale at source", "arcsec/pixel", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_INST_MAG", "inst mags", "mags", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_INST_MAG_SIG", "inst mag error", "mags", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_INST_FLUX", "psf flux", "counts", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_INST_FLUX_SIG", "psf flux error", "counts ", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "AP_MAG", "standard aperture mag", "mags", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "AP_MAG_RAW", "raw aperture mag", "mags", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "AP_MAG_RADIUS", "radius used for fit", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "AP_FLUX", "aperture flux", "counts", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "AP_FLUX_SIG", "error on ap flux", "counts", 1.0, 0.0); + gfits_define_bintable_column (header, "J", "AP_NPIX", "pixels used for aper", "", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "CAL_PSF_MAG", "calibrated psf mag", "mags", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "CAL_PSF_MAG_SIG", "zero point scatter", "mags", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PEAK_FLUX_AS_MAG", "peak flux as a mag", "mags", 1.0, 0.0); + gfits_define_bintable_column (header, "D", "RA_PSF", "PSF RA coord", "degrees", 1.0, 0.0); + gfits_define_bintable_column (header, "D", "DEC_PSF", "PSF DEC coord", "degrees", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "SKY", "sky flux", "cnts/sec", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "SKY_SIG", "sky flux error", "cnts/sec", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_CHISQ", "psf fit chisq", "", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "CR_NSIGMA", "Nsigma deviations from PSF to CF", "", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "EXT_NSIGMA", "Nsigma deviations from PSF to EXT", "", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_MAJOR", "psf fit major axis", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_MINOR", "psf fit minor axis", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_THETA", "ellipse angle", "degrees", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_CORE", "extra PSF parameter", "unitless", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_FWHM_MAJ", "true fwhm of psf", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_FWHM_MIN", "true fwhm (minor)", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_QF", "quality factor", "", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "PSF_QF_PERFECT", "quality factor perfect", "", 1.0, 0.0); + gfits_define_bintable_column (header, "J", "PSF_NDOF", "psf degrees of freedom", "", 1.0, 0.0); + gfits_define_bintable_column (header, "J", "PSF_NPIX", "psf number of pixels", "", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "MOMENTS_XX", "second moment X", "pixels^2", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "MOMENTS_XY", "second moment Y", "pixels^2", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "MOMENTS_YY", "second moment XY", "pixels^2", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "MOMENTS_M3C", "third moment cos(t)", "pixels^3", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "MOMENTS_M3S", "third moment sin(t)", "pixels^3", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "MOMENTS_M4C", "fourth moment cos(t)", "pixels^4", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "MOMENTS_M4S", "fourth moment sin(t)", "pixels^4", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "MOMENTS_R1", "first radial moment", "pixels", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "MOMENTS_RH", "half radial moment", "pixels^1/2", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "KRON_FLUX", "kron flux", "counts", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "KRON_FLUX_ERR", "kron flux error", "counts", 1.0, 0.0); + gfits_define_bintable_column (header, "E", "KRON_FLUX_INNER", "kron flux 1 + +/* note that Coords.ctype carries the DEC (ctype2) value */ static Coords mosaic; @@ -621,4 +623,5 @@ /* modifications to the ctype? */ + /* note that Coords.ctype carries the DEC (ctype2) value */ OldAIPS = FALSE; gfits_modify (header, "CTYPE2", "%s", 1, coords[0].ctype); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbCheckStack.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbCheckStack.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbCheckStack.c (revision 37067) @@ -7,6 +7,4 @@ // these would be better done using bit values to test for field? temp? float? // - -#define OPIHI_INT 1 int dbCheckStack (dbStack *stack, int Nstack, int table, dbField **inFields, int *inNfields) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractAverages.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractAverages.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractAverages.c (revision 37067) @@ -52,6 +52,5 @@ dbValue dbExtractAverages (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) { - off_t i; - int Nsec; + // off_t i; dbValue value; @@ -153,4 +152,17 @@ break; + case AVE_PSF_QF: + value.Flt = average[0].psfQF; + break; + case AVE_PSF_QF_PERF: + value.Flt = average[0].psfQFperf; + break; + case AVE_STARGAL: + value.Flt = average[0].stargal; + break; + case AVE_REF_COLOR: + value.Flt = average[0].refColorBlue; + break; + case AVE_OBJ_FLAGS: value.Int = average[0].flags; @@ -169,5 +181,125 @@ break; - case AVE_MAG: + case AVE_PHOT: + // if we request mag:ave, use equiv for photcode (ie a given measure, say GPC1.g.XY01, will return g for mag:ave) + if (field->photcode->type == PHOT_MAG) { + // this is an error + break; + } + + // if we ask for 2MASS_K, etc (REF values), return NAN unless measure->code matches + if (field->photcode->type == PHOT_REF) { + // need to ensure measure exists. + break; + } + + // if we ask for GPC1.g.XY03:rel, etc (DEP values), return NAN unless measure->code matches + if (field->photcode->type == PHOT_DEP) { + // again. + break; + } + + switch (field->magOption) { + case MAG_OPTION_MAG: + switch (field->magLevel) { + case MAG_LEVEL_AVE: + value.Flt = PhotAve (field->photcode, average, secfilt, field->magClass, field->magSource); + break; + case MAG_LEVEL_REF: + // why is measure needed here? + // PhotRef (field->photcode, average, secfilt, measure, field->magClass, field->magSource); + break; + case MAG_LEVEL_INST: + case MAG_LEVEL_CAT: + case MAG_LEVEL_SYS: + case MAG_LEVEL_REL: + case MAG_LEVEL_CAL: + case MAG_LEVEL_NONE: + break; + } + break; + + case MAG_OPTION_ERR: + switch (field->magLevel) { + case MAG_LEVEL_AVE: + case MAG_LEVEL_REF: + value.Flt = PhotAveErr (field->photcode, average, secfilt, field->magClass, field->magSource); + break; + case MAG_LEVEL_INST: + case MAG_LEVEL_CAT: + case MAG_LEVEL_SYS: + case MAG_LEVEL_REL: + case MAG_LEVEL_CAL: + case MAG_LEVEL_NONE: + break; + } + break; + + case MAG_OPTION_FLUX: + switch (field->magLevel) { + case MAG_LEVEL_AVE: + value.Flt = PhotFluxAve (field->photcode, average, secfilt, field->magClass, field->magSource); + break; + case MAG_LEVEL_REF: + // value.Flt = PhotFluxRef (equiv, average, secfilt, measure, field->magClass, field->magSource); + break; + case MAG_LEVEL_INST: + case MAG_LEVEL_CAT: + case MAG_LEVEL_SYS: + case MAG_LEVEL_REL: + case MAG_LEVEL_CAL: + case MAG_LEVEL_NONE: + break; + } + break; + + case MAG_OPTION_FLUX_ERR: + switch (field->magLevel) { + case MAG_LEVEL_AVE: + case MAG_LEVEL_REF: + // value.Flt = PhotFluxAveErr (equiv, average, secfilt, field->magClass, field->magSource); + break; + case MAG_LEVEL_INST: + case MAG_LEVEL_CAT: + case MAG_LEVEL_SYS: + case MAG_LEVEL_REL: + case MAG_LEVEL_CAL: + case MAG_LEVEL_NONE: + break; + } + break; + + case MAG_OPTION_STDEV: + case MAG_OPTION_CHISQ: + case MAG_OPTION_MIN: + case MAG_OPTION_MAX: + case MAG_OPTION_NCODE: { + int Nsec = GetPhotcodeNsec (field->photcode->code); + if (Nsec == -1) break; + value.Int = secfilt[Nsec].Ncode; + break; + } + case MAG_OPTION_NPHOT: { + int Nsec = GetPhotcodeNsec (field->photcode->code); + if (Nsec == -1) break; + value.Int = secfilt[Nsec].Nused; + break; + } + case MAG_OPTION_UC_DIST: + case MAG_OPTION_STACK_DET_ID: + value.Int = PhotStackID (field->photcode, average, secfilt); + break; + case MAG_OPTION_FLAGS: { + int Nsec = GetPhotcodeNsec (field->photcode->code); + if (Nsec == -1) break; + value.Int = secfilt[Nsec].flags; + break; + } + case MAG_OPTION_NONE: + break; + } + break; + +# if (0) switch (field->magMode) { case MAG_AVE: @@ -201,5 +333,5 @@ } } else { - value.Flt = PhotdM (field->photcode, average, secfilt); + value.Flt = PhotAveErr (field->photcode, average, secfilt); } break; @@ -215,5 +347,5 @@ } } else { - Nsec = GetPhotcodeNsec (field->photcode->code); + int Nsec = GetPhotcodeNsec (field->photcode->code); if (Nsec == -1) break; value.Int = secfilt[Nsec].flags; @@ -223,16 +355,30 @@ // XXX push these into dvo_photcode_ops APIs // XXX do I need to allow for conversion to equiv? - Nsec = GetPhotcodeNsec (field->photcode->code); + int Nsec = GetPhotcodeNsec (field->photcode->code); if (Nsec == -1) break; value.Int = secfilt[Nsec].Ncode; break; case MAG_NPHOT: - Nsec = GetPhotcodeNsec (field->photcode->code); + int Nsec = GetPhotcodeNsec (field->photcode->code); if (Nsec == -1) break; value.Int = secfilt[Nsec].Nused; break; + case MAG_APER: + case MAG_APER_AVE: + value.Flt = PhotAperAve (field->photcode, average, secfilt); + break; + + case MAG_APER_REF: + value.Flt = PhotAperRef (field->photcode, average, secfilt, measure); + break; + case MAG_KRON: + case MAG_KRON_AVE: value.Flt = PhotKronAve (field->photcode, average, secfilt); + break; + + case MAG_KRON_REF: + value.Flt = PhotKronRef (field->photcode, average, secfilt, measure); break; @@ -241,9 +387,9 @@ break; - case MAG_20: - value.Flt = PhotM20 (field->photcode, average, secfilt); - break; - case MAG_80: - value.Flt = PhotM80 (field->photcode, average, secfilt); + case MAG_MIN: + value.Flt = PhotMmin (field->photcode, average, secfilt); + break; + case MAG_MAX: + value.Flt = PhotMmax (field->photcode, average, secfilt); break; case MAG_UC_DIST: @@ -269,9 +415,10 @@ break; case AVE_dMAG: - value.Flt = PhotdM (field->photcode, average, secfilt); + value.Flt = PhotAveErr (field->photcode, average, secfilt); break; case AVE_Xm: value.Flt = PhotXm (field->photcode, average, secfilt); break; +# endif case AVE_TYPE: break; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractImages.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractImages.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractImages.c (revision 37067) @@ -69,6 +69,11 @@ if (!haveCelestial) { if (!FindMosaicForImage (image, Nimage, N)) return value; - x = 0.5*image[N].NX; - y = 0.5*image[N].NY; + if (!strcmp(&image[N].coords.ctype[4], "-DIS")) { + x = 0.0; + y = 0.0; + } else { + x = 0.5*image[N].NX; + y = 0.5*image[N].NY; + } XY_to_RD (&RAo, &DECo, x, y, &image[N].coords); haveCelestial = TRUE; @@ -79,6 +84,11 @@ if (!haveCelestial) { if (!FindMosaicForImage (image, Nimage, N)) return value; - x = 0.5*image[N].NX; - y = 0.5*image[N].NY; + if (!strcmp(&image[N].coords.ctype[4], "-DIS")) { + x = 0.0; + y = 0.0; + } else { + x = 0.5*image[N].NX; + y = 0.5*image[N].NY; + } XY_to_RD (&RAo, &DECo, x, y, &image[N].coords); haveCelestial = TRUE; @@ -90,6 +100,11 @@ if (!haveCelestial) { if (!FindMosaicForImage (image, Nimage, N)) return value; - x = 0.5*image[N].NX; - y = 0.5*image[N].NY; + if (!strcmp(&image[N].coords.ctype[4], "-DIS")) { + x = 0.0; + y = 0.0; + } else { + x = 0.5*image[N].NX; + y = 0.5*image[N].NY; + } XY_to_RD (&RAo, &DECo, x, y, &image[N].coords); haveCelestial = TRUE; @@ -104,6 +119,11 @@ if (!haveCelestial) { if (!FindMosaicForImage (image, Nimage, N)) return value; - x = 0.5*image[N].NX; - y = 0.5*image[N].NY; + if (!strcmp(&image[N].coords.ctype[4], "-DIS")) { + x = 0.0; + y = 0.0; + } else { + x = 0.5*image[N].NX; + y = 0.5*image[N].NY; + } XY_to_RD (&RAo, &DECo, x, y, &image[N].coords); haveCelestial = TRUE; @@ -118,6 +138,11 @@ if (!haveCelestial) { if (!FindMosaicForImage (image, Nimage, N)) return value; - x = 0.5*image[N].NX; - y = 0.5*image[N].NY; + if (!strcmp(&image[N].coords.ctype[4], "-DIS")) { + x = 0.0; + y = 0.0; + } else { + x = 0.5*image[N].NX; + y = 0.5*image[N].NY; + } XY_to_RD (&RAo, &DECo, x, y, &image[N].coords); haveCelestial = TRUE; @@ -132,6 +157,11 @@ if (!haveCelestial) { if (!FindMosaicForImage (image, Nimage, N)) return value; - x = 0.5*image[N].NX; - y = 0.5*image[N].NY; + if (!strcmp(&image[N].coords.ctype[4], "-DIS")) { + x = 0.0; + y = 0.0; + } else { + x = 0.5*image[N].NX; + y = 0.5*image[N].NY; + } XY_to_RD (&RAo, &DECo, x, y, &image[N].coords); haveCelestial = TRUE; @@ -344,4 +374,8 @@ value.Int = image[N].nLinkAstrom; break; + + case IMAGE_REF_COLOR: + value.Flt = image[N].refColorBlue; + break; } return (value); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractMeasures.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractMeasures.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractMeasures.c (revision 37067) @@ -90,4 +90,5 @@ dbValue value; double dT; + float dR, dD; Coords *mosaic, *fieldc; @@ -99,8 +100,8 @@ switch (field->ID) { - case MEAS_MAG: { /* magnitudes are already determined above */ + case MEAS_PHOT: { /* magnitudes are already determined above */ PhotCode *myEquiv = GetPhotcodeEquivbyCode (measure[0].photcode); - // if we request mag:ave, use equiv for photcode + // if we request mag:ave, use equiv for photcode (ie a given measure, say GPC1.g.XY01, will return g for mag:ave) if (field->photcode->type == PHOT_MAG) { equiv = myEquiv; @@ -116,18 +117,11 @@ // if we ask for g:ave, or other SEC-level values, return the corresponding field if (field->photcode->type == PHOT_SEC) { - switch (field->magMode) { + switch (field->magLevel) { // measure-like : return non-NAN if measure.equiv.photcode matches field.photcode - case MAG_INST: - case MAG_CAT: - case MAG_SYS: - case MAG_REL: - case MAG_CAL: - case MAG_APER: - case MAG_APER_INST: - case MAG_KRON: - case MAG_KRON_INST: - case MAG_KRON_ERR: - case MAG_ERR: - case MAG_PHOT_FLAGS: + case MAG_LEVEL_INST: + case MAG_LEVEL_CAT: + case MAG_LEVEL_SYS: + case MAG_LEVEL_REL: + case MAG_LEVEL_CAL: equiv = myEquiv; if (equiv && (equiv->code == field->photcode->code)) goto valid_photcode; @@ -135,14 +129,6 @@ // mean-like : return value for the given photcode - case MAG_AVE: - case MAG_REF: - case MAG_CHISQ: - case MAG_AVE_ERR: - case MAG_NCODE: - case MAG_NPHOT: - case MAG_FLUX_PSF: - case MAG_FLUX_PSF_ERR: - case MAG_FLUX_KRON: - case MAG_FLUX_KRON_ERR: + case MAG_LEVEL_AVE: + case MAG_LEVEL_REF: equiv = field->photcode; goto valid_photcode; @@ -156,86 +142,113 @@ valid_photcode: - switch (field->magMode) { - case MAG_INST: - value.Flt = PhotInst (measure); - break; - case MAG_CAT: - value.Flt = PhotCat (measure); - break; - case MAG_SYS: - value.Flt = PhotSys (measure, average, secfilt); - break; - case MAG_REL: - value.Flt = PhotRel (measure, average, secfilt); - break; - case MAG_CAL: - value.Flt = PhotCal (measure, average, secfilt, measure, equiv); - break; - case MAG_AVE: - value.Flt = PhotAve (equiv, average, secfilt); - break; - case MAG_REF: - value.Flt = PhotRef (equiv, average, secfilt, measure); - break; - case MAG_APER: - value.Flt = PhotAper (measure); - break; - case MAG_APER_INST: - value.Flt = PhotAperInst (measure); - break; - case MAG_KRON: - value.Flt = PhotKron (measure); - break; - case MAG_KRON_INST: - value.Flt = PhotKronInst (measure); - break; - case MAG_KRON_ERR: - value.Flt = measure[0].dMkron; - break; - case MAG_ERR: - value.Flt = measure[0].dM; - break; - case MAG_AVE_ERR: - value.Flt = PhotdM (equiv, average, secfilt); - break; - case MAG_PHOT_FLAGS: - if ((field->photcode->type == PHOT_REF) || (field->photcode->type == PHOT_DEP)) { - value.Int = measure[0].photFlags; - } else { - value.Int = 0; + switch (field->magOption) { + case MAG_OPTION_MAG: + switch (field->magLevel) { + case MAG_LEVEL_INST: + value.Flt = PhotInst (measure, field->magClass); + break; + case MAG_LEVEL_CAT: + value.Flt = PhotCat (measure, field->magClass); + break; + case MAG_LEVEL_SYS: + value.Flt = PhotSys (measure, average, secfilt, field->magClass); + break; + case MAG_LEVEL_REL: + value.Flt = PhotRel (measure, average, secfilt, field->magClass); + break; + case MAG_LEVEL_CAL: + value.Flt = PhotCal (measure, average, secfilt, measure, equiv, field->magClass); + break; + case MAG_LEVEL_AVE: + value.Flt = PhotAve (equiv, average, secfilt, field->magClass, field->magSource); + break; + case MAG_LEVEL_REF: + value.Flt = PhotRef (equiv, average, secfilt, measure, field->magClass, field->magSource); + break; + case MAG_LEVEL_NONE: + break; } break; - case MAG_CHISQ: - value.Flt = PhotXm (equiv, average, secfilt); + + case MAG_OPTION_ERR: + switch (field->magLevel) { + case MAG_LEVEL_INST: + case MAG_LEVEL_CAT: + case MAG_LEVEL_SYS: + case MAG_LEVEL_REL: + value.Flt = PhotErr (measure, field->magClass); + break; + case MAG_LEVEL_CAL: + value.Flt = PhotCalErr (measure, field->magClass); + break; + case MAG_LEVEL_AVE: + case MAG_LEVEL_REF: + value.Flt = PhotAveErr (equiv, average, secfilt, field->magClass, field->magSource); + break; + case MAG_LEVEL_NONE: + break; + } break; - case MAG_NCODE: - if (equiv == NULL) { - value.Int = 0; - break; + + case MAG_OPTION_FLUX: + switch (field->magLevel) { + case MAG_LEVEL_INST: + value.Flt = PhotFluxInst (measure, field->magClass); + break; + case MAG_LEVEL_CAT: + value.Flt = PhotFluxCat (measure, field->magClass); + break; + case MAG_LEVEL_SYS: + value.Flt = PhotFluxSys (measure, average, secfilt, field->magClass); + break; + case MAG_LEVEL_REL: + value.Flt = PhotFluxRel (measure, average, secfilt, field->magClass); + break; + case MAG_LEVEL_CAL: + value.Flt = PhotFluxCal (measure, average, secfilt, measure, equiv, field->magClass); + break; + case MAG_LEVEL_AVE: + value.Flt = PhotFluxAve (equiv, average, secfilt, field->magClass, field->magSource); + break; + case MAG_LEVEL_REF: + value.Flt = PhotFluxRef (equiv, average, secfilt, measure, field->magClass, field->magSource); + break; + case MAG_LEVEL_NONE: + break; } - Nsec = GetPhotcodeNsec (equiv->code); - if (Nsec == -1) break; - value.Int = secfilt[Nsec].Ncode; break; - case MAG_NPHOT: - if (equiv == NULL) { - value.Int = 0; - break; + + case MAG_OPTION_FLUX_ERR: + switch (field->magLevel) { + case MAG_LEVEL_INST: + value.Flt = PhotFluxInstErr (measure, field->magClass); + break; + case MAG_LEVEL_CAT: + value.Flt = PhotFluxCatErr (measure, field->magClass); + break; + case MAG_LEVEL_SYS: + case MAG_LEVEL_REL: + case MAG_LEVEL_CAL: + // value.Flt = PhotFluxErr (measure, field->magClass); + break; + case MAG_LEVEL_AVE: + case MAG_LEVEL_REF: + // value.Flt = PhotFluxAveErr (equiv, average, secfilt, field->magClass, field->magSource); + break; + case MAG_LEVEL_NONE: + break; } - Nsec = GetPhotcodeNsec (equiv->code); - if (Nsec == -1) break; - value.Int = secfilt[Nsec].Nused; break; - case MAG_FLUX_PSF: - value.Flt = PhotAveFluxPSF (field->photcode, average, secfilt); - break; - case MAG_FLUX_PSF_ERR: - value.Flt = PhotAvedFluxPSF (field->photcode, average, secfilt); - break; - case MAG_FLUX_KRON: - value.Flt = PhotAveFluxKron (field->photcode, average, secfilt); - break; - case MAG_FLUX_KRON_ERR: - value.Flt = PhotAvedFluxKron (field->photcode, average, secfilt); + + case MAG_OPTION_STDEV: + case MAG_OPTION_CHISQ: + case MAG_OPTION_MIN: + case MAG_OPTION_MAX: + case MAG_OPTION_NCODE: + case MAG_OPTION_NPHOT: + case MAG_OPTION_UC_DIST: + case MAG_OPTION_STACK_DET_ID: + case MAG_OPTION_FLAGS: + case MAG_OPTION_NONE: break; } @@ -243,8 +256,8 @@ } case MEAS_RA: /* OK */ - value.Flt = average[0].R - measure[0].dR / 3600.0; + value.Flt = measure[0].R; break; case MEAS_DEC: /* OK */ - value.Flt = average[0].D - measure[0].dD / 3600.0; + value.Flt = measure[0].D; break; case MEAS_RA_AVE: /* OK */ @@ -257,5 +270,5 @@ case MEAS_GLON: if (!haveGalacticMeas) { - ApplyTransform (&GLON_MEAS, &GLAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_galactic); + ApplyTransform (&GLON_MEAS, &GLAT_MEAS, measure[0].R, measure[0].D, celestial_to_galactic); haveGalacticMeas = TRUE; } @@ -264,5 +277,5 @@ case MEAS_GLAT: if (!haveGalacticMeas) { - ApplyTransform (&GLON_MEAS, &GLAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_galactic); + ApplyTransform (&GLON_MEAS, &GLAT_MEAS, measure[0].R, measure[0].D, celestial_to_galactic); haveGalacticMeas = TRUE; } @@ -271,5 +284,5 @@ case MEAS_ELON: if (!haveEclipticMeas) { - ApplyTransform (&ELON_MEAS, &ELAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_ecliptic); + ApplyTransform (&ELON_MEAS, &ELAT_MEAS, measure[0].R, measure[0].D, celestial_to_ecliptic); haveEclipticMeas = TRUE; } @@ -278,5 +291,5 @@ case MEAS_ELAT: if (!haveEclipticMeas) { - ApplyTransform (&ELON_MEAS, &ELAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_ecliptic); + ApplyTransform (&ELON_MEAS, &ELAT_MEAS, measure[0].R, measure[0].D, celestial_to_ecliptic); haveEclipticMeas = TRUE; } @@ -375,16 +388,18 @@ // the error. case MEAS_RA_OFFSET: /* OK */ - value.Flt = measure[0].dR; + value.Flt = dvoOffsetR (measure, average); break; case MEAS_DEC_OFFSET: /* OK */ - value.Flt = measure[0].dD; + value.Flt = dvoOffsetD (measure, average); break; case MEAS_RA_FIT_OFFSET: /* OK */ dT = (measure[0].t - average[0].Tmean) / (86400*365.25); - value.Flt = average[0].uR * dT + measure[0].dR; + dR = dvoOffsetR (measure, average); + value.Flt = average[0].uR * dT + dR; break; case MEAS_DEC_FIT_OFFSET: /* OK */ dT = (measure[0].t - average[0].Tmean) / (86400*365.25); - value.Flt = average[0].uD * dT + measure[0].dD; + dD = dvoOffsetD (measure, average); + value.Flt = average[0].uD * dT + dD; break; case MEAS_RA_OFFSET_ERR: /* OK */ @@ -458,4 +473,8 @@ case MEAS_PLATESCALE: /* OK */ value.Flt = measure[0].pltscale; + break; + + case MEAS_REF_COLOR: + value.Flt = average[0].refColorBlue; break; @@ -486,6 +505,6 @@ // measure.xccd if we need it Image *image; - ra = average[0].R - measure[0].dR / 3600.0; - dec = average[0].D - measure[0].dD / 3600.0; + ra = measure[0].R; + dec = measure[0].D; image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID); if (image == NULL) break; @@ -501,6 +520,6 @@ { Image *image; - ra = average[0].R - measure[0].dR / 3600.0; - dec = average[0].D - measure[0].dD / 3600.0; + ra = measure[0].R; + dec = measure[0].D; image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID); if (image == NULL) break; @@ -531,11 +550,12 @@ fieldc = MatchFieldMetadata (measure[0].imageID); } else { - fprintf (stderr, "non-parallel Xmos broken\n"); - abort(); + // fprintf (stderr, "non-parallel Xmos broken\n"); + // abort(); // fieldc = MatchField (measure[0].t, measure[0].photcode); + fieldc = MatchFieldMetadata (measure[0].imageID); } if (fieldc == NULL) break; - double Rm = average[0].R - measure[0].dR / 3600.0; - double Dm = average[0].D - measure[0].dD / 3600.0; + double Rm = measure[0].R; + double Dm = measure[0].D; RD_to_XY (&XFIELD_MEAS, &YFIELD_MEAS, Rm, Dm, fieldc); } @@ -547,11 +567,12 @@ fieldc = MatchFieldMetadata (measure[0].imageID); } else { - fprintf (stderr, "non-parallel Xmos broken\n"); - abort(); + // fprintf (stderr, "non-parallel Xmos broken\n"); + // abort(); // fieldc = MatchField (measure[0].t, measure[0].photcode); + fieldc = MatchFieldMetadata (measure[0].imageID); } if (fieldc == NULL) break; - double Rm = average[0].R - measure[0].dR / 3600.0; - double Dm = average[0].D - measure[0].dD / 3600.0; + double Rm = measure[0].R; + double Dm = measure[0].D; RD_to_XY (&XFIELD_MEAS, &YFIELD_MEAS, Rm, Dm, fieldc); } @@ -564,11 +585,12 @@ mosaic = MatchMosaicMetadata (measure[0].imageID); } else { - fprintf (stderr, "non-parallel Xmos broken\n"); - abort(); - mosaic = MatchMosaic (measure[0].t, measure[0].photcode); + // fprintf (stderr, "non-parallel Xmos broken\n"); + // abort(); + // mosaic = MatchMosaic (measure[0].t, measure[0].photcode); + mosaic = MatchMosaicMetadata (measure[0].imageID); } if (mosaic == NULL) break; - double Rm = average[0].R - measure[0].dR / 3600.0; - double Dm = average[0].D - measure[0].dD / 3600.0; + double Rm = measure[0].R; + double Dm = measure[0].D; RD_to_XY (&XMOS_MEAS, &YMOS_MEAS, Rm, Dm, mosaic); } @@ -580,11 +602,12 @@ mosaic = MatchMosaicMetadata (measure[0].imageID); } else { - fprintf (stderr, "non-parallel Xmos broken\n"); - abort(); - mosaic = MatchMosaic (measure[0].t, measure[0].photcode); + // fprintf (stderr, "non-parallel Xmos broken\n"); + // abort(); + // mosaic = MatchMosaic (measure[0].t, measure[0].photcode); + mosaic = MatchMosaicMetadata (measure[0].imageID); } if (mosaic == NULL) break; - double Rm = average[0].R - measure[0].dR / 3600.0; - double Dm = average[0].D - measure[0].dD / 3600.0; + double Rm = measure[0].R; + double Dm = measure[0].D; RD_to_XY (&XMOS_MEAS, &YMOS_MEAS, Rm, Dm, mosaic); } @@ -699,16 +722,16 @@ break; - case MEAS_FLUX_PSF: /* OK */ - value.Flt = measure[0].FluxPSF; - break; - case MEAS_FLUX_PSF_ERR: /* OK */ - value.Flt = measure[0].dFluxPSF; - break; - case MEAS_FLUX_KRON: /* OK */ - value.Flt = measure[0].FluxKron; - break; - case MEAS_FLUX_KRON_ERR: /* OK */ - value.Flt = measure[0].dFluxKron; - break; + // case MEAS_FLUX_PSF: /* OK */ + // value.Flt = measure[0].FluxPSF; + // break; + // case MEAS_FLUX_PSF_ERR: /* OK */ + // value.Flt = measure[0].dFluxPSF; + // break; + // case MEAS_FLUX_KRON: /* OK */ + // value.Flt = measure[0].FluxKron; + // break; + // case MEAS_FLUX_KRON_ERR: /* OK */ + // value.Flt = measure[0].dFluxKron; + // break; } return (value); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbFields.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbFields.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbFields.c (revision 37067) @@ -9,9 +9,4 @@ for (i = 0; i < Nfields; i++) { if (fields[i].name != NULL) free (fields[i].name); - if (fields[i].photcode != NULL) { - if (fields[i].photcode[0].type == PHOT_MAG) { - free (fields[i].photcode); - } - } } free (fields); @@ -24,10 +19,73 @@ field->ID = 0; field->type = OPIHI_FLT; - field->magMode = 0; + + field->magSource = MAG_SRC_NONE; + field->magLevel = MAG_LEVEL_NONE; + field->magClass = MAG_CLASS_NONE; + field->magOption = MAG_OPTION_NONE; + field->photcode = NULL; } +dvoMagSourceType GetMagSource (char *string) { + + if (!strcasecmp (string, "chip")) return (MAG_SRC_CHP); + if (!strcasecmp (string, "warp")) return (MAG_SRC_WRP); + if (!strcasecmp (string, "stack")) return (MAG_SRC_STK); + + if (!strcasecmp (string, "chp")) return (MAG_SRC_CHP); + if (!strcasecmp (string, "wrp")) return (MAG_SRC_WRP); + if (!strcasecmp (string, "stk")) return (MAG_SRC_STK); + + return MAG_SRC_NONE; +} + +dvoMagLevelType GetMagLevel (char *string) { + + if (!strcasecmp (string, "inst")) return (MAG_LEVEL_INST); + if (!strcasecmp (string, "cat")) return (MAG_LEVEL_CAT); + if (!strcasecmp (string, "sys")) return (MAG_LEVEL_SYS); + if (!strcasecmp (string, "rel")) return (MAG_LEVEL_REL); + if (!strcasecmp (string, "cal")) return (MAG_LEVEL_CAL); + if (!strcasecmp (string, "ave")) return (MAG_LEVEL_AVE); + if (!strcasecmp (string, "ref")) return (MAG_LEVEL_REF); + + return MAG_LEVEL_NONE; +} + +dvoMagClassType GetMagClass (char *string) { + + if (!strcasecmp (string, "psf")) return (MAG_CLASS_PSF); + if (!strcasecmp (string, "kron")) return (MAG_CLASS_KRON); + if (!strcasecmp (string, "aper")) return (MAG_CLASS_APER); + if (!strcasecmp (string, "ap")) return (MAG_CLASS_APER); + + return MAG_CLASS_NONE; +} + +dvoMagOptionType GetMagOption (char *string) { + + if (!strcasecmp (string, "mag")) return (MAG_OPTION_MAG); + if (!strcasecmp (string, "err")) return (MAG_OPTION_ERR); + if (!strcasecmp (string, "magerr")) return (MAG_OPTION_ERR); + if (!strcasecmp (string, "flux")) return (MAG_OPTION_FLUX); + if (!strcasecmp (string, "fluxerr")) return (MAG_OPTION_FLUX_ERR); + if (!strcasecmp (string, "stdev")) return (MAG_OPTION_STDEV); + if (!strcasecmp (string, "chisq")) return (MAG_OPTION_CHISQ); + if (!strcasecmp (string, "min")) return (MAG_OPTION_MIN); + if (!strcasecmp (string, "max")) return (MAG_OPTION_MAX); + if (!strcasecmp (string, "ncode")) return (MAG_OPTION_NCODE); + if (!strcasecmp (string, "nphot")) return (MAG_OPTION_NPHOT); + if (!strcasecmp (string, "uc_dist")) return (MAG_OPTION_UC_DIST); + if (!strcasecmp (string, "stack_det_id")) return (MAG_OPTION_STACK_DET_ID); + if (!strcasecmp (string, "flags")) return (MAG_OPTION_FLAGS); + + return MAG_OPTION_NONE; +} + +# if (0) int GetMagMode (char *string) { + // these all imply PSF mags: if (!strcasecmp (string, "inst")) return (MAG_INST); if (!strcasecmp (string, "cat")) return (MAG_CAT); @@ -37,14 +95,45 @@ if (!strcasecmp (string, "ave")) return (MAG_AVE); if (!strcasecmp (string, "ref")) return (MAG_REF); + if (!strcasecmp (string, "err")) return (MAG_ERR); + if (!strcasecmp (string, "aveerr")) return (MAG_AVE_ERR); + + // these are explicit PSF mags: + if (!strcasecmp (string, "psf_inst")) return (MAG_INST); + if (!strcasecmp (string, "psf_cat")) return (MAG_CAT); + if (!strcasecmp (string, "psf_sys")) return (MAG_SYS); + if (!strcasecmp (string, "psf_rel")) return (MAG_REL); + if (!strcasecmp (string, "psf_cal")) return (MAG_CAL); + if (!strcasecmp (string, "psf_ave")) return (MAG_AVE); + if (!strcasecmp (string, "psf_ref")) return (MAG_REF); + if (!strcasecmp (string, "psf_err")) return (MAG_ERR); + if (!strcasecmp (string, "psf_aveerr")) return (MAG_AVE_ERR); + + // these are aper mags: if (!strcasecmp (string, "ap")) return (MAG_APER); if (!strcasecmp (string, "aper")) return (MAG_APER); if (!strcasecmp (string, "aperinst")) return (MAG_APER_INST); if (!strcasecmp (string, "aper_inst")) return (MAG_APER_INST); + if (!strcasecmp (string, "aper_cat")) return (MAG_APER_CAT); + if (!strcasecmp (string, "aper_sys")) return (MAG_APER_SYS); + if (!strcasecmp (string, "aper_rel")) return (MAG_APER_REL); + if (!strcasecmp (string, "aper_cal")) return (MAG_APER_CAL); + if (!strcasecmp (string, "aper_ave")) return (MAG_APER_AVE); + if (!strcasecmp (string, "aper_ref")) return (MAG_APER_REF); + if (!strcasecmp (string, "aper_err")) return (MAG_APER_ERR); + + // these are kron mags: if (!strcasecmp (string, "kron")) return (MAG_KRON); + if (!strcasecmp (string, "kron_inst")) return (MAG_KRON_INST); + if (!strcasecmp (string, "kron_cat")) return (MAG_KRON_CAT); + if (!strcasecmp (string, "kron_sys")) return (MAG_KRON_SYS); + if (!strcasecmp (string, "kron_rel")) return (MAG_KRON_REL); + if (!strcasecmp (string, "kron_cal")) return (MAG_KRON_CAL); + if (!strcasecmp (string, "kron_ave")) return (MAG_KRON_AVE); + if (!strcasecmp (string, "kron_ref")) return (MAG_KRON_REF); + if (!strcasecmp (string, "kron_err")) return (MAG_KRON_ERR); if (!strcasecmp (string, "kroninst")) return (MAG_KRON_INST); - if (!strcasecmp (string, "kron_inst")) return (MAG_KRON_INST); if (!strcasecmp (string, "kronerr")) return (MAG_KRON_ERR); - if (!strcasecmp (string, "err")) return (MAG_ERR); - if (!strcasecmp (string, "aveerr")) return (MAG_AVE_ERR); + + // other fields: if (!strcasecmp (string, "photflags")) return (MAG_PHOT_FLAGS); if (!strcasecmp (string, "flags")) return (MAG_PHOT_FLAGS); @@ -53,6 +142,6 @@ if (!strcasecmp (string, "nphot")) return (MAG_NPHOT); if (!strcasecmp (string, "stdev")) return (MAG_STDEV); - if (!strcasecmp (string, "20")) return (MAG_20); - if (!strcasecmp (string, "80")) return (MAG_80); + if (!strcasecmp (string, "min")) return (MAG_MIN); + if (!strcasecmp (string, "max")) return (MAG_MAX); if (!strcasecmp (string, "ucdist")) return (MAG_UC_DIST); if (!strcasecmp (string, "stackDetectID")) return (MAG_STACK_DET_ID); @@ -63,215 +152,152 @@ return (MAG_NONE); } - -PhotCode *ParsePhotcodeField (char *field, int *mode, int defMode) { - - int useDefault; - char *tmpstring, *p; - PhotCode *code; - - *mode = defMode; - useDefault = TRUE; - - p = strchr (field, ':'); - if (p != NULL) { - *mode = GetMagMode (p + 1); - useDefault = FALSE; - if (*mode == MAG_NONE) return (NULL); - tmpstring = strncreate (field, p - field); - } else { - tmpstring = strcreate (field); - } - if (!strcasecmp (tmpstring, "MAG")) { - ALLOCATE (code, PhotCode, 1); - code[0].code = 0; - strcpy (code[0].name, "MAG"); - code[0].type = PHOT_MAG; - // the field call 'mag' is only valid for mextract - // it should default to REL, but other types should default to AVE - if (useDefault) { - *mode = MAG_REL; +# endif + +// field may be of the form mag:psf:inst:wrp. except for the first subword, +// the words may be in any order +int ParsePhotcodeField (dbField *field, char *fieldName, int fieldID) { + + int j; + + // defaults: + field->ID = fieldID; // change if not true in the end? + + // check what options are provided. do not allow duplicate types + // except mag and flux may exist with err + dvoMagSourceType mySource = MAG_SRC_NONE; + dvoMagLevelType myLevel = MAG_LEVEL_NONE; + dvoMagClassType myClass = MAG_CLASS_NONE; + dvoMagOptionType myOption = MAG_OPTION_NONE; + + field->magSource = MAG_SRC_CHP; + field->magLevel = MAG_LEVEL_AVE; + field->magClass = MAG_CLASS_PSF; + field->magOption = MAG_OPTION_MAG; + + // make a local working copy of fieldName and replace ':' with spaces + char *fieldCopy = strcreate(fieldName); + for (j = 0; fieldCopy[j]; j++) { + if (fieldCopy[j] == ':') fieldCopy[j] = ' '; + } + + char *firstWord = getword(fieldCopy); + + // firstWord may be either flux, mag or photcode + if (!strcasecmp (firstWord, "MAG")) { + // default level for 'mag' is rel + field->magLevel = MAG_LEVEL_REL; + myOption = MAG_OPTION_MAG; + } + if (!strcasecmp (firstWord, "FLUX")) { + // default level for 'flux' is rel + field->magLevel = MAG_LEVEL_REL; + myOption = MAG_OPTION_FLUX; + } + PhotCode *code = GetPhotcodebyName (firstWord); + free (firstWord); + + if (!code) return FALSE; + + // defaults for photcode clases + if (code->type == PHOT_DEP) { + field->magLevel = MAG_LEVEL_REL; + } + if (code->type == PHOT_SEC) { + field->magLevel = MAG_LEVEL_AVE; + } + if (code->type == PHOT_REF) { + field->magLevel = MAG_LEVEL_CAT; + // is this one required? + } + + // look at the remaining words and assign properties as approrpiate + char *ptr = skipword(fieldCopy); + while (ptr) { + + char *word = getword(ptr); + if (!word) break; + + dvoMagSourceType source = GetMagSource (word); + if (source != MAG_SRC_NONE) { + if (mySource != MAG_SRC_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; } + mySource = source; + ptr = skipword (ptr); + continue; } - free (tmpstring); - return (code); - } - code = GetPhotcodebyName (tmpstring); - if (!code) { - return NULL; - } - - // enforce compatibility - if (useDefault) { - if (code[0].type == PHOT_REF) { - *mode = MAG_CAT; + + dvoMagLevelType level = GetMagLevel (word); + if (level != MAG_LEVEL_NONE) { + if (myLevel != MAG_LEVEL_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; } + myLevel = level; + ptr = skipword (ptr); + continue; } - if (code[0].type == PHOT_DEP) { - *mode = MAG_REL; + + dvoMagClassType class = GetMagClass (word); + if (class != MAG_CLASS_NONE) { + if (myClass != MAG_CLASS_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; } + myClass = class; + ptr = skipword (ptr); + continue; } - } - free (tmpstring); - return (code); -} - -# define ESCAPE(F,M,T) { \ - field->ID = (F); \ - field->magMode = (M); \ - field->type = (T); \ - field->photcode = NULL; \ - return (TRUE); } - -int ParseMeasureField (dbField *field, char *fieldName) { - - int mode; - PhotCode *code; - - field->table = DVO_TABLE_MEASURE; - field->name = strcreate (fieldName); - - if (!strcasecmp (fieldName, "GLON")) { - dbExtractMeasuresInitTransform (COORD_GALACTIC); - ESCAPE (MEAS_GLON, MAG_NONE, OPIHI_FLT); - } - if (!strcasecmp (fieldName, "GLAT")) { - dbExtractMeasuresInitTransform (COORD_GALACTIC); - ESCAPE (MEAS_GLAT, MAG_NONE, OPIHI_FLT); - } - if (!strcasecmp (fieldName, "GLON:AVE")) { - dbExtractMeasuresInitTransform (COORD_GALACTIC); - ESCAPE (MEAS_GLON_AVE, MAG_NONE, OPIHI_FLT); - } - if (!strcasecmp (fieldName, "GLAT:AVE")) { - dbExtractMeasuresInitTransform (COORD_GALACTIC); - ESCAPE (MEAS_GLAT_AVE, MAG_NONE, OPIHI_FLT); - } - - if (!strcasecmp (fieldName, "ELON")) { - dbExtractMeasuresInitTransform (COORD_ECLIPTIC); - ESCAPE (MEAS_ELON, MAG_NONE, OPIHI_FLT); - } - if (!strcasecmp (fieldName, "ELAT")) { - dbExtractMeasuresInitTransform (COORD_ECLIPTIC); - ESCAPE (MEAS_ELAT, MAG_NONE, OPIHI_FLT); - } - if (!strcasecmp (fieldName, "ELON:AVE")) { - dbExtractMeasuresInitTransform (COORD_ECLIPTIC); - ESCAPE (MEAS_ELON_AVE, MAG_NONE, OPIHI_FLT); - } - if (!strcasecmp (fieldName, "ELAT:AVE")) { - dbExtractMeasuresInitTransform (COORD_ECLIPTIC); - ESCAPE (MEAS_ELAT_AVE, MAG_NONE, OPIHI_FLT); - } - - if (!strcasecmp (fieldName, "RA")) ESCAPE (MEAS_RA, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "DEC")) ESCAPE (MEAS_DEC, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "RA:AVE")) ESCAPE (MEAS_RA_AVE, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "DEC:AVE")) ESCAPE (MEAS_DEC_AVE, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "RA:ERR")) ESCAPE (MEAS_RA_AVE_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "DEC:ERR")) ESCAPE (MEAS_DEC_AVE_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "uRA")) ESCAPE (MEAS_U_RA, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "uDEC")) ESCAPE (MEAS_U_DEC, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "duRA")) ESCAPE (MEAS_U_RA_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "duDEC")) ESCAPE (MEAS_U_DEC_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "PAR")) ESCAPE (MEAS_PAR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dPAR")) ESCAPE (MEAS_PAR_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dR")) ESCAPE (MEAS_RA_OFFSET, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dD")) ESCAPE (MEAS_DEC_OFFSET, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dR:FIT")) ESCAPE (MEAS_RA_FIT_OFFSET, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dD:FIT")) ESCAPE (MEAS_DEC_FIT_OFFSET, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dR:ERR")) ESCAPE (MEAS_RA_OFFSET_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dD:ERR")) ESCAPE (MEAS_DEC_OFFSET_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ChiSqPos")) ESCAPE (MEAS_CHISQ_POS, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ChiSqPM")) ESCAPE (MEAS_CHISQ_PM, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ChiSqPar")) ESCAPE (MEAS_CHISQ_PAR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Tmean")) ESCAPE (MEAS_TMEAN, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Trange")) ESCAPE (MEAS_TRANGE, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "nmeas")) ESCAPE (MEAS_NMEAS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "nmiss")) ESCAPE (MEAS_NMISS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "npos")) ESCAPE (MEAS_NPOS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "OBJFLAGS")) ESCAPE (MEAS_OBJ_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "OBJ_FLAGS")) ESCAPE (MEAS_OBJ_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "OBJ_PHOT_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "SECFLAGS")) ESCAPE (MEAS_SECFILT_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "SEC_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "SECFILT_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "DB_FLAGS")) ESCAPE (MEAS_DB_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "PHOT_FLAGS")) ESCAPE (MEAS_PHOT_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "DBFLAGS")) ESCAPE (MEAS_DB_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "PHOTFLAGS")) ESCAPE (MEAS_PHOT_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "AIRMASS")) ESCAPE (MEAS_AIRMASS, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "MEAN_AIRMASS")) ESCAPE (MEAS_MEAN_AIRMASS, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ALT")) ESCAPE (MEAS_ALT, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "AZ")) ESCAPE (MEAS_AZ, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "EXPTIME")) ESCAPE (MEAS_EXPTIME, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "PHOTCODE")) ESCAPE (MEAS_PHOTCODE, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "PHOTCODE:KLAM")) ESCAPE (MEAS_PHOTCODE_KLAM, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "PHOTCODE:C")) ESCAPE (MEAS_PHOTCODE_C, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "PHOTCODE:EQUIV")) ESCAPE (MEAS_PHOTCODE_EQUIV, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "TIME")) ESCAPE (MEAS_TIME, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM")) ESCAPE (MEAS_FWHM, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MAJ")) ESCAPE (MEAS_FWHM_MAJ, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MIN")) ESCAPE (MEAS_FWHM_MIN, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "THETA")) ESCAPE (MEAS_THETA, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "POSANGLE")) ESCAPE (MEAS_POSANGLE, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "PLATESCALE")) ESCAPE (MEAS_PLATESCALE, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "MXX")) ESCAPE (MEAS_MXX, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "MYY")) ESCAPE (MEAS_MYY, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "MXY")) ESCAPE (MEAS_MXY, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "DOPHOT")) ESCAPE (MEAS_DOPHOT, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "XCCD")) ESCAPE (MEAS_XCCD, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "YCCD")) ESCAPE (MEAS_YCCD, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "XCCD:ERR")) ESCAPE (MEAS_XCCD_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "YCCD:ERR")) ESCAPE (MEAS_YCCD_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "XFIX")) ESCAPE (MEAS_XFIX, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "YFIX")) ESCAPE (MEAS_YFIX, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "POS_SYS_ERR")) ESCAPE (MEAS_POS_SYS_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "XFIELD")) ESCAPE (MEAS_XFIELD, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "YFIELD")) ESCAPE (MEAS_YFIELD, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "XMOSAIC")) ESCAPE (MEAS_XMOSAIC, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "YMOSAIC")) ESCAPE (MEAS_YMOSAIC, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "XCHIP")) ESCAPE (MEAS_XCCD, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "YCHIP")) ESCAPE (MEAS_YCCD, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "XFPA")) ESCAPE (MEAS_XMOSAIC, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "YFPA")) ESCAPE (MEAS_YMOSAIC, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "DETID")) ESCAPE (MEAS_DET_ID, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "OBJID")) ESCAPE (MEAS_OBJ_ID, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "CATID")) ESCAPE (MEAS_CAT_ID, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "IMAGEID")) ESCAPE (MEAS_IMAGE_ID, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "EXTERNID")) ESCAPE (MEAS_EXTERN_ID, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "EXPNAME")) ESCAPE (MEAS_EXPNAME_AS_INT, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "PSF_QF")) ESCAPE (MEAS_PSF_QF, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "PSF_QF_PERFECT")) ESCAPE (MEAS_PSF_QF_PERFECT, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "PSF_CHISQ")) ESCAPE (MEAS_PSF_CHISQ, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "PSF_NDOF")) ESCAPE (MEAS_PSF_NDOF, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "PSF_NPIX")) ESCAPE (MEAS_PSF_NPIX, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "CR_NSIGMA")) ESCAPE (MEAS_CR_NSIGMA, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "EXT_NSIGMA")) ESCAPE (MEAS_EXT_NSIGMA, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "SKY")) ESCAPE (MEAS_SKY, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "SKY_ERR")) ESCAPE (MEAS_dSKY, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "MCAL_OFFSET")) ESCAPE (MEAS_MCAL_OFFSET, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FLAT")) ESCAPE (MEAS_FLAT, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "CENTER_OFFSET")) ESCAPE (MEAS_CENTER_OFFSET, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FLUX")) ESCAPE (MEAS_FLUX_PSF, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FLUX_ERR")) ESCAPE (MEAS_FLUX_PSF_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FLUX_PSF")) ESCAPE (MEAS_FLUX_PSF, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FLUX_PSF_ERR")) ESCAPE (MEAS_FLUX_PSF_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FLUX_KRON")) ESCAPE (MEAS_FLUX_KRON, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FLUX_KRON_ERR")) ESCAPE (MEAS_FLUX_KRON_ERR, MAG_NONE, OPIHI_FLT); - - // for words that don't parse, try a photcode - - // check for code:mode in photcode name - code = ParsePhotcodeField (fieldName, &mode, MAG_AVE); - if (code == NULL) { - gprint (GP_ERR, "unknown field '%s' for measurement table in DVO database\n", fieldName); - return (FALSE); - } - - field->ID = MEAS_MAG; - field->magMode = mode; - switch (mode) { - case MAG_STACK_DET_ID: - case MAG_NCODE: - case MAG_NPHOT: - case MAG_PHOT_FLAGS: + + dvoMagOptionType option = GetMagOption (word); + if (option != MAG_OPTION_NONE) { + // some combinations are OK: mag + err -> err + if ((myOption == MAG_OPTION_MAG) && (option == MAG_OPTION_ERR)) { + myOption = option; + ptr = skipword (ptr); + continue; + } + // some combinations are OK: err + mag -> err + if ((myOption == MAG_OPTION_ERR) && (option == MAG_OPTION_MAG)) { + ptr = skipword (ptr); + continue; + } + // some combinations are OK: flux + err -> FLUX_ERR + if ((myOption == MAG_OPTION_FLUX) && (option == MAG_OPTION_ERR)) { + myOption = MAG_OPTION_FLUX_ERR; + ptr = skipword (ptr); + continue; + } + // some combinations are OK: err + flux -> FLUX_ERR + if ((myOption == MAG_OPTION_ERR) && (option == MAG_OPTION_FLUX)) { + myOption = MAG_OPTION_FLUX_ERR; + ptr = skipword (ptr); + continue; + } + // some combinations are OK: flux + fluxerr -> FLUX_ERR + if ((myOption == MAG_OPTION_FLUX) && (option == MAG_OPTION_FLUX_ERR)) { + myOption = MAG_OPTION_FLUX_ERR; + ptr = skipword (ptr); + continue; + } + // some combinations are OK: fluxerr + flux -> FLUX_ERR + if ((myOption == MAG_OPTION_FLUX_ERR) && (option == MAG_OPTION_FLUX)) { + myOption = MAG_OPTION_FLUX_ERR; + ptr = skipword (ptr); + continue; + } + if (myOption != MAG_OPTION_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; } + myOption = option; + ptr = skipword (ptr); + continue; + } + + fprintf (stderr, "ERROR: unknown mag/photocode argument %s\n", word); + free (word); + } + + // if nothing is provided, use the defaults + field->magSource = (mySource == MAG_SRC_NONE) ? field->magSource : mySource; + field->magLevel = (myLevel == MAG_LEVEL_NONE) ? field->magLevel : myLevel; + field->magClass = (myClass == MAG_CLASS_NONE) ? field->magClass : myClass; + field->magOption = (myOption == MAG_OPTION_NONE) ? field->magOption : myOption; + + switch (field->magOption) { + case MAG_OPTION_STACK_DET_ID: + case MAG_OPTION_NCODE: + case MAG_OPTION_NPHOT: + case MAG_OPTION_FLAGS: field->type = OPIHI_INT; break; @@ -281,11 +307,161 @@ } field->photcode = code; + return TRUE; +} + +// field needs to be initialized with dbInitField() +# define ESCAPE(F,T) { \ + field->ID = (F); \ + field->type = (T); \ + return (TRUE); } + +int ParseMeasureField (dbField *field, char *fieldName) { + + field->table = DVO_TABLE_MEASURE; + field->name = strcreate (fieldName); + + if (!strcasecmp (fieldName, "GLON")) { + dbExtractMeasuresInitTransform (COORD_GALACTIC); + ESCAPE (MEAS_GLON, OPIHI_FLT); + } + if (!strcasecmp (fieldName, "GLAT")) { + dbExtractMeasuresInitTransform (COORD_GALACTIC); + ESCAPE (MEAS_GLAT, OPIHI_FLT); + } + if (!strcasecmp (fieldName, "GLON:AVE")) { + dbExtractMeasuresInitTransform (COORD_GALACTIC); + ESCAPE (MEAS_GLON_AVE, OPIHI_FLT); + } + if (!strcasecmp (fieldName, "GLAT:AVE")) { + dbExtractMeasuresInitTransform (COORD_GALACTIC); + ESCAPE (MEAS_GLAT_AVE, OPIHI_FLT); + } + + if (!strcasecmp (fieldName, "ELON")) { + dbExtractMeasuresInitTransform (COORD_ECLIPTIC); + ESCAPE (MEAS_ELON, OPIHI_FLT); + } + if (!strcasecmp (fieldName, "ELAT")) { + dbExtractMeasuresInitTransform (COORD_ECLIPTIC); + ESCAPE (MEAS_ELAT, OPIHI_FLT); + } + if (!strcasecmp (fieldName, "ELON:AVE")) { + dbExtractMeasuresInitTransform (COORD_ECLIPTIC); + ESCAPE (MEAS_ELON_AVE, OPIHI_FLT); + } + if (!strcasecmp (fieldName, "ELAT:AVE")) { + dbExtractMeasuresInitTransform (COORD_ECLIPTIC); + ESCAPE (MEAS_ELAT_AVE, OPIHI_FLT); + } + + if (!strcasecmp (fieldName, "RA")) ESCAPE (MEAS_RA, OPIHI_FLT); + if (!strcasecmp (fieldName, "DEC")) ESCAPE (MEAS_DEC, OPIHI_FLT); + if (!strcasecmp (fieldName, "RA:AVE")) ESCAPE (MEAS_RA_AVE, OPIHI_FLT); + if (!strcasecmp (fieldName, "DEC:AVE")) ESCAPE (MEAS_DEC_AVE, OPIHI_FLT); + if (!strcasecmp (fieldName, "RA:ERR")) ESCAPE (MEAS_RA_AVE_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "DEC:ERR")) ESCAPE (MEAS_DEC_AVE_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "uRA")) ESCAPE (MEAS_U_RA, OPIHI_FLT); + if (!strcasecmp (fieldName, "uDEC")) ESCAPE (MEAS_U_DEC, OPIHI_FLT); + if (!strcasecmp (fieldName, "duRA")) ESCAPE (MEAS_U_RA_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "duDEC")) ESCAPE (MEAS_U_DEC_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "PAR")) ESCAPE (MEAS_PAR, OPIHI_FLT); + if (!strcasecmp (fieldName, "dPAR")) ESCAPE (MEAS_PAR_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "dR")) ESCAPE (MEAS_RA_OFFSET, OPIHI_FLT); + if (!strcasecmp (fieldName, "dD")) ESCAPE (MEAS_DEC_OFFSET, OPIHI_FLT); + if (!strcasecmp (fieldName, "dR:FIT")) ESCAPE (MEAS_RA_FIT_OFFSET, OPIHI_FLT); + if (!strcasecmp (fieldName, "dD:FIT")) ESCAPE (MEAS_DEC_FIT_OFFSET, OPIHI_FLT); + if (!strcasecmp (fieldName, "dR:ERR")) ESCAPE (MEAS_RA_OFFSET_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "dD:ERR")) ESCAPE (MEAS_DEC_OFFSET_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "ChiSqPos")) ESCAPE (MEAS_CHISQ_POS, OPIHI_FLT); + if (!strcasecmp (fieldName, "ChiSqPM")) ESCAPE (MEAS_CHISQ_PM, OPIHI_FLT); + if (!strcasecmp (fieldName, "ChiSqPar")) ESCAPE (MEAS_CHISQ_PAR, OPIHI_FLT); + if (!strcasecmp (fieldName, "Tmean")) ESCAPE (MEAS_TMEAN, OPIHI_FLT); + if (!strcasecmp (fieldName, "Trange")) ESCAPE (MEAS_TRANGE, OPIHI_FLT); + if (!strcasecmp (fieldName, "nmeas")) ESCAPE (MEAS_NMEAS, OPIHI_INT); + if (!strcasecmp (fieldName, "nmiss")) ESCAPE (MEAS_NMISS, OPIHI_INT); + if (!strcasecmp (fieldName, "npos")) ESCAPE (MEAS_NPOS, OPIHI_INT); + if (!strcasecmp (fieldName, "OBJFLAGS")) ESCAPE (MEAS_OBJ_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "OBJ_FLAGS")) ESCAPE (MEAS_OBJ_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "OBJ_PHOT_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "SECFLAGS")) ESCAPE (MEAS_SECFILT_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "SEC_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "SECFILT_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "DB_FLAGS")) ESCAPE (MEAS_DB_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "PHOT_FLAGS")) ESCAPE (MEAS_PHOT_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "DBFLAGS")) ESCAPE (MEAS_DB_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "PHOTFLAGS")) ESCAPE (MEAS_PHOT_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "AIRMASS")) ESCAPE (MEAS_AIRMASS, OPIHI_FLT); + if (!strcasecmp (fieldName, "MEAN_AIRMASS")) ESCAPE (MEAS_MEAN_AIRMASS, OPIHI_FLT); + if (!strcasecmp (fieldName, "ALT")) ESCAPE (MEAS_ALT, OPIHI_FLT); + if (!strcasecmp (fieldName, "AZ")) ESCAPE (MEAS_AZ, OPIHI_FLT); + if (!strcasecmp (fieldName, "EXPTIME")) ESCAPE (MEAS_EXPTIME, OPIHI_FLT); + if (!strcasecmp (fieldName, "PHOTCODE")) ESCAPE (MEAS_PHOTCODE, OPIHI_INT); + if (!strcasecmp (fieldName, "PHOTCODE:KLAM")) ESCAPE (MEAS_PHOTCODE_KLAM, OPIHI_FLT); + if (!strcasecmp (fieldName, "PHOTCODE:C")) ESCAPE (MEAS_PHOTCODE_C, OPIHI_FLT); + if (!strcasecmp (fieldName, "PHOTCODE:EQUIV")) ESCAPE (MEAS_PHOTCODE_EQUIV, OPIHI_INT); + if (!strcasecmp (fieldName, "TIME")) ESCAPE (MEAS_TIME, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM")) ESCAPE (MEAS_FWHM, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MAJ")) ESCAPE (MEAS_FWHM_MAJ, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MIN")) ESCAPE (MEAS_FWHM_MIN, OPIHI_FLT); + if (!strcasecmp (fieldName, "THETA")) ESCAPE (MEAS_THETA, OPIHI_FLT); + if (!strcasecmp (fieldName, "POSANGLE")) ESCAPE (MEAS_POSANGLE, OPIHI_FLT); + if (!strcasecmp (fieldName, "PLATESCALE")) ESCAPE (MEAS_PLATESCALE, OPIHI_FLT); + if (!strcasecmp (fieldName, "MXX")) ESCAPE (MEAS_MXX, OPIHI_FLT); + if (!strcasecmp (fieldName, "MYY")) ESCAPE (MEAS_MYY, OPIHI_FLT); + if (!strcasecmp (fieldName, "MXY")) ESCAPE (MEAS_MXY, OPIHI_FLT); + if (!strcasecmp (fieldName, "DOPHOT")) ESCAPE (MEAS_DOPHOT, OPIHI_INT); + if (!strcasecmp (fieldName, "XCCD")) ESCAPE (MEAS_XCCD, OPIHI_FLT); + if (!strcasecmp (fieldName, "YCCD")) ESCAPE (MEAS_YCCD, OPIHI_FLT); + if (!strcasecmp (fieldName, "XCCD:ERR")) ESCAPE (MEAS_XCCD_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "YCCD:ERR")) ESCAPE (MEAS_YCCD_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "XFIX")) ESCAPE (MEAS_XFIX, OPIHI_FLT); + if (!strcasecmp (fieldName, "YFIX")) ESCAPE (MEAS_YFIX, OPIHI_FLT); + if (!strcasecmp (fieldName, "POS_SYS_ERR")) ESCAPE (MEAS_POS_SYS_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "XFIELD")) ESCAPE (MEAS_XFIELD, OPIHI_FLT); + if (!strcasecmp (fieldName, "YFIELD")) ESCAPE (MEAS_YFIELD, OPIHI_FLT); + if (!strcasecmp (fieldName, "XMOSAIC")) ESCAPE (MEAS_XMOSAIC, OPIHI_FLT); + if (!strcasecmp (fieldName, "YMOSAIC")) ESCAPE (MEAS_YMOSAIC, OPIHI_FLT); + if (!strcasecmp (fieldName, "XCHIP")) ESCAPE (MEAS_XCCD, OPIHI_FLT); + if (!strcasecmp (fieldName, "YCHIP")) ESCAPE (MEAS_YCCD, OPIHI_FLT); + if (!strcasecmp (fieldName, "XFPA")) ESCAPE (MEAS_XMOSAIC, OPIHI_FLT); + if (!strcasecmp (fieldName, "YFPA")) ESCAPE (MEAS_YMOSAIC, OPIHI_FLT); + if (!strcasecmp (fieldName, "DETID")) ESCAPE (MEAS_DET_ID, OPIHI_INT); + if (!strcasecmp (fieldName, "OBJID")) ESCAPE (MEAS_OBJ_ID, OPIHI_INT); + if (!strcasecmp (fieldName, "CATID")) ESCAPE (MEAS_CAT_ID, OPIHI_INT); + if (!strcasecmp (fieldName, "IMAGEID")) ESCAPE (MEAS_IMAGE_ID, OPIHI_INT); + if (!strcasecmp (fieldName, "EXTERNID")) ESCAPE (MEAS_EXTERN_ID, OPIHI_INT); + if (!strcasecmp (fieldName, "EXPNAME")) ESCAPE (MEAS_EXPNAME_AS_INT, OPIHI_INT); + if (!strcasecmp (fieldName, "PSF_QF")) ESCAPE (MEAS_PSF_QF, OPIHI_FLT); + if (!strcasecmp (fieldName, "PSF_QF_PERFECT")) ESCAPE (MEAS_PSF_QF_PERFECT, OPIHI_FLT); + if (!strcasecmp (fieldName, "PSF_CHISQ")) ESCAPE (MEAS_PSF_CHISQ, OPIHI_FLT); + if (!strcasecmp (fieldName, "PSF_NDOF")) ESCAPE (MEAS_PSF_NDOF, OPIHI_INT); + if (!strcasecmp (fieldName, "PSF_NPIX")) ESCAPE (MEAS_PSF_NPIX, OPIHI_INT); + if (!strcasecmp (fieldName, "CR_NSIGMA")) ESCAPE (MEAS_CR_NSIGMA, OPIHI_FLT); + if (!strcasecmp (fieldName, "EXT_NSIGMA")) ESCAPE (MEAS_EXT_NSIGMA, OPIHI_FLT); + if (!strcasecmp (fieldName, "SKY")) ESCAPE (MEAS_SKY, OPIHI_FLT); + if (!strcasecmp (fieldName, "SKY_ERR")) ESCAPE (MEAS_dSKY, OPIHI_FLT); + if (!strcasecmp (fieldName, "MCAL_OFFSET")) ESCAPE (MEAS_MCAL_OFFSET, OPIHI_FLT); + if (!strcasecmp (fieldName, "FLAT")) ESCAPE (MEAS_FLAT, OPIHI_FLT); + if (!strcasecmp (fieldName, "CENTER_OFFSET")) ESCAPE (MEAS_CENTER_OFFSET, OPIHI_FLT); + // if (!strcasecmp (fieldName, "FLUX")) ESCAPE (MEAS_FLUX_PSF, OPIHI_FLT); + // if (!strcasecmp (fieldName, "FLUX_ERR")) ESCAPE (MEAS_FLUX_PSF_ERR, OPIHI_FLT); + // if (!strcasecmp (fieldName, "FLUX_PSF")) ESCAPE (MEAS_FLUX_PSF, OPIHI_FLT); + // if (!strcasecmp (fieldName, "FLUX_PSF_ERR")) ESCAPE (MEAS_FLUX_PSF_ERR, OPIHI_FLT); + // if (!strcasecmp (fieldName, "FLUX_KRON")) ESCAPE (MEAS_FLUX_KRON, OPIHI_FLT); + // if (!strcasecmp (fieldName, "FLUX_KRON_ERR")) ESCAPE (MEAS_FLUX_KRON_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "REF_COLOR")) ESCAPE (MEAS_REF_COLOR, OPIHI_FLT); + + // for words that don't parse, try a photcode + + // check for code:mode in photcode name + if (!ParsePhotcodeField (field, fieldName, MEAS_PHOT)) { + gprint (GP_ERR, "unknown field '%s' for measurement table in DVO database\n", fieldName); + return (FALSE); + } + return (TRUE); } int ParseAverageField (dbField *field, char *fieldName) { - - int mode; - PhotCode *code; field->table = DVO_TABLE_AVERAGE; @@ -296,9 +472,9 @@ if (!strcasecmp (fieldName, "GLON")) { dbExtractAveragesInitTransform (COORD_GALACTIC); - ESCAPE (AVE_GLON, MAG_NONE, OPIHI_FLT); + ESCAPE (AVE_GLON, OPIHI_FLT); } if (!strcasecmp (fieldName, "GLAT")) { dbExtractAveragesInitTransform (COORD_GALACTIC); - ESCAPE (AVE_GLAT, MAG_NONE, OPIHI_FLT); + ESCAPE (AVE_GLAT, OPIHI_FLT); } @@ -307,69 +483,59 @@ if (!strcasecmp (fieldName, "ELON")) { dbExtractAveragesInitTransform (COORD_ECLIPTIC); - ESCAPE (AVE_ELON, MAG_NONE, OPIHI_FLT); + ESCAPE (AVE_ELON, OPIHI_FLT); } if (!strcasecmp (fieldName, "ELAT")) { dbExtractAveragesInitTransform (COORD_ECLIPTIC); - ESCAPE (AVE_ELAT, MAG_NONE, OPIHI_FLT); - } - - if (!strcasecmp (fieldName, "RA")) ESCAPE (AVE_RA, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "DEC")) ESCAPE (AVE_DEC, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "GLON")) ESCAPE (AVE_GLON, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "GLAT")) ESCAPE (AVE_GLAT, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ELON")) ESCAPE (AVE_ELON, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ELAT")) ESCAPE (AVE_ELAT, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dRA")) ESCAPE (AVE_RA_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dDEC")) ESCAPE (AVE_DEC_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "uRA")) ESCAPE (AVE_U_RA, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "uDEC")) ESCAPE (AVE_U_DEC, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "duRA")) ESCAPE (AVE_U_RA_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "duDEC")) ESCAPE (AVE_U_DEC_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "PAR")) ESCAPE (AVE_PAR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dPAR")) ESCAPE (AVE_PAR_ERR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ChiSqPos")) ESCAPE (AVE_CHISQ_POS, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ChiSqPM")) ESCAPE (AVE_CHISQ_PM, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ChiSqPar")) ESCAPE (AVE_CHISQ_PAR, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Tmean")) ESCAPE (AVE_TMEAN, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Trange")) ESCAPE (AVE_TRANGE, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "NMEAS")) ESCAPE (AVE_NMEAS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "NMISS")) ESCAPE (AVE_NMISS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "NPOS")) ESCAPE (AVE_NPOS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "NASTROM")) ESCAPE (AVE_NPOS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "FLAGS")) ESCAPE (AVE_OBJ_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "OBJ_FLAGS")) ESCAPE (AVE_OBJ_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "OBJFLAGS")) ESCAPE (AVE_OBJ_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "OBJID")) ESCAPE (AVE_OBJID, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "CATID")) ESCAPE (AVE_CATID, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "EXTID_HI")) ESCAPE (AVE_EXTID_HI, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "EXTID_LO")) ESCAPE (AVE_EXTID_LO, MAG_NONE, OPIHI_INT); + ESCAPE (AVE_ELAT, OPIHI_FLT); + } + + if (!strcasecmp (fieldName, "RA")) ESCAPE (AVE_RA, OPIHI_FLT); + if (!strcasecmp (fieldName, "DEC")) ESCAPE (AVE_DEC, OPIHI_FLT); + if (!strcasecmp (fieldName, "GLON")) ESCAPE (AVE_GLON, OPIHI_FLT); + if (!strcasecmp (fieldName, "GLAT")) ESCAPE (AVE_GLAT, OPIHI_FLT); + if (!strcasecmp (fieldName, "ELON")) ESCAPE (AVE_ELON, OPIHI_FLT); + if (!strcasecmp (fieldName, "ELAT")) ESCAPE (AVE_ELAT, OPIHI_FLT); + if (!strcasecmp (fieldName, "dRA")) ESCAPE (AVE_RA_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "dDEC")) ESCAPE (AVE_DEC_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "uRA")) ESCAPE (AVE_U_RA, OPIHI_FLT); + if (!strcasecmp (fieldName, "uDEC")) ESCAPE (AVE_U_DEC, OPIHI_FLT); + if (!strcasecmp (fieldName, "duRA")) ESCAPE (AVE_U_RA_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "duDEC")) ESCAPE (AVE_U_DEC_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "PAR")) ESCAPE (AVE_PAR, OPIHI_FLT); + if (!strcasecmp (fieldName, "dPAR")) ESCAPE (AVE_PAR_ERR, OPIHI_FLT); + if (!strcasecmp (fieldName, "ChiSqPos")) ESCAPE (AVE_CHISQ_POS, OPIHI_FLT); + if (!strcasecmp (fieldName, "ChiSqPM")) ESCAPE (AVE_CHISQ_PM, OPIHI_FLT); + if (!strcasecmp (fieldName, "ChiSqPar")) ESCAPE (AVE_CHISQ_PAR, OPIHI_FLT); + if (!strcasecmp (fieldName, "Tmean")) ESCAPE (AVE_TMEAN, OPIHI_FLT); + if (!strcasecmp (fieldName, "Trange")) ESCAPE (AVE_TRANGE, OPIHI_FLT); + if (!strcasecmp (fieldName, "psfqf")) ESCAPE (AVE_PSF_QF, OPIHI_FLT); + if (!strcasecmp (fieldName, "psfqfperf")) ESCAPE (AVE_PSF_QF_PERF, OPIHI_FLT); + if (!strcasecmp (fieldName, "psf_qf")) ESCAPE (AVE_PSF_QF, OPIHI_FLT); + if (!strcasecmp (fieldName, "psf_qf_perf")) ESCAPE (AVE_PSF_QF_PERF, OPIHI_FLT); + if (!strcasecmp (fieldName, "stargal")) ESCAPE (AVE_STARGAL, OPIHI_FLT); + if (!strcasecmp (fieldName, "NMEAS")) ESCAPE (AVE_NMEAS, OPIHI_INT); + if (!strcasecmp (fieldName, "NMISS")) ESCAPE (AVE_NMISS, OPIHI_INT); + if (!strcasecmp (fieldName, "NPOS")) ESCAPE (AVE_NPOS, OPIHI_INT); + if (!strcasecmp (fieldName, "NASTROM")) ESCAPE (AVE_NPOS, OPIHI_INT); + if (!strcasecmp (fieldName, "FLAGS")) ESCAPE (AVE_OBJ_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "OBJ_FLAGS")) ESCAPE (AVE_OBJ_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "OBJFLAGS")) ESCAPE (AVE_OBJ_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "OBJID")) ESCAPE (AVE_OBJID, OPIHI_INT); + if (!strcasecmp (fieldName, "CATID")) ESCAPE (AVE_CATID, OPIHI_INT); + if (!strcasecmp (fieldName, "EXTID_HI")) ESCAPE (AVE_EXTID_HI, OPIHI_INT); + if (!strcasecmp (fieldName, "EXTID_LO")) ESCAPE (AVE_EXTID_LO, OPIHI_INT); + if (!strcasecmp (fieldName, "REF_COLOR")) ESCAPE (AVE_REF_COLOR, OPIHI_FLT); // check for code:mode in photcode name - code = ParsePhotcodeField (fieldName, &mode, MAG_AVE); - if (code == NULL) { + if (!ParsePhotcodeField (field, fieldName, AVE_PHOT)) { gprint (GP_ERR, "unknown field '%s' for average table in DVO database\n", fieldName); return (FALSE); } - if (code[0].type == PHOT_MAG) { + if (field->photcode->type == PHOT_MAG) { gprint (GP_ERR, "'mag' is ambiguous for avextract\n"); - free (code); return (FALSE); } - field->ID = AVE_MAG; - field->magMode = mode; - switch (mode) { - case MAG_STACK_DET_ID: - case MAG_NCODE: - case MAG_NPHOT: - case MAG_PHOT_FLAGS: - field->type = OPIHI_INT; - break; - default: - field->type = OPIHI_FLT; - break; - } - field->photcode = code; return (TRUE); } @@ -385,9 +551,9 @@ if (!strcasecmp (fieldName, "GLON")) { dbExtractImagesInitTransform (COORD_GALACTIC); - ESCAPE (IMAGE_GLON, MAG_NONE, OPIHI_FLT); + ESCAPE (IMAGE_GLON, OPIHI_FLT); } if (!strcasecmp (fieldName, "GLAT")) { dbExtractImagesInitTransform (COORD_GALACTIC); - ESCAPE (IMAGE_GLAT, MAG_NONE, OPIHI_FLT); + ESCAPE (IMAGE_GLAT, OPIHI_FLT); } @@ -396,97 +562,98 @@ if (!strcasecmp (fieldName, "ELON")) { dbExtractImagesInitTransform (COORD_ECLIPTIC); - ESCAPE (IMAGE_ELON, MAG_NONE, OPIHI_FLT); + ESCAPE (IMAGE_ELON, OPIHI_FLT); } if (!strcasecmp (fieldName, "ELAT")) { dbExtractImagesInitTransform (COORD_ECLIPTIC); - ESCAPE (IMAGE_ELAT, MAG_NONE, OPIHI_FLT); - } - - if (!strcasecmp (fieldName, "RA" )) ESCAPE (IMAGE_RA, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "DEC" )) ESCAPE (IMAGE_DEC, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "GLON" )) ESCAPE (IMAGE_GLON, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "GLAT" )) ESCAPE (IMAGE_GLAT, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ELON" )) ESCAPE (IMAGE_ELON, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "ELAT" )) ESCAPE (IMAGE_ELAT, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "theta" )) ESCAPE (IMAGE_THETA, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "skew" )) ESCAPE (IMAGE_SKEW, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "scale" )) ESCAPE (IMAGE_SCALE, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dscale" )) ESCAPE (IMAGE_DSCALE, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "time" )) ESCAPE (IMAGE_TIME, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "nstar" )) ESCAPE (IMAGE_NSTAR, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "airmass" )) ESCAPE (IMAGE_AIRMASS, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "NX" )) ESCAPE (IMAGE_NX_PIX, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "NY" )) ESCAPE (IMAGE_NY_PIX, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "apresid" )) ESCAPE (IMAGE_APRESID, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dapresid" )) ESCAPE (IMAGE_DAPRESID, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "Mcal" )) ESCAPE (IMAGE_MCAL, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dMcal" )) ESCAPE (IMAGE_dMCAL, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Xm" )) ESCAPE (IMAGE_XM, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "photcode" )) ESCAPE (IMAGE_PHOTCODE, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "exptime" )) ESCAPE (IMAGE_EXPTIME, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "sidtime" )) ESCAPE (IMAGE_SIDTIME, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "latitude" )) ESCAPE (IMAGE_LATITUDE, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "detlimit" )) ESCAPE (IMAGE_DET_LIMIT, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "satlimit" )) ESCAPE (IMAGE_SAT_LIMIT, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "cerror" )) ESCAPE (IMAGE_CERROR, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "FWHM" )) ESCAPE (IMAGE_FWHM, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MAJ" )) ESCAPE (IMAGE_FWHM_MAJ, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MIN" )) ESCAPE (IMAGE_FWHM_MIN, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MAJOR" )) ESCAPE (IMAGE_FWHM_MAJ, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MINOR" )) ESCAPE (IMAGE_FWHM_MIN, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "FWHM_MEDIAN" )) ESCAPE (IMAGE_FWHM_MEDIAN, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MAJ_MEDIAN")) ESCAPE (IMAGE_FWHM_MAJ_MEDIAN, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MIN_MEDIAN")) ESCAPE (IMAGE_FWHM_MIN_MEDIAN, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MAJOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MAJ_MEDIAN, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "FWHM_MINOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MIN_MEDIAN, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "trate" )) ESCAPE (IMAGE_TRATE, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "ncal" )) ESCAPE (IMAGE_NCAL, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "sky" )) ESCAPE (IMAGE_SKY, MAG_NONE, OPIHI_FLT); // deprecated for now - - if (!strcasecmp (fieldName, "imflags" )) ESCAPE (IMAGE_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "flags" )) ESCAPE (IMAGE_FLAGS, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "ccdnum" )) ESCAPE (IMAGE_CCDNUM, MAG_NONE, OPIHI_INT); - - if (!strcasecmp (fieldName, "imageID" )) ESCAPE (IMAGE_IMAGE_ID, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "externID" )) ESCAPE (IMAGE_EXTERN_ID, MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "sourceID" )) ESCAPE (IMAGE_SOURCE_ID, MAG_NONE, OPIHI_INT); - - if (!strcasecmp (fieldName, "X_LL_CHIP")) ESCAPE (IMAGE_X_LL_CHIP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "X_LR_CHIP")) ESCAPE (IMAGE_X_LR_CHIP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "X_UL_CHIP")) ESCAPE (IMAGE_X_UL_CHIP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "X_UR_CHIP")) ESCAPE (IMAGE_X_UR_CHIP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Y_LL_CHIP")) ESCAPE (IMAGE_Y_LL_CHIP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Y_LR_CHIP")) ESCAPE (IMAGE_Y_LR_CHIP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Y_UL_CHIP")) ESCAPE (IMAGE_Y_UL_CHIP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Y_UR_CHIP")) ESCAPE (IMAGE_Y_UR_CHIP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "X_LL_FP" )) ESCAPE (IMAGE_X_LL_FP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "X_LR_FP" )) ESCAPE (IMAGE_X_LR_FP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "X_UL_FP" )) ESCAPE (IMAGE_X_UL_FP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "X_UR_FP" )) ESCAPE (IMAGE_X_UR_FP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Y_LL_FP" )) ESCAPE (IMAGE_Y_LL_FP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Y_LR_FP" )) ESCAPE (IMAGE_Y_LR_FP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Y_UL_FP" )) ESCAPE (IMAGE_Y_UL_FP, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "Y_UR_FP" )) ESCAPE (IMAGE_Y_UR_FP, MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "dX_SYS" )) ESCAPE (IMAGE_X_ERR_SYS, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dY_SYS" )) ESCAPE (IMAGE_Y_ERR_SYS, MAG_NONE, OPIHI_FLT); - if (!strcasecmp (fieldName, "dM_SYS" )) ESCAPE (IMAGE_MAG_ERR_SYS,MAG_NONE, OPIHI_FLT); - - if (!strcasecmp (fieldName, "UBERCAL_DIST")) ESCAPE (IMAGE_UBERCAL_DIST,MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "UCDIST")) ESCAPE (IMAGE_UBERCAL_DIST,MAG_NONE, OPIHI_INT); - - if (!strcasecmp (fieldName, "NFIT_PHOTOM")) ESCAPE (IMAGE_NFIT_PHOTOM,MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "NFIT_ASTROM")) ESCAPE (IMAGE_NFIT_ASTROM,MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "NLINK_PHOTOM")) ESCAPE (IMAGE_NLINK_PHOTOM,MAG_NONE, OPIHI_INT); - if (!strcasecmp (fieldName, "NLINK_ASTROM")) ESCAPE (IMAGE_NLINK_ASTROM,MAG_NONE, OPIHI_INT); + ESCAPE (IMAGE_ELAT, OPIHI_FLT); + } + + if (!strcasecmp (fieldName, "RA" )) ESCAPE (IMAGE_RA, OPIHI_FLT); + if (!strcasecmp (fieldName, "DEC" )) ESCAPE (IMAGE_DEC, OPIHI_FLT); + if (!strcasecmp (fieldName, "GLON" )) ESCAPE (IMAGE_GLON, OPIHI_FLT); + if (!strcasecmp (fieldName, "GLAT" )) ESCAPE (IMAGE_GLAT, OPIHI_FLT); + if (!strcasecmp (fieldName, "ELON" )) ESCAPE (IMAGE_ELON, OPIHI_FLT); + if (!strcasecmp (fieldName, "ELAT" )) ESCAPE (IMAGE_ELAT, OPIHI_FLT); + + if (!strcasecmp (fieldName, "theta" )) ESCAPE (IMAGE_THETA, OPIHI_FLT); + if (!strcasecmp (fieldName, "skew" )) ESCAPE (IMAGE_SKEW, OPIHI_FLT); + if (!strcasecmp (fieldName, "scale" )) ESCAPE (IMAGE_SCALE, OPIHI_FLT); + if (!strcasecmp (fieldName, "dscale" )) ESCAPE (IMAGE_DSCALE, OPIHI_FLT); + + if (!strcasecmp (fieldName, "time" )) ESCAPE (IMAGE_TIME, OPIHI_FLT); + if (!strcasecmp (fieldName, "nstar" )) ESCAPE (IMAGE_NSTAR, OPIHI_INT); + if (!strcasecmp (fieldName, "airmass" )) ESCAPE (IMAGE_AIRMASS, OPIHI_FLT); + if (!strcasecmp (fieldName, "NX" )) ESCAPE (IMAGE_NX_PIX, OPIHI_INT); + if (!strcasecmp (fieldName, "NY" )) ESCAPE (IMAGE_NY_PIX, OPIHI_INT); + if (!strcasecmp (fieldName, "apresid" )) ESCAPE (IMAGE_APRESID, OPIHI_FLT); + if (!strcasecmp (fieldName, "dapresid" )) ESCAPE (IMAGE_DAPRESID, OPIHI_FLT); + + if (!strcasecmp (fieldName, "Mcal" )) ESCAPE (IMAGE_MCAL, OPIHI_FLT); + if (!strcasecmp (fieldName, "dMcal" )) ESCAPE (IMAGE_dMCAL, OPIHI_FLT); + if (!strcasecmp (fieldName, "Xm" )) ESCAPE (IMAGE_XM, OPIHI_FLT); + if (!strcasecmp (fieldName, "photcode" )) ESCAPE (IMAGE_PHOTCODE, OPIHI_INT); + if (!strcasecmp (fieldName, "exptime" )) ESCAPE (IMAGE_EXPTIME, OPIHI_FLT); + if (!strcasecmp (fieldName, "sidtime" )) ESCAPE (IMAGE_SIDTIME, OPIHI_FLT); + + if (!strcasecmp (fieldName, "latitude" )) ESCAPE (IMAGE_LATITUDE, OPIHI_FLT); + + if (!strcasecmp (fieldName, "detlimit" )) ESCAPE (IMAGE_DET_LIMIT, OPIHI_FLT); + if (!strcasecmp (fieldName, "satlimit" )) ESCAPE (IMAGE_SAT_LIMIT, OPIHI_FLT); + if (!strcasecmp (fieldName, "cerror" )) ESCAPE (IMAGE_CERROR, OPIHI_FLT); + + if (!strcasecmp (fieldName, "FWHM" )) ESCAPE (IMAGE_FWHM, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MAJ" )) ESCAPE (IMAGE_FWHM_MAJ, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MIN" )) ESCAPE (IMAGE_FWHM_MIN, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MAJOR" )) ESCAPE (IMAGE_FWHM_MAJ, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MINOR" )) ESCAPE (IMAGE_FWHM_MIN, OPIHI_FLT); + + if (!strcasecmp (fieldName, "FWHM_MEDIAN" )) ESCAPE (IMAGE_FWHM_MEDIAN, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MAJ_MEDIAN")) ESCAPE (IMAGE_FWHM_MAJ_MEDIAN, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MIN_MEDIAN")) ESCAPE (IMAGE_FWHM_MIN_MEDIAN, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MAJOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MAJ_MEDIAN, OPIHI_FLT); + if (!strcasecmp (fieldName, "FWHM_MINOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MIN_MEDIAN, OPIHI_FLT); + + if (!strcasecmp (fieldName, "trate" )) ESCAPE (IMAGE_TRATE, OPIHI_FLT); + + if (!strcasecmp (fieldName, "ncal" )) ESCAPE (IMAGE_NCAL, OPIHI_INT); + if (!strcasecmp (fieldName, "sky" )) ESCAPE (IMAGE_SKY, OPIHI_FLT); // deprecated for now + + if (!strcasecmp (fieldName, "imflags" )) ESCAPE (IMAGE_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "flags" )) ESCAPE (IMAGE_FLAGS, OPIHI_INT); + if (!strcasecmp (fieldName, "ccdnum" )) ESCAPE (IMAGE_CCDNUM, OPIHI_INT); + + if (!strcasecmp (fieldName, "imageID" )) ESCAPE (IMAGE_IMAGE_ID, OPIHI_INT); + if (!strcasecmp (fieldName, "externID" )) ESCAPE (IMAGE_EXTERN_ID, OPIHI_INT); + if (!strcasecmp (fieldName, "sourceID" )) ESCAPE (IMAGE_SOURCE_ID, OPIHI_INT); + + if (!strcasecmp (fieldName, "X_LL_CHIP")) ESCAPE (IMAGE_X_LL_CHIP, OPIHI_FLT); + if (!strcasecmp (fieldName, "X_LR_CHIP")) ESCAPE (IMAGE_X_LR_CHIP, OPIHI_FLT); + if (!strcasecmp (fieldName, "X_UL_CHIP")) ESCAPE (IMAGE_X_UL_CHIP, OPIHI_FLT); + if (!strcasecmp (fieldName, "X_UR_CHIP")) ESCAPE (IMAGE_X_UR_CHIP, OPIHI_FLT); + if (!strcasecmp (fieldName, "Y_LL_CHIP")) ESCAPE (IMAGE_Y_LL_CHIP, OPIHI_FLT); + if (!strcasecmp (fieldName, "Y_LR_CHIP")) ESCAPE (IMAGE_Y_LR_CHIP, OPIHI_FLT); + if (!strcasecmp (fieldName, "Y_UL_CHIP")) ESCAPE (IMAGE_Y_UL_CHIP, OPIHI_FLT); + if (!strcasecmp (fieldName, "Y_UR_CHIP")) ESCAPE (IMAGE_Y_UR_CHIP, OPIHI_FLT); + if (!strcasecmp (fieldName, "X_LL_FP" )) ESCAPE (IMAGE_X_LL_FP, OPIHI_FLT); + if (!strcasecmp (fieldName, "X_LR_FP" )) ESCAPE (IMAGE_X_LR_FP, OPIHI_FLT); + if (!strcasecmp (fieldName, "X_UL_FP" )) ESCAPE (IMAGE_X_UL_FP, OPIHI_FLT); + if (!strcasecmp (fieldName, "X_UR_FP" )) ESCAPE (IMAGE_X_UR_FP, OPIHI_FLT); + if (!strcasecmp (fieldName, "Y_LL_FP" )) ESCAPE (IMAGE_Y_LL_FP, OPIHI_FLT); + if (!strcasecmp (fieldName, "Y_LR_FP" )) ESCAPE (IMAGE_Y_LR_FP, OPIHI_FLT); + if (!strcasecmp (fieldName, "Y_UL_FP" )) ESCAPE (IMAGE_Y_UL_FP, OPIHI_FLT); + if (!strcasecmp (fieldName, "Y_UR_FP" )) ESCAPE (IMAGE_Y_UR_FP, OPIHI_FLT); + + if (!strcasecmp (fieldName, "dX_SYS" )) ESCAPE (IMAGE_X_ERR_SYS, OPIHI_FLT); + if (!strcasecmp (fieldName, "dY_SYS" )) ESCAPE (IMAGE_Y_ERR_SYS, OPIHI_FLT); + if (!strcasecmp (fieldName, "dM_SYS" )) ESCAPE (IMAGE_MAG_ERR_SYS,OPIHI_FLT); + + if (!strcasecmp (fieldName, "UBERCAL_DIST")) ESCAPE (IMAGE_UBERCAL_DIST,OPIHI_INT); + if (!strcasecmp (fieldName, "UCDIST")) ESCAPE (IMAGE_UBERCAL_DIST,OPIHI_INT); + + if (!strcasecmp (fieldName, "NFIT_PHOTOM")) ESCAPE (IMAGE_NFIT_PHOTOM, OPIHI_INT); + if (!strcasecmp (fieldName, "NFIT_ASTROM")) ESCAPE (IMAGE_NFIT_ASTROM, OPIHI_INT); + if (!strcasecmp (fieldName, "NLINK_PHOTOM")) ESCAPE (IMAGE_NLINK_PHOTOM, OPIHI_INT); + if (!strcasecmp (fieldName, "NLINK_ASTROM")) ESCAPE (IMAGE_NLINK_ASTROM, OPIHI_INT); + if (!strcasecmp (fieldName, "REF_COLOR")) ESCAPE (IMAGE_REF_COLOR, OPIHI_FLT); // for words that don't parse, try a photcode Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog.c (revision 37067) @@ -56,4 +56,5 @@ if (!strcasecmp (catformat, "PS1_V3")) return (DVO_FORMAT_PS1_V3); if (!strcasecmp (catformat, "PS1_V4")) return (DVO_FORMAT_PS1_V4); + if (!strcasecmp (catformat, "PS1_V5")) return (DVO_FORMAT_PS1_V5); if (!strcasecmp (catformat, "PS1_REF")) return (DVO_FORMAT_PS1_REF); return (DVO_FORMAT_UNDEF); @@ -69,17 +70,46 @@ } +float dvoOffsetR (Measure *measure, Average *average) { + + float dR = (measure[0].R - average[0].R) * 3600.0; + return dR; +} + +float dvoOffsetD (Measure *measure, Average *average) { + + float dD = (measure[0].D - average[0].D) * 3600.0; + return dD; +} + +double dvoMeanR (float dR, Average *average) { + + double ra = average[0].R - dR / 3600.0; + return ra; +} + +double dvoMeanD (float dD, Average *average) { + + double dec = average[0].D - dD / 3600.0; + return dec; +} + // init all data, or just catalog data void dvo_average_init (Average *average) { average->R = 0; average->D = 0; - average->dR = 0; - average->dD = 0; + average->dR = NAN; + average->dD = NAN; average->uR = 0; average->uD = 0; - average->duR = 0; - average->duD = 0; + average->duR = NAN; + average->duD = NAN; average->P = 0; - average->dP = 0; + average->dP = NAN; + + average->Rstk = NAN; + average->Dstk = NAN; + average->dRstk = NAN; + average->dDstk = NAN; average->ChiSqAve = NAN; @@ -97,8 +127,17 @@ average->Nmeasure = 0; average->Nmissing = 0; + average->Nlensing = 0; + average->Nlensobj = 0; average->Nextend = 0; + average->measureOffset = -1; average->missingOffset = -1; + average->lensingOffset = -1; + average->lensobjOffset = -1; average->extendOffset = -1; + average->paramsOffset = -1; + + average->refColorBlue = NAN; + average->refColorRed = NAN; average->flags = 0; @@ -109,4 +148,5 @@ average->catID = 0; average->extID = 0; + average->extIDgc = 0; } @@ -119,4 +159,5 @@ average->measureOffset = -1; average->catID = 0; + average->nOwn = 0; } @@ -124,37 +165,72 @@ void dvo_secfilt_init (SecFilt *secfilt) { secfilt->M = NAN; + secfilt->dM = NAN; secfilt->Map = NAN; + secfilt->dMap = NAN; + secfilt->sMap = NAN; secfilt->Mkron = NAN; secfilt->dMkron = NAN; - secfilt->dM = NAN; - secfilt->Xm = NAN_S_SHORT; - - secfilt->FluxPSF = NAN; - secfilt->dFluxPSF = NAN; - secfilt->FluxKron = NAN; - secfilt->dFluxKron = NAN; - - secfilt->flags = 0; + secfilt->sMkron = NAN; + + secfilt->Mstdev = NAN; + secfilt->Mmin = NAN; + secfilt->Mmax = NAN; + secfilt->Mchisq = NAN; + secfilt->Ncode = 0; secfilt->Nused = 0; - - secfilt->M_20 = NAN_S_SHORT; - secfilt->M_80 = NAN_S_SHORT; + secfilt->NusedKron = 0; + secfilt->NusedAp = 0; + + secfilt->flags = 0; + + secfilt->MpsfStk = NAN; + secfilt->FpsfStk = NAN; + secfilt->dFpsfStk = NAN; + + secfilt->MkronStk = NAN; + secfilt->FkronStk = NAN; + secfilt->dFkronStk = NAN; + + secfilt->MapStk = NAN; + secfilt->FapStk = NAN; + secfilt->dFapStk = NAN; + + secfilt->stackDetectID = 0; + + secfilt->MpsfWrp = NAN; + secfilt->FpsfWrp = NAN; + secfilt->dFpsfWrp = NAN; + secfilt->sFpsfWrp = NAN; + + secfilt->MkronWrp = NAN; + secfilt->FkronWrp = NAN; + secfilt->dFkronWrp = NAN; + secfilt->sFkronWrp = NAN; + + secfilt->MapWrp = NAN; + secfilt->FapWrp = NAN; + secfilt->dFapWrp = NAN; + secfilt->sFapWrp = NAN; + + secfilt->NusedWrp = 0; + secfilt->NusedKronWrp = 0; + secfilt->NusedApWrp = 0; secfilt->ubercalDist = 1000; - secfilt->Mstdev = NAN_S_SHORT; - secfilt->stackDetectID = 0; } // init all data, or just catalog data void dvo_measure_init (Measure *measure) { + measure->R = NAN; + measure->D = NAN; + measure->M = NAN; - measure->dR = NAN; - measure->dD = NAN; - measure->Mcal = NAN; + measure->dM = NAN; measure->Map = NAN; + measure->dMap = NAN; measure->Mkron = NAN; measure->dMkron = NAN; - measure->dM = NAN; + measure->Mcal = NAN; measure->dMcal = NAN; measure->dt = NAN; @@ -164,4 +240,6 @@ measure->FluxKron = NAN; measure->dFluxKron = NAN; + measure->FluxAp = NAN; + measure->dFluxAp = NAN; measure->airmass = NAN; @@ -173,20 +251,29 @@ measure->Yfix = NAN; + measure->XoffKH = NAN; + measure->YoffKH = NAN; + measure->XoffDCR = NAN; + measure->YoffDCR = NAN; + measure->RoffGAL = NAN; + measure->DoffGAL = NAN; + measure->Sky = NAN; measure->dSky = NAN; measure->t = 0; - measure->t_msec = 0; measure->averef = 0; measure->detID = 0; - measure->imageID = 0; measure->objID = 0; measure->catID = 0; + measure->extID = 0; + + measure->imageID = 0; measure->psfQF = NAN; measure->psfQFperf = NAN; measure->psfChisq = NAN; + measure->psfNdof = 0; measure->psfNpix = 0; @@ -202,4 +289,7 @@ measure->Myy = 0; + measure->t_msec = 0; + measure->photcode = 0; + measure->dXccd = 0; measure->dYccd = 0; @@ -209,5 +299,4 @@ measure->pltscale = NAN; - measure->photcode = 0; measure->dbFlags = 0; measure->photFlags = 0; @@ -215,6 +304,6 @@ void dvo_measureT_init (MeasureTiny *measure) { - measure->dR = NAN; - measure->dD = NAN; + measure->R = NAN; + measure->D = NAN; measure->M = NAN; measure->Mcal = NAN; @@ -242,4 +331,93 @@ measure->dYccd = 0; measure->dRsys = 0; + measure->myDet = FALSE; +} + +// init all data, or just catalog data +void dvo_lensing_init (Lensing *lensing) { + lensing->X11_sm_obj = NAN; + lensing->X12_sm_obj = NAN; + lensing->X22_sm_obj = NAN; + lensing->E1_sm_obj = NAN; + lensing->E2_sm_obj = NAN; + + lensing->X11_sh_obj = NAN; + lensing->X12_sh_obj = NAN; + lensing->X22_sh_obj = NAN; + lensing->E1_sh_obj = NAN; + lensing->E2_sh_obj = NAN; + + lensing->X11_sm_psf = NAN; + lensing->X12_sm_psf = NAN; + lensing->X22_sm_psf = NAN; + lensing->E1_sm_psf = NAN; + lensing->E2_sm_psf = NAN; + + lensing->X11_sh_psf = NAN; + lensing->X12_sh_psf = NAN; + lensing->X22_sh_psf = NAN; + lensing->E1_sh_psf = NAN; + lensing->E2_sh_psf = NAN; + + lensing->F_ApR5 = NAN; + lensing->dF_ApR5 = NAN; + lensing->sF_ApR5 = NAN; + lensing->fF_ApR5 = NAN; + + lensing->F_ApR6 = NAN; + lensing->dF_ApR6 = NAN; + lensing->sF_ApR6 = NAN; + lensing->fF_ApR6 = NAN; + + lensing->detID = -1; + lensing->objID = -1; + lensing->catID = -1; + lensing->averef = 0; +} + +// init all data, or just catalog data +void dvo_lensobj_init (Lensobj *lensobj) { + lensobj->X11_sm_obj = NAN; + lensobj->X12_sm_obj = NAN; + lensobj->X22_sm_obj = NAN; + lensobj->E1_sm_obj = NAN; + lensobj->E2_sm_obj = NAN; + + lensobj->X11_sh_obj = NAN; + lensobj->X12_sh_obj = NAN; + lensobj->X22_sh_obj = NAN; + lensobj->E1_sh_obj = NAN; + lensobj->E2_sh_obj = NAN; + + lensobj->X11_sm_psf = NAN; + lensobj->X12_sm_psf = NAN; + lensobj->X22_sm_psf = NAN; + lensobj->E1_sm_psf = NAN; + lensobj->E2_sm_psf = NAN; + + lensobj->X11_sh_psf = NAN; + lensobj->X12_sh_psf = NAN; + lensobj->X22_sh_psf = NAN; + lensobj->E1_sh_psf = NAN; + lensobj->E2_sh_psf = NAN; + + lensobj->F_ApR5 = NAN; + lensobj->dF_ApR5 = NAN; + lensobj->sF_ApR5 = NAN; + lensobj->fF_ApR5 = NAN; + + lensobj->F_ApR6 = NAN; + lensobj->dF_ApR6 = NAN; + lensobj->sF_ApR6 = NAN; + lensobj->fF_ApR6 = NAN; + + lensobj->gamma = NAN; + lensobj->E1 = NAN; + lensobj->E2 = NAN; + + lensobj->objID = -1; + lensobj->catID = -1; + + lensobj->pad = 0; } @@ -267,4 +445,7 @@ catalog[0].secfilt = NULL; + catalog[0].lensing = NULL; + catalog[0].lensobj = NULL; + catalog[0].averageT = NULL; catalog[0].measureT = NULL; @@ -279,4 +460,7 @@ catalog[0].Nsecf_mem = 0; + catalog[0].Nlensing = 0; + catalog[0].Nlensobj = 0; + catalog[0].Naves_disk = 0; catalog[0].Nmeas_disk = 0; @@ -284,4 +468,7 @@ catalog[0].Nsecf_disk = 0; + catalog[0].Nlensing_disk = 0; + catalog[0].Nlensobj_disk = 0; + catalog[0].Naves_off = 0; catalog[0].Nmeas_off = 0; @@ -289,15 +476,22 @@ catalog[0].Nsecf_off = 0; + catalog[0].Nlensing_off = 0; + catalog[0].Nlensobj_off = 0; + /* pointers to SPLIT data files */ catalog[0].measure_catalog = NULL; catalog[0].missing_catalog = NULL; catalog[0].secfilt_catalog = NULL; + catalog[0].lensing_catalog = NULL; + catalog[0].lensobj_catalog = NULL; /* pointers for data manipulation */ - catalog[0].found = NULL; - catalog[0].image = NULL; - catalog[0].mosaic = NULL; - catalog[0].X = NULL; - catalog[0].Y = NULL; + // catalog[0].X_t = NULL; + // catalog[0].Y_t = NULL; + catalog[0].nOwn_t = NULL; + catalog[0].found_t = NULL; + // catalog[0].image_t = NULL; + // catalog[0].mosaic_t = NULL; + catalog[0].foundWarp_t = NULL; } @@ -343,10 +537,13 @@ } + // closes f but does not set back to NULL fclearlockfile (catalog[0].filename, catalog[0].f, catalog[0].lockmode, &dbstate); if (catalog[0].catmode == DVO_MODE_SPLIT) { - if (catalog[0].measure_catalog != NULL) dvo_catalog_unlock (catalog[0].measure_catalog); - if (catalog[0].missing_catalog != NULL) dvo_catalog_unlock (catalog[0].missing_catalog); - if (catalog[0].secfilt_catalog != NULL) dvo_catalog_unlock (catalog[0].secfilt_catalog); + if (catalog[0].measure_catalog) dvo_catalog_unlock (catalog[0].measure_catalog); + if (catalog[0].missing_catalog) dvo_catalog_unlock (catalog[0].missing_catalog); + if (catalog[0].secfilt_catalog) dvo_catalog_unlock (catalog[0].secfilt_catalog); + if (catalog[0].lensing_catalog) dvo_catalog_unlock (catalog[0].lensing_catalog); + if (catalog[0].lensobj_catalog) dvo_catalog_unlock (catalog[0].lensobj_catalog); } return (1); @@ -577,12 +774,12 @@ for (in = out = i = 0; i < catalog[0].Naverage; i++) { for (j = 0; j < catalog[0].Nsecfilt; j++, in++, out++) { - outsec[out].M = insec[in].M; - outsec[out].dM = insec[in].dM; - outsec[out].Xm = insec[in].Xm; + outsec[out].M = insec[in].M; + outsec[out].dM = insec[in].dM; + outsec[out].Mchisq = insec[in].Mchisq; } for (j = 0; j < Nextra; j++, out++) { - outsec[out].M = NAN; - outsec[out].dM = NAN; - outsec[out].Xm = NAN_S_SHORT; + outsec[out].M = NAN; + outsec[out].dM = NAN; + outsec[out].Mchisq = NAN; } } @@ -614,4 +811,14 @@ free (catalog[0].secfilt_catalog); } + if (catalog[0].lensing_catalog) { + free (catalog[0].lensing_catalog[0].filename); + dvo_catalog_free (catalog[0].lensing_catalog); + free (catalog[0].lensing_catalog); + } + if (catalog[0].lensobj_catalog) { + free (catalog[0].lensobj_catalog[0].filename); + dvo_catalog_free (catalog[0].lensobj_catalog); + free (catalog[0].lensobj_catalog); + } } dvo_catalog_free_data (catalog); @@ -623,24 +830,41 @@ /* free, initialize data structures */ - if (catalog[0].average != NULL) { + if (catalog[0].average) { free (catalog[0].average); catalog[0].Naverage = 0; catalog[0].average = NULL; } - if (catalog[0].measure != NULL) { + if (catalog[0].measure) { free (catalog[0].measure); catalog[0].Nmeasure = 0; catalog[0].measure = NULL; } - if (catalog[0].missing != NULL) { + if (catalog[0].missing) { free (catalog[0].missing); catalog[0].Nmissing = 0; catalog[0].missing = NULL; } - if (catalog[0].secfilt != NULL) { + if (catalog[0].secfilt) { free (catalog[0].secfilt); catalog[0].Nsecf_mem = 0; catalog[0].secfilt = NULL; } + if (catalog[0].lensing) { + free (catalog[0].lensing); + catalog[0].Nlensing = 0; + catalog[0].lensing = NULL; + } + if (catalog[0].lensobj) { + free (catalog[0].lensobj); + catalog[0].Nlensobj = 0; + catalog[0].lensobj = NULL; + } + // if (catalog[0].X_t) free (catalog[0].X_t); + // if (catalog[0].Y_t) free (catalog[0].Y_t); + if (catalog[0].nOwn_t) free (catalog[0].nOwn_t); + if (catalog[0].found_t) free (catalog[0].found_t); + // if (catalog[0].image_t) free (catalog[0].image_t); + // if (catalog[0].mosaic_t) free (catalog[0].mosaic_t); + if (catalog[0].foundWarp_t) free (catalog[0].foundWarp_t); } @@ -731,4 +955,24 @@ } } + if (catalog[0].lensing_catalog != NULL) { + if (catalog[0].Nlensing_disk == 0) { + // need to relock (and re-open) file for close elsewhere + status = dvo_catalog_lock (catalog[0].lensing_catalog, lockmode); + } else { + if (!dvo_catalog_backup (catalog[0].lensing_catalog, FALSE)) { + return FALSE; + } + } + } + if (catalog[0].lensobj_catalog != NULL) { + if (catalog[0].Nlensobj_disk == 0) { + // need to relock (and re-open) file for close elsewhere + status = dvo_catalog_lock (catalog[0].lensobj_catalog, lockmode); + } else { + if (!dvo_catalog_backup (catalog[0].lensobj_catalog, FALSE)) { + return FALSE; + } + } + } } return TRUE; @@ -752,5 +996,5 @@ status = unlink (tmpfilename); if (status) { - fprintf (stderr, "failed to unlink catalog %s\n", catalog->filename); + fprintf (stderr, "failed to unlink catalog %s~\n", catalog->filename); return FALSE; } @@ -772,4 +1016,14 @@ } } + if ((catalog[0].lensing_catalog != NULL) && (catalog[0].Nlensing_disk > 0)) { + if (!dvo_catalog_unlink_backup (catalog[0].lensing_catalog, FALSE)) { + return FALSE; + } + } + if ((catalog[0].lensobj_catalog != NULL) && (catalog[0].Nlensobj_disk > 0)) { + if (!dvo_catalog_unlink_backup (catalog[0].lensobj_catalog, FALSE)) { + return FALSE; + } + } } return TRUE; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_chipcoords.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_chipcoords.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_chipcoords.c (revision 37067) @@ -56,6 +56,6 @@ m = average[i].measureOffset; for (j = 0; j < average[i].Nmeasure; j++, m++) { - ra = average[i].R - measure[m].dR / 3600.0; - dec = average[i].D - measure[m].dD / 3600.0; + ra = measure[m].R; + dec = measure[m].D; N = dvo_match_image (image, Nimage, measure[m].t, measure[m].photcode); if (N == -1) continue; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_create.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_create.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_create.c (revision 37067) @@ -70,4 +70,29 @@ gfits_modify (&catalog[0].header, "SECFILT", "%s", 1, file); free (file); + + /* define lensing catalog file */ + ALLOCATE (catalog[0].lensing_catalog, Catalog, 1); + dvo_catalog_init (catalog[0].lensing_catalog, TRUE); + + /* create basic data for lensing catalog file */ + gfits_create_header (&catalog[0].lensing_catalog[0].header); + ALLOCATE (catalog[0].lensing_catalog[0].filename, char, length); + sprintf (catalog[0].lensing_catalog[0].filename, "%s/%s.cpx", path, root); + file = filebasename (catalog[0].lensing_catalog[0].filename); + gfits_modify (&catalog[0].header, "LENSING", "%s", 1, file); + free (file); + + /* define lensobj catalog file */ + ALLOCATE (catalog[0].lensobj_catalog, Catalog, 1); + dvo_catalog_init (catalog[0].lensobj_catalog, TRUE); + + /* create basic data for lensobj catalog file */ + gfits_create_header (&catalog[0].lensobj_catalog[0].header); + ALLOCATE (catalog[0].lensobj_catalog[0].filename, char, length); + sprintf (catalog[0].lensobj_catalog[0].filename, "%s/%s.cpy", path, root); + file = filebasename (catalog[0].lensobj_catalog[0].filename); + gfits_modify (&catalog[0].header, "LENSOBJ", "%s", 1, file); + free (file); + free (path); free (root); @@ -84,4 +109,12 @@ } if (dvo_catalog_lock (catalog[0].secfilt_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) { + fprintf (stderr, "error with file lock\n"); + exit (2); + } + if (dvo_catalog_lock (catalog[0].lensing_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) { + fprintf (stderr, "error with file lock\n"); + exit (2); + } + if (dvo_catalog_lock (catalog[0].lensobj_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) { fprintf (stderr, "error with file lock\n"); exit (2); @@ -111,4 +144,6 @@ ALLOCATE (catalog[0].missing, Missing, 1); ALLOCATE (catalog[0].secfilt, SecFilt, 1); + ALLOCATE (catalog[0].lensing, Lensing, 1); + ALLOCATE (catalog[0].lensobj, Lensobj, 1); /* setup secondary filters to match photcodes: Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_mef.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_mef.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_mef.c (revision 37067) @@ -7,4 +7,6 @@ off_t Nmeasure; off_t Nmissing; + off_t Nlensing; + off_t Nlensobj; off_t Nitems, Nexpect; int Nsecfilt; @@ -22,4 +24,6 @@ if (!gfits_scan (&catalog[0].header, "NMISS", OFF_T_FMT, 1, &Nmissing)) return (FALSE); if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0; + if (!gfits_scan (&catalog[0].header, "NLENSING", OFF_T_FMT, 1, &Nlensing)) return (FALSE); + if (!gfits_scan (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1, &Nlensobj)) return (FALSE); /* the OBJID is a counter that uniquely defines an average entry and never changes. if @@ -40,4 +44,6 @@ catalog[0].Nmiss_disk = Nmissing; catalog[0].Nsecf_disk = Naverage * Nsecfilt; + catalog[0].Nlensing_disk = Nlensing; + catalog[0].Nlensobj_disk = Nlensobj; /** Nsecfilt is unusual: it does not list the number of data items in the table @@ -50,4 +56,6 @@ catalog[0].missing = NULL; catalog[0].secfilt = NULL; + catalog[0].lensing = NULL; + catalog[0].lensobj = NULL; /* validate table mode ?*/ @@ -101,5 +109,5 @@ return (FALSE); } - catalog[0].measure = FtableToMeasure (&ftable, &catalog[0].Nmeasure, &catalog[0].catformat); + catalog[0].measure = FtableToMeasure (&ftable, catalog[0].average, &catalog[0].Nmeasure, &catalog[0].catformat); if (Nmeasure != catalog[0].Nmeas_disk) { fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nmeasure, catalog[0].Nmeas_disk); @@ -201,4 +209,54 @@ } + /* read Lensing table header */ + if (!gfits_fread_header (catalog[0].f, &header)) { + if (VERBOSE) fprintf (stderr, "can't read table lensing header"); + return (FALSE); + } + /* read Lensing table data */ + if (catalog[0].catflags & LOAD_LENSING) { + if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) { + if (VERBOSE) fprintf (stderr, "can't read table lensing data"); + return (FALSE); + } + catalog[0].lensing = FtableToLensing (&ftable, &catalog[0].Nlensing, &catalog[0].catformat); + if (Nlensing != catalog[0].Nlensing_disk) { + fprintf (stderr, "Warning: mismatch between Nlensing in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nlensing, catalog[0].Nlensing_disk); + } + catalog[0].Nlensing = catalog[0].Nlensing_disk; + catalog[0].Nlensing_off = 0; + } else { + Nbytes = gfits_data_size (&header); + fseeko (catalog[0].f, Nbytes, SEEK_CUR); + ALLOCATE (catalog[0].lensing, Lensing, 1); + catalog[0].Nlensing = 0; + catalog[0].Nlensing_off = catalog[0].Nlensing_disk; + } + + /* read Lensobj table header */ + if (!gfits_fread_header (catalog[0].f, &header)) { + if (VERBOSE) fprintf (stderr, "can't read table lensobj header"); + return (FALSE); + } + /* read Lensobj table data */ + if (catalog[0].catflags & LOAD_LENSOBJ) { + if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) { + if (VERBOSE) fprintf (stderr, "can't read table lensobj data"); + return (FALSE); + } + catalog[0].lensobj = FtableToLensobj (&ftable, &catalog[0].Nlensobj, &catalog[0].catformat); + if (Nlensobj != catalog[0].Nlensobj_disk) { + fprintf (stderr, "Warning: mismatch between Nlensobj in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nlensobj, catalog[0].Nlensobj_disk); + } + catalog[0].Nlensobj = catalog[0].Nlensobj_disk; + catalog[0].Nlensobj_off = 0; + } else { + Nbytes = gfits_data_size (&header); + fseeko (catalog[0].f, Nbytes, SEEK_CUR); + ALLOCATE (catalog[0].lensobj, Lensobj, 1); + catalog[0].Nlensobj = 0; + catalog[0].Nlensobj_off = catalog[0].Nlensobj_disk; + } + return (TRUE); } @@ -249,4 +307,6 @@ gfits_modify (&catalog[0].header, "NMISS", OFF_T_FMT, 1, catalog[0].Nmissing); gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt); + gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1, catalog[0].Nlensing); + gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1, catalog[0].Nlensobj); gfits_modify_alt (&catalog[0].header, "EXTEND", "%t", 1, TRUE); gfits_modify (&catalog[0].header, "OBJID", "%d", 1, catalog[0].objID); @@ -289,5 +349,5 @@ /* write out Measure table (convert to FITS table format) */ - MeasureToFtable (&ftable, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat); + MeasureToFtable (&ftable, catalog[0].average, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat); if (!gfits_fwrite_Theader (catalog[0].f, &header)) { fprintf (stderr, "can't write table header"); @@ -317,4 +377,30 @@ Nitems = catalog[0].Naverage * Nsecfilt; SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat); + if (!gfits_fwrite_Theader (catalog[0].f, &header)) { + fprintf (stderr, "can't write table header"); + goto failure; + } + if (!gfits_fwrite_table (catalog[0].f, &ftable)) { + fprintf (stderr, "can't write table data"); + goto failure; + } + gfits_free_table (&ftable); + gfits_free_header (&header); + + /* write out Lensing table (convert to FITS table format) */ + LensingToFtable (&ftable, catalog[0].lensing, catalog[0].Nlensing, catalog[0].catformat); + if (!gfits_fwrite_Theader (catalog[0].f, &header)) { + fprintf (stderr, "can't write table header"); + goto failure; + } + if (!gfits_fwrite_table (catalog[0].f, &ftable)) { + fprintf (stderr, "can't write table data"); + goto failure; + } + gfits_free_table (&ftable); + gfits_free_header (&header); + + /* write out Lensobj table (convert to FITS table format) */ + LensobjToFtable (&ftable, catalog[0].lensobj, catalog[0].Nlensobj, catalog[0].catformat); if (!gfits_fwrite_Theader (catalog[0].f, &header)) { fprintf (stderr, "can't write table header"); @@ -356,4 +442,8 @@ secfilt header secfilt table + lensing header + lensing table + lensobj header + lensobj table */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_raw.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_raw.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_raw.c (revision 37067) @@ -90,4 +90,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); @@ -144,5 +145,5 @@ /* read and convert the measures (use a macro to clean this up?) */ if (catalog[0].catflags & LOAD_MEAS) { - catalog[0].measure = ReadRawMeasure (catalog[0].f, catalog[0].Nmeasure, catalog[0].catformat); + catalog[0].measure = ReadRawMeasure (catalog[0].f, catalog[0].average, catalog[0].Nmeasure, catalog[0].catformat); } else { /* skip over measures */ @@ -284,4 +285,5 @@ if (catalog[0].catformat == DVO_FORMAT_PS1_V3) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V3"); if (catalog[0].catformat == DVO_FORMAT_PS1_V4) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V4"); + if (catalog[0].catformat == DVO_FORMAT_PS1_V5) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V5"); if (catalog[0].catformat == DVO_FORMAT_PS1_REF) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_REF"); @@ -303,5 +305,5 @@ /* write averages and measures */ WriteRawAverage (f, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary); - WriteRawMeasure (f, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat); + WriteRawMeasure (f, catalog[0].average, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat); /* write missing data */ @@ -387,4 +389,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); @@ -438,4 +441,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); @@ -451,5 +455,5 @@ /** Average / Raw Table conversions **/ -Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format) { +Measure *ReadRawMeasure (FILE *f, Average *average, off_t Nmeasure, char format) { Measure *measure; @@ -467,5 +471,5 @@ } \ gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \ - measure = Measure_##TYPE##_ToInternal (tmpMeasure, Nmeasure); \ + measure = Measure_##TYPE##_ToInternal (average, tmpMeasure, Nmeasure); \ free (tmpMeasure); \ break; } @@ -481,4 +485,55 @@ } gfits_convert_Measure (measure, sizeof(Measure), Nmeasure); + break; } + + FORMAT_CASE (LONEOS, Loneos); + FORMAT_CASE (ELIXIR, Elixir); + FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0); + FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1); + FORMAT_CASE (PS1_DEV_1, PS1_DEV_1); + FORMAT_CASE (PS1_DEV_2, PS1_DEV_2); + FORMAT_CASE (PS1_V1, PS1_V1); + FORMAT_CASE (PS1_V2, PS1_V2); + FORMAT_CASE (PS1_V3, PS1_V3); + FORMAT_CASE (PS1_V5, PS1_V5); + FORMAT_CASE (PS1_REF, PS1_REF); + + default: + fprintf (stderr, "error reading measures\n"); + return (NULL); + } +# undef FORMAT_CASE + + return (measure); +} + +/* accepts and converts internal measure formats and outputs + raw data in the specified format */ +int WriteRawMeasure (FILE *f, Average *average, Measure *measure, off_t Nmeasure, char format) { + +// this macro generates the case statements for each type +# define FORMAT_CASE(NAME,TYPE) \ + case DVO_FORMAT_##NAME: { \ + off_t nitems; \ + Measure_##TYPE *tmpMeasure; \ + tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \ + gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \ + nitems = fwrite (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \ + free (tmpMeasure); \ + if (nitems != Nmeasure) { \ + fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n", nitems, Nmeasure); \ + return (FALSE); \ + } \ + break; } + + switch (format) { + case DVO_FORMAT_INTERNAL: { + off_t nitems; + gfits_convert_Measure (measure, sizeof(Measure), Nmeasure); + nitems = fwrite (measure, sizeof(Measure), Nmeasure, f); + if (nitems != Nmeasure) { + fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n", nitems, Nmeasure); + return (FALSE); + } break; } @@ -493,55 +548,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); - FORMAT_CASE (PS1_REF, PS1_REF); - - default: - fprintf (stderr, "error reading measures\n"); - return (NULL); - } -# undef FORMAT_CASE - - return (measure); -} - -/* accepts and converts internal measure formats and outputs - raw data in the specified format */ -int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format) { - -// this macro generates the case statements for each type -# define FORMAT_CASE(NAME,TYPE) \ - case DVO_FORMAT_##NAME: { \ - off_t nitems; \ - Measure_##TYPE *tmpMeasure; \ - tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \ - gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \ - nitems = fwrite (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \ - free (tmpMeasure); \ - if (nitems != Nmeasure) { \ - fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n", nitems, Nmeasure); \ - return (FALSE); \ - } \ - break; } - - switch (format) { - case DVO_FORMAT_INTERNAL: { - off_t nitems; - gfits_convert_Measure (measure, sizeof(Measure), Nmeasure); - nitems = fwrite (measure, sizeof(Measure), Nmeasure, f); - if (nitems != Nmeasure) { - fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n", nitems, Nmeasure); - return (FALSE); - } - break; } - - FORMAT_CASE (LONEOS, Loneos); - FORMAT_CASE (ELIXIR, Elixir); - FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0); - FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1); - FORMAT_CASE (PS1_DEV_1, PS1_DEV_1); - FORMAT_CASE (PS1_DEV_2, PS1_DEV_2); - FORMAT_CASE (PS1_V1, PS1_V1); - FORMAT_CASE (PS1_V2, PS1_V2); - FORMAT_CASE (PS1_V3, PS1_V3); - FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); @@ -599,4 +604,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); @@ -650,4 +656,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_split.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_split.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_split.c (revision 37067) @@ -134,4 +134,8 @@ if (!gfits_scan (&catalog[0].header, name, "%s", 1, string)) { free (path); + // databases created prior to ~2014.07.01 did not have the LENSING or LENSOBJ paths in their headers. + // in these cases, we do not try to lock or open the relevant file + if (!strcmp (name, "LENSING")) return (DVO_CAT_OPEN_EMPTY); + if (!strcmp (name, "LENSOBJ")) return (DVO_CAT_OPEN_EMPTY); return (DVO_CAT_OPEN_FAIL); } @@ -161,5 +165,5 @@ fseeko (subcat[0].f, Nskip, SEEK_CUR); - /* read Measure table header */ + /* read table header */ if (!gfits_fread_header (subcat[0].f, header)) { if (VERBOSE) fprintf (stderr, "can't read %s PHU header\n", name); @@ -176,4 +180,6 @@ off_t Nmeasure; off_t Nmissing; + off_t Nlensing; + off_t Nlensobj; off_t Nitems; int status, Nsecfilt; @@ -190,8 +196,11 @@ /* get the components from the header - these duplicate information in the split files (NAXIS2) */ + // NSTARS, NMEAS, NMISS are required; NLENSING, NLENSOBJ are not (0 if not found) if (!gfits_scan (&catalog[0].header, "NSTARS", OFF_T_FMT, 1, &Naverage)) return (FALSE); if (!gfits_scan (&catalog[0].header, "NMEAS", OFF_T_FMT, 1, &Nmeasure)) return (FALSE); if (!gfits_scan (&catalog[0].header, "NMISS", OFF_T_FMT, 1, &Nmissing)) return (FALSE); - if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0; + if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0; + if (!gfits_scan (&catalog[0].header, "NLENSING", OFF_T_FMT, 1, &Nlensing)) Nlensing = 0; + if (!gfits_scan (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1, &Nlensobj)) Nlensobj = 0; /* the OBJID is a counter that uniquely defines an average entry and never changes. if @@ -212,4 +221,6 @@ catalog[0].Nmiss_disk = Nmissing; catalog[0].Nsecf_disk = Naverage * Nsecfilt; + catalog[0].Nlensing_disk = Nlensing; + catalog[0].Nlensobj_disk = Nlensobj; /** Nsecfilt is unusual: it does not list the number of data items in the table @@ -222,4 +233,6 @@ catalog[0].missing = NULL; catalog[0].secfilt = NULL; + catalog[0].lensing = NULL; + catalog[0].lensobj = NULL; /*** Average Table ***/ @@ -277,5 +290,5 @@ } /* convert data format to internal : returns number of row read in Nmeasure */ - catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat); + catalog[0].measure = FtableToMeasure (&ftable, catalog[0].average, &Nmeasure, &catalog[0].catformat); if (Nmeasure != catalog[0].Nmeas_disk) { fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nmeasure, catalog[0].Nmeas_disk); @@ -372,4 +385,84 @@ gfits_free_header (ftable.header); + /*** Lensing Table ***/ + if (!(catalog[0].catflags & SKIP_LENSING)) { + // unless we specify 'skip', we still need to load the Lensing table + status = dvo_catalog_open_subcat (catalog, &catalog[0].lensing_catalog, ftable.header, "LENSING", VERBOSE); + if (status == DVO_CAT_OPEN_FAIL) { + return (FALSE); + } + // the Lensing file need not exist, unless we expect data to exist + if ((status == DVO_CAT_OPEN_EMPTY) && (catalog[0].Nlensing_disk > 0)) { + return (FALSE); + } + } + if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_LENSING)) { + // only read the Lensing table if the file actually exists + /* read Lensing table data */ + if (!gfits_fread_ftable_data (catalog[0].lensing_catalog[0].f, &ftable, FALSE)) { + if (VERBOSE) fprintf (stderr, "can't read table lensing data\n"); + return (FALSE); + } + /* convert data format to internal : returns number of row read in Nlensing */ + catalog[0].lensing = FtableToLensing (&ftable, &Nlensing, &catalog[0].catformat); + if (Nlensing != catalog[0].Nlensing_disk) { + fprintf (stderr, "Warning: mismatch between Nlensing in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nlensing, catalog[0].Nlensing_disk); + } + catalog[0].Nlensing = catalog[0].Nlensing_disk; + catalog[0].Nlensing_off = 0; + } else { + if (catalog[0].lensing_catalog) { + gfits_free_header (&catalog[0].lensing_catalog[0].header); + } else { + ALLOCATE (catalog[0].lensing_catalog, Catalog, 1); + dvo_catalog_init (catalog[0].lensing_catalog, TRUE); + } + gfits_create_header (&catalog[0].lensing_catalog[0].header); + ALLOCATE (catalog[0].lensing, Lensing, 1); + catalog[0].Nlensing = 0; + catalog[0].Nlensing_off = catalog[0].Nlensing_disk; + } + gfits_free_header (&header); + + /*** Lensobj Table ***/ + if (!(catalog[0].catflags & SKIP_LENSOBJ)) { + // unless we specify 'skip', we still need to load the + status = dvo_catalog_open_subcat (catalog, &catalog[0].lensobj_catalog, ftable.header, "LENSOBJ", VERBOSE); + if (status == DVO_CAT_OPEN_FAIL) { + return (FALSE); + } + // the Lensobj file need not exist, unless we expect data to exist + if ((status == DVO_CAT_OPEN_EMPTY) && (catalog[0].Nlensobj_disk > 0)) { + return (FALSE); + } + } + if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_LENSOBJ)) { + // only read the Lensobj table if the file actually exists + /* read Lensobj table data */ + if (!gfits_fread_ftable_data (catalog[0].lensobj_catalog[0].f, &ftable, FALSE)) { + if (VERBOSE) fprintf (stderr, "can't read table lensobj data\n"); + return (FALSE); + } + /* convert data format to internal : returns number of row read in Nlensobj */ + catalog[0].lensobj = FtableToLensobj (&ftable, &Nlensobj, &catalog[0].catformat); + if (Nlensobj != catalog[0].Nlensobj_disk) { + fprintf (stderr, "Warning: mismatch between Nlensobj in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nlensobj, catalog[0].Nlensobj_disk); + } + catalog[0].Nlensobj = catalog[0].Nlensobj_disk; + catalog[0].Nlensobj_off = 0; + } else { + if (catalog[0].lensobj_catalog) { + gfits_free_header (&catalog[0].lensobj_catalog[0].header); + } else { + ALLOCATE (catalog[0].lensobj_catalog, Catalog, 1); + dvo_catalog_init (catalog[0].lensobj_catalog, TRUE); + } + gfits_create_header (&catalog[0].lensobj_catalog[0].header); + ALLOCATE (catalog[0].lensobj, Lensobj, 1); + catalog[0].Nlensobj = 0; + catalog[0].Nlensobj_off = catalog[0].Nlensobj_disk; + } + gfits_free_header (&header); + return (TRUE); } @@ -380,5 +473,5 @@ off_t Nbytes; - off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing; + off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing, Nlensing, Nlensobj; Header header; FTable ftable; @@ -476,5 +569,5 @@ /* convert data format to internal : returns number of row read in Nmeasure */ - catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat); + catalog[0].measure = FtableToMeasure (&ftable, catalog[0].average, &Nmeasure, &catalog[0].catformat); if (Nmeasure != Nrows) { // XXX this condition denotes the eof has been reached; not an error or a warning @@ -519,4 +612,67 @@ catalog[0].Nmiss_off = start; } + + // XXX check the open status of the catalog + if (catalog[0].catflags & LOAD_LENSING) { + + Catalog *subcat = catalog[0].lensing_catalog; + + /* move pointer past header -- must be already read (load_catalog) */ + Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header); + fseeko (subcat[0].f, Nbytes, SEEK_SET); + + /* read Lensing table header */ + if (!gfits_fread_header (subcat[0].f, &header)) { + if (VERBOSE) fprintf (stderr, "can't read table lensing header"); + return (FALSE); + } + /* read Lensing table data : format is irrelevant here */ + if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) { + if (VERBOSE) fprintf (stderr, "can't read table lensing data"); + return (FALSE); + } + + /* convert data format to internal : returns number of row read in Nlensing */ + catalog[0].lensing = FtableToLensing (&ftable, &Nlensing, &catalog[0].catformat); + if (Nlensing != Nrows) { + // XXX this condition denotes the eof has been reached; not an error or a warning + // fprintf (stderr, "Warning: mismatch between Nlensing in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nlensing, Nrows); + } + gfits_free_header (&header); + catalog[0].Nlensing = Nlensing; + catalog[0].Nlensing_off = start; + } + + // XXX check the open status of the catalog + if (catalog[0].catflags & LOAD_LENSOBJ) { + + Catalog *subcat = catalog[0].lensobj_catalog; + + /* move pointer past header -- must be already read (load_catalog) */ + Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header); + fseeko (subcat[0].f, Nbytes, SEEK_SET); + + /* read Lensobj table header */ + if (!gfits_fread_header (subcat[0].f, &header)) { + if (VERBOSE) fprintf (stderr, "can't read table lensobj header"); + return (FALSE); + } + /* read Lensobj table data : format is irrelevant here */ + if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) { + if (VERBOSE) fprintf (stderr, "can't read table lensobj data"); + return (FALSE); + } + + /* convert data format to internal : returns number of row read in Nlensobj */ + catalog[0].lensobj = FtableToLensobj (&ftable, &Nlensobj, &catalog[0].catformat); + if (Nlensobj != Nrows) { + // XXX this condition denotes the eof has been reached; not an error or a warning + // fprintf (stderr, "Warning: mismatch between Nlensobj in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nlensobj, Nrows); + } + gfits_free_header (&header); + catalog[0].Nlensobj = Nlensobj; + catalog[0].Nlensobj_off = start; + } + return (TRUE); } @@ -530,5 +686,5 @@ SecFilt *primary, *secfilt; int Nsecfilt; - off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new; + off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new; off_t first, start, Nrows; @@ -561,4 +717,6 @@ Nmiss_disk_new = MAX (catalog[0].Nmiss_disk, catalog[0].Nmissing + catalog[0].Nmiss_off); Nsecf_disk_new = MAX (catalog[0].Nsecf_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecf_off); + Nlensing_disk_new = MAX (catalog[0].Nlensing_disk, catalog[0].Nlensing + catalog[0].Nlensing_off); + Nlensobj_disk_new = MAX (catalog[0].Nlensobj_disk, catalog[0].Nlensobj + catalog[0].Nlensobj_off); /* make sure header is consistent with data */ @@ -567,4 +725,6 @@ gfits_modify (&catalog[0].header, "NMISS", OFF_T_FMT, 1, Nmiss_disk_new); gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt); + gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1, Nlensing_disk_new); + gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1, Nlensobj_disk_new); gfits_modify_alt (&catalog[0].header, "EXTEND", "%t", 1, TRUE); gfits_modify (&catalog[0].header, "OBJID", "%d", 1, catalog[0].objID); @@ -621,6 +781,6 @@ assert (catalog[0].Nmeas_disk >= catalog[0].Nmeas_off); - // convert to external table format - if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) { + // convert to external table format (note that the block above does not damage or free catalog.average) + if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat)) { fprintf (stderr, "trouble converting format\n"); goto failure; @@ -679,4 +839,58 @@ if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) { fprintf (stderr, "failure writing SecFilt table\n"); + goto failure; + } + gfits_free_header (&header); + gfits_free_table (&ftable); + } + + /*** Lensing Table ***/ + if ((catalog[0].catflags & LOAD_LENSING) && (catalog[0].lensing != NULL)) { + + first = 0; // first row in memory to write + start = catalog[0].Nlensing_off; // first disk row to write + Nrows = catalog[0].Nlensing - first; + + assert (Nrows >= 0); + assert (first >= 0); + assert (first <= catalog[0].Nlensing); + assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off); + + // convert to external table format (note that the block above does not damage or free catalog.average) + if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat)) { + fprintf (stderr, "trouble converting format\n"); + goto failure; + } + + // write out Lensing table + if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) { + fprintf (stderr, "trouble writing Lensing table\n"); + goto failure; + } + gfits_free_header (&header); + gfits_free_table (&ftable); + } + + /*** Lensobj Table ***/ + if ((catalog[0].catflags & LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) { + + first = 0; // first row in memory to write + start = catalog[0].Nlensobj_off; // first disk row to write + Nrows = catalog[0].Nlensobj - first; + + assert (Nrows >= 0); + assert (first >= 0); + assert (first <= catalog[0].Nlensobj); + assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off); + + // convert to external table format (note that the block above does not damage or free catalog.average) + if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat)) { + fprintf (stderr, "trouble converting format\n"); + goto failure; + } + + // write out Lensobj table + if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) { + fprintf (stderr, "trouble writing Lensobj table\n"); goto failure; } @@ -711,5 +925,5 @@ SecFilt *primary, *secfilt; int Nsecfilt; - off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new; + off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new; off_t first, start, Nrows; @@ -734,4 +948,12 @@ if (catalog[0].Nsecf_off > 0) { fprintf (stderr, "ERROR: only partial catalog (Secfilt) was loaded\n"); + goto failure; + } + if (catalog[0].Nlensing_off > 0) { + fprintf (stderr, "ERROR: only partial catalog (Lensing) was loaded\n"); + goto failure; + } + if (catalog[0].Nlensobj_off > 0) { + fprintf (stderr, "ERROR: only partial catalog (Lensobj) was loaded\n"); goto failure; } @@ -760,4 +982,6 @@ Nmiss_disk_new = catalog[0].Nmissing; Nsecf_disk_new = catalog[0].Naverage*Nsecfilt; + Nlensing_disk_new = catalog[0].Nlensing; + Nlensobj_disk_new = catalog[0].Nlensobj; /* make sure header is consistent with data */ @@ -766,4 +990,6 @@ gfits_modify (&catalog[0].header, "NMISS", OFF_T_FMT, 1, Nmiss_disk_new); gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt); + gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1, Nlensing_disk_new); + gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1, Nlensobj_disk_new); gfits_modify_alt (&catalog[0].header, "EXTEND", "%t", 1, TRUE); gfits_modify (&catalog[0].header, "OBJID", "%d", 1, catalog[0].objID); @@ -821,5 +1047,5 @@ // convert to external table format - if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) { + if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat)) { fprintf (stderr, "trouble converting format\n"); goto failure; @@ -878,4 +1104,58 @@ if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) { fprintf (stderr, "failure writing SecFilt table\n"); + goto failure; + } + gfits_free_header (&header); + gfits_free_table (&ftable); + } + + /*** Lensing Table ***/ + if ((catalog[0].catflags & LOAD_LENSING) && (catalog[0].lensing != NULL)) { + + first = 0; // first row in memory to write + start = catalog[0].Nlensing_off; // first disk row to write + Nrows = catalog[0].Nlensing - first; + + assert (Nrows >= 0); + assert (first >= 0); + assert (first <= catalog[0].Nlensing); + assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off); + + // convert to external table format + if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat)) { + fprintf (stderr, "trouble converting format\n"); + goto failure; + } + + // write out Lensing table + if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) { + fprintf (stderr, "trouble writing Lensing table\n"); + goto failure; + } + gfits_free_header (&header); + gfits_free_table (&ftable); + } + + /*** Lensobj Table ***/ + if ((catalog[0].catflags & LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) { + + first = 0; // first row in memory to write + start = catalog[0].Nlensobj_off; // first disk row to write + Nrows = catalog[0].Nlensobj - first; + + assert (Nrows >= 0); + assert (first >= 0); + assert (first <= catalog[0].Nlensobj); + assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off); + + // convert to external table format + if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat)) { + fprintf (stderr, "trouble converting format\n"); + goto failure; + } + + // write out Lensobj table + if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) { + fprintf (stderr, "trouble writing Lensobj table\n"); goto failure; } @@ -909,5 +1189,5 @@ SecFilt *primary, *secfilt; int Nsecfilt; - off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new; + off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new; off_t first, start, Nrows; @@ -939,4 +1219,6 @@ Nmiss_disk_new = MAX (catalog[0].Nmiss_disk, catalog[0].Nmissing + catalog[0].Nmiss_off); Nsecf_disk_new = MAX (catalog[0].Nsecf_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecf_off); + Nlensing_disk_new = MAX (catalog[0].Nlensing_disk, catalog[0].Nlensing + catalog[0].Nlensing_off); + Nlensobj_disk_new = MAX (catalog[0].Nlensobj_disk, catalog[0].Nlensobj + catalog[0].Nlensobj_off); /* make sure header is consistent with data */ @@ -945,4 +1227,6 @@ gfits_modify (&catalog[0].header, "NMISS", OFF_T_FMT, 1, Nmiss_disk_new); gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt); + gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1, Nlensing_disk_new); + gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1, Nlensobj_disk_new); gfits_modify_alt (&catalog[0].header, "EXTEND", "%t", 1, TRUE); gfits_modify (&catalog[0].header, "OBJID", "%d", 1, catalog[0].objID); @@ -1000,5 +1284,6 @@ // convert to external table format - if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) { + // XXX does catalog.measure have averef correctly set up? + if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat)) { fprintf (stderr, "trouble converting format\n"); goto failure; @@ -1058,4 +1343,60 @@ if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) { fprintf (stderr, "failure writing SecFilt table\n"); + goto failure; + } + gfits_free_header (&header); + gfits_free_table (&ftable); + } + + /*** Lensing Table ***/ + if (catalog[0].lensing != NULL) { + + first = catalog[0].Nlensing_disk - catalog[0].Nlensing_off; // first row in memory to write + start = catalog[0].Nlensing_disk; // first disk row to write + Nrows = catalog[0].Nlensing - first; + + assert (Nrows >= 0); + assert (first >= 0); + assert (first <= catalog[0].Nlensing); + assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off); + + // convert to external table format + // XXX does catalog.lensing have averef correctly set up? + if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat)) { + fprintf (stderr, "trouble converting format\n"); + goto failure; + } + + // write out Lensing table + if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) { + fprintf (stderr, "trouble writing Lensing table\n"); + goto failure; + } + gfits_free_header (&header); + gfits_free_table (&ftable); + } + + /*** Lensobj Table ***/ + if (catalog[0].lensobj != NULL) { + + first = catalog[0].Nlensobj_disk - catalog[0].Nlensobj_off; // first row in memory to write + start = catalog[0].Nlensobj_disk; // first disk row to write + Nrows = catalog[0].Nlensobj - first; + + assert (Nrows >= 0); + assert (first >= 0); + assert (first <= catalog[0].Nlensobj); + assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off); + + // convert to external table format + // XXX does catalog.lensobj have averef correctly set up? + if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat)) { + fprintf (stderr, "trouble converting format\n"); + goto failure; + } + + // write out Lensobj table + if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) { + fprintf (stderr, "trouble writing Lensobj table\n"); goto failure; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert.c (revision 37067) @@ -41,4 +41,5 @@ CONVERT_FORMAT ("DVO_AVERAGE_PS1_V3", PS1_V3); CONVERT_FORMAT ("DVO_AVERAGE_PS1_V4", PS1_V4); + CONVERT_FORMAT ("DVO_AVERAGE_PS1_V5", PS1_V5); CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF", PS1_REF); # undef CONVERT_FORMAT @@ -63,4 +64,18 @@ fprintf (stderr, "EXTNAME missing for average table\n"); return (FALSE); + } + + // block to convert broken tables (PS1_V4 made before the Xfix addition) + if (!strcmp (extname, "DVO_AVERAGE_PS1_V4") && (ftable[0].header[0].Naxis[0] == 120)) { + Average_PS1_V4alt *tmpAverage; + tmpAverage = gfits_table_get_Average_PS1_V4alt (ftable, Naverage, NULL); + if (!tmpAverage) { + fprintf (stderr, "ERROR: failed to read averages\n"); + exit (2); + } + average = Average_PS1_V4alt_ToInternal (tmpAverage, *Naverage); + free (tmpAverage); + *format = DVO_FORMAT_PS1_V4; + return (average); } @@ -98,4 +113,5 @@ CONVERT_FORMAT ("DVO_AVERAGE_PS1_V3", PS1_V3, PS1_V3); CONVERT_FORMAT ("DVO_AVERAGE_PS1_V4", PS1_V4, PS1_V4); + CONVERT_FORMAT ("DVO_AVERAGE_PS1_V5", PS1_V5, PS1_V5); CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF", PS1_REF, PS1_REF); # undef CONVERT_FORMAT @@ -133,4 +149,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); # undef FORMAT_CASE @@ -145,5 +162,6 @@ /*** Measure / FTable conversion functions ***/ -Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format) { +// FtableToMeasure needs the Average since old formats stored measure.dR,dD only +Measure *FtableToMeasure (FTable *ftable, Average *average, off_t *Nmeasure, char *format) { Measure *measure; @@ -156,15 +174,32 @@ } -# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \ - if (!strcmp (extname, NAME)) { \ - Measure_##TYPE *tmpMeasure; \ + // block to convert broken tables (PS1_V4 made before the Xfix addition) + if (!strcmp (extname, "DVO_MEASURE_PS1_V4") && (ftable[0].header[0].Naxis[0] == 176)) { + fprintf (stderr, "reading alt PS1_V4 format\n"); + Measure_PS1_V4alt *tmpMeasure; + tmpMeasure = gfits_table_get_Measure_PS1_V4alt (ftable, Nmeasure, NULL); + if (!tmpMeasure) { + fprintf (stderr, "ERROR: failed to read measures\n"); + exit (2); + } + myAssert (average, "conversion to internal needs average table"); + measure = Measure_PS1_V4alt_ToInternal (average, tmpMeasure, *Nmeasure); + free (tmpMeasure); + *format = DVO_FORMAT_PS1_V4; + return (measure); + } + +# define CONVERT_FORMAT(NAME, FORMAT, TYPE, ABS_COORDS) \ + if (!strcmp (extname, NAME)) { \ + Measure_##TYPE *tmpMeasure; \ tmpMeasure = gfits_table_get_Measure_##TYPE (ftable, Nmeasure, NULL); \ - if (!tmpMeasure) { \ - fprintf (stderr, "ERROR: failed to read measures\n"); \ - exit (2); \ - } \ - measure = Measure_##TYPE##_ToInternal (tmpMeasure, *Nmeasure); \ - free (tmpMeasure); \ - *format = DVO_FORMAT_##FORMAT; \ + if (!tmpMeasure) { \ + fprintf (stderr, "ERROR: failed to read measures\n"); \ + exit (2); \ + } \ + myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \ + measure = Measure_##TYPE##_ToInternal (average, tmpMeasure, *Nmeasure); \ + free (tmpMeasure); \ + *format = DVO_FORMAT_##FORMAT; \ return (measure); } @@ -179,15 +214,16 @@ } - CONVERT_FORMAT ("DVO_MEASURE_ELIXIR", ELIXIR, Elixir); - CONVERT_FORMAT ("DVO_MEASURE_LONEOS", LONEOS, Loneos); - CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0); - CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1); - CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_1", PS1_DEV_1, PS1_DEV_1); - CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_2", PS1_DEV_2, PS1_DEV_2); - CONVERT_FORMAT ("DVO_MEASURE_PS1_V1", PS1_V1, PS1_V1); - CONVERT_FORMAT ("DVO_MEASURE_PS1_V2", PS1_V2, PS1_V2); - CONVERT_FORMAT ("DVO_MEASURE_PS1_V3", PS1_V3, PS1_V3); - CONVERT_FORMAT ("DVO_MEASURE_PS1_V4", PS1_V4, PS1_V4); - CONVERT_FORMAT ("DVO_MEASURE_PS1_REF", PS1_REF, PS1_REF); + CONVERT_FORMAT ("DVO_MEASURE_ELIXIR", ELIXIR, Elixir, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_LONEOS", LONEOS, Loneos, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_1", PS1_DEV_1, PS1_DEV_1, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_2", PS1_DEV_2, PS1_DEV_2, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_PS1_V1", PS1_V1, PS1_V1, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_PS1_V2", PS1_V2, PS1_V2, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_PS1_V3", PS1_V3, PS1_V3, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_PS1_V4", PS1_V4, PS1_V4, FALSE); + CONVERT_FORMAT ("DVO_MEASURE_PS1_V5", PS1_V5, PS1_V5, TRUE); + CONVERT_FORMAT ("DVO_MEASURE_PS1_REF", PS1_REF, PS1_REF, FALSE); # undef CONVERT_FORMAT @@ -198,10 +234,12 @@ } -int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format) { - -# define FORMAT_CASE(FORMAT, TYPE) \ +// MeasureToFtable needs the Average since old formats stored measure.dR,dD only +int MeasureToFtable (FTable *ftable, Average *average, Measure *measure, off_t Nmeasure, char format) { + +# define FORMAT_CASE(FORMAT, TYPE, ABS_COORDS) \ case DVO_FORMAT_##FORMAT: { \ Measure_##TYPE *tmpMeasure; \ - tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \ + myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \ + tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \ gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure); \ free (tmpMeasure); \ @@ -214,15 +252,16 @@ break; } - FORMAT_CASE (ELIXIR, Elixir); - FORMAT_CASE (LONEOS, Loneos); - FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0); - FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1); - FORMAT_CASE (PS1_DEV_1, PS1_DEV_1); - FORMAT_CASE (PS1_DEV_2, PS1_DEV_2); - FORMAT_CASE (PS1_V1, PS1_V1); - FORMAT_CASE (PS1_V2, PS1_V2); - FORMAT_CASE (PS1_V3, PS1_V3); - FORMAT_CASE (PS1_V4, PS1_V4); - FORMAT_CASE (PS1_REF, PS1_REF); + FORMAT_CASE (ELIXIR, Elixir, FALSE); + FORMAT_CASE (LONEOS, Loneos, FALSE); + FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0, FALSE); + FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1, FALSE); + FORMAT_CASE (PS1_DEV_1, PS1_DEV_1, FALSE); + FORMAT_CASE (PS1_DEV_2, PS1_DEV_2, FALSE); + FORMAT_CASE (PS1_V1, PS1_V1, FALSE); + FORMAT_CASE (PS1_V2, PS1_V2, FALSE); + FORMAT_CASE (PS1_V3, PS1_V3, FALSE); + FORMAT_CASE (PS1_V4, PS1_V4, FALSE); + FORMAT_CASE (PS1_V5, PS1_V5, TRUE); + FORMAT_CASE (PS1_REF, PS1_REF, FALSE); # undef FORMAT_CASE @@ -280,4 +319,5 @@ CONVERT_FORMAT ("DVO_SECFILT_PS1_V3", PS1_V3, PS1_V3); CONVERT_FORMAT ("DVO_SECFILT_PS1_V4", PS1_V4, PS1_V4); + CONVERT_FORMAT ("DVO_SECFILT_PS1_V5", PS1_V5, PS1_V5); CONVERT_FORMAT ("DVO_SECFILT_PS1_REF", PS1_REF, PS1_REF); # undef CONVERT_FORMAT @@ -315,4 +355,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); # undef FORMAT_CASE @@ -320,4 +361,192 @@ default: fprintf (stderr, "table format unknown (secfilt)\n"); + return (FALSE); + } + return (TRUE); +} + +/*** Lensing / FTable conversion functions ***/ + +Lensing *FtableToLensing (FTable *ftable, off_t *Nlensing, char *format) { + + Lensing *lensing; + char extname[80]; + + /* convert to the internal format */ + if (!gfits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) { + fprintf (stderr, "EXTNAME missing for lensing table\n"); + return (FALSE); + } + +# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \ + if (!strcmp (extname, NAME)) { \ + Lensing_##TYPE *tmpLensing; \ + tmpLensing = gfits_table_get_Lensing_##TYPE (ftable, Nlensing, NULL); \ + if (!tmpLensing) { \ + fprintf (stderr, "ERROR: failed to read lensings\n"); \ + exit (2); \ + } \ + lensing = Lensing_##TYPE##_ToInternal (tmpLensing, *Nlensing); \ + free (tmpLensing); \ + *format = DVO_FORMAT_##FORMAT; \ + return (lensing); } + + if (!strcmp (extname, "DVO_LENSING")) { + lensing = gfits_table_get_Lensing (ftable, Nlensing, NULL); + if (!lensing) { + fprintf (stderr, "ERROR: failed to read lensings\n"); + exit (2); + } + *format = DVO_FORMAT_INTERNAL; + return (lensing); + } + +// CONVERT_FORMAT ("DVO_LENSING_PS1_REF", PS1_REF, PS1_REF); +// CONVERT_FORMAT ("DVO_LENSING_ELIXIR", ELIXIR, Elixir); +// CONVERT_FORMAT ("DVO_LENSING_LONEOS", LONEOS, Loneos); +// CONVERT_FORMAT ("DVO_LENSING_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0); +// CONVERT_FORMAT ("DVO_LENSING_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1); +// CONVERT_FORMAT ("DVO_LENSING_PS1_DEV_1", PS1_DEV_1, PS1_DEV_1); +// CONVERT_FORMAT ("DVO_LENSING_PS1_DEV_2", PS1_DEV_2, PS1_DEV_2); +// CONVERT_FORMAT ("DVO_LENSING_PS1_V1", PS1_V1, PS1_V1); +// CONVERT_FORMAT ("DVO_LENSING_PS1_V2", PS1_V2, PS1_V2); +// CONVERT_FORMAT ("DVO_LENSING_PS1_V3", PS1_V3, PS1_V3); +// CONVERT_FORMAT ("DVO_LENSING_PS1_V4", PS1_V4, PS1_V4); + CONVERT_FORMAT ("DVO_LENSING_PS1_V5", PS1_V5, PS1_V5); +# undef CONVERT_FORMAT + + fprintf (stderr, "table format unknown: %s\n", extname); + + *Nlensing = 0; + return (NULL); +} + +// LensingToFtable needs the Average since old formats stored lensing.dR,dD only +int LensingToFtable (FTable *ftable, Lensing *lensing, off_t Nlensing, char format) { + +# define FORMAT_CASE(FORMAT, TYPE) \ + case DVO_FORMAT_##FORMAT: { \ + Lensing_##TYPE *tmpLensing; \ + tmpLensing = LensingInternalTo_##TYPE (lensing, Nlensing); \ + gfits_table_set_Lensing_##TYPE (ftable, tmpLensing, Nlensing); \ + free (tmpLensing); \ + break; } + + /* convert from the internal format */ + switch (format) { + case DVO_FORMAT_INTERNAL: { + gfits_table_set_Lensing (ftable, lensing, Nlensing); + break; } + +// FORMAT_CASE (PS1_REF, PS1_REF); +// FORMAT_CASE (ELIXIR, Elixir); +// FORMAT_CASE (LONEOS, Loneos); +// FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0); +// FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1); +// FORMAT_CASE (PS1_DEV_1, PS1_DEV_1); +// FORMAT_CASE (PS1_DEV_2, PS1_DEV_2); +// FORMAT_CASE (PS1_V1, PS1_V1); +// FORMAT_CASE (PS1_V2, PS1_V2); +// FORMAT_CASE (PS1_V3, PS1_V3); +// FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); +# undef FORMAT_CASE + + default: + fprintf (stderr, "table format unknown (lensing)\n"); + return (FALSE); + } + return (TRUE); +} + +/*** Lensobj / FTable conversion functions ***/ + +Lensobj *FtableToLensobj (FTable *ftable, off_t *Nlensobj, char *format) { + + Lensobj *lensobj; + char extname[80]; + + /* convert to the internal format */ + if (!gfits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) { + fprintf (stderr, "EXTNAME missing for lensobj table\n"); + return (FALSE); + } + +# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \ + if (!strcmp (extname, NAME)) { \ + Lensobj_##TYPE *tmpLensobj; \ + tmpLensobj = gfits_table_get_Lensobj_##TYPE (ftable, Nlensobj, NULL); \ + if (!tmpLensobj) { \ + fprintf (stderr, "ERROR: failed to read lensobjs\n"); \ + exit (2); \ + } \ + lensobj = Lensobj_##TYPE##_ToInternal (tmpLensobj, *Nlensobj); \ + free (tmpLensobj); \ + *format = DVO_FORMAT_##FORMAT; \ + return (lensobj); } + + if (!strcmp (extname, "DVO_LENSOBJ")) { + lensobj = gfits_table_get_Lensobj (ftable, Nlensobj, NULL); + if (!lensobj) { + fprintf (stderr, "ERROR: failed to read lensobjs\n"); + exit (2); + } + *format = DVO_FORMAT_INTERNAL; + return (lensobj); + } + +// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_REF", PS1_REF, PS1_REF); +// CONVERT_FORMAT ("DVO_LENSOBJ_ELIXIR", ELIXIR, Elixir); +// CONVERT_FORMAT ("DVO_LENSOBJ_LONEOS", LONEOS, Loneos); +// CONVERT_FORMAT ("DVO_LENSOBJ_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0); +// CONVERT_FORMAT ("DVO_LENSOBJ_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1); +// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_DEV_1", PS1_DEV_1, PS1_DEV_1); +// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_DEV_2", PS1_DEV_2, PS1_DEV_2); +// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V1", PS1_V1, PS1_V1); +// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V2", PS1_V2, PS1_V2); +// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V3", PS1_V3, PS1_V3); +// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V4", PS1_V4, PS1_V4); + CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V5", PS1_V5, PS1_V5); +# undef CONVERT_FORMAT + + fprintf (stderr, "table format unknown: %s\n", extname); + + *Nlensobj = 0; + return (NULL); +} + +// LensobjToFtable needs the Average since old formats stored lensobj.dR,dD only +int LensobjToFtable (FTable *ftable, Lensobj *lensobj, off_t Nlensobj, char format) { + +# define FORMAT_CASE(FORMAT, TYPE) \ + case DVO_FORMAT_##FORMAT: { \ + Lensobj_##TYPE *tmpLensobj; \ + tmpLensobj = LensobjInternalTo_##TYPE (lensobj, Nlensobj); \ + gfits_table_set_Lensobj_##TYPE (ftable, tmpLensobj, Nlensobj); \ + free (tmpLensobj); \ + break; } + + /* convert from the internal format */ + switch (format) { + case DVO_FORMAT_INTERNAL: { + gfits_table_set_Lensobj (ftable, lensobj, Nlensobj); + break; } + +// FORMAT_CASE (PS1_REF, PS1_REF); +// FORMAT_CASE (ELIXIR, Elixir); +// FORMAT_CASE (LONEOS, Loneos); +// FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0); +// FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1); +// FORMAT_CASE (PS1_DEV_1, PS1_DEV_1); +// FORMAT_CASE (PS1_DEV_2, PS1_DEV_2); +// FORMAT_CASE (PS1_V1, PS1_V1); +// FORMAT_CASE (PS1_V2, PS1_V2); +// FORMAT_CASE (PS1_V3, PS1_V3); +// FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); +# undef FORMAT_CASE + + default: + fprintf (stderr, "table format unknown (lensobj)\n"); return (FALSE); } @@ -399,4 +628,5 @@ CONVERT_FORMAT ("DVO_IMAGE_PS1_V3", PS1_V3, PS1_V3); CONVERT_FORMAT ("DVO_IMAGE_PS1_V4", PS1_V4, PS1_V4); + CONVERT_FORMAT ("DVO_IMAGE_PS1_V5", PS1_V5, PS1_V5); CONVERT_FORMAT ("DVO_IMAGE_PS1_REF", PS1_REF, PS1_REF); @@ -438,4 +668,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); @@ -493,4 +724,5 @@ FORMAT_CASE (PS1_V3, PS1_V3); FORMAT_CASE (PS1_V4, PS1_V4); + FORMAT_CASE (PS1_V5, PS1_V5); FORMAT_CASE (PS1_REF, PS1_REF); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c (revision 37067) @@ -3,5 +3,5 @@ /* convert PS1_DEV_1 formats to internal formats */ -Measure *Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, off_t Nvalues) { +Measure *Measure_PS1_DEV_1_ToInternal (Average *ave, Measure_PS1_DEV_1 *in, off_t Nvalues) { off_t i; @@ -12,6 +12,8 @@ for (i = 0; i < Nvalues; i++) { dvo_measure_init (&out[i]); - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -50,5 +52,5 @@ } -Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Measure *in, off_t Nvalues) { +Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -58,6 +60,8 @@ for (i = 0; i < Nvalues; i++) { - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + + out[i].dR = 3600.0*(ave[averef].R - in[i].R); + out[i].dD = 3600.0*(ave[averef].D - in[i].D); out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -180,5 +184,5 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq= pow (10.0, 0.01*in[i].Xm); out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; @@ -197,5 +201,5 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Xm = 100.0*log10(in[i].Mchisq); out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; @@ -203,4 +207,6 @@ return (out); } + +# define RAW_IMAGE_NAME_LEN 64 Image *Image_PS1_DEV_1_ToInternal (Image_PS1_DEV_1 *in, off_t Nvalues, off_t Nalloc) { @@ -217,6 +223,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 63); // out[128], in[64] - out[i].name[63] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -284,6 +291,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 63); // out[128], in[64] - out[i].name[63] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c (revision 37067) @@ -3,5 +3,5 @@ /* convert PS1_DEV_2 formats to internal formats */ -Measure *Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, off_t Nvalues) { +Measure *Measure_PS1_DEV_2_ToInternal (Average *ave, Measure_PS1_DEV_2 *in, off_t Nvalues) { off_t i; @@ -12,6 +12,8 @@ for (i = 0; i < Nvalues; i++) { dvo_measure_init (&out[i]); - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -48,5 +50,5 @@ } -Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Measure *in, off_t Nvalues) { +Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -56,6 +58,8 @@ for (i = 0; i < Nvalues; i++) { - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + + out[i].dR = 3600.0*(ave[averef].R - in[i].R); + out[i].dD = 3600.0*(ave[averef].D - in[i].D); out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -119,5 +123,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColorBlue = in[i].refColor; out[i].objID = in[i].objID; out[i].catID = in[i].catID; @@ -153,5 +157,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColor = in[i].refColorBlue; out[i].objID = in[i].objID; out[i].catID = in[i].catID; @@ -175,5 +179,5 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq= pow (10.0, 0.01*in[i].Xm); out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; @@ -192,5 +196,5 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Xm = 100.0*log10(in[i].Mchisq); out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; @@ -198,4 +202,6 @@ return (out); } + +# define RAW_IMAGE_NAME_LEN 64 Image *Image_PS1_DEV_2_ToInternal (Image_PS1_DEV_2 *in, off_t Nvalues, off_t Nalloc) { @@ -212,6 +218,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 63); // out[121], in[64] - out[i].name[63] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -276,6 +283,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 63); // in[121], out[64] - out[i].name[63] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_3.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_3.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_3.c (revision 37067) @@ -4,4 +4,6 @@ // We only provide image and photcode conversion + +# define RAW_IMAGE_NAME_LEN 128 Image *Image_PS1_DEV_3_ToInternal (Image_PS1_DEV_3 *in, off_t Nvalues, off_t Nalloc) { @@ -18,6 +20,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -77,6 +80,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 127); // out[128], in[128] - out[i].name[127] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c (revision 37067) @@ -3,5 +3,5 @@ /* convert PS1_REF formats to internal formats */ -Measure *Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, off_t Nvalues) { +Measure *Measure_PS1_REF_ToInternal (Average *ave, Measure_PS1_REF *in, off_t Nvalues) { off_t i; @@ -13,6 +13,7 @@ dvo_measure_init (&out[i]); - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; out[i].M = in[i].M; out[i].dM = in[i].dM; @@ -28,5 +29,5 @@ } -Measure_PS1_REF *MeasureInternalTo_PS1_REF (Measure *in, off_t Nvalues) { +Measure_PS1_REF *MeasureInternalTo_PS1_REF (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -36,6 +37,8 @@ for (i = 0; i < Nvalues; i++) { - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + + out[i].dR = 3600.0*(ave[averef].R - in[i].R); + out[i].dD = 3600.0*(ave[averef].D - in[i].D); out[i].M = in[i].M; out[i].dM = in[i].dM; @@ -129,4 +132,6 @@ } +# define RAW_IMAGE_NAME_LEN 121 + Image *Image_PS1_REF_ToInternal (Image_PS1_REF *in, off_t Nvalues, off_t Nalloc) { @@ -142,6 +147,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -204,6 +210,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c (revision 37067) @@ -3,5 +3,5 @@ /* convert PS1_V1 formats to internal formats */ -Measure *Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, off_t Nvalues) { +Measure *Measure_PS1_V1_ToInternal (Average *ave, Measure_PS1_V1 *in, off_t Nvalues) { off_t i; @@ -13,6 +13,7 @@ dvo_measure_init (&out[i]); - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -58,5 +59,5 @@ } -Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Measure *in, off_t Nvalues) { +Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -66,6 +67,8 @@ for (i = 0; i < Nvalues; i++) { - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + + out[i].dR = 3600.0*(ave[averef].R - in[i].R); + out[i].dD = 3600.0*(ave[averef].D - in[i].D); out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -140,5 +143,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColorBlue = in[i].refColor; out[i].flags = in[i].flags; out[i].objID = in[i].objID; @@ -175,5 +178,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColor = in[i].refColorBlue; out[i].flags = in[i].flags; out[i].objID = in[i].objID; @@ -196,9 +199,9 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq= in[i].Mchisq; out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; - out[i].M_20 = in[i].M_20; - out[i].M_80 = in[i].M_80; + out[i].Mmin = in[i].M_20*0.001; + out[i].Mmax = in[i].M_80*0.001; } return (out); @@ -215,12 +218,14 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq= in[i].Mchisq; out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; - out[i].M_20 = in[i].M_20; - out[i].M_80 = in[i].M_80; - } - return (out); -} + out[i].M_20 = in[i].Mmin*1000.0; + out[i].M_80 = in[i].Mmax*1000.0; + } + return (out); +} + +# define RAW_IMAGE_NAME_LEN 121 Image *Image_PS1_V1_ToInternal (Image_PS1_V1 *in, off_t Nvalues, off_t Nalloc) { @@ -237,6 +242,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -300,6 +306,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c (revision 37067) @@ -3,5 +3,5 @@ /* convert PS1_V2 formats to internal formats */ -Measure *Measure_PS1_V2_ToInternal (Measure_PS1_V2 *in, off_t Nvalues) { +Measure *Measure_PS1_V2_ToInternal (Average *ave, Measure_PS1_V2 *in, off_t Nvalues) { off_t i; @@ -13,6 +13,7 @@ dvo_measure_init (&out[i]); - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -59,5 +60,5 @@ } -Measure_PS1_V2 *MeasureInternalTo_PS1_V2 (Measure *in, off_t Nvalues) { +Measure_PS1_V2 *MeasureInternalTo_PS1_V2 (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -67,6 +68,8 @@ for (i = 0; i < Nvalues; i++) { - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + + out[i].dR = 3600.0*(ave[averef].R - in[i].R); + out[i].dD = 3600.0*(ave[averef].D - in[i].D); out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -145,5 +148,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColorBlue = in[i].refColor; out[i].flags = in[i].flags; out[i].objID = in[i].objID; @@ -184,5 +187,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColor = in[i].refColorBlue; out[i].flags = in[i].flags; out[i].objID = in[i].objID; @@ -205,10 +208,10 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq= in[i].Mchisq; out[i].flags = in[i].flags; out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; - out[i].M_20 = in[i].M_20; - out[i].M_80 = in[i].M_80; + out[i].Mmin = in[i].M_20*0.001; + out[i].Mmax = in[i].M_80*0.001; } return (out); @@ -225,13 +228,15 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq= in[i].Mchisq; out[i].flags = in[i].flags; out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; - out[i].M_20 = in[i].M_20; - out[i].M_80 = in[i].M_80; - } - return (out); -} + out[i].M_20 = in[i].Mmin*1000.0; + out[i].M_80 = in[i].Mmax*1000.0; + } + return (out); +} + +# define RAW_IMAGE_NAME_LEN 121 Image *Image_PS1_V2_ToInternal (Image_PS1_V2 *in, off_t Nvalues, off_t Nalloc) { @@ -248,6 +253,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -269,4 +275,5 @@ out[i].DECo = in[i].DECo; out[i].Radius = in[i].Radius; + out[i].refColorBlue = in[i].refColor; out[i].detection_limit = in[i].detection_limit; @@ -310,6 +317,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -331,4 +339,5 @@ out[i].DECo = in[i].DECo; out[i].Radius = in[i].Radius; + out[i].refColor = in[i].refColorBlue; out[i].detection_limit = in[i].detection_limit; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c (revision 37067) @@ -3,5 +3,5 @@ /* convert PS1_V3 formats to internal formats */ -Measure *Measure_PS1_V3_ToInternal (Measure_PS1_V3 *in, off_t Nvalues) { +Measure *Measure_PS1_V3_ToInternal (Average *ave, Measure_PS1_V3 *in, off_t Nvalues) { off_t i; @@ -13,6 +13,7 @@ dvo_measure_init (&out[i]); - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -59,5 +60,5 @@ } -Measure_PS1_V3 *MeasureInternalTo_PS1_V3 (Measure *in, off_t Nvalues) { +Measure_PS1_V3 *MeasureInternalTo_PS1_V3 (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -67,6 +68,8 @@ for (i = 0; i < Nvalues; i++) { - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + + out[i].dR = 3600.0*(ave[averef].R - in[i].R); + out[i].dD = 3600.0*(ave[averef].D - in[i].D); out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -145,5 +148,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColorBlue = in[i].refColor; out[i].flags = in[i].flags; out[i].photFlagsUpper = in[i].photFlagsUpper; @@ -186,5 +189,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColor = in[i].refColorBlue; out[i].flags = in[i].flags; out[i].photFlagsUpper = in[i].photFlagsUpper; @@ -210,10 +213,10 @@ out[i].Map = in[i].Map; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq = in[i].Mchisq; out[i].flags = in[i].flags; out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; - out[i].M_20 = in[i].M_20; - out[i].M_80 = in[i].M_80; + out[i].Mmin = in[i].M_20*0.001; + out[i].Mmax = in[i].M_80*0.001; out[i].Mstdev = in[i].Mstdev; out[i].ubercalDist = in[i].ubercalDist; @@ -233,10 +236,10 @@ out[i].Map = in[i].Map; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq = in[i].Mchisq; out[i].flags = in[i].flags; out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; - out[i].M_20 = in[i].M_20; - out[i].M_80 = in[i].M_80; + out[i].M_20 = in[i].Mmin*1000.0; + out[i].M_80 = in[i].Mmax*1000.0; out[i].Mstdev = in[i].Mstdev; out[i].ubercalDist = in[i].ubercalDist; @@ -244,4 +247,6 @@ return (out); } + +# define RAW_IMAGE_NAME_LEN 121 Image *Image_PS1_V3_ToInternal (Image_PS1_V3 *in, off_t Nvalues, off_t Nalloc) { @@ -258,6 +263,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -279,4 +285,5 @@ out[i].DECo = in[i].DECo; out[i].Radius = in[i].Radius; + out[i].refColorBlue = in[i].refColor; out[i].detection_limit = in[i].detection_limit; @@ -320,6 +327,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -341,4 +349,5 @@ out[i].DECo = in[i].DECo; out[i].Radius = in[i].Radius; + out[i].refColor = in[i].refColorBlue; out[i].detection_limit = in[i].detection_limit; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c (revision 37067) @@ -3,5 +3,5 @@ /* convert PS1_V4 formats to internal formats */ -Measure *Measure_PS1_V4_ToInternal (Measure_PS1_V4 *in, off_t Nvalues) { +Measure *Measure_PS1_V4_ToInternal (Average *ave, Measure_PS1_V4 *in, off_t Nvalues) { off_t i; @@ -13,6 +13,7 @@ dvo_measure_init (&out[i]); - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -68,5 +69,5 @@ } -Measure_PS1_V4 *MeasureInternalTo_PS1_V4 (Measure *in, off_t Nvalues) { +Measure_PS1_V4 *MeasureInternalTo_PS1_V4 (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -76,6 +77,8 @@ for (i = 0; i < Nvalues; i++) { - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + + out[i].dR = 3600.0*(ave[averef].R - in[i].R); + out[i].dD = 3600.0*(ave[averef].D - in[i].D); out[i].M = in[i].M; out[i].Mcal = in[i].Mcal; @@ -166,5 +169,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColorBlue = in[i].refColor; out[i].flags = in[i].flags; out[i].photFlagsUpper = in[i].photFlagsUpper; @@ -210,5 +213,5 @@ out[i].measureOffset = in[i].measureOffset; out[i].missingOffset = in[i].missingOffset; - out[i].extendOffset = in[i].extendOffset; + out[i].refColor = in[i].refColorBlue; out[i].flags = in[i].flags; out[i].photFlagsUpper = in[i].photFlagsUpper; @@ -236,14 +239,14 @@ out[i].dMkron = in[i].dMkron; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; - out[i].FluxPSF = in[i].FluxPSF; - out[i].dFluxPSF = in[i].dFluxPSF; - out[i].FluxKron = in[i].FluxKron; - out[i].dFluxKron = in[i].dFluxKron; + out[i].Mchisq = in[i].Mchisq; + out[i].FpsfStk = in[i].FluxPSF; + out[i].dFpsfStk = in[i].dFluxPSF; + out[i].FkronStk = in[i].FluxKron; + out[i].dFkronStk = in[i].dFluxKron; out[i].flags = in[i].flags; out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; - out[i].M_20 = in[i].M_20; - out[i].M_80 = in[i].M_80; + out[i].Mmin = in[i].M_20*0.001; + out[i].Mmax = in[i].M_80*0.001; out[i].Mstdev = in[i].Mstdev; out[i].ubercalDist = in[i].ubercalDist; @@ -266,14 +269,14 @@ out[i].dMkron = in[i].dMkron; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; - out[i].FluxPSF = in[i].FluxPSF; - out[i].dFluxPSF = in[i].dFluxPSF; - out[i].FluxKron = in[i].FluxKron; - out[i].dFluxKron = in[i].dFluxKron; + out[i].Mchisq = in[i].Mchisq; + out[i].FluxPSF = in[i].FpsfStk; + out[i].dFluxPSF = in[i].dFpsfStk; + out[i].FluxKron = in[i].FkronStk; + out[i].dFluxKron = in[i].dFkronStk; out[i].flags = in[i].flags; out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; - out[i].M_20 = in[i].M_20; - out[i].M_80 = in[i].M_80; + out[i].M_20 = in[i].Mmin*1000.0; + out[i].M_80 = in[i].Mmax*1000.0; out[i].Mstdev = in[i].Mstdev; out[i].ubercalDist = in[i].ubercalDist; @@ -282,4 +285,6 @@ return (out); } + +# define RAW_IMAGE_NAME_LEN 121 Image *Image_PS1_V4_ToInternal (Image_PS1_V4 *in, off_t Nvalues, off_t Nalloc) { @@ -296,6 +301,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -317,4 +323,5 @@ out[i].DECo = in[i].DECo; out[i].Radius = in[i].Radius; + out[i].refColorBlue = in[i].refColor; out[i].detection_limit = in[i].detection_limit; @@ -358,6 +365,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 120); // out[121], in[121] - out[i].name[120] = 0; // force termination + // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1); + out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -379,4 +387,5 @@ out[i].DECo = in[i].DECo; out[i].Radius = in[i].Radius; + out[i].refColor = in[i].refColorBlue; out[i].detection_limit = in[i].detection_limit; @@ -481,2 +490,293 @@ return (out); } + +/*** there are some mini dvodbs with the wrong PS1_V4 format (missing Xoff,Yoff / Xfix,Yfix) ************/ + +Measure *Measure_PS1_V4alt_ToInternal (Average *ave, Measure_PS1_V4alt *in, off_t Nvalues) { + + off_t i; + Measure *out; + + ALLOCATE_ZERO (out, Measure, Nvalues); + + for (i = 0; i < Nvalues; i++) { + dvo_measure_init (&out[i]); + + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; + out[i].M = in[i].M; + out[i].Mcal = in[i].Mcal; + out[i].Map = in[i].Map; + out[i].Mkron = in[i].Mkron; + out[i].dMkron = in[i].dMkron; + out[i].dM = in[i].dM; + out[i].dMcal = in[i].dMcal; + out[i].dt = in[i].dt; + out[i].FluxPSF = in[i].FluxPSF; + out[i].dFluxPSF = in[i].dFluxPSF; + out[i].FluxKron = in[i].FluxKron; + out[i].dFluxKron = in[i].dFluxKron; + out[i].airmass = in[i].airmass; + out[i].az = in[i].az; + out[i].Xccd = in[i].Xccd; + out[i].Yccd = in[i].Yccd; + out[i].Xfix = in[i].Xccd; + out[i].Yfix = in[i].Yccd; + out[i].Sky = in[i].Sky; + out[i].dSky = in[i].dSky; + out[i].t = in[i].t; + out[i].t_msec = in[i].t_msec; + out[i].averef = in[i].averef; + out[i].detID = in[i].detID; + out[i].imageID = in[i].imageID; + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + out[i].extID = in[i].extID; + out[i].psfQF = in[i].psfQF; + out[i].psfQFperf = in[i].psfQFperf; + out[i].psfChisq = in[i].psfChisq; + out[i].psfNdof = in[i].psfNdof; + out[i].psfNpix = in[i].psfNpix; + out[i].crNsigma = in[i].crNsigma; + out[i].extNsigma = in[i].extNsigma; + out[i].FWx = in[i].FWx; + out[i].FWy = in[i].FWy; + out[i].theta = in[i].theta; + out[i].Mxx = in[i].Mxx; + out[i].Mxy = in[i].Mxy; + out[i].Myy = in[i].Myy; + out[i].dXccd = in[i].dXccd; + out[i].dYccd = in[i].dYccd; + out[i].dRsys = in[i].dRsys; + out[i].posangle = in[i].posangle; + out[i].pltscale = in[i].pltscale; + out[i].photcode = in[i].photcode; + out[i].dbFlags = in[i].dbFlags; + out[i].photFlags = in[i].photFlags; + } + return (out); +} + +// XXX note that there are 2 bad versions of PS1_V4 : the other one does have have PSF_QF_PERFECT, but has PAD instead +int gfits_convert_Measure_PS1_V4alt (Measure_PS1_V4alt *data, off_t size, off_t nitems) { + + off_t i; + unsigned char *byte, tmp; + + if (size != 176) { + fprintf (stderr, "WARNING: mismatch in data types Measure_PS1_V4alt: "OFF_T_FMT" vs %d\n", size, 176); + return (FALSE); + } + + /* provide initial values to avoid compiler warnings for non-BYTE_SWAP arch */ + i = tmp = 0; + byte = NULL; + +# ifdef BYTE_SWAP + byte = (unsigned char *) data; + for (i = 0; i < nitems; i++, byte += 176) { + /** BYTE SWAP **/ + SWAP_WORD (0); // D_RA + SWAP_WORD (4); // D_DEC + SWAP_WORD (8); // MAG + SWAP_WORD (12); // M_CAL + SWAP_WORD (16); // M_APER + SWAP_WORD (20); // M_KRON + SWAP_WORD (24); // M_KRON_ERR + SWAP_WORD (28); // MAG_ERR + SWAP_WORD (32); // MAG_CAL_ERR + SWAP_WORD (36); // M_TIME + SWAP_WORD (40); // FLUX_PSF + SWAP_WORD (44); // FLUX_PSF_ERR + SWAP_WORD (48); // FLUX_KRON + SWAP_WORD (52); // FLUX_KRON_ERR + SWAP_WORD (56); // AIRMASS + SWAP_WORD (60); // AZ + SWAP_WORD (64); // X_CCD + SWAP_WORD (68); // Y_CCD + SWAP_WORD (72); // SKY_FLUX + SWAP_WORD (76); // SKY_FLUX_ERR + SWAP_WORD (80); // TIME + SWAP_WORD (84); // AVE_REF + SWAP_WORD (88); // DET_ID + SWAP_WORD (92); // IMAGE_ID + SWAP_WORD (96); // OBJ_ID + SWAP_WORD (100); // CAT_ID + SWAP_DBLE (104); // EXT_ID + SWAP_WORD (112); // PSF_QF + SWAP_WORD (116); // PSF_QF_PERFECT + SWAP_WORD (120); // PSF_CHISQ + SWAP_WORD (124); // PSF_NDOF + SWAP_WORD (128); // PSF_NPIX + SWAP_WORD (132); // CR_NSIGMA + SWAP_WORD (136); // EXT_NSIGMA + SWAP_BYTE (140); // FWHM_MAJOR + SWAP_BYTE (142); // FWHM_MINOR + SWAP_BYTE (144); // PSF_THETA + SWAP_BYTE (146); // MXX + SWAP_BYTE (148); // MXY + SWAP_BYTE (150); // MYY + SWAP_BYTE (152); // TIME_MSEC + SWAP_BYTE (154); // PHOTCODE + SWAP_BYTE (156); // X_CCD_ERR + SWAP_BYTE (158); // Y_CCD_ERR + SWAP_BYTE (160); // POS_SYS_ERR + SWAP_BYTE (162); // POSANGLE + SWAP_WORD (164); // PLTSCALE + SWAP_WORD (168); // DB_FLAGS + SWAP_WORD (172); // PHOT_FLAGS + } +# endif + + return (TRUE); +} + +/*** add test of EXTNAME and header-defined columns? ***/ +/* return internal structure representation */ +Measure_PS1_V4alt *gfits_table_get_Measure_PS1_V4alt (FTable *ftable, off_t *Ndata, char *swapped) { + + int Ncols; + Measure_PS1_V4alt *data; + + Ncols = ftable[0].header[0].Naxis[0]; + if (Ncols != 176) { + fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, 176); + return NULL; + } + + *Ndata = ftable[0].header[0].Naxis[1]; + data = (Measure_PS1_V4alt *) ftable[0].buffer; + if ((swapped == NULL) || (*swapped == FALSE)) { + if (!gfits_convert_Measure_PS1_V4alt (data, sizeof (Measure_PS1_V4alt), *Ndata)) { + return NULL; + } + gfits_table_scale_data (ftable); + if (swapped != NULL) *swapped = TRUE; + } + return (data); +} + +// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used +Average *Average_PS1_V4alt_ToInternal (Average_PS1_V4alt *in, off_t Nvalues) { + + off_t i; + Average *out; + + ALLOCATE_ZERO (out, Average, Nvalues); + + for (i = 0; i < Nvalues; i++) { + dvo_average_init (&out[i]); + + out[i].R = in[i].R; + out[i].D = in[i].D; + out[i].dR = in[i].dR; + out[i].dD = in[i].dD; + out[i].uR = in[i].uR; + out[i].uD = in[i].uD; + out[i].duR = in[i].duR; + out[i].duD = in[i].duD; + out[i].P = in[i].P; + out[i].dP = in[i].dP; + out[i].ChiSqAve = in[i].ChiSqAve; + out[i].ChiSqPM = in[i].ChiSqPM; + out[i].ChiSqPar = in[i].ChiSqPar; + out[i].Tmean = in[i].Tmean; + out[i].Trange = in[i].Trange; + out[i].Npos = in[i].Npos; + out[i].Nmeasure = in[i].Nmeasure; + out[i].Nmissing = in[i].Nmissing; + out[i].Nextend = in[i].Nextend; + out[i].measureOffset = in[i].measureOffset; + out[i].missingOffset = in[i].missingOffset; + out[i].refColorBlue = in[i].refColor; + out[i].flags = in[i].flags; + out[i].photFlagsUpper = in[i].photFlagsUpper; + out[i].photFlagsLower = in[i].photFlagsLower; + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + out[i].extID = in[i].extID; + } + return (out); +} + +/******/ + +int gfits_convert_Average_PS1_V4alt (Average_PS1_V4alt *data, off_t size, off_t nitems) { + + off_t i; + unsigned char *byte, tmp; + + if (size != 120) { + fprintf (stderr, "WARNING: mismatch in data types Average_PS1_V4alt: "OFF_T_FMT" vs %d\n", size, 120); + return (FALSE); + } + + /* provide initial values to avoid compiler warnings for non-BYTE_SWAP arch */ + i = tmp = 0; + byte = NULL; + +# ifdef BYTE_SWAP + byte = (unsigned char *) data; + for (i = 0; i < nitems; i++, byte += 120) { + /** BYTE SWAP **/ + SWAP_DBLE (0); // RA + SWAP_DBLE (8); // DEC + SWAP_WORD (16); // RA_ERR + SWAP_WORD (20); // DEC_ERR + SWAP_WORD (24); // U_RA + SWAP_WORD (28); // U_DEC + SWAP_WORD (32); // V_RA_ERR + SWAP_WORD (36); // V_DEC_ERR + SWAP_WORD (40); // PAR + SWAP_WORD (44); // PAR_ERR + SWAP_WORD (48); // CHISQ_POS + SWAP_WORD (52); // CHISQ_PM + SWAP_WORD (56); // CHISQ_PAP + SWAP_WORD (60); // MEAN_EPOCH + SWAP_WORD (64); // TIME_RANGE + SWAP_WORD (68); // SIGMA + SWAP_BYTE (72); // NUMBER_POS + SWAP_BYTE (74); // NMEASURE + SWAP_BYTE (76); // NMISSING + SWAP_BYTE (78); // NEXTEND + SWAP_WORD (80); // OFF_MEASURE + SWAP_WORD (84); // OFF_MISSING + SWAP_WORD (88); // OFF_EXTEND + SWAP_WORD (92); // FLAGS + SWAP_WORD (96); // PHOTFLAGS_U + SWAP_WORD (100); // PHOTFLAGS_L + SWAP_WORD (104); // OBJ_ID + SWAP_WORD (108); // CAT_ID + SWAP_DBLE (112); // EXT_ID + } +# endif + + return (TRUE); +} + +/*** add test of EXTNAME and header-defined columns? ***/ +/* return internal structure representation */ +Average_PS1_V4alt *gfits_table_get_Average_PS1_V4alt (FTable *ftable, off_t *Ndata, char *swapped) { + + int Ncols; + Average_PS1_V4alt *data; + + Ncols = ftable[0].header[0].Naxis[0]; + if (Ncols != 120) { + fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, 120); + return NULL; + } + + *Ndata = ftable[0].header[0].Naxis[1]; + data = (Average_PS1_V4alt *) ftable[0].buffer; + if ((swapped == NULL) || (*swapped == FALSE)) { + if (!gfits_convert_Average_PS1_V4alt (data, sizeof (Average_PS1_V4alt), *Ndata)) { + return NULL; + } + gfits_table_scale_data (ftable); + if (swapped != NULL) *swapped = TRUE; + } + return (data); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V5.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V5.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V5.c (revision 37067) @@ -0,0 +1,833 @@ +# include + +/* convert PS1_V5 formats to internal formats */ + +Measure *Measure_PS1_V5_ToInternal (Average *ave, Measure_PS1_V5 *in, off_t Nvalues) { + + off_t i; + Measure *out; + + ALLOCATE_ZERO (out, Measure, Nvalues); + + for (i = 0; i < Nvalues; i++) { + dvo_measure_init (&out[i]); + + out[i].R = in[i].R; + out[i].D = in[i].D; + out[i].M = in[i].M; + out[i].dM = in[i].dM; + out[i].Map = in[i].Map; + out[i].dMap = in[i].dMap; + out[i].Mkron = in[i].Mkron; + out[i].dMkron = in[i].dMkron; + out[i].Mcal = in[i].Mcal; + out[i].dMcal = in[i].dMcal; + out[i].dt = in[i].dt; + out[i].FluxPSF = in[i].FluxPSF; + out[i].dFluxPSF = in[i].dFluxPSF; + out[i].FluxKron = in[i].FluxKron; + out[i].dFluxKron = in[i].dFluxKron; + out[i].FluxAp = in[i].FluxAp; + out[i].dFluxAp = in[i].dFluxAp; + out[i].airmass = in[i].airmass; + out[i].az = in[i].az; + out[i].Xccd = in[i].Xccd; + out[i].Yccd = in[i].Yccd; + out[i].Xfix = in[i].Xfix; + out[i].Yfix = in[i].Yfix; + out[i].XoffKH = in[i].XoffKH; + out[i].YoffKH = in[i].YoffKH; + out[i].XoffDCR = in[i].XoffDCR; + out[i].YoffDCR = in[i].YoffDCR; + out[i].RoffGAL = in[i].RoffGAL; + out[i].DoffGAL = in[i].DoffGAL; + out[i].Sky = in[i].Sky; + out[i].dSky = in[i].dSky; + out[i].t = in[i].t; + out[i].averef = in[i].averef; + out[i].detID = in[i].detID; + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + out[i].extID = in[i].extID; + out[i].imageID = in[i].imageID; + out[i].psfQF = in[i].psfQF; + out[i].psfQFperf = in[i].psfQFperf; + out[i].psfChisq = in[i].psfChisq; + out[i].psfNdof = in[i].psfNdof; + out[i].psfNpix = in[i].psfNpix; + out[i].crNsigma = in[i].crNsigma; + out[i].extNsigma = in[i].extNsigma; + out[i].FWx = in[i].FWx; + out[i].FWy = in[i].FWy; + out[i].theta = in[i].theta; + out[i].Mxx = in[i].Mxx; + out[i].Mxy = in[i].Mxy; + out[i].Myy = in[i].Myy; + out[i].t_msec = in[i].t_msec; + out[i].photcode = in[i].photcode; + out[i].dXccd = in[i].dXccd; + out[i].dYccd = in[i].dYccd; + out[i].dRsys = in[i].dRsys; + out[i].posangle = in[i].posangle; + out[i].pltscale = in[i].pltscale; + out[i].dbFlags = in[i].dbFlags; + out[i].photFlags = in[i].photFlags; + } + return (out); +} + +Measure_PS1_V5 *MeasureInternalTo_PS1_V5 (Average *ave, Measure *in, off_t Nvalues) { + + off_t i; + Measure_PS1_V5 *out; + + ALLOCATE_ZERO (out, Measure_PS1_V5, Nvalues); + + for (i = 0; i < Nvalues; i++) { + out[i].R = in[i].R; + out[i].D = in[i].D; + out[i].M = in[i].M; + out[i].dM = in[i].dM; + out[i].Map = in[i].Map; + out[i].dMap = in[i].dMap; + out[i].Mkron = in[i].Mkron; + out[i].dMkron = in[i].dMkron; + out[i].Mcal = in[i].Mcal; + out[i].dMcal = in[i].dMcal; + out[i].dt = in[i].dt; + out[i].FluxPSF = in[i].FluxPSF; + out[i].dFluxPSF = in[i].dFluxPSF; + out[i].FluxKron = in[i].FluxKron; + out[i].dFluxKron = in[i].dFluxKron; + out[i].FluxAp = in[i].FluxAp; + out[i].dFluxAp = in[i].dFluxAp; + out[i].airmass = in[i].airmass; + out[i].az = in[i].az; + out[i].Xccd = in[i].Xccd; + out[i].Yccd = in[i].Yccd; + out[i].Xfix = in[i].Xfix; + out[i].Yfix = in[i].Yfix; + out[i].XoffKH = in[i].XoffKH; + out[i].YoffKH = in[i].YoffKH; + out[i].XoffDCR = in[i].XoffDCR; + out[i].YoffDCR = in[i].YoffDCR; + out[i].RoffGAL = in[i].RoffGAL; + out[i].DoffGAL = in[i].DoffGAL; + out[i].Sky = in[i].Sky; + out[i].dSky = in[i].dSky; + out[i].t = in[i].t; + out[i].averef = in[i].averef; + out[i].detID = in[i].detID; + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + out[i].extID = in[i].extID; + out[i].imageID = in[i].imageID; + out[i].psfQF = in[i].psfQF; + out[i].psfQFperf = in[i].psfQFperf; + out[i].psfChisq = in[i].psfChisq; + out[i].psfNdof = in[i].psfNdof; + out[i].psfNpix = in[i].psfNpix; + out[i].crNsigma = in[i].crNsigma; + out[i].extNsigma = in[i].extNsigma; + out[i].FWx = in[i].FWx; + out[i].FWy = in[i].FWy; + out[i].theta = in[i].theta; + out[i].Mxx = in[i].Mxx; + out[i].Mxy = in[i].Mxy; + out[i].Myy = in[i].Myy; + out[i].t_msec = in[i].t_msec; + out[i].photcode = in[i].photcode; + out[i].dXccd = in[i].dXccd; + out[i].dYccd = in[i].dYccd; + out[i].dRsys = in[i].dRsys; + out[i].posangle = in[i].posangle; + out[i].pltscale = in[i].pltscale; + out[i].dbFlags = in[i].dbFlags; + out[i].photFlags = in[i].photFlags; + } + return (out); +} + +// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used +Average *Average_PS1_V5_ToInternal (Average_PS1_V5 *in, off_t Nvalues, SecFilt **primary) { + + off_t i; + Average *out; + + ALLOCATE_ZERO (out, Average, Nvalues); + + for (i = 0; i < Nvalues; i++) { + dvo_average_init (&out[i]); + + out[i].R = in[i].R; + out[i].D = in[i].D; + out[i].dR = in[i].dR; + out[i].dD = in[i].dD; + out[i].uR = in[i].uR; + out[i].uD = in[i].uD; + out[i].duR = in[i].duR; + out[i].duD = in[i].duD; + out[i].P = in[i].P; + out[i].dP = in[i].dP; + + out[i].Rstk = in[i].Rstk; + out[i].Dstk = in[i].Dstk; + out[i].dRstk = in[i].dRstk; + out[i].dDstk = in[i].dDstk; + + out[i].ChiSqAve = in[i].ChiSqAve; + out[i].ChiSqPM = in[i].ChiSqPM; + out[i].ChiSqPar = in[i].ChiSqPar; + out[i].Tmean = in[i].Tmean; + out[i].Trange = in[i].Trange; + + out[i].psfQF = in[i].psfQF; + out[i].psfQFperf = in[i].psfQFperf; + out[i].stargal = in[i].stargal; + out[i].Npos = in[i].Npos; + + out[i].Nmeasure = in[i].Nmeasure; + out[i].Nmissing = in[i].Nmissing; + out[i].Nlensing = in[i].Nlensing; + out[i].Nlensobj = in[i].Nlensobj; + out[i].Nextend = in[i].Nextend; + + out[i].measureOffset = in[i].measureOffset; + out[i].missingOffset = in[i].missingOffset; + out[i].lensingOffset = in[i].lensingOffset; + out[i].lensobjOffset = in[i].lensobjOffset; + out[i].extendOffset = in[i].extendOffset; + out[i].paramsOffset = in[i].paramsOffset; + + out[i].refColorBlue = in[i].refColorBlue; + out[i].refColorRed = in[i].refColorRed; + + out[i].flags = in[i].flags; + out[i].photFlagsUpper = in[i].photFlagsUpper; + out[i].photFlagsLower = in[i].photFlagsLower; + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + out[i].extID = in[i].extID; + out[i].extIDgc = in[i].extIDgc; + } + return (out); +} + +// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used +Average_PS1_V5 *AverageInternalTo_PS1_V5 (Average *in, off_t Nvalues, SecFilt *primary) { + + off_t i; + Average_PS1_V5 *out; + + ALLOCATE_ZERO (out, Average_PS1_V5, Nvalues); + + for (i = 0; i < Nvalues; i++) { + out[i].R = in[i].R; + out[i].D = in[i].D; + out[i].dR = in[i].dR; + out[i].dD = in[i].dD; + out[i].uR = in[i].uR; + out[i].uD = in[i].uD; + out[i].duR = in[i].duR; + out[i].duD = in[i].duD; + out[i].P = in[i].P; + out[i].dP = in[i].dP; + + out[i].Rstk = in[i].Rstk; + out[i].Dstk = in[i].Dstk; + out[i].dRstk = in[i].dRstk; + out[i].dDstk = in[i].dDstk; + + out[i].ChiSqAve = in[i].ChiSqAve; + out[i].ChiSqPM = in[i].ChiSqPM; + out[i].ChiSqPar = in[i].ChiSqPar; + out[i].Tmean = in[i].Tmean; + out[i].Trange = in[i].Trange; + + out[i].psfQF = in[i].psfQF; + out[i].psfQFperf = in[i].psfQFperf; + out[i].stargal = in[i].stargal; + out[i].Npos = in[i].Npos; + + out[i].Nmeasure = in[i].Nmeasure; + out[i].Nmissing = in[i].Nmissing; + out[i].Nlensing = in[i].Nlensing; + out[i].Nlensobj = in[i].Nlensobj; + out[i].Nextend = in[i].Nextend; + + out[i].measureOffset = in[i].measureOffset; + out[i].missingOffset = in[i].missingOffset; + out[i].lensingOffset = in[i].lensingOffset; + out[i].lensobjOffset = in[i].lensobjOffset; + out[i].extendOffset = in[i].extendOffset; + out[i].paramsOffset = in[i].paramsOffset; + + out[i].refColorBlue = in[i].refColorBlue; + out[i].refColorRed = in[i].refColorRed; + + out[i].flags = in[i].flags; + out[i].photFlagsUpper = in[i].photFlagsUpper; + out[i].photFlagsLower = in[i].photFlagsLower; + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + out[i].extID = in[i].extID; + out[i].extIDgc = in[i].extIDgc; + } + return (out); +} + +SecFilt *SecFilt_PS1_V5_ToInternal (SecFilt_PS1_V5 *in, off_t Nvalues) { + + off_t i; + SecFilt *out; + + ALLOCATE_ZERO (out, SecFilt, Nvalues); + + for (i = 0; i < Nvalues; i++) { + dvo_secfilt_init (&out[i]); + + out[i].M = in[i].M; + out[i].dM = in[i].dM; + out[i].Map = in[i].Map; + out[i].dMap = in[i].dMap; + out[i].sMap = in[i].sMap; + out[i].Mkron = in[i].Mkron; + out[i].dMkron = in[i].dMkron; + + out[i].Mstdev = in[i].Mstdev; + out[i].Mmin = in[i].Mmin; + out[i].Mmax = in[i].Mmax; + out[i].Mchisq = in[i].Mchisq; + + out[i].Ncode = in[i].Ncode; + out[i].Nused = in[i].Nused; + out[i].NusedKron = in[i].NusedKron; + out[i].NusedAp = in[i].NusedAp; + + out[i].flags = in[i].flags; + + out[i].MpsfStk = in[i].MpsfStk; + out[i].FpsfStk = in[i].FpsfStk; + out[i].dFpsfStk = in[i].dFpsfStk; + + out[i].MkronStk = in[i].MkronStk; + out[i].FkronStk = in[i].FkronStk; + out[i].dFkronStk = in[i].dFkronStk; + + out[i].MapStk = in[i].MapStk; + out[i].FapStk = in[i].FapStk; + out[i].dFapStk = in[i].dFapStk; + + out[i].stackDetectID = in[i].stackDetectID; + + out[i].MpsfWrp = in[i].MpsfWrp; + out[i].FpsfWrp = in[i].FpsfWrp; + out[i].dFpsfWrp = in[i].dFpsfWrp; + out[i].sFpsfWrp = in[i].sFpsfWrp; + + out[i].MkronWrp = in[i].MkronWrp; + out[i].FkronWrp = in[i].FkronWrp; + out[i].dFkronWrp = in[i].dFkronWrp; + out[i].sFkronWrp = in[i].sFkronWrp; + + out[i].MapWrp = in[i].MapWrp; + out[i].FapWrp = in[i].FapWrp; + out[i].dFapWrp = in[i].dFapWrp; + out[i].sFapWrp = in[i].sFapWrp; + + out[i].NusedWrp = in[i].NusedWrp; + out[i].NusedKronWrp = in[i].NusedKronWrp; + out[i].NusedApWrp = in[i].NusedApWrp; + + out[i].ubercalDist = in[i].ubercalDist; + } + return (out); +} + +SecFilt_PS1_V5 *SecFiltInternalTo_PS1_V5 (SecFilt *in, off_t Nvalues) { + + off_t i; + SecFilt_PS1_V5 *out; + + ALLOCATE_ZERO (out, SecFilt_PS1_V5, Nvalues); + + for (i = 0; i < Nvalues; i++) { + + out[i].M = in[i].M; + out[i].dM = in[i].dM; + out[i].Map = in[i].Map; + out[i].dMap = in[i].dMap; + out[i].sMap = in[i].sMap; + out[i].Mkron = in[i].Mkron; + out[i].dMkron = in[i].dMkron; + out[i].sMkron = in[i].sMkron; + + out[i].Mstdev = in[i].Mstdev; + out[i].Mmin = in[i].Mmin; + out[i].Mmax = in[i].Mmax; + out[i].Mchisq = in[i].Mchisq; + + out[i].Ncode = in[i].Ncode; + out[i].Nused = in[i].Nused; + out[i].NusedKron = in[i].NusedKron; + out[i].NusedAp = in[i].NusedAp; + + out[i].flags = in[i].flags; + + out[i].MpsfStk = in[i].MpsfStk; + out[i].FpsfStk = in[i].FpsfStk; + out[i].dFpsfStk = in[i].dFpsfStk; + + out[i].MkronStk = in[i].MkronStk; + out[i].FkronStk = in[i].FkronStk; + out[i].dFkronStk = in[i].dFkronStk; + + out[i].MapStk = in[i].MapStk; + out[i].FapStk = in[i].FapStk; + out[i].dFapStk = in[i].dFapStk; + + out[i].stackDetectID = in[i].stackDetectID; + + out[i].MpsfWrp = in[i].MpsfWrp; + out[i].FpsfWrp = in[i].FpsfWrp; + out[i].dFpsfWrp = in[i].dFpsfWrp; + out[i].sFpsfWrp = in[i].sFpsfWrp; + + out[i].MkronWrp = in[i].MkronWrp; + out[i].FkronWrp = in[i].FkronWrp; + out[i].dFkronWrp = in[i].dFkronWrp; + out[i].sFkronWrp = in[i].sFkronWrp; + + out[i].MapWrp = in[i].MapWrp; + out[i].FapWrp = in[i].FapWrp; + out[i].dFapWrp = in[i].dFapWrp; + out[i].sFapWrp = in[i].sFapWrp; + + out[i].NusedWrp = in[i].NusedWrp; + out[i].NusedKronWrp = in[i].NusedKronWrp; + out[i].NusedApWrp = in[i].NusedApWrp; + + out[i].ubercalDist = in[i].ubercalDist; + } + return (out); +} + +Lensing *Lensing_PS1_V5_ToInternal (Lensing_PS1_V5 *in, off_t Nvalues) { + + off_t i; + Lensing *out; + + ALLOCATE_ZERO (out, Lensing, Nvalues); + + for (i = 0; i < Nvalues; i++) { + dvo_lensing_init (&out[i]); + + out[i].X11_sm_obj = in[i].X11_sm_obj; + out[i].X12_sm_obj = in[i].X12_sm_obj; + out[i].X22_sm_obj = in[i].X22_sm_obj; + out[i].E1_sm_obj = in[i].E1_sm_obj; + out[i].E2_sm_obj = in[i].E2_sm_obj; + + out[i].X11_sh_obj = in[i].X11_sh_obj; + out[i].X12_sh_obj = in[i].X12_sh_obj; + out[i].X22_sh_obj = in[i].X22_sh_obj; + out[i].E1_sh_obj = in[i].E1_sh_obj; + out[i].E2_sh_obj = in[i].E2_sh_obj; + + out[i].X11_sm_psf = in[i].X11_sm_psf; + out[i].X12_sm_psf = in[i].X12_sm_psf; + out[i].X22_sm_psf = in[i].X22_sm_psf; + out[i].E1_sm_psf = in[i].E1_sm_psf; + out[i].E2_sm_psf = in[i].E2_sm_psf; + + out[i].X11_sh_psf = in[i].X11_sh_psf; + out[i].X12_sh_psf = in[i].X12_sh_psf; + out[i].X22_sh_psf = in[i].X22_sh_psf; + out[i].E1_sh_psf = in[i].E1_sh_psf; + out[i].E2_sh_psf = in[i].E2_sh_psf; + + out[i].F_ApR5 = in[i].F_ApR5; + out[i].dF_ApR5 = in[i].dF_ApR5; + out[i].sF_ApR5 = in[i].sF_ApR5; + out[i].fF_ApR5 = in[i].fF_ApR5; + + out[i].F_ApR6 = in[i].F_ApR6; + out[i].dF_ApR6 = in[i].dF_ApR6; + out[i].sF_ApR6 = in[i].sF_ApR6; + out[i].fF_ApR6 = in[i].fF_ApR6; + + out[i].detID = in[i].detID; + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + + out[i].averef = in[i].averef; + } + return (out); +} + +Lensing_PS1_V5 *LensingInternalTo_PS1_V5 (Lensing *in, off_t Nvalues) { + + off_t i; + Lensing_PS1_V5 *out; + + ALLOCATE_ZERO (out, Lensing_PS1_V5, Nvalues); + + for (i = 0; i < Nvalues; i++) { + + out[i].X11_sm_obj = in[i].X11_sm_obj; + out[i].X12_sm_obj = in[i].X12_sm_obj; + out[i].X22_sm_obj = in[i].X22_sm_obj; + out[i].E1_sm_obj = in[i].E1_sm_obj; + out[i].E2_sm_obj = in[i].E2_sm_obj; + + out[i].X11_sh_obj = in[i].X11_sh_obj; + out[i].X12_sh_obj = in[i].X12_sh_obj; + out[i].X22_sh_obj = in[i].X22_sh_obj; + out[i].E1_sh_obj = in[i].E1_sh_obj; + out[i].E2_sh_obj = in[i].E2_sh_obj; + + out[i].X11_sm_psf = in[i].X11_sm_psf; + out[i].X12_sm_psf = in[i].X12_sm_psf; + out[i].X22_sm_psf = in[i].X22_sm_psf; + out[i].E1_sm_psf = in[i].E1_sm_psf; + out[i].E2_sm_psf = in[i].E2_sm_psf; + + out[i].X11_sh_psf = in[i].X11_sh_psf; + out[i].X12_sh_psf = in[i].X12_sh_psf; + out[i].X22_sh_psf = in[i].X22_sh_psf; + out[i].E1_sh_psf = in[i].E1_sh_psf; + out[i].E2_sh_psf = in[i].E2_sh_psf; + + out[i].F_ApR5 = in[i].F_ApR5; + out[i].dF_ApR5 = in[i].dF_ApR5; + out[i].sF_ApR5 = in[i].sF_ApR5; + out[i].fF_ApR5 = in[i].fF_ApR5; + + out[i].F_ApR6 = in[i].F_ApR6; + out[i].dF_ApR6 = in[i].dF_ApR6; + out[i].sF_ApR6 = in[i].sF_ApR6; + out[i].fF_ApR6 = in[i].fF_ApR6; + + out[i].detID = in[i].detID; + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + + out[i].averef = in[i].averef; + } + return (out); +} + +Lensobj *Lensobj_PS1_V5_ToInternal (Lensobj_PS1_V5 *in, off_t Nvalues) { + + off_t i; + Lensobj *out; + + ALLOCATE_ZERO (out, Lensobj, Nvalues); + + for (i = 0; i < Nvalues; i++) { + dvo_lensobj_init (&out[i]); + + out[i].X11_sm_obj = in[i].X11_sm_obj; + out[i].X12_sm_obj = in[i].X12_sm_obj; + out[i].X22_sm_obj = in[i].X22_sm_obj; + out[i].E1_sm_obj = in[i].E1_sm_obj; + out[i].E2_sm_obj = in[i].E2_sm_obj; + + out[i].X11_sh_obj = in[i].X11_sh_obj; + out[i].X12_sh_obj = in[i].X12_sh_obj; + out[i].X22_sh_obj = in[i].X22_sh_obj; + out[i].E1_sh_obj = in[i].E1_sh_obj; + out[i].E2_sh_obj = in[i].E2_sh_obj; + + out[i].X11_sm_psf = in[i].X11_sm_psf; + out[i].X12_sm_psf = in[i].X12_sm_psf; + out[i].X22_sm_psf = in[i].X22_sm_psf; + out[i].E1_sm_psf = in[i].E1_sm_psf; + out[i].E2_sm_psf = in[i].E2_sm_psf; + + out[i].X11_sh_psf = in[i].X11_sh_psf; + out[i].X12_sh_psf = in[i].X12_sh_psf; + out[i].X22_sh_psf = in[i].X22_sh_psf; + out[i].E1_sh_psf = in[i].E1_sh_psf; + out[i].E2_sh_psf = in[i].E2_sh_psf; + + out[i].F_ApR5 = in[i].F_ApR5; + out[i].dF_ApR5 = in[i].dF_ApR5; + out[i].sF_ApR5 = in[i].sF_ApR5; + out[i].fF_ApR5 = in[i].fF_ApR5; + + out[i].F_ApR6 = in[i].F_ApR6; + out[i].dF_ApR6 = in[i].dF_ApR6; + out[i].sF_ApR6 = in[i].sF_ApR6; + out[i].fF_ApR6 = in[i].fF_ApR6; + + out[i].gamma = in[i].gamma; + out[i].E1 = in[i].E1; + out[i].E2 = in[i].E2; + + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + + } + return (out); +} + +Lensobj_PS1_V5 *LensobjInternalTo_PS1_V5 (Lensobj *in, off_t Nvalues) { + + off_t i; + Lensobj_PS1_V5 *out; + + ALLOCATE_ZERO (out, Lensobj_PS1_V5, Nvalues); + + for (i = 0; i < Nvalues; i++) { + + out[i].X11_sm_obj = in[i].X11_sm_obj; + out[i].X12_sm_obj = in[i].X12_sm_obj; + out[i].X22_sm_obj = in[i].X22_sm_obj; + out[i].E1_sm_obj = in[i].E1_sm_obj; + out[i].E2_sm_obj = in[i].E2_sm_obj; + + out[i].X11_sh_obj = in[i].X11_sh_obj; + out[i].X12_sh_obj = in[i].X12_sh_obj; + out[i].X22_sh_obj = in[i].X22_sh_obj; + out[i].E1_sh_obj = in[i].E1_sh_obj; + out[i].E2_sh_obj = in[i].E2_sh_obj; + + out[i].X11_sm_psf = in[i].X11_sm_psf; + out[i].X12_sm_psf = in[i].X12_sm_psf; + out[i].X22_sm_psf = in[i].X22_sm_psf; + out[i].E1_sm_psf = in[i].E1_sm_psf; + out[i].E2_sm_psf = in[i].E2_sm_psf; + + out[i].X11_sh_psf = in[i].X11_sh_psf; + out[i].X12_sh_psf = in[i].X12_sh_psf; + out[i].X22_sh_psf = in[i].X22_sh_psf; + out[i].E1_sh_psf = in[i].E1_sh_psf; + out[i].E2_sh_psf = in[i].E2_sh_psf; + + out[i].F_ApR5 = in[i].F_ApR5; + out[i].dF_ApR5 = in[i].dF_ApR5; + out[i].sF_ApR5 = in[i].sF_ApR5; + out[i].fF_ApR5 = in[i].fF_ApR5; + + out[i].F_ApR6 = in[i].F_ApR6; + out[i].dF_ApR6 = in[i].dF_ApR6; + out[i].sF_ApR6 = in[i].sF_ApR6; + out[i].fF_ApR6 = in[i].fF_ApR6; + + out[i].gamma = in[i].gamma; + out[i].E1 = in[i].E1; + out[i].E2 = in[i].E2; + + out[i].objID = in[i].objID; + out[i].catID = in[i].catID; + } + return (out); +} + +# define RAW_IMAGE_NAME_LEN 117 + +Image *Image_PS1_V5_ToInternal (Image_PS1_V5 *in, off_t Nvalues, off_t Nalloc) { + + off_t i; + Image *out; + + char *buffer; + ALLOCATE_ZERO (buffer, char, Nalloc); + out = (Image *) buffer; + // ALLOCATE_ZERO (out, Image, Nvalues); + + for (i = 0; i < Nvalues; i++) { + memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); + + // RAW_IMAGE_NAME_LEN == DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination + + out[i].tzero = in[i].tzero; + out[i].nstar = in[i].nstar; + out[i].secz = in[i].secz; + out[i].NX = in[i].NX; + out[i].NY = in[i].NY; + out[i].apmifit = in[i].apmifit; + out[i].dapmifit = in[i].dapmifit; + out[i].Mcal = in[i].Mcal; + out[i].dMcal = in[i].dMcal; + out[i].Xm = in[i].Xm; + out[i].photcode = in[i].photcode; + out[i].exptime = in[i].exptime; + out[i].sidtime = in[i].sidtime; + out[i].latitude = in[i].latitude; + + out[i].RAo = in[i].RAo; + out[i].DECo = in[i].DECo; + out[i].Radius = in[i].Radius; + out[i].refColorBlue = in[i].refColorBlue; + out[i].refColorRed = in[i].refColorRed; + + out[i].detection_limit = in[i].detection_limit; + out[i].saturation_limit = in[i].saturation_limit; + out[i].cerror = in[i].cerror; + out[i].fwhm_x = in[i].fwhm_x; + out[i].fwhm_y = in[i].fwhm_y; + out[i].trate = in[i].trate; + out[i].ccdnum = in[i].ccdnum; + out[i].flags = in[i].flags; + out[i].imageID = in[i].imageID; + out[i].parentID = in[i].parentID; + out[i].externID = in[i].externID; + out[i].sourceID = in[i].sourceID; + + // as of 2011.02.03, the old Mx,My,..., Mxxxx,Myyyy have been deprecated and replaced + // with the following. (no real databases used those values -- see + // libdvo/doc/dvo-images.txt) + out[i].nLinkAstrom = in[i].nLinkAstrom; + out[i].nLinkPhotom = in[i].nLinkPhotom; + out[i].ubercalDist = in[i].ubercalDist; + out[i].dXpixSys = in[i].dXpixSys; + out[i].dYpixSys = in[i].dYpixSys; + out[i].dMagSys = in[i].dMagSys; + out[i].nFitAstrom = in[i].nFitAstrom; + out[i].nFitPhotom = in[i].nFitPhotom; + out[i].photom_map_id = in[i].photom_map_id; + out[i].astrom_map_id = in[i].astrom_map_id; + } + return (out); +} + +Image_PS1_V5 *ImageInternalTo_PS1_V5 (Image *in, off_t Nvalues) { + + off_t i; + Image_PS1_V5 *out; + + ALLOCATE_ZERO (out, Image_PS1_V5, Nvalues); + + for (i = 0; i < Nvalues; i++) { + memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); + + // RAW_IMAGE_NAME_LEN == DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination + + out[i].tzero = in[i].tzero; + out[i].nstar = in[i].nstar; + out[i].secz = in[i].secz; + out[i].NX = in[i].NX; + out[i].NY = in[i].NY; + out[i].apmifit = in[i].apmifit; + out[i].dapmifit = in[i].dapmifit; + out[i].Mcal = in[i].Mcal; + out[i].dMcal = in[i].dMcal; + out[i].Xm = in[i].Xm; + out[i].photcode = in[i].photcode; + out[i].exptime = in[i].exptime; + out[i].sidtime = in[i].sidtime; + out[i].latitude = in[i].latitude; + + out[i].RAo = in[i].RAo; + out[i].DECo = in[i].DECo; + out[i].Radius = in[i].Radius; + out[i].refColorBlue = in[i].refColorBlue; + out[i].refColorRed = in[i].refColorRed; + + out[i].detection_limit = in[i].detection_limit; + out[i].saturation_limit = in[i].saturation_limit; + out[i].cerror = in[i].cerror; + out[i].fwhm_x = in[i].fwhm_x; + out[i].fwhm_y = in[i].fwhm_y; + out[i].trate = in[i].trate; + out[i].ccdnum = in[i].ccdnum; + out[i].flags = in[i].flags; + out[i].imageID = in[i].imageID; + out[i].parentID = in[i].parentID; + out[i].externID = in[i].externID; + out[i].sourceID = in[i].sourceID; + + // as of 2011.02.03, the old Mx,My,..., Mxxxx,Myyyy have been deprecated and replaced + // with the following. (no real databases used those values -- see + // libdvo/doc/dvo-images.txt) + out[i].nLinkAstrom = in[i].nLinkAstrom; + out[i].nLinkPhotom = in[i].nLinkPhotom; + out[i].ubercalDist = in[i].ubercalDist; + out[i].dXpixSys = in[i].dXpixSys; + out[i].dYpixSys = in[i].dYpixSys; + out[i].dMagSys = in[i].dMagSys; + out[i].nFitAstrom = in[i].nFitAstrom; + out[i].nFitPhotom = in[i].nFitPhotom; + out[i].photom_map_id = in[i].photom_map_id; + out[i].astrom_map_id = in[i].astrom_map_id; + } + return (out); +} + +PhotCode *PhotCode_PS1_V5_To_Internal (PhotCode_PS1_V5 *in, off_t Nvalues) { + + off_t i; + PhotCode *out; + + ALLOCATE_ZERO (out, PhotCode, Nvalues); + + for (i = 0; i < Nvalues; i++) { + strncpy (out[i].name, in[i].name, 31); // out[32], in[32] + out[i].name[31] = 0; // force termination + + out[i].code = in[i].code; + out[i].type = in[i].type; + out[i].C = in[i].C; + out[i].dC = in[i].dC; + out[i].dX = in[i].dX; + out[i].K = in[i].K; + out[i].c1 = in[i].c1; + out[i].c2 = in[i].c2; + out[i].equiv = in[i].equiv; + out[i].Nc = in[i].Nc; + memcpy (out[i].X, in[i].X, 4*sizeof(float)); + + out[i].astromErrSys = in[i].astromErrSys; + out[i].astromErrScale = in[i].astromErrScale; + out[i].astromErrMagScale = in[i].astromErrMagScale; + out[i].photomErrSys = in[i].photomErrSys; + + out[i].photomPoorMask = in[i].photomPoorMask; + out[i].photomBadMask = in[i].photomBadMask; + out[i].astromPoorMask = in[i].astromPoorMask; + out[i].astromBadMask = in[i].astromBadMask; + } + return (out); +} + +PhotCode_PS1_V5 *PhotCode_Internal_To_PS1_V5 (PhotCode *in, off_t Nvalues) { + + off_t i; + PhotCode_PS1_V5 *out; + + ALLOCATE_ZERO (out, PhotCode_PS1_V5, Nvalues); + + for (i = 0; i < Nvalues; i++) { + strncpy (out[i].name, in[i].name, 31); // out[32], in[32] + out[i].name[31] = 0; // force termination + + out[i].code = in[i].code; + out[i].type = in[i].type; + out[i].C = in[i].C; + out[i].dC = in[i].dC; + out[i].dX = in[i].dX; + out[i].K = in[i].K; + out[i].c1 = in[i].c1; + out[i].c2 = in[i].c2; + out[i].equiv = in[i].equiv; + out[i].Nc = in[i].Nc; + memcpy (out[i].X, in[i].X, 4*sizeof(float)); + + out[i].astromErrSys = in[i].astromErrSys; + out[i].astromErrScale = in[i].astromErrScale; + out[i].astromErrMagScale = in[i].astromErrMagScale; + out[i].photomErrSys = in[i].photomErrSys; + + out[i].photomPoorMask = in[i].photomPoorMask; + out[i].photomBadMask = in[i].photomBadMask; + out[i].astromPoorMask = in[i].astromPoorMask; + out[i].astromBadMask = in[i].astromBadMask; + } + return (out); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_elixir.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_elixir.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_elixir.c (revision 37067) @@ -2,5 +2,5 @@ /* convert elixir-format measures to internal measures */ -Measure *Measure_Elixir_ToInternal (Measure_Elixir *in, off_t Nvalues) { +Measure *Measure_Elixir_ToInternal (Average *ave, Measure_Elixir *in, off_t Nvalues) { off_t i; @@ -15,7 +15,10 @@ out[i].averef = in[i].averef; + // changed for PS1_V5 + int averef = out[i].averef; + out[i].R = (in[i].dR == NAN_S_SHORT) ? NAN : ave[averef].R - 0.01 * in[i].dR / 3600.0; + out[i].D = (in[i].dD == NAN_S_SHORT) ? NAN : ave[averef].D - 0.01 * in[i].dD / 3600.0; + // changed for PANSTARRS_DEV_0 - out[i].dR = (in[i].dR == NAN_S_SHORT) ? NAN : in[i].dR * 0.01; - out[i].dD = (in[i].dD == NAN_S_SHORT) ? NAN : in[i].dD * 0.01; out[i].M = (in[i].M == NAN_S_SHORT) ? NAN : in[i].M * 0.001; out[i].dM = (in[i].dM == NAN_U_CHAR) ? NAN : in[i].dM * 0.001; @@ -47,5 +50,5 @@ /* convert internal measures to elixir-format measures */ -Measure_Elixir *MeasureInternalTo_Elixir (Measure *in, off_t Nvalues) { +Measure_Elixir *MeasureInternalTo_Elixir (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -59,7 +62,11 @@ out[i].averef = in[i].averef; + // changed for PS1_V5 + int averef = in[i].averef; + int isBad = isnan(in[i].R) || isnan(in[i].D); + out[i].dR = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].R - in[i].R); + out[i].dD = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].D - in[i].D); + // changed for PANSTARRS_DEV_0 - out[i].dR = isnan(in[i].dR ) ? NAN_S_SHORT : in[i].dR * 100.0; - out[i].dD = isnan(in[i].dD ) ? NAN_S_SHORT : in[i].dD * 100.0; out[i].M = isnan(in[i].M ) ? NAN_S_SHORT : in[i].M * 1000.0; out[i].dM = isnan(in[i].dM ) ? NAN_U_CHAR : in[i].dM * 1000.0; @@ -104,5 +111,5 @@ primary[0][i].M = (in[i].M == NAN_S_SHORT) ? NAN : in[i].M * 0.001; primary[0][i].dM = (in[i].dM == NAN_S_SHORT) ? NAN : in[i].dM * 0.001; - primary[0][i].Xm = in[i].Xm; + primary[0][i].Mchisq= pow (10.0, 0.01*in[i].Xm); // added for PANSTARRS_DEV_0 @@ -137,5 +144,5 @@ out[i].M = isnan(primary[i].M) ? NAN_S_SHORT : primary[i].M * 1000.0; out[i].dM = isnan(primary[i].dM) ? NAN_S_SHORT : primary[i].dM * 1000.0; - out[i].Xm = primary[i].Xm; + out[i].Xm = 100.0*log10(primary[i].Mchisq); // changed or added for PS1_DEV_2 @@ -162,5 +169,5 @@ dvo_secfilt_init (&out[i]); - out[i].Xm = in[i].Xm; + out[i].Mchisq = pow (10.0, 0.01*in[i].Xm); // added or changed for PANSTARRS_DEV_0 @@ -180,5 +187,5 @@ for (i = 0; i < Nvalues; i++) { - out[i].Xm = in[i].Xm; + out[i].Xm = 100.0*log10(in[i].Mchisq); // added or changed for PANSTARRS_DEV_0 @@ -188,4 +195,6 @@ return (out); } + +# define RAW_IMAGE_NAME_LEN 32 /* convert elixir-format images to internal images */ @@ -203,6 +212,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 31); // in[32], out[128] - out[i].name[31] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -272,6 +282,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 31); // out[32], in[128] - out[i].name[31] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_loneos.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_loneos.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_loneos.c (revision 37067) @@ -2,5 +2,5 @@ /* convert loneos-format measures to internal measures */ -Measure *Measure_Loneos_ToInternal (Measure_Loneos *in, off_t Nvalues) { +Measure *Measure_Loneos_ToInternal (Average *ave, Measure_Loneos *in, off_t Nvalues) { off_t i; @@ -18,7 +18,10 @@ out[i].t = in[i].t; + // changed for PS1_V5 + int averef = out[i].averef; + out[i].R = (in[i].dR == NAN_S_SHORT) ? NAN : ave[averef].R - 0.01 * in[i].dR / 3600.0; + out[i].D = (in[i].dD == NAN_S_SHORT) ? NAN : ave[averef].D - 0.01 * in[i].dD / 3600.0; + // changed for PANSTARRS_DEV_0 - out[i].dR = (in[i].dR == NAN_S_SHORT) ? NAN : in[i].dR * 0.01; - out[i].dD = (in[i].dD == NAN_S_SHORT) ? NAN : in[i].dD * 0.01; out[i].M = (in[i].M == NAN_S_SHORT) ? NAN : in[i].M * 0.001; out[i].dM = (in[i].dM == NAN_U_CHAR) ? NAN : in[i].dM * 0.001; @@ -40,5 +43,5 @@ /* convert internal measures to loneos-format measures */ -Measure_Loneos *MeasureInternalTo_Loneos (Measure *in, off_t Nvalues) { +Measure_Loneos *MeasureInternalTo_Loneos (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -48,8 +51,10 @@ for (i = 0; i < Nvalues; i++) { - - // changed for PANSTARRS_DEV_0 - out[i].dR = isnan(in[i].dR ) ? NAN_S_SHORT : in[i].dR * 100.0; - out[i].dD = isnan(in[i].dD ) ? NAN_S_SHORT : in[i].dD * 100.0; + // changed for PS1_V5 + int averef = in[i].averef; + int isBad = isnan(in[i].R) || isnan(in[i].D); + out[i].dR = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].R - in[i].R); + out[i].dD = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].D - in[i].D); + out[i].M = isnan(in[i].M ) ? NAN_S_SHORT : in[i].M * 1000.0; out[i].dM = isnan(in[i].dM ) ? NAN_U_CHAR : in[i].dM * 1000.0; @@ -85,5 +90,5 @@ // changed for PANSTARRS_DEV_0 (moved from Average to Measure) primary[0][i].M = (in[i].M == NAN_S_SHORT) ? NAN : in[i].M * 0.001; - primary[0][i].Xm = in[i].Xm; + primary[0][i].Mchisq= pow (10.0, 0.01*in[i].Xm); // added for PANSTARRS_DEV_0 @@ -119,5 +124,5 @@ // changed for PANSTARRS_DEV_0 (moved from Average to Measure) out[i].M = isnan(primary[i].M) ? NAN_S_SHORT : primary[i].M * 1000.0; - out[i].Xm = primary[i].Xm; + out[i].Xm = 100.0*log10(primary[i].Mchisq); // changed or added for PS1_DEV_2 @@ -144,5 +149,5 @@ dvo_secfilt_init (&out[i]); - out[i].Xm = in[i].Xm; + out[i].Mchisq= pow (10.0, 0.01*in[i].Xm); // added or changed for PANSTARRS_DEV_0 @@ -161,5 +166,5 @@ for (i = 0; i < Nvalues; i++) { - out[i].Xm = in[i].Xm; + out[i].Xm = 100.0*log10(in[i].Mchisq); // added or changed for PANSTARRS_DEV_0 @@ -168,4 +173,6 @@ return (out); } + +# define RAW_IMAGE_NAME_LEN 32 /* convert loneos-format images to internal images */ @@ -183,6 +190,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 31); // in[32], out[128] - out[i].name[31] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -253,6 +261,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 31); // out[32], in[128] - out[i].name[31] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c (revision 37067) @@ -2,5 +2,5 @@ /* convert panstarrs-format measures to internal measures */ -Measure *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, off_t Nvalues) { +Measure *Measure_Panstarrs_DEV_0_ToInternal (Average *ave, Measure_Panstarrs_DEV_0 *in, off_t Nvalues) { off_t i; @@ -11,6 +11,8 @@ for (i = 0; i < Nvalues; i++) { dvo_measure_init (&out[i]); - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; out[i].M = in[i].M; out[i].dM = in[i].dM; @@ -52,5 +54,5 @@ /* convert internal measures to panstarrs-format measures */ -Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, off_t Nvalues) { +Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -60,6 +62,8 @@ for (i = 0; i < Nvalues; i++) { - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + + out[i].dR = 3600.0*(ave[averef].R - in[i].R); + out[i].dD = 3600.0*(ave[averef].D - in[i].D); out[i].M = in[i].M; out[i].dM = in[i].dM; @@ -184,5 +188,5 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq= pow (10.0, 0.01*in[i].Xm); out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; @@ -202,5 +206,5 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Xm = 100.0*log10(in[i].Mchisq); out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; @@ -208,4 +212,6 @@ return (out); } + +# define RAW_IMAGE_NAME_LEN 32 /* convert panstarrs-format images to internal images */ @@ -223,6 +229,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 31); // out[128], in[32] - out[i].name[31] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -292,6 +299,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 31); // out[32], in[128] - out[i].name[31] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c (revision 37067) @@ -2,5 +2,5 @@ /* convert panstarrs-format measures to internal measures */ -Measure *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, off_t Nvalues) { +Measure *Measure_Panstarrs_DEV_1_ToInternal (Average *ave, Measure_Panstarrs_DEV_1 *in, off_t Nvalues) { off_t i; @@ -11,6 +11,8 @@ for (i = 0; i < Nvalues; i++) { dvo_measure_init (&out[i]); - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + + int averef = in[i].averef; + out[i].R = ave[averef].R - in[i].dR / 3600.0; + out[i].D = ave[averef].D - in[i].dD / 3600.0; out[i].M = in[i].M; out[i].dM = in[i].dM; @@ -52,5 +54,5 @@ /* convert internal measures to panstarrs-format measures */ -Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, off_t Nvalues) { +Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Average *ave, Measure *in, off_t Nvalues) { off_t i; @@ -60,6 +62,8 @@ for (i = 0; i < Nvalues; i++) { - out[i].dR = in[i].dR; - out[i].dD = in[i].dD; + int averef = in[i].averef; + + out[i].dR = 3600.0*(ave[averef].R - in[i].R); + out[i].dD = 3600.0*(ave[averef].D - in[i].D); out[i].M = in[i].M; out[i].dM = in[i].dM; @@ -184,5 +188,5 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Mchisq= pow (10.0, 0.01*in[i].Xm); out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; @@ -202,5 +206,5 @@ out[i].M = in[i].M; out[i].dM = in[i].dM; - out[i].Xm = in[i].Xm; + out[i].Xm = 100.0*log10(in[i].Mchisq); out[i].Ncode = in[i].Ncode; out[i].Nused = in[i].Nused; @@ -208,4 +212,6 @@ return (out); } + +# define RAW_IMAGE_NAME_LEN 64 /* convert panstarrs-format images to internal images */ @@ -223,6 +229,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 63); // in[64], out[128] - out[i].name[63] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; @@ -292,6 +299,7 @@ memcpy (&out[i].coords, &in[i].coords, sizeof(Coords)); - strncpy (out[i].name, in[i].name, 63); // in[128], out[64] - out[i].name[63] = 0; // force termination + // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN + strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1); + out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination out[i].tzero = in[i].tzero; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_image.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_image.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_image.c (revision 37067) @@ -219,4 +219,5 @@ if (db[0].format == DVO_FORMAT_PS1_V3) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V3"); if (db[0].format == DVO_FORMAT_PS1_V4) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V4"); + if (db[0].format == DVO_FORMAT_PS1_V5) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V5"); if (db[0].format == DVO_FORMAT_PS1_REF) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_REF"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_image_raw.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_image_raw.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_image_raw.c (revision 37067) @@ -59,4 +59,5 @@ if (db[0].format == DVO_FORMAT_PS1_V3) ImageSize = sizeof(Image_PS1_V3); if (db[0].format == DVO_FORMAT_PS1_V4) ImageSize = sizeof(Image_PS1_V4); + if (db[0].format == DVO_FORMAT_PS1_V5) ImageSize = sizeof(Image_PS1_V5); if (db[0].format == DVO_FORMAT_PS1_REF) ImageSize = sizeof(Image_PS1_REF); @@ -89,4 +90,5 @@ if (db[0].format == DVO_FORMAT_PS1_V3) gfits_table_mkheader_Image_PS1_V3 (&db[0].theader); if (db[0].format == DVO_FORMAT_PS1_V4) gfits_table_mkheader_Image_PS1_V4 (&db[0].theader); + if (db[0].format == DVO_FORMAT_PS1_V5) gfits_table_mkheader_Image_PS1_V5 (&db[0].theader); if (db[0].format == DVO_FORMAT_PS1_REF) gfits_table_mkheader_Image_PS1_REF (&db[0].theader); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_photcode_ops.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_photcode_ops.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_photcode_ops.c (revision 37067) @@ -18,4 +18,6 @@ static PhotCodeData *photcodes = NULL; +static PhotCode *genericCodeMag = NULL; +static PhotCode *genericCodeFlux = NULL; PhotCodeData *GetPhotcodeTable () { @@ -26,4 +28,16 @@ photcodes[0].code = NULL; } + if (genericCodeMag == NULL) { + ALLOCATE (genericCodeMag, PhotCode, 1); + genericCodeMag->code = 0; + strcpy (genericCodeMag->name, "MAG"); + genericCodeMag->type = PHOT_MAG; + } + if (genericCodeFlux == NULL) { + ALLOCATE (genericCodeFlux, PhotCode, 1); + genericCodeFlux->code = 0; + strcpy (genericCodeFlux->name, "MAG"); + genericCodeFlux->type = PHOT_MAG; + } return photcodes; } @@ -57,4 +71,14 @@ if (name == NULL) return (NULL); + // "MAG" is a special word, not allowed for a photcode name + if (!strcasecmp (name, "MAG")) { + return genericCodeMag; + } + + // "FLUX" is a special word, not allowed for a photcode name + if (!strcasecmp (name, "FLUX")) { + return genericCodeFlux; + } + for (i = 0; i < photcodes[0].Ncode; i++) { if (!strcmp (photcodes[0].code[i].name, name)) { @@ -70,4 +94,13 @@ if (name == NULL) return (0); + + // "MAG" is a special photcode name for internal use + if (!strcasecmp (name, "MAG")) { + return genericCodeMag->code; + } + // "FLUX" is a special photcode name for internal use + if (!strcasecmp (name, "FLUX")) { + return genericCodeFlux->code; + } for (i = 0; i < photcodes[0].Ncode; i++) { @@ -169,4 +202,5 @@ } +// returns Nsec if code is PRI/SEC, else -1 int GetPhotcodeNsec (int code) { @@ -221,144 +255,365 @@ /******** photometry conversion functions *********/ -float PhotInst (Measure *measure) { - - int Np; - float M; - - Np = photcodes[0].hashcode[measure[0].photcode]; +float PhotInst (Measure *measure, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - M = measure[0].M; - return (M); - } - - M = measure[0].M - measure[0].dt - ZERO_POINT; - - return (M); - -} - -float PhotCat (Measure *measure) { - - int Np; - float Mcat; - PhotCode *code; - - Np = photcodes[0].hashcode[measure[0].photcode]; + PhotCode *code = &photcodes[0].code[Np]; + + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = measure[0].M; + break; + case MAG_CLASS_KRON: + Mraw = measure[0].Mkron; + break; + case MAG_CLASS_APER: + Mraw = measure[0].Map; + break; + default: + break; + } + if (code->type == PHOT_REF) { + return (Mraw); + } + float Minst = Mraw - measure[0].dt - ZERO_POINT; + + return (Minst); +} + +float PhotCat (Measure *measure, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Mcat = measure[0].M; - return (Mcat); - } - code = &photcodes[0].code[Np]; - Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; + PhotCode *code = &photcodes[0].code[Np]; + + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = measure[0].M; + break; + case MAG_CLASS_KRON: + Mraw = measure[0].Mkron; + break; + case MAG_CLASS_APER: + Mraw = measure[0].Map; + break; + default: + break; + } + if (code->type == PHOT_REF) { + return (Mraw); + } + + float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; return (Mcat); } -float PhotAper (Measure *measure) { - - int Np; - float Mcat; - PhotCode *code; - - Np = photcodes[0].hashcode[measure[0].photcode]; +float PhotSys (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Mcat = measure[0].Map; - return (Mcat); - } - code = &photcodes[0].code[Np]; - Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; - - return (Mcat); -} - -float PhotAperInst (Measure *measure) { - - int Np; - float Minst; - - Np = photcodes[0].hashcode[measure[0].photcode]; - if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Minst = measure[0].Map; - return (Minst); - } - Minst = measure[0].Map - measure[0].dt - ZERO_POINT; - - return (Minst); -} - -float PhotKron (Measure *measure) { - - int Np; - float Mcat; - PhotCode *code; - - Np = photcodes[0].hashcode[measure[0].photcode]; - if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Mcat = measure[0].Mkron; - return (Mcat); - } - code = &photcodes[0].code[Np]; - Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; - - return (Mcat); -} - -float PhotKronInst (Measure *measure) { - - int Np; - float Minst; - - Np = photcodes[0].hashcode[measure[0].photcode]; - if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Minst = measure[0].Mkron; - return (Minst); - } - Minst = measure[0].Mkron - measure[0].dt - ZERO_POINT; - - return (Minst); -} - -float PhotSys (Measure *measure, Average *average, SecFilt *secfilt) { - - int i, Np; - float Mcat, Mcol, Msys, mc, Mc; - PhotCode *code; - - Np = photcodes[0].hashcode[measure[0].photcode]; - if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Msys = measure[0].M; - return (Msys); - } - code = &photcodes[0].code[Np]; - Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; + PhotCode *code = &photcodes[0].code[Np]; + + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = measure[0].M; + break; + case MAG_CLASS_KRON: + Mraw = measure[0].Mkron; + break; + case MAG_CLASS_APER: + Mraw = measure[0].Map; + break; + default: + break; + } + if (code->type == PHOT_REF) { + return (Mraw); + } + float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; /* for DEP, color must be made of PRI/SEC */ - mc = PhotColorForCode (average, secfilt, NULL, code); + float mc = PhotColorForCode (average, secfilt, NULL, code); if (isnan(mc)) return (Mcat); - mc = mc - SCALE*code[0].dX; - - Mc = mc; - Mcol = 0; + mc -= SCALE*code[0].dX; + + int i = 0; + double Mc = mc; + float Mcol = 0; for (i = 0; i < code[0].Nc; i++) { Mcol += code[0].X[i]*Mc; Mc *= mc; } - Msys = Mcat + Mcol; + float Msys = Mcat + Mcol; return (Msys); } + +float PhotRel (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; + if (Np == -1) return (NAN); + PhotCode *code = &photcodes[0].code[Np]; + + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = measure[0].M; + break; + case MAG_CLASS_KRON: + Mraw = measure[0].Mkron; + break; + case MAG_CLASS_APER: + Mraw = measure[0].Map; + break; + default: + break; + } + if (code->type == PHOT_REF) { + return (Mraw); + } + float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal; + + /* for DEP, color must be made of PRI/SEC */ + float mc = PhotColorForCode (average, secfilt, NULL, code); + if (isnan(mc)) return (Mcat); + mc -= SCALE*code[0].dX; + + double Mc = mc; + float Mcol = 0; + int i = 0; + for (i = 0; i < code[0].Nc; i++) { + Mcol += code[0].X[i]*Mc; + Mc *= mc; + } + float Mrel = Mcat + Mcol; + return (Mrel); +} + +/* return calibrated magnitude from measure for given photcode */ +float PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code, dvoMagClassType class) { + + int i; + + if (code == NULL) return NAN; + + /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */ + int Np = photcodes[0].hashcode[thisone[0].photcode]; + if (Np == -1) return (NAN); + PhotCode *myCode = &photcodes[0].code[Np]; + + if (code->code != myCode->equiv) return (NAN); + + // if we are REF type, just get the right version and return + if (myCode->type == PHOT_REF) { + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = thisone[0].M; + break; + case MAG_CLASS_KRON: + Mraw = thisone[0].Mkron; + break; + case MAG_CLASS_APER: + Mraw = thisone[0].Map; + break; + default: + break; + } + return (Mraw); + } + + float Mcal = PhotRel (thisone, average, secfilt, class) + SCALE*code[0].C; + + float mc = PhotColorForCode (average, secfilt, measure, code); + if (isnan(mc)) return (Mcal); + mc -= SCALE*code[0].dX; + + double Mc = mc; + float Mcol = 0; + for (i = 0; i < code[0].Nc; i++) { + Mcol += code[0].X[i]*Mc; + Mc *= mc; + } + Mcal += Mcol; + return (Mcal); +} + +/***/ +float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) { + + if (code == NULL) return NAN; + + int Ns = photcodes[0].hashNsec[code[0].code]; + if (Ns == -1) return (NAN); + + float Mave = NAN; + switch (source) { + case MAG_SRC_CHP: + switch (class) { + case MAG_CLASS_PSF: + Mave = secfilt[Ns].M; + break; + case MAG_CLASS_KRON: + Mave = secfilt[Ns].Mkron; + break; + case MAG_CLASS_APER: + Mave = secfilt[Ns].Map; + break; + default: + break; + } + break; + case MAG_SRC_WRP: + switch (class) { + case MAG_CLASS_PSF: + Mave = secfilt[Ns].MpsfWrp; + break; + case MAG_CLASS_KRON: + Mave = secfilt[Ns].MkronWrp; + break; + case MAG_CLASS_APER: + Mave = secfilt[Ns].MapWrp; + break; + default: + break; + } + break; + case MAG_SRC_STK: + switch (class) { + case MAG_CLASS_PSF: + Mave = secfilt[Ns].MpsfStk; + break; + case MAG_CLASS_KRON: + Mave = secfilt[Ns].MkronStk; + break; + case MAG_CLASS_APER: + Mave = secfilt[Ns].MapStk; + break; + default: + break; + } + break; + default: + break; + } + return (Mave); +} + +/* return calibrated magnitude from average/secfilt for given photcode */ +float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure, dvoMagClassType class, dvoMagSourceType source) { + + int i; + + float Mave = PhotAve (code, average, secfilt, class, source); + if (isnan(Mave)) return NAN; + + // correct for relative zero-point + float Mref = Mave + SCALE*code[0].C; + + float mc = PhotColorForCode (average, secfilt, measure, code); + if (isnan(mc)) return (Mref); + mc -= SCALE*code[0].dX; + + // correct for color terms + double Mc = mc; + float Mcol = 0; + for (i = 0; i < code[0].Nc; i++) { + Mcol += code[0].X[i]*Mc; + Mc *= mc; /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */ + } + Mref += Mcol; + return (Mref); +} + +float PhotErr (Measure *measure, dvoMagClassType class) { + + float dMraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + dMraw = measure[0].dM; + break; + case MAG_CLASS_KRON: + dMraw = measure[0].dMkron; + break; + case MAG_CLASS_APER: + dMraw = measure[0].dMap; + break; + default: + break; + } + return (dMraw); +} + +float PhotCalErr (Measure *measure, dvoMagClassType class) { + + float dMcal = measure[0].dMcal; + return (dMcal); +} + +float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) { + + if (code == NULL) return NAN; + + int Ns = photcodes[0].hashNsec[code[0].code]; + if (Ns == -1) return (NAN); + + float dMave = NAN; + switch (source) { + case MAG_SRC_CHP: + switch (class) { + case MAG_CLASS_PSF: + dMave = secfilt[Ns].dM; + break; + case MAG_CLASS_KRON: + dMave = secfilt[Ns].dMkron; + break; + case MAG_CLASS_APER: + dMave = secfilt[Ns].dMap; + break; + default: + break; + } + break; + case MAG_SRC_WRP: + switch (class) { + case MAG_CLASS_PSF: + dMave = secfilt[Ns].dFpsfWrp / secfilt[Ns].FpsfWrp; + break; + case MAG_CLASS_KRON: + dMave = secfilt[Ns].dFkronWrp / secfilt[Ns].FkronWrp; + break; + case MAG_CLASS_APER: + dMave = secfilt[Ns].dFapWrp / secfilt[Ns].FapWrp; + break; + default: + break; + } + break; + case MAG_SRC_STK: + switch (class) { + case MAG_CLASS_PSF: + dMave = secfilt[Ns].dFpsfStk / secfilt[Ns].FpsfStk; + break; + case MAG_CLASS_KRON: + dMave = secfilt[Ns].dFkronStk / secfilt[Ns].FkronStk; + break; + case MAG_CLASS_APER: + dMave = secfilt[Ns].dFapStk / secfilt[Ns].FapStk; + break; + default: + break; + } + break; + default: + break; + } + return (dMave); +} + +/********************* other support functions ********************************/ float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt) { @@ -381,70 +636,6 @@ } -float PhotRel (Measure *measure, Average *average, SecFilt *secfilt) { - - int i, Np; - float Mcat, Mcol, Mrel, mc, Mc; - PhotCode *code; - - Np = photcodes[0].hashcode[measure[0].photcode]; - if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Mcat = measure[0].M; - return (Mcat); - } - code = &photcodes[0].code[Np]; - Mrel = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal; - - /* for DEP, color must be made of PRI/SEC */ - mc = PhotColorForCode (average, secfilt, NULL, code); - if (isnan(mc)) return (Mrel); - mc = mc - SCALE*code[0].dX; - - Mc = mc; - Mcol = 0; - for (i = 0; i < code[0].Nc; i++) { - Mcol += code[0].X[i]*Mc; - Mc *= mc; /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */ - } - Mrel += Mcol; - return (Mrel); -} - -/* return calibrated magnitude from measure for given photcode */ -float PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) { - - int i, Np; - float Mcal, Mrel, Mcol, mc, Mc; - - if (code == NULL) return NAN; - - /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */ - Np = photcodes[0].hashcode[thisone[0].photcode]; - if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Mrel = thisone[0].M; - return (Mrel); - } - if (code[0].code != photcodes[0].code[Np].equiv) return (NAN); - - Mcal = PhotRel (thisone, average, secfilt) + SCALE*code[0].C; - - mc = PhotColorForCode (average, secfilt, measure, code); - if (isnan(mc)) return (Mcal); - mc = mc - SCALE*code[0].dX; - - Mc = mc; - Mcol = 0; - for (i = 0; i < code[0].Nc; i++) { - Mcol += code[0].X[i]*Mc; - Mc *= mc; - } - Mcal += Mcol; - return (Mcal); -} - /* color term may not use DEP magnitude */ +// currently only returns the PSF color float PhotColorForCode (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) { @@ -496,56 +687,4 @@ } -/* return calibrated magnitude from average/secfilt for given photcode */ -float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) { - - int i, Ns; - float Mave, Mref, Mcol, mc; - double Mc; - - if (code == NULL) return NAN; - - Ns = photcodes[0].hashNsec[code[0].code]; - Mave = (Ns == -1) ? NAN : secfilt[Ns].M; - Mref = Mave + SCALE*code[0].C; - - mc = PhotColorForCode (average, secfilt, measure, code); - if (isnan(mc)) return (Mref); - mc = mc - SCALE*code[0].dX; - - Mc = mc; - Mcol = 0; - for (i = 0; i < code[0].Nc; i++) { - Mcol += code[0].X[i]*Mc; - Mc *= mc; /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */ - } - Mref += Mcol; - return (Mref); -} - -/***/ -float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt) { - - int Ns; - float Mave; - - if (code == NULL) return NAN; - - Ns = photcodes[0].hashNsec[code[0].code]; - Mave = (Ns == -1) ? NAN : secfilt[Ns].M; - return (Mave); -} - -float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt) { - - int Ns; - float dM; - - if (code == NULL) return NAN; - - Ns = photcodes[0].hashNsec[code[0].code]; - dM = (Ns == -1) ? NAN : secfilt[Ns].dM; - return (dM); -} - float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt) { @@ -560,28 +699,4 @@ } -float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt) { - - int Ns; - float Mkron; - - if (code == NULL) return NAN; - - Ns = photcodes[0].hashNsec[code[0].code]; - Mkron = (Ns == -1) ? NAN : secfilt[Ns].Mkron; - return (Mkron); -} - -float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt) { - - int Ns; - float dMkron; - - if (code == NULL) return NAN; - - Ns = photcodes[0].hashNsec[code[0].code]; - dMkron = (Ns == -1) ? NAN : secfilt[Ns].dMkron; - return (dMkron); -} - float PhotAveFluxPSF (PhotCode *code, Average *average, SecFilt *secfilt) { @@ -592,5 +707,5 @@ Ns = photcodes[0].hashNsec[code[0].code]; - Fpsf = (Ns == -1) ? NAN : secfilt[Ns].FluxPSF; + Fpsf = (Ns == -1) ? NAN : secfilt[Ns].FpsfStk; return (Fpsf); } @@ -604,5 +719,5 @@ Ns = photcodes[0].hashNsec[code[0].code]; - dFpsf = (Ns == -1) ? NAN : secfilt[Ns].dFluxPSF; + dFpsf = (Ns == -1) ? NAN : secfilt[Ns].dFpsfStk; return (dFpsf); } @@ -616,5 +731,5 @@ Ns = photcodes[0].hashNsec[code[0].code]; - Fkron = (Ns == -1) ? NAN : secfilt[Ns].FluxKron; + Fkron = (Ns == -1) ? NAN : secfilt[Ns].FkronStk; return (Fkron); } @@ -628,30 +743,30 @@ Ns = photcodes[0].hashNsec[code[0].code]; - dFkron = (Ns == -1) ? NAN : secfilt[Ns].dFluxKron; + dFkron = (Ns == -1) ? NAN : secfilt[Ns].dFkronStk; return (dFkron); } -float PhotM20 (PhotCode *code, Average *average, SecFilt *secfilt) { +float PhotMmin (PhotCode *code, Average *average, SecFilt *secfilt) { int Ns; - float M20; + float Mmin; if (code == NULL) return NAN; Ns = photcodes[0].hashNsec[code[0].code]; - M20 = (Ns == -1) ? NAN : 0.001*secfilt[Ns].M_20; - return (M20); -} - -float PhotM80 (PhotCode *code, Average *average, SecFilt *secfilt) { + Mmin = (Ns == -1) ? NAN : secfilt[Ns].Mmin; + return (Mmin); +} + +float PhotMmax (PhotCode *code, Average *average, SecFilt *secfilt) { int Ns; - float M80; + float Mmax; if (code == NULL) return NAN; Ns = photcodes[0].hashNsec[code[0].code]; - M80 = (Ns == -1) ? NAN : 0.001*secfilt[Ns].M_80; - return (M80); + Mmax = (Ns == -1) ? NAN : secfilt[Ns].Mmax; + return (Mmax); } @@ -680,9 +795,8 @@ } -// XXX return NAN or NAN_S_SHORT? (secfilt->Xm is short) +// Xm is now (2014.07.03) stored as the chisq except in dvo formats which use as short float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt) { int Ns; - short Mi; float Xm; @@ -690,6 +804,5 @@ Ns = photcodes[0].hashNsec[code[0].code]; - Mi = (Ns == -1) ? NAN : secfilt[Ns].Xm; - Xm = (isnan(Mi)) ? -1.0 : pow (10.0, 0.01*Mi); + Xm = (Ns == -1) ? NAN : secfilt[Ns].Mchisq; return (Xm); } @@ -741,158 +854,649 @@ } -/******** alternate photometry conversion functions using MeasureTiny and AverageTiny *********/ -float PhotInstTiny (MeasureTiny *measure) { - - int Np; - float M; - - Np = photcodes[0].hashcode[measure[0].photcode]; +float MagToFlux (float Mag) { + float Flux = pow(10.0, -0.4*(Mag)); + return (Flux); +} + +/** flux conversion *******************************************************************/ +float PhotFluxInst (Measure *measure, dvoMagClassType class) { + + float Moff = - measure[0].dt - ZERO_POINT; + float Finst = NAN; + switch (class) { + case MAG_CLASS_PSF: + Finst = isnan (measure[0].FluxPSF) ? MagToFlux(measure[0].M + Moff) : measure[0].FluxPSF; + break; + case MAG_CLASS_KRON: + Finst = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron; + break; + case MAG_CLASS_APER: + Finst = isnan (measure[0].FluxAp) ? MagToFlux(measure[0].Map + Moff) : measure[0].FluxAp; + break; + default: + break; + } + return (Finst); +} + +// returns Jy fluxes assuming mag in AB? (needs an extra AP factor, right?) +float PhotFluxCat (Measure *measure, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - M = measure[0].M; - return (M); - } - - M = measure[0].M - measure[0].dt - ZERO_POINT; - - return (M); - -} - -float PhotCatTiny (MeasureTiny *measure) { - - int Np; - float Mcat; - PhotCode *code; - - Np = photcodes[0].hashcode[measure[0].photcode]; + PhotCode *code = &photcodes[0].code[Np]; + + // mag_AB = -2.5 log (flux_cgs) - 48.6 (by definition) [~Vega flux in V-band] + // flux_Jy = flux_cgs * 10^23 + // -2.5 log (flux_cgs) = -2.5 log (flux_Jy * 10^-23) = -2.5 log (flux_Jy) + 2.5*23 + + // from these we get: + // mag_AB = -2.5 log (flux_Jy) + 8.9 + // log (flux_Jy) = -0.4*mag_AB + 3.56 + + // mag_AB = mag_inst + ZP + + // log(flux_Jy) = -0.4*mag_inst -0.4*ZP + 3.56 + // mag_inst = -2.5 log (flux_Jy) - ZP + 8.9 + + // log (flux_Jy) = -0.4*(mag_inst + ZP - 8.9) + + // -2.5 log (flux_inst) = -2.5 log (flux_Jy) - ZP + 8.9 + // log (flux_inst) = log (flux_Jy) + 0.4 ZP - 3.56 + // flux_inst = flux_Jy * 10^(0.4*ZP - 3.56) + // flux_Jy = flux_inst * 10^(3.56 - 0.4*ZP) = flux_inst * zpFactor + // flux_Jy = flux_inst * 3630.8 * 10^(-0.4*ZP) + + // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux + float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; + float Moff = Mcal - ZERO_POINT + 8.9; + float Foff = 3630.8 * MagToFlux(Mcal); + float Fcat = NAN; + switch (class) { + case MAG_CLASS_PSF: + Fcat = isnan (measure[0].FluxPSF) ? MagToFlux(measure[0].M + Moff) : measure[0].FluxPSF * Foff; + break; + case MAG_CLASS_KRON: + Fcat = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron * Foff; + break; + case MAG_CLASS_APER: + Fcat = isnan (measure[0].FluxAp) ? MagToFlux(measure[0].Map + Moff) : measure[0].FluxAp * Foff; + break; + default: + break; + } + return (Fcat); +} + +// corrected for color trends +float PhotFluxSys (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Mcat = measure[0].M; - return (Mcat); - } - code = &photcodes[0].code[Np]; - Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; - - return (Mcat); -} - -# if (0) -float PhotAperTiny (MeasureTiny *measure) { - - int Np; - float Mcat; - PhotCode *code; - - Np = photcodes[0].hashcode[measure[0].photcode]; - if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Mcat = measure[0].Map; - return (Mcat); - } - code = &photcodes[0].code[Np]; - Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; - - return (Mcat); -} -# endif - -float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt) { - - int i, Np; - float Mcat, Mcol, Msys, mc, Mc; - PhotCode *code; - - Np = photcodes[0].hashcode[measure[0].photcode]; - if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Msys = measure[0].M; - return (Msys); - } - code = &photcodes[0].code[Np]; - Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; - - /* for DEP, color must be made of PRI/SEC */ - mc = PhotColorForCodeTiny (average, secfilt, NULL, code); - if (isnan(mc)) return (Mcat); - mc = mc - SCALE*code[0].dX; - - Mc = mc; - Mcol = 0; + PhotCode *code = &photcodes[0].code[Np]; + + // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux + float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; + float Moff = Mcal - ZERO_POINT + 8.9; + float Foff = 3630.8 * MagToFlux(Mcal); + float Fcat = NAN; + switch (class) { + case MAG_CLASS_PSF: + Fcat = isnan (measure[0].FluxPSF) ? MagToFlux(measure[0].M + Moff) : measure[0].FluxPSF * Foff; + break; + case MAG_CLASS_KRON: + Fcat = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron * Foff; + break; + case MAG_CLASS_APER: + Fcat = isnan (measure[0].FluxAp) ? MagToFlux(measure[0].Map + Moff) : measure[0].FluxAp * Foff; + break; + default: + break; + } + if (isnan(Fcat)) return (NAN); + + // find the relevant color + float mc = PhotColorForCode (average, secfilt, NULL, code); + if (isnan(mc)) return (Fcat); + mc -= SCALE*code[0].dX; + + // find the color correction in mags + int i = 0; + double Mc = mc; + float Mcol = 0; for (i = 0; i < code[0].Nc; i++) { Mcol += code[0].X[i]*Mc; Mc *= mc; } - Msys = Mcat + Mcol; - return (Msys); -} - -float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt) { - - int i, Np; - float Mcat, Mcol, Mrel, mc, Mc; - PhotCode *code; - - Np = photcodes[0].hashcode[measure[0].photcode]; + float Fcol = MagToFlux (Mcol); + + float Fsys = Fcat * Fcol; + return (Fsys); +} + +float PhotFluxRel (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Mcat = measure[0].M; - return (Mcat); - } - code = &photcodes[0].code[Np]; - Mrel = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal; + PhotCode *code = &photcodes[0].code[Np]; + + // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux + float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal; + float Moff = Mcal - ZERO_POINT + 8.9; + float Foff = 3630.8 * MagToFlux(Mcal); + float Fcat = NAN; + switch (class) { + case MAG_CLASS_PSF: + Fcat = isnan (measure[0].FluxPSF) ? MagToFlux(measure[0].M + Moff) : measure[0].FluxPSF * Foff; + break; + case MAG_CLASS_KRON: + Fcat = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron * Foff; + break; + case MAG_CLASS_APER: + Fcat = isnan (measure[0].FluxAp) ? MagToFlux(measure[0].Map + Moff) : measure[0].FluxAp * Foff; + break; + default: + break; + } + if (isnan(Fcat)) return (NAN); /* for DEP, color must be made of PRI/SEC */ - mc = PhotColorForCodeTiny (average, secfilt, NULL, code); - if (isnan(mc)) return (Mrel); - mc = mc - SCALE*code[0].dX; - - Mc = mc; - Mcol = 0; + float mc = PhotColorForCode (average, secfilt, NULL, code); + if (isnan(mc)) return (Fcat); + mc -= SCALE*code[0].dX; + + double Mc = mc; + float Mcol = 0; + int i = 0; + for (i = 0; i < code[0].Nc; i++) { + Mcol += code[0].X[i]*Mc; + Mc *= mc; + } + float Fcol = MagToFlux (Mcol); + + float Frel = Fcat * Fcol; + return (Frel); +} + +/* return calibrated magnitude from measure for given photcode */ +float PhotFluxCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code, dvoMagClassType class) { + + int i; + + if (code == NULL) return NAN; + + /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */ + int Np = photcodes[0].hashcode[thisone[0].photcode]; + if (Np == -1) return (NAN); + PhotCode *myCode = &photcodes[0].code[Np]; + + if (code->code != myCode->equiv) return (NAN); + + float Frel = PhotFluxRel (thisone, average, secfilt, class) + SCALE*code[0].C; + + // get the relevant color term + float mc = PhotColorForCode (average, secfilt, measure, code); + if (isnan(mc)) return (Frel); + mc -= SCALE*code[0].dX; + + // get the corresponding color correction in mags, convert to flux + double Mc = mc; + float Mcol = 0; + for (i = 0; i < code[0].Nc; i++) { + Mcol += code[0].X[i]*Mc; + Mc *= mc; + } + float Fcol = MagToFlux (Mcol); + + float Fcal = Frel * Fcol; + return (Fcal); +} + +/***/ +float PhotFluxAve (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) { + + if (code == NULL) return NAN; + + int Ns = photcodes[0].hashNsec[code[0].code]; + if (Ns == -1) return (NAN); + + float Fave = NAN; + switch (source) { + case MAG_SRC_CHP: + switch (class) { + case MAG_CLASS_PSF: + Fave = MagToFlux(secfilt[Ns].M); + break; + case MAG_CLASS_KRON: + Fave = MagToFlux(secfilt[Ns].Mkron); + break; + case MAG_CLASS_APER: + Fave = MagToFlux(secfilt[Ns].Map); + break; + default: + break; + } + break; + case MAG_SRC_WRP: + switch (class) { + case MAG_CLASS_PSF: + Fave = isnan (secfilt[Ns].FpsfWrp) ? MagToFlux(secfilt[Ns].MpsfWrp) : secfilt[Ns].FpsfWrp; + break; + case MAG_CLASS_KRON: + Fave = isnan (secfilt[Ns].FkronWrp) ? MagToFlux(secfilt[Ns].MkronWrp) : secfilt[Ns].FkronWrp; + break; + case MAG_CLASS_APER: + Fave = isnan (secfilt[Ns].FapWrp) ? MagToFlux(secfilt[Ns].MapWrp) : secfilt[Ns].FapWrp; + break; + default: + break; + } + break; + case MAG_SRC_STK: + switch (class) { + case MAG_CLASS_PSF: + Fave = isnan (secfilt[Ns].FpsfStk) ? MagToFlux(secfilt[Ns].MpsfStk) : secfilt[Ns].FpsfStk; + break; + case MAG_CLASS_KRON: + Fave = isnan (secfilt[Ns].FkronStk) ? MagToFlux(secfilt[Ns].MkronStk) : secfilt[Ns].FkronStk; + break; + case MAG_CLASS_APER: + Fave = isnan (secfilt[Ns].FapStk) ? MagToFlux(secfilt[Ns].MapStk) : secfilt[Ns].FapStk; + break; + default: + break; + } + break; + default: + break; + } + return (Fave); +} + +/* return calibrated magnitude from average/secfilt for given photcode */ +float PhotFluxRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure, dvoMagClassType class, dvoMagSourceType source) { + + int i; + + float Fave = PhotFluxAve (code, average, secfilt, class, source); + if (isnan(Fave)) return NAN; + + // correct for relative zero-point + float Moff = SCALE*code[0].C; + + float mc = PhotColorForCode (average, secfilt, measure, code); + if (isnan(mc)) return (Fave * MagToFlux(Moff)); + mc -= SCALE*code[0].dX; + + // correct for color terms + double Mc = mc; + float Mcol = 0; for (i = 0; i < code[0].Nc; i++) { Mcol += code[0].X[i]*Mc; Mc *= mc; /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */ } - Mrel += Mcol; - return (Mrel); -} - -/* return calibrated magnitude from measure for given photcode */ -float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code) { - - int i, Np; - float Mcal, Mrel, Mcol, mc, Mc; - - if (code == NULL) return NAN; - - /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */ - Np = photcodes[0].hashcode[thisone[0].photcode]; + float Foff = MagToFlux(Mcol); + return (Fave * Foff); +} + +float PhotFluxInstErr (Measure *measure, dvoMagClassType class) { + + float Moff = - measure[0].dt - ZERO_POINT; + + // use dFlux if we can, but use dMag if we must: + // dFlux = Flux * dMag + + float dFinst = NAN; + switch (class) { + case MAG_CLASS_PSF: + if (isnan (measure[0].dFluxPSF)) { + float Finst = MagToFlux(measure[0].M + Moff); + dFinst = measure[0].dM * Finst; + } else { + dFinst = measure[0].dFluxPSF; + } + break; + case MAG_CLASS_KRON: + if (isnan (measure[0].dFluxKron)) { + float Finst = MagToFlux(measure[0].Mkron + Moff); + dFinst = measure[0].dMkron * Finst; + } else { + dFinst = measure[0].dFluxKron; + } + break; + case MAG_CLASS_APER: + if (isnan (measure[0].dFluxAp)) { + float Finst = MagToFlux(measure[0].Map + Moff); + dFinst = measure[0].dMap * Finst; + } else { + dFinst = measure[0].dFluxAp; + } + break; + default: + break; + } + return (dFinst); +} + +float PhotFluxCatErr (Measure *measure, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; if (Np == -1) return (NAN); - - if (photcodes[0].code[Np].type == PHOT_REF) { - Mrel = thisone[0].M; - return (Mrel); - } - if (code[0].code != photcodes[0].code[Np].equiv) return (NAN); - - Mcal = PhotRelTiny (thisone, average, secfilt) + SCALE*code[0].C; - - mc = PhotColorForCodeTiny (average, secfilt, measure, code); - if (isnan(mc)) return (Mcal); - mc = mc - SCALE*code[0].dX; - - Mc = mc; - Mcol = 0; + PhotCode *code = &photcodes[0].code[Np]; + + // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux + float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; + float Moff = Mcal - ZERO_POINT + 8.9; + float Foff = 3630.8 * MagToFlux(Mcal); + + // use dFlux if we can, but use dMag if we must: + // dFlux = Flux * dMag + + float dFcat = NAN; + switch (class) { + case MAG_CLASS_PSF: + if (isnan (measure[0].dFluxPSF)) { + float Finst = MagToFlux(measure[0].M + Moff); + dFcat = measure[0].dM * Finst; + } else { + dFcat = measure[0].dFluxPSF * Foff; + } + break; + case MAG_CLASS_KRON: + if (isnan (measure[0].dFluxKron)) { + float Finst = MagToFlux(measure[0].Mkron + Moff); + dFcat = measure[0].dMkron * Finst; + } else { + dFcat = measure[0].dFluxKron * Foff; + } + break; + case MAG_CLASS_APER: + if (isnan (measure[0].dFluxAp)) { + float Finst = MagToFlux(measure[0].Map + Moff); + dFcat = measure[0].dMap * Finst; + } else { + dFcat = measure[0].dFluxAp * Foff; + } + break; + default: + break; + } + return (dFcat); +} + +/******** alternate photometry conversion functions using MeasureTiny and AverageTiny *********/ +float PhotInstTiny (MeasureTiny *measure, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; + if (Np == -1) return (NAN); + PhotCode *code = &photcodes[0].code[Np]; + + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = measure[0].M; + break; + case MAG_CLASS_KRON: + // Mraw = measure[0].Mkron; + break; + case MAG_CLASS_APER: + // Mraw = measure[0].Map; + break; + default: + break; + } + if (code->type == PHOT_REF) { + return (Mraw); + } + float Minst = Mraw - measure[0].dt - ZERO_POINT; + + return (Minst); +} + +float PhotCatTiny (MeasureTiny *measure, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; + if (Np == -1) return (NAN); + PhotCode *code = &photcodes[0].code[Np]; + + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = measure[0].M; + break; + case MAG_CLASS_KRON: + // Mraw = measure[0].Mkron; + break; + case MAG_CLASS_APER: + // Mraw = measure[0].Map; + break; + default: + break; + } + if (code->type == PHOT_REF) { + return (Mraw); + } + + float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; + + return (Mcat); +} + +float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; + if (Np == -1) return (NAN); + PhotCode *code = &photcodes[0].code[Np]; + + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = measure[0].M; + break; + case MAG_CLASS_KRON: + // Mraw = measure[0].Mkron; + break; + case MAG_CLASS_APER: + // Mraw = measure[0].Map; + break; + default: + break; + } + if (code->type == PHOT_REF) { + return (Mraw); + } + float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C; + + /* for DEP, color must be made of PRI/SEC */ + float mc = PhotColorForCodeTiny (average, secfilt, NULL, code); + if (isnan(mc)) return (Mcat); + mc -= SCALE*code[0].dX; + + int i = 0; + double Mc = mc; + float Mcol = 0; for (i = 0; i < code[0].Nc; i++) { Mcol += code[0].X[i]*Mc; Mc *= mc; } + float Msys = Mcat + Mcol; + return (Msys); +} + +float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class) { + + int Np = photcodes[0].hashcode[measure[0].photcode]; + if (Np == -1) return (NAN); + PhotCode *code = &photcodes[0].code[Np]; + + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = measure[0].M; + break; + case MAG_CLASS_KRON: + // Mraw = measure[0].Mkron; + break; + case MAG_CLASS_APER: + // Mraw = measure[0].Map; + break; + default: + break; + } + if (code->type == PHOT_REF) { + return (Mraw); + } + float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal; + + /* for DEP, color must be made of PRI/SEC */ + float mc = PhotColorForCodeTiny (average, secfilt, NULL, code); + if (isnan(mc)) return (Mcat); + mc -= SCALE*code[0].dX; + + double Mc = mc; + float Mcol = 0; + int i = 0; + for (i = 0; i < code[0].Nc; i++) { + Mcol += code[0].X[i]*Mc; + Mc *= mc; + } + float Mrel = Mcat + Mcol; + return (Mrel); +} + +/* return calibrated magnitude from measure for given photcode */ +float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code, dvoMagClassType class) { + + int i; + + if (code == NULL) return NAN; + + /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */ + int Np = photcodes[0].hashcode[thisone[0].photcode]; + if (Np == -1) return (NAN); + PhotCode *myCode = &photcodes[0].code[Np]; + + if (code->code != myCode->equiv) return (NAN); + + // if we are REF type, just get the right version and return + if (myCode->type == PHOT_REF) { + float Mraw = NAN; + switch (class) { + case MAG_CLASS_PSF: + Mraw = thisone[0].M; + break; + case MAG_CLASS_KRON: + // Mraw = thisone[0].Mkron; + break; + case MAG_CLASS_APER: + // Mraw = thisone[0].Map; + break; + default: + break; + } + return (Mraw); + } + + float Mcal = PhotRelTiny (thisone, average, secfilt, class) + SCALE*code[0].C; + + float mc = PhotColorForCodeTiny (average, secfilt, measure, code); + if (isnan(mc)) return (Mcal); + mc -= SCALE*code[0].dX; + + double Mc = mc; + float Mcol = 0; + for (i = 0; i < code[0].Nc; i++) { + Mcol += code[0].X[i]*Mc; + Mc *= mc; + } Mcal += Mcol; return (Mcal); +} + +/***/ +float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) { + + if (code == NULL) return NAN; + + int Ns = photcodes[0].hashNsec[code[0].code]; + if (Ns == -1) return (NAN); + + float Mave = NAN; + switch (source) { + case MAG_SRC_CHP: + switch (class) { + case MAG_CLASS_PSF: + Mave = secfilt[Ns].M; + break; + case MAG_CLASS_KRON: + Mave = secfilt[Ns].Mkron; + break; + case MAG_CLASS_APER: + Mave = secfilt[Ns].Map; + break; + default: + break; + } + break; + case MAG_SRC_WRP: + switch (class) { + case MAG_CLASS_PSF: + Mave = secfilt[Ns].MpsfWrp; + break; + case MAG_CLASS_KRON: + Mave = secfilt[Ns].MkronWrp; + break; + case MAG_CLASS_APER: + Mave = secfilt[Ns].MapWrp; + break; + default: + break; + } + break; + case MAG_SRC_STK: + switch (class) { + case MAG_CLASS_PSF: + Mave = secfilt[Ns].MpsfStk; + break; + case MAG_CLASS_KRON: + Mave = secfilt[Ns].MkronStk; + break; + case MAG_CLASS_APER: + Mave = secfilt[Ns].MapStk; + break; + default: + break; + } + break; + default: + break; + } + return (Mave); +} + +/* return calibrated magnitude from average/secfilt for given photcode */ +float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, dvoMagClassType class, dvoMagSourceType source) { + + int i; + + float Mave = PhotAveTiny (code, average, secfilt, class, source); + if (isnan(Mave)) return NAN; + + // correct for relative zero-point + float Mref = Mave + SCALE*code[0].C; + + float mc = PhotColorForCodeTiny (average, secfilt, measure, code); + if (isnan(mc)) return (Mref); + mc -= SCALE*code[0].dX; + + // correct for color terms + double Mc = mc; + float Mcol = 0; + for (i = 0; i < code[0].Nc; i++) { + Mcol += code[0].X[i]*Mc; + Mc *= mc; /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */ + } + Mref += Mcol; + return (Mref); } @@ -947,44 +1551,4 @@ } -/* return calibrated magnitude from average/secfilt for given photcode */ -float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure) { - - int i, Ns; - float Mave, Mref, Mcol, mc; - double Mc; - - if (code == NULL) return NAN; - - Ns = photcodes[0].hashNsec[code[0].code]; - Mave = (Ns == -1) ? NAN : secfilt[Ns].M; - Mref = Mave + SCALE*code[0].C; - - mc = PhotColorForCodeTiny (average, secfilt, measure, code); - if (isnan(mc)) return (Mref); - mc = mc - SCALE*code[0].dX; - - Mc = mc; - Mcol = 0; - for (i = 0; i < code[0].Nc; i++) { - Mcol += code[0].X[i]*Mc; - Mc *= mc; /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */ - } - Mref += Mcol; - return (Mref); -} - -/***/ -float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) { - - int Ns; - float Mave; - - if (code == NULL) return NAN; - - Ns = photcodes[0].hashNsec[code[0].code]; - Mave = (Ns == -1) ? NAN : secfilt[Ns].M; - return (Mave); -} - float PhotdMTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) { @@ -999,9 +1563,8 @@ } -// XXX return NAN or NAN_S_SHORT? (secfilt->Xm is short) +// Xm is now (2014.07.03) stored as the chisq except in dvo formats which use as short float PhotXmTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) { int Ns; - short Mi; float Xm; @@ -1009,6 +1572,5 @@ Ns = photcodes[0].hashNsec[code[0].code]; - Mi = (Ns == -1) ? NAN : secfilt[Ns].Xm; - Xm = (isnan(Mi)) ? -1.0 : pow (10.0, 0.01*Mi); + Xm = (Ns == -1) ? NAN : secfilt[Ns].Mchisq; return (Xm); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_tiny_values.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_tiny_values.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_tiny_values.c (revision 37067) @@ -8,10 +8,12 @@ averageT[0].measureOffset = average[0].measureOffset; averageT[0].catID = average[0].catID; + averageT[0].objID = average[0].objID; + averageT[0].nOwn = -1; return; } void CopyMeasureToTiny (MeasureTiny *measureT, Measure *measure) { - measureT[0].dR = measure[0].dR; - measureT[0].dD = measure[0].dD; + measureT[0].R = measure[0].R; + measureT[0].D = measure[0].D; measureT[0].M = measure[0].M; measureT[0].Mcal = measure[0].Mcal; @@ -33,4 +35,5 @@ measureT[0].dYccd = measure[0].dYccd; measureT[0].dRsys = measure[0].dRsys; + measureT[0].myDet = 0; return ; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvosorts.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvosorts.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvosorts.c (revision 37067) @@ -60,4 +60,19 @@ /* sort a coordinate pair (X,Y) and the associated index (S) */ +void sort_IDs_indexonly (opihi_int *X, off_t *S, off_t N) { + +# define SWAPFUNC(A,B){ off_t itmp; \ + itmp = S[A]; S[A] = S[B]; S[B] = itmp; \ +} +# define COMPARE(A,B)(X[S[A]] < X[S[B]]) + + OHANA_SORT (N, COMPARE, SWAPFUNC); + +# undef SWAPFUNC +# undef COMPARE + +} + +/* sort a coordinate pair (X,Y) and the associated index (S) */ void sort_coords_indexonly (double *X, double *Y, off_t *S, off_t N) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/skyregion_io.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/skyregion_io.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/skyregion_io.c (revision 37067) @@ -78,4 +78,5 @@ gfits_free_matrix (&matrix); gfits_free_header (&theader); + fclose (f); return (skytable); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/include/gfitsio.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/include/gfitsio.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/include/gfitsio.h (revision 37067) @@ -27,6 +27,8 @@ # define FT_RECORD_SIZE 2880 /* FITS block size */ +# define FT_BZERO_INT8 -1.0*0x80 # define FT_BZERO_INT16 1.0*0x8000 # define FT_BZERO_INT32 1.0*0x80000000 +# define FT_BZERO_INT64 1.0*0x8000000000000000 /* this structure defines the buffer which contains a header Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/matrix/F_compress_M.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/matrix/F_compress_M.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/matrix/F_compress_M.c (revision 37067) @@ -58,4 +58,5 @@ // is ZIMAGE present? + // NOTE target of %t must be int length status = gfits_scan_alt (ftable->header, "ZIMAGE", "%t", 1, &zimage); if (!status || !zimage) ESCAPE; @@ -125,4 +126,5 @@ int have_ztension; + // NOTE target of %t must be int length have_zsimple = gfits_scan_alt (header, "ZSIMPLE", "%t", 1, &zsimple); have_ztension = gfits_scan (header, "ZTENSION", "%s", 1, exttype); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_get_column.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_get_column.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_get_column.c (revision 37067) @@ -79,4 +79,9 @@ } } + if (!strcmp (type, "byte")) { + for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { + *(char *)Pout = *(char *)Pin*Bscale + Bzero; + } + } if (!strcmp (type, "short")) { for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { @@ -174,118 +179,13 @@ int gfits_get_bintable_column (Header *header, FTable *table, char *label, void **data) { - off_t Nx, Ny; - int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb; - char tlabel[80], field[80], format[80], type[16], tmpline[16]; - char *Pin, *Pout, *array; - double Bscale, Bzero; - - if (label == (char *) NULL) return (FALSE); - if (label[0] == 0) return (FALSE); - - /* find label in header */ - tlabel[0] = 0; - gfits_scan (header, "TFIELDS", "%d", 1, &Nfields); - for (i = 1; strcasecmp (label, tlabel) && (i < Nfields + 1); i++) { - sprintf (field, "TTYPE%d", i); - gfits_scan (header, field, "%s", 1, tlabel); - } - if (strcasecmp (label, tlabel)) return (FALSE); - N = i - 1; - - Bscale = 1; - Bzero = 0; - - /* interpret format */ - sprintf (field, "TSCAL%d", N); - gfits_scan (header, field, "%lf", 1, &Bscale); - sprintf (field, "TZERO%d", N); - gfits_scan (header, field, "%lf", 1, &Bzero); - sprintf (field, "TFORM%d", N); - gfits_scan (header, field, "%s", 1, format); - - if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE); - - /* check existing table dimensions */ - gfits_scan (header, "NAXIS1", OFF_T_FMT, 1, &Nx); - gfits_scan (header, "NAXIS2", OFF_T_FMT, 1, &Ny); - - /* scan columns to find insert point */ - Nstart = 0; - for (i = 1; i < N; i++) { - sprintf (field, "TFORM%d", i); - gfits_scan (header, field, "%s", 1, format); - gfits_bintable_format (format, tmpline, &Nv, &Nb); - Nstart += Nv*Nb; - } - - /* extract bytes from table into temporary array */ - ALLOCATE (array, char, Nbytes*Nval*Ny); - Pin = table[0].buffer + Nstart; - Pout = array; - for (i = 0; i < Ny; i++, Pin += Nx, Pout += Nval*Nbytes) { - memcpy (Pout, Pin, Nval*Nbytes); - } - - /* convert data in-situ with correct type, byte swap and Bzero/Bscale */ - Pin = array; - Pout = array; - if (!strcmp (type, "char")) { - for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { - *(char *)Pout = *(char *)Pin*Bscale + Bzero; - } - } - if (!strcmp (type, "short")) { - for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { -# ifdef BYTE_SWAP - SWAP_BYTE; -# endif - *(short *)Pout = *(short *)Pin*Bscale + Bzero; - } - } - if (!strcmp (type, "int")) { - for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { -# ifdef BYTE_SWAP - SWAP_WORD; -# endif - *(int *)Pout = *(int *)Pin*Bscale + Bzero; - } - } - if (!strcmp (type, "int64_t")) { - // XXX 64 bit int operations with Bzero & Bscale are inaccurate even with doubles - if ((Bzero == 0.0) && (Bscale == 1.0)) { - for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { -# ifdef BYTE_SWAP - SWAP_DBLE; -# endif - *(int64_t *)Pout = *(int64_t *)Pin; - } - } else { - for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { -# ifdef BYTE_SWAP - SWAP_DBLE; -# endif - *(int64_t *)Pout = *(int64_t *)Pin*Bscale + Bzero; - } - } - } - if (!strcmp (type, "float")) { - for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { -# ifdef BYTE_SWAP - SWAP_WORD; -# endif - *(float *)Pout = *(float *)Pin*Bscale + Bzero; - } - } - if (!strcmp (type, "double")) { - for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) { -# ifdef BYTE_SWAP - SWAP_DBLE; -# endif - *(double *)Pout = *(double *)Pin*Bscale + Bzero; - } - } + char type[16]; + off_t Nrow; + int Ncol; + + char *array = gfits_get_bintable_column_data (header, table, label, type, &Nrow, &Ncol); + if (array == NULL) return (FALSE); *data = array; - return (TRUE); + return TRUE; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_set_column.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_set_column.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_set_column.c (revision 37067) @@ -81,5 +81,11 @@ Pin = data; Pout = array; + // does it makes sense to scale 'char' data? if (!strcmp (type, "char")) { + for (i = 0; i < Nval*Nrow; i++, Pin+=Nbytes, Pout+=Nbytes) { + *(char *)Pout = (*(char *)Pin - Bzero) / Bscale; + } + } + if (!strcmp (type, "byte")) { for (i = 0; i < Nval*Nrow; i++, Pin+=Nbytes, Pout+=Nbytes) { *(char *)Pout = (*(char *)Pin - Bzero) / Bscale; @@ -221,4 +227,7 @@ Pout = array; + // # define ASSIGN_DATA(ITYPE,INAME,ISIZE,OTYPE,ONAME) + // if (!strcmp (intype, #ITYPE)) { + /** input == char **/ if (!strcmp (outtype, "char") && !strcmp (intype, "char")) { @@ -228,4 +237,10 @@ } } + if (!strcmp (outtype, "byte") && !strcmp (intype, "char")) { + int NbytesIn = 1; + for (i = 0; i < Nval*Nrow; i++, Pin+=NbytesIn, Pout+=NbytesOut) { + *(char *)Pout = (*(char *)Pin - Bzero) / Bscale; + } + } if (!strcmp (outtype, "short") && !strcmp (intype, "char")) { int NbytesIn = 1; @@ -265,4 +280,63 @@ } if (!strcmp (outtype, "double") && !strcmp (intype, "char")) { + int NbytesIn = 1; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(double *)Pout = (*(char *)Pin - Bzero) / Bscale; +# ifdef BYTE_SWAP + SWAP_DBLE; +# endif + } + } + + /** input == byte **/ + if (!strcmp (outtype, "char") && !strcmp (intype, "byte")) { + int NbytesIn = 1; + for (i = 0; i < Nval*Nrow; i++, Pin+=NbytesIn, Pout+=NbytesOut) { + *(char *)Pout = (*(char *)Pin - Bzero) / Bscale; + } + } + if (!strcmp (outtype, "byte") && !strcmp (intype, "byte")) { + int NbytesIn = 1; + for (i = 0; i < Nval*Nrow; i++, Pin+=NbytesIn, Pout+=NbytesOut) { + *(char *)Pout = (*(char *)Pin - Bzero) / Bscale; + } + } + if (!strcmp (outtype, "short") && !strcmp (intype, "byte")) { + int NbytesIn = 1; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(short *)Pout = (*(char *)Pin - Bzero) / Bscale; +# ifdef BYTE_SWAP + SWAP_BYTE; +# endif + } + } + if (!strcmp (outtype, "int") && !strcmp (intype, "byte")) { + int NbytesIn = 1; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(int *)Pout = (*(char *)Pin - Bzero) / Bscale; +# ifdef BYTE_SWAP + SWAP_WORD; +# endif + } + } + if (!strcmp (outtype, "int64_t") && !strcmp (intype, "byte")) { + int NbytesIn = 1; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(int64_t *)Pout = (*(char *)Pin - Bzero) / Bscale; +# ifdef BYTE_SWAP + SWAP_DBLE; +# endif + } + } + if (!strcmp (outtype, "float") && !strcmp (intype, "byte")) { + int NbytesIn = 1; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(float *)Pout = (*(char *)Pin - Bzero) / Bscale; +# ifdef BYTE_SWAP + SWAP_WORD; +# endif + } + } + if (!strcmp (outtype, "double") && !strcmp (intype, "byte")) { int NbytesIn = 1; for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { @@ -281,4 +355,10 @@ } } + if (!strcmp (outtype, "byte") && !strcmp (intype, "short")) { + int NbytesIn = 2; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(char *)Pout = (*(short *)Pin - Bzero) / Bscale; + } + } if (!strcmp (outtype, "short") && !strcmp (intype, "short")) { int NbytesIn = 2; @@ -334,4 +414,10 @@ } } + if (!strcmp (outtype, "byte") && !strcmp (intype, "int")) { + int NbytesIn = 4; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(char *)Pout = (*(int *)Pin - Bzero) / Bscale; + } + } if (!strcmp (outtype, "short") && !strcmp (intype, "int")) { int NbytesIn = 4; @@ -387,4 +473,10 @@ } } + if (!strcmp (outtype, "byte") && !strcmp (intype, "int64_t")) { + int NbytesIn = 8; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(char *)Pout = (*(int64_t *)Pin - Bzero) / Bscale; + } + } if (!strcmp (outtype, "short") && !strcmp (intype, "int64_t")) { int NbytesIn = 8; @@ -440,4 +532,10 @@ } } + if (!strcmp (outtype, "byte") && !strcmp (intype, "float")) { + int NbytesIn = 4; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(char *)Pout = (*(float *)Pin - Bzero) / Bscale; + } + } if (!strcmp (outtype, "short") && !strcmp (intype, "float")) { int NbytesIn = 4; @@ -488,4 +586,10 @@ /** input == double **/ if (!strcmp (outtype, "char") && !strcmp (intype, "double")) { + int NbytesIn = 8; + for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { + *(char *)Pout = (*(double *)Pin - Bzero) / Bscale; + } + } + if (!strcmp (outtype, "byte") && !strcmp (intype, "double")) { int NbytesIn = 8; for (i = 0; i < Nval*Nrow; i++, Pin += NbytesIn, Pout += NbytesOut) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_table_format.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_table_format.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_table_format.c (revision 37067) @@ -19,11 +19,14 @@ if ((Nv == 0) && (Fchar == format)) Nv = 1; + // NOTE: X, L, B all are stored in 1-byte columns (X by default has at least room for 8 bits) + // I report these as type 'byte' as opposed to 'char', which is interpreted as a string + *Nbytes = 0; switch (*Fchar) { case 'X': - { *Nbytes = 1; strcpy (type, "char"); *Nval = 1 + (int) Nv / 8; } + { *Nbytes = 1; strcpy (type, "byte"); *Nval = 1 + (int) Nv / 8; } break; case 'L': - { *Nbytes = 1; strcpy (type, "char"); *Nval = Nv; } + { *Nbytes = 1; strcpy (type, "byte"); *Nval = Nv; } break; case 'A': @@ -31,5 +34,5 @@ break; case 'B': - { *Nbytes = 1; strcpy (type, "char"); *Nval = Nv; } + { *Nbytes = 1; strcpy (type, "byte"); *Nval = Nv; } break; case 'I': @@ -268,5 +271,14 @@ } + // Does it make sense to scale 'char' data (as opposed to 'byte')? if (!strcmp (type, "char")) { + for (j = 0; j < Ny; j++) { + for (n = 0; n < Nval; n++) { + tmpChar = (char *)&ftable[0].buffer[j*Nx + n*Nbytes + off]; + *tmpChar = *tmpChar * tscale + tzero; + } + } + } + if (!strcmp (type, "byte")) { for (j = 0; j < Ny; j++) { for (n = 0; n < Nval; n++) { @@ -352,4 +364,5 @@ } + // does this make sense? (see note above) if (!strcmp (type, "char")) { for (j = 0; j < Ny; j++) { @@ -360,4 +373,12 @@ } } + if (!strcmp (type, "byte")) { + for (j = 0; j < Ny; j++) { + for (n = 0; n < Nval; n++) { + tmpChar = (char *)&ftable[0].buffer[j*Nx + n*Nbytes + off]; + *tmpChar = (*tmpChar - tzero) / tscale; + } + } + } if (!strcmp (type, "short")) { for (j = 0; j < Ny; j++) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/IOfuncs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/IOfuncs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/IOfuncs.c (revision 37067) @@ -54,5 +54,8 @@ va_end (argp); - if (!Nbyte) return (FALSE); + if (!Nbyte) { + KiiSendCommand (device, 16, "LEN: %11d", 0); + return (FALSE); + } /* the message may contain up to 99,999,999,999 bytes (100MB) */ @@ -84,6 +87,11 @@ /* find the message length, allocate space */ sscanf (buffer, "%*s %d", &Nbytes); + if (Nbytes == 0) { + return TRUE; + } + ALLOCATE (message, char, Nbytes + 1); memset (message, 0, Nbytes + 1); + /* read Nbytes from the device */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KapaOpen.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KapaOpen.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KapaOpen.c (revision 37067) @@ -1,3 +1,6 @@ # include "kapa_internal.h" + +// kapa connection timeout is N_RETRY * 10000 usec +# define N_RETRY 2000 # define MY_PORT 2500 @@ -9,5 +12,4 @@ static int *VALID = NULL; -char *_parse_nextword (char *string); int KapaLaunchCommand (char *line); @@ -218,15 +220,33 @@ // apparently, I can connect on someone else's port (eg GoogleTalkPlugin) // do a simple handshake before we set !NONBLOCK: - char line[5]; - int Nout = read (InitSocket, line, 4); - if (Nout != 4) { - if (DEBUG) fprintf (stderr, "connection failed\n"); - close (InitSocket); - return (-1); - } - if (strncmp (line, "KAPA", 4)) { - if (DEBUG) fprintf (stderr, "connection to the wrong server\n"); - close (InitSocket); - return (-1); + + // ensure the socket is NONBLOCK first... + fcntl (InitSocket, F_SETFL, O_NONBLOCK); + + int Ntry = 0; +retry_message: + { + char line[5]; + int Nout = read (InitSocket, line, 4); + if ((Nout == -1) && (errno == EAGAIN)) { + Ntry ++; + if (Ntry > 500) { + if (DEBUG) fprintf (stderr, "handshake failure\n"); + close (InitSocket); + return (-1); + } + usleep (10000); + goto retry_message; + } + if (Nout != 4) { + if (DEBUG) fprintf (stderr, "connection failed\n"); + close (InitSocket); + return (-1); + } + if (strncmp (line, "KAPA", 4)) { + if (DEBUG) fprintf (stderr, "connection to the wrong server\n"); + close (InitSocket); + return (-1); + } } @@ -265,11 +285,14 @@ } -# define NTRY 500 + INITTIME; + Ntry = 0; - while (Ntry < NTRY) { + while (Ntry < N_RETRY) { sock = KapaClientSocket ("localhost"); if (sock != -1) break; - // if (errno != EAGAIN) break; - if (errno != ECONNREFUSED) break; + if (errno != ECONNREFUSED) { + perror ("KapaOpen"); + break; + } // no connection yet. try again, but first check // if the kapa job has exited @@ -288,5 +311,23 @@ } - if (sock < 0) return (-1); + if (sock < 0) { + MARKTIME ("failed to connect to kapa after %f seconds\n", dtime); + int killStatus = kill (pid, SIGKILL); + if (killStatus) { + perror ("failed to kill process"); + } + int waitStatus = waitpid (pid, NULL, 0); + if (waitStatus == pid) { + fprintf (stderr, "harvested process %d\n", pid); + } else if (waitStatus < 0) { + fprintf (stderr, "failed to harvest process %d\n", pid); + } else if (waitStatus == 0) { + fprintf (stderr, "process not exited: %d\n", pid); + } else { + fprintf (stderr, "odd exit status: %d vs pid %d\n", waitStatus, pid); + } + return (-1); + } + return (sock); } @@ -330,7 +371,8 @@ fcntl (InitSocket, F_SETFL, O_NONBLOCK); -# define NTRY 500 + INITTIME; + Ntry = 0; - while (Ntry < NTRY) { + while (Ntry < N_RETRY) { fd = accept (InitSocket, (struct sockaddr *)&Address, &AddressLength); if (fd != -1) break; @@ -352,5 +394,10 @@ } - if (fd < 0) return (-1); + if (fd < 0) { + MARKTIME ("failed to connect to kapa after %f seconds\n", dtime); + kill (pid, SIGKILL); + waitpid (pid, NULL, WNOHANG); + return (-1); + } // the client uses a BLOCKing socket by default @@ -394,5 +441,5 @@ done = FALSE; while (!done) { - q = _parse_nextword (p); + q = parse_nextword (p); if (q && *q) { argv[i] = strncreate (p, q - p); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KapaWindow.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KapaWindow.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KapaWindow.c (revision 37067) @@ -100,5 +100,5 @@ graphdata[0].coords.pc1_1 = graphdata[0].coords.pc2_2 = 1.0; graphdata[0].coords.pc1_2 = graphdata[0].coords.pc2_1 = 0.0; - strcpy (graphdata[0].coords.ctype, "RA---LIN"); + strcpy (graphdata[0].coords.ctype, "DEC--LIN"); graphdata[0].coords.crval1 = 0.0; graphdata[0].coords.crval2 = 0.0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KiiPicture.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KiiPicture.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KiiPicture.c (revision 37067) @@ -21,5 +21,6 @@ int KiiNewPicture1D (int fd, KiiImage *image, KapaImageData *data, Coords *coords) { - int Nwrite, Npix, Ncolors, size; + int Ncolors; + off_t Nwrite, Npix, size; float min, max; @@ -36,5 +37,5 @@ KiiSendMessage (fd, "%8d %8d", image[0].Nx, image[0].Ny); KiiSendMessage (fd, "%f %f %s %s", data[0].zero, data[0].range, data[0].name, data[0].file); - KiiSendMessage (fd, "%f %f %d ", min, max, size); + KiiSendMessage (fd, "%f %f "OFF_T_FMT" ", min, max, size); KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval1, coords[0].crpix1, coords[0].cdelt1, coords[0].pc1_1, coords[0].pc1_2); KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval2, coords[0].crpix2, coords[0].cdelt2, coords[0].pc2_1, coords[0].pc2_2); @@ -42,8 +43,18 @@ /* send the image data */ - Nwrite = write (fd, image[0].data1d, size); - if (Nwrite != size) { - fprintf (stderr, "error sending picture to kapa\n"); - return (FALSE); + off_t bytes_left = size; + while (bytes_left > 0) { + Nwrite = write (fd, image[0].data1d, bytes_left); + if (Nwrite == 0) { + fprintf (stderr, "unable to send more data to kapa?\n"); + return FALSE; + } + if (Nwrite < 0) { + if (errno == EAGAIN) continue; + if (errno == EWOULDBLOCK) continue; + perror ("KiiNewPicture1D:"); + return FALSE; + } + bytes_left -= Nwrite; } @@ -114,6 +125,6 @@ int KiiNewPicture2D (int fd, KiiImage *image, KapaImageData *data, Coords *coords) { - int j; - int Nwrite, Nbytes, Npix, Ncolors, size; + int Ncolors; + off_t j, Nwrite, Nbytes, Npix, size; float min, max; @@ -130,5 +141,5 @@ KiiSendMessage (fd, "%8d %8d", image[0].Nx, image[0].Ny); KiiSendMessage (fd, "%f %f %s %s", data[0].zero, data[0].range, data[0].name, data[0].file); - KiiSendMessage (fd, "%f %f %d ", min, max, size); + KiiSendMessage (fd, "%f %f "OFF_T_FMT" ", min, max, size); KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval1, coords[0].crpix1, coords[0].cdelt1, coords[0].pc1_1, coords[0].pc1_2); KiiSendMessage (fd, "%f %f %g %g %g ", coords[0].crval2, coords[0].crpix2, coords[0].cdelt2, coords[0].pc2_1, coords[0].pc2_2); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/bDrawFuncs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/bDrawFuncs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/bDrawFuncs.c (revision 37067) @@ -247,5 +247,10 @@ int i; + if (Y < 0) return; + if (Y >= buffer[0].Ny) return; + for (i = X1; i < X2; i++) { + if (i < 0) continue; + if (i >= buffer[0].Nx) continue; if (buffer[0].Nbyte == 1) { buffer[0].pixels[Y][i] = buffer->bColor; @@ -263,5 +268,10 @@ int i; + if (X < 0) return; + if (X >= buffer[0].Nx) return; + for (i = Y1; i < Y2; i++) { + if (i < 0) continue; + if (i >= buffer[0].Ny) continue; if (buffer[0].Nbyte == 1) { buffer[0].pixels[i][X] = buffer->bColor; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/include/ohana.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/include/ohana.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/include/ohana.h (revision 37067) @@ -71,4 +71,13 @@ # endif +# define MARKTIME(MSG,...) { \ + gettimeofday (&stopTimer, (void *) NULL); \ + float dtime = DTIME (stopTimer, startTimer); \ + fprintf (stderr, MSG, __VA_ARGS__); } + +# define INITTIME \ + struct timeval startTimer, stopTimer; \ + gettimeofday (&startTimer, (void *) NULL); + #ifdef __GNUC__ #define OHANA_FORMAT(style, fmt, varargs) __attribute__((format(style, fmt, varargs))) @@ -252,8 +261,13 @@ int scan_line PROTO((FILE *f, char *line)); int scan_line_maxlen PROTO((FILE *f, char *line, int maxlen)); +char *parse_nextword PROTO((char *string)); +char *parse_nextword_csv PROTO((char *string)); int dparse PROTO((double *X, int NX, char *line)); int dparse_csv PROTO((double *X, int NX, char *line)); int iparse PROTO((int *X, int NX, char *line)); int iparse_csv PROTO((int *X, int NX, char *line)); +int charparse_csv PROTO((char *X, int NX, char *line)); +char *ptrparse PROTO((int NX, char *line)); +char *ptrparse_csv PROTO((int NX, char *line)); int charparse_csv PROTO((char *X, int NX, char *line)); int charparse PROTO((char *X, int NX, char *line)); @@ -266,4 +280,7 @@ char *strip_version PROTO((char *input)); char *strsubs PROTO((char *string, char *match, char *with)); + +char *getword PROTO((char *string)); +char *skipword PROTO((char *string)); /* in findexec.c */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/src/gaussj.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/src/gaussj.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/src/gaussj.c (revision 37067) @@ -1,5 +1,5 @@ # include # define GROWTHTEST 0 -# define MAX_RANGE 1.0e7 +# define MAX_RANGE 1.0e9 // Gauss-Jordan elimination using full pivots based on Press et al's description. Substantially @@ -91,4 +91,5 @@ /* rescale by pivot reciprocal */ double tmpval = 1.0 / A[maxcol][maxcol]; + // XXX why is this here (don't I double count this element?) A[maxcol][maxcol] = 1.0; A[maxcol][maxcol] = 1.0; for (col = 0; col < N; col++) A[maxcol][col] *= tmpval; @@ -117,4 +118,15 @@ } } + +# if (GROWTHTEST) + fprintf (stderr, "final A matrix:\n"); + for (row = 0; row < N; row++) { + for (col = 0; col < N; col++) { + fprintf (stderr, "%10.3e ", A[row][col]); + } + fprintf (stderr, "\n"); + } + fprintf (stderr, "\n"); +# endif // swap back the inverse matrix based on the row swaps above Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/src/string.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/src/string.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/src/string.c (revision 37067) @@ -167,5 +167,5 @@ } -char *_parse_nextword (char *string) { +char *parse_nextword (char *string) { if (string == (char *) NULL) return ((char *) NULL); @@ -182,5 +182,5 @@ // ,,, : go from , to , to , to 0 -char *_parse_nextword_csv (char *string) { +char *parse_nextword_csv (char *string) { if (string == (char *) NULL) return ((char *) NULL); @@ -199,5 +199,5 @@ word = line; for (i = 0; i < NX - 1; i++) - word = _parse_nextword (word); + word = parse_nextword (word); *X = strtod (word, &ptr); @@ -215,5 +215,5 @@ word = line; for (i = 0; i < NX - 1; i++) - word = _parse_nextword_csv (word); + word = parse_nextword_csv (word); if (word[0] == '"') word[0] = ' '; @@ -237,5 +237,5 @@ word = line; for (i = 0; i < NX - 1; i++) - word = _parse_nextword (word); + word = parse_nextword (word); *X = strtol (word, &ptr, 0); @@ -253,5 +253,5 @@ word = line; for (i = 0; i < NX - 1; i++) - word = _parse_nextword_csv (word); + word = parse_nextword_csv (word); if (word[0] == '"') word[0] = ' '; @@ -274,5 +274,5 @@ word = line; for (i = 0; i < NX - 1; i++) - word = _parse_nextword (word); + word = parse_nextword (word); *X = word[0]; @@ -287,5 +287,5 @@ word = line; for (i = 0; i < NX - 1; i++) - word = _parse_nextword_csv (word); + word = parse_nextword_csv (word); if (word[0] == '"') word[0] = word[1]; @@ -299,4 +299,31 @@ } +// return a pointer to the start of the desired field +char *ptrparse (int NX, char *line) { + + int i; + char *word; + + word = line; + for (i = 0; i < NX - 1; i++) { + word = parse_nextword (word); + } + return word; +} + +char *ptrparse_csv (int NX, char *line) { + + int i; + char *word; + + word = line; + for (i = 0; i < NX - 1; i++) + word = parse_nextword_csv (word); + + if (word[0] == '"') word ++; + if (word[0] == ',') return NULL; + return word; +} + int tparse (time_t *X, int NX, char *line) { @@ -306,5 +333,5 @@ word = line; for (i = 0; i < NX - 1; i++) - word = _parse_nextword (word); + word = parse_nextword (word); status = ohana_str_to_time (word, X); @@ -320,5 +347,5 @@ word = line; for (i = 0; i < NX - 1; i++) - word = _parse_nextword_csv (word); + word = parse_nextword_csv (word); if (word[0] == '"') word[0] = ' '; @@ -341,5 +368,5 @@ word = line; for (i = 0; i < NX - 1; i++) - word = _parse_nextword (word); + word = parse_nextword (word); *X = strtod (word, &ptr); @@ -402,2 +429,41 @@ return (q); } + +// return a newly allocated string containing the first complete set of non-whitespace +char *getword (char *string) { + + int i, j; + char *word; + + if (!string) return (NULL); + + // find the end of the whitespace (is there any non-whitespace?) + for (i = 0; OHANA_WHITESPACE (string[i]); i++); + if (!string[i]) return (NULL); + + for (j = i; string[j] && !OHANA_WHITESPACE(string[j]); j++); + word = strncreate (&string[i], j - i); + return (word); +} + +// returns a pointer to the next word, or NULL if there is not a next word +char *skipword (char *string) { + + int i; + + if (!string) return (NULL); + + // find the end of the whitespace (is there any non-whitespace?) + for (i = 0; OHANA_WHITESPACE (string[i]); i++); + if (!string[i]) return (NULL); + + // find the end of the non-whitespace (this word) + while (string[i] && !OHANA_WHITESPACE(string[i])) i++; + + // find the end of the following whitespace + while (string[i] && OHANA_WHITESPACE(string[i])) i++; + if (!string[i]) return (NULL); + + return (&string[i]); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/markrock/src/gcatstats.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/markrock/src/gcatstats.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/markrock/src/gcatstats.c (revision 37067) @@ -40,5 +40,5 @@ catstats[0].coords.pc1_1 = catstats[0].coords.pc2_2 = 1.0; catstats[0].coords.pc1_2 = catstats[0].coords.pc2_1 = 0.0; - strcpy (catstats[0].coords.ctype, "RA---TAN"); + strcpy (catstats[0].coords.ctype, "DEC--TAN"); X1 = catstats[0].X; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/markstar/src/gcatstats.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/markstar/src/gcatstats.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/markstar/src/gcatstats.c (revision 37067) @@ -50,5 +50,5 @@ catstats[0].coords.pc1_1 = catstats[0].coords.pc2_2 = 1.0; catstats[0].coords.pc1_2 = catstats[0].coords.pc2_1 = 0.0; - strcpy (catstats[0].coords.ctype, "RA---TAN"); + strcpy (catstats[0].coords.ctype, "DEC--TAN"); X1 = catstats[0].X; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/mosastro/src/warptest.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/mosastro/src/warptest.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/mosastro/src/warptest.c (revision 37067) @@ -15,5 +15,5 @@ /* bore site center guess */ - sprintf (coords.ctype, "RA---%s", argv[1]); + sprintf (coords.ctype, "DEC--%s", argv[1]); coords.crval1 = 0.0; coords.crval2 = 0.0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/Makefile (revision 37067) @@ -28,7 +28,9 @@ $(SRC)/cval.$(ARCH).o \ $(SRC)/czplot.$(ARCH).o \ +$(SRC)/cdensify.$(ARCH).o \ $(SRC)/drizzle.$(ARCH).o \ $(SRC)/flux.$(ARCH).o \ $(SRC)/fitplx.$(ARCH).o \ +$(SRC)/fitpm.$(ARCH).o \ $(SRC)/fixwrap.$(ARCH).o \ $(SRC)/fixcols.$(ARCH).o \ @@ -60,4 +62,5 @@ $(SRC)/scale.$(ARCH).o \ $(SRC)/sexigesimal.$(ARCH).o \ +$(SRC)/sersic.$(ARCH).o \ $(SRC)/spec.$(ARCH).o \ $(SRC)/specpairfit.$(ARCH).o \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/cdensify.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/cdensify.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/cdensify.c (revision 37067) @@ -0,0 +1,192 @@ +# include "data.h" + +# define CHECKVAL(ARG) if (!isfinite(ARG)) { gprint (GP_ERR, "illegal value for %s: %f\n", #ARG, ARG); return (FALSE); } +enum {IS_DOT, IS_SQUARE, IS_CIRCLE, IS_GAUSS}; + +int cdensify (int argc, char **argv) { + + int i, Nx, Ny, Xb, Yb, N, Xpix, Ypix; + double Xmin, Xmax, dX, Ymin, Ymax, dY, ix, iy; + float *val; + Buffer *bf; + Vector *vr, *vd; + opihi_flt *r, *d, x, y; + int kapa; + Graphdata graphmode; + + int Normalize = TRUE; + if ((N = get_argument (argc, argv, "-raw"))) { + remove_argument (N, &argc, argv); + Normalize = FALSE; + } + + if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE; + double Rmin = graphmode.coords.crval1 - 182.0; + double Rmax = graphmode.coords.crval1 + 182.0; + + float scale = 0.0; + if ((N = get_argument (argc, argv, "-scale"))) { + remove_argument (N, &argc, argv); + scale = atof(argv[N]); + remove_argument (N, &argc, argv); + } + + int PSFTYPE = IS_DOT; + if ((N = get_argument (argc, argv, "-psf"))) { + remove_argument (N, &argc, argv); + if (!strcasecmp(argv[N], "dot")) PSFTYPE = IS_DOT; + if (!strcasecmp(argv[N], "square")) PSFTYPE = IS_SQUARE; + if (!strcasecmp(argv[N], "circle")) PSFTYPE = IS_CIRCLE; + if (!strcasecmp(argv[N], "gauss")) PSFTYPE = IS_GAUSS; + remove_argument (N, &argc, argv); + } + + if (argc != 4) { + gprint (GP_ERR, "USAGE: cdensify buffer R D\n"); + gprint (GP_ERR, " option: -psf [dot] (circle) (square) (gauss)\n"); + return (FALSE); + } + + if ((bf = SelectBuffer (argv[1], ANYBUFFER, TRUE)) == NULL) return (FALSE); + if ((vr = SelectVector (argv[2], OLDVECTOR, TRUE)) == NULL) return (FALSE); + if ((vd = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return (FALSE); + + if (vr[0].Nelements != vd[0].Nelements) return (FALSE); + + REQUIRE_VECTOR_FLT (vr, FALSE); + REQUIRE_VECTOR_FLT (vd, FALSE); + + KapaGetImageRange (kapa, &Xmin, &Xmax, &Ymax, &Ymin, &Xpix, &Ypix); + Xmax = graphmode.xmax; + Xmin = graphmode.xmin; + Ymax = graphmode.ymax; + Ymin = graphmode.ymin; + dX = (Xmax - Xmin) / (Xpix - 1); + dY = (Ymax - Ymin) / (Ypix - 1); + + CHECKVAL(Xmin); + CHECKVAL(Xmax); + CHECKVAL(dX); + + CHECKVAL(Ymin); + CHECKVAL(Ymax); + CHECKVAL(dY); + + Nx = (Xmax - Xmin) / dX + 1; + Ny = (Ymax - Ymin) / dY + 1; + + Coords newcoords = graphmode.coords; + newcoords.cdelt1 *= dX; + newcoords.cdelt2 *= dY; + newcoords.crpix1 = (newcoords.crpix1 - Xmin) / dX; + newcoords.crpix2 = (newcoords.crpix2 - Ymin) / dY; + + gfits_free_matrix (&bf[0].matrix); + gfits_free_header (&bf[0].header); + CreateBuffer (bf, Nx, Ny, -32, 0.0, 1.0); + strcpy (bf[0].file, "(empty)"); + PutCoords (&newcoords, &bf[0].header); + + float scalescale = scale*scale; + float scale2 = (scale + 1.0) * (scale + 1.0); + float fSquare = 1.0 / scale2; + float fCircle = 1.0 / (3.141592 * scale2); + float fSigma = 0.5 / scale2; + float fGauss = 1.0 / (2.0 * 3.141592 * scale2); + + // generate the PSF in a local tangent plane + Coords coords; + coords.crpix1 = coords.crpix2 = 0.0; + coords.crval1 = coords.crval2 = 0.0; + coords.cdelt1 = coords.cdelt2 = 1.0; + coords.pc1_1 = coords.pc2_2 = 1.0; + coords.pc1_2 = coords.pc2_1 = 0.0; + coords.Npolyterms = 0; + strcpy (coords.ctype, "DEC--TAN"); + + r = vr[0].elements.Flt; + d = vd[0].elements.Flt; + val = (float *)bf[0].matrix.buffer; + for (i = 0; i < vr[0].Nelements; i++, r++, d++) { + double rn = ohana_normalize_angle (*r); + while (rn < Rmin) rn += 360.0; + while (rn > Rmax) rn -= 360.0; + coords.crval1 = rn; + coords.crval2 = *d; + + switch (PSFTYPE) { + case IS_DOT: + RD_to_XY (&x, &y, rn, *d, &graphmode.coords); + Xb = (x - Xmin) / dX; + Yb = (y - Ymin) / dY; + + RD_to_XY (&x, &y, rn, *d, &newcoords); + Xb = (int) x; + Yb = (int) y; + if (Xb >= Nx) continue; + if (Yb >= Ny) continue; + if (Xb < 0) continue; + if (Yb < 0) continue; + val[Xb + Yb*Nx] ++; + break; + case IS_SQUARE: + for (ix = -scale; ix <= scale; ix += dX) { + for (iy = -scale; iy <= scale; iy += dY) { + double rp, dp; + XY_to_RD (&rp, &dp, ix, iy, &coords); + while (rp < Rmin) rp += 360.0; + while (rp > Rmax) rp -= 360.0; + RD_to_XY (&x, &y, rp, dp, &graphmode.coords); + Xb = (x - Xmin) / dX; + Yb = (y - Ymin) / dY; + if (Xb >= Nx) continue; + if (Yb >= Ny) continue; + if (Xb < 0) continue; + if (Yb < 0) continue; + val[Xb + Yb*Nx] += Normalize ? fSquare : 1.0; + } + } + break; + case IS_CIRCLE: + for (ix = -scale; ix <= scale; ix += dX) { + for (iy = -scale; iy <= scale; iy += dY) { + float r2 = ix*ix + iy*iy; + double rp, dp; + if (r2 > scalescale) continue; + XY_to_RD (&rp, &dp, ix, iy, &coords); + while (rp < Rmin) rp += 360.0; + while (rp > Rmax) rp -= 360.0; + RD_to_XY (&x, &y, rp, dp, &graphmode.coords); + Xb = (x - Xmin) / dX; + Yb = (y - Ymin) / dY; + if (Xb >= Nx) continue; + if (Yb >= Ny) continue; + if (Xb < 0) continue; + if (Yb < 0) continue; + val[Xb + Yb*Nx] += Normalize ? fCircle : 1.0; + } + } + break; + case IS_GAUSS: + for (ix = -3.0*scale; ix <= 3.0*scale; ix += dX) { + for (iy = -3.0*scale; iy <= 3.0*scale; iy += dY) { + float r2 = ix*ix + iy*iy; + double rp, dp; + XY_to_RD (&rp, &dp, ix, iy, &coords); + while (rp < Rmin) rp += 360.0; + while (rp > Rmax) rp -= 360.0; + RD_to_XY (&x, &y, rp, dp, &graphmode.coords); + Xb = (x - Xmin) / dX; + Yb = (y - Ymin) / dY; + if (Xb >= Nx) continue; + if (Yb >= Ny) continue; + if (Xb < 0) continue; + if (Yb < 0) continue; + val[Xb + Yb*Nx] += fGauss*exp(-fSigma*r2); + } + } + break; + } + } + return (TRUE); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/fitplx.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/fitplx.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/fitplx.c (revision 37067) @@ -41,4 +41,8 @@ remove_argument (N, &argc, argv); VERBOSE = TRUE; + } + if ((N = get_argument (argc, argv, "-vv"))) { + remove_argument (N, &argc, argv); + VERBOSE = 2; } @@ -108,5 +112,5 @@ coords.pc1_2 = coords.pc2_1 = 0.0; coords.Npolyterms = 1; - strcpy (coords.ctype, "RA---SIN"); + strcpy (coords.ctype, "DEC--SIN"); double *X, *Y, *t, *pX, *pY, *dX, *dY; @@ -145,5 +149,7 @@ PlxFit fit; - FitPMandPar (&fit, X, dX, Y, dY, t, pX, pY, n, VERBOSE); + if (!FitPMandPar (&fit, X, dX, Y, dY, t, pX, pY, n, VERBOSE)) { + return FALSE; + } // fprintf (stderr, "Roff, Doff: %f, %f; dRo, dDo: %f, %f\n", fit.Ro, fit.Do, fit.dRo, fit.dDo); @@ -204,9 +210,9 @@ for (i = 0; i < Npts; i++) { - if (VERBOSE) fprintf (stderr, "%f %f : %f %f : %f : %f %f\n", X[i], dX[i], Y[i], dY[i], T[i], pR[i], pD[i]); + if (VERBOSE == 2) fprintf (stderr, "%f %f : %f %f : %f : %f %f\n", X[i], dX[i], Y[i], dY[i], T[i], pR[i], pD[i]); /* handle case where dX or dY = 0.0 */ - wx = 1.0 / SQ(dX[i]); - wy = 1.0 / SQ(dY[i]); + wx = (fabs(dX[i]) < 0.0001) ? 1.0 : 1.0 / SQ(dX[i]); + wy = (fabs(dY[i]) < 0.0001) ? 1.0 : 1.0 / SQ(dY[i]); Wx += wx; @@ -266,5 +272,17 @@ B[4][0] = PRX + PDY; - dgaussjordan ((double **)A, (double **)B, 5, 1); + if (!dgaussjordan ((double **)A, (double **)B, 5, 1)) { + if (VERBOSE) fprintf (stderr, "error in fit\n"); + if (VERBOSE == 2) { + int j; + for (i = 0; i < 5; i++) { + for (j = 0; j < 5; j++) { + fprintf (stderr, "%e ", A[i][j]); + } + fprintf (stderr, " : %e\n", A[i][0]); + } + } + return FALSE; + } fit[0].Ro = B[0][0]; @@ -285,7 +303,9 @@ Xf = fit[0].Ro + fit[0].uR*T[i] + fit[0].p*pR[i]; Yf = fit[0].Do + fit[0].uD*T[i] + fit[0].p*pD[i]; - chisq += SQ(X[i] - Xf) / SQ(dX[i]); - chisq += SQ(Y[i] - Yf) / SQ(dY[i]); - if (VERBOSE) fprintf (stderr, "chisq contrib : %f %f : %f %f : %f %f : %f %f : %f\n", Xf, Yf, X[i] - Xf, Y[i] - Yf, dX[i], dY[i], (X[i] - Xf) / dX[i], (Y[i] - Yf) / dY[i], chisq); + wx = (fabs(dX[i]) < 0.0001) ? 1.0 : 1.0 / SQ(dX[i]); + wy = (fabs(dY[i]) < 0.0001) ? 1.0 : 1.0 / SQ(dY[i]); + chisq += SQ(X[i] - Xf) * wx; + chisq += SQ(Y[i] - Yf) * wy; + // if (VERBOSE) fprintf (stderr, "chisq contrib : %f %f : %f %f : %f %f : %f %f : %f\n", Xf, Yf, X[i] - Xf, Y[i] - Yf, dX[i], dY[i], (X[i] - Xf) / dX[i], (Y[i] - Yf) / dY[i], chisq); } fit[0].Nfit = Npts; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/fitpm.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/fitpm.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/fitpm.c (revision 37067) @@ -0,0 +1,262 @@ +# include "astro.h" +# define J2000 51544.5 /* Modified Julian date at standard epoch J2000 */ + +# define ESCAPE(MSG,...) { \ + gprint (GP_ERR, MSG, __VA_ARGS__); \ + return FALSE; } + +typedef struct { + double Ro, dRo; + double Do, dDo; + + double uR, duR; + double uD, duD; + + double chisq; + int Nfit; +} PMFit; + +int FitPMonly (PMFit *fit, double *X, double *dX, double *Y, double *dY, double *T, int Npts, int VERBOSE); + +int fitpm (int argc, char **argv) { + + int i, N; + + Vector *rvec, *dvec, *tvec, *dRvec, *dDvec; + + Vector *mvec = NULL; // mask vector + if ((N = get_argument (argc, argv, "-mask"))) { + remove_argument (N, &argc, argv); + if ((mvec = SelectVector (argv[N], ANYVECTOR, TRUE)) == NULL) return (FALSE); + remove_argument (N, &argc, argv); + CastVector (mvec, OPIHI_INT); + } + + int VERBOSE = FALSE; + if ((N = get_argument (argc, argv, "-v"))) { + remove_argument (N, &argc, argv); + VERBOSE = TRUE; + } + if ((N = get_argument (argc, argv, "-vv"))) { + remove_argument (N, &argc, argv); + VERBOSE = 2; + } + + if (argc != 6) { + gprint (GP_ERR, "USAGE: fitplx (ra) (dR) (dec) (dD) (mjd) [-mask mask]\n"); + // what about the errors? + return (FALSE); + } + + /* select input / output buffers */ + // if ((buf = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE); + // Nx = buf[0].header.Naxis[0]; + // Ny = buf[0].header.Naxis[1]; + + if ((rvec = SelectVector (argv[1], ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", argv[1]); + if ((dvec = SelectVector (argv[3], ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", argv[3]); + if ((tvec = SelectVector (argv[5], ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", argv[5]); + + if ((dRvec = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", argv[2]); + if ((dDvec = SelectVector (argv[4], ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", argv[4]); + + double *R = rvec->elements.Flt; + double *D = dvec->elements.Flt; + double *T = tvec->elements.Flt; + + double *dR = dRvec->elements.Flt; + double *dD = dDvec->elements.Flt; + + int *mask = NULL; + if (mvec) { + mask = mvec->elements.Int; + } + + N = tvec->Nelements; // XXX check other lengths + + // find mean values to remove + double Npts = 0; + double Tmean = 0; + double Rmean = 0; + double Dmean = 0; + double Tmin = +1000000; + double Tmax = -1000000; + for (i = 0; i < N; i++) { + if (mask && !mask[i]) continue; + Rmean += R[i]; + Dmean += D[i]; + Tmean += T[i]; + Tmin = MIN(Tmin, T[i]); + Tmax = MAX(Tmax, T[i]); + Npts += 1.0; + } + Rmean /= Npts; + Dmean /= Npts; + Tmean /= Npts; + + float Trange = Tmax - Tmin; + // fprintf (stderr, "R,D : %f,%f, T: %f, Trange: %f, Tmin: %f, Tmax: %f\n", Rmean, Dmean, Tmean, Trange, Tmin, Tmax); + + /* project coordinates to a plane centered on the object with units of arcsec */ + Coords coords; + coords.crval1 = Rmean; + coords.crval2 = Dmean; + coords.crpix1 = 0; + coords.crpix2 = 0; + coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0; + coords.pc1_1 = coords.pc2_2 = 1.0; + coords.pc1_2 = coords.pc2_1 = 0.0; + coords.Npolyterms = 1; + strcpy (coords.ctype, "DEC--SIN"); + + double *X, *Y, *t, *dX, *dY; + ALLOCATE (X, double, N); + ALLOCATE (Y, double, N); + ALLOCATE (dX, double, N); + ALLOCATE (dY, double, N); + ALLOCATE (t, double, N); + + int n = 0; + for (i = 0; i < N; i++) { + if (mask && !mask[i]) continue; + RD_to_XY (&X[n], &Y[n], R[i], D[i], &coords); + dX[n] = dR[i]; + dY[n] = dD[i]; + t[n] = (T[i] - Tmean) / 365.25; + n++; + } + + PMFit fit; + if (!FitPMonly (&fit, X, dX, Y, dY, t, n, VERBOSE)) { + return FALSE; + } + + // fprintf (stderr, "Roff, Doff: %f, %f; dRo, dDo: %f, %f\n", fit.Ro, fit.Do, fit.dRo, fit.dDo); + + XY_to_RD (&Rmean, &Dmean, fit.Ro, fit.Do, &coords); + if (VERBOSE) { + fprintf (stderr, "Ro, Do: %f, %f +/- %f, %f\n", Rmean, Dmean, fit.dRo, fit.dDo); + fprintf (stderr, "uR, uD: %f, %f; duR, duD: %f, %f\n", fit.uR, fit.uD, fit.duR, fit.duD); + fprintf (stderr, "chisq: %f Nfit %d\n", fit.chisq, fit.Nfit); + } + + set_variable ("RA", Rmean); + set_variable ("DEC", Dmean); + set_variable ("dR", fit.dRo); + set_variable ("dD", fit.dDo); + set_variable ("uR", fit.uR); + set_variable ("uD", fit.uD); + set_variable ("duR", fit.duR); + set_variable ("duD", fit.duD); + set_variable ("plx", 0.0); + set_variable ("dplx", 0.0); + + set_variable ("Tmean", Tmean); + set_variable ("Trange", Trange); + set_variable ("Prange", 0.0); + + set_variable ("chisq", fit.chisq); + set_variable ("Nfit", fit.Nfit); + + return (TRUE); +} + +/* do we want an init function which does the alloc and a clear function to free? */ +int FitPMonly (PMFit *fit, double *X, double *dX, double *Y, double *dY, double *T, int Npts, int VERBOSE) { + + int i; + + static double **A, **B; + double wx, wy, Wx, Wy, Tx, Ty, Tx2, Ty2, Xs, Ys, XT, YT; + double chisq, Xf, Yf; + + /* do I need to do this as 2 2x2 matrix equations? */ + if (A == NULL) { + ALLOCATE (A, double *, 4); + ALLOCATE (B, double *, 4); + for (i = 0; i < 4; i++) { + ALLOCATE (A[i], double, 4); + ALLOCATE (B[i], double, 1); + memset (A[i], 0, 4*sizeof(double)); + memset (B[i], 0, 1*sizeof(double)); + } + } + + Wx = Wy = Tx = Ty = Tx2 = Ty2 = Xs = Ys = XT = YT = 0.0; + for (i = 0; i < Npts; i++) { + /* handle case where dX or dY = 0.0 */ + wx = 1.0 / SQ(dX[i]); + wy = 1.0 / SQ(dY[i]); + + Wx += wx; + Wy += wy; + + Tx += T[i]*wx; + Ty += T[i]*wy; + + Tx2 += SQ(T[i])*wx; + Ty2 += SQ(T[i])*wy; + + Xs += X[i]*wx; + Ys += Y[i]*wy; + + XT += X[i]*T[i]*wx; + YT += Y[i]*T[i]*wy; + } + + A[0][0] = Wx; + A[0][1] = Tx; + + A[1][0] = Tx; + A[1][1] = Tx2; + + A[2][2] = Wy; + A[2][3] = Ty; + + A[3][2] = Ty; + A[3][3] = Ty2; + + B[0][0] = Xs; + B[1][0] = XT; + B[2][0] = Ys; + B[3][0] = YT; + + if (!dgaussjordan ((double **)A, (double **)B, 4, 1)) { + if (VERBOSE) fprintf (stderr, "error in fit\n"); + if (VERBOSE == 2) { + int j; + for (i = 0; i < 4; i++) { + for (j = 0; j < 4; j++) { + fprintf (stderr, "%e ", A[i][j]); + } + fprintf (stderr, " : %e\n", A[i][0]); + } + } + return FALSE; + } + + fit[0].Ro = B[0][0]; + fit[0].uR = B[1][0]; + fit[0].Do = B[2][0]; + fit[0].uD = B[3][0]; + + fit[0].dRo = sqrt(A[0][0]); + fit[0].duR = sqrt(A[1][1]); + fit[0].dDo = sqrt(A[2][2]); + fit[0].duD = sqrt(A[3][3]); + + // add up the chi square for the fit + chisq = 0.0; + for (i = 0; i < Npts; i++) { + Xf = fit[0].Ro + fit[0].uR*T[i]; + Yf = fit[0].Do + fit[0].uD*T[i]; + chisq += SQ(X[i] - Xf) / SQ(dX[i]); + chisq += SQ(Y[i] - Yf) / SQ(dY[i]); + // if (VERBOSE) fprintf (stderr, "chisq contrib : %f %f : %f %f : %f %f : %f %f : %f\n", Xf, Yf, X[i] - Xf, Y[i] - Yf, dX[i], dY[i], (X[i] - Xf) / dX[i], (Y[i] - Yf) / dY[i], chisq); + } + fit[0].Nfit = Npts; + + // the reduced chisq is divided by (Ndof = 2*Npts - 4) + fit[0].chisq = chisq / (2.0*Npts - 4.0); + return (TRUE); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/gauss.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/gauss.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/gauss.c (revision 37067) @@ -10,4 +10,15 @@ Buffer *buf; KapaImageData data; + int VERBOSE; + + VERBOSE = TRUE; + if ((N = get_argument (argc, argv, "-q"))) { + VERBOSE = FALSE; + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-quiet"))) { + VERBOSE = FALSE; + remove_argument (N, &argc, argv); + } name = NULL; @@ -58,5 +69,5 @@ KiiCursorRead (kapa, &X, &Y, &ZP, &RA, &DEC, key); if (!strcasecmp (key, "Q")) break; - get_aperture_stats (&buf[0].matrix, (int)(X+0.5), (int)(Y+0.5), Npix, Nborder, max); + get_aperture_stats (&buf[0].matrix, (int)(X+0.5), (int)(Y+0.5), Npix, Nborder, max, VERBOSE); } KiiCursorOff (kapa); @@ -64,2 +75,3 @@ } + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/init.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/init.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/init.c (revision 37067) @@ -13,7 +13,9 @@ int czplot PROTO((int, char **)); int czcplot PROTO((int, char **)); +int cdensify PROTO((int, char **)); int drizzle PROTO((int, char **)); int flux PROTO((int, char **)); int fitplx PROTO((int, char **)); +int fitpm PROTO((int, char **)); int fixwrap PROTO((int, char **)); int fiximage PROTO((int, char **)); @@ -49,4 +51,5 @@ int scale PROTO((int, char **)); int sexigesimal PROTO((int, char **)); +int sersic PROTO((int, char **)); int spec PROTO((int, char **)); int specpairfit PROTO((int, char **)); @@ -72,7 +75,9 @@ {1, "czplot", czplot, "plot scaled vectors in sky coordinates"}, {1, "czcplot", czcplot, "plot color-scaled vectors in sky coordinates"}, + {1, "cdensify", cdensify, "vectors to density history on projection"}, {1, "drizzle", drizzle, "transform image to image"}, {1, "flux", flux, "flux in a convex contour"}, {1, "fitplx", fitplx, "fit proper motion and parallax"}, + {1, "fitpm", fitpm, "fit proper motion only"}, {1, "fixwrap", fixwrap, "fix megacam over-wrapped pixels"}, {1, "fiximage", fiximage, "fix pixels in an image by interpolation"}, @@ -107,4 +112,5 @@ {1, "scale", scale, "get / set real bzero / bscale values"}, {1, "sexigesimal", sexigesimal, "convert to/from sexigesimal/decimal"}, + {1, "sersic", sersic, "generate sub-pixel resolved sersic model"}, {1, "spec", spec, "extract a spectrum"}, {1, "specpairfit", specpairfit, "fit spectrum to another spectrum"}, Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/region.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/region.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/region.c (revision 37067) @@ -80,22 +80,22 @@ if (!ohana_str_to_radec (&Ra, &Dec, argv[1], argv[2])) return (FALSE); Radius = atof (argv[3]); - strcpy (graphmode.coords.ctype, "RA---TAN"); + strcpy (graphmode.coords.ctype, "DEC--TAN"); if (argc == 5) { if (!strcasecmp (argv[4], "TAN")) - strcpy (graphmode.coords.ctype, "RA---TAN"); + strcpy (graphmode.coords.ctype, "DEC--TAN"); if (!strcasecmp (argv[4], "SIN")) - strcpy (graphmode.coords.ctype, "RA---SIN"); + strcpy (graphmode.coords.ctype, "DEC--SIN"); if (!strcasecmp (argv[4], "ARC")) - strcpy (graphmode.coords.ctype, "RA---ARC"); + strcpy (graphmode.coords.ctype, "DEC--ARC"); if (!strcasecmp (argv[4], "STG")) - strcpy (graphmode.coords.ctype, "RA---STG"); + strcpy (graphmode.coords.ctype, "DEC--STG"); if (!strcasecmp (argv[4], "ZEA")) - strcpy (graphmode.coords.ctype, "RA---ZEA"); + strcpy (graphmode.coords.ctype, "DEC--ZEA"); if (!strcasecmp (argv[4], "AIT")) - strcpy (graphmode.coords.ctype, "RA---AIT"); + strcpy (graphmode.coords.ctype, "DEC--AIT"); if (!strcasecmp (argv[4], "GLS")) - strcpy (graphmode.coords.ctype, "RA---GLS"); + strcpy (graphmode.coords.ctype, "DEC--GLS"); if (!strcasecmp (argv[4], "PAR")) - strcpy (graphmode.coords.ctype, "RA---PAR"); + strcpy (graphmode.coords.ctype, "DEC--PAR"); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/sersic.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/sersic.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/sersic.c (revision 37067) @@ -0,0 +1,115 @@ +# include "astro.h" + +float sersic_norm (float index); + +// the sersic model has an integral of 2 \pi Rmin Rmax Io norm * Nsubpix^2 + +int sersic (int argc, char **argv) { + + int i, j; + Buffer *buf; + + // generate a sersic profile in the given buffer using N + + if (argc != 10) { + gprint (GP_ERR, "USAGE: sersic (buffer) (Io) (Xo) (Yo) (Rmajor) (Rminor) (theta) (index) (Nsubpix)\n"); + gprint (GP_ERR, " generate a sersic profile for the given parameters\n"); + return (FALSE); + } + + /* select input / output buffers */ + if ((buf = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE); + int Nx = buf[0].header.Naxis[0]; + int Ny = buf[0].header.Naxis[1]; + + // Io is the central pixel normalization + float Io = atof(argv[2]); + + // Xo, Yo are the central pixel coordinates in real pixels + float Xo = atof(argv[3]); + float Yo = atof(argv[4]); + + float Rmaj = atof(argv[5]); + float Rmin = atof(argv[6]); + + float theta = atof(argv[7]); + float index = atof(argv[8]); + float rindex = 0.5 / index; + + float Nsubpix = atof(argv[9]); + + float f1 = 1.0 / SQ(Rmin) + 1.0 / SQ(Rmaj); + float f2 = 1.0 / SQ(Rmin) - 1.0 / SQ(Rmaj); + + float sxr = 0.5*f1 - 0.5*f2*cos(2.0*theta*RAD_DEG); + float syr = 0.5*f1 + 0.5*f2*cos(2.0*theta*RAD_DEG); + + // sxr, syr cannot be < 0 (f1 >= f2) + + float Rxx = +1.0 / sqrt(sxr); + float Ryy = +1.0 / sqrt(syr); + float Rxy = -f2*sin(2.0*theta*RAD_DEG); + + float kappa = -0.275552 + 1.972625*index + 0.003487 * SQ(index); + + // dereference pointer + float *in = (float *) buf[0].matrix.buffer; + + for (j = 0; j < Ny; j++) { + for (i = 0; i < Nx; i++) { + + float x = ((i / Nsubpix) - Xo); + float y = ((j / Nsubpix) - Yo); + + // z = r^2 + float z = SQ(x/Rxx) + SQ(y/Ryy) + Rxy*x*y; + + float q = pow (z, rindex); + float f = Io * exp(-kappa*q); + + in[i + j*Nx] = f; + } + } + + float norm = sersic_norm(index); + set_variable ("sersic_norm", norm); + set_variable ("sersic_kappa", kappa); + + return (TRUE); +} + +float sersic_norm (float index) { + + float lnorm, norm; + + if ((index >= 0.0) && (index < 1.0)) { + lnorm = 0.201545 - 0.950965 * index - 0.315248 * SQ(index); + norm = exp(lnorm); + return norm; + } + + if ((index >= 1.0) && (index < 2.0)) { + lnorm = 0.402084 - 1.357775 * index - 0.105102 * SQ(index); + norm = exp(lnorm); + return norm; + } + + if ((index >= 2.0) && (index < 3.0)) { + lnorm = 0.619093 - 1.591674 * index - 0.041576 * SQ(index); + norm = exp(lnorm); + return norm; + } + + if ((index >= 3.0) && (index < 4.0)) { + lnorm = 0.770263 - 1.696421 * index - 0.023363 * SQ(index); + norm = exp(lnorm); + return norm; + } + + if ((index >= 4.0) && (index < 5.5)) { + lnorm = 0.885891 - 1.755684 * index - 0.015753 * SQ(index); + norm = exp(lnorm); + return norm; + } + return NAN; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/star.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/star.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/star.c (revision 37067) @@ -6,4 +6,15 @@ double max; Buffer *buf; + int VERBOSE; + + VERBOSE = TRUE; + if ((N = get_argument (argc, argv, "-q"))) { + VERBOSE = FALSE; + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-quiet"))) { + VERBOSE = FALSE; + remove_argument (N, &argc, argv); + } Nborder = 3; @@ -36,5 +47,5 @@ } - get_aperture_stats (&buf[0].matrix, x, y, dx, Nborder, max); + get_aperture_stats (&buf[0].matrix, x, y, dx, Nborder, max, VERBOSE); return (TRUE); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/Makefile (revision 37067) @@ -55,4 +55,5 @@ $(SRC)/substr.$(ARCH).o \ $(SRC)/strhash.$(ARCH).o \ +$(SRC)/strmatch.$(ARCH).o \ $(SRC)/strpop.$(ARCH).o \ $(SRC)/strsub.$(ARCH).o \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/init.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/init.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/init.c (revision 37067) @@ -40,4 +40,5 @@ int fprintf_opihi PROTO((int, char **)); int strlen_func PROTO((int, char **)); +int strmatch PROTO((int, char **)); int substr_func PROTO((int, char **)); int strpop PROTO((int, char **)); @@ -97,4 +98,5 @@ {1, "strpop", strpop, "pop a string"}, {1, "strsub", strsub, "replace instances of a key in a string"}, + {1, "strmatch", strmatch, "string length"}, {1, "wait", wait_func, "wait until return is typed"}, {1, "which", which, "show command *"} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/list.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/list.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/list.c (revision 37067) @@ -21,4 +21,14 @@ } + int EXCEL_STYLE = FALSE; + if ((N = get_argument (argc, argv, "-excel-style"))) { + remove_argument (N, &argc, argv); + EXCEL_STYLE = TRUE; + } + if ((N = get_argument (argc, argv, "-excel"))) { + remove_argument (N, &argc, argv); + EXCEL_STYLE = TRUE; + } + if ((N = get_argument (argc, argv, "-vectors"))) { remove_argument (N, &argc, argv); @@ -49,5 +59,5 @@ for (i = 0; i < argc - 3; i++) { - sprintf (line, "%s:%d", argv[1], i); + set_list_varname (line, argv[1], i, EXCEL_STYLE); set_str_variable (line, argv[i+3]); } @@ -83,5 +93,7 @@ if (!word) break; - sprintf (line, "%s:%d", argv[1], nWords); + // sprintf (line, "%s:%d", argv[1], nWords); + set_list_varname (line, argv[1], nWords, EXCEL_STYLE); + set_str_variable (line, word); FREE (word); @@ -120,5 +132,6 @@ sprintf (line, "%s:%d", argv[3], i); value = get_variable (line); - sprintf (line, "%s:%d", argv[1], i); + // sprintf (line, "%s:%d", argv[1], i); + set_list_varname (line, argv[1], i, EXCEL_STYLE); set_str_variable (line, value); } @@ -136,5 +149,6 @@ N = get_int_variable (line, &found); for (i = 0; i < argc - 3; i++) { - sprintf (line, "%s:%d", argv[1], N + i); + // sprintf (line, "%s:%d", argv[1], N + i); + set_list_varname (line, argv[1], N + i, EXCEL_STYLE); set_str_variable (line, argv[i+3]); } @@ -159,5 +173,6 @@ N = get_int_variable (line, &found); for (i = 0; i < N; i++) { - sprintf (line, "%s:%d", argv[1], i); + // sprintf (line, "%s:%d", argv[1], i); + set_list_varname (line, argv[1], i, EXCEL_STYLE); value = get_variable (line); if (value == NULL) continue; @@ -165,5 +180,6 @@ free (value); for (j = i + 1; j < N; j++) { - sprintf (line2, "%s:%d", argv[1], j); + // sprintf (line2, "%s:%d", argv[1], j); + set_list_varname (line2, argv[1], j, EXCEL_STYLE); next_value = get_variable (line2); set_str_variable (line, next_value); @@ -235,5 +251,6 @@ if (B != (char *) NULL) { *B = 0; } if (*A != 0) { - sprintf (line, "%s:%d", argv[1], i); + // sprintf (line, "%s:%d", argv[1], i); + set_list_varname (line, argv[1], i, EXCEL_STYLE); set_str_variable (line, A); A = B + 1; @@ -283,9 +300,10 @@ if (*input) { - sprintf (line, "%s:%d", argv[1], i); + // sprintf (line, "%s:%d", argv[1], i); + set_list_varname (line, argv[1], i, EXCEL_STYLE); set_str_variable (line, input); free (input); i++; - } + } } return (TRUE); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/strmatch.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/strmatch.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/strmatch.c (revision 37067) @@ -0,0 +1,176 @@ +# include "basic.h" + +int strmatch (int argc, char **argv) { + + /* returns position of the first given character class */ + int i, N; + + char *startName = NULL; + char *lengthName = NULL; + if ((N = get_argument (argc, argv, "-output"))) { + remove_argument (N, &argc, argv); + startName = strcreate (argv[N]); + remove_argument (N, &argc, argv); + lengthName = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + + if (argc != 3) { + gprint (GP_ERR, "USAGE: strchr (string) (class) [-output start length]\n"); + return (FALSE); + } + + // 'class' may be alpha, float, int, + + if (!strcasecmp(argv[2], "alpha")) { + int myLength = strlen(argv[1]); + int found = FALSE; + int start = -1; + int length = -1; + for (i = 0; i < myLength; i++) { + int isUpper = (argv[1][i] >= 'A') && (argv[1][i] <= 'Z'); + int isLower = (argv[1][i] >= 'a') && (argv[1][i] <= 'z'); + if (!found && (isLower || isUpper)) { + start = i; + found = TRUE; + continue; + } + if (found && !(isLower || isUpper)) { + length = i - start; + break; + } + } + if (found && (length < 0)) { + length = myLength - start; + } + if (startName && lengthName) { + set_int_variable (startName, start); + set_int_variable (lengthName, length); + } else { + gprint (GP_LOG, "match: %d %d\n", start, length); + } + return TRUE; + } + + if (!strcasecmp(argv[2], "upper")) { + int myLength = strlen(argv[1]); + int found = FALSE; + int start = -1; + int length = -1; + for (i = 0; i < myLength; i++) { + int isUpper = (argv[1][i] >= 'A') && (argv[1][i] <= 'Z'); + // int isLower = (argv[1][i] >= 'a') && (argv[1][i] <= 'z'); + if (!found && isUpper) { + start = i; + found = TRUE; + continue; + } + if (found && !isUpper) { + length = i - start; + break; + } + } + if (found && (length < 0)) { + length = myLength - start; + } + if (startName && lengthName) { + set_int_variable (startName, start); + set_int_variable (lengthName, length); + } else { + gprint (GP_LOG, "match: %d %d\n", start, length); + } + return TRUE; + } + + if (!strcasecmp(argv[2], "lower")) { + int myLength = strlen(argv[1]); + int found = FALSE; + int start = -1; + int length = -1; + for (i = 0; i < myLength; i++) { + // int isUpper = (argv[1][i] >= 'A') && (argv[1][i] <= 'Z'); + int isLower = (argv[1][i] >= 'a') && (argv[1][i] <= 'z'); + if (!found && isLower) { + start = i; + found = TRUE; + continue; + } + if (found && !isLower) { + length = i - start; + break; + } + } + if (found && (length < 0)) { + length = myLength - start; + } + if (startName && lengthName) { + set_int_variable (startName, start); + set_int_variable (lengthName, length); + } else { + gprint (GP_LOG, "match: %d %d\n", start, length); + } + return TRUE; + } + + if (!strcasecmp(argv[2], "float")) { + int myLength = strlen(argv[1]); + int found = FALSE; + int start = -1; + int length = -1; + for (i = 0; i < myLength; i++) { + int isDigit = (argv[1][i] >= '0') && (argv[1][i] <= '9'); + int isFloat = isDigit || (argv[1][i] == '-') || (argv[1][i] == '.'); + if (!found && isFloat) { + start = i; + found = TRUE; + continue; + } + if (found && !isFloat) { + length = i - start; + break; + } + } + if (found && (length < 0)) { + length = myLength - start; + } + if (startName && lengthName) { + set_int_variable (startName, start); + set_int_variable (lengthName, length); + } else { + gprint (GP_LOG, "match: %d %d\n", start, length); + } + return TRUE; + } + + if (!strcasecmp(argv[2], "int")) { + int myLength = strlen(argv[1]); + int found = FALSE; + int start = -1; + int length = -1; + for (i = 0; i < myLength; i++) { + int isDigit = (argv[1][i] >= '0') && (argv[1][i] <= '9'); + if (!found && isDigit) { + start = i; + found = TRUE; + continue; + } + if (found && !isDigit) { + length = i - start; + break; + } + } + if (found && (length < 0)) { + length = myLength - start; + } + if (startName && lengthName) { + set_int_variable (startName, start); + set_int_variable (lengthName, length); + } else { + gprint (GP_LOG, "match: %d %d\n", start, length); + } + return TRUE; + } + + gprint (GP_ERR, "unknown character class %s\n", argv[2]); + return (TRUE); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/Makefile (revision 37067) @@ -25,4 +25,5 @@ $(SRC)/book.$(ARCH).o \ $(SRC)/book_commands.$(ARCH).o \ +$(SRC)/cast.$(ARCH).o \ $(SRC)/center.$(ARCH).o \ $(SRC)/clear.$(ARCH).o \ @@ -63,7 +64,11 @@ $(SRC)/imcut.$(ARCH).o \ $(SRC)/imhist.$(ARCH).o \ +$(SRC)/impeaks.$(ARCH).o \ $(SRC)/imsmooth.$(ARCH).o \ +$(SRC)/imsmooth.generic.$(ARCH).o \ +$(SRC)/imsmooth.2d.$(ARCH).o \ $(SRC)/integrate.$(ARCH).o \ $(SRC)/interpolate.$(ARCH).o \ +$(SRC)/join.$(ARCH).o \ $(SRC)/jpeg.$(ARCH).o \ $(SRC)/kern.$(ARCH).o \ @@ -84,4 +89,6 @@ $(SRC)/mget.$(ARCH).o \ $(SRC)/minterpolate.$(ARCH).o \ +$(SRC)/medimage.$(ARCH).o \ +$(SRC)/medimage_commands.$(ARCH).o \ $(SRC)/mset.$(ARCH).o \ $(SRC)/peak.$(ARCH).o \ @@ -91,4 +98,5 @@ $(SRC)/point.$(ARCH).o \ $(SRC)/ps.$(ARCH).o \ +$(SRC)/print_vectors.$(ARCH).o \ $(SRC)/queuedelete.$(ARCH).o \ $(SRC)/queuedrop.$(ARCH).o \ @@ -143,4 +151,5 @@ $(SRC)/vmaxwell.$(ARCH).o \ $(SRC)/vgrid.$(ARCH).o \ +$(SRC)/vlist.$(ARCH).o \ $(SRC)/vload.$(ARCH).o \ $(SRC)/vzload.$(ARCH).o \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/cast.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/cast.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/cast.c (revision 37067) @@ -0,0 +1,71 @@ +# include "data.h" + +int cast (int argc, char **argv) { + + int i, valid; + Vector *ivec, *ovec; + + ivec = ovec = NULL; + + if (argc < 6) goto usage; + + valid = TRUE; + valid &= !strcmp(argv[2], "="); + valid &= !strcmp(argv[4], "as"); + if (!valid) goto usage; + + // out type + char outType = OPIHI_NOTYPE; + if (!strcasecmp(argv[5], "int")) outType = OPIHI_INT; + if (!strcasecmp(argv[5], "float")) outType = OPIHI_FLT; + if (outType == OPIHI_NOTYPE) goto usage; + + if ((ovec = SelectVector (argv[1], ANYVECTOR, TRUE)) == NULL) goto error; + if ((ivec = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) goto error; + + // ovec matches ivec in type + ResetVector (ovec, outType, ivec[0].Nelements); + + // we have four cases: (ivec == flt or int) and (tvec == flt or int) + if ((ivec->type == OPIHI_FLT) && (ovec->type == OPIHI_FLT)) { + opihi_flt *vi = ivec[0].elements.Flt; + opihi_flt *vo = ovec[0].elements.Flt; + for (i = 0; i < ovec[0].Nelements; i++, vi++, vo++) { + *vo = *vi; + } + return (TRUE); + } + if ((ivec->type == OPIHI_FLT) && (ovec->type == OPIHI_INT)) { + opihi_flt *vi = ivec[0].elements.Flt; + opihi_int *vo = ovec[0].elements.Int; + for (i = 0; i < ovec[0].Nelements; i++, vi++, vo++) { + *vo = *vi; + } + return (TRUE); + } + if ((ivec->type == OPIHI_INT) && (ovec->type == OPIHI_FLT)) { + opihi_int *vi = ivec[0].elements.Int; + opihi_flt *vo = ovec[0].elements.Flt; + for (i = 0; i < ovec[0].Nelements; i++, vi++, vo++) { + *vo = *vi; + } + return (TRUE); + } + if ((ivec->type == OPIHI_INT) && (ovec->type == OPIHI_INT)) { + opihi_int *vi = ivec[0].elements.Int; + opihi_int *vo = ovec[0].elements.Int; + for (i = 0; i < ovec[0].Nelements; i++, vi++, vo++) { + *vo = *vi; + } + return (TRUE); + } + +error: + DeleteVector (ovec); + return (FALSE); + +usage: + gprint (GP_ERR, "SYNTAX: cast vec = vec as (int/float)\n"); + return (FALSE); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/densify.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/densify.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/densify.c (revision 37067) @@ -2,8 +2,9 @@ # define CHECKVAL(ARG) if (!isfinite(ARG)) { gprint (GP_ERR, "illegal value for %s: %f\n", #ARG, ARG); return (FALSE); } +enum {IS_DOT, IS_SQUARE, IS_CIRCLE, IS_GAUSS}; int densify (int argc, char **argv) { - int i, Nx, Ny, Xb, Yb, N, Xpix, Ypix, good, UseGraph; + int i, Nx, Ny, Xb, Yb, ix, iy, N, Xpix, Ypix, good, UseGraph; double Xmin, Xmax, dX, Ymin, Ymax, dY; float *val; @@ -24,8 +25,26 @@ } + float scale = 0.0; + if ((N = get_argument (argc, argv, "-scale"))) { + remove_argument (N, &argc, argv); + scale = atof(argv[N]); + remove_argument (N, &argc, argv); + } + + int PSFTYPE = IS_DOT; + if ((N = get_argument (argc, argv, "-psf"))) { + remove_argument (N, &argc, argv); + if (!strcasecmp(argv[N], "dot")) PSFTYPE = IS_DOT; + if (!strcasecmp(argv[N], "square")) PSFTYPE = IS_SQUARE; + if (!strcasecmp(argv[N], "circle")) PSFTYPE = IS_CIRCLE; + if (!strcasecmp(argv[N], "gauss")) PSFTYPE = IS_GAUSS; + remove_argument (N, &argc, argv); + } + good = UseGraph ? (argc == 4) : (argc == 10); if (!good) { gprint (GP_ERR, "USAGE: densify buffer x y Xmin Xmax dX Ymin Ymax dY\n"); gprint (GP_ERR, " OR: densify buffer x y -graph\n"); + gprint (GP_ERR, " option: -psf [dot] (circle) (square) (gauss)\n"); return (FALSE); } @@ -69,4 +88,7 @@ CHECKVAL(dY); + float scaleX = (scale > 0.0) ? scale / dX : 3.0; + float scaleY = (scale > 0.0) ? scale / dY : 3.0; + Nx = (Xmax - Xmin) / dX + 1; Ny = (Ymax - Ymin) / dY + 1; @@ -76,4 +98,10 @@ CreateBuffer (bf, Nx, Ny, -32, 0.0, 1.0); strcpy (bf[0].file, "(empty)"); + + float scale2 = (scaleX + 1.0) * (scaleY + 1.0); + float fSquare = 1.0 / scale2; + float fCircle = 1.0 / (3.141592 * scale2); + float fSigma = 0.5 / scale2; + float fGauss = 1.0 / (2.0 * 3.141592 * scale2); x = vx[0].elements.Flt; @@ -83,9 +111,53 @@ Xb = (*x - Xmin) / dX; Yb = (*y - Ymin) / dY; - if (Xb >= Nx) continue; - if (Yb >= Ny) continue; - if (Xb < 0) continue; - if (Yb < 0) continue; - val[Xb + Yb*Nx] ++; + switch (PSFTYPE) { + case IS_DOT: + if (Xb >= Nx) continue; + if (Yb >= Ny) continue; + if (Xb < 0) continue; + if (Yb < 0) continue; + val[Xb + Yb*Nx] ++; + break; + case IS_SQUARE: + for (ix = Xb - scaleX; ix <= Xb + scaleX; ix++) { + for (iy = Yb - scaleY; iy <= Yb + scaleY; iy++) { + if (ix >= Nx) continue; + if (iy >= Ny) continue; + if (ix < 0) continue; + if (iy < 0) continue; + val[ix + iy*Nx] += fSquare; + } + } + break; + case IS_CIRCLE: + for (ix = Xb - scaleX; ix <= Xb + scaleX; ix++) { + float dX = ix - Xb; + for (iy = Yb - scaleY; iy <= Yb + scaleY; iy++) { + float dY = iy - Yb; + float r2 = dX*dX + dY*dY; + if (r2 > 9) continue; + if (ix >= Nx) continue; + if (iy >= Ny) continue; + if (ix < 0) continue; + if (iy < 0) continue; + val[ix + iy*Nx] += fCircle; + } + } + break; + case IS_GAUSS: + for (ix = Xb - scaleX; ix <= Xb + scaleX; ix++) { + float dX = ix - Xb; + for (iy = Yb - scaleY; iy <= Yb + scaleY; iy++) { + float dY = iy - Yb; + float r2 = dX*dX + dY*dY; + if (ix >= Nx) continue; + if (iy >= Ny) continue; + if (ix < 0) continue; + if (iy < 0) continue; + val[ix + iy*Nx] += fGauss*exp(-fSigma*r2); + } + } + break; + } } return (TRUE); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/impeaks.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/impeaks.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/impeaks.c (revision 37067) @@ -0,0 +1,113 @@ +# include "data.h" + +float *findPeaksInRow (Buffer *buff, int y, float threshold, float *peaks, int *npeaks); + +int impeaks (int argc, char **argv) { + + int iy, n; + Vector *vecx, *vecy, *vecf; + Buffer *buff; + + if (argc != 6) { + gprint (GP_ERR, "USAGE: impeaks (buffer) \n"); + return (FALSE); + } + + if ((buff = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE); + if ((vecx = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((vecy = SelectVector (argv[3], ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((vecf = SelectVector (argv[4], ANYVECTOR, TRUE)) == NULL) return (FALSE); + + float threshold = atof (argv[5]); + + // we find the peaks in the image by looking for peaks in each row, then checking their neighboring pixels + + float *image = (float *) buff[0].matrix.buffer; + int Nx = buff[0].matrix.Naxis[0]; + int Ny = buff[0].matrix.Naxis[1]; + + // we will use this vector for each row (allocated first pass only) + float *rowPeaks = NULL; + + int Npeak = 0; + int NPEAK = 1000; + opihi_flt *peakX = NULL; + opihi_flt *peakY = NULL; + opihi_flt *peakF = NULL; + ALLOCATE (peakX, opihi_flt, NPEAK); + ALLOCATE (peakY, opihi_flt, NPEAK); + ALLOCATE (peakF, opihi_flt, NPEAK); + + // exclude peaks on the outer edge + for (iy = 1; iy < Ny; iy++) { + + int iyn = iy - 1; + int iyp = iy + 1; + + int nRowPeaks; + rowPeaks = findPeaksInRow (buff, iy, threshold, rowPeaks, &nRowPeaks); + + // each each of the row peaks to see if it is an image peak + + for (n = 0; n < nRowPeaks; n++) { + int ix = rowPeaks[n]; + int ixn = ix - 1; + int ixp = ix + 1; + + float value = image[ix + iy*Nx]; + + // I know ix,iy is a peak in the row, is it above the neighbors in the previous and next rows? + if (value <= image[ix + iyn*Nx]) continue; + if (value < image[ix + iyp*Nx]) continue; + if (value < image[ixn + iyn*Nx]) continue; + if (value <= image[ixn + iyp*Nx]) continue; + if (value < image[ixp + iyn*Nx]) continue; + if (value <= image[ixp + iyp*Nx]) continue; + + peakX[Npeak] = ix; + peakY[Npeak] = iy; + peakF[Npeak] = value; + Npeak ++; + if (Npeak == NPEAK) { + NPEAK += 100; + REALLOCATE (peakX, opihi_flt, NPEAK); + REALLOCATE (peakY, opihi_flt, NPEAK); + REALLOCATE (peakF, opihi_flt, NPEAK); + } + } + + } + + free (vecx->elements.Flt); vecx->elements.Flt = peakX; vecx->Nelements = Npeak; + free (vecy->elements.Flt); vecy->elements.Flt = peakY; vecy->Nelements = Npeak; + free (vecf->elements.Flt); vecf->elements.Flt = peakF; vecf->Nelements = Npeak; + + return (TRUE); +} + +// skip the first and last pixel +float *findPeaksInRow (Buffer *buff, int y, float threshold, float *peaks, int *npeaks) { + + int ix; + + int Nx = buff[0].matrix.Naxis[0]; + + float *row = (float *) buff[0].matrix.buffer + Nx*y; + + if (peaks == NULL) { + ALLOCATE (peaks, float, Nx); + } + int Npeaks = 0; + for (ix = 1; ix < Nx - 1; ix++) { + if (row[ix] < threshold) continue; // only accept pixels above threshold + if (row[ix] < row[ix - 1]) continue; // peak pixel must be at least preceeding pixel + if (row[ix] <= row[ix + 1]) continue; // we accept the last pixel of a series of equal values + + peaks[Npeaks] = ix; + Npeaks ++; + } + + *npeaks = Npeaks; + return peaks; +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/imsmooth.2d.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/imsmooth.2d.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/imsmooth.2d.c (revision 37067) @@ -0,0 +1,214 @@ +# include "data.h" + +# define NRAD_MAX 44 +static float radii2[NRAD_MAX] = { 0.0, 1.0, 2.0, 4.0, 5.0, + 8.0, 9.0, 10.0, 13.0, 16.0, + 17.0, 18.0, 20.0, 25.0, 26.0, + 29.0, 32.0, 34.0, 36.0, 37.0, + 40.0, 41.0, 45.0, 49.0, 50.0, + 52.0, 53.0, 58.0, 61.0, 64.0, + 65.0, 68.0, 72.0, 73.0, 74.0, + 80.0, 81.0, 82.0, 85.0, 89.0, + 90.0, 97.0, 98.0, 100.0 +}; + +static int radiiN[NRAD_MAX] = { 1, 4, 4, 4, 8, + 4, 4, 8, 8, 4, + 8, 4, 8, 12, 8, + 8, 4, 8, 4, 8, + 8, 8, 8, 4, 12, + 8, 8, 8, 8, 4, + 16, 8, 4, 8, 8, + 8, 4, 8, 16, 8, + 8, 8, 4, 12 +}; + +/* + 0, 0 : 0 : 0 : 0 + 0, 1 : 1 : 1 : 1 + 1, 1 : 2 : 1 : 2 + 0, 2 : 3 : 2 : 4 + 1, 2 : 4 : 2 : 5 + 2, 2 : 5 : 2 : 8 + 0, 3 : 6 : 3 : 9 + 1, 3 : 7 : 3 : 10 + 2, 3 : 8 : 3 : 13 + 0, 4 : 9 : 4 : 16 + 1, 4 : 10 : 4 : 17 + 3, 3 : 11 : 4 : 18 + 2, 4 : 12 : 4 : 20 + 0, 5 : 13 : 5 : 25 + 3, 4 : 13 : 5 : 25 + 1, 5 : 14 : 5 : 26 + 2, 5 : 15 : 5 : 29 + 4, 4 : 16 : 5 : 32 + 3, 5 : 17 : 5 : 34 + 0, 6 : 18 : 6 : 36 + 1, 6 : 19 : 6 : 37 + 2, 6 : 20 : 6 : 40 + 4, 5 : 21 : 6 : 41 + 3, 6 : 22 : 6 : 45 + 0, 7 : 23 : 7 : 49 + 1, 7 : 24 : 7 : 50 * + 5, 5 : 24 : 7 : 50 * + 4, 6 : 25 : 7 : 52 + 2, 7 : 26 : 7 : 53 + 3, 7 : 27 : 7 : 58 + 5, 6 : 28 : 7 : 61 + 0, 8 : 29 : 8 : 64 + 1, 8 : 30 : 8 : 65 * + 4, 7 : 30 : 8 : 65 * + 2, 8 : 31 : 8 : 68 + 6, 6 : 32 : 8 : 72 + 3, 8 : 33 : 8 : 73 + 5, 7 : 34 : 8 : 74 + 4, 8 : 35 : 8 : 80 + 0, 9 : 36 : 9 : 81 + 1, 9 : 37 : 9 : 82 + 2, 9 : 38 : 9 : 85 * + 6, 7 : 38 : 9 : 85 * + 5, 8 : 39 : 9 : 89 + 3, 9 : 40 : 9 : 90 + 4, 9 : 41 : 9 : 97 + 7, 7 : 42 : 9 : 98 + 0, 10 : 43 : 10 : 100 * + 6, 8 : 43 : 10 : 100 * + */ + +# define ADD_AXIS(RAD,DD) s += radflux[RAD]*(vi[p - DD] + vi[p + DD] + vi[p - DD*Nx] + vi[p + DD*Nx]); +# define ADD_DIAG(RAD,DD) s += radflux[RAD]*(vi[p - DD - DD*Nx] + vi[p + DD - DD*Nx] + vi[p - DD + DD*Nx] + vi[p + DD + DD*Nx]); +# define ADD_RAND(RAD,DX,DY) s += radflux[RAD]*(vi[p - DX - DY*Nx] + vi[p + DX - DY*Nx] + vi[p - DX + DY*Nx] + vi[p + DX + DY*Nx] + \ + vi[p - DY - DX*Nx] + vi[p + DY - DX*Nx] + vi[p - DY + DX*Nx] + vi[p + DY + DX*Nx]); + +int imsmooth_2d (int argc, char **argv) { + + int i, j; + float *vi, *vo; + Buffer *in; + + if (argc != 4) { + gprint (GP_ERR, "USAGE: imsmooth (input) sigma Nsigma\n"); + return (FALSE); + } + + if ((in = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE); + float sigma = atof(argv[2]); + float Nsigma = atof(argv[3]); + + int Ns = (int)(Nsigma * sigma); + Ns = MAX (3, MIN (Ns, 10)); + int Ns2 = Ns * Ns; + + // we are going to use a hard-wired radial profile + float *radflux = NULL; + ALLOCATE (radflux, float, NRAD_MAX); + float sum = 0.0; + for (i = 0; i < NRAD_MAX; i++) { + float z = radii2[i] / SQ(sigma); + radflux[i] = 1.0 / (1.0 + z + pow(z,1.666)); + if (radii2[i] > Ns2) continue; + sum += radiiN[i] * radflux[i]; + } + for (i = 0; i < NRAD_MAX; i++) { + radflux[i] = radflux[i] / sum; + } + + int Nx = in[0].matrix.Naxis[0]; + int Ny = in[0].matrix.Naxis[1]; + ALLOCATE (vo, float, Nx*Ny); + memset (vo, 0, Nx*Ny*sizeof(float)); + + /* smooth in X direction */ + vi = (float *) in[0].matrix.buffer; + for (j = Ns; j < Ny - Ns; j++) { + for (i = Ns; i < Nx - Ns; i++) { + + int p = i + j*Nx; // current pixel of interest + float s = radflux[0]*(vi[p]); + + // r <= 1.0 + ADD_AXIS (1, 1); // r^2 = 1 + + // r <= 2.0 + ADD_DIAG (2, 1); // r^2 = 2 + ADD_AXIS (3, 2); // r^2 = 4 + + // r <= 3.0 + ADD_RAND (4, 1, 2); // r^2 = 5 + ADD_DIAG (5, 2); // r^2 = 8 + ADD_AXIS (6, 3); // r^2 = 9 + if (Ns <= 3) goto finish; + + // r <= 4.0 + ADD_RAND (7, 1, 3); // r^2 = 10 + ADD_RAND (8, 2, 3); // r^2 = 13 + ADD_AXIS (9, 4); // r^2 = 16 + if (Ns <= 4) goto finish; + + // r <= 5.0 + ADD_RAND (10, 1, 4); // r^2 = 17 + ADD_DIAG (11, 3); // r^2 = 18 + ADD_RAND (12, 2, 4); // r^2 = 20 + ADD_RAND (13, 3, 4); // r^2 = 25 + ADD_AXIS (13, 5); // r^2 = 25 + if (Ns <= 5) goto finish; + + // r <= 6.0 + ADD_RAND (14, 1, 5); // r^2 = 26 + ADD_RAND (15, 2, 5); // r^2 = 29 + ADD_DIAG (16, 4); // r^2 = 32 + ADD_RAND (17, 3, 5); // r^2 = 34 + ADD_AXIS (18, 6); // r^2 = 36 + if (Ns <= 6) goto finish; + + // r <= 7.0 + ADD_RAND (19, 1, 6); // r^2 = 37 + ADD_RAND (20, 2, 6); // r^2 = 40 + ADD_RAND (21, 4, 5); // r^2 = 41 + ADD_RAND (22, 3, 6); // r^2 = 45 + ADD_AXIS (23, 7); // r^2 = 49 + if (Ns <= 7) goto finish; + + // r <= 8.0 + ADD_RAND (24, 1, 7); // r^2 = 50 + ADD_DIAG (24, 5); // r^2 = 50 + ADD_RAND (25, 4, 6); // r^2 = 52 + ADD_RAND (26, 2, 7); // r^2 = 53 + ADD_RAND (27, 3, 7); // r^2 = 58 + ADD_RAND (28, 5, 6); // r^2 = 61 + ADD_AXIS (29, 8); // r^2 = 64 + if (Ns <= 8) goto finish; + + ADD_RAND (30, 1, 8); // r^2 = 65 * + ADD_RAND (30, 4, 7); // r^2 = 65 * + ADD_RAND (31, 2, 8); // r^2 = 68 + ADD_DIAG (32, 6); // r^2 = 72 + ADD_RAND (33, 3, 8); // r^2 = 73 + ADD_RAND (34, 5, 7); // r^2 = 74 + ADD_RAND (35, 4, 8); // r^2 = 80 + ADD_AXIS (36, 9); // r^2 = 81 + if (Ns <= 9) goto finish; + + ADD_RAND (37, 1, 9); // r^2 = 82 + ADD_RAND (38, 2, 9); // r^2 = 85 * + ADD_RAND (38, 6, 7); // r^2 = 85 * + ADD_RAND (39, 5, 8); // r^2 = 89 + ADD_RAND (40, 3, 9); // r^2 = 90 + ADD_RAND (41, 4, 9); // r^2 = 97 + ADD_DIAG (42, 7); // r^2 = 98 + ADD_RAND (43, 6, 8); // r^2 = 100 * + ADD_AXIS (43, 10); // r^2 = 100 * + if (Ns <= 10) goto finish; + + finish: + vo[p] = s; + } + } + + free (radflux); + free (in[0].matrix.buffer); + in[0].matrix.buffer = (char *) vo; + + return (TRUE); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/imsmooth.generic.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/imsmooth.generic.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/imsmooth.generic.c (revision 37067) @@ -0,0 +1,68 @@ +# include "data.h" + +int imsmooth_generic (int argc, char **argv) { + + int i, j, n; + float *vi, *vo; + float g, s; + Buffer *in; + Vector *vec; + float *temp; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: imsmooth (input) vector\n"); + return (FALSE); + } + + if ((in = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE); + if ((vec = SelectVector (argv[2], OLDVECTOR, TRUE)) == NULL) return (FALSE); + + if (vec[0].Nelements % 2 == 0) { + gprint (GP_ERR, "vector must have an odd number of elements\n"); + return FALSE; + } + + int Nx = in[0].matrix.Naxis[0]; + int Ny = in[0].matrix.Naxis[1]; + ALLOCATE (temp, float, Nx*Ny); + + /* build a 1D gaussian */ + int Ns = 0.5*(vec[0].Nelements - 1); + opihi_flt *smvec = &vec[0].elements.Flt[Ns]; + + /* smooth in X direction */ + for (j = 0; j < Ny; j++) { + vi = (float *) in[0].matrix.buffer + j*Nx; + vo = &temp[j*Nx]; + for (i = 0; i < Nx; i++) { + g = s = 0; + for (n = -Ns; n < Ns + 1; n++) { + if (i+n < 0) continue; + if (i+n >= Nx) continue; + s += smvec[n]*vi[i+n]; + g += smvec[n]; + } + vo[i] = s / g; + } + } + + /* smooth in Y direction */ + for (i = 0; i < Nx; i++) { + vi = &temp[i]; + vo = (float *)in[0].matrix.buffer + i; + for (j = 0; j < Ny; j++) { + g = s = 0; + for (n = -Ns; n < Ns + 1; n++) { + if (j+n < 0) continue; + if (j+n >= Ny) continue; + s += smvec[n]*vi[(n+j)*Nx]; + g += smvec[n]; + } + vo[j*Nx] = s / g; + } + } + + free (temp); + return (TRUE); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/init.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/init.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/init.c (revision 37067) @@ -10,4 +10,5 @@ int center PROTO((int, char **)); int parity PROTO((int, char **)); +int cast PROTO((int, char **)); int circstats PROTO((int, char **)); int clear PROTO((int, char **)); @@ -52,7 +53,11 @@ int imcut PROTO((int, char **)); int imhist PROTO((int, char **)); +int impeaks PROTO((int, char **)); int imsmooth PROTO((int, char **)); +int imsmooth_generic PROTO((int, char **)); +int imsmooth_2d PROTO((int, char **)); int integrate PROTO((int, char **)); int interpolate PROTO((int, char **)); +int join PROTO((int, char **)); int jpeg PROTO((int, char **)); int kern PROTO((int, char **)); @@ -74,4 +79,5 @@ int mget PROTO((int, char **)); int minterp PROTO((int, char **)); +int medimage_command PROTO((int, char **)); int mset PROTO((int, char **)); int peak PROTO((int, char **)); @@ -81,4 +87,5 @@ int point PROTO((int, char **)); int ps PROTO((int, char **)); +int print_vectors PROTO((int, char **)); int queuelist PROTO((int, char **)); int queueload PROTO((int, char **)); @@ -133,4 +140,5 @@ int vmaxwell PROTO((int, char **)); int vload PROTO((int, char **)); +int vlist PROTO((int, char **)); int vzload PROTO((int, char **)); int vstats PROTO((int, char **)); @@ -160,4 +168,5 @@ {1, "buffers", list_buffers, "list the currently allocated buffers (images)"}, {1, "center", center, "center image on coords"}, + {1, "cast", cast, "cast input vector to specified type"}, {1, "circstats", circstats, "circular statistics"}, {1, "clear", clear, "erase plot"}, @@ -205,8 +214,12 @@ {1, "imcut", imcut, "linear image cut between arbitrary coords"}, {1, "imhistogram", imhist, "histogram of an image region"}, + {1, "impeaks", impeaks, "find peaks in an image (return vectors)"}, {1, "imsmooth", imsmooth, "circular gaussian smoothing"}, + {1, "imsmooth.generic", imsmooth_generic, "circular non-gaussian smoothing"}, + {1, "imsmooth.2d", imsmooth_2d, "circular non-gaussian smoothing"}, {1, "imstats", imstats, "statistics on a portion of an image"}, {1, "integrate", integrate, "integrate a vector"}, {1, "interpolate", interpolate, "interpolate between vector pairs"}, + {1, "join", join, "find the join of two ID vectors"}, {1, "jpeg", jpeg, "convert display image to JPEG"}, {1, "kern", kern, "convolve with 3x3 kernel"}, @@ -224,4 +237,5 @@ {1, "minterp", minterp, "interpolate image pixels"}, {1, "iminterp", minterp, "interpolate image pixels"}, + {1, "medimage", medimage_command, "median image manipulation"}, {1, "matrix", matrix, "matrix math operations"}, {1, "match2d", match2d, "match 2 pairs of X,Y vectors and return matched indexes"}, @@ -237,4 +251,5 @@ {1, "ppm", jpeg, "convert display graphic to PPM"}, {1, "ps", ps, "convert display to PostScript"}, + {1, "print_vectors", print_vectors, "print a set of vectors"}, {1, "queuedelete", queuedelete, "delete a queue"}, {1, "queuedrop", queuedrop, "drop values from queue matching a key"}, @@ -290,4 +305,5 @@ {1, "vgrid", vgrid, "generate an image from a triplet of vectors"}, {1, "vhistogram", histogram, "generate histogram from vector"}, + {1, "vlist", vlist, "append values to a vector from command line"}, {1, "vload", vload, "load vectors as overlay on image display"}, {1, "vmaxwell", vmaxwell, "fit a Maxwellian to a vector"}, Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/join.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/join.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/join.c (revision 37067) @@ -0,0 +1,195 @@ +# include "data.h" + +int join_IDs_inner (Vector *ID1, Vector *ID2, Vector *index1, Vector *index2); +int join_IDs_outer (Vector *ID1, Vector *ID2, Vector *index); + +// join (ID1) (ID2) [-index1 (index1)] [-index2 (index2)] +// generate indexes for ID1 and ID2 to identify the matches of ID1 and ID2 (must be int?) +int join (int argc, char **argv) { + + int N, OUTER; + Vector *ID1vec, *ID2vec; + Vector *index1, *index2; + + if ((N = get_argument (argc, argv, "-h"))) goto usage; + if ((N = get_argument (argc, argv, "--help"))) goto usage; + + OUTER = FALSE; + if ((N = get_argument (argc, argv, "-outer"))) { + remove_argument (N, &argc, argv); + OUTER = TRUE; + } + + if ((N = get_argument (argc, argv, "-index1"))) { + remove_argument (N, &argc, argv); + if ((index1 = SelectVector (argv[N], ANYVECTOR, TRUE)) == NULL) return (FALSE); + remove_argument (N, &argc, argv); + } else { + if ((index1 = SelectVector ("index1", ANYVECTOR, TRUE)) == NULL) return (FALSE); + } + + if ((N = get_argument (argc, argv, "-index2"))) { + remove_argument (N, &argc, argv); + if ((index2 = SelectVector (argv[N], ANYVECTOR, TRUE)) == NULL) return (FALSE); + remove_argument (N, &argc, argv); + } else { + if ((index2 = SelectVector ("index2", ANYVECTOR, TRUE)) == NULL) return (FALSE); + } + + if (argc != 3) { + gprint (GP_ERR, "USAGE: join ID1 ID2 [-index1 (index1)] [-index2 (index2)] [-outer]\n"); + gprint (GP_ERR, " use -h or --help for more detail\n"); + return FALSE; + } + + if ((ID1vec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE); + if ((ID2vec = SelectVector (argv[2], OLDVECTOR, TRUE)) == NULL) return (FALSE); + + REQUIRE_VECTOR_INT (ID1vec, FALSE); + REQUIRE_VECTOR_INT (ID2vec, FALSE); + + if (OUTER) { + join_IDs_outer (ID1vec, ID2vec, index1); + join_IDs_outer (ID2vec, ID1vec, index2); + } else { + join_IDs_inner (ID1vec, ID2vec, index1, index2); + } + + return (TRUE); + +usage: + gprint (GP_ERR, "we have two modes of operation:\n\n"); + + gprint (GP_ERR, "without -outer, we are finding all matched ID pairs. in this\n"); + gprint (GP_ERR, "case, the two index vectors have the same length, one entry per matched pair.\n"); + gprint (GP_ERR, "ID1[index1] matches to ID2[index2].\n\n"); + + gprint (GP_ERR, "with -outer selected, we are finding the matched element of set 1 for each of set 2\n"); + gprint (GP_ERR, "and vice versa. in this case, index1 is always the same length as ID1, while index2\n"); + gprint (GP_ERR, "is the same length as ID2. ID2[index1] matches ID1 while x1[ID2] matches ID1\n"); + + return FALSE; +} + +// find the entries in ID1 which match ID2 (duplicates allows) +int join_IDs_inner (Vector *ID1, Vector *ID2, Vector *index1, Vector *index2) { + + off_t i, j, first_j, I, J, *N1, *N2, Nmatch, NMATCH, DMATCH; + opihi_int dID; + + NMATCH = MAX(MAX(0.01*ID1->Nelements, 0.01*ID2->Nelements), 100); + DMATCH = NMATCH; + + ResetVector (index1, OPIHI_INT, NMATCH); + ResetVector (index2, OPIHI_INT, NMATCH); + + ALLOCATE (N1, off_t, ID1->Nelements); + ALLOCATE (N2, off_t, ID2->Nelements); + + for (i = 0; i < ID1->Nelements; i++) { N1[i] = i; } + for (i = 0; i < ID2->Nelements; i++) { N2[i] = i; } + + sort_IDs_indexonly (ID1->elements.Int, N1, ID1->Nelements); + sort_IDs_indexonly (ID2->elements.Int, N2, ID2->Nelements); + + Nmatch = 0; + for (i = j = 0; (i < ID1->Nelements) && (j < ID2->Nelements);) { + I = N1[i]; + J = N2[j]; + + dID = ID1->elements.Int[I] - ID2->elements.Int[J]; + + if (dID < 0) { i++; continue; } + if (dID > 0) { j++; continue; } + + // look for all matches of list2() to list1(i) + // this allows for multiple values of ID1 or ID2 + first_j = j; + for (j = first_j; (dID == 0) && (j < ID2->Nelements); j++) { + J = N2[j]; + dID = ID1->elements.Int[I] - ID2->elements.Int[J]; + if (dID == 0) { + index1->elements.Int[Nmatch] = I; + index2->elements.Int[Nmatch] = J; + + Nmatch ++; + if (Nmatch >= NMATCH) { + NMATCH += DMATCH; + REALLOCATE (index1->elements.Int, opihi_int, NMATCH); + REALLOCATE (index2->elements.Int, opihi_int, NMATCH); + } + } + } + j = first_j; + i++; + } + index1->Nelements = Nmatch; + index2->Nelements = Nmatch; + + free (N1); + free (N2); + + return (TRUE); +} + +// find the elements of ID1 which match ID2 (-1 if no match) +int join_IDs_outer (Vector *ID1, Vector *ID2, Vector *index) { + + off_t i, j, Jfirst, Ji, I, J, *N1, *N2, NMATCH; + opihi_int dID; + + NMATCH = ID1->Nelements; + ResetVector (index, OPIHI_INT, NMATCH); + + for (i = 0; i < index->Nelements; i++) { index->elements.Int[i] = -1; } + + ALLOCATE (N1, off_t, ID1->Nelements); + ALLOCATE (N2, off_t, ID2->Nelements); + + for (i = 0; i < ID1->Nelements; i++) { N1[i] = i; } + for (i = 0; i < ID2->Nelements; i++) { N2[i] = i; } + + sort_IDs_indexonly (ID1->elements.Int, N1, ID1->Nelements); + sort_IDs_indexonly (ID2->elements.Int, N2, ID2->Nelements); + + // find the closest entry in list 2 to the current entry in list 1: + for (i = j = 0; (i < ID1->Nelements) && (j < ID2->Nelements);) { + I = N1[i]; + J = N2[j]; + + dID = ID1->elements.Int[I] - ID2->elements.Int[J]; + + if (dID < 0) { + // no match in list 2 to this entry + index->elements.Int[I] = -1; + i++; + continue; + } + if (dID > 0) { j++; continue; } + + // look for closest matches of list2() to list1(i) + Jfirst = -1; + for (Ji = j; (Jfirst == -1) && (dID == 0) && (Ji < ID2->Nelements); Ji++) { + J = N2[Ji]; + dID = ID1->elements.Int[I] - ID2->elements.Int[J]; + if (dID == 0) { + Jfirst = J; + } + } + + // no match in list 2 to this entry + if (Jfirst == -1) { + index->elements.Int[I] = -1; + i++; + continue; + } + index->elements.Int[I] = Jfirst; + i++; + } + index->Nelements = NMATCH; + + free (N1); + free (N2); + + return (TRUE); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/match2d.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/match2d.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/match2d.c (revision 37067) @@ -14,4 +14,7 @@ Vector *index1, *index2; + if ((N = get_argument (argc, argv, "-h"))) goto usage; + if ((N = get_argument (argc, argv, "--help"))) goto usage; + CLOSEST = FALSE; if ((N = get_argument (argc, argv, "-closest"))) { @@ -38,6 +41,5 @@ if (argc != 6) { gprint (GP_ERR, "USAGE: match2d X1 Y1 X2 Y2 Radius [-index1 (index1)] [-index2 (index2)] [-closest]\n"); - gprint (GP_ERR, " if -closest is provided, index1 & index2 will have the same length as X1 and X2 (respectively)\n"); - gprint (GP_ERR, " with either the index of the match or a value of -1 for non-matches\n"); + gprint (GP_ERR, " use -h or --help for more detail\n"); return (FALSE); } @@ -90,4 +92,21 @@ return (TRUE); + +usage: + gprint (GP_ERR, "we have two modes of operation:\n\n"); + + gprint (GP_ERR, "without -closest, we are finding all matched pairs within the match radius. in this\n"); + gprint (GP_ERR, "case, the two index vectors have the same length, one entry per matched pair.\n"); + gprint (GP_ERR, "x1[index1],y1[index1] matches to x2[index2],y2[index2].\n\n"); + + gprint (GP_ERR, "with -closest selected, we are finding the closest element of set 1 to each of set 2\n"); + gprint (GP_ERR, "and vice versa. in this case, index1 is always the same length as x1,y1, while index2\n"); + gprint (GP_ERR, "is the same lengths as x2,y2. x2[index1],y2[index1] matches x1,y1 while\n"); + gprint (GP_ERR, "x1[index2],y1[index2] matches x2,y2\n\n"); + + gprint (GP_ERR, "if -index1 or -index2 is not supplied, the vectors are created with names index1 or index2\n"); + gprint (GP_ERR, "use 'reindex' to generate new vectors based on these index vectors\n"); + + return FALSE; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/medimage.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/medimage.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/medimage.c (revision 37067) @@ -0,0 +1,53 @@ +# include "data.h" + +int medimage_help (int argc, char **argv); +int medimage_list (int argc, char **argv); +int medimage_add (int argc, char **argv); +int medimage_calc (int argc, char **argv); +int medimage_delete (int argc, char **argv); +int medimage_rename (int argc, char **argv); + +static Command medimage_commands[] = { + {1, "help", medimage_help, "list medimage help info"}, + {1, "list", medimage_list, "list medimages"}, + {1, "add", medimage_add, "add an image to the given medimage (creates new one if needed)"}, + {1, "calc", medimage_calc, "measure the median image and save to a buffer"}, + {1, "delete", medimage_delete, "delete a medimage"}, + {1, "rename", medimage_rename, "rename a medimage"}, +}; + +int medimage_help (int argc, char **argv) { + + gprint (GP_ERR, "USAGE: medimage (command)\n"); + gprint (GP_ERR, " medimage help : this listing\n"); + gprint (GP_ERR, " medimage list : list medimages\n"); + gprint (GP_ERR, " medimage add (medimage) (image) : add the given image to a medimage\n"); + gprint (GP_ERR, " medimage calc (medimage) (output) : calculate the median image\n"); + gprint (GP_ERR, " medimage delete (medimage) : delete named medimage\n"); + gprint (GP_ERR, " medimage rename (medimage) (new) : change medimage name to new name\n"); + + return FALSE; +} + +int medimage_command (int argc, char **argv) { + + int i, N, status; + + if (argc < 2) { + medimage_help(0,NULL); + return (FALSE); + } + + N = sizeof (medimage_commands) / sizeof (Command); + + /* find the medimage sub-command which matches */ + for (i = 0; i < N; i++) { + if (!strcmp (medimage_commands[i].name, argv[1])) { + status = (*medimage_commands[i].func) (argc - 1, argv + 1); + return (status); + } + } + + gprint (GP_ERR, "unknown medimage command %s\n", argv[1]); + return (FALSE); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/medimage_commands.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/medimage_commands.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/medimage_commands.c (revision 37067) @@ -0,0 +1,186 @@ +# include "data.h" + +int medimage_list (int argc, char **argv) { + if (argc != 1) { + gprint (GP_ERR, "USAGE: medimage list\n"); + return FALSE; + } + + ListMedImages(); + return TRUE; +} + +int medimage_add (int argc, char **argv) { + + Buffer *image; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: medimage add (name) (image)\n"); + gprint (GP_ERR, " add the given image to the set of images to be medianed\n"); + return FALSE; + } + + if ((image = SelectBuffer (argv[2], OLDBUFFER, TRUE)) == NULL) return (FALSE); + + MedImageType *median = FindMedImage (argv[1]); + if (!median) { + // create a new median with this name + median = CreateMedImage (argv[1], image->matrix.Naxis[0], image->matrix.Naxis[1]); + if (!median) { + gprint (GP_ERR, "failed to generate a new median image\n"); + return FALSE; + } + } + + if (median->Nx != image->matrix.Naxis[0]) { + gprint (GP_ERR, "image does not match medimage dimensions\n"); + return FALSE; + } + if (median->Ny != image->matrix.Naxis[1]) { + gprint (GP_ERR, "image does not match medimage dimensions\n"); + return FALSE; + } + + // new image should match existing medimage dimensions + + int Ninput = median->Ninput; + median->Ninput ++; + REALLOCATE (median->buffers, float *, median->Ninput); + + ALLOCATE (median->buffers[Ninput], float, median->Nx*median->Ny); + memcpy (median->buffers[Ninput], image->matrix.buffer, sizeof(float)*median->Nx*median->Ny); + + return TRUE; +} + +int medimage_calc (int argc, char **argv) { + + int ix, iy, n; + Buffer *output; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: medimage calc (name) (output)\n"); + gprint (GP_ERR, " calculate the median image for the median image set\n"); + return FALSE; + } + + MedImageType *median = FindMedImage (argv[1]); + if (!median) { + gprint (GP_ERR, "median image %s not found\n", argv[1]); + return FALSE; + } + + if ((output = SelectBuffer (argv[2], ANYBUFFER, TRUE)) == NULL) return (FALSE); + + int Ninput = median->Ninput; + int Nx = median->Nx; + int Ny = median->Ny; + + float *value = NULL; + ALLOCATE (value, float, Ninput); + + gfits_free_matrix (&output->matrix); + gfits_free_header (&output->header); + CreateBuffer (output, Nx, Ny, -32, 0.0, 1.0); + + float *outvalue = (float *) output->matrix.buffer; + + for (iy = 0; iy < Ny; iy++) { + for (ix = 0; ix < Nx; ix++) { + + int N = 0; + int Npix = ix + Nx*iy; + for (n = 0; n < Ninput; n++) { + float v = median->buffers[n][Npix]; + if (!isfinite(v)) continue; + value[N] = v; + N++; + } + if (N == 0) continue; + + fsort (value, N); + outvalue[Npix] = value[(int)(0.5*N)]; + } + } + + return TRUE; +} + +/* +int medimage_save (int argc, char **argv) { + + int N; + + int APPEND = FALSE; + if ((N = get_argument (argc, argv, "-append"))) { + APPEND = TRUE; + remove_argument (N, &argc, argv); + } + + if (argc != 3) { + gprint (GP_ERR, "USAGE: medimage save (name) (filename) [-append]\n"); + return FALSE; + } + + if (!SaveMedImage(argv[2], argv[1], APPEND)) { + gprint (GP_ERR, "failed to save medimage %s\n", argv[1]); + return (FALSE); + } + return TRUE; +} + +int medimage_load (int argc, char **argv) { + + if (argc != 3) { + gprint (GP_ERR, "USAGE: medimage load (name) (filename)\n"); + return FALSE; + } + + if (!LoadMedImage(argv[2], argv[1])) { + gprint (GP_ERR, "failed to load medimage %s\n", argv[1]); + return (FALSE); + } + return TRUE; +} +*/ + +int medimage_delete (int argc, char **argv) { + + int status; + MedImageType *medimage; + + if (argc != 2) { + gprint (GP_ERR, "USAGE: medimage delete (medimage)\n"); + return FALSE; + } + + medimage = FindMedImage (argv[1]); + if (medimage == NULL) { + gprint (GP_ERR, "medimage %s not found\n", argv[1]); + return FALSE; + } + + status = DeleteMedImage (medimage); + if (!status) abort (); + return TRUE; +} + +int medimage_rename (int argc, char **argv) { + + MedImageType *medimage; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: medimage rename (medimage) (newname)\n"); + return FALSE; + } + + medimage = FindMedImage (argv[1]); + if (medimage == NULL) { + gprint (GP_ERR, "medimage %s not found\n", argv[1]); + return FALSE; + } + + free (medimage->name); + medimage->name = strcreate (argv[2]); + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/print_vectors.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/print_vectors.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/print_vectors.c (revision 37067) @@ -0,0 +1,47 @@ +# include "data.h" + +int print_vectors (int argc, char **argv) { + + Vector **vec; + int i, j; + + if (argc < 2) { + gprint (GP_ERR, "USAGE: print_vectors (vector)[,vector,...]\n"); + return (FALSE); + } + + int Nvec = argc - 1; + ALLOCATE (vec, Vector *, Nvec); + for (i = 1; i < argc; i++) { + vec[i-1] = SelectVector (argv[i], OLDVECTOR, FALSE); + if (!vec[i-1]) { + gprint (GP_ERR, "unknown vector %s\n", argv[i]); + free (vec); + return FALSE; + } + } + + int MaxLen = 0; + for (i = 0; i < Nvec; i++) { + MaxLen = MAX (MaxLen, vec[i][0].Nelements); + } + + for (j = 0; j < MaxLen; j++) { + for (i = 0; i < Nvec; i++) { + if (j >= vec[i][0].Nelements) { + gprint (GP_LOG, "NaN "); + } else { + if (vec[i][0].type == OPIHI_FLT) { + gprint (GP_LOG, "%f ", vec[i][0].elements.Flt[j]); + } else { + gprint (GP_LOG, "%d ", vec[i][0].elements.Int[j]); + } + } + } + gprint (GP_LOG, "\n"); + } + free (vec); + + return (TRUE); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/read_vectors.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/read_vectors.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/read_vectors.c (revision 37067) @@ -3,4 +3,6 @@ FILE *f = (FILE *) NULL; char filename[2048]; + +void read_vectors_cleanup (); int datafile (int argc, char **argv) { @@ -24,14 +26,19 @@ enum {COLTYPE_NONE, COLTYPE_FLT, COLTYPE_INT, COLTYPE_TIME, COLTYPE_CHAR}; +static int Nvec = 0; +static Vector **vec = NULL; +static char **listname = NULL; +static int *col = NULL; +static int *coltype = NULL; +static char *buffer = NULL; + int read_vectors (int argc, char **argv) { int TimeFormat; time_t TimeReference; - int i, j, Nskip, Narg, Nvec, *col, IsCSV, VERBOSE; - int Nbytes, Nstart, NELEM, Nelem, nread, *coltype; + int i, j, Nskip, Narg, IsCSV, VERBOSE; + int Nbytes, Nstart, NELEM, Nelem, nread; char *colstr, *c0, *c1, *extname; - Vector **vec; - - char *buffer = NULL; + char varname[1024]; // used as a buffer for the names of string fields /* auto-sense table type */ @@ -81,7 +88,12 @@ Nvec = (argc - 1) / 2; + ALLOCATE (listname, char *, Nvec); ALLOCATE (vec, Vector *, Nvec); ALLOCATE (col, int, Nvec); ALLOCATE (coltype, int, Nvec); + for (i = 0; i < Nvec; i++) { + listname[i] = NULL; + vec[i] = NULL; + } for (i = 0; i < Nvec; i++) { @@ -108,9 +120,12 @@ } - if ((vec[i] = SelectVector (argv[2*i + 1], ANYVECTOR, TRUE)) == NULL) { - gprint (GP_ERR, "USAGE: read name N name N ...\n"); - free (vec); - free (col); - return (FALSE); + if (coltype[i] == COLTYPE_CHAR) { + listname[i] = strcreate (argv[2*i + 1]); + } else { + if ((vec[i] = SelectVector (argv[2*i + 1], ANYVECTOR, TRUE)) == NULL) { + gprint (GP_ERR, "USAGE: read name N name N ...\n"); + read_vectors_cleanup(); + return (FALSE); + } } @@ -137,6 +152,5 @@ bad_colname: gprint (GP_ERR, "USAGE: read name N name N ...\n"); - free (vec); - free (col); + read_vectors_cleanup(); return (FALSE); } @@ -146,9 +160,16 @@ NELEM = 1000; for (i = 0; i < Nvec; i++) { - if ((coltype[i] == COLTYPE_INT) || (coltype[i] == COLTYPE_CHAR)) { - ResetVector (vec[i], OPIHI_INT, NELEM); - } else { - // note that COLTYPE_TIME is a type of float - ResetVector (vec[i], OPIHI_FLT, NELEM); + switch (coltype[i]) { + case COLTYPE_INT: + ResetVector (vec[i], OPIHI_INT, NELEM); + break; + case COLTYPE_FLT: + case COLTYPE_TIME: + // note that COLTYPE_TIME is a type of float + ResetVector (vec[i], OPIHI_FLT, NELEM); + break; + case COLTYPE_CHAR: + default: + break; } } @@ -159,6 +180,5 @@ if (scan_line_maxlen (f, buffer, 0x10000) == EOF) { gprint (GP_ERR, "problem reading file %s\n", filename); - free (vec); - free (col); + read_vectors_cleanup(); return FALSE; } @@ -206,5 +226,4 @@ for (i = 0; i < Nvec; i++) { int ivalue; - char cvalue; double dvalue; time_t tvalue; @@ -217,7 +236,21 @@ break; case COLTYPE_CHAR: - readStatus = IsCSV ? charparse_csv (&cvalue, col[i], c0) : charparse (&cvalue, col[i], c0); - vec[i][0].elements.Int[Nelem] = readStatus ? cvalue : 0; - break; + { + // I need to get an isolated word in 'value' with the string value of this field + char *ptr = IsCSV ? ptrparse_csv (col[i], c0) : ptrparse (col[i], c0); + char *value = NULL; + if (IsCSV) { + char *end = parse_nextword_csv (ptr); + if (end) { + value = end ? strncreate (ptr, end - ptr) : strcreate (ptr); + } + } else { + value = thisword(ptr); + } + set_list_varname (varname, listname[i], Nelem, FALSE); + set_str_variable (varname, value); + free (value); + break; + } case COLTYPE_FLT: readStatus = IsCSV ? dparse_csv (&dvalue, col[i], c0) : dparse (&dvalue, col[i], c0); @@ -249,8 +282,15 @@ NELEM += 1000; for (i = 0; i < Nvec; i++) { - if (coltype[i] == COLTYPE_INT) { - REALLOCATE (vec[i][0].elements.Int, opihi_int, NELEM); - } else { - REALLOCATE (vec[i][0].elements.Flt, opihi_flt, NELEM); + switch (coltype[i]) { + case COLTYPE_INT: + ResetVector (vec[i], OPIHI_INT, NELEM); + break; + case COLTYPE_FLT: + case COLTYPE_TIME: + ResetVector (vec[i], OPIHI_FLT, NELEM); + break; + case COLTYPE_CHAR: + default: + break; } } @@ -259,22 +299,28 @@ } } + // set the final vector / list length for (i = 0; i < Nvec; i++) { - if (coltype[i] == COLTYPE_INT) { - REALLOCATE (vec[i][0].elements.Int, opihi_int, MAX (Nelem,1)); - } else { - REALLOCATE (vec[i][0].elements.Flt, opihi_flt, MAX (Nelem,1)); - } - vec[i][0].Nelements = Nelem; - } - - free (vec); - free (col); - if (buffer) free (buffer); + switch (coltype[i]) { + case COLTYPE_INT: + ResetVector (vec[i], OPIHI_INT, Nelem); + break; + case COLTYPE_FLT: + case COLTYPE_TIME: + ResetVector (vec[i], OPIHI_FLT, Nelem); + break; + case COLTYPE_CHAR: + sprintf (varname, "%s:n", listname[i]); + set_int_variable (varname, Nelem); + break; + default: + break; + } + } + read_vectors_cleanup(); return (TRUE); - } -# define ESCAPE(MSG) { \ - gprint (GP_ERR, "%s\n", MSG); \ +# define ESCAPE(...) { \ + gprint (GP_ERR, __VA_ARGS__); \ if (CCDKeyword != NULL) free (CCDKeyword); \ gfits_free_table (&table); \ @@ -285,12 +331,19 @@ off_t Nbytes; - int i, j, k, N, Nextend, Ny, Binary, vecType, padIfShort; + int i, j, N, Nextend, Ny, Binary, vecType, padIfShort; char type[16], ID[80], *CCDKeyword; FTable table; Header header; Vector **vec; + int FITS_TRANSPOSE; table.buffer = NULL; header.buffer = NULL; + + FITS_TRANSPOSE = FALSE; + if ((N = get_argument (argc, argv, "-transpose"))) { + remove_argument (N, &argc, argv); + FITS_TRANSPOSE = TRUE; + } CCDKeyword = NULL; @@ -321,7 +374,7 @@ // } - if (argc < 2) ESCAPE ("USAGE: read -fits extension [-extnum] [-keyword key] name name ..."); - - if (f == NULL) ESCAPE ("file not found"); + if (argc < 2) ESCAPE ("USAGE: read -fits extension [-extnum] [-keyword key] name name ...\n"); + + if (f == NULL) ESCAPE ("file not found\n"); fseeko (f, 0LL, SEEK_SET); table.header = &header; @@ -331,5 +384,5 @@ // first extension is PHU, cannot be a table. // Nextend counts from 0 for first extension - if (!gfits_load_header (f, &header)) ESCAPE ("error reading primary header for file"); + if (!gfits_load_header (f, &header)) ESCAPE ("error reading primary header for file\n"); Nbytes = gfits_data_size (&header); fseeko (f, Nbytes, SEEK_CUR); @@ -337,5 +390,5 @@ for (i = 0; i < Nextend; i++) { - if (!gfits_load_header (f, &header)) ESCAPE ("extension not found"); + if (!gfits_load_header (f, &header)) ESCAPE ("extension %d not found\n", i); Nbytes = gfits_data_size (&header); /* skip the prior data buffers */ @@ -343,6 +396,6 @@ gfits_free_header (&header); } - if (!gfits_load_header (f, &header)) ESCAPE ("error reading header for extension"); - if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension"); + if (!gfits_load_header (f, &header)) ESCAPE ("error reading header for extension %d\n", Nextend); + if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension %d\n", Nextend); } else { @@ -375,5 +428,5 @@ continue; } - if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension"); + if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension\n"); break; } @@ -384,5 +437,5 @@ gfits_scan (&header, "XTENSION", "%s", 1, type); if (strcmp (type, "BINTABLE") && strcmp (type, "TABLE")) { - ESCAPE ("specified extension is not a table\n"); + ESCAPE ("specified extension %s is not a table\n", type); } Binary = !strcmp (type, "BINTABLE"); @@ -410,62 +463,53 @@ } - // define the multifield vector names - ALLOCATE (vec, Vector *, Nval); - for (j = 0; j < Nval; j++) { - if (Nval == 1) - sprintf (name, "%s", argv[i]); - else - sprintf (name, "%s:%d", argv[i], j); - if ((vec[j] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) ESCAPE ("bad vector name"); - ResetVector (vec[j], vecType, Ny); - } - - if (!strcmp (type, "char")) { - char *Ptr = data; + if (!FITS_TRANSPOSE) { + // read string column into a list rather than a vector + if (!strcmp (type, "char")) { + char *fieldName = argv[i]; + char *Ptr = data; + char varname[1024]; // used as a buffer for the names of string fields + for (j = 0; j < Ny; j++) { + set_list_varname (varname, fieldName, j, FALSE); + char *value = strncreate (&Ptr[j*Nval], Nval); + // replace instances of $ with _ + char *p = strchr (value, '$'); + while (p) { + *p = '_'; + p = strchr (p, '$'); + } + set_str_variable (varname, value); + free (value); + } + sprintf (varname, "%s:n", fieldName); + set_int_variable (varname, Ny); + continue; + } + + // define the multifield vector names (Nval vectors x Ny elements) + ALLOCATE (vec, Vector *, Nval); + for (j = 0; j < Nval; j++) { + if (Nval == 1) + sprintf (name, "%s", argv[i]); + else + sprintf (name, "%s:%d", argv[i], j); + if ((vec[j] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) ESCAPE ("bad vector name"); + ResetVector (vec[j], vecType, Ny); + } + + if (!VectorAssignData (vec, type, data, Ny, Nval)) ESCAPE ("bad column type %s", type); + + } else { + // define the multifield vector names (Ny vectors x Nval elements) + ALLOCATE (vec, Vector *, Ny); for (j = 0; j < Ny; j++) { - for (k = 0; k < Nval; k++, Ptr++) { - vec[k][0].elements.Int[j] = *Ptr; - } - } - } - if (!strcmp (type, "short")) { - short *Ptr = data; - for (j = 0; j < Ny; j++) { - for (k = 0; k < Nval; k++, Ptr++) { - vec[k][0].elements.Int[j] = *Ptr; - } - } - } - if (!strcmp (type, "int")) { - int *Ptr = data; - for (j = 0; j < Ny; j++) { - for (k = 0; k < Nval; k++, Ptr++) { - vec[k][0].elements.Int[j] = *Ptr; - } - } - } - if (!strcmp (type, "int64_t")) { - int64_t *Ptr = data; - for (j = 0; j < Ny; j++) { - for (k = 0; k < Nval; k++, Ptr++) { - vec[k][0].elements.Int[j] = *Ptr; - } - } - } - if (!strcmp (type, "float")) { - float *Ptr = data; - for (j = 0; j < Ny; j++) { - for (k = 0; k < Nval; k++, Ptr++) { - vec[k][0].elements.Flt[j] = *Ptr; - } - } - } - if (!strcmp (type, "double")) { - double *Ptr = data; - for (j = 0; j < Ny; j++) { - for (k = 0; k < Nval; k++, Ptr++) { - vec[k][0].elements.Flt[j] = *Ptr; - } - } + if (Ny == 1) + sprintf (name, "%s", argv[i]); + else + sprintf (name, "%s:%d", argv[i], j); + if ((vec[j] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) ESCAPE ("bad vector name"); + ResetVector (vec[j], vecType, Nval); + } + + if (!VectorAssignDataTranspose (vec, type, data, Ny, Nval)) ESCAPE ("bad column type %s", type); } free (data); @@ -477,2 +521,18 @@ return (TRUE); } + +void read_vectors_cleanup () { + + int i; + + if (col) free (col); + if (coltype) free (coltype); + if (buffer) free (buffer); + if (listname) { + for (i = 0; i < Nvec; i++) { + if (listname[i]) free (listname[i]); + } + free (listname); + } + if (vec) free (vec); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/rebin.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/rebin.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/rebin.c (revision 37067) @@ -133,4 +133,5 @@ *Vout += *Vin; if (Normalize) {(*Vn) ++;} + // if ((i == 1) && (j == 1)) fprintf (stderr, "%d,%d : %d,%d : %f : %f : %d\n", i, j, x, y, *Vin, *Vout, *Vn); } if (Normalize) {Vn ++;} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/test/join.sh =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/test/join.sh (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/test/join.sh (revision 37067) @@ -0,0 +1,110 @@ + +list tests + test1 + memtest1 +end + +# Test if imhist works +macro test1 + + $PASS = 1 + + local i + + delete ID1 ID2 + + vlist -int ID1 1 2 3 4 5 6 + vlist val1 0.1 4.3 2.1 5.5 2.1 4.2 + + vlist -int ID2 5 3 1 6 + vlist val 0.3 2.3 1.1 2.5 + + join ID1 ID2 + +mana: for i 0 index1[] +>> echo index1[$i] index2[$i] +>> end +0 2 +2 1 +4 0 +5 3 +mana: join ID1 ID2 -outer +mana: vectors + N name size + 0 ID1 6 (INT) + 1 val1 6 (FLT) + 2 ID2 4 (INT) + 3 val 4 (FLT) + 4 index1 6 (INT) + 5 index2 4 (INT) +mana: for i 0 index1[] +>> echo index1[$i] +>> end +2 +-1 +1 +-1 +0 +3 +mana: echo ID1[2] +3 +mana: echo ID1[0] ID2[2] +1 1 +mana: for i 0 index1[] +>> if (index1[$i] == -1) continue +>> $N = index1[$i] +>> echo $i index1[$i] ID1[$i] ID2[$N] +>> end +0 2 1 1 +2 1 3 3 +4 0 5 5 +5 3 6 6 +mana: for i 0 index2[] +>> if (index2[$i] == -1) continue +>> $N = index2[$i] +>> echo $i index2[$i] ID2[$i] ID1[$N] +>> end +0 4 5 5 +1 2 3 3 +2 0 1 1 +3 5 6 6 +mana: + + # if ((xvec[1024] != 17) || (yvec[1024] != 100)) + # $PASS = 0 + # echo "Value mismatch: xvec[1024] yvec[1024] (should be 17,100)" + # end + # + # imhist -q buff xvec yvec -region 40 0 25 10 -range 0 10 + # + # if ((xvec[1024] != 10) || (yvec[1024] != 100)) + # $PASS = 0 + # echo "Value mismatch: xvec[1024] yvec[1024] (should be 10,100)" + # end + +end + + +# Memory test +macro memtest1 + + local i + + list word -x "ps -p $PID -o rss" + $startmem = $word:1 + + for i 0 1000 + imhist -q buff xvec yvec -region 40 0 25 10 -range 0 10 + end + + list word -x "ps -p $PID -o rss" + $endmem = $word:1 + + $PASS = 1 + + if ($endmem - $startmem > 10) + $PASS = 0 + echo "growth: {$endmem-$startmem}" + echo "kB/loop: {($endmem-$startmem)/1000}" + end +end Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/test/medimage.sh =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/test/medimage.sh (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/test/medimage.sh (revision 37067) @@ -0,0 +1,11 @@ + +macro go + mcreate a 30 30 + for i 0 40 + set a$i = zero(a) + $i + end + + for i 0 40 + medimage add t1 a$i + end +end Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vellipse.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vellipse.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vellipse.c (revision 37067) @@ -228,4 +228,5 @@ */ +// XXX NOTE that PHI is defined with the wrong sign, should fix this... opihi_flt fellipseOD (opihi_flt alpha, opihi_flt *par, int Npar, opihi_flt *dpar) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vgauss.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vgauss.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vgauss.c (revision 37067) @@ -48,4 +48,7 @@ if ((ovec = SelectVector (argv[4], ANYVECTOR, TRUE)) == NULL) return (FALSE); + CastVector (xvec, OPIHI_FLT); + CastVector (yvec, OPIHI_FLT); + int Nsvec = strlen(argv[3]); @@ -69,6 +72,4 @@ } - CastVector (xvec, OPIHI_FLT); - CastVector (yvec, OPIHI_FLT); CastVector (svec, OPIHI_FLT); // XXX Cast is failing. Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vlist.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vlist.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vlist.c (revision 37067) @@ -0,0 +1,63 @@ +# include "data.h" + +int vlist (int argc, char **argv) { + + int i, N; + Vector *vec; + + int APPEND = FALSE; + if ((N = get_argument (argc, argv, "-append"))) { + APPEND = TRUE; + remove_argument (N, &argc, argv); + } + + int INT = FALSE; + if ((N = get_argument (argc, argv, "-int"))) { + if (APPEND) { + gprint (GP_ERR, " ERROR : cannot mix -append and -int\n"); + return (FALSE); + } + INT = TRUE; + remove_argument (N, &argc, argv); + } + + if (argc < 3) { + gprint (GP_ERR, "USAGE: vlist [-append] [-int] vector value value ...\n"); + gprint (GP_ERR, " -int : resulting vector is integer type (values are truncated to integer)\n"); + gprint (GP_ERR, " -append : append value to end of vector (otherwise deleted)\n"); + return (FALSE); + } + + if ((vec = SelectVector (argv[1], ANYVECTOR, TRUE)) == NULL) return (FALSE); + + // for append, type comes from input vector + if (APPEND) { + INT = (vec[0].type == OPIHI_INT); + } + + int Nitem = argc - 2; + int Noffset = APPEND ? vec[0].Nelements : 0; + vec[0].Nelements = APPEND ? vec[0].Nelements + Nitem : Nitem; + + if (INT) { + vec[0].type = OPIHI_INT; + REALLOCATE (vec[0].elements.Int, opihi_int, vec[0].Nelements); + for (i = 0; i < Nitem; i++) { + vec[0].elements.Int[i + Noffset] = atoi (argv[i+2]); + } + } else { + vec[0].type = OPIHI_FLT; + REALLOCATE (vec[0].elements.Flt, opihi_flt, vec[0].Nelements); + for (i = 0; i < Nitem; i++) { + vec[0].elements.Flt[i + Noffset] = atof (argv[i+2]); + } + } + + return (TRUE); +} + +// vlist name 0 1 2 3 +// argc = 6 +// Nitem = 4 +// Noffset = 0 +// Int[0,1,2,3] = argv[2,3,4,5] Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/Makefile (revision 37067) @@ -25,6 +25,19 @@ $(SRC)/dvo_host_utils.$(ARCH).o \ $(SRC)/region_list.$(ARCH).o \ -$(SRC)/find_matches.$(ARCH).o \ -$(SRC)/photometry.$(ARCH).o +$(SRC)/photcode_ops.$(ARCH).o \ +$(SRC)/find_matches.$(ARCH).o + +# $(SRC)/photometry.$(ARCH).o + +broken = \ +$(SRC)/calextract.$(ARCH).o \ +$(SRC)/calmextract.$(ARCH).o \ +$(SRC)/ccd.$(ARCH).o \ +$(SRC)/cmd.$(ARCH).o \ +$(SRC)/dmagaves.$(ARCH).o \ +$(SRC)/dmagmeas.$(ARCH).o \ +$(SRC)/dmags.$(ARCH).o \ +$(SRC)/ddmags.$(ARCH).o \ +$(SRC)/fitcolors.$(ARCH).o cmds = \ @@ -32,20 +45,13 @@ $(SRC)/avmatch.$(ARCH).o \ $(SRC)/badimages.$(ARCH).o \ -$(SRC)/calextract.$(ARCH).o \ -$(SRC)/calmextract.$(ARCH).o \ $(SRC)/catdir.$(ARCH).o \ -$(SRC)/ccd.$(ARCH).o \ $(SRC)/cmatch.$(ARCH).o \ -$(SRC)/cmd.$(ARCH).o \ $(SRC)/cmpload.$(ARCH).o \ $(SRC)/cmpread.$(ARCH).o \ -$(SRC)/ddmags.$(ARCH).o \ +$(SRC)/coordimage.$(ARCH).o \ +$(SRC)/coordmosaic.$(ARCH).o \ $(SRC)/detrend.$(ARCH).o \ -$(SRC)/dmagaves.$(ARCH).o \ -$(SRC)/dmagmeas.$(ARCH).o \ -$(SRC)/dmags.$(ARCH).o \ $(SRC)/dmt.$(ARCH).o \ $(SRC)/elixir.$(ARCH).o \ -$(SRC)/fitcolors.$(ARCH).o \ $(SRC)/fitsed.$(ARCH).o \ $(SRC)/gcat.$(ARCH).o \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/avextract.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/avextract.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/avextract.c (revision 37067) @@ -166,6 +166,5 @@ needMeasures = FALSE; for (i = 0; !needMeasures && (i < Nfields); i++) { - if (fields[i].magMode == MAG_NONE) continue; - if (fields[i].photcode == NULL) continue; // assert this? + if (fields[i].photcode == NULL) continue; // non-measure fields do not have a photcode if (fields[i].photcode[0].type == PHOT_REF) needMeasures = TRUE; if (fields[i].photcode[0].type == PHOT_DEP) needMeasures = TRUE; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/avmatch.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/avmatch.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/avmatch.c (revision 37067) @@ -70,40 +70,6 @@ dbExtractAveragesInit (); - // this does all the work of re-packaging the command, calling it on the remote machines, then loading in the results RAvec = NULL; DECvec = NULL; - if (PARALLEL && !HOST_ID) { - if (!CoordsFile) { - // get vectors corresponding to coordinates of interest - if ((RAvec = SelectVector (argv[1], ANYVECTOR, TRUE)) == NULL) goto help; - if ((DECvec = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) goto help; - - ALLOCATE (vec, Vector *, 2); - vec[0] = RAvec; - vec[1] = DECvec; - - CoordsFile = abspath("coords.fits", 1024); - int status = WriteVectorTableFITS (CoordsFile, "COORDS", vec, 2, FALSE, NULL); - if (!status) goto escape; - } - - char *targv1 = argv[1]; - char *targv2 = argv[2]; - argv[1] = strcreate ("-coords"); - argv[2] = strcreate (CoordsFile); - free (CoordsFile); - - // I need to pass the RA & DEC vectors to the remote clients... - int status = HostTableParallelOps (skylist, argc, argv, RESULT_FILE, TRUE, RAvec->Nelements, VERBOSE); - if (vec) free (vec); - - free (argv[1]); - free (argv[2]); - argv[1] = targv1; - argv[2] = targv2; - - return status; - } - // get vectors corresponding to coordinates of interest if (CoordsFile) { @@ -120,4 +86,55 @@ remove_argument (1, &argc, argv); } + + /* load regions which contain all supplied RA,DEC coordinates */ + if ((skylist = SelectRegionsByCoordVectors (RAvec, DECvec)) == NULL) goto escape; + + // this does all the work of re-packaging the command, calling it on the remote machines, then loading in the results + if (PARALLEL && !HOST_ID) { + + // We need to copy the args to a temp array and modify them so that we send the + // correct set to the remote client. The args list looks like this: + // if (!CoordsFile) : avmatch (RADIUS) field, ... [we removed RA & DEC above] + // if ( CoordsFile) : avmatch (RADIUS) field, ... [because we stripped off the -coords filename elements] + + // allocate the temp array and copy all but (RA) (DEC) + int targc = 0; + char **targv = NULL; + ALLOCATE (targv, char *, argc + 2); + for (i = 0; i < argc; i++) { + targv[targc] = strcreate (argv[i]); + targc ++; + } + + // if not specified, create the coords.fits input file + // NOTE: RAvec, DECvec were set above + if (!CoordsFile) { + ALLOCATE (vec, Vector *, 2); + vec[0] = RAvec; + vec[1] = DECvec; + + CoordsFile = abspath("coords.fits", 1024); + int status = WriteVectorTableFITS (CoordsFile, "COORDS", vec, 2, FALSE, NULL); + if (!status) goto escape; + } + + // add the coords file to the args list + targv[targc+0] = strcreate ("-coords"); + targv[targc+1] = CoordsFile; // this gets freed with targv + targc += 2; + + // I need to pass the RA & DEC vectors to the remote clients... + int status = HostTableParallelOps (skylist, targc, targv, RESULT_FILE, TRUE, RAvec->Nelements, VERBOSE); + if (vec) free (vec); + + // free up targv + for (i = 0; i < targc; i++) { + free (targv[i]); + } + free (targv); + + return status; + } + RADIUS = atof (argv[1]); remove_argument (1, &argc, argv); @@ -135,12 +152,8 @@ int needMeasures = FALSE; for (i = 0; !needMeasures && (i < Nfields); i++) { - if (fields[i].magMode == MAG_NONE) continue; if (fields[i].photcode == NULL) continue; // assert this? if (fields[i].photcode[0].type == PHOT_REF) needMeasures = TRUE; if (fields[i].photcode[0].type == PHOT_DEP) needMeasures = TRUE; } - - /* load regions which contain all supplied RA,DEC coordinates */ - if ((skylist = SelectRegionsByCoordVectors (RAvec, DECvec)) == NULL) goto escape; /* create output storage vectors */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/coordimage.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/coordimage.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/coordimage.c (revision 37067) @@ -0,0 +1,143 @@ +# include "dvoshell.h" + +int coordimage (int argc, char **argv) { + + int N; + off_t i, j, Nimage, *subset, Nsubset; + time_t tzero; + double trange; + Buffer *bufX, *bufY; + SkyRegionSelection *selection; + Image *image; + + if (!InitPhotcodes ()) return (FALSE); + + // parse skyregion options + if ((selection = SetRegionSelection (&argc, argv)) == NULL) { + gprint (GP_ERR, "invalid sky region selection\n"); + return FALSE; + } + + int TimeSelect = FALSE; + if ((N = get_argument (argc, argv, "-time"))) { + remove_argument (N, &argc, argv); + if (!ohana_str_to_time (argv[N], &tzero)) { + gprint (GP_ERR, "syntax error\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + if (!ohana_str_to_dtime (argv[N], &trange)) { + gprint (GP_ERR, "syntax error\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + TimeSelect = TRUE; + gprint (GP_ERR, "plotting in range %ds - %ds (%f seconds)\n", (int)tzero, (int)(tzero + trange), trange); + } + + PhotCode *Photcode = NULL; + if ((N = get_argument (argc, argv, "-photcode"))) { + remove_argument (N, &argc, argv); + Photcode = GetPhotcodebyName (argv[N]); + if (Photcode == NULL) { + gprint (GP_ERR, "photcode not found in photcode table\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-Nphotcode"))) { + remove_argument (N, &argc, argv); + Photcode = GetPhotcodebyCode (atoi(argv[N])); + if (Photcode == NULL) { + gprint (GP_ERR, "photcode not found in photcode table\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + } + + char *Name = NULL; + if ((N = get_argument (argc, argv, "-name"))) { + remove_argument (N, &argc, argv); + Name = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + + int chipID = -1; + if ((N = get_argument (argc, argv, "-chip"))) { + remove_argument (N, &argc, argv); + chipID = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + + if (argc != 5) goto syntax; + + if ((bufX = SelectBuffer (argv[1], ANYBUFFER, TRUE)) == NULL) goto escape; + if ((bufY = SelectBuffer (argv[2], ANYBUFFER, TRUE)) == NULL) goto escape; + int Nx = atoi (argv[3]); + int Ny = atoi (argv[4]); + + gfits_free_matrix (&bufX[0].matrix); + gfits_free_header (&bufX[0].header); + CreateBuffer (bufX, Nx, Ny, -32, 0.0, 1.0); // initialized to 0.0 here + strcpy (bufX[0].file, "(empty)"); + + gfits_free_matrix (&bufY[0].matrix); + gfits_free_header (&bufY[0].header); + CreateBuffer (bufY, Nx, Ny, -32, 0.0, 1.0); // initialized to 0.0 here + strcpy (bufY[0].file, "(empty)"); + + if ((image = LoadImagesDVO (&Nimage)) == NULL) return (FALSE); + image_subset (image, Nimage, &subset, &Nsubset, selection, tzero, trange, TimeSelect); + + float Nsum = 0.0; + float *vX = (float *) bufX[0].matrix.buffer; + float *vY = (float *) bufY[0].matrix.buffer; + + for (j = 0; j < Nsubset; j++) { + i = subset[j]; + if (Name && (strstr (image[i].name, Name) == (char *) NULL)) continue; + if (Photcode) { + if (Photcode[0].type == PHOT_DEP) { + if (Photcode[0].code != image[i].photcode) continue; + } else { + if (Photcode[0].code != GetPhotcodeEquivCodebyCode (image[i].photcode)) continue; + } + } + if (chipID > -1) { + if (image[i].ccdnum != chipID) continue; + } + + float dX = image[i].NX / (float) Nx; + float dY = image[i].NY / (float) Ny; + + Coords coords = image[i].coords; + coords.Npolyterms = 0; + + int ix, iy; + for (iy = 0; iy < Ny; iy++) { + double fy = iy * dY; // coordinate in full image + for (ix = 0; ix < Nx; ix++) { + double fx = ix * dX; // coordinate in full image + + double Lo, Lm, dL; + double Mo, Mm, dM; + + XY_to_LM (&Lo, &Mo, fx, fy, &coords); + XY_to_LM (&Lm, &Mm, fx, fy, &image[i].coords); + dL = Lo - Lm; + dM = Mo - Mm; + + vX[ix + iy*Nx] += dL; + vY[ix + iy*Nx] += dM; + } + } + Nsum ++; + } + fprintf (stderr, "Nsum: %f\n", Nsum); + return TRUE; + + syntax: + gprint (GP_ERR, "USAGE: coordimage buffX buffY Nx Ny\n"); + escape: + return (FALSE); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/coordmosaic.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/coordmosaic.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/coordmosaic.c (revision 37067) @@ -0,0 +1,524 @@ +# include "dvoshell.h" + +int coordmosaic (int argc, char **argv) { + + int N, ix, iy; + off_t i, j, nt, Nimage, *subset, Nsubset; + time_t tzero; + double trange; + Buffer *bufX, *bufY; + SkyRegionSelection *selection; + Image *image; + + if (!InitPhotcodes ()) return (FALSE); + + // parse skyregion options + if ((selection = SetRegionSelection (&argc, argv)) == NULL) { + gprint (GP_ERR, "invalid sky region selection\n"); + return FALSE; + } + + int TimeSelect = FALSE; + if ((N = get_argument (argc, argv, "-time"))) { + remove_argument (N, &argc, argv); + if (!ohana_str_to_time (argv[N], &tzero)) { + gprint (GP_ERR, "syntax error\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + if (!ohana_str_to_dtime (argv[N], &trange)) { + gprint (GP_ERR, "syntax error\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + TimeSelect = TRUE; + gprint (GP_ERR, "plotting in range %ds - %ds (%f seconds)\n", (int)tzero, (int)(tzero + trange), trange); + } + + /* + PhotCode *Photcode = NULL; + if ((N = get_argument (argc, argv, "-photcode"))) { + remove_argument (N, &argc, argv); + Photcode = GetPhotcodebyName (argv[N]); + if (Photcode == NULL) { + gprint (GP_ERR, "photcode not found in photcode table\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-Nphotcode"))) { + remove_argument (N, &argc, argv); + Photcode = GetPhotcodebyCode (atoi(argv[N])); + if (Photcode == NULL) { + gprint (GP_ERR, "photcode not found in photcode table\n"); + return (FALSE); + } + remove_argument (N, &argc, argv); + } + */ + + char *Name = NULL; + if ((N = get_argument (argc, argv, "-name"))) { + remove_argument (N, &argc, argv); + Name = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + + /* + int chipID = -1; + if ((N = get_argument (argc, argv, "-chip"))) { + remove_argument (N, &argc, argv); + chipID = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + */ + + // save the image plate scales + Vector *cd1v = NULL, *cd2v = NULL; + if ((cd1v = SelectVector ("cd1", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((cd2v = SelectVector ("cd2", ANYVECTOR, TRUE)) == NULL) return (FALSE); + + if (argc != 5) goto syntax; + + if ((bufX = SelectBuffer (argv[1], ANYBUFFER, TRUE)) == NULL) goto escape; + if ((bufY = SelectBuffer (argv[2], ANYBUFFER, TRUE)) == NULL) goto escape; + int Nx = atoi (argv[3]); + int Ny = atoi (argv[4]); + + gfits_free_matrix (&bufX[0].matrix); + gfits_free_header (&bufX[0].header); + CreateBuffer (bufX, Nx, Ny, -32, 0.0, 1.0); // initialized to 0.0 here + strcpy (bufX[0].file, "(empty)"); + + gfits_free_matrix (&bufY[0].matrix); + gfits_free_header (&bufY[0].header); + CreateBuffer (bufY, Nx, Ny, -32, 0.0, 1.0); // initialized to 0.0 here + strcpy (bufY[0].file, "(empty)"); + + if ((image = LoadImagesDVO (&Nimage)) == NULL) return (FALSE); + image_subset (image, Nimage, &subset, &Nsubset, selection, tzero, trange, TimeSelect); + + float *vX = (float *) bufX[0].matrix.buffer; + float *vY = (float *) bufY[0].matrix.buffer; + + int Nsum = 0; + int NSUM = 1000; + opihi_flt *cd1 = NULL; + opihi_flt *cd2 = NULL; + ALLOCATE (cd1, opihi_flt, NSUM); + ALLOCATE (cd2, opihi_flt, NSUM); + + int NX = 0; + int NY = 0; + float dX = NAN; + float dY = NAN; + + // only select the DIS (mosaic) images + for (j = 0; j < Nsubset; j++) { + i = subset[j]; + if (Name && (strstr (image[i].name, Name) == (char *) NULL)) continue; + + if (strcmp (&image[i].coords.ctype[4], "-DIS")) continue; + + if (!isfinite(dX)) { + NX = image[i].NX; + NY = image[i].NY; + dX = NX / (float) Nx; + dY = NY / (float) Ny; + } else { + if ((NX != image[i].NX) || (NY != image[i].NY)) { + // fprintf (stderr, "mosaic size mismatch? %d,%d vs %d,%d\n", NX, NY, image[i].NX, image[i].NY); + } + } + + // DIS image pixels range fom -0.5*NX to +0.5*NX + // output pixels range from 0 to Nx + // dX = NX / Nx + // fx = ix * dX - 0.5*NX + + Coords coords = image[i].coords; + // coords.Npolyterms = 0; + + // the coords have an arbitrary rotation. I want derotate: + double T = 1.0 / (image[i].coords.pc1_1*image[i].coords.pc2_2 - image[i].coords.pc2_1*image[i].coords.pc1_2); + double A10 = +image[i].coords.pc2_2 * T; + double A01 = -image[i].coords.pc1_2 * T; + double B10 = -image[i].coords.pc2_1 * T; + double B01 = +image[i].coords.pc1_1 * T; + + coords.pc1_1 = image[i].coords.pc1_1 * A10 + image[i].coords.pc2_1 * A01; + coords.pc1_2 = image[i].coords.pc1_2 * A10 + image[i].coords.pc2_2 * A01; + coords.pc2_1 = image[i].coords.pc1_1 * B10 + image[i].coords.pc2_1 * B01; + coords.pc2_2 = image[i].coords.pc1_2 * B10 + image[i].coords.pc2_2 * B01; + + if (coords.Npolyterms > 1) { + for (nt = 0; nt < 3; nt++) { + coords.polyterms[nt][0] = image[i].coords.polyterms[nt][0] * A10 + image[i].coords.polyterms[nt][1] * A01; + coords.polyterms[nt][1] = image[i].coords.polyterms[nt][0] * B10 + image[i].coords.polyterms[nt][1] * B01; + } + } + + if (coords.Npolyterms > 2) { + for (nt = 3; nt < 7; nt++) { + coords.polyterms[nt][0] = image[i].coords.polyterms[nt][0] * A10 + image[i].coords.polyterms[nt][1] * A01; + coords.polyterms[nt][1] = image[i].coords.polyterms[nt][0] * B10 + image[i].coords.polyterms[nt][1] * B01; + } + } + + Coords linear = coords; + linear.Npolyterms = 0; + + for (iy = 0; iy < Ny; iy++) { + double fy = iy * dY - 0.5*NY; // coordinate in full image + for (ix = 0; ix < Nx; ix++) { + double fx = ix * dX - 0.5*NX; // coordinate in full image + + double Lo, Lm; //, dL; + double Mo, Mm; //, dM; + + XY_to_LM (&Lo, &Mo, fx, fy, &coords); + XY_to_LM (&Lm, &Mm, fx, fy, &linear); + // dL = Lo - Lm; + // dM = Mo - Mm; + + // vX[ix + iy*Nx] += dL; + // vY[ix + iy*Nx] += dM; + vX[ix + iy*Nx] += Lo; + vY[ix + iy*Nx] += Mo; + } + } + + cd1[Nsum] = image[i].coords.cdelt1; + cd2[Nsum] = image[i].coords.cdelt2; + Nsum ++; + if (Nsum == NSUM) { + NSUM += 1000; + REALLOCATE (cd1, opihi_flt, NSUM); + REALLOCATE (cd2, opihi_flt, NSUM); + } + } + + free (cd1v->elements.Flt); cd1v->elements.Flt = cd1; cd1v->Nelements = Nsum; + free (cd2v->elements.Flt); cd2v->elements.Flt = cd2; cd2v->Nelements = Nsum; + + for (iy = 0; iy < Ny; iy++) { + for (ix = 0; ix < Nx; ix++) { + vX[ix + iy*Nx] /= (float) Nsum; + vY[ix + iy*Nx] /= (float) Nsum; + } + } + + gfits_modify (&bufX->header, "MOS_NX", "%d", 1, NX); + gfits_modify (&bufX->header, "MOS_NY", "%d", 1, NY); + gfits_modify (&bufX->header, "MOS_DX", "%f", 1, dX); + gfits_modify (&bufX->header, "MOS_DY", "%f", 1, dY); + gfits_modify (&bufX->header, "MOS_NSUM", "%d", 1, Nsum); + + fprintf (stderr, "Nsum: %d\n", Nsum); + return TRUE; + + syntax: + gprint (GP_ERR, "USAGE: coordmosaic buffX buffY Nx Ny\n"); + escape: + return (FALSE); +} + +# define ESCAPE(MSG) { \ + if (src) fclose (src); \ + if (tgt) fclose (tgt); \ + fprintf (stderr, "%s\n", MSG); return FALSE; } + +# define GET_COLUMN(OUT,NAME,TYPE) \ + TYPE *OUT = gfits_get_bintable_column_data (&header, &table, NAME, type, &Nrow, &Ncol); \ + myAssert (!strcmp(type, #TYPE), "wrong column type"); + +int psastro_model (int argc, char **argv) { + + // I need to write out the full psastro input model based on my new fits + + // astrometry model consists of an empty PHU + 4 extensions: + // CHIPS : + // FP + // TP + // SKY + + int Ncol; + off_t Nrow, Nout; + char type[16]; + + FTable table; + Header header; + table.header = &header; + + FILE *src = NULL, *tgt = NULL; + + if (argc != 3) { + fprintf (stderr, "USAGE: psastro_model (src) (tgt)\n"); + return FALSE; + } + + // I am going to read in the tables from one file and save them (with updates) in another + src = fopen (argv[1], "r"); + if (!src) ESCAPE ("failed to open source file"); + + tgt = fopen (argv[2], "w"); + if (!tgt) ESCAPE ("failed to open output file"); + + // read the PHU + if (!gfits_load_header (src, &header)) ESCAPE ("error loading PHU"); + int Nbytes = gfits_data_size (&header); + if (Nbytes) ESCAPE ("non-zero PHU matrix??"); + + // save the PHU + if (!gfits_save_header (tgt, &header)) ESCAPE ("error saving PHU"); + gfits_free_header (&header); + + { + // read the CHIPS + if (!gfits_load_header (src, &header)) ESCAPE ("error loading CHIPS header"); + if (!gfits_fread_ftable_data (src, &table, FALSE)) ESCAPE ("error reading table for CHIPS"); + + // these set the value of Nrow + GET_COLUMN (SEGMENT , "SEGMENT", char ); int Nsegment = Ncol; + GET_COLUMN (PARENT , "PARENT" , char ); + GET_COLUMN (MINX , "MINX" , float); + GET_COLUMN (MAXX , "MAXX" , float); + GET_COLUMN (MINY , "MINY" , float); + GET_COLUMN (MAXY , "MAXY" , float); + GET_COLUMN (XORDER , "XORDER" , int ); + GET_COLUMN (YORDER , "YORDER" , int ); + GET_COLUMN (NXORDER , "NXORDER", int ); + GET_COLUMN (NYORDER , "NYORDER", int ); + GET_COLUMN (POLY_X , "POLY_X" , float); + GET_COLUMN (POLY_Y , "POLY_Y" , float); + GET_COLUMN (ERROR_X , "ERROR_X", float); + GET_COLUMN (ERROR_Y , "ERROR_Y", float); + GET_COLUMN (MASK_X , "MASK_X" , char ); + GET_COLUMN (MASK_Y , "MASK_Y" , char ); + + // I am keeping the same number of entries, but changing the values of + // POLY_X, POLY_Y + int i; + for (i = 0; i < Nrow; i++) { + // validate that NX, NY orders are 1 + assert (NXORDER[i] == 1); + assert (NYORDER[i] == 1); + + char name[16], segment[16]; + + int found, xmask, ymask; + + memset (segment, 0, 16); memcpy (segment, &SEGMENT[i*Nsegment], 4); + snprintf (name, 16, "%s_L_CX%dY%d", segment, XORDER[i], YORDER[i]); + double xvalue = get_double_variable (name, &found); + xmask = !found; + + memset (segment, 0, 16); memcpy (segment, &SEGMENT[i*Nsegment], 4); + snprintf (name, 16, "%s_M_CX%dY%d", segment, XORDER[i], YORDER[i]); + double yvalue = get_double_variable (name, &found); + ymask = !found; + + POLY_X[i] = xvalue; + POLY_Y[i] = yvalue; + ERROR_X[i] = 0.0; + ERROR_Y[i] = 0.0; + MASK_X[i] = xmask; + MASK_Y[i] = ymask; + } + + // reset the table size to 0 rows -- this forces the data array to be reallocate by gfits_set_bintable_column + gfits_modify (&header, "NAXIS2", "%d", 1, 0); + + gfits_set_bintable_column (&header, &table, "SEGMENT", SEGMENT , Nrow); + gfits_set_bintable_column (&header, &table, "PARENT" , PARENT , Nrow); + gfits_set_bintable_column (&header, &table, "MINX" , MINX , Nrow); + gfits_set_bintable_column (&header, &table, "MAXX" , MAXX , Nrow); + gfits_set_bintable_column (&header, &table, "MINY" , MINY , Nrow); + gfits_set_bintable_column (&header, &table, "MAXY" , MAXY , Nrow); + gfits_set_bintable_column (&header, &table, "XORDER" , XORDER , Nrow); + gfits_set_bintable_column (&header, &table, "YORDER" , YORDER , Nrow); + gfits_set_bintable_column (&header, &table, "NXORDER", NXORDER , Nrow); + gfits_set_bintable_column (&header, &table, "NYORDER", NYORDER , Nrow); + gfits_set_bintable_column (&header, &table, "POLY_X" , POLY_X , Nrow); + gfits_set_bintable_column (&header, &table, "POLY_Y" , POLY_Y , Nrow); + gfits_set_bintable_column (&header, &table, "ERROR_X", ERROR_X , Nrow); + gfits_set_bintable_column (&header, &table, "ERROR_Y", ERROR_Y , Nrow); + gfits_set_bintable_column (&header, &table, "MASK_X" , MASK_X , Nrow); + gfits_set_bintable_column (&header, &table, "MASK_Y" , MASK_Y , Nrow); + + free (SEGMENT ); + free (PARENT ); + free (MINX ); + free (MAXX ); + free (MINY ); + free (MAXY ); + free (XORDER ); + free (YORDER ); + free (NXORDER ); + free (NYORDER ); + free (POLY_X ); + free (POLY_Y ); + free (ERROR_X ); + free (ERROR_Y ); + free (MASK_X ); + free (MASK_Y ); + + // save the CHIPS + gfits_fwrite_Theader (tgt, &header); + gfits_fwrite_table (tgt, &table); + gfits_free_header (&header); + gfits_free_table (&table); + } + + { + // read the FP + if (!gfits_load_header (src, &header)) ESCAPE ("error loading FP header"); + if (!gfits_fread_ftable_data (src, &table, FALSE)) ESCAPE ("error reading table for FP"); + + // these set the value of Nrow + GET_COLUMN (SEGMENT , "SEGMENT", char ); int Nsegment = Ncol; + GET_COLUMN (PARENT , "PARENT" , char ); int Nparent = Ncol; + GET_COLUMN (MINX , "MINX" , float); + GET_COLUMN (MAXX , "MAXX" , float); + GET_COLUMN (MINY , "MINY" , float); + GET_COLUMN (MAXY , "MAXY" , float); + GET_COLUMN (XORDER , "XORDER" , int ); + GET_COLUMN (YORDER , "YORDER" , int ); + GET_COLUMN (NXORDER , "NXORDER", int ); + GET_COLUMN (NYORDER , "NYORDER", int ); + GET_COLUMN (POLY_X , "POLY_X" , float); + GET_COLUMN (POLY_Y , "POLY_Y" , float); + GET_COLUMN (ERROR_X , "ERROR_X", float); + GET_COLUMN (ERROR_Y , "ERROR_Y", float); + GET_COLUMN (MASK_X , "MASK_X" , char ); + GET_COLUMN (MASK_Y , "MASK_Y" , char ); + + Nout = 16; + + REALLOCATE (SEGMENT , char , Nout*Nsegment); + REALLOCATE (PARENT , char , Nout*Nparent); + REALLOCATE (MINX , float, Nout); + REALLOCATE (MAXX , float, Nout); + REALLOCATE (MINY , float, Nout); + REALLOCATE (MAXY , float, Nout); + REALLOCATE (XORDER , int , Nout); + REALLOCATE (YORDER , int , Nout); + REALLOCATE (NXORDER , int , Nout); + REALLOCATE (NYORDER , int , Nout); + REALLOCATE (POLY_X , float, Nout); + REALLOCATE (POLY_Y , float, Nout); + REALLOCATE (ERROR_X , float, Nout); + REALLOCATE (ERROR_Y , float, Nout); + REALLOCATE (MASK_X , char , Nout); + REALLOCATE (MASK_Y , char , Nout); + + float minX = MINX[0]; + float maxX = MAXX[0]; + float minY = MINY[0]; + float maxY = MAXY[0]; + + int ix, iy, nrow; + nrow = 0; + for (ix = 0; ix < 4; ix++) { + for (iy = 0; iy < 4; iy++) { + memcpy (&SEGMENT[nrow*Nsegment], "FOCAL_PLANE", strlen("FOCAL_PLANE")); + memcpy (&PARENT[nrow*Nparent], "TANGENT_PLANE", strlen("TANGENT_PLANE")); + MINX[nrow] = minX; + MAXX[nrow] = maxX; + MINY[nrow] = minY; + MAXY[nrow] = maxY; + XORDER[nrow] = ix; + YORDER[nrow] = iy; + NXORDER[nrow] = 3; + NYORDER[nrow] = 3; + + char name[16]; + + int found, xmask, ymask; + snprintf (name, 16, "L_X%dY%d", ix, iy); + double xvalue = get_double_variable (name, &found); + xmask = !found; + + snprintf (name, 16, "M_X%dY%d", ix, iy); + double yvalue = get_double_variable (name, &found); + ymask = !found; + + POLY_X[nrow] = xvalue; + POLY_Y[nrow] = yvalue; + ERROR_X[nrow] = 0.0; + ERROR_Y[nrow] = 0.0; + MASK_X[nrow] = xmask; + MASK_Y[nrow] = ymask; + nrow ++; + } + } + + // reset the table size to 0 rows -- this forces the data array to be reallocate by gfits_set_bintable_column + gfits_modify (&header, "NAXIS2", "%d", 1, 0); + + gfits_set_bintable_column (&header, &table, "SEGMENT", SEGMENT , Nout); + gfits_set_bintable_column (&header, &table, "PARENT" , PARENT , Nout); + gfits_set_bintable_column (&header, &table, "MINX" , MINX , Nout); + gfits_set_bintable_column (&header, &table, "MAXX" , MAXX , Nout); + gfits_set_bintable_column (&header, &table, "MINY" , MINY , Nout); + gfits_set_bintable_column (&header, &table, "MAXY" , MAXY , Nout); + gfits_set_bintable_column (&header, &table, "XORDER" , XORDER , Nout); + gfits_set_bintable_column (&header, &table, "YORDER" , YORDER , Nout); + gfits_set_bintable_column (&header, &table, "NXORDER", NXORDER , Nout); + gfits_set_bintable_column (&header, &table, "NYORDER", NYORDER , Nout); + gfits_set_bintable_column (&header, &table, "POLY_X" , POLY_X , Nout); + gfits_set_bintable_column (&header, &table, "POLY_Y" , POLY_Y , Nout); + gfits_set_bintable_column (&header, &table, "ERROR_X", ERROR_X , Nout); + gfits_set_bintable_column (&header, &table, "ERROR_Y", ERROR_Y , Nout); + gfits_set_bintable_column (&header, &table, "MASK_X" , MASK_X , Nout); + gfits_set_bintable_column (&header, &table, "MASK_Y" , MASK_Y , Nout); + + free (SEGMENT ); + free (PARENT ); + free (MINX ); + free (MAXX ); + free (MINY ); + free (MAXY ); + free (XORDER ); + free (YORDER ); + free (NXORDER ); + free (NYORDER ); + free (POLY_X ); + free (POLY_Y ); + free (ERROR_X ); + free (ERROR_Y ); + free (MASK_X ); + free (MASK_Y ); + + // save the FP + gfits_fwrite_Theader (tgt, &header); + gfits_fwrite_table (tgt, &table); + gfits_free_header (&header); + gfits_free_table (&table); + } + + // read the TP + if (!gfits_load_header (src, &header)) ESCAPE ("error loading TP header"); + if (!gfits_fread_ftable_data (src, &table, FALSE)) ESCAPE ("error reading table for TP"); + + // save the TP + gfits_fwrite_Theader (tgt, &header); + gfits_fwrite_table (tgt, &table); + gfits_free_header (&header); + gfits_free_table (&table); + + // read the SKY + if (!gfits_load_header (src, &header)) ESCAPE ("error loading SKY header"); + if (!gfits_fread_ftable_data (src, &table, FALSE)) ESCAPE ("error reading table for SKY"); + + // save the SKY + gfits_fwrite_Theader (tgt, &header); + gfits_fwrite_table (tgt, &table); + gfits_free_header (&header); + gfits_free_table (&table); + + fclose (tgt); + fclose (src); + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/dvo_client.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/dvo_client.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/dvo_client.c (revision 37067) @@ -90,4 +90,10 @@ } + // these are set in 'startup.c' for readline-based programs + set_variable ("PID", getpid()); + set_str_variable ("KAPA", "kapa"); + set_int_variable ("UNSIGN", 0); + gfits_set_unsign_mode (FALSE); + return; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/find_matches.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/find_matches.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/find_matches.c (revision 37067) @@ -50,5 +50,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 1; - strcpy (tcoords.ctype, "RA---ARC"); + strcpy (tcoords.ctype, "DEC--ARC"); // this region includes a boundary layer of size RADIUS Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/fitsed.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/fitsed.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/fitsed.c (revision 37067) @@ -83,5 +83,5 @@ /* interpret command-line options */ if ((selection = SetRegionSelection (&argc, argv)) == NULL) goto escape; - if (!SetPhotSelections (&argc, argv, 4)) goto usage; + // if (!SetPhotSelections (&argc, argv, 4)) goto usage; PLOT = FALSE; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/gimages.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/gimages.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/gimages.c (revision 37067) @@ -136,5 +136,5 @@ local.pc2_1 = local.pc1_2 = 0.0; local.Npolyterms = 1; - strcpy (local.ctype, "RA---TAN"); + strcpy (local.ctype, "DEC--TAN"); if (typehash == DistortImage) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/gstar.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/gstar.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/gstar.c (revision 37067) @@ -15,6 +15,6 @@ GSTAR_UCDIST, GSTAR_AVE_AP_MAG, - GSTAR_AVE_MAG_20, - GSTAR_AVE_MAG_80, + GSTAR_AVE_MAG_MIN, + GSTAR_AVE_MAG_MAX, GSTAR_AVE_KRON_MAG, GSTAR_AVE_KRON_MAG_ERR, @@ -307,10 +307,10 @@ gprint (GP_LOG, "\n"); - /* M_20 */ - for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_20); - gprint (GP_LOG, "\n"); - - /* M_80 */ - for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_80);; + /* Mmin */ + for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MIN); + gprint (GP_LOG, "\n"); + + /* Mmax */ + for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MAX);; gprint (GP_LOG, "\n"); @@ -374,10 +374,13 @@ int Nv = index[j]; - Mcat = PhotCat (&catalog.measure[Nv]); + Mcat = PhotCat (&catalog.measure[Nv], MAG_CLASS_PSF); if (INST) { - Mrel = PhotInst (&catalog.measure[Nv]); + Mrel = PhotInst (&catalog.measure[Nv], MAG_CLASS_PSF); } else { - Mrel = PhotRel (&catalog.measure[Nv], &catalog.average[k], &catalog.secfilt[k*Nsecfilt]); + Mrel = PhotRel (&catalog.measure[Nv], &catalog.average[k], &catalog.secfilt[k*Nsecfilt], MAG_CLASS_PSF); } + + float dRoff = dvoOffsetR(&catalog.measure[Nv], &catalog.average[k]); + float dDoff = dvoOffsetD(&catalog.measure[Nv], &catalog.average[k]); if (GetMeasures && !QUIET) { @@ -387,6 +390,7 @@ gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].dM); gprint (GP_LOG, "%20s ", date); - gprint (GP_LOG, "%7.4f ", catalog.measure[Nv].dR); - gprint (GP_LOG, "%7.4f ", catalog.measure[Nv].dD); + + gprint (GP_LOG, "%7.4f ", dRoff); + gprint (GP_LOG, "%7.4f ", dDoff); gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].photFlags); gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].dbFlags); @@ -447,6 +451,6 @@ vec3[0].elements.Flt[N] = catalog.measure[Nv].airmass; vec4[0].elements.Flt[N] = catalog.measure[Nv].photcode; - vec5[0].elements.Flt[N] = catalog.measure[Nv].dR; - vec6[0].elements.Flt[N] = catalog.measure[Nv].dD; + vec5[0].elements.Flt[N] = dRoff; + vec6[0].elements.Flt[N] = dDoff; N ++; if (N == NPTS - 1) { @@ -561,7 +565,7 @@ case GSTAR_AVE_MAG_CHISQ: /* average mag chisq */ if (seq == -1) { - print_short (NAN_S_SHORT, NAN_S_SHORT); - } else { - print_short (pow (10.0, 0.01*secfilt[seq].Xm), secfilt[seq].Xm); + print_double (NAN); + } else { + print_double (secfilt[seq].Mchisq); } break; @@ -596,17 +600,17 @@ break; - case GSTAR_AVE_MAG_20: /* average ap mags */ - if (seq == -1) { - print_double (NAN); - } else { - print_short (0.001*secfilt[seq].M_20, secfilt[seq].M_20); - } - break; - - case GSTAR_AVE_MAG_80: /* average ap mags */ - if (seq == -1) { - print_double (NAN); - } else { - print_short (0.001*secfilt[seq].M_80, secfilt[seq].M_80); + case GSTAR_AVE_MAG_MIN: /* average ap mags */ + if (seq == -1) { + print_double (NAN); + } else { + print_double (secfilt[seq].Mmin); + } + break; + + case GSTAR_AVE_MAG_MAX: /* average ap mags */ + if (seq == -1) { + print_double (NAN); + } else { + print_double (secfilt[seq].Mmax); } break; @@ -632,5 +636,5 @@ print_double (NAN); } else { - print_double_exp (secfilt[seq].FluxPSF); + print_double_exp (secfilt[seq].FpsfStk); } break; @@ -640,5 +644,5 @@ print_double (NAN); } else { - print_double_exp (secfilt[seq].dFluxPSF); + print_double_exp (secfilt[seq].dFpsfStk); } break; @@ -648,5 +652,5 @@ print_double (NAN); } else { - print_double_exp (secfilt[seq].FluxKron); + print_double_exp (secfilt[seq].FkronStk); } break; @@ -656,8 +660,8 @@ print_double (NAN); } else { - print_double_exp (secfilt[seq].dFluxKron); - } - break; - - } -} + print_double_exp (secfilt[seq].dFkronStk); + } + break; + + } +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/hosts.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/hosts.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/hosts.c (revision 37067) @@ -3,5 +3,8 @@ # define DVO_MAX_PATH 1024 -enum {TEMP_NONE, TEMP_DVO_RESULTS, TEMP_DVO_LOG, TEMP_RELASTRO_CATALOG, TEMP_RELPHOT_CATALOG, TEMP_RELPHOT_LOG, TEMP_DVOPSPS_DET, TEMP_FIXSTKIDS_RESULTS}; +enum {TEMP_NONE, TEMP_DVO_RESULTS, TEMP_DVO_LOG, + TEMP_RELASTRO_CATALOG, TEMP_RELPHOT_CATALOG, TEMP_RELPHOT_LOG, TEMP_DVOPSPS_DET, TEMP_FIXSTKIDS_RESULTS, + TEMP_RELASTRO_CAT_FULL, TEMP_RELPHOT_CAT_FULL, TEMP_CHECKASTRO_CAT_FULL, +}; // functions to manage the remote hosts @@ -12,5 +15,5 @@ gprint (GP_ERR, " commands:\n"); gprint (GP_ERR, " purge-temp : delete all tempfiles for this shell\n"); - gprint (GP_ERR, " : [-old-pid] [-all-pid] [-v] [-verbose] [-commit] [-type type]\n"); + gprint (GP_ERR, " : [-old-pid] [-all-pid] [-v] [-verbose] [-commit] [-type type] [-age hours]\n"); gprint (GP_ERR, " get-results : determine name of RESULTS file\n"); return FALSE; @@ -33,4 +36,15 @@ } + struct timeval now; + gettimeofday (&now, NULL); + + float AGE = 0; + int NOW = now.tv_sec; + if ((N = get_argument (argc, argv, "-age"))) { + remove_argument (N, &argc, argv); + AGE = atof(argv[N]); + remove_argument (N, &argc, argv); + } + int VERBOSE = FALSE; if ((N = get_argument (argc, argv, "-v"))) { @@ -60,6 +74,9 @@ if (!strcasecmp(argv[N], "dvo.results")) TEMP_TYPE = TEMP_DVO_RESULTS; if (!strcasecmp(argv[N], "dvo.log")) TEMP_TYPE = TEMP_DVO_LOG; - if (!strcasecmp(argv[N], "relastro.catalog")) TEMP_TYPE = TEMP_RELASTRO_CATALOG; + if (!strcasecmp(argv[N], "relastro.catalog")) TEMP_TYPE = TEMP_RELASTRO_CATALOG; if (!strcasecmp(argv[N], "relphot.catalog")) TEMP_TYPE = TEMP_RELPHOT_CATALOG; + if (!strcasecmp(argv[N], "relastro.catfull")) TEMP_TYPE = TEMP_RELASTRO_CAT_FULL; + if (!strcasecmp(argv[N], "checkastro.catfull"))TEMP_TYPE = TEMP_CHECKASTRO_CAT_FULL; + if (!strcasecmp(argv[N], "relphot.catfull")) TEMP_TYPE = TEMP_RELPHOT_CAT_FULL; if (!strcasecmp(argv[N], "relphot.log")) TEMP_TYPE = TEMP_RELPHOT_LOG; if (!strcasecmp(argv[N], "dvopsps.det")) TEMP_TYPE = TEMP_DVOPSPS_DET; @@ -67,5 +84,5 @@ if (TEMP_TYPE == TEMP_NONE) { gprint (GP_ERR, "USAGE: hosts purge-temp [-type (type)]\n"); - gprint (GP_ERR, " allowed types dvo.results, dvo.log, relphot.results, relphot.log]\n"); + gprint (GP_ERR, " allowed types dvo.results, dvo.log, relphot.catalog, relphot.log, relphot.catfull, relastro.catalog, relastro.catfull, checkastro.catfull, dvopsps.det, fixstkids.results]\n"); return FALSE; } @@ -107,4 +124,7 @@ if (TEMP_TYPE == TEMP_RELPHOT_CATALOG) snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.subset.dat", table->hosts[i].pathname); if (TEMP_TYPE == TEMP_RELPHOT_LOG) snprintf (name, DVO_MAX_PATH, "%s/log.rlpc.*", table->hosts[i].pathname); + if (TEMP_TYPE == TEMP_RELASTRO_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/relastro.catalog.?????.?????.dat", table->hosts[i].pathname); + if (TEMP_TYPE == TEMP_CHECKASTRO_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/checkastro.catalog.?????.?????.dat", table->hosts[i].pathname); + if (TEMP_TYPE == TEMP_RELPHOT_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.?????.?????.dat", table->hosts[i].pathname); if (TEMP_TYPE == TEMP_DVOPSPS_DET) snprintf (name, DVO_MAX_PATH, "%s/dvopsps.*.det.dat", table->hosts[i].pathname); if (TEMP_TYPE == TEMP_FIXSTKIDS_RESULTS) snprintf (name, DVO_MAX_PATH, "%s/fixstkids.results.*.dat", table->hosts[i].pathname); @@ -115,4 +135,7 @@ if (TEMP_TYPE == TEMP_RELPHOT_CATALOG) snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.subset.dat", table->hosts[i].pathname); if (TEMP_TYPE == TEMP_RELPHOT_LOG) snprintf (name, DVO_MAX_PATH, "%s/log.rlpc.*", table->hosts[i].pathname); + if (TEMP_TYPE == TEMP_RELASTRO_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/relastro.catalog.%05d.?????.dat", table->hosts[i].pathname, PID); + if (TEMP_TYPE == TEMP_CHECKASTRO_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/checkastro.catalog.%05d.?????.dat", table->hosts[i].pathname, PID); + if (TEMP_TYPE == TEMP_RELPHOT_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.%05d.?????.dat", table->hosts[i].pathname, PID); if (TEMP_TYPE == TEMP_DVOPSPS_DET) snprintf (name, DVO_MAX_PATH, "%s/dvopsps.%05d.*.det.dat", table->hosts[i].pathname, PID); if (TEMP_TYPE == TEMP_FIXSTKIDS_RESULTS) snprintf (name, DVO_MAX_PATH, "%s/fixstkids.results.%05d.*.dat", table->hosts[i].pathname, PID); @@ -121,5 +144,14 @@ glob (name, 0, NULL, &pglob); int j; + struct stat filestats; for (j = 0; j < pglob.gl_pathc; j++) { + if (AGE > 0) { + if (stat(pglob.gl_pathv[j], &filestats)) { + gprint (GP_ERR, "failed to get stats for %s\n", pglob.gl_pathv[j]); + continue; + } + float myAge = (NOW - filestats.st_mtime) / 3600.0; + if (myAge < AGE) continue; + } if (VERBOSE) gprint (GP_ERR, "unlink %s\n", pglob.gl_pathv[j]); if (!DRYRUN) unlink (pglob.gl_pathv[j]); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/imdata.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/imdata.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/imdata.c (revision 37067) @@ -3,5 +3,5 @@ int imdata (int argc, char **argv) { - off_t i, j, k, n, I; + off_t i, j, k, I; int N, NPTS, found, mode, TimeSelect, TimeFormat; off_t Nregions, NREGIONS; @@ -152,6 +152,5 @@ for (i = 0; i < catalog.Nmeasure; i++) { if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue; - n = catalog.measure[i].averef; - vec[0].elements.Flt[N] = catalog.average[n].R - catalog.measure[i].dR / 3600.0; + vec[0].elements.Flt[N] = catalog.measure[i].R; N++; CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000); @@ -161,6 +160,5 @@ for (i = 0; i < catalog.Nmeasure; i++) { if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue; - n = catalog.measure[i].averef; - vec[0].elements.Flt[N] = catalog.average[n].D - catalog.measure[i].dD / 3600.0; + vec[0].elements.Flt[N] = catalog.measure[i].D; N++; CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000); @@ -194,5 +192,5 @@ for (i = 0; i < catalog.Nmeasure; i++) { if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue; - n = catalog.measure[i].averef; + //n = catalog.measure[i].averef; // vec[0].elements.Flt[N] = catalog.average[n].M; N++; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/imextract.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/imextract.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/imextract.c (revision 37067) @@ -185,5 +185,5 @@ gprint (GP_ERR, " Mcal : photometry calibration (mags)\n"); gprint (GP_ERR, " dMcal : photometry calibration error (mags)\n"); - gprint (GP_ERR, " Xm : chisq of photometry calibration\n"); + gprint (GP_ERR, " Mchisq : chisq of photometry calibration\n"); gprint (GP_ERR, " photcode : numeric photcode value for image\n"); gprint (GP_ERR, " exptime : exposure duration (seconds)\n"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/init.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/init.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/init.c (revision 37067) @@ -13,4 +13,7 @@ int cmpload PROTO((int, char **)); int cmpread PROTO((int, char **)); +int coordimage PROTO((int, char **)); +int coordmosaic PROTO((int, char **)); +int psastro_model PROTO((int, char **)); int ddmags PROTO((int, char **)); int detrend PROTO((int, char **)); @@ -63,20 +66,23 @@ {1, "avmatch", avmatch, "extract average data values matched to RA,DEC points"}, {1, "badimages", badimages, "look for images with anomalous astrometry"}, - {1, "calextract", calextract, "extract photometry calibration"}, - {1, "calmextract", calmextract, "extract photometry calibration"}, +// {1, "calextract", calextract, "extract photometry calibration"}, +// {1, "calmextract", calmextract, "extract photometry calibration"}, {1, "catdir", catdir_define,"re-define CATDIR"}, - {1, "ccd", ccd, "plot color-color diagram"}, +// {1, "ccd", ccd, "plot color-color diagram"}, {1, "cmatch", cmatch, "match two catalogs"}, - {1, "cmd", cmd, "plot cmd of stars in current region"}, +// {1, "cmd", cmd, "plot cmd of stars in current region"}, {1, "cmpload", cmpload, "load cmp file into ?"}, {1, "cmpread", cmpread, "read data from cmp format files"}, - {1, "ddmags", ddmags, "plot magnitude differences"}, + {1, "coordimage", coordimage, "generate a map of the transformation residuals"}, + {1, "coordmosaic", coordmosaic, "generate a map of the distortion"}, + {1, "psastro_model", psastro_model, "save psastro-format astrometry model"}, +// {1, "ddmags", ddmags, "plot magnitude differences"}, {1, "detrend", detrend, "extract from detrend database?"}, - {1, "dmagaves", dmagaves, "foo"}, - {1, "dmagmeas", dmagmeas, "foo"}, - {1, "dmags", dmags, "plot differential magnitudes between filters"}, +// {1, "dmagaves", dmagaves, "foo"}, +// {1, "dmagmeas", dmagmeas, "foo"}, +// {1, "dmags", dmags, "plot differential magnitudes between filters"}, {1, "dmt", dmt, "plot mag scatter"}, {1, "elixir", elixir, "talk to elixir"}, - {1, "fitcolors", fitcolors, "fit chip-to-chip color terms"}, +// {1, "fitcolors", fitcolors, "fit chip-to-chip color terms"}, {1, "fitsed", fitsed, "fit stellar SEDs to objects"}, {1, "gcat", gcat, "get catalog at location"}, Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/lcurve.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/lcurve.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/lcurve.c (revision 37067) @@ -129,5 +129,5 @@ if (ErrorBars) dYvec.elements.Flt[N] = catalog.measure[m].dM; Xvec.elements.Flt[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat); - Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m]); + Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m], MAG_CLASS_PSF); /**** need to use PhotRel optionally here ****/ N++; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/lightcurve.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/lightcurve.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/lightcurve.c (revision 37067) @@ -121,7 +121,7 @@ dmvec[0].elements.Flt[N] = catalog.measure[m].dM; if (RELPHOT) { - mvec[0].elements.Flt[N] = PhotCat (&catalog.measure[m]); + mvec[0].elements.Flt[N] = PhotCat (&catalog.measure[m], MAG_CLASS_PSF); } else { - mvec[0].elements.Flt[N] = PhotRel (&catalog.measure[m], &catalog.average[k], &catalog.secfilt[k*Nsecfilt]); + mvec[0].elements.Flt[N] = PhotRel (&catalog.measure[m], &catalog.average[k], &catalog.secfilt[k*Nsecfilt], MAG_CLASS_PSF); } N++; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/photcode_ops.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/photcode_ops.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/photcode_ops.c (revision 37067) @@ -0,0 +1,35 @@ +# include "dvoshell.h" + +/* (re)load photcodes from photcode table */ +int InitPhotcodes () { + + double ZERO_POINT; + char MasterPhotcodeFile[256]; + char CatdirPhotcodeFile[256]; + char *catdir; + + if (VarConfig ("ZERO_PT", "%lf", &ZERO_POINT) == (char *) NULL) { + gprint (GP_ERR, "ZERO_PT undefined in config\n"); + return (FALSE); + } + SetZeroPoint (ZERO_POINT); + + catdir = GetCATDIR(); + if (catdir == NULL) { + CatdirPhotcodeFile[0] = 0; + } else { + sprintf (CatdirPhotcodeFile, "%s/Photcodes.dat", catdir); + } + + if (VarConfig ("PHOTCODE_FILE", "%s", MasterPhotcodeFile) == (char *) NULL) { + gprint (GP_ERR, "PHOTCODE_FILE undefined in config\n"); + return (FALSE); + } + + // XXX now that DVO does not allow write access, we can drop the MasterPhotcodeFile + if (!LoadPhotcodes (CatdirPhotcodeFile, MasterPhotcodeFile, FALSE)) { + gprint (GP_ERR, "error loading photcode table %s or master file %s\n", CatdirPhotcodeFile, MasterPhotcodeFile); + return (FALSE); + } + return (TRUE); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/photometry.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/photometry.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/photometry.c (revision 37067) @@ -41,4 +41,5 @@ } +# if (0) /* selection criteria */ /* selections based on Measure quantities */ @@ -78,5 +79,7 @@ static time_t TimeReference; static int TimeFormat; - +# endif + +# if (0) int GetTimeSelection (time_t *tz, time_t *te) { *tz = tzero; @@ -298,39 +301,7 @@ return; } - -/* (re)load photcodes from photcode table */ -int InitPhotcodes () { - - double ZERO_POINT; - char MasterPhotcodeFile[256]; - char CatdirPhotcodeFile[256]; - char *catdir; - - if (VarConfig ("ZERO_PT", "%lf", &ZERO_POINT) == (char *) NULL) { - gprint (GP_ERR, "ZERO_PT undefined in config\n"); - return (FALSE); - } - SetZeroPoint (ZERO_POINT); - - catdir = GetCATDIR(); - if (catdir == NULL) { - CatdirPhotcodeFile[0] = 0; - } else { - sprintf (CatdirPhotcodeFile, "%s/Photcodes.dat", catdir); - } - - if (VarConfig ("PHOTCODE_FILE", "%s", MasterPhotcodeFile) == (char *) NULL) { - gprint (GP_ERR, "PHOTCODE_FILE undefined in config\n"); - return (FALSE); - } - - // XXX now that DVO does not allow write access, we can drop the MasterPhotcodeFile - if (!LoadPhotcodes (CatdirPhotcodeFile, MasterPhotcodeFile, FALSE)) { - gprint (GP_ERR, "error loading photcode table %s or master file %s\n", CatdirPhotcodeFile, MasterPhotcodeFile); - return (FALSE); - } - return (TRUE); -} - +# endif + +# if (0) int ListPhotSelections () { @@ -662,5 +633,5 @@ break; case AVE_dMAG: - value = PhotdM (code, average, secfilt); + value = PhotAveErr (code, average, secfilt); break; case AVE_Xm: @@ -865,5 +836,5 @@ /* for ErrSelect, check average errors */ if (ErrSelect) { - dM = PhotdM (code, average, secfilt); + dM = PhotAveErr (code, average, secfilt); if (dM > ErrValue) return (FALSE); } @@ -1121,5 +1092,7 @@ return (list); } - +# endif + +# if (0) double GetMeasure (int param, Average *average, Measure *measure, double mag) { @@ -1135,8 +1108,8 @@ break; case MEAS_RA: /* OK */ - value = average[0].R - measure[0].dR / 3600.0; + value = measure[0].R; break; case MEAS_DEC: /* OK */ - value = average[0].D - measure[0].dD / 3600.0; + value = measure[0].D; break; case MEAS_DOPHOT: /* OK */ @@ -1156,8 +1129,8 @@ break; case MEAS_RA_OFFSET: /* OK */ - value = measure[0].dR; + value = dvoOffsetR(measure, average); break; case MEAS_DEC_OFFSET: /* OK */ - value = measure[0].dD; + value = dvoOffsetD(measure, average); break; case MEAS_FWHM: /* OK */ @@ -1172,6 +1145,6 @@ value = measure[0].Xccd; # else - ra = average[0].R - measure[0].dR / 3600.0; - dec = average[0].D - measure[0].dD / 3600.0; + ra = measure[0].R; + dec = measure[0].D; image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID); if (image == NULL) break; @@ -1185,6 +1158,6 @@ value = measure[0].Yccd; # else - ra = average[0].R - measure[0].dR / 3600.0; - dec = average[0].D - measure[0].dD / 3600.0; + ra = measure[0].R; + dec = measure[0].D; image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID); if (image == NULL) break; @@ -1195,6 +1168,6 @@ # if 0 case MEAS_XMOSAIC: /* OK */ - ra = average[0].R - measure[0].dR / 3600.0; - dec = average[0].D - measure[0].dD / 3600.0; + ra = measure[0].R; + dec = measure[0].D; mosaic = MatchMosaic (measure[0].t, measure[0].photcode); // XXX not used anymore if (mosaic == NULL) break; @@ -1203,6 +1176,6 @@ break; case MEAS_YMOSAIC: /* OK */ - ra = average[0].R - measure[0].dR / 3600.0; - dec = average[0].D - measure[0].dD / 3600.0; + ra = measure[0].R; + dec = measure[0].D; mosaic = MatchMosaic (measure[0].t, measure[0].photcode); // XXX not used anymore if (mosaic == NULL) break; @@ -1214,4 +1187,5 @@ return (value); } +# endif /** the mosaic entries do not use the registered mosaic found Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/pmeasure.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/pmeasure.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/pmeasure.c (revision 37067) @@ -203,15 +203,15 @@ if (TimeSelect && (catalog.measure[m+k].t > tzero + trange)) continue; if ((PhotcodeClip != -1) && (catalog.measure[m+k].photcode != PhotcodeClip)) continue; - mag = PhotCat (&catalog.measure[m+k]); + mag = PhotCat (&catalog.measure[m+k], MAG_CLASS_PSF); Zvec[Npts] = MIN (1.0, MAX (0.01, (mag - Mz) / Mr)); if (LimExclude && (Zvec[Npts] > 0.99)) continue; if (Zvec[Npts] < 0.011) continue; - R = catalog.average[i].R - catalog.measure[m+k].dR/3600.0; - D = catalog.average[i].D - catalog.measure[m+k].dD/3600.0; + R = catalog.measure[m+k].R; + D = catalog.measure[m+k].D; // XXX drop this check if ((R < Rmin) || (R > Rmax) || (D < -90.0) || (D > 90.0)) { char *date; date = ohana_sec_to_date (catalog.measure[m+k].t); - gprint (GP_LOG, "out: %f, %f : %s : (%f, %f) + (%f, %f)\n", R, D, date, catalog.average[i].R, catalog.average[i].D, catalog.measure[m+k].dR/3600.0, catalog.measure[m+k].dD/3600.0); + gprint (GP_LOG, "out: %f, %f : %s : (%f, %f) + (%f, %f)\n", R, D, date, catalog.average[i].R, catalog.average[i].D, catalog.measure[m+k].R, catalog.measure[m+k].D); free (date); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/showtile.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/showtile.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/showtile.c (revision 37067) @@ -34,5 +34,5 @@ coords.pc1_2 = coords.pc2_1 = 0.0; coords.Npolyterms = 0; - strcpy (coords.ctype, "RA---TAN"); + strcpy (coords.ctype, "DEC--TAN"); /* fill in top-left region */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/simage.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/simage.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/simage.c (revision 37067) @@ -43,6 +43,6 @@ /* get astrometry information */ strcpy (coords.ctype, "NONE"); - gfits_scan (&header, "CTYPE1", "%s", 1, coords.ctype); - if (strcmp (coords.ctype, "RA---PLY")) { + gfits_scan (&header, "CTYPE2", "%s", 1, coords.ctype); + if (strcmp (coords.ctype, "DEC--PLY")) { gprint (GP_ERR, "ERROR: wrong astrometric info in header\n"); return (FALSE); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/subpix.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/subpix.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/subpix.c (revision 37067) @@ -138,5 +138,5 @@ for (j = 0; j < Nmeasure; j++) { if (measure[j].t == Timage) { - Mabs = PhotCat (&measure[j]); + Mabs = PhotCat (&measure[j], MAG_CLASS_PSF); RD_to_XY (&X, &Y, Ra, Dec, &image[I].coords); t = TimeValue (measure[j].t, TimeReference, TimeFormat); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/data.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/data.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/data.h (revision 37067) @@ -33,4 +33,21 @@ char **pageIDs; } Book; + +// the interpolating spline has valu +typedef struct { + int Nknots; + opihi_flt *xk; + opihi_flt *yk; + opihi_flt *y2; + char *name; +} Spline; + +typedef struct { + char *name; + int Ninput; + int Nx; + int Ny; + float **buffers; +} MedImageType; void InitData (void); @@ -144,5 +161,5 @@ /* starfuncs.c */ -double get_aperture_stats (Matrix *matrix, int X, int Y, int Npix, int Nborder, double max); +double get_aperture_stats (Matrix *matrix, int X, int Y, int Npix, int Nborder, double max, int VERBOSE); int set_rough_radii (double Ra, double Ri, double Ro); int get_rough_star (float *data, int Nx, int Ny, int x, int y, opihi_flt *xc, opihi_flt *yc, opihi_flt *sx, opihi_flt *sy, opihi_flt *sxy, opihi_flt *zs, opihi_flt *zp, opihi_flt *sk); @@ -170,13 +187,4 @@ void FreeQueues (void); void FreeBooks (void); - -// the interpolating spline has valu -typedef struct { - int Nknots; - opihi_flt *xk; - opihi_flt *yk; - opihi_flt *y2; - char *name; -} Spline; /* in SplineOps.c */ @@ -207,3 +215,12 @@ double hermitian_10(double x); +/* in MedImageOps.c */ +void InitMedImages (); +void FreeMedImages (); +void FreeMedImage (MedImageType *medimage); +MedImageType *FindMedImage (char *name); +MedImageType *CreateMedImage (char *name, int Nx, int Ny); +int DeleteMedImage (MedImageType *medimage); +void ListMedImages (); + # endif Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/dvomath.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/dvomath.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/dvomath.h (revision 37067) @@ -55,7 +55,35 @@ } Buffer; +typedef enum { + ST_NONE, + ST_LEFT, + ST_RIGHT, + ST_COMMA, + ST_TRINARY, + ST_OR, + ST_AND, + ST_LOGIC, + ST_BITWISE, + ST_ADD, + ST_TIMES, + ST_POWER, + ST_UNARY, + ST_BINARY, + + ST_VALUE, + ST_SCALAR_INT, + ST_SCALAR_FLT, + ST_VECTOR, + ST_VECTOR_TMP, + ST_MATRIX, + ST_MATRIX_TMP, + + ST_STRING, + ST_STRING_TMP, +} StackVarType; + typedef struct { /* math stack structure */ char *name; - char type; + StackVarType type; Buffer *buffer; Vector *vector; @@ -77,5 +105,9 @@ void delete_stack PROTO((StackVar *stack, int Nstack)); void clear_stack PROTO((StackVar *stack)); -void assign_stack PROTO((StackVar *stack, char *name, int type)); +void assign_stack PROTO((StackVar *stack, char *name, StackVarType type)); + +int SSS_trinary PROTO((StackVar *OUT, StackVar *V1, StackVar *V2, StackVar *V3, char *op)); +int VVV_trinary PROTO((StackVar *OUT, StackVar *V1, StackVar *V2, StackVar *V3, char *op)); +int MMM_trinary PROTO((StackVar *OUT, StackVar *V1, StackVar *V2, StackVar *V3, char *op)); int VV_binary PROTO((StackVar *OUT, StackVar *V1, StackVar *V2, char *op)); @@ -138,4 +170,7 @@ Vector **ReadVectorTableFITS PROTO((char *filename, char *extname, int *Nvec)); +int VectorAssignData PROTO((Vector **vec, char *type, void *data, int Nrows, int Nval)); +int VectorAssignDataTranspose PROTO((Vector **vec, char *type, void *data, int Nrows, int Nval)); + /* buffer handling */ Buffer *InitBuffer PROTO((void)); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/dvoshell.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/dvoshell.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/dvoshell.h (revision 37067) @@ -90,13 +90,4 @@ int wordhash PROTO((char *word)); -int GetMagMode PROTO((char *string)); -PhotCode *ParsePhotcodeField PROTO((char *field, int *mode, int def)); -int ParseMeasureField PROTO((dbField *field, char *fieldName)); -int ParseAverageField PROTO((dbField *field, char *fieldName)); -int ParseImageField PROTO((dbField *field, char *fieldName)); - -dbValue dbExtractMeasures PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field)); -dbValue dbExtractImages PROTO((Image *image, off_t Nimage, off_t N, dbField *field)); - int HostTableLaunchJobs PROTO((SkyList *sky, HostTable *table, char *basecmd, char *options, int VERBOSE)); int HostTableParallelOps PROTO((SkyList *sky, int argc, char **argv, char *ResultFile, int ReadVectors, int Nelements, int VERBOSE)); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/pantasks.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/pantasks.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/pantasks.h (revision 37067) @@ -116,5 +116,5 @@ int active; - int priority; + int nicelevel; } Task; @@ -161,5 +161,5 @@ JobMode mode; /* local or controller? */ - int priority; + int nicelevel; char *realhost; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/pcontrol.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/pcontrol.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/pcontrol.h (revision 37067) @@ -8,4 +8,5 @@ /** job status values **/ typedef enum { + PCONTROL_JOB_NONE, // XXX OK? PCONTROL_JOB_ALLJOBS, PCONTROL_JOB_PENDING, @@ -119,5 +120,5 @@ int exit_status; int Reset; - int priority; + int nicelevel; JobMode mode; JobStat state; @@ -309,9 +310,10 @@ char *GetJobStackName (int StackID); Stack *GetJobStackByName (char *name); +int GetJobStackIDbyName (char *name); int PutJob (Job *job, int StackID, int where); int PutJobSetState (Job *job, int StackID, int where, int state); Job *PullJobByID (IDtype JobID, int *StackID); Job *PullJobFromStackByID (int StackID, int ID); -IDtype AddJob (char *hostname, JobMode mode, int timeout, int priority, int argc, char **argv, int Nxhosts, char **xhosts); +IDtype AddJob (char *hostname, JobMode mode, int timeout, int nicelevel, int argc, char **argv, int Nxhosts, char **xhosts); void DelJob (Job *job); Host *UnlinkJobAndHost (Job *job); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/shell.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/shell.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/shell.h (revision 37067) @@ -166,4 +166,6 @@ // wrap readline in ohana mem functions: char *opihi_readline PROTO((char *prompt)); + +int set_list_varname (char *line, char *base, int N, int excelStyle); /* gprint functions */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/Makefile (revision 37067) @@ -24,4 +24,5 @@ $(SDIR)/spline.$(ARCH).o \ $(SDIR)/SplineOps.$(ARCH).o \ +$(SDIR)/MedImageOps.$(ARCH).o \ $(SDIR)/mrqmin.$(ARCH).o \ $(SDIR)/mrq2dmin.$(ARCH).o \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/MedImageOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/MedImageOps.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/MedImageOps.c (revision 37067) @@ -0,0 +1,125 @@ +# include "data.h" + +/* this file contains functions to manage the median image data + */ + +MedImageType **medimages = NULL; /* book to store the list of all splines */ +int Nmedimages; /* number of currently defined medimages */ +int NMEDIMAGES; /* number of currently allocated medimages */ + +void InitMedImages () { + Nmedimages = 0; + NMEDIMAGES = 16; + ALLOCATE (medimages, MedImageType *, NMEDIMAGES); +} + +void FreeMedImages () { + + int i; + + for (i = 0; i < Nmedimages; i++) { + FreeMedImage (medimages[i]); + } + free (medimages); +} + +void FreeMedImage (MedImageType *medimage) { + + int i; + + if (!medimage) return; + + free (medimage[0].name); + for (i = 0; i < medimage[0].Ninput; i++) { + free (medimage[0].buffers[i]); + } + free (medimage[0].buffers); + free (medimage); +} + +/* return the given medimage */ +MedImageType *FindMedImage (char *name) { + + int i; + + if (!medimages) return NULL; + + for (i = 0; i < Nmedimages; i++) { + if (!strcmp (medimages[i][0].name, name)) { + return (medimages[i]); + } + } + return (NULL); +} + +/* make a new named medimage */ +MedImageType *CreateMedImage (char *name, int Nx, int Ny) { + + int N; + MedImageType *medimage; + + // do not create an image if one exists + medimage = FindMedImage (name); + if (medimage != NULL) { + return NULL; + } + + if (!medimages) InitMedImages (); + + N = Nmedimages; + Nmedimages ++; + CHECK_REALLOCATE (medimages, MedImageType *, NMEDIMAGES, Nmedimages, 16); + ALLOCATE (medimage, MedImageType, 1); + medimage->name = strcreate (name); + medimage->Ninput = 0; + medimage->Nx = Nx; + medimage->Ny = Ny; + ALLOCATE (medimage->buffers, float *, 1); + + medimages[N] = medimage; + return (medimage); +} + +/* delete a medimage */ +int DeleteMedImage (MedImageType *medimage) { + + int i, N, NMEDIMAGES_2; + + if (!medimages) return FALSE; + + /* find medimage in medimage list */ + N = -1; + for (i = 0; i < Nmedimages; i++) { + if (medimages[i] == medimage) { + N = i; + break; + } + } + if (N == -1) return (FALSE); + + for (i = N; i < Nmedimages - 1; i++) { + medimages[i] = medimages[i + 1]; + } + Nmedimages --; + NMEDIMAGES_2 = MAX (16, NMEDIMAGES / 2); + if (Nmedimages < NMEDIMAGES_2) { + NMEDIMAGES = NMEDIMAGES_2; + REALLOCATE (medimages, MedImageType *, NMEDIMAGES); + } + + FreeMedImage (medimage); + return (TRUE); +} + +/* list known medimages */ +void ListMedImages () { + + int i; + + if (!medimages) return; + + for (i = 0; i < Nmedimages; i++) { + gprint (GP_ERR, "%-15s %4d x %4d : %3d inputs\n", medimages[i][0].name, medimages[i][0].Nx, medimages[i][0].Ny, medimages[i][0].Ninput); + } + return; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/starfuncs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/starfuncs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/starfuncs.c (revision 37067) @@ -1,5 +1,5 @@ # include "data.h" -double get_aperture_stats (Matrix *matrix, int X, int Y, int Npix, int Nborder, double max) { +double get_aperture_stats (Matrix *matrix, int X, int Y, int Npix, int Nborder, double max, int VERBOSE) { double *ring; @@ -95,5 +95,5 @@ set_int_variable ("Npts", Npts); - gprint (GP_LOG, "%f %f %f %f %f %f %f %f\n", x, y, FWHMx, FWHMy, sky, I, mag, dmag); + if (VERBOSE) gprint (GP_LOG, "%f %f %f %f %f %f %f %f\n", x, y, FWHMx, FWHMy, sky, I, mag, dmag); return (mag); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/ListOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/ListOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/ListOps.c (revision 37067) @@ -185,16 +185,27 @@ // list (word) : nested list -// list (word) -x : not nested list -// list (word) -split : not nested list +// list (word) -x : not nested list [-x may be the list of options below] +// list -excel (word) -x : int is_list_data (char *line) { - char *comm, *temp; - - temp = thisword (nextword (nextword (line))); - comm = thisword (line); - + char *comm = NULL; + char *temp = NULL; + char *name = NULL; + char *opts = NULL; + + comm = thisword (line); if (comm == NULL) goto escape; - if (strcmp (comm, "list")) goto escape; + + // name == name of the list in question + name = nextword (line); + + // skip a -excel or -excel-style modifier + if (!strncmp("-excel", name, strlen("-excel"))) name = nextword (name); + if (!strncmp("-excel-style", name, strlen("-excel-style"))) name = nextword (name); + + // get the thing following ptr, if any (opts points at a substring, temp is a new string) + opts = nextword (name); + temp = thisword (opts); /* if (cond) (command) does not define a complete block */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/VectorIO.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/VectorIO.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/VectorIO.c (revision 37067) @@ -134,5 +134,5 @@ FTable ftable; - int i, j, k; + int i, j; FILE *f = NULL; @@ -202,20 +202,9 @@ assert (status); -# define ASSIGN_DATA(TYPE,OPTYPE) \ - /* assign the data to the actual vector */ \ - if (!strcmp (type, #TYPE)) { \ - TYPE *Ptr = data; \ - for (k = 0; k < Nrows; k++) { \ - for (j = 0; j < Nval; j++, Ptr++) { \ - vec[Nvec + j][0].elements.OPTYPE[k] = *Ptr; \ - } } } - - // assign the data to the actual vector - ASSIGN_DATA(char, Int); - ASSIGN_DATA(short, Int); - ASSIGN_DATA(int, Int); - ASSIGN_DATA(int64_t, Int); - ASSIGN_DATA(float, Flt); - ASSIGN_DATA(double, Flt); + if (!VectorAssignData(&vec[Nvec], type, data, Nrows, Nval)) { + // free unneeded things + gprint (GP_ERR, "trouble parsing data block type %s\n", type); + return (NULL); + } free (data); @@ -241,2 +230,52 @@ // return (FALSE); } + +# define ASSIGN_DATA(TYPE,DTYPE,OPTYPE) \ + /* assign the data to the actual vector */ \ + if (!strcmp (type, #TYPE)) { \ + DTYPE *Ptr = data; \ + for (k = 0; k < Nrows; k++) { \ + for (j = 0; j < Nval; j++, Ptr++) { \ + vec[j][0].elements.OPTYPE[k] = *Ptr; \ + } } return TRUE; } + +int VectorAssignData (Vector **vec, char *type, void *data, int Nrows, int Nval) { + + int j, k; + + // assign the data to the actual vector + ASSIGN_DATA(byte, char, Int); + ASSIGN_DATA(char, char, Int); + ASSIGN_DATA(short, short, Int); + ASSIGN_DATA(int, int, Int); + ASSIGN_DATA(int64_t, int64_t, Int); + ASSIGN_DATA(float, float, Flt); + ASSIGN_DATA(double, double, Flt); + + return FALSE; +} + +# define ASSIGN_DATA_TRANSPOSE(TYPE,DTYPE,OPTYPE) \ + /* assign the data to the actual vector */ \ + if (!strcmp (type, #TYPE)) { \ + DTYPE *Ptr = data; \ + for (k = 0; k < Nrows; k++) { \ + for (j = 0; j < Nval; j++, Ptr++) { \ + vec[k][0].elements.OPTYPE[j] = *Ptr; \ + } } return TRUE; } + +int VectorAssignDataTranspose (Vector **vec, char *type, void *data, int Nrows, int Nval) { + + int j, k; + + // assign the data to the actual vector + ASSIGN_DATA_TRANSPOSE(byte, char, Int); + ASSIGN_DATA_TRANSPOSE(char, char, Int); + ASSIGN_DATA_TRANSPOSE(short, short, Int); + ASSIGN_DATA_TRANSPOSE(int, int, Int); + ASSIGN_DATA_TRANSPOSE(int64_t, int64_t, Int); + ASSIGN_DATA_TRANSPOSE(float, float, Flt); + ASSIGN_DATA_TRANSPOSE(double, double, Flt); + + return FALSE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/check_stack.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/check_stack.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/check_stack.c (revision 37067) @@ -12,5 +12,5 @@ for (i = 0; i < Nstack; i++) { - if (stack[i].type == 'X') { + if (stack[i].type == ST_VALUE) { /** if this is a number, put it on the list of scalars and move on. assume value is @@ -27,13 +27,13 @@ stack[i].IntValue = strtol (stack[i].name, &c2, 0); if ((fabs(stack[i].FltValue) > MAX_INT) && (c1 == stack[i].name + strlen (stack[i].name))) { - stack[i].type = 'S'; // 'S' == (float) + stack[i].type = ST_SCALAR_FLT; // (float) continue; } if (c2 == stack[i].name + strlen (stack[i].name)) { - stack[i].type = 's'; // 's' == (int) + stack[i].type = ST_SCALAR_INT; // (int) continue; } if (c1 == stack[i].name + strlen (stack[i].name)) { - stack[i].type = 'S'; // 'S' == (float) + stack[i].type = ST_SCALAR_FLT; // (float) continue; } @@ -42,5 +42,5 @@ if (IsBuffer (stack[i].name)) { stack[i].buffer = SelectBuffer (stack[i].name, OLDBUFFER, TRUE); - stack[i].type = 'M'; + stack[i].type = ST_MATRIX; if (Nx == -1) { Nx = stack[i].buffer[0].matrix.Naxis[0]; @@ -63,5 +63,5 @@ if (IsVector (stack[i].name)) { stack[i].vector = SelectVector (stack[i].name, OLDVECTOR, FALSE); - stack[i].type = 'V'; + stack[i].type = ST_VECTOR; if (Nv == -1) Nv = stack[i].vector[0].Nelements; @@ -80,5 +80,5 @@ /* this is not a scalar, vector, or matrix. must be string */ - stack[i].type = 'W'; + stack[i].type = ST_STRING; } } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/convert_to_RPN.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/convert_to_RPN.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/convert_to_RPN.c (revision 37067) @@ -4,5 +4,5 @@ StackVar *convert_to_RPN (int argc, char **argv, int *nstack) { - int type; + StackVarType type; int i, j, Nstack, Nop_stack, NSTACK; StackVar *stack, *op_stack; @@ -21,78 +21,88 @@ /* decide on priority of object */ - type = 0; + type = ST_NONE; + + /* trinary operations */ + if (!strcmp (argv[i], "?")) { type = ST_TRINARY; goto gotit; } + if (!strcmp (argv[i], ":")) { type = ST_COMMA; goto gotit; } + /* unary operations */ - if (!strcmp (argv[i], "abs")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "int")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "exp")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "ten")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "log")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "ln")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "sqrt")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "erf")) { type = 9; goto gotit; } - - if (!strcmp (argv[i], "sinh")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "cosh")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "asinh")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "acosh")) { type = 9; goto gotit; } - - if (!strcmp (argv[i], "sin")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "cos")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "tan")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "dsin")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "dcos")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "dtan")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "asin")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "acos")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "atan")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "dasin")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "dacos")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "datan")) { type = 9; goto gotit; } - - if (!strcmp (argv[i], "lgamma")) { type = 9; goto gotit; } - - if (!strcmp (argv[i], "rnd")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "xramp")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "yramp")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "ramp")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "zero")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "--")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "not")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "isinf")) { type = 9; goto gotit; } - if (!strcmp (argv[i], "isnan")) { type = 9; goto gotit; } + if (!strcmp (argv[i], "abs")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "int")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "floor")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "round")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "ceil")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "rint")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "exp")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "ten")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "log")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "ln")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "sqrt")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "erf")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "sinh")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "cosh")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "asinh")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "acosh")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "sin")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "cos")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "tan")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "dsin")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "dcos")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "dtan")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "asin")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "acos")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "atan")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "dasin")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "dacos")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "datan")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "lgamma")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "rnd")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "xramp")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "yramp")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "ramp")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "zero")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "--")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "not")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "isinf")) { type = ST_UNARY; goto gotit; } + if (!strcmp (argv[i], "isnan")) { type = ST_UNARY; goto gotit; } /* binary operations */ - if (!strcmp (argv[i], "^")) { type = 8; goto gotit; } - - if (!strcmp (argv[i], "@")) { type = 7; goto gotit; } - if (!strcmp (argv[i], "/")) { type = 7; goto gotit; } - if (!strcmp (argv[i], "*")) { type = 7; goto gotit; } - if (!strcmp (argv[i], "%")) { type = 7; goto gotit; } - - if (!strcmp (argv[i], "+")) { type = 6; goto gotit; } - if (!strcmp (argv[i], "-")) { type = 6; goto gotit; } + if (!strcmp (argv[i], "^")) { type = ST_POWER; goto gotit; } + + if (!strcmp (argv[i], "max")) { type = ST_BINARY; strcpy (argv[i], "U"); goto gotit; } + if (!strcmp (argv[i], "min")) { type = ST_BINARY; strcpy (argv[i], "D"); goto gotit; } + if (!strcmp (argv[i], "atan2")) { type = ST_BINARY; goto gotit; } + if (!strcmp (argv[i], ",")) { type = ST_COMMA; goto gotit; } + + if (!strcmp (argv[i], "@")) { type = ST_TIMES; goto gotit; } + if (!strcmp (argv[i], "/")) { type = ST_TIMES; goto gotit; } + if (!strcmp (argv[i], "*")) { type = ST_TIMES; goto gotit; } + if (!strcmp (argv[i], "%")) { type = ST_TIMES; goto gotit; } + + if (!strcmp (argv[i], "+")) { type = ST_ADD; goto gotit; } + if (!strcmp (argv[i], "-")) { type = ST_ADD; goto gotit; } - if (!strcmp (argv[i], "&")) { type = 5; goto gotit; } - if (!strcmp (argv[i], "|")) { type = 5; goto gotit; } - - if (!strcmp (argv[i], "<")) { type = 4; goto gotit; } - if (!strcmp (argv[i], ">")) { type = 4; goto gotit; } - if (!strcmp (argv[i], "==")) { type = 4; strcpy (argv[i], "E"); goto gotit; } - if (!strcmp (argv[i], "!=")) { type = 4; strcpy (argv[i], "N"); goto gotit; } - if (!strcmp (argv[i], "<=")) { type = 4; strcpy (argv[i], "L"); goto gotit; } - if (!strcmp (argv[i], ">=")) { type = 4; strcpy (argv[i], "G"); goto gotit; } - if (!strcmp (argv[i], ">>")) { type = 4; strcpy (argv[i], "U"); goto gotit; } - if (!strcmp (argv[i], "<<")) { type = 4; strcpy (argv[i], "D"); goto gotit; } - - if (!strcmp (argv[i], "&&")) { type = 3; strcpy (argv[i], "A"); goto gotit; } - if (!strcmp (argv[i], "||")) { type = 3; strcpy (argv[i], "O"); goto gotit; } - - if (!strcmp (argv[i], "(")) { type = 2; goto gotit; } - if (!strcmp (argv[i], ")")) { type = 1; goto gotit; } + if (!strcmp (argv[i], "&")) { type = ST_BITWISE; goto gotit; } + if (!strcmp (argv[i], "|")) { type = ST_BITWISE; goto gotit; } + + if (!strcmp (argv[i], "<")) { type = ST_LOGIC; goto gotit; } + if (!strcmp (argv[i], ">")) { type = ST_LOGIC; goto gotit; } + if (!strcmp (argv[i], "==")) { type = ST_LOGIC; strcpy (argv[i], "E"); goto gotit; } + if (!strcmp (argv[i], "!=")) { type = ST_LOGIC; strcpy (argv[i], "N"); goto gotit; } + if (!strcmp (argv[i], "<=")) { type = ST_LOGIC; strcpy (argv[i], "L"); goto gotit; } + if (!strcmp (argv[i], ">=")) { type = ST_LOGIC; strcpy (argv[i], "G"); goto gotit; } + if (!strcmp (argv[i], ">>")) { type = ST_LOGIC; strcpy (argv[i], "U"); goto gotit; } + if (!strcmp (argv[i], "<<")) { type = ST_LOGIC; strcpy (argv[i], "D"); goto gotit; } + + if (!strcmp (argv[i], "&&")) { type = ST_AND; strcpy (argv[i], "A"); goto gotit; } + if (!strcmp (argv[i], "||")) { type = ST_OR ; strcpy (argv[i], "O"); goto gotit; } + + if (!strcmp (argv[i], "(")) { type = ST_LEFT; goto gotit; } + if (!strcmp (argv[i], ")")) { type = ST_RIGHT; goto gotit; } gotit: /* choose how to deal with object */ switch (type) { - case 8: /* exponentiation: 2^2^3 = 64 != 256 (precedence is right-to-left, not left-to-right!) */ + case ST_POWER: /* exponentiation: 2^2^3 = 64 != 256 (precedence is right-to-left, not left-to-right!) */ /* pop previous, higher operators from OP stack to stack */ for (j = Nop_stack - 1; (j >= 0) && (op_stack[j].type > type); j--) { @@ -105,10 +115,13 @@ Nop_stack ++; break; - case 9: /* unary OPs */ - case 7: /* binary OPs */ - case 6: - case 5: - case 4: - case 3: + case ST_UNARY: + case ST_BINARY: + case ST_TRINARY: + case ST_TIMES: + case ST_ADD: + case ST_BITWISE: + case ST_LOGIC: + case ST_AND: + case ST_OR: /* pop previous, higher or equal operators from OP stack to stack */ for (j = Nop_stack - 1; (j >= 0) && (op_stack[j].type >= type); j--) { @@ -121,5 +134,5 @@ Nop_stack ++; break; - case 2: + case ST_LEFT: /* push operator on OP stack */ assign_stack (&op_stack[Nop_stack], argv[i], type); @@ -127,12 +140,12 @@ Nop_stack ++; break; - case 1: + case ST_RIGHT: /* pop rest of operators from OP stack to stack, looking for '(' */ - for (j = Nop_stack - 1; (j >= 0) && (op_stack[j].type != 2); j--) { - move_stack (&stack[Nstack], &op_stack[j]); - Nstack ++; - Nop_stack --; - } - if ((j == -1) || (op_stack[j].type != 2)) { + for (j = Nop_stack - 1; (j >= 0) && (op_stack[j].type != ST_LEFT); j--) { + move_stack (&stack[Nstack], &op_stack[j]); + Nstack ++; + Nop_stack --; + } + if ((j == -1) || (op_stack[j].type != ST_LEFT)) { push_error ("syntax error: mismatched parenthesis"); Nstack = 0; @@ -144,16 +157,29 @@ Nop_stack --; break; - case 0: + case ST_COMMA: + /* pop rest of operators from OP stack to stack, looking for '(' (but do not pop the '(')*/ + for (j = Nop_stack - 1; (j >= 0) && (op_stack[j].type != ST_LEFT) && (op_stack[j].type != ST_TRINARY); j--) { + move_stack (&stack[Nstack], &op_stack[j]); + Nstack ++; + Nop_stack --; + } + break; + case ST_NONE: /* place the value (number or vector/matrix name) on stack */ /* value of 'X' is used as sentinel until we sort out values */ - assign_stack (&stack[Nstack], argv[i], 'X'); + assign_stack (&stack[Nstack], argv[i], ST_VALUE); Nstack ++; break; + + default: + push_error ("invalid stack typ"); + Nstack = 0; + goto cleanup; } } - /* dump remaining operators on stack, checking for ')' */ + /* dump remaining operators on stack, checking for '(' */ for (j = Nop_stack - 1; j >= 0; j--) { - if (op_stack[j].type == 2) { + if (op_stack[j].type == ST_LEFT) { push_error ("syntax error: mismatched parenthesis"); Nstack = 0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/dvomath.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/dvomath.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/dvomath.c (revision 37067) @@ -80,5 +80,5 @@ sprintf (outname, "%s", stack[0].name); } else { - if (stack[0].type == 's') { + if (stack[0].type == ST_SCALAR_INT) { sprintf (outname, "%d", stack[0].IntValue); } else { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/evaluate_stack.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/evaluate_stack.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/evaluate_stack.c (revision 37067) @@ -2,11 +2,51 @@ # define VERBOSE 0 -# define TWO_OP(A,B,FUNC) \ - if (!strncasecmp (&stack[i - 2].type, A, 1) && !strncasecmp (&stack[i - 1].type, B, 1)) \ - status = FUNC (&tmp_stack, &stack[i - 2], &stack[i - 1], stack[i].name); - -# define ONE_OP(A,FUNC) \ - if (!strncasecmp (&stack[i - 1].type, A, 1)) \ - status = FUNC (&tmp_stack, &stack[i - 1], stack[i].name); +// all three operands must have the same type +# define THREE_OP(A,FUNC) \ + if ((stack[i - 3].type == A) && (stack[i - 2].type == A) && (stack[i - 1].type == A)) { \ + status = FUNC (&tmp_stack, &stack[i - 3], &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_three_op; } \ + if ((stack[i - 3].type == A+1) && (stack[i - 2].type == A) && (stack[i - 1].type == A)) { \ + status = FUNC (&tmp_stack, &stack[i - 3], &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_three_op; } \ + if ((stack[i - 3].type == A) && (stack[i - 2].type == A+1) && (stack[i - 1].type == A)) { \ + status = FUNC (&tmp_stack, &stack[i - 3], &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_three_op; } \ + if ((stack[i - 3].type == A+1) && (stack[i - 2].type == A+1) && (stack[i - 1].type == A)) { \ + status = FUNC (&tmp_stack, &stack[i - 3], &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_three_op; } \ + if ((stack[i - 3].type == A) && (stack[i - 2].type == A) && (stack[i - 1].type == A+1)) { \ + status = FUNC (&tmp_stack, &stack[i - 3], &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_three_op; } \ + if ((stack[i - 3].type == A+1) && (stack[i - 2].type == A) && (stack[i - 1].type == A+1)) { \ + status = FUNC (&tmp_stack, &stack[i - 3], &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_three_op; } \ + if ((stack[i - 3].type == A) && (stack[i - 2].type == A+1) && (stack[i - 1].type == A+1)) { \ + status = FUNC (&tmp_stack, &stack[i - 3], &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_three_op; } \ + if ((stack[i - 3].type == A+1) && (stack[i - 2].type == A+1) && (stack[i - 1].type == A+1)) { \ + status = FUNC (&tmp_stack, &stack[i - 3], &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_three_op; } \ + +// A & B value types all have 2 possible values +# define TWO_OP(A,B,FUNC) { \ + if ((stack[i - 2].type == A) && (stack[i - 1].type == B)) { \ + status = FUNC (&tmp_stack, &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_two_op; } \ + if ((stack[i - 2].type == A+1) && (stack[i - 1].type == B)) { \ + status = FUNC (&tmp_stack, &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_two_op; } \ + if ((stack[i - 2].type == A) && (stack[i - 1].type == B+1)) { \ + status = FUNC (&tmp_stack, &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_two_op; } \ + if ((stack[i - 2].type == A+1) && (stack[i - 1].type == B+1)) { \ + status = FUNC (&tmp_stack, &stack[i - 2], &stack[i - 1], stack[i].name); \ + goto got_two_op; } \ + } + +# define ONE_OP(A,FUNC) \ + if (stack[i - 1].type == A) { \ + status = FUNC (&tmp_stack, &stack[i - 1], stack[i].name); \ + goto got_one_op; } int evaluate_stack (StackVar *stack, int *Nstack) { @@ -20,9 +60,9 @@ if (*Nstack == 1) { - if ((stack[0].type == 'S') || (stack[0].type == 's')) { + if ((stack[0].type == ST_SCALAR_INT) || (stack[0].type == ST_SCALAR_FLT)) { clear_stack (&tmp_stack); return (TRUE); } - if (stack[0].type == 'V') { + if (stack[0].type == ST_VECTOR) { /* need to make a copy so we set output value? */ V_unary (&tmp_stack, &stack[0], "="); @@ -30,5 +70,5 @@ return (TRUE); } - if (stack[0].type == 'M') { + if (stack[0].type == ST_MATRIX) { /* need to make a copy so we set output value? */ M_unary (&tmp_stack, &stack[0], "="); @@ -56,75 +96,148 @@ } - /***** binary operators *****/ - if ((stack[i].type >= 3) && (stack[i].type <= 8)) { - - if (i < 2) { /* need two variables to operate on */ - sprintf (line, "syntax error: binary operator with one operand: %s\n", stack[i].name); + /***** trinary operators *****/ + switch (stack[i].type) { + case ST_TRINARY: + + if (i < 3) { /* need two variables to operate on */ + snprintf (line, 512, "syntax error: trinary operator without three operands: %s\n", stack[i].name); + push_error (line); + clear_stack (&tmp_stack); + return (FALSE); + } + + status = FALSE; + THREE_OP (ST_MATRIX,MMM_trinary); + THREE_OP (ST_VECTOR,VVV_trinary); + + THREE_OP (ST_SCALAR_FLT,SSS_trinary); + THREE_OP (ST_SCALAR_INT,SSS_trinary); + + /* there are no valid unary string operators */ + push_error ("invalid operands for trinary operator (mismatch types?)"); + clear_stack (&tmp_stack); + return (FALSE); + + got_three_op: + if (!status) { + snprintf (line, 512, "syntax error: invalid operand for binary operation: %s or %s or %s\n", stack[i-1].name, stack[i-2].name, stack[i-3].name); + push_error (line); + clear_stack (&tmp_stack); + return (FALSE); + } + move_stack (&stack[i-3], &tmp_stack); + delete_stack (&stack[i-2], 3); + for (j = i + 1; j < *Nstack; j++) { + move_stack (&stack[j-3], &stack[j]); + } + *Nstack -= 3; + i -= 3; + init_stack (&tmp_stack); + continue; + + /***** binary operators *****/ + case ST_OR: + case ST_AND: + case ST_LOGIC: + case ST_BITWISE: + case ST_ADD: + case ST_TIMES: + case ST_POWER: + case ST_BINARY: + + if (i < 2) { /* need two variables to operate on */ + snprintf (line, 512, "syntax error: binary operator with one operand: %s\n", stack[i].name); + push_error (line); + clear_stack (&tmp_stack); + return (FALSE); + } + + status = FALSE; + TWO_OP (ST_MATRIX,ST_MATRIX,MM_binary); + TWO_OP (ST_MATRIX,ST_VECTOR,MV_binary); + TWO_OP (ST_MATRIX,ST_SCALAR_INT,MS_binary); + + TWO_OP (ST_VECTOR,ST_MATRIX,VM_binary); + TWO_OP (ST_VECTOR,ST_VECTOR,VV_binary); + TWO_OP (ST_VECTOR,ST_SCALAR_INT,VS_binary); + + TWO_OP (ST_SCALAR_INT,ST_MATRIX,SM_binary); + TWO_OP (ST_SCALAR_INT,ST_VECTOR,SV_binary); + TWO_OP (ST_SCALAR_INT,ST_SCALAR_INT,SS_binary); + + TWO_OP (ST_SCALAR_FLT,ST_MATRIX,SM_binary); + TWO_OP (ST_SCALAR_FLT,ST_VECTOR,SV_binary); + TWO_OP (ST_SCALAR_FLT,ST_SCALAR_INT,SS_binary); + + TWO_OP (ST_STRING,ST_STRING,WW_binary); + TWO_OP (ST_STRING,ST_SCALAR_INT,WW_binary); + TWO_OP (ST_SCALAR_INT,ST_STRING,WW_binary); + + got_two_op: + if (!status) { + snprintf (line, 512, "syntax error: invalid operand for binary operation: %s or %s\n", stack[i-1].name, stack[i-2].name); + push_error (line); + clear_stack (&tmp_stack); + return (FALSE); + } + move_stack (&stack[i-2], &tmp_stack); + delete_stack (&stack[i-1], 2); + for (j = i + 1; j < *Nstack; j++) { + move_stack (&stack[j - 2], &stack[j]); + } + *Nstack -= 2; + i -= 2; + init_stack (&tmp_stack); + continue; + + /***** unary operators **/ + case ST_UNARY: + + if (i < 1) { /* need one variable to operate on */ + push_error ("syntax error: unary operator with no operand"); + clear_stack (&tmp_stack); + return (FALSE); + } + + ONE_OP (ST_MATRIX, M_unary); + ONE_OP (ST_MATRIX_TMP, M_unary); + + ONE_OP (ST_VECTOR, V_unary); + ONE_OP (ST_VECTOR_TMP, V_unary); + + ONE_OP (ST_SCALAR_INT, S_unary); + ONE_OP (ST_SCALAR_FLT, S_unary); + + /* there are no valid unary string operators */ + push_error ("syntax error: no valid string unary ops"); + clear_stack (&tmp_stack); + return (FALSE); + + got_one_op: + move_stack (&stack[i-1], &tmp_stack); + delete_stack (&stack[i], 1); + for (j = i + 1; j < *Nstack; j++) { + move_stack (&stack[j - 1], &stack[j]); + } + init_stack (&tmp_stack); + *Nstack -= 1; + i -= 1; + continue; + + case ST_SCALAR_INT: + case ST_SCALAR_FLT: + case ST_VECTOR: + case ST_VECTOR_TMP: + case ST_MATRIX: + case ST_MATRIX_TMP: + case ST_STRING: + continue; + + default: + snprintf (line, 512, "syntax error: unexpected operator type %s", stack[i].name); push_error (line); clear_stack (&tmp_stack); return (FALSE); - } - - status = FALSE; - TWO_OP ("M","M",MM_binary); - TWO_OP ("M","V",MV_binary); - TWO_OP ("M","S",MS_binary); - TWO_OP ("V","M",VM_binary); - TWO_OP ("V","V",VV_binary); - TWO_OP ("V","S",VS_binary); - TWO_OP ("S","M",SM_binary); - TWO_OP ("S","V",SV_binary); - TWO_OP ("S","S",SS_binary); - TWO_OP ("W","W",WW_binary); - TWO_OP ("W","S",WW_binary); - TWO_OP ("S","W",WW_binary); - - if (!status) { - sprintf (line, "syntax error: invalid operand for binary operation: %s or %s\n", stack[i-1].name, stack[i-2].name); - push_error (line); - clear_stack (&tmp_stack); - return (FALSE); - } - move_stack (&stack[i-2], &tmp_stack); - delete_stack (&stack[i-1], 2); - for (j = i + 1; j < *Nstack; j++) { - move_stack (&stack[j - 2], &stack[j]); - } - *Nstack -= 2; - i -= 2; - init_stack (&tmp_stack); - continue; - } - - /***** unary operators **/ - if (stack[i].type == 9) { - - if (i < 1) { /* need one variable to operate on */ - push_error ("syntax error: unary operator with no operand"); - clear_stack (&tmp_stack); - return (FALSE); - } - - ONE_OP ("M", M_unary); - ONE_OP ("V", V_unary); - ONE_OP ("S", S_unary); - - /* there are no valid unary string operators */ - if (!strncasecmp (&stack[i - 1].type, "W", 1)) { - push_error ("syntax error: no valid string unary ops"); - clear_stack (&tmp_stack); - return (FALSE); - } - - move_stack (&stack[i-1], &tmp_stack); - delete_stack (&stack[i], 1); - for (j = i + 1; j < *Nstack; j++) { - move_stack (&stack[j - 1], &stack[j]); - } - init_stack (&tmp_stack); - *Nstack -= 1; - i -= 1; - continue; - } + } } clear_stack (&tmp_stack); @@ -160,5 +273,5 @@ for (i = 0; i < Nstack; i++) { - if (IsBufferPtr (stack[i].buffer) && (stack[i].type == 'm')) { + if (IsBufferPtr (stack[i].buffer) && (stack[i].type == ST_MATRIX_TMP)) { if (VERBOSE) gprint (GP_ERR, "free %s (buff) (%lx)\n", stack[i].name, (long) stack[i].buffer); free (stack[i].buffer[0].header.buffer); @@ -167,5 +280,5 @@ stack[i].buffer = NULL; } - if (IsVectorPtr (stack[i].vector) && (stack[i].type == 'v')) { + if (IsVectorPtr (stack[i].vector) && (stack[i].type == ST_VECTOR_TMP)) { if (VERBOSE) gprint (GP_ERR, "free %s (vect) (%lx)\n", stack[i].name, (long) stack[i].vector); free (stack[i].vector[0].elements.Ptr); @@ -193,5 +306,5 @@ } -void assign_stack (StackVar *stack, char *name, int type) { +void assign_stack (StackVar *stack, char *name, StackVarType type) { stack->name = strcreate (name); stack->type = type; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/macro_list.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/macro_list.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/macro_list.c (revision 37067) @@ -11,5 +11,5 @@ } - macro = MatchMacro (argv[0], FALSE, TRUE); + macro = MatchMacro (argv[1], FALSE, TRUE); if (macro == NULL) { gprint (GP_ERR, "%s: Macro not found\n", argv[1]); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/stack_math.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/stack_math.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/stack_math.c (revision 37067) @@ -6,9 +6,46 @@ */ -// XXX we temporarily drop the concept of using one of the temporary input vectors for -// the output vector (thus saving an ALLOC): we have to juggle the size of the input vectors -// as well as their temporary state - -int VV_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) { +int SSS_trinary (StackVar *OUT, StackVar *V1, StackVar *V2, StackVar *V3, char *op) { + + char line[512]; // this is only used to report an error + + // set up the possible operations : int OP int -> int, all else yield float + // OP is the operation performed on *M1 and *M2 +# define SSS_FUNC(OP) { \ + if ((V1->type == ST_SCALAR_FLT) && (V2->type == ST_SCALAR_FLT) && (V3->type == ST_SCALAR_FLT)) { \ + opihi_flt M1 = V1[0].FltValue; \ + opihi_flt M2 = V2[0].FltValue; \ + opihi_flt M3 = V3[0].FltValue; \ + OUT[0].type = ST_SCALAR_FLT; \ + OUT[0].FltValue = OP; \ + break; \ + } \ + if ((V1->type == ST_SCALAR_INT) && (V2->type == ST_SCALAR_INT) && (V3->type == ST_SCALAR_INT)) { \ + opihi_int M1 = V1[0].IntValue; \ + opihi_int M2 = V2[0].IntValue; \ + opihi_int M3 = V3[0].IntValue; \ + OUT[0].type = ST_SCALAR_INT; \ + OUT[0].IntValue = OP; \ + break; \ + } \ + } + + switch (op[0]) { + case '?': SSS_FUNC(M1 ? M2: M3); + default: + snprintf (line, 512, "error: op %c not defined!", op[0]); + push_error (line); + return (FALSE); + } +# undef SSS_FUNC + + clear_stack (V1); + clear_stack (V2); + clear_stack (V3); + return (TRUE); + +} + +int VVV_trinary (StackVar *OUT, StackVar *V1, StackVar *V2, StackVar *V3, char *op) { int i, Nx; @@ -19,4 +56,7 @@ return (FALSE); } + if (V1[0].vector[0].Nelements != V3[0].vector[0].Nelements) { + return (FALSE); + } Nx = V1[0].vector[0].Nelements; @@ -24,5 +64,154 @@ // create the output vector guaranteed to be temporary until the very end OUT[0].vector = InitVector (); - OUT[0].type = 'v'; + OUT[0].type = ST_VECTOR_TMP; + + // set up the possible operations : int OP int -> int, all else yield float + // OP is the operation performed on *M1 and *M2 +# define VVV_FUNC(OP) { \ + if ((V1->vector->type == OPIHI_FLT) && (V2->vector->type == OPIHI_FLT) && (V3->vector->type == OPIHI_FLT)) { \ + CopyVector (OUT[0].vector, V1[0].vector); \ + opihi_flt *M1 = V1[0].vector[0].elements.Flt; \ + opihi_flt *M2 = V2[0].vector[0].elements.Flt; \ + opihi_flt *M3 = V3[0].vector[0].elements.Flt; \ + opihi_flt *out = OUT[0].vector[0].elements.Flt; \ + for (i = 0; i < Nx; i++, out++, M1++, M2++, M3++) { \ + *out = OP; \ + } \ + break; \ + } \ + if ((V1->vector->type == OPIHI_INT) && (V2->vector->type == OPIHI_INT) && (V3->vector->type == OPIHI_INT)) { \ + CopyVector (OUT[0].vector, V1[0].vector); \ + opihi_int *M1 = V1[0].vector[0].elements.Int; \ + opihi_int *M2 = V2[0].vector[0].elements.Int; \ + opihi_int *M3 = V3[0].vector[0].elements.Int; \ + opihi_int *out = OUT[0].vector[0].elements.Int; \ + for (i = 0; i < Nx; i++, out++, M1++, M2++, M3++) { \ + *out = OP; \ + } \ + break; \ + } \ + } + + switch (op[0]) { + case '?': VVV_FUNC(*M1 ? *M2: *M3); + default: + snprintf (line, 512, "error: op %c not defined!", op[0]); + push_error (line); + return (FALSE); + } +# undef VVV_FUNC + + /** free up any temporary buffers: **/ + + if (V1[0].type == ST_VECTOR_TMP) { + free (V1[0].vector[0].elements.Ptr); + free (V1[0].vector); + } + if (V2[0].type == ST_VECTOR_TMP) { + free (V2[0].vector[0].elements.Ptr); + free (V2[0].vector); + } + if (V3[0].type == ST_VECTOR_TMP) { + free (V3[0].vector[0].elements.Ptr); + free (V3[0].vector); + } + /* at the end, V1 and V2 are deleted only if they were temporary */ + + clear_stack (V1); + clear_stack (V2); + clear_stack (V3); + return (TRUE); + +} + +int MMM_trinary (StackVar *OUT, StackVar *V1, StackVar *V2, StackVar *V3, char *op) { + + int i, Nx, Ny; + float *out, *M1, *M2, *M3; + char line[512]; // this is only used to report an error + + Nx = V1[0].buffer[0].matrix.Naxis[0]; + Ny = V1[0].buffer[0].matrix.Naxis[1]; + + if (V1[0].type == ST_MATRIX_TMP) { /** use V1 as temp buffer **/ + OUT[0].buffer = V1[0].buffer; + V1[0].type = ST_MATRIX; /* prevent it from being freed below */ + } else { + if (V2[0].type == ST_MATRIX_TMP) { /** use V2 as temp buffer, but header of V1 **/ + OUT[0].buffer = V2[0].buffer; + V2[0].type = ST_MATRIX; /* prevent it from being freed below */ + } else { /* no spare temp buffer */ + OUT[0].buffer = InitBuffer (); + CopyBuffer (OUT[0].buffer, V1[0].buffer); + } + } + OUT[0].type = ST_MATRIX_TMP; /*** <<--- says this is a temporary matrix ***/ + + M1 = (float *)V1[0].buffer[0].matrix.buffer; + M2 = (float *)V2[0].buffer[0].matrix.buffer; + M3 = (float *)V3[0].buffer[0].matrix.buffer; + out = (float *)OUT[0].buffer[0].matrix.buffer; + +# define MMM_FUNC(OP) \ + for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++, M3++) { \ + *out = OP; \ + } \ + break; + + switch (op[0]) { + case '?': MMM_FUNC(*M1 ? *M2: *M3); + default: + snprintf (line, 512, "error: op %c not defined!", op[0]); + push_error (line); + return (FALSE); + } +# undef MMM_FUNC + + /** free up any temporary buffers: **/ + + if (V1[0].type == ST_MATRIX_TMP) { + free (V1[0].buffer[0].header.buffer); + free (V1[0].buffer[0].matrix.buffer); + free (V1[0].buffer); + } + if (V2[0].type == ST_MATRIX_TMP) { + free (V2[0].buffer[0].header.buffer); + free (V2[0].buffer[0].matrix.buffer); + free (V2[0].buffer); + } + if (V3[0].type == ST_MATRIX_TMP) { + free (V3[0].buffer[0].header.buffer); + free (V3[0].buffer[0].matrix.buffer); + free (V3[0].buffer); + } + + /* at the end, V1 and V2 are deleted only if they were temporary */ + + clear_stack (V1); + clear_stack (V2); + clear_stack (V3); + return (TRUE); + +} + +// XXX we temporarily drop the concept of using one of the temporary input vectors for +// the output vector (thus saving an ALLOC): we have to juggle the size of the input vectors +// as well as their temporary state + +int VV_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) { + + int i, Nx; + char line[512]; // this is only used to report an error + + // the vectors have to match in length + if (V1[0].vector[0].Nelements != V2[0].vector[0].Nelements) { + return (FALSE); + } + + Nx = V1[0].vector[0].Nelements; + + // create the output vector guaranteed to be temporary until the very end + OUT[0].vector = InitVector (); + OUT[0].type = ST_VECTOR_TMP; // set up the possible operations : int OP int -> int, all else yield float @@ -59,5 +248,5 @@ break; \ } \ - if ((FTYPE == 'S') && (V1->vector->type != OPIHI_FLT) && (V2->vector->type != OPIHI_FLT)) { \ + if ((FTYPE == ST_SCALAR_FLT) && (V1->vector->type != OPIHI_FLT) && (V2->vector->type != OPIHI_FLT)) { \ MatchVector (OUT[0].vector, V1[0].vector, OPIHI_FLT); \ opihi_int *M1 = V1[0].vector[0].elements.Int; \ @@ -82,25 +271,26 @@ switch (op[0]) { - case '+': VV_FUNC('s', *M1 + *M2); - case '-': VV_FUNC('s', *M1 - *M2); - case '*': VV_FUNC('s', *M1 * *M2); - case '/': VV_FUNC('S', *M1 / (opihi_flt) *M2); - case '%': VV_FUNC('s', (long long)*M1 % (long long)*M2); - case '^': VV_FUNC('S', pow (*M1, *M2)); - case '@': VV_FUNC('S', DEG_RAD*atan2 (*M1, *M2)); - case 'D': VV_FUNC('s', MIN (*M1, *M2)); - case 'U': VV_FUNC('s', MAX (*M1, *M2)); - case '<': VV_FUNC('s', (*M1 < *M2) ? 1 : 0); - case '>': VV_FUNC('s', (*M1 > *M2) ? 1 : 0); - case '&': VV_FUNC('s', ((long long)*M1 & (long long)*M2)); - case '|': VV_FUNC('s', ((long long)*M1 | (long long)*M2)); - case 'E': VV_FUNC('s', (*M1 == *M2) ? 1 : 0); - case 'N': VV_FUNC('s', (*M1 != *M2) ? 1 : 0); - case 'L': VV_FUNC('s', (*M1 <= *M2) ? 1 : 0); - case 'G': VV_FUNC('s', (*M1 >= *M2) ? 1 : 0); - case 'A': VV_FUNC('s', (*M1 && *M2) ? 1 : 0); - case 'O': VV_FUNC('s', (*M1 || *M2) ? 1 : 0); + case '+': VV_FUNC(ST_SCALAR_INT, *M1 + *M2); + case '-': VV_FUNC(ST_SCALAR_INT, *M1 - *M2); + case '*': VV_FUNC(ST_SCALAR_INT, *M1 * *M2); + case '/': VV_FUNC(ST_SCALAR_FLT, *M1 / (opihi_flt) *M2); + case '%': VV_FUNC(ST_SCALAR_INT, (long long)*M1 % (long long)*M2); + case '^': VV_FUNC(ST_SCALAR_FLT, pow (*M1, *M2)); + case '@': VV_FUNC(ST_SCALAR_FLT, DEG_RAD*atan2 (*M1, *M2)); + case 'a': VV_FUNC(ST_SCALAR_FLT, DEG_RAD*atan2 (*M1, *M2)); + case 'D': VV_FUNC(ST_SCALAR_INT, MIN (*M1, *M2)); + case 'U': VV_FUNC(ST_SCALAR_INT, MAX (*M1, *M2)); + case '<': VV_FUNC(ST_SCALAR_INT, (*M1 < *M2) ? 1 : 0); + case '>': VV_FUNC(ST_SCALAR_INT, (*M1 > *M2) ? 1 : 0); + case '&': VV_FUNC(ST_SCALAR_INT, ((long long)*M1 & (long long)*M2)); + case '|': VV_FUNC(ST_SCALAR_INT, ((long long)*M1 | (long long)*M2)); + case 'E': VV_FUNC(ST_SCALAR_INT, (*M1 == *M2) ? 1 : 0); + case 'N': VV_FUNC(ST_SCALAR_INT, (*M1 != *M2) ? 1 : 0); + case 'L': VV_FUNC(ST_SCALAR_INT, (*M1 <= *M2) ? 1 : 0); + case 'G': VV_FUNC(ST_SCALAR_INT, (*M1 >= *M2) ? 1 : 0); + case 'A': VV_FUNC(ST_SCALAR_INT, (*M1 && *M2) ? 1 : 0); + case 'O': VV_FUNC(ST_SCALAR_INT, (*M1 || *M2) ? 1 : 0); default: - sprintf (line, "error: op %c not defined!", op[0]); + snprintf (line, 512, "error: op %c not defined!", op[0]); push_error (line); return (FALSE); @@ -110,9 +300,9 @@ /** free up any temporary buffers: **/ - if (V1[0].type == 'v') { + if (V1[0].type == ST_VECTOR_TMP) { free (V1[0].vector[0].elements.Ptr); free (V1[0].vector); } - if (V2[0].type == 'v') { + if (V2[0].type == ST_VECTOR_TMP) { free (V2[0].vector[0].elements.Ptr); free (V2[0].vector); @@ -134,10 +324,10 @@ OUT[0].vector = InitVector (); - OUT[0].type = 'v'; /*** <<--- says this is a temporary matrix ***/ + OUT[0].type = ST_VECTOR_TMP; /*** <<--- says this is a temporary matrix ***/ // set up the possible operations : int OP int -> int, all else yield float // OP is the operation performed on *M1 and *M2 # define SV_FUNC(FTYPE,OP) { \ - if ((V1->type == 'S') && (V2->vector->type == OPIHI_FLT)) { \ + if ((V1->type == ST_SCALAR_FLT) && (V2->vector->type == OPIHI_FLT)) { \ CopyVector (OUT[0].vector, V2[0].vector); \ opihi_flt M1 = V1[0].FltValue; \ @@ -149,5 +339,5 @@ break; \ } \ - if ((V1->type == 'S') && (V2->vector->type != OPIHI_FLT)) { \ + if ((V1->type == ST_SCALAR_FLT) && (V2->vector->type != OPIHI_FLT)) { \ MatchVector (OUT[0].vector, V2[0].vector, OPIHI_FLT); \ opihi_flt M1 = V1[0].FltValue; \ @@ -159,5 +349,5 @@ break; \ } \ - if ((V1->type == 's') && (V2->vector->type == OPIHI_FLT)) { \ + if ((V1->type == ST_SCALAR_INT) && (V2->vector->type == OPIHI_FLT)) { \ CopyVector (OUT[0].vector, V2[0].vector); \ opihi_int M1 = V1[0].IntValue; \ @@ -169,5 +359,5 @@ break; \ } \ - if ((FTYPE == 'S') && (V1->type == 's') && (V2->vector->type != OPIHI_FLT)) { \ + if ((FTYPE == ST_SCALAR_FLT) && (V1->type == ST_SCALAR_INT) && (V2->vector->type != OPIHI_FLT)) { \ MatchVector (OUT[0].vector, V2[0].vector, OPIHI_FLT); \ opihi_int M1 = V1[0].IntValue; \ @@ -179,5 +369,5 @@ break; \ } \ - if ((V1->type == 's') && (V2->vector->type != OPIHI_FLT)) { \ + if ((V1->type == ST_SCALAR_INT) && (V2->vector->type != OPIHI_FLT)) { \ CopyVector (OUT[0].vector, V2[0].vector); \ opihi_int M1 = V1[0].IntValue; \ @@ -192,25 +382,26 @@ switch (op[0]) { - case '+': SV_FUNC('s', M1 + *M2); - case '-': SV_FUNC('s', M1 - *M2); - case '*': SV_FUNC('s', M1 * *M2); - case '/': SV_FUNC('S', M1 / (opihi_flt) *M2); - case '%': SV_FUNC('s', (long long) M1 % (long long) *M2); - case '^': SV_FUNC('S', pow (M1, *M2)); - case '@': SV_FUNC('S', DEG_RAD*atan2 (M1, *M2)); - case 'D': SV_FUNC('s', MIN (M1, *M2)); - case 'U': SV_FUNC('s', MAX (M1, *M2)); - case '<': SV_FUNC('s', (M1 < *M2) ? 1 : 0); - case '>': SV_FUNC('s', (M1 > *M2) ? 1 : 0); - case '&': SV_FUNC('s', ((long long)M1 & (long long)*M2)); - case '|': SV_FUNC('s', ((long long)M1 | (long long)*M2)); - case 'E': SV_FUNC('s', (M1 == *M2) ? 1 : 0); - case 'N': SV_FUNC('s', (M1 != *M2) ? 1 : 0); - case 'L': SV_FUNC('s', (M1 <= *M2) ? 1 : 0); - case 'G': SV_FUNC('s', (M1 >= *M2) ? 1 : 0); - case 'A': SV_FUNC('s', (M1 && *M2) ? 1 : 0); - case 'O': SV_FUNC('s', (M1 || *M2) ? 1 : 0); + case '+': SV_FUNC(ST_SCALAR_INT, M1 + *M2); + case '-': SV_FUNC(ST_SCALAR_INT, M1 - *M2); + case '*': SV_FUNC(ST_SCALAR_INT, M1 * *M2); + case '/': SV_FUNC(ST_SCALAR_FLT, M1 / (opihi_flt) *M2); + case '%': SV_FUNC(ST_SCALAR_INT, (long long) M1 % (long long) *M2); + case '^': SV_FUNC(ST_SCALAR_FLT, pow (M1, *M2)); + case '@': SV_FUNC(ST_SCALAR_FLT, DEG_RAD*atan2 (M1, *M2)); + case 'a': SV_FUNC(ST_SCALAR_FLT, DEG_RAD*atan2 (M1, *M2)); + case 'D': SV_FUNC(ST_SCALAR_INT, MIN (M1, *M2)); + case 'U': SV_FUNC(ST_SCALAR_INT, MAX (M1, *M2)); + case '<': SV_FUNC(ST_SCALAR_INT, (M1 < *M2) ? 1 : 0); + case '>': SV_FUNC(ST_SCALAR_INT, (M1 > *M2) ? 1 : 0); + case '&': SV_FUNC(ST_SCALAR_INT, ((long long)M1 & (long long)*M2)); + case '|': SV_FUNC(ST_SCALAR_INT, ((long long)M1 | (long long)*M2)); + case 'E': SV_FUNC(ST_SCALAR_INT, (M1 == *M2) ? 1 : 0); + case 'N': SV_FUNC(ST_SCALAR_INT, (M1 != *M2) ? 1 : 0); + case 'L': SV_FUNC(ST_SCALAR_INT, (M1 <= *M2) ? 1 : 0); + case 'G': SV_FUNC(ST_SCALAR_INT, (M1 >= *M2) ? 1 : 0); + case 'A': SV_FUNC(ST_SCALAR_INT, (M1 && *M2) ? 1 : 0); + case 'O': SV_FUNC(ST_SCALAR_INT, (M1 || *M2) ? 1 : 0); default: - sprintf (line, "error: op %c not defined!", op[0]); + snprintf (line, 512, "error: op %c not defined!", op[0]); push_error (line); return (FALSE); @@ -219,5 +410,5 @@ /** free up any temporary buffers: **/ - if (V2[0].type == 'v') { + if (V2[0].type == ST_VECTOR_TMP) { free (V2[0].vector[0].elements.Ptr); free (V2[0].vector); @@ -240,10 +431,10 @@ OUT[0].vector = InitVector (); - OUT[0].type = 'v'; /*** <<--- says this is a temporary matrix ***/ + OUT[0].type = ST_VECTOR_TMP; /*** <<--- says this is a temporary matrix ***/ // set up the possible operations : int OP int -> int, all else yield float // OP is the operation performed on *M1 and *M2 # define VS_FUNC(FTYPE,OP) { \ - if ((V2->type == 'S') && (V1->vector->type == OPIHI_FLT)) { \ + if ((V2->type == ST_SCALAR_FLT) && (V1->vector->type == OPIHI_FLT)) { \ CopyVector (OUT[0].vector, V1[0].vector); \ opihi_flt *M1 = V1[0].vector[0].elements.Flt; \ @@ -255,5 +446,5 @@ break; \ } \ - if ((V2->type == 'S') && (V1->vector->type != OPIHI_FLT)) { \ + if ((V2->type == ST_SCALAR_FLT) && (V1->vector->type != OPIHI_FLT)) { \ MatchVector (OUT[0].vector, V1[0].vector, OPIHI_FLT); \ opihi_int *M1 = V1[0].vector[0].elements.Int; \ @@ -265,5 +456,5 @@ break; \ } \ - if ((V2->type == 's') && (V1->vector->type == OPIHI_FLT)) { \ + if ((V2->type == ST_SCALAR_INT) && (V1->vector->type == OPIHI_FLT)) { \ CopyVector (OUT[0].vector, V1[0].vector); \ opihi_flt *M1 = V1[0].vector[0].elements.Flt; \ @@ -275,5 +466,5 @@ break; \ } \ - if ((FTYPE == 'S') && (V2->type == 's') && (V1->vector->type != OPIHI_FLT)) { \ + if ((FTYPE == ST_SCALAR_FLT) && (V2->type == ST_SCALAR_INT) && (V1->vector->type != OPIHI_FLT)) { \ CopyVector (OUT[0].vector, V1[0].vector); \ opihi_int *M1 = V1[0].vector[0].elements.Int; \ @@ -285,5 +476,5 @@ break; \ } \ - if ((V2->type == 's') && (V1->vector->type != OPIHI_FLT)) { \ + if ((V2->type == ST_SCALAR_INT) && (V1->vector->type != OPIHI_FLT)) { \ CopyVector (OUT[0].vector, V1[0].vector); \ opihi_int *M1 = V1[0].vector[0].elements.Int; \ @@ -298,25 +489,26 @@ switch (op[0]) { - case '+': VS_FUNC('s', *M1 + M2); - case '-': VS_FUNC('s', *M1 - M2); - case '*': VS_FUNC('s', *M1 * M2); - case '/': VS_FUNC('S', *M1 / (opihi_flt) M2); - case '%': VS_FUNC('s', (long long) *M1 % (long long) M2); - case '^': VS_FUNC('S', pow (*M1, M2)); - case '@': VS_FUNC('S', DEG_RAD*atan2 (*M1, M2)); - case 'D': VS_FUNC('s', MIN (*M1, M2)); - case 'U': VS_FUNC('s', MAX (*M1, M2)); - case '<': VS_FUNC('s', (*M1 < M2) ? 1 : 0); - case '>': VS_FUNC('s', (*M1 > M2) ? 1 : 0); - case '&': VS_FUNC('s', ((long long)*M1 & (long long)M2)); - case '|': VS_FUNC('s', ((long long)*M1 | (long long)M2)); - case 'E': VS_FUNC('s', (*M1 == M2) ? 1 : 0); - case 'N': VS_FUNC('s', (*M1 != M2) ? 1 : 0); - case 'L': VS_FUNC('s', (*M1 <= M2) ? 1 : 0); - case 'G': VS_FUNC('s', (*M1 >= M2) ? 1 : 0); - case 'A': VS_FUNC('s', (*M1 && M2) ? 1 : 0); - case 'O': VS_FUNC('s', (*M1 || M2) ? 1 : 0); + case '+': VS_FUNC(ST_SCALAR_INT, *M1 + M2); + case '-': VS_FUNC(ST_SCALAR_INT, *M1 - M2); + case '*': VS_FUNC(ST_SCALAR_INT, *M1 * M2); + case '/': VS_FUNC(ST_SCALAR_FLT, *M1 / (opihi_flt) M2); + case '%': VS_FUNC(ST_SCALAR_INT, (long long) *M1 % (long long) M2); + case '^': VS_FUNC(ST_SCALAR_FLT, pow (*M1, M2)); + case '@': VS_FUNC(ST_SCALAR_FLT, DEG_RAD*atan2 (*M1, M2)); + case 'a': VS_FUNC(ST_SCALAR_FLT, DEG_RAD*atan2 (*M1, M2)); + case 'D': VS_FUNC(ST_SCALAR_INT, MIN (*M1, M2)); + case 'U': VS_FUNC(ST_SCALAR_INT, MAX (*M1, M2)); + case '<': VS_FUNC(ST_SCALAR_INT, (*M1 < M2) ? 1 : 0); + case '>': VS_FUNC(ST_SCALAR_INT, (*M1 > M2) ? 1 : 0); + case '&': VS_FUNC(ST_SCALAR_INT, ((long long)*M1 & (long long)M2)); + case '|': VS_FUNC(ST_SCALAR_INT, ((long long)*M1 | (long long)M2)); + case 'E': VS_FUNC(ST_SCALAR_INT, (*M1 == M2) ? 1 : 0); + case 'N': VS_FUNC(ST_SCALAR_INT, (*M1 != M2) ? 1 : 0); + case 'L': VS_FUNC(ST_SCALAR_INT, (*M1 <= M2) ? 1 : 0); + case 'G': VS_FUNC(ST_SCALAR_INT, (*M1 >= M2) ? 1 : 0); + case 'A': VS_FUNC(ST_SCALAR_INT, (*M1 && M2) ? 1 : 0); + case 'O': VS_FUNC(ST_SCALAR_INT, (*M1 || M2) ? 1 : 0); default: - sprintf (line, "error: op %c not defined!", op[0]); + snprintf (line, 512, "error: op %c not defined!", op[0]); push_error (line); return (FALSE); @@ -326,5 +518,5 @@ /** free up any temporary buffers: **/ - if (V1[0].type == 'v') { + if (V1[0].type == ST_VECTOR_TMP) { free (V1[0].vector[0].elements.Ptr); free (V1[0].vector); @@ -353,7 +545,7 @@ /* if possible, use V1 as temp buffer, otherwise create new one */ - if (V1[0].type == 'm') { + if (V1[0].type == ST_MATRIX_TMP) { OUT[0].buffer = V1[0].buffer; - V1[0].type = 'M'; /* prevent it from being freed below */ + V1[0].type = ST_MATRIX; /* prevent it from being freed below */ } else { /* do buffer.matrix.buffer and buffer.header.buffer get correctly zeroed? */ @@ -361,5 +553,5 @@ CopyBuffer (OUT[0].buffer, V1[0].buffer); } - OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/ + OUT[0].type = ST_MATRIX_TMP; /*** <<--- says this is a temporary matrix ***/ float *M1 = (float *) V1[0].buffer[0].matrix.buffer; @@ -395,4 +587,5 @@ case '^': MV_FUNC(pow (*M1, *M2)); case '@': MV_FUNC(DEG_RAD*atan2 (*M1, *M2)); + case 'a': MV_FUNC(DEG_RAD*atan2 (*M1, *M2)); case 'D': MV_FUNC(MIN (*M1, *M2)); case 'U': MV_FUNC(MAX (*M1, *M2)); @@ -408,5 +601,5 @@ case 'O': MV_FUNC((*M1 || *M2) ? 1 : 0); default: - sprintf (line, "error: op %c not defined!", op[0]); + snprintf (line, 512, "error: op %c not defined!", op[0]); push_error (line); return (FALSE); @@ -416,10 +609,10 @@ /** free up any temporary buffers: **/ - if (V1[0].type == 'm') { + if (V1[0].type == ST_MATRIX_TMP) { free (V1[0].buffer[0].header.buffer); free (V1[0].buffer[0].matrix.buffer); free (V1[0].buffer); } - if (V2[0].type == 'v') { + if (V2[0].type == ST_VECTOR_TMP) { free (V2[0].vector[0].elements.Ptr); free (V2[0].vector); @@ -446,12 +639,12 @@ /* if possible, use V2 as temp buffer, otherwise create new one */ - if (V2[0].type == 'm') { + if (V2[0].type == ST_MATRIX_TMP) { OUT[0].buffer = V2[0].buffer; - V2[0].type = 'M'; /* prevent it from being freed below */ + V2[0].type = ST_MATRIX; /* prevent it from being freed below */ } else { /* no spare temp buffer */ OUT[0].buffer = InitBuffer (); CopyBuffer (OUT[0].buffer, V2[0].buffer); } - OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/ + OUT[0].type = ST_MATRIX_TMP; /*** <<--- says this is a temporary matrix ***/ float *M2 = (float *) V2[0].buffer[0].matrix.buffer; @@ -487,4 +680,5 @@ case '^': VM_FUNC(pow (*M1, *M2)); case '@': VM_FUNC(DEG_RAD*atan2 (*M1, *M2)); + case 'a': VM_FUNC(DEG_RAD*atan2 (*M1, *M2)); case 'D': VM_FUNC(MIN (*M1, *M2)); case 'U': VM_FUNC(MAX (*M1, *M2)); @@ -500,5 +694,5 @@ case 'O': VM_FUNC((*M1 || *M2) ? 1 : 0); default: - sprintf (line, "error: op %c not defined!", op[0]); + snprintf (line, 512, "error: op %c not defined!", op[0]); push_error (line); return (FALSE); @@ -508,9 +702,9 @@ /** free up any temporary buffers: **/ - if (V1[0].type == 'v') { + if (V1[0].type == ST_VECTOR_TMP) { free (V1[0].vector[0].elements.Ptr); free (V1[0].vector); } - if (V2[0].type == 'm') { + if (V2[0].type == ST_MATRIX_TMP) { free (V2[0].buffer[0].header.buffer); free (V2[0].buffer[0].matrix.buffer); @@ -535,11 +729,11 @@ Ny = V1[0].buffer[0].matrix.Naxis[1]; - if (V1[0].type == 'm') { /** use V1 as temp buffer **/ + if (V1[0].type == ST_MATRIX_TMP) { /** use V1 as temp buffer **/ OUT[0].buffer = V1[0].buffer; - V1[0].type = 'M'; /* prevent it from being freed below */ + V1[0].type = ST_MATRIX; /* prevent it from being freed below */ } else { - if (V2[0].type == 'm') { /** use V2 as temp buffer, but header of V1 **/ + if (V2[0].type == ST_MATRIX_TMP) { /** use V2 as temp buffer, but header of V1 **/ OUT[0].buffer = V2[0].buffer; - V2[0].type = 'M'; /* prevent it from being freed below */ + V2[0].type = ST_MATRIX; /* prevent it from being freed below */ } else { /* no spare temp buffer */ OUT[0].buffer = InitBuffer (); @@ -547,5 +741,5 @@ } } - OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/ + OUT[0].type = ST_MATRIX_TMP; /*** <<--- says this is a temporary matrix ***/ M1 = (float *)V1[0].buffer[0].matrix.buffer; @@ -567,4 +761,5 @@ case '^': MM_FUNC(pow (*M1, *M2)); case '@': MM_FUNC(DEG_RAD*atan2 (*M1, *M2)); + case 'a': MM_FUNC(DEG_RAD*atan2 (*M1, *M2)); case 'D': MM_FUNC(MIN (*M1, *M2)); case 'U': MM_FUNC(MAX (*M1, *M2)); @@ -580,5 +775,5 @@ case 'O': MM_FUNC((*M1 || *M2) ? 1 : 0); default: - sprintf (line, "error: op %c not defined!", op[0]); + snprintf (line, 512, "error: op %c not defined!", op[0]); push_error (line); return (FALSE); @@ -588,10 +783,10 @@ /** free up any temporary buffers: **/ - if (V1[0].type == 'm') { + if (V1[0].type == ST_MATRIX_TMP) { free (V1[0].buffer[0].header.buffer); free (V1[0].buffer[0].matrix.buffer); free (V1[0].buffer); } - if (V2[0].type == 'm') { + if (V2[0].type == ST_MATRIX_TMP) { free (V2[0].buffer[0].header.buffer); free (V2[0].buffer[0].matrix.buffer); @@ -615,12 +810,12 @@ /* if possible, use V1 as temp buffer, otherwise create new one */ - if (V1[0].type == 'm') { + if (V1[0].type == ST_MATRIX_TMP) { OUT[0].buffer = V1[0].buffer; - V1[0].type = 'M'; /* prevent it from being freed below */ + V1[0].type = ST_MATRIX; /* prevent it from being freed below */ } else { OUT[0].buffer = InitBuffer (); CopyBuffer (OUT[0].buffer, V1[0].buffer); } - OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/ + OUT[0].type = ST_MATRIX_TMP; /*** <<--- says this is a temporary matrix ***/ float *M1 = (float *)V1[0].buffer[0].matrix.buffer; @@ -628,5 +823,5 @@ # define MS_FUNC(OP) { \ - if (V2->type == 'S') { \ + if (V2->type == ST_SCALAR_FLT) { \ opihi_flt M2 = V2[0].FltValue; \ for (i = 0; i < Nx*Ny; i++, out++, M1++) { \ @@ -635,5 +830,5 @@ break; \ } \ - if (V2->type == 's') { \ + if (V2->type == ST_SCALAR_INT) { \ opihi_int M2 = V2[0].IntValue; \ for (i = 0; i < Nx*Ny; i++, out++, M1++) { \ @@ -652,4 +847,5 @@ case '^': MS_FUNC(pow (*M1, M2)); case '@': MS_FUNC(DEG_RAD*atan2 (*M1, M2)); + case 'a': MS_FUNC(DEG_RAD*atan2 (*M1, M2)); case 'D': MS_FUNC(MIN (*M1, M2)); case 'U': MS_FUNC(MAX (*M1, M2)); @@ -665,5 +861,5 @@ case 'O': MS_FUNC((*M1 || M2) ? 1 : 0); default: - sprintf (line, "error: op %c not defined!", op[0]); + snprintf (line, 512, "error: op %c not defined!", op[0]); push_error (line); return (FALSE); @@ -671,5 +867,5 @@ # undef MS_FUNC - if (V1[0].type == 'm') { + if (V1[0].type == ST_MATRIX_TMP) { free (V1[0].buffer[0].header.buffer); free (V1[0].buffer[0].matrix.buffer); @@ -691,12 +887,12 @@ Ny = V2[0].buffer[0].matrix.Naxis[1]; - if (V2[0].type == 'm') { /* V2[0] is NOT temporary, we can't use it for storage */ + if (V2[0].type == ST_MATRIX_TMP) { /* V2[0] is NOT temporary, we can't use it for storage */ OUT[0].buffer = V2[0].buffer; - V2[0].type = 'M'; /* prevent it from being freed below */ + V2[0].type = ST_MATRIX; /* prevent it from being freed below */ } else { OUT[0].buffer = InitBuffer (); CopyBuffer (OUT[0].buffer, V2[0].buffer); } - OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/ + OUT[0].type = ST_MATRIX_TMP; /*** <<--- says this is a temporary matrix ***/ float *M2 = (float *)V2[0].buffer[0].matrix.buffer; @@ -704,5 +900,5 @@ # define SM_FUNC(OP) { \ - if (V1->type == 'S') { \ + if (V1->type == ST_SCALAR_FLT) { \ opihi_flt M1 = V1[0].FltValue; \ for (i = 0; i < Nx*Ny; i++, out++, M2++) { \ @@ -711,5 +907,5 @@ break; \ } \ - if (V1->type == 's') { \ + if (V1->type == ST_SCALAR_INT) { \ opihi_int M1 = V1[0].IntValue; \ for (i = 0; i < Nx*Ny; i++, out++, M2++) { \ @@ -728,4 +924,5 @@ case '^': SM_FUNC(pow (M1, *M2)); case '@': SM_FUNC(DEG_RAD*atan2 (M1, *M2)); + case 'a': SM_FUNC(DEG_RAD*atan2 (M1, *M2)); case 'D': SM_FUNC(MIN (M1, *M2)); case 'U': SM_FUNC(MAX (M1, *M2)); @@ -741,5 +938,5 @@ case 'O': SM_FUNC((M1 || *M2) ? 1 : 0); default: - sprintf (line, "error: op %c not defined!", op[0]); + snprintf (line, 512, "error: op %c not defined!", op[0]); push_error (line); return (FALSE); @@ -747,5 +944,5 @@ # undef SM_FUNC - if (V2[0].type == 'm') { + if (V2[0].type == ST_MATRIX_TMP) { free (V2[0].buffer[0].header.buffer); free (V2[0].buffer[0].matrix.buffer); @@ -764,36 +961,36 @@ # define SS_FUNC(FTYPE,OP) { \ - if ((V1->type == 'S') && (V2->type == 'S')) { \ + if ((V1->type == ST_SCALAR_FLT) && (V2->type == ST_SCALAR_FLT)) { \ opihi_flt M1 = V1[0].FltValue; \ opihi_flt M2 = V2[0].FltValue; \ - OUT[0].type = 'S'; \ + OUT[0].type = ST_SCALAR_FLT; \ OUT[0].FltValue = OP; \ break; \ } \ - if ((V1->type == 'S') && (V2->type == 's')) { \ + if ((V1->type == ST_SCALAR_FLT) && (V2->type == ST_SCALAR_INT)) { \ opihi_flt M1 = V1[0].FltValue; \ opihi_int M2 = V2[0].IntValue; \ - OUT[0].type = 'S'; \ + OUT[0].type = ST_SCALAR_FLT; \ OUT[0].FltValue = OP; \ break; \ } \ - if ((V1->type == 's') && (V2->type == 'S')) { \ + if ((V1->type == ST_SCALAR_INT) && (V2->type == ST_SCALAR_FLT)) { \ opihi_int M1 = V1[0].IntValue; \ opihi_flt M2 = V2[0].FltValue; \ - OUT[0].type = 'S'; \ + OUT[0].type = ST_SCALAR_FLT; \ OUT[0].FltValue = OP; \ break; \ } \ - if ((FTYPE == 'S') && (V1->type == 's') && (V2->type == 's')) { \ + if ((FTYPE == ST_SCALAR_FLT) && (V1->type == ST_SCALAR_INT) && (V2->type == ST_SCALAR_INT)) { \ opihi_int M1 = V1[0].IntValue; \ opihi_int M2 = V2[0].IntValue; \ - OUT[0].type = 'S'; \ + OUT[0].type = ST_SCALAR_FLT; \ OUT[0].FltValue = OP; \ break; \ } \ - if ((V1->type == 's') && (V2->type == 's')) { \ + if ((V1->type == ST_SCALAR_INT) && (V2->type == ST_SCALAR_INT)) { \ opihi_int M1 = V1[0].IntValue; \ opihi_int M2 = V2[0].IntValue; \ - OUT[0].type = 's'; \ + OUT[0].type = ST_SCALAR_INT; \ OUT[0].IntValue = OP; \ break; \ @@ -802,25 +999,26 @@ switch (op[0]) { - case '+': SS_FUNC('s', M1 + M2); - case '-': SS_FUNC('s', M1 - M2); - case '*': SS_FUNC('s', M1 * M2); - case '/': SS_FUNC('S', M1 / (opihi_flt) M2); - case '%': SS_FUNC('s', (long long) M1 % (long long) M2); - case '^': SS_FUNC('S', pow (M1, M2)); - case '@': SS_FUNC('S', DEG_RAD*atan2 (M1, M2)); - case 'D': SS_FUNC('s', MIN (M1, M2)); - case 'U': SS_FUNC('s', MAX (M1, M2)); - case '<': SS_FUNC('s', (M1 < M2) ? 1 : 0); - case '>': SS_FUNC('s', (M1 > M2) ? 1 : 0); - case '&': SS_FUNC('s', ((long long)M1 & (long long)M2)); - case '|': SS_FUNC('s', ((long long)M1 | (long long)M2)); - case 'E': SS_FUNC('s', (M1 == M2) ? 1 : 0); - case 'N': SS_FUNC('s', (M1 != M2) ? 1 : 0); - case 'L': SS_FUNC('s', (M1 <= M2) ? 1 : 0); - case 'G': SS_FUNC('s', (M1 >= M2) ? 1 : 0); - case 'A': SS_FUNC('s', (M1 && M2) ? 1 : 0); - case 'O': SS_FUNC('s', (M1 || M2) ? 1 : 0); + case '+': SS_FUNC(ST_SCALAR_INT, M1 + M2); + case '-': SS_FUNC(ST_SCALAR_INT, M1 - M2); + case '*': SS_FUNC(ST_SCALAR_INT, M1 * M2); + case '/': SS_FUNC(ST_SCALAR_FLT, M1 / (opihi_flt) M2); + case '%': SS_FUNC(ST_SCALAR_INT, (long long) M1 % (long long) M2); + case '^': SS_FUNC(ST_SCALAR_FLT, pow (M1, M2)); + case '@': SS_FUNC(ST_SCALAR_FLT, DEG_RAD*atan2 (M1, M2)); + case 'a': SS_FUNC(ST_SCALAR_FLT, DEG_RAD*atan2 (M1, M2)); + case 'D': SS_FUNC(ST_SCALAR_INT, MIN (M1, M2)); + case 'U': SS_FUNC(ST_SCALAR_INT, MAX (M1, M2)); + case '<': SS_FUNC(ST_SCALAR_INT, (M1 < M2) ? 1 : 0); + case '>': SS_FUNC(ST_SCALAR_INT, (M1 > M2) ? 1 : 0); + case '&': SS_FUNC(ST_SCALAR_INT, ((long long)M1 & (long long)M2)); + case '|': SS_FUNC(ST_SCALAR_INT, ((long long)M1 | (long long)M2)); + case 'E': SS_FUNC(ST_SCALAR_INT, (M1 == M2) ? 1 : 0); + case 'N': SS_FUNC(ST_SCALAR_INT, (M1 != M2) ? 1 : 0); + case 'L': SS_FUNC(ST_SCALAR_INT, (M1 <= M2) ? 1 : 0); + case 'G': SS_FUNC(ST_SCALAR_INT, (M1 >= M2) ? 1 : 0); + case 'A': SS_FUNC(ST_SCALAR_INT, (M1 && M2) ? 1 : 0); + case 'O': SS_FUNC(ST_SCALAR_INT, (M1 || M2) ? 1 : 0); default: - sprintf (line, "error: op %c not defined!", op[0]); + snprintf (line, 512, "error: op %c not defined!", op[0]); push_error (line); return (FALSE); @@ -844,5 +1042,5 @@ if ((op[0] != 'N') && (op[0] != 'E')) { - sprintf (line, "error: op %c not defined for string operations!", op[0]); + snprintf (line, 512, "error: op %c not defined for string operations!", op[0]); push_error (line); return (FALSE); @@ -853,9 +1051,17 @@ thus: string == number -> false */ - if (!strncasecmp (&V1[0].type, "S", 1)) { + if (V1[0].type == ST_SCALAR_INT) { value = (op[0] == 'N'); goto escape; } - if (!strncasecmp (&V2[0].type, "S", 1)) { + if (V1[0].type == ST_SCALAR_FLT) { + value = (op[0] == 'N'); + goto escape; + } + if (V2[0].type == ST_SCALAR_INT) { + value = (op[0] == 'N'); + goto escape; + } + if (V2[0].type == ST_SCALAR_FLT) { value = (op[0] == 'N'); goto escape; @@ -870,5 +1076,5 @@ break; default: - sprintf (line, "error: op %c not defined for string operations!", op[0]); + snprintf (line, 512, "error: op %c not defined for string operations!", op[0]); push_error (line); return (FALSE); @@ -877,5 +1083,5 @@ escape: OUT[0].FltValue = value; - OUT[0].type = 'S'; + OUT[0].type = ST_SCALAR_FLT; clear_stack (V1); @@ -891,21 +1097,21 @@ # define S_FUNC(OP,FTYPE) { \ - if (V1->type == 'S') { \ + if (V1->type == ST_SCALAR_FLT) { \ opihi_flt M1 = V1[0].FltValue; \ - OUT[0].type = 'S'; \ + OUT[0].type = ST_SCALAR_FLT; \ OUT[0].FltValue = OP; \ clear_stack (V1); \ return (TRUE); \ } \ - if ((FTYPE == 'S') && (V1->type == 's')) { \ + if ((FTYPE == ST_SCALAR_FLT) && (V1->type == ST_SCALAR_INT)) { \ opihi_int M1 = V1[0].IntValue; \ - OUT[0].type = 'S'; \ + OUT[0].type = ST_SCALAR_FLT; \ OUT[0].FltValue = OP; \ clear_stack (V1); \ return (TRUE); \ } \ - if ((FTYPE == 's') && (V1->type == 's')) { \ + if ((FTYPE == ST_SCALAR_INT) && (V1->type == ST_SCALAR_INT)) { \ opihi_int M1 = V1[0].IntValue; \ - OUT[0].type = 's'; \ + OUT[0].type = ST_SCALAR_INT; \ OUT[0].IntValue = OP; \ clear_stack (V1); \ @@ -914,40 +1120,43 @@ } - if (!strcmp (op, "=")) S_FUNC(M1, 's'); - if (!strcmp (op, "abs")) S_FUNC(fabs(M1), 's'); - if (!strcmp (op, "int")) S_FUNC((long long)(M1), 's'); - if (!strcmp (op, "exp")) S_FUNC(exp (M1), 'S'); - if (!strcmp (op, "ten")) S_FUNC(pow (10.0,M1), 'S'); - if (!strcmp (op, "log")) S_FUNC(log10 (M1), 'S'); - if (!strcmp (op, "ln")) S_FUNC(log (M1), 'S'); - if (!strcmp (op, "sqrt")) S_FUNC(sqrt (M1), 'S'); - if (!strcmp (op, "erf")) S_FUNC(erf (M1), 'S'); - if (!strcmp (op, "sinh")) S_FUNC(sinh (M1), 'S'); - if (!strcmp (op, "cosh")) S_FUNC(cosh (M1), 'S'); - if (!strcmp (op, "asinh")) S_FUNC(asinh (M1), 'S'); - if (!strcmp (op, "acosh")) S_FUNC(acosh (M1), 'S'); - if (!strcmp (op, "lgamma")) S_FUNC(lgamma (M1), 'S'); - if (!strcmp (op, "sin")) S_FUNC(sin (M1), 'S'); - if (!strcmp (op, "cos")) S_FUNC(cos (M1), 'S'); - if (!strcmp (op, "tan")) S_FUNC(tan (M1), 'S'); - if (!strcmp (op, "dsin")) S_FUNC(sin (M1*RAD_DEG), 'S'); - if (!strcmp (op, "dcos")) S_FUNC(cos (M1*RAD_DEG), 'S'); - if (!strcmp (op, "dtan")) S_FUNC(tan (M1*RAD_DEG), 'S'); - if (!strcmp (op, "asin")) S_FUNC(asin (M1), 'S'); - if (!strcmp (op, "acos")) S_FUNC(acos (M1), 'S'); - if (!strcmp (op, "atan")) S_FUNC(atan (M1), 'S'); - if (!strcmp (op, "dasin")) S_FUNC(asin (M1)*DEG_RAD, 'S'); - if (!strcmp (op, "dacos")) S_FUNC(acos (M1)*DEG_RAD, 'S'); - if (!strcmp (op, "datan")) S_FUNC(atan (M1)*DEG_RAD, 'S'); - if (!strcmp (op, "rnd")) S_FUNC(M1*0.0 + drand48(), 'S'); - if (!strcmp (op, "not")) S_FUNC(!(M1), 's'); - if (!strcmp (op, "--")) S_FUNC(-1*M1, 's'); // NOTE: opihi_int is signed, - if (!strcmp (op, "isinf")) S_FUNC(!finite(M1), 'S'); // XXX modify in future - if (!strcmp (op, "isnan")) S_FUNC(isnan(M1), 'S'); // XXX modify in future + if (!strcmp (op, "=")) S_FUNC(M1, ST_SCALAR_INT); + if (!strcmp (op, "abs")) S_FUNC(fabs(M1), ST_SCALAR_INT); + if (!strcmp (op, "int")) S_FUNC((long long)(M1), ST_SCALAR_INT); + if (!strcmp (op, "floor")) S_FUNC(floor (M1), ST_SCALAR_FLT); + if (!strcmp (op, "ceil")) S_FUNC(ceil (M1), ST_SCALAR_FLT); + // if (!strcmp (op, "rint")) S_FUNC(nearbyint (M1), ST_SCALAR_FLT); + if (!strcmp (op, "exp")) S_FUNC(exp (M1), ST_SCALAR_FLT); + if (!strcmp (op, "ten")) S_FUNC(pow (10.0,M1), ST_SCALAR_FLT); + if (!strcmp (op, "log")) S_FUNC(log10 (M1), ST_SCALAR_FLT); + if (!strcmp (op, "ln")) S_FUNC(log (M1), ST_SCALAR_FLT); + if (!strcmp (op, "sqrt")) S_FUNC(sqrt (M1), ST_SCALAR_FLT); + if (!strcmp (op, "erf")) S_FUNC(erf (M1), ST_SCALAR_FLT); + if (!strcmp (op, "sinh")) S_FUNC(sinh (M1), ST_SCALAR_FLT); + if (!strcmp (op, "cosh")) S_FUNC(cosh (M1), ST_SCALAR_FLT); + if (!strcmp (op, "asinh")) S_FUNC(asinh (M1), ST_SCALAR_FLT); + if (!strcmp (op, "acosh")) S_FUNC(acosh (M1), ST_SCALAR_FLT); + if (!strcmp (op, "lgamma")) S_FUNC(lgamma (M1), ST_SCALAR_FLT); + if (!strcmp (op, "sin")) S_FUNC(sin (M1), ST_SCALAR_FLT); + if (!strcmp (op, "cos")) S_FUNC(cos (M1), ST_SCALAR_FLT); + if (!strcmp (op, "tan")) S_FUNC(tan (M1), ST_SCALAR_FLT); + if (!strcmp (op, "dsin")) S_FUNC(sin (M1*RAD_DEG), ST_SCALAR_FLT); + if (!strcmp (op, "dcos")) S_FUNC(cos (M1*RAD_DEG), ST_SCALAR_FLT); + if (!strcmp (op, "dtan")) S_FUNC(tan (M1*RAD_DEG), ST_SCALAR_FLT); + if (!strcmp (op, "asin")) S_FUNC(asin (M1), ST_SCALAR_FLT); + if (!strcmp (op, "acos")) S_FUNC(acos (M1), ST_SCALAR_FLT); + if (!strcmp (op, "atan")) S_FUNC(atan (M1), ST_SCALAR_FLT); + if (!strcmp (op, "dasin")) S_FUNC(asin (M1)*DEG_RAD, ST_SCALAR_FLT); + if (!strcmp (op, "dacos")) S_FUNC(acos (M1)*DEG_RAD, ST_SCALAR_FLT); + if (!strcmp (op, "datan")) S_FUNC(atan (M1)*DEG_RAD, ST_SCALAR_FLT); + if (!strcmp (op, "rnd")) S_FUNC(M1*0.0 + drand48(), ST_SCALAR_FLT); + if (!strcmp (op, "not")) S_FUNC(!(M1), ST_SCALAR_INT); + if (!strcmp (op, "--")) S_FUNC(-1*M1, ST_SCALAR_INT); // NOTE: opihi_int is signed, + if (!strcmp (op, "isinf")) S_FUNC(!finite(M1), ST_SCALAR_FLT); // XXX modify in future + if (!strcmp (op, "isnan")) S_FUNC(isnan(M1), ST_SCALAR_FLT); // XXX modify in future # undef S_FUNC clear_stack (V1); - sprintf (line, "error: op %s not defined!", op); + snprintf (line, 512, "error: op %s not defined!", op); push_error (line); return (FALSE); @@ -962,5 +1171,5 @@ OUT[0].vector = InitVector (); - OUT[0].type = 'v'; /*** <<--- says this is a temporary matrix ***/ + OUT[0].type = ST_VECTOR_TMP; /*** <<--- says this is a temporary matrix ***/ # define V_FUNC(OP,FTYPE) { \ @@ -974,5 +1183,5 @@ goto escape; \ } \ - if ((V1->vector->type == OPIHI_INT) && (FTYPE == 'S')) { \ + if ((V1->vector->type == OPIHI_INT) && (FTYPE == ST_SCALAR_FLT)) { \ MatchVector (OUT[0].vector, V1[0].vector, OPIHI_FLT); \ opihi_int *M1 = V1[0].vector[0].elements.Int; \ @@ -983,5 +1192,5 @@ goto escape; \ } \ - if ((V1->vector->type == OPIHI_INT) && (FTYPE == 's')) { \ + if ((V1->vector->type == OPIHI_INT) && (FTYPE == ST_SCALAR_INT)) { \ CopyVector (OUT[0].vector, V1[0].vector); \ opihi_int *M1 = V1[0].vector[0].elements.Int; \ @@ -993,39 +1202,42 @@ } } - if (!strcmp (op, "=")) V_FUNC(*M1, 's'); - if (!strcmp (op, "abs")) V_FUNC(fabs(*M1), 's'); - if (!strcmp (op, "int")) V_FUNC((long long)(*M1), 's'); - if (!strcmp (op, "exp")) V_FUNC(exp(*M1), 'S'); - if (!strcmp (op, "ten")) V_FUNC(pow(10.0,*M1), 'S'); - if (!strcmp (op, "log")) V_FUNC(log10(*M1), 'S'); - if (!strcmp (op, "ln")) V_FUNC(log(*M1), 'S'); - if (!strcmp (op, "sqrt")) V_FUNC(sqrt(*M1), 'S'); - if (!strcmp (op, "erf")) V_FUNC(erf(*M1), 'S'); - if (!strcmp (op, "sinh")) V_FUNC(sinh(*M1), 'S'); - if (!strcmp (op, "cosh")) V_FUNC(cosh(*M1), 'S'); - if (!strcmp (op, "asinh")) V_FUNC(asinh(*M1), 'S'); - if (!strcmp (op, "acosh")) V_FUNC(acosh(*M1), 'S'); - if (!strcmp (op, "lgamma")) V_FUNC(lgamma(*M1), 'S'); - if (!strcmp (op, "sin")) V_FUNC(sin(*M1), 'S'); - if (!strcmp (op, "cos")) V_FUNC(cos(*M1), 'S'); - if (!strcmp (op, "tan")) V_FUNC(tan(*M1), 'S'); - if (!strcmp (op, "dsin")) V_FUNC(sin(*M1*RAD_DEG), 'S'); - if (!strcmp (op, "dcos")) V_FUNC(cos(*M1*RAD_DEG), 'S'); - if (!strcmp (op, "dtan")) V_FUNC(tan(*M1*RAD_DEG), 'S'); - if (!strcmp (op, "asin")) V_FUNC(asin(*M1), 'S'); - if (!strcmp (op, "acos")) V_FUNC(acos(*M1), 'S'); - if (!strcmp (op, "atan")) V_FUNC(atan(*M1), 'S'); - if (!strcmp (op, "dasin")) V_FUNC(asin(*M1)*DEG_RAD, 'S'); - if (!strcmp (op, "dacos")) V_FUNC(acos(*M1)*DEG_RAD, 'S'); - if (!strcmp (op, "datan")) V_FUNC(atan(*M1)*DEG_RAD, 'S'); - if (!strcmp (op, "rnd")) V_FUNC(drand48(), 'S'); - if (!strcmp (op, "ramp")) V_FUNC(i, 's'); - if (!strcmp (op, "zero")) V_FUNC(0, 's'); - if (!strcmp (op, "not")) V_FUNC(!(*M1), 's'); - if (!strcmp (op, "--")) V_FUNC(-1*(*M1), 's'); // NOTE: opihi_int is signed - if (!strcmp (op, "isinf")) V_FUNC(!finite(*M1), 'S'); - if (!strcmp (op, "isnan")) V_FUNC(isnan(*M1), 'S'); - if (!strcmp (op, "xramp")) V_FUNC(i, 's'); - if (!strcmp (op, "yramp")) V_FUNC(0, 's'); + if (!strcmp (op, "=")) V_FUNC(*M1, ST_SCALAR_INT); + if (!strcmp (op, "abs")) V_FUNC(fabs(*M1), ST_SCALAR_INT); + if (!strcmp (op, "int")) V_FUNC((long long)(*M1), ST_SCALAR_INT); + if (!strcmp (op, "floor")) V_FUNC(floor (*M1), ST_SCALAR_FLT); + if (!strcmp (op, "ceil")) V_FUNC(ceil (*M1), ST_SCALAR_FLT); + // if (!strcmp (op, "rint")) V_FUNC(nearbyint (*M1), ST_SCALAR_FLT); + if (!strcmp (op, "exp")) V_FUNC(exp(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "ten")) V_FUNC(pow(10.0,*M1), ST_SCALAR_FLT); + if (!strcmp (op, "log")) V_FUNC(log10(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "ln")) V_FUNC(log(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "sqrt")) V_FUNC(sqrt(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "erf")) V_FUNC(erf(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "sinh")) V_FUNC(sinh(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "cosh")) V_FUNC(cosh(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "asinh")) V_FUNC(asinh(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "acosh")) V_FUNC(acosh(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "lgamma")) V_FUNC(lgamma(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "sin")) V_FUNC(sin(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "cos")) V_FUNC(cos(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "tan")) V_FUNC(tan(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "dsin")) V_FUNC(sin(*M1*RAD_DEG), ST_SCALAR_FLT); + if (!strcmp (op, "dcos")) V_FUNC(cos(*M1*RAD_DEG), ST_SCALAR_FLT); + if (!strcmp (op, "dtan")) V_FUNC(tan(*M1*RAD_DEG), ST_SCALAR_FLT); + if (!strcmp (op, "asin")) V_FUNC(asin(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "acos")) V_FUNC(acos(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "atan")) V_FUNC(atan(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "dasin")) V_FUNC(asin(*M1)*DEG_RAD, ST_SCALAR_FLT); + if (!strcmp (op, "dacos")) V_FUNC(acos(*M1)*DEG_RAD, ST_SCALAR_FLT); + if (!strcmp (op, "datan")) V_FUNC(atan(*M1)*DEG_RAD, ST_SCALAR_FLT); + if (!strcmp (op, "rnd")) V_FUNC(drand48(), ST_SCALAR_FLT); + if (!strcmp (op, "ramp")) V_FUNC(i, ST_SCALAR_INT); + if (!strcmp (op, "zero")) V_FUNC(0, ST_SCALAR_INT); + if (!strcmp (op, "not")) V_FUNC(!(*M1), ST_SCALAR_INT); + if (!strcmp (op, "--")) V_FUNC(-1*(*M1), ST_SCALAR_INT); // NOTE: opihi_int is signed + if (!strcmp (op, "isinf")) V_FUNC(!finite(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "isnan")) V_FUNC(isnan(*M1), ST_SCALAR_FLT); + if (!strcmp (op, "xramp")) V_FUNC(i, ST_SCALAR_INT); + if (!strcmp (op, "yramp")) V_FUNC(0, ST_SCALAR_INT); /* xramp and yramp above only make sense for matrices. for vectors, xramp = ramp, yramp = zero */ @@ -1034,5 +1246,5 @@ escape: - if (V1[0].type == 'v') { + if (V1[0].type == ST_VECTOR_TMP) { free (V1[0].vector[0].elements.Ptr); free (V1[0].vector); @@ -1053,12 +1265,12 @@ Ny = V1[0].buffer[0].matrix.Naxis[1]; - if (V1[0].type == 'm') { + if (V1[0].type == ST_MATRIX_TMP) { OUT[0].buffer = V1[0].buffer; - V1[0].type = 'M'; /* prevent it from being freed below */ + V1[0].type = ST_MATRIX; /* prevent it from being freed below */ } else { OUT[0].buffer = InitBuffer (); CopyBuffer (OUT[0].buffer, V1[0].buffer); } - OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/ + OUT[0].type = ST_MATRIX_TMP; /*** <<--- says this is a temporary matrix ***/ M1 = (float *) V1[0].buffer[0].matrix.buffer; out = (float *)OUT[0].buffer[0].matrix.buffer; @@ -1067,4 +1279,9 @@ if (!strcmp (op, "abs")) { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = fabs(*M1); }} if (!strcmp (op, "int")) { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = (opihi_flt)(long long)(*M1); }} + + if (!strcmp (op, "floor")) { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = floor (*M1); }} + if (!strcmp (op, "ceil")) { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = ceil (*M1); }} + // if (!strcmp (op, "rint")) { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = nearbyint (*M1); }} + if (!strcmp (op, "exp")) { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = exp(*M1); }} if (!strcmp (op, "ten")) { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = pow(10.0,*M1); }} @@ -1116,5 +1333,5 @@ } - if (V1[0].type == 'm') { + if (V1[0].type == ST_MATRIX_TMP) { free (V1[0].buffer[0].header.buffer); free (V1[0].buffer[0].matrix.buffer); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/string.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/string.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/string.c (revision 37067) @@ -322,2 +322,31 @@ } +int set_list_varname (char *line, char *base, int N, int excelStyle) { + + int i; + + // A-Z correspond to 0 - 25 + + if (excelStyle) { + float f = log(26.0); + float g = (N == 0) ? 0.0 : log(1.0*N); + int Ndigit = (int) (g / f) + 1; + if (Ndigit > 10) { + sprintf (line, "%s:ZZZZZZZZZZ", base); + return FALSE; + } + char name[12]; + memset (name, 0, 12); + for (i = 0; i < Ndigit; i++) { + float Npow = Ndigit - i - 1; + float g = pow(26.0, Npow); + int V = (int) (N / g); + name[i] = (Npow == 0.0) ? 'A' + V : 'A' + V - 1; + N -= V * g; + } + sprintf (line, "%s:%s", base, name); + } else { + sprintf (line, "%s:%d", base, N); + } + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/CheckController.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/CheckController.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/CheckController.c (revision 37067) @@ -29,10 +29,23 @@ if (p != NULL) goto escape; + /** skip past any leading garbage? ***/ + + /** find "Njobs: **/ + p = memstr (buffer.buffer, "BEGIN BLOCK Njobs:", MIN(buffer.Nbuffer, 256)); + p += strlen("BEGIN BLOCK Njobs:"); + /** parse job list **/ - status = sscanf (buffer.buffer, "%*s %d", &Njobs); + status = sscanf (p, "%d", &Njobs); if (status != 1) goto escape; if (VerboseMode()) gprint (GP_ERR, "parse %d jobs on stack %f\n", Njobs, TimerElapsed(&start, TRUE)); - p = buffer.buffer; + /* output looks like: + BEGIN BLOCK Njobs: NN\n + ID name machine\n + ID name machine\n + */ + + // p is currently pointing at "BEGIN BLOCK Njobs" + for (i = 0; i < Njobs; i++) { q = strchr (p, '\n'); @@ -67,10 +80,23 @@ if (p != NULL) goto escape; + /** skip past any leading garbage? ***/ + + /** find "Njobs: **/ + p = memstr (buffer.buffer, "BEGIN BLOCK Njobs:", MIN(buffer.Nbuffer, 256)); + p += strlen("BEGIN BLOCK Njobs:"); + /** parse job list **/ - status = sscanf (buffer.buffer, "%*s %d", &Njobs); + status = sscanf (p, "%d", &Njobs); if (status != 1) goto escape; if (VerboseMode()) gprint (GP_ERR, "check crash stack %f\n", TimerElapsed(&start, TRUE)); - p = buffer.buffer; + /* output looks like: + BEGIN BLOCK Njobs: NN\n + ID name machine\n + ID name machine\n + */ + + // p is currently pointing at "BEGIN BLOCK Njobs" + for (i = 0; i < Njobs; i++) { q = strchr (p, '\n'); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/ControllerOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/ControllerOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/ControllerOps.c (revision 37067) @@ -259,7 +259,7 @@ } - if (job[0].priority) { + if (job[0].nicelevel) { char tmp[64]; - snprintf (tmp, 64, " -nice %d", job[0].priority); + snprintf (tmp, 64, " -nice %d", job[0].nicelevel); strcat (cmd, tmp); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/JobOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/JobOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/JobOps.c (revision 37067) @@ -107,5 +107,5 @@ job[0].mode = JOB_CONTROLLER; } - job[0].priority = task[0].priority; + job[0].nicelevel = task[0].nicelevel; /* we need our own copy of task[0].argv argc is the number of valid args, like the usual command line. we Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/LocalJob.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/LocalJob.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/LocalJob.c (revision 37067) @@ -162,8 +162,8 @@ /* set nice level for the child process -- maybe I should not exit here... */ - if (job[0].priority) { - status = setpriority (PRIO_PROCESS, pid, job[0].priority); + if (job[0].nicelevel) { + status = setpriority (PRIO_PROCESS, pid, job[0].nicelevel); if (status == -1) { - gprint (GP_ERR, "error setting priority\n"); + gprint (GP_ERR, "error setting nice level\n"); perror ("setpriority: "); exit (2); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/TaskOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/TaskOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/TaskOps.c (revision 37067) @@ -487,5 +487,5 @@ NewTask[0].active = TRUE; - NewTask[0].priority = 0; + NewTask[0].nicelevel = 0; return (NewTask); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/init.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/init.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/init.c (revision 37067) @@ -34,5 +34,5 @@ {1, "halt", halt, "halt the scheduler (no job harvesting)"}, {1, "host", task_host, "define host machine for a task"}, - {1, "nice", task_nice, "set nice priority level for a task"}, + {1, "nice", task_nice, "set nice level for a task"}, {1, "ipptool2book", ipptool2book, "convert queue with ipptool output to book"}, {1, "kill", kill_job, "kill job"}, Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/init_server.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/init_server.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/init_server.c (revision 37067) @@ -35,5 +35,5 @@ {1, "delete", delete_job, "delete job"}, {1, "host", task_host, "define host machine for a task"}, - {1, "nice", task_nice, "set nice priority level for a task"}, + {1, "nice", task_nice, "set nice level for a task"}, {1, "ipptool2book", ipptool2book, "convert queue with ipptool output to book"}, {1, "kill", kill_job, "kill job"}, Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/task_nice.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/task_nice.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/task_nice.c (revision 37067) @@ -4,9 +4,9 @@ char *endptr = NULL; - int priority; + int nicelevel; Task *task; if (argc != 2) { - gprint (GP_ERR, "USAGE: nice (priority)\n"); + gprint (GP_ERR, "USAGE: nice (nicelevel)\n"); return (FALSE); } @@ -20,15 +20,15 @@ } - priority = strtol (argv[1], &endptr, 10); + nicelevel = strtol (argv[1], &endptr, 10); if (*endptr) goto fail; - if (priority < 0) goto fail; - if (priority > 20) goto fail; + if (nicelevel < 0) goto fail; + if (nicelevel > 20) goto fail; - task[0].priority = priority; + task[0].nicelevel = nicelevel; JobTaskUnlock(); return (TRUE); fail: - gprint (GP_ERR, "ERROR: nice (priority) -- priority must be an integer 0 to 20\n"); + gprint (GP_ERR, "ERROR: nice (nicelevel) -- nicelevel must be an integer 0 to 20\n"); return (FALSE); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pclient/job.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pclient/job.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pclient/job.c (revision 37067) @@ -3,11 +3,11 @@ int job (int argc, char **argv) { - int i, N, pid, status, priority; + int i, N, pid, status, nicelevel; char **targv; - priority = 0; + nicelevel = 0; if ((N = get_argument (argc, argv, "-nice"))) { remove_argument (N, &argc, argv); - priority = atoi (argv[N]); + nicelevel = atoi (argv[N]); remove_argument (N, &argc, argv); } @@ -62,8 +62,8 @@ /* set nice level for the child process */ - if (priority) { - status = setpriority (PRIO_PROCESS, pid, priority); + if (nicelevel) { + status = setpriority (PRIO_PROCESS, pid, nicelevel); if (status == -1) { - gprint (GP_ERR, "error setting priority\n"); + gprint (GP_ERR, "error setting nicelevel\n"); perror ("setpriority: "); exit (2); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/CheckBusyJob.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/CheckBusyJob.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/CheckBusyJob.c (revision 37067) @@ -99,6 +99,6 @@ // XXX runaway job if output too large? - if (job[0].stdout_buf.size > 0x1000000) abort(); - if (job[0].stderr_buf.size > 0x1000000) abort(); + if (job[0].stdout_buf.size > 0x10000000) abort(); + if (job[0].stderr_buf.size > 0x10000000) abort(); // job has exited : move to DONE stack Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/JobOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/JobOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/JobOps.c (revision 37067) @@ -61,4 +61,16 @@ } +int GetJobStackIDbyName (char *name) { + if (!strcasecmp (name, "ALLJOBS")) return PCONTROL_JOB_ALLJOBS; + if (!strcasecmp (name, "PENDING")) return PCONTROL_JOB_PENDING; + if (!strcasecmp (name, "BUSY")) return PCONTROL_JOB_BUSY ; + if (!strcasecmp (name, "RESP")) return PCONTROL_JOB_RESP ; + if (!strcasecmp (name, "DONE")) return PCONTROL_JOB_DONE ; + if (!strcasecmp (name, "KILL")) return PCONTROL_JOB_KILL ; + if (!strcasecmp (name, "EXIT")) return PCONTROL_JOB_EXIT ; + if (!strcasecmp (name, "CRASH")) return PCONTROL_JOB_CRASH ; + return (PCONTROL_JOB_NONE); +} + Stack *GetJobStack (int StackID) { switch (StackID) { @@ -195,5 +207,5 @@ } -IDtype AddJob (char *hostname, JobMode mode, int timeout, int priority, int argc, char **argv, int Nxhosts, char **xhosts) { +IDtype AddJob (char *hostname, JobMode mode, int timeout, int nicelevel, int argc, char **argv, int Nxhosts, char **xhosts) { int JobID; @@ -220,5 +232,5 @@ job[0].mode = mode; - job[0].priority = priority; + job[0].nicelevel = nicelevel; job[0].state = 0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/StartJob.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/StartJob.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/StartJob.c (revision 37067) @@ -25,7 +25,7 @@ bzero (line, Nline); strcpy (line, "job"); - if (job[0].priority) { + if (job[0].nicelevel) { char tmp[64]; - snprintf (tmp, 64, " -nice %d", job[0].priority); + snprintf (tmp, 64, " -nice %d", job[0].nicelevel); strcat (line, tmp); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/job.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/job.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/job.c (revision 37067) @@ -5,5 +5,5 @@ char *Host = NULL; char **targv = NULL; - int i, N, Mode, targc, Timeout, priority; + int i, N, Mode, targc, Timeout, nicelevel; IDtype JobID; char **xhosts = NULL; @@ -43,8 +43,8 @@ } - priority = 0; + nicelevel = 0; if ((N = get_argument (argc, argv, "-nice"))) { remove_argument (N, &argc, argv); - priority = atoi (argv[N]); + nicelevel = atoi (argv[N]); remove_argument (N, &argc, argv); } @@ -76,5 +76,5 @@ // a JobID < 0 mean the job was not accepted - JobID = AddJob (Host, Mode, Timeout, priority, targc, targv, Nxhosts, xhosts); + JobID = AddJob (Host, Mode, Timeout, nicelevel, targc, targv, Nxhosts, xhosts); gprint (GP_LOG, "JobID: %d\n", (int) JobID); return (TRUE); @@ -82,5 +82,5 @@ usage: gprint (GP_ERR, "USAGE: job [options] (arg0) (arg1) ... (argN)\n"); - gprint (GP_ERR, " options: -host, +host, -timeout, -xhost (host)\n"); + gprint (GP_ERR, " options: -host, +host, -timeout, -xhost (host) -nice (level)\n"); gprint (GP_ERR, " arguments of the form @MAX_THREADS@ will be replaced when the job is launched\n"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/jobstack.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/jobstack.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/jobstack.c (revision 37067) @@ -22,5 +22,5 @@ /* print list */ LockStack (stack); - gprint (GP_LOG, "Njobs: %d\n", stack[0].Nobject); + gprint (GP_LOG, "BEGIN BLOCK Njobs: %d\n", stack[0].Nobject); for (i = 0; i < stack[0].Nobject; i++) { job = stack[0].object[i]; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/status.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/status.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/status.c (revision 37067) @@ -1,16 +1,93 @@ # include "pcontrol.h" -int PrintJobStack (int Nstack); +int PrintJobStack (int Nstack, char *command, char *hostname, int state, float age); int PrintHostStack (int Nstack); int status (int argc, char **argv) { - PrintJobStack (PCONTROL_JOB_ALLJOBS); - PrintHostStack (PCONTROL_HOST_ALLHOSTS); + int N; + + if (get_argument (argc, argv, "-h")) goto usage; + if (get_argument (argc, argv, "-help")) goto usage; + if (get_argument (argc, argv, "--help")) goto usage; + + /* I would like to add the following options: + * strsub on argv[0] + * strsub on hostname, realhost + * list hostname and realhost + * filter by state + * filter by dtime + */ + + // -cmd (cmd) + // -host (hostname) + // -state (busy, pending, done, kill, exit, crash, resp, hung + // -age (seconds?) (minutes?) + // -nohost + + char *COMMAND = NULL; + if ((N = get_argument (argc, argv, "-cmd"))) { + remove_argument (N, &argc, argv); + COMMAND = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + + char *HOSTNAME = NULL; + if ((N = get_argument (argc, argv, "-host"))) { + remove_argument (N, &argc, argv); + HOSTNAME = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + + int STATE = PCONTROL_JOB_ALLJOBS; + if ((N = get_argument (argc, argv, "-state"))) { + remove_argument (N, &argc, argv); + STATE = GetJobStackIDbyName (argv[N]); + remove_argument (N, &argc, argv); + if (STATE == PCONTROL_JOB_NONE) goto usage; + } + + float AGE = 0.0; + if ((N = get_argument (argc, argv, "-age"))) { + remove_argument (N, &argc, argv); + AGE = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + int SHOWHOST = TRUE; + if ((N = get_argument (argc, argv, "-nohost"))) { + remove_argument (N, &argc, argv); + SHOWHOST = FALSE; + } + if ((N = get_argument (argc, argv, "+jobs"))) { + remove_argument (N, &argc, argv); + SHOWHOST = FALSE; + } + + int SHOWJOBS = TRUE; + if ((N = get_argument (argc, argv, "-nojobs"))) { + remove_argument (N, &argc, argv); + SHOWJOBS = FALSE; + } + if ((N = get_argument (argc, argv, "+host"))) { + remove_argument (N, &argc, argv); + SHOWJOBS = FALSE; + } + + if (SHOWJOBS) { + PrintJobStack (PCONTROL_JOB_ALLJOBS, COMMAND, HOSTNAME, STATE, AGE); + } + if (SHOWHOST) { + PrintHostStack (PCONTROL_HOST_ALLHOSTS); + } return (TRUE); + +usage: + gprint (GP_ERR, "USAGE: status [-cmd command] [-host hostname] [-state state] [-age seconds] [+jobs,-nohost] [+host,-nojobs]\n"); + return FALSE; } -int PrintJobStack (int Nstack) { +int PrintJobStack (int Nstack, char *command, char *hostname, int state, float age) { int i, j, Nobject; @@ -30,10 +107,6 @@ job = stack[0].object[i]; ASSERT (job != NULL, "programming error"); - if (job[0].realhost == NULL) { - gprint (GP_LOG, "%3d %9s ", i, job[0].hostname); - } else { - gprint (GP_LOG, "%3d %9s ", i, job[0].realhost); - } - gprint (GP_LOG, "%7s ", GetJobStackName (job[0].state)); + + char *thishost = (job[0].realhost == NULL) ? job[0].hostname : job[0].realhost; switch (job[0].state) { @@ -45,5 +118,4 @@ gettimeofday (&now, (void *) NULL); dtime = DTIME (now, job[0].start); - gprint (GP_LOG, "%8.2f ", dtime); break; @@ -55,10 +127,32 @@ default: dtime = DTIME (job[0].stop, job[0].start); - gprint (GP_LOG, "%8.2f ", dtime); break; } + // check on the filters + if (command) { + if (!strstr (job[0].argv[0], command)) continue; + } + if (hostname) { + if (!strstr (thishost, hostname)) continue; + } + if (age > 0.0) { + if (dtime < age) continue; + } + if (state != PCONTROL_JOB_ALLJOBS) { + // allow PCONTROL_JOB_RESP == BUSY + int validState = FALSE; + validState |= (state == PCONTROL_JOB_RESP) && (job[0].state == PCONTROL_JOB_BUSY); + validState |= (state == PCONTROL_JOB_BUSY) && (job[0].state == PCONTROL_JOB_RESP); + validState |= (state == job[0].state); + if (!validState) continue; + } + + gprint (GP_LOG, "%3d %9s ", i, thishost); + gprint (GP_LOG, "%7s ", GetJobStackName (job[0].state)); + gprint (GP_LOG, "%8.2f ", dtime); + PrintID (GP_LOG, job[0].JobID); - gprint (GP_LOG, " %2d ", job[0].priority); + gprint (GP_LOG, " %2d ", job[0].nicelevel); for (j = 0; j < job[0].argc; j++) { gprint (GP_LOG, "%s ", job[0].argv[j]); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/Makefile (revision 37067) @@ -31,4 +31,5 @@ $(SRC)/args.$(ARCH).o \ $(SRC)/copy_images.$(ARCH).o \ +$(SRC)/select_images.$(ARCH).o \ $(SRC)/Shutdown.$(ARCH).o \ $(SRC)/join_stars.$(ARCH).o \ @@ -41,5 +42,4 @@ $(SRC)/ConfigInit.$(ARCH).o \ $(SRC)/args.$(ARCH).o \ -$(SRC)/copy_images.$(ARCH).o \ $(SRC)/Shutdown.$(ARCH).o \ $(SRC)/join_stars.$(ARCH).o \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/include/photdbc.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/include/photdbc.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/include/photdbc.h (revision 37067) @@ -20,4 +20,11 @@ int Nmeas; } StatType; + +typedef struct { + double Xc[5]; + double Yc[5]; + double Rc; + double Dc; +} SkyRegionCoords; int PARALLEL; @@ -80,7 +87,7 @@ PhotCodeData photcodes; -char *PHOTCODE_DROP_LIST, *PHOTCODE_SKIP_LIST; -int NphotcodesDrop, NphotcodesSkip; -PhotCode **photcodesDrop, **photcodesSkip; +char *PHOTCODE_DROP_LIST, *PHOTCODE_KEEP_LIST; +int NphotcodesDrop, NphotcodesKeep; +PhotCode **photcodesDrop, **photcodesKeep; # define FLAG_AREA 0X0001 @@ -131,6 +138,11 @@ void SetProtect (int mode); int SetSignals (void); -int copy_images (char *outdir); +int copy_images (char *outdir, SkyList *skylist); void usage(); + +void dsortindex (double *X, off_t *Y, int N); +off_t getRegionStartByRA (double R, double *Rref, off_t Nregions); + +Image *select_images (SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage, int UseFullOverlap); int photdbc_catalogs (char *outroot, SkyList *skylist, int hostID); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/args.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/args.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/args.c (revision 37067) @@ -85,4 +85,5 @@ } + // measurements with these photcodes are not copied to the output PHOTCODE_DROP_LIST = NULL; if ((N = get_argument (argc, argv, "-photcode-drop"))) { @@ -92,8 +93,11 @@ } - PHOTCODE_SKIP_LIST = NULL; - if ((N = get_argument (argc, argv, "-photcode-skip"))) { - remove_argument (N, &argc, argv); - PHOTCODE_SKIP_LIST = strcreate(argv[N]); + // measurements with these photcodes are kept ***regardless of quality*** + // -photcode-keep J will keep all J-band measurements of all kinds + // -photcode-keep GPC1.02.g will keep all g-band measurements from chip XY02 + PHOTCODE_KEEP_LIST = NULL; + if ((N = get_argument (argc, argv, "-photcode-keep"))) { + remove_argument (N, &argc, argv); + PHOTCODE_KEEP_LIST = strcreate(argv[N]); remove_argument (N, &argc, argv); } @@ -254,8 +258,8 @@ } - PHOTCODE_SKIP_LIST = NULL; - if ((N = get_argument (argc, argv, "-photcode-skip"))) { - remove_argument (N, &argc, argv); - PHOTCODE_SKIP_LIST = strcreate(argv[N]); + PHOTCODE_KEEP_LIST = NULL; + if ((N = get_argument (argc, argv, "-photcode-keep"))) { + remove_argument (N, &argc, argv); + PHOTCODE_KEEP_LIST = strcreate(argv[N]); remove_argument (N, &argc, argv); } @@ -290,5 +294,5 @@ fprintf (stderr, " -photcode-drop : remove these photcodes from the output (REF or DEP only)\n"); - fprintf (stderr, " -photcode-skip : ignore these photcodes when assessing the validity (keep unless object is dropped)\n"); + fprintf (stderr, " -photcode-keep : ignore these photcodes when assessing the validity (keep unless object is dropped)\n"); fprintf (stderr, " -instmag (min) (max) : range of valid instrumental magnitudes (or measurements are dropped)\n"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/copy_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/copy_images.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/copy_images.c (revision 37067) @@ -1,13 +1,14 @@ # include "photdbc.h" -int copy_images (char *outdir) { +int copy_images (char *outdir, SkyList *skylist) { int status; - off_t Nimage; + off_t Nimage, Nsubset; + off_t *LineNumber; char *ImageOut; unsigned int imageID; FITS_DB in; FITS_DB out; - Image *image; + Image *image, *subset; struct stat filestat; char *path; @@ -50,5 +51,8 @@ exit (2); } - dvo_image_addrows (&out, image, Nimage); + + subset = select_images (skylist, image, Nimage, &LineNumber, &Nsubset, FALSE); + + dvo_image_addrows (&out, subset, Nsubset); // note that imageID is unsigned int Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/find_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/find_images.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/find_images.c (revision 37067) @@ -25,5 +25,5 @@ tcoords.pc1_1 = tcoords.pc2_2 = 1.0; tcoords.pc1_2 = tcoords.pc2_1 = 0.0; - strcpy (tcoords.ctype, "RA---TAN"); + strcpy (tcoords.ctype, "DEC--TAN"); timage = gfits_table_get_Image (&db[0].ftable, &Ntimage, &db[0].swapped); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/get_mags.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/get_mags.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/get_mags.c (revision 37067) @@ -22,5 +22,5 @@ catalog[0].secfilt[i*Nsecfilt+j].M = NAN; catalog[0].secfilt[i*Nsecfilt+j].dM = NAN; - catalog[0].secfilt[i*Nsecfilt+j].Xm = NAN_S_SHORT; + catalog[0].secfilt[i*Nsecfilt+j].Mchisq = NAN; } } @@ -56,6 +56,6 @@ Mval = (Nsec == -1) ? &catalog[0].average[i].dM : &catalog[0].secfilt[i*Nsecfilt+Nsec].dM; *Mval = stats.sigma; - Mval = (Nsec == -1) ? &catalog[0].average[i].Xm : &catalog[0].secfilt[i*Nsecfilt+Nsec].Xm; - *Mval = 100.0*log10(stats.chisq); + Mval = (Nsec == -1) ? &catalog[0].average[i].Mchisq : &catalog[0].secfilt[i*Nsecfilt+Nsec].Mchisq; + *Mval = stats.chisq; } } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/initialize.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/initialize.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/initialize.c (revision 37067) @@ -13,5 +13,5 @@ photcodesDrop = ParsePhotcodeList (PHOTCODE_DROP_LIST, &NphotcodesDrop, FALSE); - photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE); + photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE); if (SHOW_PARAMS) { @@ -54,5 +54,5 @@ photcodesDrop = ParsePhotcodeList (PHOTCODE_DROP_LIST, &NphotcodesDrop, FALSE); - photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE); + photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE); if (SHOW_PARAMS) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/join_stars.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/join_stars.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/join_stars.c (revision 37067) @@ -3,5 +3,5 @@ void join_stars (Catalog *catalog) { - off_t i, j, k, m, M, Ni, Nj, first_j, Nfirst; + off_t i, j, k, m, Ni, Nj, first_j; off_t Naves, Nmeas, Ncurr; off_t Naverage, Nmeasure, *index; @@ -57,5 +57,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 0; - strcpy (tcoords.ctype, "RA---TAN"); + strcpy (tcoords.ctype, "DEC--TAN"); /* project & sort coordinates in local linear frame */ @@ -109,6 +109,6 @@ mpointer[Nmeas].measure = m; mpointer[Nmeas].averef = Naves; - mpointer[Nmeas].R = average[Ni].R - measure[m].dR / 3600.0; - mpointer[Nmeas].D = average[Ni].D - measure[m].dD / 3600.0; + mpointer[Nmeas].R = measure[m].R; + mpointer[Nmeas].D = measure[m].D; Nmeas ++; } @@ -155,9 +155,8 @@ mpointer[Nmeas].measure = m; mpointer[Nmeas].averef = Ncurr; - mpointer[Nmeas].R = average[Nj].R - measure[m].dR / 3600.0; - mpointer[Nmeas].D = average[Nj].D - measure[m].dD / 3600.0; + mpointer[Nmeas].R = measure[m].R; + mpointer[Nmeas].D = measure[m].D; Nmeas ++; } - Nfirst = average[Nj].Nmeasure; naverage[Ncurr].Nmeasure += average[Nj].Nmeasure; found[j] = TRUE; @@ -178,10 +177,10 @@ /* update original measurement offsets for new detections */ - for (k = Nfirst; k < naverage[Ncurr].Nmeasure; k++) { - m = naverage[Ncurr].measureOffset + k; - M = mpointer[m].measure; - measure[M].dR = 3600.0*(Sr - mpointer[m].R); - measure[M].dD = 3600.0*(Sd - mpointer[m].D); - } + // for (k = Nfirst; k < naverage[Ncurr].Nmeasure; k++) { + // m = naverage[Ncurr].measureOffset + k; + // M = mpointer[m].measure; + // measure[M].dR = 3600.0*(Sr - mpointer[m].R); + // measure[M].dD = 3600.0*(Sd - mpointer[m].D); + // } /* update current reference star position */ @@ -189,10 +188,11 @@ # else /* update original measurement offsets for new detections */ - for (k = Nfirst; k < naverage[Ncurr].Nmeasure; k++) { - m = naverage[Ncurr].measureOffset + k; - M = mpointer[m].measure; - measure[M].dR = 3600.0*(naverage[Ncurr].R - mpointer[m].R); - measure[M].dD = 3600.0*(naverage[Ncurr].D - mpointer[m].D); - } + // now not needed measure[M] carries R,D + // for (k = Nfirst; k < naverage[Ncurr].Nmeasure; k++) { + // m = naverage[Ncurr].measureOffset + k; + // M = mpointer[m].measure; + // measure[M].dR = 3600.0*(naverage[Ncurr].R - mpointer[m].R); + // measure[M].dD = 3600.0*(naverage[Ncurr].D - mpointer[m].D); + // } # endif } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/make_subcatalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/make_subcatalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/make_subcatalog.c (revision 37067) @@ -9,5 +9,5 @@ off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nm, Nsecfilt; double mag, minMag, minSigma; - int keep, *secSkip; + int keep, *secKeep; PhotCode *photcode; @@ -16,11 +16,11 @@ // set up a list of SEC entries to ignore when evaluating a source - ALLOCATE (secSkip, int, Nsecfilt); + ALLOCATE (secKeep, int, Nsecfilt); for (i = 0; i < Nsecfilt; i++) { - secSkip[i] = FALSE; + secKeep[i] = FALSE; photcode = GetPhotcodebyNsec(i); - for (k = 0; k < NphotcodesSkip; k++) { - if (photcodesSkip[k][0].code != photcode[0].code) continue; - secSkip[i] = TRUE; + for (k = 0; k < NphotcodesKeep; k++) { + if (photcodesKeep[k][0].code != photcode[0].code) continue; + secKeep[i] = TRUE; } } @@ -67,5 +67,5 @@ keep = FALSE; for (j = 0; !keep && (j < Nsecfilt); j++) { - if (secSkip[j]) continue; + if (secKeep[j]) continue; if (catalog[0].secfilt[Nsecfilt*i+j].Ncode >= NCODE_MIN) { keep = TRUE; @@ -101,7 +101,7 @@ if (NphotcodesDrop > 0) { found = FALSE; - for (k = 0; (k < NphotcodesSkip) && !found; k++) { - if (photcodesSkip[k][0].code == catalog[0].measure[offset].photcode) found = TRUE; - if (photcodesSkip[k][0].code == GetPhotcodeEquivCodebyCode(catalog[0].measure[offset].photcode)) found = TRUE; + for (k = 0; (k < NphotcodesDrop) && !found; k++) { + if (photcodesDrop[k][0].code == catalog[0].measure[offset].photcode) found = TRUE; + if (photcodesDrop[k][0].code == GetPhotcodeEquivCodebyCode(catalog[0].measure[offset].photcode)) found = TRUE; } if (found) continue; @@ -109,9 +109,9 @@ // ignore certain photcodes to assess the measurements - if (NphotcodesSkip > 0) { + if (NphotcodesKeep > 0) { found = FALSE; - for (k = 0; (k < NphotcodesSkip) && !found; k++) { - if (photcodesSkip[k][0].code == catalog[0].measure[offset].photcode) found = TRUE; - if (photcodesSkip[k][0].code == GetPhotcodeEquivCodebyCode(catalog[0].measure[offset].photcode)) found = TRUE; + for (k = 0; (k < NphotcodesKeep) && !found; k++) { + if (photcodesKeep[k][0].code == catalog[0].measure[offset].photcode) found = TRUE; + if (photcodesKeep[k][0].code == GetPhotcodeEquivCodebyCode(catalog[0].measure[offset].photcode)) found = TRUE; } if (found) goto keep; @@ -123,5 +123,5 @@ // select measurements by mag limit -- drop exactly this measurement if (ExcludeByInstMag) { - mag = PhotInst (&catalog[0].measure[offset]); + mag = PhotInst (&catalog[0].measure[offset], MAG_CLASS_PSF); if (mag < INST_MAG_MIN) continue; if (mag > INST_MAG_MAX) continue; @@ -135,5 +135,5 @@ // check measurements for this object -- drop object if no measurements pass if (ExcludeByMaxMinMag) { - mag = PhotSys (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]); + mag = PhotSys (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], MAG_CLASS_PSF); minMag = MIN (minMag, mag); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/photdbc.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/photdbc.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/photdbc.c (revision 37067) @@ -9,11 +9,11 @@ initialize (argc, argv); - // load and copy the image table - copy_images (argv[1]); - // the output catalog needs to inherit the SKY_DEPTH of the input catalog sky = SkyTableLoadOptimal (CATDIR, NULL, NULL, TRUE, 0, VERBOSE); SkyTableSetFilenames (sky, CATDIR, "cpt"); skylist = SkyListByPatch (sky, -1, ®ION); + + // load and copy the image table + copy_images (argv[1], skylist); // hostID is 0 for master program Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/photdbc_catalogs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/photdbc_catalogs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/photdbc_catalogs.c (revision 37067) @@ -120,5 +120,5 @@ if (ExcludeByMaxMinMag) { snprintf (tmpline, DVO_MAX_PATH, "%s -maxminmag %f", command, MAX_MIN_MAG); strcpy (command, tmpline); } if (PHOTCODE_DROP_LIST) { snprintf (tmpline, DVO_MAX_PATH, "%s -photcode-drop %s", command, PHOTCODE_DROP_LIST); strcpy (command, tmpline); } - if (PHOTCODE_SKIP_LIST) { snprintf (tmpline, DVO_MAX_PATH, "%s -photcode-skip %s", command, PHOTCODE_SKIP_LIST); strcpy (command, tmpline); } + if (PHOTCODE_KEEP_LIST) { snprintf (tmpline, DVO_MAX_PATH, "%s -photcode-keep %s", command, PHOTCODE_KEEP_LIST); strcpy (command, tmpline); } if (CATFORMAT) { snprintf (tmpline, DVO_MAX_PATH, "%s -set-format %s", command, CATFORMAT); strcpy (command, tmpline); } if (CATMODE) { snprintf (tmpline, DVO_MAX_PATH, "%s -set-mode %s", command, CATMODE); strcpy (command, tmpline); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/select_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/select_images.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/select_images.c (revision 37067) @@ -0,0 +1,234 @@ +# include "photdbc.h" + +/* this function returns a list of all images which overlap the given SkyList (set of + SkyRegions). All images in the image catalog are tested once, so there is no check that an + image already has been included. LineNum stores the locations in the Image database of the + list of images */ + +Image *select_images (SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage, int UseFullOverlap) { + + Image *image; + off_t i, j, k, nimage, NIMAGE, D_NIMAGE; + off_t *line_number; + int found; + double Ri[5], Di[5], Xi[5], Yi[5], dx, dy; + Coords tcoords; + SkyRegionCoords *skycoords; + + double RmaxSkyRegion, RminSkyRegion, RmidSkyRegion, DminSkyRegion, DmaxSkyRegion; + + double *RmaxSky; + off_t *index; + + if (skylist[0].Nregions < 1) { + *Nimage = 0; + *LineNumber = NULL; + if (VERBOSE) fprintf (stderr, "no matching sky regions\n"); + return NULL; + } + + // if no region is selected, we are choosing the whole sky; I should sort-circuit + // this function in that case + + INITTIME; + + // the comparison is made in the catalog local projection. below we set crval1,2 + tcoords.crpix1 = tcoords.crpix2 = 0.0; + tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0; + tcoords.pc1_1 = tcoords.pc2_2 = 1.0; + tcoords.pc1_2 = tcoords.pc2_1 = 0.0; + strcpy (tcoords.ctype, "DEC--TAN"); + + ALLOCATE (skycoords, SkyRegionCoords, skylist[0].Nregions); + + ALLOCATE (RmaxSky, double, skylist[0].Nregions); + ALLOCATE (index, off_t, skylist[0].Nregions); + + RminSkyRegion = +360.0; + RmaxSkyRegion = -360.0; + DminSkyRegion = +90.0; + DmaxSkyRegion = -90.0; + + D_NIMAGE = 6000; + + /* compare with each region file */ + for (i = 0; i < skylist[0].Nregions; i++) { + + /* we make positional comparisons in the projection of catalog */ + skycoords[i].Rc = 0.5*(skylist[0].regions[i][0].Rmax + skylist[0].regions[i][0].Rmin); + skycoords[i].Dc = 0.5*(skylist[0].regions[i][0].Dmax + skylist[0].regions[i][0].Dmin); + tcoords.crval1 = skycoords[i].Rc; + tcoords.crval2 = skycoords[i].Dc; + + /* define catalog corners */ + RD_to_XY (&skycoords[i].Xc[0], &skycoords[i].Yc[0], skylist[0].regions[i][0].Rmin, skylist[0].regions[i][0].Dmin, &tcoords); + RD_to_XY (&skycoords[i].Xc[1], &skycoords[i].Yc[1], skylist[0].regions[i][0].Rmax, skylist[0].regions[i][0].Dmin, &tcoords); + RD_to_XY (&skycoords[i].Xc[2], &skycoords[i].Yc[2], skylist[0].regions[i][0].Rmax, skylist[0].regions[i][0].Dmax, &tcoords); + RD_to_XY (&skycoords[i].Xc[3], &skycoords[i].Yc[3], skylist[0].regions[i][0].Rmin, skylist[0].regions[i][0].Dmax, &tcoords); + skycoords[i].Xc[4] = skycoords[i].Xc[0]; + skycoords[i].Yc[4] = skycoords[i].Yc[0]; + + RmaxSky[i] = skylist[0].regions[i][0].Rmax; + index[i] = i; + + dx = 0.02*(skycoords[i].Xc[2] - skycoords[i].Xc[0]); + dy = 0.02*(skycoords[i].Yc[2] - skycoords[i].Yc[0]); + skycoords[i].Xc[0] -= dx; skycoords[i].Yc[0] -= dy; + skycoords[i].Xc[1] += dx; skycoords[i].Yc[1] -= dy; + skycoords[i].Xc[2] += dx; skycoords[i].Yc[2] += dy; + skycoords[i].Xc[3] -= dx; skycoords[i].Yc[3] += dy; + skycoords[i].Xc[4] -= dx; skycoords[i].Yc[4] -= dy; + + RminSkyRegion = MIN(RminSkyRegion, skylist[0].regions[i][0].Rmin); + RmaxSkyRegion = MAX(RmaxSkyRegion, skylist[0].regions[i][0].Rmax); + DminSkyRegion = MIN(DminSkyRegion, skylist[0].regions[i][0].Dmin); + DmaxSkyRegion = MAX(DmaxSkyRegion, skylist[0].regions[i][0].Dmax); + } + RmidSkyRegion = 0.5*(RminSkyRegion + RmaxSkyRegion); + MARKTIME("create sky region coords: %f sec\n", dtime); + + dsortindex (RmaxSky, index, skylist[0].Nregions); + MARKTIME("sort sky coords: %f sec\n", dtime); + + if (VERBOSE) fprintf (stderr, "finding images\n"); + BuildChipMatch (timage, Ntimage); + MARKTIME("build chip match: %f sec\n", dtime); + + nimage = 0; + NIMAGE = D_NIMAGE; + ALLOCATE (image, Image, NIMAGE); + ALLOCATE (line_number, off_t, NIMAGE); + + // go through the complete list of images, selecting ones which overlap any region + for (i = 0; i < Ntimage; i++) { + + /* exclude images by photcode, or equiv photcode, if specified */ + if (NphotcodesDrop > 0) { + if (timage[i].photcode == 0) goto keep_image; // PHU image can be immediately passed in here + found = FALSE; // here 'found' refers to a match to a drop photcode + for (k = 0; (k < NphotcodesDrop) && !found; k++) { + if (photcodesDrop[k][0].code == timage[i].photcode) found = TRUE; + if (photcodesDrop[k][0].code == GetPhotcodeEquivCodebyCode(timage[i].photcode)) found = TRUE; + } + if (found) continue; + } +keep_image: + + // this adds 1.3 sec for 3M images + if (!FindMosaicForImage (timage, Ntimage, i)) { + fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i); + continue; + } + + /* define image corners - note the DIS images (mosaic phu) are special */ + if (!strcmp(&timage[i].coords.ctype[4], "-DIS")) { + Xi[0] = -0.5*timage[i].NX; Yi[0] = -0.5*timage[i].NY; + Xi[1] = +0.5*timage[i].NX; Yi[1] = -0.5*timage[i].NY; + Xi[2] = +0.5*timage[i].NX; Yi[2] = +0.5*timage[i].NY; + Xi[3] = -0.5*timage[i].NX; Yi[3] = +0.5*timage[i].NY; + Xi[4] = -0.5*timage[i].NX; Yi[4] = -0.5*timage[i].NY; + } else { + Xi[0] = 0; Yi[0] = 0; + Xi[1] = timage[i].NX; Yi[1] = 0; + Xi[2] = timage[i].NX; Yi[2] = timage[i].NY; + Xi[3] = 0; Yi[3] = timage[i].NY; + Xi[4] = 0; Yi[4] = 0; + } + found = FALSE; + + /* transform corners to ra,dec -- costs ~3sec for 3M images (pikake) */ + double RminImage = RmidSkyRegion + 180.0; + double RmaxImage = RmidSkyRegion - 180.0; + double DminImage = +90.0; + double DmaxImage = -90.0; + for (j = 0; j < 5; j++) { + XY_to_RD (&Ri[j], &Di[j], Xi[j], Yi[j], &timage[i].coords); + Ri[j] = ohana_normalize_angle_to_midpoint (Ri[j], RmidSkyRegion); + + RminImage = MIN(RminImage, Ri[j]); + RmaxImage = MAX(RmaxImage, Ri[j]); + DminImage = MIN(DminImage, Di[j]); + DmaxImage = MAX(DmaxImage, Di[j]); + } + if (RmaxImage - RminImage > 180.0) { + double tmp = RminImage; + RmaxImage = RminImage; + RminImage = tmp - 360.0; + } + + // check that this image is even in range of the searched region + if (DminImage > DmaxSkyRegion) continue; + if (DmaxImage < DminSkyRegion) continue; + + // the sky region RA is defined to be 0 - 360.0 + if (RminImage > RmaxSkyRegion) continue; + if (RmaxImage < RminSkyRegion) continue; + + // require that the full image be inside the region of interest (only for non PHU + // images) XXX : if we calibrate the mosaic, require that the full mosaic be inside + // the region and all of its chips.. + if (UseFullOverlap && strcmp(&timage[i].coords.ctype[4], "-DIS")) { + if (RmaxImage > REGION.Rmax) continue; + if (RminImage < REGION.Rmin) continue; + if (DmaxImage > REGION.Dmax) continue; + if (DminImage < REGION.Dmin) continue; + } + + image[nimage] = timage[i]; + line_number[nimage] = i; + nimage ++; + if (nimage == NIMAGE) { + NIMAGE += D_NIMAGE; + D_NIMAGE = MAX (100000, D_NIMAGE * 1.5); + REALLOCATE (image, Image, NIMAGE); + REALLOCATE (line_number, off_t, NIMAGE); + } + } + MARKTIME("finish image selection: %f sec\n", dtime); + + if (VERBOSE) fprintf (stderr, "found "OFF_T_FMT" images\n", nimage); + + REALLOCATE (image, Image, MAX (nimage, 1)); + REALLOCATE (line_number, off_t, MAX (nimage, 1)); + free (skycoords); + free (RmaxSky); + free (index); + + *Nimage = nimage; + *LineNumber = line_number; + return (image); +} + +void dsortindex (double *X, off_t *Y, int N) { + +# define SWAPFUNC(A,B){ double tmpf; off_t tmpi; \ + tmpf = X[A]; X[A] = X[B]; X[B] = tmpf; \ + tmpi = Y[A]; Y[A] = Y[B]; Y[B] = tmpi; \ +} +# define COMPARE(A,B)(X[A] < X[B]) + + OHANA_SORT (N, COMPARE, SWAPFUNC); + +# undef SWAPFUNC +# undef COMPARE + +} + +off_t getRegionStartByRA (double R, double *Rref, off_t Nregions) { + + // use bisection to find the overlapping mosaic + + off_t Nlo, Nhi, N; + + // find the last mosaic before start + Nlo = 0; Nhi = Nregions; + while (Nhi - Nlo > 10) { + N = 0.5*(Nlo + Nhi); + if (Rref[N] < R) { + Nlo = MAX(N, 0); + } else { + Nhi = MIN(N, Nregions); + } + } + return (Nlo); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/Makefile (revision 37067) @@ -69,4 +69,16 @@ $(SRC)/resort_catalog.$(ARCH).o \ $(SRC)/BrightCatalog.$(ARCH).o \ +$(SRC)/assign_images.$(ARCH).o \ +$(SRC)/launch_region_hosts.$(ARCH).o \ +$(SRC)/relastro_parallel_images.$(ARCH).o \ +$(SRC)/relastro_parallel_regions.$(ARCH).o \ +$(SRC)/MeanPosIO.$(ARCH).o \ +$(SRC)/share_mean_pos.$(ARCH).o \ +$(SRC)/share_images_pos.$(ARCH).o \ +$(SRC)/ImagePosIO.$(ARCH).o \ +$(SRC)/ImageTable.$(ARCH).o \ +$(SRC)/markObjects.$(ARCH).o \ +$(SRC)/indexCatalogs.$(ARCH).o \ +$(SRC)/syncfile.$(ARCH).o \ $(SRC)/relastroVisual.$(ARCH).o @@ -115,4 +127,5 @@ $(SRC)/plotstuff.$(ARCH).o \ $(SRC)/relastroVisual.$(ARCH).o \ +$(SRC)/syncfile.$(ARCH).o \ $(SRC)/BrightCatalog.$(ARCH).o Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/doc/pv2.txt =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/doc/pv2.txt (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/doc/pv2.txt (revision 37067) @@ -0,0 +1,121 @@ + +2014.07.03 + +Thinking some more about the galactic rotation / solar motion based +tie of relastro. What do I need in the db to do this process? Here +is an outline: + +* generate the PS1 + 2MASS (+ other) database + +* ingest the stellar distances from greg. this boils down to distance + (or parallax) + error. These values exist for ~500M objects, so a + non-trivial fraction of the db. I suppose the easiest way to handle + this is as an extra 2 fields in average.d. The correct (database) + way to do this would be to define another table with objID, par, + dpar, refID + +* a stand-alone process like setastrom would run through the database + and set the RoffGAL,DoffGAL offsets. + +** I have a model for the motion, but I will need to choose a + reference date. I suppose it does not matter too much in detail, + but obviously I should not choose J1900. I assume I should choose + something like the mean epoch (but it needs to be a single epoch + for the survey). so, eg, 2012.01.01. So, I use the model to + predict the offset for the given distance in the dR,dD direction. + +ref: R,D -> P,Q -> L,M -> X,Y (average) +raw: X,Y -> L,N -> P,Q -> R,D (measure) + +* fit is raw.X,Y -> ref.L,M + +* KHE : apply correction to raw.X,Y (I can calculate it for all stars + +* DCR : apply correction to raw.X,Y (need more than one color, can + calculate up front). choose a median color and airmass? + +* GAL : I want the transformation of a given image to convert X,Y to + R,D for that epoch. This really says I need to apply the proper + motion offset to the ref.R,D so ref.L,M is a prediction of the true + position. + +* QSO : I have the QSO coordinates in the db as specific measurments + with their own photcode(s). During the iteration, extract all + average.R,D for the QSOs and their specific measurements. Fit + Y(l,m) to dR,dD. Find the significant entries (how). Subtract the + offsets from ALL average.R,D values?? + +--------------------------------------------------- + +* external steps: + + * set the KHE X,Y offset values + * set the DCR X,Y offset values + * ingest the GAL P,dP values, set the GAL dR,dD values + +* relastro loop + * update objects + * fit & apply the QSO correction + * update chips + + ** I need to do a better job of tracking the change from each + iteration. + + ** add a bunch of visualizations to demonstrate the quality + +2014.07.01 + +I had a nice conversation with Valeri Makarov about astrometric +calibration. I have committed to send them the qsos matched to ps1 +positions. + +some things Valeri raised: + +1) if I make the QSOs into hard points, then they will drive the +solution have to a peak consistency at that location. thus errors +will build up away from those points, with potential ringing. His +suggestion is to use a set of spherical harmonics to fit the residual +between the QSO positions and relastro fitted position and to correct +based on this model fit. + +How exactly that works is not completely clear to me. I imaging doing +something iteratively. my sequence is basically: + +1) fit the image parameters +2) determine the per-epoch R,D values +3) determine mean positions +4) fit the Ylms between QSO radio positions (selected subset only) + and the new fitted R,D values +5) identify the significant Ylm terms, the negative of this is the + correction (actually, I'm fitting dR,dD = Y^D_lm, Y^R_lm +6) adjust the mean positions for all objects based on the correction +7) re-fit the images to these new positions +8) back to step 2 and repeat... + +Clearly I can only do this (consistently) if I fit the entire sky (or +as much as possible) in a single pass. I'll need to put some smarts +into the relastro_parallel_regions to get this right. But, also note +that having the technology in place to apply the Ylms means that I can +apply a correction from Valeri, if supplied. + +** What new fields do I need to handle this? + +2) regarding the application of the Galactic rotation / solar motion +model, Valeri raise the concern that different populations follow +different rotation curves. This is a good point, and an obvious one +in retrospect. In fact, we would like to be able to measure this. + +Now, clearly Pop I and Pop II stars are very different in terms of +rotation / stellar motions. How much does this matter? +Specifically, how much does solar motion matter vs the galactic +rotation model? Also, what fraction of my reference stars are likely +to be giants instead of MS stars? + +Some mitigation strategies: + +1) attempt to use only stars in a modest range of colors and predicted +distances? +2) ?? + +NOTE: I need to get the QSOs from bertrand + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/include/relastro.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/include/relastro.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/include/relastro.h (revision 37067) @@ -20,5 +20,7 @@ typedef enum {FIT_NONE, FIT_AVERAGE, FIT_PM_ONLY, FIT_PAR_ONLY, FIT_PM_AND_PAR} FitMode; -typedef enum {TARGET_NONE, TARGET_SIMPLE, TARGET_CHIPS, TARGET_MOSAICS, TARGET_HIGH_SPEED, TARGET_MERGE_SOURCE, TARGET_UPDATE_OBJECTS, TARGET_UPDATE_OFFSETS, TARGET_LOAD_OBJECTS, TARGET_HPM} FitTarget; +typedef enum {OP_NONE, OP_IMAGES, OP_HIGH_SPEED, OP_MERGE_SOURCE, OP_UPDATE_OBJECTS, OP_UPDATE_OFFSETS, OP_LOAD_OBJECTS, OP_HPM, OP_PARALLEL_REGIONS, OP_PARALLEL_IMAGES} RelastroOp; + +typedef enum {TARGET_NONE, TARGET_SIMPLE, TARGET_CHIPS, TARGET_MOSAICS} FitTarget; typedef enum { @@ -30,4 +32,20 @@ MARK_BIG_OFFSET = 0x0010, } MeasurementMask; + +typedef struct { + float R; + float D; + unsigned int objID; + unsigned int catID; +} MeanPos; + +typedef struct { + Coords coords; + float dXpixSys; + float dYpixSys; + unsigned int imageID; + int nFitAstrom; + int flags; +} ImagePos; typedef struct { @@ -56,7 +74,9 @@ double L, M; /* Focal Plane - pixels */ double X, Y; /* Chip Coords - pixels */ - double Mag; - double dMag; - double dPos; + float Mag; + float ColorBlue; + float ColorRed; + float dMag; + float dPos; int mask; int Nmeas; @@ -93,4 +113,5 @@ unsigned int start; unsigned int stop; + off_t myImage; float Mcal; float dMcal; @@ -113,10 +134,4 @@ } StatType; -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); \ - fprintf (stderr, MSG, __VA_ARGS__); } - /* global variables set in parameter file */ # define DVO_MAX_PATH 1024 @@ -129,4 +144,10 @@ char SKY_TABLE[DVO_MAX_PATH]; int SKY_DEPTH; /** XXX EAM : depth of catalog tables, fix usage */ + +// globals for parallel region operations +char *REGION_FILE; +char *IMAGE_TABLE; +int REGION_HOST_ID; +int PARALLEL_REGIONS_MANUAL; int HOST_ID; @@ -179,7 +200,7 @@ double MaxDensityValue; -char *PHOTCODE_KEEP_LIST, *PHOTCODE_SKIP_LIST; -int NphotcodesKeep, NphotcodesSkip; -PhotCode **photcodesKeep, **photcodesSkip; +char *PHOTCODE_KEEP_LIST, *PHOTCODE_SKIP_LIST, *PHOTCODE_RESET_LIST; +int NphotcodesKeep, NphotcodesSkip, NphotcodesReset; +PhotCode **photcodesKeep, **photcodesSkip, **photcodesReset; char *PHOTCODE_A_LIST, *PHOTCODE_B_LIST; @@ -189,4 +210,12 @@ SkyRegionSelection SELECTION; +char *DCR_BLUE_COLOR_POS, *DCR_BLUE_COLOR_NEG; +PhotCode *DCR_BLUE_PHOTCODE_POS, *DCR_BLUE_PHOTCODE_NEG; +int DCR_BLUE_NSEC_POS, DCR_BLUE_NSEC_NEG; + +char *DCR_RED_COLOR_POS, *DCR_RED_COLOR_NEG; +PhotCode *DCR_RED_PHOTCODE_POS, *DCR_RED_PHOTCODE_NEG; +int DCR_RED_NSEC_POS, DCR_RED_NSEC_NEG; + int ImagSelect; double ImagMin, ImagMax; @@ -206,6 +235,10 @@ int USE_BASIC_CHECK; +int ExcludeBogus; +double ExcludeBogusRadius; + FitMode FIT_MODE; +RelastroOp RELASTRO_OP; FitTarget FIT_TARGET; @@ -278,5 +311,5 @@ int liststats PROTO((double *value, double *dvalue, int N, StatType *stats)); int liststats_pos PROTO((double *value, double *dvalue, int N, StatType *stats, int XVERB)); -Catalog *load_catalogs PROTO((SkyList *skylist, int *Ncatalog, int subselect, int hostID, char *hostpath)); +Catalog *load_catalogs PROTO((SkyList *skylist, int *Ncatalog, int subselect, int hostID, char *hostpath, char *syncfile)); int load_images PROTO((FITS_DB *db, SkyList *skylist, int UseFullOverlap)); Image *select_images PROTO((SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage, int UseFullOverlap)); @@ -388,4 +421,6 @@ int setMeanR (double ra_fit, MeasureTiny *measure, Average *average, SecFilt *secfilt); int setMeanD (double dec_fit, MeasureTiny *measure, Average *average, SecFilt *secfilt); +double getMeanR_Big (Measure *measure, Average *average, SecFilt *secfilt); +double getMeanD_Big (Measure *measure, Average *average, SecFilt *secfilt); int setMeanR_Big (double ra_fit, Measure *measure, Average *average, SecFilt *secfilt); int setMeanD_Big (double dec_fit, Measure *measure, Average *average, SecFilt *secfilt); @@ -450,2 +485,52 @@ int hpm_catalogs_parallel (SkyList *skylist); int hpm_objects (SkyRegion *region, Catalog *catalog); + +int strextend (char *input, char *format,...); +int launch_region_hosts (RegionHostTable *regionHosts); + +int assign_images (FITS_DB *db, RegionHostTable *regionHosts); +int select_images_hostregion (RegionHostTable *regionHosts, Image *image, off_t Nimage); +int calculate_image_bounds (Image *image, double *rmin, double *rmax, double *dmin, double *dmax, double Rmid); +int calculate_host_image_bounds (RegionHostTable *regionHosts); +int find_host_for_coords (RegionHostTable *regionHosts, double Rc, double Dc); + +int relastro_parallel_regions (); +int relastro_parallel_images (); + +char *make_filename (char *dirname, char *hostname, int hostID, char *tailname); +int check_sync_file (char *filename, int nloop); +int clear_sync_file (char *filename); +int update_sync_file (char *filename, int nloop); + +int share_mean_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop); +int slurp_mean_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop); +int set_mean_pos (MeanPos *meanpos, Average *average); +MeanPos *merge_mean_pos (MeanPos *target, int *ntarget, MeanPos *source, int Nsource); + +int MeanPosSave(char *filename, MeanPos *meanpos, off_t Nmeanpos); +MeanPos *MeanPosLoad(char *filename, off_t *nmeanpos); + +int indexCatalogs (Catalog *catalog, int Ncatalog); +int catID_and_objID_to_seq (int catID, int objID, int *catSeq, off_t *objSeq); + +int markObjects (Catalog *catalog, int Ncatalog); + +int ImagePosSave(char *filename, ImagePos *image_pos, off_t Nimage_pos); +ImagePos *ImagePosLoad(char *filename, off_t *nimage_pos); + +int share_image_pos (RegionHostTable *regionHosts, int nloop); +int slurp_image_pos (RegionHostTable *regionHosts, int nloop); +ImagePos *merge_image_pos (ImagePos *target, int *ntarget, ImagePos *source, int Nsource); +int set_image_pos (ImagePos *image_pos, Image *image); + +Image *ImageTableLoad(char *filename, off_t *nimage); +int ImageTableSave (char *filename, Image *images, off_t Nimages); +int select_mosaics_hostregion (RegionHostTable *regionHosts, Image *image, off_t Nimage); + +float getColorBlue (off_t meas, int cat); +float getColorRed (off_t meas, int cat); + +int strextend (char *input, char *format,...); + +int areImagesLoaded (); +int areImagesMatched (); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/BrightCatalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/BrightCatalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/BrightCatalog.c (revision 37067) @@ -68,6 +68,6 @@ // need to create and assign to flat-field correction - GET_COLUMN(dR, "RA_OFF", float); - GET_COLUMN(dD, "DEC_OFF", float); + GET_COLUMN(R, "RA", double); + GET_COLUMN(D, "DEC", double); GET_COLUMN(M, "MAG_SYS", float); GET_COLUMN(Mcal, "MAG_CAL", float); @@ -92,6 +92,6 @@ ALLOCATE (measure, MeasureTiny, Nrow); for (i = 0; i < Nrow; i++) { - measure[i].dR = dR[i]; - measure[i].dD = dD[i]; + measure[i].R = R[i]; + measure[i].D = D[i]; measure[i].M = M[i]; measure[i].Mcal = Mcal[i]; @@ -113,6 +113,6 @@ // fprintf (stderr, "loaded data for %lld measures\n", (long long) Nrow); - free (dR ); - free (dD ); + free (R ); + free (D ); free (M ); free (Mcal ); @@ -145,33 +145,34 @@ if (!gfits_fread_ftable_data (f, &ftable, FALSE)) goto escape; - GET_COLUMN(R, "RA", double); - GET_COLUMN(D, "DEC", double); - GET_COLUMN(dR, "RA_ERR", float); - GET_COLUMN(dD, "DEC_ERR", float); - GET_COLUMN(uR, "U_RA", float); - GET_COLUMN(uD, "U_DEC", float); - GET_COLUMN(duR, "V_RA_ERR", float); - GET_COLUMN(duD, "V_DEC_ERR", float); - GET_COLUMN(P, "PAR", float); - GET_COLUMN(dP, "PAR_ERR", float); - GET_COLUMN(ChiSqAve, "CHISQ_POS", float); - GET_COLUMN(ChiSqPM, "CHISQ_PM", float); - GET_COLUMN(ChiSqPar, "CHISQ_PAP", float); - GET_COLUMN(Tmean, "MEAN_EPOCH", int); - GET_COLUMN(Trange, "TIME_RANGE", int); - GET_COLUMN(stargal, "STARGAL_SEP", float); - GET_COLUMN(Npos, "NUMBER_POS", short); - GET_COLUMN(Nmeasure, "NMEASURE", short); - GET_COLUMN(Nmissing, "NMISSING", short); - GET_COLUMN(Nextend, "NEXTEND", short); - GET_COLUMN(measureOffset, "OFF_MEASURE", int); - GET_COLUMN(missingOffset, "OFF_MISSING", int); - GET_COLUMN(extendOffset, "OFF_EXTEND", int); - GET_COLUMN(flags, "FLAGS", int); - GET_COLUMN(photFlagsUpper, "PHOTFLAGS_U", int); - GET_COLUMN(photFlagsLower, "PHOTFLAGS_L", int); - GET_COLUMN(objID, "OBJ_ID", int); - GET_COLUMN(catID, "CAT_ID", int); - GET_COLUMN(extID, "EXT_ID", int64_t); + GET_COLUMN(R, "RA", double); + GET_COLUMN(D, "DEC", double); + GET_COLUMN(dR, "RA_ERR", float); + GET_COLUMN(dD, "DEC_ERR", float); + GET_COLUMN(uR, "U_RA", float); + GET_COLUMN(uD, "U_DEC", float); + GET_COLUMN(duR, "V_RA_ERR", float); + GET_COLUMN(duD, "V_DEC_ERR", float); + GET_COLUMN(P, "PAR", float); + GET_COLUMN(dP, "PAR_ERR", float); + GET_COLUMN(ChiSqAve, "CHISQ_POS", float); + GET_COLUMN(ChiSqPM, "CHISQ_PM", float); + GET_COLUMN(ChiSqPar, "CHISQ_PAP", float); + GET_COLUMN(Tmean, "MEAN_EPOCH", int); + GET_COLUMN(Trange, "TIME_RANGE", int); + GET_COLUMN(stargal, "STARGAL_SEP", float); + GET_COLUMN(Npos, "NUMBER_POS", short); + GET_COLUMN(Nmeasure, "NMEASURE", short); + GET_COLUMN(Nmissing, "NMISSING", short); + GET_COLUMN(Nextend, "NEXTEND", short); + GET_COLUMN(measureOffset, "OFF_MEASURE", int); + GET_COLUMN(missingOffset, "OFF_MISSING", int); + GET_COLUMN(refColorBlue, "REF_COLOR_BLUE", float); + GET_COLUMN(refColorRed, "REF_COLOR_RED", float); + GET_COLUMN(flags, "FLAGS", int); + GET_COLUMN(photFlagsUpper, "PHOTFLAGS_U", int); + GET_COLUMN(photFlagsLower, "PHOTFLAGS_L", int); + GET_COLUMN(objID, "OBJ_ID", int); + GET_COLUMN(catID, "CAT_ID", int); + GET_COLUMN(extID, "EXT_ID", int64_t); gfits_free_header (&theader); gfits_free_table (&ftable); @@ -202,5 +203,6 @@ average[i].measureOffset = measureOffset[i] ; average[i].missingOffset = missingOffset[i] ; - average[i].extendOffset = extendOffset[i] ; + average[i].refColorBlue = refColorBlue[i] ; + average[i].refColorRed = refColorRed[i] ; average[i].flags = flags[i] ; average[i].photFlagsUpper = photFlagsUpper[i] ; @@ -234,5 +236,6 @@ free (measureOffset); free (missingOffset); - free (extendOffset); + free (refColorBlue); + free (refColorRed); free (flags); free (photFlagsUpper); @@ -256,12 +259,12 @@ // need to create and assign to flat-field correction - GET_COLUMN(M, "MAG", float); - GET_COLUMN(dM, "MAG_ERR", float); - GET_COLUMN(Xm, "MAG_CHI", float); - GET_COLUMN(flags, "FLAGS", int); - GET_COLUMN(Ncode, "NCODE", short); - GET_COLUMN(Nused, "NUSED", short); - GET_COLUMN(M_20, "MAG_20", short); - GET_COLUMN(M_80, "MAG_80", short); + GET_COLUMN(M, "MAG", float); + GET_COLUMN(dM, "MAG_ERR", float); + GET_COLUMN(Mchisq, "MAG_CHI", float); + GET_COLUMN(flags, "FLAGS", int); + GET_COLUMN(Ncode, "NCODE", short); + GET_COLUMN(Nused, "NUSED", short); + GET_COLUMN(Mmin, "MAG_MIN", float); + GET_COLUMN(Mmax, "MAG_MAX", float); gfits_free_header (&theader); gfits_free_table (&ftable); @@ -270,12 +273,12 @@ ALLOCATE (secfilt, SecFilt, Nrow); for (i = 0; i < Nrow; i++) { - secfilt[i].M = M[i]; - secfilt[i].dM = dM[i]; - secfilt[i].Xm = Xm[i]; - secfilt[i].flags = flags[i]; - secfilt[i].Ncode = Ncode[i]; - secfilt[i].Nused = Nused[i]; - secfilt[i].M_20 = M_20[i]; - secfilt[i].M_80 = M_80[i]; + secfilt[i].M = M[i]; + secfilt[i].dM = dM[i]; + secfilt[i].Mchisq = Mchisq[i]; + secfilt[i].flags = flags[i]; + secfilt[i].Ncode = Ncode[i]; + secfilt[i].Nused = Nused[i]; + secfilt[i].Mmin = Mmin[i]; + secfilt[i].Mmax = Mmax[i]; } fprintf (stderr, "loaded data for %lld averages\n", (long long) Nrow); @@ -283,10 +286,10 @@ free (M ); free (dM ); - free (Xm ); + free (Mchisq); free (flags); free (Ncode); free (Nused); - free (M_20 ); - free (M_80 ); + free (Mmin ); + free (Mmax ); catalog->secfilt = secfilt; // assert Nsecfilt * Naverage = Nrow? @@ -351,11 +354,11 @@ gfits_define_bintable_column (&theader, "E", "Y_FIX", "ccd y fiex coord", "pix", 1.0, 0.0); gfits_define_bintable_column (&theader, "E", "EXPTIME", "-2.5 * log (exposure time)", "sec", 1.0, 0.0); - gfits_define_bintable_column (&theader, "J", "TIME", "time of exp", "sec", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "AVE_REF", "pointer to average table", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "DB_FLAGS", "flags", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "PHOT_FLAGS", "photflags", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "CAT_ID", "catalog", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "I", "PHOTCODE", "photcode", NULL, 1.0, 1.0*0x80); + gfits_define_bintable_column (&theader, "J", "TIME", "time of exp", "sec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "AVE_REF", "pointer to average table", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "DB_FLAGS", "flags", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "PHOT_FLAGS", "photflags", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "CAT_ID", "catalog", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "PHOTCODE", "photcode", NULL, 1.0, 0.0); // generate the output array that carries the data @@ -363,28 +366,28 @@ // create intermediate storage arrays - float *dR ; ALLOCATE (dR , float, catalog->Nmeasure); - float *dD ; ALLOCATE (dD , float, catalog->Nmeasure); - float *M ; ALLOCATE (M , float, catalog->Nmeasure); - float *Mcal ; ALLOCATE (Mcal , float, catalog->Nmeasure); - float *dM ; ALLOCATE (dM , float, catalog->Nmeasure); - float *airmass ; ALLOCATE (airmass , float, catalog->Nmeasure); - float *Xccd ; ALLOCATE (Xccd , float, catalog->Nmeasure); - float *Yccd ; ALLOCATE (Yccd , float, catalog->Nmeasure); - float *Xfix ; ALLOCATE (Xfix , float, catalog->Nmeasure); - float *Yfix ; ALLOCATE (Yfix , float, catalog->Nmeasure); - float *dt ; ALLOCATE (dt , float, catalog->Nmeasure); - int *t ; ALLOCATE (t , int , catalog->Nmeasure); - int *averef ; ALLOCATE (averef , int , catalog->Nmeasure); - int *imageID ; ALLOCATE (imageID , int , catalog->Nmeasure); - int *dbFlags ; ALLOCATE (dbFlags , int , catalog->Nmeasure); - int *photFlags ; ALLOCATE (photFlags, int , catalog->Nmeasure); - int *catID ; ALLOCATE (catID , int , catalog->Nmeasure); - short *photcode ; ALLOCATE (photcode , short, catalog->Nmeasure); + double *R ; ALLOCATE (R , double, catalog->Nmeasure); + double *D ; ALLOCATE (D , double, catalog->Nmeasure); + float *M ; ALLOCATE (M , float, catalog->Nmeasure); + float *Mcal ; ALLOCATE (Mcal , float, catalog->Nmeasure); + float *dM ; ALLOCATE (dM , float, catalog->Nmeasure); + float *airmass ; ALLOCATE (airmass , float, catalog->Nmeasure); + float *Xccd ; ALLOCATE (Xccd , float, catalog->Nmeasure); + float *Yccd ; ALLOCATE (Yccd , float, catalog->Nmeasure); + float *Xfix ; ALLOCATE (Xfix , float, catalog->Nmeasure); + float *Yfix ; ALLOCATE (Yfix , float, catalog->Nmeasure); + float *dt ; ALLOCATE (dt , float, catalog->Nmeasure); + int *t ; ALLOCATE (t , int , catalog->Nmeasure); + int *averef ; ALLOCATE (averef , int , catalog->Nmeasure); + int *imageID ; ALLOCATE (imageID , int , catalog->Nmeasure); + int *dbFlags ; ALLOCATE (dbFlags , int , catalog->Nmeasure); + int *photFlags ; ALLOCATE (photFlags, int , catalog->Nmeasure); + int *catID ; ALLOCATE (catID , int , catalog->Nmeasure); + short *photcode ; ALLOCATE (photcode , short, catalog->Nmeasure); // assign the storage arrays MeasureTiny *measure = catalog->measure; for (i = 0; i < catalog->Nmeasure; i++) { - dR[i] = measure[i].dR ; - dD[i] = measure[i].dD ; + R[i] = measure[i].R ; + D[i] = measure[i].D ; M[i] = measure[i].M ; Mcal[i] = measure[i].Mcal ; @@ -406,6 +409,6 @@ // add the columns to the output array - gfits_set_bintable_column (&theader, &ftable, "RA_OFF", dR, catalog->Nmeasure); - gfits_set_bintable_column (&theader, &ftable, "DEC_OFF", dD, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "RA", R, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "DEC", D, catalog->Nmeasure); gfits_set_bintable_column (&theader, &ftable, "MAG_SYS", M, catalog->Nmeasure); gfits_set_bintable_column (&theader, &ftable, "MAG_CAL", Mcal, catalog->Nmeasure); @@ -425,6 +428,6 @@ gfits_set_bintable_column (&theader, &ftable, "PHOTCODE", photcode, catalog->Nmeasure); - free (dR ); - free (dD ); + free (R ); + free (D ); free (M ); free (Mcal ); @@ -454,33 +457,34 @@ gfits_create_table_header (&theader, "BINTABLE", "AVERAGE"); - gfits_define_bintable_column (&theader, "D", "RA", "RA", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "D", "DEC", "DEC", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "RA_ERR", "RA error", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "DEC_ERR", "DEC error", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "U_RA", "RA*cos(D) proper-motion", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "U_DEC", "DEC proper-motion", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "V_RA_ERR", "RA*cos(D) p-m error", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "V_DEC_ERR", "DEC p-m error", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "PAR", "parallax", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "PAR_ERR", "parallax error", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "CHISQ_POS", "astrometry analysis chisq", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "CHISQ_PM", "astrometry analysis chisq", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "CHISQ_PAP", "astrometry analysis chisq", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "J", "MEAN_EPOCH", "mean epoch (PM-PAR ref)", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "TIME_RANGE", "mean epoch (PM-PAR ref)", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "E", "STARGAL_SEP", "star/galaxy separator", "", 1.0, 0.0); - gfits_define_bintable_column (&theader, "I", "NUMBER_POS", "number of detections used for astrometry", "", 1.0, 1.0*0x80); - gfits_define_bintable_column (&theader, "I", "NMEASURE", "number of psf measurements", "", 1.0, 1.0*0x80); - gfits_define_bintable_column (&theader, "I", "NMISSING", "number of missings", "", 1.0, 1.0*0x80); - gfits_define_bintable_column (&theader, "I", "NEXTEND", "number of extended measurements", "", 1.0, 1.0*0x80); - gfits_define_bintable_column (&theader, "J", "OFF_MEASURE", "offset to first psf measurement", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "OFF_MISSING", "offset to first missing obs", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "OFF_EXTEND", "offset to first extended measurement", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "FLAGS", "average object flags (star; ghost; etc)", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "PHOTFLAGS_U", "upper bit of 2 bit summary of per-measure photflags", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "PHOTFLAGS_L", "lower bit of 2 bit summary of per-measure photflags", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "OBJ_ID", "unique ID for object in table", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "CAT_ID", "unique ID for table in which object was first realized", "", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "K", "EXT_ID", "external ID for object (eg PSPS objID)", "", 1.0, 1.0*0x80000000); + gfits_define_bintable_column (&theader, "D", "RA", "RA", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "DEC", "DEC", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "RA_ERR", "RA error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "DEC_ERR", "DEC error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "U_RA", "RA*cos(D) proper-motion", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "U_DEC", "DEC proper-motion", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "V_RA_ERR", "RA*cos(D) p-m error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "V_DEC_ERR", "DEC p-m error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "PAR", "parallax", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "PAR_ERR", "parallax error", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CHISQ_POS", "astrometry analysis chisq", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CHISQ_PM", "astrometry analysis chisq", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CHISQ_PAP", "astrometry analysis chisq", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "MEAN_EPOCH", "mean epoch (PM-PAR ref)", "", 1.0, 0.00); + gfits_define_bintable_column (&theader, "J", "TIME_RANGE", "mean epoch (PM-PAR ref)", "", 1.0, 0.00); + gfits_define_bintable_column (&theader, "E", "STARGAL_SEP", "star/galaxy separator", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NUMBER_POS", "number of detections used for astrometry", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NMEASURE", "number of psf measurements", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NMISSING", "number of missings", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NEXTEND", "number of extended measurements", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "OFF_MEASURE", "offset to first psf measurement", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "OFF_MISSING", "offset to first missing obs", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "REF_COLOR_BLUE", "reference color", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "REF_COLOR_RED", "reference color", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "FLAGS", "average object flags (star; ghost; etc)", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "PHOTFLAGS_U", "upper bit of 2 bit summary of per-measure photflags", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "PHOTFLAGS_L", "lower bit of 2 bit summary of per-measure photflags", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "OBJ_ID", "unique ID for object in table", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "CAT_ID", "unique ID for table in which object was first realized", "", 1.0, 0.0); + gfits_define_bintable_column (&theader, "K", "EXT_ID", "external ID for object (eg PSPS objID)", "", 1.0, 0.0); // generate the output array that carries the data @@ -510,5 +514,6 @@ int *measureOffset ; ALLOCATE (measureOffset , int , catalog->Naverage); int *missingOffset ; ALLOCATE (missingOffset , int , catalog->Naverage); - int *extendOffset ; ALLOCATE (extendOffset , int , catalog->Naverage); + float *refColorBlue ; ALLOCATE (refColorBlue , float , catalog->Naverage); + float *refColorRed ; ALLOCATE (refColorRed , float , catalog->Naverage); int *flags ; ALLOCATE (flags , int , catalog->Naverage); int *photFlagsUpper; ALLOCATE (photFlagsUpper, int , catalog->Naverage); @@ -543,5 +548,6 @@ measureOffset[i] = average[i].measureOffset ; missingOffset[i] = average[i].missingOffset ; - extendOffset[i] = average[i].extendOffset ; + refColorBlue[i] = average[i].refColorBlue ; + refColorRed[i] = average[i].refColorRed ; flags[i] = average[i].flags ; photFlagsUpper[i] = average[i].photFlagsUpper ; @@ -553,33 +559,34 @@ // add the columns to the output array - gfits_set_bintable_column (&theader, &ftable, "RA", R, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "DEC", D, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "RA_ERR", dR, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "DEC_ERR", dD, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "U_RA", uR, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "U_DEC", uD, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "V_RA_ERR", duR, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "V_DEC_ERR", duD, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "PAR", P, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "PAR_ERR", dP, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "CHISQ_POS", ChiSqAve, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "CHISQ_PM", ChiSqPM, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "CHISQ_PAP", ChiSqPar, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "MEAN_EPOCH", Tmean, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "TIME_RANGE", Trange, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "STARGAL_SEP", stargal, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "NUMBER_POS", Npos, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "NMEASURE", Nmeasure, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "NMISSING", Nmissing, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "NEXTEND", Nextend, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "OFF_MEASURE", measureOffset, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "OFF_MISSING", missingOffset, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "OFF_EXTEND", extendOffset, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "PHOTFLAGS_U", photFlagsUpper, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "PHOTFLAGS_L", photFlagsLower, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "OBJ_ID", objID, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "CAT_ID", catID, catalog->Naverage); - gfits_set_bintable_column (&theader, &ftable, "EXT_ID", extID, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "RA", R, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "DEC", D, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "RA_ERR", dR, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "DEC_ERR", dD, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "U_RA", uR, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "U_DEC", uD, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "V_RA_ERR", duR, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "V_DEC_ERR", duD, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "PAR", P, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "PAR_ERR", dP, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "CHISQ_POS", ChiSqAve, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "CHISQ_PM", ChiSqPM, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "CHISQ_PAP", ChiSqPar, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "MEAN_EPOCH", Tmean, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "TIME_RANGE", Trange, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "STARGAL_SEP", stargal, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "NUMBER_POS", Npos, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "NMEASURE", Nmeasure, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "NMISSING", Nmissing, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "NEXTEND", Nextend, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "OFF_MEASURE", measureOffset, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "OFF_MISSING", missingOffset, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "REF_COLOR_BLUE", refColorBlue, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "REF_COLOR_RED", refColorRed, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "PHOTFLAGS_U", photFlagsUpper, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "PHOTFLAGS_L", photFlagsLower, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "OBJ_ID", objID, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "CAT_ID", catID, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "EXT_ID", extID, catalog->Naverage); free (R); @@ -605,5 +612,6 @@ free (measureOffset); free (missingOffset); - free (extendOffset); + free (refColorBlue); + free (refColorRed); free (flags); free (photFlagsUpper); @@ -629,6 +637,6 @@ gfits_define_bintable_column (&theader, "I", "NCODE", "magnitude (err)", NULL, 1.0, 0.0); gfits_define_bintable_column (&theader, "I", "NUSED", "airmass", NULL, 1.0, 0.0); - gfits_define_bintable_column (&theader, "I", "MAG_20", "ccd x coord", "pix", 1.0, 0.0); - gfits_define_bintable_column (&theader, "I", "MAG_80", "ccd y coord", "pix", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_MIN", "ccd x coord", "pix", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_MAX", "ccd y coord", "pix", 1.0, 0.0); // generate the output array that carries the data @@ -642,42 +650,42 @@ float *M ; ALLOCATE (M , float, Nsec); float *dM ; ALLOCATE (dM , float, Nsec); - float *Xm ; ALLOCATE (Xm , float, Nsec); + float *Mchisq ; ALLOCATE (Mchisq , float, Nsec); int *flags ; ALLOCATE (flags , int, Nsec); short *Ncode ; ALLOCATE (Ncode , short, Nsec); short *Nused ; ALLOCATE (Nused , short, Nsec); - short *M_20 ; ALLOCATE (M_20 , short, Nsec); - short *M_80 ; ALLOCATE (M_80 , short, Nsec); + float *Mmin ; ALLOCATE (Mmin , float, Nsec); + float *Mmax ; ALLOCATE (Mmax , float, Nsec); // assign the storage arrays SecFilt *secfilt = catalog->secfilt; for (i = 0; i < Nsec; i++) { - M [i] = secfilt[i]. M ; - dM [i] = secfilt[i]. dM ; - Xm [i] = secfilt[i]. Xm ; - flags [i] = secfilt[i]. flags ; - Ncode [i] = secfilt[i]. Ncode ; - Nused [i] = secfilt[i]. Nused ; - M_20 [i] = secfilt[i]. M_20 ; - M_80 [i] = secfilt[i]. M_80 ; + M [i] = secfilt[i].M ; + dM [i] = secfilt[i].dM ; + Mchisq[i] = secfilt[i].Mchisq ; + flags [i] = secfilt[i].flags ; + Ncode [i] = secfilt[i].Ncode ; + Nused [i] = secfilt[i].Nused ; + Mmin [i] = secfilt[i].Mmin ; + Mmax [i] = secfilt[i].Mmax ; } // add the columns to the output array - gfits_set_bintable_column (&theader, &ftable, "MAG", M , Nsec); - gfits_set_bintable_column (&theader, &ftable, "MAG_ERR", dM , Nsec); - gfits_set_bintable_column (&theader, &ftable, "MAG_CHI", Xm , Nsec); - gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags, Nsec); - gfits_set_bintable_column (&theader, &ftable, "NCODE", Ncode, Nsec); - gfits_set_bintable_column (&theader, &ftable, "NUSED", Nused, Nsec); - gfits_set_bintable_column (&theader, &ftable, "MAG_20", M_20 , Nsec); - gfits_set_bintable_column (&theader, &ftable, "MAG_80", M_80 , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG", M , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_ERR", dM , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_CHI", Mchisq, Nsec); + gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags , Nsec); + gfits_set_bintable_column (&theader, &ftable, "NCODE", Ncode , Nsec); + gfits_set_bintable_column (&theader, &ftable, "NUSED", Nused , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_MIN", Mmin , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_MAX", Mmax , Nsec); free (M ); free (dM ); - free (Xm ); + free (Mchisq ); free (flags ); free (Ncode ); free (Nused ); - free (M_20 ); - free (M_80 ); + free (Mmin ); + free (Mmax ); gfits_fwrite_Theader (f, &theader); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ConfigInit.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ConfigInit.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ConfigInit.c (revision 37067) @@ -18,6 +18,7 @@ if (VERBOSE) fprintf (stderr, "loaded config file: %s\n", file); - GetConfig (config, "RELASTRO_SIGMA_LIM", "%lf", 0, &SIGMA_LIM); // exclude measurements on this basis - GetConfig (config, "RELASTRO_SRC_MEAS_TOOFEW", "%d", 0, &SRC_MEAS_TOOFEW); + // set defaults for all of these if they are not used by parallel / remote clients + if (!ScanConfig (config, "RELASTRO_SIGMA_LIM", "%lf", 0, &SIGMA_LIM)) SIGMA_LIM = 0.01; + if (!ScanConfig (config, "RELASTRO_SRC_MEAS_TOOFEW", "%d", 0, &SRC_MEAS_TOOFEW)) SRC_MEAS_TOOFEW = 3; if (!ScanConfig (config, "RELASTRO_IMFIT_CLIP_NITER", "%d", 0, &IMFIT_CLIP_NITER)) IMFIT_CLIP_NITER = 3; @@ -25,18 +26,14 @@ if (!ScanConfig (config, "RELASTRO_IMFIT_SYS_SIGMA_LIM", "%lf", 0, &IMFIT_SYS_SIGMA_LIM)) IMFIT_SYS_SIGMA_LIM = 0.01; - GetConfig (config, "PM_DT_MIN", "%lf", 0, &PM_DT_MIN); - GetConfig (config, "PM_TOOFEW", "%d", 0, &PM_TOOFEW); - GetConfig (config, "POS_TOOFEW", "%d", 0, &POS_TOOFEW); + if (!ScanConfig (config, "PM_DT_MIN", "%lf", 0, &PM_DT_MIN)) PM_DT_MIN = 0.25; + if (!ScanConfig (config, "PM_TOOFEW", "%d", 0, &PM_TOOFEW)) PM_TOOFEW = 4; + if (!ScanConfig (config, "POS_TOOFEW", "%d", 0, &POS_TOOFEW)) POS_TOOFEW = 1; + if (!ScanConfig (config, "PAR_FACTOR_MIN", "%lf", 0, &PAR_FACTOR_MIN)) PAR_FACTOR_MIN = 0.2; + if (!ScanConfig (config, "RELASTRO_MAP_NX", "%d", 0, &NX_MAP)) NX_MAP = 5; + if (!ScanConfig (config, "RELASTRO_MAP_NY", "%d", 0, &NY_MAP)) NY_MAP = 5; + if (!ScanConfig (config, "RELASTRO_DPOS_MAX", "%lf", 0, &DPOS_MAX)) DPOS_MAX = 6.0; + if (!ScanConfig (config, "ADDSTAR_RADIUS", "%lf", 0, &ADDSTAR_RADIUS)) ADDSTAR_RADIUS = 1.0; - GetConfig (config, "PAR_FACTOR_MIN", "%lf", 0, &PAR_FACTOR_MIN); - - GetConfig (config, "RELASTRO_MAP_NX", "%d", 0, &NX_MAP); - GetConfig (config, "RELASTRO_MAP_NY", "%d", 0, &NY_MAP); - GetConfig (config, "RELASTRO_DPOS_MAX", "%lf", 0, &DPOS_MAX); - GetConfig (config, "ADDSTAR_RADIUS", "%lf", 0, &ADDSTAR_RADIUS); - - if (!ScanConfig (config, "USE_FIXED_PIXCOORDS", "%d", 0, &USE_FIXED_PIXCOORDS)) { - USE_FIXED_PIXCOORDS = FALSE; - } + if (!ScanConfig (config, "USE_FIXED_PIXCOORDS", "%d", 0, &USE_FIXED_PIXCOORDS)) USE_FIXED_PIXCOORDS = FALSE; // force CATDIR to be absolute (so parallel mode will work) @@ -56,10 +53,6 @@ sprintf (ImageCat, "%s/Images.dat", CATDIR); - if (!ScanConfig (config, "SKY_DEPTH", "%d", 0, &SKY_DEPTH)) { - SKY_DEPTH = 2; - } - if (!ScanConfig (config, "SKY_TABLE", "%s", 0, SKY_TABLE)) { - SKY_TABLE[0] = 0; - } + if (!ScanConfig (config, "SKY_DEPTH", "%d", 0, &SKY_DEPTH)) SKY_DEPTH = 2; + if (!ScanConfig (config, "SKY_TABLE", "%s", 0, SKY_TABLE)) SKY_TABLE[0] = 0; if (*CATMODE == 0) strcpy (CATMODE, "RAW"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/FitChip.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/FitChip.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/FitChip.c (revision 37067) @@ -4,5 +4,5 @@ int FitChip (StarData *raw, StarData *ref, int Nmatch, Image *image) { - int i, NstatFull, Nstat, Niter; + int i, NstatFull, Nstat, Niter, Nkeep; float dLsig, dMsig, dRsig; float dLsigFull, dMsigFull, dRsigFull; @@ -24,4 +24,5 @@ // measure the scatter distribution (use only the bright end detections) + Nkeep = 0; for (i = 0; i < Nmatch; i++) { if (raw[i].mask) continue; @@ -42,5 +43,9 @@ continue; } - } + Nkeep ++; + } + + // I'm rejecting some points from the fit above; I count the remainders and actually + // use that count to set order_use below // figures to assess the fitting process: @@ -50,16 +55,15 @@ relastroVisualPlotChipFit(raw, ref, dRmax, Nmatch); - // fit the requested order polynomial - if (CHIPORDER > 0) { - int Ndof_min = 3; - int order_max = 0.5*(sqrt(4*Nmatch - 4*Ndof_min + 1) - 3); - int order_use = MIN (CHIPORDER, order_max); - if (order_use < 1) { - if (VERBOSE2) fprintf (stderr, "insufficient measurements (%d) for linear fit\n", Nmatch); - image[0].flags |= ID_IMAGE_ASTROM_FEW; - return FALSE; - } - image[0].coords.Npolyterms = order_use; - } + // set the maximum order for the polynomial (based on number of stars kept above) + int order_use = 0; + if (Nkeep > 5) order_use = 1; // 4 stars per polynomial term (per dimension) + if (Nkeep > 30) order_use = 2; // 5 stars per polynomial term (per dimension) + if (Nkeep > 60) order_use = 3; // 6 stars per polynomial term (per dimension) + if (order_use < 1) { + if (VERBOSE2) fprintf (stderr, "insufficient measurements (%d) for linear fit\n", Nkeep); + image[0].flags |= ID_IMAGE_ASTROM_FEW; + return FALSE; + } + image[0].coords.Npolyterms = order_use; if (fit) fit_free (fit); @@ -71,30 +75,4 @@ fit_add (fit, raw[i].X, raw[i].Y, ref[i].L, ref[i].M, raw[i].dPos); } - -# if (0) - // check if the fit has enough data points for the polynomial order - skip = FALSE; - switch (image[0].coords.Npolyterms) { - case 0: - case 1: - skip = (fit[0].Npts < 8); - break; - case 2: - skip = (fit[0].Npts < 11); - break; - case 3: - skip = (fit[0].Npts < 15); - break; - default: - fprintf (stderr, "invalid chip order %d\n", image[0].coords.Npolyterms); - skip = TRUE; - } - if (skip) { - if (VERBOSE2) fprintf (stderr, "insufficient measurements (%d) for requested order (%d)\n", fit[0].Npts, image[0].coords.Npolyterms); - fit_free (fit); - image[0].flags |= ID_IMAGE_ASTROM_FEW; - return FALSE; - } -# endif // measure the fit, update the coords & object coordinates @@ -134,4 +112,35 @@ } + int Ncolor; + float colorMedian; + float *colorList = NULL; + ALLOCATE (colorList, float, Nmatch); + + // calculate the median blue color + Ncolor = 0; + for (i = 0; i < Nmatch; i++) { + if (!raw[i].mask) continue; + if (isnan(ref[i].ColorBlue)) continue; + colorList[Ncolor] = ref[i].ColorBlue; + Ncolor ++; + } + fsort (colorList, Ncolor); + colorMedian = (Ncolor > 0) ? colorList[(int)(0.5*Ncolor)] : NAN; + image[0].refColorBlue = colorMedian; + + // calculate the median red color + Ncolor = 0; + for (i = 0; i < Nmatch; i++) { + if (!raw[i].mask) continue; + if (isnan(ref[i].ColorRed)) continue; + colorList[Ncolor] = ref[i].ColorRed; + Ncolor ++; + } + fsort (colorList, Ncolor); + colorMedian = (Ncolor > 0) ? colorList[(int)(0.5*Ncolor)] : NAN; + image[0].refColorRed = colorMedian; + + free (colorList); + GetScatterRawRef(&dLsigFull, &dMsigFull, &dRsigFull, &NstatFull, raw, ref, Nmatch, SIGMA_LIM); GetScatterRawRef(&dLsig, &dMsig, &dRsig, &Nstat, raw, ref, Nmatch, IMFIT_SYS_SIGMA_LIM); @@ -151,4 +160,6 @@ image[0].dYpixSys = dMsig; image[0].nFitAstrom = fit[0].Npts; + + // fprintf (stderr, "%s %6.3f %4d %4d\n", image[0].name, image[0].refColor, Ncolor, image[0].nFitAstrom); if (fit) fit_free (fit); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/GetAstromError.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/GetAstromError.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/GetAstromError.c (revision 37067) @@ -30,4 +30,5 @@ code = GetPhotcodebyCode (measure[0].photcode); + if (!code) return NAN; // do not raise an exception, just send back the result @@ -72,4 +73,5 @@ code = GetPhotcodebyCode (measure[0].photcode); + if (!code) return NAN; // do not raise an exception, just send back the result Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImageOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImageOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImageOps.c (revision 37067) @@ -39,4 +39,16 @@ // N_onImage was 'Nlist' // N_ONIMAGE was 'NLIST' + +int areImagesLoaded () { + + if (image) return TRUE; + return FALSE; +} + +int areImagesMatched () { + + if (MeasureToImage) return TRUE; + return FALSE; +} Image *getimages (off_t *N, off_t **line_number) { @@ -226,6 +238,6 @@ Measure *measureBig = &catalog[cat].measure[meas]; int TESTPT = FALSE; - TESTPT |= (measureBig->imageID == CAT_ID_SRC) && (measureBig->detID == OBJ_ID_SRC); - TESTPT |= (measureBig->imageID == CAT_ID_DST) && (measureBig->detID == OBJ_ID_DST); + TESTPT |= CAT_ID_SRC && OBJ_ID_SRC && (measureBig->imageID == CAT_ID_SRC) && (measureBig->detID == OBJ_ID_SRC); + TESTPT |= CAT_ID_DST && OBJ_ID_DST && (measureBig->imageID == CAT_ID_DST) && (measureBig->detID == OBJ_ID_DST); if (TESTPT) { fprintf (stderr, "got test det\n"); @@ -333,4 +345,22 @@ */ +float getColorBlue (off_t meas, int cat) { + + off_t i; + + i = MeasureToImage[cat][meas]; + if (i == -1) return (NAN); + return (image[i].refColorBlue); +} + +float getColorRed (off_t meas, int cat) { + + off_t i; + + i = MeasureToImage[cat][meas]; + if (i == -1) return (NAN); + return (image[i].refColorRed); +} + void plot_images () { @@ -385,5 +415,5 @@ for (j = 0; j < average[0].Nmeasure; j++) { off = average[0].measureOffset + j; - fprintf (stderr, "dR, dD, mag, dMag: %f, %f, %f, %f\n", measure[off].dR, measure[off].dD, measure[off].M, measure[off].dM); + fprintf (stderr, "R, D, mag, dMag: %lf, %lf, %f, %f\n", measure[off].R, measure[off].D, measure[off].M, measure[off].dM); } return; @@ -462,16 +492,21 @@ int TESTPT = FALSE; - TESTPT |= (measure->imageID == CAT_ID_SRC) && (measure->detID == OBJ_ID_SRC); - TESTPT |= (measure->imageID == CAT_ID_DST) && (measure->detID == OBJ_ID_DST); + TESTPT |= CAT_ID_SRC && OBJ_ID_SRC && (measure->imageID == CAT_ID_SRC) && (measure->detID == OBJ_ID_SRC); + TESTPT |= CAT_ID_DST && OBJ_ID_DST && (measure->imageID == CAT_ID_DST) && (measure->detID == OBJ_ID_DST); if (TESTPT) { fprintf (stderr, "got test det\n"); } + X = measure[0].Xccd; + Y = measure[0].Yccd; if (USE_FIXED_PIXCOORDS) { - X = isfinite(measure[0].Xfix) ? measure[0].Xfix : measure[0].Xccd; - Y = isfinite(measure[0].Yfix) ? measure[0].Yfix : measure[0].Yccd; - } else { - X = measure[0].Xccd; - Y = measure[0].Yccd; + if (isfinite(measure[0].Xfix) && isfinite(measure[0].Yfix)) { + float dX = measure[0].Xfix - measure[0].Xccd; + float dY = measure[0].Yfix - measure[0].Yccd; + if (hypot(dX,dY) < 2.0) { + X = measure[0].Xfix; + Y = measure[0].Yfix; + } + } } n = measure[0].averef; @@ -528,27 +563,28 @@ // complain if the new location is far from the old location - if (fabs(csdec*(measure[0].dR - dR)) > DPOS_MAX_ASEC) { + if (fabs(csdec*(measure[0].R - R)) > DPOS_MAX_ASEC) { NoffRAori ++; if (VERBOSE2) { - fprintf (stderr, "measurement moves far from original location (R): %f %f (%f %f %f %f)\n", average[0].R, average[0].D, measure[0].dR, dR, csdec*(measure[0].dR - dR), dD); + fprintf (stderr, "measurement moves far from original location (R): %f %f (%f %f %f %f)\n", average[0].R, average[0].D, measure[0].R, dR, csdec*(measure[0].R - R), dD); dump_measures (&average[0], catalog[c].measure); } // abort(); } - if (fabs(measure[0].dD - dD) > DPOS_MAX_ASEC) { + if (fabs(measure[0].D - D) > DPOS_MAX_ASEC) { NoffDECori ++; if (VERBOSE2) { - fprintf (stderr, "measurement moves far from original location (D): %f %f (%f %f %f)\n", average[0].R, average[0].D, dR, measure[0].dD, dD); + fprintf (stderr, "measurement moves far from original location (D): %f %f (%f %f %f)\n", average[0].R, average[0].D, dR, measure[0].D, dD); dump_measures (&average[0], catalog[c].measure); } // abort(); } - dPos += SQ(measure[0].dR - dR) + SQ(measure[0].dD - dD); + // XXX NOTE : apply csdec: + dPos += SQ(measure[0].R - R) + SQ(measure[0].D - D); nPos ++; - measure[0].dR = dR; - measure[0].dD = dD; - measureT[0].dR = dR; - measureT[0].dD = dD; + measure[0].R = R; + measure[0].D = D; + measureT[0].R = R; + measureT[0].D = D; // set the systematic error for this image: @@ -560,5 +596,5 @@ int Noff = NoffRAave + NoffDECave + NoffRAori + NoffDECori; - if (VERBOSE && (Noff > 0)) fprintf (stderr, "Noff ave RA %d, Noff ave DEC %d, Noff ori RA %d, Noff ori DEC %d\n", NoffRAave, NoffDECave, NoffRAori, NoffDECori); + if (VERBOSE2 && (Noff > 0)) fprintf (stderr, "Noff ave RA %d, Noff ave DEC %d, Noff ori RA %d, Noff ori DEC %d\n", NoffRAave, NoffDECave, NoffRAori, NoffDECori); saveOffsets (dPos, nPos, im); @@ -575,5 +611,5 @@ off_t i, m, c, n; - double X, Y, L, M, P, Q, R, D, dR, dD; + double X, Y, L, M, P, Q, R, D; Mosaic *mosaic; @@ -609,14 +645,18 @@ Measure *measure = &catalog[c].measure[m]; + X = measure[0].Xccd; + Y = measure[0].Yccd; if (USE_FIXED_PIXCOORDS) { - X = isfinite(measure[0].Xfix) ? measure[0].Xfix : measure[0].Xccd; - Y = isfinite(measure[0].Yfix) ? measure[0].Yfix : measure[0].Yccd; - } else { - X = measure[0].Xccd; - Y = measure[0].Yccd; + if (isfinite(measure[0].Xfix) && isfinite(measure[0].Yfix)) { + float dX = measure[0].Xfix - measure[0].Xccd; + float dY = measure[0].Yfix - measure[0].Yccd; + if (hypot(dX,dY) < 2.0) { + X = measure[0].Xfix; + Y = measure[0].Yfix; + } + } } n = measure[0].averef; - dR = dD = 0.0; if (moscoords == NULL) { // this is a Simple image (not a mosaic) @@ -629,17 +669,17 @@ LM_to_RD (&R, &D, P, Q, moscoords); } - - measure[0].dR = dR; - measure[0].dD = dD; - - if (measure[0].dR > +180.0*3600.0) { + measure[0].R = R; + measure[0].D = D; + + float dRoff = dvoOffsetR(measure, &catalog[c].average[n]); + + if (dRoff > +180.0*3600.0) { // average on high end of boundary, move star up - R += 360.0; - measure[0].dR = 3600.0*(catalog[c].average[n].R - R); - } - if (measure[0].dR < -180.0*3600.0) { - // average on low end of boundary, move star down - R -= 360.0; - measure[0].dR = 3600.0*(catalog[c].average[n].R - R); + measure[0].R += 360.0; + dRoff -= 360.0*3600.0; + } + if (dRoff < -180.0*3600.0) { + measure[0].R -= 360.0; + dRoff += 360.0*3600.0; } } @@ -679,12 +719,16 @@ /* apply the current image transformation or use the current value of R+dR, D+dD? */ + raw[i].X = measure[0].Xccd; + raw[i].Y = measure[0].Yccd; if (USE_FIXED_PIXCOORDS) { - raw[i].X = isfinite(measure[0].Xfix) ? measure[0].Xfix : measure[0].Xccd; - raw[i].Y = isfinite(measure[0].Yfix) ? measure[0].Yfix : measure[0].Yccd; - } else { - raw[i].X = measure[0].Xccd; - raw[i].Y = measure[0].Yccd; - } - + if (isfinite(measure[0].Xfix) && isfinite(measure[0].Yfix)) { + float dX = measure[0].Xfix - measure[0].Xccd; + float dY = measure[0].Yfix - measure[0].Yccd; + if (hypot(dX,dY) < 2.0) { + raw[i].X = measure[0].Xfix; + raw[i].Y = measure[0].Yfix; + } + } + } raw[i].Mag = measure[0].M; raw[i].dMag = measure[0].dM; @@ -699,5 +743,5 @@ raw[i].mask |= MARK_TOO_FEW_MEAS; } - if (!finite(measure[0].dR) || !finite(measure[0].dD)) { + if (!finite(measure[0].R) || !finite(measure[0].D)) { raw[i].mask |= MARK_NAN_POS_ERROR; } @@ -738,4 +782,6 @@ StarData *ref; + int Nsecfilt = GetPhotcodeNsecfilt(); + mosaic = NULL; moscoords = NULL; @@ -765,4 +811,11 @@ ref[i].dMag = measure[0].dM; ref[i].dPos = GetAstromErrorTiny (&measure[0], ERROR_MODE_POS); + + if ((DCR_BLUE_NSEC_POS >= 0) && (DCR_BLUE_NSEC_NEG >= -1)) { + ref[i].ColorBlue = catalog[c].secfilt[n*Nsecfilt + DCR_BLUE_NSEC_POS].M - catalog[c].secfilt[n*Nsecfilt + DCR_BLUE_NSEC_NEG].M; + } + if ((DCR_RED_NSEC_POS >= 0) && (DCR_RED_NSEC_NEG >= -1)) { + ref[i].ColorRed = catalog[c].secfilt[n*Nsecfilt + DCR_RED_NSEC_POS].M - catalog[c].secfilt[n*Nsecfilt + DCR_RED_NSEC_NEG].M; + } ref[i].mask = FALSE; @@ -839,6 +892,6 @@ // skip measurements based on user selected criteria if (!MeasFilterTest(&measure[k], FALSE)) continue; - R[N] = measure[k].dR; - D[N] = measure[k].dD; + R[N] = measure[k].R; + D[N] = measure[k].D; dR[N] = GetAstromError (&measure[k], ERROR_MODE_RA); dD[N] = GetAstromError (&measure[k], ERROR_MODE_DEC); @@ -859,5 +912,5 @@ N = 0; for (k = 0; k < catalog[0].average[j].Nmeasure; k++) { - //reset flag on each invocation + // reset flag on each invocation measure[k].dbFlags &= ~ID_MEAS_POOR_ASTROM; @@ -865,6 +918,6 @@ if (!MeasFilterTest(&measure[k], FALSE)) continue; - x = measure[k].dR - statsR.median; - y = measure[k].dD - statsD.median; + x = measure[k].R - statsR.median; + y = measure[k].D - statsD.median; theta = atan2(y,x); if ((x*x + y*y) > (SQR(statsR.sigma * Ns * cos(theta)) + @@ -898,4 +951,7 @@ double *R, *D, *dR, *dD, *d2; StatType statsR, statsD; + + // XXX we are not going to use this for now + return; Nsecfilt = GetPhotcodeNsecfilt(); @@ -937,6 +993,6 @@ // skip measurements based on user selected criteria if (!MeasFilterTest(&measure[k], FALSE)) continue; - R[N] = measure[k].dR; - D[N] = measure[k].dD; + R[N] = measure[k].R; + D[N] = measure[k].D; dR[N] = GetAstromError(&measure[k], ERROR_MODE_RA); dD[N] = GetAstromError(&measure[k], ERROR_MODE_DEC); @@ -958,6 +1014,6 @@ // skip bad measurements if (!MeasFilterTest(&measure[k], FALSE)) continue; - x = measure[k].dR - statsR.median; - y = measure[k].dD - statsD.median; + x = measure[k].R - statsR.median; + y = measure[k].D - statsD.median; theta = atan2(y,x); d2[N] = (x*x + y*y) / (SQR(statsR.sigma * Ns * cos(theta)) + @@ -974,6 +1030,6 @@ for (k = 0; k < N; k++) { off_t ind = (off_t) index[k]; - R[k] = measure[ind].dR; - D[k] = measure[ind].dD; + R[k] = measure[ind].R; + D[k] = measure[ind].D; dR[k] = GetAstromError(&measure[ind], ERROR_MODE_RA); dD[k] = GetAstromError(&measure[ind], ERROR_MODE_DEC); @@ -989,6 +1045,6 @@ //skip bad measurements if (!MeasFilterTest(&measure[k], FALSE)) continue; - x = measure[k].dR - statsR.median; - y = measure[k].dD - statsD.median; + x = measure[k].R - statsR.median; + y = measure[k].D - statsD.median; theta = atan2(y,x); d2[N] = (x*x + y*y) / (SQR(statsR.sigma * Ns * cos(theta)) + @@ -1024,5 +1080,5 @@ float mag; - if (!finite(measure[0].dR) || !finite(measure[0].dD)) return FALSE; + if (!finite(measure[0].R) || !finite(measure[0].D)) return FALSE; if (!finite(measure[0].M)) return FALSE; //XXX is this necessary for all relastro tasks? if (!finite(measure[0].dM)) return FALSE; //XXX is this necessary for all relastro tasks? @@ -1063,4 +1119,5 @@ } else { code = GetPhotcodebyCode (measure[0].photcode); + if (!code) return FALSE; mask = code[0].astromBadMask; } @@ -1075,5 +1132,5 @@ /* select measurements by mag limit */ if (ImagSelect) { - mag = PhotInstTiny (measure); + mag = PhotInstTiny (measure, MAG_CLASS_PSF); if (mag < ImagMin || mag > ImagMax) return FALSE; } @@ -1090,5 +1147,5 @@ float mag; - if (!finite(measure[0].dR) || !finite(measure[0].dD)) return FALSE; + if (!finite(measure[0].R) || !finite(measure[0].D)) return FALSE; if (!finite(measure[0].M)) return FALSE; //XXX is this necessary for all relastro tasks? if (!finite(measure[0].dM)) return FALSE; //XXX is this necessary for all relastro tasks? @@ -1129,4 +1186,5 @@ } else { code = GetPhotcodebyCode (measure[0].photcode); + if (!code) return FALSE; mask = code[0].astromBadMask; } @@ -1141,5 +1199,5 @@ /* select measurements by mag limit */ if (ImagSelect) { - mag = PhotInst (measure); + mag = PhotInst (measure, MAG_CLASS_PSF); if (mag < ImagMin || mag > ImagMax) return FALSE; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImagePosIO.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImagePosIO.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImagePosIO.c (revision 37067) @@ -0,0 +1,315 @@ +# include "relastro.h" + +# define GET_COLUMN(OUT,NAME,TYPE) \ + TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \ + myAssert (!strcmp(type, #TYPE), "wrong column type"); + +// this is nearly identical to the one in 'uniphot/src' used by setphot / setphot_client. +// Here, we use a handful of different columns (if not, we could move to libdvo) +ImagePos *ImagePosLoad(char *filename, off_t *nimage_pos) { + + int i, Ncol; + off_t Nrow; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + *nimage_pos = 0; + ImagePos *image_pos = NULL; + + FILE *f = fopen (filename, "r"); + if (!f) { + fprintf (stderr, "ERROR: cannot open image subset file %s\n", filename); + return NULL; + } + + /* load in PHU segment (ignore) */ + if (!gfits_fread_header (f, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset header\n"); + fclose (f); + return NULL; + } + if (!gfits_fread_matrix (f, &matrix, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset matrix\n"); + gfits_free_header (&header); + fclose (f); + return NULL; + } + + ftable.header = &theader; + + // load data for this header + if (!gfits_load_header (f, &theader)) { + fclose (f); + return NULL; + } + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftable, FALSE)) { + fclose (f); + return (NULL); + } + fclose (f); + + // we read the entire block of data, then extract the columns, then set the image structure values. + // I free the FITS table data after extracting the colums to avoid having 3 copies in memory. + + char type[16]; + + GET_COLUMN (crval1, "CRVAL1", double); + GET_COLUMN (crval2, "CRVAL2", double); + GET_COLUMN (crpix1, "CRPIX1", float); + GET_COLUMN (crpix2, "CRPIX2", float); + GET_COLUMN (cdelt1, "CDELT1", float); + GET_COLUMN (cdelt2, "CDELT2", float); + GET_COLUMN (pc1_1, "PC1_1", float); + GET_COLUMN (pc1_2, "PC1_2", float); + GET_COLUMN (pc2_1, "PC2_1", float); + GET_COLUMN (pc2_2, "PC2_2", float); + GET_COLUMN (polyterms, "POLYTERMS", float); // verify that we got 14 columns? + GET_COLUMN (ctype, "CTYPE", char); // verify that we got 15 columns? + GET_COLUMN (Npolyterms, "NPOLYTERMS", char); + GET_COLUMN (dXpixSys, "XPIX_SYS_ERR", float); + GET_COLUMN (dYpixSys, "YPIX_SYS_ERR", float); + GET_COLUMN (imageID, "ID", int); + GET_COLUMN (nFitAstrom, "NFIT", int); + GET_COLUMN (flags, "FLAGS", int); + + // free the memory associated with the FITS files + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + ALLOCATE (image_pos, ImagePos, Nrow); + for (i = 0; i < Nrow; i++) { + image_pos[i].coords.crval1 = crval1 [i]; + image_pos[i].coords.crval2 = crval2 [i]; + image_pos[i].coords.crpix1 = crpix1 [i]; + image_pos[i].coords.crpix2 = crpix2 [i]; + image_pos[i].coords.cdelt1 = cdelt1 [i]; + image_pos[i].coords.cdelt2 = cdelt2 [i]; + image_pos[i].coords.pc1_1 = pc1_1 [i]; + image_pos[i].coords.pc1_2 = pc1_2 [i]; + image_pos[i].coords.pc2_1 = pc2_1 [i]; + image_pos[i].coords.pc2_2 = pc2_2 [i]; + image_pos[i].coords.Npolyterms = Npolyterms[i]; + image_pos[i].dXpixSys = dXpixSys [i]; + image_pos[i].dYpixSys = dYpixSys [i]; + image_pos[i].imageID = imageID [i]; + image_pos[i].nFitAstrom = nFitAstrom[i]; + image_pos[i].flags = flags [i]; + + // polyterms and ctype are a bit different + memcpy (&image_pos[i].coords.polyterms, &polyterms[i*14], 14*sizeof(float)); + memcpy (&image_pos[i].coords.ctype , &ctype [i*15], 15*sizeof(char)); + } + fprintf (stderr, "loaded data for %lld images\n", (long long) Nrow); + + free (crval1 ); + free (crval2 ); + free (crpix1 ); + free (crpix2 ); + free (cdelt1 ); + free (cdelt2 ); + free (pc1_1 ); + free (pc1_2 ); + free (pc2_1 ); + free (pc2_2 ); + free (polyterms ); + free (ctype ); + free (Npolyterms); + free (dXpixSys ); + free (dYpixSys ); + free (imageID ); + free (nFitAstrom); + free (flags ); + + *nimage_pos = Nrow; + return image_pos; +} + +// STATUS is value expected for success +# define CHECK_STATUS(STATUS,MSG,...) \ + if (!(STATUS)) { \ + fprintf (stderr, MSG, __VA_ARGS__); \ + return FALSE; \ + } + +int ImagePosSave(char *filename, ImagePos *image_pos, off_t Nimage_pos) { + + int i; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + gfits_init_header (&header); + header.extend = TRUE; + gfits_create_header (&header); + gfits_create_matrix (&header, &matrix); + + gfits_create_table_header (&theader, "BINTABLE", "IMAGE_POS"); + + gfits_define_bintable_column (&theader, "D", "CRVAL1", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "CRVAL2", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CRPIX1", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CRPIX2", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CDELT1", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "CDELT2", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "PC1_1", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "PC1_2", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "PC2_1", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "PC2_2", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "14E", "POLYTERMS", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "15A", "CTYPE", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "L", "NPOLYTERMS", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "XPIX_SYS_ERR", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "YPIX_SYS_ERR", "word", "unit", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "ID", "image ID", "unitless", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "NFIT", "number of fitted stars", "unitless", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "FLAGS", "analysis flags", "unitless", 1.0, 0.0); + + // generate the output array that carries the data + gfits_create_table (&theader, &ftable); + + double *crval1 ; + double *crval2 ; + float *crpix1 ; + float *crpix2 ; + float *cdelt1 ; + float *cdelt2 ; + float *pc1_1 ; + float *pc1_2 ; + float *pc2_1 ; + float *pc2_2 ; + float *polyterms ; + char *ctype ; + char *Npolyterms; + float *dXpixSys ; + float *dYpixSys ; + int *imageID ; + int *nFitAstrom; + int *flags ; + + // create intermediate storage arrays + ALLOCATE (crval1 , double, Nimage_pos); + ALLOCATE (crval2 , double, Nimage_pos); + ALLOCATE (crpix1 , float , Nimage_pos); + ALLOCATE (crpix2 , float , Nimage_pos); + ALLOCATE (cdelt1 , float , Nimage_pos); + ALLOCATE (cdelt2 , float , Nimage_pos); + ALLOCATE (pc1_1 , float , Nimage_pos); + ALLOCATE (pc1_2 , float , Nimage_pos); + ALLOCATE (pc2_1 , float , Nimage_pos); + ALLOCATE (pc2_2 , float , Nimage_pos); + ALLOCATE (polyterms , float , 14*Nimage_pos); + ALLOCATE (ctype , char , 15*Nimage_pos); + ALLOCATE (Npolyterms, char , Nimage_pos); + ALLOCATE (dXpixSys , float , Nimage_pos); + ALLOCATE (dYpixSys , float , Nimage_pos); + ALLOCATE (imageID , int , Nimage_pos); + ALLOCATE (nFitAstrom, int , Nimage_pos); + ALLOCATE (flags , int , Nimage_pos); + + // assign the storage arrays + for (i = 0; i < Nimage_pos; i++) { + crval1 [i] = image_pos[i].coords.crval1 ; + crval2 [i] = image_pos[i].coords.crval2 ; + crpix1 [i] = image_pos[i].coords.crpix1 ; + crpix2 [i] = image_pos[i].coords.crpix2 ; + cdelt1 [i] = image_pos[i].coords.cdelt1 ; + cdelt2 [i] = image_pos[i].coords.cdelt2 ; + pc1_1 [i] = image_pos[i].coords.pc1_1 ; + pc1_2 [i] = image_pos[i].coords.pc1_2 ; + pc2_1 [i] = image_pos[i].coords.pc2_1 ; + pc2_2 [i] = image_pos[i].coords.pc2_2 ; + Npolyterms[i] = image_pos[i].coords.Npolyterms; + dXpixSys [i] = image_pos[i].dXpixSys ; + dYpixSys [i] = image_pos[i].dYpixSys ; + imageID [i] = image_pos[i].imageID ; + nFitAstrom[i] = image_pos[i].nFitAstrom ; + flags [i] = image_pos[i].flags ; + + // polyterms and ctype are a bit different + memcpy (&polyterms[i*14], &image_pos[i].coords.polyterms, 14*sizeof(float)); + memcpy (&ctype [i*15], &image_pos[i].coords.ctype , 15*sizeof(char)); + } + + // add the columns to the output array + gfits_set_bintable_column (&theader, &ftable, "CRVAL1", crval1 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "CRVAL2", crval2 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "CRPIX1", crpix1 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "CRPIX2", crpix2 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "CDELT1", cdelt1 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "CDELT2", cdelt2 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "PC1_1", pc1_1 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "PC1_2", pc1_2 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "PC2_1", pc2_1 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "PC2_2", pc2_2 , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "POLYTERMS", polyterms , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "CTYPE", ctype , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "NPOLYTERMS", Npolyterms, Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "XPIX_SYS_ERR",dXpixSys , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "YPIX_SYS_ERR",dYpixSys , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "ID", imageID , Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "NFIT", nFitAstrom, Nimage_pos); + gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags , Nimage_pos); + + free (crval1 ); + free (crval2 ); + free (crpix1 ); + free (crpix2 ); + free (cdelt1 ); + free (cdelt2 ); + free (pc1_1 ); + free (pc1_2 ); + free (pc2_1 ); + free (pc2_2 ); + free (polyterms ); + free (ctype ); + free (Npolyterms); + free (dXpixSys ); + free (dYpixSys ); + free (imageID ); + free (nFitAstrom); + free (flags ); + + FILE *f = fopen (filename, "w"); + if (!f) { + fprintf (stderr, "ERROR: cannot open image_pos file for output %s\n", filename); + return FALSE; + } + + int status; + status = gfits_fwrite_header (f, &header); + CHECK_STATUS (status, "ERROR: cannot write header for image_pos %s\n", filename); + + status = gfits_fwrite_matrix (f, &matrix); + CHECK_STATUS (status, "ERROR: cannot write matrix for image_pos %s\n", filename); + + status = gfits_fwrite_Theader (f, &theader); + CHECK_STATUS (status, "ERROR: cannot write table header for image_pos %s\n", filename); + + status = gfits_fwrite_table (f, &ftable); + CHECK_STATUS (status, "ERROR: cannot write table data for image_pos %s\n", filename); + + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + int fd = fileno (f); + + status = fflush (f); + CHECK_STATUS (!status, "ERROR: cannot flush file image_pos %s\n", filename); + + status = fsync (fd); + CHECK_STATUS (!status, "ERROR: cannot flush file image_pos %s\n", filename); + + status = fclose (f); + CHECK_STATUS (!status, "ERROR: problem closing image_pos file %s\n", filename); + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImageTable.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImageTable.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImageTable.c (revision 37067) @@ -0,0 +1,62 @@ +# include "relastro.h" + +Image *ImageTableLoad(char *filename, off_t *nimage) { + + int status; + off_t Nimage; + FITS_DB db; + + db.mode = dvo_catalog_catmode (CATMODE); + db.format = dvo_catalog_catformat (CATFORMAT); + + /* lock and load the image db table */ + status = dvo_image_lock (&db, filename, 60.0, LCK_SOFT); + if (!status) { + Shutdown ("ERROR: failure to lock image catalog %s", db.filename); + } + + // if the file is missing, db.dbstate will have a value of either: + // LCK_EMPTY (if UPDATE) or LCK_MISSING (if !UPDATE) + if ((db.dbstate == LCK_EMPTY) || (db.dbstate == LCK_MISSING)) { + Shutdown ("ERROR: database %s contains no image data", CATDIR); + } + + // read data from Image.dat file + if (!dvo_image_load (&db, VERBOSE, FALSE)) Shutdown ("can't read image catalog %s", db.filename); + + // convert database table to internal structure (binary to Image) + // 'image' points to the same memory as db->ftable->buffer + Image *image = gfits_table_get_Image (&db.ftable, &Nimage, &db.swapped); + if (!image) { + Shutdown ("ERROR: failed to read images"); + } + + *nimage = Nimage; + return image; +} + +int ImageTableSave (char *filename, Image *images, off_t Nimages) { + + int status; + FITS_DB db; + + // setup image table format and lock + db.mode = dvo_catalog_catmode (CATMODE); + db.format = dvo_catalog_catformat (CATFORMAT); + status = dvo_image_lock (&db, filename, 60.0, LCK_XCLD); // shorter timeout? + if (!status) Shutdown ("ERROR: failure to lock image catalog %s", db.filename); + + // load or create the image table + if (db.dbstate != LCK_EMPTY) { + Shutdown ("image catalog already exists %s", db.filename); + } + + dvo_image_create (&db, GetZeroPoint()); + + /* add the new images and save */ + dvo_image_addrows (&db, images, Nimages); + dvo_image_update (&db, VERBOSE); + dvo_image_unlock (&db); + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/MeanPosIO.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/MeanPosIO.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/MeanPosIO.c (revision 37067) @@ -0,0 +1,183 @@ +# include "relastro.h" + +# define GET_COLUMN(OUT,NAME,TYPE) \ + TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \ + myAssert (!strcmp(type, #TYPE), "wrong column type"); + +// this is nearly identical to the one in 'uniphot/src' used by setphot / setphot_client. +// Here, we use a handful of different columns (if not, we could move to libdvo) +MeanPos *MeanPosLoad(char *filename, off_t *nmeanpos) { + + int i, Ncol; + off_t Nrow; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + *nmeanpos = 0; + MeanPos *meanpos = NULL; + + FILE *f = fopen (filename, "r"); + if (!f) { + fprintf (stderr, "ERROR: cannot open image subset file %s\n", filename); + return NULL; + } + + /* load in PHU segment (ignore) */ + if (!gfits_fread_header (f, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset header\n"); + fclose (f); + return NULL; + } + if (!gfits_fread_matrix (f, &matrix, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset matrix\n"); + gfits_free_header (&header); + fclose (f); + return NULL; + } + + ftable.header = &theader; + + // load data for this header + if (!gfits_load_header (f, &theader)) { + fclose (f); + return NULL; + } + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftable, FALSE)) { + fclose (f); + return (NULL); + } + fclose (f); + + // a bit annoying : we read the entire block of data, then extract the columns, then set the image structure values. + // this means I need 3 copies in memory at some point. ugh. + + char type[16]; + + GET_COLUMN (R, "RA", double); + GET_COLUMN (D, "DEC", double); + GET_COLUMN (objID, "OBJ_ID", int); + GET_COLUMN (catID, "CAT_ID", int); + + ALLOCATE (meanpos, MeanPos, Nrow); + for (i = 0; i < Nrow; i++) { + meanpos[i].R = R [i]; + meanpos[i].D = D [i]; + meanpos[i].objID = objID[i]; + meanpos[i].catID = catID[i]; + } + fprintf (stderr, "loaded data for %lld objects (* filters)\n", (long long) Nrow); + + free (R ); + free (D ); + free (objID); + free (catID); + + // free FITS table pieces... + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + *nmeanpos = Nrow; + return meanpos; +} + +// STATUS is value expected for success +# define CHECK_STATUS(STATUS,MSG,...) \ + if (!(STATUS)) { \ + fprintf (stderr, MSG, __VA_ARGS__); \ + return FALSE; \ + } + +int MeanPosSave(char *filename, MeanPos *meanpos, off_t Nmeanpos) { + + int i; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + gfits_init_header (&header); + header.extend = TRUE; + gfits_create_header (&header); + gfits_create_matrix (&header, &matrix); + + gfits_create_table_header (&theader, "BINTABLE", "MEANPOS"); + + gfits_define_bintable_column (&theader, "D", "RA", "mean position, ra", "degrees", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "DEC", "mean position, dec", "degrees", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "OBJ_ID", "object ID", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "CAT_ID", "catalog ID", NULL, 1.0, FT_BZERO_INT32); + + // generate the output array that carries the data + gfits_create_table (&theader, &ftable); + + double *R, *D; + unsigned int *objID, *catID; + + // create intermediate storage arrays + ALLOCATE (R, double, Nmeanpos); + ALLOCATE (D, double, Nmeanpos); + ALLOCATE (objID, unsigned int, Nmeanpos); + ALLOCATE (catID, unsigned int, Nmeanpos); + + // assign the storage arrays + for (i = 0; i < Nmeanpos; i++) { + R [i] = meanpos[i].R ; + D [i] = meanpos[i].D ; + objID[i] = meanpos[i].objID; + catID[i] = meanpos[i].catID; + } + + // add the columns to the output array + gfits_set_bintable_column (&theader, &ftable, "RA", R, Nmeanpos); + gfits_set_bintable_column (&theader, &ftable, "DEC", D, Nmeanpos); + gfits_set_bintable_column (&theader, &ftable, "OBJ_ID", objID, Nmeanpos); + gfits_set_bintable_column (&theader, &ftable, "CAT_ID", catID, Nmeanpos); + + free (R ); + free (D ); + free (objID); + free (catID); + + FILE *f = fopen (filename, "w"); + if (!f) { + fprintf (stderr, "ERROR: cannot open meanmag file for output %s\n", filename); + return FALSE; + } + + int status; + status = gfits_fwrite_header (f, &header); + CHECK_STATUS (status, "ERROR: cannot write header for meanpos %s\n", filename); + + status = gfits_fwrite_matrix (f, &matrix); + CHECK_STATUS (status, "ERROR: cannot write matrix for meanpos %s\n", filename); + + status = gfits_fwrite_Theader (f, &theader); + CHECK_STATUS (status, "ERROR: cannot write table header for meanpos %s\n", filename); + + status = gfits_fwrite_table (f, &ftable); + CHECK_STATUS (status, "ERROR: cannot write table data for meanpos %s\n", filename); + + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + int fd = fileno (f); + + status = fflush (f); + CHECK_STATUS (!status, "ERROR: cannot flush file meanpos %s\n", filename); + + status = fsync (fd); + CHECK_STATUS (!status, "ERROR: cannot flush file meanpos %s\n", filename); + + status = fclose (f); + CHECK_STATUS (!status, "ERROR: problem closing meanpos file %s\n", filename); + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/MosaicOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/MosaicOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/MosaicOps.c (revision 37067) @@ -11,5 +11,5 @@ // list of mosaic associated with each image -static off_t Nmosaic_for_images; // number of images (for off_ternal checks) +static off_t Nmosaic_for_images; // number of images (for internal checks) static off_t *mosaic_for_images; // array of: image -> mosaic @@ -97,12 +97,13 @@ /* a new mosaic, define ranges */ - mosaic[Nmosaic].start = start; - mosaic[Nmosaic].stop = stop; - mosaic[Nmosaic].Mcal = 0.0; - mosaic[Nmosaic].dMcal = 0.0; - mosaic[Nmosaic].Xm = 0.0; - mosaic[Nmosaic].flags = image[i].flags; - mosaic[Nmosaic].secz = image[i].secz; - mosaic[Nmosaic].coords = image[i].coords; + mosaic[Nmosaic].start = start; + mosaic[Nmosaic].stop = stop; + mosaic[Nmosaic].Mcal = 0.0; + mosaic[Nmosaic].dMcal = 0.0; + mosaic[Nmosaic].Xm = 0.0; + mosaic[Nmosaic].flags = image[i].flags; + mosaic[Nmosaic].secz = image[i].secz; + mosaic[Nmosaic].coords = image[i].coords; + mosaic[Nmosaic].myImage = i; // init the mosaic_own_images array data @@ -135,4 +136,8 @@ ALLOCATE (mosaic_for_images, off_t, Nmosaic_for_images); + // emit an error if we miss mosaics, but stop if we miss too many + int NmissMosaic = 0; + int NtestMosaic = 0; + /* now assign the WRP images to these mosaics */ for (i = 0; i < Nimage; i++) { @@ -140,4 +145,5 @@ if (strcmp(&image[i].coords.ctype[4], "-WRP")) continue; + NtestMosaic ++; /* set image time range */ @@ -147,5 +153,8 @@ Nmos = getMosaicByTimes (start, stop, startMos, stopMos, indexMos); if (Nmos == -1) { - fprintf (stderr, "cannot match mosaic for %s\n", image[i].name); + if (NmissMosaic < 1000) { + fprintf (stderr, "cannot match mosaic for %s\n", image[i].name); + } + NmissMosaic ++; continue; } @@ -164,4 +173,10 @@ } + fprintf (stderr, "mosaic matching : %d of possible %d failed to match\n", NmissMosaic, NtestMosaic); + if (NmissMosaic > 0.5*NtestMosaic) { + fprintf (stderr, "serious problem with mosaic matching\n"); + exit (5); + } + free (startMos); free (stopMos); @@ -250,5 +265,5 @@ if (im >= Nmosaic_for_images) abort(); - // search for the mosaic that + // search for the mosaic that matches this image mos = mosaic_for_images[im]; if (mos < 0) return NULL; @@ -256,2 +271,60 @@ return &mosaic[mos]; } + +// extend each host image table to include the mosaic 'images' needed by the host +int select_mosaics_hostregion (RegionHostTable *regionHosts, Image *image, off_t Nimage) { + + int i; + off_t j; + char *mosaicUsed; + + ALLOCATE (mosaicUsed, char, Nmosaic); + + // we need to add the mosaics to each of the region hosts lists of images + for (i = 0; i < regionHosts->Nhosts; i++) { + + int Nadd = 0; + int NADD = 100; + off_t *addMosaic = NULL; + ALLOCATE (addMosaic, off_t, NADD); + + // reset the mosaicUsed flags (valid only for this host) + memset (mosaicUsed, 0, Nmosaic * sizeof(char)); + + RegionHostInfo *host = ®ionHosts->hosts[i]; + + // find the mosaics associated with a given + for (j = 0; j < host->Nimage; j++) { + + int im = host->imseq[j]; + + if (im < 0) abort(); + if (im >= Nmosaic_for_images) abort(); + + // search for the mosaic that matches this image (skip unmatched images) + off_t mos = mosaic_for_images[im]; + if (mos < 0) continue; + + if (mosaicUsed[mos]) continue; + + mosaicUsed[mos] = TRUE; + addMosaic[Nadd] = mos; + Nadd ++; + + CHECK_REALLOCATE (addMosaic, off_t, NADD, Nadd, 100); + } + + REALLOCATE (host->image, Image, host->Nimage + Nadd); + + for (j = 0; j < Nadd; j++) { + off_t mos = addMosaic[j]; + off_t mos_im = mosaic[mos].myImage; + + host->image[host->Nimage + j] = image[mos_im]; + } + + host->Nimage += Nadd; + } + return TRUE; +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/Shutdown.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/Shutdown.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/Shutdown.c (revision 37067) @@ -23,5 +23,5 @@ SetProtect (TRUE); gfits_db_close (db); - fprintf (stderr, "ERROR: addstar halted\n"); + fprintf (stderr, "ERROR: relastro halted\n"); exit (1); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/StarMaps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/StarMaps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/StarMaps.c (revision 37067) @@ -59,7 +59,6 @@ off_t i, N, Nimages; int xbin, ybin; - struct timeval start, stop; - gettimeofday (&start, (void *) NULL); + INITTIME; // Images *images = getimages(&Nimages, NULL); return value ignored Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/UpdateObjectOffsets.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/UpdateObjectOffsets.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/UpdateObjectOffsets.c (revision 37067) @@ -126,41 +126,47 @@ table->hosts[i].hostID, CATDIR, table->hosts[i].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, STATMODE, MIN_ERROR); - char tmpline[1024]; - if (FIT_MODE == FIT_PM_ONLY) { snprintf (tmpline, 1024, "%s -pm", command); strcpy (command, tmpline); } - if (FIT_MODE == FIT_PAR_ONLY) { snprintf (tmpline, 1024, "%s -par", command); strcpy (command, tmpline); } - if (FIT_MODE == FIT_PM_AND_PAR) { snprintf (tmpline, 1024, "%s -pmpar", command); strcpy (command, tmpline); } - - if (VERBOSE) { snprintf (tmpline, 1024, "%s -v", command); strcpy (command, tmpline); } - if (VERBOSE2) { snprintf (tmpline, 1024, "%s -vv", command); strcpy (command, tmpline); } - if (RESET) { snprintf (tmpline, 1024, "%s -reset", command); strcpy (command, tmpline); } - if (UPDATE) { snprintf (tmpline, 1024, "%s -update", command); strcpy (command, tmpline); } - - if (RESET_BAD_IMAGES) { snprintf (tmpline, 1024, "%s -reset-bad-images", command); strcpy (command, tmpline); } - - if (ImagSelect) { snprintf (tmpline, 1024, "%s -instmag %f %f", command, ImagMin, ImagMax); strcpy (command, tmpline); } - if (MaxDensityUse) { snprintf (tmpline, 1024, "%s -max-density %f", command, MaxDensityValue); strcpy (command, tmpline); } + if (FIT_MODE == FIT_PM_ONLY) strextend (command, "-pm"); + if (FIT_MODE == FIT_PAR_ONLY) strextend (command, "-par"); + if (FIT_MODE == FIT_PM_AND_PAR) strextend (command, "-pmpar"); + + if (VERBOSE) strextend (command, "-v"); + if (VERBOSE2) strextend (command, "-vv"); + if (RESET) strextend (command, "-reset"); + if (UPDATE) strextend (command, "-update"); + + if (RESET_BAD_IMAGES) strextend (command, "-reset-bad-images"); + + if (ImagSelect) strextend (command, "-instmag %f %f", ImagMin, ImagMax); + if (MaxDensityUse) strextend (command, "-max-density %f", MaxDensityValue); - if (USE_BASIC_CHECK) { snprintf (tmpline, 1024, "%s -basic-image-search", command); strcpy (command, tmpline); } - if (FlagOutlier) { snprintf (tmpline, 1024, "%s -clip %d", command, CLIP_THRESH); strcpy (command, tmpline); } + if (USE_BASIC_CHECK) strextend (command, "-basic-image-search"); + if (FlagOutlier) strextend (command, "-clip %d", CLIP_THRESH); + if (ExcludeBogus) strextend (command, "-exclude-bogus %f", ExcludeBogusRadius); - if (USE_FIXED_PIXCOORDS) { snprintf (tmpline, 1024, "%s -D USE_FIXED_PIXCOORDS 1", command); strcpy (command, tmpline); } - - if (PHOTCODE_KEEP_LIST) { snprintf (tmpline, 1024, "%s +photcode %s", command, PHOTCODE_KEEP_LIST); strcpy (command, tmpline); } - if (PHOTCODE_SKIP_LIST) { snprintf (tmpline, 1024, "%s -photcode %s", command, PHOTCODE_SKIP_LIST); strcpy (command, tmpline); } - if (PhotFlagSelect) { snprintf (tmpline, 1024, "%s +photflags", command); strcpy (command, tmpline); } - if (PhotFlagBad) { snprintf (tmpline, 1024, "%s +photflagbad %d", command, PhotFlagBad); strcpy (command, tmpline); } - if (PhotFlagPoor) { snprintf (tmpline, 1024, "%s +photflagpoor %d", command, PhotFlagPoor); strcpy (command, tmpline); } + if (USE_FIXED_PIXCOORDS) strextend (command, "-D USE_FIXED_PIXCOORDS 1"); + + if (PHOTCODE_KEEP_LIST) strextend (command, "+photcode %s", PHOTCODE_KEEP_LIST); + if (PHOTCODE_SKIP_LIST) strextend (command, "-photcode %s", PHOTCODE_SKIP_LIST); + if (PhotFlagSelect) strextend (command, "+photflags"); + if (PhotFlagBad) strextend (command, "+photflagbad %d", PhotFlagBad); + if (PhotFlagPoor) strextend (command, "+photflagpoor %d", PhotFlagPoor); // XXX note that the above pass in the flag as decimal -- also note that args.c cannot handle 0xHEX values - if (MinBadQF > 0.0) { snprintf (tmpline, 1024, "%s -min-bad-psfqf %f", command, MinBadQF); strcpy (command, tmpline); } - if (MaxMeanOffset != 10.0) { snprintf (tmpline, 1024, "%s -max-mean-offset %f", command, MaxMeanOffset); strcpy (command, tmpline); } + if (DCR_BLUE_COLOR_POS && DCR_BLUE_COLOR_NEG) { + strextend (command, "-dcr-blue-color %s %s", DCR_BLUE_COLOR_POS, DCR_BLUE_COLOR_NEG); + } + if (DCR_RED_COLOR_POS && DCR_RED_COLOR_NEG) { + strextend (command, "-dcr-red-color %s %s", DCR_RED_COLOR_POS, DCR_RED_COLOR_NEG); + } + + if (MinBadQF > 0.0) strextend (command, "-min-bad-psfqf %f", MinBadQF); + if (MaxMeanOffset != 10.0) strextend (command, "-max-mean-offset %f", MaxMeanOffset); if (TimeSelect) { char *tstart = ohana_sec_to_date (TSTART); char *tstop = ohana_sec_to_date (TSTOP); - snprintf (tmpline, 1024, "%s -time %s %s", command, tstart, tstop); + strextend (command, "-time %s %s", tstart, tstop); free (tstart); free (tstop); - strcpy (command, tmpline); } fprintf (stderr, "command: %s\n", command); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/UpdateObjects.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/UpdateObjects.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/UpdateObjects.c (revision 37067) @@ -1,5 +1,5 @@ # include "relastro.h" -static off_t Nmax; +static off_t Nmax; static double *X, *dX; static double *Y, *dY; @@ -10,4 +10,6 @@ static double *T; static double *dT; +static double *C_blue; +static double *C_red; void initObjectData (Catalog *catalog, int Ncatalog) { @@ -36,4 +38,28 @@ ALLOCATE (pX, double, MAX (1, Nmax)); ALLOCATE (pY, double, MAX (1, Nmax)); + + ALLOCATE (C_blue, double, MAX (1, Nmax)); + ALLOCATE (C_red, double, MAX (1, Nmax)); +} + +void freeObjectData () { + + free (R); + free (D); + free (T); + free (X); + free (Y); + + free (dR); + free (dD); + free (dT); + free (dX); + free (dY); + + free (pX); + free (pY); + + free (C_blue); + free (C_red); } @@ -43,5 +69,5 @@ off_t j, k, m; - int i, N, Nsecfilt, mode, result, status, XVERB; + int i, N, NcBlue, NcRed, Nsecfilt, mode, result, status, XVERB; StatType statsR, statsD; Coords coords; @@ -57,4 +83,6 @@ memset (&fitPAR, 0, sizeof(fitPAR)); initObjectData (catalog, Ncatalog); + + int setRefColor = areImagesMatched(); /* project coordinates to a plane centered on the object with units of arcsec */ @@ -67,5 +95,5 @@ coords.pc1_2 = coords.pc2_1 = 0.0; coords.Npolyterms = 1; - strcpy (coords.ctype, "RA---SIN"); + strcpy (coords.ctype, "DEC--SIN"); XVERB = FALSE; @@ -94,8 +122,17 @@ fitPAR.chisq = NAN; + // if we fail to fit the astrometry for some reason, we need to set/reset these + catalog[i].average[j].flags |= ID_STAR_NO_ASTROM; + catalog[i].average[j].ChiSqAve = NAN; + catalog[i].average[j].ChiSqPM = NAN; + catalog[i].average[j].ChiSqPar = NAN; + catalog[i].average[j].Npos = 0; + if (catalog[i].average[j].Nmeasure == 0) { - continue; - } - + continue; + } + + NcBlue = 0; + NcRed = 0; N = 0; m = catalog[i].average[j].measureOffset; @@ -116,26 +153,42 @@ char *date = ohana_sec_to_date (measure[k].t); int dbFlagsBig = measureBig ? measureBig[k].dbFlags : 0; - fprintf (stderr, OFF_T_FMT" %f %f %s : 0x%08x : 0x%08x\n", k, measure[k].dR, measure[k].dD, date, measure[k].dbFlags, dbFlagsBig); + fprintf (stderr, OFF_T_FMT" %f %f %s : 0x%08x : 0x%08x\n", k, measure[k].R, measure[k].D, date, measure[k].dbFlags, dbFlagsBig); free (date); } + + // reset the bit to note that a detection was used (or not) + measure[k].dbFlags &= ~ID_MEAS_USED_OBJ; + if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_USED_OBJ; } // does the measurement pass the supplied filtering constraints? // MeasFilterTestTiny does not test psfQF + // exclude bad detections based on: photcodes, psfQF, time range, photflags & astromBadMask, mag_inst int keepMeasure = measureBig ? MeasFilterTest(&measureBig[k], FALSE) : MeasFilterTestTiny(&measure[k], FALSE); if (!keepMeasure) { - measure[k].dbFlags &= ~ID_MEAS_USED_OBJ; - if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_USED_OBJ; } continue; } + // mark (as POOR) any measurements which are deviant from the mean by > ExcludeBogusRadius + if (ExcludeBogus) { + double Ri = getMeanR (&measure[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]); + double Di = getMeanD (&measure[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]); + coords.crval1 = catalog[i].average[j].R; + coords.crval2 = catalog[i].average[j].D; + double Xi, Yi; + RD_to_XY (&Xi, &Yi, Ri, Di, &coords); + double radius = hypot(Xi, Yi); + if (radius > ExcludeBogusRadius) { + measure[k].dbFlags |= ID_MEAS_POOR_ASTROM; + if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_POOR_ASTROM; } + continue; + } + measure[k].dbFlags &= ~ID_MEAS_POOR_ASTROM; + if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_POOR_ASTROM; } + } + // outlier rejection - if (FlagOutlier && (measure[k].dbFlags & ID_MEAS_POOR_ASTROM)) { - measure[k].dbFlags &= ~ID_MEAS_USED_OBJ; - if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_USED_OBJ; } + if (FALSE && FlagOutlier && (measure[k].dbFlags & ID_MEAS_POOR_ASTROM)) { continue; } - - measure[k].dbFlags |= ID_MEAS_USED_OBJ; - if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_USED_OBJ; } R[N] = getMeanR (&measure[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]); @@ -152,14 +205,6 @@ // allow a given photcode or measurement to be // ignored if the error is NAN (for photcode, set astromErrSys to NaN) - if (isnan(dX[N])) { - measure[k].dbFlags &= ~ID_MEAS_USED_OBJ; - if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_USED_OBJ; } - continue; - } - if (isnan(dY[N])) { - measure[k].dbFlags &= ~ID_MEAS_USED_OBJ; - if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_USED_OBJ; } - continue; - } + if (isnan(dX[N])) continue; + if (isnan(dY[N])) continue; // add systematic error in quadrature, if desired @@ -183,12 +228,26 @@ dD[N] = dY[N] / 3600.0; + if (setRefColor) { + float colorBlue = getColorBlue (m+k, i); + if (!isnan(colorBlue)) { + C_blue[NcBlue] = colorBlue; + NcBlue++; + } + float colorRed = getColorRed (m+k, i); + if (!isnan(colorRed)) { + C_red[NcRed] = colorRed; + NcRed++; + } + } + + measure[k].dbFlags |= ID_MEAS_USED_OBJ; + if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_USED_OBJ; } + N++; - } + } // loop over measurements : catalog[i].average[j].Nmeasure // if we have too few good detections for the desired fit, or too limited a // baseline, use a fit with fewer parameters. XXX if we have too few measurements // for even the average position, consider including the lower-quality detections? - - catalog[i].average[j].flags &= ~ID_STAR_NO_ASTROM; // find Tmin & Tmax from the list of accepted measurements @@ -205,5 +264,5 @@ if (((mode == FIT_PM_ONLY) || (mode == FIT_PM_AND_PAR)) && (N <= PM_TOOFEW)) mode = FIT_AVERAGE; - if (FIT_TARGET == TARGET_HIGH_SPEED) { + if (RELASTRO_OP == OP_HIGH_SPEED) { Tmean = 0.5*(Tmax - Tmin); } else { @@ -213,10 +272,4 @@ // too few measurements for average position (require 2 values) if (N < SRC_MEAS_TOOFEW) { - // XXX need to define PHOTOM and ASTROM object flags - // XXX reset the average value fields? - catalog[i].average[j].flags |= ID_STAR_NO_ASTROM; - catalog[i].average[j].ChiSqAve = NAN; - catalog[i].average[j].ChiSqPM = NAN; - catalog[i].average[j].ChiSqPar = NAN; if (N < 2) continue; } @@ -250,9 +303,13 @@ catalog[i].average[j].flags |= ID_STAR_FIT_PM; Npm ++; + + // XXX a hard-wired hack... + if ((fabs(fitPM.uR) > 2.0) || (fabs(fitPM.uD) > 2.0)) { + mode = FIT_AVERAGE; + catalog[i].average[j].flags |= ID_STAR_BAD_PM; + } } if (mode == FIT_PM_AND_PAR) { - // fprintf (stderr, "parallax fitting is still untested (%s, %d)\n", __FILE__, __LINE__); - float pXmin = +2.0; float pXmax = -2.0; @@ -278,4 +335,10 @@ catalog[i].average[j].flags |= ID_STAR_FIT_PAR; Npar ++; + + // XXX a hard-wired hack... + if ((fabs(fitPAR.uR) > 2.0) || (fabs(fitPAR.uD) > 2.0)) { + mode = FIT_AVERAGE; + catalog[i].average[j].flags |= ID_STAR_BAD_PM; + } } else { // need to set mode = FIT_PM_ONLY if we do not fit for parallax @@ -303,4 +366,14 @@ catalog[i].average[j].flags |= ID_STAR_FIT_AVE; Nave ++; + } + + if (setRefColor) { + float colorMedian; + dsort (C_blue, NcBlue); + colorMedian = (NcBlue > 0) ? C_blue[(int)(0.5*NcBlue)] : NAN; + catalog[i].average[j].refColorBlue = colorMedian; + dsort (C_red, NcRed); + colorMedian = (NcRed > 0) ? C_red[(int)(0.5*NcRed)] : NAN; + catalog[i].average[j].refColorRed = colorMedian; } @@ -393,4 +466,8 @@ catalog[i].average[j].Trange = (Trange * 86400 * 365.25); catalog[i].average[j].Npos = fit.Nfit; + + // unset the NO_ASTROM bit (not(NO_ASTROM) == HAVE_ASTROM) + catalog[i].average[j].flags &= ~ID_STAR_NO_ASTROM; + if (XVERB) fprintf (stderr, "%f %f -> %f %f (%f,%f) pm=(%f %f) chisq=(%f, %f, %f)\n", catalog[i].average[j].R, @@ -412,4 +489,6 @@ } + freeObjectData (); + if (VERBOSE) fprintf (stderr, "fitted "OFF_T_FMT" objects ("OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par), skipped "OFF_T_FMT", "OFF_T_FMT" have too large an offset\n", (NaveSum + NpmSum + NparSum), NaveSum, NpmSum, NparSum, NskipSum, NoffSum); return (TRUE); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/args.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/args.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/args.c (revision 37067) @@ -13,4 +13,5 @@ /* possible operations */ FIT_TARGET = TARGET_NONE; + RELASTRO_OP = OP_NONE; FIT_MODE = FIT_AVERAGE; @@ -21,5 +22,5 @@ if (N > argc - 6) usage_merge_source(); if (strcmp(argv[N+3], "into")) usage_merge_source(); - FIT_TARGET = TARGET_MERGE_SOURCE; + RELASTRO_OP = OP_MERGE_SOURCE; remove_argument (N, &argc, argv); OBJ_ID_SRC = strtol(argv[N], &endptr, 0); @@ -43,10 +44,51 @@ if ((N = get_argument (argc, argv, "-update-objects"))) { remove_argument (N, &argc, argv); - FIT_TARGET = TARGET_UPDATE_OBJECTS; + RELASTRO_OP = OP_UPDATE_OBJECTS; } if ((N = get_argument (argc, argv, "-update-offsets"))) { remove_argument (N, &argc, argv); - FIT_TARGET = TARGET_UPDATE_OFFSETS; + RELASTRO_OP = OP_UPDATE_OFFSETS; + } + + // elements needed for parallel regions / parallel images + REGION_FILE = NULL; + if ((N = get_argument (argc, argv, "-region-hosts"))) { + remove_argument (N, &argc, argv); + REGION_FILE = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + + REGION_HOST_ID = 0; + if ((N = get_argument (argc, argv, "-region-hostID"))) { + remove_argument (N, &argc, argv); + REGION_HOST_ID = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + + IMAGE_TABLE = NULL; + if ((N = get_argument (argc, argv, "-parallel-images"))) { + remove_argument (N, &argc, argv); + RELASTRO_OP = OP_PARALLEL_IMAGES; + if (N >= argc) usage(); + IMAGE_TABLE = strcreate (argv[N]); + remove_argument (N, &argc, argv); + if (!REGION_FILE) usage(); + } + + if ((N = get_argument (argc, argv, "-images"))) { + remove_argument (N, &argc, argv); + RELASTRO_OP = OP_IMAGES; + } + + PARALLEL_REGIONS_MANUAL = FALSE; + if ((N = get_argument (argc, argv, "-parallel-regions"))) { + remove_argument (N, &argc, argv); + RELASTRO_OP = OP_PARALLEL_REGIONS; + if (!REGION_FILE) usage(); + if ((N = get_argument (argc, argv, "-parallel-regions-manual"))) { + remove_argument (N, &argc, argv); + PARALLEL_REGIONS_MANUAL = TRUE; + } } @@ -90,5 +132,5 @@ // XXX include a parallax / no-parallax option if (N >= argc - 4) usage(); - FIT_TARGET = TARGET_HIGH_SPEED; + RELASTRO_OP = OP_HIGH_SPEED; remove_argument (N, &argc, argv); PHOTCODE_A_LIST = strcreate(argv[N]); @@ -104,5 +146,5 @@ if ((N = get_argument (argc, argv, "-hpm"))) { if (N >= argc - 2) usage(); - FIT_TARGET = TARGET_HPM; + RELASTRO_OP = OP_HPM; remove_argument (N, &argc, argv); RADIUS = atof(argv[N]); @@ -116,5 +158,5 @@ remove_argument (N, &argc, argv); PARALLEL_OUTPUT = TRUE; - if ((FIT_TARGET != TARGET_HIGH_SPEED) && (FIT_TARGET != TARGET_HPM)) { + if ((RELASTRO_OP != OP_HIGH_SPEED) && (RELASTRO_OP != OP_HPM)) { fprintf (stderr, "-parallel-output only valid for -high-speed or -hpm modes\n"); exit (1); @@ -137,4 +179,5 @@ FlagOutlier = FALSE; if ((N = get_argument (argc, argv, "-clip"))) { + fprintf (stderr, "-clip is currently disabled\n"); remove_argument (N, &argc, argv); CLIP_THRESH = atof (argv[N]); @@ -143,5 +186,16 @@ } - if (FIT_TARGET == TARGET_NONE) usage(); + ExcludeBogus = FALSE; + ExcludeBogusRadius = 0.0; + if ((N = get_argument (argc, argv, "-exclude-bogus"))) { + remove_argument (N, &argc, argv); + ExcludeBogusRadius = atof (argv[N]); + remove_argument (N, &argc, argv); + ExcludeBogus = TRUE; + } + + if (RELASTRO_OP == OP_NONE) usage(); + + if (((RELASTRO_OP == OP_IMAGES) || (RELASTRO_OP == OP_PARALLEL_REGIONS) || (RELASTRO_OP == OP_PARALLEL_IMAGES)) && (FIT_TARGET == TARGET_NONE)) usage(); /* specify portion of the sky : allow default of all sky? */ @@ -240,4 +294,33 @@ } + // eg g - r or r - i + DCR_BLUE_COLOR_POS = NULL; + DCR_BLUE_COLOR_NEG = NULL; + if ((N = get_argument (argc, argv, "-dcr-blue-color"))) { + remove_argument (N, &argc, argv); + DCR_BLUE_COLOR_POS = strcreate(argv[N]); + remove_argument (N, &argc, argv); + DCR_BLUE_COLOR_NEG = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + + // eg, z - y or i - z + DCR_RED_COLOR_POS = NULL; + DCR_RED_COLOR_NEG = NULL; + if ((N = get_argument (argc, argv, "-dcr-red-color"))) { + remove_argument (N, &argc, argv); + DCR_RED_COLOR_POS = strcreate(argv[N]); + remove_argument (N, &argc, argv); + DCR_RED_COLOR_NEG = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + + PHOTCODE_RESET_LIST = NULL; + if ((N = get_argument (argc, argv, "-reset-to-photcode"))) { + remove_argument (N, &argc, argv); + PHOTCODE_RESET_LIST = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + PHOTCODE_KEEP_LIST = NULL; if ((N = get_argument (argc, argv, "+photcode"))) { @@ -247,19 +330,21 @@ } - PHOTCODE_SKIP_LIST = strcreate("SCOS.103a.E,SCOS.4414.OG590,SCOS.4415.OG590,SCOS.IIIaF.OG590,SCOS.IIIaF.RG610,SCOS.IIIaF.RG630,SCOS.IIIaJ.GG385,SCOS.IIIaJ.GG395,SCOS.IVN.RG715,SCOS.IVN.RG9"); + char *SuperCOSMOS_SKIP = strcreate("SCOS.103a.E,SCOS.4414.OG590,SCOS.4415.OG590,SCOS.IIIaF.OG590,SCOS.IIIaF.RG610,SCOS.IIIaF.RG630,SCOS.IIIaJ.GG385,SCOS.IIIaJ.GG395,SCOS.IVN.RG715,SCOS.IVN.RG9"); + + PHOTCODE_SKIP_LIST = NULL; if ((N = get_argument (argc, argv, "-photcode"))) { remove_argument (N, &argc, argv); - char *tmp1 = strcreate(argv[N]); - - int Ntotal = strlen(tmp1) + strlen(PHOTCODE_SKIP_LIST) + 5; - - char *tmp2 = NULL; - ALLOCATE (tmp2, char, Ntotal); - snprintf (tmp2, Ntotal, "%s,%s", PHOTCODE_SKIP_LIST, tmp1); - - free (tmp1); - free (PHOTCODE_SKIP_LIST); - - PHOTCODE_SKIP_LIST = tmp2; + char *RawSkip = strcreate(argv[N]); + + char *GotSkip = strstr (RawSkip, SuperCOSMOS_SKIP); + if (!GotSkip) { + int Ntotal = strlen(RawSkip) + strlen(SuperCOSMOS_SKIP) + 5; + ALLOCATE (PHOTCODE_SKIP_LIST, char, Ntotal); + snprintf (PHOTCODE_SKIP_LIST, Ntotal, "%s,%s", SuperCOSMOS_SKIP, RawSkip); + free (RawSkip); + free (SuperCOSMOS_SKIP); + } else { + PHOTCODE_SKIP_LIST = RawSkip; + } remove_argument (N, &argc, argv); } @@ -427,5 +512,5 @@ /* possible operations */ - FIT_TARGET = TARGET_NONE; + RELASTRO_OP = TARGET_NONE; FIT_MODE = FIT_AVERAGE; @@ -437,4 +522,9 @@ BCATALOG = NULL; + REGION_FILE = NULL; + REGION_HOST_ID = 0; + IMAGE_TABLE = NULL; + PARALLEL_REGIONS_MANUAL = FALSE; + HOST_ID = 0; if ((N = get_argument (argc, argv, "-hostID"))) { @@ -457,15 +547,15 @@ BCATALOG = strcreate(argv[N]); remove_argument (N, &argc, argv); - FIT_TARGET = TARGET_LOAD_OBJECTS; + RELASTRO_OP = OP_LOAD_OBJECTS; } if ((N = get_argument (argc, argv, "-update-objects"))) { remove_argument (N, &argc, argv); - FIT_TARGET = TARGET_UPDATE_OBJECTS; + RELASTRO_OP = OP_UPDATE_OBJECTS; } if ((N = get_argument (argc, argv, "-update-offsets"))) { remove_argument (N, &argc, argv); - FIT_TARGET = TARGET_UPDATE_OFFSETS; + RELASTRO_OP = OP_UPDATE_OFFSETS; } @@ -487,5 +577,5 @@ // XXX include a parallax / no-parallax option if (N >= argc - 5) usage_client(); - FIT_TARGET = TARGET_HIGH_SPEED; + RELASTRO_OP = OP_HIGH_SPEED; remove_argument (N, &argc, argv); PHOTCODE_A_LIST = strcreate(argv[N]); @@ -501,5 +591,5 @@ if ((N = get_argument (argc, argv, "-hpm"))) { if (N >= argc - 3) usage(); - FIT_TARGET = TARGET_HPM; + RELASTRO_OP = OP_HPM; remove_argument (N, &argc, argv); RADIUS = atof(argv[N]); @@ -533,4 +623,5 @@ FlagOutlier = FALSE; if ((N = get_argument (argc, argv, "-clip"))) { + fprintf (stderr, "-clip is currently disabled\n"); remove_argument (N, &argc, argv); CLIP_THRESH = atof (argv[N]); @@ -539,5 +630,14 @@ } - if (FIT_TARGET == TARGET_NONE) usage_client(); + ExcludeBogus = FALSE; + ExcludeBogusRadius = 0.0; + if ((N = get_argument (argc, argv, "-exclude-bogus"))) { + remove_argument (N, &argc, argv); + ExcludeBogusRadius = atof (argv[N]); + remove_argument (N, &argc, argv); + ExcludeBogus = TRUE; + } + + if (RELASTRO_OP == OP_NONE) usage_client(); /* specify portion of the sky : allow default of all sky? */ @@ -608,4 +708,30 @@ } + DCR_BLUE_COLOR_POS = NULL; + DCR_BLUE_COLOR_NEG = NULL; + if ((N = get_argument (argc, argv, "-dcr-blue-color"))) { + remove_argument (N, &argc, argv); + DCR_BLUE_COLOR_POS = strcreate(argv[N]); + remove_argument (N, &argc, argv); + DCR_BLUE_COLOR_NEG = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + DCR_RED_COLOR_POS = NULL; + DCR_RED_COLOR_NEG = NULL; + if ((N = get_argument (argc, argv, "-dcr-red-color"))) { + remove_argument (N, &argc, argv); + DCR_RED_COLOR_POS = strcreate(argv[N]); + remove_argument (N, &argc, argv); + DCR_RED_COLOR_NEG = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + + PHOTCODE_RESET_LIST = NULL; + if ((N = get_argument (argc, argv, "-reset-to-photcode"))) { + remove_argument (N, &argc, argv); + PHOTCODE_RESET_LIST = strcreate(argv[N]); + remove_argument (N, &argc, argv); + } + PHOTCODE_KEEP_LIST = NULL; if ((N = get_argument (argc, argv, "+photcode"))) { @@ -718,7 +844,13 @@ void usage () { - fprintf (stderr, "ERROR: USAGE: relastro -update-simple [options]\n"); - fprintf (stderr, " OR: relastro -update-chips [options]\n"); - fprintf (stderr, " OR: relastro -update-mosaic [options]\n"); + fprintf (stderr, "ERROR: USAGE: relastro -images -update-simple [options]\n"); + fprintf (stderr, " OR: relastro -images -update-chips [options]\n"); + fprintf (stderr, " OR: relastro -images -update-mosaic [options]\n"); + fprintf (stderr, " OR: relastro -parallel-regions -update-simple [options]\n"); + fprintf (stderr, " OR: relastro -parallel-regions -update-chips [options]\n"); + fprintf (stderr, " OR: relastro -parallel-regions -update-mosaic [options]\n"); + fprintf (stderr, " OR: relastro -parallel-images -update-simple [options]\n"); + fprintf (stderr, " OR: relastro -parallel-images -update-chips [options]\n"); + fprintf (stderr, " OR: relastro -parallel-images -update-mosaic [options]\n"); fprintf (stderr, " OR: relastro -update-objects [options]\n"); fprintf (stderr, " OR: relastro -high-speed [options]\n"); @@ -806,2 +938,15 @@ exit (2); } + +int strextend (char *input, char *format,...) { + + char tmpextra[1024], tmpline[1024]; + va_list argp; + + va_start (argp, format); + vsnprintf (tmpextra, 1024, format, argp); + snprintf (tmpline, 1024, "%s %s", input, tmpextra); + strcpy (input, tmpline); + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/assign_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/assign_images.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/assign_images.c (revision 37067) @@ -0,0 +1,280 @@ +# include "relastro.h" + +// This function generates a subset of the images based on selections. Input db has already +// been loaded with the raw fits table data +int assign_images (FITS_DB *db, RegionHostTable *regionHosts) { + + off_t Nimage; + + INITTIME; + + // convert database table to internal structure (binary to Image) + // 'image' points to the same memory as db->ftable->buffer + Image *image = gfits_table_get_Image (&db[0].ftable, &Nimage, &db[0].swapped); + if (!image) { + fprintf (stderr, "ERROR: failed to read images\n"); + exit (2); + } + MARKTIME("convert image table to internal structure: %f sec\n", dtime); + + // *** NOTE : for the moment, regions must be in the range 0 - 360, -90 - +90 + + // generate the chip match here so we can define the mosaic centers (if needed) + BuildChipMatch (image, Nimage); + MARKTIME("build chip match for %d images: %f sec\n", (int) Nimage, dtime); + + initMosaics (image, Nimage); + MARKTIME("set mosaic coordinates and Mcal values: %f sec\n", dtime); + + // register the image array with ImageOps.c for later getimageByID calls + initImages (image, NULL, Nimage); + + if (VERBOSE) fprintf (stderr, "finding images\n"); + + // for each regionHost, select images which are contained by the region + // even faster would be to use a tree to get to the real regions... + select_images_hostregion (regionHosts, image, Nimage); + + // supply the mosaics to the image table for the regionHosts : we already have the image + // <-> mosaic relationship, we just need to select these mosaics (once per regionHost) + select_mosaics_hostregion (regionHosts, image, Nimage); + + return TRUE; +} + +# define D_NIMAGE 1000 + +// assign images to the region hosts; at the end, each host will have its list of images +int select_images_hostregion (RegionHostTable *regionHosts, Image *image, off_t Nimage) { + + off_t i, j; + + // INITTIME; + + for (i = 0; i < regionHosts->Nhosts; i++) { + regionHosts->hosts[i].Nimage = 0; + regionHosts->hosts[i].NIMAGE = D_NIMAGE; + ALLOCATE (regionHosts->hosts[i].image, Image, regionHosts->hosts[i].NIMAGE); + ALLOCATE (regionHosts->hosts[i].imseq, off_t, regionHosts->hosts[i].NIMAGE); + } + + for (j = 0; j < Nimage; j++) { + + /* select images by photcode, or equiv photcode, if specified */ + if (NphotcodesKeep > 0) { + int found = FALSE; + // XXX this bit of code excludes DIS mosaics and should be fixed + for (i = 0; (i < NphotcodesKeep) && !found; i++) { + if (photcodesKeep[i][0].code == image[j].photcode) found = TRUE; + if (photcodesKeep[i][0].code == GetPhotcodeEquivCodebyCode(image[j].photcode)) found = TRUE; + } + if (!found) continue; + } + if (NphotcodesSkip > 0) { + int found = FALSE; + for (i = 0; (i < NphotcodesSkip) && !found; i++) { + if (photcodesSkip[i][0].code == image[j].photcode) found = TRUE; + if (photcodesSkip[i][0].code == GetPhotcodeEquivCodebyCode(image[j].photcode)) found = TRUE; + } + if (found) continue; + } + + /* exclude images by time */ + if (TimeSelect) { + if (image[j].tzero < TSTART) continue; + if (image[j].tzero > TSTOP) continue; + } + + // do not include DIS (PHU-level mosaics) in the output list + if (!strcmp(&image[j].coords.ctype[4], "-DIS")) continue; + + // match the image to its corresponding ASTROMETRIC mosaic (not the same as the Mosaic above) + if (!FindMosaicForImage (image, Nimage, j)) { + if (VERBOSE2) fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i); + continue; + } + + // Exclude images with crazy astrometry + // XXX NOTE : this is gpc1-specific + { + double dP1 = hypot(image[j].coords.pc1_1, image[j].coords.pc1_2); + double dP2 = hypot(image[j].coords.pc2_1, image[j].coords.pc2_2); + if (fabs(dP1 - 1.0) > 0.02) continue; + if (fabs(dP2 - 1.0) > 0.02) continue; + + double X00, Y00, X10, Y10, X01, Y01; + XY_to_LM (&X00, &Y00, 0.0, 0.0, &image[j].coords); + XY_to_LM (&X10, &Y10, image[j].NX, 0.0, &image[j].coords); + XY_to_LM (&X01, &Y01, 0.0, image[j].NY, &image[j].coords); + double dS0 = hypot ((X00 - X10), (Y00 - Y10)); + double dS1 = hypot ((X00 - X01), (Y00 - Y01)); + if (dS0 > 6000) continue; + if (dS1 > 6500) continue; + } + + // use a reference coordinate for each image to assign to hosts + // define image center - note the DIS images (mosaic phu) are special + double Xc, Yc; + double Rc, Dc; + Xc = 0.5*image[j].NX; + Yc = 0.5*image[j].NY; + + XY_to_RD (&Rc, &Dc, Xc, Yc, &image[j].coords); + Rc = ohana_normalize_angle_to_midpoint (Rc, 180.0); + image[j].RAo = Rc; + image[j].DECo = Dc; + + i = find_host_for_coords (regionHosts, Rc, Dc); + + if (i == -1) continue; + + RegionHostInfo *host = ®ionHosts->hosts[i]; + + // image bounds are defined for a range centered on the image center thus, an image + // with center 0.5 will have chips bounds ranging from ~ -1.5 to +2.5 or so, while an + // image with center 359.5 will have chips bounds ranging from ~ 357.5 to 361.5 or so + double Rmin, Rmax, Dmin, Dmax; + calculate_image_bounds (&image[j], &Rmin, &Rmax, &Dmin, &Dmax, Rc); + + host->RminCat = MIN(Rmin, host->RminCat); + host->RmaxCat = MAX(Rmax, host->RmaxCat); + host->DminCat = MIN(Dmin, host->DminCat); + host->DmaxCat = MAX(Dmax, host->DmaxCat); + + // regionHosts needs to have the full outer boundary + // (so reload_catalogs covers the correct region) + regionHosts->Rmin = MIN(Rmin, regionHosts->Rmin); + regionHosts->Rmax = MAX(Rmax, regionHosts->Rmax); + regionHosts->Dmin = MIN(Dmin, regionHosts->Dmin); + regionHosts->Dmax = MAX(Dmax, regionHosts->Dmax); + + // this is a bit memory expensive : I am making a complete copy of the image table here + off_t Nsubset = regionHosts->hosts[i].Nimage; + regionHosts->hosts[i].image[Nsubset] = image[j]; + regionHosts->hosts[i].imseq[Nsubset] = j; + + regionHosts->hosts[i].Nimage ++; + if (regionHosts->hosts[i].Nimage == regionHosts->hosts[i].NIMAGE) { + regionHosts->hosts[i].NIMAGE += D_NIMAGE; + REALLOCATE (regionHosts->hosts[i].image, Image, regionHosts->hosts[i].NIMAGE); + REALLOCATE (regionHosts->hosts[i].imseq, off_t, regionHosts->hosts[i].NIMAGE); + } + } + + return TRUE; +} + +double Xf[] = {0.0, 1.0, 0.0, 1.0}; +double Yf[] = {0.0, 0.0, 1.0, 1.0}; + +int calculate_image_bounds (Image *image, double *rmin, double *rmax, double *dmin, double *dmax, double Rmid) { + + int n; + + double Rmin = 360.0; + double Rmax = 0.0; + double Dmin = +90.0; + double Dmax = -90.0; + + // define image corners + for (n = 0; n < 4; n++) { + double Xc, Yc, Rc, Dc; + Xc = Xf[n]*image->NX; + Yc = Yf[n]*image->NY; + XY_to_RD (&Rc, &Dc, Xc, Yc, &image->coords); + Rc = ohana_normalize_angle_to_midpoint (Rc, Rmid); + + Rmin = MIN (Rmin, Rc); + Rmax = MAX (Rmax, Rc); + Dmin = MIN (Dmin, Dc); + Dmax = MAX (Dmax, Dc); + } + + *rmin = Rmin; + *rmax = Rmax; + *dmin = Dmin; + *dmax = Dmax; + + return TRUE; +} + +int calculate_host_image_bounds (RegionHostTable *regionHosts) { + + int i, n; + off_t j; + + for (i = 0; i < regionHosts->Nhosts; i++) { + + RegionHostInfo *host = ®ionHosts->hosts[i]; + + // XXX clear the chip match? + + BuildChipMatch (host->image, host->Nimage); + + double Rmin = 360.0; + double Rmax = 0.0; + double Dmin = +90.0; + double Dmax = -90.0; + + for (j = 0; j < host->Nimage; j++) { + + Image *image = &host->image[j]; + + if (!FindMosaicForImage (host->image, host->Nimage, j)) { + fprintf (stderr, "missing astrometry? programming error?\n"); + abort (); + } + + // define image corners + for (n = 0; n < 4; n++) { + double Xc, Yc, Rc, Dc; + Xc = Xf[n]*image->NX; + Yc = Yf[n]*image->NY; + XY_to_RD (&Rc, &Dc, Xc, Yc, &image->coords); + Rc = ohana_normalize_angle_to_midpoint (Rc, 180.0); + + Rmin = MIN (Rmin, Rc); + Dmin = MIN (Dmin, Rc); + + Rmax = MAX (Rmax, Rc); + Dmax = MAX (Dmax, Rc); + } + + } + + host->RminCat = Rmin; + host->DminCat = Dmin; + host->RmaxCat = Rmax; + host->DmaxCat = Dmax; + + // regionHosts needs to have the full outer boundary + // (so reload_catalogs covers the correct region) + regionHosts->Rmin = MIN(Rmin, regionHosts->Rmin); + regionHosts->Rmax = MAX(Rmax, regionHosts->Rmax); + regionHosts->Dmin = MIN(Dmin, regionHosts->Dmin); + regionHosts->Dmax = MAX(Dmax, regionHosts->Dmax); + } + return TRUE; +} + + +// XXX add a search tree to speed this up? +int find_host_for_coords (RegionHostTable *regionHosts, double Rc, double Dc) { + + int i; + + if (isnan(Rc)) return -1; + if (isnan(Dc)) return -1; + + for (i = 0; i < regionHosts->Nhosts; i++) { + + RegionHostInfo *host = ®ionHosts->hosts[i]; + if (Rc < host->Rmin) continue; + if (Rc >= host->Rmax) continue; + if (Dc < host->Dmin) continue; + if (Dc >= host->Dmax) continue; + + return i; + } + return -1; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/bcatalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/bcatalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/bcatalog.c (revision 37067) @@ -1,8 +1,21 @@ # include "relastro.h" +static int Nkeep1 = 0; +static int Nkeep2 = 0; static int Nskip1 = 0; static int Nskip2 = 0; -static unsigned int Tref = 1323353985; -static short Cref = 10355; + +FILE *fbogus = NULL; +static int NskipBogus = 0; + +// test image: 2013/06/15,13:25:51, GPC1.r.XY50 +static int CHECK_TEST_IMAGE = FALSE; +// static unsigned int Tref = 1378812312; +// static short Cref = 10001; + +static unsigned int Tref = 1379570672; +static short Cref = 10341; + +int LimitDensityCatalog_ByNmeasureGrid (Catalog *subcatalog, Catalog *oldcatalog); int bcatalog (Catalog *subcatalog, Catalog *catalog) { @@ -11,4 +24,16 @@ off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nm; int Nsecfilt; + Coords coords; + + /* for outlier rejection, project coordinates to a plane centered on the object with units of arcsec */ + coords.crval1 = 0; + coords.crval2 = 0; + coords.crpix1 = 0; + coords.crpix2 = 0; + coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0; + coords.pc1_1 = coords.pc2_2 = 1.0; + coords.pc1_2 = coords.pc2_1 = 0.0; + coords.Npolyterms = 1; + strcpy (coords.ctype, "DEC--SIN"); // XXX in the future, use catalog[0].Nsecfilt only? allow catalogs to have variable Nsecfilt? @@ -34,4 +59,13 @@ ID_STAR_NO_ASTROM ; + if (VERBOSE2 && ExcludeBogus && (fbogus == NULL)) { + char name[1024]; + snprintf (name, 1024, "%s/bogus.%02d.dat", CATDIR, HOST_ID); + fbogus = fopen (name, "w"); + if (!fbogus) { + fprintf (stderr, "trouble opening bogus detection dump : %s\n", name); + } + } + /* exclude stars not in range or with too few measurements */ for (i = 0; i < catalog[0].Naverage; i++) { @@ -60,12 +94,16 @@ if (!MeasFilterTest(&catalog[0].measure[offset], TRUE)) { catalog[0].measure[offset].dbFlags &= ~ID_MEAS_USED_CHIP; - if (FALSE && (abs(catalog[0].measure[offset].t - Tref) < 10) && (catalog[0].measure[offset].photcode == Cref)) { + if (CHECK_TEST_IMAGE && (abs(catalog[0].measure[offset].t - Tref) < 10) && (catalog[0].measure[offset].photcode == Cref)) { Nskip1 ++; } continue; } - - // filter out outliers - if (FlagOutlier && (catalog[0].measure[offset].dbFlags & ID_MEAS_POOR_ASTROM)) { + if (CHECK_TEST_IMAGE && (abs(catalog[0].measure[offset].t - Tref) < 10) && (catalog[0].measure[offset].photcode == Cref)) { + Nkeep1 ++; + } + + // filter out outliers - these are detections inconsistent with the offset distribution + // XXX disable this for now + if (FALSE && FlagOutlier && (catalog[0].measure[offset].dbFlags & ID_MEAS_POOR_ASTROM)) { catalog[0].measure[offset].dbFlags &= ~ID_MEAS_USED_CHIP; if (FALSE && (abs(catalog[0].measure[offset].t - Tref) < 10) && (catalog[0].measure[offset].photcode == Cref)) { @@ -76,4 +114,25 @@ catalog[0].measure[offset].dbFlags |= ID_MEAS_USED_CHIP; + // exclude bogus + if (ExcludeBogus) { + double Ri = getMeanR_Big (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]); + double Di = getMeanD_Big (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]); + coords.crval1 = catalog[0].average[i].R; + coords.crval2 = catalog[0].average[i].D; + double Xi, Yi; + RD_to_XY (&Xi, &Yi, Ri, Di, &coords); + double radius = hypot(Xi, Yi); + if (radius > ExcludeBogusRadius) { + NskipBogus ++; + if (VERBOSE2) { + FILE *foutput = fbogus ? fbogus : stderr; + char *date = ohana_sec_to_date(catalog[0].measure[offset].t); + fprintf (foutput, "exclude bogus: %10.6f %10.6f : %10.6f %10.6f : %6.2f %6.2f : %6.2f : %5d %s\n", catalog[0].average[i].R, catalog[0].average[i].D, Ri, Di, Xi, Yi, radius, catalog[0].measure[offset].photcode, date); + free (date); + } + continue; + } + } + // re-assess on each run of relastro if a measurement should be used @@ -87,4 +146,8 @@ // but before the final average properties are calculated, these measurements may be // allowed. + + if (CHECK_TEST_IMAGE && (abs(catalog[0].measure[offset].t - Tref) < 10) && (catalog[0].measure[offset].photcode == Cref)) { + Nkeep2 ++; + } CopyMeasureToTiny (&subcatalog[0].measureT[Nmeasure], &catalog[0].measure[offset]); @@ -125,5 +188,5 @@ // limit the total number of stars in the catalog if (MaxDensityUse) { - LimitDensityCatalog_ByNmeasure (subcatalog, catalog); + LimitDensityCatalog_ByNmeasureGrid (subcatalog, catalog); } else { if (VERBOSE2) { @@ -134,9 +197,18 @@ } } + if (CHECK_TEST_IMAGE && (Nkeep1 + Nkeep2 + Nskip1 + Nskip2 > 0)) { + fprintf (stderr, "kept %d %d, skipped %d %d\n", Nkeep1, Nkeep2, Nskip1, Nskip2); + } + return (TRUE); } void bcatalog_show_skips () { - fprintf (stderr, "Nskip: %d, %d\n", Nskip1, Nskip2); + if (ExcludeBogus) { + if (fbogus) fclose (fbogus); + fprintf (stderr, "NskipBogus: %d\n", NskipBogus); + // fprintf (stderr, "Nskip: %d, %d\n", Nskip1, Nskip2); + // fprintf (stderr, "Nkeep: %d, %d\n", Nkeep1, Nkeep2); + } } @@ -155,4 +227,270 @@ # undef COMPARE +} + +/* generate a grid in a locally-projected coordinate system, try to select average entries + from each grid cell in decending Nmeasure order. + */ +int LimitDensityCatalog_ByNmeasureGrid (Catalog *subcatalog, Catalog *oldcatalog) { + + off_t i, j; + int ix, iy; + + Catalog tmpcatalog; + + double Rmin, Rmax, Dmin, Dmax; + + int Nsecfilt = GetPhotcodeNsecfilt (); + + gfits_scan (&oldcatalog[0].header, "RA0", "%lf", 1, &Rmin); + gfits_scan (&oldcatalog[0].header, "DEC0", "%lf", 1, &Dmin); + gfits_scan (&oldcatalog[0].header, "RA1", "%lf", 1, &Rmax); + gfits_scan (&oldcatalog[0].header, "DEC1", "%lf", 1, &Dmax); + + if (VERBOSE2) fprintf (stderr, "extracting from catalog covering region %f,%f to %f,%f\n", Rmin, Dmin, Rmax, Dmax); + + float AREA = fabs(Dmax - Dmin) * fabs(Rmax - Rmin) * cos (0.5*RAD_DEG*(Dmax + Dmin)); + assert (AREA > 0); + + off_t Nmax = MaxDensityValue * AREA; + if (subcatalog[0].Naverage <= Nmax) { + if (VERBOSE) { + fprintf (stderr, "subcatalog has less than the max density\n"); + } + return (TRUE); + } + + off_t Naverage = subcatalog[0].Naverage; + + // generate a grid in locally projected space + double Rc = 0.5*(Rmin + Rmax); + double Dc = 0.5*(Dmin + Dmax); + + /* project coordinates to a plane centered on the object with units of arcsec */ + Coords coords; + coords.crval1 = Rc; + coords.crval2 = Dc; + coords.crpix1 = 0; + coords.crpix2 = 0; + coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0; + coords.pc1_1 = coords.pc2_2 = 1.0; + coords.pc1_2 = coords.pc2_1 = 0.0; + coords.Npolyterms = 1; + strcpy (coords.ctype, "DEC--SIN"); + + // convert all average R,D values to X,Y: + double *X, *Y; + ALLOCATE (X, double, Naverage); + ALLOCATE (Y, double, Naverage); + float Xmin = +10000.0, Ymin = +10000.0; + float Xmax = -10000.0, Ymax = -10000.0; + for (i = 0; i < Naverage; i++) { + X[i] = NAN; + Y[i] = NAN; + // skip any stars which are outside of nominal catalog range + if (subcatalog[0].average[i].R < Rmin) continue; + if (subcatalog[0].average[i].R > Rmax) continue; + if (subcatalog[0].average[i].D < Dmin) continue; + if (subcatalog[0].average[i].D > Dmax) continue; + RD_to_XY (&X[i], &Y[i], subcatalog[0].average[i].R, subcatalog[0].average[i].D, &coords); + Xmin = MIN (Xmin, X[i]); + Xmax = MAX (Xmax, X[i]); + Ymin = MIN (Ymin, Y[i]); + Ymax = MAX (Ymax, Y[i]); + } + + // how many grid cells? what is the grid spacing? + float dX = Xmax - Xmin; + float dY = Ymax - Ymin; + + // *** XXX for the moment, I'm using a hard-wired cell size (200 arcsec ~ 3.3 arcmin) + int NX = (int)(dX / 200) + 1; + int NY = (int)(dY / 200) + 1; + // fprintf (stderr, "Density Grid: %d x %d\n", NX, NY); + // XXX check that NX,NY are sensible (5 degrees / 200 arcsec seems like the absolute max) + if (NX > 1000) { + fprintf (stderr, "serious problem with %s: NX = %d\n", subcatalog[0].filename, NX); + exit (3); + } + if (NY > 1000) { + fprintf (stderr, "serious problem with %s: NY = %d\n", subcatalog[0].filename, NY); + exit (3); + } + + // kind of ugly : generate a grid of index, Nmeasure arrays + // to be filled below (I also need NN and Nn to track the number of + // entries in each). + int **NN_grid; + int **Nn_grid; + int ***Nm_grid; + off_t ***idxgrid; + ALLOCATE (NN_grid, int *, NX); + ALLOCATE (Nn_grid, int *, NX); + ALLOCATE (Nm_grid, int **, NX); + ALLOCATE (idxgrid, off_t **, NX); + + for (ix = 0; ix < NX; ix++) { + ALLOCATE (NN_grid[ix], int, NY); + ALLOCATE (Nn_grid[ix], int, NY); + ALLOCATE (Nm_grid[ix], int *, NY); + ALLOCATE (idxgrid[ix], off_t *, NY); + for (iy = 0; iy < NY; iy++) { + Nn_grid[ix][iy] = 0; + NN_grid[ix][iy] = 100; + ALLOCATE (Nm_grid[ix][iy], int, NN_grid[ix][iy]); + ALLOCATE (idxgrid[ix][iy], off_t, NN_grid[ix][iy]); + } + } + + // assign all of the average entries to a grid cell + for (i = 0; i < Naverage; i++) { + if (isnan(X[i])) continue; + if (isnan(Y[i])) continue; + ix = (X[i] - Xmin) / 200.0; + iy = (Y[i] - Ymin) / 200.0; + int Nn = Nn_grid[ix][iy]; + Nm_grid[ix][iy][Nn] = subcatalog[0].average[i].Nmeasure; + + // if we are resetting to a given photcode, we need to have that photcode... + if (NphotcodesReset) { + int k; + int foundReset = FALSE; + int m = subcatalog[0].average[i].measureOffset; + MeasureTiny *measure = &subcatalog[0].measureT[m]; + for (j = 0; (j < subcatalog[0].average[i].Nmeasure) && !foundReset; j++) { + if (CHECK_TEST_IMAGE && (abs(measure[j].t - Tref) < 10) && (measure[j].photcode == Cref)) { + fprintf (stderr, "."); + } + for (k = 0; (k < NphotcodesReset) && !foundReset; k++) { + if (photcodesReset[k][0].code == measure[j].photcode) foundReset = TRUE; + } + } + if (!foundReset) { + Nm_grid[ix][iy][Nn] = 0; + } + } + + idxgrid[ix][iy][Nn] = i; + Nn_grid[ix][iy] ++; + if (Nn_grid[ix][iy] >= NN_grid[ix][iy]) { + NN_grid[ix][iy] += 100; + REALLOCATE (Nm_grid[ix][iy], int, NN_grid[ix][iy]); + REALLOCATE (idxgrid[ix][iy], off_t, NN_grid[ix][iy]); + } + } + + // sort all of the grid cells + for (ix = 0; ix < NX; ix++) { + for (iy = 0; iy < NY; iy++) { + sort_by_Nmeasure (Nm_grid[ix][iy], idxgrid[ix][iy], Nn_grid[ix][iy]); + NN_grid[ix][iy] = 0; // I'm going to use this array to track which element I've already selected + } + } + + // cycle over the grid until we ready Nmax + off_t *keepidx = NULL; + ALLOCATE (keepidx, off_t, Naverage); + memset (keepidx, 0, Naverage*sizeof(off_t)); + int Nkeep = 0; + + for (i = 0; (i < 20) && (Nkeep < Nmax); i++) { + for (ix = 0; (ix < NX) && (Nkeep < Nmax); ix++) { + for (iy = 0; (iy < NY) && (Nkeep < Nmax); iy++) { + if (NN_grid[ix][iy] >= Nn_grid[ix][iy]) continue; // all used up! + int Nn = NN_grid[ix][iy]; + keepidx[Nkeep] = idxgrid[ix][iy][Nn]; + Nkeep ++; + NN_grid[ix][iy] ++; + } + } + } + + // count the number of measurements this selection will yield + off_t ave, NMEASURE = 0; + for (i = 0; i < Nkeep; i++) { + ave = keepidx[i]; + NMEASURE += subcatalog[0].average[ave].Nmeasure; + } + + // test catID : 37262 37261 37257 37258 + int dumpit = FALSE; + dumpit |= (oldcatalog[0].catID == 37007); + // dumpit |= (oldcatalog[0].catID == 37261); + // dumpit |= (oldcatalog[0].catID == 37257); + // dumpit |= (oldcatalog[0].catID == 37258); + if (dumpit) { + char name[64]; + snprintf (name, 64, "cat.%05d.dump.dat", oldcatalog[0].catID); + FILE *fdump = fopen (name, "w"); + for (i = 0; i < Nkeep; i++) { + ave = keepidx[i]; + fprintf (fdump, "%10.6f %10.6f %d\n", subcatalog[0].average[ave].R, subcatalog[0].average[ave].D, subcatalog[0].average[ave].Nmeasure); + } + fclose (fdump); + } + + // allocate the output data + ALLOCATE (tmpcatalog.average, Average, Nkeep); + ALLOCATE (tmpcatalog.measureT, MeasureTiny, NMEASURE); + ALLOCATE (tmpcatalog.secfilt, SecFilt, Nkeep * Nsecfilt); + + off_t Nmeasure = 0; + + // copy the Nkeep selected entries from subcatalog to tmpcatalog (adjusting links) + for (i = 0; i < Nkeep; i++) { + ave = keepidx[i]; + tmpcatalog.average[i] = subcatalog[0].average[ave]; + tmpcatalog.average[i].measureOffset = Nmeasure; + for (j = 0; j < tmpcatalog.average[i].Nmeasure; j++) { + off_t offset = subcatalog[0].average[ave].measureOffset + j; + tmpcatalog.measureT[Nmeasure] = subcatalog[0].measureT[offset]; + tmpcatalog.measureT[Nmeasure].averef = i; + Nmeasure ++; + } + for (j = 0; j < Nsecfilt; j++) { + tmpcatalog.secfilt[i*Nsecfilt + j] = subcatalog[0].secfilt[ave*Nsecfilt + j]; + } + } + + if (VERBOSE2) { + char *basename = filebasename (oldcatalog[0].filename); + fprintf (stderr, "limited to %d ("OFF_T_FMT" subset, "OFF_T_FMT" total) stars, "OFF_T_FMT" ("OFF_T_FMT" subset, "OFF_T_FMT" total) measures for catalog %s\n", + Nkeep, subcatalog[0].Naverage, oldcatalog[0].Naverage, Nmeasure, subcatalog[0].Nmeasure, oldcatalog[0].Nmeasure, basename); + free (basename); + } + + free (X); + free (Y); + + for (ix = 0; ix < NX; ix++) { + for (iy = 0; iy < NY; iy++) { + free (Nm_grid[ix][iy]); + free (idxgrid[ix][iy]); + } + free (NN_grid[ix]); + free (Nn_grid[ix]); + free (Nm_grid[ix]); + free (idxgrid[ix]); + } + free (NN_grid); + free (Nn_grid); + free (Nm_grid); + free (idxgrid); + + free (keepidx); + + free (subcatalog[0].average); + free (subcatalog[0].measureT); + free (subcatalog[0].secfilt); + + subcatalog[0].average = tmpcatalog.average; + subcatalog[0].measureT = tmpcatalog.measureT; + subcatalog[0].secfilt = tmpcatalog.secfilt; + subcatalog[0].Naverage = Nkeep; + subcatalog[0].Nmeasure = Nmeasure; + subcatalog[0].Nsecfilt = oldcatalog[0].Nsecfilt; + subcatalog[0].Nsecf_mem = Naverage * oldcatalog[0].Nsecfilt; + + return (TRUE); } @@ -205,4 +543,15 @@ NMEASURE += subcatalog[0].average[ave].Nmeasure; } + +# if (0) + if (oldcatalog[0].catID == 59962) { + FILE *fdump = fopen ("cat.dump.dat", "w"); + for (i = 0; i < Nmax; i++) { + ave = index[i]; + fprintf (fdump, "%10.6f %10.6f %d\n", subcatalog[0].average[ave].R, subcatalog[0].average[ave].D, subcatalog[0].average[ave].Nmeasure); + } + fclose (fdump); + } +# endif // allocate the output data Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/dvo_astrom_ops.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/dvo_astrom_ops.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/dvo_astrom_ops.c (revision 37067) @@ -1,3 +1,4 @@ # include "relastro.h" +/* the Measure carries the instantaneous mean position at the epoch t */ double getMeanR (MeasureTiny *measure, Average *average, SecFilt *secfilt) { @@ -5,6 +6,79 @@ double ra; - /* the measure carries the instantaneous mean position at the epoch t */ - ra = average[0].R - measure[0].dR / 3600.0; + // old: ra = average[0].R - measure[0].dR / 3600.0; + if (!measure) return NAN; + ra = measure[0].R; + + return (ra); +} + +double getMeanD (MeasureTiny *measure, Average *average, SecFilt *secfilt) { + + double dec; + + // old: dec = average[0].D - measure[0].dD / 3600.0; + if (!measure) return NAN; + dec = measure[0].D; + + return (dec); +} + +int setMeanR (double ra_fit, MeasureTiny *measure, Average *average, SecFilt *secfilt) { + + // old: measure[0].dR += (ra_fit - average[0].R) * 3600.0; + if (!measure) return FALSE; + measure[0].R = ra_fit; + + return (TRUE); +} + +int setMeanD (double dec_fit, MeasureTiny *measure, Average *average, SecFilt *secfilt) { + + // old: measure[0].dD += (dec_fit - average[0].D) * 3600.0; + if (!measure) return FALSE; + measure[0].D = dec_fit; + + return (TRUE); +} + +double getMeanR_Big (Measure *measure, Average *average, SecFilt *secfilt) { + + double ra; + + // old: ra = average[0].R - measure[0].dR / 3600.0; + if (!measure) return NAN; + ra = measure[0].R; + + return (ra); +} + +double getMeanD_Big (Measure *measure, Average *average, SecFilt *secfilt) { + + double dec; + + // old: dec = average[0].D - measure[0].dD / 3600.0; + if (!measure) return NAN; + dec = measure[0].D; + + return (dec); +} + +int setMeanR_Big (double ra_fit, Measure *measure, Average *average, SecFilt *secfilt) { + + // old: measure[0].dR += (ra_fit - average[0].R) * 3600.0; + if (!measure) return TRUE; + measure[0].R = ra_fit; + + return (TRUE); +} + +int setMeanD_Big (double dec_fit, Measure *measure, Average *average, SecFilt *secfilt) { + + // measure[0].dD += (dec_fit - average[0].D) * 3600.0; + if (!measure) return TRUE; + measure[0].D = dec_fit; + + return (TRUE); +} /* possible corrections to mean ra: @@ -18,128 +92,2 @@ */ - return (ra); -} - -double getMeanD (MeasureTiny *measure, Average *average, SecFilt *secfilt) { - - double dec; - - /* the measure carries the instantaneous mean position at the epoch t */ - dec = average[0].D - measure[0].dD / 3600.0; - - /* possible corrections to mean ra: - - - proper-motion and parallax - - abberation - - precession and nutation, etc - - refraction - - DCR - - */ - - return (dec); -} - -int setMeanR (double ra_fit, MeasureTiny *measure, Average *average, SecFilt *secfilt) { - - /* math to get from new fitted position to new measure offset - ra_obs = average[0].R - measure[0].dR / 3600.0; - measure[0].dR = (ra_fit - ra_obs) * 3600.0; - measure[0].dR = (ra_fit - average[0].R + measure[0].dR/3600) * 3600.0 - measure[0].dR = (ra_fit - average[0].R) * 3600.0 + measure[0].dR; - */ - - /* the measure carries the instantaneous mean position at the epoch t */ - measure[0].dR += (ra_fit - average[0].R) * 3600.0; - - /* possible corrections to mean ra: - - - proper-motion and parallax - - abberation - - precession and nutation, etc - - refraction - - DCR - - */ - - return (TRUE); -} - -int setMeanD (double dec_fit, MeasureTiny *measure, Average *average, SecFilt *secfilt) { - - /* math to get from new fitted position to new measure offset - dec_obs = average[0].D - measure[0].dD / 3600.0; - measure[0].dD = (dec_fit - dec_obs) * 3600.0; - measure[0].dD = (dec_fit - average[0].D + measure[0].dD/3600) * 3600.0 - measure[0].dD = (dec_fit - average[0].D) * 3600.0 + measure[0].dD; - */ - - /* the measure carries the instantaneous mean position at the epoch t */ - measure[0].dD += (dec_fit - average[0].D) * 3600.0; - - /* possible corrections to mean ra: - - - proper-motion and parallax - - abberation - - precession and nutation, etc - - refraction - - DCR - - */ - - return (TRUE); -} - -int setMeanR_Big (double ra_fit, Measure *measure, Average *average, SecFilt *secfilt) { - - if (!measure) return TRUE; - - /* math to get from new fitted position to new measure offset - ra_obs = average[0].R - measure[0].dR / 3600.0; - measure[0].dR = (ra_fit - ra_obs) * 3600.0; - measure[0].dR = (ra_fit - average[0].R + measure[0].dR/3600) * 3600.0 - measure[0].dR = (ra_fit - average[0].R) * 3600.0 + measure[0].dR; - */ - - /* the measure carries the instantaneous mean position at the epoch t */ - measure[0].dR += (ra_fit - average[0].R) * 3600.0; - - /* possible corrections to mean ra: - - - proper-motion and parallax - - abberation - - precession and nutation, etc - - refraction - - DCR - - */ - - return (TRUE); -} - -int setMeanD_Big (double dec_fit, Measure *measure, Average *average, SecFilt *secfilt) { - - if (!measure) return TRUE; - - /* math to get from new fitted position to new measure offset - dec_obs = average[0].D - measure[0].dD / 3600.0; - measure[0].dD = (dec_fit - dec_obs) * 3600.0; - measure[0].dD = (dec_fit - average[0].D + measure[0].dD/3600) * 3600.0 - measure[0].dD = (dec_fit - average[0].D) * 3600.0 + measure[0].dD; - */ - - /* the measure carries the instantaneous mean position at the epoch t */ - measure[0].dD += (dec_fit - average[0].D) * 3600.0; - - /* possible corrections to mean ra: - - - proper-motion and parallax - - abberation - - precession and nutation, etc - - refraction - - DCR - - */ - - return (TRUE); -} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/high_speed_objects.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/high_speed_objects.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/high_speed_objects.c (revision 37067) @@ -161,5 +161,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 1; - strcpy (tcoords.ctype, "RA---ARC"); + strcpy (tcoords.ctype, "DEC--ARC"); /* build spatial index (RA sort) referencing input array sequence */ @@ -241,7 +241,7 @@ for(i1=0;i1 0); - if (!finite(measure[0].dR)) return FALSE; - if (!finite(measure[0].dD)) return FALSE; - if (!finite(measure[0].M)) return FALSE; + if (!finite(measure[0].R)) return FALSE; + if (!finite(measure[0].D)) return FALSE; + if (!finite(measure[0].M)) return FALSE; float dX = GetAstromError (measure, ERROR_MODE_RA); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/hpm_objects.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/hpm_objects.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/hpm_objects.c (revision 37067) @@ -138,5 +138,5 @@ tcoords.pc1_2 = tcoords.pc2_1 = 0.0; tcoords.Npolyterms = 1; - strcpy (tcoords.ctype, "RA---ARC"); + strcpy (tcoords.ctype, "DEC--ARC"); /* build spatial index (RA sort) referencing input array sequence */ @@ -240,7 +240,7 @@ for (k = 0; k < catalog[0].average[nj].Nmeasure; k++) { testcat.measure[Nmatchmeas] = catalog[0].measure[m+k]; - /* Set offset RA and Dec wrt correct average value*/ - testcat.measure[Nmatchmeas].dR = catalog[0].measure[m+k].dR + 3600.0*(catalog[0].average[ni].R - catalog[0].average[nj].R); - testcat.measure[Nmatchmeas].dD = catalog[0].measure[m+k].dD + 3600.0*(catalog[0].average[ni].D - catalog[0].average[nj].D); + // DROP: was needed when dR,dD were relative to average.R,D + // testcat.measure[Nmatchmeas].R = catalog[0].measure[m+k].R; + // testcat.measure[Nmatchmeas].D = catalog[0].measure[m+k].D; testcat.measure[Nmatchmeas].averef = 0; Nmatchmeas++; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/indexCatalogs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/indexCatalogs.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/indexCatalogs.c (revision 37067) @@ -0,0 +1,66 @@ +# include "relastro.h" + +static int catIDmax = 0; +static int *catIDseq = NULL; +static int *objIDmax = NULL; +static int **objIDseq = NULL; + +int indexCatalogs (Catalog *catalog, int Ncatalog) { + + int i; + off_t j; + + if (!Ncatalog) return TRUE; + + // find the max value of catID + for (i = 0; i < Ncatalog; i++) { + catIDmax = MAX (catalog[i].catID, catIDmax); + } + + ALLOCATE (catIDseq, int, catIDmax + 1); + for (i = 0; i < catIDmax + 1; i++) { + catIDseq[i] = -1; + } + + for (i = 0; i < Ncatalog; i++) { + int catID = catalog[i].catID; + catIDseq[catID] = i; + } + + ALLOCATE (objIDmax, int, Ncatalog); + ALLOCATE (objIDseq, int *, Ncatalog); + for (i = 0; i < Ncatalog; i++) { + objIDmax[i] = 0; + for (j = 0; j < catalog[i].Naverage; j++) { + objIDmax[i] = MAX (catalog[i].average[j].objID, objIDmax[i]); + } + + ALLOCATE (objIDseq[i], int, objIDmax[i] + 1); + for (j = 0; j < objIDmax[i] + 1; j++) { + objIDseq[i][j] = -1; + } + + for (j = 0; j < catalog[i].Naverage; j++) { + int objID = catalog[i].average[j].objID; + objIDseq[i][objID] = j; + } + } + return TRUE; +} + +int catID_and_objID_to_seq (int catID, int objID, int *catSeq, off_t *objSeq) { + + if (catID > catIDmax) return FALSE; + + int cat = catIDseq[catID]; + if (cat < 1) return FALSE; + + if (objID > objIDmax[cat]) return FALSE; + + int obj = objIDseq[cat][objID]; + if (obj < 1) return FALSE; + + *catSeq = cat; + *objSeq = obj; + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/initialize.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/initialize.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/initialize.c (revision 37067) @@ -6,15 +6,58 @@ args (argc, argv); - if (FIT_TARGET == TARGET_MERGE_SOURCE) return; + if (RELASTRO_OP == OP_MERGE_SOURCE) return; - fprintf (stderr, "PHOTCODE_KEEP_LIST: %s\n", PHOTCODE_KEEP_LIST); - fprintf (stderr, "PHOTCODE_SKIP_LIST: %s\n", PHOTCODE_SKIP_LIST); - fprintf (stderr, "PHOTCODE_A_LIST: %s\n", PHOTCODE_A_LIST); - fprintf (stderr, "PHOTCODE_B_LIST: %s\n", PHOTCODE_B_LIST); + if (DCR_BLUE_COLOR_POS) fprintf (stderr, "DCR_BLUE_COLOR_POS: %s - %s\n", DCR_BLUE_COLOR_POS, DCR_BLUE_COLOR_NEG); + if (DCR_BLUE_COLOR_POS) fprintf (stderr, "DCR_BLUE_COLOR_POS: %s - %s\n", DCR_BLUE_COLOR_POS, DCR_BLUE_COLOR_NEG); - photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE); - photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE); - photcodesGroupA = ParsePhotcodeList (PHOTCODE_A_LIST, &NphotcodesGroupA, TRUE); - photcodesGroupB = ParsePhotcodeList (PHOTCODE_B_LIST, &NphotcodesGroupB, TRUE); + if (PHOTCODE_KEEP_LIST) fprintf (stderr, "PHOTCODE_KEEP_LIST: %s\n", PHOTCODE_KEEP_LIST); + if (PHOTCODE_SKIP_LIST) fprintf (stderr, "PHOTCODE_SKIP_LIST: %s\n", PHOTCODE_SKIP_LIST); + if (PHOTCODE_RESET_LIST) fprintf (stderr, "PHOTCODE_RESET_LIST: %s\n", PHOTCODE_RESET_LIST); + if (PHOTCODE_A_LIST) fprintf (stderr, "PHOTCODE_A_LIST: %s\n", PHOTCODE_A_LIST); + if (PHOTCODE_B_LIST) fprintf (stderr, "PHOTCODE_B_LIST: %s\n", PHOTCODE_B_LIST); + + photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE); + photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE); + photcodesReset = ParsePhotcodeList (PHOTCODE_RESET_LIST, &NphotcodesReset, FALSE); + photcodesGroupA = ParsePhotcodeList (PHOTCODE_A_LIST, &NphotcodesGroupA, TRUE); + photcodesGroupB = ParsePhotcodeList (PHOTCODE_B_LIST, &NphotcodesGroupB, TRUE); + + // blue color elements + DCR_BLUE_NSEC_POS = DCR_BLUE_NSEC_NEG = -1; + if (DCR_BLUE_COLOR_POS) { + DCR_BLUE_PHOTCODE_POS = GetPhotcodebyName (DCR_BLUE_COLOR_POS); + if (!DCR_BLUE_PHOTCODE_POS) { + fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", DCR_BLUE_COLOR_POS); + exit (1); + } + DCR_BLUE_NSEC_POS = GetPhotcodeNsec (DCR_BLUE_PHOTCODE_POS[0].code); + } + if (DCR_BLUE_COLOR_NEG) { + DCR_BLUE_PHOTCODE_NEG = GetPhotcodebyName (DCR_BLUE_COLOR_NEG); + if (!DCR_BLUE_PHOTCODE_NEG) { + fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", DCR_BLUE_COLOR_NEG); + exit (1); + } + DCR_BLUE_NSEC_NEG = GetPhotcodeNsec (DCR_BLUE_PHOTCODE_NEG[0].code); + } + + // red color elements + DCR_RED_NSEC_POS = DCR_RED_NSEC_NEG = -1; + if (DCR_RED_COLOR_POS) { + DCR_RED_PHOTCODE_POS = GetPhotcodebyName (DCR_RED_COLOR_POS); + if (!DCR_RED_PHOTCODE_POS) { + fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", DCR_RED_COLOR_POS); + exit (1); + } + DCR_RED_NSEC_POS = GetPhotcodeNsec (DCR_RED_PHOTCODE_POS[0].code); + } + if (DCR_RED_COLOR_NEG) { + DCR_RED_PHOTCODE_NEG = GetPhotcodebyName (DCR_RED_COLOR_NEG); + if (!DCR_RED_PHOTCODE_NEG) { + fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", DCR_RED_COLOR_NEG); + exit (1); + } + DCR_RED_NSEC_NEG = GetPhotcodeNsec (DCR_RED_PHOTCODE_NEG[0].code); + } initstats (STATMODE); @@ -42,13 +85,15 @@ args_client (argc, argv); - fprintf (stderr, "PHOTCODE_KEEP_LIST: %s\n", PHOTCODE_KEEP_LIST); - fprintf (stderr, "PHOTCODE_SKIP_LIST: %s\n", PHOTCODE_SKIP_LIST); - fprintf (stderr, "PHOTCODE_A_LIST: %s\n", PHOTCODE_A_LIST); - fprintf (stderr, "PHOTCODE_B_LIST: %s\n", PHOTCODE_B_LIST); + if (PHOTCODE_KEEP_LIST) fprintf (stderr, "PHOTCODE_KEEP_LIST: %s\n", PHOTCODE_KEEP_LIST); + if (PHOTCODE_SKIP_LIST) fprintf (stderr, "PHOTCODE_SKIP_LIST: %s\n", PHOTCODE_SKIP_LIST); + if (PHOTCODE_RESET_LIST) fprintf (stderr, "PHOTCODE_RESET_LIST: %s\n", PHOTCODE_RESET_LIST); + if (PHOTCODE_A_LIST) fprintf (stderr, "PHOTCODE_A_LIST: %s\n", PHOTCODE_A_LIST); + if (PHOTCODE_B_LIST) fprintf (stderr, "PHOTCODE_B_LIST: %s\n", PHOTCODE_B_LIST); - photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE); - photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE); - photcodesGroupA = ParsePhotcodeList (PHOTCODE_A_LIST, &NphotcodesGroupA, TRUE); - photcodesGroupB = ParsePhotcodeList (PHOTCODE_B_LIST, &NphotcodesGroupB, TRUE); + photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE); + photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE); + photcodesReset = ParsePhotcodeList (PHOTCODE_RESET_LIST, &NphotcodesReset, FALSE); + photcodesGroupA = ParsePhotcodeList (PHOTCODE_A_LIST, &NphotcodesGroupA, TRUE); + photcodesGroupB = ParsePhotcodeList (PHOTCODE_B_LIST, &NphotcodesGroupB, TRUE); initstats (STATMODE); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/launch_region_hosts.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/launch_region_hosts.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/launch_region_hosts.c (revision 37067) @@ -0,0 +1,148 @@ +# include "relastro.h" +# define DEBUG 0 + +int launch_region_hosts (RegionHostTable *regionHosts) { + + int i; + + // clear the I/O files + for (i = 0; i < regionHosts->Nhosts; i++) { + char *syncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanmags.sync"); + if (truncate (syncfile, 0)) fprintf (stderr, "trouble clearing syncfile %s\n", syncfile); + free (syncfile); + + char *fitsfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanmags.fits"); + if (truncate (fitsfile, 0)) fprintf (stderr, "trouble clearing fitsfile %s\n", fitsfile); + free (fitsfile); + + char *imsyncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagemags.sync"); + if (truncate (imsyncfile, 0)) fprintf (stderr, "trouble clearing imsyncfile %s\n", imsyncfile); + free (imsyncfile); + + char *imfitsfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagemags.fits"); + if (truncate (imfitsfile, 0)) fprintf (stderr, "trouble clearing imfitsfile %s\n", imfitsfile); + free (imfitsfile); + + char *loopsyncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "loop.sync"); + if (truncate (loopsyncfile, 0)) fprintf (stderr, "trouble clearing loopsyncfile %s\n", loopsyncfile); + free (loopsyncfile); + } + + for (i = 0; i < regionHosts->Nhosts; i++) { + + RegionHostInfo *host = ®ionHosts->hosts[i]; + + // communication files: + // subset images per host : CATDIR/Image.HOSTNAME.fits + char filename[1024]; + snprintf (filename, 1024, "%s/Image.%d.fits", CATDIR, host->hostID); + + // write the image subset for this host + ImageTableSave (filename, host->image, host->Nimage); + + char command[1024]; + snprintf (command, 1024, "relastro -parallel-images %s", filename); + strextend (command, "-region-hosts %s", REGION_FILE); + strextend (command, "-region-hostID %d", host->hostID); + strextend (command, "-D CATDIR %s", CATDIR); + strextend (command, "-region %f %f %f %f", host->RminCat, host->RmaxCat, host->DminCat, host->DmaxCat); + strextend (command, "-statmode %s", STATMODE); + strextend (command, "-minerror %f", MIN_ERROR); + strextend (command, "-nloop %d", NLOOP); + strextend (command, "-threads %d", NTHREADS); + + switch (FIT_TARGET) { + case TARGET_SIMPLE: + strextend (command, "-update-simple"); + break; + case TARGET_CHIPS: + strextend (command, "-update-chips"); + break; + case TARGET_MOSAICS: + strextend (command, "-update-mosaics"); + break; + case TARGET_NONE: + abort(); + } + + if (VERBOSE) strextend (command, "-v"); + if (VERBOSE2) strextend (command, "-vv"); + if (RESET) strextend (command, "-reset"); + if (UPDATE) strextend (command, "-update"); + if (PARALLEL) strextend (command, "-parallel"); + if (PARALLEL_MANUAL) strextend (command, "-parallel-manual"); + if (PARALLEL_SERIAL) strextend (command, "-parallel-serial"); + if (PHOTCODE_KEEP_LIST) strextend (command, "+photcode %s", PHOTCODE_KEEP_LIST); + if (PHOTCODE_SKIP_LIST) strextend (command, "-photcode %s", PHOTCODE_SKIP_LIST); + if (PHOTCODE_RESET_LIST) strextend (command, "-reset-to-photcode %s", PHOTCODE_RESET_LIST); + + if (MaxDensityUse) strextend (command, "-max-density %f", MaxDensityValue); + if (ImagSelect) strextend (command, "-instmag %f %f", ImagMin, ImagMax); + if (ExcludeBogus) strextend (command, "-exclude-bogus %f", ExcludeBogusRadius); + + if (DCR_BLUE_COLOR_POS && DCR_BLUE_COLOR_NEG) { + strextend (command, "-dcr-blue-color %s %s", DCR_BLUE_COLOR_POS, DCR_BLUE_COLOR_NEG); + } + if (DCR_RED_COLOR_POS && DCR_RED_COLOR_NEG) { + strextend (command, "-dcr-red-color %s %s", DCR_RED_COLOR_POS, DCR_RED_COLOR_NEG); + } + + if (PhotFlagSelect) strextend (command, "+photflags"); + if (PhotFlagBad) strextend (command, "+photflagbad %d", PhotFlagBad); + if (PhotFlagPoor) strextend (command, "+photflagpoor %d", PhotFlagPoor); + + if (MinBadQF > 0.0) strextend (command, "-min-bad-psfqf %f", MinBadQF); + if (MaxMeanOffset != 10.0) strextend (command, "-max-mean-offset %f", MaxMeanOffset); + + strextend (command, "-D RELASTRO_SRC_MEAS_TOOFEW %d", SRC_MEAS_TOOFEW); + strextend (command, "-D RELASTRO_SIGMA_LIM %f", SIGMA_LIM); + strextend (command, "-D RELASTRO_DPOS_MAX %f", DPOS_MAX); + strextend (command, "-D ADDSTAR_RADIUS %f", ADDSTAR_RADIUS); + + if (USE_FIXED_PIXCOORDS) strextend (command, "-D USE_FIXED_PIXCOORDS 1"); + + if (TimeSelect) { + char *tstart = ohana_sec_to_date (TSTART); + char *tstop = ohana_sec_to_date (TSTOP); + strextend (command, "-time %s %s", tstart, tstop); + free (tstart); + free (tstop); + } + + fprintf (stderr, "command: %s\n", command); + + if (PARALLEL_REGIONS_MANUAL) continue; + + // launch the job, then wait for it to be done loading catalogs. force the remote + // client to generate the file + char *syncfile = make_filename (CATDIR, host->hostname, host->hostID, "loadcat.sync"); + clear_sync_file (syncfile); + + // launch the job on the remote machine (no handshake) + int errorInfo = 0; + int pid = rconnect ("ssh", host->hostname, command, host->stdio, &errorInfo, FALSE); + if (!pid) { + if (DEBUG) fprintf (stderr, "failure to start %s (error %d)\n", host->hostname, errorInfo); + exit (1); + } + host->pid = pid; // save for future reference + + // remove client is done, go ahead with next client + check_sync_file (syncfile, 1); + free (syncfile); + } + + if (PARALLEL_REGIONS_MANUAL) { + fprintf (stderr, "run the relastro_client commands above. when these are done, hit return\n"); + getchar(); + } else { + RegionHostTableWaitJobsGetIO (regionHosts, __FILE__, __LINE__, VERBOSE); + } + + int status = TRUE; + for (i = 0; i < regionHosts->Nhosts; i++) { + status = status && (regionHosts->hosts[i].status == 0); + } + + return status; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/load_catalogs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/load_catalogs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/load_catalogs.c (revision 37067) @@ -1,15 +1,16 @@ # include "relastro.h" -Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog); +Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog, char *syncfile); void bcatalog_show_skips (); -Catalog *load_catalogs (SkyList *skylist, int *Ncatalog, int subselect, int hostID, char *hostpath) { - - int i, j, k, m, Nstar; +Catalog *load_catalogs (SkyList *skylist, int *Ncatalog, int subselect, int hostID, char *hostpath, char *syncfile) { + + int i, j, Nstar; + // int k, m; Catalog *catalog, *pcatalog, tcatalog; // XXX need to decide how to determine PARALLEL mode... if (PARALLEL && !hostID) { - catalog = load_catalogs_parallel (skylist, Ncatalog); + catalog = load_catalogs_parallel (skylist, Ncatalog, syncfile); return catalog; } @@ -73,4 +74,5 @@ if (RESET) { for (j = 0; j < catalog[Ncat].Naverage; j++) { +# if (0) catalog[Ncat].average[j].flags = 0; m = catalog[Ncat].average[j].measureOffset; @@ -78,4 +80,5 @@ catalog[Ncat].measure[m+k].dbFlags = 0; } +# endif } } @@ -84,5 +87,5 @@ } - // XXX TEST : bcatalog_show_skips(); + bcatalog_show_skips(); Nstar = 0; @@ -99,4 +102,10 @@ } + // if we are running with parallel_images but not a parallel database, we need to + // release the lock so the next image host can proceed + if (!hostID && syncfile) { + update_sync_file (syncfile, 1); + } + // only return the populated catalogs REALLOCATE (catalog, Catalog, Ncat); @@ -113,5 +122,10 @@ // CATDIR is supplied globally # define DEBUG 1 -Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog) { +Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog, char *syncfile) { + + char uniquer[12]; + int TIME = time(NULL); + int PID = getpid(); + snprintf (uniquer, 12, "%05d.%05d", PID, TIME % 100000); // load the list of hosts @@ -131,5 +145,5 @@ ALLOCATE (table->hosts[i].results, char, 1024); - snprintf (table->hosts[i].results, 1024, "%s/relastro.catalog.subset.dat", table->hosts[i].pathname); + snprintf (table->hosts[i].results, 1024, "%s/relastro.catalog.%s.dat", table->hosts[i].pathname, uniquer); // options / arguments that can affect relastro_client -load: @@ -145,24 +159,29 @@ table->hosts[i].results, table->hosts[i].hostID, CATDIR, table->hosts[i].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, STATMODE, MIN_ERROR, SIGMA_LIM); - char tmpline[1024]; - if (FIT_MODE == FIT_PM_ONLY) { snprintf (tmpline, 1024, "%s -pm", command); strcpy (command, tmpline); } - if (FIT_MODE == FIT_PAR_ONLY) { snprintf (tmpline, 1024, "%s -par", command); strcpy (command, tmpline); } - if (FIT_MODE == FIT_PM_AND_PAR) { snprintf (tmpline, 1024, "%s -pmpar", command); strcpy (command, tmpline); } - - if (VERBOSE) { snprintf (tmpline, 1024, "%s -v", command); strcpy (command, tmpline); } - if (VERBOSE2) { snprintf (tmpline, 1024, "%s -vv", command); strcpy (command, tmpline); } - if (RESET) { snprintf (tmpline, 1024, "%s -reset", command); strcpy (command, tmpline); } - if (ImagSelect) { snprintf (tmpline, 1024, "%s -instmag %f %f", command, ImagMin, ImagMax); strcpy (command, tmpline); } - if (MaxDensityUse) { snprintf (tmpline, 1024, "%s -max-density %f", command, MaxDensityValue); strcpy (command, tmpline); } + if (FIT_MODE == FIT_PM_ONLY) strextend (command, "-pm"); + if (FIT_MODE == FIT_PAR_ONLY) strextend (command, "-par"); + if (FIT_MODE == FIT_PM_AND_PAR) strextend (command, "-pmpar"); + + if (VERBOSE) strextend (command, "-v"); + if (VERBOSE2) strextend (command, "-vv"); + if (RESET) strextend (command, "-reset"); + if (ImagSelect) strextend (command, "-instmag %f %f", ImagMin, ImagMax); + if (MaxDensityUse) strextend (command, "-max-density %f", MaxDensityValue); + if (FlagOutlier) strextend (command, "-clip %d", CLIP_THRESH); + if (ExcludeBogus) strextend (command, "-exclude-bogus %f", ExcludeBogusRadius); - if (FlagOutlier) { snprintf (tmpline, 1024, "%s -clip %d", command, CLIP_THRESH); strcpy (command, tmpline); } - - if (USE_FIXED_PIXCOORDS) { snprintf (tmpline, 1024, "%s -D USE_FIXED_PIXCOORDS 1", command); strcpy (command, tmpline); } - - if (PHOTCODE_KEEP_LIST) { snprintf (tmpline, 1024, "%s +photcode %s", command, PHOTCODE_KEEP_LIST); strcpy (command, tmpline); } - if (PHOTCODE_SKIP_LIST) { snprintf (tmpline, 1024, "%s -photcode %s", command, PHOTCODE_SKIP_LIST); strcpy (command, tmpline); } - if (PhotFlagSelect) { snprintf (tmpline, 1024, "%s +photflags", command); strcpy (command, tmpline); } - if (PhotFlagBad) { snprintf (tmpline, 1024, "%s +photflagbad %d", command, PhotFlagBad); strcpy (command, tmpline); } - if (PhotFlagPoor) { snprintf (tmpline, 1024, "%s +photflagpoor %d", command, PhotFlagPoor); strcpy (command, tmpline); } + if (DCR_BLUE_COLOR_POS && DCR_BLUE_COLOR_NEG) { + strextend (command, "-dcr-blue-color %s %s", DCR_BLUE_COLOR_POS, DCR_BLUE_COLOR_NEG); + } + if (DCR_RED_COLOR_POS && DCR_RED_COLOR_NEG) { + strextend (command, "-dcr-red-color %s %s", DCR_RED_COLOR_POS, DCR_RED_COLOR_NEG); + } + + if (USE_FIXED_PIXCOORDS) strextend (command, "-D USE_FIXED_PIXCOORDS 1"); + if (PHOTCODE_KEEP_LIST) strextend (command, "+photcode %s", PHOTCODE_KEEP_LIST); + if (PHOTCODE_SKIP_LIST) strextend (command, "-photcode %s", PHOTCODE_SKIP_LIST); + if (PhotFlagSelect) strextend (command, "+photflags"); + if (PhotFlagBad) strextend (command, "+photflagbad %d", PhotFlagBad); + if (PhotFlagPoor) strextend (command, "+photflagpoor %d", PhotFlagPoor); // XXX note that the above pass in the flag as decimal -- also note that args.c cannot handle 0xHEX values @@ -170,8 +189,7 @@ char *tstart = ohana_sec_to_date (TSTART); char *tstop = ohana_sec_to_date (TSTOP); - snprintf (tmpline, 1024, "%s -time %s %s", command, tstart, tstop); + strextend (command, "-time %s %s", tstart, tstop); free (tstart); free (tstop); - strcpy (command, tmpline); } @@ -206,4 +224,17 @@ } + // update syncfile here (save lots of I/O time): + + // at this point, the remote relastro_client jobs are done loading their data. in a + // parallel_images mode, the next image host can be launched while this image host now + // reads that + + // NOTE: if I let all hosts load blindly, I saturate the data clients with too many + // relastro_client requests. I need to have the master mediate this. the master + // will not launch the next remote job until this one says it is done + if (syncfile) { + update_sync_file (syncfile, 1); + } + // each host generates a BrightCatalog structure, with the measure, average, etc value // loaded into a single set of arrays (of MeasureTiny, AverageTiny, Secfilt). I need to Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/load_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/load_images.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/load_images.c (revision 37067) @@ -1,9 +1,3 @@ # include "relastro.h" - -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); \ - fprintf (stderr, MSG, __VA_ARGS__); } int load_images (FITS_DB *db, SkyList *skylist, int UseFullOverlap) { @@ -12,7 +6,6 @@ off_t Nimage, Nsubset; off_t *LineNumber; - struct timeval start, stop; - gettimeofday (&start, (void *) NULL); + INITTIME; // convert database table to internal structure @@ -35,5 +28,5 @@ /* unlock, if we can (else, unlocked below) */ - int unlockImages = !UPDATE || (FIT_TARGET == TARGET_UPDATE_OFFSETS); + int unlockImages = !UPDATE || (RELASTRO_OP == OP_UPDATE_OFFSETS); if (unlockImages) dvo_image_unlock (db); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/markObjects.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/markObjects.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/markObjects.c (revision 37067) @@ -0,0 +1,24 @@ +# include "relastro.h" + +int markObjects (Catalog *catalog, int Ncatalog) { + + int i, n; + off_t j; + + // How strongly do I own this object? + for (i = 0; i < Ncatalog; i++) { + ALLOCATE (catalog[i].nOwn_t, int, catalog[i].Naverage); + memset (catalog[i].nOwn_t, 0, catalog[i].Naverage*sizeof(int)); + for (j = 0; j < catalog[i].Naverage; j++) { + int nOwn = 0; + int m = catalog[i].average[j].measureOffset; + for (n = 0; n < catalog[i].average[j].Nmeasure; n++) { + if (!catalog[i].measureT[m+n].myDet) continue; + nOwn ++; + } + catalog[i].nOwn_t[j] = nOwn; + } + } + return TRUE; +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro.c (revision 37067) @@ -10,33 +10,41 @@ SkyList *skylist = SkyListByPatch (sky, -1, &UserPatch); - switch (FIT_TARGET) { - case TARGET_UPDATE_OBJECTS: + switch (RELASTRO_OP) { + case OP_UPDATE_OBJECTS: /* the object analysis is a separate process iterating over catalogs */ relastro_objects (skylist, 0, NULL); exit (0); - case TARGET_HIGH_SPEED: + case OP_HIGH_SPEED: /* high-speed is a 2pt cross-correlation process for linking moving objects (high PM) */ high_speed_catalogs (sky, skylist, 0, NULL); exit (0); - case TARGET_HPM: + case OP_HPM: hpm_catalogs (sky, skylist, 0, NULL); exit (0); - case TARGET_MERGE_SOURCE: + case OP_MERGE_SOURCE: /* a special method to manually merge unlinked detections of sources togther (not parallel) */ relastro_merge_source (sky); exit (0); - case TARGET_SIMPLE: - case TARGET_CHIPS: - case TARGET_MOSAICS: + case OP_IMAGES: relastro_images (skylist); exit (0); - case TARGET_UPDATE_OFFSETS: + case OP_UPDATE_OFFSETS: // iterate over catalogs to make detection coordinates consistant UpdateObjectOffsets (skylist, 0, NULL); + exit (0); + + case OP_PARALLEL_REGIONS: + // run image updates in parallel across multiple remote machines + relastro_parallel_regions (); + exit (0); + + case OP_PARALLEL_IMAGES: + // operation on the remote machines in the PARALLEL_REGION mode + relastro_parallel_images (); exit (0); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastroVisual.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastroVisual.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastroVisual.c (revision 37067) @@ -431,6 +431,6 @@ // populate vectors - ALLOCATE(Din, float, Nmeasure); - ALLOCATE(Rin, float, Nmeasure); + ALLOCATE(Din, float, Nmeasure); + ALLOCATE(Rin, float, Nmeasure); ALLOCATE(Dout, float, Nmeasure); ALLOCATE(Rout, float, Nmeasure); @@ -451,17 +451,17 @@ meas = catalog[0].measure[m]; if (!MeasFilterTest(&meas, FALSE)) continue; - xmin = MIN(xmin, meas.dR); - xmax = MAX(xmax, meas.dR); - ymin = MIN(ymin, meas.dD); - ymax = MAX(ymax, meas.dD); + xmin = MIN(xmin, meas.R); + xmax = MAX(xmax, meas.R); + ymin = MIN(ymin, meas.D); + ymax = MAX(ymax, meas.D); if (meas.dbFlags & ID_MEAS_POOR_ASTROM) { - Rout[Nout] = (float)(meas.dR); - Dout[Nout] = (float)(meas.dD); + Rout[Nout] = (meas.R); + Dout[Nout] = (meas.D); fprintf(stderr, "r: %f\td: %f\t outlier: 1\n", Rout[Nout], Dout[Nout]); Nout++; } else { - Rin[Nin] = (float)(meas.dR); - Din[Nin] = (float)(meas.dD); + Rin[Nin] = (meas.R); + Din[Nin] = (meas.D); fprintf(stderr, "r: %f\td: %f\t outlier: 0\n", Rin[Nin], Din[Nin]); Nin++; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_client.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_client.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_client.c (revision 37067) @@ -28,23 +28,23 @@ SkyList *skylist = SkyListByPatch (sky, -1, &UserPatch); - switch (FIT_TARGET) { + switch (RELASTRO_OP) { - case TARGET_LOAD_OBJECTS: { + case OP_LOAD_OBJECTS: { // USAGE: relastro_client -load-objects int Ncatalog; - Catalog *catalog = load_catalogs (skylist, &Ncatalog, TRUE, HOST_ID, HOSTDIR); + Catalog *catalog = load_catalogs (skylist, &Ncatalog, TRUE, HOST_ID, HOSTDIR, NULL); if (!catalog) { - fprintf (stderr, "ERROR loading catalogs from %s\n", CATDIR); - exit (2); + fprintf (stderr, "ERROR loading catalogs from %s\n", CATDIR); + exit (2); } BrightCatalog *bcatalog = BrightCatalogMerge (catalog, Ncatalog); if (!BrightCatalogSave (BCATALOG, bcatalog)) { - fprintf (stderr, "ERROR saving bright catalog from %s\n", CATDIR); - exit (2); + fprintf (stderr, "ERROR saving bright catalog from %s\n", CATDIR); + exit (2); } break; } - case TARGET_UPDATE_OBJECTS: { + case OP_UPDATE_OBJECTS: { // USAGE: relastro_client -update-objects relastro_objects (skylist, HOST_ID, HOSTDIR); @@ -52,5 +52,5 @@ } - case TARGET_HIGH_SPEED: { + case OP_HIGH_SPEED: { // USAGE: relastro_client -high-speed high_speed_catalogs (sky, skylist, HOST_ID, HOSTDIR); @@ -58,5 +58,5 @@ } - case TARGET_HPM: { + case OP_HPM: { // USAGE: relastro_client -high-speed hpm_catalogs (sky, skylist, HOST_ID, HOSTDIR); @@ -64,6 +64,6 @@ } - // XXX loading the images is fairly costly -- see if we can do an image subset - case TARGET_UPDATE_OFFSETS: { + // XXX loading the images is fairly costly -- see if we can do an image subset? + case OP_UPDATE_OFFSETS: { FITS_DB db; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_images.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_images.c (revision 37067) @@ -6,7 +6,6 @@ Catalog *catalog; FITS_DB db; - struct timeval start, stop; - gettimeofday (&start, (void *) NULL); + INITTIME; /* register database handle with shutdown procedure */ @@ -29,6 +28,14 @@ // XXX pass in the image table // XXX who carries the image grid? - catalog = load_catalogs (skylist, &Ncatalog, TRUE, 0, NULL); + + // photcodesKeep is used here to allow measurements from the images being calibrated + // note if -reset-to-photcode is selected, photocodesKeep is replaced with below with photcodesReset + catalog = load_catalogs (skylist, &Ncatalog, TRUE, 0, NULL, NULL); MARKTIME("load catalog data: %f sec\n", dtime); + + if (photcodesReset) { + photcodesKeep = photcodesReset; + NphotcodesKeep = NphotcodesReset; + } if (Ncatalog == 0) { @@ -51,4 +58,6 @@ // set test points based on the starmap createStarMap (catalog, Ncatalog); + + // XXX NOTE : for 2mass reset, photcodesKeep should now limit to 2MASS measurements /* major modes */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_merge_source.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_merge_source.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_merge_source.c (revision 37067) @@ -100,11 +100,12 @@ catalog_src.measure[m].averef = index_dst; + // OLD CODE: when measure.dR,dD were relative to average.R,D it was necessary to modify them // get the instantaneous positions: - double R = catalog_src.average[index_src].R - catalog_src.measure[m].dR / 3600.0; - double D = catalog_src.average[index_src].D - catalog_src.measure[m].dD / 3600.0; + // DROP double R = catalog_src.average[index_src].R - catalog_src.measure[m].dR / 3600.0; + // DROP double D = catalog_src.average[index_src].D - catalog_src.measure[m].dD / 3600.0; // update the offset coordinates to match the new source - catalog_src.measure[m].dR = 3600.0*(catalog_src.average[index_dst].R - R); - catalog_src.measure[m].dD = 3600.0*(catalog_src.average[index_dst].D - D); + // DROP catalog_src.measure[m].dR = 3600.0*(catalog_src.average[index_dst].R - R); + // DROP catalog_src.measure[m].dD = 3600.0*(catalog_src.average[index_dst].D - D); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_objects.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_objects.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_objects.c (revision 37067) @@ -40,4 +40,6 @@ snprintf (hostfile, 1024, "%s/%s.cpt", hostpath, skylist[0].regions[i]->name); catalog.filename = hostID ? hostfile : skylist[0].filename[i]; + + // set up the basic catalog info catalog.catformat = dvo_catalog_catformat (CATFORMAT); // set the default catformat from config data catalog.catmode = dvo_catalog_catmode (CATMODE); // set the default catmode from config data @@ -144,5 +146,4 @@ // PM_TOOFEW // SRC_MEAS_TOOFEW - // FIT_TARGET char command[1024]; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_parallel_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_parallel_images.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_parallel_images.c (revision 37067) @@ -0,0 +1,132 @@ +# include "relastro.h" + +/* This function is essentially identical to relastro_images, except: + + * load the subset images saved by the master node + * distinguish detections we own (touch our images) and those we don't + * distinguish objects we own (in region) and those we don't + * update the unowned detections for owned objects from neighbor regions + * update the unowned objects for owned detections + */ + +int relastro_parallel_images () { + + int i, Ncatalog; + Catalog *catalog = NULL; + + INITTIME; + + // load the RegionTable (UserRegion should not be used at this level) + RegionHostTable *regionHosts = RegionHostTableLoad (CATDIR, REGION_FILE); + int myHost = regionHosts->index[REGION_HOST_ID]; + RegionHostFindNeighbors (regionHosts, myHost); + + // load the subset images belonging to this host + off_t Nimage; + Image *image = ImageTableLoad (IMAGE_TABLE, &Nimage); + if (!image) { + fprintf (stderr, "ERROR loading image %s\n", IMAGE_TABLE); + exit (2); + } + + // once we have read this table, we should remove it for repeat runs + // unlink (IMAGE_TABLE); // XXX a bit risky, add some protection? + + // XXX need to deal with mosaic vs image... + initMosaics (image, Nimage); + + initImages (image, NULL, Nimage); + + SkyTable *sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, TRUE, SKY_DEPTH, VERBOSE); + SkyTableSetFilenames (sky, CATDIR, "cpt"); + SkyList *skylist = SkyListByBounds (sky, -1, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax); + + initCoords(); + + /* load catalog data from region files (hostID is 0 since we are not a client */ + char *syncfile = make_filename (CATDIR, regionHosts->hosts[myHost].hostname, REGION_HOST_ID, "loadcat.sync"); + catalog = load_catalogs (skylist, &Ncatalog, TRUE, 0, NULL, syncfile); + MARKTIME("-- load catalog data: %f sec\n", dtime); + free (syncfile); + + if (photcodesReset) { + photcodesKeep = photcodesReset; + NphotcodesKeep = NphotcodesReset; + } + + // generate tables go from catID,objID -> catSeq,objSeq + indexCatalogs (catalog, Ncatalog); + + /* match measurements with images, mosaics */ + initImageBins (catalog, Ncatalog, TRUE); + MARKTIME("-- make image bins: %f sec\n", dtime); + + findImages (catalog, Ncatalog, TRUE); + MARKTIME("-- set up image indexes: %f sec\n", dtime); + + // set test points based on the starmap + createStarMap (catalog, Ncatalog); + + markObjects (catalog, Ncatalog); + + SAVEPLOT = FALSE; + + /* major modes */ + switch (FIT_TARGET) { + case TARGET_SIMPLE: + for (i = 0; i < NLOOP; i++) { + UpdateObjects (catalog, Ncatalog); + share_mean_pos (catalog, Ncatalog, regionHosts, i); + slurp_mean_pos (catalog, Ncatalog, regionHosts, i); + UpdateSimple (catalog, Ncatalog); + share_image_pos (regionHosts, i); + slurp_image_pos (regionHosts, i); + } + break; + + case TARGET_CHIPS: + for (i = 0; i < NLOOP; i++) { + UpdateObjects (catalog, Ncatalog); + share_mean_pos (catalog, Ncatalog, regionHosts, i); + slurp_mean_pos (catalog, Ncatalog, regionHosts, i); + UpdateChips (catalog, Ncatalog); + share_image_pos (regionHosts, i); + slurp_image_pos (regionHosts, i); + MARKTIME("update chips: %f sec\n", dtime); + } + // create summary plots of the process + // relastroVisualSummaryChips(); + break; + + case TARGET_MOSAICS: + for (i = 0; i < NLOOP; i++) { + UpdateObjects (catalog, Ncatalog); + share_mean_pos (catalog, Ncatalog, regionHosts, i); + slurp_mean_pos (catalog, Ncatalog, regionHosts, i); + UpdateMosaic (catalog, Ncatalog); + share_image_pos (regionHosts, i); + slurp_image_pos (regionHosts, i); + } + break; + + default: + fprintf (stderr, "programming error at %s:%d", __FILE__, __LINE__); + exit (2); + } + + // this is a checkpoint to make sure all hosts have finished the loop above + char *loopsyncfile = make_filename (CATDIR, regionHosts->hosts[myHost].hostname, REGION_HOST_ID, "loop.sync"); + update_sync_file (loopsyncfile, 0); + free (loopsyncfile); + + for (i = 0; i < regionHosts->Nhosts; i++) { + if (regionHosts->hosts[i].hostID == REGION_HOST_ID) continue; + char *loopsync = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "loop.sync"); + check_sync_file (loopsync, 0); + free (loopsync); + } + + share_image_pos (regionHosts, -1); + + exit (0); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_parallel_regions.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_parallel_regions.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_parallel_regions.c (revision 37067) @@ -0,0 +1,79 @@ +# include "relastro.h" + +int relastro_parallel_regions () { + + int status; + FITS_DB db; + + INITTIME; + + // load the RegionTable (UserRegion should not be used at this level) + RegionHostTable *regionHosts = RegionHostTableLoad (CATDIR, REGION_FILE); + if (!regionHosts) { + fprintf (stderr, "ERROR: problem with region host table\n"); + exit (2); + } + + // register database handle with shutdown procedure + set_db (&db); + db.mode = dvo_catalog_catmode (CATMODE); + db.format = dvo_catalog_catformat (CATFORMAT); + + // lock and load the image db table + status = dvo_image_lock (&db, ImageCat, 60.0, (UPDATE ? LCK_XCLD : LCK_SOFT)); + if (!status && UPDATE) { + fprintf (stderr, "error\n"); + Shutdown ("ERROR: failure to lock image catalog %s", db.filename); + } + + if ((db.dbstate == LCK_EMPTY) || (db.dbstate == LCK_MISSING)) { + // if the Image.dat file is missing, db.dbstate will have a value of either: + // LCK_EMPTY (if UPDATE) or LCK_MISSING (if !UPDATE) + Shutdown ("ERROR: database %s contains no image data", CATDIR); + } + + // read data from Image.dat file + if (!dvo_image_load (&db, VERBOSE, FALSE)) Shutdown ("can't read image catalog %s", db.filename); + MARKTIME("-- load image data: %f sec\n", dtime); + + /* assign the images to the different region hosts */ + if (!assign_images (&db, regionHosts)) Shutdown ("error assigning images to region hosts"); + MARKTIME("-- assign images: %f sec\n", dtime); + + /* launch processing on the parallel region hosts */ + if (!launch_region_hosts (regionHosts)) Shutdown ("error launching region hosts"); + + // retrieve updated image parameters from the remote hosts (also set Image.mcal) + if (!slurp_image_pos (regionHosts, -1)) Shutdown ("error loading image updates"); + + if (!UPDATE) { + dvo_image_unlock (&db); + MARKTIME ("finished relastro -parallel-regions: %f sec total\n", dtime); + fprintf (stderr, "NOTE: UPDATE is OFF (results are not saved)\n"); + exit (0); + } + + SkyTable *sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, TRUE, SKY_DEPTH, VERBOSE); + SkyTableSetFilenames (sky, CATDIR, "cpt"); + SkyList *skylist = SkyListByBounds (sky, -1, regionHosts->Rmin, regionHosts->Rmax, regionHosts->Dmin, regionHosts->Dmax); + + if (PARALLEL) { + // save the updated image parameters + dvo_image_save (&db, VERBOSE); + dvo_image_unlock (&db); + } + + // iterate over catalogs to make detection coordinates consistant + UpdateObjectOffsets (skylist, 0, NULL); + + if (!PARALLEL) { + // save the changes to the image parameters + dvo_image_save (&db, VERBOSE); + dvo_image_unlock (&db); + } + + MARKTIME ("finished relastro -parallel-regions: %f sec total\n", dtime); + + exit (0); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/resort_catalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/resort_catalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/resort_catalog.c (revision 37067) @@ -30,6 +30,5 @@ if (catalog[0].sorted == TRUE) return; - // struct timeval start, stop; - // gettimeofday (&start, NULL); + // INITTIME; /* internal counters */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/select_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/select_images.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/select_images.c (revision 37067) @@ -15,10 +15,4 @@ void dsortindex (double *X, off_t *Y, int N); off_t getRegionStartByRA (double R, double *Rref, off_t Nregions); - -# define MARKTIME(MSG,...) { \ - float dtime; \ - gettimeofday (&stop, (void *) NULL); \ - dtime = DTIME (stop, start); \ - fprintf (stderr, MSG, __VA_ARGS__); } Image *select_images (SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage, int UseFullOverlap) { @@ -31,5 +25,4 @@ Coords tcoords; SkyRegionCoords *skycoords; - struct timeval start, stop; double RmaxSkyRegion, RminSkyRegion, RmidSkyRegion, DminSkyRegion, DmaxSkyRegion; @@ -50,5 +43,5 @@ } - gettimeofday (&start, (void *) NULL); + INITTIME; // the comparison is made in the catalog local projection. below we set crval1,2 @@ -57,5 +50,5 @@ tcoords.pc1_1 = tcoords.pc2_2 = 1.0; tcoords.pc1_2 = tcoords.pc2_1 = 0.0; - strcpy (tcoords.ctype, "RA---TAN"); + strcpy (tcoords.ctype, "DEC--TAN"); ALLOCATE (skycoords, SkyRegionCoords, skylist[0].Nregions); @@ -132,5 +125,6 @@ if (NphotcodesKeep > 0) { found = FALSE; - // XXX this bit of code excludes DIS mosaics and should be fixed + // we have to keep DIS mosaics explicitly (photcode = 0) + if (!strcmp(&timage[i].coords.ctype[4], "-DIS")) found = TRUE; for (k = 0; (k < NphotcodesKeep) && !found; k++) { if (photcodesKeep[k][0].code == timage[i].photcode) found = TRUE; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/share_images_pos.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/share_images_pos.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/share_images_pos.c (revision 37067) @@ -0,0 +1,117 @@ +# include "relastro.h" + +// we are sharing image astrometry calibrations for all images which (a) I own and (b) which have unowned detections + +# define D_NIMAGEPOS 1000 +int share_image_pos (RegionHostTable *regionHosts, int nloop) { + + off_t i, Nimages; + Image *images = getimages (&Nimages, NULL); + + off_t Nimage_pos = 0; + off_t NIMAGE_POS = D_NIMAGEPOS; + + ImagePos *image_pos = NULL; + ALLOCATE (image_pos, ImagePos, NIMAGE_POS); + + for (i = 0; i < Nimages; i++) { + // XXX does this image have missing detections (does someone else need it?) + // XXX : NOTE NEED TO FIX THIS: if (imageExtra[i].Nmiss == 0) continue; + + set_image_pos (&image_pos[Nimage_pos], &images[i]); + Nimage_pos ++; + + CHECK_REALLOCATE (image_pos, ImagePos, NIMAGE_POS, Nimage_pos, D_NIMAGEPOS); + } + + // write out the image_mag fits table AND write state in some file + int myHost = regionHosts->index[REGION_HOST_ID]; + char *hostname = regionHosts->hosts[myHost].hostname; + + char *iposfile = make_filename (CATDIR, hostname, REGION_HOST_ID, "imagepos.fits"); + ImagePosSave (iposfile, image_pos, Nimage_pos); + free (image_pos); + free (iposfile); + + char *syncfile = make_filename (CATDIR, hostname, REGION_HOST_ID, "imagepos.sync"); + update_sync_file (syncfile, nloop); + free (syncfile); + + return TRUE; +} + +int slurp_image_pos (RegionHostTable *regionHosts, int nloop) { + + off_t Nimage, i; + Image *images = getimages (&Nimage, NULL); + + int Nimage_pos = 0; + ImagePos *image_pos = NULL; + ALLOCATE (image_pos, ImagePos, 1); + + fprintf (stderr, "grabbing image mags from other hosts...\n"); + + for (i = 0; i < regionHosts->Nhosts; i++) { + if (regionHosts->hosts[i].hostID == REGION_HOST_ID) continue; + if (REGION_HOST_ID && !regionHosts->hosts[i].isNeighbor) continue; + + char *syncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagepos.sync"); + check_sync_file (syncfile, nloop); + free (syncfile); + + off_t Nsubset; + char *iposfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagepos.fits"); + ImagePos *image_pos_subset = ImagePosLoad (iposfile, &Nsubset); + free (iposfile); + + image_pos = merge_image_pos (image_pos, &Nimage_pos, image_pos_subset, Nsubset); + } + + for (i = 0; i < Nimage_pos; i++) { + off_t seq = getImageByID (image_pos[i].imageID); + if (seq < 0) { + // XXX is this a problem? (no, other hosts don't know which images I own) + continue; + } + images[seq].coords = image_pos[i].coords ; + images[seq].dXpixSys = image_pos[i].dXpixSys ; + images[seq].dYpixSys = image_pos[i].dYpixSys ; + images[seq].imageID = image_pos[i].imageID ; + images[seq].nFitAstrom = image_pos[i].nFitAstrom; + images[seq].flags = image_pos[i].flags ; + } + free (image_pos); + + fprintf (stderr, "DONE grabbing image mags from other hosts\n"); + + return TRUE; +} + +int set_image_pos (ImagePos *image_pos, Image *image) { + + image_pos->coords = image->coords; + image_pos->dXpixSys = image->dXpixSys; + image_pos->dYpixSys = image->dYpixSys; + image_pos->imageID = image->imageID; + image_pos->nFitAstrom = image->nFitAstrom; + image_pos->flags = image->flags; + + return TRUE; +} + +ImagePos *merge_image_pos (ImagePos *target, int *ntarget, ImagePos *source, int Nsource) { + + off_t i; + + REALLOCATE (target, ImagePos, *ntarget + Nsource); + for (i = 0; i < Nsource; i++) { + off_t n = i + *ntarget; + target[n] = source[i]; + } + + free (source); + + *ntarget += Nsource; + return (target); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/share_mean_pos.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/share_mean_pos.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/share_mean_pos.c (revision 37067) @@ -0,0 +1,132 @@ +# include "relastro.h" +// we are sharing mean positions for all objects which (a) I own and (b) which have unowned detections + +# define D_NMEANPOS 10000 +int share_mean_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop) { + + int i; + off_t j; + + off_t Nmeanpos = 0; + off_t NMEANPOS = D_NMEANPOS; + + MeanPos *meanpos = NULL; + ALLOCATE (meanpos, MeanPos, NMEANPOS); + + int myHost = regionHosts->index[REGION_HOST_ID]; + double Rmin = regionHosts->hosts[myHost].Rmin; + double Rmax = regionHosts->hosts[myHost].Rmax; + double Dmin = regionHosts->hosts[myHost].Dmin; + double Dmax = regionHosts->hosts[myHost].Dmax; + + // XXX skip some catalogs based on UserPatch? + for (i = 0; i < Ncatalog; i++) { + for (j = 0; j < catalog[i].Naverage; j++) { + + // do I own this object? (in region range?) --- CAREFUL HERE!! + if (catalog[i].average[j].R < Rmin) continue; + if (catalog[i].average[j].R >= Rmax) continue; + if (catalog[i].average[j].D < Dmin) continue; + if (catalog[i].average[j].D >= Dmax) continue; + + // does this object have missing detections (does someone else need it?) + // XXX : sky objects without missing detections + // XXX watch out for detections which are not associated with an image (REF) + if (catalog[i].nOwn_t[j] == catalog[i].average[j].Nmeasure) continue; + + set_mean_pos (&meanpos[Nmeanpos], &catalog[i].average[j]); + Nmeanpos ++; + CHECK_REALLOCATE (meanpos, MeanPos, NMEANPOS, Nmeanpos, D_NMEANPOS); + } + } + + // write out the meanmag fits table AND write state in some file + char *hostname = regionHosts->hosts[myHost].hostname; + + char *posfile = make_filename (CATDIR, hostname, REGION_HOST_ID, "meanpos.fits"); + MeanPosSave (posfile, meanpos, Nmeanpos); + free (meanpos); + free (posfile); + + char *syncfile = make_filename (CATDIR, hostname, REGION_HOST_ID, "meanpos.sync"); + update_sync_file (syncfile, nloop); + free (syncfile); + + return TRUE; +} + +int slurp_mean_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop) { + + off_t i; + + int Nmeanpos = 0; + MeanPos *meanpos = NULL; + ALLOCATE (meanpos, MeanPos, 1); + + fprintf (stderr, "grabbing mean object pos from other hosts...\n"); + + for (i = 0; i < regionHosts->Nhosts; i++) { + if (regionHosts->hosts[i].hostID == REGION_HOST_ID) continue; + if (REGION_HOST_ID && !regionHosts->hosts[i].isNeighbor) continue; + + char *syncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanpos.sync"); + check_sync_file (syncfile, nloop); + free (syncfile); + + off_t Nsubset = 0; + char *posfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanpos.fits"); + MeanPos *meanposSubset = MeanPosLoad (posfile, &Nsubset); + free (posfile); + + // merge_mean_pos reallocs meanpos and frees the input meanposSubset + meanpos = merge_mean_pos (meanpos, &Nmeanpos, meanposSubset, Nsubset); + } + + for (i = 0; i < Nmeanpos; i++) { + int objID = meanpos[i].objID; + int catID = meanpos[i].catID; + + // set the mean mag + int catSeq; + off_t objSeq; + if (!catID_and_objID_to_seq (catID, objID, &catSeq, &objSeq)) { + // XXX what should I do if this does not match? + continue; + } + + catalog[catSeq].average[objSeq].R = meanpos[i].R; + catalog[catSeq].average[objSeq].D = meanpos[i].D; + } + free (meanpos); + + fprintf (stderr, "DONE grabbing mean object pos from other hosts...\n"); + + return TRUE; +} + +int set_mean_pos (MeanPos *meanpos, Average *average) { + + meanpos->R = average->R; + meanpos->D = average->D; + meanpos->objID = average->objID; + meanpos->catID = average->catID; + + return TRUE; +} + +MeanPos *merge_mean_pos (MeanPos *target, int *ntarget, MeanPos *source, int Nsource) { + + off_t i; + + REALLOCATE (target, MeanPos, *ntarget + Nsource); + for (i = 0; i < Nsource; i++) { + off_t n = i + *ntarget; + target[n] = source[i]; + } + + free (source); + + *ntarget += Nsource; + return (target); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/syncfile.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/syncfile.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/syncfile.c (revision 37067) @@ -0,0 +1,77 @@ +# include "relastro.h" +# define MSG_LENGTH 12 + +char *make_filename (char *dirname, char *hostname, int hostID, char *tailname) { + + char tmp[10], *line; + int Nchar = snprintf (tmp, 0, "%s/%s.%03d.%s", dirname, hostname, hostID, tailname); + + ALLOCATE (line, char, Nchar + 1); + snprintf (line, Nchar + 1, "%s/%s.%03d.%s", dirname, hostname, hostID, tailname); + + return line; +} + +int check_sync_file (char *filename, int nloop) { + + char message[MSG_LENGTH]; + + FILE *f = NULL; + + while (TRUE) { + + f = fopen (filename, "r"); + if (!f) { + usleep (2000000); + continue; + } + + // XXX MSG_LENGTH : 0 EOL byte? + int Nread = fread (message, 1, MSG_LENGTH, f); + if (Nread < MSG_LENGTH) { + fclose (f); + usleep (2000000); + continue; + } + fclose (f); + + // message is of the form: NLOOP: %03d + int loop; + sscanf (message, "%*s %d", &loop); + if (loop != nloop) { + usleep (2000000); + continue; + } + return TRUE; + } + return FALSE; +} + +int clear_sync_file (char *filename) { + // delete file contents + if (truncate (filename, 0)) fprintf (stderr, "trouble clearing file %s\n", filename); + + return TRUE; +} + +int update_sync_file (char *filename, int nloop) { + + char message[MSG_LENGTH]; + + FILE *f = fopen (filename, "w"); + if (!f) { + fprintf (stderr, "failure to open sync file for write\n"); + exit (4); + } + + snprintf (message, MSG_LENGTH, "NLOOP: %03d\n", nloop); + + int Nwrite = fwrite (message, 1, MSG_LENGTH, f); + if (Nwrite != MSG_LENGTH) { + fprintf (stderr, "failure to write sync message\n"); + exit (3); + } + + fclose (f); + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/testparallax.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/testparallax.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/testparallax.c (revision 37067) @@ -57,5 +57,5 @@ coords.pc1_2 = coords.pc2_1 = 0.0; coords.Npolyterms = 1; - strcpy (coords.ctype, "RA---SIN"); + strcpy (coords.ctype, "DEC--SIN"); // use one point as a local reference Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/Makefile (revision 37067) @@ -34,4 +34,5 @@ $(SRC)/args.$(ARCH).o \ $(SRC)/help.$(ARCH).o \ +$(SRC)/extra.$(ARCH).o \ $(SRC)/bcatalog.$(ARCH).o \ $(SRC)/global_stats.$(ARCH).o \ @@ -47,5 +48,16 @@ $(SRC)/relphot_images.$(ARCH).o \ $(SRC)/relphot_objects.$(ARCH).o \ +$(SRC)/relphot_parallel_regions.$(ARCH).o \ +$(SRC)/relphot_parallel_images.$(ARCH).o \ $(SRC)/select_images.$(ARCH).o \ +$(SRC)/assign_images.$(ARCH).o \ +$(SRC)/launch_region_hosts.$(ARCH).o \ +$(SRC)/ImageTable.$(ARCH).o \ +$(SRC)/ImageMagIO.$(ARCH).o \ +$(SRC)/syncfile.$(ARCH).o \ +$(SRC)/share_image_mags.$(ARCH).o \ +$(SRC)/share_mean_mags.$(ARCH).o \ +$(SRC)/MeanMagIO.$(ARCH).o \ +$(SRC)/indexCatalog.$(ARCH).o \ $(SRC)/client_logger.$(ARCH).o \ $(SRC)/setExclusions.$(ARCH).o \ @@ -71,8 +83,10 @@ $(SRC)/args.$(ARCH).o \ $(SRC)/help.$(ARCH).o \ +$(SRC)/extra.$(ARCH).o \ $(SRC)/synthetic_mags.$(ARCH).o \ $(SRC)/plotstuff.$(ARCH).o \ $(SRC)/liststats.$(ARCH).o \ $(SRC)/initialize.$(ARCH).o \ +$(SRC)/syncfile.$(ARCH).o \ $(SRC)/load_catalogs.$(ARCH).o \ $(SRC)/reload_catalogs.$(ARCH).o \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/mosaic.txt =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/mosaic.txt (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/mosaic.txt (revision 37067) @@ -1,2 +1,26 @@ + + +2014.07.09 + +* trying to make sense of mosaic.Mcal vs image.Mcal in the context of UBERCAL: + + * relphot_images: + * load_images (convert raw FITS table to Image structure, select subset matching selection) + * initMosaics (associate mosaics to images (gpc1 photcodes only)) + * initMosaicGrid (define spatial range of mosaics [only used by grid analysis]; set Mcal to and image.Mcal to 0.0) + --- calculate image or mosaic Mcal values + * setMcalFinal (set image.Mcal = mosaicMcal) + + * relphot_parallel_regions: + * assign_images + * makeMosaics (equivalent to initMosaics, but works on full image table, not subset) + * setMosaicCenters (set Mcal to and image.Mcal to 0.0) <--- this is wrong! + (sends images ONLY, not mosaics, to remote machines) + (slurps back new image values, applies to db) + + * relphot_parallel_images: + * makeMosaics (associate mosaics to images, gpc1 photcodes only) + * initMosaicGrid (needed in this one) +--- For 'mosaic' zero points, I define the mosaics by grouping the images Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/parallel.txt =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/parallel.txt (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/parallel.txt (revision 37067) @@ -1,2 +1,71 @@ + +2014.02.15 + +Nearly done with the relphot mods. some outstanding questions; + + * image vs mosaic? + * how do decide which images need to be shared? + +2014.02.14 + + more relphot notes: + + * I load the catalogs, with a + +2014.02.12 + +I am making progess on the relphot -parallel-regions implementation. some things I need to deal with: + + * assign_images: select mosaics for all images saved for a given host (need to supply them as well) + ** I need to decide on the Image / Mosaic split. If I am calibrating by image, then the image center defines ownership + ** if I am calibrating by exposure, then the mosaic center must define ownership + o determine SkyList covering the images for region host + o tag detections and objects which I own or do not own + o ImageOps.c / matchImage matches detections to images and needs to handle mine / not mine cases + o ditto for matchMosaics + o load_catalogs : I need to make my requested catalogs unique (just add uniquer to load_catalogs.c:130 + o figure out what fields I'm saving in meanmags and how to construct it + -- mag, objID, catID, photcode, (dmag or other stats?) + * from which hosts do I slurp mean mags? + o function to merge a new meanmag array into the existing one + o how to go from (objID,catID) to a given catalog[i].average[j] + +2014.02.06 + +** a single region-level host owns images for which the center lands + in its region. + +** it owns detections which come from images which it owns + +** it owns objects which land in its region + +Extending parallel relphot processing to split the sky (and images) +into regions, each of which runs in parallel at the same time: + +Top Level (relphot -parallel-images): + * define regions of the sky -> hosts + * load images, assign to hosts + * launch region-level jobs on remote hosts + + Region Level (relphot -parallel-images-region) + * load my image subset table + * request objects and detections for my skyregion + * match images & objects, etc + + * update my image parameters + * update my detections + * write out detections + * load detections from my border hosts + * match to my objects + * update my objects + * write out objects + * load objects from my border hosts + * update images + (iterate N times) + * write out image parameters + +Top Level + * read image parameters, update + * update objects 2012.02.13 Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/pv2.txt =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/pv2.txt (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/pv2.txt (revision 37067) @@ -0,0 +1,53 @@ + +2014.07.03 + +NOTE: 2 questions on these measurements: chisq and ubercal dist? + +I think I have worked out all of the issues in the mag / flux +calibrations for stacks and forced warps. It took me a few passes to +get the right combinations of the 3.56 or the 8.9 offset to the mags. +But now, the stack psf mags, warp psf mags, stack flux, warp flux, and +mean psf mags all agree at the 0.1 mmag level. + +I still have some concerns regarding the flags and astrometry. I am +not set on my laptop to test the primary cell stuff (well, I could +probably reproduce it, but easier to wait until I'm home). I need to +review the 'waterfall' and check that the choices make sense (and +write it down for review). + +2014.07.02 + +I am trying to run a (rather artificial) test of relphot +specifically, I have taken a single smf and an associated warp cmf and +modified the headers so I can load them in DVO and run relphot. Some +issues I've hit: + +* needed to specify PHOTCODE for the stack and fforce fake cmfs +* needed to modify IMAGEID and MJD-OBS so the chips associated + correctly with different gpc1 images +* modified relphot/MosaicOps.c to explicitly skip stack and warp by + photcode when matching chips into mosaics (kind of a hack as it + won't work with other cameras) + +2014.07.01 + +thinking about the issues with relphot for the new PV2 / PV3 schema. +I now have 3 separate sets of mean photometry for each of the stages +cam/staticsky/warp. I need to make sure I am handling everthing +needed. + +Calibration sequence: + +* relphot_images / relphot_parallel_images : calculate the zero points + +Loop around with the standard sequence, but only fitting for the mean +camera mags and camera zero points. At the end of the iteration, fit +the stacks and warps to the new mean object mags. + +Some things I've started to worry about: + +1) QSOs & other variables. Am I detecting and avoiding these well +enough? + +2) what is the appropriate ubercal weight (10, 100, 1000?) + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/include/relphot.h =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/include/relphot.h (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/include/relphot.h (revision 37067) @@ -5,13 +5,4 @@ # include -# define MARKTIME(MSG,...) { \ - gettimeofday (&stopTimer, (void *) NULL); \ - float dtime = DTIME (stopTimer, startTimer); \ - fprintf (stderr, MSG, __VA_ARGS__); } - -# define INITTIME \ - struct timeval startTimer, stopTimer; \ - gettimeofday (&startTimer, (void *) NULL); - /* # define GRID_V1 */ # define GRID_V2 @@ -23,4 +14,13 @@ // # define IDX_T off_t # define IDX_T int + +typedef enum { + MODE_ERROR = 0, + UPDATE_IMAGES, + UPDATE_AVERAGES, + PARALLEL_REGIONS, + PARALLEL_IMAGES, + APPLY_OFFSETS, +} RelphotMode; typedef enum { @@ -86,10 +86,15 @@ // others are only used on the final output steps. - double *list; // list of measure.mag values for a given star - double *dlist; // mag errors for a star - double *wlist; // weights to use for mean mags - double *aplist; // ap mags for a star - double *kronlist; // kron mags for a star + double *Mpsflist; // list of measure.mag values for a given star + double *dpsflist; // mag errors for a star + double *wpsflist; // weights to use for mean mags + + double *Maplist; // ap mags for a star + double *daplist; // ap mags for a star + double *waplist; // ap mags for a star + + double *Mkronlist; // kron mags for a star double *dkronlist; // kron mag errors + double *wkronlist; // kron mag errors double *psfqf_list; // psfqf for all filters @@ -97,8 +102,29 @@ double *stargal_list; // stargal for all filters - StatType stats; + StatType psfstats; StatType apstats; StatType kronstats; } SetMrelInfo; + +typedef struct { + float M; + float dM; + float Mchisq; + int Nsec; + unsigned int objID; + unsigned int catID; + int photcode; +} MeanMag; + +typedef struct { + float Mcal; + float dMcal; + float dMagSys; + short Xm; + int nFitPhotom; + int flags; + unsigned int imageID; + short ubercalDist; +} ImageMag; typedef struct { @@ -116,4 +142,5 @@ unsigned int photom_map_id; unsigned int flags; + int tessID; int projID; int skycellID; @@ -149,4 +176,9 @@ int SKY_DEPTH; /** XXX EAM : depth of catalog tables, fix usage */ +// globals for parallel region operations +char *REGION_FILE; +char *IMAGE_TABLE; +int REGION_HOST_ID; + int HOST_ID; char *HOSTDIR; @@ -173,4 +205,6 @@ int PARALLEL_MANUAL; int PARALLEL_SERIAL; + +int PARALLEL_REGIONS_MANUAL; int NTHREADS; @@ -260,5 +294,5 @@ void InterpolateGrid PROTO((float *buffer, int Nx, int Ny, Coords *ccd, Coords *gcoords)); off_t *SelectRefMosaic PROTO((Mosaic **refmosaic, off_t *Nimage)); -int args PROTO((int argc, char **argv)); +RelphotMode args PROTO((int argc, char **argv)); int args_client PROTO((int argc, char **argv)); int bcatalog PROTO((Catalog *subcatalog, Catalog *catalog, int Ncat)); @@ -273,4 +307,8 @@ void findImages PROTO((Catalog *catalog, int Ncatalog, int doImageList)); int findMosaics PROTO((Catalog *catalog, int Ncatalog, int doMosaicList)); + +void makeMosaics (Image *image, off_t Nimage, int mergeMcal); +Mosaic *getMosaicForImage (off_t im); +void setMosaicCenters (Image *image, off_t Nimage); void set_db (FITS_DB *in); @@ -309,10 +347,10 @@ void initMosaics PROTO((Image *subset, off_t Nsubset, Image *image, char *inSubset, off_t Nimage)); void initMrel PROTO((Catalog *catalog, int Ncatalog)); -void initialize PROTO((int argc, char **argv)); +RelphotMode initialize PROTO((int argc, char **argv)); void initialize_client PROTO((int argc, char **argv)); void liststats_setmode PROTO((StatType *stats, char *strmode)); int liststats PROTO((double *value, double *dvalue, double *wvalue, int N, StatType *stats)); -Catalog *load_catalogs PROTO((SkyList *skylist, int *Ncatalog, int hostID, char *hostpath)); -Catalog *load_catalogs_parallel PROTO((SkyList *sky, int *Ncatalog)); +Catalog *load_catalogs PROTO((SkyList *skylist, int *Ncatalog, int hostID, char *hostpath, char *syncfile)); +Catalog *load_catalogs_parallel PROTO((SkyList *sky, int *Ncatalog, char *syncfile)); SkyList *load_images PROTO((FITS_DB *db, char *regionName, SkyRegion *region)); @@ -397,13 +435,16 @@ ImageSubset *ImageSubsetLoad(char *filename, off_t *nimage); -int client_logger_init (); +int client_logger_init (char *dirname); int client_logger_message (char *format,...); int MatchImageName (off_t meas, int cat, char *name); -int MatchImageSkycellID (off_t meas, int cat, int myProjectionID, int mySkycellID); - -int load_tree (char *treefile); -int BoundaryTreePrimaryCell (char *primaryCellName, double ra, double dec); -int BoundaryTreePrimaryCellIDs (int *projID, int *skycellID, double ra, double dec); +int MatchImageSkycellID (off_t meas, int cat, int myTessID, int myProjectionID, int mySkycellID); + +int load_tess (char *treefile); +int get_tess_ids (int *tessID, int *projID, int *skycellID, double ra, double dec); +int TessellationIDsByImageName (int *tessID, int *projID, int *skycellID, char *name); + +// int BoundaryTreePrimaryCell (char *primaryCellName, double ra, double dec); +// int BoundaryTreePrimaryCellIDs (int *projID, int *skycellID, double ra, double dec); int print_measure_set_alt (Average *average, SecFilt *secfilt, Measure *measure); @@ -417,2 +458,51 @@ int init_synthetic_mags (); int add_synthetic_mags (AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, off_t *Nmeasure, off_t *Nm); + +int relphot_parallel_regions (); + +int assign_images (FITS_DB *db, RegionHostTable *regionHosts); +int select_images_hostregion (RegionHostTable *hosts, Image *image, off_t Nimage); +int find_host_for_coords (RegionHostTable *regionHosts, double R, double d); +int calculate_image_bounds (Image *image, double *rmin, double *rmax, double *dmin, double *dmax, double Rmid); + +int launch_region_hosts (RegionHostTable *regionHosts); +int strextend (char *input, char *format,...); + +Image *ImageTableLoad(char *filename, off_t *nimage); +int ImageTableSave (char *filename, Image *images, off_t Nimages); + +int indexCatalogs (Catalog *catalog, int Ncatalog); +int catID_and_objID_to_seq (int catID, int objID, int *catSeq, off_t *objSeq); + +int check_sync_file (char *filename, int nloop); +int clear_sync_file (char *filename); +int update_sync_file (char *filename, int nloop); +char *make_filename (char *dirname, char *hostname, int hostID, char *tailname); + +int share_mean_mags (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop); +int slurp_mean_mags (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop); +int set_mean_mags (MeanMag *meanmags, AverageTiny *average, SecFilt *secfilt, int Nsec); +MeanMag *merge_mean_mags (MeanMag *target, int *ntarget, MeanMag *source, int Nsource); + +MeanMag *MeanMagLoad(char *filename, off_t *nmeanmags); +int MeanMagSave(char *filename, MeanMag *meanmags, off_t Nmeanmags); + +int share_image_mags (RegionHostTable *regionHosts, int nloop); +int slurp_image_mags (RegionHostTable *regionHosts, int nloop); +int set_image_mags (ImageMag *image_mags, Image *image); +ImageMag *merge_image_mags (ImageMag *target, int *ntarget, ImageMag *source, int Nsource); + +ImageMag *ImageMagLoad(char *filename, off_t *nimage_mags); +int ImageMagSave(char *filename, ImageMag *image_mags, off_t Nimage_mags); + +int markObjects (Catalog *catalog, int Ncatalog); + +int relphot_parallel_images (); +int relphot_parallel_regions (); + +// in extra.c +int isGPC1chip (int photcode); +int isGPC1stack (int photcode); +int isGPC1warp (int photcode); + + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/BoundaryTreeOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/BoundaryTreeOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/BoundaryTreeOps.c (revision 37067) @@ -1,88 +1,42 @@ # include "relphot.h" -// XXX for the moment, only load one boundary tree at a time -// XXX in fact, only allow RINGS.V3... +static int Ntess = 0; +static TessellationTable *tess = NULL; -static BoundaryTree *tree = NULL; +int TessellationIDsByImageName (int *tessID, int *projID, int *skycellID, char *name) { -int BoundaryTreePrimaryCell (char *primaryCellName, double ra, double dec) { + int i; - int zone, band; - - if (!primaryCellName) return FALSE; - - primaryCellName[0] = 0; - - if (!tree) return FALSE; - - if (!BoundaryTreeCellCoords (tree, &zone, &band, ra, dec)) { - fprintf (stderr, "mismatch!\n"); - return FALSE; - } - -# define USE_PROJECTION_CELL 0 -# if (USE_PROJECTION_CELL) - snprintf (primaryCellName, DVO_MAX_PATH, "RINGS.V3.%s", tree->name[zone][band]); -# else - - // I have ra, dec, and the primary projection cell. In order to choose the primary skycell, - // I just need to project to ra,dec to X,Y based on the center of the cell and then get the subdivision right. - - double x = 0.0; - double y = 0.0; - BoundaryTreeProjection (&x, &y, ra, dec, tree, zone, band); - - int xi = x / tree->dX[zone][band]; - int yi = y / tree->dY[zone][band]; - int N = xi + tree->NX_SUB * yi; - - // XXX short-circuit this for now (we should use this code if we make tree have more variable NX,NY values - // char format[24], skycellname[128]; - // int Ndigit = (int)(log10(tree->NX_SUB*tree->NY_SUB)) + 1 ; - // snprintf (format, 24, "%s.%%0%dd", tree->name[zone][band], Ndigit); - // snprintf (skycellname, 128, format, N); - - snprintf (primaryCellName, DVO_MAX_PATH, "RINGS.V3.%s.%03d", tree->name[zone][band], N); -# endif - - return TRUE; -} - -int BoundaryTreePrimaryCellIDs (int *projID, int *skycellID, double ra, double dec) { - - int zone, band; - + *tessID = -1; *projID = -1; *skycellID = -1; - if (!tree) return FALSE; + if (!tess) return FALSE; - if (!BoundaryTreeCellCoords (tree, &zone, &band, ra, dec)) { - fprintf (stderr, "mismatch!\n"); - return FALSE; + for (i = 0; i < Ntess; i++) { + // do this with a strhash of some kind? + if (!strncmp (name, tess[i].basename, tess[i].Nbasename)) { + *tessID = i; + if (tess[i].projectIDoff >= 0) { + *projID = atoi(&name[tess[i].projectIDoff]); + } else { + *projID = 0; + } + if (tess[i].skycellIDoff >= 0) { + *skycellID = atoi(&name[tess[i].skycellIDoff]); + } else { + *skycellID = 0; + } + return TRUE; + } } - - // I have ra, dec, and the primary projection cell. In order to choose the primary skycell, - // I just need to project to ra,dec to X,Y based on the center of the cell and then get the subdivision right. - - double x = 0.0; - double y = 0.0; - BoundaryTreeProjection (&x, &y, ra, dec, tree, zone, band); - - int xi = x / tree->dX[zone][band]; - int yi = y / tree->dY[zone][band]; - int N = xi + tree->NX_SUB * yi; - - *projID = tree->projID[zone][band]; - *skycellID = N; - - return TRUE; + return FALSE; } -int load_tree (char *treefile) { +int load_tess (char *tessfile) { - tree = BoundaryTreeLoad (treefile); - if (!tree) { - fprintf (stderr, "failed to load boundary tree %s\n", treefile); + tess = TessellationTableLoad (tessfile, &Ntess); + if (!tess) { + fprintf (stderr, "failed to load tessellation boundary file %s\n", tessfile); exit (2); } @@ -90,2 +44,12 @@ return TRUE; } + +int get_tess_ids (int *tessID, int *projID, int *skycellID, double ra, double dec) { + + int status; + + if (!tess) return FALSE; + + status = TessellationPrimaryCellIDs(tess, Ntess, tessID, projID, skycellID, ra, dec); + return status; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/BrightCatalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/BrightCatalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/BrightCatalog.c (revision 37067) @@ -63,6 +63,6 @@ // need to create and assign to flat-field correction - GET_COLUMN(dR, "RA_OFF", float); - GET_COLUMN(dD, "DEC_OFF", float); + GET_COLUMN(R, "RA", double); + GET_COLUMN(D, "DEC", double); GET_COLUMN(M, "MAG_SYS", float); GET_COLUMN(Mcal, "MAG_CAL", float); @@ -85,6 +85,6 @@ ALLOCATE (measure, MeasureTiny, Nrow); for (i = 0; i < Nrow; i++) { - measure[i].dR = dR[i]; - measure[i].dD = dD[i]; + measure[i].R = R[i]; + measure[i].D = D[i]; measure[i].M = M[i]; measure[i].Mcal = Mcal[i]; @@ -101,9 +101,10 @@ measure[i].catID = catID[i]; measure[i].photcode = photcode[i]; + measure[i].myDet = FALSE; } fprintf (stderr, "loaded data for %lld measure\n", (long long) Nrow); - free (dR ); - free (dD ); + free (R ); + free (D ); free (M ); free (Mcal ); @@ -135,10 +136,11 @@ // need to create and assign to flat-field correction - GET_COLUMN(R, "RA", double); - GET_COLUMN(D, "DEC", double); + GET_COLUMN(R, "RA", double); + GET_COLUMN(D, "DEC", double); GET_COLUMN(Nmeasure, "NMEAS", int); GET_COLUMN(measureOffset, "MEASURE_OFF", int); GET_COLUMN(flags, "FLAGS", int); GET_COLUMN(catID, "CAT_ID", int); + GET_COLUMN(objID, "OBJ_ID", int); gfits_free_header (&theader); gfits_free_table (&ftable); @@ -153,4 +155,6 @@ average[i].flags = flags[i]; average[i].catID = catID[i]; + average[i].objID = objID[i]; + average[i].nOwn = 0; } fprintf (stderr, "loaded data for %lld average\n", (long long) Nrow); @@ -162,4 +166,5 @@ free (flags ); free (catID ); + free (objID ); catalog->average = average; @@ -177,12 +182,12 @@ // need to create and assign to flat-field correction - GET_COLUMN(M, "MAG", float); - GET_COLUMN(dM, "MAG_ERR", float); - GET_COLUMN(Xm, "MAG_CHI", float); - GET_COLUMN(flags, "FLAGS", int); - GET_COLUMN(Ncode, "NCODE", short); - GET_COLUMN(Nused, "NUSED", short); - GET_COLUMN(M_20, "MAG_20", short); - GET_COLUMN(M_80, "MAG_80", short); + GET_COLUMN(M, "MAG", float); + GET_COLUMN(dM, "MAG_ERR", float); + GET_COLUMN(Mchisq, "MAG_CHI", float); + GET_COLUMN(flags, "FLAGS", int); + GET_COLUMN(Ncode, "NCODE", short); + GET_COLUMN(Nused, "NUSED", short); + GET_COLUMN(Mmin, "MAG_MIN", float); + GET_COLUMN(Mmax, "MAG_MAX", float); gfits_free_header (&theader); gfits_free_table (&ftable); @@ -191,23 +196,23 @@ ALLOCATE (secfilt, SecFilt, Nrow); for (i = 0; i < Nrow; i++) { - secfilt[i].M = M[i]; - secfilt[i].dM = dM[i]; - secfilt[i].Xm = Xm[i]; - secfilt[i].flags = flags[i]; - secfilt[i].Ncode = Ncode[i]; - secfilt[i].Nused = Nused[i]; - secfilt[i].M_20 = M_20[i]; - secfilt[i].M_80 = M_80[i]; + secfilt[i].M = M[i]; + secfilt[i].dM = dM[i]; + secfilt[i].Mchisq = Mchisq[i]; + secfilt[i].flags = flags[i]; + secfilt[i].Ncode = Ncode[i]; + secfilt[i].Nused = Nused[i]; + secfilt[i].Mmin = Mmin[i]; + secfilt[i].Mmax = Mmax[i]; } fprintf (stderr, "loaded data for %lld secfilt\n", (long long) Nrow); - free (M ); - free (dM ); - free (Xm ); - free (flags); - free (Ncode); - free (Nused); - free (M_20 ); - free (M_80 ); + free (M ); + free (dM ); + free (Mchisq); + free (flags ); + free (Ncode ); + free (Nused ); + free (Mmin ); + free (Mmax ); catalog->secfilt = secfilt; // assert Nsecfilt * Naverage = Nrow? @@ -260,6 +265,6 @@ gfits_create_table_header (&theader, "BINTABLE", "MEASURE_TINY"); - gfits_define_bintable_column (&theader, "E", "RA_OFF", "ra offset", "arcsec", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "DEC_OFF", "dec offset", "arcsec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "RA", "ra", "degree", 1.0, 0.0); + gfits_define_bintable_column (&theader, "D", "DEC", "dec", "degree", 1.0, 0.0); gfits_define_bintable_column (&theader, "E", "MAG_SYS", "magnitude (sys)", NULL, 1.0, 0.0); gfits_define_bintable_column (&theader, "E", "MAG_CAL", "magnitude (cal)", NULL, 1.0, 0.0); @@ -269,11 +274,11 @@ gfits_define_bintable_column (&theader, "E", "Y_CCD", "ccd y coord", "pix", 1.0, 0.0); gfits_define_bintable_column (&theader, "E", "EXPTIME", "-2.5 * log (exposure time)", "sec", 1.0, 0.0); - gfits_define_bintable_column (&theader, "J", "TIME", "time of exp", "sec", 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "AVE_REF", "pointer to average table", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "DB_FLAGS", "flags", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "PHOT_FLAGS", "photflags", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "CAT_ID", "catalog", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "I", "PHOTCODE", "photcode", NULL, 1.0, 1.0*0x80); + gfits_define_bintable_column (&theader, "J", "TIME", "time of exp", "sec", 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "AVE_REF", "pointer to average table", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "DB_FLAGS", "flags", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "PHOT_FLAGS", "photflags", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "CAT_ID", "catalog", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "I", "PHOTCODE", "photcode", NULL, 1.0, FT_BZERO_INT16); // generate the output array that carries the data @@ -281,26 +286,26 @@ // create intermediate storage arrays - float *dR ; ALLOCATE (dR , float, catalog->Nmeasure); - float *dD ; ALLOCATE (dD , float, catalog->Nmeasure); - float *M ; ALLOCATE (M , float, catalog->Nmeasure); - float *Mcal ; ALLOCATE (Mcal , float, catalog->Nmeasure); - float *dM ; ALLOCATE (dM , float, catalog->Nmeasure); - float *airmass ; ALLOCATE (airmass , float, catalog->Nmeasure); - float *Xccd ; ALLOCATE (Xccd , float, catalog->Nmeasure); - float *Yccd ; ALLOCATE (Yccd , float, catalog->Nmeasure); - float *dt ; ALLOCATE (dt , float, catalog->Nmeasure); - int *t ; ALLOCATE (t , int , catalog->Nmeasure); - int *averef ; ALLOCATE (averef , int , catalog->Nmeasure); - int *imageID ; ALLOCATE (imageID , int , catalog->Nmeasure); - int *dbFlags ; ALLOCATE (dbFlags , int , catalog->Nmeasure); - int *photFlags ; ALLOCATE (photFlags, int , catalog->Nmeasure); - int *catID ; ALLOCATE (catID , int , catalog->Nmeasure); - short *photcode ; ALLOCATE (photcode , short, catalog->Nmeasure); + double *R ; ALLOCATE (R , double, catalog->Nmeasure); + double *D ; ALLOCATE (D , double, catalog->Nmeasure); + float *M ; ALLOCATE (M , float, catalog->Nmeasure); + float *Mcal ; ALLOCATE (Mcal , float, catalog->Nmeasure); + float *dM ; ALLOCATE (dM , float, catalog->Nmeasure); + float *airmass ; ALLOCATE (airmass , float, catalog->Nmeasure); + float *Xccd ; ALLOCATE (Xccd , float, catalog->Nmeasure); + float *Yccd ; ALLOCATE (Yccd , float, catalog->Nmeasure); + float *dt ; ALLOCATE (dt , float, catalog->Nmeasure); + int *t ; ALLOCATE (t , int , catalog->Nmeasure); + int *averef ; ALLOCATE (averef , int , catalog->Nmeasure); + int *imageID ; ALLOCATE (imageID , int , catalog->Nmeasure); + int *dbFlags ; ALLOCATE (dbFlags , int , catalog->Nmeasure); + int *photFlags ; ALLOCATE (photFlags, int , catalog->Nmeasure); + int *catID ; ALLOCATE (catID , int , catalog->Nmeasure); + short *photcode ; ALLOCATE (photcode , short, catalog->Nmeasure); // assign the storage arrays MeasureTiny *measure = catalog->measure; for (i = 0; i < catalog->Nmeasure; i++) { - dR[i] = measure[i].dR ; - dD[i] = measure[i].dD ; + R[i] = measure[i].R ; + D[i] = measure[i].D ; M[i] = measure[i].M ; Mcal[i] = measure[i].Mcal ; @@ -320,6 +325,6 @@ // add the columns to the output array - gfits_set_bintable_column (&theader, &ftable, "RA_OFF", dR, catalog->Nmeasure); - gfits_set_bintable_column (&theader, &ftable, "DEC_OFF", dD, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "RA", R, catalog->Nmeasure); + gfits_set_bintable_column (&theader, &ftable, "DEC", D, catalog->Nmeasure); gfits_set_bintable_column (&theader, &ftable, "MAG_SYS", M, catalog->Nmeasure); gfits_set_bintable_column (&theader, &ftable, "MAG_CAL", Mcal, catalog->Nmeasure); @@ -337,6 +342,6 @@ gfits_set_bintable_column (&theader, &ftable, "PHOTCODE", photcode, catalog->Nmeasure); - free (dR ); - free (dD ); + free (R ); + free (D ); free (M ); free (Mcal ); @@ -370,4 +375,5 @@ gfits_define_bintable_column (&theader, "J", "FLAGS", "flags", NULL, 1.0, 0.0); gfits_define_bintable_column (&theader, "J", "CAT_ID", "catalog ref", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "OBJ_ID", "object ref", NULL, 1.0, 0.0); // generate the output array that carries the data @@ -381,4 +387,5 @@ int *flags ; ALLOCATE (flags, int, catalog->Naverage); int *catID ; ALLOCATE (catID, int, catalog->Naverage); + int *objID ; ALLOCATE (objID, int, catalog->Naverage); // assign the storage arrays @@ -391,4 +398,5 @@ flags[i] = average[i].flags; catID[i] = average[i].catID; + objID[i] = average[i].objID; } @@ -400,4 +408,5 @@ gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags, catalog->Naverage); gfits_set_bintable_column (&theader, &ftable, "CAT_ID", catID, catalog->Naverage); + gfits_set_bintable_column (&theader, &ftable, "OBJ_ID", objID, catalog->Naverage); free (R ); @@ -407,4 +416,5 @@ free (flags ); free (catID ); + free (objID ); gfits_fwrite_Theader (f, &theader); @@ -418,12 +428,12 @@ gfits_create_table_header (&theader, "BINTABLE", "SECFILT"); - gfits_define_bintable_column (&theader, "E", "MAG", "ra offset", "arcsec", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "MAG_ERR", "dec offset", "arcsec", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "MAG_CHI", "magnitude (sys)", NULL, 1.0, 0.0); - gfits_define_bintable_column (&theader, "J", "FLAGS", "magnitude (cal)", NULL, 1.0, 0.0); - gfits_define_bintable_column (&theader, "I", "NCODE", "magnitude (err)", NULL, 1.0, 0.0); - gfits_define_bintable_column (&theader, "I", "NUSED", "airmass", NULL, 1.0, 0.0); - gfits_define_bintable_column (&theader, "I", "MAG_20", "ccd x coord", "pix", 1.0, 0.0); - gfits_define_bintable_column (&theader, "I", "MAG_80", "ccd y coord", "pix", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG", "", "arcsec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_ERR", "", "arcsec", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_CHI", "", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "FLAGS", "", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NCODE", "", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "NUSED", "", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_MIN", "min valid mag", "mag", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_MAX", "max valid mag", "mag", 1.0, 0.0); // generate the output array that carries the data @@ -437,42 +447,42 @@ float *M ; ALLOCATE (M , float, Nsec); float *dM ; ALLOCATE (dM , float, Nsec); - float *Xm ; ALLOCATE (Xm , float, Nsec); + float *Mchisq ; ALLOCATE (Mchisq , float, Nsec); int *flags ; ALLOCATE (flags , int, Nsec); short *Ncode ; ALLOCATE (Ncode , short, Nsec); short *Nused ; ALLOCATE (Nused , short, Nsec); - short *M_20 ; ALLOCATE (M_20 , short, Nsec); - short *M_80 ; ALLOCATE (M_80 , short, Nsec); + float *Mmin ; ALLOCATE (Mmin , float, Nsec); + float *Mmax ; ALLOCATE (Mmax , float, Nsec); // assign the storage arrays SecFilt *secfilt = catalog->secfilt; for (i = 0; i < Nsec; i++) { - M [i] = secfilt[i]. M ; - dM [i] = secfilt[i]. dM ; - Xm [i] = secfilt[i]. Xm ; - flags [i] = secfilt[i]. flags ; - Ncode [i] = secfilt[i]. Ncode ; - Nused [i] = secfilt[i]. Nused ; - M_20 [i] = secfilt[i]. M_20 ; - M_80 [i] = secfilt[i]. M_80 ; + M [i] = secfilt[i].M ; + dM [i] = secfilt[i].dM ; + Mchisq[i] = secfilt[i].Mchisq ; + flags [i] = secfilt[i].flags ; + Ncode [i] = secfilt[i].Ncode ; + Nused [i] = secfilt[i].Nused ; + Mmin [i] = secfilt[i].Mmin ; + Mmax [i] = secfilt[i].Mmax ; } // add the columns to the output array - gfits_set_bintable_column (&theader, &ftable, "MAG", M , Nsec); - gfits_set_bintable_column (&theader, &ftable, "MAG_ERR", dM , Nsec); - gfits_set_bintable_column (&theader, &ftable, "MAG_CHI", Xm , Nsec); - gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags, Nsec); - gfits_set_bintable_column (&theader, &ftable, "NCODE", Ncode, Nsec); - gfits_set_bintable_column (&theader, &ftable, "NUSED", Nused, Nsec); - gfits_set_bintable_column (&theader, &ftable, "MAG_20", M_20 , Nsec); - gfits_set_bintable_column (&theader, &ftable, "MAG_80", M_80 , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG", M , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_ERR", dM , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_CHI", Mchisq, Nsec); + gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags , Nsec); + gfits_set_bintable_column (&theader, &ftable, "NCODE", Ncode , Nsec); + gfits_set_bintable_column (&theader, &ftable, "NUSED", Nused , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_MIN", Mmin , Nsec); + gfits_set_bintable_column (&theader, &ftable, "MAG_MAX", Mmax , Nsec); free (M ); free (dM ); - free (Xm ); + free (Mchisq ); free (flags ); free (Ncode ); free (Nused ); - free (M_20 ); - free (M_80 ); + free (Mmin ); + free (Mmax ); gfits_fwrite_Theader (f, &theader); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/GridOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/GridOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/GridOps.c (revision 37067) @@ -414,5 +414,5 @@ // select the color- and airmass-corrected observed magnitude for this star // XXX need to be able to turn off the color-correction until initial average mags are found - Msys = PhotCatTiny (&catalog[c].measureT[m]); + Msys = PhotCatTiny (&catalog[c].measureT[m], MAG_CLASS_PSF); if (isnan(Msys)) { Nsys++; @@ -573,5 +573,5 @@ n = catalog[c].measureT[m].averef; - Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]); + Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF); if (isnan(Msys)) { Nsys++; @@ -651,5 +651,5 @@ n = catalog[c].measureT[m].averef; - Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]); + Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF); xlist[N] = Xmeas[c][m]; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageMagIO.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageMagIO.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageMagIO.c (revision 37067) @@ -0,0 +1,221 @@ +# include "relphot.h" + +# define GET_COLUMN(OUT,NAME,TYPE) \ + TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \ + myAssert (!strcmp(type, #TYPE), "wrong column type"); + +// this is nearly identical to the one in 'uniphot/src' used by setphot / setphot_client. +// Here, we use a handful of different columns (if not, we could move to libdvo) +ImageMag *ImageMagLoad(char *filename, off_t *nimage_mags) { + + int i, Ncol; + off_t Nrow; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + *nimage_mags = 0; + ImageMag *image_mags = NULL; + + FILE *f = fopen (filename, "r"); + if (!f) { + fprintf (stderr, "ERROR: cannot open image subset file %s\n", filename); + return NULL; + } + + /* load in PHU segment (ignore) */ + if (!gfits_fread_header (f, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset header\n"); + fclose (f); + return NULL; + } + if (!gfits_fread_matrix (f, &matrix, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset matrix\n"); + gfits_free_header (&header); + fclose (f); + return NULL; + } + + ftable.header = &theader; + + // load data for this header + if (!gfits_load_header (f, &theader)) { + fclose (f); + return NULL; + } + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftable, FALSE)) { + fclose (f); + return (NULL); + } + fclose (f); + + // we read the entire block of data, then extract the columns, then set the image structure values. + // I free the FITS table data after extracting the colums to avoid having 3 copies in memory. + + char type[16]; + + GET_COLUMN (Mcal, "MCAL", float); + GET_COLUMN (dMcal, "MCAL_ERR", float); + GET_COLUMN (dMagSys, "MCAL_SYSERR", float); + GET_COLUMN (nFitPhotom, "NFIT", int); + GET_COLUMN (flags, "FLAGS", int); + GET_COLUMN (ubercalDist, "UDIST", int); + GET_COLUMN (imageID, "ID", int); + GET_COLUMN (Xm, "CHISQ", short); + + // free the memory associated with the FITS files + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + ALLOCATE (image_mags, ImageMag, Nrow); + for (i = 0; i < Nrow; i++) { + image_mags[i].Mcal = Mcal [i]; + image_mags[i].dMcal = dMcal [i]; + image_mags[i].dMagSys = dMagSys [i]; + image_mags[i].Xm = Xm [i]; + image_mags[i].nFitPhotom = nFitPhotom [i]; + image_mags[i].flags = flags [i]; + image_mags[i].ubercalDist = ubercalDist[i]; + image_mags[i].imageID = imageID [i]; + } + fprintf (stderr, "loaded data for %lld images\n", (long long) Nrow); + + free (Mcal ); + free (dMcal ); + free (dMagSys ); + free (Xm ); + free (nFitPhotom ); + free (flags ); + free (ubercalDist); + free (imageID ); + + *nimage_mags = Nrow; + return image_mags; +} + +// STATUS is value expected for success +# define CHECK_STATUS(STATUS,MSG,...) \ + if (!(STATUS)) { \ + fprintf (stderr, MSG, __VA_ARGS__); \ + return FALSE; \ + } + +int ImageMagSave(char *filename, ImageMag *image_mags, off_t Nimage_mags) { + + int i; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + gfits_init_header (&header); + header.extend = TRUE; + gfits_create_header (&header); + gfits_create_matrix (&header, &matrix); + + gfits_create_table_header (&theader, "BINTABLE", "IMAGE_MAGS"); + + gfits_define_bintable_column (&theader, "E", "MCAL", "cal offset", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MCAL_ERR", "cal error", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MCAL_SYSERR", "systematic error", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "NFIT", "number of fitted stars", "unitless", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "FLAGS", "analysis flags", "unitless", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "UDIST", "distance to ubercal images", "images", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "ID", "image ID", "unitless", 1.0, 0.0); + gfits_define_bintable_column (&theader, "I", "CHISQ", "cal chisq", "unitless", 1.0, FT_BZERO_INT16); + + // generate the output array that carries the data + gfits_create_table (&theader, &ftable); + + float *Mcal ; + float *dMcal ; + float *dMagSys ; + float *Xm ; + int *nFitPhotom ; + int *flags ; + int *ubercalDist ; + int *imageID ; + + // create intermediate storage arrays + ALLOCATE (Mcal , float, Nimage_mags); + ALLOCATE (dMcal , float, Nimage_mags); + ALLOCATE (dMagSys , float, Nimage_mags); + ALLOCATE (Xm , float, Nimage_mags); + ALLOCATE (nFitPhotom , int, Nimage_mags); + ALLOCATE (flags , int, Nimage_mags); + ALLOCATE (ubercalDist , int, Nimage_mags); + ALLOCATE (imageID , int, Nimage_mags); + + // assign the storage arrays + for (i = 0; i < Nimage_mags; i++) { + Mcal [i] = image_mags[i].Mcal ; + dMcal [i] = image_mags[i].dMcal ; + dMagSys [i] = image_mags[i].dMagSys ; + Xm [i] = image_mags[i].Xm ; + nFitPhotom [i] = image_mags[i].nFitPhotom ; + flags [i] = image_mags[i].flags ; + ubercalDist[i] = image_mags[i].ubercalDist; + imageID [i] = image_mags[i].imageID ; + } + + // add the columns to the output array + gfits_set_bintable_column (&theader, &ftable, "MCAL", Mcal , Nimage_mags); + gfits_set_bintable_column (&theader, &ftable, "MCAL_ERR", dMcal , Nimage_mags); + gfits_set_bintable_column (&theader, &ftable, "MCAL_SYSERR", dMagSys , Nimage_mags); + gfits_set_bintable_column (&theader, &ftable, "CHISQ", Xm , Nimage_mags); + gfits_set_bintable_column (&theader, &ftable, "NFIT", nFitPhotom , Nimage_mags); + gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags , Nimage_mags); + gfits_set_bintable_column (&theader, &ftable, "UDIST", ubercalDist, Nimage_mags); + gfits_set_bintable_column (&theader, &ftable, "ID", imageID , Nimage_mags); + + free (Mcal ); + free (dMcal ); + free (dMagSys ); + free (Xm ); + free (nFitPhotom ); + free (flags ); + free (ubercalDist); + free (imageID ); + + FILE *f = fopen (filename, "w"); + if (!f) { + fprintf (stderr, "ERROR: cannot open image_mags file for output %s\n", filename); + return FALSE; + } + + int status; + status = gfits_fwrite_header (f, &header); + CHECK_STATUS (status, "ERROR: cannot write header for image_mags %s\n", filename); + + status = gfits_fwrite_matrix (f, &matrix); + CHECK_STATUS (status, "ERROR: cannot write matrix for image_mags %s\n", filename); + + status = gfits_fwrite_Theader (f, &theader); + CHECK_STATUS (status, "ERROR: cannot write table header for image_mags %s\n", filename); + + status = gfits_fwrite_table (f, &ftable); + CHECK_STATUS (status, "ERROR: cannot write table data for image_mags %s\n", filename); + + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + int fd = fileno (f); + + status = fflush (f); + CHECK_STATUS (!status, "ERROR: cannot flush file image_mags %s\n", filename); + + status = fsync (fd); + CHECK_STATUS (!status, "ERROR: cannot flush file image_mags %s\n", filename); + + status = fclose (f); + CHECK_STATUS (!status, "ERROR: problem closing image_mags file %s\n", filename); + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageOps.c (revision 37067) @@ -48,4 +48,5 @@ // stack image. for now, we generate these ID arrays based on the image names when we load in the image table (initImages). // When we pass data to the remote clients via the ImageSubset, the projID/skycellID values are carried directly in the table. +int *tessID = NULL; int *projectID = NULL; int *skycellID = NULL; @@ -81,4 +82,5 @@ // for stack images, assign projection cell ID and skycell ID based on filenames + ALLOCATE (tessID, int, Nimage); ALLOCATE (projectID, int, Nimage); ALLOCATE (skycellID, int, Nimage); @@ -87,13 +89,14 @@ imageIdx[i] = i; imageIDs[i] = image[i].imageID; + + tessID[i] = -1; projectID[i] = -1; skycellID[i] = -1; - if (!strncmp (image[i].name, "RINGS.V3.skycell", strlen("RINGS.V3.skycell"))) { - projectID[i] = atoi(&image[i].name[17]); - skycellID[i] = atoi(&image[i].name[22]); - } + + TessellationIDsByImageName (&tessID[i], &projectID[i], &skycellID[i], image[i].name); } // sort the image index by the IDs + // XXX does this break the imageID <-> projectID, etc match? llsortpair (imageIDs, imageIdx, Nimage); } @@ -106,4 +109,6 @@ // create full a Image array and save the needed values ALLOCATE (image, Image, N); + + ALLOCATE (tessID, int, N); ALLOCATE (projectID, int, N); ALLOCATE (skycellID, int, N); @@ -118,4 +123,5 @@ image[i].trate = input[i].trate ; image[i].ubercalDist = input[i].ubercalDist ; + tessID[i] = input[i].tessID ; projectID[i] = input[i].projID ; skycellID[i] = input[i].skycellID ; @@ -153,4 +159,5 @@ subset[i].trate = image[i].trate ; subset[i].ubercalDist = image[i].ubercalDist ; + subset[i].tessID = tessID[i]; subset[i].projID = projectID[i]; subset[i].skycellID = skycellID[i]; @@ -237,7 +244,11 @@ int Nmatch = 0; - for (i = 0; i < Ncatalog; i++) { + for (i = 0; i < Ncatalog; i++) { for (j = 0; j < catalog[i].Nmeasure; j++) { + catalog[i].measureT[j].myDet = FALSE; // a detetion is not mine until proven otherwise ecode = GetPhotcodeEquivCodebyCode (catalog[i].measureT[j].photcode); + + // skip measurements which do not match one of the requested photcodes ( + // (do we not already exclude in bcatalog -- maybe needed for reload_objects? found = FALSE; for (Ns = 0; !found && (Ns < Nphotcodes); Ns++) { @@ -245,4 +256,6 @@ } if (!found) continue; + + // if we match one of our images, myDet gets set to TRUE matchImage (catalog, j, i, doImageList); Nmatch ++; @@ -315,4 +328,5 @@ return; } + catalog[cat].measureT[meas].myDet = TRUE; if (USE_GRID) { @@ -461,5 +475,5 @@ // returns image.Mcal - ff(x,y) -int MatchImageSkycellID (off_t meas, int cat, int myProjectionID, int mySkycellID) { +int MatchImageSkycellID (off_t meas, int cat, int myTessID, int myProjectionID, int mySkycellID) { off_t i; @@ -470,7 +484,9 @@ if (i == -1) return FALSE; + if (tessID[i] == -1) return FALSE; if (projectID[i] == -1) return FALSE; if (skycellID[i] == -1) return FALSE; + if (tessID[i] != myTessID) return FALSE; if (projectID[i] != myProjectionID) return FALSE; if (skycellID[i] != mySkycellID) return FALSE; @@ -515,5 +531,5 @@ liststats_setmode (&stats, STATMODE); - if (FREEZE_IMAGES) return; + // FREEZE_IMAGES only applies to mosaic data (eg, gpc1) fprintf (stderr, "limiting negative clouds to %f\n", CLOUD_TOLERANCE); @@ -545,4 +561,6 @@ if (!bad) continue; } + + if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue; // UBERCAL image: if this is an ubercal image, set minUbercalDist to 0: @@ -592,5 +610,5 @@ n = catalog[c].measureT[m].averef; - Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]); + Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF); if (isnan(Msys)) { Nsys++; @@ -679,5 +697,5 @@ double MaxOffset, MaxScatter, MedOffset; - if (FREEZE_IMAGES) return; + // if (FREEZE_IMAGES) return; if (VERBOSE) fprintf (stderr, "marking poor images\n"); @@ -690,4 +708,7 @@ for (i = N = 0; i < Nimage; i++) { if (image[i].flags & IMAGE_BAD) continue; + + if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue; + mlist[N] = image[i].Mcal; slist[N] = image[i].dMcal; @@ -781,5 +802,5 @@ Graphdata graphdata; - if (FREEZE_IMAGES) return; + // if (FREEZE_IMAGES) return; ALLOCATE (xlist, double, Nimage); @@ -794,8 +815,14 @@ float mindMcal = +100.0; float maxdMcal = -100.0; - for (i = 0; i < Nimage; i++) { - Mlist[i] = image[i].Mcal; - dlist[i] = image[i].dMcal; - xlist[i] = image[i].secz; + + int Nplot = 0; + + for (i = 0; i < Nimage; i++) { + + if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue; + + Mlist[Nplot] = image[i].Mcal; + dlist[Nplot] = image[i].dMcal; + xlist[Nplot] = image[i].secz; minAirmass = MIN (image[i].secz, minAirmass); maxAirmass = MAX (image[i].secz, maxAirmass); @@ -804,4 +831,6 @@ mindMcal = MIN (image[i].dMcal, mindMcal); maxdMcal = MAX (image[i].dMcal, maxdMcal); + + Nplot ++; } @@ -836,5 +865,8 @@ for (i = 0; i < NBIN; i++) xlist[i] = 0.00025*i; bzero (Mlist, NBIN*sizeof(double)); - for (i = 0; i < Nimage; i++) { + + for (i = 0; i < Nimage; i++) { + if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue; + bin = image[i].dMcal / 0.00025; bin = MAX (0, MIN (NBIN - 1, bin)); @@ -861,5 +893,7 @@ StatType stats; bzero (&stats, sizeof (StatType)); - if (FREEZE_IMAGES) return (stats); + + // we no longer blindly apply FREEZE_IMAGES to all images, only to mosaics + // if (FREEZE_IMAGES) return (stats); ALLOCATE (list, double, Nimage); @@ -869,4 +903,6 @@ for (i = 0; i < Nimage; i++) { if (image[i].flags & IMAGE_BAD) continue; + + if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue; N = 0; @@ -904,5 +940,5 @@ bzero (&stats, sizeof (StatType)); - if (FREEZE_IMAGES) return (stats); + // if (FREEZE_IMAGES) return (stats); ALLOCATE (list, double, Nimage); @@ -913,4 +949,6 @@ if (image[i].flags & IMAGE_BAD) continue; + + if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue; list[n] = pow (10.0, 0.01*image[i].Xm); @@ -934,5 +972,5 @@ bzero (&stats, sizeof (StatType)); - if (FREEZE_IMAGES) return (stats); + // if (FREEZE_IMAGES) return (stats); ALLOCATE (list, double, Nimage); @@ -943,4 +981,6 @@ if (image[i].flags & IMAGE_BAD) continue; + + if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue; list[n] = image[i].Mcal; @@ -964,5 +1004,5 @@ bzero (&stats, sizeof (StatType)); - if (FREEZE_IMAGES) return (stats); + // if (FREEZE_IMAGES) return (stats); ALLOCATE (list, double, Nimage); @@ -973,4 +1013,6 @@ if (image[i].flags & IMAGE_BAD) continue; + + if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue; list[n] = image[i].dMcal; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageSubset.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageSubset.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageSubset.c (revision 37067) @@ -63,4 +63,5 @@ GET_COLUMN (map, "PHOTOM_MAP", int); GET_COLUMN (flags, "FLAGS", int); + GET_COLUMN (tessID, "TESS_ID", int); GET_COLUMN (projID, "PROJ_ID", int); GET_COLUMN (skycellID, "SKYCELL_ID", int); @@ -78,4 +79,5 @@ image[i].photom_map_id = map[i]; image[i].flags = flags[i]; + image[i].tessID = tessID[i]; image[i].projID = projID[i]; image[i].skycellID = skycellID[i]; @@ -91,4 +93,5 @@ free (map); free (flags); + free (tessID); free (projID); free (skycellID); @@ -123,18 +126,15 @@ gfits_create_table_header (&theader, "BINTABLE", "IMAGE_SUBSET"); - gfits_define_bintable_column (&theader, "E", "MCAL", "zero point offset", "magnitudes", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "MCAL_ERR", "zero point error", "magnitudes", 1.0, 0.0); - - gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "PHOTOM_MAP", "map", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "FLAGS", "flags", NULL, 1.0, 1.0*0x8000); - - gfits_define_bintable_column (&theader, "J", "PROJ_ID", "ID", NULL, 1.0, 0.0); - gfits_define_bintable_column (&theader, "J", "SKYCELL_ID", "ID", NULL, 1.0, 0.0); - - gfits_define_bintable_column (&theader, "J", "TZERO", "exposure start", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "I", "TRATE", "tti rate", NULL, 1.0, 0.0); - - gfits_define_bintable_column (&theader, "I", "UBERCAL_DIST", "ubercal distance", NULL, 1.0, 1.0*0x80); + gfits_define_bintable_column (&theader, "E", "MCAL", "zero point offset", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MCAL_ERR", "zero point error", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "PHOTOM_MAP", "map", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "FLAGS", "flags", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "TESS_ID", "ID", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "PROJ_ID", "ID", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "SKYCELL_ID", "ID", NULL, 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "TZERO", "exposure start", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "I", "TRATE", "tti rate", NULL, 1.0, FT_BZERO_INT16); + gfits_define_bintable_column (&theader, "I", "UBERCAL_DIST", "ubercal distance", NULL, 1.0, 0.0); // generate the output array that carries the data @@ -143,14 +143,15 @@ float *Mcal, *dMcal; unsigned int *imageID, *map, *flags, *tzero; - int *projID, *skycellID; + int *tessID, *projID, *skycellID; unsigned short *trate; short *ucdist; // create intermediate storage arrays - ALLOCATE (Mcal, float, Nimage); - ALLOCATE (dMcal, float, Nimage); + ALLOCATE (Mcal, float, Nimage); + ALLOCATE (dMcal, float, Nimage); ALLOCATE (imageID, unsigned int, Nimage); ALLOCATE (map, unsigned int, Nimage); ALLOCATE (flags, unsigned int, Nimage); + ALLOCATE (tessID, int, Nimage); ALLOCATE (projID, int, Nimage); ALLOCATE (skycellID, int, Nimage); @@ -169,4 +170,5 @@ trate[i] = image[i].trate; ucdist[i] = image[i].ubercalDist; + tessID[i] = image[i].tessID; projID[i] = image[i].projID; skycellID[i] = image[i].skycellID; @@ -179,4 +181,5 @@ gfits_set_bintable_column (&theader, &ftable, "PHOTOM_MAP", map, Nimage); gfits_set_bintable_column (&theader, &ftable, "FLAGS", flags, Nimage); + gfits_set_bintable_column (&theader, &ftable, "TESS_ID", tessID, Nimage); gfits_set_bintable_column (&theader, &ftable, "PROJ_ID", projID, Nimage); gfits_set_bintable_column (&theader, &ftable, "SKYCELL_ID", skycellID, Nimage); @@ -190,4 +193,5 @@ free (map); free (flags); + free (tessID); free (projID); free (skycellID); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageTable.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageTable.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageTable.c (revision 37067) @@ -0,0 +1,62 @@ +# include "relphot.h" + +Image *ImageTableLoad(char *filename, off_t *nimage) { + + int status; + off_t Nimage; + FITS_DB db; + + db.mode = dvo_catalog_catmode (CATMODE); + db.format = dvo_catalog_catformat (CATFORMAT); + + /* lock and load the image db table */ + status = dvo_image_lock (&db, filename, 60.0, LCK_SOFT); + if (!status) { + Shutdown ("ERROR: failure to lock image catalog %s", db.filename); + } + + // if the file is missing, db.dbstate will have a value of either: + // LCK_EMPTY (if UPDATE) or LCK_MISSING (if !UPDATE) + if ((db.dbstate == LCK_EMPTY) || (db.dbstate == LCK_MISSING)) { + Shutdown ("ERROR: database %s contains no image data", CATDIR); + } + + // read data from Image.dat file + if (!dvo_image_load (&db, VERBOSE, FALSE)) Shutdown ("can't read image catalog %s", db.filename); + + // convert database table to internal structure (binary to Image) + // 'image' points to the same memory as db->ftable->buffer + Image *image = gfits_table_get_Image (&db.ftable, &Nimage, &db.swapped); + if (!image) { + Shutdown ("ERROR: failed to read images"); + } + + *nimage = Nimage; + return image; +} + +int ImageTableSave (char *filename, Image *images, off_t Nimages) { + + int status; + FITS_DB db; + + // setup image table format and lock + db.mode = dvo_catalog_catmode (CATMODE); + db.format = dvo_catalog_catformat (CATFORMAT); + status = dvo_image_lock (&db, filename, 60.0, LCK_XCLD); // shorter timeout? + if (!status) Shutdown ("ERROR: failure to lock image catalog %s", db.filename); + + // load or create the image table + if (db.dbstate != LCK_EMPTY) { + Shutdown ("image catalog already exists %s", db.filename); + } + + dvo_image_create (&db, GetZeroPoint()); + + /* add the new images and save */ + dvo_image_addrows (&db, images, Nimages); + dvo_image_update (&db, VERBOSE); + dvo_image_unlock (&db); + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/MeanMagIO.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/MeanMagIO.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/MeanMagIO.c (revision 37067) @@ -0,0 +1,200 @@ +# include "relphot.h" + +# define GET_COLUMN(OUT,NAME,TYPE) \ + TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \ + myAssert (!strcmp(type, #TYPE), "wrong column type"); + +// this is nearly identical to the one in 'uniphot/src' used by setphot / setphot_client. +// Here, we use a handful of different columns (if not, we could move to libdvo) +MeanMag *MeanMagLoad(char *filename, off_t *nmeanmags) { + + int i, Ncol; + off_t Nrow; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + *nmeanmags = 0; + MeanMag *meanmags = NULL; + + FILE *f = fopen (filename, "r"); + if (!f) { + fprintf (stderr, "ERROR: cannot open image subset file %s\n", filename); + return NULL; + } + + /* load in PHU segment (ignore) */ + if (!gfits_fread_header (f, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset header\n"); + fclose (f); + return NULL; + } + if (!gfits_fread_matrix (f, &matrix, &header)) { + if (VERBOSE) fprintf (stderr, "can't read image subset matrix\n"); + gfits_free_header (&header); + fclose (f); + return NULL; + } + + ftable.header = &theader; + + // load data for this header + if (!gfits_load_header (f, &theader)) { + fclose (f); + return NULL; + } + + // read the fits table bytes + if (!gfits_fread_ftable_data (f, &ftable, FALSE)) { + fclose (f); + return (NULL); + } + fclose (f); + + // a bit annoying : we read the entire block of data, then extract the columns, then set the image structure values. + // this means I need 3 copies in memory at some point. ugh. + + char type[16]; + + GET_COLUMN (M, "MAG", float); + GET_COLUMN (dM, "MAG_ERR", float); + GET_COLUMN (Mchisq, "MAG_CHISQ", float); + GET_COLUMN (Nsec, "NSEC", int); + GET_COLUMN (objID, "OBJ_ID", int); + GET_COLUMN (catID, "CAT_ID", int); + + // free the memory associated with the FITS files + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + ALLOCATE (meanmags, MeanMag, Nrow); + for (i = 0; i < Nrow; i++) { + meanmags[i].M = M [i]; + meanmags[i].dM = dM [i]; + meanmags[i].Mchisq = Mchisq [i]; + meanmags[i].Nsec = Nsec [i]; + meanmags[i].objID = objID [i]; + meanmags[i].catID = catID [i]; + } + fprintf (stderr, "loaded data for %lld objects (* filters)\n", (long long) Nrow); + + free (M ); + free (dM ); + free (Mchisq); + free (Nsec ); + free (objID ); + free (catID ); + + *nmeanmags = Nrow; + return meanmags; +} + +// STATUS is value expected for success +# define CHECK_STATUS(STATUS,MSG,...) \ + if (!(STATUS)) { \ + fprintf (stderr, MSG, __VA_ARGS__); \ + return FALSE; \ + } + +int MeanMagSave(char *filename, MeanMag *meanmags, off_t Nmeanmags) { + + int i; + Header header; + Header theader; + Matrix matrix; + FTable ftable; + + gfits_init_header (&header); + header.extend = TRUE; + gfits_create_header (&header); + gfits_create_matrix (&header, &matrix); + + gfits_create_table_header (&theader, "BINTABLE", "MEANMAGS"); + + gfits_define_bintable_column (&theader, "E", "MAG", "mean magnitude", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_ERR", "mean magnitude error", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MAG_CHISQ", "mean magnitude chisq", "unitless", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "NSEC", "secfilt sequence", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "OBJ_ID", "object ID", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "CAT_ID", "catalog ID", NULL, 1.0, FT_BZERO_INT32); + + // generate the output array that carries the data + gfits_create_table (&theader, &ftable); + + float *M, *dM, *Mchisq; + int *Nsec; + unsigned int *objID, *catID; + + // create intermediate storage arrays + ALLOCATE (M, float, Nmeanmags); + ALLOCATE (dM, float, Nmeanmags); + ALLOCATE (Mchisq, float, Nmeanmags); + ALLOCATE (Nsec, int, Nmeanmags); + ALLOCATE (objID, unsigned int, Nmeanmags); + ALLOCATE (catID, unsigned int, Nmeanmags); + + // assign the storage arrays + for (i = 0; i < Nmeanmags; i++) { + M [i] = meanmags[i].M ; + dM [i] = meanmags[i].dM ; + Mchisq[i] = meanmags[i].Mchisq; + Nsec [i] = meanmags[i].Nsec ; + objID [i] = meanmags[i].objID ; + catID [i] = meanmags[i].catID ; + } + + // add the columns to the output array + gfits_set_bintable_column (&theader, &ftable, "MAG", M, Nmeanmags); + gfits_set_bintable_column (&theader, &ftable, "MAG_ERR", dM, Nmeanmags); + gfits_set_bintable_column (&theader, &ftable, "MAG_CHISQ", Mchisq, Nmeanmags); + gfits_set_bintable_column (&theader, &ftable, "NSEC", Nsec, Nmeanmags); + gfits_set_bintable_column (&theader, &ftable, "OBJ_ID", objID, Nmeanmags); + gfits_set_bintable_column (&theader, &ftable, "CAT_ID", catID, Nmeanmags); + + free (M ); + free (dM ); + free (Mchisq); + free (Nsec ); + free (objID ); + free (catID ); + + FILE *f = fopen (filename, "w"); + if (!f) { + fprintf (stderr, "ERROR: cannot open meanmag file for output %s\n", filename); + return FALSE; + } + + int status; + status = gfits_fwrite_header (f, &header); + CHECK_STATUS (status, "ERROR: cannot write header for meanmags %s\n", filename); + + status = gfits_fwrite_matrix (f, &matrix); + CHECK_STATUS (status, "ERROR: cannot write matrix for meanmags %s\n", filename); + + status = gfits_fwrite_Theader (f, &theader); + CHECK_STATUS (status, "ERROR: cannot write table header for meanmags %s\n", filename); + + status = gfits_fwrite_table (f, &ftable); + CHECK_STATUS (status, "ERROR: cannot write table data for meanmags %s\n", filename); + + gfits_free_header (&header); + gfits_free_matrix (&matrix); + gfits_free_header (&theader); + gfits_free_table (&ftable); + + int fd = fileno (f); + + status = fflush (f); + CHECK_STATUS (!status, "ERROR: cannot flush file meanmags %s\n", filename); + + status = fsync (fd); + CHECK_STATUS (!status, "ERROR: cannot flush file meanmags %s\n", filename); + + status = fclose (f); + CHECK_STATUS (!status, "ERROR: problem closing meanmags file %s\n", filename); + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/MosaicOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/MosaicOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/MosaicOps.c (revision 37067) @@ -1,4 +1,5 @@ # include "relphot.h" void plot_setMcal (double *list, int Npts, StatType *stats, float clouds); +off_t findMosaic (unsigned int *startTimes, off_t Nmosaic, unsigned int start); // see discussion in ImagesOps.c re: IDX_T @@ -36,4 +37,18 @@ // MosaicN_image was 'Nimlist' // MosaicToImage was 'imlist' + +void sort_times (unsigned int *T, int N) { + +# define SWAPFUNC(A,B){ unsigned int tmp; \ + tmp = T[A]; T[A] = T[B]; T[B] = tmp; \ +} +# define COMPARE(A,B)(T[A] < T[B]) + + OHANA_SORT (N, COMPARE, SWAPFUNC); + +# undef SWAPFUNC +# undef COMPARE + +} /* find mosaic frames (unique time periods & photcode name matches mosaic) */ @@ -96,12 +111,12 @@ /* a new mosaic, define ranges -- preserve the original values incase this image is not used */ - mosaic[Nmosaic].start = start; - mosaic[Nmosaic].stop = stop; - mosaic[Nmosaic].Mcal = 0.0; // note : mosaic stores only offsets relative to the original image values - mosaic[Nmosaic].dMcal = 0.0; // note : at the end, mosaic.Mcal is added back to the input images - mosaic[Nmosaic].dMsys = 0.0; - mosaic[Nmosaic].Xm = 0.0; + mosaic[Nmosaic].start = start; + mosaic[Nmosaic].stop = stop; + mosaic[Nmosaic].Mcal = 0.0; // note : mosaic stores only offsets relative to the original image values + mosaic[Nmosaic].dMcal = 0.0; // note : at the end, mosaic.Mcal is added back to the input images + mosaic[Nmosaic].dMsys = 0.0; + mosaic[Nmosaic].Xm = 0.0; mosaic[Nmosaic].flags = image[i].flags; - mosaic[Nmosaic].secz = image[i].secz; + mosaic[Nmosaic].secz = image[i].secz; mosaic[Nmosaic].photcode = GetPhotcodeEquivCodebyCode (image[i].photcode); @@ -136,20 +151,4 @@ } -off_t findMosaic (unsigned int *startTimes, off_t Nmosaic, unsigned int start); - -void sort_times (unsigned int *T, int N) { - -# define SWAPFUNC(A,B){ unsigned int tmp; \ - tmp = T[A]; T[A] = T[B]; T[B] = tmp; \ -} -# define COMPARE(A,B)(T[A] < T[B]) - - OHANA_SORT (N, COMPARE, SWAPFUNC); - -# undef SWAPFUNC -# undef COMPARE - -} - /* find mosaic frames (unique time periods) (NOTE : we do NOT require matching photcodes...) this function will also identify the images NOT in the subset which belong to a selected mosaic @@ -157,7 +156,6 @@ void initMosaics (Image *subset, off_t Nsubset, Image *image, char *inSubset, off_t Nimage) { - off_t i, j, status, found, NMOSAIC, *MosaicN_IMAGE; + off_t i, j, found, NMOSAIC, *MosaicN_IMAGE; unsigned int start, stop, *startTimes, *startTimesMosaic; - char *pname; if (!MOSAIC_ZEROPT) return; @@ -172,8 +170,11 @@ // generate a list of all subset image start times ALLOCATE (startTimes, unsigned int, Nsubset); + int Nmoschip = 0; for (i = 0; i < Nsubset; i++) { - startTimes[i] = subset[i].tzero; - } - sort_times (startTimes, Nsubset); + if (!isGPC1chip(subset[i].photcode)) continue; + startTimes[Nmoschip] = subset[i].tzero; + Nmoschip ++; + } + sort_times (startTimes, Nmoschip); MARKTIME("create array of all image obstimes: %f sec\n", dtime); @@ -184,9 +185,6 @@ // generate a list of the unique start times (these define the mosaics) - for (i = 0; i < Nsubset; i++) { - if (startTimes[i] < startTimesMosaic[Nmosaic]) { - fprintf (stderr, "error?\n"); - abort(); - } + for (i = 0; i < Nmoschip; i++) { + myAssert (startTimes[i] >= startTimesMosaic[Nmosaic], "times out of order?"); if (startTimes[i] == startTimesMosaic[Nmosaic]) continue; Nmosaic ++; @@ -210,14 +208,14 @@ for (i = 0; i < Nmosaic; i++) { /* a new mosaic, define ranges */ - mosaic[i].start = startTimesMosaic[i]; - mosaic[i].stop = 0; - mosaic[i].Mcal = 0.0; - mosaic[i].dMcal = 0.0; - mosaic[i].dMsys = 0.0; - mosaic[i].Xm = 0.0; - mosaic[i].flags = 0; - mosaic[i].secz = NAN; + mosaic[i].start = startTimesMosaic[i]; + mosaic[i].stop = 0; + mosaic[i].Mcal = 0.0; + mosaic[i].dMcal = 0.0; + mosaic[i].dMsys = 0.0; + mosaic[i].Xm = 0.0; + mosaic[i].flags = 0; + mosaic[i].secz = NAN; mosaic[i].photcode = 0; - mosaic[i].skipCal = FALSE; + mosaic[i].skipCal = FALSE; memset (&mosaic[i].coords, 0, sizeof(Coords)); @@ -238,9 +236,5 @@ } - /* select valid mosaic images by photcode */ - pname = GetPhotcodeNamebyCode (image[i].photcode); - if (!pname) continue; - status = strncmp (pname, MOSAICNAME, strlen (MOSAICNAME)); - if (status) continue; + if (!isGPC1chip(image[i].photcode)) continue; /* set image time range */ @@ -262,11 +256,12 @@ // assign each image to a mosaic + int Nsimple = 0; for (i = 0; i < Nsubset; i++) { ImageToMosaic[i] = -1; - /* select valid mosaic images by photcode */ - pname = GetPhotcodeNamebyCode (subset[i].photcode); - status = strncmp (pname, MOSAICNAME, strlen (MOSAICNAME)); - if (status) continue; + if (!isGPC1chip(subset[i].photcode)) { + Nsimple ++; + continue; + } start = subset[i].tzero; @@ -299,11 +294,11 @@ abort(); } - mosaic[j].stop = stop; - mosaic[j].Mcal = 0.0; - mosaic[j].dMcal = 0.0; - mosaic[j].Xm = 0.0; - mosaic[j].dMsys = subset[i].flags; - mosaic[j].flags = subset[i].flags; - mosaic[j].secz = subset[i].secz; + mosaic[j].stop = stop; + mosaic[j].Mcal = 0.0; + mosaic[j].dMcal = 0.0; + mosaic[j].Xm = 0.0; + mosaic[j].dMsys = subset[i].flags; + mosaic[j].flags = subset[i].flags; + mosaic[j].secz = subset[i].secz; mosaic[j].photcode = GetPhotcodeEquivCodebyCode (subset[i].photcode); } @@ -316,6 +311,159 @@ initMosaicGrid (subset, Nsubset); - fprintf (stderr, "matched %d images to %d mosaics\n", (int) Nsubset, (int) Nmosaic); + fprintf (stderr, "matched %d images to %d mosaics, %d simple chips not matched to mosaics\n", (int) (Nsubset - Nsimple), (int) Nmosaic, (int) Nsimple); return; +} + +/* find mosaic frames (unique time periods) (NOTE : require gpc1 chips, which is pretty limiting) + if mergeMcal is TRUE, values will be saved on Mosaic.Mcal + */ +void makeMosaics (Image *image, off_t Nimage, int mergeMcal) { + + off_t i, j, found, NMOSAIC, *MosaicN_IMAGE; + unsigned int start, stop, *startTimes, *startTimesMosaic; + + if (!MOSAIC_ZEROPT) return; + + INITTIME; + + /* a 'mosaic' in relphot is (unlike relastro) a virtual concept: there is no + * entry in the image table that represents this mosaic. Instead, it is an + * internal construct that defines a group of related images + */ + + // generate a list of all image start times + ALLOCATE (startTimes, unsigned int, Nimage); + int Nmoschip = 0; + for (i = 0; i < Nimage; i++) { + if (!isGPC1chip(image[i].photcode)) continue; + startTimes[Nmoschip] = image[i].tzero; + Nmoschip ++; + } + sort_times (startTimes, Nmoschip); + MARKTIME("create array of all image obstimes: %f sec\n", dtime); + + Nmosaic = 0; + NMOSAIC = 1000; + ALLOCATE (startTimesMosaic, unsigned int, NMOSAIC); + startTimesMosaic[0] = startTimes[0]; + + // generate a list of the unique start times (these define the mosaics) + for (i = 0; i < Nmoschip; i++) { + myAssert (startTimes[i] >= startTimesMosaic[Nmosaic], "times out of order?"); + if (startTimes[i] == startTimesMosaic[Nmosaic]) continue; + Nmosaic ++; + if (Nmosaic >= NMOSAIC) { + NMOSAIC += 1000; + REALLOCATE (startTimesMosaic, unsigned int, NMOSAIC); + } + startTimesMosaic[Nmosaic] = startTimes[i]; + } + Nmosaic ++; + MARKTIME("create array of mosaic obstimes: %f sec\n", dtime); + + // now I have a list of uniq start times, and they are in order + // create the mosaic arrays for these times + ALLOCATE (mosaic, Mosaic, Nmosaic); + + ALLOCATE (MosaicToImage, off_t *, Nmosaic); + ALLOCATE (MosaicN_Image, off_t, Nmosaic); + ALLOCATE (MosaicN_IMAGE, off_t, Nmosaic); + + // init the mosaic array values + for (i = 0; i < Nmosaic; i++) { + mosaic[i].start = startTimesMosaic[i]; + mosaic[i].stop = 0; + mosaic[i].Mcal = 0.0; + mosaic[i].dMcal = 0.0; + mosaic[i].dMsys = 0.0; + mosaic[i].Xm = 0.0; + mosaic[i].flags = 0; + mosaic[i].secz = NAN; + mosaic[i].photcode = 0; + mosaic[i].skipCal = FALSE; + + memset (&mosaic[i].coords, 0, sizeof(Coords)); + + MosaicN_IMAGE[i] = 10; + MosaicN_Image[i] = 0; + ALLOCATE (MosaicToImage[i], off_t, MosaicN_IMAGE[i]); + MosaicToImage[i][0] = -1; + } + + ALLOCATE (ImageToMosaic, off_t, Nimage); // mosaic to which image belongs + + // assign each image to a mosaic + int Nsimple = 0; + for (i = 0; i < Nimage; i++) { + ImageToMosaic[i] = -1; + + if (!isGPC1chip(image[i].photcode)) { + Nsimple ++; + continue; + } + + start = image[i].tzero; + stop = image[i].tzero + MAX(1.01*image[i].trate*image[i].NY, 1); + + j = findMosaic(startTimesMosaic, Nmosaic, start); + if (j == -1) { + fprintf (stderr, "programming error? all image images should belong to a mosaic\n"); + abort(); + } + + // add reference from image to mosaic + ImageToMosaic[i] = j; + + // have we already found this mosaic? + found = (MosaicN_Image[j] > 0); + + /* add image to mosaic image list */ + MosaicToImage[j][MosaicN_Image[j]] = i; + MosaicN_Image[j] ++; + if (MosaicN_Image[j] == MosaicN_IMAGE[j]) { + MosaicN_IMAGE[j] += 10; + REALLOCATE (MosaicToImage[j], off_t, MosaicN_IMAGE[j]); + } + if (found) continue; + + /* a new mosaic, define ranges */ + if (mosaic[j].start != start) { + fprintf (stderr, "error?\n"); + abort(); + } + mosaic[j].stop = stop; + mosaic[j].Mcal = 0.0; + mosaic[j].dMcal = 0.0; + mosaic[j].Xm = 0.0; + mosaic[j].dMsys = image[i].flags; + mosaic[j].flags = image[i].flags; + mosaic[j].secz = image[i].secz; + mosaic[j].photcode = GetPhotcodeEquivCodebyCode (image[i].photcode); + } + MARKTIME("assign images to mosaic: %f sec\n", dtime); + + // free this or not? + free (MosaicN_IMAGE); + free (startTimes); + free (startTimesMosaic); + + if (mergeMcal) { + initMosaicGrid (image, Nimage); + } + + fprintf (stderr, "matched %d images to %d mosaics\n", (int) Nimage, (int) Nmosaic); + return; +} + +Mosaic *getMosaicForImage (off_t im) { + + if (im < 0) return NULL; + if (!ImageToMosaic) return NULL; + + off_t m = ImageToMosaic[im]; + if (m < 0) return NULL; + if (m >= Nmosaic) return NULL; + + return (&mosaic[m]); } @@ -352,4 +500,110 @@ } +void setMosaicCenters (Image *image, off_t Nimage) { + + /* find max dR, dD range for all mosaics */ + /* define mosaic.coords to cover dR, dD */ + /* send results to initGridBins */ + + off_t i, j, m, NX, NY, NC, Nc; + double R, D, Rmid, Dmid; + double *Rc, *Dc; + + NC = 100; + ALLOCATE (Rc, double, NC); + ALLOCATE (Dc, double, NC); + + for (i = 0; i < Nmosaic; i++) { + Nc = 0; + Rmid = Dmid = NAN; + for (j = 0; j < MosaicN_Image[i]; j++) { + m = MosaicToImage[i][j]; + + if (!FindMosaicForImage (image, Nimage, m)) { + if (VERBOSE2) fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i); + continue; + } + + NX = image[m].NX; + NY = image[m].NY; + XY_to_RD (&R, &D, 0.5*NX, 0.5*NY, &image[m].coords); + R = ohana_normalize_angle_to_midpoint (R, 180.0); + + // Exclude images with crazy astrometry + // XXX NOTE : this is gpc1-specific + { + double dP1 = hypot(image[m].coords.pc1_1, image[m].coords.pc1_2); + double dP2 = hypot(image[m].coords.pc2_1, image[m].coords.pc2_2); + if (fabs(dP1 - 1.0) > 0.02) continue; + if (fabs(dP2 - 1.0) > 0.02) continue; + + double X00, Y00, X10, Y10, X01, Y01; + XY_to_LM (&X00, &Y00, 0.0, 0.0, &image[m].coords); + XY_to_LM (&X10, &Y10, image[m].NX, 0.0, &image[m].coords); + XY_to_LM (&X01, &Y01, 0.0, image[m].NY, &image[m].coords); + double dS0 = hypot ((X00 - X10), (Y00 - Y10)); + double dS1 = hypot ((X00 - X01), (Y00 - Y01)); + if (dS0 > 6000) continue; + if (dS1 > 6500) continue; + } + + Rc[Nc] = R; + Dc[Nc] = D; + Nc ++; + if (Nc >= NC) { + NC += 100; + REALLOCATE (Rc, double, NC); + REALLOCATE (Dc, double, NC); + } + } + + if (Nc > 0) { + dsort (Rc, Nc); + if (Rc[Nc-1] - Rc[0] > 180.0) { + // in our list, Rc is in the range 0.0 to 360.0. + // any mosaic which is close to the 0.0, 360.0 boundary may have some on + // one side or the other. count how many have values more than Rc[0] + 180. + // if more than half are at the large end, re-normalize to that range + int Nbig = 0; + for (j = 1; j < Nc; j++) { + if (Rc[j] - Rc[0] > 180.0) Nbig ++; + } + if (Nbig > 0.5*Nc) { + for (j = 0; j < Nc; j++) { + Rc[j] = ohana_normalize_angle_to_midpoint (Rc[j], 360.0); + } + dsort (Rc, Nc); + } else if (Nbig > 0) { + for (j = 0; j < Nc; j++) { + Rc[j] = ohana_normalize_angle_to_midpoint (Rc[j], 0.0); + } + dsort (Rc, Nc); + } + } + dsort (Dc, Nc); + + Rmid = Rc[(int)(0.5*Nc)]; + Dmid = Dc[(int)(0.5*Nc)]; + } + + strcpy (mosaic[i].coords.ctype, "DEC--TAN"); + mosaic[i].coords.crval1 = Rmid; + mosaic[i].coords.crval2 = Dmid; + mosaic[i].coords.crpix1 = 0.0; + mosaic[i].coords.crpix2 = 0.0; + mosaic[i].coords.cdelt1 = 1.0 / 3600.0; + mosaic[i].coords.cdelt2 = 1.0 / 3600.0; + mosaic[i].coords.pc1_1 = 1.0; + mosaic[i].coords.pc2_2 = 1.0; + mosaic[i].coords.pc1_2 = 0.0; + mosaic[i].coords.pc2_1 = 0.0; + + mosaic[i].Mcal = 0.0; + mosaic[i].dMcal = 0.0; + mosaic[i].Xm = 0.0; + } + return; +} + void initMosaicGrid (Image *image, off_t Nimage) { @@ -363,4 +617,6 @@ double R, D, Rmin, Rmax, Dmin, Dmax; double Mcal, dMcal, Xm; + + fprintf (stderr, "*** moving Mcal from image.Mcal to mosaic.Mcal ***\n"); dXmax = dYmax = 0.0; @@ -395,22 +651,22 @@ Dmin = MIN (Dmin, D); Dmax = MAX (Dmax, D); + + /* we are using mosaic.Mcal, not image.Mcal. reset image.Mcal */ + + // XXX: how does this work with UBERCAL? We want to keep the Mcal values supplied by ubercal, but + // solve for a single offset for each exposure (Mosaic.Mcal). + // we also want to keep the flat-field terms for each exposure (regardless of ubercal or not) + // if it helps, note that ubercal uses a single zp per exposure, so the mean of those values is the same as the value + Mcal += image[m].Mcal; dMcal += image[m].dMcal; Xm += image[m].Xm; - // XXX: how does this work with UBERCAL? We want to keep the Mcal values supplied by ubercal, but - // solve for a single offset for each exposure (Mosaic.Mcal). - - // we also want to keep the flat-field terms for each exposure (regardless of ubercal or not) - - // if it helps, note that ubercal uses a single zp per exposure, so the mean of those values is the same as the value - - /* we are using mosaic.Mcal, not image.Mcal. reset image.Mcal */ - image[m].Mcal = 0.0; - image[m].dMcal = NAN; - image[m].Xm = NAN_S_SHORT; + image[m].Mcal = 0.0; + image[m].dMcal = NAN; + image[m].Xm = NAN_S_SHORT; } dS /= MosaicN_Image[i]; - strcpy (mosaic[i].coords.ctype, "RA---TAN"); + strcpy (mosaic[i].coords.ctype, "DEC--TAN"); mosaic[i].coords.crval1 = Rmin; mosaic[i].coords.crval2 = Dmin; @@ -425,7 +681,7 @@ RD_to_XY (&dX, &dY, Rmax, Dmax, &mosaic[i].coords); - mosaic[i].Mcal = Mcal / MosaicN_Image[i]; - mosaic[i].dMcal = dMcal / MosaicN_Image[i]; - mosaic[i].Xm = Xm / MosaicN_Image[i]; + mosaic[i].Mcal = Mcal / MosaicN_Image[i]; + mosaic[i].dMcal = dMcal / MosaicN_Image[i]; + mosaic[i].Xm = Xm / MosaicN_Image[i]; } if (!USE_GRID) return; @@ -437,5 +693,4 @@ } -// XXX : what about mosaics with skipCal == TRUE? void setMcalFinal () { @@ -447,6 +702,5 @@ image = getimages (&Nimage, NULL); - // XXX I think this is OK in the ubercal context, but probably need to skip UBERCAL - // images? (no need to update them) + fprintf (stderr, "*** return Mcal from mosaic.Mcal to image.Mcal ***\n"); // copy the mosaic results to the images. set the mosaic Mcal to 0.0 since we have moved its @@ -527,8 +781,11 @@ if (!MOSAIC_ZEROPT) return (FALSE); + // if we are calibrating by mosaic, redefine myDet == on one of my mosaics int Nmatch = 0; for (i = 0; i < Ncatalog; i++) { for (j = 0; j < catalog[i].Nmeasure; j++) { + catalog[i].measureT[j].myDet = FALSE; // a detetion is not mine until proven otherwise + if (TimeSelect) { if (catalog[i].measureT[j].t < TSTART) continue; @@ -565,6 +822,7 @@ mosID = ImageToMosaic[idx]; if (mosID < 0) { - Image *image = getimage(idx); - fprintf (stderr, "unmatched image %s\n", image[0].name); + // Image *image = getimage(idx); + // fprintf (stderr, "unmatched image %s\n", image[0].name); + // skip measurements from simple chips (not matched to a mosaic by definition) return; } @@ -582,4 +840,6 @@ } + // this measurement is on one of my mosaics, mark it as mine. + catalog[cat].measureT[meas].myDet = TRUE; MeasureToMosaic[cat][meas] = mosID; @@ -605,6 +865,7 @@ if (!MOSAIC_ZEROPT) return (0); + // unassigned measurements belong to simple chips i = MeasureToMosaic[cat][meas]; - if (i == -1) return (NAN); + if (i == -1) return (0.0); if (mosaic[i].flags & IMAGE_BAD) return (NAN); @@ -850,5 +1111,5 @@ off_t n = catalog[c].measureT[m].averef; - Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]); + Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF); float delta = Msys - Mrel - Mcal - Mgrid + Mflat; @@ -887,5 +1148,5 @@ off_t n = catalog[c].measureT[m].averef; - Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]); + Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF); if (isnan(Msys)) { info->Nsys++; @@ -962,5 +1223,5 @@ if (testImage) { - fprintf (stderr, "%f %f : %d %f\n", myMosaic[0].Mcal, myMosaic[0].dMsys, myMosaic[0].Xm, pow(10.0, 0.01*myMosaic[0].Xm)); + fprintf (stderr, "%f %f : %f\n", myMosaic[0].Mcal, myMosaic[0].dMsys, pow (10.0, 0.01*myMosaic[0].Xm)); } @@ -1315,4 +1576,6 @@ if (mosaic[i].flags & IMAGE_BAD) continue; if (mosaic[i].skipCal) continue; + if (KEEP_UBERCAL && (mosaic[i].flags & ID_IMAGE_PHOTOM_UBERCAL)) continue; + list[n] = mosaic[i].Mcal; dlist[n] = 1; @@ -1345,4 +1608,6 @@ if (mosaic[i].flags & IMAGE_BAD) continue; if (mosaic[i].skipCal) continue; + if (KEEP_UBERCAL && (mosaic[i].flags & ID_IMAGE_PHOTOM_UBERCAL)) continue; + list[n] = mosaic[i].dMcal; dlist[n] = 1; @@ -1376,4 +1641,5 @@ if (mosaic[i].flags & IMAGE_BAD) continue; if (mosaic[i].skipCal) continue; + if (KEEP_UBERCAL && (mosaic[i].flags & ID_IMAGE_PHOTOM_UBERCAL)) continue; N = 0; @@ -1422,5 +1688,7 @@ if (mosaic[i].flags & IMAGE_BAD) continue; if (mosaic[i].skipCal) continue; - list[n] = pow(10.0, 0.01*mosaic[i].Xm); + if (KEEP_UBERCAL && (mosaic[i].flags & ID_IMAGE_PHOTOM_UBERCAL)) continue; + + list[n] = pow (10.0, 0.01*mosaic[i].Xm); dlist[n] = 1; n++; @@ -1505,7 +1773,6 @@ void plot_mosaic_fields (Catalog *catalog) { - off_t i, j, m, c, N, ave, Nimage; + off_t i, j, m, c, N, Nimage; double *xlist, *ylist; - // double Xmin, Xmax, Ymin, Ymax; char string[64]; Graphdata graphdata; @@ -1526,6 +1793,4 @@ for (i = 0; i < Nmosaic; i++) { N = 0; - // Xmin = Ymin = +360.0; - // Xmax = Ymax = -360.0; for (j = 0; j < N_onMosaic[i]; j++) { @@ -1535,7 +1800,7 @@ if (catalog[c].measureT[m].dbFlags & (ID_MEAS_AREA | ID_MEAS_NOCAL)) continue; - ave = catalog[c].measureT[m].averef; - xlist[N] = catalog[c].averageT[ave].R - catalog[c].measureT[m].dR / 3600.0; - ylist[N] = catalog[c].averageT[ave].D - catalog[c].measureT[m].dD / 3600.0; + // ave = catalog[c].measureT[m].averef; + xlist[N] = catalog[c].measureT[m].R; + ylist[N] = catalog[c].measureT[m].D; N++; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/Shutdown.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/Shutdown.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/Shutdown.c (revision 37067) @@ -23,5 +23,5 @@ SetProtect (TRUE); if (db) gfits_db_close (db); - fprintf (stderr, "ERROR: addstar halted\n"); + fprintf (stderr, "ERROR: relphot halted\n"); exit (1); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/StarOps.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/StarOps.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/StarOps.c (revision 37067) @@ -63,19 +63,19 @@ results->Ngrid = 0; if (allocLists) { - ALLOCATE (results->list, double, Nmax); - ALLOCATE (results->dlist, double, Nmax); - ALLOCATE (results->wlist, double, Nmax); + ALLOCATE (results->Mpsflist, double, Nmax); + ALLOCATE (results->dpsflist, double, Nmax); + ALLOCATE (results->wpsflist, double, Nmax); } } void SetMrelInfoFree (SetMrelInfo *results) { - free (results->list); - free (results->dlist); - free (results->wlist); + free (results->Mpsflist); + free (results->dpsflist); + free (results->wpsflist); } void SetMrelInfoAccum (SetMrelInfo *summary, SetMrelInfo *results) { summary->Nfew += results->Nfew ; - summary->Ncode += results->Ncode ; + summary->Ncode += results->Ncode ; summary->Nsys += results->Nsys ; summary->Nbad += results->Nbad ; @@ -153,4 +153,7 @@ int i; + // fprintf (stderr, "this version of setMrel is invalid for now\n"); + // exit (1); + int Nsecfilt = GetPhotcodeNsecfilt (); @@ -158,7 +161,12 @@ SetMrelInfoInit (&summary, FALSE); SetMrelInfoInit (&results, TRUE); // allocates results->list,dlist,wlist - ALLOCATE (results.aplist, double, Nmax); - ALLOCATE (results.kronlist, double, Nmax); + + ALLOCATE (results.Maplist, double, Nmax); + ALLOCATE (results.daplist, double, Nmax); + ALLOCATE (results.waplist, double, Nmax); + + ALLOCATE (results.Mkronlist, double, Nmax); ALLOCATE (results.dkronlist, double, Nmax); + ALLOCATE (results.wkronlist, double, Nmax); ALLOCATE (results.psfqf_list, double, Nmax); @@ -183,7 +191,11 @@ SetMrelInfoFree (&results); - free (results.aplist); - free (results.kronlist); + free (results.Maplist); + free (results.daplist); + free (results.waplist); + + free (results.Mkronlist); free (results.dkronlist); + free (results.wkronlist); free (results.psfqf_list); @@ -328,4 +340,9 @@ int setMrel_catalog (Catalog *catalog, int Nc, int pass, FlatCorrectionTable *flatcorr, SetMrelInfo *results, int Nsecfilt) { + fprintf (stderr, "??? should you still be using the old version of setMrel_catalog??\n"); + exit (3); + +# if (0) + off_t j, k, m, ID; int N; @@ -333,5 +350,5 @@ StatType stats, apstats, kronstats; - liststats_setmode (&stats, STATMODE); + liststats_setmode (&psfstats, STATMODE); liststats_setmode (&apstats, STATMODE); liststats_setmode (&kronstats, STATMODE); @@ -366,5 +383,6 @@ if (isSetMrelFinal) { // set the name of the primary skycell (this is used in a strcmp to match the skycells in stack detections) - BoundaryTreePrimaryCell(primaryCell, catalog[Nc].average[j].R, catalog[Nc].average[j].D); + // XXX : this whole function is deprecated + // BoundaryTreePrimaryCell(primaryCell, catalog[Nc].average[j].R, catalog[Nc].average[j].D); } @@ -392,5 +410,5 @@ /* star/photcodes already calibrated */ - if ( isSetMrelFinal && catalog[Nc].found[Nsecfilt*j+Nsec]) continue; + if ( isSetMrelFinal && catalog[Nc].found_t[Nsecfilt*j+Nsec]) continue; // skip bad stars @@ -452,5 +470,5 @@ // skip some absurd values NAN, < 0.0, > 30.0 - Msys = PhotSysTiny (&catalog[Nc].measureT[m], &catalog[Nc].averageT[j], &catalog[Nc].secfilt[j*Nsecfilt]); + Msys = PhotSysTiny (&catalog[Nc].measureT[m], &catalog[Nc].averageT[j], &catalog[Nc].secfilt[j*Nsecfilt], MAG_CLASS_PSF); if (isnan(Msys)) SKIP_THIS_MEAS(Nsys); if (Msys < 0.0) SKIP_THIS_MEAS(Nsys); @@ -655,7 +673,7 @@ liststats (list, dlist, wlist, N, &stats); - catalog[Nc].secfilt[Nsecfilt*j+Nsec].M = stats.mean; - catalog[Nc].secfilt[Nsecfilt*j+Nsec].dM = stats.error; - catalog[Nc].secfilt[Nsecfilt*j+Nsec].Xm = (stats.Nmeas > 1) ? 100.0*log10(stats.chisq + 1e-4) : NAN_S_SHORT; + catalog[Nc].secfilt[Nsecfilt*j+Nsec].M = stats.mean; + catalog[Nc].secfilt[Nsecfilt*j+Nsec].dM = stats.error; + catalog[Nc].secfilt[Nsecfilt*j+Nsec].Mchisq = (stats.Nmeas > 1) ? stats.chisq : NAN; // when running -averages, we have no information about the images, so we cannot set this @@ -665,5 +683,5 @@ if (isSetMrelFinal) { - catalog[Nc].found[Nsecfilt*j+Nsec] = TRUE; + catalog[Nc].found_t[Nsecfilt*j+Nsec] = TRUE; catalog[Nc].secfilt[Nsecfilt*j+Nsec].Mstdev = 1000.0*stats.sigma; // Mstdev is in millimags (not enough space for more precision) @@ -833,4 +851,5 @@ if (primaryCell) free (primaryCell); return (TRUE); +# endif } @@ -892,9 +911,48 @@ } +int markObjects (Catalog *catalog, int Ncatalog) { + + int i, n; + off_t j; + + // How strongly do I own this object? + for (i = 0; i < Ncatalog; i++) { + for (j = 0; j < catalog[i].Naverage; j++) { + int nOwn = 0; + int m = catalog[i].averageT[j].measureOffset; + for (n = 0; n < catalog[i].averageT[j].Nmeasure; n++) { + if (!catalog[i].measureT[m+n].myDet) continue; + nOwn ++; + } + catalog[i].averageT[j].nOwn = nOwn; + } + } + return TRUE; +} + +int dumpObjects (char *filename, Catalog *catalog, int Ncatalog) { + + int i, n; + off_t j; + + FILE *ftest = fopen (filename, "w"); + + for (i = 0; i < Ncatalog; i++) { + for (j = 0; j < catalog[i].Naverage; j++) { + int m = catalog[i].averageT[j].measureOffset; + for (n = 0; n < catalog[i].averageT[j].Nmeasure; n++) { + fprintf (ftest, "%08x %08x %10.6f %10.6f %3d %1d\n", catalog[i].averageT[j].catID, catalog[i].averageT[j].objID, catalog[i].averageT[j].R, catalog[i].averageT[j].D, catalog[i].averageT[j].Nmeasure, catalog[i].measureT[m+n].myDet); + } + } + } + fclose (ftest); + return TRUE; +} + void clean_stars (Catalog *catalog, int Ncatalog) { int i, j, Ndel, Nave, Ntot, mark, Ns, Nscat, Nchi, Nnan; - float dM, Xm; - double Chisq, MaxScatter, MaxChisq; + float dM; + double MaxScatter, MaxChisq; double *xlist, *slist, *dlist; @@ -923,8 +981,7 @@ for (j = 0; j < catalog[i].Naverage; j++) { if ( catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD ) continue; - Xm = catalog[i].secfilt[Nsecfilt*j+Nsec].Xm; - if (Xm == -1) continue; - Chisq = pow (10.0, 0.01*Xm); - xlist[Ntot] = Chisq; + float Mchisq = catalog[i].secfilt[Nsecfilt*j+Nsec].Mchisq; + if (isnan(Mchisq)) continue; + xlist[Ntot] = Mchisq; slist[Ntot] = catalog[i].secfilt[Nsecfilt*j+Nsec].dM; dlist[Ntot] = 1; @@ -944,13 +1001,12 @@ for (j = 0; j < catalog[i].Naverage; j++) { dM = catalog[i].secfilt[Nsecfilt*j+Nsec].dM; - Xm = catalog[i].secfilt[Nsecfilt*j+Nsec].Xm; - Chisq = pow (10.0, 0.01*Xm); - mark = (dM > MaxScatter) || (Xm == NAN_S_SHORT) || (Chisq > MaxChisq); + float Mchisq = catalog[i].secfilt[Nsecfilt*j+Nsec].Mchisq; + mark = (dM > MaxScatter) || (isnan(Mchisq)) || (Mchisq > MaxChisq); if (mark) { catalog[i].secfilt[Nsecfilt*j+Nsec].flags |= ID_STAR_POOR; Ndel ++; - if (dM > MaxScatter) { Nscat ++; } - if (Xm == NAN_S_SHORT) { Nnan ++; } - if (Chisq > MaxChisq) { Nchi ++; } + if (dM > MaxScatter) { Nscat ++; } + if (isnan(Mchisq)) { Nnan ++; } + if (Mchisq > MaxChisq) { Nchi ++; } } else { catalog[i].secfilt[Nsecfilt*j+Nsec].flags &= ~ID_STAR_POOR; @@ -1017,5 +1073,5 @@ /* on final processing, skip stars already measured */ - if (final && catalog[i].found[Nsecfilt*j + Nsec]) continue; + if (final && catalog[i].found_t[Nsecfilt*j + Nsec]) continue; /* skip bad stars to prevent them from becoming good (on inner sample) */ @@ -1038,5 +1094,5 @@ if (isnan(Mgrid)) { Ngrid ++; continue; } - Msys = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt]); + Msys = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt], MAG_CLASS_PSF); list[N] = Msys - Mcal - Mmos - Mgrid; dlist[N] = MAX (catalog[i].measureT[m].dM, MIN_ERROR); @@ -1083,5 +1139,5 @@ if (isnan(Mgrid)) continue; - Msys = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt]); + Msys = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt], MAG_CLASS_PSF); list[N] = Msys - Mcal - Mmos - Mgrid; dlist[N] = MAX (catalog[i].measureT[m].dM, MIN_ERROR); @@ -1178,5 +1234,5 @@ off_t j, Ntot; - int i, n, Xm; + int i, n; double *list, *dlist; StatType stats; @@ -1199,7 +1255,7 @@ if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue; - Xm = catalog[i].secfilt[Nsecfilt*j+Nsec].Xm; - if (Xm == NAN_S_SHORT) continue; - list[n] = pow (10.0, 0.01*Xm); + float Mchisq = catalog[i].secfilt[Nsecfilt*j+Nsec].Mchisq; + if (isnan(Mchisq)) continue; + list[n] = Mchisq; dlist[n] = 1; n++; @@ -1322,7 +1378,7 @@ if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue; xlist[N] = catalog[i].secfilt[Nsecfilt*j+Nsec].M; - value = catalog[i].secfilt[Nsecfilt*j+Nsec].Xm; - if (value == NAN_S_SHORT) continue; - ylist[N] = 0.01*value; + value = catalog[i].secfilt[Nsecfilt*j+Nsec].Mchisq; + if (isnan(value)) continue; + ylist[N] = value; N++; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/args.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/args.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/args.c (revision 37067) @@ -1,8 +1,538 @@ # include "relphot.h" -int args (int argc, char **argv) { +RelphotMode args (int argc, char **argv) { int N; double trange; + + /* define time */ + TimeSelect = FALSE; + if ((N = get_argument (argc, argv, "-time"))) { + remove_argument (N, &argc, argv); + if (!ohana_str_to_time (argv[N], &TSTART)) { + fprintf (stderr, "ERROR: syntax error\n"); + return (MODE_ERROR); + } + remove_argument (N, &argc, argv); + if (!ohana_str_to_dtime (argv[N], &trange)) { + if (!ohana_str_to_time (argv[N], &TSTOP)) { + fprintf (stderr, "ERROR: syntax error\n"); + return (MODE_ERROR); + } + } else { + if (trange < 0) { + trange = fabs (trange); + TSTOP = TSTART; + TSTART -= trange; + } else { + TSTOP = TSTART + trange; + } + } + remove_argument (N, &argc, argv); + TimeSelect = TRUE; + } + + /* specify portion of the sky */ + UserPatch.Rmin = 0; + UserPatch.Rmax = 360; + UserPatch.Dmin = -90; + UserPatch.Dmax = +90; + if ((N = get_argument (argc, argv, "-region"))) { + remove_argument (N, &argc, argv); + UserPatch.Rmin = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Rmax = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Dmin = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Dmax = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + /* specify region file by name (eg n0000/0000.00) */ + UserCatalog = NULL; + if ((N = get_argument (argc, argv, "-catalog"))) { + remove_argument (N, &argc, argv); + UserCatalog = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + + USE_BASIC_CHECK = FALSE; + if ((N = get_argument (argc, argv, "-basic-image-search"))) { + remove_argument (N, &argc, argv); + USE_BASIC_CHECK = TRUE; + } + + USE_FULL_OVERLAP = TRUE; + if ((N = get_argument (argc, argv, "-sloppy-image-overlap"))) { + remove_argument (N, &argc, argv); + USE_FULL_OVERLAP = FALSE; + } + + SET_MREL_VERSION = 1; + if ((N = get_argument (argc, argv, "-set-mrel-version"))) { + remove_argument (N, &argc, argv); + SET_MREL_VERSION = atof(argv[N]); + remove_argument (N, &argc, argv); + } + + VERBOSE = VERBOSE2 = FALSE; + if ((N = get_argument (argc, argv, "-v"))) { + VERBOSE = TRUE; + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-vv"))) { + VERBOSE2 = VERBOSE = TRUE; + remove_argument (N, &argc, argv); + } + + NTHREADS = 0; + if ((N = get_argument (argc, argv, "-threads"))) { + remove_argument (N, &argc, argv); + NTHREADS = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + // XXX for the moment, make this selection manual. it needs to be automatic + // based on the state of the SkyTable + HOST_ID = 0; + PARALLEL = FALSE; + if ((N = get_argument (argc, argv, "-parallel"))) { + PARALLEL = TRUE; + remove_argument (N, &argc, argv); + } + // this is a test mode : rather than launching the remote jobs and waiting for completion, + // relphot will simply list the remote command and wait for the user to signal completion + PARALLEL_MANUAL = FALSE; + if ((N = get_argument (argc, argv, "-parallel-manual"))) { + PARALLEL = TRUE; // -parallel-manual implies -parallel + PARALLEL_MANUAL = TRUE; + remove_argument (N, &argc, argv); + } + // this is a test mode : rather than launching the relphot_client jobs remotely, they are + // run in serial via 'system' + PARALLEL_SERIAL = FALSE; + if ((N = get_argument (argc, argv, "-parallel-serial"))) { + if (PARALLEL_MANUAL) { + fprintf (stderr, "ERROR: cannot mix -parallel-manual and -parallel-serial\n"); + exit (1); + } + PARALLEL = TRUE; // -parallel-serial implies -parallel + PARALLEL_SERIAL = TRUE; + remove_argument (N, &argc, argv); + } + + PLOTSTUFF = FALSE; + if ((N = get_argument (argc, argv, "-plot"))) { + PLOTSTUFF = TRUE; + remove_argument (N, &argc, argv); + } + + PLOTDELAY = 500000; + if ((N = get_argument (argc, argv, "-plotdelay"))) { + remove_argument (N, &argc, argv); + PLOTDELAY = 1e6*atof(argv[N]); + PLOTSTUFF = TRUE; // always turn on plotting if i request a plot delay + remove_argument (N, &argc, argv); + } + + if ((N = get_argument (argc, argv, "-outroot"))) { + remove_argument (N, &argc, argv); + OUTROOT = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } else { + OUTROOT = strcreate ("relphot"); + } + + strcpy (STATMODE, "WT_MEAN"); + if ((N = get_argument (argc, argv, "-statmode"))) { + remove_argument (N, &argc, argv); + strcpy (STATMODE, argv[N]); + remove_argument (N, &argc, argv); + } + + NLOOP = 8; + if ((N = get_argument (argc, argv, "-n"))) { + remove_argument (N, &argc, argv); + NLOOP = atof (argv[N]); + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-nloop"))) { + remove_argument (N, &argc, argv); + NLOOP = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + NGRID = 8; + if ((N = get_argument (argc, argv, "-ngrid"))) { + remove_argument (N, &argc, argv); + NGRID = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + RESET = FALSE; + if ((N = get_argument (argc, argv, "-reset"))) { + remove_argument (N, &argc, argv); + RESET = TRUE; + } + + RESET_ZEROPTS = FALSE; + if ((N = get_argument (argc, argv, "-reset-zpts"))) { + remove_argument (N, &argc, argv); + RESET_ZEROPTS = TRUE; + } + + UPDATE = FALSE; + if ((N = get_argument (argc, argv, "-update"))) { + remove_argument (N, &argc, argv); + UPDATE = TRUE; + } + + UPDATE_CATFORMAT = NULL; + if ((N = get_argument (argc, argv, "-update-catformat"))) { + remove_argument (N, &argc, argv); + UPDATE_CATFORMAT = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + + SAVE_IMAGE_UPDATES = TRUE; + if ((N = get_argument (argc, argv, "-skip-image-updates"))) { + remove_argument (N, &argc, argv); + SAVE_IMAGE_UPDATES = FALSE; + } + + MaxDensityUse = FALSE; + if ((N = get_argument (argc, argv, "-max-density"))) { + remove_argument (N, &argc, argv); + MaxDensityValue = atof(argv[N]); + remove_argument (N, &argc, argv); + MaxDensityUse = TRUE; + } + + CLOUD_TOLERANCE = 0.02; + if ((N = get_argument (argc, argv, "-cloud-limit"))) { + remove_argument (N, &argc, argv); + CLOUD_TOLERANCE = atof(argv[N]); + remove_argument (N, &argc, argv); + } + + // XXX should we load a tree from CATDIR by default? + // NOTE: a given catdir needs an appropriate boundary tree + BOUNDARY_TREE = NULL; + if ((N = get_argument (argc, argv, "-boundary-tree"))) { + remove_argument (N, &argc, argv); + BOUNDARY_TREE = strcreate(argv[N]); + load_tess (BOUNDARY_TREE); + remove_argument (N, &argc, argv); + } + + SHOW_PARAMS = TRUE; + if ((N = get_argument (argc, argv, "-params"))) { + remove_argument (N, &argc, argv); + SHOW_PARAMS = FALSE; + } + + PlotMmin = 10.0; PlotMmax = 20.0; PlotdMmin = -1.0; PlotdMmax = 1.0; + if ((N = get_argument (argc, argv, "-plrange"))) { + remove_argument (N, &argc, argv); + PlotMmin = atof (argv[N]); + remove_argument (N, &argc, argv); + PlotMmax = atof (argv[N]); + remove_argument (N, &argc, argv); + PlotdMmin = atof (argv[N]); + remove_argument (N, &argc, argv); + PlotdMmax = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + /* XXX this argument used to do two things: specify the camera name and tell the analysis to + calculate a common zero point for a single mosaic. I've moved the MOSAICNAME concept into the + config system, but need to use this argument to specify that the mosaic zeropoints should be + calculated. */ + MOSAIC_ZEROPT = FALSE; + if ((N = get_argument (argc, argv, "-mosaic"))) { + remove_argument (N, &argc, argv); + MOSAIC_ZEROPT = TRUE; + if (!strcasecmp (MOSAICNAME, "none")) { + fprintf (stderr, "mosaic astrometry selected by MOSAICNAME not defined\n"); + exit (2); + } + } + + FREEZE_IMAGES = FALSE; + if ((N = get_argument (argc, argv, "-imfreeze"))) { + remove_argument (N, &argc, argv); + FREEZE_IMAGES = TRUE; + } + + FREEZE_MOSAICS = FALSE; + if ((N = get_argument (argc, argv, "-mosfreeze"))) { + remove_argument (N, &argc, argv); + FREEZE_MOSAICS = TRUE; + } + + // USE_GRID is not valid for all cases, probably should be its own mode... + USE_GRID = FALSE; + if ((N = get_argument (argc, argv, "-grid"))) { + remove_argument (N, &argc, argv); + USE_GRID = TRUE; + } + + KEEP_UBERCAL = TRUE; + if ((N = get_argument (argc, argv, "-reset-ubercal"))) { + remove_argument (N, &argc, argv); + KEEP_UBERCAL = FALSE; + } + + MIN_ERROR = 0.001; + if ((N = get_argument (argc, argv, "-minerror"))) { + remove_argument (N, &argc, argv); + MIN_ERROR = atof (argv[N]); + remove_argument (N, &argc, argv); + /* require MIN_ERROR > 0 */ + } + + AreaSelect = FALSE; + if ((N = get_argument (argc, argv, "-area"))) { + remove_argument (N, &argc, argv); + AreaXmin = atof (argv[N]); + remove_argument (N, &argc, argv); + AreaXmax = atof (argv[N]); + remove_argument (N, &argc, argv); + AreaYmin = atof (argv[N]); + remove_argument (N, &argc, argv); + AreaYmax = atof (argv[N]); + remove_argument (N, &argc, argv); + AreaSelect = TRUE; + } + + ImagSelect = FALSE; + if ((N = get_argument (argc, argv, "-instmag"))) { + remove_argument (N, &argc, argv); + ImagMin = atof (argv[N]); + remove_argument (N, &argc, argv); + ImagMax = atof (argv[N]); + remove_argument (N, &argc, argv); + ImagSelect = TRUE; + } + + DophotSelect = FALSE; + if ((N = get_argument (argc, argv, "-dophot"))) { + remove_argument (N, &argc, argv); + DophotValue = atof (argv[N]); + remove_argument (N, &argc, argv); + DophotSelect = TRUE; + } + + SyntheticPhotometry = FALSE; + if ((N = get_argument (argc, argv, "-synthphot"))) { + remove_argument (N, &argc, argv); + SyntheticPhotometry = TRUE; + init_synthetic_mags(); + } + + refPhotcode = NULL; + if ((N = get_argument (argc, argv, "-refcode"))) { + remove_argument (N, &argc, argv); + refPhotcode = GetPhotcodebyName (argv[N]); + if (!refPhotcode) { + fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", argv[N]); + exit (1); + } + remove_argument (N, &argc, argv); + } + + REGION_FILE = NULL; + if ((N = get_argument (argc, argv, "-region-hosts"))) { + remove_argument (N, &argc, argv); + REGION_FILE = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + + REGION_HOST_ID = 0; + if ((N = get_argument (argc, argv, "-region-hostID"))) { + remove_argument (N, &argc, argv); + REGION_HOST_ID = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + + RelphotMode mode = MODE_ERROR; + if ((N = get_argument (argc, argv, "-images"))) { + remove_argument (N, &argc, argv); + mode = UPDATE_IMAGES; + } + if ((N = get_argument (argc, argv, "-averages"))) { + remove_argument (N, &argc, argv); + mode = UPDATE_AVERAGES; + } + if ((N = get_argument (argc, argv, "-apply-offsets"))) { + remove_argument (N, &argc, argv); + mode = APPLY_OFFSETS; + } + IMAGE_TABLE = NULL; + if ((N = get_argument (argc, argv, "-parallel-images"))) { + remove_argument (N, &argc, argv); + mode = PARALLEL_IMAGES; + if (N >= argc) relphot_usage(); + IMAGE_TABLE = strcreate (argv[N]); + remove_argument (N, &argc, argv); + if (!REGION_FILE) relphot_usage(); + } + + PARALLEL_REGIONS_MANUAL = FALSE; + if ((N = get_argument (argc, argv, "-parallel-regions"))) { + remove_argument (N, &argc, argv); + mode = PARALLEL_REGIONS; + if (!REGION_FILE) relphot_usage(); + if ((N = get_argument (argc, argv, "-parallel-regions-manual"))) { + remove_argument (N, &argc, argv); + PARALLEL_REGIONS_MANUAL = TRUE; + } + } + + switch (mode) { + case UPDATE_AVERAGES: + if (argc != 1) relphot_usage(); + break; + + case UPDATE_IMAGES: + case PARALLEL_IMAGES: + case PARALLEL_REGIONS: + PhotcodeList = strcreate (argv[1]); + photcodes = ParsePhotcodeList (PhotcodeList, &Nphotcodes, TRUE); // require SEC photcodes + remove_argument (1, &argc, argv); + break; + + default: + fprintf (stderr, "no valid mode selected\n"); + relphot_usage(); + break; + } + if (argc != 1) relphot_usage (); + + return mode; +} + +int args_client (int argc, char **argv) { + + int N; + double trange; + + // by definition, the client is not parallel + PARALLEL = FALSE; + PARALLEL_MANUAL = FALSE; + PARALLEL_SERIAL = FALSE; + + HOST_ID = 0; + if ((N = get_argument (argc, argv, "-hostID"))) { + remove_argument (N, &argc, argv); + HOST_ID = atoi (argv[N]); + remove_argument (N, &argc, argv); + } + if (!HOST_ID) relphot_client_usage(); + + HOSTDIR = NULL; + if ((N = get_argument (argc, argv, "-hostdir"))) { + remove_argument (N, &argc, argv); + HOSTDIR = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + if (!HOSTDIR) relphot_client_usage(); + + IMAGES = NULL; // used in -update mode + BCATALOG = NULL; // used in -load mode + MODE = MODE_NONE; + if ((N = get_argument (argc, argv, "-load"))) { + MODE = MODE_LOAD; + remove_argument (N, &argc, argv); + BCATALOG = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-update-catalogs"))) { + if (MODE) { + fprintf (stderr, "ERROR: cannot mix modes (-load, -update-catalogs, -update-objects)\n"); + relphot_client_usage(); + } + MODE = MODE_UPDATE; + remove_argument (N, &argc, argv); + IMAGES = strcreate (argv[N]); + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-update-objects"))) { + if (MODE) { + fprintf (stderr, "ERROR: cannot mix modes (-load, -update-catalogs, -update-objects)\n"); + relphot_client_usage(); + } + MODE = MODE_UPDATE_OBJECTS; + remove_argument (N, &argc, argv); + } + if (!MODE) relphot_client_usage(); + + strcpy (STATMODE, "WT_MEAN"); + if ((N = get_argument (argc, argv, "-statmode"))) { + remove_argument (N, &argc, argv); + strcpy (STATMODE, argv[N]); + remove_argument (N, &argc, argv); + } + + BOUNDARY_TREE = NULL; + if ((N = get_argument (argc, argv, "-boundary-tree"))) { + remove_argument (N, &argc, argv); + BOUNDARY_TREE = strcreate(argv[N]); + load_tess (BOUNDARY_TREE); + remove_argument (N, &argc, argv); + } + + /* specify portion of the sky */ + UserPatch.Rmin = 0; + UserPatch.Rmax = 360; + UserPatch.Dmin = -90; + UserPatch.Dmax = +90; + if ((N = get_argument (argc, argv, "-region"))) { + remove_argument (N, &argc, argv); + UserPatch.Rmin = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Rmax = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Dmin = atof (argv[N]); + remove_argument (N, &argc, argv); + UserPatch.Dmax = atof (argv[N]); + remove_argument (N, &argc, argv); + } + + SET_MREL_VERSION = 1; + if ((N = get_argument (argc, argv, "-set-mrel-version"))) { + remove_argument (N, &argc, argv); + SET_MREL_VERSION = atof(argv[N]); + remove_argument (N, &argc, argv); + } + + VERBOSE = VERBOSE2 = FALSE; + if ((N = get_argument (argc, argv, "-v"))) { + VERBOSE = TRUE; + remove_argument (N, &argc, argv); + } + if ((N = get_argument (argc, argv, "-vv"))) { + VERBOSE2 = VERBOSE = TRUE; + remove_argument (N, &argc, argv); + } + + RESET = FALSE; + if ((N = get_argument (argc, argv, "-reset"))) { + remove_argument (N, &argc, argv); + RESET = TRUE; + } + + RESET_ZEROPTS = FALSE; + if ((N = get_argument (argc, argv, "-reset-zpts"))) { + remove_argument (N, &argc, argv); + RESET_ZEROPTS = TRUE; + } + + KEEP_UBERCAL = TRUE; + if ((N = get_argument (argc, argv, "-reset-ubercal"))) { + remove_argument (N, &argc, argv); + KEEP_UBERCAL = FALSE; + } /* define time */ @@ -33,153 +563,12 @@ } - /* specify portion of the sky */ - UserPatch.Rmin = 0; - UserPatch.Rmax = 360; - UserPatch.Dmin = -90; - UserPatch.Dmax = +90; - if ((N = get_argument (argc, argv, "-region"))) { - remove_argument (N, &argc, argv); - UserPatch.Rmin = atof (argv[N]); - remove_argument (N, &argc, argv); - UserPatch.Rmax = atof (argv[N]); - remove_argument (N, &argc, argv); - UserPatch.Dmin = atof (argv[N]); - remove_argument (N, &argc, argv); - UserPatch.Dmax = atof (argv[N]); - remove_argument (N, &argc, argv); - } - - /* specify region file by name (eg n0000/0000.00) */ - UserCatalog = NULL; - if ((N = get_argument (argc, argv, "-catalog"))) { - remove_argument (N, &argc, argv); - UserCatalog = strcreate (argv[N]); - remove_argument (N, &argc, argv); - } - - USE_BASIC_CHECK = FALSE; - if ((N = get_argument (argc, argv, "-basic-image-search"))) { - remove_argument (N, &argc, argv); - USE_BASIC_CHECK = TRUE; - } - - USE_FULL_OVERLAP = TRUE; - if ((N = get_argument (argc, argv, "-sloppy-image-overlap"))) { - remove_argument (N, &argc, argv); - USE_FULL_OVERLAP = FALSE; - } - - SET_MREL_VERSION = 1; - if ((N = get_argument (argc, argv, "-set-mrel-version"))) { - remove_argument (N, &argc, argv); - SET_MREL_VERSION = atof(argv[N]); - remove_argument (N, &argc, argv); - } - - VERBOSE = VERBOSE2 = FALSE; - if ((N = get_argument (argc, argv, "-v"))) { - VERBOSE = TRUE; - remove_argument (N, &argc, argv); - } - if ((N = get_argument (argc, argv, "-vv"))) { - VERBOSE2 = VERBOSE = TRUE; - remove_argument (N, &argc, argv); - } - - NTHREADS = 0; - if ((N = get_argument (argc, argv, "-threads"))) { - remove_argument (N, &argc, argv); - NTHREADS = atof (argv[N]); - remove_argument (N, &argc, argv); - } - - // XXX for the moment, make this selection manual. it needs to be automatic - // based on the state of the SkyTable - HOST_ID = 0; - PARALLEL = FALSE; - if ((N = get_argument (argc, argv, "-parallel"))) { - PARALLEL = TRUE; - remove_argument (N, &argc, argv); - } - // this is a test mode : rather than launching the remote jobs and waiting for completion, - // relphot will simply list the remote command and wait for the user to signal completion - PARALLEL_MANUAL = FALSE; - if ((N = get_argument (argc, argv, "-parallel-manual"))) { - PARALLEL = TRUE; // -parallel-manual implies -parallel - PARALLEL_MANUAL = TRUE; - remove_argument (N, &argc, argv); - } - // this is a test mode : rather than launching the relphot_client jobs remotely, they are - // run in serial via 'system' - PARALLEL_SERIAL = FALSE; - if ((N = get_argument (argc, argv, "-parallel-serial"))) { - if (PARALLEL_MANUAL) { - fprintf (stderr, "ERROR: cannot mix -parallel-manual and -parallel-serial\n"); - exit (1); - } - PARALLEL = TRUE; // -parallel-serial implies -parallel - PARALLEL_SERIAL = TRUE; - remove_argument (N, &argc, argv); - } - - PLOTSTUFF = FALSE; - if ((N = get_argument (argc, argv, "-plot"))) { - PLOTSTUFF = TRUE; - remove_argument (N, &argc, argv); - } - - PLOTDELAY = 500000; - if ((N = get_argument (argc, argv, "-plotdelay"))) { - remove_argument (N, &argc, argv); - PLOTDELAY = 1e6*atof(argv[N]); - PLOTSTUFF = TRUE; // always turn on plotting if i request a plot delay - remove_argument (N, &argc, argv); - } - - if ((N = get_argument (argc, argv, "-outroot"))) { - remove_argument (N, &argc, argv); - OUTROOT = strcreate (argv[N]); - remove_argument (N, &argc, argv); - } else { - OUTROOT = strcreate ("relphot"); - } - - strcpy (STATMODE, "WT_MEAN"); - if ((N = get_argument (argc, argv, "-statmode"))) { - remove_argument (N, &argc, argv); - strcpy (STATMODE, argv[N]); - remove_argument (N, &argc, argv); - } - - NLOOP = 8; - if ((N = get_argument (argc, argv, "-n"))) { - remove_argument (N, &argc, argv); - NLOOP = atof (argv[N]); - remove_argument (N, &argc, argv); - } - if ((N = get_argument (argc, argv, "-nloop"))) { - remove_argument (N, &argc, argv); - NLOOP = atof (argv[N]); - remove_argument (N, &argc, argv); - } - - NGRID = 8; - if ((N = get_argument (argc, argv, "-ngrid"))) { - remove_argument (N, &argc, argv); - NGRID = atof (argv[N]); - remove_argument (N, &argc, argv); - } - - RESET = FALSE; - if ((N = get_argument (argc, argv, "-reset"))) { - remove_argument (N, &argc, argv); - RESET = TRUE; - } - - RESET_ZEROPTS = FALSE; - if ((N = get_argument (argc, argv, "-reset-zpts"))) { - remove_argument (N, &argc, argv); - RESET_ZEROPTS = TRUE; - } + + MIN_ERROR = 0.001; + if ((N = get_argument (argc, argv, "-minerror"))) { + remove_argument (N, &argc, argv); + MIN_ERROR = atof (argv[N]); + remove_argument (N, &argc, argv); + /* require MIN_ERROR > 0 */ + } UPDATE = FALSE; @@ -196,8 +585,41 @@ } - SAVE_IMAGE_UPDATES = TRUE; - if ((N = get_argument (argc, argv, "-skip-image-updates"))) { - remove_argument (N, &argc, argv); - SAVE_IMAGE_UPDATES = FALSE; + AreaSelect = FALSE; + if ((N = get_argument (argc, argv, "-area"))) { + remove_argument (N, &argc, argv); + AreaXmin = atof (argv[N]); + remove_argument (N, &argc, argv); + AreaXmax = atof (argv[N]); + remove_argument (N, &argc, argv); + AreaYmin = atof (argv[N]); + remove_argument (N, &argc, argv); + AreaYmax = atof (argv[N]); + remove_argument (N, &argc, argv); + AreaSelect = TRUE; + } + + SyntheticPhotometry = FALSE; + if ((N = get_argument (argc, argv, "-synthphot"))) { + remove_argument (N, &argc, argv); + SyntheticPhotometry = FALSE; + init_synthetic_mags(); + } + + ImagSelect = FALSE; + if ((N = get_argument (argc, argv, "-instmag"))) { + remove_argument (N, &argc, argv); + ImagMin = atof (argv[N]); + remove_argument (N, &argc, argv); + ImagMax = atof (argv[N]); + remove_argument (N, &argc, argv); + ImagSelect = TRUE; + } + + DophotSelect = FALSE; + if ((N = get_argument (argc, argv, "-dophot"))) { + remove_argument (N, &argc, argv); + DophotValue = atof (argv[N]); + remove_argument (N, &argc, argv); + DophotSelect = TRUE; } @@ -210,374 +632,8 @@ } - CLOUD_TOLERANCE = 0.02; - if ((N = get_argument (argc, argv, "-cloud-limit"))) { - remove_argument (N, &argc, argv); - CLOUD_TOLERANCE = atof(argv[N]); - remove_argument (N, &argc, argv); - } - - BOUNDARY_TREE = NULL; - if ((N = get_argument (argc, argv, "-boundary-tree"))) { - remove_argument (N, &argc, argv); - BOUNDARY_TREE = strcreate(argv[N]); - load_tree (BOUNDARY_TREE); - remove_argument (N, &argc, argv); - } - - SHOW_PARAMS = FALSE; - if ((N = get_argument (argc, argv, "-params"))) { - remove_argument (N, &argc, argv); - SHOW_PARAMS = TRUE; - } - - PlotMmin = 10.0; PlotMmax = 20.0; PlotdMmin = -1.0; PlotdMmax = 1.0; - if ((N = get_argument (argc, argv, "-plrange"))) { - remove_argument (N, &argc, argv); - PlotMmin = atof (argv[N]); - remove_argument (N, &argc, argv); - PlotMmax = atof (argv[N]); - remove_argument (N, &argc, argv); - PlotdMmin = atof (argv[N]); - remove_argument (N, &argc, argv); - PlotdMmax = atof (argv[N]); - remove_argument (N, &argc, argv); - } - - /* XXX this argument used to do two things: specify the camera name and tell the analysis to - calculate a common zero point for a single mosaic. I've moved the MOSAICNAME concept into the - config system, but need to use this argument to specify that the mosaic zeropoints should be - calculated. */ - MOSAIC_ZEROPT = FALSE; - if ((N = get_argument (argc, argv, "-mosaic"))) { - remove_argument (N, &argc, argv); - MOSAIC_ZEROPT = TRUE; - if (!strcasecmp (MOSAICNAME, "none")) { - fprintf (stderr, "mosaic astrometry selected by MOSAICNAME not defined\n"); - exit (2); - } - } - - FREEZE_IMAGES = FALSE; - if ((N = get_argument (argc, argv, "-imfreeze"))) { - remove_argument (N, &argc, argv); - FREEZE_IMAGES = TRUE; - } - - FREEZE_MOSAICS = FALSE; - if ((N = get_argument (argc, argv, "-mosfreeze"))) { - remove_argument (N, &argc, argv); - FREEZE_MOSAICS = TRUE; - } - - USE_GRID = FALSE; - if ((N = get_argument (argc, argv, "-grid"))) { - remove_argument (N, &argc, argv); - USE_GRID = TRUE; - } - - KEEP_UBERCAL = TRUE; - if ((N = get_argument (argc, argv, "-reset-ubercal"))) { - remove_argument (N, &argc, argv); - KEEP_UBERCAL = FALSE; - } - - MIN_ERROR = 0.001; - if ((N = get_argument (argc, argv, "-minerror"))) { - remove_argument (N, &argc, argv); - MIN_ERROR = atof (argv[N]); - remove_argument (N, &argc, argv); - /* require MIN_ERROR > 0 */ - } - - AreaSelect = FALSE; - if ((N = get_argument (argc, argv, "-area"))) { - remove_argument (N, &argc, argv); - AreaXmin = atof (argv[N]); - remove_argument (N, &argc, argv); - AreaXmax = atof (argv[N]); - remove_argument (N, &argc, argv); - AreaYmin = atof (argv[N]); - remove_argument (N, &argc, argv); - AreaYmax = atof (argv[N]); - remove_argument (N, &argc, argv); - AreaSelect = TRUE; - } - - ImagSelect = FALSE; - if ((N = get_argument (argc, argv, "-instmag"))) { - remove_argument (N, &argc, argv); - ImagMin = atof (argv[N]); - remove_argument (N, &argc, argv); - ImagMax = atof (argv[N]); - remove_argument (N, &argc, argv); - ImagSelect = TRUE; - } - - DophotSelect = FALSE; - if ((N = get_argument (argc, argv, "-dophot"))) { - remove_argument (N, &argc, argv); - DophotValue = atof (argv[N]); - remove_argument (N, &argc, argv); - DophotSelect = TRUE; - } - - SyntheticPhotometry = FALSE; - if ((N = get_argument (argc, argv, "-synthphot"))) { - remove_argument (N, &argc, argv); - SyntheticPhotometry = TRUE; - init_synthetic_mags(); - } - - refPhotcode = NULL; - if ((N = get_argument (argc, argv, "-refcode"))) { - remove_argument (N, &argc, argv); - refPhotcode = GetPhotcodebyName (argv[N]); - if (!refPhotcode) { - fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", argv[N]); - exit (1); - } - remove_argument (N, &argc, argv); - } - - UpdateAverages = FALSE; - if ((N = get_argument (argc, argv, "-averages"))) { - remove_argument (N, &argc, argv); - UpdateAverages = TRUE; - } - - ApplyOffsets = FALSE; - if ((N = get_argument (argc, argv, "-apply-offsets"))) { - remove_argument (N, &argc, argv); - ApplyOffsets = TRUE; - } - - if (UpdateAverages && (argc == 1)) return TRUE; - if (argc != 2) relphot_usage (); + if ((MODE == MODE_UPDATE_OBJECTS) && (argc == 1)) return TRUE; + if (argc != 2) relphot_client_usage (); return TRUE; } -int args_client (int argc, char **argv) { - - int N; - double trange; - - // by definition, the client is not parallel - PARALLEL = FALSE; - PARALLEL_MANUAL = FALSE; - PARALLEL_SERIAL = FALSE; - - HOST_ID = 0; - if ((N = get_argument (argc, argv, "-hostID"))) { - remove_argument (N, &argc, argv); - HOST_ID = atoi (argv[N]); - remove_argument (N, &argc, argv); - } - if (!HOST_ID) relphot_client_usage(); - - HOSTDIR = NULL; - if ((N = get_argument (argc, argv, "-hostdir"))) { - remove_argument (N, &argc, argv); - HOSTDIR = strcreate (argv[N]); - remove_argument (N, &argc, argv); - } - if (!HOSTDIR) relphot_client_usage(); - - IMAGES = NULL; // used in -update mode - BCATALOG = NULL; // used in -load mode - MODE = MODE_NONE; - if ((N = get_argument (argc, argv, "-load"))) { - MODE = MODE_LOAD; - remove_argument (N, &argc, argv); - BCATALOG = strcreate (argv[N]); - remove_argument (N, &argc, argv); - } - if ((N = get_argument (argc, argv, "-update-catalogs"))) { - if (MODE) { - fprintf (stderr, "ERROR: cannot mix modes (-load, -update-catalogs, -update-objects)\n"); - relphot_client_usage(); - } - MODE = MODE_UPDATE; - remove_argument (N, &argc, argv); - IMAGES = strcreate (argv[N]); - remove_argument (N, &argc, argv); - } - if ((N = get_argument (argc, argv, "-update-objects"))) { - if (MODE) { - fprintf (stderr, "ERROR: cannot mix modes (-load, -update-catalogs, -update-objects)\n"); - relphot_client_usage(); - } - MODE = MODE_UPDATE_OBJECTS; - remove_argument (N, &argc, argv); - } - if (!MODE) relphot_client_usage(); - - strcpy (STATMODE, "WT_MEAN"); - if ((N = get_argument (argc, argv, "-statmode"))) { - remove_argument (N, &argc, argv); - strcpy (STATMODE, argv[N]); - remove_argument (N, &argc, argv); - } - - BOUNDARY_TREE = NULL; - if ((N = get_argument (argc, argv, "-boundary-tree"))) { - remove_argument (N, &argc, argv); - BOUNDARY_TREE = strcreate(argv[N]); - load_tree (BOUNDARY_TREE); - remove_argument (N, &argc, argv); - } - - /* specify portion of the sky */ - UserPatch.Rmin = 0; - UserPatch.Rmax = 360; - UserPatch.Dmin = -90; - UserPatch.Dmax = +90; - if ((N = get_argument (argc, argv, "-region"))) { - remove_argument (N, &argc, argv); - UserPatch.Rmin = atof (argv[N]); - remove_argument (N, &argc, argv); - UserPatch.Rmax = atof (argv[N]); - remove_argument (N, &argc, argv); - UserPatch.Dmin = atof (argv[N]); - remove_argument (N, &argc, argv); - UserPatch.Dmax = atof (argv[N]); - remove_argument (N, &argc, argv); - } - - SET_MREL_VERSION = 1; - if ((N = get_argument (argc, argv, "-set-mrel-version"))) { - remove_argument (N, &argc, argv); - SET_MREL_VERSION = atof(argv[N]); - remove_argument (N, &argc, argv); - } - - VERBOSE = VERBOSE2 = FALSE; - if ((N = get_argument (argc, argv, "-v"))) { - VERBOSE = TRUE; - remove_argument (N, &argc, argv); - } - if ((N = get_argument (argc, argv, "-vv"))) { - VERBOSE2 = VERBOSE = TRUE; - remove_argument (N, &argc, argv); - } - - RESET = FALSE; - if ((N = get_argument (argc, argv, "-reset"))) { - remove_argument (N, &argc, argv); - RESET = TRUE; - } - - RESET_ZEROPTS = FALSE; - if ((N = get_argument (argc, argv, "-reset-zpts"))) { - remove_argument (N, &argc, argv); - RESET_ZEROPTS = TRUE; - } - - KEEP_UBERCAL = TRUE; - if ((N = get_argument (argc, argv, "-reset-ubercal"))) { - remove_argument (N, &argc, argv); - KEEP_UBERCAL = FALSE; - } - - /* define time */ - TimeSelect = FALSE; - if ((N = get_argument (argc, argv, "-time"))) { - remove_argument (N, &argc, argv); - if (!ohana_str_to_time (argv[N], &TSTART)) { - fprintf (stderr, "ERROR: syntax error\n"); - return (FALSE); - } - remove_argument (N, &argc, argv); - if (!ohana_str_to_dtime (argv[N], &trange)) { - if (!ohana_str_to_time (argv[N], &TSTOP)) { - fprintf (stderr, "ERROR: syntax error\n"); - return (FALSE); - } - } else { - if (trange < 0) { - trange = fabs (trange); - TSTOP = TSTART; - TSTART -= trange; - } else { - TSTOP = TSTART + trange; - } - } - remove_argument (N, &argc, argv); - TimeSelect = TRUE; - } - - - MIN_ERROR = 0.001; - if ((N = get_argument (argc, argv, "-minerror"))) { - remove_argument (N, &argc, argv); - MIN_ERROR = atof (argv[N]); - remove_argument (N, &argc, argv); - /* require MIN_ERROR > 0 */ - } - - UPDATE = FALSE; - if ((N = get_argument (argc, argv, "-update"))) { - remove_argument (N, &argc, argv); - UPDATE = TRUE; - } - - UPDATE_CATFORMAT = NULL; - if ((N = get_argument (argc, argv, "-update-catformat"))) { - remove_argument (N, &argc, argv); - UPDATE_CATFORMAT = strcreate (argv[N]); - remove_argument (N, &argc, argv); - } - - AreaSelect = FALSE; - if ((N = get_argument (argc, argv, "-area"))) { - remove_argument (N, &argc, argv); - AreaXmin = atof (argv[N]); - remove_argument (N, &argc, argv); - AreaXmax = atof (argv[N]); - remove_argument (N, &argc, argv); - AreaYmin = atof (argv[N]); - remove_argument (N, &argc, argv); - AreaYmax = atof (argv[N]); - remove_argument (N, &argc, argv); - AreaSelect = TRUE; - } - - SyntheticPhotometry = FALSE; - if ((N = get_argument (argc, argv, "-synthphot"))) { - remove_argument (N, &argc, argv); - SyntheticPhotometry = FALSE; - init_synthetic_mags(); - } - - ImagSelect = FALSE; - if ((N = get_argument (argc, argv, "-instmag"))) { - remove_argument (N, &argc, argv); - ImagMin = atof (argv[N]); - remove_argument (N, &argc, argv); - ImagMax = atof (argv[N]); - remove_argument (N, &argc, argv); - ImagSelect = TRUE; - } - - DophotSelect = FALSE; - if ((N = get_argument (argc, argv, "-dophot"))) { - remove_argument (N, &argc, argv); - DophotValue = atof (argv[N]); - remove_argument (N, &argc, argv); - DophotSelect = TRUE; - } - - MaxDensityUse = FALSE; - if ((N = get_argument (argc, argv, "-max-density"))) { - remove_argument (N, &argc, argv); - MaxDensityValue = atof(argv[N]); - remove_argument (N, &argc, argv); - MaxDensityUse = TRUE; - } - - if ((MODE == MODE_UPDATE_OBJECTS) && (argc == 1)) return TRUE; - if (argc != 2) relphot_client_usage (); - - return TRUE; -} - Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/assign_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/assign_images.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/assign_images.c (revision 37067) @@ -0,0 +1,289 @@ +# include "relphot.h" + +// This function generates a subset of the images based on selections. Input db has already +// been loaded with the raw fits table data +int assign_images (FITS_DB *db, RegionHostTable *regionHosts) { + + off_t Nimage; + + INITTIME; + + // convert database table to internal structure (binary to Image) + // 'image' points to the same memory as db->ftable->buffer + Image *image = gfits_table_get_Image (&db[0].ftable, &Nimage, &db[0].swapped); + if (!image) { + fprintf (stderr, "ERROR: failed to read images\n"); + exit (2); + } + MARKTIME("convert image table to internal structure: %f sec\n", dtime); + + // *** NOTE : for the moment, regions must be in the range 0 - 360, -90 - +90 + + // generate the chip match here so we can define the mosaic centers (if needed) + BuildChipMatch (image, Nimage); + MARKTIME("build chip match for %d images: %f sec\n", (int) Nimage, dtime); + + if (MOSAIC_ZEROPT) { + makeMosaics (image, Nimage, FALSE); + + // center coords and Mcal, dMcal, Mchisq for the mosaics + setMosaicCenters (image, Nimage); + MARKTIME("set mosaic coordinates and Mcal values: %f sec\n", dtime); + } + + // register the image array with ImageOps.c for later getimageByID calls + initImages (image, NULL, Nimage); + + if (VERBOSE) fprintf (stderr, "finding images\n"); + + // for each regionHost, select images which are contained by the region + // even faster would be to use a tree to get to the real regions... + select_images_hostregion (regionHosts, image, Nimage); + + return TRUE; +} + +# define D_NIMAGE 1000 + +// assign images to the region hosts; at the end, each host will have its list of images +int select_images_hostregion (RegionHostTable *regionHosts, Image *image, off_t Nimage) { + + int ecode, found; + off_t i, j; + + // INITTIME; + + for (i = 0; i < regionHosts->Nhosts; i++) { + regionHosts->hosts[i].Nimage = 0; + regionHosts->hosts[i].NIMAGE = D_NIMAGE; + ALLOCATE (regionHosts->hosts[i].image, Image, regionHosts->hosts[i].NIMAGE); + } + + for (j = 0; j < Nimage; j++) { + + /* exclude images by photcode */ + ecode = GetPhotcodeEquivCodebyCode (image[j].photcode); + found = FALSE; + int Ns; + for (Ns = 0; !found && (Ns < Nphotcodes); Ns++) { + if (ecode == photcodes[Ns][0].code) found = TRUE; + } + if (!found) continue; + + /* exclude images by time */ + if (TimeSelect) { + if (image[j].tzero < TSTART) continue; + if (image[j].tzero > TSTOP) continue; + } + + // do not include DIS (PHU-level mosaics) in the output list + if (!strcmp(&image[j].coords.ctype[4], "-DIS")) continue; + + // match the image to its corresponding ASTROMETRIC mosaic (not the same as the Mosaic above) + if (!FindMosaicForImage (image, Nimage, j)) { + if (VERBOSE2) fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i); + continue; + } + + // Exclude images with crazy astrometry + // XXX NOTE : this is gpc1-specific + { + double dP1 = hypot(image[j].coords.pc1_1, image[j].coords.pc1_2); + double dP2 = hypot(image[j].coords.pc2_1, image[j].coords.pc2_2); + if (fabs(dP1 - 1.0) > 0.02) continue; + if (fabs(dP2 - 1.0) > 0.02) continue; + + double X00, Y00, X10, Y10, X01, Y01; + XY_to_LM (&X00, &Y00, 0.0, 0.0, &image[j].coords); + XY_to_LM (&X10, &Y10, image[j].NX, 0.0, &image[j].coords); + XY_to_LM (&X01, &Y01, 0.0, image[j].NY, &image[j].coords); + double dS0 = hypot ((X00 - X10), (Y00 - Y10)); + double dS1 = hypot ((X00 - X01), (Y00 - Y01)); + if (dS0 > 6000) continue; + if (dS1 > 6500) continue; + } + + // use a reference coordinate for each image to assign to hosts + // define image center - note the DIS images (mosaic phu) are special, but we have + // already excluded them above. we also save the image centers for reference + double Xc, Yc; + double Rc, Dc; + + Xc = 0.5*image[j].NX; + Yc = 0.5*image[j].NY; + + XY_to_RD (&Rc, &Dc, Xc, Yc, &image[j].coords); + Rc = ohana_normalize_angle_to_midpoint (Rc, 180.0); + image[j].RAo = Rc; + image[j].DECo = Dc; + + // NOTE: if we are NOT using mosaic centers, we don't need to keep chips with centers + // on opposite sides of 0,360 together. in which case, it is OK for the range of Rc + // to be 0.0 to 360.0. also NOTE: RAo,DECo are only used for debugging reference. + + if (MOSAIC_ZEROPT) { + // use the coords of the associated mosaic to select + Mosaic *mosaic = getMosaicForImage (j); + Rc = mosaic->coords.crval1; + Dc = mosaic->coords.crval2; + // NOTE : have defined mosaic Rc,Dc to choose the side of 0,360 on which most of the + // chips are located. but, for host assignment, we rationalize to 0.0 - 360.0 + Rc = ohana_normalize_angle_to_midpoint (Rc, 180.0); + } + + i = find_host_for_coords (regionHosts, Rc, Dc); + + if (i == -1) continue; + + RegionHostInfo *host = ®ionHosts->hosts[i]; + + // image bounds are defined for a range centered on the mosaic center thus, a mosaic + // with center 0.5 will have chips bounds ranging from ~ -1.5 to +2.5 or so, while a mosaic + // with center 359.5 will have chips bounds ranging from ~ 357.5 to 361.5 or so + double Rmin, Rmax, Dmin, Dmax; + calculate_image_bounds (&image[j], &Rmin, &Rmax, &Dmin, &Dmax, Rc); + + host->RminCat = MIN(Rmin, host->RminCat); + host->RmaxCat = MAX(Rmax, host->RmaxCat); + host->DminCat = MIN(Dmin, host->DminCat); + host->DmaxCat = MAX(Dmax, host->DmaxCat); + + // regionHosts needs to have the full outer boundary + // (so reload_catalogs covers the correct region) + regionHosts->Rmin = MIN(Rmin, regionHosts->Rmin); + regionHosts->Rmax = MAX(Rmax, regionHosts->Rmax); + regionHosts->Dmin = MIN(Dmin, regionHosts->Dmin); + regionHosts->Dmax = MAX(Dmax, regionHosts->Dmax); + + // this is a bit memory expensive : I am making a complete copy of the image table here + off_t Nsubset = regionHosts->hosts[i].Nimage; + regionHosts->hosts[i].image[Nsubset] = image[j]; + // regionHosts->hosts[i].line_number[Nsubset] = j; + + regionHosts->hosts[i].Nimage ++; + if (regionHosts->hosts[i].Nimage == regionHosts->hosts[i].NIMAGE) { + regionHosts->hosts[i].NIMAGE += D_NIMAGE; + REALLOCATE (regionHosts->hosts[i].image, Image, regionHosts->hosts[i].NIMAGE); + // REALLOCATE (regionHosts->hosts[i].line_number, off_t, regionHosts->hosts[i].NIMAGE); + } + } + + return TRUE; +} + +double Xf[] = {0.0, 1.0, 0.0, 1.0}; +double Yf[] = {0.0, 0.0, 1.0, 1.0}; + +int calculate_image_bounds (Image *image, double *rmin, double *rmax, double *dmin, double *dmax, double Rmid) { + + int n; + + double Rmin = 360.0; + double Rmax = 0.0; + double Dmin = +90.0; + double Dmax = -90.0; + + // define image corners + for (n = 0; n < 4; n++) { + double Xc, Yc, Rc, Dc; + Xc = Xf[n]*image->NX; + Yc = Yf[n]*image->NY; + XY_to_RD (&Rc, &Dc, Xc, Yc, &image->coords); + Rc = ohana_normalize_angle_to_midpoint (Rc, Rmid); + + Rmin = MIN (Rmin, Rc); + Rmax = MAX (Rmax, Rc); + Dmin = MIN (Dmin, Dc); + Dmax = MAX (Dmax, Dc); + } + + *rmin = Rmin; + *rmax = Rmax; + *dmin = Dmin; + *dmax = Dmax; + + return TRUE; +} + +int calculate_host_image_bounds (RegionHostTable *regionHosts, double Rmid) { + + int i, n; + off_t j; + + for (i = 0; i < regionHosts->Nhosts; i++) { + + RegionHostInfo *host = ®ionHosts->hosts[i]; + + // XXX clear the chip match? + + BuildChipMatch (host->image, host->Nimage); + + double Rmin = 720.0; + double Rmax = -360.0; + double Dmin = +90.0; + double Dmax = -90.0; + + for (j = 0; j < host->Nimage; j++) { + + Image *image = &host->image[j]; + + if (!FindMosaicForImage (host->image, host->Nimage, j)) { + fprintf (stderr, "missing astrometry? programming error?\n"); + abort (); + } + + // define image corners + for (n = 0; n < 4; n++) { + double Xc, Yc, Rc, Dc; + Xc = Xf[n]*image->NX; + Yc = Yf[n]*image->NY; + XY_to_RD (&Rc, &Dc, Xc, Yc, &image->coords); + Rc = ohana_normalize_angle_to_midpoint (Rc, Rmid); + + Rmin = MIN (Rmin, Rc); + Dmin = MIN (Dmin, Rc); + + Rmax = MAX (Rmax, Rc); + Dmax = MAX (Dmax, Rc); + } + + } + + // RminCat, RmaxCat may extended beyond 0.0 - 360.0 + host->RminCat = Rmin; + host->DminCat = Dmin; + host->RmaxCat = Rmax; + host->DmaxCat = Dmax; + + // regionHosts needs to have the full outer boundary + // (so reload_catalogs covers the correct region) + regionHosts->Rmin = MIN(Rmin, regionHosts->Rmin); + regionHosts->Rmax = MAX(Rmax, regionHosts->Rmax); + regionHosts->Dmin = MIN(Dmin, regionHosts->Dmin); + regionHosts->Dmax = MAX(Dmax, regionHosts->Dmax); + } + return TRUE; +} + + +// Rc is in range 0.0 - 360.0, hosts Rmin,Rmax in range 0.0 - 360.0 +int find_host_for_coords (RegionHostTable *regionHosts, double Rc, double Dc) { + + int i; + + if (isnan(Rc)) return -1; + if (isnan(Dc)) return -1; + + for (i = 0; i < regionHosts->Nhosts; i++) { + + RegionHostInfo *host = ®ionHosts->hosts[i]; + if (Rc < host->Rmin) continue; + if (Rc >= host->Rmax) continue; + if (Dc < host->Dmin) continue; + if (Dc >= host->Dmax) continue; + + return i; + } + return -1; +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/bcatalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/bcatalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/bcatalog.c (revision 37067) @@ -23,4 +23,7 @@ Nmeasure = Naverage = 0; + int NmMax = 0; + int NmMin = catalog[0].Nmeasure; + Ncode = Ntime = Ndophot = Nmag = Nsigma = Nimag = Nfew = Npsfqf = Ngalaxy = Nnan = Nbad = Npoor = 0; @@ -55,4 +58,6 @@ if (RESET) { int Ns; + +# if (0) DVOSecfiltFlags secfiltBits = ID_SECF_STAR_FEW | @@ -66,4 +71,6 @@ ID_SECF_USE_UBERCAL | ID_SECF_OBJ_EXT; +# endif + for (Ns = 0; Ns < Nphotcodes; Ns++) { @@ -71,15 +78,18 @@ int Nsec = GetPhotcodeNsec(thisCode); - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].M = NAN; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Map = NAN; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].dM = NAN; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Mstdev = NAN_S_SHORT; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Xm = NAN; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].M_20 = NAN_S_SHORT; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].M_80 = NAN_S_SHORT; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Ncode = 0; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Nused = 0; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].flags &= ~secfiltBits; - subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].ubercalDist = 1000; + fprintf (stderr, "really use dvo_secfilt_init?"); + dvo_secfilt_init (&subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec]); + + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].M = NAN; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Map = NAN; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].dM = NAN; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Mstdev = NAN_S_SHORT; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Mchisq = NAN; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].M_20 = NAN_S_SHORT; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].M_80 = NAN_S_SHORT; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Ncode = 0; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].Nused = 0; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].flags &= ~secfiltBits; + // subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].ubercalDist = 1000; } } @@ -136,5 +146,5 @@ /* select measurements by mag limit */ - mag = PhotCat (&catalog[0].measure[offset]); + mag = PhotCat (&catalog[0].measure[offset], MAG_CLASS_PSF); if (mag > MAG_LIM) { Nmag ++; continue; } @@ -144,5 +154,5 @@ /* select measurements by mag limit */ if (ImagSelect) { - mag = PhotInst (&catalog[0].measure[offset]); + mag = PhotInst (&catalog[0].measure[offset], MAG_CLASS_PSF); if (mag < ImagMin) { Nimag ++; continue; } if (mag > ImagMax) { Nimag ++; continue; } @@ -180,5 +190,5 @@ } myAssert (Nmeasure < NMEASURE, "realloc failure"); - } + } // end of catalog.average.Nmeasure loop // skip object if it is likely to be a galaxy @@ -205,4 +215,6 @@ continue; } + NmMin = MIN (Nm, NmMin); + NmMax = MAX (Nm, NmMax); // for w-band photometry (& other cases?) convert gri photometry @@ -235,4 +247,11 @@ subcatalog[0].Nsecf_mem = Naverage * catalog[0].Nsecfilt; + if (VERBOSE) { + fprintf (stderr, "using "OFF_T_FMT" stars ("OFF_T_FMT" measures) of "OFF_T_FMT" ("OFF_T_FMT" measures) for catalog %s, %d < Nm < %d\n", + subcatalog[0].Naverage, subcatalog[0].Nmeasure, catalog[0].Naverage, catalog[0].Nmeasure, catalog[0].filename, NmMin, NmMax); + fprintf (stderr, "rejections: %d stars have too few measures:\n %d code, %d time, %d dophot, %d mag, %d sigma, %d imag, %d psfqf, %d Nnan, %d galaxies, %d bad, %d poor\n", + Nfew, Ncode, Ntime, Ndophot, Nmag, Nsigma, Nimag, Npsfqf, Nnan, Ngalaxy, Nbad, Npoor); + } + // limit the total number of stars in the catalog if (MaxDensityUse) { @@ -240,10 +259,4 @@ } - if (VERBOSE) { - fprintf (stderr, "using "OFF_T_FMT" stars ("OFF_T_FMT" measures) of "OFF_T_FMT" for catalog %s\n", - subcatalog[0].Naverage, subcatalog[0].Nmeasure, i, catalog[0].filename); - fprintf (stderr, "rejections: %d code, %d time, %d dophot, %d mag, %d sigma, %d imag, %d few, %d psfqf, %d Nnan, %d galaxies, %d bad, %d poor\n", - Ncode, Ntime, Ndophot, Nmag, Nsigma, Nimag, Nfew, Npsfqf, Nnan, Ngalaxy, Nbad, Npoor); - } return (TRUE); } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/client_logger.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/client_logger.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/client_logger.c (revision 37067) @@ -5,13 +5,13 @@ static FILE *logfile = NULL; -int client_logger_init () { +int client_logger_init (char *dirname) { char filename[DVO_MAX_PATH]; - snprintf (filename, DVO_MAX_PATH, "%s/log.rlpc.XXXXXX", HOSTDIR); + snprintf (filename, DVO_MAX_PATH, "%s/log.rlpc.XXXXXX", dirname); int fd = mkstemp (filename); if (fd == -1) { - fprintf (stderr, "failed to open client logger, exiting\n"); + fprintf (stderr, "failed to open client logger %s, exiting\n", filename); exit (50); } @@ -32,4 +32,6 @@ vfprintf (logfile, format, argp); va_end (argp); + + fflush (logfile); return TRUE; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/extra.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/extra.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/extra.c (revision 37067) @@ -0,0 +1,40 @@ +# include "relphot.h" + +// for now (20140710) I need to identify gpc1 chips explicitly. generalize in the future +int isGPC1chip (int photcode) { + + if ((photcode > 10000) && (photcode < 10077)) return TRUE; // g-band + if ((photcode > 10100) && (photcode < 10177)) return TRUE; // r-band + if ((photcode > 10200) && (photcode < 10277)) return TRUE; // i-band + if ((photcode > 10300) && (photcode < 10377)) return TRUE; // z-band + if ((photcode > 10400) && (photcode < 10477)) return TRUE; // y-band + if ((photcode > 10500) && (photcode < 10577)) return TRUE; // w-band + + return FALSE; +} + +// for now (20140710) I need to identify gpc1 stacks explicitly. generalize in the future +int isGPC1stack (int photcode) { + + if (photcode == 11000) return TRUE; // g-band + if (photcode == 11100) return TRUE; // r-band + if (photcode == 11200) return TRUE; // i-band + if (photcode == 11300) return TRUE; // z-band + if (photcode == 11400) return TRUE; // y-band + if (photcode == 11500) return TRUE; // w-band + + return FALSE; +} + +// for now (20140710) I need to identify gpc1 stacks explicitly. generalize in the future +int isGPC1warp (int photcode) { + + if (photcode == 12000) return TRUE; // g-band + if (photcode == 12100) return TRUE; // r-band + if (photcode == 12200) return TRUE; // i-band + if (photcode == 12300) return TRUE; // z-band + if (photcode == 12400) return TRUE; // y-band + if (photcode == 12500) return TRUE; // w-band + + return FALSE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/help.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/help.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/help.c (revision 37067) @@ -2,7 +2,11 @@ void relphot_usage (void) { - fprintf (stderr, "ERROR: USAGE: relphot (photcodes) -region RA RA DEC DEC\n"); - fprintf (stderr, " or: relphot (photcodes) -catalog (name)\n"); - fprintf (stderr, " or: relphot -averages -region RA RA DEC DEC\n"); + fprintf (stderr, "ERROR: USAGE: relphot (photcodes) -images\n"); + fprintf (stderr, " or: relphot -averages\n"); + fprintf (stderr, " or: relphot -apply-offsets\n"); + fprintf (stderr, " or: relphot (photcodes) -parallel-regions -region-hosts (RegionFile)\n"); + fprintf (stderr, " or: relphot (photcodes) -parallel-images (ImageTable) -region-hosts (RegionFile)\n\n"); + fprintf (stderr, " regions: -region RA RA DEC DEC)\n"); + fprintf (stderr, " or: -catalog (name)\n"); fprintf (stderr, " use -h for more usage information\n"); exit (2); @@ -18,7 +22,11 @@ show_help: - fprintf (stderr, "ERROR: USAGE: relphot (photcode) -region RA RA DEC DEC\n"); - fprintf (stderr, " or: relphot (photcode) -catalog (name)\n"); - fprintf (stderr, " or: relphot -averages -region RA RA DEC DEC\n"); + fprintf (stderr, "ERROR: USAGE: relphot (photcodes) -images\n"); + fprintf (stderr, " or: relphot -averages\n"); + fprintf (stderr, " or: relphot -apply-offsets\n"); + fprintf (stderr, " or: relphot (photcodes) -parallel-regions -region-hosts (RegionFile)\n"); + fprintf (stderr, " or: relphot (photcodes) -parallel-images (ImageTable) -region-hosts (RegionFile)\n\n"); + fprintf (stderr, " regions: -region RA RA DEC DEC)\n"); + fprintf (stderr, " or: -catalog (name)\n"); fprintf (stderr, " options: \n"); fprintf (stderr, " -time (start) (stop)\n"); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/indexCatalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/indexCatalog.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/indexCatalog.c (revision 37067) @@ -0,0 +1,64 @@ +# include "relphot.h" + +static int catIDmax = 0; +static int *catIDseq = NULL; +static int *objIDmax = NULL; +static int **objIDseq = NULL; + +int indexCatalogs (Catalog *catalog, int Ncatalog) { + + int i; + off_t j; + + // find the max value of catID + for (i = 0; i < Ncatalog; i++) { + catIDmax = MAX (catalog[i].catID, catIDmax); + } + + ALLOCATE (catIDseq, int, catIDmax + 1); + for (i = 0; i < catIDmax + 1; i++) { + catIDseq[i] = -1; + } + + for (i = 0; i < Ncatalog; i++) { + int catID = catalog[i].catID; + catIDseq[catID] = i; + } + + ALLOCATE (objIDmax, int, Ncatalog); + ALLOCATE (objIDseq, int *, Ncatalog); + for (i = 0; i < Ncatalog; i++) { + objIDmax[i] = 0; + for (j = 0; j < catalog[i].Naverage; j++) { + objIDmax[i] = MAX (catalog[i].averageT[j].objID, objIDmax[i]); + } + + ALLOCATE (objIDseq[i], int, objIDmax[i] + 1); + for (j = 0; j < objIDmax[i] + 1; j++) { + objIDseq[i][j] = -1; + } + + for (j = 0; j < catalog[i].Naverage; j++) { + int objID = catalog[i].averageT[j].objID; + objIDseq[i][objID] = j; + } + } + return TRUE; +} + +int catID_and_objID_to_seq (int catID, int objID, int *catSeq, off_t *objSeq) { + + if (catID > catIDmax) return FALSE; + + int cat = catIDseq[catID]; + if (cat < 1) return FALSE; + + if (objID > objIDmax[cat]) return FALSE; + + int obj = objIDseq[cat][objID]; + if (obj < 1) return FALSE; + + *catSeq = cat; + *objSeq = obj; + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/initialize.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/initialize.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/initialize.c (revision 37067) @@ -1,16 +1,13 @@ # include "relphot.h" -void initialize (int argc, char **argv) { +RelphotMode initialize (int argc, char **argv) { relphot_help (argc, argv); ConfigInit (&argc, argv); - args (argc, argv); + RelphotMode mode = args (argc, argv); + if (!mode) exit (2); - if (!UpdateAverages) { - // load the list of photcodes into the globals (photcodes, Nphotcodes) - // only a single remaining argument in this mode (the list of photcodes, eg g,r,i) - PhotcodeList = strcreate (argv[1]); - photcodes = ParsePhotcodeList (PhotcodeList, &Nphotcodes, TRUE); // require SEC photcodes - } else { + // UPDATE_AVERAGES always operates on all photcodes? + if (mode == UPDATE_AVERAGES) { char tmpline1[256]; int Ns; @@ -39,5 +36,14 @@ if (SHOW_PARAMS) { - fprintf (stderr, "current parameter settings:\n"); + int Ns; + fprintf (stderr, "subset selection criteria:\n"); + fprintf (stderr, " photcodes "); + for (Ns = 0; Ns < Nphotcodes; Ns++) { + if (Ns == Nphotcodes - 1) { + fprintf (stderr, "%s\n", photcodes[Ns][0].name); + } else { + fprintf (stderr, "%s, ", photcodes[Ns][0].name); + } + } if (TimeSelect) { fprintf (stderr, "TimeSelect: TRUE (%s - %s)\n", ohana_sec_to_date (TSTART), ohana_sec_to_date (TSTOP)); @@ -45,4 +51,18 @@ fprintf (stderr, "TimeSelect: FALSE\n"); } + if (DophotSelect) { + fprintf (stderr, "DophotSelect: TRUE (%d)\n", DophotValue); + } else { + fprintf (stderr, "DophotSelect: FALSE\n"); + } + fprintf (stderr, "PSF_QF limit: 0.85 (hardwired)\n"); + + // fprintf (stderr, "Photom Bad Mask: 0x%08x, Photom Poor Mask: 0x%08x\n"); + + fprintf (stderr, "MAG_LIM: %f, SIGMA_LIM: %f\n", MAG_LIM, SIGMA_LIM); + fprintf (stderr, "INST_MAG_MIN: %f, INST_MAG_MAX: %f\n", ImagMin, ImagMax); + + fprintf (stderr, "STAR_TOOFEW: %d\n", STAR_TOOFEW); + fprintf (stderr, "VERBOSE: %d, PLOTSTUFF: %d\n", VERBOSE, PLOTSTUFF); fprintf (stderr, "GRID_X: %d, GRID_Y: %d, BINNING: %d == Nmx: %d, Nmy: %d\n", @@ -52,5 +72,4 @@ (int)(RELPHOT_GRID_X/RELPHOT_GRID_BINNING), (int)(RELPHOT_GRID_Y/RELPHOT_GRID_BINNING)); - fprintf (stderr, "MAG_LIM %lf\n", MAG_LIM); fprintf (stderr, "STAR_SCATTER %lf\n", STAR_SCATTER); fprintf (stderr, "IMAGE_SCATTER %lf\n", IMAGE_SCATTER); @@ -59,5 +78,4 @@ fprintf (stderr, "GSCFILE %s\n", GSCFILE); fprintf (stderr, "CATDIR %s\n", CATDIR); - exit (0); } @@ -67,4 +85,6 @@ for (B = 0; A == time(NULL); B++); srand48(B); + + return mode; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/launch_region_hosts.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/launch_region_hosts.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/launch_region_hosts.c (revision 37067) @@ -0,0 +1,126 @@ +# include "relphot.h" +# define DEBUG 0 + +int strextend (char *input, char *format,...) { + + char tmpextra[1024], tmpline[1024]; + va_list argp; + + va_start (argp, format); + vsnprintf (tmpextra, 1024, format, argp); + snprintf (tmpline, 1024, "%s %s", input, tmpextra); + strcpy (input, tmpline); + + return TRUE; +} + +int launch_region_hosts (RegionHostTable *regionHosts) { + + int i; + + // clear the I/O files + for (i = 0; i < regionHosts->Nhosts; i++) { + char *syncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanmags.sync"); + if (truncate (syncfile, 0)) fprintf (stderr, "trouble clearing syncfile %s\n", syncfile); + free (syncfile); + + char *fitsfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanmags.fits"); + if (truncate (fitsfile, 0)) fprintf (stderr, "trouble clearing fitsfile %s\n", fitsfile ); + free (fitsfile); + + char *imsyncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagemags.sync"); + if (truncate (imsyncfile, 0)) fprintf (stderr, "trouble clearing imsyncfile %s\n", imsyncfile); + free (imsyncfile); + + char *imfitsfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagemags.fits"); + if (truncate (imfitsfile, 0)) fprintf (stderr, "trouble clearing imfitsfile %s\n", imfitsfile); + free (imfitsfile); + + char *loopsyncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "loop.sync"); + if (truncate (loopsyncfile, 0)) fprintf (stderr, "trouble clearing loopsyncfile %s\n", loopsyncfile); + free (loopsyncfile); + } + + for (i = 0; i < regionHosts->Nhosts; i++) { + + RegionHostInfo *host = ®ionHosts->hosts[i]; + + // communication files: + // subset images per host : CATDIR/Image.HOSTNAME.fits + char filename[1024]; + snprintf (filename, 1024, "%s/Image.%d.fits", CATDIR, host->hostID); + + // write the image subset for this host + ImageTableSave (filename, host->image, host->Nimage); + + char command[1024]; + snprintf (command, 1024, "relphot %s", PhotcodeList); + strextend (command, "-parallel-images %s", filename); + strextend (command, "-region-hosts %s", REGION_FILE); + strextend (command, "-region-hostID %d", host->hostID); + strextend (command, "-D CATDIR %s", CATDIR); + strextend (command, "-region %f %f %f %f", host->RminCat, host->RmaxCat, host->DminCat, host->DmaxCat); + strextend (command, "-statmode %s", STATMODE); + strextend (command, "-D CAMERA %s", CAMERA); + strextend (command, "-D STAR_TOOFEW %d", STAR_TOOFEW); + strextend (command, "-minerror %f", MIN_ERROR); + strextend (command, "-cloud-limit %f", CLOUD_TOLERANCE); + + if (VERBOSE) strextend (command, "-v"); + if (VERBOSE2) strextend (command, "-vv"); + if (RESET) strextend (command, "-reset"); + if (RESET_ZEROPTS) strextend (command, "-reset-zpts"); + if (!KEEP_UBERCAL) strextend (command, "-reset-ubercal"); + if (DophotSelect) strextend (command, "-dophot %d", DophotValue); + if (ImagSelect) strextend (command, "-instmag %f %f", ImagMin, ImagMax); + if (MaxDensityUse) strextend (command, "-max-density %f", MaxDensityValue); + if (SyntheticPhotometry) strextend (command, "-synthphot"); + + if (UPDATE) strextend (command, "-update"); + if (MOSAIC_ZEROPT) strextend (command, "-mosaic"); + if (FREEZE_IMAGES) strextend (command, "-imfreeze"); + if (FREEZE_MOSAICS) strextend (command, "-mosfreeze"); + if (PARALLEL) strextend (command, "-parallel"); + if (PARALLEL_MANUAL) strextend (command, "-parallel-manual"); + if (PARALLEL_SERIAL) strextend (command, "-parallel-serial"); + + // XXX deprecate this if we are happy with the new version + if (SET_MREL_VERSION != 1) strextend (command, "-set-mrel-version %d", SET_MREL_VERSION); + + fprintf (stderr, "command: %s\n", command); + + if (PARALLEL_REGIONS_MANUAL) continue; + + // launch the job, then wait for it to be done loading catalogs. force the remote + // client to generate the file + char *syncfile = make_filename (CATDIR, host->hostname, host->hostID, "loadcat.sync"); + clear_sync_file (syncfile); + + // launch the job on the remote machine (no handshake) + int errorInfo = 0; + int pid = rconnect ("ssh", host->hostname, command, host->stdio, &errorInfo, FALSE); + if (!pid) { + if (DEBUG) fprintf (stderr, "failure to start %s (error %d)\n", host->hostname, errorInfo); + exit (1); + } + host->pid = pid; // save for future reference + + // remote client is done, go ahead with next client + check_sync_file (syncfile, 1); + free (syncfile); + } + + if (PARALLEL_REGIONS_MANUAL) { + fprintf (stderr, "run the relphot_client commands above. when these are done, hit return\n"); + getchar(); + } else { + RegionHostTableWaitJobsGetIO (regionHosts, __FILE__, __LINE__, VERBOSE); + } + + int status = TRUE; + for (i = 0; i < regionHosts->Nhosts; i++) { + status = status && (regionHosts->hosts[i].status == 0); + } + + return status; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/load_catalogs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/load_catalogs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/load_catalogs.c (revision 37067) @@ -12,5 +12,5 @@ // if this function is called with a specified hostID, then only the fraction of the // database hosted by that hostID is loaded -Catalog *load_catalogs (SkyList *skylist, int *Ncatalog, int hostID, char *hostpath) { +Catalog *load_catalogs (SkyList *skylist, int *Ncatalog, int hostID, char *hostpath, char *syncfile) { off_t i, Nmeas, Nstar, Nmeas_total, Nstar_total; @@ -19,5 +19,5 @@ // XXX need to decide how to determine PARALLEL mode... if (PARALLEL && !hostID) { - catalog = load_catalogs_parallel (skylist, Ncatalog); + catalog = load_catalogs_parallel (skylist, Ncatalog, syncfile); return catalog; } @@ -89,7 +89,12 @@ fprintf (stderr, "using "OFF_T_FMT" of "OFF_T_FMT" stars ("OFF_T_FMT" of "OFF_T_FMT" measurements)\n", Nstar, Nstar_total, Nmeas, Nmeas_total); - if (!hostID && (Nstar < 1)) Shutdown ("%s", "ERROR: no stars match the minimum requirements; exiting \n"); + if (!hostID && !REGION_HOST_ID && (Nstar < 1)) Shutdown ("%s", "ERROR: no stars match the minimum requirements; exiting \n"); // in regular relphot, we shutdown here; in relphot_client, we generate and return an empty table (for consistency) - + + // if we are running with parallel_images but not a parallel database, we need to + // release the lock so the next image host can proceed + if (!hostID && syncfile) { + update_sync_file (syncfile, 1); + } // XXX consider only returning the populated catalogs @@ -106,5 +111,10 @@ // CATDIR is supplied globally # define DEBUG 1 -Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog) { +Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog, char *syncfile) { + + char uniquer[12]; + int TIME = time(NULL); + int PID = getpid(); + snprintf (uniquer, 12, "%05d.%05d", PID, TIME % 100000); int Nsecfilt = GetPhotcodeNsecfilt (); // set the desired number in case we need to create the catalog @@ -128,5 +138,5 @@ ALLOCATE (table->hosts[i].results, char, 1024); - snprintf (table->hosts[i].results, 1024, "%s/relphot.catalog.subset.dat", table->hosts[i].pathname); + snprintf (table->hosts[i].results, 1024, "%s/relphot.catalog.%s.dat", table->hosts[i].pathname, uniquer); // options / arguments that can affect relphot_client -load: @@ -202,4 +212,17 @@ } + // update syncfile here (save lots of I/O time): + + // at this point, the remote relastro_client jobs are done loading their data. in a + // parallel_images mode, the next image host can be launched while this image host now + // reads that + + // NOTE: if I let all hosts load blindly, I saturate the data clients with too many + // relphot_client requests. I need to have the master mediate this. the master + // will not launch the next remote job until this one says it is done + if (syncfile) { + update_sync_file (syncfile, 1); + } + // each host generates a BrightCatalog structure, with the measure, average, etc value // loaded into a single set of arrays (of MeasureTiny, AverageTiny, Secfilt). I need to Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/plot_scatter.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/plot_scatter.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/plot_scatter.c (revision 37067) @@ -51,6 +51,6 @@ xlist[N] = Mrel; - ylist[N] = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt]) - Mcal - Mmos - Mgrid - Mrel; - ilist[N] = PhotInstTiny (&catalog[i].measureT[m]); + ylist[N] = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt], MAG_CLASS_PSF) - Mcal - Mmos - Mgrid - Mrel; + ilist[N] = PhotInstTiny (&catalog[i].measureT[m], MAG_CLASS_PSF); N++; } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/reload_catalogs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/reload_catalogs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/reload_catalogs.c (revision 37067) @@ -156,4 +156,8 @@ // load the list of hosts HostTable *table = HostTableLoad (CATDIR, sky->hosts); + if (!table) { + fprintf (stderr, "ERROR: problem with parallel host table\n"); + exit (2); + } if (BOUNDARY_TREE) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot.c (revision 37067) @@ -3,26 +3,42 @@ int main (int argc, char **argv) { - /* get configuration info, args */ - initialize (argc, argv); + // get configuration info, args + RelphotMode mode = initialize (argc, argv); + if (!mode) exit (2); - /* the object analysis is a separate process iterating over catalogs */ - if (UpdateAverages) { - relphot_objects (0, NULL); - exit (0); + switch (mode) { + case UPDATE_IMAGES: + relphot_images (); + exit (0); + + case UPDATE_AVERAGES: + // take the current set of detections and set the mean magnitudes + relphot_objects (0, NULL); + exit (0); + + case PARALLEL_REGIONS: + // run image updates in parallel across multiple remote machines + relphot_parallel_regions (); + exit (0); + + case PARALLEL_IMAGES: + // operation on the remote machines in the PARALLEL_REGION mode + relphot_parallel_images (); + exit (0); + + case APPLY_OFFSETS: + // re-run this step from a previous attempt (assumes an existing Images.subset.dat file) + if (!PARALLEL) { + fprintf (stderr, "-apply-offsets only makes sense in an parallel context\n"); + exit (2); + } + reload_catalogs (NULL, NULL, 0, NULL); + exit (0); + + default: + fprintf (stderr, "ERROR: no valid relphot mode chosen\n"); + exit (2); } - - if (ApplyOffsets) { - // re-run this step from a previous attempt (assumes an existing Images.subset.dat file) - if (!PARALLEL) { - fprintf (stderr, "-apply-offsets only makes sense in an parallel context\n"); - exit (2); - } - reload_catalogs (NULL, NULL, 0, NULL); - exit (0); - } - - relphot_images (); - - exit (0); + fprintf (stderr, "IMPOSSIBLE: skipped out of switch?\n"); + exit (1); } - Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_client.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_client.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_client.c (revision 37067) @@ -19,5 +19,5 @@ // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, etc) initialize_client (argc, argv); - client_logger_init (); + client_logger_init (HOSTDIR); // load the current sky table (layout of all SkyRegions) @@ -39,5 +39,5 @@ case MODE_LOAD: { int Ncatalog; - Catalog *catalog = load_catalogs (skylist, &Ncatalog, HOST_ID, HOSTDIR); + Catalog *catalog = load_catalogs (skylist, &Ncatalog, HOST_ID, HOSTDIR, NULL); if (!catalog) { fprintf (stderr, "ERROR loading catalogs from %s\n", CATDIR); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_images.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_images.c (revision 37067) @@ -52,5 +52,5 @@ if (NLOOP > 0) { /* load catalog data from region files (hostID is 0 since we are not a client */ - catalog = load_catalogs (skylist, &Ncatalog, 0, NULL); + catalog = load_catalogs (skylist, &Ncatalog, 0, NULL, NULL); MARKTIME("-- load catalog data: %f sec\n", dtime); @@ -244,5 +244,7 @@ if (!UPDATE) exit (0); - /* load catalog data from region files, update Mrel include all data */ + /* Load catalog data from region files, update Mrel include all data. In a parallel + context, this function writes the image parameters as a subset table for the remote + clients */ reload_catalogs (skylist, flatcorr, 0, NULL); MARKTIME("-- updated all catalogs: %f sec\n", dtime); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_parallel_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_parallel_images.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_parallel_images.c (revision 37067) @@ -0,0 +1,161 @@ +# include "relphot.h" + +/* This function is essentially identical to relphot_images, except: + + * load the subset images saved by the master node + * distinguish detections we own (touch our images) and those we don't + * distinguish objects we own (in region) and those we don't + * update the unowned detections for owned objects from neighbor regions + * update the unowned objects for owned detections + */ + +int dumpObjects (char *filename, Catalog *catalog, int Ncatalog); + +int relphot_parallel_images () { + + int i, Ncatalog; + Catalog *catalog = NULL; + + INITTIME; + + client_logger_init (CATDIR); + + // load the RegionTable (UserRegion should not be used at this level) + RegionHostTable *regionHosts = RegionHostTableLoad (CATDIR, REGION_FILE); + int myHost = regionHosts->index[REGION_HOST_ID]; + RegionHostFindNeighbors (regionHosts, myHost); + client_logger_message ("started parallel images on %s\n", regionHosts->hosts[myHost].hostname); + + // load the subset images belonging to this host + off_t Nimage; + Image *image = ImageTableLoad (IMAGE_TABLE, &Nimage); + if (!image) { + fprintf (stderr, "ERROR loading image %s\n", IMAGE_TABLE); + exit (2); + } + + // once we have read this table, we should remove it for repeat runs + // unlink (IMAGE_TABLE); // XXX a bit risky, add some protection? + + makeMosaics (image, Nimage, TRUE); + + initImages (image, NULL, Nimage); + + // load the flat correction table (if defined) + char flatcorrfile[256]; + sprintf (flatcorrfile, "%s/flatcorr.fits", CATDIR); + FlatCorrectionTable *flatcorr = FlatCorrectionLoad (flatcorrfile, VERBOSE); + + SkyTable *sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, TRUE, SKY_DEPTH, VERBOSE); + SkyTableSetFilenames (sky, CATDIR, "cpt"); + + // UserPatch.Rmin,Rmax may have range from a few degrees < 0.0 to few degrees > 360.0. + // the following function correctly chooses the sky regions on the 0,360 boundary + SkyList *skylist = SkyListByBounds (sky, -1, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax); + + /* load catalog data from region files (hostID is 0 since we are not a client */ + char *syncfile = make_filename (CATDIR, regionHosts->hosts[myHost].hostname, REGION_HOST_ID, "loadcat.sync"); + catalog = load_catalogs (skylist, &Ncatalog, 0, NULL, syncfile); + MARKTIME("-- load catalog data: %f sec\n", dtime); + free (syncfile); + + client_logger_message ("loaded catalog data\n"); + + // generate tables go from catID,objID -> catSeq,objSeq + indexCatalogs (catalog, Ncatalog); + client_logger_message ("indexed Catalogs\n"); + + /* match measurements with images, mosaics */ + initImageBins (catalog, Ncatalog, TRUE); + MARKTIME("-- make image bins: %f sec\n", dtime); + + initMosaicBins (catalog, Ncatalog, TRUE); + initMrel (catalog, Ncatalog); + + findImages (catalog, Ncatalog, TRUE); + MARKTIME("-- set up image indexes: %f sec\n", dtime); + + findMosaics (catalog, Ncatalog, TRUE); /* also sets Grid values */ + MARKTIME("-- set up mosaic indexes: %f sec\n", dtime); + + client_logger_message ("done setting up indexes\n"); + + // dumpObjects ("test.obj.dat", catalog, Ncatalog); + markObjects (catalog, Ncatalog); + + SAVEPLOT = FALSE; + + setExclusions (catalog, Ncatalog, TRUE); + + global_stats (catalog, Ncatalog, flatcorr); + + if (PLOTSTUFF) { + plot_star_coords (catalog, Ncatalog); + // plot_mosaic_fields (catalog); + } + + // XXX : add this in the loop at various points + // if (PLOTSTUFF) plot_scatter (catalog, Ncatalog, flatcorr); + + /* determine fit values */ + client_logger_message ("starting the loops : %d \n", NLOOP); + for (i = 0; i < NLOOP; i++) { + + // set the mean stellar mags given the measurements and the image calibrations + setMrel (catalog, Ncatalog, flatcorr); + + // share mean mags for objects at the boundary (number of unowned meas > 0) + share_mean_mags (catalog, Ncatalog, regionHosts, i); + client_logger_message ("shared mean mag data : loop %d \n", i); + + // load mean mags from other region hosts + slurp_mean_mags (catalog, Ncatalog, regionHosts, i); + client_logger_message ("slurped mean mag data : loop %d \n", i); + + // set the image (Mcal) and mosaic (Mmos) zero point offsets given the mean mags and measurements + setMcal (catalog, FALSE, flatcorr); + setMmos (catalog, FALSE, flatcorr); + MARKTIME("-- set Mrel, Mcal, Mmos, Mgrid : %f sec\n", dtime); + + // share image mags for images with non-zero unowned detections + share_image_mags (regionHosts, i); + client_logger_message ("shared image data : loop %d \n", i); + + slurp_image_mags (regionHosts, i); + client_logger_message ("slurped image data : loop %d \n", i); + + if ((i > 8) && (i % 8 == 2)) clean_measures (catalog, Ncatalog, FALSE, flatcorr); + if ((i > 8) && (i % 8 == 3)) clean_stars (catalog, Ncatalog); + if ((i > 8) && (i % 8 == 5)) clean_mosaics (); + if ((i > 8) && (i % 8 == 5)) clean_images (); + + if (i % 3 == 2) global_stats (catalog, Ncatalog, flatcorr); + MARKTIME("-- finished loop %d: %f sec\n", i, dtime); + } + client_logger_message ("done with loops\n"); + + // this is a checkpoint to make sure all hosts have finished the loop above + char *loopsyncfile = make_filename (CATDIR, regionHosts->hosts[myHost].hostname, REGION_HOST_ID, "loop.sync"); + update_sync_file (loopsyncfile, 0); + free (loopsyncfile); + + for (i = 0; i < regionHosts->Nhosts; i++) { + if (regionHosts->hosts[i].hostID == REGION_HOST_ID) continue; + char *loopsync = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "loop.sync"); + check_sync_file (loopsync, 0); + free (loopsync); + } + client_logger_message ("all hosts are done the loops\n"); + + /* set Mcal & Mmos for bad images */ + setMcal (catalog, TRUE, flatcorr); + setMmos (catalog, TRUE, flatcorr); + MARKTIME("-- finalize Mcal values: %f sec\n", dtime); + + setMcalFinal (); // copy per-mosaic calibrations to the images + + share_image_mags (regionHosts, -1); + client_logger_message ("done with parallel images\n"); + + exit (0); +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_parallel_regions.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_parallel_regions.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_parallel_regions.c (revision 37067) @@ -0,0 +1,114 @@ +# include "relphot.h" +int save_images_backup (FITS_DB *db); + +int relphot_parallel_regions () { + + int status; + FITS_DB db; + + INITTIME; + + // load the RegionTable (UserRegion should not be used at this level) + RegionHostTable *regionHosts = RegionHostTableLoad (CATDIR, REGION_FILE); + if (!regionHosts) { + fprintf (stderr, "ERROR: problem with region host table\n"); + exit (2); + } + + // load the flat correction table (if defined) + char flatcorrfile[256]; + sprintf (flatcorrfile, "%s/flatcorr.fits", CATDIR); + FlatCorrectionTable *flatcorr = FlatCorrectionLoad (flatcorrfile, VERBOSE); + + // register database handle with shutdown procedure + set_db (&db); + db.mode = dvo_catalog_catmode (CATMODE); + db.format = dvo_catalog_catformat (CATFORMAT); + + // lock and load the image db table + status = dvo_image_lock (&db, ImageCat, 60.0, (UPDATE ? LCK_XCLD : LCK_SOFT)); + if (!status && UPDATE) { + fprintf (stderr, "error\n"); + Shutdown ("ERROR: failure to lock image catalog %s", db.filename); + } + + if ((db.dbstate == LCK_EMPTY) || (db.dbstate == LCK_MISSING)) { + // if the Image.dat file is missing, db.dbstate will have a value of either: + // LCK_EMPTY (if UPDATE) or LCK_MISSING (if !UPDATE) + Shutdown ("ERROR: database %s contains no image data", CATDIR); + } + + // read data from Image.dat file + if (!dvo_image_load (&db, VERBOSE, FALSE)) Shutdown ("can't read image catalog %s", db.filename); + MARKTIME("-- load image data: %f sec\n", dtime); + + /* assign the images to the different region hosts */ + if (!assign_images (&db, regionHosts)) Shutdown ("error assigning images to region hosts"); + MARKTIME("-- assign images: %f sec\n", dtime); + + /* launch processing on the parallel region hosts */ + if (!launch_region_hosts (regionHosts)) Shutdown ("error launching region hosts"); + + // retrieve updated image parameters from the remote hosts (also set Image.mcal) + if (!slurp_image_mags (regionHosts, -1)) Shutdown ("error loading image updates"); + + if (!UPDATE) { + dvo_image_unlock (&db); + MARKTIME ("finished relphot -parallel-regions: %f sec total\n", dtime); + fprintf (stderr, "NOTE: UPDATE is OFF (results are not saved)\n"); + exit (0); + } + + SkyTable *sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, TRUE, SKY_DEPTH, VERBOSE); + SkyTableSetFilenames (sky, CATDIR, "cpt"); + SkyList *skylist = SkyListByBounds (sky, -1, regionHosts->Rmin, regionHosts->Rmax, regionHosts->Dmin, regionHosts->Dmax); + + // I have to save a copy because dvo_image_save and _unlock swap and free the data + save_images_backup (&db); + + /* update catalogs (in parallel) */ + reload_catalogs (skylist, flatcorr, 0, NULL); + + // save the changes to the image parameters + dvo_image_save (&db, VERBOSE); + dvo_image_unlock (&db); + MARKTIME ("finished relphot -parallel-regions: %f sec total\n", dtime); + + exit (0); +} + +int save_images_backup (FITS_DB *db) { + + FITS_DB dbX; + char filename[1024]; + + INITTIME; + + gfits_db_init (&dbX); + dbX.lockstate = LCK_XCLD; + dbX.timeout = 60.0; + dbX.mode = db->mode; + dbX.format = db->format; + + snprintf (filename, 1024, "%s.bck", ImageCat); + if (!gfits_db_lock (&dbX, filename)) { + fprintf (stderr, "can't lock backup image image catalog\n"); + return (FALSE); + } + + // copy Images.dat data (all or only the subset / vtable elements?) I think I need to dump + // the entire Image table, but with the updates in place I think this says: re-work the + // ftable/vtable usage in this program to be more sensible... + gfits_copy_header (&db->header, &dbX.header); + gfits_copy_matrix (&db->matrix, &dbX.matrix); + gfits_copy_header (&db->theader, &dbX.theader); + gfits_copy_ftable (&db->ftable, &dbX.ftable); + + dbX.ftable.header = &dbX.theader; + + dvo_image_save (&dbX, VERBOSE); + dvo_image_unlock (&dbX); + MARKTIME("-- save Image.dat.bck: %f sec\n", dtime); + + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/select_images.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/select_images.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/select_images.c (revision 37067) @@ -40,5 +40,5 @@ tcoords.pc1_1 = tcoords.pc2_2 = 1.0; tcoords.pc1_2 = tcoords.pc2_1 = 0.0; - strcpy (tcoords.ctype, "RA---TAN"); + strcpy (tcoords.ctype, "DEC--TAN"); double RminSkyRegion = region[0].Rmin; @@ -412,5 +412,5 @@ tcoords.Npolyterms = 0; memset (tcoords.polyterms, 0, 14*sizeof(float)); - strcpy (tcoords.ctype, "RA---TAN"); + strcpy (tcoords.ctype, "DEC--TAN"); /* compare with each region file */ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setExclusions.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setExclusions.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setExclusions.c (revision 37067) @@ -35,6 +35,6 @@ /* select measurements by mag limit */ if (AreaSelect) { - r = catalog[i].averageT[j].R + catalog[i].measureT[m].dR / 3600.0; - d = catalog[i].averageT[j].D + catalog[i].measureT[m].dD / 3600.0; + r = catalog[i].measureT[m].R; + d = catalog[i].measureT[m].D; if ((coords = getCoords (m, i)) == NULL) goto markbad; RD_to_XY (&x, &y, r, d, coords); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setMrelCatalog.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setMrelCatalog.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setMrelCatalog.c (revision 37067) @@ -1,3 +1,4 @@ # include "relphot.h" +# define UBERCAL_WEIGHT 100.0 # define SKIP_THIS_MEAS(REASON) { \ @@ -13,4 +14,9 @@ continue; } +static float MagToFlux (float Mag) { + float Flux = pow(10.0, -0.4*(Mag)); + return (Flux); +} + int print_measure_set_alt (Average *average, SecFilt *secfilt, Measure *measure) { @@ -30,9 +36,11 @@ } +int setMrelAverageForcedWarp (off_t measureOffset, int cat, int pass, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, off_t *found); + int setMrel_catalog_alt (Catalog *catalog, int Nc, int pass, FlatCorrectionTable *flatcorr, SetMrelInfo *results, int Nsecfilt) { off_t j; - liststats_setmode (&results->stats, STATMODE); + liststats_setmode (&results->psfstats, STATMODE); liststats_setmode (&results->apstats, STATMODE); liststats_setmode (&results->kronstats, STATMODE); @@ -52,5 +60,5 @@ Average *average = catalog[Nc].average ? &catalog[Nc].average[j] : NULL; Measure *measure = catalog[Nc].measure ? &catalog[Nc].measure[m] : NULL; - setMrelAverageExposure (m, Nc, pass, flatcorr, results, average, &catalog[Nc].averageT[j], &catalog[Nc].secfilt[j*Nsecfilt], measure, &catalog[Nc].measureT[m], &catalog[Nc].found[Nsecfilt*j]); + setMrelAverageExposure (m, Nc, pass, flatcorr, results, average, &catalog[Nc].averageT[j], &catalog[Nc].secfilt[j*Nsecfilt], measure, &catalog[Nc].measureT[m], &catalog[Nc].found_t[Nsecfilt*j]); // only apply Stack operation on setMrelFinal in first pass @@ -59,4 +67,10 @@ setGlobalObjStats (&catalog[Nc].average[j], &catalog[Nc].measure[m]); } + + // only measure force-warp mean values if issetMrelFinal (make it optional?) + if (isSetMrelFinal) { + setMrelAverageForcedWarp (m, Nc, pass, results, &catalog[Nc].average[j], &catalog[Nc].secfilt[j*Nsecfilt], &catalog[Nc].measure[m], &catalog[Nc].foundWarp_t[Nsecfilt*j]); + setGlobalObjStats (&catalog[Nc].average[j], &catalog[Nc].measure[m]); + } } if (primaryCell) free (primaryCell); @@ -64,19 +78,27 @@ } +// set mean of chip measurements (selected by photcode range for now): int setMrelAverageExposure (off_t measureOffset, int cat, int pass, FlatCorrectionTable *flatcorr, SetMrelInfo *results, Average *average, AverageTiny *averageT, SecFilt *secfilt, Measure *measure, MeasureTiny *measureT, off_t *found) { off_t k; - int N; float Msys = 0, Mcal= 0, Mmos = 0, Mgrid = 0; - double *list = results->list; - double *dlist = results->dlist; - double *wlist = results->wlist; - double *aplist = results->aplist; - double *kronlist = results->kronlist; + // we are measuring means for 3 types of mags: psf, ap, kron. I am using the psf mag + // error for the ap mags, but krons have their own errors. it is an open question if I + // should be doing weighted or unweighted fits (this is a user option) + double *Mpsflist = results->Mpsflist; + double *dpsflist = results->dpsflist; + double *wpsflist = results->wpsflist; + + double *Maplist = results->Maplist; + double *daplist = results->daplist; + double *waplist = results->waplist; + + double *Mkronlist = results->Mkronlist; double *dkronlist = results->dkronlist; - - StatType *stats = &results->stats; - StatType *apstats = &results->apstats; + double *wkronlist = results->wkronlist; + + StatType *psfstats = &results->psfstats; + StatType *apstats = &results->apstats; StatType *kronstats = &results->kronstats; @@ -125,5 +147,7 @@ off_t meas = measureOffset; - N = 0; + int Nap = 0; + int Npsf = 0; + int Nkron = 0; for (k = 0; k < averageT[0].Nmeasure; k++, meas++) { @@ -135,7 +159,11 @@ // are we a PS1 exposure photcode? - if ((measure[k].photcode >= 10000) && (measure[k].photcode <= 10500)) { - NexpPS1 ++; - } + if (isGPC1chip(measureT[k].photcode)) NexpPS1 ++; + + // SKIP gpc1 stack data + if (isGPC1stack(measureT[k].photcode)) continue; + + // SKIP gpc1 forced-warp data + if (isGPC1warp(measureT[k].photcode)) continue; if (measureT[k].dbFlags & MEAS_BAD) SKIP_THIS_MEAS(Nbad); @@ -157,5 +185,5 @@ // skip some absurd values NAN, < 0.0, > 30.0 - Msys = PhotSysTiny (&measureT[k], &averageT[0], &secfilt[0]); + Msys = PhotSysTiny (&measureT[k], &averageT[0], &secfilt[0], MAG_CLASS_PSF); if (isnan(Msys)) SKIP_THIS_MEAS(Nsys); if (Msys < 0.0) SKIP_THIS_MEAS(Nsys); @@ -164,4 +192,9 @@ int myUbercalDist = getUbercalDist(meas, cat); minUbercalDist = MIN(minUbercalDist, myUbercalDist); + + int isUbercal = (measureT[k].dbFlags & ID_MEAS_PHOTOM_UBERCAL); + float dMpsf = MAX (hypot(measureT[k].dM, code->photomErrSys), MIN_ERROR); + + if (isUbercal) haveUbercal = TRUE; // haveUbercal is set per secfilt, isUbercal is per measure if (isSetMrelFinal) { @@ -183,9 +216,4 @@ } havePS1 = TRUE; - } - - // gpc1 stack data - if ((measure[k].photcode >= 11000) && (measure[k].photcode <= 11400)) { - continue; } @@ -231,5 +259,5 @@ if (measureT[k].M < MaxMagForceSynth) { forceSynth = TRUE; - forceSynthEntry = N; + forceSynthEntry = Npsf; } else { if (pass < 4) { @@ -240,12 +268,21 @@ } - // Map (aplist) and Mkron (kronlist,dkronlist) are used to calculate mean mags per filter - float Map = PhotAper (&measure[k]); - aplist[N] = Map - Mcal - Mmos - Mgrid; - - float Mkron = PhotKron (&measure[k]); - kronlist[N] = Mkron - Mcal - Mmos - Mgrid; - dkronlist[N] = measure[k].dMkron; - } + // Map (Maplist) and Mkron (Mkronlist,dkronlist) are used to calculate mean mags per filter + float Map = PhotCat (&measure[k], MAG_CLASS_APER); + if (!isnan(Map)) { + Maplist[Nap] = Map - Mcal - Mmos - Mgrid; + daplist[Nap] = dMpsf;// XXX check on this... + waplist[Nap] = isUbercal ? UBERCAL_WEIGHT : 1.0; + Nap ++; + } + + float Mkron = PhotCat (&measure[k], MAG_CLASS_KRON); + if (!isnan(Mkron)) { + Mkronlist[Nkron] = Mkron - Mcal - Mmos - Mgrid; + dkronlist[Nkron] = measure[k].dMkron; + wkronlist[Nkron] = isUbercal ? UBERCAL_WEIGHT : 1.0; + Nkron ++; + } + } // if (isSetMrelFinal) // dlist gives the error per measurement, wlist gives the weight @@ -255,23 +292,23 @@ // 3) UBERCAL measurements can have their weight increased by a big factor to help tie down the averages // 4) some reference photcode of some kind can be specified as fixed and have a high weight - dlist[N] = MAX (hypot(measureT[k].dM, code->photomErrSys), MIN_ERROR); - wlist[N] = 1.0; - list[N] = Msys - Mcal - Mmos - Mgrid; - - // up-weight the ubercal values (or convergence can take a long time...) - if (measureT[k].dbFlags & ID_MEAS_PHOTOM_UBERCAL) { - haveUbercal = TRUE; - wlist[N] = 10.0; - } + Mpsflist[Npsf] = Msys - Mcal - Mmos - Mgrid; + dpsflist[Npsf] = dMpsf; + wpsflist[Npsf] = isUbercal ? UBERCAL_WEIGHT : 1.0; + + // NOTE: + // Msys is measure[i].M + zp corrections + // Mcal is image[j].Mcal + // Mmos and Mgrid are offsets for mosaic and grid // tie down reference photometry if the -refcode (code) option is selected // eg, -refcode g_SDSS // this probably makes no sense in the context of multifilter analysis + // XXX probably need to use the photocde table to assign reference mag weights. if (refPhotcode) { if (code->code == refPhotcode->code) { - wlist[N] = 100.0; + wpsflist[Npsf] = UBERCAL_WEIGHT; } } - N++; + Npsf ++; } @@ -281,5 +318,5 @@ if (isSetMrelFinal && (pass == 0)) { if ((thisCode < 6) || (thisCode == 9)) { - secfilt[Nsec].Ncode = NexpPS1; + secfilt[Nsec].Ncode = NexpPS1; } else { secfilt[Nsec].Ncode = Ncode; // 2MASS data if it exists @@ -288,6 +325,6 @@ // when performing the grid analysis, STAR_TOOFEW should be set to 1; - if (N < Nminmeas) { /* too few measurements */ - // fprintf (f, "%10.6f %10.6f %d %d %d\n", averageT[0].R, averageT[0].D, measureT[0].imageID, N, STAR_TOOFEW); + if (Npsf < Nminmeas) { /* too few measurements */ + // fprintf (f, "%10.6f %10.6f %d %d %d\n", averageT[0].R, averageT[0].D, measureT[0].imageID, Npsf, STAR_TOOFEW); secfilt[Nsec].flags |= ID_STAR_FEW; if (Ncode == 0) { @@ -303,15 +340,15 @@ if (forceSynth) { // use the single SYNTH value instead of the other mags here - myAssert ((forceSynthEntry < N) && (forceSynthEntry >= 0), "programming error"); - list[0] = list[forceSynthEntry]; - dlist[0] = dlist[forceSynthEntry]; - wlist[0] = wlist[forceSynthEntry]; - N = 1; - } - liststats (list, dlist, wlist, N, stats); - - secfilt[Nsec].M = stats->mean; - secfilt[Nsec].dM = stats->error; - secfilt[Nsec].Xm = (stats->Nmeas > 1) ? 100.0*log10(stats->chisq + 1e-4) : NAN_S_SHORT; + myAssert ((forceSynthEntry < Npsf) && (forceSynthEntry >= 0), "programming error"); + Mpsflist[0] = Mpsflist[forceSynthEntry]; + dpsflist[0] = dpsflist[forceSynthEntry]; + wpsflist[0] = wpsflist[forceSynthEntry]; + Npsf = 1; + } + liststats (Mpsflist, dpsflist, wpsflist, Npsf, psfstats); + + secfilt[Nsec].M = psfstats->mean; + secfilt[Nsec].dM = psfstats->error; + secfilt[Nsec].Mchisq = (psfstats->Nmeas > 1) ? psfstats->chisq : NAN; // when running -averages, we have no information about the images, so we cannot set this @@ -323,21 +360,26 @@ found[Nsec] = TRUE; - secfilt[Nsec].Mstdev = 1000.0*stats->sigma; // Mstdev is in millimags (not enough space for more precision) + secfilt[Nsec].Mstdev = psfstats->sigma; // Mstdev is in millimags (not enough space for more precision) // secfilt[Nsec].Ncode = Ncode; - secfilt[Nsec].Nused = stats->Nmeas; - - secfilt[Nsec].M_80 = 1000 * stats->Upper80; - secfilt[Nsec].M_20 = 1000 * stats->Lower20; + secfilt[Nsec].Nused = psfstats->Nmeas; + + secfilt[Nsec].Mmax = psfstats->max; + secfilt[Nsec].Mmin = psfstats->min; // NOTE : use the modified weight for apmags as well as psf mags - liststats (aplist, dlist, wlist, N, apstats); - secfilt[Nsec].Map = apstats->mean; - - liststats (kronlist, dkronlist, wlist, N, kronstats); - secfilt[Nsec].Mkron = kronstats->mean; - secfilt[Nsec].dMkron = kronstats->error; + liststats (Maplist, daplist, waplist, Nap, apstats); + secfilt[Nsec].Map = Nap > 0 ? apstats->mean : NAN; + secfilt[Nsec].dMap = Nap > 0 ? apstats->error : NAN; + secfilt[Nsec].sMap = Nap > 0 ? apstats->sigma : NAN; + secfilt[Nsec].NusedAp = Nap; + + liststats (Mkronlist, dkronlist, wkronlist, Nkron, kronstats); + secfilt[Nsec].Mkron = Nkron > 0 ? kronstats->mean : NAN; + secfilt[Nsec].dMkron = Nkron > 0 ? kronstats->error : NAN; + secfilt[Nsec].sMkron = Nkron > 0 ? kronstats->sigma : NAN; + secfilt[Nsec].NusedKron = Nkron; // NOTE: for 2MASS measurements, Next should be 1, as should N - if ((Next > 0) && (Next > 0.5*N)) { + if ((Next > 0) && (Next > 0.5*Npsf)) { secfilt[Nsec].flags |= ID_SECF_OBJ_EXT; } @@ -405,9 +447,9 @@ float Msys = 0, Mcal= 0, Mmos = 0, Mgrid = 0; - // set the name of the primary skycell (this is used in a strcmp to match the skycells in stack detections) - // XXX drop BoundaryTreePrimaryCell(primaryCell, average[0].R, average[0].D); + // set the primary projection cell and skycell for this coordinate + int tessID = -1; int projectID = -1; int skycellID = -1; - BoundaryTreePrimaryCellIDs(&projectID, &skycellID, average[0].R, average[0].D); + get_tess_ids(&tessID, &projectID, &skycellID, average[0].R, average[0].D); int NstackGood = 0; @@ -449,7 +491,5 @@ // only examine gpc1 stack data - // XXX this is absurdly hardwired (along with several photcode tests) - if (measure[k].photcode < 11000) continue; - if (measure[k].photcode > 11400) continue; + if (!isGPC1stack(measure[k].photcode)) continue; haveStack = TRUE; @@ -470,5 +510,5 @@ if (isnan(Mgrid)) SKIP_THIS_MEAS_STACK(Ngrid); - Msys = PhotSys (&measure[k], &average[0], &secfilt[0]); + Msys = PhotSys (&measure[k], &average[0], &secfilt[0], MAG_CLASS_PSF); if (isnan(Msys)) SKIP_THIS_MEAS_STACK(Nsys); @@ -477,5 +517,5 @@ // which stack image should we use for the mean value? // if we request the primary (USE_TREE_FOR_PRIMARY), then find the min distances for data from the primary cell - if (MatchImageSkycellID (meas, cat, projectID, skycellID)) { + if (MatchImageSkycellID (meas, cat, tessID, projectID, skycellID)) { float stackPrimaryOffset = getCenterOffset (meas, cat, &measure[k], &stackImageID); if (stackPrimaryOffset < stackPrimaryOffsetMin) { @@ -558,8 +598,14 @@ // need to put in AB mag factor to get to Janskies (or uJy?) - secfilt[Nsec].FluxPSF = zpFactor * measure[k].FluxPSF; - secfilt[Nsec].dFluxPSF = zpFactor * measure[k].dFluxPSF; - secfilt[Nsec].FluxKron = zpFactor * measure[k].FluxKron; - secfilt[Nsec].dFluxKron = zpFactor * measure[k].dFluxKron; + secfilt[Nsec].FpsfStk = zpFactor * measure[k].FluxPSF; + secfilt[Nsec].dFpsfStk = zpFactor * measure[k].dFluxPSF; + secfilt[Nsec].FkronStk = zpFactor * measure[k].FluxKron; + secfilt[Nsec].dFkronStk = zpFactor * measure[k].dFluxKron; + secfilt[Nsec].FapStk = zpFactor * measure[k].FluxAp; + secfilt[Nsec].dFapStk = zpFactor * measure[k].dFluxAp; + + secfilt[Nsec].MpsfStk = (measure[k].FluxPSF > 0.0) ? 8.9 - 2.5*log10(secfilt[Nsec].FpsfStk) : NAN; + secfilt[Nsec].MkronStk = (measure[k].FluxKron > 0.0) ? 8.9 - 2.5*log10(secfilt[Nsec].FkronStk) : NAN; + secfilt[Nsec].MapStk = (measure[k].FluxAp > 0.0) ? 8.9 - 2.5*log10(secfilt[Nsec].FapStk) : NAN; secfilt[Nsec].stackDetectID = ID; @@ -584,4 +630,153 @@ } +# undef SKIP_THIS_MEAS +# define SKIP_THIS_MEAS(REASON) { \ + measure[k].dbFlags |= ID_MEAS_SKIP_PHOTOM; \ + results->REASON ++; \ + continue; } + +// set mean of forced-warp measurements (selected by photcode range for now): +// somewhat simplified relative to chip-photometry: +// * no grid, no mosaic, no 2MASS, no SYNTH, no Ubercal, no flatcorr +int setMrelAverageForcedWarp (off_t measureOffset, int cat, int pass, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, off_t *found) { + + off_t k; + float Fsys = 0, Mcal= 0; + + // we are measuring means for 3 types of FLUXes: psf, ap, kron. I am using the psf mag + // error for the ap mags, but krons have their own errors. it is an open question if I + // should be doing weighted or unweighted fits (this is a user option) + double *Fpsflist = results->Mpsflist; + double *dpsflist = results->dpsflist; + double *wpsflist = results->wpsflist; + + double *Faplist = results->Maplist; + double *daplist = results->daplist; + double *waplist = results->waplist; + + double *Fkronlist = results->Mkronlist; + double *dkronlist = results->dkronlist; + double *wkronlist = results->wkronlist; + + StatType *psfstats = &results->psfstats; + StatType *apstats = &results->apstats; + StatType *kronstats = &results->kronstats; + + // option for a test print + if (FALSE && (average[0].objID == 0x7146) && (average[0].catID == 0x49d8)) { + fprintf (stderr, "test obj\n"); + print_measure_set_alt (average, secfilt, measure); + } + + int Ns; + for (Ns = 0; Ns < Nphotcodes; Ns++) { + + int thisCode = photcodes[Ns][0].code; + int Nsec = GetPhotcodeNsec(thisCode); + + /* calculate the average mag in this SEC photcode for a single star */ + + /* star/photcodes already calibrated */ + if (found[Nsec]) continue; + + off_t meas = measureOffset; + + int Nap = 0; + int Npsf = 0; + int Nkron = 0; + for (k = 0; k < average[0].Nmeasure; k++, meas++) { + + // only examine gpc1 forced-warp data + if (!isGPC1warp(measure[k].photcode)) continue; + + // skip measurements that do not match the current photcode + PhotCode *code = GetPhotcodebyCode (measure[k].photcode); + if (!code) continue; + if (code->equiv != thisCode) { continue; } + + if (measure[k].dbFlags & MEAS_BAD) SKIP_THIS_MEAS(Nbad); + + if (getImageEntry (meas, cat) < 0) { + // measurements without an image are either external reference photometry or + // data for which the associated image has not been loaded (probably because of + // overlaps). Msys + measure.Mcal is our best guess of the true magnitude + Mcal = measure[k].Mcal; // check that this is zero for loaded REF value + } else { + // use getMcal not getMcal_alt? + Mcal = getMcal_alt (meas, cat, NULL, measure[k].Xccd, measure[k].Yccd); + // Mcal = getMcal (meas, cat); + if (isnan(Mcal)) SKIP_THIS_MEAS(Ncal); + } + float Fcal = MagToFlux(-Mcal); + + // in the calculations below, + // ...list gives the error per measurement, wlist gives the weight + // we can modify the error and weight in a few ways: + // 1) MIN_ERROR guarantees a floor + // 2) photomErrSys is added in quadrature as a sytematic error, set per photcode + + // skip some absurd values NAN + // NOTE : I am using PhotCat not PhotSys for now since GPC1 chip-to-chip color terms + // are small (and not measured) + float Fpsf = PhotFluxCat (&measure[k], MAG_CLASS_PSF); + if (isnan(Fsys)) SKIP_THIS_MEAS(Nsys); + // if (Msys < 0.0) SKIP_THIS_MEAS(Nsys); + // if (Msys > 30.0) SKIP_THIS_MEAS(Nsys); + + float dFpsf = PhotFluxCatErr (&measure[k], MAG_CLASS_PSF); + dFpsf = MAX (dFpsf, MIN_ERROR*Fpsf); // MIN_ERROR is a fractional error + Fpsflist[Npsf] = Fpsf * Fcal; + dpsflist[Npsf] = dFpsf * Fcal; + wpsflist[Npsf] = 1.0; + Npsf ++; + + float Fap = PhotFluxCat (&measure[k], MAG_CLASS_APER); + float dFap = PhotFluxCatErr (&measure[k], MAG_CLASS_APER); + if (!isnan(Fap)) { + Faplist[Nap] = Fap * Fcal; + daplist[Nap] = dFap * Fcal; + waplist[Nap] = 1.0; // drop weight lists? + Nap ++; + } + + float Fkron = PhotFluxCat (&measure[k], MAG_CLASS_KRON); + float dFkron = PhotFluxCatErr (&measure[k], MAG_CLASS_KRON); + if (!isnan(Fkron)) { + Fkronlist[Nkron] = Fkron * Fcal; + dkronlist[Nkron] = dFkron * Fcal; + wkronlist[Nkron] = 1.0; + Nkron ++; + } + } + if (Npsf < 1) continue; + + found[Nsec] = TRUE; + + liststats (Fpsflist, dpsflist, wpsflist, Npsf, psfstats); + + secfilt[Nsec].FpsfWrp = psfstats->mean; + secfilt[Nsec].dFpsfWrp = psfstats->error; + secfilt[Nsec].sFpsfWrp = psfstats->sigma; // Mstdev is in millimags (not enough space for more precision) + secfilt[Nsec].NusedWrp = psfstats->Nmeas; + secfilt[Nsec].MpsfWrp = isnan(secfilt[Nsec].FpsfWrp) ? NAN : 8.9 - 2.5*log10(secfilt[Nsec].FpsfWrp); // 8.9 since flux is in Jy + + // NOTE : use the modified weight for apmags as well as psf mags + liststats (Faplist, daplist, waplist, Nap, apstats); + secfilt[Nsec].FapWrp = Nap > 0 ? apstats->mean : NAN; + secfilt[Nsec].dFapWrp = Nap > 0 ? apstats->error : NAN; + secfilt[Nsec].sFapWrp = Nap > 0 ? apstats->sigma : NAN; + secfilt[Nsec].NusedApWrp = Nap; + secfilt[Nsec].MapWrp = isnan(secfilt[Nsec].FapWrp) ? NAN : 8.9 - 2.5*log10(secfilt[Nsec].FapWrp); // 8.9 since flux is in Jy + + liststats (Fkronlist, dkronlist, wkronlist, Nkron, kronstats); + secfilt[Nsec].FkronWrp = Nkron > 0 ? kronstats->mean : NAN; + secfilt[Nsec].dFkronWrp = Nkron > 0 ? kronstats->error : NAN; + secfilt[Nsec].sFkronWrp = Nkron > 0 ? kronstats->sigma : NAN; + secfilt[Nsec].NusedKronWrp = Nkron; + secfilt[Nsec].MkronWrp = isnan(secfilt[Nsec].FkronWrp) ? NAN : 8.9 - 2.5*log10(secfilt[Nsec].FkronWrp); // 8.9 since flux is in Jy + } + return (TRUE); +} + int setGlobalObjStats (Average *average, Measure *measure) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setMrelFinal.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setMrelFinal.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setMrelFinal.c (revision 37067) @@ -85,7 +85,9 @@ /* set catalog[0].found[i] = FALSE */ - ALLOCATE (catalog[0].found, off_t, MAX (1, Nsecfilt*catalog[0].Naverage)); + ALLOCATE (catalog[0].found_t, off_t, MAX (1, Nsecfilt*catalog[0].Naverage)); + ALLOCATE (catalog[0].foundWarp_t, off_t, MAX (1, Nsecfilt*catalog[0].Naverage)); for (i = 0; i < Nsecfilt*catalog[0].Naverage; i++) { - catalog[0].found[i] = FALSE; + catalog[0].found_t[i] = FALSE; + catalog[0].foundWarp_t[i] = FALSE; } @@ -194,5 +196,5 @@ /* star/photcodes already calibrated */ - if (catalog[0].found[Nsecfilt*i+Nsec]) continue; + if (catalog[0].found_t[Nsecfilt*i+Nsec]) continue; m = catalog[0].average[i].measureOffset; @@ -229,5 +231,5 @@ if ((pass < 4) && ImagSelect) { if (Nim > -1) { - mag = PhotInst (&catalog[0].measure[m]); + mag = PhotInst (&catalog[0].measure[m], MAG_CLASS_PSF); if (mag < ImagMin) goto skip; if (mag > ImagMax) goto skip; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/share_image_mags.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/share_image_mags.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/share_image_mags.c (revision 37067) @@ -0,0 +1,120 @@ +# include "relphot.h" + +// we are sharing image calibrations mags for all images which (a) I own and (b) which have unowned detections + +# define D_NIMAGEMAGS 1000 +int share_image_mags (RegionHostTable *regionHosts, int nloop) { + + off_t i, Nimages; + Image *images = getimages (&Nimages, NULL); + + off_t Nimage_mags = 0; + off_t NIMAGE_MAGS = D_NIMAGEMAGS; + + ImageMag *image_mags = NULL; + ALLOCATE (image_mags, ImageMag, NIMAGE_MAGS); + + for (i = 0; i < Nimages; i++) { + // XXX does this image have missing detections (does someone else need it?) + // XXX : NOTE NEED TO FIX THIS: if (imageExtra[i].Nmiss == 0) continue; + + set_image_mags (&image_mags[Nimage_mags], &images[i]); + Nimage_mags ++; + + CHECK_REALLOCATE (image_mags, ImageMag, NIMAGE_MAGS, Nimage_mags, D_NIMAGEMAGS); + } + + // write out the image_mag fits table AND write state in some file + int myHost = regionHosts->index[REGION_HOST_ID]; + char *hostname = regionHosts->hosts[myHost].hostname; + + char *imagfile = make_filename (CATDIR, hostname, REGION_HOST_ID, "imagemags.fits"); + ImageMagSave (imagfile, image_mags, Nimage_mags); + free (image_mags); + free (imagfile); + + char *syncfile = make_filename (CATDIR, hostname, REGION_HOST_ID, "imagemags.sync"); + update_sync_file (syncfile, nloop); + free (syncfile); + + return TRUE; +} + +int slurp_image_mags (RegionHostTable *regionHosts, int nloop) { + + off_t Nimage, i; + Image *images = getimages (&Nimage, NULL); + + int Nimage_mags = 0; + ImageMag *image_mags = NULL; + ALLOCATE (image_mags, ImageMag, 1); + + fprintf (stderr, "grabbing image mags from other hosts...\n"); + + for (i = 0; i < regionHosts->Nhosts; i++) { + if (regionHosts->hosts[i].hostID == REGION_HOST_ID) continue; + if (REGION_HOST_ID && !regionHosts->hosts[i].isNeighbor) continue; + + char *syncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagemags.sync"); + check_sync_file (syncfile, nloop); + free (syncfile); + + off_t Nsubset; + char *imagfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagemags.fits"); + ImageMag *image_mags_subset = ImageMagLoad (imagfile, &Nsubset); + free (imagfile); + + image_mags = merge_image_mags (image_mags, &Nimage_mags, image_mags_subset, Nsubset); + } + + for (i = 0; i < Nimage_mags; i++) { + off_t seq = getImageByID (image_mags[i].imageID); + if (seq < 0) { + // XXX is this a problem? (no, other hosts don't know which images I own) + continue; + } + images[seq].Mcal = image_mags[i].Mcal; + images[seq].dMcal = image_mags[i].dMcal; + images[seq].dMagSys = image_mags[i].dMagSys; + images[seq].Xm = image_mags[i].Xm; + images[seq].nFitPhotom = image_mags[i].nFitPhotom; + images[seq].flags = image_mags[i].flags; + images[seq].ubercalDist = image_mags[i].ubercalDist; + } + free (image_mags); + + fprintf (stderr, "DONE grabbing image mags from other hosts\n"); + + return TRUE; +} + +int set_image_mags (ImageMag *image_mags, Image *image) { + + image_mags->Mcal = image->Mcal; + image_mags->dMcal = image->dMcal; + image_mags->dMagSys = image->dMagSys; + image_mags->Xm = image->Xm; + image_mags->nFitPhotom = image->nFitPhotom; + image_mags->flags = image->flags; + image_mags->ubercalDist = image->ubercalDist; + image_mags->imageID = image->imageID; + + return TRUE; +} + +ImageMag *merge_image_mags (ImageMag *target, int *ntarget, ImageMag *source, int Nsource) { + + off_t i; + + REALLOCATE (target, ImageMag, *ntarget + Nsource); + for (i = 0; i < Nsource; i++) { + off_t n = i + *ntarget; + target[n] = source[i]; + } + + free (source); + + *ntarget += Nsource; + return (target); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/share_mean_mags.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/share_mean_mags.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/share_mean_mags.c (revision 37067) @@ -0,0 +1,149 @@ +# include "relphot.h" +// we are sharing mean mags for all objects which (a) I own and (b) which have unowned detections + +# define D_NMEANMAGS 10000 +int share_mean_mags (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop) { + + int i; + off_t j; + + off_t Nmeanmags = 0; + off_t NMEANMAGS = D_NMEANMAGS; + + MeanMag *meanmags = NULL; + ALLOCATE (meanmags, MeanMag, NMEANMAGS); + + int Ns; + int Nsecfilt = GetPhotcodeNsecfilt(); + + int myHost = regionHosts->index[REGION_HOST_ID]; + double Rmin = regionHosts->hosts[myHost].Rmin; + double Rmax = regionHosts->hosts[myHost].Rmax; + double Dmin = regionHosts->hosts[myHost].Dmin; + double Dmax = regionHosts->hosts[myHost].Dmax; + + // XXX skip some catalogs based on UserPatch? + for (i = 0; i < Ncatalog; i++) { + for (j = 0; j < catalog[i].Naverage; j++) { + + // do I own this object? (in region range?) + if (catalog[i].averageT[j].R < Rmin) continue; + if (catalog[i].averageT[j].R >= Rmax) continue; + if (catalog[i].averageT[j].D < Dmin) continue; + if (catalog[i].averageT[j].D >= Dmax) continue; + + // does this object have missing detections (does someone else need it?) + // XXX : sky objects without missing detections + // XXX watch out for detections which are not associated with an image (REF) + if (catalog[i].averageT[j].nOwn == catalog[i].averageT[j].Nmeasure) continue; + + for (Ns = 0; Ns < Nphotcodes; Ns++) { + int thisCode = photcodes[Ns][0].code; + int Nsec = GetPhotcodeNsec(thisCode); + set_mean_mags (&meanmags[Nmeanmags], &catalog[i].averageT[j], &catalog[i].secfilt[Nsecfilt*j + Nsec], Nsec); + Nmeanmags ++; + CHECK_REALLOCATE (meanmags, MeanMag, NMEANMAGS, Nmeanmags, D_NMEANMAGS); + } + } + } + + // write out the meanmag fits table AND write state in some file + char *hostname = regionHosts->hosts[myHost].hostname; + + char *magsfile = make_filename (CATDIR, hostname, REGION_HOST_ID, "meanmags.fits"); + MeanMagSave (magsfile, meanmags, Nmeanmags); + free (meanmags); + free (magsfile); + + char *syncfile = make_filename (CATDIR, hostname, REGION_HOST_ID, "meanmags.sync"); + update_sync_file (syncfile, nloop); + free (syncfile); + + return TRUE; +} + +int slurp_mean_mags (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop) { + + off_t i; + + int Nmeanmags = 0; + MeanMag *meanmags = NULL; + ALLOCATE (meanmags, MeanMag, 1); + + fprintf (stderr, "grabbing mean object mags from other hosts...\n"); + + int Nsecfilt = GetPhotcodeNsecfilt(); + + for (i = 0; i < regionHosts->Nhosts; i++) { + // if (not_neighbor(host[i])) continue; + if (regionHosts->hosts[i].hostID == REGION_HOST_ID) continue; + if (REGION_HOST_ID && !regionHosts->hosts[i].isNeighbor) continue; + + char *syncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanmags.sync"); + check_sync_file (syncfile, nloop); + free (syncfile); + + off_t Nsubset = 0; + char *magsfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanmags.fits"); + MeanMag *meanmagsSubset = MeanMagLoad (magsfile, &Nsubset); + free (magsfile); + + // merge_mean_mags reallocs meanmags and frees the input meanmagsSubset + meanmags = merge_mean_mags (meanmags, &Nmeanmags, meanmagsSubset, Nsubset); + } + + for (i = 0; i < Nmeanmags; i++) { + int objID = meanmags[i].objID; + int catID = meanmags[i].catID; + + // set the mean mag + int catSeq; + off_t objSeq; + if (!catID_and_objID_to_seq (catID, objID, &catSeq, &objSeq)) { + // XXX what should I do if this does not match? + continue; + } + + int ecode = GetPhotcodeEquivCodebyCode (meanmags[i].photcode); + if (ecode < 0) continue; + int Nsec = GetPhotcodeNsec (ecode); + if (Nsec < 0) continue; + + catalog[catSeq].secfilt[objSeq*Nsecfilt + Nsec].M = meanmags[i].M; + } + free (meanmags); + + fprintf (stderr, "DONE grabbing mean object mags from other hosts...\n"); + + return TRUE; +} + +int set_mean_mags (MeanMag *meanmags, AverageTiny *average, SecFilt *secfilt, int Nsec) { + + meanmags->M = secfilt->M; + meanmags->dM = secfilt->dM; + meanmags->Mchisq = secfilt->Mchisq; + meanmags->Nsec = Nsec; // key to secfilt entry + + meanmags->objID = average->objID; + meanmags->catID = average->catID; + + return TRUE; +} + +MeanMag *merge_mean_mags (MeanMag *target, int *ntarget, MeanMag *source, int Nsource) { + + off_t i; + + REALLOCATE (target, MeanMag, *ntarget + Nsource); + for (i = 0; i < Nsource; i++) { + off_t n = i + *ntarget; + target[n] = source[i]; + } + + free (source); + + *ntarget += Nsource; + return (target); +} + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/syncfile.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/syncfile.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/syncfile.c (revision 37067) @@ -0,0 +1,77 @@ +# include "relphot.h" +# define MSG_LENGTH 12 + +char *make_filename (char *dirname, char *hostname, int hostID, char *tailname) { + + char tmp[10], *line; + int Nchar = snprintf (tmp, 0, "%s/%s.%03d.%s", dirname, hostname, hostID, tailname); + + ALLOCATE (line, char, Nchar + 1); + snprintf (line, Nchar + 1, "%s/%s.%03d.%s", dirname, hostname, hostID, tailname); + + return line; +} + +int check_sync_file (char *filename, int nloop) { + + char message[MSG_LENGTH]; + + FILE *f = NULL; + + while (TRUE) { + + f = fopen (filename, "r"); + if (!f) { + usleep (2000000); + continue; + } + + // XXX MSG_LENGTH : 0 EOL byte? + int Nread = fread (message, 1, MSG_LENGTH, f); + if (Nread < MSG_LENGTH) { + fclose (f); + usleep (2000000); + continue; + } + fclose (f); + + // message is of the form: NLOOP: %03d + int loop; + sscanf (message, "%*s %d", &loop); + if (loop != nloop) { + usleep (2000000); + continue; + } + return TRUE; + } + return FALSE; +} + +int clear_sync_file (char *filename) { + // delete file contents + if (truncate (filename, 0)) fprintf (stderr, "trouble clearing file %s\n", filename); + + return TRUE; +} + +int update_sync_file (char *filename, int nloop) { + + char message[MSG_LENGTH]; + + FILE *f = fopen (filename, "w"); + if (!f) { + fprintf (stderr, "failure to open sync file for write\n"); + exit (4); + } + + snprintf (message, MSG_LENGTH, "NLOOP: %03d\n", nloop); + + int Nwrite = fwrite (message, 1, MSG_LENGTH, f); + if (Nwrite != MSG_LENGTH) { + fprintf (stderr, "failure to write sync message\n"); + exit (3); + } + + fclose (f); + return TRUE; +} Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/Makefile =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/Makefile (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/Makefile (revision 37067) @@ -17,5 +17,5 @@ PROGRAMS = gconfig fhead ftable fields list_astro glockfile \ radec mktemp precess csystem fits_insert \ -medianfilter mefhead ckfits roc +medianfilter mefhead ckfits roc random all tools: $(PROGRAMS) Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/ftable.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/ftable.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/ftable.c (revision 37067) @@ -460,4 +460,12 @@ } else { for (j = 0; j < Nv; j++) { + if (!strcmp (type, "byte")) { + memcpy (line, &data[i*Nv*Nb + Nb*j], Nb); + fprintf (stdout, "%d ", *(char *)line); + } + if (!strcmp (type, "short")) { + memcpy (line, &data[i*Nv*Nb + Nb*j], Nb); + fprintf (stdout, "%d ", *(short *)line); + } if (!strcmp (type, "int")) { memcpy (line, &data[i*Nv*Nb + Nb*j], Nb); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/medianfilter.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/medianfilter.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/medianfilter.c (revision 37067) @@ -96,14 +96,26 @@ for (j = 0; j < Npixrd; j++, O++) { Nvalid = 0; + int debug = FALSE && (n == 5) && (j >= 1776779) && (j <= 1776789); for (k = 0; k < Nfiles; k++) { v = (float *)tmpmatr[k].buffer; + if (debug) { + fprintf (stderr, "%8.2f ", v[j]); + } if (v[j] < MinValid) continue; - if (isnan(v[j])) continue; - if (isinf(v[j])) continue; - list[k] = v[j]; + if (isnan(v[j])) { + continue; + } + if (isinf(v[j])) { + continue; + } + list[Nvalid] = v[j]; Nvalid ++; } + if (debug) fprintf (stderr, "\n"); if (Nvalid == 0) { - *O = 0.0; + *O = NAN; + if (debug) { + fprintf (stderr, "Nvalid is 0\n"); + } continue; } @@ -111,9 +123,17 @@ sum = 0; Nval = 0; + if (debug) fprintf (stderr, "list : "); for (k = fmin*Nvalid; k < fmax*Nvalid; k++) { + if (debug) { + fprintf (stderr, "%8.2f ", list[k]); + } sum += list[k]; Nval ++; } *O = (sum / Nval); + if (debug) { + fprintf (stderr, " = %f / %f = %f\n", sum, Nval, *O); + fprintf (stderr, "\n"); + } } Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/random.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/random.c (revision 37067) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/random.c (revision 37067) @@ -0,0 +1,63 @@ +# include +# define NBUFFER 8000000 + +int main (int argc, char **argv) { + + char c; + int i, j, N; + + int FAST = FALSE; + if ((N = get_argument (argc, argv, "-fast"))) { + remove_argument (N, &argc, argv); + FAST = TRUE; + } + + if (argc != 2) { + fprintf (stderr, "USAGE: random (Nbytes) [-fast]\n"); + fprintf (stderr, " generates Nbytes of random characters, to stdout\n"); + fprintf (stderr, " [-fast generates non random bytes, but ~2x faster]\n"); + exit (1); + } + + long A = time(NULL); + srand48(A); + + int Nbytes = atoi (argv[1]); + char buffer[NBUFFER]; + + int Nblock = Nbytes / NBUFFER; + int Nextra = Nbytes - (Nblock * NBUFFER); + + for (j = 0; j < Nblock; j++) { + for (i = 0; i < NBUFFER; i++) { + if (i % 80 == 0) { + buffer[i] = '\n'; + continue; + } + if (FAST) { + c = (i % 90) + 33; + } else { + c = (char) 90*drand48() + 33; + } + buffer[i] = c; + } + fwrite (buffer, 1, NBUFFER, stdout); + } + for (i = 0; i < Nextra - 1; i++) { + if (i % 80 == 0) { + buffer[i] = '\n'; + continue; + } + if (FAST) { + c = (i % 90) + 33; + } else { + c = (char) 90*drand48() + 33; + } + buffer[i] = c; + } + buffer[i] = '\n'; + fwrite (buffer, 1, Nextra, stdout); + exit (0); +} + + Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubset.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubset.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubset.c (revision 37067) @@ -99,11 +99,9 @@ gfits_create_table_header (&theader, "BINTABLE", "IMAGE_SUBSET"); - gfits_define_bintable_column (&theader, "E", "MCAL", "zero point offset", "magnitudes", 1.0, 0.0); - gfits_define_bintable_column (&theader, "E", "MCAL_ERR", "zero point error", "magnitudes", 1.0, 0.0); - - // an unsigned int needs to have bzero of 0x8000 - gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "PHOTOM_MAP", "map", NULL, 1.0, 1.0*0x8000); - gfits_define_bintable_column (&theader, "J", "FLAGS", "flags", NULL, 1.0, 1.0*0x8000); + gfits_define_bintable_column (&theader, "E", "MCAL", "zero point offset", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "E", "MCAL_ERR", "zero point error", "magnitudes", 1.0, 0.0); + gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "PHOTOM_MAP", "map", NULL, 1.0, FT_BZERO_INT32); + gfits_define_bintable_column (&theader, "J", "FLAGS", "flags", NULL, 1.0, FT_BZERO_INT32); // generate the output array that carries the data @@ -114,6 +112,6 @@ // create intermediate storage arrays - ALLOCATE (Mcal, float, Nimage); - ALLOCATE (dMcal, float, Nimage); + ALLOCATE (Mcal, float, Nimage); + ALLOCATE (dMcal, float, Nimage); ALLOCATE (imageID, unsigned int, Nimage); ALLOCATE (map, unsigned int, Nimage); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetFixImageIDs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetFixImageIDs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetFixImageIDs.c (revision 37067) @@ -1,5 +1,3 @@ # include "fiximids.h" -# define FT_BZERO_INT16 1.0*0x8000 -# define FT_BZERO_INT32 1.0*0x80000000 # define GET_COLUMN(OUT,NAME,TYPE) \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetFixStackIDs.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetFixStackIDs.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetFixStackIDs.c (revision 37067) @@ -1,5 +1,3 @@ # include "fixstkids.h" -# define FT_BZERO_INT16 1.0*0x8000 -# define FT_BZERO_INT32 1.0*0x80000000 # define GET_COLUMN(OUT,NAME,TYPE) \ Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetSetPosangle.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetSetPosangle.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetSetPosangle.c (revision 37067) @@ -149,6 +149,5 @@ gfits_create_table_header (&theader, "BINTABLE", "IMAGE_SUBSET"); - // an unsigned int needs to have bzero of 0x8000 - gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, 1.0*0x8000); + gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, FT_BZERO_INT32); gfits_define_bintable_column (&theader, "E", "TZERO", "tmp", "mp", 1.0, 0.0); gfits_define_bintable_column (&theader, "E", "TRATE", "tmp", "mp", 1.0, 0.0); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/find_image_sgroups.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/find_image_sgroups.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/find_image_sgroups.c (revision 37067) @@ -22,5 +22,5 @@ coords.pc1_1 = coords.pc2_2 = 1.0; coords.pc1_2 = coords.pc2_1 = 0.0; - strcpy (coords.ctype, "RA---TAN"); + strcpy (coords.ctype, "DEC--TAN"); Ngroup = 0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/load_images_fiximids.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/load_images_fiximids.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/load_images_fiximids.c (revision 37067) @@ -1,4 +1,3 @@ # include "fiximids.h" -# define FT_BZERO_INT32 1.0*0x80000000 off_t Nimage = 0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/load_images_fixstkids.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/load_images_fixstkids.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/load_images_fixstkids.c (revision 37067) @@ -1,4 +1,3 @@ # include "fixstkids.h" -# define FT_BZERO_INT32 1.0*0x80000000 off_t Nimage = 0; Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_catalog_fiximids.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_catalog_fiximids.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_catalog_fiximids.c (revision 37067) @@ -1,3 +1,8 @@ # include "fiximids.h" + +// test image: 2013/06/15,13:25:51, GPC1.r.XY50 +static int CHECK_TEST_IMAGE = FALSE; +static unsigned int Tref = 1378812312; +static short Cref = 10001; void update_catalog_fiximids (Catalog *catalog) { @@ -18,4 +23,8 @@ short photcode = catalog[0].measure[i].photcode; e_time time = catalog[0].measure[i].t; + + if (CHECK_TEST_IMAGE && (abs(time - Tref) < 10) && (photcode == Cref)) { + fprintf (stderr, "."); + } // skip detections with no valid imageID (eg, ref photcode) Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_catalog_setastrom.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_catalog_setastrom.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_catalog_setastrom.c (revision 37067) @@ -76,5 +76,5 @@ // correction may be Minst or Minst + 5.0*log(fwhm float fwhm_maj = FromShortPixels(measure[0].FWx); - float Minst = PhotInst (measure); + float Minst = PhotInst (measure, MAG_CLASS_PSF); float MinstSB = Minst + 5.0*log10(fwhm_maj); Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_dvo_setphot.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_dvo_setphot.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_dvo_setphot.c (revision 37067) @@ -2,4 +2,5 @@ int update_dvo_setphot_parallel (SkyTable *sky, Image *image, off_t Nimage); +// XXX convert this to use the ImageSubset to save space int update_dvo_setphot (Image *image, off_t Nimage, FlatCorrectionTable *flatcorr) { Index: branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_dvo_uniphot.c =================================================================== --- branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_dvo_uniphot.c (revision 37064) +++ branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_dvo_uniphot.c (revision 37067) @@ -61,5 +61,5 @@ coords.pc1_1 = coords.pc2_2 = 1.0; coords.pc1_2 = coords.pc2_1 = 0.0; - strcpy (coords.ctype, "RA---TAN"); + strcpy (coords.ctype, "DEC--TAN"); for (i = 0; i < pglob.gl_pathc; i++) {