Changeset 37067 for branches/eam_branches/ipp-ops-20130712/Ohana

branches/eam_branches/ipp-ops-20130712/Ohana

Property svn:mergeinfo deleted

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/include/addstar.h

-              r35579
+              r37067
 typedef struct {
+  Average average;
+  Measure measure;
+  Average  average;
+  Measure  measure;
+  Lensing *lensing; // optionally carry out the lensing measurements
   int found;
 } Stars;
 …
 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));

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/FilterStars.c

-              r34260
+              r37067
       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?

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/GetFileMode.c

-              r35416
+              r37067
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/LoadDataPMM.c

r34088	r37067
193	193
194	194	// XXX for now, we define a totally fake coordinate system centered on the plate center
195		strcpy (image[0].coords.ctype, "~~RA-~~--TAN");
	195	strcpy (image[0].coords.ctype, "DEC--TAN");
196	196
197	197	image[0].coords.crval1 = pmm_get_ra (RA);

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/MatchHeaders.c

-              r35416
+              r37067
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadImageHeader.c

-              r31395
+              r37067
   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) {
 …
   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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadStarsFITS.c

-              r35416
+              r37067
 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
 …
     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);
 …
     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);
 …
   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;
+}
 …
     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:
 …
     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:
 …
     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:
 …
     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;
 …
     // 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;
 …
     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;
 …
     // 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 *Convert_PS1_SV1 (FTable *table, unsigned int *nstars) {
+Stars *Convert_PS1_V5 (FTable *table, unsigned int *nstars) {
   off_t Nstars;
 …
   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");
 …
     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;
 …
     // 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
 …
+}
 Stars *Convert_PS1_SV1_Alt (FTable *table, unsigned int *nstars) {
+Stars *Convert_PS1_V5_Lensing (FTable *table, unsigned int *nstars) {
   off_t Nstars;
 …
   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");
 …
     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;
 …
     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;
 …
     // 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 *Convert_PS1_DV3 (FTable *table, unsigned int *nstars) {
+Stars *Convert_PS1_SV3 (FTable *table, unsigned int *nstars) {
   off_t Nstars;
 …
   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");
 …
     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;
 …
+}
+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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/ReadStarsSDSS.c

r34088	r37067
201	201
202	202	// XXX for now, we define a totally fake coordinate system centered on the first listed star
203		strcpy (images[N].coords.ctype, "~~RA-~~--TAN");
	203	strcpy (images[N].coords.ctype, "DEC--TAN");
204	204
205	205	images[N].coords.crval1 = stars[0].average.R;

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/SEDfit.c

-              r34405
+              r37067
+    }
+    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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/StarOps.c

r34260	r37067
8	8	star[0].found = -1; // found == -1 -> not yet found (use enums?)
9	9
	10	star[0].lensing = NULL; // we only populate this if needed
10	11	return TRUE;
11	12	}

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/addstar.c

-              r34405
+              r37067
   int Nmatch, status, loadObjects;
   off_t i, Nimages;
   off_t Naverage, Nmeasure;
+  off_t Naverage, Nmeasure, Nlensing;
   Stars *stars, **subset;
   Image *images;
 …
   /* 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++) {
 …
     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 ();
 …
     Naverage += catalog.Naverage;
     Nmeasure += catalog.Nmeasure;
+    Nlensing += catalog.Nlensing;
     // write out catalog, if appropriate
 …
       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 {
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/build_links.c

-              r27435
+              r37067
+}
+/*******************************************************************************************/
+/* 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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/fakeimage.c

-              r30613
+              r37067
   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];
 …
   /* create a mosaic distortion structure */
   strcpy (MOSAIC.ctype, "RA---DIS");
+  strcpy (MOSAIC.ctype, "DEC--DIS");
   MOSAIC.crval1 = FAKE_RA;
   MOSAIC.crval2 = FAKE_DEC;
 …
     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;
 …
   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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches.c

-              r34361
+              r37067
   if (NSTAR_GROUP <= 0) {
       fprintf (stderr, "ERROR: NSTAR_GROUP NOT SET!\n");
       exit (1);
+    fprintf (stderr, "ERROR: NSTAR_GROUP NOT SET!\n");
+    exit (1);
+  }
 …
   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] */
 …
   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 */
 …
   if (Nstars < 1) {
     if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", catalog[0].filename);
-    free (catalog[0].found);
     free (X1);
     free (Y1);
 …
     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);
 …
       // 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
 …
       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,
 …
                    X1[i], X2[J],
                    Y1[i], Y2[J]);
+        }
+      }
 …
       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);
+        }
+      }
 …
+      }
       /* 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)
 …
+  }
   /* 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 */
 …
     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);
+    }
 …
       // 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
 …
       /* 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
 …
+  }
   /* 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) {
 …
+  }
   /* 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;
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_closest.c

-              r34361
+              r37067
   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;
 …
   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] */
 …
   Nmatch = 0;
   NMEAS = Nmeas = catalog[0].Nmeasure;
+  NLENS = Nlens = catalog[0].Nlensing;
   // current max obj ID for this catalog
 …
   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 */
 …
   if (Nstars < 1) {
     if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", catalog[0].filename);
-    free (catalog[0].found);
     free (X1);
     free (Y1);
 …
     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);
 …
     // 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);
+  }
 …
       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 */
 …
     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;
 …
     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 ++;
+    }
 …
     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);
+      }
+    }
 …
        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 ++;
 …
       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;
 …
     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 ++;
+  }
 …
   REALLOCATE (catalog[0].average, Average, Nave);
   REALLOCATE (catalog[0].measure, Measure, Nmeas);
+  REALLOCATE (catalog[0].lensing, Lensing, Nlens);
   if (options.nosort) {
 …
     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);
+  }
 …
   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);
 …
   free (Y2);
   free (next_meas);
+  free (next_lens);
   return (Nmatch);

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_closest_refstars.c

-              r34361
+              r37067
   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] */
 …
   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 */
 …
   if (Nstars < 1) {
     if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", catalog[0].filename);
-    free (catalog[0].found);
     free (X1);
     free (Y1);
 …
     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);
 …
     /** *** 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;
 …
     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;
+    }
 …
     /* 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;
+    }
 …
       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;
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/find_matches_refstars.c

-              r34260
+              r37067
   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);
 …
   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;
 …
     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);
 …
       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;
 …
       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;
+      }
 …
+      }
       /* 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;
+      }
 …
       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 **/
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/findskycell.c

-              r34844
+              r37067
 // 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");
 …
 int mktree (char *treefile, char *catdir);
+int mklocal (char *treefile, char *catdir);
 int apply_tree (char *treefile, char *datafile);
 …
 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) {
 …
   if (get_argument (argc, argv, "-h")) usage ();
-  NX_SUB = NY_SUB = 1;
   if ((N = get_argument (argc, argv, "-nx"))) {
     remove_argument (N, &argc, argv);
 …
   /* 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);
+  }
 …
     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;
 …
+  }
+  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) {
 …
+  }
+  struct timeval start, stop;
+  gettimeofday (&start, (void *) NULL);
+  INITTIME;
   int Npts = 10000000;
 …
   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;
 …
 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);
 …
+}
+// 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;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/load2mass_catalog.c

-              r35416
+              r37067
   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;
 …
       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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/loadsupercos_ops.c

-              r33653
+              r37067
 # 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) {
 …
   // 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);
 …
+  }
   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);
 …
+  }
   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);
 …
   // 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/loadsupercos_plates.c

r33653	r37067
118	118
119	119	// for now, we define a fake coordinate system based on the boresite center
120		strcpy (image[Nimage].coords.ctype, "~~RA-~~--TAN");
	120	strcpy (image[Nimage].coords.ctype, "DEC--TAN");
121	121
122	122	image[Nimage].coords.crval1 = RAo;

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/mkcmf.c

-              r35760
+              r37067
 # include "mkcmf.h"
+# define ZERO_POINT 25.0
 # define SKY 100.0
 # define DSKY 2.0
 …
 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);
 …
 int ADDNOISE = TRUE;
 float BAD_PSFQF_FRAC = 0.0;
+static float exptime = 1.0;
+static Coords coords;
 int main (int argc, char **argv) {
 …
   Matrix matrix;
   FTable ftable;
-  Coords coords;
   int APPEND = FALSE;
 …
+  }
-  float exptime = 1.0;
   if ((N = get_argument (argc, argv, "-exptime"))) {
     remove_argument (N, &argc, argv);
 …
     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);
 …
   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;
+  }
 …
+}
+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");
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/replace_match.c

-              r26278
+              r37067
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_catalog.c

-              r35760
+              r37067
 # 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) {
 …
   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 */
 …
   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;
 …
   Measure *measureTMP = NULL;
-  if (catalog[0].sorted == TRUE) return;
   // struct timeval start, stop;
   // gettimeofday (&start, NULL);
 …
   Nmeasure = catalog[0].Nmeasure;
   Naverage = catalog[0].Naverage;
+  if (!Nmeasure) return;
   measure = catalog[0].measure;
 …
   // fprintf (stderr, "\n");
   SortAveMeasMatch(measureSeq, averageSeq, Nmeasure);
+  SortAveMatch(measureSeq, averageSeq, Nmeasure);
   // MARKTIME("sort : %f sec\n", dtime);
 …
+}
+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
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_threaded.c

r29938	r37067
41	41	catalog.catformat = dvo_catalog_catformat (CATFORMAT); // set the default catformat from config data
42	42	catalog.catmode = dvo_catalog_catmode (CATMODE); // set the default catmode from config data
43		catalog.catflags = LOAD_AVES \| LOAD_MEAS;
	43	catalog.catflags = LOAD_AVES \| LOAD_MEAS \| LOAD_LENSING;
44	44	catalog.Nsecfilt = GetPhotcodeNsecfilt ();
45	45

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/resort_unthreaded_catalogs.c

r33963	r37067
30	30	catalog.catformat = dvo_catalog_catformat (CATFORMAT); // set the default catformat from config data
31	31	catalog.catmode = dvo_catalog_catmode (CATMODE); // set the default catmode from config data
32		catalog.catflags = LOAD_AVES \| LOAD_MEAS;
	32	catalog.catflags = LOAD_AVES \| LOAD_MEAS \| LOAD_LENSING;
33	33	catalog.Nsecfilt = GetPhotcodeNsecfilt ();
34	34

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/sky_tessalation.c

r34844	r37067
1106	1106	refcoords[0].Npolyterms = 0;
1107	1107	memset (refcoords[0].polyterms, 0, 14*sizeof(float));
1108		strcpy (refcoords[0].ctype, "~~RA-~~--TAN");
	1108	strcpy (refcoords[0].ctype, "DEC--TAN");
1109	1109	return (TRUE);
1110	1110	}

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/src/update_coords.c

-              r34405
+              r37067
       continue;
+    }
     R = measure[m].dR;
     D = measure[m].dD;
+    R = measure[m].R;
+    D = measure[m].D;
     r += R;
     d += D;
 …
   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;
 …
   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 */

branches/eam_branches/ipp-ops-20130712/Ohana/src/addstar/test/simple.dvo

-              r35263
+              r37067
   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
 …
   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
 …
     # 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
 …
 # 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
 …
   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
 …
   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
 …
   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
 …
   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
 …
   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
 …
   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
 …
   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
 …
 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/include/delstar.h

-              r35758
+              r37067
 int    UPDATE;
 int    IMAGE_DETAILS;
+int    IMAGE_DUPLICATES_BY_OBSTIME;
 int    IMAGE_ONLY;
 int    ORPHAN;
 …
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/ImageOpsFixLAP.c

r35758	r37067
1	1	# include "delstar.h"
2		~~# define FT_BZERO_INT32 1.0*0x80000000~~
3	2
4	3	off_t Nimage = 0;

branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/ImageSubsetFixLAP.c

r35758	r37067
1	1	# include "delstar.h"
2		~~# define FT_BZERO_INT16 1.0*0x8000~~
3		~~# define FT_BZERO_INT32 1.0*0x80000000~~
4	2
5	3	# define GET_COLUMN(OUT,NAME,TYPE) \

branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/MeasureEdgeOps.c

r35758	r37067
1	1	# include "delstar.h"
2		~~# define FT_BZERO_INT32 1.0*0x80000000~~
3	2
4	3	# define GET_COLUMN(OUT,NAME,TYPE) \

branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/args.c

-              r35758
+              r37067
   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");
 …
   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);
+  }

branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/delete_duplicate_images.c

-              r35758
+              r37067
 # 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
 …
   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) {
 …
+}
+// 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/delstar/src/delete_fix_LAP_edges.c

-              r35805
+              r37067
   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...
 …
     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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge

Property svn:mergeinfo deleted

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/IDmapIO.c

-              r34277
+              r37067
   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

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvo_image_merge_dbs.c

-              r34277
+              r37067
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeImageIDs.c

-              r35765
+              r37067
   if (inDB.dbstate == LCK_EMPTY) {
     dvo_image_unlock (&inDB); // unlock input
+    IDmap->old = NULL;
+    IDmap->new = NULL;
     IDmap->Nmap = 0;
     return TRUE;
 …
   if (inDB.dbstate == LCK_EMPTY) {
     dvo_image_unlock (&inDB); // unlock input
+    IDmap->old = NULL;
+    IDmap->new = NULL;
     IDmap->Nmap = 0;
     return TRUE;

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeUpdate.c

-              r35765
+              r37067
   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
 …
   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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomergeUpdate_catalogs.c

-              r35765
+              r37067
+    }
+    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++) {
 …
       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);
+      }
 …
     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);
 …
+  }
   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;
+    }
+  }

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvomerge_client.c

Property svn:mergeinfo changed (with no actual effect on merging)

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepair.c

-              r29938
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairCPT.c

-              r33657
+              r37067
+  }
   measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat);
+  measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat);
   myAssert(measure, "failed to convert ftable to measure data");
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairDeleteImageList.c

-              r29938
+              r37067
         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");
 …
         // convert internal to external format
         if (!MeasureToFtable (&cpmFtable, measureNew, NmeasureNew, catformat)) {
+        if (!MeasureToFtable (&cpmFtable, NULL, measureNew, NmeasureNew, catformat)) {
           myAbort("trouble converting format");
+        }
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairFixCPT.c

-              r29938
+              r37067
+  }
   measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat);
+  measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat);
   myAssert(measure, "failed to convert ftable to measure data");
 …
   // convert internal to external format
   if (!MeasureToFtable (&cpmFtable, measure, Nmeasure, catformat)) {
+  if (!MeasureToFtable (&cpmFtable, NULL, measure, Nmeasure, catformat)) {
     myAbort("trouble converting format");
+  }

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairFixTables.c

-              r29938
+              r37067
       // convert internal to external format
       if (!MeasureToFtable (&cpmFtable, measureNew, NmeasureNew, catformat)) {
+      if (!MeasureToFtable (&cpmFtable, NULL, measureNew, NmeasureNew, catformat)) {
         myAbort("trouble converting format");
+      }
 …
   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");
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairImageVsMeasure.c

r33657	r37067
128	128	gfits_scan(&cpmHeaderTBL, "NAXIS1", "%d", 1, &NbytesPerRow);
129	129
130		measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat);
	130	measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat);
131	131	myAssert(measure, "failed to convert ftable to measure data");
132	132

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/dvorepairImagesVsMeasures.c

r29938	r37067
134	134	gfits_scan(&cpmHeaderTBL, "NAXIS1", "%d", 1, &NbytesPerRow);
135	135
136		measure = FtableToMeasure (&cpmFtable, &Nmeasure, &catformat);
	136	measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat);
