Index: /branches/eam_branches/ipp-20140717/Ohana/src/opihi/dvo/gstar.c
===================================================================
--- /branches/eam_branches/ipp-20140717/Ohana/src/opihi/dvo/gstar.c	(revision 37110)
+++ /branches/eam_branches/ipp-20140717/Ohana/src/opihi/dvo/gstar.c	(revision 37111)
@@ -23,4 +23,24 @@
   GSTAR_STACK_FLUX_KRON,
   GSTAR_STACK_FLUX_KRON_ERR,
+  GSTAR_STACK_FLUX_APER,
+  GSTAR_STACK_FLUX_APER_ERR,
+  GSTAR_WARP_FLUX_PSF,
+  GSTAR_WARP_FLUX_PSF_ERR,
+  GSTAR_WARP_FLUX_KRON,
+  GSTAR_WARP_FLUX_KRON_ERR,
+  GSTAR_WARP_FLUX_APER,
+  GSTAR_WARP_FLUX_APER_ERR,
+  GSTAR_STACK_MAG_PSF,
+  GSTAR_STACK_MAG_PSF_ERR,
+  GSTAR_STACK_MAG_KRON,
+  GSTAR_STACK_MAG_KRON_ERR,
+  GSTAR_STACK_MAG_APER,
+  GSTAR_STACK_MAG_APER_ERR,
+  GSTAR_WARP_MAG_PSF,
+  GSTAR_WARP_MAG_PSF_ERR,
+  GSTAR_WARP_MAG_KRON,
+  GSTAR_WARP_MAG_KRON_ERR,
+  GSTAR_WARP_MAG_APER,
+  GSTAR_WARP_MAG_APER_ERR,
 } GSTAR_SECF_CODES;
 
@@ -31,8 +51,8 @@
 void sort_index_float (float *X, int *IDX, int N) {
 
-# define SWAPFUNC(A,B){ float tmp; int itmp; 	\
-  tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
-  itmp = IDX[A]; IDX[A] = IDX[B]; IDX[B] = itmp; \
-}
+# define SWAPFUNC(A,B){ float tmp; int itmp;		\
+    tmp = X[A]; X[A] = X[B]; X[B] = tmp;		\
+    itmp = IDX[A]; IDX[A] = IDX[B]; IDX[B] = itmp;	\
+  }
 # define COMPARE(A,B)(X[A] < X[B])
 
@@ -52,5 +72,5 @@
   off_t i, Nstars, *N1;
   off_t j, k, m, N, Nlo, Nhi;
-  int Nsecfilt, NPTS, QUIET, FULL_OUTPUT, STACK_OUTPUT, INST, SHOW_MASKS;
+  int Nsecfilt, NPTS, QUIET, INST, SHOW_MASKS;
   int found, GetMeasures;
   int SaveVectors;
@@ -109,5 +129,5 @@
   }
 
-  FULL_OUTPUT = FALSE;
+  int FULL_OUTPUT = FALSE;
   if ((N = get_argument (argc, argv, "-full"))) {
     FULL_OUTPUT = TRUE;
@@ -115,7 +135,43 @@
   }
 
-  STACK_OUTPUT = FALSE;
-  if ((N = get_argument (argc, argv, "-stack"))) {
+  int STACK_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+stack"))) {
     STACK_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+
+  int EXTRA_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+extras"))) {
+    EXTRA_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+
+  int WARP_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+warp"))) {
+    WARP_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+
+  int FLUX_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+flux"))) {
+    FLUX_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+
+  int MAG_OUTPUT = TRUE;
+  if ((N = get_argument (argc, argv, "-mag"))) {
+    MAG_OUTPUT = FALSE;
+    remove_argument (N, &argc, argv);
+  }
+
+  int KRON_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+kron"))) {
+    KRON_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+
+  int APER_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+aper"))) {
+    APER_OUTPUT = TRUE;
     remove_argument (N, &argc, argv);
   }
@@ -185,6 +241,6 @@
   // an error exit status here is a significant error
   if (!dvo_catalog_open (&catalog, NULL, FALSE, "r")) {
-      fprintf (stderr, "ERROR: failure to open catalog file %s\n", catalog.filename);
-      exit (2);
+    fprintf (stderr, "ERROR: failure to open catalog file %s\n", catalog.filename);
+    exit (2);
   }
   dvo_catalog_unlock (&catalog);
