Index: /trunk/Ohana/src/opihi/cmd.astro/cdensify.c
===================================================================
--- /trunk/Ohana/src/opihi/cmd.astro/cdensify.c	(revision 38462)
+++ /trunk/Ohana/src/opihi/cmd.astro/cdensify.c	(revision 38463)
@@ -73,6 +73,6 @@
   CHECKVAL(dY);
 
-  Nx = (Xmax - Xmin) / dX + 1;
-  Ny = (Ymax - Ymin) / dY + 1;
+  Nx = abs((Xmax - Xmin) / dX) + 1;
+  Ny = abs((Ymax - Ymin) / dY) + 1;
   
   Coords newcoords = graphmode.coords;
Index: /trunk/Ohana/src/opihi/cmd.data/Makefile
===================================================================
--- /trunk/Ohana/src/opihi/cmd.data/Makefile	(revision 38462)
+++ /trunk/Ohana/src/opihi/cmd.data/Makefile	(revision 38463)
@@ -25,4 +25,5 @@
 $(SRC)/book.$(ARCH).o		\
 $(SRC)/book_commands.$(ARCH).o	\
+$(SRC)/bisection.$(ARCH).o		\
 $(SRC)/cast.$(ARCH).o		\
 $(SRC)/center.$(ARCH).o	\