137	137	myAssert(measure, "failed to convert ftable to measure data");
138	138

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/merge_catalogs_old.c

-              r35416
+              r37067
 # 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) (                                       \
 …
   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;
 …
   Coords tcoords;
+  // struct timeval start, stop;
+  // gettimeofday (&start, (void *) NULL);
+  // INITTIME;
   NsecfiltOut = output[0].Nsecfilt;
 …
   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) **/
 …
   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] */
 …
   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);
 …
     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);
 …
   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;
+  }
 …
         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;
+        }
 …
       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;
 …
       // 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 ++;
 …
     /* 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++;
+  }
 …
+    }
     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;
 …
       /* 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 ++;
 …
   /* 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;
+    }
+  }
 …
   free (next_meas);
-  free (output[0].found);
   free (X2);
   free (Y2);
   free (N2);
-  free (input[0].found);
   free (X1);
   free (Y1);
 …
    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
 */

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvomerge/src/replace_match.c

-              r33963
+              r37067
   unsigned int averef;
   unsigned int catID;
-  double Rin, Din;
   // find the matching photcode in the object's list of measurements
 …
     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;
 …
     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);
+      }
+    }

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/include/dvopsps.h

-              r35578
+              r37067
 # include <signal.h>
 # include "mysql.h"
+# include "limits.h"
 # define DVO_MAX_PATH 1024
 …
 int          PARALLEL_MANUAL;
 int          PARALLEL_SERIAL;
+char        *TIME_START;
+char        *TIME_END;
+int          PHOTCODE_START;
+int          PHOTCODE_END;
 char        *SINGLE_CPT;

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/initialize_dvopsps.c

-              r35206
+              r37067
 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");
 …
   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);
 …
   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);
+  }
 …
+  }
+  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"))) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_detections_dvopsps.c

-              r35804
+              r37067
 # 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:
 …
     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);
 …
   buffer.Nalloc = 0;
-  struct timeval start, stop;
   if (Ndetections == 0) return TRUE;
 …
   int Ninsert = 0;
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   for (i = 0; i < Ndetections; i++) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_detections_dvopsps_catalog.c

-              r35777
+              r37067
 # 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;
 …
+  }
+  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++) {
 …
       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);
 …
       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
 …
+}
+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;
 …
   off_t found = 0;
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   insert_detections_mysql_init (&buffer);
   int Ninsert = 0;
 …
   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) {
 …
     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;
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_objects_dvopsps_catalog.c

-              r35450
+              r37067
 # 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;
 …
   insert_objects_mysql_create_tables (cleanname, mysql);
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   insert_objects_mysql_init (&ave_buffer, &sec_buffer, cleanname);
   int Ninsert = 0;
 …
   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);
 …
     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;
+      }
+    }
 …
     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;
+      }
+    }
 …
     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");

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvopsps/src/insert_skytable.c

-              r35098
+              r37067
 # 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
 …
   off_t i;
-  struct timeval start, stop;
   SkyTable *sky = NULL;
 …
 # endif
+  gettimeofday (&start, (void *) NULL);
+  INITTIME;
   insert_skytable_mysql_init (&buffer);
   int Ninsert = 0;

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/dvosplit.c

-              r33963
+              r37067
   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]);

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/split_averages.c

r33656	r37067
1	1	# include "dvosplit.h"
2		# define NROWS 100000 /* ~10MB per block for measures */
	2	# define NROWS 1000000 /* ~10MB per block for measures */
3	3	# define DNOUT 1000
4	4

branches/eam_branches/ipp-ops-20130712/Ohana/src/dvosplit/src/split_measures.c

-              r33656
+              r37067
 # include "dvosplit.h"
 # define NROWS 100000 /* ~10MB per row for measures */
+# define NROWS 1000000 /* ~10MB per row for measures */
 # define DNOUT 1000
 …
   // 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...

branches/eam_branches/ipp-ops-20130712/Ohana/src/fixcat/src/gcatstats.c

r27435	r37067
52	52	catstats[0].coords.pc1_1 = catstats[0].coords.pc2_2 = 1.0;
53	53	catstats[0].coords.pc1_2 = catstats[0].coords.pc2_1 = 0.0;
54		strcpy (catstats[0].coords.ctype, "~~RA-~~--TAN");
	54	strcpy (catstats[0].coords.ctype, "DEC--TAN");
55	55
56	56	X1 = catstats[0].X;

branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro/src/gstars.c

r34088	r37067
79	79	if (!strcasecmp (ROUGH_ASTROMETRY, "config")) {
80	80	/* default values for coords */
81		strcpy (coords[0].ctype, "~~RA-~~--TAN");
	81	strcpy (coords[0].ctype, "DEC--TAN");
82	82	coords[0].pc1_1 = CCD_PC1_1; coords[0].pc1_2 = CCD_PC1_2;
83	83	coords[0].pc2_1 = CCD_PC2_1; coords[0].pc2_2 = CCD_PC2_2;

branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro2/src/coordtest.c

r8300	r37067
85	85	fit_eval ();
86	86
87		strcpy (coords.ctype, "~~RA-~~--PLY");
	87	strcpy (coords.ctype, "DEC--PLY");
88	88	coords.crval1 = 0.0;
89	89	coords.crval2 = 0.0;

branches/eam_branches/ipp-ops-20130712/Ohana/src/gastro2/src/gstars2.c

-              r34088
+              r37067
   /* 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;
 …
   /* 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar

Property svn:mergeinfo set to

/branches/eam_branches/ipp-20140423/Ohana/src/getstar	merged	eligible
/branches/eam_branches/ipp-20140610/Ohana/src/getstar	merged	eligible
/tags/ipp-pv3-cr-20140614/Ohana/src/getstar	merged	eligible
/trunk/Ohana/src/getstar	merged	eligible

branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/GetFileMode.c

-              r34088
+              r37067
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/MatchImages.c

-              r34430
+              r37067
     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 {
 …
     tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
     tcoords.Npolyterms = 1;
     strcpy (tcoords.ctype, "RA---TAN");
+    strcpy (tcoords.ctype, "DEC--TAN");
+  }

branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/ReadImageFiles.c

-              r34088
+              r37067
           !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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/dvoImagesAtCoords.c

Property svn:mergeinfo changed
/trunk/Ohana/src/getstar/src/dvoImagesAtCoords.c merged: 36131

branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/select_by_region.c

-              r35066
+              r37067
         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;
+          }
 …
         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;
+          }

branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_0.c

-              r21508
+              r37067
       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;
+        }
 …
       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;
+        }
 …
       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;
+        }

branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_1.c

-              r21508
+              r37067
       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;
+        }
 …
       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;
+        }
 …
       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;
+        }

branches/eam_branches/ipp-ops-20130712/Ohana/src/getstar/src/write_getstar_ps1_dev_2.c

-              r21508
+              r37067
       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;
+        }
 …
       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;
+        }
 …
       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;
+        }

branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/include/constants.h

r35766	r37067
15	15	// XXX for the moment, this is set to match the values in SetColorScale3D_CC
16	16	# define NPIXELS_STATIC 128
17		// # define NPIXELS_STATIC ~~1000~~
	17	// # define NPIXELS_STATIC 4600 -- if we want fullcolor to work, need this
18	18
19	19	# define PAD1 3

branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/CheckPipe.c

-              r29938
+              r37067
 # include "Ximage.h"
+# include <errno.h>
 # define STRCONST(A) ((int)(0x1000000*A[0] + 0x10000*A[1] + 0x100*A[2] + 0x1*A[3]))
 …
   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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/DrawObjects.c

-              r35416
+              r37067
+    }
+  }
+  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 */

branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/EventLoop.c

-              r21153
+              r37067
 # include "Ximage.h"
+# define DEBUG 0
 /* list events being selected below, all other masks are ignored */
 …
 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);
 …
     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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/FlushDisplay.c

-              r21153
+              r37067
   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;
+  }

branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Graphs.c

r29539	r37067
64	64	graph[0].data.coords.crpix2 = 0.0;
65	65	graph[0].data.coords.cdelt1 = graph[0].data.coords.cdelt2 = 1.0;
66		strcpy (graph[0].data.coords.ctype, "~~RA-~~--LIN");
	66	strcpy (graph[0].data.coords.ctype, "DEC--LIN");
67	67	strcpy (graph[0].data.axis, "2222");
68	68	strcpy (graph[0].data.ticks, "2222");

branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Image.c

r29938	r37067
18	18	channel->coords.crpix2 = 0.0;
19	19	channel->coords.cdelt1 = channel->coords.cdelt2 = 1.0;
20		strcpy (channel->coords.ctype, "~~RA-~~--LIN");
	20	strcpy (channel->coords.ctype, "DEC--LIN");
21	21	channel->coords.Npolyterms = 0;
22	22

branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/Refresh.c

r27790	r37067
47	47	Y0 = graphic[0].dy - graphic[0].dy * section[0].y - dY;
48	48	X0 = graphic[0].dx * section[0].x;
49		~~// fprintf (stderr, "section: (%s) %d %d - %d %d\n", section[0].name, X0, Y0, dX, dY);~~
50	49
51	50	XFillRectangle (graphic[0].display, graphic[0].window, graphic[0].gc, X0, Y0, dX, dY);

branches/eam_branches/ipp-ops-20130712/Ohana/src/kapa2/src/bDrawObjects.c

r35416	r37067
315	315	D = scaleSize ? dz*z[i] : ds;
316	316	FillRectangle (buffer, sx, sy, 2D, 2D);
	317	// plot range saturated by bDrawRectFill
317	318	}
318	319	}
…	…
335	336	D = scaleSize ? dz*z[i] : ds;
336	337	DrawRectangle (buffer, sx, sy, 2D, 2D);
	338	// plot range saturated by bDrawRectOpen
337	339	}
338	340	}
…	…
356	358	DrawLine (buffer, sx - D, sy, sx + D, sy);
357	359	DrawLine (buffer, sx, sy - D, sx, sy + D);
	360	// out-of-range points skipped by bDrawPoint
358	361	}
359	362	}
…	…
377	380	DrawLine (buffer, sx + D, sy - D, sx - D, sy + D);
378	381	DrawLine (buffer, sx - D, sy - D, sx + D, sy + D);
	382	// out-of-range points skipped by bDrawPoint
379	383	}
380	384	}
…	…
398	402	// FillTriangle (buffer, sx - D, sy - 0.58D, sx + D, sy - 0.58D, sx, sy + 1.15*D);
399	403	FillTriangle (buffer, sx, sy + 0.58D, D, -1.73D);
	404	// out-of-range points skipped by bDrawPoint
400	405	}
401	406	}
…	…
418	423	D = scaleSize ? dz*z[i] : ds;
419	424	OpenTriangle (buffer, sx - D, sy + 0.58D, sx + D, sy + 0.58D, sx, sy - 1.15*D);
	425	// out-of-range points skipped by bDrawPoint
420	426	}
421	427	}
…	…
440	446	DrawLine (buffer, sx, sy, sx + D, sy - 0.58*D);
441	447	DrawLine (buffer, sx, sy, sx, sy + 1.15*D);
	448	// out-of-range points skipped by bDrawPoint
442	449	}
443	450	}
…	…
460	467	D = scaleSize ? dz*z[i] : ds;
461	468	DrawCircle (buffer, sx, sy, D);
	469	// out-of-range points skipped by bDrawPoint
462	470	}
463	471	}
…	…
484	492	DrawLine (buffer, sx - 0.58D, sy + 0.81D, sx - 0.95D, sy - 0.31D);
485	493	DrawLine (buffer, sx - 0.95D, sy - 0.31D, sx + 0.00D, sy - 1.00D);
	494	// out-of-range points skipped by bDrawPoint
486	495	}
487	496	}
…	…
509	518	DrawLine (buffer, sx + 0.50D, sy - 0.87D, sx - 0.50D, sy - 0.87D);
510	519	DrawLine (buffer, sx - 0.50D, sy - 0.87D, sx - D, sy);
	520	// out-of-range points skipped by bDrawPoint
