Changeset 34429 for trunk

Timestamp:

Sep 11, 2012, 10:26:52 AM (14 years ago)

Author:

eugene

Message:

merge changes from eam_branches/ipp-20120905 (fixes some mean values and flags in DVO)

Location:

trunk

Files:

• . (modified) (1 prop)
• Ohana/src/addstar/src/ReadStarsFITS.c (modified) (7 diffs)
• Ohana/src/libdvo/include/dvo.h (modified) (2 diffs)
• Ohana/src/libdvo/src/dvo_catalog.c (modified) (1 diff)
• Ohana/src/opihi/cmd.astro (modified) (1 prop)
• Ohana/src/relastro/src/UpdateObjects.c (modified) (2 diffs)
• Ohana/src/relastro/src/bcatalog.c (modified) (1 diff)
• Ohana/src/relastro/src/initialize.c (modified) (2 diffs)
• Ohana/src/relastro/src/liststats.c (modified) (1 diff)
• Ohana/src/relastro/src/relastro_objects.c (modified) (1 diff)
• Ohana/src/relphot/src/StarOps.c (modified) (18 diffs)
• Ohana/src/relphot/src/initialize.c (modified) (1 diff)
• Ohana/src/relphot/src/liststats.c (modified) (1 diff)
• Ohana/src/relphot/src/relphot_objects.c (modified) (1 diff)
• Ohana/src/relphot/src/setMrelFinal.c (modified) (1 diff)
• ippMonitor (modified) (1 prop)
• ippScripts/scripts/destreak_restore_camera.pl (modified) (1 prop)
• ippScripts/scripts/ipp_apply_burntool_single.pl (modified) (1 prop)
• ippScripts/scripts/magic_destreak.pl (modified) (1 prop)
• ippToPsps (modified) (1 prop)
• ippTools/share/camtool_find_pendingimfile.sql (modified) (1 prop)
• ippTools/share/chiptool_setimfiletoupdate.sql (modified) (1 prop)
• ippTools/share/pxadmin_create_tables.sql (modified) (1 prop)
• ippTools/share/warptool_towarped.sql (modified) (1 prop)
• ippTools/src (modified) (1 prop)
• ippTools/src/magictool.c (modified) (1 prop)
• ippconfig (modified) (1 prop)
• ippconfig/recipes/reductionClasses.mdc (modified) (1 prop)
• ppImage/src (modified) (1 prop)
• psModules (modified) (1 prop)
• psphot (modified) (1 prop)
• psphot/src (modified) (1 prop)
• psphot/src/psphotStackImageLoop.c (modified) (1 prop)
• pstamp/scripts (modified) (1 prop)
• psvideophot (modified) (1 prop)

trunk/Ohana/src/addstar/src/ReadStarsFITS.c

@@ -606 +606 @@
     stars[i].measure.psfChisq   = ps1data[i].psfChisq;
     stars[i].measure.psfQF      = ps1data[i].psfQF;
+    stars[i].measure.psfQFperf  = ps1data[i].psfQFpef;
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
@@ -675 +676 @@
     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.FluxKron   = ps1data[i].kronFlux;
+    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
+
+    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].psfQFpef;
+    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 (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.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.FluxKron   = ps1data[i].kronFlux;
+    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
+
+    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].psfQFpef;
+    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.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;
@@ -705 +872 @@
 
     // 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
@@ -717 +881 @@
 }
 