@@ -259,88 +315,228 @@
 	
 	if (FULL_OUTPUT) {
-	    gprint (GP_LOG, "%f ",     catalog.average[k].dR);
-	    gprint (GP_LOG, "%f ",     catalog.average[k].dD);
-	    gprint (GP_LOG, "%f ",     catalog.average[k].uR);
-	    gprint (GP_LOG, "%f ",     catalog.average[k].uD);
-	    gprint (GP_LOG, "%f ",     catalog.average[k].duR);
-	    gprint (GP_LOG, "%f ",     catalog.average[k].duD);
-	    gprint (GP_LOG, "%f ",     catalog.average[k].P);
-	    gprint (GP_LOG, "%f   ",     catalog.average[k].dP);
-
-	    gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPM);
-	    gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPar);
-
-	    date = ohana_sec_to_date (catalog.average[k].Tmean);
-	    gprint (GP_LOG, "%20s ",     date);
-	    gprint (GP_LOG, "%f   ",     catalog.average[k].Trange / 86400.0);
+	  gprint (GP_LOG, "%f ",     catalog.average[k].dR);
+	  gprint (GP_LOG, "%f ",     catalog.average[k].dD);
+	  gprint (GP_LOG, "%f ",     catalog.average[k].uR);
+	  gprint (GP_LOG, "%f ",     catalog.average[k].uD);
+	  gprint (GP_LOG, "%f ",     catalog.average[k].duR);
+	  gprint (GP_LOG, "%f ",     catalog.average[k].duD);
+	  gprint (GP_LOG, "%f ",     catalog.average[k].P);
+	  gprint (GP_LOG, "%f   ",     catalog.average[k].dP);
+
+	  gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPM);
+	  gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPar);
+
+	  date = ohana_sec_to_date (catalog.average[k].Tmean);
+	  gprint (GP_LOG, "%20s ",     date);
+	  gprint (GP_LOG, "%f   ",     catalog.average[k].Trange / 86400.0);
 	}
 
-	gprint (GP_LOG, "\n");
+	gprint (GP_LOG, "\n\n");
       
 	/* filter names */
+	gprint (GP_LOG, "filter     : ");
 	for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_FILTER_NAMES);
 	gprint (GP_LOG, "\n");
 
 	/* average mags */
+	gprint (GP_LOG, "chp_psf_ave: ");
 	for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG);
 	gprint (GP_LOG, "\n");
 
 	/* average mag errors */
+	gprint (GP_LOG, "chp_psf_err: ");
 	for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_ERR);
 	gprint (GP_LOG, "\n");
 
 	/* average mag chisq */
+	gprint (GP_LOG, "chp_psf_chi: ");
 	for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_CHISQ);
 	gprint (GP_LOG, "\n");
 
-	if (FULL_OUTPUT) {
+	
+	if (APER_OUTPUT) {
 	  /* Map */
+	  gprint (GP_LOG, "chp_ap__ave: ");
 	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_AP_MAG);
 	  gprint (GP_LOG, "\n");
-
+	}
+
+	if (KRON_OUTPUT) {
 	  /* Mkron */
+	  gprint (GP_LOG, "chp_krn_ave: ");
 	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_KRON_MAG);
 	  gprint (GP_LOG, "\n");
 
 	  /* dMkron */