511	521	}
512	522	}
…	…
529	539	D = scaleSize ? dz*z[i] : ds;
530	540	FillCircle (buffer, sx, sy, D);
	541	// out-of-range points skipped by bDrawLineHorizontal
	542	}
	543	}
	544	}
	545	if (object[0].ptype == 12) { /* filled triangle (down) */
	546	for (i = 0; i < object[0].Npts; i++) {
	547	if (!(finite(x[i]) && finite(y[i]))) continue;
	548	sx = x[i]mxi + y[i]mxj + bx;
	549	sy = x[i]myi + y[i]myj + by;
	550	if ((sx > graph[0].axis[0].fx) && (sx < graph[0].axis[0].fx + graph[0].axis[0].dfx) &&
	551	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
	552	{
	553	if (scaleColor) {
	554	if (!finite(z[i])) continue;
	555	int pixel = MIN (graphic->Npixels - 2, MAX (0, z[i]*(graphic->Npixels - 1)));
	556	buffer->bColor_R = pixel1[pixel];
	557	buffer->bColor_G = pixel2[pixel];
	558	buffer->bColor_B = pixel3[pixel];
	559	}
	560	D = scaleSize ? dz*z[i] : ds;
	561	// FillTriangle (buffer, sx - D, sy - 0.58D, sx + D, sy - 0.58D, sx, sy + 1.15*D);
	562	FillTriangle (buffer, sx, sy + 0.58D, D, 1.73D);
	563	// out-of-range points skipped by bDrawPoint
531	564	}
532	565	}

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/Makefile.Targets

-              r34405
+              r37067
 $(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 \
 …
 $(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 \
 …
 $(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 \
 …
 $(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 \
 …
 $(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 \
 …
 $(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 \
 …
 $(ASRC)/FlatCorrectionImage.$(ARCH).o \
 $(ASRC)/FlatCorrection.$(ARCH).o
+# $(ASRC)/cmf-ps1-sv3.$(ARCH).o
 AINCS = \
 …
 $(AINC)/average-ps1-v3.h \
 $(AINC)/average-ps1-v4.h \
+$(AINC)/average-ps1-v5.h \
 $(AINC)/average-ps1-ref.h \
 $(AINC)/secfilt.h \
 …
 $(AINC)/secfilt-ps1-v3.h \
 $(AINC)/secfilt-ps1-v4.h \
+$(AINC)/secfilt-ps1-v5.h \
 $(AINC)/secfilt-ps1-ref.h \
 $(AINC)/measure.h \
 …
 $(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 \
 …
 $(AINC)/photcode-ps1-v3.h \
 $(AINC)/photcode-ps1-v4.h \
+$(AINC)/photcode-ps1-v5.h \
 $(AINC)/photcode-ps1-ref.h \
 $(AINC)/image.h \
 …
 $(AINC)/image-ps1-v3.h \
 $(AINC)/image-ps1-v4.h \
+$(AINC)/image-ps1-v5.h \
 $(AINC)/image-ps1-ref.h \
 $(AINC)/regimage.h \
 …
 $(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 \

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-dev-2.d

r16810	r37067
25	25	FIELD measureOffset, OFF_MEASURE, int, offset to first psf measurement
26	26	FIELD missingOffset, OFF_MISSING, int, offset to first missing obs
27		FIELD ~~extendOffset, OFF_EXTEND, int, offset to first extended measurement~~
	27	FIELD refColor, REF_COLOR, float, color of astrometry ref stars
28	28
29	29	FIELD code, code, unsigned short, ID code (star; ghost; etc)

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v1.d

r21508	r37067
30	30	FIELD measureOffset, OFF_MEASURE, uint32_t, offset to first psf measurement
31	31	FIELD missingOffset, OFF_MISSING, uint32_t, offset to first missing obs
32		FIELD ~~extendOffset, OFF_EXTEND, uint32_t, offset to first extended measurement~~
	32	FIELD refColor, REF_COLOR, float, color of astrometry ref stars
33	33
34	34	# 'flags' was called 'code' prior to 2009.02.07

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v2.d

r33647	r37067
35	35	FIELD measureOffset, OFF_MEASURE, uint32_t, offset to first psf measurement
36	36	FIELD missingOffset, OFF_MISSING, uint32_t, offset to first missing obs
37		FIELD ~~extendOffset, OFF_EXTEND, uint32_t, offset to first extended measurement~~
	37	FIELD refColor, REF_COLOR, float, color of astrometry ref stars
38	38
39	39	# 'flags' was called 'code' prior to 2009.02.07

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v3.d

r33647	r37067
35	35	FIELD measureOffset, OFF_MEASURE, uint32_t, offset to first psf measurement
36	36	FIELD missingOffset, OFF_MISSING, uint32_t, offset to first missing obs
37		FIELD ~~extendOffset, OFF_EXTEND, uint32_t, offset to first extended measurement~~
	37	FIELD refColor, REF_COLOR, float, color of astrometry ref stars
38	38
39	39	# 'flags' was called 'code' prior to 2009.02.07

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average-ps1-v4.d

r34405	r37067
38	38	FIELD measureOffset, OFF_MEASURE, uint32_t, offset to first psf measurement
39	39	FIELD missingOffset, OFF_MISSING, uint32_t, offset to first missing obs
40		FIELD ~~extendOffset, OFF_EXTEND, uint32_t, offset to first extended measurement~~
	40	FIELD refColor, REF_COLOR, float, color of reference stars
41	41
42	42	# 'flags' was called 'code' prior to 2009.02.07

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/average.d

-              r34405
+              r37067
 EXTNAME      DVO_AVERAGE
 TYPE         BINTABLE
 SIZE         128
+SIZE         184
 DESCRIPTION  DVO Average Object Table
 …
 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 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
 …
 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
 …
 # *** 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/common.h

r34088	r37067
32	32	# define rawshort short
33	33
34		# define DVO_IMAGE_NAME_LEN 121
	34	# define DVO_IMAGE_NAME_LEN 117
35	35
36	36	/*** rawshort is used to handle the broken pre-autocode photreg tables

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/image-ps1-v2.d

r30604	r37067
42	42	FIELD DECo, DEC_CENTER, float, image center, degrees
43	43	FIELD Radius, RADIUS, float, image radius, degrees
44		FIELD ~~DUMMY, DUMMY,~~ float, dummy
	44	FIELD refColor, REF_COLOR, float, dummy
45	45
46	46	# should we define the max length of name as a macro?

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/image-ps1-v3.d

r33647	r37067
42	42	FIELD DECo, DEC_CENTER, float, image center, degrees
43	43	FIELD Radius, RADIUS, float, image radius, degrees
44		FIELD ~~DUMMY, DUMMY,~~ float, dummy
	44	FIELD refColor, REF_COLOR, float, dummy
45	45
46	46	# should we define the max length of name as a macro?

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/image-ps1-v4.d

r34260	r37067
42	42	FIELD DECo, DEC_CENTER, float, image center, degrees
43	43	FIELD Radius, RADIUS, float, image radius, degrees
44		FIELD ~~DUMMY, DUMMY,~~ float, dummy
	44	FIELD refColor, REF_COLOR, float, dummy
45	45
46	46	# should we define the max length of name as a macro?

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/image.d

-              r33963
+              r37067
 FIELD     DECo,             DEC_CENTER,           float,          image center,              degrees
 FIELD     Radius,           RADIUS,               float,          image radius,              degrees
+FIELD     DUMMY,            DUMMY,                float,          dummy
+FIELD     refColorBlue,     REF_COLOR_BLUE,       float,          median astrometry ref color
+FIELD     refColorRed,      REF_COLOR_RED,        float,          median astrometry ref color
+FIELD     name,             NAME,                 char[121],      name of original image
+# should we define the max length of name as a macro?
+FIELD     name,             NAME,                 char[117],      name of original image
 FIELD     detection_limit,  DETECTION_LIMIT,      unsigned char,  detection limit,           10*mag
 FIELD     saturation_limit, SATURATION_LIMIT,     unsigned char,  saturation limit,          10*mag

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/measure.d

-              r35099
+              r37067
 EXTNAME      DVO_MEASURE
 TYPE         BINTABLE
 SIZE         184
+SIZE         228
 DESCRIPTION  DVO Detection Measurement Table
+FIELD dR,             D_RA,         float,          RA offset,                      arcsec
+FIELD dD,             D_DEC,        float,          DEC offset,                     arcsec
+FIELD M,              MAG,          float,          catalog mag,                    mag
+FIELD Mcal,           M_CAL,        float,          image cal mag,                  mag
+FIELD Map,            M_APER,       float,          aperture mag,                   mag
+FIELD Mkron,          M_KRON,       float,          kron magnitude,                 mag
+FIELD dMkron,         M_KRON_ERR,   float,          kron magnitude error,           mag
+FIELD dM,             MAG_ERR,      float,          mag error,                      mag
+FIELD dMcal,          MAG_CAL_ERR,  float,          systematic calibration error,   mag
+FIELD dt,             M_TIME,       float,          exposure time,                  2.5*log(exptime)
+FIELD R,              RA,            double,         RA at epoch,                  degrees
+FIELD D,              DEC,           double,         DEC at epoch,                 degrees
+FIELD M,              MAG,           float,          catalog mag,                    mag
+FIELD dM,             MAG_ERR,       float,          mag error,                      mag
+FIELD Map,            M_APER,        float,          aperture mag,                   mag
+FIELD dMap,           M_APER,        float,          aperture mag,                   mag
+FIELD Mkron,          M_KRON,        float,          kron magnitude,                 mag
+FIELD dMkron,         M_KRON_ERR,    float,          kron magnitude error,           mag
+FIELD Mcal,           M_CAL,         float,          image cal mag,                  mag
+FIELD dMcal,          MAG_CAL_ERR,   float,          systematic calibration error,   mag
+FIELD dt,             M_TIME,        float,          exposure time,                  2.5*log(exptime)
 # for stacks only?
+FIELD FluxPSF,        FLUX_PSF,     float,          flux from psf fit,              counts/sec?
+FIELD dFluxPSF,       FLUX_PSF_ERR, float,          error on psf flux,              counts/sec?
+FIELD FluxKron,       FLUX_KRON,     float,         flux from kron ap,              counts/sec?
+FIELD dFluxKron,      FLUX_KRON_ERR, float,         error on kron flux,             counts/sec?
+FIELD FluxPSF,        FLUX_PSF,      float,         flux from psf fit,              counts/sec
+FIELD dFluxPSF,       FLUX_PSF_ERR,  float,         error on psf flux,              counts/sec
+FIELD FluxKron,       FLUX_KRON,     float,         flux from kron ap,              counts/sec
+FIELD dFluxKron,      FLUX_KRON_ERR, float,         error on kron flux,             counts/sec
+FIELD FluxAp,         FLUX_AP,       float,         flux from ap,                   counts/sec
+FIELD dFluxAp,        FLUX_AP_ERR,   float,         error on ap flux,               counts/sec
 # note that with airmass = 1.0 / cos(90 - alt), we have full alt/az representation
 …
 FIELD Yfix,           Y_FIX,        float,          Y coord after correction,     pixels
+FIELD XoffKH,         X_OFF_KH,      float,          X offset from correction,     pixels
+FIELD YoffKH,         Y_OFF_KH,      float,          Y offset from correction,     pixels
+FIELD XoffDCR,        X_OFF_DCR,     float,          X offset from correction,     pixels
+FIELD YoffDCR,        Y_OFF_DCR,     float,          Y offset from correction,     pixels
+FIELD RoffGAL,        R_OFF_GAL,     float,          RA offset from correction,    arcsec
+FIELD DoffGAL,        D_OFF_GAL,     float,          DEC offset from correction,   arcsec
 # could these be packed into fewer bits?
 FIELD Sky,            SKY_FLUX,     float,          local estimate of sky flux,     counts/sec
 …
 FIELD t,              TIME,         int,            time in seconds (UNIX)
-FIELD t_msec,         TIME_MSEC,    unsigned short, time fraction of second,        milliseconds
 FIELD averef,         AVE_REF,      unsigned int,   reference to average entry
 FIELD detID,          DET_ID,       unsigned int,   detection ID
-FIELD imageID,        IMAGE_ID,     unsigned int,   reference to DVO image ID
 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
 …
 # PSPS uses a 64-bit detection ID
 FIELD extID,          EXT_ID,       uint64_t,       external ID (eg PSPS detID)
+FIELD imageID,        IMAGE_ID,     unsigned int,   reference to DVO image ID
 # do we need more resolution than a short? should this be a log?
 …
 FIELD Myy,            MYY,          short,          second moments in pixel coords, 1/100 of pixels^2
+# fractional exposure time
+FIELD t_msec,         TIME_MSEC,    unsigned short, time fraction of second,        milliseconds
+FIELD photcode,       PHOTCODE,     unsigned short, photcode
 # convert this to error in pixels on load?
 FIELD dXccd,          X_CCD_ERR,    short,          X coord error on chip,          1/100 of pixels
 …
 FIELD pltscale,       PLTSCALE,     float,          plate scale,                    arcsec/pixel
-FIELD photcode,       PHOTCODE,     unsigned short, photcode
 FIELD dbFlags,        DB_FLAGS,     unsigned int,   flags supplied by analysis in database
 FIELD photFlags,      PHOT_FLAGS,   unsigned int,   flags supplied by photometry program
 …
 #                Changed dbFlags, photFlags : uint16_t to uint64_t
+# *** 20140617 : changed: dR,dD -> 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v2.d

-              r27579
+              r37067
 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v3.d

-              r33647
+              r37067
 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode-ps1-v4.d

-              r34260
+              r37067
 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/photcode.d

-              r33647
+              r37067
 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v1.d

-              r21508
+              r37067
 # 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v2.d

-              r27579
+              r37067
 # 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v3.d

r33963	r37067
9	9	FIELD Map, MAG_AP, float, ave aperture mag in this band, mags
10	10	FIELD dM, MAG_ERR, float, formal error on average mag, mags
11		FIELD ~~Xm, MAG_CHI, float, chisq on average mag, [100*log(value)]~~
	11	FIELD Mchisq, MAG_CHI, float, chisq on average mag, value
12	12	FIELD flags, FLAGS, uint32_t, photometry flags
13	13	FIELD Ncode, NCODE, short, number of detections in band

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt-ps1-v4.d

r34620	r37067
11	11	FIELD dMkron, MAG_KRON_ERR, float, formal error on average kron mag, mags
12	12	FIELD dM, MAG_ERR, float, formal error on average mag, mags
13		FIELD ~~Xm, MAG_CHI, float, chisq on average mag, [100*log(value)]~~
	13	FIELD Mchisq, MAG_CHI, float, chisq on average mag, value
14	14	FIELD FluxPSF, FLUX_PSF, float, mean flux psf fit (PS1: stack)
15	15	FIELD dFluxPSF, FLUX_PSF_ERR, float, mean flux psf error

branches/eam_branches/ipp-ops-20130712/Ohana/src/libautocode/def/secfilt.d

-              r35099
+              r37067
 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)

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/Makefile

-              r35416
+              r37067
 $(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
 …
 $(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    \
 …
 $(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          \
 …
 $(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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/dvo.h

-              r35755
+              r37067
   DVO_FORMAT_PS1_V3,
   DVO_FORMAT_PS1_V4,
+  DVO_FORMAT_PS1_V5,
 } DVOTableFormat;
 …
 /* catalog values to be loaded */
+# define LOAD_NONE      0x00
+# define LOAD_AVES      0x01
+# define LOAD_MEAS      0x02
+# define LOAD_MISS      0x04
+# define LOAD_SECF      0x08
+# define SKIP_AVES      0x10
+# define SKIP_MEAS      0x20
+# define SKIP_MISS      0x40
+# define SKIP_SECF      0x80
+// # define LOAD_MEAS_META 0x100 -- is this used??
+# define LOAD_NONE      0x000
+# define LOAD_AVES      0x001
+# define LOAD_MEAS      0x002
+# define LOAD_MISS      0x004
+# define LOAD_SECF      0x008
+# define SKIP_AVES      0x010
+# define SKIP_MEAS      0x020
+# define SKIP_MISS      0x040
+# define SKIP_SECF      0x080
+# define LOAD_LENSING   0x100
+# define LOAD_LENSOBJ   0x200
+# define SKIP_LENSING   0x400
+# define SKIP_LENSOBJ   0x800
 /* photometry code types */
 …
   ID_STAR_USE_PAR   = 0x00200000, // parallax used (not AVE or PM)
   ID_STAR_NO_ASTROM = 0x00400000, // mean astrometry could not be measured
+  ID_STAR_BAD_PM    = 0x00800000, // mean astrometry could not be measured
   ID_OBJ_EXT        = 0x01000000, // extended in our data (eg, PS)
   ID_OBJ_EXT_ALT    = 0x02000000, // extended in external data (eg, 2MASS)
 …
 } HostTable;
+// A RegionHost processes data for some region in parallel with other regions
+typedef struct RegionHostInfo {
+  double Rmin;        // (Rmin,Rmax),(Dmin,Dmax) arehard RA,DEC boundaries of the
+  double Rmax;        // region for which each host is responsible.  A given host
+  double Dmin;        // calibrates the images for which the fiducial point (center)
+  double Dmax;        // lands in the region, and all objects in the region
+  double RminCat;      // (RminCat,RmaxCat),(DminCat,DmaxCat) are the region for which
+  double RmaxCat;      // the catalogs need to be loaded : this is the outer bounds
+  double DminCat;      // of the region containing all images completely
+  double DmaxCat;
+  char *hostname;
+  int hostID;                 // remove machine ID in SkyTable
+  int stdio[3];               // fd's for communication with the remote host
+  int pid;                    // remote process ID
+  int status;
+  IOBuffer stdout;
+  IOBuffer stderr;
+  off_t Nimage;
+  off_t NIMAGE;
+  Image *image;
+  off_t *imseq;
+  int *neighbors;             // list of neighbor index values
+  int Nneighbors;             // number of neighbors
+  char isNeighbor;            // TRUE if I am a neighbor to the current region host
+} RegionHostInfo;
+typedef struct {
+  double Rmin;
+  double Rmax;
+  double Dmin;
+  double Dmax;
+  int Nhosts;
+  RegionHostInfo *hosts;
+  short *index;
+} RegionHostTable;
 // special-case function:
 CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, off_t *Ndata, char *swapped);
 …
 // another special case : does not match byte-boundaries
 # include "cmf-ps1-dv3.h"
+# include "cmf-ps1-sv3.h"
+# include "cmf-ps1-v5.h"
+# include "cmf-ps1-v5-lensing.h"
 typedef struct {
 …
 # define BOUNDARY_TREE_NAME_LENGTH 128
+// BoundaryTree is a structure to describe the 3pi RINGS skycell boundaries in terms of lines of constant (RA,DEC)
+// the structure is flexible for a variety of RINGS-like tessellations, but is not appropriate for the LOCAL style tess
 typedef struct {
   int FixedGridDEC;           // is the DEC sequence linear?
 …
 } BoundaryTree;
+// XXX DROP? // a reduced-subset structure for relastro
+// XXX DROP? typedef struct {
+// XXX DROP?   double         R;
+// XXX DROP?   double         D;
+// XXX DROP?   unsigned short Nmeasure;
+// XXX DROP?   int            measureOffset;
+// XXX DROP?   uint32_t       flags;
+// XXX DROP?   int            catID;
+// XXX DROP? } AverageTinyAstro;
+typedef enum { TESS_NONE, TESS_LOCAL, TESS_RINGS } TessType;
+// TessellationTable is a structure to describe the parameters of a set of "tessellations"
+// (these are not strictly tessellations but projection sets as only the non-local
+// versions can cover the full sky).  For LOCAL projection cells, the structure describes
+// the boundaries of a SINGLE projection cell with Nx * Ny skycells and includes some
+// basic parameters (not used by the fullsky, eg RINGS, tessellations)
+typedef struct {
+  double Rmin; // this tessellation is valid only for RA >= 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
 …
   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;
 …
   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 */
 …
   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
 …
   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;
 …
   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;
 …
 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);
 …
 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);
 …
 /*** 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);
 …
 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);
 …
 # include "ps1_v3_defs.h"
 # include "ps1_v4_defs.h"
+# include "ps1_v5_defs.h"
 # include "ps1_ref_defs.h"
 …
 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);
 …
 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);
 …
 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/dvodb.h

-              r35416
+              r37067
 /* 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 */
 …
       MEAS_OBJ_FLAGS,
       MEAS_SECFILT_FLAGS,
       MEAS_MAG,
+      MEAS_PHOT, // photometry class of measurements
       MEAS_MINST,
       MEAS_MCAT,
 …
       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,
 };
 …
       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,
 …
       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,
 …
       IMAGE_NFIT_ASTROM,
       IMAGE_NLINK_PHOTOM,
+      IMAGE_NLINK_ASTROM
+      IMAGE_NLINK_ASTROM,
+      IMAGE_REF_COLOR
 };
 …
   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;
 …
 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));
 …
 // 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/elixir_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/loneos_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/panstarrs_dev_0_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/panstarrs_dev_1_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_dev_1_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_dev_2_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_ref_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v1_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v2_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v3_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/include/ps1_v4_defs.h

-              r35162
+              r37067
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/BoundaryTree.c

-              r35755
+              r37067
 # 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");
 …
 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;
+}
 …
 int BoundaryTreeSave(char *filename, BoundaryTree *tree) {
-  int i, nz, nb;
   Header header;
-  Header theader;
   Matrix matrix;
-  FTable ftable;
   gfits_init_header (&header);
 …
   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 ***/

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/HostTable.c

-              r35102
+              r37067
       FreeHosts (hosts, Nhosts);
       free (filename);
+      fclose (f);
       return NULL;
+    }
 …
   free (filename);
+  fclose (f);
   return table;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageMetadata.c

-              r35416
+              r37067
   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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageMetadataSelection.c

-              r35416
+              r37067
   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 */
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/ImageSelection.c

r35416	r37067
28	28	mosaic.pc1_2 = mosaic.pc2_1 = 0.0;
29	29	mosaic.Npolyterms = 0;
30		strcpy (mosaic.ctype, "~~RA-~~--SIN");
	30	strcpy (mosaic.ctype, "DEC--SIN");
31	31	}
32	32

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/LoadPhotcodesFITS.c

-              r35755
+              r37067
   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 ();
 …
   // 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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/LoadPhotcodesText.c

-              r28833
+              r37067
+    }
+    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));
 …
     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) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/SavePhotcodesFITS.c