-Stars *Convert_PS1_SV1 (FTable *table, unsigned int *nstars) {
+Stars *Convert_PS1_SV2 (FTable *table, unsigned int *nstars) {
 
   off_t Nstars; 
@@ -723 +887 @@
   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_SV2 *ps1data;
+
+  ps1data = gfits_table_get_CMF_PS1_SV2 (table, &Nstars, NULL);
   if (!ps1data) {
     fprintf (stderr, "skipping inconsistent entry\n");
@@ -771 +930 @@
     stars[i].measure.psfChisq   = ps1data[i].psfChisq;
     stars[i].measure.psfQF      = ps1data[i].psfQF;
+    stars[i].measure.psfQFperf  = ps1data[i].psfQFpef;
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
@@ -799 +959 @@
 }
 
-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.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.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-
-    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.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_SV2 (FTable *table, unsigned int *nstars) {
-
-  off_t Nstars; 
-  unsigned int i;
-  double ZeroPt;
-  Stars *stars;
-  CMF_PS1_SV2 *ps1data;
-
-  ps1data = gfits_table_get_CMF_PS1_SV2 (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.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.FluxKron   = ps1data[i].kronFlux;
-    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
-
-    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.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);
-}
-
-
+

trunk/Ohana/src/libdvo/include/dvo.h

@@ -149 +149 @@
 /* Average.flags values -- these values are 32 bit (as of PS1_V1) */
 typedef enum {
-  ID_STAR_FEW     = 0x00000001, // used within relphot: skip star
-  ID_STAR_POOR    = 0x00000002, // used within relphot: skip star
-  ID_PROPER       = 0x00000400, // star with large proper motion
-  ID_TRANSIENT    = 0x00001000, // is this mutually exclusive with USNO?
-  ID_VARIABLE     = 0x00002000, // not currently set?
-  ID_ASTEROID     = 0x00002000, // identified with an asteroid
-  ID_BAD_OBJECT   = 0x00004000, // if all measurements are bad, set this bit
-  ID_MOVING       = 0x00008000, // is a moving object
-  ID_ROCK         = 0x0000a000, // 0x8000 + 0x2000
-  ID_GHOST        = 0x0000c001, // 0x8000 + 0x4000 + 0x0001
-  ID_TRAIL        = 0x0000c002, // 0x8000 + 0x4000 + 0x0002
-  ID_BLEED        = 0x0000c003, // 0x8000 + 0x4000 + 0x0003
-  ID_COSMIC       = 0x0000c004, // 0x8000 + 0x4000 + 0x0004
-  ID_STAR_FIT_AVE = 0x00010000, // average position fitted
-  ID_STAR_FIT_PM  = 0x00020000, // proper motion fitted
-  ID_STAR_FIT_PAR = 0x00040000, // parallax fitted
-  ID_STAR_USE_AVE = 0x00080000, // average position used (not PM or PAR)
-  ID_STAR_USE_PM  = 0x00100000, // proper motion used (not AVE or PAR)
-  ID_STAR_USE_PAR = 0x00200000, // parallax used (not AVE or PM)
-  ID_OBJ_EXT      = 0x01000000, // extended in our data (eg, PS)
-  ID_OBJ_EXT_ALT  = 0x02000000, // extended in external data (eg, 2MASS)
-  ID_OBJ_GOOD     = 0x04000000, // good-quality measurement in our data (eg,PS)
-  ID_OBJ_GOOD_ALT = 0x08000000, // good-quality measurement in  external data (eg, 2MASS)
+  ID_STAR_FEW       = 0x00000001, // used within relphot: skip star
+  ID_STAR_POOR      = 0x00000002, // used within relphot: skip star
+  ID_PROPER         = 0x00000400, // star with large proper motion
+  ID_TRANSIENT      = 0x00001000, // is this mutually exclusive with USNO?
+  ID_VARIABLE       = 0x00002000, // not currently set?
+  ID_ASTEROID       = 0x00002000, // identified with an asteroid
+  ID_BAD_OBJECT     = 0x00004000, // if all measurements are bad, set this bit
+  ID_MOVING         = 0x00008000, // is a moving object
+  ID_ROCK           = 0x0000a000, // 0x8000 + 0x2000
+  ID_GHOST          = 0x0000c001, // 0x8000 + 0x4000 + 0x0001
+  ID_TRAIL          = 0x0000c002, // 0x8000 + 0x4000 + 0x0002
+  ID_BLEED          = 0x0000c003, // 0x8000 + 0x4000 + 0x0003
+  ID_COSMIC         = 0x0000c004, // 0x8000 + 0x4000 + 0x0004
+  ID_STAR_FIT_AVE   = 0x00010000, // average position fitted
+  ID_STAR_FIT_PM    = 0x00020000, // proper motion fitted
+  ID_STAR_FIT_PAR   = 0x00040000, // parallax fitted
+  ID_STAR_USE_AVE   = 0x00080000, // average position used (not PM or PAR)
+  ID_STAR_USE_PM    = 0x00100000, // proper motion used (not AVE or PAR)
+  ID_STAR_USE_PAR   = 0x00200000, // parallax used (not AVE or PM)
+  ID_STAR_NO_ASTROM = 0x00400000, // 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)
+  ID_OBJ_GOOD       = 0x04000000, // good-quality measurement in our data (eg,PS)
+  ID_OBJ_GOOD_ALT   = 0x08000000, // good-quality measurement in  external data (eg, 2MASS)
 } DVOAverageFlags;
 
@@ -180 +181 @@
   ID_SECF_USE_SYNTH   = 0x00000004, // synthetic photometry used in average measurement
   ID_SECF_USE_UBERCAL = 0x00000008, // synthetic photometry used in average measurement
+  ID_SECF_HAS_PS1     = 0x00000010, // PS1 photometry used in average measurement
+  ID_SECF_HAS_STACK   = 0x00000020, // PS1 stack photometry exists
   ID_PHOTOM_PASS_0    = 0x00000100, // average magnitude calculated in 0th pass
   ID_PHOTOM_PASS_1    = 0x00000200, // average magnitude calculated in 1th pass

trunk/Ohana/src/libdvo/src/dvo_catalog.c

@@ -89 +89 @@
   average->Trange          = 0;
 
+  average->psfQF           = 0.0;
+  average->psfQFperf       = 0.0;
+
   average->stargal         = 0.0;
   average->Npos            = 0;

trunk/Ohana/src/relastro/src/UpdateObjects.c

@@ -168 +168 @@
       }
 
-      // 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 parameters for even the average
-      // position, consider including the lower-quality detections
-
-      catalog[i].average[j].flags &= ~ID_STAR_FEW;
+      // 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
@@ -197 +197 @@
         // XXX need to define PHOTOM and ASTROM object flags
         // XXX reset the average value fields?
-        catalog[i].average[j].flags |= ID_STAR_FEW;
+        catalog[i].average[j].flags |= ID_STAR_NO_ASTROM;
         catalog[i].average[j].ChiSqAve  = NAN;
         catalog[i].average[j].ChiSqPM   = NAN;

trunk/Ohana/src/relastro/src/bcatalog.c

@@ -26 +26 @@
 
   DVOAverageFlags averageBits = 
-    ID_STAR_FEW     |
-    ID_STAR_POOR    |
-    ID_STAR_FIT_AVE |
-    ID_STAR_FIT_PM  |
-    ID_STAR_FIT_PAR |
-    ID_STAR_USE_AVE |
-    ID_STAR_USE_PM  |
-    ID_STAR_USE_PAR; 
+    ID_STAR_FIT_AVE   |
+    ID_STAR_FIT_PM    |
+    ID_STAR_FIT_PAR   |
+    ID_STAR_USE_AVE   |
+    ID_STAR_USE_PM    |
+    ID_STAR_USE_PAR   |
+    ID_STAR_NO_ASTROM ; 
 
   /* exclude stars not in range or with too few measurements */

trunk/Ohana/src/relastro/src/initialize.c

@@ -19 +19 @@
 
   initstats (STATMODE);
-
-  // IMAGE_BAD = ID_IMAGE_ASTROM_POOR | ID_IMAGE_ASTROM_FEW | ID_IMAGE_ASTROM_SKIP;
-  // STAR_BAD  = ID_STAR_POOR | ID_STAR_FEW;
-  // MEAS_BAD  = ID_MEAS_NOCAL | ID_MEAS_POOR_ASTROM | ID_MEAS_SKIP_ASTROM | ID_MEAS_AREA;
 
   /* XXX drop irrelevant entries */
@@ -57 +53 @@
 
   initstats (STATMODE);
-
-  // IMAGE_BAD = ID_IMAGE_ASTROM_POOR | ID_IMAGE_ASTROM_FEW | ID_IMAGE_ASTROM_SKIP;
-  // STAR_BAD  = ID_STAR_POOR | ID_STAR_FEW;
-  // MEAS_BAD  = ID_MEAS_NOCAL | ID_MEAS_POOR_ASTROM | ID_MEAS_SKIP_ASTROM | ID_MEAS_AREA;
 }
 