+	  gprint (GP_LOG, "chp_krn_err: ");
 	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_KRON_MAG_ERR);
 	  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) {
+	if (STACK_OUTPUT && MAG_OUTPUT) {
 	  /* FluxPSF */
+	  gprint (GP_LOG, "stk_psf_ave: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_PSF);
+	  gprint (GP_LOG, "\n");
+  
+	  /* dFluxPSF */
+	  gprint (GP_LOG, "stk_psf_err: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_PSF_ERR);
+	  gprint (GP_LOG, "\n");
+  
+	  if (KRON_OUTPUT) {
+	    /* MagKron */
+	    gprint (GP_LOG, "stk_krn_ave: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_KRON);
+	    gprint (GP_LOG, "\n");
+  
+	    /* dMagKron */
+	    gprint (GP_LOG, "stk_krn_err: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_KRON_ERR);
+	    gprint (GP_LOG, "\n");
+	  }
+
+	  if (APER_OUTPUT) {
+	    /* MagAper */
+	    gprint (GP_LOG, "stk_ap__ave: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_APER);
+	    gprint (GP_LOG, "\n");
+  
+	    /* dMagAper */
+	    gprint (GP_LOG, "stk_ap__err: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_APER_ERR);
+	    gprint (GP_LOG, "\n");
+	  }
+	}
+	if (WARP_OUTPUT && MAG_OUTPUT) {
+	  /* FluxPSF */
+	  gprint (GP_LOG, "wrp_psf_ave: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_PSF);
+	  gprint (GP_LOG, "\n");
+  
+	  /* dFluxPSF */
+	  gprint (GP_LOG, "wrp_psf_err: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_PSF_ERR);
+	  gprint (GP_LOG, "\n");
+  
+	  if (KRON_OUTPUT) {
+	    /* MagKron */
+	    gprint (GP_LOG, "wrp_krn_ave: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_KRON);
+	    gprint (GP_LOG, "\n");
+  
+	    /* dMagKron */
+	    gprint (GP_LOG, "wrp_krn_err: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_KRON_ERR);
+	    gprint (GP_LOG, "\n");
+
+	  }
+
+	  if (APER_OUTPUT) {
+	    /* MagAper */
+	    gprint (GP_LOG, "wrp_ap__ave: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_APER);
+	    gprint (GP_LOG, "\n");
+  
+	    /* dMagAper */
+	    gprint (GP_LOG, "wrp_ap__err: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_APER_ERR);
+	    gprint (GP_LOG, "\n");
+	  }
+	}
+	if (STACK_OUTPUT && FLUX_OUTPUT) {
+	  /* FluxPSF */
+	  gprint (GP_LOG, "stk_psf_ave: ");
 	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_PSF);
 	  gprint (GP_LOG, "\n");
-
+  
 	  /* dFluxPSF */
+	  gprint (GP_LOG, "stk_psf_err: ");
 	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_PSF_ERR);
 	  gprint (GP_LOG, "\n");
-
-	  /* FluxKron */
-	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON);
-	  gprint (GP_LOG, "\n");
-
-	  /* dFluxKron */
-	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON_ERR);
-	  gprint (GP_LOG, "\n");
-
+  
+	  if (KRON_OUTPUT) {
+	    /* FluxKron */
+	    gprint (GP_LOG, "stk_krn_ave: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON);
+	    gprint (GP_LOG, "\n");
+  
+	    /* dFluxKron */
+	    gprint (GP_LOG, "stk_krn_err: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON_ERR);
+	    gprint (GP_LOG, "\n");
+	  }
+
+	  if (APER_OUTPUT) {
+	    /* FluxAper */
+	    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: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_APER_ERR);
+	    gprint (GP_LOG, "\n");
+	  }
 	}
-      }
+	if (WARP_OUTPUT && FLUX_OUTPUT) {
+	  /* FluxPSF */
+	  gprint (GP_LOG, "wrp_psf_ave: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_PSF);
+	  gprint (GP_LOG, "\n");
+  
+	  /* dFluxPSF */
+	  gprint (GP_LOG, "wrp_psf_ave: ");
+	  for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_PSF_ERR);
+	  gprint (GP_LOG, "\n");
+  
+	  if (KRON_OUTPUT) {
+	    /* FluxKron */
+	    gprint (GP_LOG, "wrp_krn_ave: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_KRON);
+	    gprint (GP_LOG, "\n");
+  
+	    /* dFluxKron */
+	    gprint (GP_LOG, "wrp_krn_err: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_KRON_ERR);
+	    gprint (GP_LOG, "\n");
+	  }
+
+	  if (APER_OUTPUT) {
+	    /* FluxAper */
+	    gprint (GP_LOG, "wrp_ap__ave: ");
+	    for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_APER);
+	    gprint (GP_LOG, "\n");
+  
+	    /* dFluxAper */
+	    gprint (GP_LOG, "wrp_ap__err: ");
+	    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, "\n");
+      
       if (GetMeasures || SaveVectors) {
 
@@ -413,31 +609,31 @@
 
 	    if (FULL_OUTPUT) {
-		gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mcal);
-		gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Map);
-		gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mkron);
-		gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].dMkron);
-		gprint (GP_LOG, "%5.1f ", pow(10.0, 0.4*catalog.measure[Nv].dt));
-		gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].airmass);
-		gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].az);
-		gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Xccd);
-		gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Yccd);
-		gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dXccd));
-		gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dYccd));
-		gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Sky);
-		gprint (GP_LOG, "%5.1f ", catalog.measure[Nv].dSky);
-		gprint (GP_LOG, "%8d ", catalog.measure[Nv].averef);
-		gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].detID);
-		gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].imageID);
-		gprint (GP_LOG, "%.3f ", catalog.measure[Nv].psfQF);
-		gprint (GP_LOG, "%.1f ", catalog.measure[Nv].psfChisq);
-		gprint (GP_LOG, "%.1f ", catalog.measure[Nv].crNsigma);
-		gprint (GP_LOG, "%.1f ", catalog.measure[Nv].extNsigma);
-		gprint (GP_LOG, "%.1f ", FromShortDegrees(catalog.measure[Nv].theta));
+	      gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mcal);
+	      gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Map);
+	      gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mkron);
+	      gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].dMkron);
+	      gprint (GP_LOG, "%5.1f ", pow(10.0, 0.4*catalog.measure[Nv].dt));
+	      gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].airmass);
+	      gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].az);
+	      gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Xccd);
+	      gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Yccd);
+	      gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dXccd));
+	      gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dYccd));
+	      gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Sky);
+	      gprint (GP_LOG, "%5.1f ", catalog.measure[Nv].dSky);
+	      gprint (GP_LOG, "%8d ", catalog.measure[Nv].averef);
+	      gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].detID);
+	      gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].imageID);
+	      gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].psfQF);
+	      gprint (GP_LOG, "%7.1f ", catalog.measure[Nv].psfChisq);
+	      gprint (GP_LOG, "%3.1f ", catalog.measure[Nv].crNsigma);
+	      gprint (GP_LOG, "%4.1f ", catalog.measure[Nv].extNsigma);
+	      gprint (GP_LOG, "%5.1f ", FromShortDegrees(catalog.measure[Nv].theta));
 	    }