-              r34260
+              r37067
   // 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/cmf-ps1-dv3.c

r35416	r37067
2	2
3	3	/*** note : this file is derived from the autocode version, but is modified because
4		the forma does not match with structure byte boundaries ***/
	4	the format does not match with structure byte boundaries ***/
5	5
6	6	/* if we are not correctly including the ohana headers, this will fail */

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/coordops.c

-              r34088
+              r37067
 # include <dvo.h>
+/* note that Coords.ctype carries the DEC (ctype2) value */
 static Coords mosaic;
 …
   /* modifications to the ctype? */
+  /* note that Coords.ctype carries the DEC (ctype2) value */
   OldAIPS = FALSE;
   gfits_modify (header, "CTYPE2",   "%s",  1, coords[0].ctype);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbCheckStack.c

r35755	r37067
7	7	// these would be better done using bit values to test for field? temp? float?
8	8	//
9
10		~~#define OPIHI_INT 1~~
11	9
12	10	int dbCheckStack (dbStack stack, int Nstack, int table, dbField inFields, int inNfields) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractAverages.c

-              r35416
+              r37067
 dbValue dbExtractAverages (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
+  off_t i;
+  int Nsec;
+  // off_t i;
   dbValue value;
 …
       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;
 …
       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:
 …
+            }
           } else {
             value.Flt = PhotdM (field->photcode, average, secfilt);
+            value.Flt = PhotAveErr (field->photcode, average, secfilt);
+          }
           break;
 …
+            }
           } else {
             Nsec = GetPhotcodeNsec (field->photcode->code);
+            int Nsec = GetPhotcodeNsec (field->photcode->code);
             if (Nsec == -1) break;
             value.Int = secfilt[Nsec].flags;
 …
           // 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;
 …
           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:
 …
       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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractImages.c

-              r35102
+              r37067
       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;
 …
       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;
 …
         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;
 …
         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;
 …
         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;
 …
         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;
 …
       value.Int = image[N].nLinkAstrom;
       break;
+    case IMAGE_REF_COLOR:
+      value.Flt = image[N].refColorBlue;
+      break;
+  }
   return (value);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbExtractMeasures.c

-              r35508
+              r37067
   dbValue value;
   double dT;
+  float dR, dD;
   Coords *mosaic, *fieldc;
 …
   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;
 …
       // 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;
 …
             // 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;
 …
   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;
+      }
 …
+    }
     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 */
 …
     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;
+      }
 …
     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;
+      }
 …
     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;
+      }
 …
     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;
+      }
 …
     // 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 */
 …
     case MEAS_PLATESCALE: /* OK */
       value.Flt = measure[0].pltscale;
+      break;
+    case MEAS_REF_COLOR:
+      value.Flt = average[0].refColorBlue;
       break;
 …
         // 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;
 …
+      {
         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;
 …
           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);
+      }
 …
           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);
+      }
 …
           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);
+      }
 …
           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);
+      }
 …
       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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dbFields.c

-              r35416
+              r37067
   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);
 …
   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);
 …
   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);
 …
   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);
 …
   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;
 …
+  }
   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;
 …
   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);
+  }
 …
   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);
+}
 …
   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);
+  }
 …
   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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog.c

-              r35416
+              r37067
   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);
 …
+}
+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;
 …
   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;
 …
   average->catID           = 0;
   average->extID           = 0;
+  average->extIDgc         = 0;
+}
 …
   average->measureOffset   = -1;
   average->catID           = 0;
+  average->nOwn            = 0;
+}
 …
 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;
 …
  measure->FluxKron  = NAN;
  measure->dFluxKron = NAN;
+ measure->FluxAp    = NAN;
+ measure->dFluxAp   = NAN;
  measure->airmass   = NAN;
 …
  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;
 …
  measure->Myy       = 0;
+ measure->t_msec    = 0;
+ measure->photcode  = 0;
  measure->dXccd     = 0;
  measure->dYccd     = 0;
 …
  measure->pltscale  = NAN;
- measure->photcode  = 0;
  measure->dbFlags   = 0;
  measure->photFlags = 0;
 …
 void dvo_measureT_init (MeasureTiny *measure) {
  measure->dR        = NAN;
  measure->dD        = NAN;
+ measure->R         = NAN;
+ measure->D         = NAN;
  measure->M         = NAN;
  measure->Mcal      = NAN;
 …
  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;
+}
 …
   catalog[0].secfilt = NULL;
+  catalog[0].lensing = NULL;
+  catalog[0].lensobj = NULL;
   catalog[0].averageT = NULL;
   catalog[0].measureT = NULL;
 …
   catalog[0].Nsecf_mem = 0;
+  catalog[0].Nlensing = 0;
+  catalog[0].Nlensobj = 0;
   catalog[0].Naves_disk = 0;
   catalog[0].Nmeas_disk = 0;
 …
   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;
 …
   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;
+}
 …
+  }
+  // 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);
 …
     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;
+      }
+    }
 …
       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);
 …
   /* 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);
+}
 …
+      }
+    }
+    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;
 …
   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;
+  }
 …
+      }
+    }
+    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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_chipcoords.c

-              r16810
+              r37067
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_create.c

-              r27435
+              r37067
     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);
 …
+    }
     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);
 …
   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:

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_mef.c

-              r33649
+              r37067
   off_t Nmeasure;
   off_t Nmissing;
+  off_t Nlensing;
+  off_t Nlensobj;
   off_t Nitems, Nexpect;
   int Nsecfilt;
 …
   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
 …
   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
 …
   catalog[0].missing = NULL;
   catalog[0].secfilt = NULL;
+  catalog[0].lensing = NULL;
+  catalog[0].lensobj = NULL;
   /* validate table mode ?*/
 …
       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);
 …
+  }
+  /* 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);
+}
 …
   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);
 …
   /* 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");
 …
   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");
 …
   secfilt header
   secfilt table
+  lensing header
+  lensing table
+  lensobj header
+  lensobj table
 */

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_raw.c

-              r34260
+              r37067
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 …
   /* 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 */
 …
   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");
 …
   /* 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 */
 …
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 …
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 …
 /** 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;
 …
       } \
       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; }
 …
+      }
       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; }
 …
       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);
 …
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 …
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_catalog_split.c

-              r34844
+              r37067
   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);
+  }
 …
   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);
 …
   off_t Nmeasure;
   off_t Nmissing;
+  off_t Nlensing;
+  off_t Nlensobj;
   off_t Nitems;
   int status, Nsecfilt;
 …
   /* 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
 …
   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
 …
   catalog[0].missing = NULL;
   catalog[0].secfilt = NULL;
+  catalog[0].lensing = NULL;
+  catalog[0].lensobj = NULL;
   /*** Average Table ***/
 …
+    }
     /* 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);
 …
   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);
+}
 …
   off_t Nbytes;
   off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing;
+  off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing, Nlensing, Nlensobj;
   Header header;
   FTable ftable;
 …
     /* 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
 …
     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);
+}
 …
   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;
 …
   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 */
 …
   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);
 …
     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;
 …
     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;
+    }
 …
   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;
 …
   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;
+  }
 …
   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 */
 …
   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);
 …
     // 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;
 …
     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;
+    }
 …
   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;
 …
   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 */
 …
   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);
 …
     // 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;
 …
     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;
+    }

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert.c

-              r35172
+              r37067
   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
 …
     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);
+  }
 …
   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
 …
       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
 …
 /*** 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;
 …
+  }
+# 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); }
 …
+  }
+  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
 …
+}
+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); \
 …
       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
 …
   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
 …
       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
 …
     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);
+  }
 …
   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);
 …
       FORMAT_CASE (PS1_V3,          PS1_V3);
       FORMAT_CASE (PS1_V4,          PS1_V4);
+      FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);
 …
       FORMAT_CASE (PS1_V3,          PS1_V3);
       FORMAT_CASE (PS1_V4,          PS1_V4);
+      FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c

-              r35162
+              r37067
 /* 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;
 …
   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;
 …
+}
 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;
 …
   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;
 …
     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;
 …
     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;
 …
   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) {
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c

-              r35162
+              r37067
 /* 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;
 …
   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;
 …
+}
 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;
 …
   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;
 …
     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;
 …
     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;
 …
     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;
 …
     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;
 …
   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) {
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_3.c

-              r35162
+              r37067
 // 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) {
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c

-              r35162
+              r37067
 /* 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;
 …
     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;
 …
+}
 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;
 …
   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;
 …
+}
+# define RAW_IMAGE_NAME_LEN 121
 Image *Image_PS1_REF_ToInternal (Image_PS1_REF *in, off_t Nvalues, off_t Nalloc) {
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c

-              r35162
+              r37067
 /* 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;
 …
     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;
 …
+}
 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;
 …
   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;
 …
     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;
 …
     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;
 …
     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);
 …
     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) {
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c

-              r35162
+              r37067
 /* 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;
 …
     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;
 …
+}
 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;
 …
   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;
 …
     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;
 …
     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;
 …
     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);
 …
     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) {
 …
     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;
 …
     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;
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c

-              r35162
+              r37067
 /* 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;
 …
     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;
 …
+}
 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;
 …
   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;
 …
     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;
 …
     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;
 …
     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;
 …
     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;
 …
   return (out);
+}
+# define RAW_IMAGE_NAME_LEN 121
 Image *Image_PS1_V3_ToInternal (Image_PS1_V3 *in, off_t Nvalues, off_t Nalloc) {
 …
     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;
 …
     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;
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c

-              r35162
+              r37067
 /* 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;
 …
     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;
 …
+}
 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;
 …
   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;
 …
     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;
 …
     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;
 …
     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;
 …
     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;
 …
   return (out);
+}
+# define RAW_IMAGE_NAME_LEN 121
 Image *Image_PS1_V4_ToInternal (Image_PS1_V4 *in, off_t Nvalues, off_t Nalloc) {
 …
     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;
 …
     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;
 …
     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;
 …
     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;
 …
   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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_elixir.c

-              r35162
+              r37067
 /* 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;
 …
     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;
 …
 /* 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;
 …
     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;
 …
     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
 …
     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
 …
     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
 …
   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
 …
   return (out);
+}
+# define RAW_IMAGE_NAME_LEN 32
 /* convert elixir-format images to internal images */
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_loneos.c

-              r35162
+              r37067
 /* 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;
 …
     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;
 …
 /* 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;
 …
   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;
 …
     // 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
 …
     // 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
 …
     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
 …
   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
 …
   return (out);
+}
+# define RAW_IMAGE_NAME_LEN 32
 /* convert loneos-format images to internal images */
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c

-              r35162
+              r37067
 /* 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;
 …
   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;
 …
 /* 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;
 …
   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;
 …
     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;
 …
     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;
 …
   return (out);
+}
+# define RAW_IMAGE_NAME_LEN 32
 /* convert panstarrs-format images to internal images */
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c

-              r35162
+              r37067
 /* 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;
 …
   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;
 …
 /* 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;
 …
   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;
 …
     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;
 …
     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;
 …
   return (out);
+}
+# define RAW_IMAGE_NAME_LEN 64
 /* convert panstarrs-format images to internal images */
 …
     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;
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_image.c

r35162	r37067
219	219	if (db[0].format == DVO_FORMAT_PS1_V3) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V3");
220	220	if (db[0].format == DVO_FORMAT_PS1_V4) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V4");
	221	if (db[0].format == DVO_FORMAT_PS1_V5) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V5");
221	222	if (db[0].format == DVO_FORMAT_PS1_REF) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_REF");
222	223

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_image_raw.c

-              r34260
+              r37067
   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);
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_photcode_ops.c

-              r34844
+              r37067
 static PhotCodeData *photcodes = NULL;