trunk/Ohana/src/relastro/src/liststats.c

@@ -136 +136 @@
     dS += M;
   }
-  X2 = X2 / Nm;
+  X2 = X2 / (Nm - 1);
   dS = sqrt (dS / Nm);
 

trunk/Ohana/src/relastro/src/relastro_objects.c

@@ -16 +16 @@
 
   DVOAverageFlags averageBits = 
-    ID_STAR_FEW     |
-    ID_STAR_POOR    |
-    ID_STAR_FIT_AVE |
-    ID_STAR_FIT_PM  |
-    ID_STAR_FIT_PAR |
-    ID_STAR_USE_AVE |
-    ID_STAR_USE_PM  |
-    ID_STAR_USE_PAR; 
+    ID_STAR_FIT_AVE   |
+    ID_STAR_FIT_PM    |
+    ID_STAR_FIT_PAR   |
+    ID_STAR_USE_AVE   |
+    ID_STAR_USE_PM    |
+    ID_STAR_USE_PAR   |
+    ID_STAR_NO_ASTROM ; 
 
   // XXX need to decide how to determine PARALLEL mode...

trunk/Ohana/src/relphot/src/StarOps.c

@@ -11 +11 @@
   int Nmos;
   int Ngrid;
-  double *list;
-  double *dlist;
-  double *wlist;
-  double *aplist;
-  double *kronlist;
-  double *dkronlist;
+
+  // NOTE: the following arrays are (possibly) pre-allocated and carried down to each
+  // thread.  The first 3 (list, dlist, wlist) are used in all relphot analyses; the
+  // 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 *dkronlist;          // kron mag errors 
+
+  double *psfqf_list;         // psfqf for all filters
+  double *psfqfperf_list;     // psfqfperf for all filters
+  double *stargal_list;       // stargal for all filters
 } SetMrelInfo;
 