-	    if (STACK_OUTPUT) {
-		gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxPSF);
-		gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxPSF);
-		gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxKron);
-		gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxKron);
+	    if (FLUX_OUTPUT) {
+	      gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxPSF);
+	      gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxPSF);
+	      gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxKron);
+	      gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxKron);
 	    }
 	    gprint (GP_LOG, "\n");
@@ -547,17 +743,17 @@
 
   switch (type) {
-    case GSTAR_AVE_MAG: /* average mags */
-      if (seq == -1) {
-	print_double (NAN);
-      } else {
-	print_double (secfilt[seq].M);
-      }
-      break;
-
-    case GSTAR_AVE_MAG_ERR: /* average mags errors */
-      if (seq == -1) {
-	print_double (NAN);
-      } else {
-	print_double (secfilt[seq].dM);
+    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;
@@ -592,4 +788,22 @@
       break;
 
+      /*** CHIP : MAG ***/
+
+    case GSTAR_AVE_MAG: /* average mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].M);
+      }
+      break;
+
+    case GSTAR_AVE_MAG_ERR: /* average mags errors */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].dM);
+      }
+      break;
+
     case GSTAR_AVE_AP_MAG: /* average ap mags */
       if (seq == -1) {
@@ -600,20 +814,4 @@
       break;
 
-    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;
-
     case GSTAR_AVE_KRON_MAG: /* average ap mags */
       if (seq == -1) {
@@ -632,4 +830,6 @@
       break;
 
+      /******************* STACK : FLUX **********************/
+
     case GSTAR_STACK_FLUX_PSF: /* average ap mags */
       if (seq == -1) {
@@ -664,4 +864,170 @@
       break;
 
+    case GSTAR_STACK_FLUX_APER: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].FapStk);
+      }
+      break;
+
+    case GSTAR_STACK_FLUX_APER_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].dFapStk);
+      }
+      break;
+
+      /******************* STACK : MAG **********************/
+
+    case GSTAR_STACK_MAG_PSF: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].MpsfStk);
+      }
+      break;
+
+    case GSTAR_STACK_MAG_PSF_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].dFpsfStk / secfilt[seq].FpsfStk);
+      }
+      break;
+
+    case GSTAR_STACK_MAG_KRON: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].MkronStk);
+      }
+      break;
+
+    case GSTAR_STACK_MAG_KRON_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].dFkronStk / secfilt[seq].FkronStk);
+      }
+      break;
+
+    case GSTAR_STACK_MAG_APER: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].MapStk);
+      }
+      break;
+
+    case GSTAR_STACK_MAG_APER_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].dFapStk / secfilt[seq].FapStk);
+      }
+      break;
+
+      /******************* WARP : FLUX **********************/
+
+    case GSTAR_WARP_FLUX_PSF: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].FpsfWrp);
+      }
+      break;
+
+    case GSTAR_WARP_FLUX_PSF_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].dFpsfWrp);
+      }
+      break;
+
+    case GSTAR_WARP_FLUX_KRON: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].FkronWrp);
+      }
+      break;
+
+    case GSTAR_WARP_FLUX_KRON_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].dFkronWrp);
+      }
+      break;
+
+    case GSTAR_WARP_FLUX_APER: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].FapWrp);
+      }
+      break;
+
+    case GSTAR_WARP_FLUX_APER_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double_exp (secfilt[seq].dFapWrp);
+      }
+      break;
+
+      /******************* WARP : MAG **********************/
+
+    case GSTAR_WARP_MAG_PSF: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].MpsfWrp);
+      }
+      break;
+
+    case GSTAR_WARP_MAG_PSF_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].dFpsfWrp / secfilt[seq].FpsfWrp);
+      }
+      break;
+
+    case GSTAR_WARP_MAG_KRON: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].MkronWrp);
+      }
+      break;
+
+    case GSTAR_WARP_MAG_KRON_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].dFkronWrp / secfilt[seq].FkronWrp);
+      }
+      break;
+
+    case GSTAR_WARP_MAG_APER: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].MapWrp);
+      }
+      break;
+
+    case GSTAR_WARP_MAG_APER_ERR: /* average ap mags */
+      if (seq == -1) {
+	print_double (NAN);
+      } else {
+	print_double (secfilt[seq].dFapWrp / secfilt[seq].FapWrp);
+      }
+      break;
+
   }
 }