+static PhotCode *genericCodeMag = NULL;
+static PhotCode *genericCodeFlux = NULL;
 PhotCodeData *GetPhotcodeTable () {
 …
     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;
+}
 …
   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)) {
 …
   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++) {
 …
+}
+// returns Nsec if code is PRI/SEC, else -1
 int GetPhotcodeNsec (int code) {
 …
 /******** 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) {
 …
+}
-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) {
 …
+}
-/* 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) {
 …
+}
-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) {
 …
   Ns = photcodes[0].hashNsec[code[0].code];
   Fpsf = (Ns == -1) ? NAN : secfilt[Ns].FluxPSF;
+  Fpsf = (Ns == -1) ? NAN : secfilt[Ns].FpsfStk;
   return (Fpsf);
+}
 …
   Ns = photcodes[0].hashNsec[code[0].code];
   dFpsf = (Ns == -1) ? NAN : secfilt[Ns].dFluxPSF;
+  dFpsf = (Ns == -1) ? NAN : secfilt[Ns].dFpsfStk;
   return (dFpsf);
+}
 …
   Ns = photcodes[0].hashNsec[code[0].code];
   Fkron = (Ns == -1) ? NAN : secfilt[Ns].FluxKron;
+  Fkron = (Ns == -1) ? NAN : secfilt[Ns].FkronStk;
   return (Fkron);
+}
 …
   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);
+}
 …
+}
 // 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;
 …
   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);
+}
 …
+}
+/******** 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);
+}
 …
+}
-/* 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) {
 …
+}
 // 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;
 …
   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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvo_tiny_values.c

-              r35102
+              r37067
   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;
 …
   measureT[0].dYccd      = measure[0].dYccd;
   measureT[0].dRsys      = measure[0].dRsys;
+  measureT[0].myDet      = 0;
   return ;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/dvosorts.c

-              r35263
+              r37067
 /* 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) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/libdvo/src/skyregion_io.c

r33649	r37067
78	78	gfits_free_matrix (&matrix);
79	79	gfits_free_header (&theader);
	80	fclose (f);
80	81
81	82	return (skytable);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/include/gfitsio.h

-              r35756
+              r37067
 # 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/matrix/F_compress_M.c

-              r34088
+              r37067
   // 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;
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_get_column.c

-              r35101
+              r37067
+    }
+  }
+  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) {
 …
 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;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_set_column.c

-              r35101
+              r37067
   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;
 …
   Pout = array;
+  // # define ASSIGN_DATA(ITYPE,INAME,ISIZE,OTYPE,ONAME)
+  // if (!strcmp (intype, #ITYPE)) {
   /** input == char **/
   if (!strcmp (outtype, "char") && !strcmp (intype, "char")) {
 …
+    }
+  }
+  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;
 …
+  }
   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) {
 …
+    }
+  }
+  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;
 …
+    }
+  }
+  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;
 …
+    }
+  }
+  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;
 …
+    }
+  }
+  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;
 …
   /** 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) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/libfits/table/F_table_format.c

-              r28241
+              r37067
   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':
 …
     break;
   case  'B':
     { *Nbytes = 1;  strcpy (type, "char");   *Nval = Nv;               }
+    { *Nbytes = 1;  strcpy (type, "byte");   *Nval = Nv;               }
     break;
   case  'I':
 …
+    }
+    // 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++) {
 …
+    }
+    // does this make sense? (see note above)
     if (!strcmp (type, "char"))   {
       for (j = 0; j < Ny; j++) {
 …
+      }
+    }
+    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++) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/IOfuncs.c

-              r35761
+              r37067
   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) */
 …
   /* 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 */

branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KapaOpen.c

-              r35761
+              r37067
 # include "kapa_internal.h"
+// kapa connection timeout is N_RETRY * 10000 usec
+# define N_RETRY 2000
 # define MY_PORT 2500
 …
 static int *VALID = NULL;
-char *_parse_nextword (char *string);
 int KapaLaunchCommand (char *line);
 …
   // 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);
+    }
+  }
 …
+  }
+# 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
 …
+  }
+  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);
+}
 …
   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;
 …
+  }
+  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
 …
   done = FALSE;
   while (!done) {
     q = _parse_nextword (p);
+    q = parse_nextword (p);
     if (q && *q) {
       argv[i] = strncreate (p, q - p);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KapaWindow.c

r35761	r37067
100	100	graphdata[0].coords.pc1_1 = graphdata[0].coords.pc2_2 = 1.0;
101	101	graphdata[0].coords.pc1_2 = graphdata[0].coords.pc2_1 = 0.0;
102		strcpy (graphdata[0].coords.ctype, "~~RA-~~--LIN");
	102	strcpy (graphdata[0].coords.ctype, "DEC--LIN");
103	103	graphdata[0].coords.crval1 = 0.0;
104	104	graphdata[0].coords.crval2 = 0.0;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/KiiPicture.c

-              r34088
+              r37067
 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;
 …
   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);
 …
   /* 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;
+  }
 …
 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;
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/libkapa/src/bDrawFuncs.c

-              r33956
+              r37067
   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;
 …
   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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/include/ohana.h

-              r35754
+              r37067
 # 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)))
 …
 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));
 …
 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 */

branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/src

Property svn:mergeinfo deleted

branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/src/gaussj.c

-              r24080
+              r37067
 # include <ohana.h>
 # 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
 …
     /* 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;
 …
+    }
+  }
+# 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/libohana/src/string.c

-              r34753
+              r37067
+}
 char *_parse_nextword (char *string) {
+char *parse_nextword (char *string) {
   if (string == (char *) NULL) return ((char *) NULL);
 …
 // ,,, : 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);
 …
   word = line;
   for (i = 0; i < NX - 1; i++)
     word = _parse_nextword (word);
+    word = parse_nextword (word);
   *X = strtod (word, &ptr);
 …
   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 = line;
   for (i = 0; i < NX - 1; i++)
     word = _parse_nextword (word);
+    word = parse_nextword (word);
   *X = strtol (word, &ptr, 0);
 …
   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 = line;
   for (i = 0; i < NX - 1; i++)
     word = _parse_nextword (word);
+    word = parse_nextword (word);
   *X = word[0];
 …
   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];
 …
+}
+// 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) {
 …
   word = line;
   for (i = 0; i < NX - 1; i++)
     word = _parse_nextword (word);
+    word = parse_nextword (word);
   status = ohana_str_to_time (word, X);
 …
   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 = line;
   for (i = 0; i < NX - 1; i++)
     word = _parse_nextword (word);
+    word = parse_nextword (word);
   *X = strtod (word, &ptr);
 …
   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]);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/markrock/src/gcatstats.c

r27435	r37067
40	40	catstats[0].coords.pc1_1 = catstats[0].coords.pc2_2 = 1.0;
41	41	catstats[0].coords.pc1_2 = catstats[0].coords.pc2_1 = 0.0;
42		strcpy (catstats[0].coords.ctype, "~~RA-~~--TAN");
	42	strcpy (catstats[0].coords.ctype, "DEC--TAN");
43	43
44	44	X1 = catstats[0].X;

branches/eam_branches/ipp-ops-20130712/Ohana/src/markstar/src/gcatstats.c

r27435	r37067
50	50	catstats[0].coords.pc1_1 = catstats[0].coords.pc2_2 = 1.0;
51	51	catstats[0].coords.pc1_2 = catstats[0].coords.pc2_1 = 0.0;
52		strcpy (catstats[0].coords.ctype, "~~RA-~~--TAN");
	52	strcpy (catstats[0].coords.ctype, "DEC--TAN");
53	53
54	54	X1 = catstats[0].X;

branches/eam_branches/ipp-ops-20130712/Ohana/src/mosastro/src/warptest.c

r3323	r37067
15	15
16	16	/* bore site center guess */
17		sprintf (coords.ctype, "~~RA-~~--%s", argv[1]);
	17	sprintf (coords.ctype, "DEC--%s", argv[1]);
18	18	coords.crval1 = 0.0;
19	19	coords.crval2 = 0.0;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi

Property svn:mergeinfo deleted

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro

Property svn:mergeinfo deleted

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/Makefile

-              r35416
+              r37067
 $(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           \
 …
 $(SRC)/scale.$(ARCH).o             \
 $(SRC)/sexigesimal.$(ARCH).o       \
+$(SRC)/sersic.$(ARCH).o    \
 $(SRC)/spec.$(ARCH).o              \
 $(SRC)/specpairfit.$(ARCH).o       \

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/fitplx.c

-              r35416
+              r37067
     remove_argument (N, &argc, argv);
     VERBOSE = TRUE;
+  }
+  if ((N = get_argument (argc, argv, "-vv"))) {
+    remove_argument (N, &argc, argv);
+    VERBOSE = 2;
+  }
 …
   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;
 …
   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);
 …
   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;
 …
   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];
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/gauss.c

-              r34088
+              r37067
   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;
 …
     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);
 …
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/init.c

-              r35757
+              r37067
 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 **));
 …
 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 **));
 …
   {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"},
 …
   {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"},

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/region.c

-              r31160
+              r37067
   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");
+  }

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.astro/star.c

-              r34088
+              r37067
   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;
 …
+  }
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/Makefile

r35237	r37067
55	55	$(SRC)/substr.$(ARCH).o \
56	56	$(SRC)/strhash.$(ARCH).o \
	57	$(SRC)/strmatch.$(ARCH).o \
57	58	$(SRC)/strpop.$(ARCH).o \
58	59	$(SRC)/strsub.$(ARCH).o \

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/init.c

-              r35237
+              r37067
 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 **));
 …
   {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 *"}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.basic/list.c

-              r33662
+              r37067
+  }
+  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);
 …
     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]);
+    }
 …
         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);
 …
       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);
+    }
 …
     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]);
+    }
 …
     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;
 …
         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);
 …
       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;
 …
     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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data

Property svn:mergeinfo deleted

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/Makefile

-              r35416
+              r37067
 $(SRC)/book.$(ARCH).o           \
 $(SRC)/book_commands.$(ARCH).o  \
+$(SRC)/cast.$(ARCH).o           \
 $(SRC)/center.$(ARCH).o \
 $(SRC)/clear.$(ARCH).o          \
 …
 $(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           \
 …
 $(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           \
 …
 $(SRC)/point.$(ARCH).o          \
 $(SRC)/ps.$(ARCH).o             \
+$(SRC)/print_vectors.$(ARCH).o  \
 $(SRC)/queuedelete.$(ARCH).o    \
 $(SRC)/queuedrop.$(ARCH).o      \
 …
 $(SRC)/vmaxwell.$(ARCH).o          \
 $(SRC)/vgrid.$(ARCH).o             \
+$(SRC)/vlist.$(ARCH).o             \
 $(SRC)/vload.$(ARCH).o             \
 $(SRC)/vzload.$(ARCH).o            \

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/densify.c

-              r34088
+              r37067
 # 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;
 …
+  }
+  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);
+  }
 …
   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;
 …
   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;
 …
     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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/init.c

-              r35416
+              r37067
 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 **));
 …
 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 **));
 …
 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 **));
 …
 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 **));
 …
 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 **));
 …
   {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"},
 …
   {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"},
 …
   {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"},
 …
   {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"},
 …
   {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"},

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/match2d.c

-              r33963
+              r37067
   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"))) {
 …
   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);
+  }
 …
   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;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/read_vectors.c

-              r34753
+              r37067
 FILE *f = (FILE *) NULL;
 char filename[2048];
+void read_vectors_cleanup ();
 int datafile (int argc, char **argv) {
 …
 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 */
 …
   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++) {
 …
+    }
+    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);
+      }
+    }
 …
     bad_colname:
       gprint (GP_ERR, "USAGE: read name N name N ...\n");
+      free (vec);
+      free (col);
+      read_vectors_cleanup();
       return (FALSE);
+    }
 …
   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;
+    }
+  }
 …
     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;
+    }
 …
       for (i = 0; i < Nvec; i++) {
         int ivalue;
-        char cvalue;
         double dvalue;
         time_t tvalue;
 …
             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);
 …
         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;
+          }
+        }
 …
+    }
+  }
+  // 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); \
 …
   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;
 …
   // }
   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;
 …
     // 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);
 …
     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 */
 …
       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 {
 …
         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;
+    }
 …
   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");
 …
+    }
+    // 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);
 …
   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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/rebin.c

r28241	r37067
133	133	Vout += Vin;
134	134	if (Normalize) {(*Vn) ++;}
	135	// if ((i == 1) && (j == 1)) fprintf (stderr, "%d,%d : %d,%d : %f : %f : %d\n", i, j, x, y, Vin, Vout, *Vn);
135	136	}
136	137	if (Normalize) {Vn ++;}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vellipse.c

r25757	r37067
228	228	*/
229	229
	230	// XXX NOTE that PHI is defined with the wrong sign, should fix this...
230	231	opihi_flt fellipseOD (opihi_flt alpha, opihi_flt par, int Npar, opihi_flt dpar) {
231	232

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/cmd.data/vgauss.c

-              r35109
+              r37067
   if ((ovec = SelectVector (argv[4], ANYVECTOR, TRUE)) == NULL) return (FALSE);
+  CastVector (xvec, OPIHI_FLT);
+  CastVector (yvec, OPIHI_FLT);
   int Nsvec = strlen(argv[3]);
 …
+  }
-  CastVector (xvec, OPIHI_FLT);
-  CastVector (yvec, OPIHI_FLT);
   CastVector (svec, OPIHI_FLT);
   // XXX Cast is failing.

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/Makefile

-              r34461
+              r37067
 $(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 = \
 …
 $(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                   \

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/avextract.c

-              r35416
+              r37067
   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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/avmatch.c

-              r35416
+              r37067
   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) {
 …
     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);
 …
   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 */

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/dvo_client.c

r35263	r37067
90	90	}
91	91
	92	// these are set in 'startup.c' for readline-based programs
	93	set_variable ("PID", getpid());
	94	set_str_variable ("KAPA", "kapa");
	95	set_int_variable ("UNSIGN", 0);
	96	gfits_set_unsign_mode (FALSE);
	97
92	98	return;
93	99	}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/find_matches.c

r29759	r37067
50	50	tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
51	51	tcoords.Npolyterms = 1;
52		strcpy (tcoords.ctype, "~~RA-~~--ARC");
	52	strcpy (tcoords.ctype, "DEC--ARC");
53	53
54	54	// this region includes a boundary layer of size RADIUS

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/fitsed.c

r34088	r37067
83	83	/* interpret command-line options */
84	84	if ((selection = SetRegionSelection (&argc, argv)) == NULL) goto escape;
85		if (!SetPhotSelections (&argc, argv, 4)) goto usage;
	85	// if (!SetPhotSelections (&argc, argv, 4)) goto usage;
86	86
87	87	PLOT = FALSE;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/gimages.c

r34844	r37067
136	136	local.pc2_1 = local.pc1_2 = 0.0;
137	137	local.Npolyterms = 1;
138		strcpy (local.ctype, "~~RA-~~--TAN");
	138	strcpy (local.ctype, "DEC--TAN");
139	139
140	140	if (typehash == DistortImage) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/gstar.c

-              r35109
+              r37067
   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,
 …
           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");
 …
           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) {
 …
             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);
 …
             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) {
 …
     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;
 …
       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;
 …
         print_double (NAN);
       } else {
         print_double_exp (secfilt[seq].FluxPSF);
+        print_double_exp (secfilt[seq].FpsfStk);
+      }
       break;
 …
         print_double (NAN);
       } else {
         print_double_exp (secfilt[seq].dFluxPSF);
+        print_double_exp (secfilt[seq].dFpsfStk);
+      }
       break;
 …
         print_double (NAN);
       } else {
         print_double_exp (secfilt[seq].FluxKron);
+        print_double_exp (secfilt[seq].FkronStk);
+      }
       break;
 …
         print_double (NAN);
       } else {
         print_double_exp (secfilt[seq].dFluxKron);
+      }
       break;