@@ -168 +177 @@
   ALLOCATE (results.dkronlist, double, Nmax);
 
+  ALLOCATE (results.psfqf_list, double, Nmax);
+  ALLOCATE (results.psfqfperf_list, double, Nmax);
+  ALLOCATE (results.stargal_list, double, Nmax);
+
   for (i = 0; i < Ncatalog; i++) {
     setMrel_catalog  (catalog, i, pass, flatcorr, &results, Nsecfilt); // XXX add arguments as needed for options
@@ -178 +191 @@
   free (results.kronlist);
   free (results.dkronlist);
+
+  free (results.psfqf_list);
+  free (results.psfqfperf_list);
+  free (results.stargal_list);
   return (TRUE);
 }
@@ -315 +332 @@
   liststats_setmode (&kronstats, STATMODE);
 
+  // StatType psfstats;
+  // liststats_setmode (&psfstats, "MEAN");
+
   double *list      = results->list;
   double *dlist     = results->dlist;
@@ -322 +342 @@
   double *dkronlist = results->dkronlist;
 
+  double *psfqf_list     = results->psfqf_list;
+  double *psfqfperf_list = results->psfqfperf_list;
+  double *stargal_list   = results->stargal_list;
+
   SetMrelInfoInit (results, FALSE); // do not allocate list,dlist,wlist arrays
 
@@ -327 +351 @@
 
   char *primaryCell = NULL;
