Index: /trunk/Ohana/src/libdvo/Makefile
===================================================================
--- /trunk/Ohana/src/libdvo/Makefile	(revision 37034)
+++ /trunk/Ohana/src/libdvo/Makefile	(revision 37035)
@@ -36,6 +36,10 @@
 $(DESTINC)/ps1_v3_defs.h \
 $(DESTINC)/ps1_v4_defs.h \
+$(DESTINC)/ps1_v5_defs.h \
 $(DESTINC)/ps1_ref_defs.h \
-$(DESTINC)/cmf-ps1-dv3.h
+$(DESTINC)/cmf-ps1-dv3.h \
+$(DESTINC)/cmf-ps1-v5.h \
+$(DESTINC)/cmf-ps1-sv3.h \
+$(DESTINC)/cmf-ps1-v5-lensing.h
 
 INCS = $(DEFS) $(DESTINC)/dvo.h $(DESTINC)/autocode.h $(DESTINC)/dvo_util.h $(DESTINC)/dvodb.h $(DESTINC)/libdvo_astro.h $(DESTINC)/convert.h $(DESTINC)/get_graphdata.h
@@ -76,4 +80,5 @@
 $(SRC)/dvo_convert_PS1_V3.$(ARCH).o \
 $(SRC)/dvo_convert_PS1_V4.$(ARCH).o \
+$(SRC)/dvo_convert_PS1_V5.$(ARCH).o \
 $(SRC)/dvo_convert_PS1_REF.$(ARCH).o \
 $(SRC)/flatcorr_io.$(ARCH).o    \
@@ -86,4 +91,7 @@
 $(SRC)/cmf-ps1-sv1-alt.$(ARCH).o \
 $(SRC)/cmf-ps1-dv3.$(ARCH).o \
+$(SRC)/cmf-ps1-sv3.$(ARCH).o \
+$(SRC)/cmf-ps1-v5.$(ARCH).o \
+$(SRC)/cmf-ps1-v5-lensing.$(ARCH).o \
 $(SRC)/dvo_util.$(ARCH).o \
 $(SRC)/dbBooleanCond.$(ARCH).o		\
Index: /trunk/Ohana/src/libdvo/doc/notes.ps1v5.txt
===================================================================
--- /trunk/Ohana/src/libdvo/doc/notes.ps1v5.txt	(revision 37035)
+++ /trunk/Ohana/src/libdvo/doc/notes.ps1v5.txt	(revision 37035)
@@ -0,0 +1,27 @@
+
+changes to make:
+
+Average: add: Rstk, Dstk, dRstk,dDstk, Nlensing, Nlensobj, lensingOffset, lensobjOffset, refColor
+Measure: mod: dR,dD -> R,D (change Measure_*_ToInteral to pass Average)
+      	 add: dMap, FluxAp, dFluxAp, (X,Y)off(KH,DCR,GAL)
+SecFilt: add: dMap, NusedKron, NusedAp, MpsfStk, MkronStk, MapStk, *Wrp
+      	 mod: Mstdev, M_20 (to Mmin,short:float),M_80 (to Mmax,short:float),
+         mod: FpsfStk, dFpsfStk, FkronStk, dFronStk (were FluxPSF, dFluxPSF, FluxKron, dFluxKron)
+
+name changes:
+Measure:
+dR,dD -> R,D (done)
+SecFilt
+    out[i].FpsfStk       = in[i].FluxPSF;
+    out[i].dFpsfStk      = in[i].dFluxPSF;
+    out[i].FkronStk      = in[i].FluxKron;
+    out[i].dFkronStk     = in[i].dFluxKron;
+    out[i].Mmin          = in[i].M_20*0.001;      
+    out[i].Mmax          = in[i].M_80*0.001;      
+
+    out[i].FluxPSF     	 = in[i].FpsfStk;
+    out[i].dFluxPSF    	 = in[i].dFpsfStk;
+    out[i].FluxKron    	 = in[i].FkronStk;
+    out[i].dFluxKron   	 = in[i].dFkronStk;
+    out[i].M_20        	 = in[i].Mmin*1000.0;      
+    out[i].M_80        	 = in[i].Mmax*1000.0;      
Index: /trunk/Ohana/src/libdvo/include/cmf-ps1-sv3.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/cmf-ps1-sv3.h	(revision 37035)
+++ /trunk/Ohana/src/libdvo/include/cmf-ps1-sv3.h	(revision 37035)
@@ -0,0 +1,66 @@
+
+/** STRUCT DEFINITION **/
+typedef struct {
+  unsigned int     detID;                // detection ID                     
+  float            X;                    // x coord (pixels)
+  float            Y;                    // y coord (pixels)
+  float            dX;                   // x coord error (pixels)
+  float            dY;                   // y coord error (pixels)
+  float            posangle;             // Posangle at source (degrees)
+  float            pltscale;             // Plate Scale at source (arcsec/pixel)
+  float            M;                    // inst mags (mags)
+  float            dM;                   // inst mag error (mags)
+  float            Flux;                 // psf flux (counts)
+  float            dFlux;                // psf flux error (counts      )
+  float            Map;                  // standard aperture mag (mags)
+  float            MapRaw;               // raw aperture mag (mags)
+  float            apRadius;             // radius used for fit (pixels)
+  float            apFlux;               // aperture flux (counts)
+  float            apFluxErr;            // error on ap flux (counts)
+  int              apNpix;               // pixels used for aper
+  float            Mcalib;               // calibrated psf mag (mags)
+  float            dMcal;                // zero point scatter (mags)
+  float            Mpeak;                // peak flux as a mag (mags)
+  double           RA;                   // PSF RA coord (degrees)
+  double           DEC;                  // PSF DEC coord (degrees)
+  float            sky;                  // sky flux (cnts/sec)
+  float            dSky;                 // sky flux error (cnts/sec)
+  float            psfChisq;             // psf fit chisq
+  float            crNsigma;             // Nsigma deviations from PSF to CF
+  float            extNsigma;            // Nsigma deviations from PSF to EXT
+  float            fx;                   // psf fit major axis (pixels)
+  float            fy;                   // psf fit minor axis (pixels)
+  float            df;                   // ellipse angle (degrees)
+  float            k;                    // extra PSF parameter (unitless)
+  float            fwhmMaj;              // true fwhm of psf (pixels)
+  float            fwhmMin;              // true fwhm (minor) (pixels)
+  float            psfQF;                // quality factor
+  float            psfQFperf;            // quality factor perfect
+  int              psfNdof;              // psf degrees of freedom
+  int              psfNpix;              // psf number of pixels
+  float            Mxx;                  // second moment X (pixels^2)
+  float            Mxy;                  // second moment Y (pixels^2)
+  float            Myy;                  // second moment XY (pixels^2)
+  float            M3c;                  // third moment cos(t) (pixels^3)
+  float            M3s;                  // third moment sin(t) (pixels^3)
+  float            M4c;                  // fourth moment cos(t) (pixels^4)
+  float            M4s;                  // fourth moment sin(t) (pixels^4)
+  float            Mr1;                  // first radial moment (pixels)
+  float            Mrh;                  // half radial moment (pixels^1/2)
+  float            kronFlux;             // kron flux (counts)
+  float            kronFluxErr;          // kron flux error (counts)
+  float            kronInner;            // kron flux 1<R<2.5 (counts)
+  float            kronOuter;            // kron flux 2.5<R<4 (counts)
+  int              flags;                // analysis flags
+  int              flags2;               // analysis flags (2)
+  short            nFrames;              // images overlapping peak
+  short            padding;              // padding for 8byte records
+  int              padding2;             // padding for 8byte records
+} CMF_PS1_SV3;
+
+CMF_PS1_SV3 *gfits_table_get_CMF_PS1_SV3 (FTable *table, off_t *Ndata, char *swapped);
+int      gfits_table_set_CMF_PS1_SV3 (FTable *ftable, CMF_PS1_SV3 *data, off_t Ndata);
+int      gfits_table_mkheader_CMF_PS1_SV3 (Header *header);
+unsigned char *gfits_convert_CMF_PS1_SV3 (unsigned char *data, off_t size, off_t nitems, char toStruct);
+int      Send_CMF_PS1_SV3 (int device, CMF_PS1_SV3 *data, int Ndata, int copy);
+int      Recv_CMF_PS1_SV3 (int device, CMF_PS1_SV3 **data, int *Ndata);
Index: /trunk/Ohana/src/libdvo/include/cmf-ps1-v5-lensing.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/cmf-ps1-v5-lensing.h	(revision 37035)
+++ /trunk/Ohana/src/libdvo/include/cmf-ps1-v5-lensing.h	(revision 37035)
@@ -0,0 +1,93 @@
+
+/** STRUCT DEFINITION **/
+typedef struct {
+  unsigned int     detID;                // detection ID                     
+  float            X;                    // x coord (pixels)
+  float            Y;                    // y coord (pixels)
+  float            dX;                   // x coord error (pixels)
+  float            dY;                   // y coord error (pixels)
+  float            posangle;             // Posangle at source (degrees)
+  float            pltscale;             // Plate Scale at source (arcsec/pixel)
+  float            M;                    // inst mags (mags)
+  float            dM;                   // inst mag error (mags)
+  float            Flux;                 // psf flux (counts)
+  float            dFlux;                // psf flux error (counts      )
+  float            Map;                  // standard aperture mag (mags)
+  float            MapRaw;               // raw aperture mag (mags)
+  float            apRadius;             // radius used for aper (pixels)
+  float            apFlux;               // aperture flux (counts)
+  float            apFluxErr;            // error on ap flux (counts)
+  int              apNpix;               // pixels used by aper (pixels)
+  float            Mcalib;               // calibrated psf mag (mags)
+  float            dMcal;                // zero point scatter (mags)
+  float            Mpeak;                // peak flux as a mag (mags)
+  double           RA;                   // PSF RA coord (degrees)
+  double           DEC;                  // PSF DEC coord (degrees)
+  float            sky;                  // sky flux (cnts/sec)
+  float            dSky;                 // sky flux error (cnts/sec)
+  float            psfChisq;             // psf fit chisq
+  float            crNsigma;             // Nsigma deviations from PSF to CF
+  float            extNsigma;            // Nsigma deviations from PSF to EXT
+  float            fx;                   // psf fit major axis (pixels)
+  float            fy;                   // psf fit minor axis (pixels)
+  float            df;                   // ellipse angle (degrees)
+  float            k;                    // extra PSF parameter (unitless)
+  float            fwhmMaj;              // true fwhm of psf (pixels)
+  float            fwhmMin;              // true fwhm (minor) (pixels)
+  float            psfQF;                // quality factor
+  float            psfQFperf;            // quality factor perfect
+  int              psfNdof;              // psf degrees of freedom
+  int              psfNpix;              // psf number of pixels
+  float            Mxx;                  // second moment X (pixels^2)
+  float            Mxy;                  // second moment Y (pixels^2)
+  float            Myy;                  // second moment XY (pixels^2)
+  float            M3c;                  // third moment cos(t) (pixels^3)
+  float            M3s;                  // third moment sin(t) (pixels^3)
+  float            M4c;                  // fourth moment cos(t) (pixels^4)
+  float            M4s;                  // fourth moment sin(t) (pixels^4)
+
+  float            X11_sm_obj;           // lensing smear
+  float            X12_sm_obj;           // lensing smear
+  float            X22_sm_obj;           // lensing smear
+  float            E1_sm_obj;            // lensing smear
+  float            E2_sm_obj;            // lensing smear
+
+  float            X11_sh_obj;           // lensing shear
+  float            X12_sh_obj;           // lensing shear
+  float            X22_sh_obj;           // lensing shear
+  float            E1_sh_obj;            // lensing shear
+  float            E2_sh_obj;            // lensing shear
+
+  float            X11_sm_psf;           // lensing smear
+  float            X12_sm_psf;           // lensing smear
+  float            X22_sm_psf;           // lensing smear
+  float            E1_sm_psf;            // lensing smear
+  float            E2_sm_psf;            // lensing smear
+
+  float            X11_sh_psf;           // lensing shear
+  float            X12_sh_psf;           // lensing shear
+  float            X22_sh_psf;           // lensing shear
+  float            E1_sh_psf;            // lensing shear
+  float            E2_sh_psf;            // lensing shear
+
+  float            Mr1;                  // first radial moment (pixels)
+  float            Mrh;                  // half radial moment (pixels^1/2)
+  float            kronFlux;             // kron flux (counts)
+  float            kronFluxErr;          // kron flux error (counts)
+  float            kronInner;            // kron flux 1<R<2.5 (counts)
+  float            kronOuter;            // kron flux 2.5<R<4 (counts)
+  float            skyLimitRad;          // profile to sky limit (radius)
+  float            skyLimitFlux;         // profile to sky limit (flux)
+  float            skyLimitSlope;        // profile to sky limit (slope)
+  int              flags;                // analysis flags
+  int              flags2;               // analysis flags (2)
+  short            nFrames;              // images overlapping peak
+  short            padding;              // padding for 8byte records
+} CMF_PS1_V5_Lensing;
+
+CMF_PS1_V5_Lensing *gfits_table_get_CMF_PS1_V5_Lensing (FTable *table, off_t *Ndata, char *swapped);
+int      gfits_table_set_CMF_PS1_V5_Lensing (FTable *ftable, CMF_PS1_V5_Lensing *data, off_t Ndata);
+int      gfits_table_mkheader_CMF_PS1_V5_Lensing (Header *header);
+int      gfits_convert_CMF_PS1_V5_Lensing (unsigned char *data, off_t size, off_t nitems, char toStruct);
+int      Send_CMF_PS1_V5_Lensing (int device, CMF_PS1_V5_Lensing *data, int Ndata, int copy);
+int      Recv_CMF_PS1_V5_Lensing (int device, CMF_PS1_V5_Lensing **data, int *Ndata);
Index: /trunk/Ohana/src/libdvo/include/cmf-ps1-v5.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/cmf-ps1-v5.h	(revision 37035)
+++ /trunk/Ohana/src/libdvo/include/cmf-ps1-v5.h	(revision 37035)
@@ -0,0 +1,68 @@
+
+/** STRUCT DEFINITION **/
+typedef struct {
+  unsigned int     detID;                // detection ID                     
+  float            X;                    // x coord (pixels)
+  float            Y;                    // y coord (pixels)
+  float            dX;                   // x coord error (pixels)
+  float            dY;                   // y coord error (pixels)
+  float            posangle;             // Posangle at source (degrees)
+  float            pltscale;             // Plate Scale at source (arcsec/pixel)
+  float            M;                    // inst mags (mags)
+  float            dM;                   // inst mag error (mags)
+  float            Flux;                 // psf flux (counts)
+  float            dFlux;                // psf flux error (counts      )
+  float            Map;                  // standard aperture mag (mags)
+  float            MapRaw;               // raw aperture mag (mags)
+  float            apRadius;             // radius used for aper (pixels)
+  float            apFlux;               // aperture flux (counts)
+  float            apFluxErr;            // error on ap flux (counts)
+  int              apNpix;               // pixels used by aper (pixels)
+  float            Mcalib;               // calibrated psf mag (mags)
+  float            dMcal;                // zero point scatter (mags)
+  float            Mpeak;                // peak flux as a mag (mags)
+  double           RA;                   // PSF RA coord (degrees)
+  double           DEC;                  // PSF DEC coord (degrees)
+  float            sky;                  // sky flux (cnts/sec)
+  float            dSky;                 // sky flux error (cnts/sec)
+  float            psfChisq;             // psf fit chisq
+  float            crNsigma;             // Nsigma deviations from PSF to CF
+  float            extNsigma;            // Nsigma deviations from PSF to EXT
+  float            fx;                   // psf fit major axis (pixels)
+  float            fy;                   // psf fit minor axis (pixels)
+  float            df;                   // ellipse angle (degrees)
+  float            k;                    // extra PSF parameter (unitless)
+  float            fwhmMaj;              // true fwhm of psf (pixels)
+  float            fwhmMin;              // true fwhm (minor) (pixels)
+  float            psfQF;                // quality factor
+  float            psfQFperf;            // quality factor perfect
+  int              psfNdof;              // psf degrees of freedom
+  int              psfNpix;              // psf number of pixels
+  float            Mxx;                  // second moment X (pixels^2)
+  float            Mxy;                  // second moment Y (pixels^2)
+  float            Myy;                  // second moment XY (pixels^2)
+  float            M3c;                  // third moment cos(t) (pixels^3)
+  float            M3s;                  // third moment sin(t) (pixels^3)
+  float            M4c;                  // fourth moment cos(t) (pixels^4)
+  float            M4s;                  // fourth moment sin(t) (pixels^4)
+  float            Mr1;                  // first radial moment (pixels)
+  float            Mrh;                  // half radial moment (pixels^1/2)
+  float            kronFlux;             // kron flux (counts)
+  float            kronFluxErr;          // kron flux error (counts)
+  float            kronInner;            // kron flux 1<R<2.5 (counts)
+  float            kronOuter;            // kron flux 2.5<R<4 (counts)
+  float            skyLimitRad;          // profile to sky limit (radius)
+  float            skyLimitFlux;         // profile to sky limit (flux)
+  float            skyLimitSlope;        // profile to sky limit (slope)
+  int              flags;                // analysis flags
+  int              flags2;               // analysis flags (2)
+  short            nFrames;              // images overlapping peak
+  short            padding;              // padding for 8byte records
+} CMF_PS1_V5;
+
+CMF_PS1_V5 *gfits_table_get_CMF_PS1_V5 (FTable *table, off_t *Ndata, char *swapped);
+int      gfits_table_set_CMF_PS1_V5 (FTable *ftable, CMF_PS1_V5 *data, off_t Ndata);
+int      gfits_table_mkheader_CMF_PS1_V5 (Header *header);
+int      gfits_convert_CMF_PS1_V5 (unsigned char *data, off_t size, off_t nitems, char toStruct);
+int      Send_CMF_PS1_V5 (int device, CMF_PS1_V5 *data, int Ndata, int copy);
+int      Recv_CMF_PS1_V5 (int device, CMF_PS1_V5 **data, int *Ndata);
Index: /trunk/Ohana/src/libdvo/include/dvo.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/dvo.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/dvo.h	(revision 37035)
@@ -28,4 +28,5 @@
   DVO_FORMAT_PS1_V3,
   DVO_FORMAT_PS1_V4,
+  DVO_FORMAT_PS1_V5,
 } DVOTableFormat;
 
@@ -78,15 +79,17 @@
 
 /* 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 */
@@ -334,4 +337,7 @@
 // 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 {
@@ -434,6 +440,6 @@
 // a reduced-subset structure for relphot & relastro
 typedef struct {
-  float          dR;
-  float          dD;
+  double         R;
+  double         D;
   float          M;
   float          Mcal;
@@ -548,5 +554,8 @@
 
 Measure_PS1_V4alt *gfits_table_get_Measure_PS1_V4alt (FTable *table, off_t *Ndata, char *swapped);
-Measure *Measure_PS1_V4alt_ToInternal (Measure_PS1_V4alt *in, off_t Nvalues);
+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 */
@@ -562,8 +571,12 @@
   SecFilt *secfilt;
 
+  // lensing data (optional?)
+  Lensing *lensing;
+  Lensobj *lensobj;
+
   int Nsecfilt;  /* number of secfilt entries for each average entry */
-  off_t Naverage,   Nmeasure,   Nmissing,   Nsecf_mem;  /* current number of each component in memory */
-  off_t Naves_disk, Nmeas_disk, Nmiss_disk, Nsecf_disk; /* current number of each component on disk */
-  off_t Naves_off,  Nmeas_off,  Nmiss_off,  Nsecf_off;  /* index of first loaded data value */
+  off_t Naverage,   Nmeasure,   Nmissing,   Nlensing,      Nlensobj,      Nsecf_mem;  /* current number of each component in memory */
+  off_t Naves_disk, Nmeas_disk, Nmiss_disk, Nlensing_disk, Nlensobj_disk, Nsecf_disk; /* current number of each component on disk */
+  off_t Naves_off,  Nmeas_off,  Nmiss_off,  Nlensing_off,  Nlensobj_off,  Nsecf_off;  /* index of first loaded data value */
 
   // note that we use these for the full-sky relphot analysis
@@ -584,4 +597,6 @@
   struct Catalog *missing_catalog;		/* missing catalog data (split) */
   struct Catalog *secfilt_catalog;		/* secfilt catalog data (split) */
+  struct Catalog *lensing_catalog;		/* lensing catalog data (split) */
+  struct Catalog *lensobj_catalog;		/* lensobj catalog data (split) */
 
   unsigned int objID;
@@ -592,14 +607,16 @@
   char catmode;				/* storage mode (raw, mef, split, mysql) */
   char catformat;			/* storage format (elixir, panstarrs, etc) */
-  char catflags;				/* choices to be loaded */
-  char sorted;				/* is measure table average-sorted? */
+  int sorted;				/* is measure table average-sorted? (NOTE this is an int only because gfits_scan %t requires it) */
   
+  short catflags; /* choices to be loaded */
+
   /* pointers for data manipulation */
-  off_t *found;
-  off_t *image;
-  off_t *mosaic;
-  float *X;
-  float *Y;
-  int   *nOwn; // relastro uses this to count owned detections per object
+  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;
@@ -661,41 +678,43 @@
 char     *GetPhotcodeNamebyCode (int code);
 
-float PhotInst (Measure *measure);
-float PhotCat (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 PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
-
-float PhotAperInst (Measure *measure);
-float PhotAperCat (Measure *measure);
-float PhotAperSys (Measure *measure, Average *average, SecFilt *secfilt);
-float PhotAperRel (Measure *measure, Average *average, SecFilt *secfilt);
-float PhotAperCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
-float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt);
-float PhotAperRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
-
-float PhotKronInst (Measure *measure);
-float PhotKronCat (Measure *measure);
-float PhotKronSys (Measure *measure, Average *average, SecFilt *secfilt);
-float PhotKronRel (Measure *measure, Average *average, SecFilt *secfilt);
-float PhotKronCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
-float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt);
-float PhotKronRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
-float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
+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 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);
@@ -704,12 +723,4 @@
 int PhotColor (Average *average, SecFilt *secfilt, Measure *measure, int c1, int c2, double *color);
 
-float PhotInstTiny (MeasureTiny *measure);
-float PhotCatTiny (MeasureTiny *measure);
-float PhotAperTiny (MeasureTiny *measure);
-float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt);
-float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt);
-float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code);
-float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt);
-float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure);
 float PhotXmTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt);
 float PhotdMTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt);
@@ -782,8 +793,8 @@
 /*** conversion functions / I/O conversions ***/
 Average *ReadRawAverage (FILE *f, off_t Naverage, char format, SecFilt **primary);
-Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format);
+Measure *ReadRawMeasure (FILE *f, Average *average, off_t Nmeasure, char format);
 SecFilt *ReadRawSecFilt (FILE *f, off_t Nsecfilt, char format);
 int WriteRawAverage (FILE *f, Average *average, off_t Naverage, char format, SecFilt *primary);
-int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format);
+int WriteRawMeasure (FILE *f, Average *average, Measure *measure, off_t Nmeasure, char format);
 int WriteRawSecFilt (FILE *f, SecFilt *secfilt, off_t Nsecfilt, char format);
 
@@ -791,11 +802,15 @@
 
 Average *FtableToAverage (FTable *ftable, off_t *Naverage, char *format, SecFilt **primary);
-Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format);
+Measure *FtableToMeasure (FTable *ftable, Average *average, off_t *Nmeasure, char *format);
 SecFilt *FtableToSecFilt (FTable *ftable, off_t *Nsecfilt, char *format);
+Lensing *FtableToLensing (FTable *ftable, off_t *Nlensing, char *format);
+Lensobj *FtableToLensobj (FTable *ftable, off_t *Nlensobj, char *format);
 int      FtableToImage   (FTable *ftable, Header *theader, char *format);
 
 int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, char format, SecFilt *primary);
-int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format);
+int MeasureToFtable (FTable *ftable, Average *average, Measure *measure, off_t Nmeasure, char format);
 int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, char format);
+int LensingToFtable (FTable *ftable, Lensing *lensing, off_t Nlensing, char format);
+int LensobjToFtable (FTable *ftable, Lensobj *lensobj, off_t Nlensobj, char format);
 int ImageToFtable (FTable *ftable, Header *theader, char format);
 int ImageToVtable (VTable *vtable, Header *theader, char format);
@@ -812,4 +827,5 @@
 # include "ps1_v3_defs.h"
 # include "ps1_v4_defs.h"
+# include "ps1_v5_defs.h"
 # include "ps1_ref_defs.h"
 
@@ -906,4 +922,9 @@
 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_averageT_init (AverageTiny *average);
@@ -911,4 +932,7 @@
 void dvo_measure_init (Measure *measure);
 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);
Index: /trunk/Ohana/src/libdvo/include/dvodb.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/dvodb.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/dvodb.h	(revision 37035)
@@ -22,62 +22,46 @@
 
 /* magnitude types */
-enum {MAG_NONE, 
-
-      // these magnitude types are from the measurement table (or derived therein)
-      // the following imply PSF magnitudes:
-      MAG_INST, // -2.5*log(DN) [ie, not DN/sec]
-      MAG_CAT,  // MAG_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
-      MAG_SYS,  // MAG_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
-      MAG_REL,  // MAG_SYS - Mcal [specific zero point for image]
-      MAG_CAL,  // MAG_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
-      MAG_ERR,  // error on PSF MAG
-
-      // the following imply APERTURE magnitudes:
-      MAG_APER_INST, // -2.5*log(DN) [ie, not DN/sec]
-      MAG_APER_CAT,  // MAG_APER_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
-      MAG_APER_SYS,  // MAG_APER_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
-      MAG_APER_REL,  // MAG_APER_SYS - Mcal [specific zero point for image]
-      MAG_APER_CAL,  // MAG_APER_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
-      MAG_APER_ERR,  // error on APER MAG (if known, else psf error)
-      MAG_APER,      // in mextract -> MAG_APER_REL, in avextract -> MAG_APER_AVE
-
-      // the following imply KRON magnitudes:
-      MAG_KRON_INST, // -2.5*log(DN) [ie, not DN/sec]
-      MAG_KRON_CAT,  // MAG_KRON_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
-      MAG_KRON_SYS,  // MAG_KRON_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
-      MAG_KRON_REL,  // MAG_KRON_SYS - Mcal [specific zero point for image]
-      MAG_KRON_CAL,  // MAG_KRON_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
-      MAG_KRON_ERR,  // error on KRON MAG
-      MAG_KRON,      // in mextract -> MAG_KRON_REL, in avextract -> MAG_KRON_AVE
-
-      // these magnitude types are from the average (secfilt) table:
-      // the following imply PSF magnitudes (or fluxes)
-      MAG_AVE, 
-      MAG_REF, 
-      MAG_STDEV, 
-      MAG_AVE_ERR, 
-      MAG_CHISQ,
-      MAG_20, 
-      MAG_80, 
-      MAG_FLUX_PSF,
-      MAG_FLUX_PSF_ERR,
-
-      // the following imply APERTURE magnitudes:
-      MAG_APER_AVE,
-      MAG_APER_REF,
-
-      // the following imply KRON magnitudes or fluxes:
-      MAG_KRON_AVE,
-      MAG_KRON_REF,
-      MAG_FLUX_KRON,
-      MAG_FLUX_KRON_ERR,
-
-      // other secfilt fields of interest
-      MAG_PHOT_FLAGS, 
-      MAG_NCODE,
-      MAG_NPHOT,
-      MAG_UC_DIST, 
-      MAG_STACK_DET_ID, 
-};
+
+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 */
@@ -119,5 +103,5 @@
       MEAS_OBJ_FLAGS, 
       MEAS_SECFILT_FLAGS, 
-      MEAS_MAG, 
+      MEAS_PHOT, // photometry class of measurements
       MEAS_MINST, 
       MEAS_MCAT, 
@@ -173,11 +157,7 @@
       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,
 };
@@ -211,9 +191,4 @@
       AVE_NMISS, 
       AVE_NPOS, 
-      AVE_NPHOT, 
-      AVE_NCODE, 
-      AVE_MAG, 
-      AVE_dMAG, 
-      AVE_Xm, 
       AVE_OBJ_FLAGS, 
       AVE_TYPE, 
@@ -224,5 +199,12 @@
       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, 
@@ -312,5 +294,10 @@
   int table;
   int ID;
-  int magMode;
+
+  dvoMagSourceType magSource; // chip, (forced) warp, stack [only relevant for averages]
+  dvoMagLevelType magLevel;  // inst, cat, sys, rel, ave, ref, err, min, max, stdev, nphot, chisq, 
+  dvoMagOptionType magOption;  // psf, kron, aper
+  dvoMagClassType magClass;
+
   char type;
   PhotCode *photcode;
@@ -374,5 +361,5 @@
 
 int          GetMagMode             PROTO((char *string));
-PhotCode    *ParsePhotcodeField     PROTO((char *field, int *mode, int def));
+int          ParsePhotcodeField     PROTO((dbField *field, char *fieldName, int fieldID));
 int          ParseMeasureField      PROTO((dbField *field, char *fieldName));
 int          ParseAverageField      PROTO((dbField *field, char *fieldName));
Index: /trunk/Ohana/src/libdvo/include/elixir_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/elixir_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/elixir_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_Elixir_ToInternal (Average_Elixir *in, off_t Nvalues, SecFilt **primary);
 Average_Elixir 	        *AverageInternalTo_Elixir (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_Elixir_ToInternal (Measure_Elixir *in, off_t Nvalues);
-Measure_Elixir 	        *MeasureInternalTo_Elixir (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_Elixir_ToInternal (Average *ave, Measure_Elixir *in, off_t Nvalues);
+Measure_Elixir 	        *MeasureInternalTo_Elixir (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_Elixir_ToInternal (SecFilt_Elixir *in, off_t Nvalues);
 SecFilt_Elixir 	       	*SecFiltInternalTo_Elixir (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/loneos_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/loneos_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/loneos_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average                	*Average_Loneos_ToInternal (Average_Loneos *in, off_t Nvalues, SecFilt **primary);
 Average_Loneos 	        *AverageInternalTo_Loneos (Average *in, off_t Nvalues, SecFilt *primary);
-Measure                	*Measure_Loneos_ToInternal (Measure_Loneos *in, off_t Nvalues);
-Measure_Loneos 	        *MeasureInternalTo_Loneos (Measure *in, off_t Nvalues);
+Measure                	*Measure_Loneos_ToInternal (Average *ave, Measure_Loneos *in, off_t Nvalues);
+Measure_Loneos 	        *MeasureInternalTo_Loneos (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_Loneos_ToInternal (SecFilt_Loneos *in, off_t Nvalues);
 SecFilt_Loneos 	       	*SecFiltInternalTo_Loneos (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/panstarrs_dev_0_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/panstarrs_dev_0_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/panstarrs_dev_0_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_Panstarrs_DEV_0_ToInternal (Average_Panstarrs_DEV_0 *in, off_t Nvalues, SecFilt **primary);
 Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, off_t Nvalues);
-Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_Panstarrs_DEV_0_ToInternal (Average *ave, Measure_Panstarrs_DEV_0 *in, off_t Nvalues);
+Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_Panstarrs_DEV_0_ToInternal (SecFilt_Panstarrs_DEV_0 *in, off_t Nvalues);
 SecFilt_Panstarrs_DEV_0 *SecFiltInternalTo_Panstarrs_DEV_0 (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/panstarrs_dev_1_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/panstarrs_dev_1_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/panstarrs_dev_1_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_Panstarrs_DEV_1_ToInternal (Average_Panstarrs_DEV_1 *in, off_t Nvalues, SecFilt **primary);
 Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, off_t Nvalues);
-Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_Panstarrs_DEV_1_ToInternal (Average *ave, Measure_Panstarrs_DEV_1 *in, off_t Nvalues);
+Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_Panstarrs_DEV_1_ToInternal (SecFilt_Panstarrs_DEV_1 *in, off_t Nvalues);
 SecFilt_Panstarrs_DEV_1 *SecFiltInternalTo_Panstarrs_DEV_1 (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/ps1_dev_1_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/ps1_dev_1_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/ps1_dev_1_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_PS1_DEV_1_ToInternal (Average_PS1_DEV_1 *in, off_t Nvalues, SecFilt **primary);
 Average_PS1_DEV_1       *AverageInternalTo_PS1_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, off_t Nvalues);
-Measure_PS1_DEV_1       *MeasureInternalTo_PS1_DEV_1 (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_PS1_DEV_1_ToInternal (Average *ave, Measure_PS1_DEV_1 *in, off_t Nvalues);
+Measure_PS1_DEV_1       *MeasureInternalTo_PS1_DEV_1 (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_PS1_DEV_1_ToInternal (SecFilt_PS1_DEV_1 *in, off_t Nvalues);
 SecFilt_PS1_DEV_1       *SecFiltInternalTo_PS1_DEV_1 (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/ps1_dev_2_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/ps1_dev_2_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/ps1_dev_2_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_PS1_DEV_2_ToInternal (Average_PS1_DEV_2 *in, off_t Nvalues, SecFilt **primary);
 Average_PS1_DEV_2       *AverageInternalTo_PS1_DEV_2 (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, off_t Nvalues);
-Measure_PS1_DEV_2       *MeasureInternalTo_PS1_DEV_2 (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_PS1_DEV_2_ToInternal (Average *ave, Measure_PS1_DEV_2 *in, off_t Nvalues);
+Measure_PS1_DEV_2       *MeasureInternalTo_PS1_DEV_2 (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_PS1_DEV_2_ToInternal (SecFilt_PS1_DEV_2 *in, off_t Nvalues);
 SecFilt_PS1_DEV_2       *SecFiltInternalTo_PS1_DEV_2 (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/ps1_ref_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/ps1_ref_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/ps1_ref_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_PS1_REF_ToInternal (Average_PS1_REF *in, off_t Nvalues, SecFilt **primary);
 Average_PS1_REF          *AverageInternalTo_PS1_REF (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, off_t Nvalues);
-Measure_PS1_REF          *MeasureInternalTo_PS1_REF (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_PS1_REF_ToInternal (Average *ave, Measure_PS1_REF *in, off_t Nvalues);
+Measure_PS1_REF          *MeasureInternalTo_PS1_REF (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_PS1_REF_ToInternal (SecFilt_PS1_REF *in, off_t Nvalues);
 SecFilt_PS1_REF          *SecFiltInternalTo_PS1_REF (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/ps1_v1_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/ps1_v1_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/ps1_v1_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_PS1_V1_ToInternal (Average_PS1_V1 *in, off_t Nvalues, SecFilt **primary);
 Average_PS1_V1          *AverageInternalTo_PS1_V1 (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, off_t Nvalues);
-Measure_PS1_V1          *MeasureInternalTo_PS1_V1 (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_PS1_V1_ToInternal (Average *ave, Measure_PS1_V1 *in, off_t Nvalues);
+Measure_PS1_V1          *MeasureInternalTo_PS1_V1 (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_PS1_V1_ToInternal (SecFilt_PS1_V1 *in, off_t Nvalues);
 SecFilt_PS1_V1          *SecFiltInternalTo_PS1_V1 (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/ps1_v2_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/ps1_v2_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/ps1_v2_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_PS1_V2_ToInternal (Average_PS1_V2 *in, off_t Nvalues, SecFilt **primary);
 Average_PS1_V2          *AverageInternalTo_PS1_V2 (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_PS1_V2_ToInternal (Measure_PS1_V2 *in, off_t Nvalues);
-Measure_PS1_V2          *MeasureInternalTo_PS1_V2 (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_PS1_V2_ToInternal (Average *ave, Measure_PS1_V2 *in, off_t Nvalues);
+Measure_PS1_V2          *MeasureInternalTo_PS1_V2 (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_PS1_V2_ToInternal (SecFilt_PS1_V2 *in, off_t Nvalues);
 SecFilt_PS1_V2          *SecFiltInternalTo_PS1_V2 (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/ps1_v3_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/ps1_v3_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/ps1_v3_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_PS1_V3_ToInternal (Average_PS1_V3 *in, off_t Nvalues, SecFilt **primary);
 Average_PS1_V3          *AverageInternalTo_PS1_V3 (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_PS1_V3_ToInternal (Measure_PS1_V3 *in, off_t Nvalues);
-Measure_PS1_V3          *MeasureInternalTo_PS1_V3 (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_PS1_V3_ToInternal (Average *ave, Measure_PS1_V3 *in, off_t Nvalues);
+Measure_PS1_V3          *MeasureInternalTo_PS1_V3 (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_PS1_V3_ToInternal (SecFilt_PS1_V3 *in, off_t Nvalues);
 SecFilt_PS1_V3          *SecFiltInternalTo_PS1_V3 (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/ps1_v4_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/ps1_v4_defs.h	(revision 37034)
+++ /trunk/Ohana/src/libdvo/include/ps1_v4_defs.h	(revision 37035)
@@ -3,6 +3,6 @@
 Average 	       	*Average_PS1_V4_ToInternal (Average_PS1_V4 *in, off_t Nvalues, SecFilt **primary);
 Average_PS1_V4          *AverageInternalTo_PS1_V4 (Average *in, off_t Nvalues, SecFilt *primary);
-Measure 	       	*Measure_PS1_V4_ToInternal (Measure_PS1_V4 *in, off_t Nvalues);
-Measure_PS1_V4          *MeasureInternalTo_PS1_V4 (Measure *in, off_t Nvalues);
+Measure 	       	*Measure_PS1_V4_ToInternal (Average *ave, Measure_PS1_V4 *in, off_t Nvalues);
+Measure_PS1_V4          *MeasureInternalTo_PS1_V4 (Average *ave, Measure *in, off_t Nvalues);
 SecFilt 	       	*SecFilt_PS1_V4_ToInternal (SecFilt_PS1_V4 *in, off_t Nvalues);
 SecFilt_PS1_V4          *SecFiltInternalTo_PS1_V4 (SecFilt *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/include/ps1_v5_defs.h
===================================================================
--- /trunk/Ohana/src/libdvo/include/ps1_v5_defs.h	(revision 37035)
+++ /trunk/Ohana/src/libdvo/include/ps1_v5_defs.h	(revision 37035)
@@ -0,0 +1,16 @@
+Image 		       	*Image_PS1_V5_ToInternal (Image_PS1_V5 *in, off_t Nvalues, off_t Nalloc);
+Image_PS1_V5    	*ImageInternalTo_PS1_V5 (Image *in, off_t Nvalues);
+Average 	       	*Average_PS1_V5_ToInternal (Average_PS1_V5 *in, off_t Nvalues, SecFilt **primary);
+Average_PS1_V5          *AverageInternalTo_PS1_V5 (Average *in, off_t Nvalues, SecFilt *primary);
+Measure 	       	*Measure_PS1_V5_ToInternal (Average *ave, Measure_PS1_V5 *in, off_t Nvalues);
+Measure_PS1_V5          *MeasureInternalTo_PS1_V5 (Average *ave, Measure *in, off_t Nvalues);
+SecFilt 	       	*SecFilt_PS1_V5_ToInternal (SecFilt_PS1_V5 *in, off_t Nvalues);
+SecFilt_PS1_V5          *SecFiltInternalTo_PS1_V5 (SecFilt *in, off_t Nvalues);
+
+Lensing 	       	*Lensing_PS1_V5_ToInternal (Lensing_PS1_V5 *in, off_t Nvalues);
+Lensing_PS1_V5          *LensingInternalTo_PS1_V5 (Lensing *in, off_t Nvalues);
+Lensobj 	       	*Lensobj_PS1_V5_ToInternal (Lensobj_PS1_V5 *in, off_t Nvalues);
+Lensobj_PS1_V5          *LensobjInternalTo_PS1_V5 (Lensobj *in, off_t Nvalues);
+
+PhotCode                *PhotCode_PS1_V5_To_Internal (PhotCode_PS1_V5 *in, off_t Nvalues);
+PhotCode_PS1_V5         *PhotCode_Internal_To_PS1_V5 (PhotCode *in, off_t Nvalues);
Index: /trunk/Ohana/src/libdvo/src/ImageMetadata.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/ImageMetadata.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/ImageMetadata.c	(revision 37035)
@@ -124,14 +124,14 @@
   gfits_create_table_header (&theader, "BINTABLE", "IMAGE_SUBSET");
 
-  gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, 1.0*0x8000);
-  gfits_define_bintable_column (&theader, "J", "EXTERN_ID", "extern ID", NULL, 1.0, 1.0*0x8000);
-  gfits_define_bintable_column (&theader, "J", "EXPNAME_AS_INT", "expname as integer", NULL, 1.0, 1.0*0x8000);
-  gfits_define_bintable_column (&theader, "D", "CRVAL1", "ra at center", "degrees", 1.0, 0.0);
-  gfits_define_bintable_column (&theader, "D", "CRVAL2", "dec at center", "degrees", 1.0, 0.0);
-  gfits_define_bintable_column (&theader, "E", "THETA", "camera rot angle", "degrees", 1.0, 0.0);
-  gfits_define_bintable_column (&theader, "E", "MCAL", "zero point offset", "magnitudes", 1.0, 0.0);
-  gfits_define_bintable_column (&theader, "E", "SECZ", "airmass", "none", 1.0, 0.0);
-  gfits_define_bintable_column (&theader, "E", "X_CENTER", "chip center", "none", 1.0, 0.0);
-  gfits_define_bintable_column (&theader, "E", "Y_CENTER", "chip center", "none", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J", "IMAGE_ID", 	 "image ID",  	       NULL, 	     1.0, FT_BZERO_INT32);
+  gfits_define_bintable_column (&theader, "J", "EXTERN_ID",      "extern ID", 	       NULL, 	     1.0, FT_BZERO_INT32);
+  gfits_define_bintable_column (&theader, "J", "EXPNAME_AS_INT", "expname as integer", NULL, 	     1.0, FT_BZERO_INT32);
+  gfits_define_bintable_column (&theader, "D", "CRVAL1", 	 "ra at center",       "degrees",    1.0, 0.0);
+  gfits_define_bintable_column (&theader, "D", "CRVAL2", 	 "dec at center",      "degrees",    1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "THETA", 	 "camera rot angle",   "degrees",    1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "MCAL",  	 "zero point offset",  "magnitudes", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "SECZ",  	 "airmass",            "none", 	     1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "X_CENTER", 	 "chip center",        "none", 	     1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "Y_CENTER", 	 "chip center",        "none", 	     1.0, 0.0);
 
   // generate the output array that carries the data
Index: /trunk/Ohana/src/libdvo/src/LoadPhotcodesFITS.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/LoadPhotcodesFITS.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/LoadPhotcodesFITS.c	(revision 37035)
@@ -64,4 +64,5 @@
   CONVERT_FORMAT("DVO_PHOTCODE_PS1_V3",    PS1_V3);
   CONVERT_FORMAT("DVO_PHOTCODE_PS1_V4",    PS1_V4);
+  CONVERT_FORMAT("DVO_PHOTCODE_PS1_V5",    PS1_V5);
 
   table = GetPhotcodeTable ();
@@ -100,4 +101,15 @@
   // photcode.equiv of 0 means "undefined"
   for (i = 0; i < Ncode; i++) {
+    if (!strcasecmp(photcode[i].name, "MAG")) {
+      fprintf (stderr, "MAG is not an allowed photcode name (reserved to DVO internals)\n");
+      free (photcode);
+      return FALSE;
+    }
+    if (!strcasecmp(photcode[i].name, "FLUX")) {
+      fprintf (stderr, "FLUX is not an allowed photcode name (reserved to DVO internals)\n");
+      free (photcode);
+      return FALSE;
+    }
+
     if (photcode[i].type == PHOT_DEP) {
       if (photcode[i].equiv == 0) continue;
Index: /trunk/Ohana/src/libdvo/src/LoadPhotcodesText.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/LoadPhotcodesText.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/LoadPhotcodesText.c	(revision 37035)
@@ -108,4 +108,9 @@
     }
 
+    if (!strcasecmp(name, "MAG")) {
+      fprintf (stderr, "MAG is not an allowed photcode name (reserved to DVO internals)\n");
+      return FALSE;
+    }
+
     photcode[Ncode].type = 0;
     memset(photcode[Ncode].dummy, 0, sizeof(photcode[Ncode].dummy));
@@ -137,8 +142,8 @@
     photcode[Ncode].photomErrSys      = atof (photomErrSys);
 
-    photcode[Ncode].astromPoorMask    = strtol (astromPoorMask, NULL, 0);
-    photcode[Ncode].astromBadMask     = strtol (astromBadMask, NULL, 0);
-    photcode[Ncode].photomPoorMask    = strtol (photomPoorMask, NULL, 0);
-    photcode[Ncode].photomBadMask     = strtol (photomBadMask, NULL, 0);
+    photcode[Ncode].astromPoorMask    = strtoll (astromPoorMask, NULL, 0);
+    photcode[Ncode].astromBadMask     = strtoll (astromBadMask, NULL, 0);
+    photcode[Ncode].photomPoorMask    = strtoll (photomPoorMask, NULL, 0);
+    photcode[Ncode].photomBadMask     = strtoll (photomBadMask, NULL, 0);
 
     switch (photcode[Ncode].type) {
Index: /trunk/Ohana/src/libdvo/src/SavePhotcodesFITS.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/SavePhotcodesFITS.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/SavePhotcodesFITS.c	(revision 37035)
@@ -30,9 +30,9 @@
   // for the moment, we simply support the latest photcode format for output
   // XXX update this as needed as new formats are defined
-  PhotCode_PS1_V4 *photcode_output = PhotCode_Internal_To_PS1_V4 (table[0].code, table[0].Ncode);
+  PhotCode_PS1_V5 *photcode_output = PhotCode_Internal_To_PS1_V5 (table[0].code, table[0].Ncode);
 
   /* convert FITS format data to internal format (byteswaps & EXTNAME) */
   if (!gfits_db_create (&db)) return (FALSE);
-  if (!gfits_table_set_PhotCode_PS1_V4 (&db.ftable, photcode_output, table[0].Ncode)) return (FALSE);
+  if (!gfits_table_set_PhotCode_PS1_V5 (&db.ftable, photcode_output, table[0].Ncode)) return (FALSE);
   if (!gfits_db_save (&db)) return (FALSE);
   if (!gfits_db_close (&db)) return (FALSE);
Index: /trunk/Ohana/src/libdvo/src/cmf-ps1-dv3.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/cmf-ps1-dv3.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/cmf-ps1-dv3.c	(revision 37035)
@@ -2,5 +2,5 @@
 
 /*** note : this file is derived from the autocode version, but is modified because
-     the forma does not match with structure byte boundaries ***/
+     the format does not match with structure byte boundaries ***/
 
 /* if we are not correctly including the ohana headers, this will fail */
Index: /trunk/Ohana/src/libdvo/src/cmf-ps1-sv3.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/cmf-ps1-sv3.c	(revision 37035)
+++ /trunk/Ohana/src/libdvo/src/cmf-ps1-sv3.c	(revision 37035)
@@ -0,0 +1,374 @@
+# include "dvo.h"
+
+// ST_SIZE is the size of the structure (must be modulo 8 bytes)
+// FT_SIZE is the size of a row in the FITS table (inpt or output)
+# define ST_SIZE 224
+# define FT_SIZE 220
+
+// this function is based on the one generated by the autocode of cmf-ps1-v5.d
+unsigned char *gfits_convert_CMF_PS1_SV3 (unsigned char *input, off_t size, off_t nitems, char toStruct) {
+
+  off_t i;
+  unsigned char *byte, *output;
+
+  if (size != ST_SIZE) { 
+    fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_SV3: "OFF_T_FMT" vs %d\n",  size,  ST_SIZE);
+    return (NULL);
+  }
+
+  /* provide initial values to avoid compiler warnings for non-BYTE_SWAP arch */
+  i = 0;
+
+  // BYTE & WORD swap below is valid for the structure, not the FITS buffer
+  if (toStruct) {
+    // allocate a new output data buffer
+    ALLOCATE (output, unsigned char, nitems*sizeof(CMF_PS1_SV3));
+    unsigned char *inbyte = input;
+    unsigned char *otbyte = output;
+
+    // the data in the input table does not line up with the output structure: copy carefully.
+    for (i = 0; i < nitems; i++, inbyte += FT_SIZE, otbyte += ST_SIZE) {
+      memcpy (&otbyte[  0], &inbyte[  0],  76); // IPP_IDET to CAL_PSF_MAG_SIG
+      memcpy (&otbyte[ 80], &inbyte[ 76],  16); // RA_PSF, DEC_PSF
+      memcpy (&otbyte[ 76], &inbyte[ 92],   8); // PEAK_FLUX_AS_MAG
+      memcpy (&otbyte[ 96], &inbyte[ 96], 124); // SKY to PADDING
+      memset (&otbyte[220], 0, 4); // PADDING2
+    }
+
+    // after we have moved around PEAK_FLUX_AS_MAG, RA_PSF, DEC_PSF, we can swap as needed for this platform
+    byte = output;
+  } else {
+    byte = input;
+  }
+
+# ifdef BYTE_SWAP
+  char tmp = 0;
+  for (i = 0; i < nitems; i++, byte += ST_SIZE) {
+    /** BYTE SWAP **/
+    SWAP_WORD (0);   // IPP_IDET
+    SWAP_WORD (4);   // X_PSF
+    SWAP_WORD (8);   // Y_PSF
+    SWAP_WORD (12);  // X_PSF_SIG
+    SWAP_WORD (16);  // Y_PSF_SIG
+    SWAP_WORD (20);  // POSANGLE
+    SWAP_WORD (24);  // PLTSCALE
+    SWAP_WORD (28);  // PSF_INST_MAG
+    SWAP_WORD (32);  // PSF_INST_MAG_SIG
+    SWAP_WORD (36);  // PSF_INST_FLUX
+    SWAP_WORD (40);  // PSF_INST_FLUX_SIG
+    SWAP_WORD (44);  // AP_MAG
+    SWAP_WORD (48);  // AP_MAG_RAW
+    SWAP_WORD (52);  // AP_MAG_RADIUS
+    SWAP_WORD (56);  // AP_FLUX
+    SWAP_WORD (60);  // AP_FLUX_SIG
+    SWAP_WORD (64);  // AP_NPIX
+    SWAP_WORD (68);  // CAL_PSF_MAG
+    SWAP_WORD (72);  // CAL_PSF_MAG_SIG
+
+    // order in structure
+    SWAP_WORD (76);  // PEAK_FLUX_AS_MAG
+    SWAP_DBLE (80);  // RA_PSF
+    SWAP_DBLE (88);  // DEC_PSF
+
+    // order in FITS table
+    // SWAP_WORD (76);  // RA_PSF
+    // SWAP_DBLE (84);  // DEC_PSF
+    // SWAP_DBLE (92);  // PEAK_FLUX_AS_MAG
+
+    SWAP_WORD (96);  // SKY
+    SWAP_WORD (100); // SKY_SIG
+    SWAP_WORD (104); // PSF_CHISQ
+    SWAP_WORD (108); // CR_NSIGMA
+    SWAP_WORD (112); // EXT_NSIGMA
+    SWAP_WORD (116); // PSF_MAJOR
+    SWAP_WORD (120); // PSF_MINOR
+    SWAP_WORD (124); // PSF_THETA
+    SWAP_WORD (128); // PSF_CORE
+    SWAP_WORD (132); // PSF_FWHM_MAJ
+    SWAP_WORD (136); // PSF_FWHM_MIN
+    SWAP_WORD (140); // PSF_QF
+    SWAP_WORD (144); // PSF_QF_PERFECT
+    SWAP_WORD (148); // PSF_NDOF
+    SWAP_WORD (152); // PSF_NPIX
+    SWAP_WORD (156); // MOMENTS_XX
+    SWAP_WORD (160); // MOMENTS_XY
+    SWAP_WORD (164); // MOMENTS_YY
+    SWAP_WORD (168); // MOMENTS_M3C
+    SWAP_WORD (172); // MOMENTS_M3S
+    SWAP_WORD (176); // MOMENTS_M4C
+    SWAP_WORD (180); // MOMENTS_M4S
+    SWAP_WORD (184); // MOMENTS_R1
+    SWAP_WORD (188); // MOMENTS_RH
+    SWAP_WORD (192); // KRON_FLUX
+    SWAP_WORD (196); // KRON_FLUX_ERR
+    SWAP_WORD (200); // KRON_FLUX_INNER
+    SWAP_WORD (204); // KRON_FLUX_OUTER
+    SWAP_WORD (208); // FLAGS
+    SWAP_WORD (212); // FLAGS2
+    SWAP_BYTE (216); // N_FRAMES
+    SWAP_BYTE (218); // PADDING
+    SWAP_WORD (220); // PADDING2
+  }
+# endif  
+
+  // BYTE & WORD swap below is valid for the structure, not the FITS buffer
+  if (!toStruct) {
+    // allocate a new output data buffer
+    ALLOCATE (output, unsigned char, nitems*FT_SIZE);
+    unsigned char *inbyte = input;
+    unsigned char *otbyte = output;
+
+    // the data in the input table does not line up with the output structure: copy carefully.
+    for (i = 0; i < nitems; i++, inbyte += ST_SIZE, otbyte += FT_SIZE) {
+      memcpy (&otbyte[  0], &inbyte[  0],  76); // IPP_IDET to CAL_PSF_MAG_SIG
+      memcpy (&otbyte[ 76], &inbyte[ 80],  16); // RA_PSF, DEC_PSF
+      memcpy (&otbyte[ 92], &inbyte[ 76],   4); // PEAK_FLUX_AS_MAG
+      memcpy (&otbyte[ 96], &inbyte[ 96], 124); // SKY to PADDING
+    }
+  }
+
+  return (output);
+} 
+
+int gfits_table_scale_storage_CMF_PS1_SV3 (CMF_PS1_SV3 *data, off_t Ndata) {
+
+  off_t i;
+  for (i = 0; i < Ndata; i++) {
+    data[i].detID   -= 0x80000000;
+    data[i].flags   -= 0x80000000;
+    data[i].flags2  -= 0x80000000;
+    data[i].nFrames -= 0x8000;
+  }
+  return TRUE;
+}
+
+/*** add test of EXTNAME and header-defined columns? ***/
+/* return internal structure representation */
+CMF_PS1_SV3 *gfits_table_get_CMF_PS1_SV3 (FTable *ftable, off_t *Ndata, char *swapped) {
+
+  int Ncols;
+  CMF_PS1_SV3 *data;
+
+  Ncols = ftable[0].header[0].Naxis[0];
+  if (Ncols != FT_SIZE) {
+    fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, FT_SIZE);
+    return NULL;
+  }
+
+  *Ndata = ftable[0].header[0].Naxis[1];
+  data = (CMF_PS1_SV3 *) ftable[0].buffer;
+  if ((swapped == NULL) || (*swapped == FALSE)) {
+    unsigned char *newdata = gfits_convert_CMF_PS1_SV3 ((unsigned char *) data, sizeof (CMF_PS1_SV3), *Ndata, TRUE);
+    if (!newdata) return NULL;
+    free (ftable[0].buffer);
+    ftable[0].buffer = (char *) newdata;
+    data = (CMF_PS1_SV3 *) ftable[0].buffer;
+    gfits_table_scale_storage_CMF_PS1_SV3 (data, *Ndata);
+    if (swapped != NULL) *swapped = TRUE;
+  }
+  return (data);
+}
+
+int gfits_table_set_CMF_PS1_SV3 (FTable *ftable, CMF_PS1_SV3 *data, off_t Ndata) {
+
+  Header *header;
+
+  header = ftable[0].header;
+
+  /* create table header */
+  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_SV3")) return (FALSE);
+
+  /* define table layout */
+  /** TABLE DEFINITION **/
+  gfits_define_bintable_column (header, "J",    "IPP_IDET",         "detection ID                     ", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF",            "x coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF",            "y coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF_SIG",        "x coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF_SIG",        "y coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "POSANGLE",         "Posangle at source",              "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PLTSCALE",         "Plate Scale at source",           "arcsec/pixel",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG",     "inst mags",                       "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG_SIG", "inst mag error",                  "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX",    "psf flux",                        "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX_SIG", "psf flux error",                  "counts      ",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG",           "standard aperture mag",           "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RAW",       "raw aperture mag",                "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RADIUS",    "radius used for fit",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX",          "aperture flux",                   "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX_SIG",      "error on ap flux",                "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "AP_NPIX",          "pixels used for aper",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG",      "calibrated psf mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG_SIG",  "zero point scatter",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PEAK_FLUX_AS_MAG", "peak flux as a mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "RA_PSF",           "PSF RA coord",                    "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "DEC_PSF",          "PSF DEC coord",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY",              "sky flux",                        "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_SIG",          "sky flux error",                  "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CHISQ",        "psf fit chisq",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CR_NSIGMA",        "Nsigma deviations from PSF to CF", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "EXT_NSIGMA",       "Nsigma deviations from PSF to EXT", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MAJOR",        "psf fit major axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MINOR",        "psf fit minor axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_THETA",        "ellipse angle",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CORE",         "extra PSF parameter",             "unitless",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MAJ",     "true fwhm of psf",                "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MIN",     "true fwhm (minor)",               "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF",           "quality factor",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF_PERFECT",   "quality factor perfect",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NDOF",         "psf degrees of freedom",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NPIX",         "psf number of pixels",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XX",       "second moment X",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XY",       "second moment Y",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_YY",       "second moment XY",                "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3C",      "third moment cos(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3S",      "third moment sin(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4C",      "fourth moment cos(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4S",      "fourth moment sin(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_R1",       "first radial moment",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_RH",       "half radial moment",              "pixels^1/2",        1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX",        "kron flux",                       "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_ERR",    "kron flux error",                 "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_INNER",  "kron flux 1<R<2.5",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_OUTER",  "kron flux 2.5<R<4",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS",            "analysis flags",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS2",           "analysis flags (2)",              "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "N_FRAMES",         "images overlapping peak",         "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "PADDING",          "padding for 8byte records",       "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PADDING2",         "padding for 8byte records",       "",                  1.0, 0.0);
+
+  /* create table */
+  if (!gfits_create_table (header, ftable)) return (FALSE);
+
+  /* add data values */
+  if (!gfits_table_scale_data (ftable)) return (FALSE);
+  unsigned char *newdata = gfits_convert_CMF_PS1_SV3 ((unsigned char *) data, sizeof (CMF_PS1_SV3), Ndata, FALSE);
+  if (!newdata) return (FALSE);
+  free (ftable[0].buffer);
+  ftable[0].buffer = (char *) newdata;
+  if (!gfits_add_rows (ftable, (char *) newdata, Ndata, sizeof (CMF_PS1_SV3))) return (FALSE);
+
+  return (TRUE);
+}
+
+int gfits_table_mkheader_CMF_PS1_SV3 (Header *header) {
+
+  /* create table header */
+  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_SV3")) return (FALSE);
+
+  /* define table layout */
+  /** TABLE DEFINITION **/
+  gfits_define_bintable_column (header, "J",    "IPP_IDET",         "detection ID                     ", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF",            "x coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF",            "y coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF_SIG",        "x coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF_SIG",        "y coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "POSANGLE",         "Posangle at source",              "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PLTSCALE",         "Plate Scale at source",           "arcsec/pixel",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG",     "inst mags",                       "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG_SIG", "inst mag error",                  "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX",    "psf flux",                        "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX_SIG", "psf flux error",                  "counts      ",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG",           "standard aperture mag",           "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RAW",       "raw aperture mag",                "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RADIUS",    "radius used for fit",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX",          "aperture flux",                   "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX_SIG",      "error on ap flux",                "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "AP_NPIX",          "pixels used for aper",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG",      "calibrated psf mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG_SIG",  "zero point scatter",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PEAK_FLUX_AS_MAG", "peak flux as a mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "RA_PSF",           "PSF RA coord",                    "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "DEC_PSF",          "PSF DEC coord",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY",              "sky flux",                        "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_SIG",          "sky flux error",                  "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CHISQ",        "psf fit chisq",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CR_NSIGMA",        "Nsigma deviations from PSF to CF", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "EXT_NSIGMA",       "Nsigma deviations from PSF to EXT", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MAJOR",        "psf fit major axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MINOR",        "psf fit minor axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_THETA",        "ellipse angle",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CORE",         "extra PSF parameter",             "unitless",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MAJ",     "true fwhm of psf",                "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MIN",     "true fwhm (minor)",               "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF",           "quality factor",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF_PERFECT",   "quality factor perfect",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NDOF",         "psf degrees of freedom",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NPIX",         "psf number of pixels",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XX",       "second moment X",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XY",       "second moment Y",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_YY",       "second moment XY",                "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3C",      "third moment cos(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3S",      "third moment sin(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4C",      "fourth moment cos(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4S",      "fourth moment sin(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_R1",       "first radial moment",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_RH",       "half radial moment",              "pixels^1/2",        1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX",        "kron flux",                       "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_ERR",    "kron flux error",                 "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_INNER",  "kron flux 1<R<2.5",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_OUTER",  "kron flux 2.5<R<4",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS",            "analysis flags",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS2",           "analysis flags (2)",              "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "N_FRAMES",         "images overlapping peak",         "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "PADDING",          "padding for 8byte records",       "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PADDING2",         "padding for 8byte records",       "",                  1.0, 0.0);
+
+  return (TRUE);
+}
+
+int Send_CMF_PS1_SV3 (int device, CMF_PS1_SV3 *data, int Ndata, int copy) {
+
+  int Nwrite, Nbytes;
+  CMF_PS1_SV3 *tmpdata;
+
+  Nbytes = Ndata * sizeof (CMF_PS1_SV3);
+
+  if (copy) {
+    ALLOCATE (tmpdata, CMF_PS1_SV3, Ndata);
+    memcpy (tmpdata, data, Nbytes);
+  } else {
+    tmpdata = data;
+  }
+
+  unsigned char *newdata = gfits_convert_CMF_PS1_SV3 ((unsigned char *) tmpdata, sizeof (CMF_PS1_SV3), Ndata, FALSE);
+  if (!newdata) return FALSE;
+
+  SendCommand (device, 16, "NVALUE: %6d", Ndata);
+  SendCommand (device, 16, "NBYTES: %6d", Nbytes);
+  Nwrite = write (device, newdata, Nbytes);
+  if (Nwrite != Nbytes) {
+    return (FALSE);
+  }
+  
+  /* perform handshaking? */
+
+  return (TRUE);
+}
+
+int Recv_CMF_PS1_SV3 (int device, CMF_PS1_SV3 **data, int *Ndata) {
+
+  int ndata;
+  IOBuffer message;
+  CMF_PS1_SV3 *tmpdata;
+
+  ExpectCommand (device, 16, 1.0, &message);
+  sscanf (message.buffer, "%*s %d", &ndata);
+  FreeIOBuffer (&message);
+  
+  /* what is reasonable for timeout? */
+  ExpectMessage (device, 1.0, &message);
+  
+  tmpdata = (CMF_PS1_SV3 *) message.buffer;
+  unsigned char *newdata = gfits_convert_CMF_PS1_SV3 ((unsigned char *) tmpdata, sizeof (CMF_PS1_SV3), ndata, TRUE);
+  if (!newdata) return FALSE;
+  free (message.buffer);
+
+  /* double-check data length? */
+  /* perform handshaking? */
+
+  *Ndata = ndata;
+  *data = (CMF_PS1_SV3 *) newdata;
+
+  return (TRUE);
+}
+
Index: /trunk/Ohana/src/libdvo/src/cmf-ps1-v5-lensing.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/cmf-ps1-v5-lensing.c	(revision 37035)
+++ /trunk/Ohana/src/libdvo/src/cmf-ps1-v5-lensing.c	(revision 37035)
@@ -0,0 +1,456 @@
+# include "dvo.h"
+# define ST_SIZE 312
+
+// this function is based on the one generated by the autocode of cmf-ps1-v5.d
+int gfits_convert_CMF_PS1_V5_Lensing (unsigned char *data, off_t size, off_t nitems, char toStruct) {
+
+  off_t i;
+  unsigned char tmp;
+
+  if (size != ST_SIZE) { 
+    fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_V5_Lensing: "OFF_T_FMT" vs %d\n",  size,  ST_SIZE);
+    return (FALSE);
+  }
+
+  /* provide initial values to avoid compiler warnings for non-BYTE_SWAP arch */
+  i = tmp = 0;
+
+  // allocate a temporary output 
+  unsigned char tmpdata[64];
+
+  // move the bytes corresponding to PEAK_FLUX_AS_MAG, RA_PSF, DEC_PSF
+  if (toStruct) {
+    unsigned char *row = data;
+    for (i = 0; i < nitems; i++, row += size) {
+      memcpy  (tmpdata, &row[92], 4); // save PEAK_FLUX_AS_MAG (92-95)
+      memmove (&row[80], &row[76], 16); // move RA_PSF & DEC_PSF
+      memcpy  (&row[76], tmpdata, 4); // replace PEAK_FLUX_AS_MAG
+    }
+  }
+
+  // after we have moved around PEAK_FLUX_AS_MAG, RA_PSF, DEC_PSF, we can swap as needed for this platform
+  unsigned char *byte = data;
+
+# ifdef BYTE_SWAP
+  byte = (unsigned char *) data;
+  for (i = 0; i < nitems; i++, byte += ST_SIZE) {
+    /** BYTE SWAP **/
+    SWAP_WORD (0);   // IPP_IDET                     
+    SWAP_WORD (4);   // X_PSF
+    SWAP_WORD (8);   // Y_PSF
+    SWAP_WORD (12);  // X_PSF_SIG
+    SWAP_WORD (16);  // Y_PSF_SIG
+    SWAP_WORD (20);  // POSANGLE
+    SWAP_WORD (24);  // PLTSCALE
+    SWAP_WORD (28);  // PSF_INST_MAG
+    SWAP_WORD (32);  // PSF_INST_MAG_SIG
+    SWAP_WORD (36);  // PSF_INST_FLUX
+    SWAP_WORD (40);  // PSF_INST_FLUX_SIG
+    SWAP_WORD (44);  // AP_MAG
+    SWAP_WORD (48);  // AP_MAG_RAW
+    SWAP_WORD (52);  // AP_MAG_RADIUS
+    SWAP_WORD (56);  // AP_FLUX
+    SWAP_WORD (60);  // AP_FLUX_SIG
+    SWAP_WORD (64);  // AP_NPIX
+    SWAP_WORD (68);  // CAL_PSF_MAG
+    SWAP_WORD (72);  // CAL_PSF_MAG_SIG
+    SWAP_WORD (76);  // PEAK_FLUX_AS_MAG
+    SWAP_DBLE (80);  // RA_PSF
+    SWAP_DBLE (88);  // DEC_PSF
+    SWAP_WORD (96);  // SKY
+    SWAP_WORD (100); // SKY_SIGMA
+    SWAP_WORD (104); // PSF_CHISQ
+    SWAP_WORD (108); // CR_NSIGMA
+    SWAP_WORD (112); // EXT_NSIGMA
+    SWAP_WORD (116); // PSF_MAJOR
+    SWAP_WORD (120); // PSF_MINOR
+    SWAP_WORD (124); // PSF_THETA
+    SWAP_WORD (128); // PSF_CORE
+    SWAP_WORD (132); // PSF_FWHM_MAJ
+    SWAP_WORD (136); // PSF_FWHM_MIN
+    SWAP_WORD (140); // PSF_QF
+    SWAP_WORD (144); // PSF_QF_PERFECT
+    SWAP_WORD (148); // PSF_NDOF
+    SWAP_WORD (152); // PSF_NPIX
+    SWAP_WORD (156); // MOMENTS_XX
+    SWAP_WORD (160); // MOMENTS_XY
+    SWAP_WORD (164); // MOMENTS_YY
+    SWAP_WORD (168); // MOMENTS_M3C
+    SWAP_WORD (172); // MOMENTS_M3S
+    SWAP_WORD (176); // MOMENTS_M4C
+    SWAP_WORD (180); // MOMENTS_M4S
+    SWAP_WORD (184); // X11_SM_OBJ
+    SWAP_WORD (188); // X12_SM_OBJ
+    SWAP_WORD (192); // X22_SM_OBJ
+    SWAP_WORD (196); // E1_SM_OBJ
+    SWAP_WORD (200); // E2_SM_OBJ
+    SWAP_WORD (204); // X11_SH_OBJ
+    SWAP_WORD (208); // X12_SH_OBJ
+    SWAP_WORD (212); // X22_SH_OBJ
+    SWAP_WORD (216); // E1_SH_OBJ
+    SWAP_WORD (220); // E2_SH_OBJ
+    SWAP_WORD (224); // X11_SM_PSF
+    SWAP_WORD (228); // X12_SM_PSF
+    SWAP_WORD (232); // X22_SM_PSF
+    SWAP_WORD (236); // E1_SM_PSF
+    SWAP_WORD (240); // E2_SM_PSF
+    SWAP_WORD (244); // X11_SH_PSF
+    SWAP_WORD (248); // X12_SH_PSF
+    SWAP_WORD (252); // X22_SH_PSF
+    SWAP_WORD (256); // E1_SH_PSF
+    SWAP_WORD (260); // E2_SH_PSF
+    SWAP_WORD (264); // MOMENTS_R1
+    SWAP_WORD (268); // MOMENTS_RH
+    SWAP_WORD (272); // KRON_FLUX
+    SWAP_WORD (276); // KRON_FLUX_ERR
+    SWAP_WORD (280); // KRON_FLUX_INNER
+    SWAP_WORD (284); // KRON_FLUX_OUTER
+    SWAP_WORD (288); // SKY_LIMIT_RAD
+    SWAP_WORD (292); // SKY_LIMIT_FLUX
+    SWAP_WORD (296); // SKY_LIMIT_SLOPE
+    SWAP_WORD (300); // FLAGS
+    SWAP_WORD (304); // FLAGS2
+    SWAP_BYTE (308); // N_FRAMES
+    SWAP_BYTE (310); // PADDING                       
+  }
+# endif  
+
+  // move the bytes corresponding to PEAK_FLUX_AS_MAG, RA_PSF, DEC_PSF
+  if (!toStruct) {
+    unsigned char *row = data;
+    for (i = 0; i < nitems; i++, row += size) {
+      memcpy  (tmpdata, &row[76], 4); // save PEAK_FLUX_AS_MAG (92-95)
+      memmove (&row[76], &row[80], 16); // move RA_PSF & DEC_PSF
+      memcpy  (&row[92], tmpdata, 4); // replace PEAK_FLUX_AS_MAG
+    }
+  }
+
+  return (TRUE);
+} 
+
+// data organization (input vs output)
+//                FITS               struct
+// WORD   (0); // IPP_IDET           IPP_IDET           / 1J                  
+// WORD   (4); // X_PSF              X_PSF              / 1E                  
+// WORD   (8); // Y_PSF              Y_PSF              / 1E                  
+// WORD  (12); // X_PSF_SIG          X_PSF_SIG          / 1E                  
+// WORD  (16); // Y_PSF_SIG          Y_PSF_SIG          / 1E                  
+// WORD  (20); // POSANGLE           POSANGLE           / 1E                  
+// WORD  (24); // PLTSCALE           PLTSCALE           / 1E                  
+// WORD  (28); // PSF_INST_MAG       PSF_INST_MAG       / 1E                  
+// WORD  (32); // PSF_INST_MAG_SIG   PSF_INST_MAG_SIG   / 1E                  
+// WORD  (36); // PSF_INST_FLUX      PSF_INST_FLUX      / 1E                  
+// WORD  (40); // PSF_INST_FLUX_SIG  PSF_INST_FLUX_SIG  / 1E                  
+// WORD  (44); // AP_MAG             AP_MAG             / 1E                  
+// WORD  (48); // AP_MAG_RAW         AP_MAG_RAW         / 1E                  
+// WORD  (52); // AP_MAG_RADIUS      AP_MAG_RADIUS      / 1E                  
+// WORD  (56); // AP_FLUX            AP_FLUX            / 1E                  
+// WORD  (60); // AP_FLUX_SIG        AP_FLUX_SIG        / 1E                  
+// WORD  (64); // AP_NPIX            AP_NPIX            / 1J                  
+// WORD  (68); // CAL_PSF_MAG        CAL_PSF_MAG        / 1E                  
+// WORD  (72); // CAL_PSF_MAG_SIG    CAL_PSF_MAG_SIG    / 1E                  
+// WORD  (76); // PEAK_FLUX_AS_MAG   RA_PSF             / 1D                  
+// DBLE  (80); // RA_PSF             DEC_PSF            / 1D                  
+// DBLE  (88); // DEC_PSF            PEAK_FLUX_AS_MAG   / 1E                  
+// WORD  (96); // SKY                SKY                / 1E                  
+// WORD (100); // SKY_SIGMA          SKY_SIGMA          / 1E                  
+// WORD (104); // PSF_CHISQ          PSF_CHISQ          / 1E                  
+// WORD (108); // CR_NSIGMA          CR_NSIGMA          / 1E                  
+// WORD (112); // EXT_NSIGMA         EXT_NSIGMA         / 1E                  
+// WORD (116); // PSF_MAJOR          PSF_MAJOR          / 1E                  
+// WORD (120); // PSF_MINOR          PSF_MINOR          / 1E                  
+// WORD (124); // PSF_THETA          PSF_THETA          / 1E                  
+// WORD (128); // PSF_CORE           PSF_CORE           / 1E                  
+// WORD (132); // PSF_FWHM_MAJ       PSF_FWHM_MAJ       / 1E                  
+// WORD (136); // PSF_FWHM_MIN       PSF_FWHM_MIN       / 1E                  
+// WORD (140); // PSF_QF             PSF_QF             / 1E                  
+// WORD (144); // PSF_QF_PERFECT     PSF_QF_PERFECT     / 1E                  
+// WORD (148); // PSF_NDOF           PSF_NDOF           / 1J                  
+// WORD (152); // PSF_NPIX           PSF_NPIX           / 1J                  
+// WORD (156); // MOMENTS_XX         MOMENTS_XX         / 1E                  
+// WORD (160); // MOMENTS_XY         MOMENTS_XY         / 1E                  
+// WORD (164); // MOMENTS_YY         MOMENTS_YY         / 1E                  
+// WORD (168); // MOMENTS_M3C        MOMENTS_M3C        / 1E                  
+// WORD (172); // MOMENTS_M3S        MOMENTS_M3S        / 1E                  
+// WORD (176); // MOMENTS_M4C        MOMENTS_M4C        / 1E                  
+// WORD (180); // MOMENTS_M4S        MOMENTS_M4S        / 1E                  
+// WORD (184); // MOMENTS_R1         MOMENTS_R1         / 1E                  
+// WORD (188); // MOMENTS_RH         MOMENTS_RH         / 1E                  
+// WORD (192); // KRON_FLUX          KRON_FLUX          / 1E                  
+// WORD (196); // KRON_FLUX_ERR      KRON_FLUX_ERR      / 1E                  
+// WORD (200); // KRON_FLUX_INNER    KRON_FLUX_INNER    / 1E                  
+// WORD (204); // KRON_FLUX_OUTER    KRON_FLUX_OUTER    / 1E                  
+// WORD (208); // SKY_LIMIT_RAD      SKY_LIMIT_RAD      / 1E                  
+// WORD (212); // SKY_LIMIT_FLUX     SKY_LIMIT_FLUX     / 1E                  
+// WORD (216); // SKY_LIMIT_SLOPE    SKY_LIMIT_SLOPE    / 1E                  
+// WORD (220); // FLAGS              FLAGS              / 1J                  
+// WORD (224); // FLAGS2             FLAGS2             / 1J                  
+// BYTE (228); // N_FRAMES           N_FRAMES           / 1I                  
+// BYTE (230); // PADDING            PADDING            / 1I                  
+
+/*** add test of EXTNAME and header-defined columns? ***/
+/* return internal structure representation */
+CMF_PS1_V5_Lensing *gfits_table_get_CMF_PS1_V5_Lensing (FTable *ftable, off_t *Ndata, char *swapped) {
+
+  int Ncols;
+  CMF_PS1_V5_Lensing *data;
+
+  Ncols = ftable[0].header[0].Naxis[0];
+  if (Ncols != ST_SIZE) {
+    fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, ST_SIZE);
+    return NULL;
+  }
+
+  *Ndata = ftable[0].header[0].Naxis[1];
+  data = (CMF_PS1_V5_Lensing *) ftable[0].buffer;
+  if ((swapped == NULL) || (*swapped == FALSE)) {
+    if (!gfits_convert_CMF_PS1_V5_Lensing ((unsigned char *) data, sizeof (CMF_PS1_V5_Lensing), *Ndata, TRUE)) {
+      return NULL;
+    }
+    gfits_table_scale_data (ftable);
+    if (swapped != NULL) *swapped = TRUE;
+  }
+  return (data);
+}
+
+int gfits_table_set_CMF_PS1_V5_Lensing (FTable *ftable, CMF_PS1_V5_Lensing *data, off_t Ndata) {
+
+  Header *header;
+
+  header = ftable[0].header;
+
+  /* create table header */
+  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_Lensing")) return (FALSE);
+
+  /* define table layout */
+  /** TABLE DEFINITION **/
+  gfits_define_bintable_column (header, "J",    "IPP_IDET",         "detection ID                     ", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF",            "x coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF",            "y coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF_SIG",        "x coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF_SIG",        "y coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "POSANGLE",         "Posangle at source",              "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PLTSCALE",         "Plate Scale at source",           "arcsec/pixel",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG",     "inst mags",                       "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG_SIG", "inst mag error",                  "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX",    "psf flux",                        "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX_SIG", "psf flux error",                  "counts      ",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG",           "standard aperture mag",           "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RAW",       "raw aperture mag",                "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RADIUS",    "radius used for aper",            "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX",          "aperture flux",                   "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX_SIG",      "error on ap flux",                "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "AP_NPIX",          "pixels used by aper",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG",      "calibrated psf mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG_SIG",  "zero point scatter",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "RA_PSF",           "PSF RA coord",                    "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "DEC_PSF",          "PSF DEC coord",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PEAK_FLUX_AS_MAG", "peak flux as a mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY",              "sky flux",                        "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_SIGMA",        "sky flux error",                  "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CHISQ",        "psf fit chisq",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CR_NSIGMA",        "Nsigma deviations from PSF to CF", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "EXT_NSIGMA",       "Nsigma deviations from PSF to EXT", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MAJOR",        "psf fit major axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MINOR",        "psf fit minor axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_THETA",        "ellipse angle",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CORE",         "extra PSF parameter",             "unitless",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MAJ",     "true fwhm of psf",                "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MIN",     "true fwhm (minor)",               "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF",           "quality factor",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF_PERFECT",   "quality factor perfect",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NDOF",         "psf degrees of freedom",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NPIX",         "psf number of pixels",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XX",       "second moment X",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XY",       "second moment Y",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_YY",       "second moment XY",                "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3C",      "third moment cos(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3S",      "third moment sin(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4C",      "fourth moment cos(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4S",      "fourth moment sin(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X11_SM_OBJ",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X12_SM_OBJ",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X22_SM_OBJ",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E1_SM_OBJ",        "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E2_SM_OBJ",        "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X11_SH_OBJ",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X12_SH_OBJ",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X22_SH_OBJ",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E1_SH_OBJ",        "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E2_SH_OBJ",        "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X11_SM_PSF",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X12_SM_PSF",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X22_SM_PSF",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E1_SM_PSF",        "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E2_SM_PSF",        "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X11_SH_PSF",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X12_SH_PSF",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X22_SH_PSF",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E1_SH_PSF",        "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E2_SH_PSF",        "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_R1",       "first radial moment",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_RH",       "half radial moment",              "pixels^1/2",        1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX",        "kron flux",                       "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_ERR",    "kron flux error",                 "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_INNER",  "kron flux 1<R<2.5",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_OUTER",  "kron flux 2.5<R<4",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_RAD",    "profile to sky limit (radius)",   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_FLUX",   "profile to sky limit (flux)",     "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_SLOPE",  "profile to sky limit (slope)",    "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS",            "analysis flags",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS2",           "analysis flags (2)",              "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "N_FRAMES",         "images overlapping peak",         "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "PADDING",          "padding for 8byte records",       "",                  1.0, 0.0);
+
+  /* create table */
+  if (!gfits_create_table (header, ftable)) return (FALSE);
+
+  /* add data values */
+  if (!gfits_table_scale_data (ftable)) return (FALSE);
+  if (!gfits_convert_CMF_PS1_V5_Lensing ((unsigned char *) data, sizeof (CMF_PS1_V5_Lensing), Ndata, FALSE)) return (FALSE);
+  if (!gfits_add_rows (ftable, (char *) data, Ndata, sizeof (CMF_PS1_V5_Lensing))) return (FALSE);
+
+  return (TRUE);
+}
+
+int gfits_table_mkheader_CMF_PS1_V5_Lensing (Header *header) {
+
+  /* create table header */
+  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5_Lensing")) return (FALSE);
+
+  /* define table layout */
+  /** TABLE DEFINITION **/
+  gfits_define_bintable_column (header, "J",    "IPP_IDET",         "detection ID                     ", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF",            "x coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF",            "y coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF_SIG",        "x coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF_SIG",        "y coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "POSANGLE",         "Posangle at source",              "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PLTSCALE",         "Plate Scale at source",           "arcsec/pixel",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG",     "inst mags",                       "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG_SIG", "inst mag error",                  "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX",    "psf flux",                        "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX_SIG", "psf flux error",                  "counts      ",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG",           "standard aperture mag",           "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RAW",       "raw aperture mag",                "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RADIUS",    "radius used for aper",            "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX",          "aperture flux",                   "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX_SIG",      "error on ap flux",                "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "AP_NPIX",          "pixels used by aper",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG",      "calibrated psf mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG_SIG",  "zero point scatter",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PEAK_FLUX_AS_MAG", "peak flux as a mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "RA_PSF",           "PSF RA coord",                    "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "DEC_PSF",          "PSF DEC coord",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY",              "sky flux",                        "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_SIGMA",        "sky flux error",                  "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CHISQ",        "psf fit chisq",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CR_NSIGMA",        "Nsigma deviations from PSF to CF", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "EXT_NSIGMA",       "Nsigma deviations from PSF to EXT", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MAJOR",        "psf fit major axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MINOR",        "psf fit minor axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_THETA",        "ellipse angle",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CORE",         "extra PSF parameter",             "unitless",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MAJ",     "true fwhm of psf",                "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MIN",     "true fwhm (minor)",               "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF",           "quality factor",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF_PERFECT",   "quality factor perfect",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NDOF",         "psf degrees of freedom",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NPIX",         "psf number of pixels",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XX",       "second moment X",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XY",       "second moment Y",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_YY",       "second moment XY",                "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3C",      "third moment cos(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3S",      "third moment sin(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4C",      "fourth moment cos(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4S",      "fourth moment sin(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X11_SM_OBJ",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X12_SM_OBJ",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X22_SM_OBJ",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E1_SM_OBJ",        "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E2_SM_OBJ",        "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X11_SH_OBJ",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X12_SH_OBJ",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X22_SH_OBJ",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E1_SH_OBJ",        "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E2_SH_OBJ",        "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X11_SM_PSF",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X12_SM_PSF",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X22_SM_PSF",       "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E1_SM_PSF",        "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E2_SM_PSF",        "lensing smear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X11_SH_PSF",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X12_SH_PSF",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X22_SH_PSF",       "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E1_SH_PSF",        "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "E2_SH_PSF",        "lensing shear",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_R1",       "first radial moment",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_RH",       "half radial moment",              "pixels^1/2",        1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX",        "kron flux",                       "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_ERR",    "kron flux error",                 "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_INNER",  "kron flux 1<R<2.5",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_OUTER",  "kron flux 2.5<R<4",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_RAD",    "profile to sky limit (radius)",   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_FLUX",   "profile to sky limit (flux)",     "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_SLOPE",  "profile to sky limit (slope)",    "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS",            "analysis flags",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS2",           "analysis flags (2)",              "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "N_FRAMES",         "images overlapping peak",         "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "PADDING",          "padding for 8byte records",       "",                  1.0, 0.0);
+
+  return (TRUE);
+}
+
+int Send_CMF_PS1_V5_Lensing (int device, CMF_PS1_V5_Lensing *data, int Ndata, int copy) {
+
+  int Nwrite, Nbytes;
+  CMF_PS1_V5_Lensing *tmpdata;
+
+  Nbytes = Ndata * sizeof (CMF_PS1_V5_Lensing);
+
+  if (copy) {
+    ALLOCATE (tmpdata, CMF_PS1_V5_Lensing, Ndata);
+    memcpy (tmpdata, data, Nbytes);
+  } else {
+    tmpdata = data;
+  }
+
+  if (!gfits_convert_CMF_PS1_V5_Lensing ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_Lensing), Ndata, FALSE)) return (FALSE);
+
+  SendCommand (device, 16, "NVALUE: %6d", Ndata);
+  SendCommand (device, 16, "NBYTES: %6d", Nbytes);
+  Nwrite = write (device, tmpdata, Nbytes);
+  if (Nwrite != Nbytes) {
+    return (FALSE);
+  }
+  
+  /* perform handshaking? */
+
+  return (TRUE);
+}
+
+int Recv_CMF_PS1_V5_Lensing (int device, CMF_PS1_V5_Lensing **data, int *Ndata) {
+
+  int ndata;
+  IOBuffer message;
+  CMF_PS1_V5_Lensing *tmpdata;
+
+  ExpectCommand (device, 16, 1.0, &message);
+  sscanf (message.buffer, "%*s %d", &ndata);
+  FreeIOBuffer (&message);
+  
+  /* what is reasonable for timeout? */
+  ExpectMessage (device, 1.0, &message);
+  
+  tmpdata = (CMF_PS1_V5_Lensing *) message.buffer;
+  if (!gfits_convert_CMF_PS1_V5_Lensing ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5_Lensing), ndata, TRUE)) return (FALSE);
+
+  /* double-check data length? */
+  /* perform handshaking? */
+
+  *Ndata = ndata;
+  *data = tmpdata;
+
+  return (TRUE);
+}
+
Index: /trunk/Ohana/src/libdvo/src/cmf-ps1-v5.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/cmf-ps1-v5.c	(revision 37035)
+++ /trunk/Ohana/src/libdvo/src/cmf-ps1-v5.c	(revision 37035)
@@ -0,0 +1,395 @@
+# include "dvo.h"
+
+// this function is based on the one generated by the autocode of cmf-ps1-v5.d
+int gfits_convert_CMF_PS1_V5 (unsigned char *data, off_t size, off_t nitems, char toStruct) {
+
+  off_t i;
+  unsigned char tmp;
+
+  if (size != 232) { 
+    fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_V5: "OFF_T_FMT" vs %d\n",  size,  232);
+    return (FALSE);
+  }
+
+  /* provide initial values to avoid compiler warnings for non-BYTE_SWAP arch */
+  i = tmp = 0;
+
+  // allocate a temporary output 
+  unsigned char tmpdata[64];
+
+  // move the bytes corresponding to PEAK_FLUX_AS_MAG, RA_PSF, DEC_PSF
+  if (toStruct) {
+    unsigned char *row = data;
+    for (i = 0; i < nitems; i++, row += size) {
+      memcpy  (tmpdata, &row[92], 4); // save PEAK_FLUX_AS_MAG (92-95)
+      memmove (&row[80], &row[76], 16); // move RA_PSF & DEC_PSF
+      memcpy  (&row[76], tmpdata, 4); // replace PEAK_FLUX_AS_MAG
+    }
+  }
+
+  // after we have moved around PEAK_FLUX_AS_MAG, RA_PSF, DEC_PSF, we can swap as needed for this platform
+  unsigned char *byte = data;
+
+# ifdef BYTE_SWAP
+  byte = (unsigned char *) data;
+  for (i = 0; i < nitems; i++, byte += 232) {
+    /** BYTE SWAP **/
+    SWAP_WORD (0); // IPP_IDET                     
+    SWAP_WORD (4); // X_PSF
+    SWAP_WORD (8); // Y_PSF
+    SWAP_WORD (12); // X_PSF_SIG
+    SWAP_WORD (16); // Y_PSF_SIG
+    SWAP_WORD (20); // POSANGLE
+    SWAP_WORD (24); // PLTSCALE
+    SWAP_WORD (28); // PSF_INST_MAG
+    SWAP_WORD (32); // PSF_INST_MAG_SIG
+    SWAP_WORD (36); // PSF_INST_FLUX
+    SWAP_WORD (40); // PSF_INST_FLUX_SIG
+    SWAP_WORD (44); // AP_MAG
+    SWAP_WORD (48); // AP_MAG_RAW
+    SWAP_WORD (52); // AP_MAG_RADIUS
+    SWAP_WORD (56); // AP_FLUX
+    SWAP_WORD (60); // AP_FLUX_SIG
+    SWAP_WORD (64); // AP_NPIX
+    SWAP_WORD (68); // CAL_PSF_MAG
+    SWAP_WORD (72); // CAL_PSF_MAG_SIG
+    SWAP_WORD (76); // PEAK_FLUX_AS_MAG
+    SWAP_DBLE (80); // RA_PSF
+    SWAP_DBLE (88); // DEC_PSF
+    SWAP_WORD (96); // SKY
+    SWAP_WORD (100); // SKY_SIGMA
+    SWAP_WORD (104); // PSF_CHISQ
+    SWAP_WORD (108); // CR_NSIGMA
+    SWAP_WORD (112); // EXT_NSIGMA
+    SWAP_WORD (116); // PSF_MAJOR
+    SWAP_WORD (120); // PSF_MINOR
+    SWAP_WORD (124); // PSF_THETA
+    SWAP_WORD (128); // PSF_CORE
+    SWAP_WORD (132); // PSF_FWHM_MAJ
+    SWAP_WORD (136); // PSF_FWHM_MIN
+    SWAP_WORD (140); // PSF_QF
+    SWAP_WORD (144); // PSF_QF_PERFECT
+    SWAP_WORD (148); // PSF_NDOF
+    SWAP_WORD (152); // PSF_NPIX
+    SWAP_WORD (156); // MOMENTS_XX
+    SWAP_WORD (160); // MOMENTS_XY
+    SWAP_WORD (164); // MOMENTS_YY
+    SWAP_WORD (168); // MOMENTS_M3C
+    SWAP_WORD (172); // MOMENTS_M3S
+    SWAP_WORD (176); // MOMENTS_M4C
+    SWAP_WORD (180); // MOMENTS_M4S
+    SWAP_WORD (184); // MOMENTS_R1
+    SWAP_WORD (188); // MOMENTS_RH
+    SWAP_WORD (192); // KRON_FLUX
+    SWAP_WORD (196); // KRON_FLUX_ERR
+    SWAP_WORD (200); // KRON_FLUX_INNER
+    SWAP_WORD (204); // KRON_FLUX_OUTER
+    SWAP_WORD (208); // SKY_LIMIT_RAD
+    SWAP_WORD (212); // SKY_LIMIT_FLUX
+    SWAP_WORD (216); // SKY_LIMIT_SLOPE
+    SWAP_WORD (220); // FLAGS
+    SWAP_WORD (224); // FLAGS2
+    SWAP_BYTE (228); // N_FRAMES
+    SWAP_BYTE (230); // PADDING
+  }
+# endif  
+
+  // move the bytes corresponding to PEAK_FLUX_AS_MAG, RA_PSF, DEC_PSF
+  if (!toStruct) {
+    unsigned char *row = data;
+    for (i = 0; i < nitems; i++, row += size) {
+      memcpy  (tmpdata, &row[76], 4); // save PEAK_FLUX_AS_MAG (92-95)
+      memmove (&row[76], &row[80], 16); // move RA_PSF & DEC_PSF
+      memcpy  (&row[92], tmpdata, 4); // replace PEAK_FLUX_AS_MAG
+    }
+  }
+
+  return (TRUE);
+} 
+
+// data organization (input vs output)
+//                FITS               struct
+// WORD   (0); // IPP_IDET           IPP_IDET           / 1J                  
+// WORD   (4); // X_PSF              X_PSF              / 1E                  
+// WORD   (8); // Y_PSF              Y_PSF              / 1E                  
+// WORD  (12); // X_PSF_SIG          X_PSF_SIG          / 1E                  
+// WORD  (16); // Y_PSF_SIG          Y_PSF_SIG          / 1E                  
+// WORD  (20); // POSANGLE           POSANGLE           / 1E                  
+// WORD  (24); // PLTSCALE           PLTSCALE           / 1E                  
+// WORD  (28); // PSF_INST_MAG       PSF_INST_MAG       / 1E                  
+// WORD  (32); // PSF_INST_MAG_SIG   PSF_INST_MAG_SIG   / 1E                  
+// WORD  (36); // PSF_INST_FLUX      PSF_INST_FLUX      / 1E                  
+// WORD  (40); // PSF_INST_FLUX_SIG  PSF_INST_FLUX_SIG  / 1E                  
+// WORD  (44); // AP_MAG             AP_MAG             / 1E                  
+// WORD  (48); // AP_MAG_RAW         AP_MAG_RAW         / 1E                  
+// WORD  (52); // AP_MAG_RADIUS      AP_MAG_RADIUS      / 1E                  
+// WORD  (56); // AP_FLUX            AP_FLUX            / 1E                  
+// WORD  (60); // AP_FLUX_SIG        AP_FLUX_SIG        / 1E                  
+// WORD  (64); // AP_NPIX            AP_NPIX            / 1J                  
+// WORD  (68); // CAL_PSF_MAG        CAL_PSF_MAG        / 1E                  
+// WORD  (72); // CAL_PSF_MAG_SIG    CAL_PSF_MAG_SIG    / 1E                  
+// WORD  (76); // PEAK_FLUX_AS_MAG   RA_PSF             / 1D                  
+// DBLE  (80); // RA_PSF             DEC_PSF            / 1D                  
+// DBLE  (88); // DEC_PSF            PEAK_FLUX_AS_MAG   / 1E                  
+// WORD  (96); // SKY                SKY                / 1E                  
+// WORD (100); // SKY_SIGMA          SKY_SIGMA          / 1E                  
+// WORD (104); // PSF_CHISQ          PSF_CHISQ          / 1E                  
+// WORD (108); // CR_NSIGMA          CR_NSIGMA          / 1E                  
+// WORD (112); // EXT_NSIGMA         EXT_NSIGMA         / 1E                  
+// WORD (116); // PSF_MAJOR          PSF_MAJOR          / 1E                  
+// WORD (120); // PSF_MINOR          PSF_MINOR          / 1E                  
+// WORD (124); // PSF_THETA          PSF_THETA          / 1E                  
+// WORD (128); // PSF_CORE           PSF_CORE           / 1E                  
+// WORD (132); // PSF_FWHM_MAJ       PSF_FWHM_MAJ       / 1E                  
+// WORD (136); // PSF_FWHM_MIN       PSF_FWHM_MIN       / 1E                  
+// WORD (140); // PSF_QF             PSF_QF             / 1E                  
+// WORD (144); // PSF_QF_PERFECT     PSF_QF_PERFECT     / 1E                  
+// WORD (148); // PSF_NDOF           PSF_NDOF           / 1J                  
+// WORD (152); // PSF_NPIX           PSF_NPIX           / 1J                  
+// WORD (156); // MOMENTS_XX         MOMENTS_XX         / 1E                  
+// WORD (160); // MOMENTS_XY         MOMENTS_XY         / 1E                  
+// WORD (164); // MOMENTS_YY         MOMENTS_YY         / 1E                  
+// WORD (168); // MOMENTS_M3C        MOMENTS_M3C        / 1E                  
+// WORD (172); // MOMENTS_M3S        MOMENTS_M3S        / 1E                  
+// WORD (176); // MOMENTS_M4C        MOMENTS_M4C        / 1E                  
+// WORD (180); // MOMENTS_M4S        MOMENTS_M4S        / 1E                  
+// WORD (184); // MOMENTS_R1         MOMENTS_R1         / 1E                  
+// WORD (188); // MOMENTS_RH         MOMENTS_RH         / 1E                  
+// WORD (192); // KRON_FLUX          KRON_FLUX          / 1E                  
+// WORD (196); // KRON_FLUX_ERR      KRON_FLUX_ERR      / 1E                  
+// WORD (200); // KRON_FLUX_INNER    KRON_FLUX_INNER    / 1E                  
+// WORD (204); // KRON_FLUX_OUTER    KRON_FLUX_OUTER    / 1E                  
+// WORD (208); // SKY_LIMIT_RAD      SKY_LIMIT_RAD      / 1E                  
+// WORD (212); // SKY_LIMIT_FLUX     SKY_LIMIT_FLUX     / 1E                  
+// WORD (216); // SKY_LIMIT_SLOPE    SKY_LIMIT_SLOPE    / 1E                  
+// WORD (220); // FLAGS              FLAGS              / 1J                  
+// WORD (224); // FLAGS2             FLAGS2             / 1J                  
+// BYTE (228); // N_FRAMES           N_FRAMES           / 1I                  
+// BYTE (230); // PADDING            PADDING            / 1I                  
+
+/*** add test of EXTNAME and header-defined columns? ***/
+/* return internal structure representation */
+CMF_PS1_V5 *gfits_table_get_CMF_PS1_V5 (FTable *ftable, off_t *Ndata, char *swapped) {
+
+  int Ncols;
+  CMF_PS1_V5 *data;
+
+  Ncols = ftable[0].header[0].Naxis[0];
+  if (Ncols != 232) {
+    fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, 232);
+    return NULL;
+  }
+
+  *Ndata = ftable[0].header[0].Naxis[1];
+  data = (CMF_PS1_V5 *) ftable[0].buffer;
+  if ((swapped == NULL) || (*swapped == FALSE)) {
+    if (!gfits_convert_CMF_PS1_V5 ((unsigned char *) data, sizeof (CMF_PS1_V5), *Ndata, TRUE)) {
+      return NULL;
+    }
+    gfits_table_scale_data (ftable);
+    if (swapped != NULL) *swapped = TRUE;
+  }
+  return (data);
+}
+
+int gfits_table_set_CMF_PS1_V5 (FTable *ftable, CMF_PS1_V5 *data, off_t Ndata) {
+
+  Header *header;
+
+  header = ftable[0].header;
+
+  /* create table header */
+  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5")) return (FALSE);
+
+  /* define table layout */
+  /** TABLE DEFINITION **/
+  gfits_define_bintable_column (header, "J",    "IPP_IDET",         "detection ID                     ", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF",            "x coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF",            "y coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF_SIG",        "x coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF_SIG",        "y coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "POSANGLE",         "Posangle at source",              "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PLTSCALE",         "Plate Scale at source",           "arcsec/pixel",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG",     "inst mags",                       "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG_SIG", "inst mag error",                  "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX",    "psf flux",                        "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX_SIG", "psf flux error",                  "counts      ",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG",           "standard aperture mag",           "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RAW",       "raw aperture mag",                "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RADIUS",    "radius used for aper",            "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX",          "aperture flux",                   "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX_SIG",      "error on ap flux",                "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "AP_NPIX",          "pixels used by aper",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG",      "calibrated psf mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG_SIG",  "zero point scatter",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "RA_PSF",           "PSF RA coord",                    "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "DEC_PSF",          "PSF DEC coord",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PEAK_FLUX_AS_MAG", "peak flux as a mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY",              "sky flux",                        "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_SIGMA",        "sky flux error",                  "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CHISQ",        "psf fit chisq",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CR_NSIGMA",        "Nsigma deviations from PSF to CF", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "EXT_NSIGMA",       "Nsigma deviations from PSF to EXT", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MAJOR",        "psf fit major axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MINOR",        "psf fit minor axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_THETA",        "ellipse angle",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CORE",         "extra PSF parameter",             "unitless",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MAJ",     "true fwhm of psf",                "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MIN",     "true fwhm (minor)",               "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF",           "quality factor",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF_PERFECT",   "quality factor perfect",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NDOF",         "psf degrees of freedom",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NPIX",         "psf number of pixels",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XX",       "second moment X",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XY",       "second moment Y",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_YY",       "second moment XY",                "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3C",      "third moment cos(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3S",      "third moment sin(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4C",      "fourth moment cos(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4S",      "fourth moment sin(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_R1",       "first radial moment",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_RH",       "half radial moment",              "pixels^1/2",        1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX",        "kron flux",                       "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_ERR",    "kron flux error",                 "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_INNER",  "kron flux 1<R<2.5",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_OUTER",  "kron flux 2.5<R<4",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_RAD",    "profile to sky limit (radius)",   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_FLUX",   "profile to sky limit (flux)",     "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_SLOPE",  "profile to sky limit (slope)",    "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS",            "analysis flags",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS2",           "analysis flags (2)",              "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "N_FRAMES",         "images overlapping peak",         "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "PADDING",          "padding for 8byte records",       "",                  1.0, 0.0);
+
+  /* create table */
+  if (!gfits_create_table (header, ftable)) return (FALSE);
+
+  /* add data values */
+  if (!gfits_table_scale_data (ftable)) return (FALSE);
+  if (!gfits_convert_CMF_PS1_V5 ((unsigned char *) data, sizeof (CMF_PS1_V5), Ndata, FALSE)) return (FALSE);
+  if (!gfits_add_rows (ftable, (char *) data, Ndata, sizeof (CMF_PS1_V5))) return (FALSE);
+
+  return (TRUE);
+}
+
+int gfits_table_mkheader_CMF_PS1_V5 (Header *header) {
+
+  /* create table header */
+  if (!gfits_create_table_header (header, "BINTABLE", "CMF_PS1_V5")) return (FALSE);
+
+  /* define table layout */
+  /** TABLE DEFINITION **/
+  gfits_define_bintable_column (header, "J",    "IPP_IDET",         "detection ID                     ", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF",            "x coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF",            "y coord",                         "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "X_PSF_SIG",        "x coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "Y_PSF_SIG",        "y coord error",                   "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "POSANGLE",         "Posangle at source",              "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PLTSCALE",         "Plate Scale at source",           "arcsec/pixel",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG",     "inst mags",                       "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_MAG_SIG", "inst mag error",                  "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX",    "psf flux",                        "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_INST_FLUX_SIG", "psf flux error",                  "counts      ",      1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG",           "standard aperture mag",           "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RAW",       "raw aperture mag",                "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_MAG_RADIUS",    "radius used for aper",            "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX",          "aperture flux",                   "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "AP_FLUX_SIG",      "error on ap flux",                "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "AP_NPIX",          "pixels used by aper",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG",      "calibrated psf mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CAL_PSF_MAG_SIG",  "zero point scatter",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PEAK_FLUX_AS_MAG", "peak flux as a mag",              "mags",              1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "RA_PSF",           "PSF RA coord",                    "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "DEC_PSF",          "PSF DEC coord",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY",              "sky flux",                        "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_SIGMA",        "sky flux error",                  "cnts/sec",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CHISQ",        "psf fit chisq",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CR_NSIGMA",        "Nsigma deviations from PSF to CF", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "EXT_NSIGMA",       "Nsigma deviations from PSF to EXT", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MAJOR",        "psf fit major axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_MINOR",        "psf fit minor axis",              "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_THETA",        "ellipse angle",                   "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_CORE",         "extra PSF parameter",             "unitless",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MAJ",     "true fwhm of psf",                "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_FWHM_MIN",     "true fwhm (minor)",               "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF",           "quality factor",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PSF_QF_PERFECT",   "quality factor perfect",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NDOF",         "psf degrees of freedom",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PSF_NPIX",         "psf number of pixels",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XX",       "second moment X",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_XY",       "second moment Y",                 "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_YY",       "second moment XY",                "pixels^2",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3C",      "third moment cos(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M3S",      "third moment sin(t)",             "pixels^3",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4C",      "fourth moment cos(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_M4S",      "fourth moment sin(t)",            "pixels^4",          1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_R1",       "first radial moment",             "pixels",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MOMENTS_RH",       "half radial moment",              "pixels^1/2",        1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX",        "kron flux",                       "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_ERR",    "kron flux error",                 "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_INNER",  "kron flux 1<R<2.5",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "KRON_FLUX_OUTER",  "kron flux 2.5<R<4",               "counts",            1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_RAD",    "profile to sky limit (radius)",   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_FLUX",   "profile to sky limit (flux)",     "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SKY_LIMIT_SLOPE",  "profile to sky limit (slope)",    "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS",            "analysis flags",                  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS2",           "analysis flags (2)",              "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "N_FRAMES",         "images overlapping peak",         "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "PADDING",          "padding for 8byte records",       "",                  1.0, 0.0);
+
+  return (TRUE);
+}
+
+int Send_CMF_PS1_V5 (int device, CMF_PS1_V5 *data, int Ndata, int copy) {
+
+  int Nwrite, Nbytes;
+  CMF_PS1_V5 *tmpdata;
+
+  Nbytes = Ndata * sizeof (CMF_PS1_V5);
+
+  if (copy) {
+    ALLOCATE (tmpdata, CMF_PS1_V5, Ndata);
+    memcpy (tmpdata, data, Nbytes);
+  } else {
+    tmpdata = data;
+  }
+
+  if (!gfits_convert_CMF_PS1_V5 ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5), Ndata, FALSE)) return (FALSE);
+
+  SendCommand (device, 16, "NVALUE: %6d", Ndata);
+  SendCommand (device, 16, "NBYTES: %6d", Nbytes);
+  Nwrite = write (device, tmpdata, Nbytes);
+  if (Nwrite != Nbytes) {
+    return (FALSE);
+  }
+  
+  /* perform handshaking? */
+
+  return (TRUE);
+}
+
+int Recv_CMF_PS1_V5 (int device, CMF_PS1_V5 **data, int *Ndata) {
+
+  int ndata;
+  IOBuffer message;
+  CMF_PS1_V5 *tmpdata;
+
+  ExpectCommand (device, 16, 1.0, &message);
+  sscanf (message.buffer, "%*s %d", &ndata);
+  FreeIOBuffer (&message);
+  
+  /* what is reasonable for timeout? */
+  ExpectMessage (device, 1.0, &message);
+  
+  tmpdata = (CMF_PS1_V5 *) message.buffer;
+  if (!gfits_convert_CMF_PS1_V5 ((unsigned char *) tmpdata, sizeof (CMF_PS1_V5), ndata, TRUE)) return (FALSE);
+
+  /* double-check data length? */
+  /* perform handshaking? */
+
+  *Ndata = ndata;
+  *data = tmpdata;
+
+  return (TRUE);
+}
+
Index: /trunk/Ohana/src/libdvo/src/dbExtractAverages.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dbExtractAverages.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dbExtractAverages.c	(revision 37035)
@@ -52,6 +52,5 @@
 dbValue dbExtractAverages (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
 
-  off_t i;
-  int Nsec;
+  // off_t i;
   dbValue value;
 
@@ -163,5 +162,5 @@
       break;
     case AVE_REF_COLOR:
-      value.Flt = average[0].refColor;
+      value.Flt = average[0].refColorBlue;
       break;
 
@@ -182,5 +181,125 @@
       break;
 
-    case AVE_MAG:
+    case AVE_PHOT:
+      // if we request mag:ave, use equiv for photcode (ie a given measure, say GPC1.g.XY01, will return g for mag:ave)
+      if  (field->photcode->type == PHOT_MAG) {
+	// this is an error
+	break;
+      }
+
+      // if we ask for 2MASS_K, etc (REF values), return NAN unless measure->code matches
+      if (field->photcode->type == PHOT_REF) {
+	// need to ensure measure exists.
+	break;
+      }
+
+      // if we ask for GPC1.g.XY03:rel, etc (DEP values), return NAN unless measure->code matches
+      if (field->photcode->type == PHOT_DEP) {
+	// again.
+	break;
+      }
+
+      switch (field->magOption) {
+	case MAG_OPTION_MAG:
+	  switch (field->magLevel) {
+	    case MAG_LEVEL_AVE:
+	      value.Flt = PhotAve  (field->photcode, average, secfilt, field->magClass, field->magSource); 
+	      break;
+	    case MAG_LEVEL_REF:
+	      // why is measure needed here?
+	      // PhotRef  (field->photcode, average, secfilt, measure, field->magClass, field->magSource); 
+	      break;
+	    case MAG_LEVEL_INST:
+	    case MAG_LEVEL_CAT:
+	    case MAG_LEVEL_SYS:
+	    case MAG_LEVEL_REL:
+	    case MAG_LEVEL_CAL:
+	    case MAG_LEVEL_NONE:
+	      break;
+	  }
+	  break;
+
+	case MAG_OPTION_ERR:
+	  switch (field->magLevel) {
+	    case MAG_LEVEL_AVE:
+	    case MAG_LEVEL_REF:
+	      value.Flt = PhotAveErr (field->photcode, average, secfilt, field->magClass, field->magSource);  
+	      break;
+	    case MAG_LEVEL_INST:
+	    case MAG_LEVEL_CAT:
+	    case MAG_LEVEL_SYS:
+	    case MAG_LEVEL_REL:
+	    case MAG_LEVEL_CAL:
+	    case MAG_LEVEL_NONE:
+	      break;
+	  }
+	  break;
+
+	case MAG_OPTION_FLUX:
+	  switch (field->magLevel) {
+	    case MAG_LEVEL_AVE:
+	      value.Flt = PhotFluxAve  (field->photcode, average, secfilt, field->magClass, field->magSource); 
+	      break;
+	    case MAG_LEVEL_REF:
+	      // value.Flt = PhotFluxRef  (equiv, average, secfilt, measure, field->magClass, field->magSource); 
+	      break;
+	    case MAG_LEVEL_INST:
+	    case MAG_LEVEL_CAT:
+	    case MAG_LEVEL_SYS:
+	    case MAG_LEVEL_REL:
+	    case MAG_LEVEL_CAL:
+	    case MAG_LEVEL_NONE:
+	      break;
+	  }
+	  break;
+
+	case MAG_OPTION_FLUX_ERR:
+	  switch (field->magLevel) {
+	    case MAG_LEVEL_AVE:
+	    case MAG_LEVEL_REF:
+	      // value.Flt = PhotFluxAveErr (equiv, average, secfilt, field->magClass, field->magSource);  
+	      break;
+	    case MAG_LEVEL_INST:
+	    case MAG_LEVEL_CAT:
+	    case MAG_LEVEL_SYS:
+	    case MAG_LEVEL_REL:
+	    case MAG_LEVEL_CAL:
+	    case MAG_LEVEL_NONE:
+	      break;
+	  }
+	  break;
+
+	case MAG_OPTION_STDEV:
+	case MAG_OPTION_CHISQ:
+	case MAG_OPTION_MIN:
+	case MAG_OPTION_MAX:
+	case MAG_OPTION_NCODE: {
+	  int Nsec = GetPhotcodeNsec (field->photcode->code);
+	  if (Nsec == -1) break;
+	  value.Int = secfilt[Nsec].Ncode;
+	  break;
+	}
+	case MAG_OPTION_NPHOT: {
+	  int Nsec = GetPhotcodeNsec (field->photcode->code);
+	  if (Nsec == -1) break;
+	  value.Int = secfilt[Nsec].Nused;
+	  break;
+	}
+	case MAG_OPTION_UC_DIST:
+	case MAG_OPTION_STACK_DET_ID:
+	  value.Int = PhotStackID (field->photcode, average, secfilt);
+	  break;
+	case MAG_OPTION_FLAGS: {
+	  int Nsec = GetPhotcodeNsec (field->photcode->code);
+	  if (Nsec == -1) break;
+	  value.Int = secfilt[Nsec].flags;
+	  break;
+	}
+	case MAG_OPTION_NONE:
+	  break;
+      }
+      break;
+
+# if (0)
       switch (field->magMode) {
 	case MAG_AVE:
@@ -228,5 +347,5 @@
 	    }
 	  } else {
-	    Nsec = GetPhotcodeNsec (field->photcode->code);
+	    int Nsec = GetPhotcodeNsec (field->photcode->code);
 	    if (Nsec == -1) break;
 	    value.Int = secfilt[Nsec].flags;
@@ -236,10 +355,10 @@
 	  // 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;
@@ -268,9 +387,9 @@
 	  break;
 
-	case MAG_20:
-	  value.Flt = PhotM20 (field->photcode, average, secfilt);
-	  break;
-	case MAG_80:
-	  value.Flt = PhotM80 (field->photcode, average, secfilt);
+	case MAG_MIN:
+	  value.Flt = PhotMmin (field->photcode, average, secfilt);
+	  break;
+	case MAG_MAX:
+	  value.Flt = PhotMmax (field->photcode, average, secfilt);
 	  break;
 	case MAG_UC_DIST:
@@ -301,4 +420,5 @@
       value.Flt = PhotXm (field->photcode, average, secfilt);
       break;
+# endif
     case AVE_TYPE:
       break;
Index: /trunk/Ohana/src/libdvo/src/dbExtractImages.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dbExtractImages.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dbExtractImages.c	(revision 37035)
@@ -376,5 +376,5 @@
 
     case IMAGE_REF_COLOR:
-      value.Flt = image[N].refColor;
+      value.Flt = image[N].refColorBlue;
       break;
   }
Index: /trunk/Ohana/src/libdvo/src/dbExtractMeasures.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dbExtractMeasures.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dbExtractMeasures.c	(revision 37035)
@@ -90,4 +90,5 @@
   dbValue value;
   double dT;
+  float dR, dD;
 
   Coords *mosaic, *fieldc;
@@ -99,8 +100,8 @@
 
   switch (field->ID) {
-    case MEAS_MAG: { /* magnitudes are already determined above */
+    case MEAS_PHOT: { /* magnitudes are already determined above */
       PhotCode *myEquiv = GetPhotcodeEquivbyCode (measure[0].photcode);
 
-      // if we request mag:ave, use equiv for photcode
+      // if we request mag:ave, use equiv for photcode (ie a given measure, say GPC1.g.XY01, will return g for mag:ave)
       if  (field->photcode->type == PHOT_MAG) {
 	equiv = myEquiv;
@@ -116,28 +117,11 @@
       // if we ask for g:ave, or other SEC-level values, return the corresponding field 
       if (field->photcode->type == PHOT_SEC) {
-	switch (field->magMode) {
+	switch (field->magLevel) {
 	  // measure-like : return non-NAN if measure.equiv.photcode matches field.photcode
-	  case MAG_INST:
-	  case MAG_CAT:
-	  case MAG_SYS:
-	  case MAG_REL:
-	  case MAG_CAL:
-	  case MAG_ERR:
-
-	  case MAG_APER_INST:
-	  case MAG_APER_CAT:
-	  case MAG_APER_SYS:
-	  case MAG_APER_REL:
-	  case MAG_APER_CAL:
-	  case MAG_APER_ERR:
-
-	  case MAG_KRON_INST:
-	  case MAG_KRON_CAT:
-	  case MAG_KRON_SYS:
-	  case MAG_KRON_REL:
-	  case MAG_KRON_CAL:
-	  case MAG_KRON_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;
@@ -145,25 +129,6 @@
 
 	    // mean-like : return value for the given photcode
-	  case MAG_AVE:
-	  case MAG_REF:
-	  case MAG_STDEV:
-	  case MAG_AVE_ERR:
-	  case MAG_CHISQ:
-	  case MAG_FLUX_PSF:
-	  case MAG_FLUX_PSF_ERR:
-
-	  case MAG_APER_AVE:
-
-	  case MAG_KRON_AVE:
-	  case MAG_FLUX_KRON:
-	  case MAG_FLUX_KRON_ERR:
-
-	  case MAG_20:
-	  case MAG_80:
-	  case MAG_UC_DIST:
-	  case MAG_STACK_DET_ID:
-
-	  case MAG_NCODE:
-	  case MAG_NPHOT:
+	  case MAG_LEVEL_AVE:
+	  case MAG_LEVEL_REF:
 	    equiv = field->photcode;
 	    goto valid_photcode;
@@ -177,131 +142,113 @@
 
   valid_photcode:
-      switch (field->magMode) {
-	case MAG_INST:
-	  value.Flt = PhotInst (measure);  
-	  break;
-	case MAG_CAT:
-	  value.Flt = PhotCat  (measure); 
-	  break;
-	case MAG_SYS:
-	  value.Flt = PhotSys  (measure, average, secfilt); 
-	  break;
-	case MAG_REL:
-	  value.Flt = PhotRel  (measure, average, secfilt); 
-	  break;
-	case MAG_CAL:
-	  value.Flt = PhotCal  (measure, average, secfilt, measure, equiv); 
-	  break;
-	case MAG_AVE:
-	  value.Flt = PhotAve  (equiv, average, secfilt); 
-	  break;
-	case MAG_REF:
-	  value.Flt = PhotRef  (equiv, average, secfilt, measure); 
-	  break;
-	case MAG_ERR:
-	  value.Flt = measure[0].dM;
-	  break;
-	case MAG_AVE_ERR:
-	  value.Flt = PhotAveErr  (equiv, average, secfilt); 
-	  break;
-
-	case MAG_APER_INST:
-	  value.Flt = PhotAperInst (measure); 
-	  break;
-	case MAG_APER_CAT:
-	  value.Flt = PhotAperCat (measure); 
-	  break;
-	case MAG_APER_SYS:
-	  value.Flt = PhotAperSys (measure, average, secfilt); 
-	  break;
-	case MAG_APER:
-	case MAG_APER_REL:
-	  value.Flt = PhotAperRel (measure, average, secfilt); 
-	  break;
-	case MAG_APER_CAL:
-	  value.Flt = PhotAperCal (measure, average, secfilt, measure, equiv); 
-	  break;
-	case MAG_APER_AVE:
-	  value.Flt = PhotAperAve (equiv, average, secfilt);
-	  break;
-	case MAG_APER_REF:
-	  value.Flt = PhotAperRef (equiv, average, secfilt, measure); 
-	  break;
-	case MAG_APER_ERR:
-	  value.Flt = measure[0].dM;
-	  break;
-
-	case MAG_KRON_INST:
-	  value.Flt = PhotKronInst (measure); 
-	  break;
-	case MAG_KRON_CAT:
-	  value.Flt = PhotKronCat (measure); 
-	  break;
-	case MAG_KRON_SYS:
-	  value.Flt = PhotKronSys (measure, average, secfilt); 
-	  break;
-	case MAG_KRON:
-	case MAG_KRON_REL:
-	  value.Flt = PhotKronRel (measure, average, secfilt); 
-	  break;
-	case MAG_KRON_CAL:
-	  value.Flt = PhotKronCal (measure, average, secfilt, measure, equiv); 
-	  break;
-	case MAG_KRON_AVE:
-	  value.Flt = PhotKronAve (equiv, average, secfilt);
-	  break;
-	case MAG_KRON_REF:
-	  value.Flt = PhotKronRef (equiv, average, secfilt, measure); 
-	  break;
-	case MAG_KRON_ERR:
-	  value.Flt = measure[0].dMkron;
-	  break;
-
-	case MAG_PHOT_FLAGS:
-	  if ((field->photcode->type == PHOT_REF) || (field->photcode->type == PHOT_DEP)) {
-	    value.Int = measure[0].photFlags;
+      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_NCODE:
-	  if (equiv == NULL) break;
-	  Nsec = GetPhotcodeNsec (equiv->code);
-	  if (Nsec == -1) break;
-	  value.Int = secfilt[Nsec].Ncode;
+	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_NPHOT:
-	  if (equiv == NULL) break;
-	  Nsec = GetPhotcodeNsec (equiv->code);
-	  if (Nsec == -1) break;
-	  value.Int = secfilt[Nsec].Nused;
+
+	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;
+	  }
 	  break;
 
-	case MAG_CHISQ:
-	  value.Flt = PhotXm (equiv, average, secfilt); 
+	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;
+	  }
 	  break;
-	case MAG_STDEV:
-	  value.Flt = PhotMstdev (equiv, average, secfilt);
-	  break;
-	case MAG_20:
-	  value.Flt = PhotM20 (equiv, average, secfilt);
-	  break;
-	case MAG_80:
-	  value.Flt = PhotM80 (equiv, average, secfilt);
-	  break;
-	case MAG_UC_DIST:
-	  value.Flt = PhotUCdist (equiv, average, secfilt); 
-	  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;
       }
@@ -309,8 +256,8 @@
     }
     case MEAS_RA: /* OK */
-      value.Flt = average[0].R - measure[0].dR / 3600.0;
+      value.Flt = measure[0].R;
       break;
     case MEAS_DEC: /* OK */
-      value.Flt = average[0].D - measure[0].dD / 3600.0;
+      value.Flt = measure[0].D;
       break;
     case MEAS_RA_AVE: /* OK */
@@ -323,5 +270,5 @@
     case MEAS_GLON:
       if (!haveGalacticMeas) {
-	ApplyTransform (&GLON_MEAS, &GLAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_galactic);
+	ApplyTransform (&GLON_MEAS, &GLAT_MEAS, measure[0].R, measure[0].D, celestial_to_galactic);
 	haveGalacticMeas = TRUE;
       }
@@ -330,5 +277,5 @@
     case MEAS_GLAT:
       if (!haveGalacticMeas) {
-	ApplyTransform (&GLON_MEAS, &GLAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_galactic);
+	ApplyTransform (&GLON_MEAS, &GLAT_MEAS, measure[0].R, measure[0].D, celestial_to_galactic);
 	haveGalacticMeas = TRUE;
       }
@@ -337,5 +284,5 @@
     case MEAS_ELON:
       if (!haveEclipticMeas) {
-	ApplyTransform (&ELON_MEAS, &ELAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_ecliptic);
+	ApplyTransform (&ELON_MEAS, &ELAT_MEAS, measure[0].R, measure[0].D, celestial_to_ecliptic);
 	haveEclipticMeas = TRUE;
       }
@@ -344,5 +291,5 @@
     case MEAS_ELAT:
       if (!haveEclipticMeas) {
-	ApplyTransform (&ELON_MEAS, &ELAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_ecliptic);
+	ApplyTransform (&ELON_MEAS, &ELAT_MEAS, measure[0].R, measure[0].D, celestial_to_ecliptic);
 	haveEclipticMeas = TRUE;
       }
@@ -441,16 +388,18 @@
     // the error.
     case MEAS_RA_OFFSET: /* OK */
-      value.Flt = measure[0].dR;
+      value.Flt = dvoOffsetR (measure, average);
       break;
     case MEAS_DEC_OFFSET: /* OK */
-      value.Flt = measure[0].dD;
+      value.Flt = dvoOffsetD (measure, average);
       break;
     case MEAS_RA_FIT_OFFSET: /* OK */
       dT = (measure[0].t - average[0].Tmean) / (86400*365.25);
-      value.Flt = average[0].uR * dT + measure[0].dR;
+      dR = dvoOffsetR (measure, average);
+      value.Flt = average[0].uR * dT + dR;
       break;
     case MEAS_DEC_FIT_OFFSET: /* OK */
       dT = (measure[0].t - average[0].Tmean) / (86400*365.25);
-      value.Flt = average[0].uD * dT + measure[0].dD;
+      dD = dvoOffsetD (measure, average);
+      value.Flt = average[0].uD * dT + dD;
       break;
     case MEAS_RA_OFFSET_ERR: /* OK */
@@ -527,5 +476,5 @@
 
     case MEAS_REF_COLOR:
-      value.Flt = average[0].refColor;
+      value.Flt = average[0].refColorBlue;
       break;
 
@@ -556,6 +505,6 @@
 	// measure.xccd if we need it
 	Image *image;
-	ra  = average[0].R - measure[0].dR / 3600.0;
-	dec = average[0].D - measure[0].dD / 3600.0;
+	ra  = measure[0].R;
+	dec = measure[0].D;
 	image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID);
 	if (image == NULL) break;
@@ -571,6 +520,6 @@
       {
 	Image *image;
-	ra  = average[0].R - measure[0].dR / 3600.0;
-	dec = average[0].D - measure[0].dD / 3600.0;
+	ra  = measure[0].R;
+	dec = measure[0].D;
 	image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID);
 	if (image == NULL) break;
@@ -607,6 +556,6 @@
 	}
 	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);
       }
@@ -624,6 +573,6 @@
 	}
 	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);
       }
@@ -642,6 +591,6 @@
 	}
 	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);
       }
@@ -659,6 +608,6 @@
 	}
 	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);
       }
@@ -773,16 +722,16 @@
       break;
 
-    case MEAS_FLUX_PSF: /* OK */
-      value.Flt = measure[0].FluxPSF;
-      break;
-    case MEAS_FLUX_PSF_ERR: /* OK */
-      value.Flt = measure[0].dFluxPSF;
-      break;
-    case MEAS_FLUX_KRON: /* OK */
-      value.Flt = measure[0].FluxKron;
-      break;
-    case MEAS_FLUX_KRON_ERR: /* OK */
-      value.Flt = measure[0].dFluxKron;
-      break;
+    // case MEAS_FLUX_PSF: /* OK */
+    //   value.Flt = measure[0].FluxPSF;
+    //   break;
+    // case MEAS_FLUX_PSF_ERR: /* OK */
+    //   value.Flt = measure[0].dFluxPSF;
+    //   break;
+    // case MEAS_FLUX_KRON: /* OK */
+    //   value.Flt = measure[0].FluxKron;
+    //   break;
+    // case MEAS_FLUX_KRON_ERR: /* OK */
+    //   value.Flt = measure[0].dFluxKron;
+    //   break;
   }
   return (value);
Index: /trunk/Ohana/src/libdvo/src/dbFields.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dbFields.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dbFields.c	(revision 37035)
@@ -9,9 +9,4 @@
   for (i = 0; i < Nfields; i++) {
     if (fields[i].name != NULL) free (fields[i].name);
-    if (fields[i].photcode != NULL) {
-      if (fields[i].photcode[0].type == PHOT_MAG) {
-        free (fields[i].photcode);
-      }
-    }
   }
   free (fields);
@@ -24,8 +19,70 @@
   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) {
 
@@ -85,6 +142,6 @@
   if (!strcasecmp (string, "nphot"))       return (MAG_NPHOT);
   if (!strcasecmp (string, "stdev"))       return (MAG_STDEV);
-  if (!strcasecmp (string, "20"))          return (MAG_20);
-  if (!strcasecmp (string, "80"))          return (MAG_80);
+  if (!strcasecmp (string, "min"))         return (MAG_MIN);
+  if (!strcasecmp (string, "max"))         return (MAG_MAX);
   if (!strcasecmp (string, "ucdist"))      return (MAG_UC_DIST);
   if (!strcasecmp (string, "stackDetectID")) return (MAG_STACK_DET_ID);
@@ -95,216 +152,152 @@
   return (MAG_NONE);
 }
-
-PhotCode *ParsePhotcodeField (char *field, int *mode, int defMode) {
-
-  int useDefault;
-  char *tmpstring, *p;
-  PhotCode *code;
-
-  *mode = defMode;
-  useDefault = TRUE;
-
-  p = strchr (field, ':');
-  if (p != NULL) {
-    *mode = GetMagMode (p + 1);
-    useDefault = FALSE;
-    if (*mode == MAG_NONE) return (NULL);
-    tmpstring = strncreate (field, p - field);
-  } else {
-    tmpstring = strcreate (field);
-  }
-  if (!strcasecmp (tmpstring, "MAG")) {
-    ALLOCATE (code, PhotCode, 1);
-    code[0].code = 0;
-    strcpy (code[0].name, "MAG");
-    code[0].type = PHOT_MAG;
-    // the field call 'mag' is only valid for mextract
-    // it should default to REL, but other types should default to AVE
-    if (useDefault) {
-      *mode = MAG_REL;
+# endif
+
+// field may be of the form mag:psf:inst:wrp.  except for the first subword, 
+// the words may be in any order
+int ParsePhotcodeField (dbField *field, char *fieldName, int fieldID) {
+
+  int j;
+
+  // defaults:
+  field->ID = fieldID; // change if not true in the end?
+
+  // check what options are provided.  do not allow duplicate types
+  // except mag and flux may exist with err
+  dvoMagSourceType mySource = MAG_SRC_NONE;
+  dvoMagLevelType myLevel = MAG_LEVEL_NONE;
+  dvoMagClassType myClass = MAG_CLASS_NONE;
+  dvoMagOptionType myOption = MAG_OPTION_NONE;
+
+  field->magSource = MAG_SRC_CHP;
+  field->magLevel  = MAG_LEVEL_AVE;
+  field->magClass  = MAG_CLASS_PSF;
+  field->magOption = MAG_OPTION_MAG;
+
+  // make a local working copy of fieldName and replace ':' with spaces
+  char *fieldCopy = strcreate(fieldName);
+  for (j = 0; fieldCopy[j]; j++) { 
+    if (fieldCopy[j] == ':') fieldCopy[j] = ' '; 
+  }
+
+  char *firstWord = getword(fieldCopy);
+  
+  // firstWord may be either flux, mag or photcode
+  if (!strcasecmp (firstWord, "MAG")) {
+    // default level for 'mag' is rel
+    field->magLevel  = MAG_LEVEL_REL;
+    myOption = MAG_OPTION_MAG;
+  } 
+  if (!strcasecmp (firstWord, "FLUX")) {
+    // default level for 'flux' is rel
+    field->magLevel  = MAG_LEVEL_REL;
+    myOption = MAG_OPTION_FLUX;
+  } 
+  PhotCode *code = GetPhotcodebyName (firstWord);
+  free (firstWord);
+
+  if (!code) return FALSE;
+
+  // defaults for photcode clases
+  if (code->type == PHOT_DEP) {
+    field->magLevel = MAG_LEVEL_REL;
+  }
+  if (code->type == PHOT_SEC) {
+    field->magLevel = MAG_LEVEL_AVE;
+  }
+  if (code->type == PHOT_REF) {
+    field->magLevel = MAG_LEVEL_CAT;
+    // is this one required?
+  }
+  
+  // look at the remaining words and assign properties as approrpiate
+  char *ptr = skipword(fieldCopy);
+  while (ptr) {
+
+    char *word = getword(ptr);
+    if (!word) break;
+    
+    dvoMagSourceType source = GetMagSource (word);
+    if (source != MAG_SRC_NONE) {
+      if (mySource != MAG_SRC_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; } 
+      mySource = source;
+      ptr = skipword (ptr);
+      continue;
     }
-    free (tmpstring);
-    return (code);
-  }
-  code = GetPhotcodebyName (tmpstring);
-  if (!code) {
-      return NULL;
-  }
-
-  // enforce compatibility
-  if (useDefault) {
-    if (code[0].type == PHOT_REF) {
-      *mode = MAG_CAT;
+
+    dvoMagLevelType level = GetMagLevel (word);
+    if (level != MAG_LEVEL_NONE) {
+      if (myLevel != MAG_LEVEL_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; } 
+      myLevel = level;
+      ptr = skipword (ptr);
+      continue;
     }
-    if (code[0].type == PHOT_DEP) {
-      *mode = MAG_REL;
+
+    dvoMagClassType class = GetMagClass (word);
+    if (class != MAG_CLASS_NONE) {
+      if (myClass != MAG_CLASS_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; } 
+      myClass = class;
+      ptr = skipword (ptr);
+      continue;
     }
-  } 
-  free (tmpstring);
-  return (code);
-}
-
-# define ESCAPE(F,M,T) { \
-  field->ID = (F); \
-  field->magMode = (M); \
-  field->type = (T); \
-  field->photcode = NULL; \
-  return (TRUE); }
-
-int ParseMeasureField (dbField *field, char *fieldName) {
-
-  int mode;
-  PhotCode *code;
-
-  field->table = DVO_TABLE_MEASURE;
-  field->name  = strcreate (fieldName);
-
-  if (!strcasecmp (fieldName, "GLON"))       {
-    dbExtractMeasuresInitTransform (COORD_GALACTIC);
-    ESCAPE (MEAS_GLON, MAG_NONE, OPIHI_FLT);
-  }
-  if (!strcasecmp (fieldName, "GLAT")) {
-    dbExtractMeasuresInitTransform (COORD_GALACTIC);
-    ESCAPE (MEAS_GLAT, MAG_NONE, OPIHI_FLT);
-  }
-  if (!strcasecmp (fieldName, "GLON:AVE")) {
-    dbExtractMeasuresInitTransform (COORD_GALACTIC);
-    ESCAPE (MEAS_GLON_AVE, MAG_NONE, OPIHI_FLT);
-  }
-  if (!strcasecmp (fieldName, "GLAT:AVE")) {
-    dbExtractMeasuresInitTransform (COORD_GALACTIC);
-    ESCAPE (MEAS_GLAT_AVE, MAG_NONE, OPIHI_FLT);
-  }
-
-  if (!strcasecmp (fieldName, "ELON"))       {
-    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
-    ESCAPE (MEAS_ELON, MAG_NONE, OPIHI_FLT);
-  }
-  if (!strcasecmp (fieldName, "ELAT")) {
-    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
-    ESCAPE (MEAS_ELAT, MAG_NONE, OPIHI_FLT);
-  }
-  if (!strcasecmp (fieldName, "ELON:AVE")) {
-    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
-    ESCAPE (MEAS_ELON_AVE, MAG_NONE, OPIHI_FLT);
-  }
-  if (!strcasecmp (fieldName, "ELAT:AVE")) {
-    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
-    ESCAPE (MEAS_ELAT_AVE, MAG_NONE, OPIHI_FLT);
-  }
-
-  if (!strcasecmp (fieldName, "RA"))         	 ESCAPE (MEAS_RA,             MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "DEC"))        	 ESCAPE (MEAS_DEC,            MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "RA:AVE"))     	 ESCAPE (MEAS_RA_AVE,         MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "DEC:AVE"))    	 ESCAPE (MEAS_DEC_AVE,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "RA:ERR"))     	 ESCAPE (MEAS_RA_AVE_ERR,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "DEC:ERR"))    	 ESCAPE (MEAS_DEC_AVE_ERR,    MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "uRA"))        	 ESCAPE (MEAS_U_RA,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "uDEC"))       	 ESCAPE (MEAS_U_DEC,          MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "duRA"))       	 ESCAPE (MEAS_U_RA_ERR,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "duDEC"))      	 ESCAPE (MEAS_U_DEC_ERR,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "PAR"))        	 ESCAPE (MEAS_PAR,            MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dPAR"))       	 ESCAPE (MEAS_PAR_ERR,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dR"))         	 ESCAPE (MEAS_RA_OFFSET,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dD"))         	 ESCAPE (MEAS_DEC_OFFSET,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dR:FIT"))     	 ESCAPE (MEAS_RA_FIT_OFFSET,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dD:FIT"))     	 ESCAPE (MEAS_DEC_FIT_OFFSET, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dR:ERR"))     	 ESCAPE (MEAS_RA_OFFSET_ERR,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dD:ERR"))     	 ESCAPE (MEAS_DEC_OFFSET_ERR, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ChiSqPos"))       ESCAPE (MEAS_CHISQ_POS,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ChiSqPM"))        ESCAPE (MEAS_CHISQ_PM,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ChiSqPar"))       ESCAPE (MEAS_CHISQ_PAR,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Tmean"))          ESCAPE (MEAS_TMEAN,          MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Trange"))         ESCAPE (MEAS_TRANGE,         MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "nmeas"))      	 ESCAPE (MEAS_NMEAS,          MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "nmiss"))      	 ESCAPE (MEAS_NMISS,          MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "npos"))      	 ESCAPE (MEAS_NPOS,           MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "OBJFLAGS"))   	 ESCAPE (MEAS_OBJ_FLAGS,      MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "OBJ_FLAGS"))   	 ESCAPE (MEAS_OBJ_FLAGS,      MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "OBJ_PHOT_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS,      MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "SECFLAGS"))   	 ESCAPE (MEAS_SECFILT_FLAGS,      MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "SEC_FLAGS"))   	 ESCAPE (MEAS_SECFILT_FLAGS,      MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "SECFILT_FLAGS"))  ESCAPE (MEAS_SECFILT_FLAGS,      MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "DB_FLAGS"))   	 ESCAPE (MEAS_DB_FLAGS,       MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "PHOT_FLAGS")) 	 ESCAPE (MEAS_PHOT_FLAGS,     MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "DBFLAGS"))   	 ESCAPE (MEAS_DB_FLAGS,       MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "PHOTFLAGS")) 	 ESCAPE (MEAS_PHOT_FLAGS,     MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "AIRMASS"))    	 ESCAPE (MEAS_AIRMASS,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "MEAN_AIRMASS"))   ESCAPE (MEAS_MEAN_AIRMASS,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ALT"))        	 ESCAPE (MEAS_ALT,            MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "AZ"))         	 ESCAPE (MEAS_AZ,             MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "EXPTIME"))    	 ESCAPE (MEAS_EXPTIME,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "PHOTCODE"))   	 ESCAPE (MEAS_PHOTCODE,       MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "PHOTCODE:KLAM"))  ESCAPE (MEAS_PHOTCODE_KLAM,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "PHOTCODE:C"))     ESCAPE (MEAS_PHOTCODE_C,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "PHOTCODE:EQUIV")) ESCAPE (MEAS_PHOTCODE_EQUIV, MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "TIME"))       	 ESCAPE (MEAS_TIME,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM"))       	 ESCAPE (MEAS_FWHM,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MAJ"))   	 ESCAPE (MEAS_FWHM_MAJ,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MIN"))   	 ESCAPE (MEAS_FWHM_MIN,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "THETA"))      	 ESCAPE (MEAS_THETA,          MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "POSANGLE"))     	 ESCAPE (MEAS_POSANGLE,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "PLATESCALE"))   	 ESCAPE (MEAS_PLATESCALE,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "MXX"))       	 ESCAPE (MEAS_MXX,            MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "MYY"))       	 ESCAPE (MEAS_MYY,            MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "MXY"))       	 ESCAPE (MEAS_MXY,            MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "DOPHOT"))     	 ESCAPE (MEAS_DOPHOT,         MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "XCCD"))       	 ESCAPE (MEAS_XCCD,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "YCCD"))       	 ESCAPE (MEAS_YCCD,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "XCCD:ERR"))   	 ESCAPE (MEAS_XCCD_ERR,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "YCCD:ERR"))   	 ESCAPE (MEAS_YCCD_ERR,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "XFIX"))       	 ESCAPE (MEAS_XFIX,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "YFIX"))       	 ESCAPE (MEAS_YFIX,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "POS_SYS_ERR"))    ESCAPE (MEAS_POS_SYS_ERR,    MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "XFIELD"))    	 ESCAPE (MEAS_XFIELD,         MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "YFIELD"))    	 ESCAPE (MEAS_YFIELD,         MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "XMOSAIC"))    	 ESCAPE (MEAS_XMOSAIC,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "YMOSAIC"))    	 ESCAPE (MEAS_YMOSAIC,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "XCHIP"))      	 ESCAPE (MEAS_XCCD,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "YCHIP"))      	 ESCAPE (MEAS_YCCD,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "XFPA"))       	 ESCAPE (MEAS_XMOSAIC,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "YFPA"))       	 ESCAPE (MEAS_YMOSAIC,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "DETID"))      	 ESCAPE (MEAS_DET_ID,         MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "OBJID"))      	 ESCAPE (MEAS_OBJ_ID,         MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "CATID"))      	 ESCAPE (MEAS_CAT_ID,         MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "IMAGEID"))    	 ESCAPE (MEAS_IMAGE_ID,       MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "EXTERNID"))    	 ESCAPE (MEAS_EXTERN_ID,      MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "EXPNAME"))    	 ESCAPE (MEAS_EXPNAME_AS_INT, MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "PSF_QF"))     	 ESCAPE (MEAS_PSF_QF,         MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "PSF_QF_PERFECT")) ESCAPE (MEAS_PSF_QF_PERFECT, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "PSF_CHISQ"))  	 ESCAPE (MEAS_PSF_CHISQ,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "PSF_NDOF"))  	 ESCAPE (MEAS_PSF_NDOF,       MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "PSF_NPIX"))  	 ESCAPE (MEAS_PSF_NPIX,       MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "CR_NSIGMA"))  	 ESCAPE (MEAS_CR_NSIGMA,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "EXT_NSIGMA")) 	 ESCAPE (MEAS_EXT_NSIGMA,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "SKY"))        	 ESCAPE (MEAS_SKY,            MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "SKY_ERR"))    	 ESCAPE (MEAS_dSKY,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "MCAL_OFFSET"))    ESCAPE (MEAS_MCAL_OFFSET,    MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FLAT"))    	 ESCAPE (MEAS_FLAT,           MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "CENTER_OFFSET"))  ESCAPE (MEAS_CENTER_OFFSET,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FLUX"))       	 ESCAPE (MEAS_FLUX_PSF,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FLUX_ERR"))       ESCAPE (MEAS_FLUX_PSF_ERR,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FLUX_PSF"))       ESCAPE (MEAS_FLUX_PSF,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FLUX_PSF_ERR"))   ESCAPE (MEAS_FLUX_PSF_ERR,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FLUX_KRON"))      ESCAPE (MEAS_FLUX_KRON,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FLUX_KRON_ERR"))  ESCAPE (MEAS_FLUX_KRON_ERR,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "REF_COLOR"))      ESCAPE (MEAS_REF_COLOR,      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;
@@ -314,11 +307,161 @@
   }
   field->photcode = code;
+  return TRUE;
+}
+
+// field needs to be initialized with dbInitField()
+# define ESCAPE(F,T) { \
+  field->ID = (F); \
+  field->type = (T); \
+  return (TRUE); }
+
+int ParseMeasureField (dbField *field, char *fieldName) {
+
+  field->table = DVO_TABLE_MEASURE;
+  field->name  = strcreate (fieldName);
+
+  if (!strcasecmp (fieldName, "GLON"))       {
+    dbExtractMeasuresInitTransform (COORD_GALACTIC);
+    ESCAPE (MEAS_GLON, OPIHI_FLT);
+  }
+  if (!strcasecmp (fieldName, "GLAT")) {
+    dbExtractMeasuresInitTransform (COORD_GALACTIC);
+    ESCAPE (MEAS_GLAT, OPIHI_FLT);
+  }
+  if (!strcasecmp (fieldName, "GLON:AVE")) {
+    dbExtractMeasuresInitTransform (COORD_GALACTIC);
+    ESCAPE (MEAS_GLON_AVE, OPIHI_FLT);
+  }
+  if (!strcasecmp (fieldName, "GLAT:AVE")) {
+    dbExtractMeasuresInitTransform (COORD_GALACTIC);
+    ESCAPE (MEAS_GLAT_AVE, OPIHI_FLT);
+  }
+
+  if (!strcasecmp (fieldName, "ELON"))       {
+    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
+    ESCAPE (MEAS_ELON, OPIHI_FLT);
+  }
+  if (!strcasecmp (fieldName, "ELAT")) {
+    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
+    ESCAPE (MEAS_ELAT, OPIHI_FLT);
+  }
+  if (!strcasecmp (fieldName, "ELON:AVE")) {
+    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
+    ESCAPE (MEAS_ELON_AVE, OPIHI_FLT);
+  }
+  if (!strcasecmp (fieldName, "ELAT:AVE")) {
+    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
+    ESCAPE (MEAS_ELAT_AVE, OPIHI_FLT);
+  }
+
+  if (!strcasecmp (fieldName, "RA"))         	 ESCAPE (MEAS_RA,             OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DEC"))        	 ESCAPE (MEAS_DEC,            OPIHI_FLT);
+  if (!strcasecmp (fieldName, "RA:AVE"))     	 ESCAPE (MEAS_RA_AVE,         OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DEC:AVE"))    	 ESCAPE (MEAS_DEC_AVE,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "RA:ERR"))     	 ESCAPE (MEAS_RA_AVE_ERR,     OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DEC:ERR"))    	 ESCAPE (MEAS_DEC_AVE_ERR,    OPIHI_FLT);
+  if (!strcasecmp (fieldName, "uRA"))        	 ESCAPE (MEAS_U_RA,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "uDEC"))       	 ESCAPE (MEAS_U_DEC,          OPIHI_FLT);
+  if (!strcasecmp (fieldName, "duRA"))       	 ESCAPE (MEAS_U_RA_ERR,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "duDEC"))      	 ESCAPE (MEAS_U_DEC_ERR,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "PAR"))        	 ESCAPE (MEAS_PAR,            OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dPAR"))       	 ESCAPE (MEAS_PAR_ERR,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dR"))         	 ESCAPE (MEAS_RA_OFFSET,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dD"))         	 ESCAPE (MEAS_DEC_OFFSET,     OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dR:FIT"))     	 ESCAPE (MEAS_RA_FIT_OFFSET,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dD:FIT"))     	 ESCAPE (MEAS_DEC_FIT_OFFSET, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dR:ERR"))     	 ESCAPE (MEAS_RA_OFFSET_ERR,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dD:ERR"))     	 ESCAPE (MEAS_DEC_OFFSET_ERR, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "ChiSqPos"))       ESCAPE (MEAS_CHISQ_POS,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "ChiSqPM"))        ESCAPE (MEAS_CHISQ_PM,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "ChiSqPar"))       ESCAPE (MEAS_CHISQ_PAR,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Tmean"))          ESCAPE (MEAS_TMEAN,          OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Trange"))         ESCAPE (MEAS_TRANGE,         OPIHI_FLT);
+  if (!strcasecmp (fieldName, "nmeas"))      	 ESCAPE (MEAS_NMEAS,          OPIHI_INT);
+  if (!strcasecmp (fieldName, "nmiss"))      	 ESCAPE (MEAS_NMISS,          OPIHI_INT);
+  if (!strcasecmp (fieldName, "npos"))      	 ESCAPE (MEAS_NPOS,           OPIHI_INT);
+  if (!strcasecmp (fieldName, "OBJFLAGS"))   	 ESCAPE (MEAS_OBJ_FLAGS,      OPIHI_INT);
+  if (!strcasecmp (fieldName, "OBJ_FLAGS"))   	 ESCAPE (MEAS_OBJ_FLAGS,      OPIHI_INT);
+  if (!strcasecmp (fieldName, "OBJ_PHOT_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS,      OPIHI_INT);
+  if (!strcasecmp (fieldName, "SECFLAGS"))   	 ESCAPE (MEAS_SECFILT_FLAGS,      OPIHI_INT);
+  if (!strcasecmp (fieldName, "SEC_FLAGS"))   	 ESCAPE (MEAS_SECFILT_FLAGS,      OPIHI_INT);
+  if (!strcasecmp (fieldName, "SECFILT_FLAGS"))  ESCAPE (MEAS_SECFILT_FLAGS,      OPIHI_INT);
+  if (!strcasecmp (fieldName, "DB_FLAGS"))   	 ESCAPE (MEAS_DB_FLAGS,       OPIHI_INT);
+  if (!strcasecmp (fieldName, "PHOT_FLAGS")) 	 ESCAPE (MEAS_PHOT_FLAGS,     OPIHI_INT);
+  if (!strcasecmp (fieldName, "DBFLAGS"))   	 ESCAPE (MEAS_DB_FLAGS,       OPIHI_INT);
+  if (!strcasecmp (fieldName, "PHOTFLAGS")) 	 ESCAPE (MEAS_PHOT_FLAGS,     OPIHI_INT);
+  if (!strcasecmp (fieldName, "AIRMASS"))    	 ESCAPE (MEAS_AIRMASS,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "MEAN_AIRMASS"))   ESCAPE (MEAS_MEAN_AIRMASS,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "ALT"))        	 ESCAPE (MEAS_ALT,            OPIHI_FLT);
+  if (!strcasecmp (fieldName, "AZ"))         	 ESCAPE (MEAS_AZ,             OPIHI_FLT);
+  if (!strcasecmp (fieldName, "EXPTIME"))    	 ESCAPE (MEAS_EXPTIME,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "PHOTCODE"))   	 ESCAPE (MEAS_PHOTCODE,       OPIHI_INT);
+  if (!strcasecmp (fieldName, "PHOTCODE:KLAM"))  ESCAPE (MEAS_PHOTCODE_KLAM,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "PHOTCODE:C"))     ESCAPE (MEAS_PHOTCODE_C,     OPIHI_FLT);
+  if (!strcasecmp (fieldName, "PHOTCODE:EQUIV")) ESCAPE (MEAS_PHOTCODE_EQUIV, OPIHI_INT);
+  if (!strcasecmp (fieldName, "TIME"))       	 ESCAPE (MEAS_TIME,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM"))       	 ESCAPE (MEAS_FWHM,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MAJ"))   	 ESCAPE (MEAS_FWHM_MAJ,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MIN"))   	 ESCAPE (MEAS_FWHM_MIN,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "THETA"))      	 ESCAPE (MEAS_THETA,          OPIHI_FLT);
+  if (!strcasecmp (fieldName, "POSANGLE"))     	 ESCAPE (MEAS_POSANGLE,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "PLATESCALE"))   	 ESCAPE (MEAS_PLATESCALE,     OPIHI_FLT);
+  if (!strcasecmp (fieldName, "MXX"))       	 ESCAPE (MEAS_MXX,            OPIHI_FLT);
+  if (!strcasecmp (fieldName, "MYY"))       	 ESCAPE (MEAS_MYY,            OPIHI_FLT);
+  if (!strcasecmp (fieldName, "MXY"))       	 ESCAPE (MEAS_MXY,            OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DOPHOT"))     	 ESCAPE (MEAS_DOPHOT,         OPIHI_INT);
+  if (!strcasecmp (fieldName, "XCCD"))       	 ESCAPE (MEAS_XCCD,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "YCCD"))       	 ESCAPE (MEAS_YCCD,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "XCCD:ERR"))   	 ESCAPE (MEAS_XCCD_ERR,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "YCCD:ERR"))   	 ESCAPE (MEAS_YCCD_ERR,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "XFIX"))       	 ESCAPE (MEAS_XFIX,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "YFIX"))       	 ESCAPE (MEAS_YFIX,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "POS_SYS_ERR"))    ESCAPE (MEAS_POS_SYS_ERR,    OPIHI_FLT);
+  if (!strcasecmp (fieldName, "XFIELD"))    	 ESCAPE (MEAS_XFIELD,         OPIHI_FLT);
+  if (!strcasecmp (fieldName, "YFIELD"))    	 ESCAPE (MEAS_YFIELD,         OPIHI_FLT);
+  if (!strcasecmp (fieldName, "XMOSAIC"))    	 ESCAPE (MEAS_XMOSAIC,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "YMOSAIC"))    	 ESCAPE (MEAS_YMOSAIC,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "XCHIP"))      	 ESCAPE (MEAS_XCCD,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "YCHIP"))      	 ESCAPE (MEAS_YCCD,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "XFPA"))       	 ESCAPE (MEAS_XMOSAIC,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "YFPA"))       	 ESCAPE (MEAS_YMOSAIC,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DETID"))      	 ESCAPE (MEAS_DET_ID,         OPIHI_INT);
+  if (!strcasecmp (fieldName, "OBJID"))      	 ESCAPE (MEAS_OBJ_ID,         OPIHI_INT);
+  if (!strcasecmp (fieldName, "CATID"))      	 ESCAPE (MEAS_CAT_ID,         OPIHI_INT);
+  if (!strcasecmp (fieldName, "IMAGEID"))    	 ESCAPE (MEAS_IMAGE_ID,       OPIHI_INT);
+  if (!strcasecmp (fieldName, "EXTERNID"))    	 ESCAPE (MEAS_EXTERN_ID,      OPIHI_INT);
+  if (!strcasecmp (fieldName, "EXPNAME"))    	 ESCAPE (MEAS_EXPNAME_AS_INT, OPIHI_INT);
+  if (!strcasecmp (fieldName, "PSF_QF"))     	 ESCAPE (MEAS_PSF_QF,         OPIHI_FLT);
+  if (!strcasecmp (fieldName, "PSF_QF_PERFECT")) ESCAPE (MEAS_PSF_QF_PERFECT, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "PSF_CHISQ"))  	 ESCAPE (MEAS_PSF_CHISQ,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "PSF_NDOF"))  	 ESCAPE (MEAS_PSF_NDOF,       OPIHI_INT);
+  if (!strcasecmp (fieldName, "PSF_NPIX"))  	 ESCAPE (MEAS_PSF_NPIX,       OPIHI_INT);
+  if (!strcasecmp (fieldName, "CR_NSIGMA"))  	 ESCAPE (MEAS_CR_NSIGMA,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "EXT_NSIGMA")) 	 ESCAPE (MEAS_EXT_NSIGMA,     OPIHI_FLT);
+  if (!strcasecmp (fieldName, "SKY"))        	 ESCAPE (MEAS_SKY,            OPIHI_FLT);
+  if (!strcasecmp (fieldName, "SKY_ERR"))    	 ESCAPE (MEAS_dSKY,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "MCAL_OFFSET"))    ESCAPE (MEAS_MCAL_OFFSET,    OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FLAT"))    	 ESCAPE (MEAS_FLAT,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "CENTER_OFFSET"))  ESCAPE (MEAS_CENTER_OFFSET,  OPIHI_FLT);
+  // if (!strcasecmp (fieldName, "FLUX"))       	 ESCAPE (MEAS_FLUX_PSF,       OPIHI_FLT);
+  // if (!strcasecmp (fieldName, "FLUX_ERR"))       ESCAPE (MEAS_FLUX_PSF_ERR,   OPIHI_FLT);
+  // if (!strcasecmp (fieldName, "FLUX_PSF"))       ESCAPE (MEAS_FLUX_PSF,       OPIHI_FLT);
+  // if (!strcasecmp (fieldName, "FLUX_PSF_ERR"))   ESCAPE (MEAS_FLUX_PSF_ERR,   OPIHI_FLT);
+  // if (!strcasecmp (fieldName, "FLUX_KRON"))      ESCAPE (MEAS_FLUX_KRON,      OPIHI_FLT);
+  // if (!strcasecmp (fieldName, "FLUX_KRON_ERR"))  ESCAPE (MEAS_FLUX_KRON_ERR,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "REF_COLOR"))      ESCAPE (MEAS_REF_COLOR,      OPIHI_FLT);
+
+  // for words that don't parse, try a photcode
+
+  // check for code:mode in photcode name 
+  if (!ParsePhotcodeField (field, fieldName, MEAS_PHOT)) {
+    gprint (GP_ERR, "unknown field '%s' for measurement table in DVO database\n", fieldName);
+    return (FALSE);
+  }
+
   return (TRUE);
 }
 
 int ParseAverageField (dbField *field, char *fieldName) {
-
-  int mode;
-  PhotCode *code;
 
   field->table = DVO_TABLE_AVERAGE;
@@ -329,9 +472,9 @@
   if (!strcasecmp (fieldName, "GLON"))  { 
     dbExtractAveragesInitTransform (COORD_GALACTIC);
-    ESCAPE (AVE_GLON, MAG_NONE, OPIHI_FLT);
+    ESCAPE (AVE_GLON, OPIHI_FLT);
   }
   if (!strcasecmp (fieldName, "GLAT"))  {
     dbExtractAveragesInitTransform (COORD_GALACTIC);
-    ESCAPE (AVE_GLAT, MAG_NONE, OPIHI_FLT);
+    ESCAPE (AVE_GLAT, OPIHI_FLT);
   }
 
@@ -340,75 +483,59 @@
   if (!strcasecmp (fieldName, "ELON"))  { 
     dbExtractAveragesInitTransform (COORD_ECLIPTIC);
-    ESCAPE (AVE_ELON, MAG_NONE, OPIHI_FLT);
+    ESCAPE (AVE_ELON, OPIHI_FLT);
   }
   if (!strcasecmp (fieldName, "ELAT"))  {
     dbExtractAveragesInitTransform (COORD_ECLIPTIC);
-    ESCAPE (AVE_ELAT, MAG_NONE, OPIHI_FLT);
-  }
-
-  if (!strcasecmp (fieldName, "RA"))          ESCAPE (AVE_RA,          MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "DEC"))         ESCAPE (AVE_DEC,         MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "GLON"))        ESCAPE (AVE_GLON,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "GLAT"))        ESCAPE (AVE_GLAT,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ELON"))        ESCAPE (AVE_ELON,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ELAT"))        ESCAPE (AVE_ELAT,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dRA"))         ESCAPE (AVE_RA_ERR,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dDEC"))        ESCAPE (AVE_DEC_ERR,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "uRA"))         ESCAPE (AVE_U_RA,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "uDEC"))        ESCAPE (AVE_U_DEC,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "duRA"))        ESCAPE (AVE_U_RA_ERR,    MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "duDEC"))       ESCAPE (AVE_U_DEC_ERR,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "PAR"))         ESCAPE (AVE_PAR,         MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dPAR"))        ESCAPE (AVE_PAR_ERR,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ChiSqPos"))    ESCAPE (AVE_CHISQ_POS,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ChiSqPM"))     ESCAPE (AVE_CHISQ_PM,    MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ChiSqPar"))    ESCAPE (AVE_CHISQ_PAR,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Tmean"))       ESCAPE (AVE_TMEAN,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Trange"))      ESCAPE (AVE_TRANGE,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "psfqf"))       ESCAPE (AVE_PSF_QF,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "psfqfperf"))   ESCAPE (AVE_PSF_QF_PERF, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "psf_qf"))      ESCAPE (AVE_PSF_QF,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "psf_qf_perf")) ESCAPE (AVE_PSF_QF_PERF, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "stargal"))     ESCAPE (AVE_STARGAL,     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);
-  if (!strcasecmp (fieldName, "REF_COLOR"))   ESCAPE (AVE_REF_COLOR,   MAG_NONE, OPIHI_FLT);
+    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);
 }
@@ -424,9 +551,9 @@
   if (!strcasecmp (fieldName, "GLON"))  { 
     dbExtractImagesInitTransform (COORD_GALACTIC);
-    ESCAPE (IMAGE_GLON, MAG_NONE, OPIHI_FLT);
+    ESCAPE (IMAGE_GLON, OPIHI_FLT);
   }
   if (!strcasecmp (fieldName, "GLAT"))  {
     dbExtractImagesInitTransform (COORD_GALACTIC);
-    ESCAPE (IMAGE_GLAT, MAG_NONE, OPIHI_FLT);
+    ESCAPE (IMAGE_GLAT, OPIHI_FLT);
   }
 
@@ -435,98 +562,98 @@
   if (!strcasecmp (fieldName, "ELON"))  { 
     dbExtractImagesInitTransform (COORD_ECLIPTIC);
-    ESCAPE (IMAGE_ELON, MAG_NONE, OPIHI_FLT);
+    ESCAPE (IMAGE_ELON, OPIHI_FLT);
   }
   if (!strcasecmp (fieldName, "ELAT"))  {
     dbExtractImagesInitTransform (COORD_ECLIPTIC);
-    ESCAPE (IMAGE_ELAT, MAG_NONE, OPIHI_FLT);
-  }
-
-  if (!strcasecmp (fieldName, "RA"       )) ESCAPE (IMAGE_RA,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "DEC"      )) ESCAPE (IMAGE_DEC,       MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "GLON"     )) ESCAPE (IMAGE_GLON,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "GLAT"     )) ESCAPE (IMAGE_GLAT,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ELON"     )) ESCAPE (IMAGE_ELON,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "ELAT"     )) ESCAPE (IMAGE_ELAT,      MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "theta"    )) ESCAPE (IMAGE_THETA,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "skew"     )) ESCAPE (IMAGE_SKEW,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "scale"    )) ESCAPE (IMAGE_SCALE,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dscale"   )) ESCAPE (IMAGE_DSCALE,    MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "time"     )) ESCAPE (IMAGE_TIME,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "nstar"    )) ESCAPE (IMAGE_NSTAR,     MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "airmass"  )) ESCAPE (IMAGE_AIRMASS,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "NX"       )) ESCAPE (IMAGE_NX_PIX,    MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "NY"       )) ESCAPE (IMAGE_NY_PIX,    MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "apresid"  )) ESCAPE (IMAGE_APRESID,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dapresid" )) ESCAPE (IMAGE_DAPRESID,  MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "Mcal"     )) ESCAPE (IMAGE_MCAL,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dMcal"    )) ESCAPE (IMAGE_dMCAL,     MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Xm"       )) ESCAPE (IMAGE_XM,        MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "photcode" )) ESCAPE (IMAGE_PHOTCODE,  MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "exptime"  )) ESCAPE (IMAGE_EXPTIME,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "sidtime"  )) ESCAPE (IMAGE_SIDTIME,   MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "latitude" )) ESCAPE (IMAGE_LATITUDE,  MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "detlimit" )) ESCAPE (IMAGE_DET_LIMIT, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "satlimit" )) ESCAPE (IMAGE_SAT_LIMIT, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "cerror"   )) ESCAPE (IMAGE_CERROR,    MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "FWHM"       )) ESCAPE (IMAGE_FWHM,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MAJ"   )) ESCAPE (IMAGE_FWHM_MAJ,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MIN"   )) ESCAPE (IMAGE_FWHM_MIN,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MAJOR" )) ESCAPE (IMAGE_FWHM_MAJ,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MINOR" )) ESCAPE (IMAGE_FWHM_MIN,  MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "FWHM_MEDIAN"    ))   ESCAPE (IMAGE_FWHM_MEDIAN,      MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MAJ_MEDIAN"))   ESCAPE (IMAGE_FWHM_MAJ_MEDIAN,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MIN_MEDIAN"))   ESCAPE (IMAGE_FWHM_MIN_MEDIAN,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MAJOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MAJ_MEDIAN,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "FWHM_MINOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MIN_MEDIAN,  MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "trate"    )) ESCAPE (IMAGE_TRATE,     MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "ncal"     )) ESCAPE (IMAGE_NCAL,      MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "sky"      )) ESCAPE (IMAGE_SKY,       MAG_NONE, OPIHI_FLT); // deprecated for now
-
-  if (!strcasecmp (fieldName, "imflags"  )) ESCAPE (IMAGE_FLAGS,     MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "flags"    )) ESCAPE (IMAGE_FLAGS,     MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "ccdnum"   )) ESCAPE (IMAGE_CCDNUM,    MAG_NONE, OPIHI_INT);
-
-  if (!strcasecmp (fieldName, "imageID"  )) ESCAPE (IMAGE_IMAGE_ID,  MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "externID" )) ESCAPE (IMAGE_EXTERN_ID, MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "sourceID" )) ESCAPE (IMAGE_SOURCE_ID, MAG_NONE, OPIHI_INT);
-
-  if (!strcasecmp (fieldName, "X_LL_CHIP")) ESCAPE (IMAGE_X_LL_CHIP, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "X_LR_CHIP")) ESCAPE (IMAGE_X_LR_CHIP, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "X_UL_CHIP")) ESCAPE (IMAGE_X_UL_CHIP, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "X_UR_CHIP")) ESCAPE (IMAGE_X_UR_CHIP, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Y_LL_CHIP")) ESCAPE (IMAGE_Y_LL_CHIP, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Y_LR_CHIP")) ESCAPE (IMAGE_Y_LR_CHIP, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Y_UL_CHIP")) ESCAPE (IMAGE_Y_UL_CHIP, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Y_UR_CHIP")) ESCAPE (IMAGE_Y_UR_CHIP, MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "X_LL_FP"  )) ESCAPE (IMAGE_X_LL_FP,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "X_LR_FP"  )) ESCAPE (IMAGE_X_LR_FP,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "X_UL_FP"  )) ESCAPE (IMAGE_X_UL_FP,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "X_UR_FP"  )) ESCAPE (IMAGE_X_UR_FP,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Y_LL_FP"  )) ESCAPE (IMAGE_Y_LL_FP,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Y_LR_FP"  )) ESCAPE (IMAGE_Y_LR_FP,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Y_UL_FP"  )) ESCAPE (IMAGE_Y_UL_FP,   MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "Y_UR_FP"  )) ESCAPE (IMAGE_Y_UR_FP,   MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "dX_SYS"  )) ESCAPE (IMAGE_X_ERR_SYS,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dY_SYS"  )) ESCAPE (IMAGE_Y_ERR_SYS,  MAG_NONE, OPIHI_FLT);
-  if (!strcasecmp (fieldName, "dM_SYS"  )) ESCAPE (IMAGE_MAG_ERR_SYS,MAG_NONE, OPIHI_FLT);
-
-  if (!strcasecmp (fieldName, "UBERCAL_DIST")) ESCAPE (IMAGE_UBERCAL_DIST,MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "UCDIST")) ESCAPE (IMAGE_UBERCAL_DIST,MAG_NONE, OPIHI_INT);
-
-  if (!strcasecmp (fieldName, "NFIT_PHOTOM"))  ESCAPE (IMAGE_NFIT_PHOTOM,  MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "NFIT_ASTROM"))  ESCAPE (IMAGE_NFIT_ASTROM,  MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "NLINK_PHOTOM")) ESCAPE (IMAGE_NLINK_PHOTOM, MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "NLINK_ASTROM")) ESCAPE (IMAGE_NLINK_ASTROM, MAG_NONE, OPIHI_INT);
-  if (!strcasecmp (fieldName, "REF_COLOR"))    ESCAPE (IMAGE_REF_COLOR,    MAG_NONE, OPIHI_FLT);
+    ESCAPE (IMAGE_ELAT, OPIHI_FLT);
+  }
+
+  if (!strcasecmp (fieldName, "RA"       )) ESCAPE (IMAGE_RA,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DEC"      )) ESCAPE (IMAGE_DEC,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "GLON"     )) ESCAPE (IMAGE_GLON,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "GLAT"     )) ESCAPE (IMAGE_GLAT,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "ELON"     )) ESCAPE (IMAGE_ELON,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "ELAT"     )) ESCAPE (IMAGE_ELAT,      OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "theta"    )) ESCAPE (IMAGE_THETA,     OPIHI_FLT);
+  if (!strcasecmp (fieldName, "skew"     )) ESCAPE (IMAGE_SKEW,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "scale"    )) ESCAPE (IMAGE_SCALE,     OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dscale"   )) ESCAPE (IMAGE_DSCALE,    OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "time"     )) ESCAPE (IMAGE_TIME,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "nstar"    )) ESCAPE (IMAGE_NSTAR,     OPIHI_INT);
+  if (!strcasecmp (fieldName, "airmass"  )) ESCAPE (IMAGE_AIRMASS,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "NX"       )) ESCAPE (IMAGE_NX_PIX,    OPIHI_INT);
+  if (!strcasecmp (fieldName, "NY"       )) ESCAPE (IMAGE_NY_PIX,    OPIHI_INT);
+  if (!strcasecmp (fieldName, "apresid"  )) ESCAPE (IMAGE_APRESID,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dapresid" )) ESCAPE (IMAGE_DAPRESID,  OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "Mcal"     )) ESCAPE (IMAGE_MCAL,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dMcal"    )) ESCAPE (IMAGE_dMCAL,     OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Xm"       )) ESCAPE (IMAGE_XM,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "photcode" )) ESCAPE (IMAGE_PHOTCODE,  OPIHI_INT);
+  if (!strcasecmp (fieldName, "exptime"  )) ESCAPE (IMAGE_EXPTIME,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "sidtime"  )) ESCAPE (IMAGE_SIDTIME,   OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "latitude" )) ESCAPE (IMAGE_LATITUDE,  OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "detlimit" )) ESCAPE (IMAGE_DET_LIMIT, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "satlimit" )) ESCAPE (IMAGE_SAT_LIMIT, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "cerror"   )) ESCAPE (IMAGE_CERROR,    OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "FWHM"       )) ESCAPE (IMAGE_FWHM,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MAJ"   )) ESCAPE (IMAGE_FWHM_MAJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MIN"   )) ESCAPE (IMAGE_FWHM_MIN,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MAJOR" )) ESCAPE (IMAGE_FWHM_MAJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MINOR" )) ESCAPE (IMAGE_FWHM_MIN,  OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "FWHM_MEDIAN"    ))   ESCAPE (IMAGE_FWHM_MEDIAN,      OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MAJ_MEDIAN"))   ESCAPE (IMAGE_FWHM_MAJ_MEDIAN,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MIN_MEDIAN"))   ESCAPE (IMAGE_FWHM_MIN_MEDIAN,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MAJOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MAJ_MEDIAN,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FWHM_MINOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MIN_MEDIAN,  OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "trate"    )) ESCAPE (IMAGE_TRATE,     OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "ncal"     )) ESCAPE (IMAGE_NCAL,      OPIHI_INT);
+  if (!strcasecmp (fieldName, "sky"      )) ESCAPE (IMAGE_SKY,       OPIHI_FLT); // deprecated for now
+
+  if (!strcasecmp (fieldName, "imflags"  )) ESCAPE (IMAGE_FLAGS,     OPIHI_INT);
+  if (!strcasecmp (fieldName, "flags"    )) ESCAPE (IMAGE_FLAGS,     OPIHI_INT);
+  if (!strcasecmp (fieldName, "ccdnum"   )) ESCAPE (IMAGE_CCDNUM,    OPIHI_INT);
+
+  if (!strcasecmp (fieldName, "imageID"  )) ESCAPE (IMAGE_IMAGE_ID,  OPIHI_INT);
+  if (!strcasecmp (fieldName, "externID" )) ESCAPE (IMAGE_EXTERN_ID, OPIHI_INT);
+  if (!strcasecmp (fieldName, "sourceID" )) ESCAPE (IMAGE_SOURCE_ID, OPIHI_INT);
+
+  if (!strcasecmp (fieldName, "X_LL_CHIP")) ESCAPE (IMAGE_X_LL_CHIP, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X_LR_CHIP")) ESCAPE (IMAGE_X_LR_CHIP, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X_UL_CHIP")) ESCAPE (IMAGE_X_UL_CHIP, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X_UR_CHIP")) ESCAPE (IMAGE_X_UR_CHIP, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Y_LL_CHIP")) ESCAPE (IMAGE_Y_LL_CHIP, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Y_LR_CHIP")) ESCAPE (IMAGE_Y_LR_CHIP, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Y_UL_CHIP")) ESCAPE (IMAGE_Y_UL_CHIP, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Y_UR_CHIP")) ESCAPE (IMAGE_Y_UR_CHIP, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X_LL_FP"  )) ESCAPE (IMAGE_X_LL_FP,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X_LR_FP"  )) ESCAPE (IMAGE_X_LR_FP,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X_UL_FP"  )) ESCAPE (IMAGE_X_UL_FP,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X_UR_FP"  )) ESCAPE (IMAGE_X_UR_FP,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Y_LL_FP"  )) ESCAPE (IMAGE_Y_LL_FP,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Y_LR_FP"  )) ESCAPE (IMAGE_Y_LR_FP,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Y_UL_FP"  )) ESCAPE (IMAGE_Y_UL_FP,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "Y_UR_FP"  )) ESCAPE (IMAGE_Y_UR_FP,   OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "dX_SYS"  )) ESCAPE (IMAGE_X_ERR_SYS,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dY_SYS"  )) ESCAPE (IMAGE_Y_ERR_SYS,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "dM_SYS"  )) ESCAPE (IMAGE_MAG_ERR_SYS,OPIHI_FLT);
+
+  if (!strcasecmp (fieldName, "UBERCAL_DIST")) ESCAPE (IMAGE_UBERCAL_DIST,OPIHI_INT);
+  if (!strcasecmp (fieldName, "UCDIST")) ESCAPE (IMAGE_UBERCAL_DIST,OPIHI_INT);
+
+  if (!strcasecmp (fieldName, "NFIT_PHOTOM"))  ESCAPE (IMAGE_NFIT_PHOTOM,  OPIHI_INT);
+  if (!strcasecmp (fieldName, "NFIT_ASTROM"))  ESCAPE (IMAGE_NFIT_ASTROM,  OPIHI_INT);
+  if (!strcasecmp (fieldName, "NLINK_PHOTOM")) ESCAPE (IMAGE_NLINK_PHOTOM, OPIHI_INT);
+  if (!strcasecmp (fieldName, "NLINK_ASTROM")) ESCAPE (IMAGE_NLINK_ASTROM, OPIHI_INT);
+  if (!strcasecmp (fieldName, "REF_COLOR"))    ESCAPE (IMAGE_REF_COLOR,    OPIHI_FLT);
 
   // for words that don't parse, try a photcode
Index: /trunk/Ohana/src/libdvo/src/dvo_catalog.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_catalog.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_catalog.c	(revision 37035)
@@ -56,4 +56,5 @@
   if (!strcasecmp (catformat, "PS1_V3"))          return (DVO_FORMAT_PS1_V3);
   if (!strcasecmp (catformat, "PS1_V4"))          return (DVO_FORMAT_PS1_V4);
+  if (!strcasecmp (catformat, "PS1_V5"))          return (DVO_FORMAT_PS1_V5);
   if (!strcasecmp (catformat, "PS1_REF"))         return (DVO_FORMAT_PS1_REF);
   return (DVO_FORMAT_UNDEF);
@@ -69,17 +70,46 @@
 }
 
+float dvoOffsetR (Measure *measure, Average *average) {
+
+  float dR = (measure[0].R - average[0].R) * 3600.0;
+  return dR;
+}
+
+float dvoOffsetD (Measure *measure, Average *average) {
+
+  float dD = (measure[0].D - average[0].D) * 3600.0;
+  return dD;
+}
+
+double dvoMeanR (float dR, Average *average) {
+
+  double ra = average[0].R - dR / 3600.0;
+  return ra;
+}
+
+double dvoMeanD (float dD, Average *average) {
+
+  double dec = average[0].D - dD / 3600.0;
+  return dec;
+}
+
 // init all data, or just catalog data
 void dvo_average_init (Average *average) {
   average->R         	   = 0;
   average->D         	   = 0;
-  average->dR        	   = 0;
-  average->dD        	   = 0;
+  average->dR        	   = NAN;
+  average->dD        	   = NAN;
 
   average->uR        	   = 0;
   average->uD        	   = 0;
-  average->duR       	   = 0;
-  average->duD       	   = 0;
+  average->duR       	   = NAN;
+  average->duD       	   = NAN;
   average->P         	   = 0;
-  average->dP        	   = 0;
+  average->dP        	   = NAN;
+
+  average->Rstk        	   = NAN;
+  average->Dstk        	   = NAN;
+  average->dRstk       	   = NAN;
+  average->dDstk       	   = NAN;
 
   average->ChiSqAve  	   = NAN;
@@ -97,8 +127,17 @@
   average->Nmeasure        = 0;
   average->Nmissing        = 0;
+  average->Nlensing        = 0;
+  average->Nlensobj        = 0;
   average->Nextend         = 0;
+
   average->measureOffset   = -1;
   average->missingOffset   = -1;
-  average->refColor        = NAN;
+  average->lensingOffset   = -1;
+  average->lensobjOffset   = -1;
+  average->extendOffset    = -1;
+  average->paramsOffset    = -1;
+
+  average->refColorBlue    = NAN;
+  average->refColorRed     = NAN;
 
   average->flags           = 0;
@@ -109,4 +148,5 @@
   average->catID     	   = 0;
   average->extID     	   = 0;
+  average->extIDgc    	   = 0;
 }
 
@@ -125,37 +165,72 @@
 void dvo_secfilt_init (SecFilt *secfilt) {
   secfilt->M           = NAN;
+  secfilt->dM          = NAN;
   secfilt->Map         = NAN;
+  secfilt->dMap        = NAN;
+  secfilt->sMap        = NAN;
   secfilt->Mkron       = NAN;
   secfilt->dMkron      = NAN;
-  secfilt->dM          = NAN;
-  secfilt->Xm          = NAN_S_SHORT;
-
-  secfilt->FluxPSF     = NAN;
-  secfilt->dFluxPSF    = NAN;
-  secfilt->FluxKron    = NAN;
-  secfilt->dFluxKron   = NAN;
-
-  secfilt->flags       = 0;
+  secfilt->sMkron      = NAN;
+
+  secfilt->Mstdev      = NAN;
+  secfilt->Mmin        = NAN;
+  secfilt->Mmax        = NAN;
+  secfilt->Mchisq      = NAN;
+
   secfilt->Ncode       = 0;
   secfilt->Nused       = 0;
-
-  secfilt->M_20        = NAN_S_SHORT;
-  secfilt->M_80        = NAN_S_SHORT;
+  secfilt->NusedKron   = 0;
+  secfilt->NusedAp     = 0;
+
+  secfilt->flags       = 0;
+
+  secfilt->MpsfStk     = NAN;
+  secfilt->FpsfStk     = NAN;
+  secfilt->dFpsfStk    = NAN;
+
+  secfilt->MkronStk    = NAN;
+  secfilt->FkronStk    = NAN;
+  secfilt->dFkronStk   = NAN;
+
+  secfilt->MapStk      = NAN;
+  secfilt->FapStk      = NAN;
+  secfilt->dFapStk     = NAN;
+
+  secfilt->stackDetectID = 0;
+
+  secfilt->MpsfWrp     = NAN;
+  secfilt->FpsfWrp     = NAN;
+  secfilt->dFpsfWrp    = NAN;
+  secfilt->sFpsfWrp    = NAN;
+
+  secfilt->MkronWrp    = NAN;
+  secfilt->FkronWrp    = NAN;
+  secfilt->dFkronWrp   = NAN;
+  secfilt->sFkronWrp   = NAN;
+
+  secfilt->MapWrp      = NAN;
+  secfilt->FapWrp      = NAN;
+  secfilt->dFapWrp     = NAN;
+  secfilt->sFapWrp     = NAN;
+
+  secfilt->NusedWrp     = 0;
+  secfilt->NusedKronWrp = 0;
+  secfilt->NusedApWrp   = 0;
 
   secfilt->ubercalDist = 1000;
-  secfilt->Mstdev      = NAN_S_SHORT;
-  secfilt->stackDetectID     = 0;
 }
 
 // init all data, or just catalog data
 void dvo_measure_init (Measure *measure) {
+ measure->R         = NAN;
+ measure->D         = NAN;
+
  measure->M         = NAN;
- measure->dR        = NAN;
- measure->dD        = NAN;
- measure->Mcal      = NAN;
+ measure->dM        = NAN;
  measure->Map       = NAN;
+ measure->dMap      = NAN;
  measure->Mkron     = NAN;
  measure->dMkron    = NAN;
- measure->dM        = NAN;
+ measure->Mcal      = NAN;
  measure->dMcal     = NAN;
  measure->dt        = NAN;
@@ -165,4 +240,6 @@
  measure->FluxKron  = NAN;
  measure->dFluxKron = NAN;
+ measure->FluxAp    = NAN;
+ measure->dFluxAp   = NAN;
 
  measure->airmass   = NAN;
@@ -174,20 +251,29 @@
  measure->Yfix      = NAN;
 
+ measure->XoffKH    = NAN;
+ measure->YoffKH    = NAN;
+ measure->XoffDCR   = NAN;
+ measure->YoffDCR   = NAN;
+ measure->RoffGAL   = NAN;
+ measure->DoffGAL   = NAN;
+
  measure->Sky       = NAN;
  measure->dSky      = NAN;
 
  measure->t         = 0;
- measure->t_msec    = 0;
  measure->averef    = 0;
 
  measure->detID     = 0;
- measure->imageID   = 0;
  measure->objID     = 0;
  measure->catID     = 0;
+
  measure->extID     = 0;
+
+ measure->imageID   = 0;
 
  measure->psfQF     = NAN;
  measure->psfQFperf = NAN;
  measure->psfChisq  = NAN;
+
  measure->psfNdof   = 0;
  measure->psfNpix   = 0;
@@ -203,4 +289,7 @@
  measure->Myy       = 0;
 
+ measure->t_msec    = 0;
+ measure->photcode  = 0;
+
  measure->dXccd     = 0;
  measure->dYccd     = 0;
@@ -210,5 +299,4 @@
  measure->pltscale  = NAN;
 
- measure->photcode  = 0;
  measure->dbFlags   = 0;
  measure->photFlags = 0;
@@ -216,6 +304,6 @@
 
 void dvo_measureT_init (MeasureTiny *measure) {
- measure->dR        = NAN;
- measure->dD        = NAN;
+ measure->R         = NAN;
+ measure->D         = NAN;
  measure->M         = NAN;
  measure->Mcal      = NAN;
@@ -244,4 +332,92 @@
  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;
 }
 
@@ -269,4 +445,7 @@
   catalog[0].secfilt = NULL;
   
+  catalog[0].lensing = NULL; 
+  catalog[0].lensobj = NULL; 
+
   catalog[0].averageT = NULL;
   catalog[0].measureT = NULL; 
@@ -281,4 +460,7 @@
   catalog[0].Nsecf_mem = 0;
 
+  catalog[0].Nlensing = 0;
+  catalog[0].Nlensobj = 0;
+
   catalog[0].Naves_disk = 0;
   catalog[0].Nmeas_disk = 0;
@@ -286,4 +468,7 @@
   catalog[0].Nsecf_disk = 0;
 
+  catalog[0].Nlensing_disk = 0;
+  catalog[0].Nlensobj_disk = 0;
+
   catalog[0].Naves_off  = 0;
   catalog[0].Nmeas_off  = 0;
@@ -291,15 +476,22 @@
   catalog[0].Nsecf_off  = 0;
 
+  catalog[0].Nlensing_off  = 0;
+  catalog[0].Nlensobj_off  = 0;
+
   /* pointers to SPLIT data files */
   catalog[0].measure_catalog = NULL;
   catalog[0].missing_catalog = NULL;
   catalog[0].secfilt_catalog = NULL;
+  catalog[0].lensing_catalog = NULL;
+  catalog[0].lensobj_catalog = NULL;
 
   /* pointers for data manipulation */
-  catalog[0].found = NULL;
-  catalog[0].image = NULL;
-  catalog[0].mosaic = NULL;
-  catalog[0].X = NULL;
-  catalog[0].Y = NULL;
+  // catalog[0].X_t = NULL;
+  // catalog[0].Y_t = NULL;
+  catalog[0].nOwn_t = NULL;
+  catalog[0].found_t = NULL;
+  // catalog[0].image_t = NULL;
+  // catalog[0].mosaic_t = NULL;
+  catalog[0].foundWarp_t = NULL;
 }
 
@@ -345,10 +537,13 @@
   }
 
+  // closes f but does not set back to NULL
   fclearlockfile (catalog[0].filename, catalog[0].f, catalog[0].lockmode, &dbstate);
 
   if (catalog[0].catmode == DVO_MODE_SPLIT) {
-    if (catalog[0].measure_catalog != NULL) dvo_catalog_unlock (catalog[0].measure_catalog);
-    if (catalog[0].missing_catalog != NULL) dvo_catalog_unlock (catalog[0].missing_catalog);
-    if (catalog[0].secfilt_catalog != NULL) dvo_catalog_unlock (catalog[0].secfilt_catalog);
+    if (catalog[0].measure_catalog) dvo_catalog_unlock (catalog[0].measure_catalog);
+    if (catalog[0].missing_catalog) dvo_catalog_unlock (catalog[0].missing_catalog);
+    if (catalog[0].secfilt_catalog) dvo_catalog_unlock (catalog[0].secfilt_catalog);
+    if (catalog[0].lensing_catalog) dvo_catalog_unlock (catalog[0].lensing_catalog);
+    if (catalog[0].lensobj_catalog) dvo_catalog_unlock (catalog[0].lensobj_catalog);
   }
   return (1);
@@ -579,12 +774,12 @@
     for (in = out = i = 0; i < catalog[0].Naverage; i++) {
       for (j = 0; j < catalog[0].Nsecfilt; j++, in++, out++) {
-	outsec[out].M  = insec[in].M;
-	outsec[out].dM = insec[in].dM;
-	outsec[out].Xm = insec[in].Xm;
+	outsec[out].M  	   = insec[in].M;
+	outsec[out].dM 	   = insec[in].dM;
+	outsec[out].Mchisq = insec[in].Mchisq;
       }
       for (j = 0; j < Nextra; j++, out++) {
-	outsec[out].M  = NAN;
-	outsec[out].dM = NAN;
-	outsec[out].Xm = NAN_S_SHORT;
+	outsec[out].M  	   = NAN;
+	outsec[out].dM 	   = NAN;
+	outsec[out].Mchisq = NAN;
       }
     }
@@ -616,4 +811,14 @@
       free (catalog[0].secfilt_catalog);
     }
+    if (catalog[0].lensing_catalog) {
+      free (catalog[0].lensing_catalog[0].filename);
+      dvo_catalog_free (catalog[0].lensing_catalog);
+      free (catalog[0].lensing_catalog);
+    }
+    if (catalog[0].lensobj_catalog) {
+      free (catalog[0].lensobj_catalog[0].filename);
+      dvo_catalog_free (catalog[0].lensobj_catalog);
+      free (catalog[0].lensobj_catalog);
+    }
   }
   dvo_catalog_free_data (catalog);
@@ -625,24 +830,41 @@
 
   /* free, initialize data structures */
-  if (catalog[0].average != NULL) {
+  if (catalog[0].average) {
     free (catalog[0].average); 
     catalog[0].Naverage = 0;
     catalog[0].average = NULL;
   }
-  if (catalog[0].measure != NULL) {
+  if (catalog[0].measure) {
     free (catalog[0].measure); 
     catalog[0].Nmeasure = 0;
     catalog[0].measure = NULL;
   }
-  if (catalog[0].missing != NULL) {
+  if (catalog[0].missing) {
     free (catalog[0].missing); 
     catalog[0].Nmissing = 0;
     catalog[0].missing = NULL;
   }
-  if (catalog[0].secfilt != NULL) {
+  if (catalog[0].secfilt) {
     free (catalog[0].secfilt); 
     catalog[0].Nsecf_mem = 0;
     catalog[0].secfilt = NULL;
   }
+  if (catalog[0].lensing) {
+    free (catalog[0].lensing); 
+    catalog[0].Nlensing = 0;
+    catalog[0].lensing = NULL;
+  }
+  if (catalog[0].lensobj) {
+    free (catalog[0].lensobj); 
+    catalog[0].Nlensobj = 0;
+    catalog[0].lensobj = NULL;
+  }
+  // if (catalog[0].X_t)      free (catalog[0].X_t);
+  // if (catalog[0].Y_t)      free (catalog[0].Y_t);
+  if (catalog[0].nOwn_t)      free (catalog[0].nOwn_t);
+  if (catalog[0].found_t)     free (catalog[0].found_t);
+  // if (catalog[0].image_t)  free (catalog[0].image_t);
+  // if (catalog[0].mosaic_t) free (catalog[0].mosaic_t);
+  if (catalog[0].foundWarp_t) free (catalog[0].foundWarp_t);
 }
 
@@ -733,4 +955,24 @@
       }
     }
+    if (catalog[0].lensing_catalog != NULL) {
+      if (catalog[0].Nlensing_disk == 0) {
+	// need to relock (and re-open) file for close elsewhere
+	status = dvo_catalog_lock (catalog[0].lensing_catalog, lockmode);
+      } else {
+	if (!dvo_catalog_backup (catalog[0].lensing_catalog, FALSE)) {
+	  return FALSE;
+	}
+      }
+    }
+    if (catalog[0].lensobj_catalog != NULL) {
+      if (catalog[0].Nlensobj_disk == 0) {
+	// need to relock (and re-open) file for close elsewhere
+	status = dvo_catalog_lock (catalog[0].lensobj_catalog, lockmode);
+      } else {
+	if (!dvo_catalog_backup (catalog[0].lensobj_catalog, FALSE)) {
+	  return FALSE;
+	}
+      }
+    }
   }
   return TRUE;
@@ -754,5 +996,5 @@
   status = unlink (tmpfilename);
   if (status) {
-    fprintf (stderr, "failed to unlink catalog %s\n", catalog->filename);
+    fprintf (stderr, "failed to unlink catalog %s~\n", catalog->filename);
     return FALSE;
   }
@@ -774,4 +1016,14 @@
       }
     }
+    if ((catalog[0].lensing_catalog != NULL) && (catalog[0].Nlensing_disk > 0)) {
+      if (!dvo_catalog_unlink_backup (catalog[0].lensing_catalog, FALSE)) {
+	return FALSE;
+      }
+    }
+    if ((catalog[0].lensobj_catalog != NULL) && (catalog[0].Nlensobj_disk > 0)) {
+      if (!dvo_catalog_unlink_backup (catalog[0].lensobj_catalog, FALSE)) {
+	return FALSE;
+      }
+    }
   }
   return TRUE;
Index: /trunk/Ohana/src/libdvo/src/dvo_catalog_chipcoords.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_catalog_chipcoords.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_catalog_chipcoords.c	(revision 37035)
@@ -56,6 +56,6 @@
     m = average[i].measureOffset;
     for (j = 0; j < average[i].Nmeasure; j++, m++) {
-      ra  = average[i].R - measure[m].dR / 3600.0;
-      dec = average[i].D - measure[m].dD / 3600.0;
+      ra  = measure[m].R;
+      dec = measure[m].D;
       N = dvo_match_image (image, Nimage, measure[m].t, measure[m].photcode);
       if (N == -1) continue;
Index: /trunk/Ohana/src/libdvo/src/dvo_catalog_create.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_catalog_create.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_catalog_create.c	(revision 37035)
@@ -70,4 +70,29 @@
     gfits_modify (&catalog[0].header, "SECFILT", "%s", 1, file);
     free (file);
+
+    /* define lensing catalog file */
+    ALLOCATE (catalog[0].lensing_catalog, Catalog, 1);
+    dvo_catalog_init (catalog[0].lensing_catalog, TRUE);
+
+    /* create basic data for lensing catalog file */
+    gfits_create_header (&catalog[0].lensing_catalog[0].header);
+    ALLOCATE (catalog[0].lensing_catalog[0].filename, char, length);
+    sprintf (catalog[0].lensing_catalog[0].filename, "%s/%s.cpx", path, root);
+    file = filebasename (catalog[0].lensing_catalog[0].filename);
+    gfits_modify (&catalog[0].header, "LENSING", "%s", 1, file);
+    free (file);
+
+    /* define lensobj catalog file */
+    ALLOCATE (catalog[0].lensobj_catalog, Catalog, 1);
+    dvo_catalog_init (catalog[0].lensobj_catalog, TRUE);
+
+    /* create basic data for lensobj catalog file */
+    gfits_create_header (&catalog[0].lensobj_catalog[0].header);
+    ALLOCATE (catalog[0].lensobj_catalog[0].filename, char, length);
+    sprintf (catalog[0].lensobj_catalog[0].filename, "%s/%s.cpy", path, root);
+    file = filebasename (catalog[0].lensobj_catalog[0].filename);
+    gfits_modify (&catalog[0].header, "LENSOBJ", "%s", 1, file);
+    free (file);
+
     free (path);
     free (root);
@@ -84,4 +109,12 @@
     }
     if (dvo_catalog_lock (catalog[0].secfilt_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
+      fprintf (stderr, "error with file lock\n");
+      exit (2);
+    }
+    if (dvo_catalog_lock (catalog[0].lensing_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
+      fprintf (stderr, "error with file lock\n");
+      exit (2);
+    }
+    if (dvo_catalog_lock (catalog[0].lensobj_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
       fprintf (stderr, "error with file lock\n");
       exit (2);
@@ -111,4 +144,6 @@
   ALLOCATE (catalog[0].missing, Missing, 1);
   ALLOCATE (catalog[0].secfilt, SecFilt, 1);
+  ALLOCATE (catalog[0].lensing, Lensing, 1);
+  ALLOCATE (catalog[0].lensobj, Lensobj, 1);
 
   /* setup secondary filters to match photcodes:
Index: /trunk/Ohana/src/libdvo/src/dvo_catalog_mef.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_catalog_mef.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_catalog_mef.c	(revision 37035)
@@ -7,4 +7,6 @@
   off_t Nmeasure;
   off_t Nmissing;
+  off_t Nlensing;
+  off_t Nlensobj;
   off_t Nitems, Nexpect;
   int Nsecfilt;
@@ -22,4 +24,6 @@
   if (!gfits_scan (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  &Nmissing)) return (FALSE);
   if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d",   1,               &Nsecfilt)) Nsecfilt = 0;
+  if (!gfits_scan (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  &Nlensing)) return (FALSE);
+  if (!gfits_scan (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  &Nlensobj)) return (FALSE);
 
   /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
@@ -40,4 +44,6 @@
   catalog[0].Nmiss_disk = Nmissing;
   catalog[0].Nsecf_disk = Naverage * Nsecfilt;
+  catalog[0].Nlensing_disk = Nlensing;
+  catalog[0].Nlensobj_disk = Nlensobj;
 
   /**  Nsecfilt is unusual: it does not list the number of data items in the table
@@ -50,4 +56,6 @@
   catalog[0].missing = NULL;
   catalog[0].secfilt = NULL;
+  catalog[0].lensing = NULL;
+  catalog[0].lensobj = NULL;
 
   /* validate table mode ?*/
@@ -101,5 +109,5 @@
       return (FALSE);
     }
-    catalog[0].measure = FtableToMeasure (&ftable, &catalog[0].Nmeasure, &catalog[0].catformat);
+    catalog[0].measure = FtableToMeasure (&ftable, catalog[0].average, &catalog[0].Nmeasure, &catalog[0].catformat);
     if (Nmeasure != catalog[0].Nmeas_disk) {
       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nmeasure,  catalog[0].Nmeas_disk);
@@ -201,4 +209,54 @@
   }
 
+  /* read Lensing table header */
+  if (!gfits_fread_header (catalog[0].f, &header)) {
+    if (VERBOSE) fprintf (stderr, "can't read table lensing header");
+    return (FALSE);
+  }
+  /* read Lensing table data */
+  if (catalog[0].catflags & LOAD_LENSING) {
+    if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) {
+      if (VERBOSE) fprintf (stderr, "can't read table lensing data");
+      return (FALSE);
+    }
+    catalog[0].lensing = FtableToLensing (&ftable, &catalog[0].Nlensing, &catalog[0].catformat);
+    if (Nlensing != catalog[0].Nlensing_disk) {
+      fprintf (stderr, "Warning: mismatch between Nlensing in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensing,  catalog[0].Nlensing_disk);
+    }
+    catalog[0].Nlensing = catalog[0].Nlensing_disk;
+    catalog[0].Nlensing_off = 0;
+  } else {
+    Nbytes = gfits_data_size (&header);
+    fseeko (catalog[0].f, Nbytes, SEEK_CUR);
+    ALLOCATE (catalog[0].lensing, Lensing, 1);
+    catalog[0].Nlensing = 0;
+    catalog[0].Nlensing_off = catalog[0].Nlensing_disk;
+  }
+
+  /* read Lensobj table header */
+  if (!gfits_fread_header (catalog[0].f, &header)) {
+    if (VERBOSE) fprintf (stderr, "can't read table lensobj header");
+    return (FALSE);
+  }
+  /* read Lensobj table data */
+  if (catalog[0].catflags & LOAD_LENSOBJ) {
+    if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) {
+      if (VERBOSE) fprintf (stderr, "can't read table lensobj data");
+      return (FALSE);
+    }
+    catalog[0].lensobj = FtableToLensobj (&ftable, &catalog[0].Nlensobj, &catalog[0].catformat);
+    if (Nlensobj != catalog[0].Nlensobj_disk) {
+      fprintf (stderr, "Warning: mismatch between Nlensobj in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensobj,  catalog[0].Nlensobj_disk);
+    }
+    catalog[0].Nlensobj = catalog[0].Nlensobj_disk;
+    catalog[0].Nlensobj_off = 0;
+  } else {
+    Nbytes = gfits_data_size (&header);
+    fseeko (catalog[0].f, Nbytes, SEEK_CUR);
+    ALLOCATE (catalog[0].lensobj, Lensobj, 1);
+    catalog[0].Nlensobj = 0;
+    catalog[0].Nlensobj_off = catalog[0].Nlensobj_disk;
+  }
+
   return (TRUE);
 }
@@ -249,4 +307,6 @@
   gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  catalog[0].Nmissing);
   gfits_modify (&catalog[0].header, "NSECFILT", "%d",   1,                        Nsecfilt);
+  gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  catalog[0].Nlensing);
+  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  catalog[0].Nlensobj);
   gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
   gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
@@ -289,5 +349,5 @@
 
   /* write out Measure table (convert to FITS table format) */
-  MeasureToFtable (&ftable, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
+  MeasureToFtable (&ftable, catalog[0].average, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
   if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
     fprintf (stderr, "can't write table header");
@@ -317,4 +377,30 @@
   Nitems = catalog[0].Naverage * Nsecfilt;
   SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
+  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
+    fprintf (stderr, "can't write table header");
+    goto failure;
+  }
+  if (!gfits_fwrite_table (catalog[0].f, &ftable)) {
+    fprintf (stderr, "can't write table data");
+    goto failure;
+  }
+  gfits_free_table (&ftable);
+  gfits_free_header (&header);
+
+  /* write out Lensing table (convert to FITS table format) */
+  LensingToFtable (&ftable, catalog[0].lensing, catalog[0].Nlensing, catalog[0].catformat);
+  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
+    fprintf (stderr, "can't write table header");
+    goto failure;
+  }
+  if (!gfits_fwrite_table (catalog[0].f, &ftable)) {
+    fprintf (stderr, "can't write table data");
+    goto failure;
+  }
+  gfits_free_table (&ftable);
+  gfits_free_header (&header);
+
+  /* write out Lensobj table (convert to FITS table format) */
+  LensobjToFtable (&ftable, catalog[0].lensobj, catalog[0].Nlensobj, catalog[0].catformat);
   if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
     fprintf (stderr, "can't write table header");
@@ -356,4 +442,8 @@
   secfilt header
   secfilt table
+  lensing header
+  lensing table
+  lensobj header
+  lensobj table
 */
    
Index: /trunk/Ohana/src/libdvo/src/dvo_catalog_raw.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_catalog_raw.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_catalog_raw.c	(revision 37035)
@@ -90,4 +90,5 @@
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 
@@ -144,5 +145,5 @@
   /* read and convert the measures (use a macro to clean this up?) */
   if (catalog[0].catflags & LOAD_MEAS) {
-    catalog[0].measure = ReadRawMeasure (catalog[0].f, catalog[0].Nmeasure, catalog[0].catformat);
+    catalog[0].measure = ReadRawMeasure (catalog[0].f, catalog[0].average, catalog[0].Nmeasure, catalog[0].catformat);
   } else {
     /* skip over measures */
@@ -284,4 +285,5 @@
   if (catalog[0].catformat == DVO_FORMAT_PS1_V3)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V3");
   if (catalog[0].catformat == DVO_FORMAT_PS1_V4)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V4");
+  if (catalog[0].catformat == DVO_FORMAT_PS1_V5)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V5");
   if (catalog[0].catformat == DVO_FORMAT_PS1_REF)         gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_REF");
 
@@ -303,5 +305,5 @@
   /* write averages and measures */
   WriteRawAverage (f, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
-  WriteRawMeasure (f, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
+  WriteRawMeasure (f, catalog[0].average, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
 
   /* write missing data */
@@ -387,4 +389,5 @@
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 
@@ -438,4 +441,5 @@
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 
@@ -451,5 +455,5 @@
 /** Average / Raw Table conversions **/
 
-Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format) {
+Measure *ReadRawMeasure (FILE *f, Average *average, off_t Nmeasure, char format) {
 
   Measure *measure;
@@ -467,5 +471,5 @@
       } \
       gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \
-      measure = Measure_##TYPE##_ToInternal (tmpMeasure, Nmeasure); \
+      measure = Measure_##TYPE##_ToInternal (average, tmpMeasure, Nmeasure); \
       free (tmpMeasure); \
       break; }
@@ -481,4 +485,55 @@
       }
       gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
+      break; }
+
+      FORMAT_CASE (LONEOS, Loneos);
+      FORMAT_CASE (ELIXIR, Elixir);
+      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
+      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
+      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
+      FORMAT_CASE (PS1_DEV_2, PS1_DEV_2);
+      FORMAT_CASE (PS1_V1,    PS1_V1);
+      FORMAT_CASE (PS1_V2,    PS1_V2);
+      FORMAT_CASE (PS1_V3,    PS1_V3);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
+      FORMAT_CASE (PS1_REF,   PS1_REF);
+
+    default:
+      fprintf (stderr, "error reading measures\n");
+      return (NULL);
+  }
+# undef FORMAT_CASE
+
+  return (measure);
+}
+
+/* accepts and converts internal measure formats and outputs 
+   raw data in the specified format */
+int WriteRawMeasure (FILE *f, Average *average, Measure *measure, off_t Nmeasure, char format) {
+
+// this macro generates the case statements for each type
+# define FORMAT_CASE(NAME,TYPE) \
+    case DVO_FORMAT_##NAME: { \
+      off_t nitems; \
+      Measure_##TYPE *tmpMeasure; \
+      tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
+      gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \
+      nitems = fwrite (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \
+      free (tmpMeasure); \
+      if (nitems != Nmeasure) { \
+	fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n",  nitems,  Nmeasure); \
+	return (FALSE); \
+      } \
+      break; }
+
+  switch (format) {
+    case DVO_FORMAT_INTERNAL: {
+      off_t nitems;
+      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
+      nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
+      if (nitems != Nmeasure) {
+	fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n",  nitems,  Nmeasure);
+	return (FALSE);
+      }
       break; }
 
@@ -493,55 +548,5 @@
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
-      FORMAT_CASE (PS1_REF,   PS1_REF);
-
-    default:
-      fprintf (stderr, "error reading measures\n");
-      return (NULL);
-  }
-# undef FORMAT_CASE
-
-  return (measure);
-}
-
-/* accepts and converts internal measure formats and outputs 
-   raw data in the specified format */
-int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format) {
-
-// this macro generates the case statements for each type
-# define FORMAT_CASE(NAME,TYPE) \
-    case DVO_FORMAT_##NAME: { \
-      off_t nitems; \
-      Measure_##TYPE *tmpMeasure; \
-      tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \
-      gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \
-      nitems = fwrite (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \
-      free (tmpMeasure); \
-      if (nitems != Nmeasure) { \
-	fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n",  nitems,  Nmeasure); \
-	return (FALSE); \
-      } \
-      break; }
-
-  switch (format) {
-    case DVO_FORMAT_INTERNAL: {
-      off_t nitems;
-      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
-      nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
-      if (nitems != Nmeasure) {
-	fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n",  nitems,  Nmeasure);
-	return (FALSE);
-      }
-      break; }
-
-      FORMAT_CASE (LONEOS, Loneos);
-      FORMAT_CASE (ELIXIR, Elixir);
-      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
-      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
-      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
-      FORMAT_CASE (PS1_DEV_2, PS1_DEV_2);
-      FORMAT_CASE (PS1_V1,    PS1_V1);
-      FORMAT_CASE (PS1_V2,    PS1_V2);
-      FORMAT_CASE (PS1_V3,    PS1_V3);
-      FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 
@@ -599,4 +604,5 @@
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 
@@ -650,4 +656,5 @@
       FORMAT_CASE (PS1_V3,    PS1_V3);
       FORMAT_CASE (PS1_V4,    PS1_V4);
+      FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
 
Index: /trunk/Ohana/src/libdvo/src/dvo_catalog_split.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_catalog_split.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_catalog_split.c	(revision 37035)
@@ -134,4 +134,8 @@
   if (!gfits_scan (&catalog[0].header, name,  "%s", 1, string)) {
     free (path);
+    // databases created prior to ~2014.07.01 did not have the LENSING or LENSOBJ paths in their headers.
+    // in these cases, we do not try to lock or open the relevant file
+    if (!strcmp (name, "LENSING")) return (DVO_CAT_OPEN_EMPTY);
+    if (!strcmp (name, "LENSOBJ")) return (DVO_CAT_OPEN_EMPTY);
     return (DVO_CAT_OPEN_FAIL);
   }
@@ -161,5 +165,5 @@
   fseeko (subcat[0].f, Nskip, SEEK_CUR);
 
-  /* read Measure table header */
+  /* read table header */
   if (!gfits_fread_header (subcat[0].f, header)) {
     if (VERBOSE) fprintf (stderr, "can't read %s PHU header\n", name);
@@ -176,4 +180,6 @@
   off_t Nmeasure;
   off_t Nmissing;
+  off_t Nlensing;
+  off_t Nlensobj;
   off_t Nitems;
   int status, Nsecfilt;
@@ -190,8 +196,11 @@
 
   /* get the components from the header - these duplicate information in the split files (NAXIS2) */
+  // NSTARS, NMEAS, NMISS are required; NLENSING, NLENSOBJ are not (0 if not found)
   if (!gfits_scan (&catalog[0].header, "NSTARS",   OFF_T_FMT, 1,  &Naverage)) return (FALSE);
   if (!gfits_scan (&catalog[0].header, "NMEAS",    OFF_T_FMT, 1,  &Nmeasure)) return (FALSE);
   if (!gfits_scan (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  &Nmissing)) return (FALSE);
-  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d",   1,               &Nsecfilt)) Nsecfilt = 0;
+  if (!gfits_scan (&catalog[0].header, "NSECFILT",      "%d", 1,  &Nsecfilt)) Nsecfilt = 0;
+  if (!gfits_scan (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  &Nlensing)) Nlensing = 0;
+  if (!gfits_scan (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  &Nlensobj)) Nlensobj = 0;
 
   /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
@@ -212,4 +221,6 @@
   catalog[0].Nmiss_disk = Nmissing;
   catalog[0].Nsecf_disk = Naverage * Nsecfilt;
+  catalog[0].Nlensing_disk = Nlensing;
+  catalog[0].Nlensobj_disk = Nlensobj;
 
   /**  Nsecfilt is unusual: it does not list the number of data items in the table
@@ -222,4 +233,6 @@
   catalog[0].missing = NULL;
   catalog[0].secfilt = NULL;
+  catalog[0].lensing = NULL;
+  catalog[0].lensobj = NULL;
 
   /*** Average Table ***/
@@ -277,5 +290,5 @@
     }
     /* convert data format to internal : returns number of row read in Nmeasure */
-    catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat);
+    catalog[0].measure = FtableToMeasure (&ftable, catalog[0].average, &Nmeasure, &catalog[0].catformat);
     if (Nmeasure != catalog[0].Nmeas_disk) {
       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nmeasure,  catalog[0].Nmeas_disk);
@@ -372,4 +385,84 @@
   gfits_free_header (ftable.header);
 
+  /*** Lensing Table ***/
+  if (!(catalog[0].catflags & SKIP_LENSING)) {
+    // unless we specify 'skip', we still need to load the Lensing table
+    status = dvo_catalog_open_subcat (catalog, &catalog[0].lensing_catalog, ftable.header, "LENSING", VERBOSE);
+    if (status == DVO_CAT_OPEN_FAIL) {
+      return (FALSE);
+    }
+    // the Lensing file need not exist, unless we expect data to exist
+    if ((status == DVO_CAT_OPEN_EMPTY) && (catalog[0].Nlensing_disk > 0)) {
+      return (FALSE);
+    }
+  }
+  if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_LENSING)) {
+    // only read the Lensing table if the file actually exists
+    /* read Lensing table data */
+    if (!gfits_fread_ftable_data (catalog[0].lensing_catalog[0].f, &ftable, FALSE)) {
+      if (VERBOSE) fprintf (stderr, "can't read table lensing data\n");
+      return (FALSE);
+    }
+    /* convert data format to internal : returns number of row read in Nlensing */
+    catalog[0].lensing = FtableToLensing (&ftable, &Nlensing, &catalog[0].catformat);
+    if (Nlensing != catalog[0].Nlensing_disk) {
+      fprintf (stderr, "Warning: mismatch between Nlensing in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensing,  catalog[0].Nlensing_disk);
+    }
+    catalog[0].Nlensing = catalog[0].Nlensing_disk;
+    catalog[0].Nlensing_off = 0;
+  } else {
+    if (catalog[0].lensing_catalog) {
+      gfits_free_header (&catalog[0].lensing_catalog[0].header);
+    } else {
+      ALLOCATE (catalog[0].lensing_catalog, Catalog, 1);
+      dvo_catalog_init (catalog[0].lensing_catalog, TRUE);
+    }
+    gfits_create_header (&catalog[0].lensing_catalog[0].header);
+    ALLOCATE (catalog[0].lensing, Lensing, 1);
+    catalog[0].Nlensing = 0;
+    catalog[0].Nlensing_off = catalog[0].Nlensing_disk;
+  }
+  gfits_free_header (&header);
+
+  /*** Lensobj Table ***/
+  if (!(catalog[0].catflags & SKIP_LENSOBJ)) {
+    // unless we specify 'skip', we still need to load the 
+    status = dvo_catalog_open_subcat (catalog, &catalog[0].lensobj_catalog, ftable.header, "LENSOBJ", VERBOSE);
+    if (status == DVO_CAT_OPEN_FAIL) {
+      return (FALSE);
+    }
+    // the Lensobj file need not exist, unless we expect data to exist
+    if ((status == DVO_CAT_OPEN_EMPTY) && (catalog[0].Nlensobj_disk > 0)) {
+      return (FALSE);
+    }
+  }
+  if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_LENSOBJ)) {
+    // only read the Lensobj table if the file actually exists
+    /* read Lensobj table data */
+    if (!gfits_fread_ftable_data (catalog[0].lensobj_catalog[0].f, &ftable, FALSE)) {
+      if (VERBOSE) fprintf (stderr, "can't read table lensobj data\n");
+      return (FALSE);
+    }
+    /* convert data format to internal : returns number of row read in Nlensobj */
+    catalog[0].lensobj = FtableToLensobj (&ftable, &Nlensobj, &catalog[0].catformat);
+    if (Nlensobj != catalog[0].Nlensobj_disk) {
+      fprintf (stderr, "Warning: mismatch between Nlensobj in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensobj,  catalog[0].Nlensobj_disk);
+    }
+    catalog[0].Nlensobj = catalog[0].Nlensobj_disk;
+    catalog[0].Nlensobj_off = 0;
+  } else {
+    if (catalog[0].lensobj_catalog) {
+      gfits_free_header (&catalog[0].lensobj_catalog[0].header);
+    } else {
+      ALLOCATE (catalog[0].lensobj_catalog, Catalog, 1);
+      dvo_catalog_init (catalog[0].lensobj_catalog, TRUE);
+    }
+    gfits_create_header (&catalog[0].lensobj_catalog[0].header);
+    ALLOCATE (catalog[0].lensobj, Lensobj, 1);
+    catalog[0].Nlensobj = 0;
+    catalog[0].Nlensobj_off = catalog[0].Nlensobj_disk;
+  }
+  gfits_free_header (&header);
+
   return (TRUE);
 }
@@ -380,5 +473,5 @@
 
   off_t Nbytes;
-  off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing;
+  off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing, Nlensing, Nlensobj;
   Header header;
   FTable ftable;
@@ -476,5 +569,5 @@
 
     /* convert data format to internal : returns number of row read in Nmeasure */
-    catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat);
+    catalog[0].measure = FtableToMeasure (&ftable, catalog[0].average, &Nmeasure, &catalog[0].catformat);
     if (Nmeasure != Nrows) {
       // XXX this condition denotes the eof has been reached; not an error or a warning
@@ -519,4 +612,67 @@
     catalog[0].Nmiss_off = start;
   }
+
+  // XXX check the open status of the catalog
+  if (catalog[0].catflags & LOAD_LENSING) {
+
+    Catalog *subcat = catalog[0].lensing_catalog;
+
+    /* move pointer past header -- must be already read (load_catalog) */
+    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
+    fseeko (subcat[0].f, Nbytes, SEEK_SET);
+
+    /* read Lensing table header */
+    if (!gfits_fread_header (subcat[0].f, &header)) {
+      if (VERBOSE) fprintf (stderr, "can't read table lensing header");
+      return (FALSE);
+    }
+    /* read Lensing table data : format is irrelevant here */
+    if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) {
+      if (VERBOSE) fprintf (stderr, "can't read table lensing data");
+      return (FALSE);
+    }
+
+    /* convert data format to internal : returns number of row read in Nlensing */
+    catalog[0].lensing = FtableToLensing (&ftable, &Nlensing, &catalog[0].catformat);
+    if (Nlensing != Nrows) {
+      // XXX this condition denotes the eof has been reached; not an error or a warning
+      // fprintf (stderr, "Warning: mismatch between Nlensing in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensing,  Nrows);
+    }
+    gfits_free_header (&header);
+    catalog[0].Nlensing = Nlensing;
+    catalog[0].Nlensing_off = start;
+  }
+
+  // XXX check the open status of the catalog
+  if (catalog[0].catflags & LOAD_LENSOBJ) {
+
+    Catalog *subcat = catalog[0].lensobj_catalog;
+
+    /* move pointer past header -- must be already read (load_catalog) */
+    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
+    fseeko (subcat[0].f, Nbytes, SEEK_SET);
+
+    /* read Lensobj table header */
+    if (!gfits_fread_header (subcat[0].f, &header)) {
+      if (VERBOSE) fprintf (stderr, "can't read table lensobj header");
+      return (FALSE);
+    }
+    /* read Lensobj table data : format is irrelevant here */
+    if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) {
+      if (VERBOSE) fprintf (stderr, "can't read table lensobj data");
+      return (FALSE);
+    }
+
+    /* convert data format to internal : returns number of row read in Nlensobj */
+    catalog[0].lensobj = FtableToLensobj (&ftable, &Nlensobj, &catalog[0].catformat);
+    if (Nlensobj != Nrows) {
+      // XXX this condition denotes the eof has been reached; not an error or a warning
+      // fprintf (stderr, "Warning: mismatch between Nlensobj in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensobj,  Nrows);
+    }
+    gfits_free_header (&header);
+    catalog[0].Nlensobj = Nlensobj;
+    catalog[0].Nlensobj_off = start;
+  }
+
   return (TRUE);
 }
@@ -530,5 +686,5 @@
   SecFilt *primary, *secfilt;
   int Nsecfilt;
-  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
+  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new;
   off_t first, start, Nrows;
 
@@ -561,4 +717,6 @@
   Nmiss_disk_new = MAX (catalog[0].Nmiss_disk, catalog[0].Nmissing + catalog[0].Nmiss_off);
   Nsecf_disk_new = MAX (catalog[0].Nsecf_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecf_off);
+  Nlensing_disk_new = MAX (catalog[0].Nlensing_disk, catalog[0].Nlensing + catalog[0].Nlensing_off);
+  Nlensobj_disk_new = MAX (catalog[0].Nlensobj_disk, catalog[0].Nlensobj + catalog[0].Nlensobj_off);
 
   /* make sure header is consistent with data */
@@ -567,4 +725,6 @@
   gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  Nmiss_disk_new);
   gfits_modify (&catalog[0].header, "NSECFILT", "%d",   1, Nsecfilt);
+  gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  Nlensing_disk_new);
+  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
   gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
   gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
@@ -621,6 +781,6 @@
     assert (catalog[0].Nmeas_disk >= catalog[0].Nmeas_off);
 
-    // convert to external table format
-    if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
+    // convert to external table format (note that the block above does not damage or free catalog.average) 
+    if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
       fprintf (stderr, "trouble converting format\n");
       goto failure;
@@ -679,4 +839,58 @@
     if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) {
       fprintf (stderr, "failure writing SecFilt table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
+    gfits_free_table (&ftable);
+  }
+
+  /*** Lensing Table ***/
+  if ((catalog[0].catflags & LOAD_LENSING) && (catalog[0].lensing != NULL)) {
+
+    first  = 0;                    // first row in memory to write
+    start  = catalog[0].Nlensing_off; // first disk row to write
+    Nrows  = catalog[0].Nlensing - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first <= catalog[0].Nlensing);
+    assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off);
+
+    // convert to external table format (note that the block above does not damage or free catalog.average) 
+    if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Lensing table
+    if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) {
+      fprintf (stderr, "trouble writing Lensing table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
+    gfits_free_table (&ftable);
+  }
+
+  /*** Lensobj Table ***/
+  if ((catalog[0].catflags & LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) {
+
+    first  = 0;                    // first row in memory to write
+    start  = catalog[0].Nlensobj_off; // first disk row to write
+    Nrows  = catalog[0].Nlensobj - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first <= catalog[0].Nlensobj);
+    assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off);
+
+    // convert to external table format (note that the block above does not damage or free catalog.average) 
+    if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Lensobj table
+    if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) {
+      fprintf (stderr, "trouble writing Lensobj table\n");
       goto failure;
     }
@@ -711,5 +925,5 @@
   SecFilt *primary, *secfilt;
   int Nsecfilt;
-  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
+  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new;
   off_t first, start, Nrows;
 
@@ -734,4 +948,12 @@
   if (catalog[0].Nsecf_off > 0) {
     fprintf (stderr, "ERROR: only partial catalog (Secfilt) was loaded\n");
+    goto failure;
+  }
+  if (catalog[0].Nlensing_off > 0) {
+    fprintf (stderr, "ERROR: only partial catalog (Lensing) was loaded\n");
+    goto failure;
+  }
+  if (catalog[0].Nlensobj_off > 0) {
+    fprintf (stderr, "ERROR: only partial catalog (Lensobj) was loaded\n");
     goto failure;
   }
@@ -760,4 +982,6 @@
   Nmiss_disk_new = catalog[0].Nmissing;
   Nsecf_disk_new = catalog[0].Naverage*Nsecfilt;
+  Nlensing_disk_new = catalog[0].Nlensing;
+  Nlensobj_disk_new = catalog[0].Nlensobj;
 
   /* make sure header is consistent with data */
@@ -766,4 +990,6 @@
   gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  Nmiss_disk_new);
   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
+  gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  Nlensing_disk_new);
+  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
   gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
   gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
@@ -821,5 +1047,5 @@
 
     // convert to external table format
-    if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
+    if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
       fprintf (stderr, "trouble converting format\n");
       goto failure;
@@ -878,4 +1104,58 @@
     if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) {
       fprintf (stderr, "failure writing SecFilt table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
+    gfits_free_table (&ftable);
+  }
+
+  /*** Lensing Table ***/
+  if ((catalog[0].catflags & LOAD_LENSING) && (catalog[0].lensing != NULL)) {
+
+    first  = 0;                    // first row in memory to write
+    start  = catalog[0].Nlensing_off; // first disk row to write
+    Nrows  = catalog[0].Nlensing - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first <= catalog[0].Nlensing);
+    assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off);
+
+    // convert to external table format
+    if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Lensing table
+    if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) {
+      fprintf (stderr, "trouble writing Lensing table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
+    gfits_free_table (&ftable);
+  }
+
+  /*** Lensobj Table ***/
+  if ((catalog[0].catflags & LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) {
+
+    first  = 0;                    // first row in memory to write
+    start  = catalog[0].Nlensobj_off; // first disk row to write
+    Nrows  = catalog[0].Nlensobj - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first <= catalog[0].Nlensobj);
+    assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off);
+
+    // convert to external table format
+    if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Lensobj table
+    if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) {
+      fprintf (stderr, "trouble writing Lensobj table\n");
       goto failure;
     }
@@ -909,5 +1189,5 @@
   SecFilt *primary, *secfilt;
   int Nsecfilt;
-  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
+  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new;
   off_t first, start, Nrows;
 
@@ -939,4 +1219,6 @@
   Nmiss_disk_new = MAX (catalog[0].Nmiss_disk, catalog[0].Nmissing + catalog[0].Nmiss_off);
   Nsecf_disk_new = MAX (catalog[0].Nsecf_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecf_off);
+  Nlensing_disk_new = MAX (catalog[0].Nlensing_disk, catalog[0].Nlensing + catalog[0].Nlensing_off);
+  Nlensobj_disk_new = MAX (catalog[0].Nlensobj_disk, catalog[0].Nlensobj + catalog[0].Nlensobj_off);
 
   /* make sure header is consistent with data */
@@ -945,4 +1227,6 @@
   gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  Nmiss_disk_new);
   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
+  gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  Nlensing_disk_new);
+  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
   gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
   gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
@@ -1000,5 +1284,6 @@
 
     // convert to external table format
-    if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
+    // XXX does catalog.measure have averef correctly set up?
+    if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
       fprintf (stderr, "trouble converting format\n");
       goto failure;
@@ -1058,4 +1343,60 @@
     if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) {
       fprintf (stderr, "failure writing SecFilt table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
+    gfits_free_table (&ftable);
+  }
+
+  /*** Lensing Table ***/
+  if (catalog[0].lensing != NULL) {
+
+    first  = catalog[0].Nlensing_disk - catalog[0].Nlensing_off;  // first row in memory to write
+    start  = catalog[0].Nlensing_disk; // first disk row to write
+    Nrows  = catalog[0].Nlensing - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first <= catalog[0].Nlensing);
+    assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off);
+
+    // convert to external table format
+    // XXX does catalog.lensing have averef correctly set up?
+    if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Lensing table
+    if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) {
+      fprintf (stderr, "trouble writing Lensing table\n");
+      goto failure;
+    }
+    gfits_free_header (&header);
+    gfits_free_table (&ftable);
+  }
+
+  /*** Lensobj Table ***/
+  if (catalog[0].lensobj != NULL) {
+
+    first  = catalog[0].Nlensobj_disk - catalog[0].Nlensobj_off;  // first row in memory to write
+    start  = catalog[0].Nlensobj_disk; // first disk row to write
+    Nrows  = catalog[0].Nlensobj - first;
+
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first <= catalog[0].Nlensobj);
+    assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off);
+
+    // convert to external table format
+    // XXX does catalog.lensobj have averef correctly set up?
+    if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+
+    // write out Lensobj table
+    if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) {
+      fprintf (stderr, "trouble writing Lensobj table\n");
       goto failure;
     }
Index: /trunk/Ohana/src/libdvo/src/dvo_convert.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert.c	(revision 37035)
@@ -41,4 +41,5 @@
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_V3",          PS1_V3);
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_V4",          PS1_V4);
+  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V5",          PS1_V5);
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF",         PS1_REF);
 # undef CONVERT_FORMAT
@@ -112,4 +113,5 @@
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_V3",          PS1_V3,          PS1_V3);
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_V4",          PS1_V4,          PS1_V4);
+  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V5",          PS1_V5,          PS1_V5);
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF",         PS1_REF,         PS1_REF);
 # undef CONVERT_FORMAT
@@ -147,4 +149,5 @@
       FORMAT_CASE (PS1_V3,          PS1_V3);
       FORMAT_CASE (PS1_V4,          PS1_V4);
+      FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);
 # undef FORMAT_CASE
@@ -159,5 +162,6 @@
 /*** Measure / FTable conversion functions ***/
 
-Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format) {
+// FtableToMeasure needs the Average since old formats stored measure.dR,dD only
+Measure *FtableToMeasure (FTable *ftable, Average *average, off_t *Nmeasure, char *format) {
 
   Measure *measure;
@@ -179,5 +183,6 @@
       exit (2);
     }
-    measure = Measure_PS1_V4alt_ToInternal (tmpMeasure, *Nmeasure);
+    myAssert (average, "conversion to internal needs average table");
+    measure = Measure_PS1_V4alt_ToInternal (average, tmpMeasure, *Nmeasure);
     free (tmpMeasure);
     *format = DVO_FORMAT_PS1_V4;
@@ -185,15 +190,16 @@
   }
 
-# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
-  if (!strcmp (extname, NAME)) { \
-    Measure_##TYPE *tmpMeasure; \
+# 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); }
 
@@ -208,15 +214,16 @@
   }
 
-  CONVERT_FORMAT ("DVO_MEASURE_ELIXIR", 	 ELIXIR, 	  Elixir);
-  CONVERT_FORMAT ("DVO_MEASURE_LONEOS", 	 LONEOS,          Loneos);
-  CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
-  CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
-  CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
-  CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
-  CONVERT_FORMAT ("DVO_MEASURE_PS1_V1",          PS1_V1,          PS1_V1);
-  CONVERT_FORMAT ("DVO_MEASURE_PS1_V2",          PS1_V2,          PS1_V2);
-  CONVERT_FORMAT ("DVO_MEASURE_PS1_V3",          PS1_V3,          PS1_V3);
-  CONVERT_FORMAT ("DVO_MEASURE_PS1_V4",          PS1_V4,          PS1_V4);
-  CONVERT_FORMAT ("DVO_MEASURE_PS1_REF",         PS1_REF,         PS1_REF);
+  CONVERT_FORMAT ("DVO_MEASURE_ELIXIR", 	 ELIXIR, 	  Elixir,          FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_LONEOS", 	 LONEOS,          Loneos,          FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0, FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1, FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1,       FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2,       FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PS1_V1",          PS1_V1,          PS1_V1,          FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PS1_V2",          PS1_V2,          PS1_V2,          FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PS1_V3",          PS1_V3,          PS1_V3,          FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PS1_V4",          PS1_V4,          PS1_V4,          FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PS1_V5",          PS1_V5,          PS1_V5,          TRUE);
+  CONVERT_FORMAT ("DVO_MEASURE_PS1_REF",         PS1_REF,         PS1_REF,         FALSE);
 # undef CONVERT_FORMAT
 
@@ -227,10 +234,12 @@
 }
 
-int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format) {
-
-# define FORMAT_CASE(FORMAT, TYPE) \
+// MeasureToFtable needs the Average since old formats stored measure.dR,dD only
+int MeasureToFtable (FTable *ftable, Average *average, Measure *measure, off_t Nmeasure, char format) {
+
+# define FORMAT_CASE(FORMAT, TYPE, ABS_COORDS)		\
     case DVO_FORMAT_##FORMAT: { \
       Measure_##TYPE *tmpMeasure; \
-      tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \
+      myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
+      tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
       gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure); \
       free (tmpMeasure); \
@@ -243,15 +252,16 @@
       break; }
 
-      FORMAT_CASE (ELIXIR, 	    Elixir);
-      FORMAT_CASE (LONEOS, 	    Loneos);
-      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
-      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
-      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
-      FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
-      FORMAT_CASE (PS1_V1,          PS1_V1);
-      FORMAT_CASE (PS1_V2,          PS1_V2);
-      FORMAT_CASE (PS1_V3,          PS1_V3);
-      FORMAT_CASE (PS1_V4,          PS1_V4);
-      FORMAT_CASE (PS1_REF,         PS1_REF);
+      FORMAT_CASE (ELIXIR, 	    Elixir,          FALSE);
+      FORMAT_CASE (LONEOS, 	    Loneos,          FALSE);
+      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0, FALSE);
+      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1, FALSE);
+      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1,       FALSE);
+      FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2,       FALSE);
+      FORMAT_CASE (PS1_V1,          PS1_V1,          FALSE);
+      FORMAT_CASE (PS1_V2,          PS1_V2,          FALSE);
+      FORMAT_CASE (PS1_V3,          PS1_V3,          FALSE);
+      FORMAT_CASE (PS1_V4,          PS1_V4,          FALSE);
+      FORMAT_CASE (PS1_V5,          PS1_V5,          TRUE);
+      FORMAT_CASE (PS1_REF,         PS1_REF,         FALSE);
 # undef FORMAT_CASE
 
@@ -309,4 +319,5 @@
   CONVERT_FORMAT ("DVO_SECFILT_PS1_V3",          PS1_V3,          PS1_V3);
   CONVERT_FORMAT ("DVO_SECFILT_PS1_V4",          PS1_V4,          PS1_V4);
+  CONVERT_FORMAT ("DVO_SECFILT_PS1_V5",          PS1_V5,          PS1_V5);
   CONVERT_FORMAT ("DVO_SECFILT_PS1_REF",         PS1_REF,         PS1_REF);
 # undef CONVERT_FORMAT
@@ -344,4 +355,5 @@
       FORMAT_CASE (PS1_V3,          PS1_V3);
       FORMAT_CASE (PS1_V4,          PS1_V4);
+      FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);
 # undef FORMAT_CASE
@@ -349,4 +361,192 @@
     default:
       fprintf (stderr, "table format unknown (secfilt)\n");
+      return (FALSE);
+  }
+  return (TRUE);
+}
+
+/*** Lensing / FTable conversion functions ***/
+
+Lensing *FtableToLensing (FTable *ftable, off_t *Nlensing, char *format) {
+
+  Lensing *lensing;
+  char extname[80];
+
+  /* convert to the internal format */
+  if (!gfits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
+    fprintf (stderr, "EXTNAME missing for lensing table\n");
+    return (FALSE);
+  }
+
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)		\
+  if (!strcmp (extname, NAME)) {					\
+    Lensing_##TYPE *tmpLensing;						\
+    tmpLensing = gfits_table_get_Lensing_##TYPE (ftable, Nlensing, NULL); \
+    if (!tmpLensing) {							\
+      fprintf (stderr, "ERROR: failed to read lensings\n");		\
+      exit (2);								\
+    }									\
+    lensing = Lensing_##TYPE##_ToInternal (tmpLensing, *Nlensing); \
+    free (tmpLensing);							\
+    *format = DVO_FORMAT_##FORMAT;					\
+    return (lensing); }
+
+  if (!strcmp (extname, "DVO_LENSING")) {
+    lensing = gfits_table_get_Lensing (ftable, Nlensing, NULL);
+    if (!lensing) {
+      fprintf (stderr, "ERROR: failed to read lensings\n");
+      exit (2);
+    }
+    *format = DVO_FORMAT_INTERNAL;
+    return (lensing);
+  }
+
+// CONVERT_FORMAT ("DVO_LENSING_PS1_REF",         PS1_REF,         PS1_REF);
+// CONVERT_FORMAT ("DVO_LENSING_ELIXIR", 	  ELIXIR,  	   Elixir);
+// CONVERT_FORMAT ("DVO_LENSING_LONEOS", 	  LONEOS,          Loneos);
+// CONVERT_FORMAT ("DVO_LENSING_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
+// CONVERT_FORMAT ("DVO_LENSING_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
+// CONVERT_FORMAT ("DVO_LENSING_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
+// CONVERT_FORMAT ("DVO_LENSING_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
+// CONVERT_FORMAT ("DVO_LENSING_PS1_V1",          PS1_V1,          PS1_V1);
+// CONVERT_FORMAT ("DVO_LENSING_PS1_V2",          PS1_V2,          PS1_V2);
+// CONVERT_FORMAT ("DVO_LENSING_PS1_V3",          PS1_V3,          PS1_V3);
+// CONVERT_FORMAT ("DVO_LENSING_PS1_V4",          PS1_V4,          PS1_V4);
+  CONVERT_FORMAT ("DVO_LENSING_PS1_V5",          PS1_V5,          PS1_V5);
+# undef CONVERT_FORMAT
+
+  fprintf (stderr, "table format unknown: %s\n", extname);
+
+  *Nlensing = 0;
+  return (NULL);
+}
+
+// LensingToFtable needs the Average since old formats stored lensing.dR,dD only
+int LensingToFtable (FTable *ftable, Lensing *lensing, off_t Nlensing, char format) {
+
+# define FORMAT_CASE(FORMAT, TYPE)		\
+    case DVO_FORMAT_##FORMAT: { \
+      Lensing_##TYPE *tmpLensing; \
+      tmpLensing = LensingInternalTo_##TYPE (lensing, Nlensing); \
+      gfits_table_set_Lensing_##TYPE (ftable, tmpLensing, Nlensing); \
+      free (tmpLensing); \
+      break; }
+
+  /* convert from the internal format */
+  switch (format) {
+    case DVO_FORMAT_INTERNAL: {
+      gfits_table_set_Lensing (ftable, lensing, Nlensing);
+      break; }
+
+//    FORMAT_CASE (PS1_REF,         PS1_REF);
+//    FORMAT_CASE (ELIXIR, 	    Elixir);
+//    FORMAT_CASE (LONEOS, 	    Loneos);
+//    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
+//    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
+//    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
+//    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
+//    FORMAT_CASE (PS1_V1,          PS1_V1);
+//    FORMAT_CASE (PS1_V2,          PS1_V2);
+//    FORMAT_CASE (PS1_V3,          PS1_V3);
+//    FORMAT_CASE (PS1_V4,          PS1_V4);
+      FORMAT_CASE (PS1_V5,          PS1_V5);
+# undef FORMAT_CASE
+
+    default:
+      fprintf (stderr, "table format unknown (lensing)\n");
+      return (FALSE);
+  }
+  return (TRUE);
+}
+
+/*** Lensobj / FTable conversion functions ***/
+
+Lensobj *FtableToLensobj (FTable *ftable, off_t *Nlensobj, char *format) {
+
+  Lensobj *lensobj;
+  char extname[80];
+
+  /* convert to the internal format */
+  if (!gfits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
+    fprintf (stderr, "EXTNAME missing for lensobj table\n");
+    return (FALSE);
+  }
+
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)		\
+  if (!strcmp (extname, NAME)) {					\
+    Lensobj_##TYPE *tmpLensobj;						\
+    tmpLensobj = gfits_table_get_Lensobj_##TYPE (ftable, Nlensobj, NULL); \
+    if (!tmpLensobj) {							\
+      fprintf (stderr, "ERROR: failed to read lensobjs\n");		\
+      exit (2);								\
+    }									\
+    lensobj = Lensobj_##TYPE##_ToInternal (tmpLensobj, *Nlensobj); \
+    free (tmpLensobj);							\
+    *format = DVO_FORMAT_##FORMAT;					\
+    return (lensobj); }
+
+  if (!strcmp (extname, "DVO_LENSOBJ")) {
+    lensobj = gfits_table_get_Lensobj (ftable, Nlensobj, NULL);
+    if (!lensobj) {
+      fprintf (stderr, "ERROR: failed to read lensobjs\n");
+      exit (2);
+    }
+    *format = DVO_FORMAT_INTERNAL;
+    return (lensobj);
+  }
+
+// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_REF",         PS1_REF,         PS1_REF);
+// CONVERT_FORMAT ("DVO_LENSOBJ_ELIXIR", 	  ELIXIR,  	   Elixir);
+// CONVERT_FORMAT ("DVO_LENSOBJ_LONEOS", 	  LONEOS,          Loneos);
+// CONVERT_FORMAT ("DVO_LENSOBJ_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
+// CONVERT_FORMAT ("DVO_LENSOBJ_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
+// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
+// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
+// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V1",          PS1_V1,          PS1_V1);
+// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V2",          PS1_V2,          PS1_V2);
+// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V3",          PS1_V3,          PS1_V3);
+// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V4",          PS1_V4,          PS1_V4);
+  CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V5",          PS1_V5,          PS1_V5);
+# undef CONVERT_FORMAT
+
+  fprintf (stderr, "table format unknown: %s\n", extname);
+
+  *Nlensobj = 0;
+  return (NULL);
+}
+
+// LensobjToFtable needs the Average since old formats stored lensobj.dR,dD only
+int LensobjToFtable (FTable *ftable, Lensobj *lensobj, off_t Nlensobj, char format) {
+
+# define FORMAT_CASE(FORMAT, TYPE)		\
+    case DVO_FORMAT_##FORMAT: { \
+      Lensobj_##TYPE *tmpLensobj; \
+      tmpLensobj = LensobjInternalTo_##TYPE (lensobj, Nlensobj); \
+      gfits_table_set_Lensobj_##TYPE (ftable, tmpLensobj, Nlensobj); \
+      free (tmpLensobj); \
+      break; }
+
+  /* convert from the internal format */
+  switch (format) {
+    case DVO_FORMAT_INTERNAL: {
+      gfits_table_set_Lensobj (ftable, lensobj, Nlensobj);
+      break; }
+
+//    FORMAT_CASE (PS1_REF,         PS1_REF);
+//    FORMAT_CASE (ELIXIR, 	    Elixir);
+//    FORMAT_CASE (LONEOS, 	    Loneos);
+//    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
+//    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
+//    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
+//    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
+//    FORMAT_CASE (PS1_V1,          PS1_V1);
+//    FORMAT_CASE (PS1_V2,          PS1_V2);
+//    FORMAT_CASE (PS1_V3,          PS1_V3);
+//    FORMAT_CASE (PS1_V4,          PS1_V4);
+      FORMAT_CASE (PS1_V5,          PS1_V5);
+# undef FORMAT_CASE
+
+    default:
+      fprintf (stderr, "table format unknown (lensobj)\n");
       return (FALSE);
   }
@@ -428,4 +628,5 @@
   CONVERT_FORMAT ("DVO_IMAGE_PS1_V3",          PS1_V3,          PS1_V3);
   CONVERT_FORMAT ("DVO_IMAGE_PS1_V4",          PS1_V4,          PS1_V4);
+  CONVERT_FORMAT ("DVO_IMAGE_PS1_V5",          PS1_V5,          PS1_V5);
   CONVERT_FORMAT ("DVO_IMAGE_PS1_REF",         PS1_REF,         PS1_REF);
 
@@ -467,4 +668,5 @@
       FORMAT_CASE (PS1_V3,          PS1_V3);
       FORMAT_CASE (PS1_V4,          PS1_V4);
+      FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);
 
@@ -522,4 +724,5 @@
       FORMAT_CASE (PS1_V3,          PS1_V3);
       FORMAT_CASE (PS1_V4,          PS1_V4);
+      FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);
 
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c	(revision 37035)
@@ -3,5 +3,5 @@
 /* convert PS1_DEV_1 formats to internal formats */
 
-Measure *Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, off_t Nvalues) {
+Measure *Measure_PS1_DEV_1_ToInternal (Average *ave, Measure_PS1_DEV_1 *in, off_t Nvalues) {
 
   off_t i;
@@ -12,6 +12,8 @@
   for (i = 0; i < Nvalues; i++) {
     dvo_measure_init (&out[i]);
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -50,5 +52,5 @@
 }
 
-Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Measure *in, off_t Nvalues) {
+Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -58,6 +60,8 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+
+    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
+    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -180,5 +184,5 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
@@ -197,5 +201,5 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
@@ -203,4 +207,6 @@
   return (out);
 }
+
+# define RAW_IMAGE_NAME_LEN 64
 
 Image *Image_PS1_DEV_1_ToInternal (Image_PS1_DEV_1 *in, off_t Nvalues, off_t Nalloc) {
@@ -217,6 +223,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 63); // out[128], in[64]
-    out[i].name[63] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -284,6 +291,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 63); // out[128], in[64]
-    out[i].name[63] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c	(revision 37035)
@@ -3,5 +3,5 @@
 /* convert PS1_DEV_2 formats to internal formats */
 
-Measure *Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, off_t Nvalues) {
+Measure *Measure_PS1_DEV_2_ToInternal (Average *ave, Measure_PS1_DEV_2 *in, off_t Nvalues) {
 
   off_t i;
@@ -12,6 +12,8 @@
   for (i = 0; i < Nvalues; i++) {
     dvo_measure_init (&out[i]);
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -48,5 +50,5 @@
 }
 
-Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Measure *in, off_t Nvalues) {
+Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -56,6 +58,8 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+
+    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
+    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -119,5 +123,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor  = in[i].refColor;
+    out[i].refColorBlue  = in[i].refColor;
     out[i].objID 	 = in[i].objID;
     out[i].catID 	 = in[i].catID;
@@ -153,5 +157,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor  = in[i].refColor;
+    out[i].refColor  = in[i].refColorBlue;
     out[i].objID 	 = in[i].objID;
     out[i].catID 	 = in[i].catID;
@@ -175,5 +179,5 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
@@ -192,5 +196,5 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
@@ -198,4 +202,6 @@
   return (out);
 }
+
+# define RAW_IMAGE_NAME_LEN 64
 
 Image *Image_PS1_DEV_2_ToInternal (Image_PS1_DEV_2 *in, off_t Nvalues, off_t Nalloc) {
@@ -212,6 +218,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 63); // out[121], in[64]
-    out[i].name[63] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -276,6 +283,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 63); // in[121], out[64]
-    out[i].name[63] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c	(revision 37035)
@@ -3,5 +3,5 @@
 /* convert PS1_REF formats to internal formats */
 
-Measure *Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, off_t Nvalues) {
+Measure *Measure_PS1_REF_ToInternal (Average *ave, Measure_PS1_REF *in, off_t Nvalues) {
 
   off_t i;
@@ -13,6 +13,7 @@
     dvo_measure_init (&out[i]);
 
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].dM         = in[i].dM;
@@ -28,5 +29,5 @@
 }
 
-Measure_PS1_REF *MeasureInternalTo_PS1_REF (Measure *in, off_t Nvalues) {
+Measure_PS1_REF *MeasureInternalTo_PS1_REF (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -36,6 +37,8 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+
+    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
+    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
     out[i].M          = in[i].M;
     out[i].dM         = in[i].dM;
@@ -129,4 +132,6 @@
 }
 
+# define RAW_IMAGE_NAME_LEN 121
+
 Image *Image_PS1_REF_ToInternal (Image_PS1_REF *in, off_t Nvalues, off_t Nalloc) {
 
@@ -142,6 +147,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -204,6 +210,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c	(revision 37035)
@@ -3,5 +3,5 @@
 /* convert PS1_V1 formats to internal formats */
 
-Measure *Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, off_t Nvalues) {
+Measure *Measure_PS1_V1_ToInternal (Average *ave, Measure_PS1_V1 *in, off_t Nvalues) {
 
   off_t i;
@@ -13,6 +13,7 @@
     dvo_measure_init (&out[i]);
 
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -58,5 +59,5 @@
 }
 
-Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Measure *in, off_t Nvalues) {
+Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -66,6 +67,8 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+
+    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
+    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -140,5 +143,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor  = in[i].refColor;
+    out[i].refColorBlue  = in[i].refColor;
     out[i].flags     	 = in[i].flags;   
     out[i].objID 	 = in[i].objID;
@@ -175,5 +178,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor  = in[i].refColor;
+    out[i].refColor      = in[i].refColorBlue;
     out[i].flags     	 = in[i].flags;   
     out[i].objID 	 = in[i].objID;
@@ -196,9 +199,9 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Mchisq= in[i].Mchisq;     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
-    out[i].M_20  = in[i].M_20;      
-    out[i].M_80  = in[i].M_80;      
+    out[i].Mmin  = in[i].M_20*0.001;      
+    out[i].Mmax  = in[i].M_80*0.001;      
  }
   return (out);
@@ -215,12 +218,14 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Mchisq= in[i].Mchisq;     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
-    out[i].M_20  = in[i].M_20;      
-    out[i].M_80  = in[i].M_80;      
-  }
-  return (out);
-}
+    out[i].M_20  = in[i].Mmin*1000.0;      
+    out[i].M_80  = in[i].Mmax*1000.0;      
+  }
+  return (out);
+}
+
+# define RAW_IMAGE_NAME_LEN 121
 
 Image *Image_PS1_V1_ToInternal (Image_PS1_V1 *in, off_t Nvalues, off_t Nalloc) {
@@ -237,6 +242,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -300,6 +306,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c	(revision 37035)
@@ -3,5 +3,5 @@
 /* convert PS1_V2 formats to internal formats */
 
-Measure *Measure_PS1_V2_ToInternal (Measure_PS1_V2 *in, off_t Nvalues) {
+Measure *Measure_PS1_V2_ToInternal (Average *ave, Measure_PS1_V2 *in, off_t Nvalues) {
 
   off_t i;
@@ -13,6 +13,7 @@
     dvo_measure_init (&out[i]);
 
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -59,5 +60,5 @@
 }
 
-Measure_PS1_V2 *MeasureInternalTo_PS1_V2 (Measure *in, off_t Nvalues) {
+Measure_PS1_V2 *MeasureInternalTo_PS1_V2 (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -67,6 +68,8 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+
+    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
+    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -145,5 +148,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor  = in[i].refColor;
+    out[i].refColorBlue  = in[i].refColor;
     out[i].flags     	 = in[i].flags;   
     out[i].objID 	 = in[i].objID;
@@ -184,5 +187,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor  = in[i].refColor;
+    out[i].refColor  = in[i].refColorBlue;
     out[i].flags     	 = in[i].flags;   
     out[i].objID 	 = in[i].objID;
@@ -205,10 +208,10 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Mchisq= in[i].Mchisq;     
     out[i].flags = in[i].flags;     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
-    out[i].M_20  = in[i].M_20;      
-    out[i].M_80  = in[i].M_80;      
+    out[i].Mmin  = in[i].M_20*0.001;      
+    out[i].Mmax  = in[i].M_80*0.001;      
  }
   return (out);
@@ -225,13 +228,15 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Mchisq= in[i].Mchisq;     
     out[i].flags = in[i].flags;     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
-    out[i].M_20  = in[i].M_20;      
-    out[i].M_80  = in[i].M_80;      
-  }
-  return (out);
-}
+    out[i].M_20  = in[i].Mmin*1000.0;      
+    out[i].M_80  = in[i].Mmax*1000.0;      
+  }
+  return (out);
+}
+
+# define RAW_IMAGE_NAME_LEN 121
 
 Image *Image_PS1_V2_ToInternal (Image_PS1_V2 *in, off_t Nvalues, off_t Nalloc) {
@@ -248,6 +253,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -269,5 +275,5 @@
     out[i].DECo  	    = in[i].DECo;
     out[i].Radius  	    = in[i].Radius;
-    out[i].refColor  	    = in[i].refColor;
+    out[i].refColorBlue  	    = in[i].refColor;
 
     out[i].detection_limit  = in[i].detection_limit;
@@ -311,6 +317,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -332,5 +339,5 @@
     out[i].DECo  	    = in[i].DECo;
     out[i].Radius  	    = in[i].Radius;
-    out[i].refColor  	    = in[i].refColor;
+    out[i].refColor  	    = in[i].refColorBlue;
 
     out[i].detection_limit  = in[i].detection_limit;
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c	(revision 37035)
@@ -3,5 +3,5 @@
 /* convert PS1_V3 formats to internal formats */
 
-Measure *Measure_PS1_V3_ToInternal (Measure_PS1_V3 *in, off_t Nvalues) {
+Measure *Measure_PS1_V3_ToInternal (Average *ave, Measure_PS1_V3 *in, off_t Nvalues) {
 
   off_t i;
@@ -13,6 +13,7 @@
     dvo_measure_init (&out[i]);
 
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -59,5 +60,5 @@
 }
 
-Measure_PS1_V3 *MeasureInternalTo_PS1_V3 (Measure *in, off_t Nvalues) {
+Measure_PS1_V3 *MeasureInternalTo_PS1_V3 (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -67,6 +68,8 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+
+    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
+    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -145,5 +148,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor  = in[i].refColor;
+    out[i].refColorBlue  = in[i].refColor;
     out[i].flags     	 = in[i].flags;   
     out[i].photFlagsUpper = in[i].photFlagsUpper;   
@@ -186,5 +189,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor  = in[i].refColor;
+    out[i].refColor      = in[i].refColorBlue;
     out[i].flags     	 = in[i].flags;   
     out[i].photFlagsUpper = in[i].photFlagsUpper;   
@@ -210,10 +213,10 @@
     out[i].Map         = in[i].Map;      
     out[i].dM          = in[i].dM;      
-    out[i].Xm          = in[i].Xm;     
+    out[i].Mchisq      = in[i].Mchisq;     
     out[i].flags       = in[i].flags;     
     out[i].Ncode       = in[i].Ncode;
     out[i].Nused       = in[i].Nused;
-    out[i].M_20        = in[i].M_20;      
-    out[i].M_80        = in[i].M_80;      
+    out[i].Mmin        = in[i].M_20*0.001;      
+    out[i].Mmax        = in[i].M_80*0.001;      
     out[i].Mstdev      = in[i].Mstdev;      
     out[i].ubercalDist = in[i].ubercalDist;      
@@ -233,10 +236,10 @@
     out[i].Map         = in[i].Map;      
     out[i].dM          = in[i].dM;      
-    out[i].Xm          = in[i].Xm;     
+    out[i].Mchisq      = in[i].Mchisq;     
     out[i].flags       = in[i].flags;     
     out[i].Ncode       = in[i].Ncode;
     out[i].Nused       = in[i].Nused;
-    out[i].M_20        = in[i].M_20;      
-    out[i].M_80        = in[i].M_80;      
+    out[i].M_20        = in[i].Mmin*1000.0;      
+    out[i].M_80        = in[i].Mmax*1000.0;      
     out[i].Mstdev      = in[i].Mstdev;      
     out[i].ubercalDist = in[i].ubercalDist;      
@@ -244,4 +247,6 @@
   return (out);
 }
+
+# define RAW_IMAGE_NAME_LEN 121
 
 Image *Image_PS1_V3_ToInternal (Image_PS1_V3 *in, off_t Nvalues, off_t Nalloc) {
@@ -258,6 +263,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -279,5 +285,5 @@
     out[i].DECo  	    = in[i].DECo;
     out[i].Radius  	    = in[i].Radius;
-    out[i].refColor  	    = in[i].refColor;
+    out[i].refColorBlue     = in[i].refColor;
 
     out[i].detection_limit  = in[i].detection_limit;
@@ -321,6 +327,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -342,5 +349,5 @@
     out[i].DECo  	    = in[i].DECo;
     out[i].Radius  	    = in[i].Radius;
-    out[i].refColor  	    = in[i].refColor;
+    out[i].refColor  	    = in[i].refColorBlue;
 
     out[i].detection_limit  = in[i].detection_limit;
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c	(revision 37035)
@@ -3,5 +3,5 @@
 /* convert PS1_V4 formats to internal formats */
 
-Measure *Measure_PS1_V4_ToInternal (Measure_PS1_V4 *in, off_t Nvalues) {
+Measure *Measure_PS1_V4_ToInternal (Average *ave, Measure_PS1_V4 *in, off_t Nvalues) {
 
   off_t i;
@@ -13,6 +13,7 @@
     dvo_measure_init (&out[i]);
 
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -68,5 +69,5 @@
 }
 
-Measure_PS1_V4 *MeasureInternalTo_PS1_V4 (Measure *in, off_t Nvalues) {
+Measure_PS1_V4 *MeasureInternalTo_PS1_V4 (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -76,6 +77,8 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+
+    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
+    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -166,5 +169,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor      = in[i].refColor;
+    out[i].refColorBlue  = in[i].refColor;
     out[i].flags     	 = in[i].flags;   
     out[i].photFlagsUpper = in[i].photFlagsUpper;   
@@ -210,5 +213,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor      = in[i].refColor;
+    out[i].refColor      = in[i].refColorBlue;
     out[i].flags     	 = in[i].flags;   
     out[i].photFlagsUpper = in[i].photFlagsUpper;   
@@ -236,14 +239,14 @@
     out[i].dMkron        = in[i].dMkron;      
     out[i].dM            = in[i].dM;      
-    out[i].Xm            = in[i].Xm;     
-    out[i].FluxPSF       = in[i].FluxPSF;
-    out[i].dFluxPSF      = in[i].dFluxPSF;
-    out[i].FluxKron      = in[i].FluxKron;
-    out[i].dFluxKron     = in[i].dFluxKron;
+    out[i].Mchisq        = in[i].Mchisq;     
+    out[i].FpsfStk       = in[i].FluxPSF;
+    out[i].dFpsfStk      = in[i].dFluxPSF;
+    out[i].FkronStk      = in[i].FluxKron;
+    out[i].dFkronStk     = in[i].dFluxKron;
     out[i].flags         = in[i].flags;     
     out[i].Ncode         = in[i].Ncode;
     out[i].Nused         = in[i].Nused;
-    out[i].M_20          = in[i].M_20;      
-    out[i].M_80          = in[i].M_80;      
+    out[i].Mmin          = in[i].M_20*0.001;      
+    out[i].Mmax          = in[i].M_80*0.001;      
     out[i].Mstdev        = in[i].Mstdev;      
     out[i].ubercalDist   = in[i].ubercalDist;      
@@ -266,14 +269,14 @@
     out[i].dMkron      	 = in[i].dMkron;      
     out[i].dM          	 = in[i].dM;      
-    out[i].Xm          	 = in[i].Xm;     
-    out[i].FluxPSF     	 = in[i].FluxPSF;
-    out[i].dFluxPSF    	 = in[i].dFluxPSF;
-    out[i].FluxKron    	 = in[i].FluxKron;
-    out[i].dFluxKron   	 = in[i].dFluxKron;
+    out[i].Mchisq        = in[i].Mchisq;
+    out[i].FluxPSF     	 = in[i].FpsfStk;
+    out[i].dFluxPSF    	 = in[i].dFpsfStk;
+    out[i].FluxKron    	 = in[i].FkronStk;
+    out[i].dFluxKron   	 = in[i].dFkronStk;
     out[i].flags       	 = in[i].flags;     
     out[i].Ncode       	 = in[i].Ncode;
     out[i].Nused       	 = in[i].Nused;
-    out[i].M_20        	 = in[i].M_20;      
-    out[i].M_80        	 = in[i].M_80;      
+    out[i].M_20        	 = in[i].Mmin*1000.0;      
+    out[i].M_80        	 = in[i].Mmax*1000.0;      
     out[i].Mstdev      	 = in[i].Mstdev;      
     out[i].ubercalDist 	 = in[i].ubercalDist;      
@@ -282,4 +285,6 @@
   return (out);
 }
+
+# define RAW_IMAGE_NAME_LEN 121
 
 Image *Image_PS1_V4_ToInternal (Image_PS1_V4 *in, off_t Nvalues, off_t Nalloc) {
@@ -296,6 +301,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -317,5 +323,5 @@
     out[i].DECo  	    = in[i].DECo;
     out[i].Radius  	    = in[i].Radius;
-    out[i].refColor  	    = in[i].refColor;
+    out[i].refColorBlue	    = in[i].refColor;
 
     out[i].detection_limit  = in[i].detection_limit;
@@ -359,6 +365,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
-    out[i].name[120] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
+    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -380,5 +387,5 @@
     out[i].DECo  	    = in[i].DECo;
     out[i].Radius  	    = in[i].Radius;
-    out[i].refColor  	    = in[i].refColor;
+    out[i].refColor  	    = in[i].refColorBlue;
 
     out[i].detection_limit  = in[i].detection_limit;
@@ -486,5 +493,5 @@
 /*** there are some mini dvodbs with the wrong PS1_V4 format (missing Xoff,Yoff / Xfix,Yfix) ************/
 
-Measure *Measure_PS1_V4alt_ToInternal (Measure_PS1_V4alt *in, off_t Nvalues) {
+Measure *Measure_PS1_V4alt_ToInternal (Average *ave, Measure_PS1_V4alt *in, off_t Nvalues) {
 
   off_t i;
@@ -496,6 +503,7 @@
     dvo_measure_init (&out[i]);
 
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].Mcal       = in[i].Mcal;
@@ -682,5 +690,5 @@
     out[i].measureOffset = in[i].measureOffset; 
     out[i].missingOffset = in[i].missingOffset;
-    out[i].refColor      = in[i].refColor;
+    out[i].refColorBlue  = in[i].refColor;
     out[i].flags     	 = in[i].flags;   
     out[i].photFlagsUpper = in[i].photFlagsUpper;   
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V5.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V5.c	(revision 37035)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V5.c	(revision 37035)
@@ -0,0 +1,833 @@
+# include <dvo.h>
+
+/* convert PS1_V5 formats to internal formats */
+
+Measure *Measure_PS1_V5_ToInternal (Average *ave, Measure_PS1_V5 *in, off_t Nvalues) {
+
+  off_t i;
+  Measure *out;
+
+  ALLOCATE_ZERO (out, Measure, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    dvo_measure_init (&out[i]);
+
+    out[i].R          = in[i].R;
+    out[i].D          = in[i].D;
+    out[i].M          = in[i].M;
+    out[i].dM         = in[i].dM;
+    out[i].Map        = in[i].Map;
+    out[i].dMap       = in[i].dMap;
+    out[i].Mkron      = in[i].Mkron;
+    out[i].dMkron     = in[i].dMkron;
+    out[i].Mcal       = in[i].Mcal;
+    out[i].dMcal      = in[i].dMcal;
+    out[i].dt         = in[i].dt;
+    out[i].FluxPSF    = in[i].FluxPSF;
+    out[i].dFluxPSF   = in[i].dFluxPSF;
+    out[i].FluxKron   = in[i].FluxKron;
+    out[i].dFluxKron  = in[i].dFluxKron;
+    out[i].FluxAp     = in[i].FluxAp;
+    out[i].dFluxAp    = in[i].dFluxAp;
+    out[i].airmass    = in[i].airmass;
+    out[i].az         = in[i].az;
+    out[i].Xccd       = in[i].Xccd;
+    out[i].Yccd       = in[i].Yccd;
+    out[i].Xfix       = in[i].Xfix;
+    out[i].Yfix       = in[i].Yfix;
+    out[i].XoffKH     = in[i].XoffKH;
+    out[i].YoffKH     = in[i].YoffKH;
+    out[i].XoffDCR    = in[i].XoffDCR;
+    out[i].YoffDCR    = in[i].YoffDCR;
+    out[i].RoffGAL    = in[i].RoffGAL;
+    out[i].DoffGAL    = in[i].DoffGAL;
+    out[i].Sky        = in[i].Sky;
+    out[i].dSky       = in[i].dSky;
+    out[i].t          = in[i].t;
+    out[i].averef     = in[i].averef;
+    out[i].detID      = in[i].detID;
+    out[i].objID      = in[i].objID;
+    out[i].catID      = in[i].catID;
+    out[i].extID      = in[i].extID;
+    out[i].imageID    = in[i].imageID;
+    out[i].psfQF      = in[i].psfQF;
+    out[i].psfQFperf  = in[i].psfQFperf;
+    out[i].psfChisq   = in[i].psfChisq;
+    out[i].psfNdof    = in[i].psfNdof;
+    out[i].psfNpix    = in[i].psfNpix;
+    out[i].crNsigma   = in[i].crNsigma;
+    out[i].extNsigma  = in[i].extNsigma;
+    out[i].FWx 	      = in[i].FWx;
+    out[i].FWy 	      = in[i].FWy;
+    out[i].theta      = in[i].theta;
+    out[i].Mxx 	      = in[i].Mxx;
+    out[i].Mxy 	      = in[i].Mxy;
+    out[i].Myy 	      = in[i].Myy;
+    out[i].t_msec     = in[i].t_msec;
+    out[i].photcode   = in[i].photcode;
+    out[i].dXccd      = in[i].dXccd;
+    out[i].dYccd      = in[i].dYccd;
+    out[i].dRsys      = in[i].dRsys;
+    out[i].posangle   = in[i].posangle;
+    out[i].pltscale   = in[i].pltscale;
+    out[i].dbFlags    = in[i].dbFlags;
+    out[i].photFlags  = in[i].photFlags;
+  }
+  return (out);
+}
+
+Measure_PS1_V5 *MeasureInternalTo_PS1_V5 (Average *ave, Measure *in, off_t Nvalues) {
+
+  off_t i;
+  Measure_PS1_V5 *out;
+
+  ALLOCATE_ZERO (out, Measure_PS1_V5, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    out[i].R          = in[i].R;
+    out[i].D          = in[i].D;
+    out[i].M          = in[i].M;
+    out[i].dM         = in[i].dM;
+    out[i].Map        = in[i].Map;
+    out[i].dMap       = in[i].dMap;
+    out[i].Mkron      = in[i].Mkron;
+    out[i].dMkron     = in[i].dMkron;
+    out[i].Mcal       = in[i].Mcal;
+    out[i].dMcal      = in[i].dMcal;
+    out[i].dt         = in[i].dt;
+    out[i].FluxPSF    = in[i].FluxPSF;
+    out[i].dFluxPSF   = in[i].dFluxPSF;
+    out[i].FluxKron   = in[i].FluxKron;
+    out[i].dFluxKron  = in[i].dFluxKron;
+    out[i].FluxAp     = in[i].FluxAp;
+    out[i].dFluxAp    = in[i].dFluxAp;
+    out[i].airmass    = in[i].airmass;
+    out[i].az         = in[i].az;
+    out[i].Xccd       = in[i].Xccd;
+    out[i].Yccd       = in[i].Yccd;
+    out[i].Xfix       = in[i].Xfix;
+    out[i].Yfix       = in[i].Yfix;
+    out[i].XoffKH     = in[i].XoffKH;
+    out[i].YoffKH     = in[i].YoffKH;
+    out[i].XoffDCR    = in[i].XoffDCR;
+    out[i].YoffDCR    = in[i].YoffDCR;
+    out[i].RoffGAL    = in[i].RoffGAL;
+    out[i].DoffGAL    = in[i].DoffGAL;
+    out[i].Sky        = in[i].Sky;
+    out[i].dSky       = in[i].dSky;
+    out[i].t          = in[i].t;
+    out[i].averef     = in[i].averef;
+    out[i].detID      = in[i].detID;
+    out[i].objID      = in[i].objID;
+    out[i].catID      = in[i].catID;
+    out[i].extID      = in[i].extID;
+    out[i].imageID    = in[i].imageID;
+    out[i].psfQF      = in[i].psfQF;
+    out[i].psfQFperf  = in[i].psfQFperf;
+    out[i].psfChisq   = in[i].psfChisq;
+    out[i].psfNdof    = in[i].psfNdof;
+    out[i].psfNpix    = in[i].psfNpix;
+    out[i].crNsigma   = in[i].crNsigma;
+    out[i].extNsigma  = in[i].extNsigma;
+    out[i].FWx 	      = in[i].FWx;
+    out[i].FWy 	      = in[i].FWy;
+    out[i].theta      = in[i].theta;
+    out[i].Mxx 	      = in[i].Mxx;
+    out[i].Mxy 	      = in[i].Mxy;
+    out[i].Myy 	      = in[i].Myy;
+    out[i].t_msec     = in[i].t_msec;
+    out[i].photcode   = in[i].photcode;
+    out[i].dXccd      = in[i].dXccd;
+    out[i].dYccd      = in[i].dYccd;
+    out[i].dRsys      = in[i].dRsys;
+    out[i].posangle   = in[i].posangle;
+    out[i].pltscale   = in[i].pltscale;
+    out[i].dbFlags    = in[i].dbFlags;
+    out[i].photFlags  = in[i].photFlags;
+  }
+  return (out);
+}
+
+// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
+Average *Average_PS1_V5_ToInternal (Average_PS1_V5 *in, off_t Nvalues, SecFilt **primary) {
+
+  off_t i;
+  Average *out;
+
+  ALLOCATE_ZERO (out, Average, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    dvo_average_init (&out[i]);
+
+    out[i].R        	 = in[i].R;      
+    out[i].D        	 = in[i].D;      
+    out[i].dR       	 = in[i].dR;
+    out[i].dD       	 = in[i].dD;
+    out[i].uR       	 = in[i].uR;
+    out[i].uD       	 = in[i].uD;
+    out[i].duR      	 = in[i].duR;
+    out[i].duD      	 = in[i].duD;
+    out[i].P        	 = in[i].P;
+    out[i].dP       	 = in[i].dP;
+
+    out[i].Rstk        	 = in[i].Rstk;      
+    out[i].Dstk        	 = in[i].Dstk;      
+    out[i].dRstk       	 = in[i].dRstk;
+    out[i].dDstk       	 = in[i].dDstk;
+
+    out[i].ChiSqAve    	 = in[i].ChiSqAve;     
+    out[i].ChiSqPM    	 = in[i].ChiSqPM;     
+    out[i].ChiSqPar    	 = in[i].ChiSqPar;     
+    out[i].Tmean    	 = in[i].Tmean;     
+    out[i].Trange   	 = in[i].Trange;     
+
+    out[i].psfQF         = in[i].psfQF;
+    out[i].psfQFperf     = in[i].psfQFperf;
+    out[i].stargal     	 = in[i].stargal;     
+    out[i].Npos       	 = in[i].Npos;     
+
+    out[i].Nmeasure      = in[i].Nmeasure;     
+    out[i].Nmissing      = in[i].Nmissing;     
+    out[i].Nlensing      = in[i].Nlensing;     
+    out[i].Nlensobj      = in[i].Nlensobj;     
+    out[i].Nextend       = in[i].Nextend;     
+
+    out[i].measureOffset = in[i].measureOffset; 
+    out[i].missingOffset = in[i].missingOffset;
+    out[i].lensingOffset = in[i].lensingOffset;
+    out[i].lensobjOffset = in[i].lensobjOffset;
+    out[i].extendOffset  = in[i].extendOffset;
+    out[i].paramsOffset  = in[i].paramsOffset;
+
+    out[i].refColorBlue  = in[i].refColorBlue;
+    out[i].refColorRed   = in[i].refColorRed;
+
+    out[i].flags     	 = in[i].flags;   
+    out[i].photFlagsUpper = in[i].photFlagsUpper;   
+    out[i].photFlagsLower = in[i].photFlagsLower;   
+    out[i].objID 	 = in[i].objID;
+    out[i].catID 	 = in[i].catID;
+    out[i].extID 	 = in[i].extID;
+    out[i].extIDgc 	 = in[i].extIDgc;
+  }
+  return (out);
+}
+
+// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
+Average_PS1_V5 *AverageInternalTo_PS1_V5 (Average *in, off_t Nvalues, SecFilt *primary) {
+
+  off_t i;
+  Average_PS1_V5 *out;
+
+  ALLOCATE_ZERO (out, Average_PS1_V5, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    out[i].R        	 = in[i].R;      
+    out[i].D        	 = in[i].D;      
+    out[i].dR       	 = in[i].dR;
+    out[i].dD       	 = in[i].dD;
+    out[i].uR       	 = in[i].uR;
+    out[i].uD       	 = in[i].uD;
+    out[i].duR      	 = in[i].duR;
+    out[i].duD      	 = in[i].duD;
+    out[i].P        	 = in[i].P;
+    out[i].dP       	 = in[i].dP;
+
+    out[i].Rstk        	 = in[i].Rstk;      
+    out[i].Dstk        	 = in[i].Dstk;      
+    out[i].dRstk       	 = in[i].dRstk;
+    out[i].dDstk       	 = in[i].dDstk;
+
+    out[i].ChiSqAve    	 = in[i].ChiSqAve;     
+    out[i].ChiSqPM     	 = in[i].ChiSqPM;     
+    out[i].ChiSqPar   	 = in[i].ChiSqPar;     
+    out[i].Tmean    	 = in[i].Tmean;     
+    out[i].Trange   	 = in[i].Trange;     
+
+    out[i].psfQF         = in[i].psfQF;
+    out[i].psfQFperf     = in[i].psfQFperf;
+    out[i].stargal     	 = in[i].stargal;     
+    out[i].Npos       	 = in[i].Npos;     
+
+    out[i].Nmeasure      = in[i].Nmeasure;     
+    out[i].Nmissing      = in[i].Nmissing;     
+    out[i].Nlensing      = in[i].Nlensing;     
+    out[i].Nlensobj      = in[i].Nlensobj;     
+    out[i].Nextend       = in[i].Nextend;     
+
+    out[i].measureOffset = in[i].measureOffset; 
+    out[i].missingOffset = in[i].missingOffset;
+    out[i].lensingOffset = in[i].lensingOffset;
+    out[i].lensobjOffset = in[i].lensobjOffset;
+    out[i].extendOffset  = in[i].extendOffset;
+    out[i].paramsOffset  = in[i].paramsOffset;
+
+    out[i].refColorBlue  = in[i].refColorBlue;
+    out[i].refColorRed   = in[i].refColorRed;
+
+    out[i].flags     	 = in[i].flags;   
+    out[i].photFlagsUpper = in[i].photFlagsUpper;   
+    out[i].photFlagsLower = in[i].photFlagsLower;   
+    out[i].objID 	 = in[i].objID;
+    out[i].catID 	 = in[i].catID;
+    out[i].extID 	 = in[i].extID;
+    out[i].extIDgc 	 = in[i].extIDgc;
+  }
+  return (out);
+}
+
+SecFilt *SecFilt_PS1_V5_ToInternal (SecFilt_PS1_V5 *in, off_t Nvalues) {
+
+  off_t i;
+  SecFilt *out;
+
+  ALLOCATE_ZERO (out, SecFilt, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    dvo_secfilt_init (&out[i]);
+
+    out[i].M             = in[i].M;      
+    out[i].dM            = in[i].dM;      
+    out[i].Map           = in[i].Map;      
+    out[i].dMap          = in[i].dMap;      
+    out[i].sMap          = in[i].sMap;      
+    out[i].Mkron         = in[i].Mkron;      
+    out[i].dMkron        = in[i].dMkron;      
+
+    out[i].Mstdev        = in[i].Mstdev;      
+    out[i].Mmin          = in[i].Mmin;      
+    out[i].Mmax          = in[i].Mmax;      
+    out[i].Mchisq        = in[i].Mchisq;     
+
+    out[i].Ncode         = in[i].Ncode;
+    out[i].Nused         = in[i].Nused;
+    out[i].NusedKron     = in[i].NusedKron;
+    out[i].NusedAp       = in[i].NusedAp;
+
+    out[i].flags         = in[i].flags;     
+
+    out[i].MpsfStk       = in[i].MpsfStk;
+    out[i].FpsfStk       = in[i].FpsfStk;
+    out[i].dFpsfStk      = in[i].dFpsfStk;
+
+    out[i].MkronStk      = in[i].MkronStk;
+    out[i].FkronStk      = in[i].FkronStk;
+    out[i].dFkronStk     = in[i].dFkronStk;
+
+    out[i].MapStk        = in[i].MapStk;
+    out[i].FapStk        = in[i].FapStk;
+    out[i].dFapStk       = in[i].dFapStk;
+
+    out[i].stackDetectID = in[i].stackDetectID;      
+
+    out[i].MpsfWrp       = in[i].MpsfWrp;
+    out[i].FpsfWrp       = in[i].FpsfWrp;
+    out[i].dFpsfWrp      = in[i].dFpsfWrp;
+    out[i].sFpsfWrp      = in[i].sFpsfWrp;
+
+    out[i].MkronWrp      = in[i].MkronWrp;
+    out[i].FkronWrp      = in[i].FkronWrp;
+    out[i].dFkronWrp     = in[i].dFkronWrp;
+    out[i].sFkronWrp     = in[i].sFkronWrp;
+
+    out[i].MapWrp        = in[i].MapWrp;
+    out[i].FapWrp        = in[i].FapWrp;
+    out[i].dFapWrp       = in[i].dFapWrp;
+    out[i].sFapWrp       = in[i].sFapWrp;
+
+    out[i].NusedWrp      = in[i].NusedWrp;
+    out[i].NusedKronWrp  = in[i].NusedKronWrp;
+    out[i].NusedApWrp    = in[i].NusedApWrp;
+
+    out[i].ubercalDist   = in[i].ubercalDist;      
+  }
+  return (out);
+}
+
+SecFilt_PS1_V5 *SecFiltInternalTo_PS1_V5 (SecFilt *in, off_t Nvalues) {
+
+  off_t i;
+  SecFilt_PS1_V5 *out;
+
+  ALLOCATE_ZERO (out, SecFilt_PS1_V5, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+
+    out[i].M             = in[i].M;      
+    out[i].dM            = in[i].dM;      
+    out[i].Map           = in[i].Map;      
+    out[i].dMap          = in[i].dMap;      
+    out[i].sMap          = in[i].sMap;      
+    out[i].Mkron         = in[i].Mkron;      
+    out[i].dMkron        = in[i].dMkron;      
+    out[i].sMkron        = in[i].sMkron;      
+
+    out[i].Mstdev        = in[i].Mstdev;      
+    out[i].Mmin          = in[i].Mmin;      
+    out[i].Mmax          = in[i].Mmax;      
+    out[i].Mchisq        = in[i].Mchisq;     
+
+    out[i].Ncode         = in[i].Ncode;
+    out[i].Nused         = in[i].Nused;
+    out[i].NusedKron     = in[i].NusedKron;
+    out[i].NusedAp       = in[i].NusedAp;
+
+    out[i].flags         = in[i].flags;     
+
+    out[i].MpsfStk       = in[i].MpsfStk;
+    out[i].FpsfStk       = in[i].FpsfStk;
+    out[i].dFpsfStk      = in[i].dFpsfStk;
+
+    out[i].MkronStk      = in[i].MkronStk;
+    out[i].FkronStk      = in[i].FkronStk;
+    out[i].dFkronStk     = in[i].dFkronStk;
+
+    out[i].MapStk        = in[i].MapStk;
+    out[i].FapStk        = in[i].FapStk;
+    out[i].dFapStk       = in[i].dFapStk;
+
+    out[i].stackDetectID = in[i].stackDetectID;      
+
+    out[i].MpsfWrp       = in[i].MpsfWrp;
+    out[i].FpsfWrp       = in[i].FpsfWrp;
+    out[i].dFpsfWrp      = in[i].dFpsfWrp;
+    out[i].sFpsfWrp      = in[i].sFpsfWrp;
+
+    out[i].MkronWrp      = in[i].MkronWrp;
+    out[i].FkronWrp      = in[i].FkronWrp;
+    out[i].dFkronWrp     = in[i].dFkronWrp;
+    out[i].sFkronWrp     = in[i].sFkronWrp;
+
+    out[i].MapWrp        = in[i].MapWrp;
+    out[i].FapWrp        = in[i].FapWrp;
+    out[i].dFapWrp       = in[i].dFapWrp;
+    out[i].sFapWrp       = in[i].sFapWrp;
+
+    out[i].NusedWrp      = in[i].NusedWrp;
+    out[i].NusedKronWrp  = in[i].NusedKronWrp;
+    out[i].NusedApWrp    = in[i].NusedApWrp;
+
+    out[i].ubercalDist   = in[i].ubercalDist;      
+  }
+  return (out);
+}
+
+Lensing *Lensing_PS1_V5_ToInternal (Lensing_PS1_V5 *in, off_t Nvalues) {
+
+  off_t i;
+  Lensing *out;
+
+  ALLOCATE_ZERO (out, Lensing, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    dvo_lensing_init (&out[i]);
+
+    out[i].X11_sm_obj  = in[i].X11_sm_obj;      
+    out[i].X12_sm_obj  = in[i].X12_sm_obj;      
+    out[i].X22_sm_obj  = in[i].X22_sm_obj;      
+    out[i].E1_sm_obj   = in[i].E1_sm_obj;      
+    out[i].E2_sm_obj   = in[i].E2_sm_obj;      
+	             	                 
+    out[i].X11_sh_obj  = in[i].X11_sh_obj;      
+    out[i].X12_sh_obj  = in[i].X12_sh_obj;      
+    out[i].X22_sh_obj  = in[i].X22_sh_obj;      
+    out[i].E1_sh_obj   = in[i].E1_sh_obj;      
+    out[i].E2_sh_obj   = in[i].E2_sh_obj;     
+	             	                 
+    out[i].X11_sm_psf  = in[i].X11_sm_psf;
+    out[i].X12_sm_psf  = in[i].X12_sm_psf;
+    out[i].X22_sm_psf  = in[i].X22_sm_psf;
+    out[i].E1_sm_psf   = in[i].E1_sm_psf;
+    out[i].E2_sm_psf   = in[i].E2_sm_psf;     
+	             	                 
+    out[i].X11_sh_psf  = in[i].X11_sh_psf;
+    out[i].X12_sh_psf  = in[i].X12_sh_psf;
+    out[i].X22_sh_psf  = in[i].X22_sh_psf;
+    out[i].E1_sh_psf   = in[i].E1_sh_psf;
+    out[i].E2_sh_psf   = in[i].E2_sh_psf;
+
+    out[i].F_ApR5      = in[i].F_ApR5;
+    out[i].dF_ApR5     = in[i].dF_ApR5;
+    out[i].sF_ApR5     = in[i].sF_ApR5;
+    out[i].fF_ApR5     = in[i].fF_ApR5;
+	               	            
+    out[i].F_ApR6      = in[i].F_ApR6;
+    out[i].dF_ApR6     = in[i].dF_ApR6;
+    out[i].sF_ApR6     = in[i].sF_ApR6;
+    out[i].fF_ApR6     = in[i].fF_ApR6;
+	          	            
+    out[i].detID       = in[i].detID;
+    out[i].objID       = in[i].objID;
+    out[i].catID       = in[i].catID;
+
+    out[i].averef      = in[i].averef;
+  }
+  return (out);
+}
+
+Lensing_PS1_V5 *LensingInternalTo_PS1_V5 (Lensing *in, off_t Nvalues) {
+
+  off_t i;
+  Lensing_PS1_V5 *out;
+
+  ALLOCATE_ZERO (out, Lensing_PS1_V5, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+
+    out[i].X11_sm_obj  = in[i].X11_sm_obj;      
+    out[i].X12_sm_obj  = in[i].X12_sm_obj;      
+    out[i].X22_sm_obj  = in[i].X22_sm_obj;      
+    out[i].E1_sm_obj   = in[i].E1_sm_obj;      
+    out[i].E2_sm_obj   = in[i].E2_sm_obj;      
+	             	                 
+    out[i].X11_sh_obj  = in[i].X11_sh_obj;      
+    out[i].X12_sh_obj  = in[i].X12_sh_obj;      
+    out[i].X22_sh_obj  = in[i].X22_sh_obj;      
+    out[i].E1_sh_obj   = in[i].E1_sh_obj;      
+    out[i].E2_sh_obj   = in[i].E2_sh_obj;     
+	             	                 
+    out[i].X11_sm_psf  = in[i].X11_sm_psf;
+    out[i].X12_sm_psf  = in[i].X12_sm_psf;
+    out[i].X22_sm_psf  = in[i].X22_sm_psf;
+    out[i].E1_sm_psf   = in[i].E1_sm_psf;
+    out[i].E2_sm_psf   = in[i].E2_sm_psf;     
+	             	                 
+    out[i].X11_sh_psf  = in[i].X11_sh_psf;
+    out[i].X12_sh_psf  = in[i].X12_sh_psf;
+    out[i].X22_sh_psf  = in[i].X22_sh_psf;
+    out[i].E1_sh_psf   = in[i].E1_sh_psf;
+    out[i].E2_sh_psf   = in[i].E2_sh_psf;
+
+    out[i].F_ApR5      = in[i].F_ApR5;
+    out[i].dF_ApR5     = in[i].dF_ApR5;
+    out[i].sF_ApR5     = in[i].sF_ApR5;
+    out[i].fF_ApR5     = in[i].fF_ApR5;
+	               	            
+    out[i].F_ApR6      = in[i].F_ApR6;
+    out[i].dF_ApR6     = in[i].dF_ApR6;
+    out[i].sF_ApR6     = in[i].sF_ApR6;
+    out[i].fF_ApR6     = in[i].fF_ApR6;
+	          	            
+    out[i].detID       = in[i].detID;
+    out[i].objID       = in[i].objID;
+    out[i].catID       = in[i].catID;
+
+    out[i].averef      = in[i].averef;
+  }
+  return (out);
+}
+
+Lensobj *Lensobj_PS1_V5_ToInternal (Lensobj_PS1_V5 *in, off_t Nvalues) {
+
+  off_t i;
+  Lensobj *out;
+
+  ALLOCATE_ZERO (out, Lensobj, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    dvo_lensobj_init (&out[i]);
+
+    out[i].X11_sm_obj  = in[i].X11_sm_obj;      
+    out[i].X12_sm_obj  = in[i].X12_sm_obj;      
+    out[i].X22_sm_obj  = in[i].X22_sm_obj;      
+    out[i].E1_sm_obj   = in[i].E1_sm_obj;      
+    out[i].E2_sm_obj   = in[i].E2_sm_obj;      
+	             	                 
+    out[i].X11_sh_obj  = in[i].X11_sh_obj;      
+    out[i].X12_sh_obj  = in[i].X12_sh_obj;      
+    out[i].X22_sh_obj  = in[i].X22_sh_obj;      
+    out[i].E1_sh_obj   = in[i].E1_sh_obj;      
+    out[i].E2_sh_obj   = in[i].E2_sh_obj;     
+	             	                 
+    out[i].X11_sm_psf  = in[i].X11_sm_psf;
+    out[i].X12_sm_psf  = in[i].X12_sm_psf;
+    out[i].X22_sm_psf  = in[i].X22_sm_psf;
+    out[i].E1_sm_psf   = in[i].E1_sm_psf;
+    out[i].E2_sm_psf   = in[i].E2_sm_psf;     
+	             	                 
+    out[i].X11_sh_psf  = in[i].X11_sh_psf;
+    out[i].X12_sh_psf  = in[i].X12_sh_psf;
+    out[i].X22_sh_psf  = in[i].X22_sh_psf;
+    out[i].E1_sh_psf   = in[i].E1_sh_psf;
+    out[i].E2_sh_psf   = in[i].E2_sh_psf;
+
+    out[i].F_ApR5      = in[i].F_ApR5;
+    out[i].dF_ApR5     = in[i].dF_ApR5;
+    out[i].sF_ApR5     = in[i].sF_ApR5;
+    out[i].fF_ApR5     = in[i].fF_ApR5;
+	               	            
+    out[i].F_ApR6      = in[i].F_ApR6;
+    out[i].dF_ApR6     = in[i].dF_ApR6;
+    out[i].sF_ApR6     = in[i].sF_ApR6;
+    out[i].fF_ApR6     = in[i].fF_ApR6;
+	          	            
+    out[i].gamma       = in[i].gamma;
+    out[i].E1          = in[i].E1;
+    out[i].E2          = in[i].E2;
+
+    out[i].objID       = in[i].objID;
+    out[i].catID       = in[i].catID;
+
+  }
+  return (out);
+}
+
+Lensobj_PS1_V5 *LensobjInternalTo_PS1_V5 (Lensobj *in, off_t Nvalues) {
+
+  off_t i;
+  Lensobj_PS1_V5 *out;
+
+  ALLOCATE_ZERO (out, Lensobj_PS1_V5, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+
+    out[i].X11_sm_obj  = in[i].X11_sm_obj;      
+    out[i].X12_sm_obj  = in[i].X12_sm_obj;      
+    out[i].X22_sm_obj  = in[i].X22_sm_obj;      
+    out[i].E1_sm_obj   = in[i].E1_sm_obj;      
+    out[i].E2_sm_obj   = in[i].E2_sm_obj;      
+	             	                 
+    out[i].X11_sh_obj  = in[i].X11_sh_obj;      
+    out[i].X12_sh_obj  = in[i].X12_sh_obj;      
+    out[i].X22_sh_obj  = in[i].X22_sh_obj;      
+    out[i].E1_sh_obj   = in[i].E1_sh_obj;      
+    out[i].E2_sh_obj   = in[i].E2_sh_obj;     
+	             	                 
+    out[i].X11_sm_psf  = in[i].X11_sm_psf;
+    out[i].X12_sm_psf  = in[i].X12_sm_psf;
+    out[i].X22_sm_psf  = in[i].X22_sm_psf;
+    out[i].E1_sm_psf   = in[i].E1_sm_psf;
+    out[i].E2_sm_psf   = in[i].E2_sm_psf;     
+	             	                 
+    out[i].X11_sh_psf  = in[i].X11_sh_psf;
+    out[i].X12_sh_psf  = in[i].X12_sh_psf;
+    out[i].X22_sh_psf  = in[i].X22_sh_psf;
+    out[i].E1_sh_psf   = in[i].E1_sh_psf;
+    out[i].E2_sh_psf   = in[i].E2_sh_psf;
+
+    out[i].F_ApR5      = in[i].F_ApR5;
+    out[i].dF_ApR5     = in[i].dF_ApR5;
+    out[i].sF_ApR5     = in[i].sF_ApR5;
+    out[i].fF_ApR5     = in[i].fF_ApR5;
+	               	            
+    out[i].F_ApR6      = in[i].F_ApR6;
+    out[i].dF_ApR6     = in[i].dF_ApR6;
+    out[i].sF_ApR6     = in[i].sF_ApR6;
+    out[i].fF_ApR6     = in[i].fF_ApR6;
+	          	            
+    out[i].gamma       = in[i].gamma;
+    out[i].E1          = in[i].E1;
+    out[i].E2          = in[i].E2;
+
+    out[i].objID       = in[i].objID;
+    out[i].catID       = in[i].catID;
+  }
+  return (out);
+}
+
+# define RAW_IMAGE_NAME_LEN 117
+
+Image *Image_PS1_V5_ToInternal (Image_PS1_V5 *in, off_t Nvalues, off_t Nalloc) {
+
+  off_t i;
+  Image *out;
+
+  char *buffer;
+  ALLOCATE_ZERO (buffer, char, Nalloc);
+  out = (Image *) buffer;
+  // ALLOCATE_ZERO (out, Image, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+
+    // RAW_IMAGE_NAME_LEN == DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
+
+    out[i].tzero    	    = in[i].tzero;
+    out[i].nstar    	    = in[i].nstar;
+    out[i].secz	    	    = in[i].secz;
+    out[i].NX	    	    = in[i].NX;
+    out[i].NY	    	    = in[i].NY;
+    out[i].apmifit  	    = in[i].apmifit;
+    out[i].dapmifit 	    = in[i].dapmifit;
+    out[i].Mcal	    	    = in[i].Mcal;
+    out[i].dMcal    	    = in[i].dMcal;
+    out[i].Xm	    	    = in[i].Xm;
+    out[i].photcode   	    = in[i].photcode;
+    out[i].exptime  	    = in[i].exptime;
+    out[i].sidtime  	    = in[i].sidtime;
+    out[i].latitude  	    = in[i].latitude;
+
+    out[i].RAo  	    = in[i].RAo;
+    out[i].DECo  	    = in[i].DECo;
+    out[i].Radius  	    = in[i].Radius;
+    out[i].refColorBlue	    = in[i].refColorBlue;
+    out[i].refColorRed 	    = in[i].refColorRed;
+
+    out[i].detection_limit  = in[i].detection_limit;
+    out[i].saturation_limit = in[i].saturation_limit;
+    out[i].cerror	    = in[i].cerror;
+    out[i].fwhm_x	    = in[i].fwhm_x;
+    out[i].fwhm_y	    = in[i].fwhm_y;
+    out[i].trate	    = in[i].trate;
+    out[i].ccdnum	    = in[i].ccdnum;
+    out[i].flags	    = in[i].flags;
+    out[i].imageID	    = in[i].imageID;
+    out[i].parentID	    = in[i].parentID;
+    out[i].externID	    = in[i].externID;
+    out[i].sourceID	    = in[i].sourceID;
+
+    // as of 2011.02.03, the old Mx,My,..., Mxxxx,Myyyy have been deprecated and replaced
+    // with the following.  (no real databases used those values -- see
+    // libdvo/doc/dvo-images.txt)
+    out[i].nLinkAstrom	    = in[i].nLinkAstrom;
+    out[i].nLinkPhotom	    = in[i].nLinkPhotom;
+    out[i].ubercalDist	    = in[i].ubercalDist;
+    out[i].dXpixSys	    = in[i].dXpixSys;
+    out[i].dYpixSys	    = in[i].dYpixSys;
+    out[i].dMagSys	    = in[i].dMagSys;
+    out[i].nFitAstrom       = in[i].nFitAstrom;
+    out[i].nFitPhotom       = in[i].nFitPhotom;
+    out[i].photom_map_id    = in[i].photom_map_id;
+    out[i].astrom_map_id    = in[i].astrom_map_id;
+  }
+  return (out);
+}
+
+Image_PS1_V5 *ImageInternalTo_PS1_V5 (Image *in, off_t Nvalues) {
+
+  off_t i;
+  Image_PS1_V5 *out;
+
+  ALLOCATE_ZERO (out, Image_PS1_V5, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+
+    // RAW_IMAGE_NAME_LEN == DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
+
+    out[i].tzero    	    = in[i].tzero;
+    out[i].nstar    	    = in[i].nstar;
+    out[i].secz	    	    = in[i].secz;
+    out[i].NX	    	    = in[i].NX;
+    out[i].NY	    	    = in[i].NY;
+    out[i].apmifit  	    = in[i].apmifit;
+    out[i].dapmifit 	    = in[i].dapmifit;
+    out[i].Mcal	    	    = in[i].Mcal;
+    out[i].dMcal    	    = in[i].dMcal;
+    out[i].Xm	    	    = in[i].Xm;
+    out[i].photcode   	    = in[i].photcode;
+    out[i].exptime  	    = in[i].exptime;
+    out[i].sidtime  	    = in[i].sidtime;
+    out[i].latitude  	    = in[i].latitude;
+
+    out[i].RAo  	    = in[i].RAo;
+    out[i].DECo  	    = in[i].DECo;
+    out[i].Radius  	    = in[i].Radius;
+    out[i].refColorBlue	    = in[i].refColorBlue;
+    out[i].refColorRed 	    = in[i].refColorRed;
+
+    out[i].detection_limit  = in[i].detection_limit;
+    out[i].saturation_limit = in[i].saturation_limit;
+    out[i].cerror	    = in[i].cerror;
+    out[i].fwhm_x	    = in[i].fwhm_x;
+    out[i].fwhm_y	    = in[i].fwhm_y;
+    out[i].trate	    = in[i].trate;
+    out[i].ccdnum	    = in[i].ccdnum;
+    out[i].flags	    = in[i].flags;
+    out[i].imageID	    = in[i].imageID;
+    out[i].parentID	    = in[i].parentID;
+    out[i].externID	    = in[i].externID;
+    out[i].sourceID	    = in[i].sourceID;
+
+    // as of 2011.02.03, the old Mx,My,..., Mxxxx,Myyyy have been deprecated and replaced
+    // with the following.  (no real databases used those values -- see
+    // libdvo/doc/dvo-images.txt)
+    out[i].nLinkAstrom	    = in[i].nLinkAstrom;
+    out[i].nLinkPhotom	    = in[i].nLinkPhotom;
+    out[i].ubercalDist	    = in[i].ubercalDist;
+    out[i].dXpixSys	    = in[i].dXpixSys;
+    out[i].dYpixSys	    = in[i].dYpixSys;
+    out[i].dMagSys	    = in[i].dMagSys;
+    out[i].nFitAstrom       = in[i].nFitAstrom;
+    out[i].nFitPhotom       = in[i].nFitPhotom;
+    out[i].photom_map_id    = in[i].photom_map_id;
+    out[i].astrom_map_id    = in[i].astrom_map_id;
+  }
+  return (out);
+}
+
+PhotCode *PhotCode_PS1_V5_To_Internal (PhotCode_PS1_V5 *in, off_t Nvalues) {
+
+  off_t i;
+  PhotCode *out;
+
+  ALLOCATE_ZERO (out, PhotCode, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    strncpy (out[i].name, in[i].name, 31); // out[32], in[32]
+    out[i].name[31] = 0; // force termination
+
+    out[i].code  = in[i].code;         
+    out[i].type  = in[i].type;         
+    out[i].C     = in[i].C;            
+    out[i].dC 	 = in[i].dC;           
+    out[i].dX 	 = in[i].dX;           
+    out[i].K  	 = in[i].K;            
+    out[i].c1 	 = in[i].c1;           
+    out[i].c2 	 = in[i].c2;           
+    out[i].equiv = in[i].equiv;        
+    out[i].Nc    = in[i].Nc;           
+    memcpy (out[i].X, in[i].X, 4*sizeof(float));            
+
+    out[i].astromErrSys      = in[i].astromErrSys;
+    out[i].astromErrScale    = in[i].astromErrScale;
+    out[i].astromErrMagScale = in[i].astromErrMagScale;
+    out[i].photomErrSys      = in[i].photomErrSys;
+
+    out[i].photomPoorMask      = in[i].photomPoorMask;
+    out[i].photomBadMask       = in[i].photomBadMask;
+    out[i].astromPoorMask      = in[i].astromPoorMask;
+    out[i].astromBadMask       = in[i].astromBadMask;
+  }
+  return (out);
+}
+
+PhotCode_PS1_V5 *PhotCode_Internal_To_PS1_V5 (PhotCode *in, off_t Nvalues) {
+
+  off_t i;
+  PhotCode_PS1_V5 *out;
+
+  ALLOCATE_ZERO (out, PhotCode_PS1_V5, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    strncpy (out[i].name, in[i].name, 31); // out[32], in[32]
+    out[i].name[31] = 0; // force termination
+
+    out[i].code  = in[i].code;         
+    out[i].type  = in[i].type;         
+    out[i].C     = in[i].C;            
+    out[i].dC 	 = in[i].dC;           
+    out[i].dX 	 = in[i].dX;           
+    out[i].K  	 = in[i].K;            
+    out[i].c1 	 = in[i].c1;           
+    out[i].c2 	 = in[i].c2;           
+    out[i].equiv = in[i].equiv;        
+    out[i].Nc    = in[i].Nc;           
+    memcpy (out[i].X, in[i].X, 4*sizeof(float));            
+
+    out[i].astromErrSys      = in[i].astromErrSys;
+    out[i].astromErrScale    = in[i].astromErrScale;
+    out[i].astromErrMagScale = in[i].astromErrMagScale;
+    out[i].photomErrSys      = in[i].photomErrSys;
+
+    out[i].photomPoorMask      = in[i].photomPoorMask;
+    out[i].photomBadMask       = in[i].photomBadMask;
+    out[i].astromPoorMask      = in[i].astromPoorMask;
+    out[i].astromBadMask       = in[i].astromBadMask;
+  }
+  return (out);
+}
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_elixir.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_elixir.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_elixir.c	(revision 37035)
@@ -2,5 +2,5 @@
 
 /* convert elixir-format measures to internal measures */
-Measure *Measure_Elixir_ToInternal (Measure_Elixir *in, off_t Nvalues) {
+Measure *Measure_Elixir_ToInternal (Average *ave, Measure_Elixir *in, off_t Nvalues) {
 
   off_t i;
@@ -15,7 +15,10 @@
     out[i].averef   = in[i].averef;
 
+    // changed for PS1_V5
+    int averef = out[i].averef;
+    out[i].R          = (in[i].dR == NAN_S_SHORT) ? NAN : ave[averef].R - 0.01 * in[i].dR / 3600.0;
+    out[i].D          = (in[i].dD == NAN_S_SHORT) ? NAN : ave[averef].D - 0.01 * in[i].dD / 3600.0;
+
     // changed for PANSTARRS_DEV_0
-    out[i].dR       = (in[i].dR      == NAN_S_SHORT) ? NAN : in[i].dR     * 0.01;
-    out[i].dD       = (in[i].dD      == NAN_S_SHORT) ? NAN : in[i].dD     * 0.01;
     out[i].M        = (in[i].M       == NAN_S_SHORT) ? NAN : in[i].M      * 0.001;
     out[i].dM       = (in[i].dM      == NAN_U_CHAR)  ? NAN : in[i].dM     * 0.001;
@@ -47,5 +50,5 @@
 
 /* convert internal measures to elixir-format measures */
-Measure_Elixir *MeasureInternalTo_Elixir (Measure *in, off_t Nvalues) {
+Measure_Elixir *MeasureInternalTo_Elixir (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -59,7 +62,11 @@
     out[i].averef  = in[i].averef;
 
+    // changed for PS1_V5
+    int averef = in[i].averef;
+    int isBad = isnan(in[i].R) || isnan(in[i].D);
+    out[i].dR     = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].R - in[i].R);
+    out[i].dD     = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].D - in[i].D);
+
     // changed for PANSTARRS_DEV_0
-    out[i].dR       = isnan(in[i].dR     ) ? NAN_S_SHORT : in[i].dR      *  100.0;
-    out[i].dD       = isnan(in[i].dD     ) ? NAN_S_SHORT : in[i].dD      *  100.0;
     out[i].M        = isnan(in[i].M      ) ? NAN_S_SHORT : in[i].M       * 1000.0;
     out[i].dM       = isnan(in[i].dM     ) ? NAN_U_CHAR  : in[i].dM      * 1000.0;
@@ -104,5 +111,5 @@
     primary[0][i].M     = (in[i].M  == NAN_S_SHORT) ? NAN : in[i].M  * 0.001;      
     primary[0][i].dM    = (in[i].dM == NAN_S_SHORT) ? NAN : in[i].dM * 0.001;      
-    primary[0][i].Xm    = in[i].Xm;     
+    primary[0][i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
 
     // added for PANSTARRS_DEV_0
@@ -137,5 +144,5 @@
     out[i].M       = isnan(primary[i].M)  ? NAN_S_SHORT : primary[i].M   * 1000.0;
     out[i].dM      = isnan(primary[i].dM) ? NAN_S_SHORT : primary[i].dM  * 1000.0;
-    out[i].Xm      = primary[i].Xm;     
+    out[i].Xm      = 100.0*log10(primary[i].Mchisq);     
 
     // changed or added for PS1_DEV_2
@@ -162,5 +169,5 @@
     dvo_secfilt_init (&out[i]);
 
-    out[i].Xm    = in[i].Xm;     
+    out[i].Mchisq = pow (10.0, 0.01*in[i].Xm);     
 
     // added or changed for PANSTARRS_DEV_0
@@ -180,5 +187,5 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].Xm    = in[i].Xm;     
+    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
 
     // added or changed for PANSTARRS_DEV_0
@@ -188,4 +195,6 @@
   return (out);
 }
+
+# define RAW_IMAGE_NAME_LEN 32
 
 /* convert elixir-format images to internal images */
@@ -203,6 +212,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 31); // in[32], out[128]
-    out[i].name[31] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -272,6 +282,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 31); // out[32], in[128]
-    out[i].name[31] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_loneos.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_loneos.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_loneos.c	(revision 37035)
@@ -2,5 +2,5 @@
 
 /* convert loneos-format measures to internal measures */
-Measure *Measure_Loneos_ToInternal (Measure_Loneos *in, off_t Nvalues) {
+Measure *Measure_Loneos_ToInternal (Average *ave, Measure_Loneos *in, off_t Nvalues) {
 
   off_t i;
@@ -18,7 +18,10 @@
     out[i].t         = in[i].t;
 
+    // changed for PS1_V5
+    int averef = out[i].averef;
+    out[i].R          = (in[i].dR == NAN_S_SHORT) ? NAN : ave[averef].R - 0.01 * in[i].dR / 3600.0;
+    out[i].D          = (in[i].dD == NAN_S_SHORT) ? NAN : ave[averef].D - 0.01 * in[i].dD / 3600.0;
+
     // changed for PANSTARRS_DEV_0
-    out[i].dR       = (in[i].dR      == NAN_S_SHORT) ? NAN : in[i].dR     * 0.01;
-    out[i].dD       = (in[i].dD      == NAN_S_SHORT) ? NAN : in[i].dD     * 0.01;
     out[i].M        = (in[i].M       == NAN_S_SHORT) ? NAN : in[i].M      * 0.001;
     out[i].dM       = (in[i].dM      == NAN_U_CHAR)  ? NAN : in[i].dM     * 0.001;
@@ -40,5 +43,5 @@
 
 /* convert internal measures to loneos-format measures */
-Measure_Loneos *MeasureInternalTo_Loneos (Measure *in, off_t Nvalues) {
+Measure_Loneos *MeasureInternalTo_Loneos (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -48,8 +51,10 @@
 
   for (i = 0; i < Nvalues; i++) {
-
-    // changed for PANSTARRS_DEV_0
-    out[i].dR     = isnan(in[i].dR     ) ? NAN_S_SHORT : in[i].dR      *  100.0;
-    out[i].dD     = isnan(in[i].dD     ) ? NAN_S_SHORT : in[i].dD      *  100.0;
+    // changed for PS1_V5
+    int averef = in[i].averef;
+    int isBad = isnan(in[i].R) || isnan(in[i].D);
+    out[i].dR     = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].R - in[i].R);
+    out[i].dD     = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].D - in[i].D);
+
     out[i].M      = isnan(in[i].M      ) ? NAN_S_SHORT : in[i].M       * 1000.0;
     out[i].dM     = isnan(in[i].dM     ) ? NAN_U_CHAR  : in[i].dM      * 1000.0;
@@ -85,5 +90,5 @@
     // changed for PANSTARRS_DEV_0 (moved from Average to Measure)
     primary[0][i].M     = (in[i].M  == NAN_S_SHORT) ? NAN : in[i].M  * 0.001;      
-    primary[0][i].Xm    = in[i].Xm;     
+    primary[0][i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
 
     // added for PANSTARRS_DEV_0
@@ -119,5 +124,5 @@
     // changed for PANSTARRS_DEV_0 (moved from Average to Measure)
     out[i].M       = isnan(primary[i].M)  ? NAN_S_SHORT : primary[i].M   * 1000.0;
-    out[i].Xm      = primary[i].Xm;     
+    out[i].Xm      = 100.0*log10(primary[i].Mchisq);     
 
     // changed or added for PS1_DEV_2
@@ -144,5 +149,5 @@
     dvo_secfilt_init (&out[i]);
 
-    out[i].Xm    = in[i].Xm;      
+    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
 
     // added or changed for PANSTARRS_DEV_0
@@ -161,5 +166,5 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].Xm   = in[i].Xm;      
+    out[i].Xm   = 100.0*log10(in[i].Mchisq);      
 
     // added or changed for PANSTARRS_DEV_0
@@ -168,4 +173,6 @@
   return (out);
 }
+
+# define RAW_IMAGE_NAME_LEN 32
 
 /* convert loneos-format images to internal images */
@@ -183,6 +190,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 31); // in[32], out[128]
-    out[i].name[31] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -253,6 +261,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 31); // out[32], in[128]
-    out[i].name[31] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c	(revision 37035)
@@ -2,5 +2,5 @@
 
 /* convert panstarrs-format measures to internal measures */
-Measure *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, off_t Nvalues) {
+Measure *Measure_Panstarrs_DEV_0_ToInternal (Average *ave, Measure_Panstarrs_DEV_0 *in, off_t Nvalues) {
 
   off_t i;
@@ -11,6 +11,8 @@
   for (i = 0; i < Nvalues; i++) {
     dvo_measure_init (&out[i]);
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].dM         = in[i].dM;
@@ -52,5 +54,5 @@
 
 /* convert internal measures to panstarrs-format measures */
-Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, off_t Nvalues) {
+Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -60,6 +62,8 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+
+    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
+    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
     out[i].M          = in[i].M;
     out[i].dM         = in[i].dM;
@@ -184,5 +188,5 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
@@ -202,5 +206,5 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
@@ -208,4 +212,6 @@
   return (out);
 }
+
+# define RAW_IMAGE_NAME_LEN 32
 
 /* convert panstarrs-format images to internal images */
@@ -223,6 +229,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 31); // out[128], in[32]
-    out[i].name[31] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -292,6 +299,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 31); // out[32], in[128]
-    out[i].name[31] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
Index: /trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c	(revision 37035)
@@ -2,5 +2,5 @@
 
 /* convert panstarrs-format measures to internal measures */
-Measure *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, off_t Nvalues) {
+Measure *Measure_Panstarrs_DEV_1_ToInternal (Average *ave, Measure_Panstarrs_DEV_1 *in, off_t Nvalues) {
 
   off_t i;
@@ -11,6 +11,8 @@
   for (i = 0; i < Nvalues; i++) {
     dvo_measure_init (&out[i]);
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+
+    int averef = in[i].averef;
+    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
+    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
     out[i].M          = in[i].M;
     out[i].dM         = in[i].dM;
@@ -52,5 +54,5 @@
 
 /* convert internal measures to panstarrs-format measures */
-Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, off_t Nvalues) {
+Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Average *ave, Measure *in, off_t Nvalues) {
 
   off_t i;
@@ -60,6 +62,8 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].dR         = in[i].dR;
-    out[i].dD         = in[i].dD;
+    int averef = in[i].averef;
+
+    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
+    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
     out[i].M          = in[i].M;
     out[i].dM         = in[i].dM;
@@ -184,5 +188,5 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
@@ -202,5 +206,5 @@
     out[i].M     = in[i].M;      
     out[i].dM    = in[i].dM;      
-    out[i].Xm    = in[i].Xm;     
+    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
     out[i].Ncode = in[i].Ncode;
     out[i].Nused = in[i].Nused;
@@ -208,4 +212,6 @@
   return (out);
 }
+
+# define RAW_IMAGE_NAME_LEN 64
 
 /* convert panstarrs-format images to internal images */
@@ -223,6 +229,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 63); // in[64], out[128]
-    out[i].name[63] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
@@ -292,6 +299,7 @@
     memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
 
-    strncpy (out[i].name, in[i].name, 63); // in[128], out[64]
-    out[i].name[63] = 0; // force termination
+    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
+    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
+    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
 
     out[i].tzero    	    = in[i].tzero;
Index: /trunk/Ohana/src/libdvo/src/dvo_image.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_image.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_image.c	(revision 37035)
@@ -219,4 +219,5 @@
   if (db[0].format == DVO_FORMAT_PS1_V3)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V3");
   if (db[0].format == DVO_FORMAT_PS1_V4)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V4");
+  if (db[0].format == DVO_FORMAT_PS1_V5)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V5");
   if (db[0].format == DVO_FORMAT_PS1_REF)         gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_REF");
   
Index: /trunk/Ohana/src/libdvo/src/dvo_image_raw.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_image_raw.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_image_raw.c	(revision 37035)
@@ -59,4 +59,5 @@
   if (db[0].format == DVO_FORMAT_PS1_V3)          ImageSize = sizeof(Image_PS1_V3);
   if (db[0].format == DVO_FORMAT_PS1_V4)          ImageSize = sizeof(Image_PS1_V4);
+  if (db[0].format == DVO_FORMAT_PS1_V5)          ImageSize = sizeof(Image_PS1_V5);
   if (db[0].format == DVO_FORMAT_PS1_REF)         ImageSize = sizeof(Image_PS1_REF);
 
@@ -89,4 +90,5 @@
   if (db[0].format == DVO_FORMAT_PS1_V3)          gfits_table_mkheader_Image_PS1_V3 (&db[0].theader);
   if (db[0].format == DVO_FORMAT_PS1_V4)          gfits_table_mkheader_Image_PS1_V4 (&db[0].theader);
+  if (db[0].format == DVO_FORMAT_PS1_V5)          gfits_table_mkheader_Image_PS1_V5 (&db[0].theader);
   if (db[0].format == DVO_FORMAT_PS1_REF)         gfits_table_mkheader_Image_PS1_REF (&db[0].theader);
     
Index: /trunk/Ohana/src/libdvo/src/dvo_photcode_ops.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_photcode_ops.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_photcode_ops.c	(revision 37035)
@@ -18,4 +18,6 @@
 
 static PhotCodeData *photcodes = NULL;
+static PhotCode *genericCodeMag = NULL;
+static PhotCode *genericCodeFlux = NULL;
 
 PhotCodeData *GetPhotcodeTable () {
@@ -26,4 +28,16 @@
     photcodes[0].code = NULL;
   }
+  if (genericCodeMag == NULL) {
+    ALLOCATE (genericCodeMag, PhotCode, 1);
+    genericCodeMag->code = 0;
+    strcpy (genericCodeMag->name, "MAG");
+    genericCodeMag->type = PHOT_MAG;
+  }
+  if (genericCodeFlux == NULL) {
+    ALLOCATE (genericCodeFlux, PhotCode, 1);
+    genericCodeFlux->code = 0;
+    strcpy (genericCodeFlux->name, "MAG");
+    genericCodeFlux->type = PHOT_MAG;
+  }
   return photcodes;
 }
@@ -57,4 +71,14 @@
   if (name == NULL) return (NULL);
   
+  // "MAG" is a special word, not allowed for a photcode name
+  if (!strcasecmp (name, "MAG")) {
+    return genericCodeMag;
+  }
+
+  // "FLUX" is a special word, not allowed for a photcode name
+  if (!strcasecmp (name, "FLUX")) {
+    return genericCodeFlux;
+  }
+
   for (i = 0; i < photcodes[0].Ncode; i++) {
     if (!strcmp (photcodes[0].code[i].name, name)) {
@@ -70,4 +94,13 @@
   
   if (name == NULL) return (0);
+
+  // "MAG" is a special photcode name for internal use
+  if (!strcasecmp (name, "MAG")) {
+    return genericCodeMag->code;
+  }
+  // "FLUX" is a special photcode name for internal use
+  if (!strcasecmp (name, "FLUX")) {
+    return genericCodeFlux->code;
+  }
 
   for (i = 0; i < photcodes[0].Ncode; i++) {
@@ -222,546 +255,362 @@
 
 /******** 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 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];
+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) {
-    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) {
-
-  int i, Np;
-  float Mcat, Mcol, Mrel, mc, Mc;
-  PhotCode *code;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
+float PhotRel (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];
+
+  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 */
-  mc = PhotColorForCode (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 (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 */
   }
-  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);
-}
-
-/***/
-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);
-}
-
-/* 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 PhotAveErr (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);
-}
-
-/************************************** APERTURE-related Magnitudes ***********************************************/
-
-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 PhotAperCat (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].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 PhotAperSys (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) {
-    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;
-  
-  /* for DEP, color must be made of PRI/SEC */
-  mc = PhotColorForCode (average, secfilt, NULL, code);
-  if (isnan(mc)) return (Mcat);
-  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;
-  }
-  Msys = Mcat + Mcol;
-  return (Msys);
-}
-
-float PhotAperRel (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].Map;
-    return (Mcat);
-  }
-  code = &photcodes[0].code[Np];
-  Mrel = measure[0].Map - 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 PhotAperCal (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].Map;
-    return (Mrel);
-  }
-  if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
-
-  Mcal = PhotAperRel (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);
-}
-
-float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt) {
-
-  int Ns;
-  float Maper;
-
-  if (code == NULL) return NAN;
-
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Maper = (Ns == -1) ? NAN : secfilt[Ns].Map;
-  return (Maper);
-}
-
-/* return calibrated magnitude from average/secfilt for given photcode */
-float PhotAperRef (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].Map;
-  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);
-}
-
-/************************************** KRON-related Magnitudes ***********************************************/
-
-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 PhotKronCat (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 PhotKronSys (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].Mkron;
-    return (Msys);
-  }
-  code = &photcodes[0].code[Np];
-  Mcat = measure[0].Mkron - 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);
-  if (isnan(mc)) return (Mcat);
-  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;
-  }
-  Msys = Mcat + Mcol;
-  return (Msys);
-}
-
-float PhotKronRel (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].Mkron;
-    return (Mcat);
-  }
-  code = &photcodes[0].code[Np];
-  Mrel = measure[0].Mkron - 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 PhotKronCal (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].Mkron;
-    return (Mrel);
-  }
-  if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
-
-  Mcal = PhotKronRel (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);
-}
-
-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);
-}
-
-/* return calibrated magnitude from average/secfilt for given photcode */
-float PhotKronRef (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].Mkron;
-  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 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 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);
 }
 
@@ -788,4 +637,5 @@
 
 /* color term may not use DEP magnitude */
+// currently only returns the PSF color
 float PhotColorForCode (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
 
@@ -857,5 +707,5 @@
 
   Ns = photcodes[0].hashNsec[code[0].code];
-  Fpsf = (Ns == -1) ? NAN : secfilt[Ns].FluxPSF;
+  Fpsf = (Ns == -1) ? NAN : secfilt[Ns].FpsfStk;
   return (Fpsf);
 }
@@ -869,5 +719,5 @@
 
   Ns = photcodes[0].hashNsec[code[0].code];
-  dFpsf = (Ns == -1) ? NAN : secfilt[Ns].dFluxPSF;
+  dFpsf = (Ns == -1) ? NAN : secfilt[Ns].dFpsfStk;
   return (dFpsf);
 }
@@ -881,5 +731,5 @@
 
   Ns = photcodes[0].hashNsec[code[0].code];
-  Fkron = (Ns == -1) ? NAN : secfilt[Ns].FluxKron;
+  Fkron = (Ns == -1) ? NAN : secfilt[Ns].FkronStk;
   return (Fkron);
 }
@@ -893,30 +743,30 @@
 
   Ns = photcodes[0].hashNsec[code[0].code];
-  dFkron = (Ns == -1) ? NAN : secfilt[Ns].dFluxKron;
+  dFkron = (Ns == -1) ? NAN : secfilt[Ns].dFkronStk;
   return (dFkron);
 }
 
-float PhotM20 (PhotCode *code, Average *average, SecFilt *secfilt) {
+float PhotMmin (PhotCode *code, Average *average, SecFilt *secfilt) {
 
   int Ns;
-  float M20;
+  float Mmin;
 
   if (code == NULL) return NAN;
 
   Ns = photcodes[0].hashNsec[code[0].code];
-  M20  = (Ns == -1) ? NAN : 0.001*secfilt[Ns].M_20;
-  return (M20);
-}
-
-float PhotM80 (PhotCode *code, Average *average, SecFilt *secfilt) {
+  Mmin  = (Ns == -1) ? NAN : secfilt[Ns].Mmin;
+  return (Mmin);
+}
+
+float PhotMmax (PhotCode *code, Average *average, SecFilt *secfilt) {
 
   int Ns;
-  float M80;
+  float Mmax;
 
   if (code == NULL) return NAN;
 
   Ns = photcodes[0].hashNsec[code[0].code];
-  M80  = (Ns == -1) ? NAN : 0.001*secfilt[Ns].M_80;
-  return (M80);
+  Mmax  = (Ns == -1) ? NAN : secfilt[Ns].Mmax;
+  return (Mmax);
 }
 
@@ -945,9 +795,8 @@
 }
 
-// XXX return NAN or NAN_S_SHORT? (secfilt->Xm is short)
+// Xm is now (2014.07.03) stored as the chisq except in dvo formats which use as short
 float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt) {
 
   int Ns;
-  short Mi;
   float Xm;
 
@@ -955,6 +804,5 @@
 
   Ns = photcodes[0].hashNsec[code[0].code];
-  Mi = (Ns == -1) ? NAN : secfilt[Ns].Xm;
-  Xm = (isnan(Mi)) ? -1.0 : pow (10.0, 0.01*Mi);
+  Xm = (Ns == -1) ? NAN : secfilt[Ns].Mchisq;
   return (Xm);
 }
@@ -1006,158 +854,649 @@
 }
 
-/******** alternate photometry conversion functions using MeasureTiny and AverageTiny *********/
-float PhotInstTiny (MeasureTiny *measure) {
-
-  int Np;
-  float M;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
+float MagToFlux (float Mag) {
+  float Flux = pow(10.0, -0.4*(Mag));
+  return (Flux);
+}
+
+/** flux conversion *******************************************************************/
+float PhotFluxInst (Measure *measure, dvoMagClassType class) {
+
+  float Moff = - measure[0].dt - ZERO_POINT;
+  float Finst = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      Finst = isnan (measure[0].FluxPSF)  ? MagToFlux(measure[0].M + Moff)     : measure[0].FluxPSF;
+      break;
+    case MAG_CLASS_KRON:
+      Finst = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron;
+      break;
+    case MAG_CLASS_APER:
+      Finst = isnan (measure[0].FluxAp)   ? MagToFlux(measure[0].Map + Moff)   : measure[0].FluxAp;
+      break;
+    default:
+      break;
+  }
+  return (Finst);
+}
+
+// returns Jy fluxes assuming mag in AB? (needs an extra AP factor, right?)
+float PhotFluxCat (Measure *measure, dvoMagClassType class) {
+
+  int Np = photcodes[0].hashcode[measure[0].photcode];
   if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    M = measure[0].M;
-    return (M);
-  }
-
-  M = measure[0].M - measure[0].dt - ZERO_POINT;
-	  
-  return (M);
-
-}
-
-float PhotCatTiny (MeasureTiny *measure) {
-
-  int Np;
-  float Mcat;
-  PhotCode *code;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
+  PhotCode *code = &photcodes[0].code[Np];
+
+  // mag_AB = -2.5 log (flux_cgs) - 48.6 (by definition) [~Vega flux in V-band]
+  // flux_Jy = flux_cgs * 10^23
+  // -2.5 log (flux_cgs) = -2.5 log (flux_Jy * 10^-23) = -2.5 log (flux_Jy) + 2.5*23
+
+  // from these we get:
+  // mag_AB = -2.5 log (flux_Jy) + 8.9
+  // log (flux_Jy) = -0.4*mag_AB + 3.56
+
+  // mag_AB = mag_inst + ZP
+
+  // log(flux_Jy) = -0.4*mag_inst -0.4*ZP + 3.56
+  // mag_inst = -2.5 log (flux_Jy) - ZP + 8.9
+
+  // log (flux_Jy) = -0.4*(mag_inst + ZP - 8.9)
+
+  // -2.5 log (flux_inst) = -2.5 log (flux_Jy) - ZP + 8.9
+  // log (flux_inst) = log (flux_Jy) + 0.4 ZP - 3.56
+  // flux_inst = flux_Jy * 10^(0.4*ZP - 3.56)
+  // flux_Jy = flux_inst * 10^(3.56 - 0.4*ZP) = flux_inst * zpFactor
+  // flux_Jy = flux_inst * 3630.8 * 10^(-0.4*ZP)
+
+  // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux
+  float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  float Moff = Mcal - ZERO_POINT + 8.9;
+  float Foff = 3630.8 * MagToFlux(Mcal);
+  float Fcat = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      Fcat = isnan (measure[0].FluxPSF)  ? MagToFlux(measure[0].M + Moff)     : measure[0].FluxPSF * Foff;
+      break;
+    case MAG_CLASS_KRON:
+      Fcat = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron * Foff;
+      break;
+    case MAG_CLASS_APER:
+      Fcat = isnan (measure[0].FluxAp)   ? MagToFlux(measure[0].Map + Moff)   : measure[0].FluxAp * Foff;
+      break;
+    default:
+      break;
+  }
+  return (Fcat);
+}
+
+// corrected for color trends
+float PhotFluxSys (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) {
+
+  int Np = photcodes[0].hashcode[measure[0].photcode];
   if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Mcat = measure[0].M;
-    return (Mcat);
-  }
-  code = &photcodes[0].code[Np];
-  Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
-  
-  return (Mcat);
-}
-
-# if (0)
-float PhotAperTiny (MeasureTiny *measure) {
-
-  int Np;
-  float Mcat;
-  PhotCode *code;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Mcat = measure[0].Map;
-    return (Mcat);
-  }
-  code = &photcodes[0].code[Np];
-  Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
-  
-  return (Mcat);
-}
-# endif
-
-float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt) {
-
-  int i, Np;
-  float Mcat, Mcol, Msys, mc, Mc;
-  PhotCode *code;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Msys = measure[0].M;
-    return (Msys);
-  }
-  code = &photcodes[0].code[Np];
-  Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
-
-  /* for DEP, color must be made of PRI/SEC */
-  mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
-  if (isnan(mc)) return (Mcat);
-  mc = mc - SCALE*code[0].dX;
-
-  Mc = mc;
-  Mcol = 0;
+  PhotCode *code = &photcodes[0].code[Np];
+
+  // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux
+  float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  float Moff = Mcal - ZERO_POINT + 8.9;
+  float Foff = 3630.8 * MagToFlux(Mcal);
+  float Fcat = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      Fcat = isnan (measure[0].FluxPSF)  ? MagToFlux(measure[0].M + Moff)     : measure[0].FluxPSF * Foff;
+      break;
+    case MAG_CLASS_KRON:
+      Fcat = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron * Foff;
+      break;
+    case MAG_CLASS_APER:
+      Fcat = isnan (measure[0].FluxAp)   ? MagToFlux(measure[0].Map + Moff)   : measure[0].FluxAp * Foff;
+      break;
+    default:
+      break;
+  }
+  if (isnan(Fcat)) return (NAN);
+
+  // find the relevant color 
+  float mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Fcat);
+  mc -= SCALE*code[0].dX;
+
+  // find the color correction in mags
+  int i = 0;
+  double Mc = mc;
+  float Mcol = 0;
   for (i = 0; i < code[0].Nc; i++) {
     Mcol += code[0].X[i]*Mc;
     Mc *= mc;
   }
-  Msys = Mcat + Mcol;
-  return (Msys);
-}
-
-float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt) {
-
-  int i, Np;
-  float Mcat, Mcol, Mrel, mc, Mc;
-  PhotCode *code;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
+  float Fcol = MagToFlux (Mcol);
+
+  float Fsys = Fcat * Fcol;
+  return (Fsys);
+}
+
+float PhotFluxRel (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) {
+
+  int Np = photcodes[0].hashcode[measure[0].photcode];
   if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Mcat = measure[0].M;
-    return (Mcat);
-  }
-  code = &photcodes[0].code[Np];
-  Mrel = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
+  PhotCode *code = &photcodes[0].code[Np];
+
+  // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux
+  float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
+  float Moff = Mcal - ZERO_POINT + 8.9;
+  float Foff = 3630.8 * MagToFlux(Mcal);
+  float Fcat = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      Fcat = isnan (measure[0].FluxPSF)  ? MagToFlux(measure[0].M + Moff)     : measure[0].FluxPSF * Foff;
+      break;
+    case MAG_CLASS_KRON:
+      Fcat = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron * Foff;
+      break;
+    case MAG_CLASS_APER:
+      Fcat = isnan (measure[0].FluxAp)   ? MagToFlux(measure[0].Map + Moff)   : measure[0].FluxAp * Foff;
+      break;
+    default:
+      break;
+  }
+  if (isnan(Fcat)) return (NAN);
 
   /* for DEP, color must be made of PRI/SEC */
-  mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
-  if (isnan(mc)) return (Mrel);
-  mc = mc - SCALE*code[0].dX;
-
-  Mc = mc;
-  Mcol = 0;
+  float mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Fcat);
+  mc -= SCALE*code[0].dX;
+
+  double Mc = mc;
+  float Mcol = 0;
+  int i = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  float Fcol = MagToFlux (Mcol);
+
+  float Frel = Fcat * Fcol;
+  return (Frel);
+}
+
+/* return calibrated magnitude from measure for given photcode */
+float PhotFluxCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code, dvoMagClassType class) {
+
+  int i; 
+
+  if (code == NULL) return NAN;
+
+  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
+  int Np = photcodes[0].hashcode[thisone[0].photcode];
+  if (Np == -1) return (NAN);
+  PhotCode *myCode = &photcodes[0].code[Np];
+
+  if (code->code != myCode->equiv) return (NAN);
+
+  float Frel = PhotFluxRel (thisone, average, secfilt, class) + SCALE*code[0].C;
+
+  // get the relevant color term
+  float mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Frel);
+  mc -= SCALE*code[0].dX;
+
+  // get the corresponding color correction in mags, convert to flux
+  double Mc = mc;
+  float Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  float Fcol = MagToFlux (Mcol);
+
+  float Fcal = Frel * Fcol;
+  return (Fcal);
+}
+
+/***/
+float PhotFluxAve (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) {
+
+  if (code == NULL) return NAN;
+
+  int Ns = photcodes[0].hashNsec[code[0].code];
+  if (Ns == -1) return (NAN);
+
+  float Fave = NAN;
+  switch (source) {
+    case MAG_SRC_CHP:
+      switch (class) {
+	case MAG_CLASS_PSF:
+	  Fave = MagToFlux(secfilt[Ns].M);
+	  break;
+	case MAG_CLASS_KRON:
+	  Fave = MagToFlux(secfilt[Ns].Mkron);
+	  break;
+	case MAG_CLASS_APER:
+	  Fave = MagToFlux(secfilt[Ns].Map);
+	  break;
+	default:
+	  break;
+      }
+      break;
+    case MAG_SRC_WRP:
+      switch (class) {
+	case MAG_CLASS_PSF:
+	  Fave = isnan (secfilt[Ns].FpsfWrp)  ? MagToFlux(secfilt[Ns].MpsfWrp)  : secfilt[Ns].FpsfWrp;
+	  break;
+	case MAG_CLASS_KRON:
+	  Fave = isnan (secfilt[Ns].FkronWrp) ? MagToFlux(secfilt[Ns].MkronWrp) : secfilt[Ns].FkronWrp;
+	  break;
+	case MAG_CLASS_APER:
+	  Fave = isnan (secfilt[Ns].FapWrp)   ? MagToFlux(secfilt[Ns].MapWrp)   : secfilt[Ns].FapWrp;
+	  break;
+	default:
+	  break;
+      }
+      break;
+    case MAG_SRC_STK:
+      switch (class) {
+	case MAG_CLASS_PSF:
+	  Fave = isnan (secfilt[Ns].FpsfStk)  ? MagToFlux(secfilt[Ns].MpsfStk)  : secfilt[Ns].FpsfStk;
+	  break;
+	case MAG_CLASS_KRON:
+	  Fave = isnan (secfilt[Ns].FkronStk) ? MagToFlux(secfilt[Ns].MkronStk) : secfilt[Ns].FkronStk;
+	  break;
+	case MAG_CLASS_APER:
+	  Fave = isnan (secfilt[Ns].FapStk)   ? MagToFlux(secfilt[Ns].MapStk)   : secfilt[Ns].FapStk;
+	  break;
+	default:
+	  break;
+      }
+      break;
+    default:
+      break;
+  }
+  return (Fave);
+}
+
+/* return calibrated magnitude from average/secfilt for given photcode */
+float PhotFluxRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure, dvoMagClassType class, dvoMagSourceType source) {
+
+  int i;
+
+  float Fave = PhotFluxAve (code, average, secfilt, class, source);
+  if (isnan(Fave)) return NAN;
+
+  // correct for relative zero-point
+  float Moff = SCALE*code[0].C;
+
+  float mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Fave * MagToFlux(Moff));
+  mc -= SCALE*code[0].dX;
+
+  // correct for color terms
+  double Mc = mc;
+  float Mcol = 0;
   for (i = 0; i < code[0].Nc; i++) {
     Mcol += code[0].X[i]*Mc;
     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
   }
-  Mrel += Mcol;
-  return (Mrel);
-}
-
-/* return calibrated magnitude from measure for given photcode */
-float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code) {
-
-  int i, Np; 
-  float Mcal, Mrel, Mcol, mc, Mc;
-
-  if (code == NULL) return NAN;
-
-  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
-  Np = photcodes[0].hashcode[thisone[0].photcode];
+  float Foff = MagToFlux(Mcol);
+  return (Fave * Foff);
+}
+
+float PhotFluxInstErr (Measure *measure, dvoMagClassType class) {
+
+  float Moff = - measure[0].dt - ZERO_POINT;
+
+  // use dFlux if we can, but use dMag if we must:
+  // dFlux = Flux * dMag
+
+  float dFinst = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      if (isnan (measure[0].dFluxPSF)) {
+	float Finst = MagToFlux(measure[0].M + Moff);
+	dFinst = measure[0].dM * Finst;
+      } else {
+	dFinst = measure[0].dFluxPSF;
+      }
+      break;
+    case MAG_CLASS_KRON:
+      if (isnan (measure[0].dFluxKron)) {
+	float Finst = MagToFlux(measure[0].Mkron + Moff);
+	dFinst = measure[0].dMkron * Finst;
+      } else {
+	dFinst = measure[0].dFluxKron;
+      }
+      break;
+    case MAG_CLASS_APER:
+      if (isnan (measure[0].dFluxAp)) {
+	float Finst = MagToFlux(measure[0].Map + Moff);
+	dFinst = measure[0].dMap * Finst;
+      } else {
+	dFinst = measure[0].dFluxAp;
+      }
+      break;
+    default:
+      break;
+  }
+  return (dFinst);
+}
+
+float PhotFluxCatErr (Measure *measure, dvoMagClassType class) {
+
+  int Np = photcodes[0].hashcode[measure[0].photcode];
   if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Mrel = thisone[0].M;
-    return (Mrel);
-  }
-  if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
-
-  Mcal = PhotRelTiny (thisone, average, secfilt) + SCALE*code[0].C;
-
-  mc = PhotColorForCodeTiny (average, secfilt, measure, code);
-  if (isnan(mc)) return (Mcal);
-  mc = mc - SCALE*code[0].dX;
-
-  Mc = mc;
-  Mcol = 0;
+  PhotCode *code = &photcodes[0].code[Np];
+
+  // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux
+  float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  float Moff = Mcal - ZERO_POINT + 8.9;
+  float Foff = 3630.8 * MagToFlux(Mcal);
+
+  // use dFlux if we can, but use dMag if we must:
+  // dFlux = Flux * dMag
+
+  float dFcat = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      if (isnan (measure[0].dFluxPSF)) {
+	float Finst = MagToFlux(measure[0].M + Moff);
+	dFcat = measure[0].dM * Finst;
+      } else {
+	dFcat = measure[0].dFluxPSF * Foff;
+      }
+      break;
+    case MAG_CLASS_KRON:
+      if (isnan (measure[0].dFluxKron)) {
+	float Finst = MagToFlux(measure[0].Mkron + Moff);
+	dFcat = measure[0].dMkron * Finst;
+      } else {
+	dFcat = measure[0].dFluxKron * Foff;
+      }
+      break;
+    case MAG_CLASS_APER:
+      if (isnan (measure[0].dFluxAp)) {
+	float Finst = MagToFlux(measure[0].Map + Moff);
+	dFcat = measure[0].dMap * Finst;
+      } else {
+	dFcat = measure[0].dFluxAp * Foff;
+      }
+      break;
+    default:
+      break;
+  }
+  return (dFcat);
+}
+
+/******** alternate photometry conversion functions using MeasureTiny and AverageTiny *********/
+float PhotInstTiny (MeasureTiny *measure, dvoMagClassType class) {
+
+  int Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  PhotCode *code = &photcodes[0].code[Np];
+
+  float Mraw = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      Mraw = measure[0].M;
+      break;
+    case MAG_CLASS_KRON:
+      // Mraw = measure[0].Mkron;
+      break;
+    case MAG_CLASS_APER:
+      // Mraw = measure[0].Map;
+      break;
+    default:
+      break;
+  }
+  if (code->type == PHOT_REF) {
+    return (Mraw);
+  }
+  float Minst = Mraw - measure[0].dt - ZERO_POINT;
+
+  return (Minst);
+}
+
+float PhotCatTiny (MeasureTiny *measure, dvoMagClassType class) {
+
+  int Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  PhotCode *code = &photcodes[0].code[Np];
+
+  float Mraw = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      Mraw = measure[0].M;
+      break;
+    case MAG_CLASS_KRON:
+      // Mraw = measure[0].Mkron;
+      break;
+    case MAG_CLASS_APER:
+      // Mraw = measure[0].Map;
+      break;
+    default:
+      break;
+  }
+  if (code->type == PHOT_REF) {
+    return (Mraw);
+  }
+
+  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  
+  return (Mcat);
+}
+
+float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class) {
+
+  int Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  PhotCode *code = &photcodes[0].code[Np];
+
+  float Mraw = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      Mraw = measure[0].M;
+      break;
+    case MAG_CLASS_KRON:
+      // Mraw = measure[0].Mkron;
+      break;
+    case MAG_CLASS_APER:
+      // Mraw = measure[0].Map;
+      break;
+    default:
+      break;
+  }
+  if (code->type == PHOT_REF) {
+    return (Mraw);
+  }
+  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+
+  /* for DEP, color must be made of PRI/SEC */
+  float mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mcat);
+  mc -= SCALE*code[0].dX;
+
+  int i = 0;
+  double Mc = mc;
+  float Mcol = 0;
   for (i = 0; i < code[0].Nc; i++) {
     Mcol += code[0].X[i]*Mc;
     Mc *= mc;
   }
+  float Msys = Mcat + Mcol;
+  return (Msys);
+}
+
+float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class) {
+
+  int Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  PhotCode *code = &photcodes[0].code[Np];
+
+  float Mraw = NAN;
+  switch (class) {
+    case MAG_CLASS_PSF:
+      Mraw = measure[0].M;
+      break;
+    case MAG_CLASS_KRON:
+      // Mraw = measure[0].Mkron;
+      break;
+    case MAG_CLASS_APER:
+      // Mraw = measure[0].Map;
+      break;
+    default:
+      break;
+  }
+  if (code->type == PHOT_REF) {
+    return (Mraw);
+  }
+  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
+
+  /* for DEP, color must be made of PRI/SEC */
+  float mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mcat);
+  mc -= SCALE*code[0].dX;
+
+  double Mc = mc;
+  float Mcol = 0;
+  int i = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  float Mrel = Mcat + Mcol;
+  return (Mrel);
+}
+
+/* return calibrated magnitude from measure for given photcode */
+float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code, dvoMagClassType class) {
+
+  int i; 
+
+  if (code == NULL) return NAN;
+
+  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
+  int Np = photcodes[0].hashcode[thisone[0].photcode];
+  if (Np == -1) return (NAN);
+  PhotCode *myCode = &photcodes[0].code[Np];
+
+  if (code->code != myCode->equiv) return (NAN);
+
+  // if we are REF type, just get the right version and return
+  if (myCode->type == PHOT_REF) {
+    float Mraw = NAN;
+    switch (class) {
+      case MAG_CLASS_PSF:
+	Mraw = thisone[0].M;
+	break;
+      case MAG_CLASS_KRON:
+	// Mraw = thisone[0].Mkron;
+	break;
+      case MAG_CLASS_APER:
+	// Mraw = thisone[0].Map;
+	break;
+      default:
+	break;
+    }
+    return (Mraw);
+  }
+
+  float Mcal = PhotRelTiny (thisone, average, secfilt, class) + SCALE*code[0].C;
+
+  float mc = PhotColorForCodeTiny (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mcal);
+  mc -= SCALE*code[0].dX;
+
+  double Mc = mc;
+  float Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
   Mcal += Mcol;
   return (Mcal);
+}
+
+/***/
+float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) {
+
+  if (code == NULL) return NAN;
+
+  int Ns = photcodes[0].hashNsec[code[0].code];
+  if (Ns == -1) return (NAN);
+
+  float Mave = NAN;
+  switch (source) {
+    case MAG_SRC_CHP:
+      switch (class) {
+	case MAG_CLASS_PSF:
+	  Mave = secfilt[Ns].M;
+	  break;
+	case MAG_CLASS_KRON:
+	  Mave = secfilt[Ns].Mkron;
+	  break;
+	case MAG_CLASS_APER:
+	  Mave = secfilt[Ns].Map;
+	  break;
+	default:
+	  break;
+      }
+      break;
+    case MAG_SRC_WRP:
+      switch (class) {
+	case MAG_CLASS_PSF:
+	  Mave = secfilt[Ns].MpsfWrp;
+	  break;
+	case MAG_CLASS_KRON:
+	  Mave = secfilt[Ns].MkronWrp;
+	  break;
+	case MAG_CLASS_APER:
+	  Mave = secfilt[Ns].MapWrp;
+	  break;
+	default:
+	  break;
+      }
+      break;
+    case MAG_SRC_STK:
+      switch (class) {
+	case MAG_CLASS_PSF:
+	  Mave = secfilt[Ns].MpsfStk;
+	  break;
+	case MAG_CLASS_KRON:
+	  Mave = secfilt[Ns].MkronStk;
+	  break;
+	case MAG_CLASS_APER:
+	  Mave = secfilt[Ns].MapStk;
+	  break;
+	default:
+	  break;
+      }
+      break;
+    default:
+      break;
+  }
+  return (Mave);
+}
+
+/* return calibrated magnitude from average/secfilt for given photcode */
+float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, dvoMagClassType class, dvoMagSourceType source) {
+
+  int i;
+
+  float Mave = PhotAveTiny (code, average, secfilt, class, source);
+  if (isnan(Mave)) return NAN;
+
+  // correct for relative zero-point
+  float Mref = Mave + SCALE*code[0].C;
+
+  float mc = PhotColorForCodeTiny (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mref);
+  mc -= SCALE*code[0].dX;
+
+  // correct for color terms
+  double Mc = mc;
+  float Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mref += Mcol;
+  return (Mref);
 }
 
@@ -1212,44 +1551,4 @@
 }
 
-/* return calibrated magnitude from average/secfilt for given photcode */
-float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure) {
-
-  int i, Ns;
-  float Mave, Mref, Mcol, mc;
-  double Mc;
-
-  if (code == NULL) return NAN;
-
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
-  Mref = Mave + SCALE*code[0].C;
-
-  mc = PhotColorForCodeTiny (average, secfilt, measure, code);
-  if (isnan(mc)) return (Mref);
-  mc = mc - SCALE*code[0].dX;
-
-  Mc = mc;
-  Mcol = 0;
-  for (i = 0; i < code[0].Nc; i++) {
-    Mcol += code[0].X[i]*Mc;
-    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
-  }
-  Mref += Mcol;
-  return (Mref);
-}
-
-/***/
-float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) {
-
-  int Ns;
-  float Mave;
-
-  if (code == NULL) return NAN;
-
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
-  return (Mave);
-}
-
 float PhotdMTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) {
 
@@ -1264,9 +1563,8 @@
 }
 
-// XXX return NAN or NAN_S_SHORT? (secfilt->Xm is short)
+// Xm is now (2014.07.03) stored as the chisq except in dvo formats which use as short
 float PhotXmTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) {
 
   int Ns;
-  short Mi;
   float Xm;
 
@@ -1274,6 +1572,5 @@
 
   Ns = photcodes[0].hashNsec[code[0].code];
-  Mi = (Ns == -1) ? NAN : secfilt[Ns].Xm;
-  Xm = (isnan(Mi)) ? -1.0 : pow (10.0, 0.01*Mi);
+  Xm = (Ns == -1) ? NAN : secfilt[Ns].Mchisq;
   return (Xm);
 }
Index: /trunk/Ohana/src/libdvo/src/dvo_tiny_values.c
===================================================================
--- /trunk/Ohana/src/libdvo/src/dvo_tiny_values.c	(revision 37034)
+++ /trunk/Ohana/src/libdvo/src/dvo_tiny_values.c	(revision 37035)
@@ -14,6 +14,6 @@
 
 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;