+  }
+}
+        print_double_exp (secfilt[seq].dFkronStk);
+      }
+      break;
+  }
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/hosts.c

-              r35757
+              r37067
 # 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
 …
     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;
 …
+    }
+    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"))) {
 …
       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;
 …
       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;
+      }
 …
         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);
 …
         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);
 …
       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]);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/imdata.c

-              r34088
+              r37067
 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;
 …
         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);
 …
         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);
 …
         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++;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/imextract.c

r34088	r37067
185	185	gprint (GP_ERR, " Mcal : photometry calibration (mags)\n");
186	186	gprint (GP_ERR, " dMcal : photometry calibration error (mags)\n");
187		gprint (GP_ERR, " Xm : chisq of photometry calibration\n");
	187	gprint (GP_ERR, " Mchisq : chisq of photometry calibration\n");
188	188	gprint (GP_ERR, " photcode : numeric photcode value for image\n");
189	189	gprint (GP_ERR, " exptime : exposure duration (seconds)\n");

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/init.c

-              r34461
+              r37067
 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 **));
 …
   {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"},

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/lcurve.c

r34584	r37067
129	129	if (ErrorBars) dYvec.elements.Flt[N] = catalog.measure[m].dM;
130	130	Xvec.elements.Flt[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
131		Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m]);
	131	Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m], MAG_CLASS_PSF);
132	132	/** need to use PhotRel optionally here **/
133	133	N++;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/lightcurve.c

-              r27435
+              r37067
         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++;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/photometry.c

-              r35416
+              r37067
+  }
+# if (0)
 /* selection criteria */
 /* selections based on Measure quantities */
 …
 static time_t TimeReference;
 static int TimeFormat;
+# endif
+# if (0)
 int GetTimeSelection (time_t *tz, time_t *te) {
   *tz = tzero;
 …
   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 () {
 …
       break;
     case AVE_dMAG:
       value = PhotdM (code, average, secfilt);
+      value = PhotAveErr (code, average, secfilt);
       break;
     case AVE_Xm:
 …
   /* for ErrSelect, check average errors */
   if (ErrSelect) {
     dM = PhotdM (code, average, secfilt);
+    dM = PhotAveErr (code, average, secfilt);
     if (dM > ErrValue) return (FALSE);
+  }
 …
   return (list);
+}
+# endif
+# if (0)
 double GetMeasure (int param, Average *average, Measure *measure, double mag) {
 …
       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 */
 …
       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 */
 …
       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;
 …
       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;
 …
 # 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;
 …
       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;
 …
   return (value);
+}
+# endif
 /** the mosaic entries do not use the registered mosaic found

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/pmeasure.c

-              r34088
+              r37067
         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);
+        }

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/showtile.c

r34584	r37067
34	34	coords.pc1_2 = coords.pc2_1 = 0.0;
35	35	coords.Npolyterms = 0;
36		strcpy (coords.ctype, "~~RA-~~--TAN");
	36	strcpy (coords.ctype, "DEC--TAN");
37	37
38	38	/* fill in top-left region */

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/simage.c

-              r34584
+              r37067
   /* 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/dvo/subpix.c

r31635	r37067
138	138	for (j = 0; j < Nmeasure; j++) {
139	139	if (measure[j].t == Timage) {
140		Mabs = PhotCat (&measure[j]);
	140	Mabs = PhotCat (&measure[j], MAG_CLASS_PSF);
141	141	RD_to_XY (&X, &Y, Ra, Dec, &image[I].coords);
142	142	t = TimeValue (measure[j].t, TimeReference, TimeFormat);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/data.h

-              r34584
+              r37067
   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);
 …
 /* 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);
 …
 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 */
 …
 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/dvomath.h

-              r33662
+              r37067
 } 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;
 …
 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));
 …
 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));

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/dvoshell.h

-              r35416
+              r37067
 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));

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/pantasks.h

-              r32632
+              r37067
   int active;
   int priority;
+  int nicelevel;
 } Task;
 …
   JobMode     mode;                     /* local or controller? */
   int     priority;
+  int     nicelevel;
   char   *realhost;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/pcontrol.h

-              r33662
+              r37067
 /** job status values **/
 typedef enum {
+  PCONTROL_JOB_NONE, // XXX OK?
   PCONTROL_JOB_ALLJOBS,
   PCONTROL_JOB_PENDING,
 …
   int          exit_status;
   int          Reset;
   int          priority;
+  int          nicelevel;
   JobMode      mode;
   JobStat      state;
 …
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/include/shell.h

r33662	r37067
166	166	// wrap readline in ohana mem functions:
167	167	char opihi_readline PROTO((char prompt));
	168
	169	int set_list_varname (char line, char base, int N, int excelStyle);
168	170
169	171	/* gprint functions */

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/Makefile

r34584	r37067
24	24	$(SDIR)/spline.$(ARCH).o \
25	25	$(SDIR)/SplineOps.$(ARCH).o \
	26	$(SDIR)/MedImageOps.$(ARCH).o \
26	27	$(SDIR)/mrqmin.$(ARCH).o \
27	28	$(SDIR)/mrq2dmin.$(ARCH).o \

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.data/starfuncs.c

-              r34088
+              r37067
 # 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;
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/ListOps.c

-              r33963
+              r37067
 // 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 */

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/VectorIO.c

-              r35109
+              r37067
   FTable ftable;
   int i, j, k;
+  int i, j;
   FILE *f = NULL;
 …
     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);
 …
 //  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;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/check_stack.c

-              r34260
+              r37067
   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
 …
       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;
+      }
 …
       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];
 …
       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;
 …
       /* this is not a scalar, vector, or matrix.  must be string */
       stack[i].type  = 'W';
+      stack[i].type  = ST_STRING;
+    }
+  }

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/convert_to_RPN.c

-              r34088
+              r37067
 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;
 …
     /* 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--) {
 …
         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--) {
 …
         Nop_stack ++;
         break;
       case 2:
+      case ST_LEFT:
         /* push operator on OP stack */
         assign_stack (&op_stack[Nop_stack], argv[i], type);
 …
         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;
 …
         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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/dvomath.c

r31635	r37067
80	80	sprintf (outname, "%s", stack[0].name);
81	81	} else {
82		if (stack[0].type == ~~'s'~~) {
	82	if (stack[0].type == ST_SCALAR_INT) {
83	83	sprintf (outname, "%d", stack[0].IntValue);
84	84	} else {

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/evaluate_stack.c

-              r34088
+              r37067
 # 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) {
 …
   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], "=");
 …
       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], "=");
 …
+    }
+    /***** 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);
 …
   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);
 …
       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);
 …
+}
 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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/macro_list.c

r7917	r37067
11	11	}
12	12
13		macro = MatchMacro (argv[0], FALSE, TRUE);
	13	macro = MatchMacro (argv[1], FALSE, TRUE);
14	14	if (macro == NULL) {
15	15	gprint (GP_ERR, "%s: Macro not found\n", argv[1]);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/stack_math.c

-              r34342
+              r37067
 */
+// 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;
 …
     return (FALSE);
+  }
+  if (V1[0].vector[0].Nelements != V3[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 = '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
 …
       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;                   \
 …
   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);
 …
   /** 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);
 …
   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;                                 \
 …
       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;                                 \
 …
       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;                                 \
 …
       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;                                 \
 …
       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;                                 \
 …
   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);
 …
   /** 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);
 …
   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;                   \
 …
       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;                   \
 …
       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;                   \
 …
       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;                   \
 …
       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;                   \
 …
   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);
 …
   /** 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 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? */
 …
     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;
 …
     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));
 …
     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);
 …
   /** 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);
 …
   /* 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;
 …
     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));
 …
     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);
 …
   /** 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);
 …
   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 ();
 …
+    }
+  }
   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;
 …
     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));
 …
     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);
 …
   /** 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);
 …
   /* 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;
 …
 # 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++) {        \
 …
       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++) {        \
 …
     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));
 …
     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);
 …
 # 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);
 …
   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;
 …
 # 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++) {        \
 …
       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++) {        \
 …
     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));
 …
     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);
 …
 # 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);
 …
 # 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;                                                            \
 …
   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);
 …
   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);
 …
      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;
 …
     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);
 …
 escape:
   OUT[0].FltValue = value;
   OUT[0].type = 'S';
+  OUT[0].type = ST_SCALAR_FLT;
   clear_stack (V1);
 …
 # 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);                         \
 …
+  }
+  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);
 …
   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) {                                     \
 …
       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;            \
 …
       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;            \
 …
     } }
+  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 */
 …
 escape:
   if (V1[0].type == 'v') {
+  if (V1[0].type == ST_VECTOR_TMP) {
     free (V1[0].vector[0].elements.Ptr);
     free (V1[0].vector);
 …
   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;
 …
   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);     }}
 …
+  }
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/lib.shell/string.c

-              r33662
+              r37067
+}
+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;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/CheckController.c

-              r23530
+              r37067
   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');
 …
   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');

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/ControllerOps.c

r34088	r37067
259	259	}
260	260
261		if (job[0].~~priority~~) {
	261	if (job[0].nicelevel) {
262	262	char tmp[64];
263		snprintf (tmp, 64, " -nice %d", job[0].~~priority~~);
	263	snprintf (tmp, 64, " -nice %d", job[0].nicelevel);
264	264	strcat (cmd, tmp);
265	265	}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/JobOps.c

r32632	r37067
107	107	job[0].mode = JOB_CONTROLLER;
108	108	}
109		job[0].~~priority = task[0].priority~~;
	109	job[0].nicelevel = task[0].nicelevel;
110	110
111	111	/* we need our own copy of task[0].argv argc is the number of valid args, like the usual command line. we

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/LocalJob.c

-              r32632
+              r37067
   /* 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/TaskOps.c

r32632	r37067
487	487
488	488	NewTask[0].active = TRUE;
489		NewTask[0].~~priority~~ = 0;
	489	NewTask[0].nicelevel = 0;
490	490	return (NewTask);
491	491	}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/init.c

r32632	r37067
34	34	{1, "halt", halt, "halt the scheduler (no job harvesting)"},
35	35	{1, "host", task_host, "define host machine for a task"},
36		{1, "nice", task_nice, "set nice ~~priority~~ level for a task"},
	36	{1, "nice", task_nice, "set nice level for a task"},
37	37	{1, "ipptool2book", ipptool2book, "convert queue with ipptool output to book"},
38	38	{1, "kill", kill_job, "kill job"},

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/init_server.c

r32632	r37067
35	35	{1, "delete", delete_job, "delete job"},
36	36	{1, "host", task_host, "define host machine for a task"},
37		{1, "nice", task_nice, "set nice ~~priority~~ level for a task"},
	37	{1, "nice", task_nice, "set nice level for a task"},
38	38	{1, "ipptool2book", ipptool2book, "convert queue with ipptool output to book"},
39	39	{1, "kill", kill_job, "kill job"},

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pantasks/task_nice.c

-              r32632
+              r37067
   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);
+  }
 …
+  }
   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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pclient/job.c

-              r32632
+              r37067
 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);
+  }
 …
   /* 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/CheckBusyJob.c

-              r28242
+              r37067
   // 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/JobOps.c

-              r32632
+              r37067
+}
+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) {
 …
+}
 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;
 …
   job[0].mode     = mode;
   job[0].priority = priority;
+  job[0].nicelevel = nicelevel;
   job[0].state = 0;

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/StartJob.c

-              r32632
+              r37067
   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);
+  }

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/job.c

-              r32632
+              r37067
   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;
 …
+  }
   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);
+  }
 …
   // 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);
 …
  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");

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/jobstack.c

r12470	r37067
22	22	/* print list */
23	23	LockStack (stack);
24		gprint (GP_LOG, "Njobs: %d\n", stack[0].Nobject);
	24	gprint (GP_LOG, "BEGIN BLOCK Njobs: %d\n", stack[0].Nobject);
25	25	for (i = 0; i < stack[0].Nobject; i++) {
26	26	job = stack[0].object[i];

branches/eam_branches/ipp-ops-20130712/Ohana/src/opihi/pcontrol/status.c

-              r32632
+              r37067
 # 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;
 …
     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) {
 …
         gettimeofday (&now, (void *) NULL);
         dtime = DTIME (now, job[0].start);
-        gprint (GP_LOG, "%8.2f ", dtime);
         break;
 …
       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]);

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/Makefile

-              r33655
+              r37067
 $(SRC)/args.$(ARCH).o              \
 $(SRC)/copy_images.$(ARCH).o       \
+$(SRC)/select_images.$(ARCH).o     \
 $(SRC)/Shutdown.$(ARCH).o          \
 $(SRC)/join_stars.$(ARCH).o        \
 …
 $(SRC)/ConfigInit.$(ARCH).o        \
 $(SRC)/args.$(ARCH).o              \
-$(SRC)/copy_images.$(ARCH).o       \
 $(SRC)/Shutdown.$(ARCH).o          \
 $(SRC)/join_stars.$(ARCH).o        \

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/include/photdbc.h

-              r33963
+              r37067
   int    Nmeas;
 } StatType;
+typedef struct {
+  double Xc[5];
+  double Yc[5];
+  double Rc;
+  double Dc;
+} SkyRegionCoords;
 int    PARALLEL;
 …
 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
 …
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/args.c

-              r33655
+              r37067
+  }
+  // measurements with these photcodes are not copied to the output
   PHOTCODE_DROP_LIST = NULL;
   if ((N = get_argument (argc, argv, "-photcode-drop"))) {
 …
+  }
+  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);
+  }
 …
+  }
   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);
+  }
 …
   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");

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/copy_images.c

-              r33655
+              r37067
 # 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;
 …
       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

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/find_images.c

r30616	r37067
25	25	tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
26	26	tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
27		strcpy (tcoords.ctype, "~~RA-~~--TAN");
	27	strcpy (tcoords.ctype, "DEC--TAN");
28	28
29	29	timage = gfits_table_get_Image (&db[0].ftable, &Ntimage, &db[0].swapped);

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/get_mags.c

r15509	r37067
22	22	catalog[0].secfilt[i*Nsecfilt+j].M = NAN;
23	23	catalog[0].secfilt[i*Nsecfilt+j].dM = NAN;
24		catalog[0].secfilt[i*Nsecfilt+j].~~Xm = NAN_S_SHORT~~;
	24	catalog[0].secfilt[i*Nsecfilt+j].Mchisq = NAN;
25	25	}
26	26	}
…	…
56	56	Mval = (Nsec == -1) ? &catalog[0].average[i].dM : &catalog[0].secfilt[i*Nsecfilt+Nsec].dM;
57	57	*Mval = stats.sigma;
58		Mval = (Nsec == -1) ? &catalog[0].average[i].~~Xm : &catalog[0].secfilt[i*Nsecfilt+Nsec].Xm~~;
59		Mval = ~~100.0log10(stats.chisq)~~;
	58	Mval = (Nsec == -1) ? &catalog[0].average[i].Mchisq : &catalog[0].secfilt[i*Nsecfilt+Nsec].Mchisq;
	59	*Mval = stats.chisq;
60	60	}
61	61	}

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/initialize.c

-              r33655
+              r37067
   photcodesDrop = ParsePhotcodeList (PHOTCODE_DROP_LIST, &NphotcodesDrop, FALSE);
   photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE);