-  ALLOCATE (primaryCell, char, DVO_MAX_PATH);
+  if (isSetMrelFinal) {
+    ALLOCATE (primaryCell, char, DVO_MAX_PATH);
+  }
 
   for (j = 0; j < catalog[Nc].Naverage; j++) {
@@ -338 +364 @@
     }
 
-    BoundaryTreePrimaryCell(primaryCell, catalog[Nc].average[j].R, catalog[Nc].average[j].D);
+    if (isSetMrelFinal) {
+      BoundaryTreePrimaryCell(primaryCell, catalog[Nc].average[j].R, catalog[Nc].average[j].D);
+    }
 
     int GoodPS1 = FALSE;
@@ -346 +374 @@
     int NextPS1 = 0;
     int NpsfPS1 = 0;
+
+    int Nmeas = 0; // number of meas used for psfqf, psfqfperf, and stargal
 
     int Ns;
@@ -365 +395 @@
       int haveSynth = FALSE;
       int haveStack = FALSE;
+      int havePS1   = FALSE;
 
       // need to find the measurement closest to the center of its skycell, as well as the
@@ -420 +451 @@
 
         if (isSetMrelFinal) {
+          // Map (aplist) and Mkron (kronlist,dkronlist) are used to calculate mean mags per filter
           float Map = PhotAper (&catalog[Nc].measure[m]);
           aplist[N] = Map - Mcal - Mmos - Mgrid;
@@ -426 +458 @@
           kronlist[N] = Mkron - Mcal - Mmos - Mgrid;
           dkronlist[N] = catalog[Nc].measure[m].dMkron;
+
+          // mean psfQF, psfQFperf, and stargal values are calculated per object (all filters)
+          psfqf_list[Nmeas]     = catalog[Nc].measure[m].psfQF;
+          psfqfperf_list[Nmeas] = catalog[Nc].measure[m].psfQF;
+          stargal_list[Nmeas]   = catalog[Nc].measure[m].extNsigma;
 
           // special options for PS1 data
@@ -431 +468 @@
             // count the extended detections
             if (!isnan(catalog[Nc].measure[m].Map)) {
-              if (catalog[Nc].measure[m].M - catalog[Nc].measure[m].Map > 0.5) {
+              float dMagAp = catalog[Nc].measure[m].M - catalog[Nc].measure[m].Map;
+              float SigmaAp = hypot(0.1, 2.5*catalog[Nc].measure[m].dM);
+              // XXX this is still quite ad hoc, but at least it:
+              // (a) converges to 0.1 mag offset at the bright end
+              // (b) converges to 0.5 mag offset at the faint end (dM = 0.2)
+              if (dMagAp > SigmaAp) {
                 Next ++;
                 NextPS1 ++;
@@ -438 +480 @@
               }
             }
+            havePS1 = TRUE;
           }
           // gpc1 stack data
@@ -543 +586 @@
         }
         N++;
+        Nmeas++;
       }
 
@@ -658 +702 @@
           case 0:
             catalog[Nc].secfilt[Nsecfilt*j+Nsec].flags |= ID_PHOTOM_PASS_0;
-            GoodPS1 = TRUE;
+            if (havePS1) GoodPS1 = TRUE;
             break;
           case 1:
             catalog[Nc].secfilt[Nsecfilt*j+Nsec].flags |= ID_PHOTOM_PASS_1;
-            GoodPS1 = TRUE;
+            if (havePS1) GoodPS1 = TRUE;
             break;
           case 2:
             catalog[Nc].secfilt[Nsecfilt*j+Nsec].flags |= ID_PHOTOM_PASS_2;
-            GoodPS1 = TRUE;
+            if (havePS1) GoodPS1 = TRUE;
             break;
           case 3:
@@ -678 +722 @@
           catalog[Nc].secfilt[Nsecfilt*j+Nsec].flags |= ID_SECF_USE_SYNTH;
         }       