Index: /trunk/Ohana/src/opihi/cmd.data/bisection.c
===================================================================
--- /trunk/Ohana/src/opihi/cmd.data/bisection.c	(revision 38463)
+++ /trunk/Ohana/src/opihi/cmd.data/bisection.c	(revision 38463)
@@ -0,0 +1,37 @@
+# include "data.h"
+
+int bisection (int argc, char **argv) {
+  
+  int N;
+  Vector *vec;
+
+  int QUIET = FALSE;
+  if ((N = get_argument (argc, argv, "-q"))) {
+    QUIET = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+
+  if (argc != 3) {
+    gprint (GP_ERR, "USAGE: bisection <vector> (threshold)\n");
+    gprint (GP_ERR, "  return the vector index for which the vector is last below the threshold via bisection\n");
+    gprint (GP_ERR, "  vector must be sorted\n");
+    return (FALSE);
+  }
+  
+  if ((vec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);
+  double threshold = atof (argv[2]);
+  
+  int isFlt = (vec[0].type == OPIHI_FLT);
+
+  if (isFlt) {
+    N = ohana_bisection_double (vec[0].elements.Flt, vec[0].Nelements, threshold);
+  } else {
+    // N = ohana_bisection_int (vec[0].elements.Flt, vec[0].Nelements);
+  }
+
+  set_variable ("bisecbin", N);
+
+  if (!QUIET) gprint (GP_LOG, "bin %d for theshold %f\n", N, threshold);
+
+  return (TRUE);
+}
Index: /trunk/Ohana/src/opihi/cmd.data/init.c
===================================================================
--- /trunk/Ohana/src/opihi/cmd.data/init.c	(revision 38462)
+++ /trunk/Ohana/src/opihi/cmd.data/init.c	(revision 38463)
@@ -9,6 +9,6 @@
 int box              PROTO((int, char **));
 int book_command     PROTO((int, char **));
+int bisection        PROTO((int, char **));
 int center           PROTO((int, char **));
-int parity           PROTO((int, char **));
 int cast             PROTO((int, char **));
 int circstats        PROTO((int, char **));
@@ -90,4 +90,5 @@
 int plot             PROTO((int, char **));
 int dot              PROTO((int, char **));
+int parity           PROTO((int, char **));
 int point            PROTO((int, char **));
 int ps               PROTO((int, char **));
@@ -176,4 +177,5 @@
   {1, "applyfit2d",   applyfit2d,       "apply 2-d fit to new vector"},
   {1, "applyfit3d",   applyfit3d,       "apply 3-d fit to new vector"},
+  {1, "bisection",    bisection,        "use bisection to find threshold in vector"},
   {1, "book",         book_command,     "commands to manipulate book/page/word data"},
   {1, "box",          box,              "draw a box on the plot"},
Index: /trunk/Ohana/src/opihi/cmd.data/tvcolors.c
===================================================================
--- /trunk/Ohana/src/opihi/cmd.data/tvcolors.c	(revision 38462)
+++ /trunk/Ohana/src/opihi/cmd.data/tvcolors.c	(revision 38463)
@@ -16,12 +16,34 @@
   FREE (name);
 
+  int SetNAN = FALSE;
+  int red, green, blue;
+  if ((N = get_argument (argc, argv, "-nan"))) {
+    if (N > argc - 4) { 
+      gprint (GP_ERR, "ERROR: -nan (red) (green) (blue) does not have enough arguments\n"); 
+      return FALSE; 
+    }
+    remove_argument (N, &argc, argv);
+    red = strtol (argv[N], NULL, 0);
+    remove_argument (N, &argc, argv);
+    green = strtol (argv[N], NULL, 0);
+    remove_argument (N, &argc, argv);
+    blue = strtol (argv[N], NULL, 0);
+    remove_argument (N, &argc, argv);
+    SetNAN = TRUE;
+  }
+
   // use the currently-set zero,range values if not supplied
-  if (argc != 2) {
-    gprint (GP_ERR, "USAGE: tvcolors (colormap)\n");
+  if (!SetNAN && (argc != 2)) {
+    gprint (GP_ERR, "USAGE: tvcolors (colormap) [-nan red green blue]\n");
     gprint (GP_ERR, " colormap options : greyscale, -greyscale, rainbow, heat, fullcolor, ruffcolor (also grayscale, -grayscale)\n");
     return (FALSE);
   }
 
-  KiiSetColormap (kapa, argv[1]);
+  if (SetNAN) {
+    KiiSetNanColor (kapa, red, green, blue);
+  }
+  if (argc == 2) {
+    KiiSetColormap (kapa, argv[1]);
+  }
   return (TRUE);
 }
Index: /trunk/Ohana/src/opihi/dvo/gstar.c
===================================================================
--- /trunk/Ohana/src/opihi/dvo/gstar.c	(revision 38462)
+++ /trunk/Ohana/src/opihi/dvo/gstar.c	(revision 38463)
@@ -8,15 +8,22 @@
 
 typedef enum {
+  GSTAR_FILTER_NAMES,
+  GSTAR_SECF_FLAGS,
+  GSTAR_UCDIST,
   GSTAR_AVE_MAG,
   GSTAR_AVE_MAG_ERR,
   GSTAR_AVE_MAG_CHISQ,
-  GSTAR_FILTER_NAMES,
-  GSTAR_SECF_FLAGS,
-  GSTAR_UCDIST,
   GSTAR_AVE_AP_MAG,
+  GSTAR_AVE_AP_MAG_ERR,
+  GSTAR_AVE_AP_MAG_CHISQ,
   GSTAR_AVE_MAG_MIN,
   GSTAR_AVE_MAG_MAX,
   GSTAR_AVE_KRON_MAG,
   GSTAR_AVE_KRON_MAG_ERR,
+  GSTAR_AVE_KRON_MAG_CHISQ,
+  GSTAR_AVE_NCODE,
+  GSTAR_AVE_NUSED,
+  GSTAR_AVE_AP_NUSED,
+  GSTAR_AVE_KRON_NUSED,
   GSTAR_STACK_FLUX_PSF,
   GSTAR_STACK_FLUX_PSF_ERR,
@@ -27,8 +34,11 @@
   GSTAR_WARP_FLUX_PSF,
   GSTAR_WARP_FLUX_PSF_ERR,
+  GSTAR_WARP_FLUX_PSF_CHISQ,
   GSTAR_WARP_FLUX_KRON,
   GSTAR_WARP_FLUX_KRON_ERR,
+  GSTAR_WARP_FLUX_KRON_CHISQ,
   GSTAR_WARP_FLUX_APER,
   GSTAR_WARP_FLUX_APER_ERR,
+  GSTAR_WARP_FLUX_APER_CHISQ,
   GSTAR_STACK_MAG_PSF,
   GSTAR_STACK_MAG_PSF_ERR,
@@ -37,10 +47,19 @@
   GSTAR_STACK_MAG_APER,
   GSTAR_STACK_MAG_APER_ERR,
+  GSTAR_STACK_NUSED,
   GSTAR_WARP_MAG_PSF,
   GSTAR_WARP_MAG_PSF_ERR,
+  GSTAR_WARP_MAG_PSF_CHISQ,
   GSTAR_WARP_MAG_KRON,
   GSTAR_WARP_MAG_KRON_ERR,
+  GSTAR_WARP_MAG_KRON_CHISQ,
   GSTAR_WARP_MAG_APER,
   GSTAR_WARP_MAG_APER_ERR,
+  GSTAR_WARP_MAG_APER_CHISQ,
+  GSTAR_WARP_NWARP,
+  GSTAR_WARP_NWARP_GOOD,
+  GSTAR_WARP_NWARP_USED_PSF,
+  GSTAR_WARP_NWARP_USED_KRON,
+  GSTAR_WARP_NWARP_USED_AP,
 } GSTAR_SECF_CODES;
 
@@ -310,7 +329,7 @@
 	gprint (GP_LOG, "%3d   ",  catalog.average[k].Nmeasure);
 	gprint (GP_LOG, "%4.1f ",  catalog.average[k].ChiSqAve);
-	gprint (GP_LOG, "%5x ",    catalog.average[k].flags);
-	gprint (GP_LOG, "%x ",     catalog.average[k].objID);
-	gprint (GP_LOG, "%x ",     catalog.average[k].catID);
+	gprint (GP_LOG, "0x%08x ", catalog.average[k].flags);
+	gprint (GP_LOG, "0x%08x ", catalog.average[k].objID);
+	gprint (GP_LOG, "0x%08x ", catalog.average[k].catID);
 	
 	if (FULL_OUTPUT) {
@@ -344,4 +363,16 @@
 	gprint (GP_LOG, "\n");
 
+	if (EXTRA_OUTPUT) {
+	  /* Mmin */
+	  gprint (GP_LOG, "chp_psf_min: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MIN);
+	  gprint (GP_LOG, "\n");
+
+	  /* Mmax */
+	  gprint (GP_LOG, "chp_psf_max: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MAX);;
+	  gprint (GP_LOG, "\n");
+	}
+
 	/* average mag errors */
 	gprint (GP_LOG, "chp_psf_err: ");
@@ -354,4 +385,13 @@
 	gprint (GP_LOG, "\n");
 
+	/* average mag Ncode */
+	gprint (GP_LOG, "chp_Ncode:   ");
+	for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_NCODE);
+	gprint (GP_LOG, "\n");
+	
+	/* average mag Nused */
+	gprint (GP_LOG, "chp_Nused:   ");
+	for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_NUSED);
+	gprint (GP_LOG, "\n");
 	
 	if (APER_OUTPUT) {
@@ -360,4 +400,17 @@
 	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_AP_MAG);
 	  gprint (GP_LOG, "\n");
+
+	  gprint (GP_LOG, "chp_ap__err: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_AP_MAG_ERR);
+	  gprint (GP_LOG, "\n");
+
+	  gprint (GP_LOG, "chp_ap__chi: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_AP_MAG_CHISQ);
+	  gprint (GP_LOG, "\n");
+
+	  /* average mag Nused */
+	  gprint (GP_LOG, "chp_ap__N:   ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_AP_NUSED);
+	  gprint (GP_LOG, "\n");
 	}
 
@@ -372,27 +425,15 @@
 	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_KRON_MAG_ERR);
 	  gprint (GP_LOG, "\n");
+
+	  gprint (GP_LOG, "chp_krn_chi: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_KRON_MAG_CHISQ);
+	  gprint (GP_LOG, "\n");
+
+	  /* average mag Nused */
+	  gprint (GP_LOG, "chp_krn_N:   ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_KRON_NUSED);
+	  gprint (GP_LOG, "\n");
 	} 
 
-	if (EXTRA_OUTPUT) {
-	  /* Mmin */
-	  gprint (GP_LOG, "chp_psf_min: ");
-	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MIN);
-	  gprint (GP_LOG, "\n");
-
-	  /* Mmax */
-	  gprint (GP_LOG, "chp_psf_max: ");
-	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MAX);;
-	  gprint (GP_LOG, "\n");
-
-	  /* UCDIST */
-	  gprint (GP_LOG, "ubercal_dst: ");
-	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_UCDIST);;
-	  gprint (GP_LOG, "\n");
-
-	  /* secfilt flags */
-	  gprint (GP_LOG, "filtflags:   ");
-	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_SECF_FLAGS);
-	  gprint (GP_LOG, "\n");
-	}
 	if (STACK_OUTPUT && MAG_OUTPUT) {
 	  /* FluxPSF */
@@ -406,4 +447,10 @@
 	  gprint (GP_LOG, "\n");
   
+	  if (!FLUX_OUTPUT) {
+	    gprint (GP_LOG, "stk_Nstack: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_NUSED);
+	    gprint (GP_LOG, "\n");
+	  }
+
 	  if (KRON_OUTPUT) {
 	    /* MagKron */
@@ -441,4 +488,22 @@
 	  gprint (GP_LOG, "\n");
   
+	  gprint (GP_LOG, "wrp_psf_chi: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_PSF_CHISQ);
+	  gprint (GP_LOG, "\n");
+  
+	  if (!FLUX_OUTPUT) {
+	    gprint (GP_LOG, "wrp_Nwarp:   ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP);
+	    gprint (GP_LOG, "\n");
+	    
+	    gprint (GP_LOG, "wrp_NGood:   ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP_GOOD);
+	    gprint (GP_LOG, "\n");
+
+	    gprint (GP_LOG, "wrp_NUsed:   ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP_USED_PSF);
+	    gprint (GP_LOG, "\n");
+	  }
+	  
 	  if (KRON_OUTPUT) {
 	    /* MagKron */
@@ -452,6 +517,16 @@
 	    gprint (GP_LOG, "\n");
 
+	    /* dMagKron */
+	    gprint (GP_LOG, "wrp_krn_chp: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_KRON_CHISQ);
+	    gprint (GP_LOG, "\n");
+
+	    if (!FLUX_OUTPUT) {
+	      gprint (GP_LOG, "wrp_krn_Nuse:");
+	      for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP_USED_KRON);
+	      gprint (GP_LOG, "\n");
+	    }
 	  }
-
+	  
 	  if (APER_OUTPUT) {
 	    /* MagAper */
@@ -464,4 +539,15 @@
 	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_APER_ERR);
 	    gprint (GP_LOG, "\n");
+
+	    /* dMagAper */
+	    gprint (GP_LOG, "wrp_ap__chi: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_APER_CHISQ);
+	    gprint (GP_LOG, "\n");
+
+	    if (!FLUX_OUTPUT) {
+	      gprint (GP_LOG, "wrp_ap_Nuse: ");
+	      for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP_USED_AP);
+	      gprint (GP_LOG, "\n");
+	    }
 	  }
 	}
@@ -491,13 +577,17 @@
 	  if (APER_OUTPUT) {
 	    /* FluxAper */
-	    gprint (GP_LOG, "stk_ap_ave: ");
+	    gprint (GP_LOG, "stk_ap_ave:  ");
 	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_APER);
 	    gprint (GP_LOG, "\n");
   
 	    /* dFluxAper */
-	    gprint (GP_LOG, "stk_ap_err: ");
+	    gprint (GP_LOG, "stk_ap_err:  ");
 	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_APER_ERR);
 	    gprint (GP_LOG, "\n");
 	  }
+
+	  gprint (GP_LOG, "stk_Nstack:  ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_NUSED);
+	  gprint (GP_LOG, "\n");
 	}
 	if (WARP_OUTPUT && FLUX_OUTPUT) {
@@ -508,8 +598,24 @@
   
 	  /* dFluxPSF */
-	  gprint (GP_LOG, "wrp_psf_ave: ");
+	  gprint (GP_LOG, "wrp_psf_err: ");
 	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_PSF_ERR);
 	  gprint (GP_LOG, "\n");
   
+	  gprint (GP_LOG, "wrp_psf_chi: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_PSF_CHISQ);
+	  gprint (GP_LOG, "\n");
+  
+	  gprint (GP_LOG, "wrp_Nwarp:   ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP);
+	  gprint (GP_LOG, "\n");
+	  
+	  gprint (GP_LOG, "wrp_NGood:   ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP_GOOD);
+	  gprint (GP_LOG, "\n");
+
+	  gprint (GP_LOG, "wrp_NUsed:   ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP_USED_PSF);
+	  gprint (GP_LOG, "\n");
+
 	  if (KRON_OUTPUT) {
 	    /* FluxKron */
@@ -522,4 +628,12 @@
 	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_KRON_ERR);
 	    gprint (GP_LOG, "\n");
+
+	    gprint (GP_LOG, "wrp_krn_chi: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_KRON_CHISQ);
+	    gprint (GP_LOG, "\n");
+
+	    gprint (GP_LOG, "wrp_krn_Nuse:");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP_USED_KRON);
+	    gprint (GP_LOG, "\n");
 	  }
 
@@ -534,7 +648,27 @@
 	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_APER_ERR);
 	    gprint (GP_LOG, "\n");
+
+	    gprint (GP_LOG, "wrp_ap__chi: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_APER_CHISQ);
+	    gprint (GP_LOG, "\n");
+
+	    gprint (GP_LOG, "wrp_ap_Nuse: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_NWARP_USED_AP);
+	    gprint (GP_LOG, "\n");
 	  }
 	}
-      }
+	if (EXTRA_OUTPUT) {
+	  /* secfilt flags */
+	  gprint (GP_LOG, "filtflags:   ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_SECF_FLAGS);
+	  gprint (GP_LOG, "\n");
+
+	  /* UCDIST */
+	  gprint (GP_LOG, "ubercal_dst: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_UCDIST);;
+	  gprint (GP_LOG, "\n");
+	}
+      }
+
       gprint (GP_LOG, "\n");
       
@@ -626,4 +760,5 @@
 	      gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].imageID);
 	      gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].psfQF);
+	      gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].psfQFperf);
 	      gprint (GP_LOG, "%7.1f ", catalog.measure[Nv].psfChisq);
 	      // gprint (GP_LOG, "%3.1f ", catalog.measure[Nv].crNsigma);