+  photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE);
   if (SHOW_PARAMS) {
 …
   photcodesDrop = ParsePhotcodeList (PHOTCODE_DROP_LIST, &NphotcodesDrop, FALSE);
   photcodesSkip = ParsePhotcodeList (PHOTCODE_SKIP_LIST, &NphotcodesSkip, FALSE);
+  photcodesKeep = ParsePhotcodeList (PHOTCODE_KEEP_LIST, &NphotcodesKeep, FALSE);
   if (SHOW_PARAMS) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/join_stars.c

-              r29938
+              r37067
 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;
 …
   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 */
 …
         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 ++;
+      }
 …
           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;
 …
         /* 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 */
 …
 # 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
+      }

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/make_subcatalog.c

-              r31635
+              r37067
   off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nm, Nsecfilt;
   double mag, minMag, minSigma;
   int keep, *secSkip;
+  int keep, *secKeep;
   PhotCode *photcode;
 …
   // 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;
+      }
+  }
 …
       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;
 …
       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;
 …
       // 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;
 …
       // 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;
 …
       // 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);
+      }

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/photdbc.c

-              r33655
+              r37067
   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, &REGION);
+  // load and copy the image table
+  copy_images (argv[1], skylist);
   // hostID is 0 for master program

branches/eam_branches/ipp-ops-20130712/Ohana/src/photdbc/src/photdbc_catalogs.c

r33963	r37067
120	120	if (ExcludeByMaxMinMag) { snprintf (tmpline, DVO_MAX_PATH, "%s -maxminmag %f", command, MAX_MIN_MAG); strcpy (command, tmpline); }
121	121	if (PHOTCODE_DROP_LIST) { snprintf (tmpline, DVO_MAX_PATH, "%s -photcode-drop %s", command, PHOTCODE_DROP_LIST); strcpy (command, tmpline); }
122		if (PHOTCODE_~~SKIP_LIST) { snprintf (tmpline, DVO_MAX_PATH, "%s -photcode-skip %s", command, PHOTCODE_SKI~~P_LIST); strcpy (command, tmpline); }
	122	if (PHOTCODE_KEEP_LIST) { snprintf (tmpline, DVO_MAX_PATH, "%s -photcode-keep %s", command, PHOTCODE_KEEP_LIST); strcpy (command, tmpline); }
123	123	if (CATFORMAT) { snprintf (tmpline, DVO_MAX_PATH, "%s -set-format %s", command, CATFORMAT); strcpy (command, tmpline); }
124	124	if (CATMODE) { snprintf (tmpline, DVO_MAX_PATH, "%s -set-mode %s", command, CATMODE); strcpy (command, tmpline); }

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/Makefile

-              r35416
+              r37067
 $(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
 …
 $(SRC)/plotstuff.$(ARCH).o           \
 $(SRC)/relastroVisual.$(ARCH).o \
+$(SRC)/syncfile.$(ARCH).o \
 $(SRC)/BrightCatalog.$(ARCH).o

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/include/relastro.h

-              r35763
+              r37067
 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 {
 …
   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 {
 …
   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;
 …
   unsigned int start;
   unsigned int stop;
+  off_t myImage;
   float Mcal;
   float dMcal;
 …
 } 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
 …
 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;
 …
 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;
 …
 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;
 …
 int USE_BASIC_CHECK;
+int ExcludeBogus;
+double ExcludeBogusRadius;
 FitMode FIT_MODE;
+RelastroOp RELASTRO_OP;
 FitTarget FIT_TARGET;
 …
 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));
 …
 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);
 …
 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 ();

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src

Property svn:mergeinfo deleted

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/BrightCatalog.c

-              r35105
+              r37067
     // 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);
 …
     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];
 …
     // fprintf (stderr, "loaded data for %lld measures\n", (long long) Nrow);
     free (dR      );
     free (dD      );
+    free (R       );
+    free (D       );
     free (M       );
     free (Mcal    );
 …
     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);
 …
       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]  ;
 …
     free (measureOffset);
     free (missingOffset);
+    free (extendOffset);
+    free (refColorBlue);
+    free (refColorRed);
     free (flags);
     free (photFlagsUpper);
 …
     // 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);
 …
     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);
 …
     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?
 …
     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
 …
     // 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     ;
 …
     // 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);
 …
     gfits_set_bintable_column (&theader, &ftable, "PHOTCODE",   photcode,  catalog->Nmeasure);
     free (dR      );
     free (dD      );
+    free (R       );
+    free (D       );
     free (M       );
     free (Mcal    );
 …
     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
 …
     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);
 …
       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  ;
 …
     // 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);
 …
     free (measureOffset);
     free (missingOffset);
+    free (extendOffset);
+    free (refColorBlue);
+    free (refColorRed);
     free (flags);
     free (photFlagsUpper);
 …
     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
 …
     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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ConfigInit.c

-              r35105
+              r37067
   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;
 …
   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)
 …
   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");

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/FitChip.c

-              r33652
+              r37067
 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;
 …
     // measure the scatter distribution (use only the bright end detections)
+    Nkeep = 0;
     for (i = 0; i < Nmatch; i++) {
       if (raw[i].mask) continue;
 …
         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:
 …
     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);
 …
       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
 …
+  }
+  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);
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/GetAstromError.c

-              r33652
+              r37067
   code  = GetPhotcodebyCode (measure[0].photcode);
+  if (!code) return NAN;
   // do not raise an exception, just send back the result
 …
   code  = GetPhotcodebyCode (measure[0].photcode);
+  if (!code) return NAN;
   // do not raise an exception, just send back the result

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/ImageOps.c

-              r35763
+              r37067
 // 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) {
 …
     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");
 …
 */
+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 () {
 …
   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;
 …
     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;
 …
     // 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:
 …
   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);
 …
   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;
 …
     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)
 …
       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;
+    }
+  }
 …
     /* 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;
 …
       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;
+    }
 …
   StarData *ref;
+  int Nsecfilt = GetPhotcodeNsecfilt();
   mosaic = NULL;
   moscoords = NULL;
 …
     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;
 …
       // 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);
 …
     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;
 …
       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)) +
 …
   double *R, *D, *dR, *dD, *d2;
   StatType statsR, statsD;
+  // XXX we are not going to use this for now
+  return;
   Nsecfilt = GetPhotcodeNsecfilt();
 …
       // 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);
 …
       // 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)) +
 …
     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);
 …
       //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)) +
 …
   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?
 …
     } else {
       code = GetPhotcodebyCode (measure[0].photcode);
+      if (!code) return FALSE;
       mask = code[0].astromBadMask;
+    }
 …
   /* select measurements by mag limit */
   if (ImagSelect) {
     mag = PhotInstTiny (measure);
+    mag = PhotInstTiny (measure, MAG_CLASS_PSF);
     if (mag < ImagMin || mag > ImagMax) return FALSE;
+  }
 …
   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?
 …
     } else {
       code = GetPhotcodebyCode (measure[0].photcode);
+      if (!code) return FALSE;
       mask = code[0].astromBadMask;
+    }
 …
   /* select measurements by mag limit */
   if (ImagSelect) {
     mag = PhotInst (measure);
+    mag = PhotInst (measure, MAG_CLASS_PSF);
     if (mag < ImagMin || mag > ImagMax) return FALSE;
+  }

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/MosaicOps.c

-              r27581
+              r37067
 // 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
 …
     /* 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
 …
   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++) {
 …
     if (strcmp(&image[i].coords.ctype[4], "-WRP")) continue;
+    NtestMosaic ++;
     /* set image time range */
 …
     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;
+    }
 …
+  }
+  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);
 …
   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;
 …
   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 = &regionHosts->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;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/Shutdown.c

r12332	r37067
23	23	SetProtect (TRUE);
24	24	gfits_db_close (db);
25		fprintf (stderr, "ERROR: ~~addstar~~ halted\n");
	25	fprintf (stderr, "ERROR: relastro halted\n");
26	26	exit (1);
27	27	}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/StarMaps.c

-              r35105
+              r37067
   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

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/UpdateObjectOffsets.c

-              r35763
+              r37067
               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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/UpdateObjects.c

-              r35763
+              r37067
 # include "relastro.h"
 static off_t   Nmax;
+static off_t Nmax;
 static double *X, *dX;
 static double *Y, *dY;
 …
 static double *T;
 static double *dT;
+static double *C_blue;
+static double *C_red;
 void initObjectData (Catalog *catalog, int Ncatalog) {
 …
   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);
+}
 …
   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;
 …
   memset (&fitPAR, 0, sizeof(fitPAR));
   initObjectData (catalog, Ncatalog);
+  int setRefColor = areImagesMatched();
   /* project coordinates to a plane centered on the object with units of arcsec */
 …
   coords.pc1_2  = coords.pc2_1 = 0.0;
   coords.Npolyterms = 1;
   strcpy (coords.ctype, "RA---SIN");
+  strcpy (coords.ctype, "DEC--SIN");
   XVERB = FALSE;
 …
       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;
 …
           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]);
 …
         // 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
 …
         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
 …
       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 {
 …
       // 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;
+      }
 …
         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;
 …
           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
 …
         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;
+      }
 …
       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,
 …
+  }
+  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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/args.c

-              r35763
+              r37067
   /* possible operations */
   FIT_TARGET = TARGET_NONE;
+  RELASTRO_OP = OP_NONE;
   FIT_MODE = FIT_AVERAGE;
 …
     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);
 …
   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;
+    }
+  }
 …
     // 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]);
 …
   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]);
 …
     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);
 …
   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]);
 …
+  }
+  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? */
 …
+  }
+  // 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"))) {
 …
+  }
+  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);
+  }
 …
   /* possible operations */
   FIT_TARGET = TARGET_NONE;
+  RELASTRO_OP = TARGET_NONE;
   FIT_MODE = FIT_AVERAGE;
 …
   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"))) {
 …
     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;
+  }
 …
     // 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]);
 …
   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]);
 …
   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]);
 …
+  }
+  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? */
 …
+  }
+  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"))) {
 …
 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");
 …
   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;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/bcatalog.c

-              r34429
+              r37067
 # 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) {
 …
   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?
 …
     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++) {
 …
       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)) {
 …
       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
 …
       // 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]);
 …
   // limit the total number of stars in the catalog
   if (MaxDensityUse) {
     LimitDensityCatalog_ByNmeasure (subcatalog, catalog);
+    LimitDensityCatalog_ByNmeasureGrid (subcatalog, catalog);
   } else {
     if (VERBOSE2) {
 …
+    }
+  }
+  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);
+  }
+}
 …
 # 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);
+}
 …
     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

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/dvo_astrom_ops.c

-              r33652
+              r37067
 # include "relastro.h"
+/* the Measure carries the instantaneous mean position at the epoch t */
 double getMeanR (MeasureTiny *measure, Average *average, SecFilt *secfilt) {
 …
   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:
 …
   */
-  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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/high_speed_objects.c

-              r35494
+              r37067
   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 */
 …
           for(i1=0;i1<catalog[0].average[nv[l]].Nmeasure;i1++) {
               catalogOut.measure[Nmatchmeas]=catalog[0].measure[m+i1];
               /*Set offset RA and Dec wrt correct average value*/
               catalogOut.measure[Nmatchmeas].dR=catalog[0].measure[m+i1].dR+3600.0*(catalog[0].average[nv[0]].R-catalog[0].average[nv[l]].R);
               catalogOut.measure[Nmatchmeas].dD=catalog[0].measure[m+i1].dD+3600.0*(catalog[0].average[nv[0]].D-catalog[0].average[nv[l]].D);
+              // DROP no longer necessary to repoint R,D
+              // catalogOut.measure[Nmatchmeas].dR=catalog[0].measure[m+i1].dR+3600.0*(catalog[0].average[nv[0]].R-catalog[0].average[nv[l]].R);
+              // catalogOut.measure[Nmatchmeas].dD=catalog[0].measure[m+i1].dD+3600.0*(catalog[0].average[nv[0]].D-catalog[0].average[nv[l]].D);
               catalogOut.measure[Nmatchmeas].averef = Nmatch;
               Nmatchmeasobj++;
 …
   // XXX require a set or not?  assert (Nset > 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/hpm_objects.c

-              r35494
+              r37067
   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 */
 …
       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++;

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/initialize.c

-              r34429
+              r37067
   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);
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/load_catalogs.c

-              r35105
+              r37067
 # 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;
+  }
 …
       if (RESET) {
         for (j = 0; j < catalog[Ncat].Naverage; j++) {
+# if (0)
           catalog[Ncat].average[j].flags = 0;
           m = catalog[Ncat].average[j].measureOffset;
 …
             catalog[Ncat].measure[m+k].dbFlags = 0;
+          }
+# endif
+        }
+      }
 …
+  }
   // XXX TEST : bcatalog_show_skips();
+  bcatalog_show_skips();
   Nstar = 0;
 …
+  }
+  // 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);
 …
 // 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
 …
     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:
 …
               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
 …
       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);
+    }
 …
+  }
+  // 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/load_images.c

-              r35763
+              r37067
 # 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) {
 …
   off_t      Nimage, Nsubset;
   off_t     *LineNumber;
-  struct timeval start, stop;
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   // convert database table to internal structure
 …
   /* 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro.c

-              r35763
+              r37067
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastroVisual.c

-              r31635
+              r37067
   // 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);
 …
     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++;

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_client.c

-              r35763
+              r37067
   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);
 …
+    }
     case TARGET_HIGH_SPEED: {
+    case OP_HIGH_SPEED: {
       // USAGE: relastro_client -high-speed
       high_speed_catalogs (sky, skylist, HOST_ID, HOSTDIR);
 …
+    }
     case TARGET_HPM: {
+    case OP_HPM: {
       // USAGE: relastro_client -high-speed
       hpm_catalogs (sky, skylist, HOST_ID, HOSTDIR);
 …
+    }
       // 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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_images.c

-              r35763
+              r37067
   Catalog *catalog;
   FITS_DB db;
-  struct timeval start, stop;
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   /* register database handle with shutdown procedure */
 …
   // 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) {
 …
   // set test points based on the starmap
   createStarMap (catalog, Ncatalog);
+  // XXX NOTE : for 2mass reset, photcodesKeep should now limit to 2MASS measurements
   /* major modes */

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_merge_source.c

-              r34088
+              r37067
       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);
+    }

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/relastro_objects.c

-              r35763
+              r37067
     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
 …
     // PM_TOOFEW
     // SRC_MEAS_TOOFEW
-    // FIT_TARGET
     char command[1024];

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/resort_catalog.c

-              r34088
+              r37067
   if (catalog[0].sorted == TRUE) return;
+  // struct timeval start, stop;
+  // gettimeofday (&start, NULL);
+  // INITTIME;
   /* internal counters */

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/select_images.c

-              r35763
+              r37067
 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) {
 …
   Coords tcoords;
   SkyRegionCoords *skycoords;
-  struct timeval start, stop;
   double RmaxSkyRegion, RminSkyRegion, RmidSkyRegion, DminSkyRegion, DmaxSkyRegion;
 …
+  }
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   // the comparison is made in the catalog local projection. below we set crval1,2
 …
   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);
 …
     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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/relastro/src/testparallax.c

r34088	r37067
57	57	coords.pc1_2 = coords.pc2_1 = 0.0;
58	58	coords.Npolyterms = 1;
59		strcpy (coords.ctype, "~~RA-~~--SIN");
	59	strcpy (coords.ctype, "DEC--SIN");
60	60
61	61	// use one point as a local reference

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/Makefile

-              r35416
+              r37067
 $(SRC)/args.$(ARCH).o            \
 $(SRC)/help.$(ARCH).o            \