+        if (haveStack) {
+          catalog[Nc].secfilt[Nsecfilt*j+Nsec].flags |= ID_SECF_HAS_STACK;
+        }       
+        if (havePS1) {
+          catalog[Nc].secfilt[Nsecfilt*j+Nsec].flags |= ID_SECF_HAS_PS1;
+        }       
         if (haveUbercal) {
           catalog[Nc].secfilt[Nsecfilt*j+Nsec].flags |= ID_SECF_USE_UBERCAL;
@@ -685 +735 @@
 
     if (isSetMrelFinal) {
-      DVOAverageFlags flagBits = ID_OBJ_EXT | ID_OBJ_EXT_ALT | ID_OBJ_GOOD | ID_OBJ_GOOD_ALT;
-
-      // we attempt to set a few flags here; reset those bits before trying:
-      catalog[Nc].average[j].flags &= ~flagBits;
+      if (pass == 0) {
+        DVOAverageFlags flagBits = ID_OBJ_EXT | ID_OBJ_EXT_ALT | ID_OBJ_GOOD | ID_OBJ_GOOD_ALT;
+        // we attempt to set a few flags here; reset those bits before trying:
+        catalog[Nc].average[j].flags &= ~flagBits;
+      }
 
       if (NextPS1 && (NextPS1 > NpsfPS1)) {
@@ -701 +752 @@
       if (Good2MASS) {
         catalog[Nc].average[j].flags |= ID_OBJ_GOOD_ALT;
+      }
+
+      // use NAN values for catalog[Nc].average[j].psfQF as signal
+      if (!isfinite(catalog[Nc].average[j].psfQF)) {
+        // do something here
+        float psfQFmax     = 0.0;
+        float psfQFperfmax = 0.0;
+        float stargalmax   = 0.0;
+        int seq;
+        for (seq = 0; seq < Nmeas; seq++) {
+          if (isfinite(psfqf_list[seq])) {
+            psfQFmax     = MAX (psfqf_list[seq], psfQFmax);
+          }
+          if (isfinite(psfqfperf_list[seq])) {
+            psfQFperfmax = MAX (psfqfperf_list[seq], psfQFperfmax);
+          }
+          if (isfinite(stargal_list[seq])) {
+            stargalmax   = MAX (stargal_list[seq], stargalmax);
+          }
+        }
+
+        catalog[Nc].average[j].psfQF     = psfQFmax;
+        catalog[Nc].average[j].psfQFperf = psfQFperfmax;
+        catalog[Nc].average[j].stargal   = stargalmax;
       }
     }

trunk/Ohana/src/relphot/src/initialize.c

@@ -77 +77 @@
   args_client (argc, argv);
 
-  if (MODE == MODE_UPDATE_OBJECTS) return;
+  if (MODE == MODE_UPDATE_OBJECTS) {
+    char tmpline1[256];
+    int Ns;
+    Nphotcodes = GetPhotcodeNsecfilt ();
+    ALLOCATE (photcodes, PhotCode *, Nphotcodes);
+    ALLOCATE (PhotcodeList, char, 256);
+    for (Ns = 0; Ns < Nphotcodes; Ns++) {
+      photcodes[Ns] = GetPhotcodebyNsec (Ns);
+      if (Ns > 0) {
+        snprintf (tmpline1, 256, "%s,%s", PhotcodeList, photcodes[Ns][0].name);
+      } else {
+        snprintf (tmpline1, 256, "%s", photcodes[Ns][0].name);
+      }
+      strcpy (PhotcodeList, tmpline1);
+    }
+    return;
+  }
 
   // load the list of photcodes into the globals (photcodes, Nphotcodes)

trunk/Ohana/src/relphot/src/liststats.c

@@ -38 +38 @@
     dsortthree (value, dvalue, weight, N);
   } else {
-    dsortpair (value, dvalue, N);
+    if (dvalue) {
+      dsortpair (value, dvalue, N);
+    } else {
+      dsort (value, N);
+    }
   }
 

trunk/Ohana/src/relphot/src/relphot_objects.c

@@ -61 +61 @@
       Nsecfilt = catalog.Nsecfilt;
       DVOSecfiltFlags secfiltBits = 
-        ID_SECF_STAR_FEW | 
-        ID_SECF_STAR_POOR | 
-        ID_PHOTOM_PASS_0 | 
-        ID_PHOTOM_PASS_1 | 
-        ID_PHOTOM_PASS_2 | 
-        ID_PHOTOM_PASS_3 | 
-        ID_PHOTOM_PASS_4 |
-        ID_SECF_USE_SYNTH |
+        ID_SECF_STAR_FEW    | 
+        ID_SECF_STAR_POOR   | 
+        ID_PHOTOM_PASS_0    | 
+        ID_PHOTOM_PASS_1    | 
+        ID_PHOTOM_PASS_2    | 
+        ID_PHOTOM_PASS_3    | 
+        ID_PHOTOM_PASS_4    |
+        ID_SECF_USE_SYNTH   |
         ID_SECF_USE_UBERCAL |
-        ID_SECF_OBJ_EXT;
+        ID_SECF_HAS_STACK   |
+        ID_SECF_HAS_PS1     |
+        ID_SECF_OBJ_EXT     ;
+      
+      DVOAverageFlags astromBits = 
+        ID_STAR_FIT_AVE   | 
+        ID_STAR_FIT_PM    | 
+        ID_STAR_FIT_PAR   | 
+        ID_STAR_USE_AVE   | 
+        ID_STAR_USE_PM    | 
+        ID_STAR_USE_PAR   |
+        ID_STAR_NO_ASTROM ; 
       
       for (j = 0; j < catalog.Naverage; j++) {
-        catalog.average[j].flags = 0;
+        catalog.average[j].flags &= astromBits; // reset all except astrometry bits
+        catalog.average[j].psfQF     = NAN;     // reset (will be re-calculated here)
+        catalog.average[j].psfQFperf = NAN;     // reset (will be re-calculated here)
+        catalog.average[j].stargal   = NAN;     // reset (will be re-calculated here)
         for (k = 0; k < Nsecfilt; k++) {
-          catalog.secfilt[j*Nsecfilt + k].M      = NAN;
-          catalog.secfilt[j*Nsecfilt + k].Map    = NAN;
-          catalog.secfilt[j*Nsecfilt + k].dM     = NAN;
-          catalog.secfilt[j*Nsecfilt + k].Mstdev = NAN_S_SHORT;
-          catalog.secfilt[j*Nsecfilt + k].Xm     = NAN;
-          catalog.secfilt[j*Nsecfilt + k].M_20   = NAN_S_SHORT;
-          catalog.secfilt[j*Nsecfilt + k].M_80   = NAN_S_SHORT;
-          catalog.secfilt[j*Nsecfilt + k].Ncode  = 0;
-          catalog.secfilt[j*Nsecfilt + k].Nused  = 0;
-          catalog.secfilt[j*Nsecfilt + k].flags &= ~secfiltBits;
-          catalog.secfilt[j*Nsecfilt + k].ubercalDist = 1000;
+          dvo_secfilt_init (&catalog.secfilt[j*Nsecfilt + k]);
+          catalog.secfilt[j*Nsecfilt + k].flags &= ~secfiltBits; // XXX: only reset photom bits: 
         }
       }

trunk/Ohana/src/relphot/src/setMrelFinal.c

@@ -94 +94 @@
   }
 
+  for (i = 0; i < catalog[0].Naverage; i++) {
+    catalog[0].average[i].psfQF     = NAN;      // force recalculation below
+    catalog[0].average[i].psfQFperf = NAN;      // force recalculation below
+    catalog[0].average[i].stargal   = NAN;      // force recalculation below
+  }
+
   // XXX make this optional? (do not clean for -averages?)
   if (!simpleAverage) clean_measures (catalog, 1, TRUE, flatcorr);    /* mark outliers ID_MEAS_POOR_PHOTOM */