@@ -636,4 +771,6 @@
 	      gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxKron);
 	      gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxKron);
+	      gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxAp);
+	      gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxAp);
 	    }
 	    gprint (GP_LOG, "\n");
@@ -688,12 +825,12 @@
 void print_double (double value) {
   if (isnan(value)) 
-    gprint (GP_LOG, "  NaN    ");
+    gprint (GP_LOG, "       NaN ");
   else 
-    gprint (GP_LOG, "  %6.3f ", value);
+    gprint (GP_LOG, "   %7.4f ", value);
 }
 
 void print_double_exp (double value) {
   if (isnan(value)) 
-    gprint (GP_LOG, "  NaN    ");
+    gprint (GP_LOG, "       NaN ");
   else 
     gprint (GP_LOG, "%10.3e ", value);
@@ -702,7 +839,7 @@
 void print_short (double value, short int ival) {
   if (ival == NAN_S_SHORT) 
-    gprint (GP_LOG, "  NaN    ");
+    gprint (GP_LOG, "       NaN ");
   else 
-    gprint (GP_LOG, "  %6.3f ", value);
+    gprint (GP_LOG, "   %7.4f ", value);
 }
 
@@ -763,5 +900,5 @@
 	print_double (NAN);
       } else {
-	print_double (secfilt[seq].Mchisq);
+	print_double_exp (secfilt[seq].Mchisq);
       }
       break;
@@ -769,12 +906,12 @@
     case GSTAR_FILTER_NAMES: /* filter names */
       code = GetPhotcodebyNsec (seq);
-      gprint (GP_LOG, "  %-6s ", code[0].name);
+      gprint (GP_LOG, "%10s ", code[0].name);
       break;
 
     case GSTAR_SECF_FLAGS: /* secfilt flags */
       if (seq == -1) {
-	gprint (GP_LOG, "%08x ", 0);
-      } else {
-	gprint (GP_LOG, "%08x ", secfilt[seq].flags);
+	gprint (GP_LOG, "0x%08x ", 0);
+      } else {
+	gprint (GP_LOG, "0x%08x ", secfilt[seq].flags);
       }
       break;
@@ -782,7 +919,39 @@
     case GSTAR_UCDIST: /* ubercal distance */
       if (seq == -1) {
-	gprint (GP_LOG, "%5d ", 0);
-      } else {
-	gprint (GP_LOG, "%5d ", secfilt[seq].ubercalDist);
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].ubercalDist);
+      }
+      break;
+
+    case GSTAR_AVE_NCODE: /* Ncode */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].Ncode);
+      }
+      break;
+
+    case GSTAR_AVE_NUSED: /* Nused */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].Nused);
+      }
+      break;
+
+    case GSTAR_AVE_KRON_NUSED: /* Nused */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].NusedKron);
+      }
+      break;
+
+    case GSTAR_AVE_AP_NUSED: /* Nused */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].NusedAp);
       }
       break;
@@ -814,4 +983,20 @@
       break;
 
+    case GSTAR_AVE_AP_MAG_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].dMap);
+      }
+      break;
+
+    case GSTAR_AVE_AP_MAG_CHISQ: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].sMap);
+      }
+      break;
+
     case GSTAR_AVE_KRON_MAG: /* average ap mags */
       if (seq == -1) {
@@ -830,4 +1015,12 @@
       break;
 
+    case GSTAR_AVE_KRON_MAG_CHISQ: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].sMkron);
+      }
+      break;
+
       /******************* STACK : FLUX **********************/
 
@@ -880,4 +1073,12 @@
       break;
 
+    case GSTAR_STACK_NUSED: /* Nused */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].Nstack);
+      }
+      break;
+
       /******************* STACK : MAG **********************/
 
@@ -948,4 +1149,12 @@
       break;
 
+    case GSTAR_WARP_FLUX_PSF_CHISQ: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].sFpsfWrp);
+      }
+      break;
+
     case GSTAR_WARP_FLUX_KRON: /* average ap mags */
       if (seq == -1) {
@@ -964,4 +1173,12 @@
       break;
 
+    case GSTAR_WARP_FLUX_KRON_CHISQ: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].sFkronWrp);
+      }
+      break;
+
     case GSTAR_WARP_FLUX_APER: /* average ap mags */
       if (seq == -1) {
@@ -980,4 +1197,12 @@
       break;
 
+    case GSTAR_WARP_FLUX_APER_CHISQ: /* average ap mags */
+      if (seq == -1) {
+	print_double_exp (NAN);
+      } else {
+	print_double_exp (secfilt[seq].sFapWrp);
+      }
+      break;
+
       /******************* WARP : MAG **********************/
 
@@ -998,4 +1223,12 @@
       break;
 
+    case GSTAR_WARP_MAG_PSF_CHISQ: /* average ap mags */
+      if (seq == -1) {
+	print_double_exp (NAN);
+      } else {
+	print_double_exp (secfilt[seq].sFpsfWrp);
+      }
+      break;
+
     case GSTAR_WARP_MAG_KRON: /* average ap mags */
       if (seq == -1) {
@@ -1014,4 +1247,12 @@
       break;
 
+    case GSTAR_WARP_MAG_KRON_CHISQ: /* average ap mags */
+      if (seq == -1) {
+	print_double_exp (NAN);
+      } else {
+	print_double_exp (secfilt[seq].sFkronWrp);
+      }
+      break;
+
     case GSTAR_WARP_MAG_APER: /* average ap mags */
       if (seq == -1) {
@@ -1030,4 +1271,51 @@
       break;
 
+    case GSTAR_WARP_MAG_APER_CHISQ: /* average ap mags */
+      if (seq == -1) {
+	print_double_exp (NAN);
+      } else {
+	print_double_exp (secfilt[seq].sFapWrp);
+      }
+      break;
+
+    case GSTAR_WARP_NWARP: /* Nused */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].Nwarp);
+      }
+      break;
+
+    case GSTAR_WARP_NWARP_GOOD: /* Nused */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].NwarpGood);
+      }
+      break;
+
+    case GSTAR_WARP_NWARP_USED_PSF: /* Nused */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].NusedWrp);
+      }
+      break;
+
+    case GSTAR_WARP_NWARP_USED_KRON: /* Nused */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].NusedKronWrp);
+      }
+      break;
+
+    case GSTAR_WARP_NWARP_USED_AP: /* Nused */
+      if (seq == -1) {
+	gprint (GP_LOG, "%10d ", 0);
+      } else {
+	gprint (GP_LOG, "%10d ", secfilt[seq].NusedApWrp);
+      }
+      break;
   }
 }
Index: /trunk/Ohana/src/opihi/pantasks/examples/rsync.sh
===================================================================
--- /trunk/Ohana/src/opihi/pantasks/examples/rsync.sh	(revision 38463)
+++ /trunk/Ohana/src/opihi/pantasks/examples/rsync.sh	(revision 38463)
@@ -0,0 +1,194 @@
+# -- sh-mode -- 
+
+# this pantasks script generates jobs in a sequence of stages.  as all
+# jobs for a given stage complete, the jobs in the next stage are
+# launched.  load the script and start pantasks running.  no jobs will
+# execute until the user runs the 'mkhosts' command (this can only be
+# run after the initialization stage is run)
+
+# we have 1 initial data source and we want to rsync out to a large number.  this seems like a good use of a binary tree.  
+
+$srcdir = /local/ipp/psconfig
+
+$test = 0
+
+$delete = 
+# $delete = --delete
+# set backup to 0 to restore on original machine, use $delete to only keep current
+
+if not($?Ntarget) set Ntarget = 0
+if not($?stage)   set stage = -1
+if not($?Nsrc)    set Nsrc = 0
+if not($?Ndone)   set Ndone = 0
+
+if not($?LOGDIR) 
+  $today = `date +%Y%m%d`
+  $LOGDIR = logs.$today
+end
+
+mkdir $LOGDIR
+
+macro mktargets
+  local i N
+
+  $target:0 = ippc12
+  $N = 1
+  for i 1 64
+    if ($i == 12) continue
+    if ($i ==  6) continue
+    sprintf target:$N ippc%02d $i
+    $N ++
+  end  
+
+  for i 1 104
+    if ($i == 71) continue
+    if ($i == 37) continue
+    if ($i == 38) continue
+    if ($i == 39) continue
+    if ($i == 40) continue
+    if ($i == 41) continue
+    if ($i == 42) continue
+    if ($i == 43) continue
+    if ($i == 44) continue
+    sprintf target:$N ippx%03d $i
+    $N ++
+  end  
+  $target:n = $N
+end
+
+macro show.targets
+  for i 0 $target:n
+    echo $target:$i
+  end  
+end
+
+# just make all connections so we can run 
+macro mkhosts
+ for i 0 $target:n
+   control host add $target:$i
+ end
+end
+
+# define the current hosts and targets
+macro next.stage
+  if ($0 != 1)
+    echo "USAGE: next.stage"
+    break
+  end
+
+  # for a given value of stage N, we are rsyncing target:0 through target:2^N-1 over to 2^N to 2^(N+1)-1 
+  # eg, stage 0 :  target:0 -> target:1
+  #     stage 1 :  target:0 -> target:2
+  #     stage 1 :  target:1 -> target:3
+
+  $stage ++
+
+  # each stage, we have 2^stage sources and targets
+  $Ntarget = 2^$stage
+  $Nsrc = 0
+  $Ndone = 0
+end
+
+# define the current hosts and targets
+macro set.stage
+  if ($0 != 2)
+    echo "USAGE: set.stage (stage)"
+    break
+  end
+
+  # for a given value of stage N, we are rsyncing target:0 through target:2^N-1 over to 2^N to 2^(N+1)-1 
+  # eg, stage 0 :  target:0 -> target:1
+  #     stage 1 :  target:0 -> target:2
+  #     stage 1 :  target:1 -> target:3
+
+  $stage = $1
+
+  # each stage, we have 2^stage sources and targets
+  $Ntarget = 2^$stage
+  $Nsrc = 0
+  $Ndone = 0
+end
+
+macro show.stage
+  echo "stage: $stage"
+  echo "Ntarget: $Ntarget"  
+  echo "Nsrc: $Nsrc"
+  echo "Ndone: $Ndone"
+end
+
+task mkjobs
+  periods -poll 0.5
+  periods -timeout 10
+  host none
+
+  task.exec 
+    periods -exec 0.2
+
+    if (not($?target:n)) 
+      periods -exec 5.0
+      break
+    end
+
+    if ($Nsrc >= $Ntarget) 
+      periods -exec 5.0
+      break
+    end
+
+    $Ntgt = $Ntarget + $Nsrc
+
+    if ($Ntgt >= $target:n) 
+      periods -exec 5.0
+      break
+    end
+
+    $src = $target:$Nsrc
+    $tgt = $target:$Ntgt
+
+    host -required $tgt
+
+    stdout $LOGDIR/$tgt.log
+    stderr $LOGDIR/$tgt.log
+
+    $run = rsync --bwlimit=3000 -auv $src\:$srcdir/ $srcdir/
+
+    if ($test)
+      command echo $run
+    else
+      command $run
+    end
+
+    $Nsrc ++
+  end
+
+  task.exit default
+    $Ndone ++
+  end
+end
+
+task advance.stage
+  periods -poll 1.0
+  periods -exec 1.0
+  periods -timeout 10
+  host local
+
+  task.exec 
+    if not($?target:n) 
+      mktargets
+    end
+
+    if ($Ndone >= $Ntarget)
+      echo "done with stage $stage, advancing to next stage"
+      next.stage
+      if ($stage == 0)
+        echo "type 'mkhosts' to start processing'"
+      end
+      periods -exec 5.0
+      break
+    end      
+
+    periods -exec 1.0
+    break    
+
+    command echo advance stage should not actually execute...
+  end
+end