+$(SRC)/extra.$(ARCH).o           \
 $(SRC)/bcatalog.$(ARCH).o        \
 $(SRC)/global_stats.$(ARCH).o    \
 …
 $(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   \
 …
 $(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 \

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/mosaic.txt

-              r33963
+              r37067
+.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 <image.Mcal> 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 <image.Mcal> 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/doc/parallel.txt

-              r33651
+              r37067
+.02.15
+Nearly done with the relphot mods.  some outstanding questions;
+ * image vs mosaic?
+ * how do decide which images need to be shared?
+.02.14
+ more relphot notes:
+ * I load the catalogs, with a
+.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]
+.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
 .02.13

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/include/relphot.h

-              r35806
+              r37067
 # include <pthread.h>
-# 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
 …
 // # 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 {
 …
   // 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
 …
   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 {
 …
   unsigned int photom_map_id;
   unsigned int flags;
+  int tessID;
   int projID;
   int skycellID;
 …
 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;
 …
 int    PARALLEL_MANUAL;
 int    PARALLEL_SERIAL;
+int    PARALLEL_REGIONS_MANUAL;
 int    NTHREADS;
 …
 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));
 …
 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);
 …
 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));
 …
 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);
 …
 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/BoundaryTreeOps.c

-              r35759
+              r37067
 # 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);
+  }
 …
   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;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/BrightCatalog.c

-              r33651
+              r37067
     // 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);
 …
     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];
 …
       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    );
 …
     // 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);
 …
       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);
 …
     free (flags         );
     free (catID         );
+    free (objID         );
     catalog->average = average;
 …
     // 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);
 …
     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?
 …
     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);
 …
     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
 …
     // 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     ;
 …
     // 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);
 …
     gfits_set_bintable_column (&theader, &ftable, "PHOTCODE",   photcode,  catalog->Nmeasure);
     free (dR      );
     free (dD      );
+    free (R       );
+    free (D       );
     free (M       );
     free (Mcal    );
 …
     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
 …
     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
 …
       flags[i]          = average[i].flags;
       catID[i]          = average[i].catID;
+      objID[i]          = average[i].objID;
+    }
 …
     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             );
 …
     free (flags         );
     free (catID         );
+    free (objID         );
     gfits_fwrite_Theader (f, &theader);
 …
     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
 …
     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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/GridOps.c

-              r34088
+              r37067
         // 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++;
 …
       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++;
 …
       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];

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageOps.c

-              r35759
+              r37067
 // 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;
 …
   // 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);
 …
     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);
+}
 …
   // 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);
 …
     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    ;
 …
     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];
 …
   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++) {
 …
+      }
       if (!found) continue;
+      // if we match one of our images, myDet gets set to TRUE
       matchImage (catalog, j, i, doImageList);
       Nmatch ++;
 …
     return;
+  }
+  catalog[cat].measureT[meas].myDet = TRUE;
   if (USE_GRID) {
 …
 // 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;
 …
   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;
 …
   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);
 …
       if (!bad) continue;
+    }
+    if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue;
     // UBERCAL image: if this is an ubercal image, set minUbercalDist to 0:
 …
       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++;
 …
   double MaxOffset, MaxScatter, MedOffset;
   if (FREEZE_IMAGES) return;
+  // if (FREEZE_IMAGES) return;
   if (VERBOSE) fprintf (stderr, "marking poor images\n");
 …
   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;
 …
   Graphdata graphdata;
   if (FREEZE_IMAGES) return;
+  // if (FREEZE_IMAGES) return;
   ALLOCATE (xlist, double, Nimage);
 …
   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);
 …
     mindMcal = MIN (image[i].dMcal, mindMcal);
     maxdMcal = MAX (image[i].dMcal, maxdMcal);
+    Nplot ++;
+  }
 …
   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));
 …
   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);
 …
   for (i = 0; i < Nimage; i++) {
     if (image[i].flags & IMAGE_BAD)  continue;
+    if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue;
     N = 0;
 …
   bzero (&stats, sizeof (StatType));
   if (FREEZE_IMAGES) return (stats);
+  // if (FREEZE_IMAGES) return (stats);
   ALLOCATE (list, double, Nimage);
 …
     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);
 …
   bzero (&stats, sizeof (StatType));
   if (FREEZE_IMAGES) return (stats);
+  // if (FREEZE_IMAGES) return (stats);
   ALLOCATE (list, double, Nimage);
 …
     if (image[i].flags & IMAGE_BAD)  continue;
+    if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue;
     list[n] = image[i].Mcal;
 …
   bzero (&stats, sizeof (StatType));
   if (FREEZE_IMAGES) return (stats);
+  // if (FREEZE_IMAGES) return (stats);
   ALLOCATE (list, double, Nimage);
 …
     if (image[i].flags & IMAGE_BAD)  continue;
+    if (FREEZE_IMAGES && isGPC1chip(image[i].photcode)) continue;
     list[n] = image[i].dMcal;

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/ImageSubset.c

-              r35759
+              r37067
   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);
 …
     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];
 …
   free (map);
   free (flags);
+  free (tessID);
   free (projID);
   free (skycellID);
 …
   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
 …
   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);
 …
     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;
 …
   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);
 …
   free (map);
   free (flags);
+  free (tessID);
   free (projID);
   free (skycellID);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/MosaicOps.c

-              r35806
+              r37067
 # 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
 …
 // 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) */
 …
     /* 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);
 …
+}
-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
 …
 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;
 …
   // 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);
 …
   // 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 ++;
 …
   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));
 …
+    }
+    /* 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 */
 …
   // 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;
 …
       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);
+  }
 …
   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, <image.Mcal> 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]);
+}
 …
+}
+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) {
 …
   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;
 …
       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;
 …
     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;
 …
+}
-// XXX : what about mosaics with skipCal == TRUE?
 void setMcalFinal () {
 …
   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
 …
   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;
 …
   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;
+  }
 …
+  }
+  // this measurement is on one of my mosaics, mark it as mine.
+  catalog[cat].measureT[meas].myDet = TRUE;
   MeasureToMosaic[cat][meas] = mosID;
 …
   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);
 …
       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;
 …
     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++;
 …
   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));
+  }
 …
     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;
 …
     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;
 …
     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;
 …
     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++;
 …
 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;
 …
   for (i = 0; i < Nmosaic; i++) {
     N = 0;
-    // Xmin = Ymin = +360.0;
-    // Xmax = Ymax = -360.0;
     for (j = 0; j < N_onMosaic[i]; j++) {
 …
       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++;
+    }

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/Shutdown.c

r33651	r37067
23	23	SetProtect (TRUE);
24	24	if (db) gfits_db_close (db);
25		fprintf (stderr, "ERROR: ~~addstar~~ halted\n");
	25	fprintf (stderr, "ERROR: relphot halted\n");
26	26	exit (1);
27	27	}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/StarOps.c

-              r35759
+              r37067
   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 ;
 …
   int i;
+  // fprintf (stderr, "this version of setMrel is invalid for now\n");
+  // exit (1);
   int Nsecfilt = GetPhotcodeNsecfilt ();
 …
   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);
 …
   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);
 …
 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;
 …
   StatType stats, apstats, kronstats;
   liststats_setmode (&stats, STATMODE);
+  liststats_setmode (&psfstats, STATMODE);
   liststats_setmode (&apstats, STATMODE);
   liststats_setmode (&kronstats, STATMODE);
 …
     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);
+    }
 …
       /* 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
 …
         // 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);
 …
       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
 …
       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)
 …
   if (primaryCell) free (primaryCell);
   return (TRUE);
+# endif
+}
 …
+}
+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;
 …
       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;
 …
       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;
 …
         /* 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) */
 …
           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);
 …
           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);
 …
   off_t j, Ntot;
   int i, n, Xm;
+  int i, n;
   double *list, *dlist;
   StatType stats;
 …
       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++;
 …
         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++;
+      }

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/args.c

-              r35806
+              r37067
 # 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 */
 …
+  }
+  /* 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;
 …
+  }
+  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;
+  }
 …
+  }
+  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;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/bcatalog.c

-              r35416
+              r37067
   Nmeasure = Naverage = 0;
+  int NmMax = 0;
+  int NmMin = catalog[0].Nmeasure;
   Ncode = Ntime = Ndophot = Nmag = Nsigma = Nimag = Nfew = Npsfqf = Ngalaxy = Nnan = Nbad = Npoor = 0;
 …
     if (RESET) {
       int Ns;
+# if (0)
       DVOSecfiltFlags secfiltBits =
         ID_SECF_STAR_FEW |
 …
         ID_SECF_USE_UBERCAL |
         ID_SECF_OBJ_EXT;
+# endif
       for (Ns = 0; Ns < Nphotcodes; Ns++) {
 …
         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;
+      }
+    }
 …
       /* 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; }
 …
       /* 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; }
 …
+      }
       myAssert (Nmeasure < NMEASURE, "realloc failure");
+    }
+    } // end of catalog.average.Nmeasure loop
     // skip object if it is likely to be a galaxy
 …
       continue;
+    }
+    NmMin = MIN (Nm, NmMin);
+    NmMax = MAX (Nm, NmMax);
     // for w-band photometry (& other cases?) convert gri photometry
 …
   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) {
 …
+  }
-  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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/client_logger.c

-              r33963
+              r37067
 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);
+  }
 …
   vfprintf (logfile, format, argp);
   va_end (argp);
+  fflush (logfile);
   return TRUE;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/help.c

-              r33651
+              r37067
 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);
 …
 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");

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/initialize.c

-              r34429
+              r37067
 # 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;
 …
   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));
 …
       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",
 …
              (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);
 …
     fprintf (stderr, "GSCFILE                %s\n",  GSCFILE);
     fprintf (stderr, "CATDIR                 %s\n",  CATDIR);
-    exit (0);
+  }
 …
   for (B = 0; A == time(NULL); B++);
   srand48(B);
+  return mode;
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/load_catalogs.c

-              r35416
+              r37067
 // 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;
 …
   // 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;
+  }
 …
   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
 …
 // 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
 …
     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:
 …
+  }
+  // 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

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/plot_scatter.c

-              r35759
+              r37067
                 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++;
+            }

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/reload_catalogs.c

-              r35806
+              r37067
   // 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) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot.c

-              r35416
+              r37067
 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);
+}

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_client.c

-              r33963
+              r37067
   // 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)
 …
     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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/relphot_images.c

-              r35806
+              r37067
   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);
 …
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/select_images.c

-              r35806
+              r37067
   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;
 …
   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 */

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setExclusions.c

-              r33651
+              r37067
         /* 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setMrelCatalog.c

-              r35759
+              r37067
 # include "relphot.h"
+# define UBERCAL_WEIGHT 100.0
 # define SKIP_THIS_MEAS(REASON) {                               \
 …
     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) {
 …
+}
+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);
 …
     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
 …
       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);
 …
+}
+// 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;
 …
     off_t meas = measureOffset;
+    N = 0;
+    int Nap = 0;
+    int Npsf = 0;
+    int Nkron = 0;
     for (k = 0; k < averageT[0].Nmeasure; k++, meas++) {
 …
       // 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);
 …
       // 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);
 …
       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) {
 …
+          }
           havePS1 = TRUE;
+        }
-        // gpc1 stack data
-        if ((measure[k].photcode >= 11000) && (measure[k].photcode <= 11400)) {
-          continue;
+        }
 …
           if (measureT[k].M < MaxMagForceSynth) {
             forceSynth = TRUE;
             forceSynthEntry = N;
+            forceSynthEntry = Npsf;
           } else {
             if (pass < 4) {
 …
+        }
+        // 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
 …
       // 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 ++;
+    }
 …
     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
 …
     // 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) {
 …
     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
 …
       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;
+      }
 …
   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;
 …
       // 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;
 …
       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);
 …
       // 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) {
 …
     // 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;
 …
+}
+# 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) {

branches/eam_branches/ipp-ops-20130712/Ohana/src/relphot/src/setMrelFinal.c

-              r35759
+              r37067
   /* 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;
+  }
 …
       /* 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;
 …
         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;

branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/Makefile

r31496	r37067
17	17	PROGRAMS = gconfig fhead ftable fields list_astro glockfile \
18	18	radec mktemp precess csystem fits_insert \
19		medianfilter mefhead ckfits roc
	19	medianfilter mefhead ckfits roc random
20	20
21	21	all tools: $(PROGRAMS)

branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/ftable.c

-              r34260
+              r37067
       } 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/tools/src/medianfilter.c

-              r20652
+              r37067
     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;
+      }
 …
       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");
+      }
+    }

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubset.c

-              r33654
+              r37067
   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
 …
   // 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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetFixImageIDs.c

r35764	r37067
1	1	# include "fiximids.h"
2		~~# define FT_BZERO_INT16 1.0*0x8000~~
3		~~# define FT_BZERO_INT32 1.0*0x80000000~~
4	2
5	3	# define GET_COLUMN(OUT,NAME,TYPE) \

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetFixStackIDs.c

r35764	r37067
1	1	# include "fixstkids.h"
2		~~# define FT_BZERO_INT16 1.0*0x8000~~
3		~~# define FT_BZERO_INT32 1.0*0x80000000~~
4	2
5	3	# define GET_COLUMN(OUT,NAME,TYPE) \

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/ImageSubsetSetPosangle.c

-              r34749
+              r37067
   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);

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/find_image_sgroups.c

r31160	r37067
22	22	coords.pc1_1 = coords.pc2_2 = 1.0;
23	23	coords.pc1_2 = coords.pc2_1 = 0.0;
24		strcpy (coords.ctype, "~~RA-~~--TAN");
	24	strcpy (coords.ctype, "DEC--TAN");
25	25
26	26	Ngroup = 0;

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/load_images_fiximids.c

r35764	r37067
1	1	# include "fiximids.h"
2		~~# define FT_BZERO_INT32 1.0*0x80000000~~
3	2
4	3	off_t Nimage = 0;

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/load_images_fixstkids.c

r35764	r37067
1	1	# include "fixstkids.h"
2		~~# define FT_BZERO_INT32 1.0*0x80000000~~
3	2
4	3	off_t Nimage = 0;

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_catalog_fiximids.c

-              r35764
+              r37067
 # 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) {
 …
     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)

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_catalog_setastrom.c

r35103	r37067
76	76	// correction may be Minst or Minst + 5.0*log(fwhm
77	77	float fwhm_maj = FromShortPixels(measure[0].FWx);
78		float Minst = PhotInst (measure);
	78	float Minst = PhotInst (measure, MAG_CLASS_PSF);
79	79	float MinstSB = Minst + 5.0*log10(fwhm_maj);
80	80

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_dvo_setphot.c

r35103	r37067
2	2	int update_dvo_setphot_parallel (SkyTable sky, Image image, off_t Nimage);
3	3
	4	// XXX convert this to use the ImageSubset to save space
4	5	int update_dvo_setphot (Image image, off_t Nimage, FlatCorrectionTable flatcorr) {
5	6

branches/eam_branches/ipp-ops-20130712/Ohana/src/uniphot/src/update_dvo_uniphot.c

r34088	r37067
61	61	coords.pc1_1 = coords.pc2_2 = 1.0;
62	62	coords.pc1_2 = coords.pc2_1 = 0.0;
63		strcpy (coords.ctype, "~~RA-~~--TAN");
	63	strcpy (coords.ctype, "DEC--TAN");
64	64
65	65	for (i = 0; i < pglob.gl_pathc; i++) {

Context Navigation

Legend: