Changeset 37822

branches/eam_branches/ipp-pv3-20140717-merge/Ohana

Property svn:mergeinfo set to

/branches/eam_branches/ipp-20140206/Ohana	merged	eligible
/branches/eam_branches/ipp-20140214/Ohana	merged	eligible
/branches/eam_branches/ipp-20140226/Ohana	merged	eligible
/branches/eam_branches/ipp-20140402/Ohana	merged	eligible
/branches/eam_branches/ipp-20140423/Ohana	merged	eligible
/branches/eam_branches/ipp-20140610/Ohana	merged	eligible
/branches/eam_branches/ipp-20140717/Ohana	merged	eligible
/branches/eam_branches/ipp-20140813/Ohana	merged	eligible
/branches/eam_branches/ipp-20140904/Ohana	merged	eligible
/branches/eam_branches/ipp-ops-20130712/Ohana	merged	eligible
/branches/eam_branches/ps2-tc3-20130727/Ohana	merged	eligible
/tags/ipp-20130712/Ohana	merged	eligible
/tags/ipp-20140114/Ohana	merged	eligible
/tags/ipp-20141119/Ohana	merged	eligible
/tags/ipp-20141224/Ohana	merged	eligible
/trunk/Ohana	merged	eligible

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/Makefile.in

r35110	r37822
34	34	dvopsps \
35	35	elixir \
	36	fakeastro \
36	37	gastro \
37	38	gastro2 \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/configure.tcsh

-              r34088
+              r37822
 set needlibs   = "$needlibs X11"
 set needlibs   = "$needlibs pthread"
+set needlibs   = "$needlibs gsl"
+set needlibs   = "$needlibs gslcblas"
 set needlibs   = "$needlibs m"
 …
 set needincs = "$needincs png.h"
 set needincs = "$needincs pthread.h"
+set needincs = "$needincs gsl/gsl_sf_legendre.h"
 set needincs = "$needincs readline/history.h"
 set needincs = "$needincs readline/readline.h"

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/Makefile

-              r37343
+              r37822
 sedstar      : $(BIN)/sedstar.$(ARCH)
 load2mass    : $(BIN)/load2mass.$(ARCH)
+loadstarpar  : $(BIN)/loadstarpar.$(ARCH)
+loadstarpar_client : $(BIN)/loadstarpar_client.$(ARCH)
+loadICRF  : $(BIN)/loadICRF.$(ARCH)
+loadICRF_client : $(BIN)/loadICRF_client.$(ARCH)
 loadwise     : $(BIN)/loadwise.$(ARCH)
 dumpskycells : $(BIN)/dumpskycells.$(ARCH)
 …
 mkcmf        : $(BIN)/mkcmf.$(ARCH)
 all: addstar addstar_client sedstar load2mass skycells mkcmf loadwise loadsupercos dumpskycells findskycell
 INSTALL = addstar addstar_client sedstar load2mass skycells mkcmf loadwise loadsupercos dumpskycells findskycell
+all: addstar addstar_client sedstar load2mass loadstarpar loadstarpar_client loadICRF loadICRF_client skycells mkcmf loadwise loadsupercos dumpskycells findskycell
+INSTALL = addstar addstar_client sedstar load2mass loadstarpar loadstarpar_client loadICRF loadICRF_client skycells mkcmf loadwise loadsupercos dumpskycells findskycell
 # I need to fix the client/server version of addstar now that I have dropped Stars
 …
 $(SRC)/parse_time.$(ARCH).o \
 $(SRC)/replace_match.$(ARCH).o \
 $(SRC)/resort_catalog.$(ARCH).o \
+$(SRC)/resort_catalogs.$(ARCH).o \
 $(SRC)/resort_threaded.$(ARCH).o \
 $(SRC)/resort_unthreaded.$(ARCH).o \
 $(SRC)/resort_unthreaded_catalogs.$(ARCH).o \
+$(SRC)/resort_catalog.$(ARCH).o \
 $(SRC)/StarOps.$(ARCH).o \
 $(SRC)/ReadStarsFITS.$(ARCH).o \
 …
 $(SRC)/addstar_client.$(ARCH).o \
 $(SRC)/args_parallel_client.$(ARCH).o \
 $(SRC)/resort_catalog.$(ARCH).o \
+$(SRC)/resort_catalogs.$(ARCH).o \
 $(SRC)/resort_threaded.$(ARCH).o \
 $(SRC)/resort_unthreaded.$(ARCH).o \
 $(SRC)/resort_unthreaded_catalogs.$(ARCH).o
+$(SRC)/resort_catalog.$(ARCH).o
 ADDSTARD = \
 …
 $(SRC)/psps_ids.$(ARCH).o
+LOAD-STARPAR = \
+$(SRC)/loadstarpar.$(ARCH).o \
+$(SRC)/ConfigInit.$(ARCH).o \
+$(SRC)/SetSignals.$(ARCH).o \
+$(SRC)/Shutdown.$(ARCH).o \
+$(SRC)/SkyRegionUtils.$(ARCH).o \
+$(SRC)/args_loadstarpar.$(ARCH).o \
+$(SRC)/find_matches_starpar.$(ARCH).o \
+$(SRC)/loadstarpar_catalog.$(ARCH).o \
+$(SRC)/loadstarpar_io.$(ARCH).o \
+$(SRC)/loadstarpar_make_subset.$(ARCH).o \
+$(SRC)/loadstarpar_readstars.$(ARCH).o \
+$(SRC)/loadstarpar_remote_hosts.$(ARCH).o \
+$(SRC)/loadstarpar_save_remote.$(ARCH).o \
+$(SRC)/loadstarpar_table.$(ARCH).o \
+$(SRC)/psps_ids.$(ARCH).o
+LOAD-STARPAR-CLIENT = \
+$(SRC)/loadstarpar_client.$(ARCH).o \
+$(SRC)/ConfigInit.$(ARCH).o \
+$(SRC)/SetSignals.$(ARCH).o \
+$(SRC)/Shutdown.$(ARCH).o \
+$(SRC)/SkyRegionUtils.$(ARCH).o \
+$(SRC)/args_loadstarpar.$(ARCH).o \
+$(SRC)/find_matches_starpar.$(ARCH).o \
+$(SRC)/loadstarpar_catalog.$(ARCH).o \
+$(SRC)/loadstarpar_io.$(ARCH).o \
+$(SRC)/loadstarpar_make_subset.$(ARCH).o \
+$(SRC)/loadstarpar_readstars.$(ARCH).o \
+$(SRC)/loadstarpar_remote_hosts.$(ARCH).o \
+$(SRC)/loadstarpar_save_remote.$(ARCH).o \
+$(SRC)/loadstarpar_table.$(ARCH).o \
+$(SRC)/psps_ids.$(ARCH).o
+LOAD-ICRF = \
+$(SRC)/loadICRF.$(ARCH).o \
+$(SRC)/ConfigInit.$(ARCH).o \
+$(SRC)/SetSignals.$(ARCH).o \
+$(SRC)/Shutdown.$(ARCH).o \
+$(SRC)/SkyRegionUtils.$(ARCH).o \
+$(SRC)/args_loadICRF.$(ARCH).o \
+$(SRC)/find_matches_ICRF.$(ARCH).o \
+$(SRC)/loadICRF_catalog.$(ARCH).o \
+$(SRC)/loadICRF_io.$(ARCH).o \
+$(SRC)/loadICRF_make_subset.$(ARCH).o \
+$(SRC)/loadICRF_readstars.$(ARCH).o \
+$(SRC)/loadICRF_remote_hosts.$(ARCH).o \
+$(SRC)/loadICRF_save_remote.$(ARCH).o \
+$(SRC)/loadICRF_table.$(ARCH).o \
+$(SRC)/psps_ids.$(ARCH).o
+LOAD-ICRF-CLIENT = \
+$(SRC)/loadICRF_client.$(ARCH).o \
+$(SRC)/ConfigInit.$(ARCH).o \
+$(SRC)/SetSignals.$(ARCH).o \
+$(SRC)/Shutdown.$(ARCH).o \
+$(SRC)/SkyRegionUtils.$(ARCH).o \
+$(SRC)/args_loadICRF.$(ARCH).o \
+$(SRC)/find_matches_ICRF.$(ARCH).o \
+$(SRC)/loadICRF_catalog.$(ARCH).o \
+$(SRC)/loadICRF_io.$(ARCH).o \
+$(SRC)/loadICRF_make_subset.$(ARCH).o \
+$(SRC)/loadICRF_readstars.$(ARCH).o \
+$(SRC)/loadICRF_remote_hosts.$(ARCH).o \
+$(SRC)/loadICRF_save_remote.$(ARCH).o \
+$(SRC)/loadICRF_table.$(ARCH).o \
+$(SRC)/psps_ids.$(ARCH).o
 LOAD-WISE = \
 $(SRC)/loadwise.$(ARCH).o \
 …
 $(SRC)/Shutdown.$(ARCH).o
+$(ADDSTARC)       : $(INC)/addstar.h
+$(ADDSTARD)       : $(INC)/addstar.h
+$(ADDSTART)       : $(INC)/addstar.h
+$(ADDSTAR)        : $(INC)/addstar.h
+$(ADDSTAR_CLIENT) : $(INC)/addstar.h
+$(SKYCELLS)       : $(INC)/addstar.h
+$(DUMPSKYCELLS)   : $(INC)/addstar.h
+$(FINDSKYCELL)    : $(INC)/addstar.h
+$(LOAD-2MASS)     : $(INC)/addstar.h $(INC)/2mass.h
+$(LOAD-WISE)      : $(INC)/addstar.h $(INC)/WISE.h
+$(MKCMF)          : $(INC)/mkcmf.h
+$(ADDSTARC)            : $(INC)/addstar.h
+$(ADDSTARD)            : $(INC)/addstar.h
+$(ADDSTART)            : $(INC)/addstar.h
+$(ADDSTAR)             : $(INC)/addstar.h
+$(ADDSTAR_CLIENT)      : $(INC)/addstar.h
+$(SKYCELLS)            : $(INC)/addstar.h
+$(DUMPSKYCELLS)        : $(INC)/addstar.h
+$(FINDSKYCELL)         : $(INC)/addstar.h
+$(LOAD-2MASS)          : $(INC)/addstar.h $(INC)/2mass.h
+$(LOAD-STARPAR)        : $(INC)/addstar.h $(INC)/loadstarpar.h
+$(LOAD-STARPAR-CLIENT) : $(INC)/addstar.h $(INC)/loadstarpar.h
+$(LOAD-ICRF)           : $(INC)/addstar.h $(INC)/loadICRF.h
+$(LOAD-ICRF-CLIENT)    : $(INC)/addstar.h $(INC)/loadICRF.h
+$(LOAD-WISE)           : $(INC)/addstar.h $(INC)/WISE.h
+$(MKCMF)               : $(INC)/mkcmf.h
 $(BIN)/addstar.$(ARCH)        : $(ADDSTAR)
 …
 $(BIN)/load2mass.$(ARCH)      : $(LOAD-2MASS)
 $(BIN)/loadwise.$(ARCH)       : $(LOAD-WISE)
+$(BIN)/loadstarpar.$(ARCH)    : $(LOAD-STARPAR)
+$(BIN)/loadstarpar_client.$(ARCH) : $(LOAD-STARPAR-CLIENT)
+$(BIN)/loadICRF.$(ARCH)       : $(LOAD-ICRF)
+$(BIN)/loadICRF_client.$(ARCH): $(LOAD-ICRF-CLIENT)
 $(BIN)/loadsupercos.$(ARCH)   : $(LOAD-SUPERCOS)
 $(BIN)/skycells.$(ARCH)       : $(SKYCELLS)

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/include/WISE.h

-              r33963
+              r37822
 short WISE_W1, WISE_W2, WISE_W3, WISE_W4;
+int ALLSKY;
+enum {MODE_NONE, MODE_ALLWISE, MODE_ALLSKY, MODE_PRELIM};
+int MODE;
 AddstarClientOptions args_loadwise (int argc, char **argv, AddstarClientOptions options);
 int loadwise_rawdata (SkyList *skytable, char *filename, AddstarClientOptions options, int ALLSKY);
+int loadwise_rawdata (SkyList *skytable, char *filename, AddstarClientOptions options);
 int getWISE_setup ();

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/include/addstar.h

-              r37343
+              r37822
 # define IN_REGION(R,D) ( \
 ((D) >= region[0].Dmin) && ((D) < region[0].Dmax) && \
 ((R) >= region[0].Rmin)  && ((R) < region[0].Rmax))
+((R) >= region[0].Rmin) && ((R) < region[0].Rmax))
 /* grab named photcode */
 …
 # define dCOS(A)   ((double) cos ((double)RAD_DEG*A))
 # define dSIN(A)   ((double) sin ((double)RAD_DEG*A))
+# define myAbortF(FORMAT,...) { fprintf (stderr, FORMAT, __VA_ARGS__); abort(); }
 typedef struct {
 …
 Stars     *rd_gsc                 PROTO((char *filename, unsigned int *nstars));
 int        replace_match          PROTO((Average *average, Measure *measure, Stars *star));
+int        resort_threaded        PROTO((AddstarClientOptions *options, SkyTable *sky));
+int        resort_unthreaded      PROTO((AddstarClientOptions *options, SkyTable *sky, int hostID, char *hostpath));
+int        resort_unthreaded_catalogs PROTO((AddstarClientOptions *options, SkyList *skylist, int hostID, char *hostpath));
+int        resort_catalogs        PROTO((AddstarClientOptions *options, SkyTable *sky));
+int        resort_catalogs_parallel PROTO((AddstarClientOptions *options, SkyList *sky));
+int        resort_threaded        PROTO((SkyList *skylist, int ForceSort));
+int        resort_unthreaded      PROTO((SkyList *skylist, int ForceSort));
 void       resort_catalog         PROTO((Catalog *catalog));
 void       resort_catalog_old     PROTO((Catalog *catalog));
 Stars     *ReadStarsFITS          PROTO((FILE *f, Header *header, Header *in_theader, unsigned int *nstars));
 Stars     *ReadStarsTEXT          PROTO((FILE *f, unsigned int *nstars));
 …
 off_t     *init_lensing_links     PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing));
 off_t     *init_missing_links     PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing));
 off_t      add_meas_link          PROTO((Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE));
 off_t      add_miss_link          PROTO((Average *average, off_t *next_miss, off_t Nmissing));
 off_t      add_lens_link          PROTO((Average *average, off_t *next_lens, off_t Nlensing, off_t NLENSING));
+int        add_meas_link          PROTO((Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE));
+int        add_miss_link          PROTO((Average *average, off_t *next_miss, off_t Nmissing));
+int        add_lens_link          PROTO((Average *average, off_t *next_lens, off_t Nlensing, off_t NLENSING));
 off_t     *build_measure_links    PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
 off_t     *build_lensing_links    PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing));
 …
 void *memrchr(const void *s, int c, size_t n);
 int addstar_create_ID ();
+int strextend (char *input, char *format,...);
+void initMosaicCoords ();
+void saveMosaicCoords (Coords *input);
 /**

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/BoundaryTreeIO.c

r34260	r37822
1	1	# include "addstar.h"
	2
	3	/ this file is deprecated (functions moved to libdvo) */
2	4
3	5	# define GET_COLUMN_NEW(OUT,NAME,TYPE) \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/LoadData.c

-              r37343
+              r37822
   // we need to perform that analysis here
   GetZeroPointExposure (headers, headerSets, Nimages);
+  if (!options[0].mosaic) {
+    // we are requiring a single set of N x WRPs + 1 DIS per file set.
+    // NOTE: if the -mosaic was supplied, do not reset the mosaic coords here
+    initMosaicCoords ();
+  }
   // now run through the images, interpret the headers and read the stars

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/LoadDataPMM.c

-              r36485
+              r37822
     // XXX for now, we define a totally fake coordinate system centered on the plate center
     strcpy (image[0].coords.ctype, "DEC--TAN");
+    InitCoords (&image[0].coords, "DEC--TAN");
     image[0].coords.crval1  = pmm_get_ra (RA);
 …
     image[0].coords.crpix2 = 0.5*PLATE_NY;
     image[0].coords.cdelt1 = image[0].coords.cdelt2 = 0.9 / 3600.0;
-    image[0].coords.pc1_1 = 0.0;
-    image[0].coords.pc1_2 = 1.0;
-    image[0].coords.pc2_1 = 1.0;
-    image[0].coords.pc2_2 = 0.0;
-    image[0].coords.Npolyterms = 0;
-    memset (image[0].coords.polyterms, 0, 2*7*sizeof(float));
     image[0].NX = PLATE_NX;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/LoadStars.c

-              r28241
+              r37822
       exit (1);
+    }
+    /* supplied photcode is incompatible with multi-chip images */
+    if ((NheaderSets > 1) && options[0].mosaic) {
+      fprintf (stderr, "ERROR: -mosaic cannot be supplied to multiple images\n");
+      exit (1);
+    }
     // if these are SDSS data, load with SDSS-specific wrapper

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/MatchHeaders.c

r37343	r37822
64	64	if (!strcmp (exttype, "PS1_SV2")) goto keep;
65	65	if (!strcmp (exttype, "PS1_SV3")) goto keep;
	66	if (!strcmp (exttype, "PS1_SV4")) goto keep;
66	67
67	68	if (!strcmp (exttype, "PS1_DV1")) goto keep;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/NewImage.c

r10939	r37822
33	33	goto reject;
34	34	}
	35	saveMosaicCoords (mosaic);
35	36	}
36	37

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/ReadImageHeader.c

-              r37036
+              r37822
 # include "addstar.h"
+// for DIS/WRP sets, we need to save the DIS set and supply it to the WRP entries
+static Coords *mosaic = NULL;
+void initMosaicCoords () {
+  mosaic = NULL;
+}
+void saveMosaicCoords (Coords *input) {
+  ALLOCATE (mosaic, Coords, 1);
+  memcpy (mosaic, input, sizeof(Coords));
+}
 /* read an image header corresponding to a CMF / CMP data block */
 …
   /* only load astrometry, NAXIS1,2, and time if this is a MOSAIC_PHU (ctype is ....-DIS) */
   if (!strcmp (&image[0].coords.ctype[4], "-DIS")) {
     RegisterMosaic (&image[0].coords);
+    saveMosaicCoords (&image[0].coords);
     return (TRUE);
+  }
 …
+  }
   if (!strcmp (&image[0].coords.ctype[4], "-WRP")) {
     if (!isRegisteredMosaic()) {
+    if (!mosaic) {
       fprintf (stderr, "no mosaic for WRP image (use -mosaic)\n");
       return (FALSE);
+    }
+    image[0].coords.mosaic = mosaic;
   } else {
     /* force image to lie in 0-360 range */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/ReadStarsFITS.c

-              r37036
+              r37822
 Stars     *Convert_PS1_V5         PROTO((FTable *table, unsigned int *nstars));
 Stars     *Convert_PS1_V5_Lensing PROTO((FTable *table, unsigned int *nstars));
+Stars     *Convert_PS1_V5_Lensing_Alt PROTO((FTable *table, unsigned int *nstars));
 Stars     *Convert_PS1_SV1        PROTO((FTable *table, unsigned int *nstars));
 Stars     *Convert_PS1_SV1_Alt    PROTO((FTable *table, unsigned int *nstars));
 Stars     *Convert_PS1_SV2        PROTO((FTable *table, unsigned int *nstars));
 Stars     *Convert_PS1_SV3        PROTO((FTable *table, unsigned int *nstars));
+Stars     *Convert_PS1_SV4        PROTO((FTable *table, unsigned int *nstars));
 Stars     *Convert_PS1_DV3        PROTO((FTable *table, unsigned int *nstars));
 Stars     *Convert_PS1_DV4        PROTO((FTable *table, unsigned int *nstars));
 …
+  }
   if (!strcmp (type, "PS1_V5")) {
+    if (table.header[0].Naxis[0] == 312) {
+      stars = Convert_PS1_V5_Lensing (&table, &Nstars);
+    } else {
+      stars = Convert_PS1_V5 (&table, &Nstars);
+    switch (table.header[0].Naxis[0]) {
+      case 232:
+        stars = Convert_PS1_V5 (&table, &Nstars);
+        break;
+      case 312:
+        stars = Convert_PS1_V5_Lensing_Alt (&table, &Nstars);
+        break;
+      case 320:
+        stars = Convert_PS1_V5_Lensing (&table, &Nstars);
+        break;
+      default:
+        fprintf (stderr, "invalid PS1_V5 table size %d\n", (int) table.header[0].Naxis[0]);
+        return NULL;
+    }
+  }
 …
   if (!strcmp (type, "PS1_SV3")) {
     stars = Convert_PS1_SV3 (&table, &Nstars);
+  }
+  if (!strcmp (type, "PS1_SV4")) {
+    stars = Convert_PS1_SV4 (&table, &Nstars);
+  }
   if (!strcmp (type, "PS1_DV3")) {
 …
     stars[i].measure.psfNdof    = NAN_S_INT; // not provided by SMPDATA:
     stars[i].measure.psfNpix    = NAN_S_INT; // not provided by SMPDATA:
-    stars[i].measure.crNsigma   = NAN;       // not provided by SMPDATA:
     stars[i].measure.extNsigma  = NAN;       // not provided by SMPDATA:
 …
     stars[i].measure.psfNdof    = NAN_S_INT; // not provided by PS1_DEV_0:
     stars[i].measure.psfNpix    = NAN_S_INT; // not provided by PS1_DEV_0:
-    stars[i].measure.crNsigma   = NAN;       // not provided by PS1_DEV_0:
     stars[i].measure.extNsigma  = NAN;        // not provided by PS1_DEV_0:
 …
     stars[i].measure.psfNdof    = NAN_S_INT; // not provided by PS1_DEV_1:
     stars[i].measure.psfNpix    = NAN_S_INT; // not provided by PS1_DEV_1:
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
+}
+Stars *Convert_PS1_V5_Lensing_Alt (FTable *table, unsigned int *nstars) {
+  off_t Nstars;
+  unsigned int i;
+  double ZeroPt;
+  Stars *stars;
+  CMF_PS1_V5_Lensing_Alt *ps1data;
+  ps1data = gfits_table_get_CMF_PS1_V5_Lensing_Alt (table, &Nstars, NULL);
+  if (!ps1data) {
+    fprintf (stderr, "skipping inconsistent entry\n");
+    return (NULL);
+  }
+  ZeroPt = GetZeroPoint();
+  ALLOCATE (stars, Stars, Nstars);
+  for (i = 0; i < Nstars; i++) {
+    InitStar (&stars[i]);
+    stars[i].measure.Xccd       = ps1data[i].X;
+    stars[i].measure.Yccd       = ps1data[i].Y;
+    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
+    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
+    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
+    stars[i].measure.pltscale   = ps1data[i].pltscale;
+    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
+      stars[i].measure.M      = NAN;
+    } else {
+      stars[i].measure.M      = ps1data[i].M + ZeroPt;
+    }
+    stars[i].measure.dM         = ps1data[i].dM;
+    stars[i].measure.dMcal      = ps1data[i].dMcal;
+    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
+    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+    // these fluxes are converted from counts to counts/sec in FilterStars.c
+    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M);
+    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
+    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
+    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
+    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map);
+    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
+    stars[i].measure.Sky        = ps1data[i].sky;
+    stars[i].measure.dSky       = ps1data[i].dSky;
+    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
+    stars[i].measure.psfQF      = ps1data[i].psfQF;
+    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
+    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
+    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
+    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
+    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
+    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
+    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
+    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
+    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
+    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
+    stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    stars[i].measure.detID      = ps1data[i].detID;
+    ALLOCATE (stars[i].lensing, Lensing, 1);
+    dvo_lensing_init (stars[i].lensing);
+    stars[i].lensing->X11_sm_obj  = ps1data[i].X11_sm_obj;
+    stars[i].lensing->X12_sm_obj  = ps1data[i].X12_sm_obj;
+    stars[i].lensing->X22_sm_obj  = ps1data[i].X22_sm_obj;
+    stars[i].lensing->E1_sm_obj   = ps1data[i].E1_sm_obj;
+    stars[i].lensing->E2_sm_obj   = ps1data[i].E2_sm_obj;
+    stars[i].lensing->X11_sh_obj  = ps1data[i].X11_sh_obj;
+    stars[i].lensing->X12_sh_obj  = ps1data[i].X12_sh_obj;
+    stars[i].lensing->X22_sh_obj  = ps1data[i].X22_sh_obj;
+    stars[i].lensing->E1_sh_obj   = ps1data[i].E1_sh_obj;
+    stars[i].lensing->E2_sh_obj   = ps1data[i].E2_sh_obj;
+    stars[i].lensing->X11_sm_psf  = ps1data[i].X11_sm_psf;
+    stars[i].lensing->X12_sm_psf  = ps1data[i].X12_sm_psf;
+    stars[i].lensing->X22_sm_psf  = ps1data[i].X22_sm_psf;
+    stars[i].lensing->E1_sm_psf   = ps1data[i].E1_sm_psf;
+    stars[i].lensing->E2_sm_psf   = ps1data[i].E2_sm_psf;
+    stars[i].lensing->X11_sh_psf  = ps1data[i].X11_sh_psf;
+    stars[i].lensing->X12_sh_psf  = ps1data[i].X12_sh_psf;
+    stars[i].lensing->X22_sh_psf  = ps1data[i].X22_sh_psf;
+    stars[i].lensing->E1_sh_psf   = ps1data[i].E1_sh_psf;
+    stars[i].lensing->E2_sh_psf   = ps1data[i].E2_sh_psf;
+    // stars[i].lensing->F_ApR5    = ps1data[i].F_ApR5;
+    // stars[i].lensing->dF_ApR5   = ps1data[i].dF_ApR5;
+    // stars[i].lensing->sF_ApR5   = ps1data[i].sF_ApR5;
+    // stars[i].lensing->fF_ApR5   = ps1data[i].fF_ApR5;
+    //
+    // stars[i].lensing->F_ApR6    = ps1data[i].F_ApR6;
+    // stars[i].lensing->dF_ApR6   = ps1data[i].dF_ApR6;
+    // stars[i].lensing->sF_ApR6   = ps1data[i].sF_ApR6;
+    // stars[i].lensing->fF_ApR6   = ps1data[i].fF_ApR6;
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    stars[i].lensing->detID      = ps1data[i].detID;
+    // the Average fields and the following Measure fields are set in FilterStars after
+    // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID.
+    // averef is set in find_matches
+    // dbFlags is zero on ingest.
+    // the following fields are currently not being set anywhere: t_msec
+  }
+  *nstars = Nstars;
+  return (stars);
+}
 Stars *Convert_PS1_SV1 (FTable *table, unsigned int *nstars) {
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
+}
 Stars *Convert_PS1_DV3 (FTable *table, unsigned int *nstars) {
+Stars *Convert_PS1_SV4 (FTable *table, unsigned int *nstars) {
   off_t Nstars;
 …
   double ZeroPt;
   Stars *stars;
   CMF_PS1_DV3 *ps1data;
   ps1data = gfits_table_get_CMF_PS1_DV3 (table, &Nstars, NULL);
+  CMF_PS1_SV4 *ps1data;
+  ps1data = gfits_table_get_CMF_PS1_SV4 (table, &Nstars, NULL);
   if (!ps1data) {
     fprintf (stderr, "skipping inconsistent entry\n");
 …
     stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
     stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
     // these fluxes are converted from counts to counts/sec in FilterStars.c
     stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M);
 …
     stars[i].measure.psfQF      = ps1data[i].psfQF;
     stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
     // the Average fields and the following Measure fields are set in FilterStars after
+    // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID.
+    // averef is set in find_matches
+    // dbFlags is zero on ingest.
+    // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID,
+    // averef is set in find_matches, dbFlags is zero on ingest.
     // the following fields are currently not being set anywhere: t_msec
 …
+}
 Stars *Convert_PS1_DV4 (FTable *table, unsigned int *nstars) {
+Stars *Convert_PS1_DV3 (FTable *table, unsigned int *nstars) {
   off_t Nstars;
 …
   double ZeroPt;
   Stars *stars;
   CMF_PS1_DV4 *ps1data;
   ps1data = gfits_table_get_CMF_PS1_DV4 (table, &Nstars, NULL);
+  CMF_PS1_DV3 *ps1data;
+  ps1data = gfits_table_get_CMF_PS1_DV3 (table, &Nstars, NULL);
   if (!ps1data) {
     fprintf (stderr, "skipping inconsistent entry\n");
 …
+  }
   ZeroPt = GetZeroPoint();
-  fprintf (stderr, "WARNING: Convert_PS1_DV4 not yet updated to match real format\n");
   ALLOCATE (stars, Stars, Nstars);
 …
     stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     stars[i].measure.psfNpix    = ps1data[i].psfNpix;
-    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     stars[i].measure.extNsigma  = ps1data[i].extNsigma;
 …
     stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
     // this is may optionally be replaced by the internal sequence (see FilterStars.c)
 …
+}
+Stars *Convert_PS1_DV4 (FTable *table, unsigned int *nstars) {
+  off_t Nstars;
+  unsigned int i;
+  double ZeroPt;
+  Stars *stars;
+  CMF_PS1_DV4 *ps1data;
+  ps1data = gfits_table_get_CMF_PS1_DV4 (table, &Nstars, NULL);
+  if (!ps1data) {
+    fprintf (stderr, "skipping inconsistent entry\n");
+    return (NULL);
+  }
+  ZeroPt = GetZeroPoint();
+  fprintf (stderr, "WARNING: Convert_PS1_DV4 not yet updated to match real format\n");
+  ALLOCATE (stars, Stars, Nstars);
+  for (i = 0; i < Nstars; i++) {
+    InitStar (&stars[i]);
+    stars[i].measure.Xccd       = ps1data[i].X;
+    stars[i].measure.Yccd       = ps1data[i].Y;
+    stars[i].measure.dXccd      = ToShortPixels(ps1data[i].dX);
+    stars[i].measure.dYccd      = ToShortPixels(ps1data[i].dY);
+    stars[i].measure.posangle   = ToShortDegrees(ps1data[i].posangle);
+    stars[i].measure.pltscale   = ps1data[i].pltscale;
+    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
+      stars[i].measure.M      = NAN;
+    } else {
+      stars[i].measure.M      = ps1data[i].M + ZeroPt;
+    }
+    stars[i].measure.dM         = ps1data[i].dM;
+    stars[i].measure.dMcal      = ps1data[i].dMcal;
+    stars[i].measure.Map        = ps1data[i].Map + ZeroPt;
+    stars[i].measure.dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+    stars[i].measure.Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    stars[i].measure.dMkron     = (ps1data[i].kronFlux > 0.0) ? ps1data[i].kronFluxErr / ps1data[i].kronFlux : NAN;
+    // these fluxes are converted from counts to counts/sec in FilterStars.c
+    stars[i].measure.FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M);
+    stars[i].measure.dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, stars[i].measure.FluxPSF, ps1data[i].dM);
+    stars[i].measure.FluxKron   = ps1data[i].kronFlux;
+    stars[i].measure.dFluxKron  = ps1data[i].kronFluxErr;
+    stars[i].measure.FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map);
+    stars[i].measure.dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, stars[i].measure.FluxAp, stars[i].measure.dMap);
+    stars[i].measure.Sky        = ps1data[i].sky;
+    stars[i].measure.dSky       = ps1data[i].dSky;
+    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
+    stars[i].measure.psfQF      = ps1data[i].psfQF;
+    stars[i].measure.psfQFperf  = ps1data[i].psfQFperf;
+    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
+    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
+    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
+    stars[i].measure.FWx        = ToShortPixels(ps1data[i].fx);
+    stars[i].measure.FWy        = ToShortPixels(ps1data[i].fy);
+    stars[i].measure.theta      = ToShortDegrees(ps1data[i].df);
+    stars[i].measure.Mxx        = ToShortPixels(ps1data[i].Mxx);
+    stars[i].measure.Mxy        = ToShortPixels(ps1data[i].Mxy);
+    stars[i].measure.Myy        = ToShortPixels(ps1data[i].Myy);
+    stars[i].measure.photFlags  = ps1data[i].flags;
+    stars[i].measure.photFlags2 = ps1data[i].flags2;
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    stars[i].measure.detID      = ps1data[i].detID;
+    // the Average fields and the following Measure fields are set in FilterStars after
+    // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID.
+    // averef is set in find_matches
+    // dbFlags is zero on ingest.
+    // the following fields are currently not being set anywhere: t_msec
+  }
+  *nstars = Nstars;
+  return (stars);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/ReadStarsSDSS.c

-              r36485
+              r37822
     // XXX for now, we define a totally fake coordinate system centered on the first listed star
+    strcpy (images[N].coords.ctype, "DEC--TAN");
+    InitCoords (&images[N].coords, "DEC--TAN");
     images[N].coords.crval1 = stars[0].average.R;
     images[N].coords.crval2 = stars[0].average.D;
     images[N].coords.crpix1 = stars[0].measure.Xccd;
     images[N].coords.crpix2 = stars[0].measure.Yccd;
     images[N].coords.cdelt1 = images[N].coords.cdelt2 = 0.4 / 3600.0;
-    images[N].coords.pc1_1 = 0.0;
-    images[N].coords.pc1_2 = 1.0;
-    images[N].coords.pc2_1 = 1.0;
-    images[N].coords.pc2_2 = 0.0;
-    images[N].coords.Npolyterms = 0;
-    memset (images[N].coords.polyterms, 0, 2*7*sizeof(float));
     images[N].NX = 2048;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/UpdateDatabase_Image.c

r27435	r37822
21	21
22	22	/* find correpsonding regions for image */
23		~~RegisterMosaic (mosaic);~~
24	23	skylist = NULL;
25	24	newlist = NULL;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/addstar.c

-              r37036
+              r37822
 # include "addstar.h"
+# define RESETTIME { gettimeofday (&startTimer, (void *) NULL); }
 // LARGEFILES: this program currently limits Nstars (input file) to < 2^31
 …
   SkyList *newlist = NULL;
   double dtime;
   struct timeval start, stop;
   gettimeofday (&start, NULL);
+  struct timeval startAddstar, stopAddstar;
+  gettimeofday (&startAddstar, (void *) NULL);
+  INITTIME;
   SetSignals ();
 …
   if (options.mode == ADDSTAR_MODE_RESORT) {
+    if (NTHREADS == 0) {
+      resort_unthreaded (&options, sky, 0, NULL);
+    } else {
+      resort_threaded (&options, sky);
+    }
+    resort_catalogs (&options, sky);
     exit (0);
+  }
+  MARKTIME ("init and config: %f sec\n", dtime); RESETTIME;
   stars = NULL;
 …
     case ADDSTAR_MODE_IMAGE:
       stars = LoadStars (argv[1], &Nstars, &images, &Nimages, &options);
+      MARKTIME ("load smf: %f sec\n", dtime); RESETTIME;
       // set and update the imageID sequence
 …
       skylist = SkyListForStars (sky, -1, stars, Nstars);
       break;
-    case ADDSTAR_MODE_RESORT:
     case ADDSTAR_MODE_REFCAT:
       skylist = SkyListByPatch (sky, -1, &UserPatch);
 …
+      }
+    }
+    if (VERBOSE) MARKTIME ("load cpt: %f sec\n", dtime); RESETTIME;
     // Naves_disk == 0 implies an empty catalog file
 …
         if (Nsubset) free (subset);
         break;
+      case ADDSTAR_MODE_RESORT:
+        if (options.nosort == 3) catalog.sorted = FALSE;
+        // no need to resort empty catalogs
+        if (catalog.Naves_disk == 0) {
+          dvo_catalog_unlock (&catalog);
+          dvo_catalog_free (&catalog);
+          continue;
+        }
+        if (OLD_RESORT) {
+          resort_catalog_old (&catalog);
+        } else {
+          resort_catalog (&catalog);
+        }
+        Nsubset = 1;
+        break;
+    }
+    }
+    if (VERBOSE) MARKTIME ("match stars: %f sec\n", dtime); RESETTIME;
     /* report total updated values */
     Naverage += catalog.Naverage;
 …
     dvo_catalog_unlock (&catalog);
     dvo_catalog_free (&catalog);
+    if (VERBOSE) MARKTIME ("save cpt: %f sec\n", dtime); RESETTIME;
     if (options.mode == ADDSTAR_MODE_REFCAT) free (stars);
 …
   dvo_image_unlock (&db); /* unlock? */
   gettimeofday (&stop, NULL);
   dtime = DTIME (stop, start);
+  gettimeofday (&stopAddstar, (void *) NULL);
+  float dtime = DTIME (stopAddstar, startAddstar);
   fprintf (stderr, "SUCCESS: elapsed time %9.4f sec for %5d stars (%5d matches), "OFF_T_FMT" average, "OFF_T_FMT" measure, "OFF_T_FMT" lensing\n", dtime, Nstars, Nmatch,  Naverage,  Nmeasure, Nlensing);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/addstar_client.c

r33963	r37822
25	25
26	26	if (options.mode == ADDSTAR_MODE_RESORT) {
27		resort_~~unthreaded (&options, sky, HOST_ID, HOSTDIR~~);
	27	resort_catalogs (&options, sky);
28	28	exit (0);
29	29	}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/args.c

-              r37343
+              r37822
     remove_argument (N, &argc, argv);
+  }
+  OLD_RESORT = FALSE;
+  if ((N = get_argument (argc, argv, "-old-resort"))) {
+    remove_argument (N, &argc, argv);
+    OLD_RESORT = TRUE;
+  }
   if ((N = get_argument (argc, argv, "-create-id"))) {
     options.mode = ADDSTAR_MODE_CREATE_ID;
 …
       exit (1);
+    }
     RegisterMosaic (&MOSAIC);
+    saveMosaicCoords (&MOSAIC);
     remove_argument (N, &argc, argv);
     gfits_free_header (&header);
 …
   // XXX for the moment, make this selection manual.  it needs to be automatic
   // based on the state of the SkyTable
+  HOST_ID = 0;
+  HOSTDIR = NULL;
   PARALLEL = FALSE;
   if ((N = get_argument (argc, argv, "-parallel"))) {
 …
+}
+int strextend (char *input, char *format,...) {
+  char tmpextra[1024], tmpline[1024];
+  va_list argp;
+  va_start (argp, format);
+  vsnprintf (tmpextra, 1024, format, argp);
+  snprintf (tmpline, 1024, "%s %s", input, tmpextra);
+  strcpy (input, tmpline);
+  return TRUE;
+}
 /** addstar modes:

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/args_client.c

r33963	r37822
83	83	exit (1);
84	84	}
85		~~RegisterMosaic~~ (&MOSAIC);
	85	saveMosaicCoords (&MOSAIC);
86	86	remove_argument (N, &argc, argv);
87	87	gfits_free_header (&header);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/args_loadwise.c

-              r33963
+              r37822
+  }
+enum {MODE_NONE, MODE_ALLWISE, MODE_ALLSKY, MODE_PRELIM};
+int MODE;
   /* load the prelim data dump */
+  ALLSKY = TRUE;
+  if ((N = get_argument (argc, argv, "-prelim"))) {
+    ALLSKY = FALSE;
+  MODE = MODE_ALLWISE;
+  if ((N = get_argument (argc, argv, "-mode"))) {
+    MODE = MODE_NONE;
+    remove_argument (N, &argc, argv);
+    if (!strcasecmp(argv[N], "allwise")) MODE = MODE_ALLWISE;
+    if (!strcasecmp(argv[N], "allsky"))  MODE = MODE_ALLSKY;
+    if (!strcasecmp(argv[N], "prelim"))  MODE = MODE_PRELIM;
+    if (MODE == MODE_NONE) {
+      fprintf (stderr, "invalid mode: %s\n", argv[N]);
+      exit (2);
+    }
     remove_argument (N, &argc, argv);
+  }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/args_parallel_client.c

-              r33963
+              r37822
+  }
+  OLD_RESORT = FALSE;
+  if ((N = get_argument (argc, argv, "-old-resort"))) {
+    remove_argument (N, &argc, argv);
+    OLD_RESORT = TRUE;
+  }
   /* extra error messages */
   VERBOSE = FALSE;
 …
   exit (2);
+}
+int strextend (char *input, char *format,...) {
+  char tmpextra[1024], tmpline[1024];
+  va_list argp;
+  va_start (argp, format);
+  vsnprintf (tmpextra, 1024, format, argp);
+  snprintf (tmpline, 1024, "%s %s", input, tmpextra);
+  strcpy (input, tmpline);
+  return TRUE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/build_links.c

-              r37036
+              r37822
     if (N >= Nmeasure) {
+      fprintf (stderr, "overflow in init_measure_links\n");
+      abort ();
+      myAbort ("overflow in init_measure_links\n");
+    }
+  }
 …
 /* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
 off_t add_meas_link (Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE) {
+int add_meas_link (Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE) {
   off_t k, m;
 …
+}
-/* Missing does not carry enough information to reconstruct the links
-   we must always save the missing table, if it exists */
 Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas) {
   off_t i, k, n, N;
+  int i, k, n, N;
   Measure *tmpmeasure;
 …
     average[i].measureOffset = N;
     for (k = 0; k < average[i].Nmeasure; k++, N++) {
       if (n == -1) abort();
+      if (n == -1) myAbortF("invalid measureOffset for ave %d, measureOffset %d, measure %d\n", i, average[i].measureOffset, k);
       tmpmeasure[N] = measure[n];
       if (measure[n].averef != i) abort();
+      if (measure[n].averef != i) myAbortF("invalid averef for ave %d, measureOffset %d, measure %d, averef %d\n", i, average[i].measureOffset, k, measure[n].averef);
       tmpmeasure[N].averef = i;
       n = next_meas[n];
 …
   return (tmpmeasure);
+}
+/*******************************************************************************************/
 /* build the initial links assuming the table is sorted */
 …
       next_miss[N] = -1;
       if (N >= Nmissing) {
+        fprintf (stderr, "overflow in init_missing_links");
+        abort ();
+        myAbort ("overflow in init_missing_links");
+      }
       N++;
 …
+}
 off_t add_miss_link (Average *average, off_t *next_miss, off_t Nmissing) {
+int add_miss_link (Average *average, off_t *next_miss, off_t Nmissing) {
   off_t k, m;
 …
+}
+/* Missing does not carry enough information to reconstruct the links
+   we must always save the missing table, if it exists */
 Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss) {
 …
     if (N >= Nlensing) {
+      fprintf (stderr, "overflow in init_lensing_links\n");
+      abort ();
+      myAbort ("overflow in init_lensing_links\n");
+    }
     N++;
 …
 /* average[].lensingOffset, average[].Nlensing are valid within an addstar run */
 off_t add_lens_link (Average *average, off_t *next_lens, off_t Nlensing, off_t NLENSING) {
+int add_lens_link (Average *average, off_t *next_lens, off_t Nlensing, off_t NLENSING) {
   off_t k, m;
 …
 Lensing *sort_lensing (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next_lens) {
   off_t i, k, n, N;
+  int i, k, n, N;
   Lensing *tmplensing;
 …
     average[i].lensingOffset = N;
     for (k = 0; k < average[i].Nlensing; k++, N++) {
       if (n == -1) abort();
+      if (n == -1) myAbortF("invalid lensingOffset for ave %d, lensingOffset %d, lensing %d\n", i, average[i].lensingOffset, k);
       tmplensing[N] = lensing[n];
       if (lensing[n].averef != i) abort();
+      if (lensing[n].averef != i) myAbortF("invalid averef for ave %d, lensingOffset %d, lensing %d, averef %d\n", i, average[i].lensingOffset, k, lensing[n].averef);
       tmplensing[N].averef = i;
       n = next_lens[n];

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/fakeimage.c

-              r37036
+              r37822
 Image *fakeimage (char *rootname, off_t *Nimage, int photcode) {
   int i, j, Nx, Ny, Nchips;
+  int i, Nx, Ny, Nchips;
   double pltscale, pixscale;
   double Rmin, Rmax, Dmin, Dmax;
 …
   /* create a mosaic distortion structure */
   strcpy (MOSAIC.ctype, "DEC--DIS");
+  InitCoords (&MOSAIC, "DEC--DIS");
   MOSAIC.crval1 = FAKE_RA;
   MOSAIC.crval2 = FAKE_DEC;
-  MOSAIC.crpix1 = MOSAIC.crpix2 = 0.0;
   /* mosaic 'pixels' are millimeters */
 …
   MOSAIC.Npolyterms = 3;
-  for (i = 0; i < 7; i++) {
-    MOSAIC.polyterms[i][0] = 0;
-    MOSAIC.polyterms[i][1] = 0;
+  }
   ScanConfig (config, "DPLATE_X",   "%lf", 0, &pltscale);
   MOSAIC.polyterms[3][0] = pltscale;  // L : X^3 Y^0
 …
   MOSAIC.polyterms[4][1] = pltscale;  // M : X^0 Y^0
   MOSAIC.polyterms[6][1] = pltscale;  // M : X^2 Y^0
-  RegisterMosaic (&MOSAIC);
   /* some basic data about the chisp */
 …
     strcpy (image[i+1].name, name);
     strcpy (image[i+1].coords.ctype, "DEC--WRP");
+    InitCoords (&image[i+1].coords, "DEC--WRP");
     image[i+1].coords.crval1 = dX*pixscale;
     image[i+1].coords.crval2 = dY*pixscale;
+    image[i+1].coords.crpix1 = image[i+1].coords.crpix2 = 0.0;
     image[i+1].coords.cdelt1 = image[i+1].coords.cdelt2 = pixscale;
+    image[i+1].coords.pc1_1 = 1.0;
+    image[i+1].coords.pc1_2 = 0.0;
+    image[i+1].coords.pc2_1 = 0.0;
+    image[i+1].coords.pc2_2 = 1.0;
+    image[i+1].coords.Npolyterms = 0;
+    for (j = 0; j < 7; j++) {
+      image[i+1].coords.polyterms[j][0] = 0;
+      image[i+1].coords.polyterms[j][1] = 0;
+    }
+    image[i+1].coords.mosaic = &MOSAIC;
     image[i+1].sidtime  = 0.0;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/find_matches.c

-              r37036
+              r37822
    * coordops.update.c).  We use the center of the region (catalog) for crval1,2.
    */
+  InitCoords (&tcoords, "DEC--ARC");
   tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
   if (region[0].Dmax < 90) {
 …
     tcoords.crval2 = 90.0;
+  }
-  tcoords.crpix1 = 0;
-  tcoords.crpix2 = 0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-  tcoords.Npolyterms = 1;
-  strcpy (tcoords.ctype, "DEC--ARC");
   /* build spatial index (RA sort) referencing input array sequence */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/find_matches_closest.c

-              r37036
+              r37822
    * far from the projection pole. We use the center of the region (catalog) for crval1,2.
    */
+  InitCoords (&tcoords, "DEC--ARC");
   tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
   if (region[0].Dmax < 90) {
 …
     tcoords.crval2 = 90.0;
+  }
-  tcoords.crpix1 = 0;
-  tcoords.crpix2 = 0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-  tcoords.Npolyterms = 1;
-  strcpy (tcoords.ctype, "DEC--ARC");
   /* build spatial index (RA sort) referencing input array sequence */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/find_matches_closest_refstars.c

-              r37036
+              r37822
    * far from the projection pole. We use the center of the region (catalog) for crval1,2.
    */
+  InitCoords (&tcoords, "DEC--ARC");
   tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
   if (region[0].Dmax < 90) {
 …
     tcoords.crval2 = 90.0;
+  }
-  tcoords.crpix1 = 0.0;
-  tcoords.crpix2 = 0.0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-  tcoords.Npolyterms = 0;
-  strcpy (tcoords.ctype, "DEC--ARC");
   /* build spatial index (RA sort) referencing input array sequence */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/find_matches_refstars.c

-              r37036
+              r37822
   /* project onto rectilinear grid with 1 arcsec pixels, sort by X */
   /* reference for coords is catalog center */
+  InitCoords (&tcoords, "DEC--ZEA");
   tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
   tcoords.crval2 = 0.5*(region[0].Dmin + region[0].Dmax);
-  tcoords.crpix1 = tcoords.crpix2 = 0.0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-  strcpy (tcoords.ctype, "DEC--ZEA");
-  tcoords.Npolyterms = 0;
   for (i = 0; i < Nstars; i++) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/find_missing.c

-              r10937
+              r37822
     REALLOCATE (catalog[0].missing, Missing, NMISS);
+  }
-  if (!FindMosaicForImage (overlap, Noverlap, j)) continue;
   if (!in_image (catalog[0].average[Nave].R, catalog[0].average[Nave].D, &overlap[j])) continue;
   add_miss_link (&catalog[0].average[Nave], next_miss, Nmiss);
 …
 /* add reference for undetected catalog stars */
 /* XXX allow this option only for single images? */
 if (!strcmp (&image[0].coords.ctype[4], "-WRP")) RegisterMosaic (mosaic);
+if (!strcmp (&image[0].coords.ctype[4], "-WRP")) image[0].coords = mosaic;
 for (j = 0; (j < Nave) && !options.skip_missed; j++) {
   n = N2[j];

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/findskycell.c

-              r37036
+              r37822
 int apply_tree (char *treefile, char *datafile);
 float SCALE = 1.0;
 int NX_SUB = 1;
 int NY_SUB = 1;
+float SCALE  = 1.0;
+float NX_SUB = 1.0;
+float NY_SUB = 1.0;
 double R_MIN = 0.0;
 …
   ALLOCATE (tree.Xo,   double *, tree.Nzone);
   ALLOCATE (tree.Yo,   double *, tree.Nzone);
   ALLOCATE (tree.dX,      int *, tree.Nzone);
   ALLOCATE (tree.dY,      int *, tree.Nzone);
+  ALLOCATE (tree.dX,    float *, tree.Nzone);
+  ALLOCATE (tree.dY,    float *, tree.Nzone);
   ALLOCATE (tree.cell,    int *, tree.Nzone);
   ALLOCATE (tree.name,  char **, tree.Nzone);
 …
     ALLOCATE (tree.Xo[zone],   double, tree.NBAND[zone]);
     ALLOCATE (tree.Yo[zone],   double, tree.NBAND[zone]);
     ALLOCATE (tree.dX[zone],      int, tree.NBAND[zone]);
     ALLOCATE (tree.dY[zone],      int, tree.NBAND[zone]);
+    ALLOCATE (tree.dX[zone],    float, tree.NBAND[zone]);
+    ALLOCATE (tree.dY[zone],    float, tree.NBAND[zone]);
     ALLOCATE (tree.cell[zone], int,    tree.NBAND[zone]);
     ALLOCATE (tree.name[zone], char *, tree.NBAND[zone]);
 …
       tree.Xo[zone][band] = NAN;
       tree.Yo[zone][band] = NAN;
       tree.dX[zone][band] = -1;
       tree.dY[zone][band] = -1;
+      tree.dX[zone][band] = NAN;
+      tree.dY[zone][band] = NAN;
       tree.cell[zone][band] = -1;
       ALLOCATE (tree.name[zone][band], char, BOUNDARY_TREE_NAME_LENGTH);
 …
       REALLOCATE (tree.Xo[zone],   double, tree.NBAND[zone]);
       REALLOCATE (tree.Yo[zone],   double, tree.NBAND[zone]);
       REALLOCATE (tree.dX[zone],      int, tree.NBAND[zone]);
       REALLOCATE (tree.dY[zone],      int, tree.NBAND[zone]);
+      REALLOCATE (tree.dX[zone],    float, tree.NBAND[zone]);
+      REALLOCATE (tree.dY[zone],    float, tree.NBAND[zone]);
       REALLOCATE (tree.cell[zone],    int, tree.NBAND[zone]);
       REALLOCATE (tree.name[zone], char *, tree.NBAND[zone]);
 …
         tree.Xo[zone][band] = NAN;
         tree.Yo[zone][band] = NAN;
         tree.dX[zone][band] = -1;
         tree.dY[zone][band] = -1;
+        tree.dX[zone][band] = NAN;
+        tree.dY[zone][band] = NAN;
         tree.cell[zone][j] = -1;
         ALLOCATE (tree.name[zone][j], char, BOUNDARY_TREE_NAME_LENGTH);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/loadsupercos_plates.c

-              r36485
+              r37822
     image[Nimage].Radius = NAN;
     snprintf (image[Nimage].name, 121, "SCOS.%02d.%06d", survey_id, plate_id);
+    snprintf (image[Nimage].name, DVO_IMAGE_NAME_LEN, "SCOS.%02d.%06d", survey_id, plate_id);
     image[Nimage].imageID = Nimage + 1;
     image[Nimage].externID = plate_id;
 …
     // for now, we define a fake coordinate system based on the boresite center
     strcpy (image[Nimage].coords.ctype, "DEC--TAN");
+    InitCoords (&image[Nimage].coords, "DEC--TAN");
     image[Nimage].coords.crval1 = RAo;
 …
     image[Nimage].coords.crpix2 = 0.5*image[Nimage].NY;
     image[Nimage].coords.cdelt1 = image[Nimage].coords.cdelt2 = scale;
-    image[Nimage].coords.pc1_1 = 0.0;
-    image[Nimage].coords.pc1_2 = 1.0;
-    image[Nimage].coords.pc2_1 = 1.0;
-    image[Nimage].coords.pc2_2 = 0.0;
-    image[Nimage].coords.Npolyterms = 0;
-    memset (image[Nimage].coords.polyterms, 0, 2*7*sizeof(float));
     Nimage ++;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/loadwise.c

r33963	r37822
40	40	for (i = 1; i < argc; i++) {
41	41	fprintf (stderr, "loading %s\n", argv[i]);
42		loadwise_rawdata (skylist, argv[i], options~~, ALLSKY~~);
	42	loadwise_rawdata (skylist, argv[i], options);
43	43	}
44	44	exit (0);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/loadwise_rawdata.c

-              r34088
+              r37822
 # define DEBUG 0
 int loadwise_rawdata (SkyList *skytable, char *filename, AddstarClientOptions options, int ALLSKY) {
+int loadwise_rawdata (SkyList *skytable, char *filename, AddstarClientOptions options) {
   int i, j, verbose;
 …
         stars[Nstars+3][0].average.D = tstars[j].D;
+        if (ALLSKY) {
+          loadwise_star_allsky (&stars[Nstars], &buffer[offset], Nbyte - offset);
+        } else {
+          loadwise_star_prelim (&stars[Nstars], &buffer[offset], Nbyte - offset);
+        switch (MODE) {
+          case MODE_PRELIM:
+            loadwise_star_prelim (&stars[Nstars], &buffer[offset], Nbyte - offset);
+            break;
+          case MODE_ALLSKY:
+            loadwise_star_allsky (&stars[Nstars], &buffer[offset], Nbyte - offset);
+            break;
+          case MODE_ALLWISE:
+          default:
+            // loadwise_star_allwise (&stars[Nstars], &buffer[offset], Nbyte - offset);
+            break;
+        }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/loadwise_star_full.c

-              r33963
+              r37822
 int setWISE_sat_flag (Stars *star, char *ptr);
 int setWISE_blend_flag (Stars **star, char *ptr);
+// fill in the data for a WISE quad star.  takes a pointer to the start of the line the
+// RA and DEC have already been set
+int loadwise_star_allwise (Stars **star, char *line, int Nmax) {
+  int i;
+  char *ptr;
+  if (line == NULL) Shutdown ("format error in WISE");
+  ptr = line;
+  // I can assign dRA and dDEC to dX and dY if I can consistently set posangle and pltscale
+  star[0][0].measure.posangle = 0.0;
+  star[0][0].measure.pltscale = 1.0;
+  ptr = skipNbounds (ptr, '|', 3, Nmax); // skip: desig, ra, dec,
+  star[0][0].measure.dXccd = ToShortPixels(strtod (ptr, NULL)); // sig_ra
+  ptr = nextWISEfield (ptr);
+  star[0][0].measure.dYccd = ToShortPixels(strtod (ptr, NULL)); // sig_dec
+  ptr = nextWISEfield (ptr);
+  // we only know a single set of values for all 4 bands
+  for (i = 1; i < 4; i++) {
+      star[i][0].measure.dXccd    = star[0][0].measure.dXccd;
+      star[i][0].measure.dYccd    = star[0][0].measure.dYccd;
+      star[i][0].measure.posangle = star[0][0].measure.posangle;
+      star[i][0].measure.pltscale = star[0][0].measure.pltscale;
+  }
+  ptr = skipNbounds (ptr, '|', 5, Nmax); // skip: sig_radec, glon, glat, elon, elat
+  star[0][0].measure.Xccd = strtod (ptr, NULL); // wx
+  ptr = nextWISEfield (ptr); // skip wx
+  star[0][0].measure.Yccd = strtod (ptr, NULL); // wy
+  ptr = nextWISEfield (ptr); // skip wy
+  for (i = 1; i < 4; i++) {
+      star[i][0].measure.Xccd    = star[0][0].measure.Xccd;
+      star[i][0].measure.Yccd    = star[0][0].measure.Yccd;
+  }
+  ptr = skipNbounds (ptr, '|', 4, Nmax); // skip: cntr, source_id, coadd_id, src
+  // W1
+  for (i = 0; i < 4; i++) {
+    char *endpoint;
+      star[i][0].measure.M  = strtod (ptr, &endpoint); // w?mpro
+      if (endpoint == ptr) {
+        star[i][0].measure.M  = NAN;
+      }
+      ptr = nextWISEfield (ptr);
+      star[i][0].measure.dM = strtod (ptr, &endpoint); // w?sigmpro
+      if (endpoint == ptr) {
+        star[i][0].measure.dM  = NAN;
+      }
+      ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: w?sigmpro, w?snr
+      star[i][0].measure.psfChisq = strtod (ptr, NULL); // w?rchi2
+      ptr = nextWISEfield (ptr); // skip : w1rchi2
+      // init the photFlags field
+      star[i][0].measure.photFlags = 0;
+  }
+  ptr = nextWISEfield (ptr); // skip: rchi2
+  // set blend flags for all 4 measures
+  setWISE_blend_flag (star, ptr); // nb & na both used here
+  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: nb, na
+  for (i = 0; i < 4; i++) {
+      setWISE_sat_flag (star[i], ptr); // w1sat
+      ptr = nextWISEfield (ptr);
+  }
+  ptr = nextWISEfield (ptr); // skip satnum
+  ptr = skipNbounds (ptr, '|', 15, Nmax); // skip pm info
+  for (i = 0; i < 4; i++) {
+      setWISE_cc_flag (star[i], ptr[i]); // cc_flags
+  }
+  ptr = nextWISEfield (ptr); // skip cc_flags
+  ptr = nextWISEfield (ptr); // skip rel
+  // set ext flags for all 4 measures
+  setWISE_ext_flag_allsky (star, ptr[0]); // ext_flg
+  ptr = nextWISEfield (ptr); // skip ext_flags
+  for (i = 0; i < 4; i++) {
+      setWISE_var_flag_allsky (star[i], ptr[i]); // var_flg
+  }
+  ptr = nextWISEfield (ptr); // skip var_flags
+  for (i = 0; i < 4; i++) {
+      setWISE_ph_qual (star[i], ptr[i]); // ph_qual
+  }
+  ptr = skipNbounds (ptr, '|', 158, Nmax); // skip: det_bit, moon_lev, w?nm, w?m, w?cov, etc, etc.
+  // w?frtr dropped, (-4), use_src, best_use_cntr, ngrp added (+3), w?dmag dropped, w?k added,
+  for (i = 0; i < 4; i++) {
+    ptr = skipNbounds (ptr, '|', 8, Nmax); // skip: w?magp, w?sigp1,2, w?dmag, w?ndf, w?m1q, w?mjdmin, w?mjdmax
+    // double mjdmin = strtod (ptr, NULL); // mjd min
+    // ptr = nextWISEfield (ptr); // skip
+    // double mjdmax = strtod (ptr, NULL); // mjd max
+    // ptr = nextWISEfield (ptr); // skip mjd max
+    double mjdmean = strtod (ptr, NULL); // mjd mean
+    ptr = nextWISEfield (ptr); // skip mjd mean
+    // fprintf (stderr, "w%d mjd: %f\n", i, mjdmean);
+    // the release is based on data taken in the period 14 January 2010 to 29 April 2010
+    if (mjdmean == 0.0) {
+      star[i][0].measure.t = 0;
+    } else {
+      star[i][0].measure.t = ohana_mjd_to_sec (mjdmean);
+    }
+  }
+  star[0][0].measure.photcode  = WISE_W1;
+  star[0][0].measure.detID   = 0;
+  star[0][0].measure.imageID = 0;
+  star[1][0].measure.photcode  = WISE_W2;
+  star[1][0].measure.detID   = 0;
+  star[1][0].measure.imageID = 0;
+  star[2][0].measure.photcode  = WISE_W3;
+  star[2][0].measure.detID   = 0;
+  star[2][0].measure.imageID = 0;
+  star[3][0].measure.photcode  = WISE_W4;
+  star[3][0].measure.detID   = 0;
+  star[3][0].measure.imageID = 0;
+  return TRUE;
+}
 // there are slight format differences between the prelim data dump and the allsky data dump:

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/mkcmf.c

-              r37036
+              r37822
 static Coords coords;
+static char reserved[] =  "Reserved space.  This line can be used to add a new FITS card.";
 int main (int argc, char **argv) {
 …
   /* bore site center guess */
   strcpy (coords.ctype, "DEC--TAN");
+  InitCoords (&coords, "DEC--TAN");
   coords.crval1 = RA;
   coords.crval2 = DEC;
 …
   coords.cdelt1 = 0.25/3600.0;
   coords.cdelt2 = 0.25/3600.0;
-  coords.pc1_1  = 1;
-  coords.pc2_2  = 1;
-  coords.pc1_2  = 0;
-  coords.pc2_1  = 0;
-  coords.Npolyterms = 1;
   // load stars and generate complete output fields
 …
   gfits_modify (&header, "NASTRO",   "%d", 1, 100);
   if (imageID == -1) imageID = 1000.0*drand48();
   if (sourceID == -1) sourceID = 100.0*drand48();
+  if (imageID == -1) imageID = 100000.0*drand48();
+  if (sourceID == -1) sourceID = 1000.0*drand48();
   gfits_modify (&header, "IMAGEID",  "%d", 1, imageID);
   gfits_modify (&header, "SOURCEID", "%d", 1, sourceID);
 …
   PutCoords (&coords, &header);
   gfits_modify (&header, "EXTNAME",   "%s", 1, exthead);
+  int i;
+  for (i = 1; i < 32; i++) {
+    gfits_modify_alt (&header, "COMMENT", "%C", i, reserved);
+  }
   ftable.header = &theader;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/resort_catalog.c

-              r37036
+              r37822
 void resort_catalog_measure (Catalog *catalog);
 void resort_catalog_lensing (Catalog *catalog);
+void resort_catalog_starpar (Catalog *catalog);
 void resort_catalog_old (Catalog *catalog) {
   off_t *next_meas;
   off_t Naves, Nmeas;
+  off_t *next_meas, *next_lens;
+  off_t Naves, Nmeas, Nlens;
   if (catalog[0].sorted == TRUE) return;
 …
   /* internal counters */
   Nmeas = catalog[0].Nmeasure;
+  Nlens = catalog[0].Nlensing;
   Naves = catalog[0].Naverage;
   /* set up pointers for linked list of measure, missing */
   next_meas = build_measure_links (catalog[0].average, Naves, catalog[0].measure, Nmeas);
+  next_lens = build_lensing_links (catalog[0].average, Naves, catalog[0].lensing, Nlens);
   catalog[0].sorted = TRUE;
   catalog[0].measure = sort_measure (catalog[0].average, Naves, catalog[0].measure, Nmeas, next_meas);
+  catalog[0].lensing = sort_lensing (catalog[0].average, Naves, catalog[0].lensing, Nlens, next_lens);
   MARKTIME ("  match time %9.4f sec for %7lld measures, %6lld average\n", dtime, (long long) Nmeas, (long long) Naves);
 …
   resort_catalog_measure (catalog);
   resort_catalog_lensing (catalog);
+  resort_catalog_starpar (catalog);
+}
 …
       myAssert(average[averageSeq[i]].catID == measure[measureSeq[i]].catID, "object / detection mismatch");
 # if (1)
+      myAssert(average[averageSeq[i]].objID == measure[measureSeq[i]].objID, "object / detection mismatch");
+      // myAssert(average[averageSeq[i]].objID == measure[measureSeq[i]].objID, "object / detection mismatch");
+      // check if the objID is correct. if not, check if it is byte-swapped (this has happened) and repair if so.
+      // otherwise, abort
+      if (average[averageSeq[i]].objID != measure[measureSeq[i]].objID) {
+        fprintf (stderr, "object / detection mismatch average.objID = %d, measure.objID = %d, catID: %d, detID: %d",
+                 average[averageSeq[i]].objID, measure[measureSeq[i]].objID,
+                 measure[measureSeq[i]].catID, measure[measureSeq[i]].detID);
+        int objIDalt = measure[measureSeq[i]].objID;
+        char *byte = (char *) &objIDalt;
+        char tmp;
+        tmp = byte[0]; byte[0] = byte[3]; byte[3] = tmp;
+        tmp = byte[1]; byte[1] = byte[2]; byte[2] = tmp;
+        if (average[averageSeq[i]].objID == objIDalt) {
+          fprintf (stderr, "objID is byte-swapped, repairing\n");
+          measure[measureSeq[i]].objID = average[averageSeq[i]].objID; // XXX I don't really like this...
+        } else if (measure[measureSeq[i]].objID == 0) {
+          fprintf (stderr, "objID is 0, repairing\n");
+          measure[measureSeq[i]].objID = average[averageSeq[i]].objID; // XXX I don't really like this...
+        } else {
+          myAbort ("objID is NOT byte-swapped, aborting\n");
+        }
+      }
 # else
       // for reasons I do not understand, the mini dvodbs generated on stsci1X had a handful of detections with an inconsistency between averef and objID.
 …
+}
+void resort_catalog_starpar (Catalog *catalog) {
+  off_t Naverage, Nstarpar;
+  StarPar *starpar;
+  Average *average;
+  off_t i, j, N, currentAve;
+  off_t *starparSeq = NULL;
+  off_t *averageSeq = NULL;
+  StarPar *starparTMP = NULL;
+  // struct timeval start, stop;
+  // gettimeofday (&start, NULL);
+  /* internal counters */
+  Nstarpar = catalog[0].Nstarpar;
+  Naverage = catalog[0].Naverage;
+  if (!Nstarpar) return;
+  starpar = catalog[0].starpar;
+  average = catalog[0].average;
+  // we have a table of average objects and an unsorted table of measurements.  each measurement
+  // has a reference to the average object sequence (as well as an ID)
+  // starpar[i].averef -> average[averef]
+  // starpar[i].objID = average[averef].objID
+  // starpar[i].catID = average[averef].catID
+  // we want a sorted starpar array with all averef entries in sequence
+  ALLOCATE (starparSeq, off_t,   Nstarpar);
+  ALLOCATE (averageSeq, off_t,   Nstarpar);
+  for (i = 0; i < Nstarpar; i++) {
+    starparSeq[i] = i;
+    averageSeq[i] = starpar[i].averef;
+    if (catalog[0].catformat >= DVO_FORMAT_PS1_V1) {
+      // earlier formats did not carry the objID or catID, so they are not available (we could assign on load, but we don't)
+      myAssert(average[averageSeq[i]].catID == starpar[starparSeq[i]].catID, "object / detection mismatch");
+# if (1)
+      myAssert(average[averageSeq[i]].objID == starpar[starparSeq[i]].objID, "object / detection mismatch");
+# else
+      // for reasons I do not understand, the mini dvodbs generated on stsci1X had a handful of detections with an inconsistency between averef and objID.
+      // this happened for 28 detections in the dbs on /data/stsci1?.0/eugene/dvo3pi.20130616, but not at all (as far as I know) in the rest of LAP DVO
+      if (average[averageSeq[i]].objID != starpar[starparSeq[i]].objID) {
+        fprintf (stderr, "R");
+        starpar[starparSeq[i]].objID = average[averageSeq[i]].objID; // XXX I don't really like this...
+      }
+# endif
+    }
+  }
+  // check that averageSeq is now in order
+  // for (i = 1; i < Nstarpar; i++) {
+  //   if (averageSeq[i] < averageSeq[i-1]) {
+  //     fprintf (stderr, "%d ", (int) i);
+  //   }
+  // }
+  // fprintf (stderr, "\n");
+  SortAveMatch(starparSeq, averageSeq, Nstarpar);
+  // MARKTIME("sort : %f sec\n", dtime);
+  // check that averageSeq is now in order
+  // for (i = 1; i < Nstarpar; i++) {
+  //   if (averageSeq[i] < averageSeq[i-1]) {
+  //     fprintf (stderr, "%d ", (int) i);
+  //   }
+  // }
+  // fprintf (stderr, "\n");
+  // copy the starpar entries in the sorted order
+  ALLOCATE (starparTMP, StarPar, Nstarpar);
+  for (i = 0; i < Nstarpar; i++) {
+    j = starparSeq[i];
+    starparTMP[i] = starpar[j];
+  }
+  // MARKTIME("assign starpar : %f sec\n", dtime);
+  // update the values of average.starparOffset and average.Nstarpar
+  FREE(starpar);
+  catalog[0].starpar = starparTMP;
+  N = 0;
+  currentAve = averageSeq[0];
+  average[currentAve].starparOffset = 0;
+  for (i = 0; i < Nstarpar; i++) {
+    if (averageSeq[i] != currentAve) {
+      // we have hit the next entry in the list
+      average[currentAve].Nstarpar = N;
+      N = 0;
+      currentAve = averageSeq[i];
+      average[currentAve].starparOffset = i;
+    }
+    N++;
+  }
+  // N++;
+  average[currentAve].Nstarpar = N;
+  // MARKTIME("update Nstarpar : %f sec\n", dtime);
+  int NstarparTotal = 0;
+  int starparOffsetOK = TRUE;
+  for (i = 0; i < Naverage; i++) {
+    NstarparTotal += catalog[0].average[i].Nstarpar;
+    if (VERBOSE && !(NstarparTotal <= catalog[0].Nstarpar)) {
+      fprintf (stderr, "too few starpar: %d %d %d\n", (int) i, NstarparTotal, (int) catalog[0].Nstarpar);
+    }
+    starparOffsetOK &= (catalog[0].average[i].starparOffset < catalog[0].Nstarpar);
+    if (VERBOSE && !(catalog[0].average[i].starparOffset < catalog[0].Nstarpar)) {
+      fprintf (stderr, "offset too large: %d %d %d\n", (int) i, catalog[0].average[i].Nstarpar, (int) catalog[0].Nstarpar);
+    }
+    starparOffsetOK &= (catalog[0].average[i].starparOffset + catalog[0].average[i].Nstarpar <= catalog[0].Nstarpar);
+    if (VERBOSE && !(catalog[0].average[i].starparOffset + catalog[0].average[i].Nstarpar <= catalog[0].Nstarpar)) {
+      fprintf (stderr, "orrset + Nstarpar too large: %d + %d > %d %d\n", (int) i, catalog[0].average[i].starparOffset, catalog[0].average[i].Nstarpar, (int) catalog[0].Nstarpar);
+    }
+  }
+  if (!starparOffsetOK) {
+    fprintf (stderr, "ERROR: catalog %s has an invalid starparOffset\n", catalog[0].filename);
+  }
+  if (NstarparTotal != catalog[0].Nstarpar) {
+    fprintf (stderr, "ERROR: catalog %s has an invalid Nstarpar\n", catalog[0].filename);
+  }
+  // MARKTIME("  match time %9.4f sec for %7lld starpars, %6lld average\n", dtime, (long long) Nstarpar, (long long) Naverage);
+  catalog[0].sorted = TRUE;
+  FREE (starparSeq);
+  FREE (averageSeq);
+  return;
+}
 // sort the measure or lensing Sequence based on the average Sequence entries
 void SortAveMatch (off_t *MEAS, off_t *AVE, off_t N) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/resort_threaded.c

-              r37036
+              r37822
   int iThread;
   int state;
   int nosort;
+  int forcesort;
   char *filename;
   SkyRegion *region;
 …
+    }
+    // chose the catalog file (local or remote?)
+    char hostfile[1024];
+    snprintf (hostfile, 1024, "%s/%s.cpt", HOSTDIR, threadData->region->name);
+    catalog.filename  = HOST_ID ? hostfile : threadData->filename;
     // set the parameters which guide catalog open/load/create
-    catalog.filename  = threadData->filename;
     catalog.catformat = dvo_catalog_catformat (CATFORMAT);  // set the default catformat from config data
     catalog.catmode   = dvo_catalog_catmode (CATMODE);      // set the default catmode from config data
 …
     // this is an overloaded value to mean 'force sort'
     if (threadData->nosort == 3) catalog.sorted = FALSE;
+    if (threadData->forcesort) catalog.sorted = FALSE;
     if (OLD_RESORT) {
 …
+}
 int resort_threaded (AddstarClientOptions *options, SkyTable *sky) {
+int resort_threaded (SkyList *skylist, int ForceSort) {
   int j, launched, done, Nwait, Nrun;
 …
   ThreadData *threadData;
   pthread_t *threads;
-  double dtime;
-  struct timeval start, stop;
-  gettimeofday (&start, NULL);
-  SkyList *skylist = SkyListByPatch (sky, -1, &UserPatch);
-  // in these cases, limit the sky catalogs to an existing subset
-  if (options->existing_regions) {
-    SkyList *tmp;
-    tmp = SkyListExistingSubset (skylist, CATDIR);
-    SkyListFree (skylist);
-    skylist = tmp;
+  }
-  if (VERBOSE) fprintf (stderr, "writing to "OFF_T_FMT" regions\n",  skylist[0].Nregions);
-  if (options->only_images) {
-    fprintf (stderr, "-image (only images) makes no sense with -resort\n");
-    exit (2);
+  }
-  if (options->only_match) {
-    fprintf (stderr, "-only-match makes no sense with -resort\n");
-    exit (2);
+  }
-  if (options->nosort == 1) {
-    fprintf (stderr, "-nosort makes no sense with -resort\n");
-    exit (2);
+  }
-  if (options->update) {
-    fprintf (stderr, "-update makes no sense with -resort\n");
-    exit (2);
+  }
-  if (options->calibrate) {
-    fprintf (stderr, "-cal (calibrate) makes no sense with -resort\n");
-    exit (2);
+  }
   ALLOCATE(threads, pthread_t, NTHREADS);
 …
   Naverage = Nmeasure = 0;
   for (i = 0; i < skylist[0].Nregions; i++) {
+    // does this host ID match the desired location for the table?
+    if (!HostTableTestHost(skylist[0].regions[i], HOST_ID)) continue;
     launched = FALSE;
 …
         if (threadData[j].state == TS_FAIL) goto failure;
         if (threadData[j].state != TS_WAIT) continue;
         threadData[j].nosort = options->nosort;
+        threadData[j].forcesort = ForceSort;
         threadData[j].filename = skylist[0].filename[i];
         threadData[j].region = skylist[0].regions[i];
 …
+  }
-  gettimeofday (&stop, NULL);
-  dtime = DTIME (stop, start);
-  fprintf (stderr, "SUCCESS: elapsed time %9.4f sec for, "OFF_T_FMT" average, "OFF_T_FMT" measure\n", dtime, Naverage, Nmeasure);
   // for (i = 0; i < NTHREADS; i++) {
   //   pthread_cancel(threads[i]);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/resort_unthreaded.c

-              r35142
+              r37822
 # include "addstar.h"
+int resort_unthreaded (AddstarClientOptions *options, SkyTable *sky, int hostID, char *hostpath) {
+// pass in options and skylist?
+int resort_unthreaded (SkyList *skylist, int ForceSort) {
+  double dtime;
+  struct timeval start, stop;
+  off_t i;
+  off_t Naverage, Nmeasure;
+  Catalog catalog;
+  gettimeofday (&start, NULL);
+  /* match stars to existing catalog data (or otherwise manipulate catalog data) */
+  Naverage = Nmeasure = 0;
+  for (i = 0; i < skylist[0].Nregions; i++) {
+  SkyList *skylist = SkyListByPatch (sky, -1, &UserPatch);
+  // in these cases, limit the sky catalogs to an existing subset
+  if (options->existing_regions) {
+    SkyList *tmp;
+    tmp = SkyListExistingSubset (skylist, CATDIR);
+    SkyListFree (skylist);
+    skylist = tmp;
+    // does this host ID match the desired location for the table?
+    if (!HostTableTestHost(skylist[0].regions[i], HOST_ID)) continue;
+    // chose the catalog file (local or remote?)
+    char hostfile[1024];
+    snprintf (hostfile, 1024, "%s/%s.cpt", HOSTDIR, skylist[0].regions[i]->name);
+    catalog.filename  = HOST_ID ? hostfile : skylist[0].filename[i];
+    // set the parameters which guide catalog open/load/create
+    catalog.catformat = dvo_catalog_catformat (CATFORMAT);  // set the default catformat from config data
+    catalog.catmode   = dvo_catalog_catmode (CATMODE);      // set the default catmode from config data
+    catalog.catflags  = LOAD_AVES | LOAD_MEAS | LOAD_LENSING;
+    catalog.Nsecfilt  = GetPhotcodeNsecfilt ();
+    // an error exit status here is a significant error (disk I/O or file access)
+    if (!dvo_catalog_open (&catalog, skylist[0].regions[i], VERBOSE, "w")) {
+      fprintf (stderr, "ERROR: failure to open/create catalog file %s\n", catalog.filename);
+      exit (2);
+    }
+    // Naves_disk == 0 implies an empty catalog file, skip empty catalogs
+    if (catalog.Naves_disk == 0) {
+      dvo_catalog_unlock (&catalog);
+      dvo_catalog_free (&catalog);
+      continue;
+    }
+    // this is an overloaded value to mean 'force sort'
+    if (ForceSort) catalog.sorted = FALSE;
+    if (OLD_RESORT) {
+      resort_catalog_old (&catalog);
+    } else {
+      resort_catalog (&catalog);
+    }
+    // report total updated values
+    Naverage += catalog.Naverage;
+    Nmeasure += catalog.Nmeasure;
+    // write out catalog, if appropriate
+    SetProtect (TRUE);
+    dvo_catalog_save (&catalog, VERBOSE);
+    SetProtect (FALSE);
+    dvo_catalog_unlock (&catalog);
+    dvo_catalog_free (&catalog);
+  }
-  if (VERBOSE) fprintf (stderr, "writing to "OFF_T_FMT" regions\n",  skylist[0].Nregions);
-  if (options->only_images) {
-    fprintf (stderr, "-image (only images) makes no sense with -resort\n");
-    exit (2);
+  }
-  if (options->only_match) {
-    fprintf (stderr, "-only-match makes no sense with -resort\n");
-    exit (2);
+  }
-  if (options->nosort == 1) {
-    fprintf (stderr, "-nosort makes no sense with -resort\n");
-    exit (2);
+  }
-  if (options->update) {
-    fprintf (stderr, "-update makes no sense with -resort\n");
-    exit (2);
+  }
-  if (options->calibrate) {
-    fprintf (stderr, "-cal (calibrate) makes no sense with -resort\n");
-    exit (2);
+  }
-  resort_unthreaded_catalogs (options, skylist, hostID, hostpath);
-  gettimeofday (&stop, NULL);
-  dtime = DTIME (stop, start);
-  fprintf (stderr, "SUCCESS: elapsed time %9.4f sec\n", dtime);
   return TRUE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/src/sky_tessalation.c

-              r36485
+              r37822
   memset (rectangle, 0, sizeof(SkyRectangle));
+  InitCoords (&rectangle[0].coords, "DEC--TAN");
   rectangle[0].coords.crval1 = CENTER_RA;
   rectangle[0].coords.crval2 = CENTER_DEC;
 …
   rectangle[0].coords.cdelt2 = SCALE / 3600.0;
-  strcpy (rectangle[0].coords.ctype, "DEC--TAN");
   rectangle[0].NX = NX;
   rectangle[0].NY = NY;
 …
   for (i = 0; i < nRA; i++) {
     memset (&ring[i], 0, sizeof(SkyRectangle));
+    memset (&ring[i].coords, 0, sizeof(Coords));
+    InitCoords (&ring[i].coords, "DEC--TAN");
     ring[i].coords.crval1 = i*dRA;
     ring[i].coords.crval2 = dec;
     ring[i].coords.pc1_1 = +1.0 * X_PARITY;
-    ring[i].coords.pc1_2 = +0.0;
-    ring[i].coords.pc2_1 = -0.0;
-    ring[i].coords.pc2_2 = +1.0;
     // range values are in projected degrees
 …
     ring[i].coords.cdelt1 = SCALE / 3600.0;
     ring[i].coords.cdelt2 = SCALE / 3600.0;
-    strcpy (ring[i].coords.ctype, "DEC--TAN");
     ring[i].NX = NX*(1.0 + PADDING);
 …
       memset (&ring[N], 0, sizeof(SkyRectangle));
       memset (&ring[N].coords, 0, sizeof(Coords));
+      InitCoords (&ring[N].coords, "DEC--TAN");
       ring[N].coords.crval1 = ra / d2r;
 …
       ring[N].coords.pc1_1 = +1.0 * X_PARITY;
-      ring[N].coords.pc1_2 = +0.0;
-      ring[N].coords.pc2_1 = -0.0;
-      ring[N].coords.pc2_2 = +1.0;
       // range values are in projected degrees
 …
       ring[N].coords.cdelt1 = SCALE / 3600.0;
       ring[N].coords.cdelt2 = SCALE / 3600.0;
-      strcpy (ring[N].coords.ctype, "DEC--TAN");
       ring[N].NX = NX*(1.0 + PADDING);
 …
   ALLOCATE (refcoords, Coords, 1);
+  refcoords[0].crval1 = refcoords[0].crval2 = 0.0;
+  refcoords[0].crpix1 = refcoords[0].crpix2 = 0.0;
+  InitCoords (refcoords, "DEC--TAN");
   refcoords[0].cdelt1 = refcoords[0].cdelt2 = scale / 3600;
-  refcoords[0].pc1_1 = refcoords[0].pc2_2 = 1.0;
-  refcoords[0].pc1_2 = refcoords[0].pc2_1 = 0.0;
-  refcoords[0].Npolyterms = 0;
-  memset (refcoords[0].polyterms, 0, 14*sizeof(float));
-  strcpy (refcoords[0].ctype, "DEC--TAN");
   return (TRUE);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/addstar/test/relphot.parallel.dvo

-              r33653
+              r37822
   if (not($?VERBOSE)) set VERBOSE = 0
+  # images are loaded into dvo with GPC1 photcodes, so we need to get the nominal zps for those filters
+  $zpt_nominal:g = 24.58
+  $zpt_nominal:r = 24.80
+  $zpt_nominal:i = 24.74
+  $zpt_nominal:z = 24.26
+  $zpt_nominal:y = 23.41
+  # klam is negative, so klam*(airmass - 1) increase the zero point
+  $klam_nominal:g = -0.15
+  $klam_nominal:r = -0.10
+  $klam_nominal:i = -0.04
+  $klam_nominal:z = -0.03
+  $klam_nominal:y = -0.03
+# images are loaded into dvo with GPC1 photcodes, so we need to get the nominal zps for those filters
+# $zpt_nominal:g = 24.58
+# $zpt_nominal:r = 24.80
+# $zpt_nominal:i = 24.74
+# $zpt_nominal:z = 24.26
+# $zpt_nominal:y = 23.41
+# klam is negative, so klam*(airmass - 1) increase the zero point
+# $klam_nominal:g = -0.15
+# $klam_nominal:r = -0.10
+# $klam_nominal:i = -0.04
+# $klam_nominal:z = -0.03
+# $klam_nominal:y = -0.03
+  $zpt_nominal:g = 24.563; $klam_nominal:g = -0.147
+  $zpt_nominal:r = 24.750; $klam_nominal:r = -0.085
+  $zpt_nominal:i = 24.611; $klam_nominal:i = -0.044
+  $zpt_nominal:z = 24.250; $klam_nominal:z = -0.033
+  $zpt_nominal:y = 23.320; $klam_nominal:y = -0.073
   # we have two sets of images: ubercaled and not-ubercaled
 …
   mksequence $fileroot $catdir
   for i 0 mjd_nc[]
     ckexposure $catdir mjd_nc[$i] zpt_nc[$i] exptime_nc[$i] airmass_nc[$i] $filt_nc:$i raw
+    ckexposure $catdir mjd_nc[$i] zpt_nc[$i] exptime_nc[$i] airmass_nc[$i] $filt_nc:$i raw 0
   end
 …
   # run relphot on the serial db and check that the images now match the expected values
   exec relphot g,r,i -v -region 9.5 10.5 19.5 20.5 -D CATDIR $catdir -D STAR_TOOFEW 1 -D SIGMA_LIM 0.07 -statmode WT_MEAN -cloud-limit 0.5 -keep-ubercal -D IMAGE_OFFSET 0.5 -update >& log.relphot.s0
+  exec relphot -images g,r,i -v -region 9.5 10.5 19.5 20.5 -D CATDIR $catdir -D STAR_TOOFEW 1 -D SIGMA_LIM 0.07 -statmode WT_MEAN -cloud-limit 0.5 -D IMAGE_OFFSET 0.5 -update >& log.relphot.s0
   for i 0 mjd_nc[]
 …
     # matching the mean zp of photometric data, which we calculate in
     # 'init'
     ckexposure $catdir mjd_nc[$i] $zpt_nc_$filt_nc:$i exptime_nc[$i] airmass_nc[$i] $filt_nc:$i relphot_nc
+    ckexposure $catdir mjd_nc[$i] $zpt_nc_$filt_nc:$i exptime_nc[$i] airmass_nc[$i] $filt_nc:$i relphot_nc 0
   end
   # run relphot on the parallel db and check that the images now match the expected values
+  exec relphot -parallel g,r,i -v -region 9.5 10.5 19.5 20.5 -D CATDIR $catdir.p0 -D STAR_TOOFEW 1 -D SIGMA_LIM 0.07 -statmode WT_MEAN -cloud-limit 0.5 -keep-ubercal -D IMAGE_OFFSET 0.5 -update >& log.relphot.p0
+  exec dvodist -in $catdir.p0 >& log.dvodist.in
+  exec relphot -images -parallel g,r,i -v -region 9.5 10.5 19.5 20.5 -D CATDIR $catdir.p0 -D STAR_TOOFEW 1 -D SIGMA_LIM 0.07 -statmode WT_MEAN -cloud-limit 0.5 -D IMAGE_OFFSET 0.5 -update >& log.relphot.p0
   for i 0 mjd_nc[]
 …
     # matching the mean zp of photometric data, which we calculate in
     # 'init'
     ckexposure $catdir.p0 mjd_nc[$i] $zpt_nc_$filt_nc:$i exptime_nc[$i] airmass_nc[$i] $filt_nc:$i relphot_nc
+    ckexposure $catdir.p0 mjd_nc[$i] $zpt_nc_$filt_nc:$i exptime_nc[$i] airmass_nc[$i] $filt_nc:$i relphot_nc 1
   end
 …
 macro ckexposure
   if ($0 != 8)
     echo "ckexposure (catdir) (mjd) (zpt) (exptime) (airmass) (filter) (mode)"
+  if ($0 != 9)
+    echo "ckexposure (catdir) (mjd) (zpt) (exptime) (airmass) (filter) (mode) (isParallel)"
     echo "  mode == raw or corr"
     break
 …
   $FILTER      = $6
   $MODE        = $7
+  $PARALLEL    =
+  if ($8)
+    $PARALLEL = "-parallel"
+  end
   # XXX need a function to extract the nominal zpt for a given filter / photcode from the db
 …
   skyregion {$RA_CENTER - 0.2/dcos($DEC_CENTER)} {$RA_CENTER + 0.2/dcos($DEC_CENTER)} {$DEC_CENTER - 0.2} {$DEC_CENTER + 0.2}
   mextract ra dec mag xccd yccd where (abs(time - $MJD_IMAGE) < 0.0001)
+  mextract $PARALLEL ra dec mag xccd yccd where (abs(time - $MJD_IMAGE) < 0.0001)
   if (not(ra[]))
     echo "no matching data for MJD = $MJD_IMAGE"
 …
     # the fake images have inconsistent ra,dec and airmass,sidtime values
     if ($VERBOSE) echo addstar $ROOT.$ix.$iy.cmf -D CATDIR $CATDIR -D CAMERA gpc1 -quick-airmass
     exec addstar $ROOT.$ix.$iy.cmf -D CATDIR $CATDIR -D CAMERA gpc1 -quick-airmass >& /dev/null
+    exec addstar $ROOT.$ix.$iy.cmf -D CATDIR $CATDIR -D CAMERA gpc1 -quick-airmass >& log.addstar
     # costs 10/36 sec / chip
   end
 …
   $catdir = $tmp1/$tmp2
+  if ($VERBOSE) echo rsync -auv $catdir/ $catdir.p0/
   exec rsync -auv $catdir/ $catdir.p0/ >& log.rsync
   mkdir $catdir.d1
 …
   exec echo "3 $hostname $catdir.d3" >> $catdir.p0/HostTable.dat
+  if ($VERBOSE) echo dvodist -out $catdir.p0
   exec dvodist -out $catdir.p0 >& log.dvodist.out
 end

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/checkastro/src/ImageOps.c

-              r36833
+              r37822
+  }
-  BuildChipMatch (image, Nimage);
   char output[128];
   snprintf (output, 128, "checkastrom.%+3.0f.%+3.0f.%03.0f.%03.0f.dat", UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
 …
     name = GetPhotcodeNamebyCode (image[i].photcode);
-    off_t myMosaic = FindMosaicForImage (image, Nimage, i);
     /* only check exposure center */
     double Rexp = NAN, Dexp = NAN, Rccd = NAN, Dccd = NAN;
+    if (myMosaic) {
+      myMosaic --;
+      XY_to_RD (&Rccd, &Dccd, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
+      XY_to_RD (&Rexp, &Dexp, 0.0, 0.0, &image[myMosaic].coords);
+    }
+    XY_to_RD (&Rccd, &Dccd, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
+    XY_to_RD (&Rexp, &Dexp, 0.0, 0.0, &image[i].parent->coords);
     char *date = ohana_sec_to_date(image[i].tzero);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/checkastro/src/bcatalog.c

-              r36833
+              r37822
   /* project coordinates to a plane centered on the object with units of arcsec */
   Coords coords;
+  InitCoords (&coords, "DEC--SIN");
   coords.crval1 = Rc;
   coords.crval2 = Dc;
-  coords.crpix1 = 0;
-  coords.crpix2 = 0;
   coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
-  coords.pc1_1  = coords.pc2_2 = 1.0;
-  coords.pc1_2  = coords.pc2_1 = 0.0;
-  coords.Npolyterms = 1;
-  strcpy (coords.ctype, "DEC--SIN");
   // convert all average R,D values to X,Y:

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/checkastro/src/load_images.c

r36833	r37822
17	17	MARKTIME(" convert image table: %f sec\n", dtime);
18	18
	19	BuildChipMatch (image, Nimage);
	20
19	21	// select the images which overlap the selected sky regions
20	22	subset = select_images (skylist, image, Nimage, &LineNumber, &Nsubset);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/checkastro/src/select_images.c

-              r36833
+              r37822
   if (VERBOSE) fprintf (stderr, "finding images\n");
-  BuildChipMatch (timage, Ntimage);
-  MARKTIME("build chip match: %f sec\n", dtime);
   nimage = 0;
 …
+    }
-    // this adds 1.3 sec for 3M images
-    off_t myMosaic = FindMosaicForImage (timage, Ntimage, i);
-    if (!myMosaic) {
-      fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i);
-      continue;
+    }
-    myMosaic --;
     /* only check exposure center */
     if (!strcmp(&timage[i].coords.ctype[4], "-DIS")) {
       XY_to_RD (&Rexp, &Dexp, 0.0, 0.0, &timage[i].coords);
     } else {
       XY_to_RD (&Rexp, &Dexp, 0.0, 0.0, &timage[myMosaic].coords);
+      XY_to_RD (&Rexp, &Dexp, 0.0, 0.0, &timage[i].parent->coords);
+    }
     Rexp = ohana_normalize_angle_to_midpoint (Rexp, RmidSkyRegion);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/delstar/src/ImageOpsFixLAP.c

-              r37040
+              r37822
     if ((Nimage_valid[i] + Nimage_invalid[i] == 0) || (found_ratio < 0.995)) {
       double r, d;
       if (!FindMosaicForImage (image, Nimage, i)) {
         fprintf (stderr, "failed to get astrometry for %s\n", image[i].name);
+      if (!strcmp(&image[i].coords.ctype[4], "-DIS")) {
+        XY_to_RD (&r, &d, 0.0, 0.0, &image[i].coords);
       } else {
+        if (!strcmp(&image[i].coords.ctype[4], "-DIS")) {
+          XY_to_RD (&r, &d, 0.0, 0.0, &image[i].coords);
+        } else {
+          XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
+        }
+        XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
+      }
       char *date = ohana_sec_to_date (image[i].tzero);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/delstar/src/delete_duplicate_measures.c

-              r35758
+              r37822
+    }
+    delete_duplicate_measures_catalog (&catalog);
+    if (UPDATE) {
+      // XXX skip if nothing was deleted
+      dvo_catalog_save_complete (&catalog, VERBOSE2);
+    if (delete_duplicate_measures_catalog (&catalog)) {
+      // skip if nothing was deleted
+      if (UPDATE) {
+        if (!dvo_catalog_backup (&catalog, TRUE)) {
+          fprintf (stderr, "ERROR: failed to make backup for catalog %s\n", catalog.filename);
+          exit (1);
+        }
+        dvo_catalog_save_complete (&catalog, VERBOSE2);
+      }
+    }
 …
     measureDrop[j] = TRUE;
     off_t N = measure[j].averef;
     fprintf (stderr, "0x%08x 0x%08x %8.4f %8.4f %5d\n", measure[j].imageID, measure[j].detID, average[N].R, average[N].D, measure[j].photcode);
+    if (VERBOSE) fprintf (stderr, "0x%08x 0x%08x %8.4f %8.4f %5d\n", measure[j].imageID, measure[j].detID, average[N].R, average[N].D, measure[j].photcode);
+  }
 …
   off_t NdelAves = Naverage - catalog[0].Naverage;
   off_t NdelMeas = Nmeasure - catalog[0].Nmeasure;
   if (NdelAves || NdelMeas) {
     fprintf (stderr, "deleting "OFF_T_FMT" measures and "OFF_T_FMT" averages : %s\n",  NdelMeas, NdelAves, catalog[0].filename);
 …
   FREE (measureAveOut);
+  return TRUE;
+  if (NdelAves || NdelMeas) return TRUE;
+  return FALSE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/delstar/src/delete_imagename.c

-              r34749
+              r37822
+  }
+  BuildChipMatch (image, Nimage);
   /* find image in db by name */
   imlist = find_images_name (db, IMAGENAME, &Nimlist);
 …
     if (VERBOSE) fprintf (stderr, "deleting %s\n", image[j].name);
-    // XXX EAM : need to handle failure
-    FindMosaicForImage (image, Nimage, j);
     skylist = SkyListByImage (sky, -1, &image[j]);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/delstar/src/delete_times.c

-              r29001
+              r37822
+  }
+  BuildChipMatch (image, Nimage);
   /* find images for time range, delete each image */
   imlist = find_images_time (db, START, END, PHOTCODE, &Nimlist);
 …
     if (VERBOSE) fprintf (stderr, "finding regions for %s\n", image[j].name);
-    // XXX EAM : need to handle failure
-    FindMosaicForImage (image, Nimage, j);
     skyset = SkyListByImage (sky, -1, &image[j]);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/Makefile

-              r35416
+              r37822
 dvoverify_client : $(BIN)/dvoverify_client.$(ARCH)
+all: dvomerge dvomerge_client dvoconvert dvosecfilt dvosecfilt_client dvoverify dvoverify_client
+dvoutils        : $(BIN)/dvoutils.$(ARCH)
+all: dvomerge dvomerge_client dvoconvert dvosecfilt dvosecfilt_client dvorepair dvoverify dvoverify_client dvoutils
 #  $(SRC)/dvomergeContinue.$(ARCH).o
 …
 $(SRC)/dvorepairImagesVsMeasures.$(ARCH).o \
 $(SRC)/dvorepairDeleteImageList.$(ARCH).o \
+$(SRC)/dvorepairDeleteImagesByExternID.$(ARCH).o \
+$(SRC)/dvorepairDeleteImagesByExternID.$(ARCH).o \
 $(SRC)/dvorepairFixImages.$(ARCH).o \
 $(SRC)/psps_ids.$(ARCH).o \
 $(SRC)/LoadImages.$(ARCH).o \
 $(SRC)/ReadDeleteList.$(ARCH).o \
+$(SRC)/ReadDeleteListExternID.$(ARCH).o \
+$(SRC)/myIndex.$(ARCH).o \
 $(SRC)/match_image.$(ARCH).o \
 $(SRC)/help.$(ARCH).o \
 …
 $(BIN)/dvoverify_client.$(ARCH) : $(DVOVERIFY_CLIENT)
+INSTALL = dvomerge dvomerge_client dvoconvert dvosecfilt dvosecfilt_client dvorepair dvoverify dvoverify_client
+DVOUTILS = \
+$(SRC)/dvoutils.$(ARCH).o \
+$(SRC)/dvoutils_args.$(ARCH).o \
+$(SRC)/dvoutils_uniq_images.$(ARCH).o \
+$(SRC)/dvoutils_load_image_index.$(ARCH).o
+$(DVOUTILS)  : $(INC)/dvoutils.h
+$(BIN)/dvoutils.$(ARCH) : $(DVOUTILS)
+INSTALL = dvomerge dvomerge_client dvoconvert dvosecfilt dvosecfilt_client dvorepair dvoverify dvoverify_client dvoverify
 # dependancy rules for binary code #########################

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/include/dvomerge.h

-              r35765
+              r37822
 int    REPLACE_BY_PHOTCODE;
 int    FORCE_MERGE;
+char  *UPDATE_CATFORMAT;
+int    MATCHED_TABLES;
 char *SINGLE_CPT;
 SkyRegion UserPatch;  // used by MODE CAT
+# ifndef MAX_INT
+# define MAX_INT 2147483647
+# endif
+typedef struct {
+  int minID;
+  int maxID;
+  int *index;
+  int Nindex;
+  int NINDEX;
+} myIndexType;
 typedef struct {
 …
 int        merge_catalogs_old     PROTO((SkyRegion *region, Catalog *output, Catalog *input, double RADIUS, int *secflitMap));
+off_t     *build_measure_links    PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
 off_t     *init_measure_links     PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
+int        add_meas_link          PROTO((Average *average, off_t *next, off_t Nmeasure, off_t NMEASURE));
+Measure   *sort_measure           PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next));
+off_t     *build_lensing_links    PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing));
+off_t     *init_lensing_links     PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing));
+int        add_lens_link          PROTO((Average *average, off_t *next, off_t Nlensing, off_t NLENSING));
+Lensing   *sort_lensing           PROTO((Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next));
+off_t     *build_starpar_links    PROTO((Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar));
+off_t     *init_starpar_links     PROTO((Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar));
+int        add_star_link          PROTO((Average *average, off_t *next, off_t Nstarpar, off_t NSTARPAR));
+StarPar   *sort_starpar           PROTO((Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar, off_t *next));
 off_t     *init_missing_links     PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing));
-off_t     *build_measure_links    PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
-int        add_meas_link          PROTO((Average *average, off_t *next, off_t Nmeasure, off_t NMEASURE));
 int        add_miss_link          PROTO((Average *average, off_t *next, off_t Nmissing));
-Measure   *sort_measure           PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next));
 Missing   *sort_missing           PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss));
 …
 int dvoCreateID (char *catdir);
+myIndexType *myIndexInit ();
+int myIndexFree (myIndexType *myIndex);
+int myIndexUpdateLimits (myIndexType *myIndex, int value);
+int myIndexSetRange (myIndexType *myIndex);
+int myIndexSetEntry (myIndexType *myIndex, int value, int entry);
+int myIndexGetEntry (myIndexType *myIndex, int value);
+int dvorepairDeleteImagesByExternID (int argc, char **argv);
+int RepairTableCPT_V1(char *cptFilenameSrc, char *cptFilenameTgt, char *cpsFilenameSrc, char *cpsFilenameTgt, Measure *measure, off_t Nmeasure, Image *image, off_t Nimage, myIndexType *imageIDindex, char catformat);
+int *ReadDeleteListExternID(char *filename, int *nindex);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/include/dvoverify.h

r34405	r37822
56	56	int LoadImageIDs (char *catdir);
57	57	int CheckImageID (Catalog *catalog);
	58
	59	int SaveImageIDsSmall(char *filename);
	60	int LoadImageIDsSmall (char *filename);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/ImageOps.c

r29938	r37822
18	18	}
19	19	if (m == -1) return (NULL);
20		~~if (!FindMosaicForImage (image, Nimage, m)) return (NULL);~~
21	20	return (&image[m]);
22	21	}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/LoadCatalog.c

r29938	r37822
8	8
9	9	// always load all of the data (if any exists)
10		catalog[0].catflags = LOAD_AVES \| LOAD_MEAS \| LOAD_MISS \| LOAD_SECF;
	10	catalog[0].catflags = LOAD_AVES \| LOAD_MEAS \| LOAD_MISS \| LOAD_SECF \| LOAD_LENSING \| LOAD_LENSOBJ \| LOAD_STARPAR;
11	11
12	12	catalog[0].catformat = dvo_catalog_catformat (CATFORMAT); // set the default catformat from config data

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/args.c

-              r35765
+              r37822
+  }
+  /* extra error messages */
+  MATCHED_TABLES = FALSE;
+  if ((N = get_argument (*argc, argv, "-matched-tables"))) {
+    MATCHED_TABLES = TRUE;
+    remove_argument (N, argc, argv);
+  }
   /* use a different photcode file to define mean values */
   if ((N = get_argument (*argc, argv, "-photcode-file"))) {
 …
   if ((N = get_argument (*argc, argv, "-force-merge"))) {
     FORCE_MERGE = TRUE;
+    remove_argument (N, argc, argv);
+  }
+  UPDATE_CATFORMAT = NULL;
+  if ((N = get_argument (*argc, argv, "-update-catformat"))) {
+    remove_argument (N, argc, argv);
+    UPDATE_CATFORMAT = strcreate (argv[N]);
     remove_argument (N, argc, argv);
+  }
 …
+  }
+  /* extra error messages */
+  MATCHED_TABLES = FALSE;
+  if ((N = get_argument (*argc, argv, "-matched-tables"))) {
+    MATCHED_TABLES = TRUE;
+    remove_argument (N, argc, argv);
+  }
   /* replace measurement, don't duplicate */
   REPLACE_BY_PHOTCODE = FALSE;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/build_links.c

-              r27435
+              r37822
 # include "dvomerge.h"
+/*
+There are two modes for the measure table: sorted and unsorted.
+In sorted mode, all measures associated with a given average are in a single block.  The block
+is pointed to by average->measureOffset and the range is average->Nmeasure
+In unsorted mode, it is not possible to go directly from average to measure without scanning.
+In this case, it is necessary to use the value measure->averef to find the corresponding
+average entry.
+Note that average->measureOffset and measure->averef are only valid for a given load of the
+data: they refer to the sequence number in the data blocks.
+next_meas is a list of the equivalent sequence of the measure block as if it were sorted.
+to find the sequence of measurements for a given average:
+n_0 = average->measureOffset
+n_1 = next_meas[n_0]
+n_i = next_meas[n_i-1]
+*/
 /* build the initial links assuming the table is sorted,
 …
   off_t i, j, N;
   off_t *next;
+  off_t *next_meas;
   N = 0;
   ALLOCATE (next, off_t, Nmeasure);
+  ALLOCATE (next_meas, off_t, Nmeasure);
   for (i = 0; i < Naverage; i++, N++) {
     for (j = 0; j < average[i].Nmeasure - 1; j++, N++) {
       next[N] = N + 1;
+      next_meas[N] = N + 1;
       if (N >= Nmeasure) {
         fprintf (stderr, "WARNING: N out of bounds (1)\n");
+      }
+    }
     next[N] = -1;
+    next_meas[N] = -1;
     if (N >= Nmeasure) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
 …
+    }
+  }
+  return (next);
+}
+/* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
+int add_meas_link (Average *average, off_t *next, off_t Nmeasure, off_t NMEASURE) {
+  off_t k, m;
+  /* if we have trouble, check validity of next[m] : m < Nmeasure */
+  m = average[0].measureOffset;
+  for (k = 0; k < average[0].Nmeasure - 1; k++)  {
+    m = next[m];
+    if (m >= NMEASURE) {
+      fprintf (stderr, "WARNING: m out of bounds (3)\n");
+    }
+  }
+  /* set up references */
+  next[Nmeasure] = -1;
+  if (Nmeasure >= NMEASURE) {
+    fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
+  }
+  if (m == -1) {
+    average[0].measureOffset = Nmeasure;
+  } else {
+    next[m] = Nmeasure;
+    if (m >= NMEASURE) {
+      fprintf (stderr, "WARNING: m out of bounds (4)\n");
+    }
+  }
+  return (TRUE);
+}
+Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next) {
+  off_t i, k, n, N;
+  Measure *tmpmeasure;
+  /* fix order of Measure (memory intensive, but fast) */
+  N = 0;
+  ALLOCATE (tmpmeasure, Measure, Nmeasure);
+  for (i = 0; i < Naverage; i++) {
+    n = average[i].measureOffset;
+    average[i].measureOffset = N;
+    for (k = 0; k < average[i].Nmeasure; k++, N++) {
+      tmpmeasure[N] = measure[n];
+      tmpmeasure[N].averef = i;
+      n = next[n];
+    }
+  }
+  free (measure);
+  return (tmpmeasure);
+  return (next_meas);
+}
 …
   off_t i, m, k, Nm, averef;
   off_t *next;
   ALLOCATE (next, off_t, Nmeasure);
+  off_t *next_meas;
+  ALLOCATE (next_meas, off_t, Nmeasure);
   /* reset the Nm, offset values for average */
 …
     averef = measure[Nm].averef;
     m = average[averef].measureOffset;
     next[Nm] = -1;
+    next_meas[Nm] = -1;
     if (m == -1) { /* no links yet for source */
 …
+    }
     for (k = 0; next[m] != -1; k++) {
       m = next[m];
+    for (k = 0; next_meas[m] != -1; k++) {
+      m = next_meas[m];
       if (m >= Nmeasure) {
         fprintf (stderr, "WARNING: m out of bounds (1)\n");
 …
     average[averef].Nmeasure = k + 2;
     next[m] = Nm;
+    next_meas[m] = Nm;
     if (m >= Nmeasure) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
+    }
+  }
+  return (next);
+}
+  return (next_meas);
+}
+/* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
+int add_meas_link (Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE) {
+  off_t k, m;
+  /* if we have trouble, check validity of next_meas[m] : m < Nmeasure */
+  m = average[0].measureOffset;
+  for (k = 0; k < average[0].Nmeasure - 1; k++)  {
+    m = next_meas[m];
+    if (m >= NMEASURE) {
+      fprintf (stderr, "WARNING: m out of bounds (3)\n");
+    }
+  }
+  /* set up references */
+  next_meas[Nmeasure] = -1;
+  if (Nmeasure >= NMEASURE) {
+    fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
+  }
+  if (m == -1) {
+    average[0].measureOffset = Nmeasure;
+  } else {
+    next_meas[m] = Nmeasure;
+    if (m >= NMEASURE) {
+      fprintf (stderr, "WARNING: m out of bounds (4)\n");
+    }
+  }
+  return (TRUE);
+}
+Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas) {
+  off_t i, k, n, N;
+  Measure *tmpmeasure;
+  /* fix order of Measure (memory intensive, but fast) */
+  N = 0;
+  ALLOCATE (tmpmeasure, Measure, Nmeasure);
+  for (i = 0; i < Naverage; i++) {
+    n = average[i].measureOffset;
+    average[i].measureOffset = N;
+    for (k = 0; k < average[i].Nmeasure; k++, N++) {
+      if (n == -1) abort();
+      tmpmeasure[N] = measure[n];
+      if (measure[n].averef != i) abort();
+      tmpmeasure[N].averef = i;
+      n = next_meas[n];
+    }
+  }
+  free (measure);
+  return (tmpmeasure);
+}
+/*******************************************************************************************/
 /* build the initial links assuming the table is sorted */
 …
   off_t i, j, N;
   off_t *next;
+  off_t *next_miss;
   N = 0;
   ALLOCATE (next, off_t, Nmissing);
+  ALLOCATE (next_miss, off_t, Nmissing);
   for (i = 0; i < Naverage; i++) {
     for (j = 0; j < average[i].Nmissing - 1; j++, N++) {
       next[N] = N + 1;
+      next_miss[N] = N + 1;
+    }
     if (average[i].Nmissing > 0) {
       next[N] = -1;
+      next_miss[N] = -1;
       if (N >= Nmissing) {
         fprintf (stderr, "overflow in init_missing_links");
 …
+  }
   return (next);
+}
 int add_miss_link (Average *average, off_t *next, off_t Nmissing) {
+  return (next_miss);
+}
+int add_miss_link (Average *average, off_t *next_miss, off_t Nmissing) {
   off_t k, m;
 …
   if (average[0].Nmissing < 1) {
     average[0].missingOffset = Nmissing;
     next[Nmissing] = -1;
+    next_miss[Nmissing] = -1;
     return (TRUE);
+  }
   m = average[0].missingOffset;
   for (k = 0; k < average[0].Nmissing - 1; k++) m = next[m];
+  for (k = 0; k < average[0].Nmissing - 1; k++) m = next_miss[m];
   /* set up references */
   next[Nmissing] = -1;
   next[m] = Nmissing;
+  next_miss[Nmissing] = -1;
+  next_miss[m] = Nmissing;
   return (TRUE);
+}
 …
    we must always save the missing table, if it exists */
 Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next) {
+Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss) {
   off_t i, k, n, N;
 …
     for (k = 0; k < average[i].Nmissing; k++, N++) {
       tmpmissing[N] = missing[n];
       n = next[n];
+      n = next_miss[n];
+    }
+  }
 …
   return (tmpmissing);
+}
+/*******************************************************************************************/
+/* build the initial links assuming the table is sorted,
+   not partial, and has a correct set of average[].lensingOffset,Nlensing values */
+off_t *init_lensing_links (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing) {
+  off_t i, j, N;
+  off_t *next_lens;
+  N = 0;
+  ALLOCATE (next_lens, off_t, Nlensing);
+  for (i = 0; i < Naverage; i++) {
+    if (!average[i].Nlensing) continue;
+    off_t m = average[i].lensingOffset;
+    myAssert (lensing[m].averef == i, "not sorted");
+    for (j = 0; j < average[i].Nlensing - 1; j++, N++) {
+      myAssert (lensing[m+j+1].averef == i, "not sorted");
+      next_lens[N] = N + 1;
+      if (N >= Nlensing) {
+        fprintf (stderr, "WARNING: N out of bounds (1)\n");
+      }
+    }
+    next_lens[N] = -1;
+    if (N >= Nlensing) {
+      fprintf (stderr, "WARNING: N out of bounds (2)\n");
+    }
+    if (N >= Nlensing) {
+      fprintf (stderr, "overflow in init_lensing_links\n");
+      abort ();
+    }
+    N++;
+  }
+  return (next_lens);
+}
+/* construct lensing links which are valid FOR THIS LOAD
+ * - if we have a full load, we will get links which can
+ *   be used by other programs (eg, relphot, etc)
+ * - if we have a partial load, the links are only valid
+ *   for that partial load
+ */
+off_t *build_lensing_links (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing) {
+  off_t i, m, k, Nm, averef;
+  off_t *next_lens;
+  ALLOCATE (next_lens, off_t, Nlensing);
+  /* reset the Nm, offset values for average */
+  for (i = 0; i < Naverage; i++) {
+    average[i].lensingOffset = -1;
+    average[i].Nlensing     =  0;
+  }
+  for (Nm = 0; Nm < Nlensing; Nm++) {
+    averef = lensing[Nm].averef;
+    m = average[averef].lensingOffset;
+    next_lens[Nm] = -1;
+    if (m == -1) { /* no links yet for source */
+      average[averef].lensingOffset = Nm;
+      average[averef].Nlensing     = 1;
+      continue;
+    }
+    for (k = 0; next_lens[m] != -1; k++) {
+      m = next_lens[m];
+      if (m >= Nlensing) {
+        fprintf (stderr, "WARNING: m out of bounds (1)\n");
+      }
+    }
+    average[averef].Nlensing = k + 2;
+    next_lens[m] = Nm;
+    if (m >= Nlensing) {
+      fprintf (stderr, "WARNING: m out of bounds (2)\n");
+    }
+  }
+  return (next_lens);
+}
+/* average[].lensingOffset, average[].Nlensing are valid within an addstar run */
+int add_lens_link (Average *average, off_t *next_lens, off_t Nlensing, off_t NLENSING) {
+  off_t k, m;
+  /* if we have trouble, check validity of next_lens[m] : m < Nlensing */
+  m = average[0].lensingOffset;
+  for (k = 0; k < average[0].Nlensing - 1; k++)  {
+    m = next_lens[m];
+    if (m >= NLENSING) {
+      fprintf (stderr, "WARNING: m out of bounds (3)\n");
+    }
+  }
+  /* set up references */
+  next_lens[Nlensing] = -1;
+  if (Nlensing >= NLENSING) {
+    fprintf (stderr, "WARNING: Nlensing out of bounds (1)\n");
+  }
+  // if Nlensing is 0, m may have been mis-set; add to the end
+  if ((average[0].Nlensing == 0) || (m == -1)) {
+    average[0].lensingOffset = Nlensing;
+  } else {
+    next_lens[m] = Nlensing;
+    if (m >= NLENSING) {
+      fprintf (stderr, "WARNING: m out of bounds (4)\n");
+    }
+  }
+  return (TRUE);
+}
+Lensing *sort_lensing (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next_lens) {
+  off_t i, k, n, np, N;
+  Lensing *tmplensing;
+  /*
+  for (i = 0; i < Naverage; i++) {
+    if (average[i].Nlensing != 4) {
+      fprintf (stderr, "check %d %d %d\n", (int) i, (int) average[i].Nlensing, (int) average[i].lensingOffset);
+    }
+  }
+  */
+  /* fix order of Lensing (memory intensive, but fast) */
+  np = -1;
+  N = 0;
+  ALLOCATE (tmplensing, Lensing, Nlensing);
+  for (i = 0; i < Naverage; i++) {
+    if (!average[i].Nlensing) continue;
+    n = average[i].lensingOffset;
+    average[i].lensingOffset = N;
+    for (k = 0; k < average[i].Nlensing; k++, N++) {
+      if (n == -1) {
+        fprintf (stderr, "entry after %d has a problem\n", (int) np);
+        abort();
+      }
+      tmplensing[N] = lensing[n];
+      if (lensing[n].averef != i) abort();
+      tmplensing[N].averef = i;
+      np = n;
+      n = next_lens[n];
+    }
+  }
+  free (lensing);
+  return (tmplensing);
+}
+/********  StarPar ********************************************************************************/
+/* build the initial links assuming the table is sorted,
+   not partial, and has a correct set of average[].starparOffset,Nstarpar values */
+off_t *init_starpar_links (Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar) {
+  off_t i, j, N;
+  off_t *next_star;
+  N = 0;
+  ALLOCATE (next_star, off_t, Nstarpar);
+  for (i = 0; i < Naverage; i++) {
+    if (!average[i].Nstarpar) continue;
+    for (j = 0; j < average[i].Nstarpar - 1; j++, N++) {
+      next_star[N] = N + 1;
+      if (N >= Nstarpar) {
+        fprintf (stderr, "WARNING: N out of bounds (1)\n");
+      }
+    }
+    next_star[N] = -1;
+    if (N >= Nstarpar) {
+      fprintf (stderr, "WARNING: N out of bounds (2)\n");
+    }
+    if (N >= Nstarpar) {
+      fprintf (stderr, "overflow in init_starpar_links\n");
+      abort ();
+    }
+    N++;
+  }
+  return (next_star);
+}
+/* construct starpar links which are valid FOR THIS LOAD
+ * - if we have a full load, we will get links which can
+ *   be used by other programs (eg, relphot, etc)
+ * - if we have a partial load, the links are only valid
+ *   for that partial load
+ */
+off_t *build_starpar_links (Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar) {
+  off_t i, m, k, Nm, averef;
+  off_t *next_star;
+  ALLOCATE (next_star, off_t, Nstarpar);
+  /* reset the Nm, offset values for average */
+  for (i = 0; i < Naverage; i++) {
+    average[i].starparOffset = -1;
+    average[i].Nstarpar     =  0;
+  }
+  for (Nm = 0; Nm < Nstarpar; Nm++) {
+    averef = starpar[Nm].averef;
+    m = average[averef].starparOffset;
+    next_star[Nm] = -1;
+    if (m == -1) { /* no links yet for source */
+      average[averef].starparOffset = Nm;
+      average[averef].Nstarpar     = 1;
+      continue;
+    }
+    for (k = 0; next_star[m] != -1; k++) {
+      m = next_star[m];
+      if (m >= Nstarpar) {
+        fprintf (stderr, "WARNING: m out of bounds (1)\n");
+      }
+    }
+    average[averef].Nstarpar = k + 2;
+    next_star[m] = Nm;
+    if (m >= Nstarpar) {
+      fprintf (stderr, "WARNING: m out of bounds (2)\n");
+    }
+  }
+  return (next_star);
+}
+/* average[].starparOffset, average[].Nstarpar are valid within an addstar run */
+int add_star_link (Average *average, off_t *next_star, off_t Nstarpar, off_t NSTARPAR) {
+  off_t k, m;
+  /* if we have trouble, check validity of next_star[m] : m < Nstarpar */
+  m = average[0].starparOffset;
+  for (k = 0; k < average[0].Nstarpar - 1; k++)  {
+    m = next_star[m];
+    if (m >= NSTARPAR) {
+      fprintf (stderr, "WARNING: m out of bounds (3)\n");
+    }
+  }
+  /* set up references */
+  next_star[Nstarpar] = -1;
+  if (Nstarpar >= NSTARPAR) {
+    fprintf (stderr, "WARNING: Nstarpar out of bounds (1)\n");
+  }
+  if (m == -1) {
+    average[0].starparOffset = Nstarpar;
+  } else {
+    next_star[m] = Nstarpar;
+    if (m >= NSTARPAR) {
+      fprintf (stderr, "WARNING: m out of bounds (4)\n");
+    }
+  }
+  return (TRUE);
+}
+StarPar *sort_starpar (Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar, off_t *next_star) {
+  off_t i, k, n, np, N;
+  StarPar *tmpstarpar;
+  /*
+  for (i = 0; i < Naverage; i++) {
+    if (average[i].Nstarpar != 4) {
+      fprintf (stderr, "check %d %d %d\n", (int) i, (int) average[i].Nstarpar, (int) average[i].starparOffset);
+    }
+  }
+  */
+  /* fix order of StarPar (memory intensive, but fast) */
+  np = -1;
+  N = 0;
+  ALLOCATE (tmpstarpar, StarPar, Nstarpar);
+  for (i = 0; i < Naverage; i++) {
+    if (!average[i].Nstarpar) continue;
+    n = average[i].starparOffset;
+    average[i].starparOffset = N;
+    for (k = 0; k < average[i].Nstarpar; k++, N++) {
+      if (n == -1) {
+        fprintf (stderr, "entry after %d has a problem\n", (int) np);
+        abort();
+      }
+      tmpstarpar[N] = starpar[n];
+      if (starpar[n].averef != i) abort();
+      tmpstarpar[N].averef = i;
+      np = n;
+      n = next_star[n];
+    }
+  }
+  free (starpar);
+  return (tmpstarpar);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvo_image_merge_dbs.c

-              r36833
+              r37822
   create_IDmap_lookup (IDmap);
-  if (!out[0].swapped) {
-    gfits_convert_Image ((Image *) out[0].ftable.buffer, sizeof(Image), Nout);
-    out[0].swapped = TRUE;
+  }
   Nout += Nimages;
   IDstart += Nimages;
 …
   off_t lastID = IDmap->old[IDmap->Nmap-1];
+  // update measure.imageID
   for (i = 0; i < catalog[0].Nmeasure; i++) {
     oldID = catalog[0].measure[i].imageID;
 …
+    }
     catalog[0].measure[i].imageID = newID;
+  }
+  // also update lensing.imageID if lensing exists
+  for (i = 0; i < catalog[0].Nlensing; i++) {
+    oldID = catalog[0].lensing[i].imageID;
+    if (oldID == 0) continue;
+    newID = dvo_map_image_ID (IDmap, oldID);
+    if (newID == 0) {
+      if (oldID > lastID) {
+        fprintf (stderr, "problem with image IDs : input out of range\n");
+        fprintf (stderr, "old ID: "OFF_T_FMT", last ID: "OFF_T_FMT"\n", oldID, lastID);
+        exit (2);
+      }
+      if (!IDmap->notFound[oldID]) {
+        fprintf (stderr, "cannot find image ID "OFF_T_FMT"\n",  oldID);
+        IDmap->notFound[oldID] = TRUE;
+        // once we discover an imageID is not found, record that fact so we do not complain for every detection
+      }
+      // optionally exit here? or wait until end to report an error?
+      // exit (2);
+    }
+    catalog[0].lensing[i].imageID = newID;
+  }
   return TRUE;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvomergeContinue.c

r34260	r37822
131	131	merge_catalogs_old (&outsky[0].regions[j], &outcatalog, &incatalog, RADIUS, secfiltMap);
132	132
133		~~outcatalog.catflags = LOAD_AVES \| LOAD_MEAS \| LOAD_MISS \| LOAD_SECF;~~
134
135	133	// if we receive a signal which would cause us to exit, wait until the full catalog is written
136	134	SetProtect (TRUE);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvomergeContinue_threaded.c

r34260	r37822
74	74	merge_catalogs_old (&threadData->outsky->regions[j], &outcatalog, &incatalog, RADIUS, threadData->secfiltMap);
75	75
76		~~outcatalog.catflags = LOAD_AVES \| LOAD_MEAS \| LOAD_MISS \| LOAD_SECF;~~
77
78	76	// if we receive a signal which would cause us to exit, wait until the full catalog is written
79	77	SetProtect (TRUE);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvomergeCreate.c

r33963	r37822
178	178	SkyListFree (inlist);
179	179
180		~~outcatalog.catflags = LOAD_AVES \| LOAD_MEAS \| LOAD_MISS \| LOAD_SECF;~~
181	180	dvo_catalog_save (&outcatalog, VERBOSE);
182	181	dvo_catalog_unlock (&outcatalog);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvomergeFromList.c

r35590	r37822
143	143	merge_catalogs_old (&skyregion, &outcatalog, &incatalog, RADIUS, secfiltMap);
144	144
145		~~outcatalog.catflags = LOAD_AVES \| LOAD_MEAS \| LOAD_MISS \| LOAD_SECF;~~
146
147	145	dmhObjectAdd (outstat[0].history, &outcatalog.header, inStats);
148	146

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvomergeUpdate.c

-              r36528
+              r37822
   int NsecfiltInput, NsecfiltOutput;
+  double dtime;
+  struct timeval start, stop;
+  gettimeofday (&start, NULL);
+  INITTIME;
   CONTINUE = FALSE;
 …
+  }
-  gettimeofday (&stop, NULL);
-  dtime = DTIME (stop, start);
   if (!status) {
     fprintf (stderr, "ERROR: elapsed time %9.4f sec\n", dtime);
+    MARKTIME ("ERROR: elapsed time %9.4f sec\n", dtime);
     exit (3);
+  }
   fprintf (stderr, "SUCCESS: elapsed time %9.4f sec\n", dtime);
+  MARKTIME ("SUCCESS: elapsed time %9.4f sec\n", dtime);
   exit (0);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvomergeUpdate_catalogs.c

-              r37046
+              r37822
+    }
+# ifdef OLD_CODE
+    // NOTE: i was having trouble dropping objects on edges with the option below.  Since an object can move outside the catalog grab the neighbors.
     // SkyListByBounds will return neighbor catalogs if the boundaries exactly match (due to rounding).  Since the regions are not infinitely small,
     // compare to a slightly reduced footprint
     float dPos = 2.0/3600.0;
     outlist = SkyListByBounds (outsky, -1, inlist[0].regions[i][0].Rmin + dPos, inlist[0].regions[i][0].Rmax - dPos, inlist[0].regions[i][0].Dmin + dPos, inlist[0].regions[i][0].Dmax - dPos);
+# endif
+    if (MATCHED_TABLES) {
+      // if we know the output will have the same depth / layout as the input, just choose the matched table
+      outlist = SkyRegionByIndex (outsky, inlist[0].regions[i][0].index);
+    } else {
+      // Since an object can move outside the catalog grab the neighbors.
+      float dPos = 2.0/3600.0;
+      outlist = SkyListByBounds (outsky, -1, inlist[0].regions[i][0].Rmin - dPos, inlist[0].regions[i][0].Rmax + dPos, inlist[0].regions[i][0].Dmin - dPos, inlist[0].regions[i][0].Dmax + dPos);
+    }
     OutputStatus *outstat = OutputStatusInit (outlist->Nregions);
 …
       LoadCatalog (&outcatalog, outlist[0].regions[j], outcatalog.filename, "w", NsecfiltOutput);
+      // if no catalog already exists, use the input catalog to define the format or the specified format
+      if (outcatalog.Naves_disk == 0) {
+        if (UPDATE_CATFORMAT) {
+          outcatalog.catformat = dvo_catalog_catformat (UPDATE_CATFORMAT);
+        } else {
+          outcatalog.catformat = incatalog.catformat;
+        }
+      }
       merge_catalogs_old (outlist[0].regions[j], &outcatalog, &incatalog, RADIUS, secfiltMap);
-      outcatalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
       if (outstat[j].missed) {
 …
       SetProtect (FALSE);
+      if (!dvo_catalog_unlock (&outcatalog)) {
+        fprintf (stderr, "ERROR: failed to unlock catalog %s\n", outlist[0].filename[j]);
+        exit (1);
+      }
       if (!dvo_catalog_unlink_backup (&outcatalog, TRUE)) {
         fprintf (stderr, "WARNING: failed to remove backup for catalog %s\n", outlist[0].filename[j]);
+      }
-      dvo_catalog_unlock (&outcatalog);
       dvo_catalog_free (&outcatalog);
 …
     if (PARALLEL_INPUT)      { snprintf (tmpline, DVO_MAX_PATH, "%s -parallel-input",  command); strcpy (command, tmpline); }
     if (FORCE_MERGE)         { snprintf (tmpline, DVO_MAX_PATH, "%s -force-merge",     command); strcpy (command, tmpline); }
+    if (MATCHED_TABLES)      { snprintf (tmpline, DVO_MAX_PATH, "%s -matched-tables",  command); strcpy (command, tmpline); }
     // add some config variables:

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvomergeUpdate_threaded.c

-              r35765
+              r37822
       merge_catalogs_old (&threadData->outsky->regions[j], &outcatalog, &incatalog, RADIUS, threadData->secfiltMap);
-      outcatalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
       // if we receive a signal which would cause us to exit, wait until the full catalog is written
       SetProtect (TRUE);
 …
   int NsecfiltInput, NsecfiltOutput;
+  double dtime;
+  struct timeval start, stop;
+  gettimeofday (&start, NULL);
+  INITTIME;
   CONTINUE = FALSE;
 …
   fprintf (stderr, "WARNING / ERROR : multi-threaded dvomerge does not handle merge tracking yet\n");
+  fprintf (stderr, "WARNING / ERROR : multi-threaded dvomerge does work in a parallel context\n");
   exit (2);
 …
+  }
+  gettimeofday (&stop, NULL);
+  dtime = DTIME (stop, start);
+  fprintf (stderr, "SUCCESS: elapsed time %9.4f sec\n", dtime);
+  MARKTIME ("SUCCESS: elapsed time %9.4f sec\n", dtime);
   exit (0);
 …
+    }
+  }
+  MARKTIME ("ERROR: elapsed time %9.4f sec\n", dtime);
   exit (1);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvorepair.c

-              r37046
+              r37822
 int main (int argc, char **argv) {
   fprintf (stderr, "this program needs to be updated to load old format Measure tables (pre PV1_V5) in which dR,dD are saved, not R,D\n");
   fprintf (stderr, "reminder: relastro can re-construct R,D from X,Y; FtableToMeasure and vice versa could just NAN those values\n");
   exit (2);
+  // fprintf (stderr, "this program needs to be updated to load old format Measure tables (pre PV1_V5) in which dR,dD are saved, not R,D\n");
+  // fprintf (stderr, "reminder: relastro can re-construct R,D from X,Y; FtableToMeasure and vice versa could just NAN those values\n");
+  // exit (2);
   dvorepair_help(argc, argv);
 …
   if (!strcmp(argv[1], "-images-vs-measures")) dvorepairImagesVsMeasures(argc, argv);
   if (!strcmp(argv[1], "-delete-image-list")) dvorepairDeleteImageList(argc, argv);
+  if (!strcmp(argv[1], "-delete-images-by-extern-id")) dvorepairDeleteImagesByExternID(argc, argv);
   if (!strcmp(argv[1], "-fix-images")) dvorepairFixImages(argc, argv);
   dvorepair_help(0, NULL);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvorepairCPT.c

r37046	r37822
119	119	thisImage = MatchImage (image, Nimage, measure[i].t, measure[i].photcode, measure[i].imageID);
120	120	XY_to_RD (&average[Nave].R, &average[Nave].D, measure[i].Xccd, measure[i].Yccd, &thisImage[0].coords);
	121	average[Nave].R = ohana_normalize_angle (average[Nave].R);
121	122
122	123	average[Nave].Nmeasure = 1;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvorepairDeleteImageList.c

-              r37046
+              r37822
     index = deleteIDs[i];
     seq = imageIdx[index];
-    if (!FindMosaicForImage (image, Nimage, seq)) {
-      fprintf (stderr, "cannot find mosaic for %s, skipping\n", image[seq].name);
-      continue;
+    }
     XY_to_RD(&Rthis, &Dthis, 0, 0, &image[seq].coords);
 …
     thisImage = MatchImage (image, Nimage, measure[i].t, measure[i].photcode, measure[i].imageID);
     XY_to_RD (&average[Nave].R, &average[Nave].D, measure[i].Xccd, measure[i].Yccd, &thisImage[0].coords);
+    average[Nave].R = ohana_normalize_angle (average[Nave].R);
     average[Nave].Nmeasure = 1;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvorepairFixImages.c

-              r29938
+              r37822
 int MarkMosaicsToDelete(Image *image, off_t Nimage, int *deleteIndex) {
+  myAbort ("this function needs to be redone with a concept to match the old BuildChipMatch");
+# if (0)
   off_t i;
 …
      marked.  Now find all WRP images for which none/some/all images are to be deleted.
   */
   // make a copy of the ChipMatch table (generated by BuildChipMatch, see libdvo/src/mosaic_astrom.c)
 …
   free (ChipByMosaicID);
+# endif
   return TRUE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvorepairFixTables.c

r37046	r37822
259	259	thisImage = MatchImage (image, Nimage, measure[i].t, measure[i].photcode, measure[i].imageID);
260	260	XY_to_RD (&average[Nave].R, &average[Nave].D, measure[i].Xccd, measure[i].Yccd, &thisImage[0].coords);
	261	average[Nave].R = ohana_normalize_angle (average[Nave].R);
261	262
262	263	average[Nave].Nmeasure = 1;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvoverify_args.c

-              r36101
+              r37822
+  }
+  /*** dvoverify -parallel (dvoverify_client, actually) ignores this argument
+       dvoverify should save a subset table of just the IDs, and dvoverify_client should load it
+       dvoverify -cpt should have CHECK_IMAGE_ID = F as default ***/
+  /*** dvoverify -cpt should have CHECK_IMAGE_ID = F as default ***/
   CHECK_IMAGE_ID = TRUE;
 …
+  }
+  CHECK_IMAGE_ID = TRUE;
+  if ((N = get_argument (*argc, argv, "-skip-image-ids"))) {
+    CHECK_IMAGE_ID = FALSE;
+    remove_argument (N, argc, argv);
+  }
   // restrict to a portion of the sky
   UserPatch.Rmin = 0;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvoverify_catalogs.c

-              r36084
+              r37822
+    }
+    sprintf (filename, "%s/%s.cpx", mycatdir, skylist[0].regions[i][0].name);
+    if (!VerifyTableFile (filename)) {
+      Nbad ++;
+      skipIndexCheck = TRUE;
+      AddFailures (filename);
+    }
+    sprintf (filename, "%s/%s.cpy", mycatdir, skylist[0].regions[i][0].name);
+    if (!VerifyTableFile (filename)) {
+      Nbad ++;
+      skipIndexCheck = TRUE;
+      AddFailures (filename);
+    }
     sprintf (filename, "%s/%s.cpt", mycatdir, skylist[0].regions[i][0].name);
     if (!skipIndexCheck) {
 …
     exit (1);
+  }
+  // save the IDlist as a smaller FITS table
+  if (CHECK_IMAGE_ID) {
+    char filename[DVO_MAX_PATH];
+    snprintf (filename, DVO_MAX_PATH, "%s/ImageIDs.fits", CATDIR);
+    if (!SaveImageIDsSmall (filename)) {
+      fprintf (stderr, "ERROR: failure to save image IDs\n");
+      exit (2);
+    }
+  }
   int i;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvoverify_client.c

-              r34405
+              r37822
     // XXX in client mode, we should be reading a reduced table generated by the calling
     // serial program
+    LoadImageIDs (CATDIR);
+    char filename[DVO_MAX_PATH];
+    snprintf (filename, DVO_MAX_PATH, "%s/ImageIDs.fits", CATDIR);
+    if (!LoadImageIDsSmall (filename)) {
+      fprintf (stderr, "ERROR: failure to load image IDs\n");
+      exit (2);
+    }
+  }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/dvoverify_utils.c

-              r36101
+              r37822
   catalog.catformat = DVO_FORMAT_UNDEF; // read-only,do not set the catformat
   catalog.catmode   = DVO_MODE_UNDEF; // read-only, do not set the catmode
   catalog.catflags  = LOAD_AVES | LOAD_MEAS;
+  catalog.catflags  = LOAD_AVES | LOAD_MEAS | LOAD_LENSING | LOAD_LENSOBJ;
   catalog.Nsecfilt  = 0;
 …
   int NmeasureTotal = 0;
   int measureOffsetOK = TRUE;
+  int NlensingTotal = 0;
+  int lensingOffsetOK = TRUE;
+  int NlensobjTotal = 0;
+  int lensobjOffsetOK = TRUE;
   for (i = 0; i < catalog.Naverage; i++) {
     NmeasureTotal += catalog.average[i].Nmeasure;
 …
       fprintf (stderr, "measureOffset + Nmeasure > catalog.Nmeasure : %d %d %d\n", i, catalog.average[i].Nmeasure, (int) catalog.Nmeasure);
+    }
+    // sum of Nlensing for each object < Nlensing for catalog
+    NlensingTotal += catalog.average[i].Nlensing;
+    if (VERBOSE && !(NlensingTotal <= catalog.Nlensing)) {
+      fprintf (stderr, "NlensingTotal > catalog.Nlensing: %d %d %d\n", i, catalog.average[i].Nlensing, (int) catalog.Nlensing);
+    }
+    // lensingOffset needs to be in range for each object
+    lensingOffsetOK &= (!catalog.Nlensing || (catalog.average[i].lensingOffset < catalog.Nlensing));
+    if (VERBOSE && catalog.Nlensing && !(catalog.average[i].lensingOffset < catalog.Nlensing)) {
+      fprintf (stderr, "lensingOffset >= catalog.Nlensing: %d %d %d\n", i, catalog.average[i].lensingOffset, (int) catalog.Nlensing);
+    }
+    lensingOffsetOK &= (catalog.average[i].lensingOffset + catalog.average[i].Nlensing <= catalog.Nlensing);
+    if (VERBOSE && !(catalog.average[i].lensingOffset + catalog.average[i].Nlensing <= catalog.Nlensing)) {
+      fprintf (stderr, "lensingOffset + Nlensing > catalog.Nlensing : %d %d %d\n", i, catalog.average[i].Nlensing, (int) catalog.Nlensing);
+    }
+    NlensobjTotal += catalog.average[i].Nlensobj;
+    if (VERBOSE && !(NlensobjTotal <= catalog.Nlensobj)) {
+      fprintf (stderr, "NlensobjTotal > catalog.Nlensobj: %d %d %d\n", i, catalog.average[i].Nlensobj, (int) catalog.Nlensobj);
+    }
+    lensobjOffsetOK &= (catalog.average[i].lensobjOffset < catalog.Nlensobj);
+    if (VERBOSE && !(catalog.average[i].lensobjOffset < catalog.Nlensobj)) {
+      fprintf (stderr, "lensobjOffset >= catalog.Nlensobj: %d %d %d\n", i, catalog.average[i].lensobjOffset, (int) catalog.Nlensobj);
+    }
+    lensobjOffsetOK &= (catalog.average[i].lensobjOffset + catalog.average[i].Nlensobj <= catalog.Nlensobj);
+    if (VERBOSE && !(catalog.average[i].lensobjOffset + catalog.average[i].Nlensobj <= catalog.Nlensobj)) {
+      fprintf (stderr, "lensobjOffset + Nlensobj > catalog.Nlensobj : %d %d %d\n", i, catalog.average[i].Nlensobj, (int) catalog.Nlensobj);
+    }
+  }
 …
   if (NmeasureTotal != catalog.Nmeasure) {
     fprintf (stderr, "ERROR: catalog %s has an invalid Nmeasure\n", catalog.filename);
+    status = FALSE;
+  }
+  if (!lensingOffsetOK) {
+    fprintf (stderr, "ERROR: catalog %s has an invalid lensingOffset\n", catalog.filename);
+    status = FALSE;
+  }
+  if (NlensingTotal != catalog.Nlensing) {
+    fprintf (stderr, "ERROR: catalog %s has an invalid Nlensing\n", catalog.filename);
+    status = FALSE;
+  }
+  if (!lensobjOffsetOK) {
+    fprintf (stderr, "ERROR: catalog %s has an invalid lensobjOffset\n", catalog.filename);
+    status = FALSE;
+  }
+  if (NlensobjTotal != catalog.Nlensobj) {
+    fprintf (stderr, "ERROR: catalog %s has an invalid Nlensobj\n", catalog.filename);
     status = FALSE;
+  }
 …
+  }
+  int objIDsOK = TRUE;
+  int catIDsOK = TRUE;
+  int averefOK = TRUE;
+  for (i = 0; i < catalog.Naverage; i++) {
+    m = catalog.average[i].measureOffset;
+    for (j = 0; j < catalog.average[i].Nmeasure; j++) {
+      objIDsOK &= (catalog.average[i].objID == catalog.measure[m+j].objID);
+      catIDsOK &= (catalog.average[i].catID == catalog.measure[m+j].catID);
+      averefOK &= (catalog.measure[m+j].averef == i);
+    }
+  }
+  // check measure <-> average links
+  {
+    int objIDsOK = TRUE;
+    int catIDsOK = TRUE;
+    int averefOK = TRUE;
+    for (i = 0; i < catalog.Naverage; i++) {
+      m = catalog.average[i].measureOffset;
+      for (j = 0; j < catalog.average[i].Nmeasure; j++) {
+        objIDsOK &= (catalog.average[i].objID == catalog.measure[m+j].objID);
+        catIDsOK &= (catalog.average[i].catID == catalog.measure[m+j].catID);
+        averefOK &= (catalog.measure[m+j].averef == i);
+      }
+    }
+  if (!objIDsOK) {
+    fprintf (stderr, "ERROR: catalog %s has invalid obj IDs\n", catalog.filename);
+    status = FALSE;
+  }
+  if (!catIDsOK) {
+    fprintf (stderr, "ERROR: catalog %s has invalid cat IDs\n", catalog.filename);
+    status = FALSE;
+  }
+  if (!averefOK) {
+    fprintf (stderr, "ERROR: catalog %s has invalid averef values\n", catalog.filename);
+    status = FALSE;
+    if (!objIDsOK) {
+      fprintf (stderr, "ERROR: catalog %s has invalid obj IDs\n", catalog.filename);
+      status = FALSE;
+    }
+    if (!catIDsOK) {
+      fprintf (stderr, "ERROR: catalog %s has invalid cat IDs\n", catalog.filename);
+      status = FALSE;
+    }
+    if (!averefOK) {
+      fprintf (stderr, "ERROR: catalog %s has invalid averef values\n", catalog.filename);
+      status = FALSE;
+    }
+  }
+  // check lensing <-> average links
+  {
+    int objIDsOK = TRUE;
+    int catIDsOK = TRUE;
+    int averefOK = TRUE;
+    for (i = 0; i < catalog.Naverage; i++) {
+      m = catalog.average[i].lensingOffset;
+      for (j = 0; j < catalog.average[i].Nlensing; j++) {
+        objIDsOK &= (catalog.average[i].objID == catalog.lensing[m+j].objID);
+        catIDsOK &= (catalog.average[i].catID == catalog.lensing[m+j].catID);
+        averefOK &= (catalog.lensing[m+j].averef == i);
+      }
+    }
+    if (!objIDsOK) {
+      fprintf (stderr, "ERROR: catalog %s has invalid lensing obj IDs\n", catalog.filename);
+      status = FALSE;
+    }
+    if (!catIDsOK) {
+      fprintf (stderr, "ERROR: catalog %s has invalid lensing cat IDs\n", catalog.filename);
+      status = FALSE;
+    }
+    if (!averefOK) {
+      fprintf (stderr, "ERROR: catalog %s has invalid lensing averef values\n", catalog.filename);
+      status = FALSE;
+    }
+  }
+  // check lensobj <-> average links
+  {
+    int objIDsOK = TRUE;
+    int catIDsOK = TRUE;
+    for (i = 0; i < catalog.Naverage; i++) {
+      m = catalog.average[i].lensobjOffset;
+      for (j = 0; j < catalog.average[i].Nlensobj; j++) {
+        objIDsOK &= (catalog.average[i].objID == catalog.lensobj[m+j].objID);
+        catIDsOK &= (catalog.average[i].catID == catalog.lensobj[m+j].catID);
+      }
+    }
+    if (!objIDsOK) {
+      fprintf (stderr, "ERROR: catalog %s has invalid lensobj obj IDs\n", catalog.filename);
+      status = FALSE;
+    }
+    if (!catIDsOK) {
+      fprintf (stderr, "ERROR: catalog %s has invalid lensobj cat IDs\n", catalog.filename);
+      status = FALSE;
+    }
+  }
 …
+    }
+  }
+  for (i = 0; i < catalog[0].Naverage; i++) {
+    m = catalog[0].average[i].lensingOffset;
+    for (j = 0; j < catalog[0].average[i].Nlensing; j++) {
+      id = catalog[0].lensing[m+j].imageID;
+      if (id == 0) continue; // detections from ref photcodes can (should) have unset image IDs
+      if (id > maxID) {
+        Nfail ++;
+        continue;
+        // is this sufficient to catch IDs set without an image table?
+      }
+      if (IDlist) {
+        if (IDlist[id] < 0) {
+          Nfail ++;
+          continue;
+        }
+      } else {
+        if (id > 0) {
+          Nfail ++;
+          continue;
+        }
+      }
+    }
+  }
   return Nfail;
+}
 …
   return TRUE;
+}
+# define GET_COLUMN(OUT,NAME,TYPE) \
+  OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \
+  myAssert (!strcmp(type, #TYPE), "wrong column type");
+// STATUS is value expected for success
+# define CHECK_STATUS(STATUS,MSG,...)                                   \
+  if (!(STATUS)) {                                                      \
+    fprintf (stderr, MSG, __VA_ARGS__);                                 \
+    return FALSE;                                                       \
+  }
+// write out the IDmap data for clients to read
+int SaveImageIDsSmall(char *filename) {
+  Header header;
+  Header theader;
+  Matrix matrix;
+  FTable ftable;
+  gfits_init_header (&header);
+  header.extend = TRUE;
+  gfits_create_header (&header);
+  gfits_create_matrix (&header, &matrix);
+  gfits_create_table_header (&theader, "BINTABLE", "IMAGE_IDS");
+  gfits_define_bintable_column (&theader, "J", "IMAGE_IDS", "image IDs", NULL, 1.0, FT_BZERO_INT32);
+  // generate the output array that carries the data
+  gfits_create_table (&theader, &ftable);
+  // add the columns to the output array
+  gfits_set_bintable_column (&theader, &ftable, "IMAGE_IDS", IDlist, maxID + 1);
+  FILE *f = fopen (filename, "w");
+  if (!f) {
+    fprintf (stderr, "ERROR: cannot open image ID file for output %s\n", filename);
+    return FALSE;
+  }
+  int status;
+  status = gfits_fwrite_header  (f, &header);
+  CHECK_STATUS (status, "ERROR: cannot write header for image ID file %s\n", filename);
+  status = gfits_fwrite_matrix  (f, &matrix);
+  CHECK_STATUS (status, "ERROR: cannot write matrix for image ID file %s\n", filename);
+  status = gfits_fwrite_Theader (f, &theader);
+  CHECK_STATUS (status, "ERROR: cannot write table header for image ID file %s\n", filename);
+  status = gfits_fwrite_table  (f, &ftable);
+  CHECK_STATUS (status, "ERROR: cannot write table data for image ID file %s\n", filename);
+  gfits_free_header (&header);
+  gfits_free_matrix (&matrix);
+  gfits_free_header (&theader);
+  gfits_free_table (&ftable);
+  int fd = fileno (f);
+  status = fflush (f);
+  CHECK_STATUS (!status, "ERROR: cannot flush file image ID file %s\n", filename);
+  status = fsync (fd);
+  CHECK_STATUS (!status, "ERROR: cannot flush file image ID file %s\n", filename);
+  status = fclose (f);
+  CHECK_STATUS (!status, "ERROR: problem closing image ID file file %s\n", filename);
+  return TRUE;
+}
+int LoadImageIDsSmall (char *filename) {
+  int Ncol;
+  off_t Nrow;
+  Header header;
+  Header theader;
+  Matrix matrix;
+  FTable ftable;
+  FILE *f = fopen (filename, "r");
+  if (!f) {
+    fprintf (stderr, "ERROR: cannot open image subset file %s\n", filename);
+    return FALSE;
+  }
+  /* load in PHU segment (ignore) */
+  if (!gfits_fread_header (f, &header)) {
+    if (VERBOSE) fprintf (stderr, "can't read image subset header\n");
+    fclose (f);
+    return FALSE;
+  }
+  if (!gfits_fread_matrix (f, &matrix, &header)) {
+    if (VERBOSE) fprintf (stderr, "can't read image subset matrix\n");
+    gfits_free_header (&header);
+    fclose (f);
+    return FALSE;
+  }
+  ftable.header = &theader;
+  // load data for this header
+  if (!gfits_load_header (f, &theader)) {
+    fclose (f);
+    return FALSE;
+  }
+  // read the fits table bytes
+  if (!gfits_fread_ftable_data (f, &ftable, FALSE)) {
+    fclose (f);
+    return FALSE;
+  }
+  fclose (f);
+  char type[16];
+  GET_COLUMN (IDlist, "IMAGE_IDS", int);
+  maxID = Nrow - 1;
+  fprintf (stderr, "loaded data for %lld images\n", (long long) Nrow);
+  return TRUE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/merge_catalogs_new.c

-              r28855
+              r37822
 // input entries always define new objects
-#define notyet 1
 int merge_catalogs_new (SkyRegion *region, Catalog *output, Catalog *input, int *secfiltMap) {
   off_t i, j, offset;
   off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, NsecfiltIn, NsecfiltOut, Nm;
+  off_t NAVERAGE, NMEASURE, NLENSING, NSTARPAR, Naverage, Nmeasure, Nlensing, Nstarpar, NsecfiltIn, NsecfiltOut, Nm;
   Naverage = output[0].Naverage;
   Nmeasure = output[0].Nmeasure;
+  Nlensing = output[0].Nlensing;
+  Nstarpar = output[0].Nstarpar;
   NsecfiltOut = output[0].Nsecfilt;
 …
   NAVERAGE = Naverage + 100;
   NMEASURE = Nmeasure + 1000;
+  NLENSING = Nlensing + 1000;
+  NSTARPAR = Nstarpar + 1000;
   REALLOCATE (output[0].average, Average, NAVERAGE);
   REALLOCATE (output[0].secfilt, SecFilt, NAVERAGE*NsecfiltOut);
   REALLOCATE (output[0].measure, Measure, NMEASURE);
+  REALLOCATE (output[0].lensing, Lensing, NLENSING);
+  REALLOCATE (output[0].starpar, StarPar, NSTARPAR);
   // add all of these entries to the existing catalog
 …
+      }
       output[0].average[Naverage].Nmeasure = Nm;
+      Nm = 0;
+      for (j = 0; j < input[0].average[i].Nlensing; j++) {
+          offset = input[0].average[i].lensingOffset + j;
+          output[0].lensing[Nlensing] = input[0].lensing[offset];
+          output[0].lensing[Nlensing].averef = Naverage;
+          Nlensing ++;
+          Nm ++;
+          if (Nlensing == NLENSING) {
+              NLENSING += 1000;
+              REALLOCATE (output[0].lensing, Lensing, NLENSING);
+          }
+      }
+      output[0].average[Naverage].Nlensing = Nm;
+      Nm = 0;
+      for (j = 0; j < input[0].average[i].Nstarpar; j++) {
+          offset = input[0].average[i].starparOffset + j;
+          output[0].starpar[Nstarpar] = input[0].starpar[offset];
+          output[0].starpar[Nstarpar].averef = Naverage;
+          Nstarpar ++;
+          Nm ++;
+          if (Nstarpar == NSTARPAR) {
+              NSTARPAR += 1000;
+              REALLOCATE (output[0].starpar, StarPar, NSTARPAR);
+          }
+      }
+      output[0].average[Naverage].Nstarpar = Nm;
       Naverage ++;
       if (Naverage == NAVERAGE) {
 …
   REALLOCATE (output[0].average, Average, MAX (Naverage, 1));
   REALLOCATE (output[0].measure, Measure, MAX (Nmeasure, 1));
+  REALLOCATE (output[0].lensing, Lensing, MAX (Nlensing, 1));
+  REALLOCATE (output[0].starpar, StarPar, MAX (Nstarpar, 1));
   REALLOCATE (output[0].secfilt, SecFilt, NsecfiltOut*MAX (Naverage, 1));
   output[0].Naverage = Naverage;
+  output[0].Nmeasure = Nmeasure;
+  output[0].Nlensing = Nlensing;
+  output[0].Nstarpar = Nstarpar;
   output[0].Nsecf_mem = Naverage * NsecfiltOut;
 …
   if (VERBOSE) {
       fprintf (stderr, OFF_T_FMT": using "OFF_T_FMT" stars ("OFF_T_FMT" measures) for catalog\n",
+      fprintf (stderr, OFF_T_FMT": using "OFF_T_FMT" stars ("OFF_T_FMT" measures, "OFF_T_FMT" lensing) for catalog\n",
                 i,
                 output[0].Naverage,
+                output[0].Nmeasure);
+                output[0].Nmeasure,
+                output[0].Nlensing);
+  }
   return (TRUE);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvomerge/src/merge_catalogs_old.c

-              r37046
+              r37822
 # define IN_REGION(R,D) (                                       \
     ((D) >= region[0].Dmin) && ((D) < region[0].Dmax) &&        \
     ((R) >= region[0].Rmin)  && ((R) < region[0].Rmax))
+    ((R) >= region[0].Rmin) && ((R) < region[0].Rmax))
 // merge the input data into the output catalog
 …
   double *X1, *Y1, *X2, *Y2;
   double dX, dY, dR;
   off_t *N1, *N2,  *next_meas;
   off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
+  off_t *N1, *N2, *next_meas, *next_lens, *next_star;
+  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch, Nlens, NLENS, Nstar, NSTAR;
   int NsecfiltIn;
   int NsecfiltOut;
 …
   Nmatch = 0;
   NMEAS = Nmeas = output[0].Nmeasure;
+  NLENS = Nlens = output[0].Nlensing;
+  NSTAR = Nstar = output[0].Nstarpar;
   // current max obj ID for this catalog
 …
    * coordops.update.c).  We use the center of the region (catalog) for crval1,2.
    */
+  InitCoords (&tcoords, "DEC--ARC");
   tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
   if (region[0].Dmax < 90) {
 …
     tcoords.crval2 = 90.0;
+  }
-  tcoords.crpix1 = 0;
-  tcoords.crpix2 = 0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-  tcoords.Npolyterms = 1;
-  strcpy (tcoords.ctype, "DEC--ARC");
   if (VERBOSE) fprintf (stderr, "merging %s into %s\n", input[0].filename, output[0].filename);
 …
+  }
   /* set up pointers for linked list of measure */
   if (output[0].sorted && (output[0].Nmeasure >= output[0].Nmeas_disk)) {
 …
     // is sorted while processed
     next_meas = init_measure_links (output[0].average, Nave, output[0].measure, Nmeas);
+    next_lens = init_lensing_links (output[0].average, Nave, output[0].lensing, Nlens);
+    next_star = init_starpar_links (output[0].average, Nave, output[0].starpar, Nstar);
   } else {
     next_meas = build_measure_links (output[0].average, Nave, output[0].measure, Nmeas);
+    next_lens = build_lensing_links (output[0].average, Nave, output[0].lensing, Nlens);
+    next_star = build_starpar_links (output[0].average, Nave, output[0].starpar, Nstar);
+  }
 …
       REALLOCATE (output[0].measure, Measure, NMEAS);
+    }
+    if (Nlens + input[0].average[N].Nlensing >= NLENS) {
+      NLENS = Nlens + input[0].average[N].Nlensing + 1000;
+      REALLOCATE (next_lens, off_t, NLENS);
+      REALLOCATE (output[0].lensing, Lensing, NLENS);
+    }
+    if (Nstar + input[0].average[N].Nstarpar >= NSTAR) {
+      NSTAR = Nstar + input[0].average[N].Nstarpar + 1000;
+      REALLOCATE (next_star, off_t, NSTAR);
+      REALLOCATE (output[0].starpar, StarPar, NSTAR);
+    }
     // 4) average properties from the input and the output db need to be properly merged.
 …
       if (REPLACE_BY_PHOTCODE) {
         // index to first measure for this object
+        // XXX this does not support lensing measurements
         int Mout = output[0].average[n].measureOffset;
         if (replace_match(&output[0].average[n], &output[0].measure[Mout], &input[0].average[N], &input[0].measure[offset])) {
 …
+    }
+    // if lensing measurements exist, add them too
+    if (output[0].lensing) {
+      for (Nin = 0; Nin < input[0].average[N].Nlensing; Nin++) {
+        /* add to end of lensing list */
+        add_lens_link (&output[0].average[n], next_lens, Nlens, NLENS);
+        // set the new lensing
+        off_t lensoff = input[0].average[N].lensingOffset + Nin;
+        output[0].lensing[Nlens] = input[0].lensing[lensoff];
+        output[0].lensing[Nlens].averef   = n;
+        output[0].lensing[Nlens].objID    = output[0].average[n].objID;
+        output[0].lensing[Nlens].catID    = output[0].catID;
+        output[0].average[n].Nlensing ++;
+        Nlens ++;
+      }
+    }
+    // if lensing measurements exist, add them too
+    if (output[0].starpar) {
+      for (Nin = 0; Nin < input[0].average[N].Nstarpar; Nin++) {
+        /* add to end of lensing list */
+        add_star_link (&output[0].average[n], next_star, Nstar, NSTAR);
+        // set the new starpar
+        off_t staroff = input[0].average[N].starparOffset + Nin;
+        output[0].starpar[Nstar] = input[0].starpar[staroff];
+        output[0].starpar[Nstar].averef   = n;
+        output[0].starpar[Nstar].objID    = output[0].average[n].objID;
+        output[0].starpar[Nstar].catID    = output[0].catID;
+        output[0].average[n].Nstarpar ++;
+        Nstar ++;
+      }
+    }
     // update the average properties to reflect the incoming entries:
     // if the original value is NAN but the input value is not, accept the input:
 …
       REALLOCATE (output[0].measure, Measure, NMEAS);
+    }
+    if (Nlens + input[0].average[N].Nlensing >= NLENS) {
+      NLENS = Nlens + input[0].average[N].Nlensing + 1000;
+      REALLOCATE (next_lens, off_t, NLENS);
+      REALLOCATE (output[0].lensing, Lensing, NLENS);
+    }
+    if (Nstar + input[0].average[N].Nstarpar >= NSTAR) {
+      NSTAR = Nstar + input[0].average[N].Nstarpar + 1000;
+      REALLOCATE (next_star, off_t, NSTAR);
+      REALLOCATE (output[0].starpar, StarPar, NSTAR);
+    }
     if (Nave >= NAVE) {
       NAVE = Nave + 1000;
 …
     if (input[0].found_t[N] >= 0) continue;
+    if (!IN_REGION (input[0].average[N].R, input[0].average[N].D)) continue;
+    // if we are using MATCHED_TABLES, we are going to leave the edge cases in their
+    // source catalog, even if they have leaked beyond the edge
+    if (!MATCHED_TABLES && !IN_REGION (input[0].average[N].R, input[0].average[N].D)) continue;
     // XXX should we accept the input measurements for these fields?
 …
       next_meas[Nmeas - Ngroup + j] = Nmeas - Ngroup + j + 1;
+    }
+    /** add lensing for this input average object **/
+    if (output[0].lensing) {
+      output[0].average[Nave].lensingOffset  = Nlens;
+      for (Nin = 0; Nin < input[0].average[N].Nlensing; Nin ++) {
+        // supply the lensing values from this detection
+        off_t lensoff = input[0].average[N].lensingOffset + Nin;
+        output[0].lensing[Nlens]           = input[0].lensing[lensoff];
+        // the following lensing elements cannot be set until here:
+        output[0].lensing[Nlens].averef   = Nave;
+        output[0].lensing[Nlens].objID    = output[0].average[Nave].objID;
+        output[0].lensing[Nlens].catID    = output[0].catID;
+        // as we add lensing, update Nlensing to match
+        output[0].average[Nave].Nlensing ++;
+        /* we set next[Nlens] to -1 here, and update correctly below */
+        next_lens[Nlens] = -1;
+        Nlens ++;
+      }
+      int Ngroup = input[0].average[N].Nlensing;
+      for (j = 0; j < Ngroup - 1; j++) {
+        next_lens[Nlens - Ngroup + j] = Nlens - Ngroup + j + 1;
+      }
+    }
+    /** add starpar for this input average object **/
+    if (output[0].starpar) {
+      output[0].average[Nave].starparOffset  = Nstar;
+      for (Nin = 0; Nin < input[0].average[N].Nstarpar; Nin ++) {
+        // supply the starpar values from this detection
+        off_t staroff = input[0].average[N].starparOffset + Nin;
+        output[0].starpar[Nstar]           = input[0].starpar[staroff];
+        // the following starpar elements cannot be set until here:
+        output[0].starpar[Nstar].averef   = Nave;
+        output[0].starpar[Nstar].objID    = output[0].average[Nave].objID;
+        output[0].starpar[Nstar].catID    = output[0].catID;
+        // as we add starpar, update Nstarpar to match
+        output[0].average[Nave].Nstarpar ++;
+        /* we set next[Nstar] to -1 here, and update correctly below */
+        next_star[Nstar] = -1;
+        Nstar ++;
+      }
+      int Ngroup = input[0].average[N].Nstarpar;
+      for (j = 0; j < Ngroup - 1; j++) {
+        next_star[Nstar - Ngroup + j] = Nstar - Ngroup + j + 1;
+      }
+    }
     Nave ++;
+  }
 …
   REALLOCATE (output[0].average, Average, Nave);
   REALLOCATE (output[0].measure, Measure, Nmeas);
+  REALLOCATE (output[0].lensing, Lensing, Nlens);
+  REALLOCATE (output[0].starpar, StarPar, Nstar);
 # define NOSORT 0
 …
     output[0].sorted = TRUE;
     output[0].measure = sort_measure (output[0].average, Nave, output[0].measure, Nmeas, next_meas);
+    output[0].lensing = sort_lensing (output[0].average, Nave, output[0].lensing, Nlens, next_lens);
+    output[0].starpar = sort_starpar (output[0].average, Nave, output[0].starpar, Nstar, next_star);
+  }
 …
   output[0].Naverage = Nave;
   output[0].Nmeasure = Nmeas;
+  output[0].Nlensing = Nlens;
+  output[0].Nstarpar = Nstar;
   output[0].Nsecf_mem = Nave*NsecfiltOut;
   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n",  Nstars,  Nave,  Nmeas,  Nmatch);
+  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas, Nlens: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n",  Nstars,  Nave,  Nmeas,  Nlens, Nmatch);
   free (next_meas);
+  free (next_lens);
+  free (next_star);
   free (X2);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvopsps/Makefile

-              r35098
+              r37822
 $(SRC)/insert_objects_dvopsps.$(ARCH).o \
 $(SRC)/insert_objects_dvopsps_catalog.$(ARCH).o \
+$(SRC)/insert_FWobjects_dvopsps.$(ARCH).o \
+$(SRC)/insert_FWobjects_dvopsps_catalog.$(ARCH).o \
 $(SRC)/insert_detections_dvopsps.$(ARCH).o \
 $(SRC)/insert_detections_dvopsps_catalog.$(ARCH).o
 …
 $(SRC)/insert_objects_dvopsps.$(ARCH).o \
 $(SRC)/insert_objects_dvopsps_catalog.$(ARCH).o \
+$(SRC)/insert_FWobjects_dvopsps.$(ARCH).o \
+$(SRC)/insert_FWobjects_dvopsps_catalog.$(ARCH).o \
 $(SRC)/insert_detections_dvopsps.$(ARCH).o \
 $(SRC)/insert_detections_dvopsps_catalog.$(ARCH).o

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvopsps/include/dvopsps.h

-              r36188
+              r37822
 typedef struct {
+  int imageID;
+  unsigned int ippDetectID;
+  uint64_t objID;
   uint64_t detectID;
   uint64_t ippObjID;
+  uint64_t objID;
+  int      photcode;
+  unsigned int flags;
+  float zp;
+  float zpErr;
+  float airMass;
+  float expTime;
+  unsigned int ippDetectID;
+  int imageID;
+  int catID;
   double ra;
   double dec;
   float raErr;
   float decErr;
+  float zp;
+  float telluricExt;
+  float airmass;
+  float expTime;
+  float Mpsf;
+  float dMpsf;
+  float Mkron;
+  float dMkron;
+  float Map;
+  float dMap;
+  unsigned int flags;
 } Detections;
 …
 int    insert_detections_mysql_commit     PROTO((IOBuffer *buffer, MYSQL *mysql));
 int    insert_detections_mysql_value      PROTO((IOBuffer *buffer, Average *average, Measure *measure));
+// int    insert_detections_mysql_value      PROTO((IOBuffer *buffer, Average *average, Measure *measure));
 int    insert_detections_mysql_init       PROTO((IOBuffer *buffer));
 int    insert_detections_mysql_array      PROTO((MYSQL *mysql, Detections *detections, int Ndetections));
 int    insert_detections_mysql_detvalue   PROTO((IOBuffer *buffer, Detections *detection));
+int    assign_detection_values            PROTO((Detections *detection, Measure *measure, Average *average));
 int    init_detections                    PROTO(());
 …
 int    insert_objects_mysql_create_tables PROTO((char *basename, MYSQL *mysql));
 int    insert_objects_mysql_commit        PROTO((IOBuffer *ave_buffer, IOBuffer *sec_buffer, MYSQL *mysql));
 int    insert_objects_mysql_value         PROTO((IOBuffer *ave_buffer, IOBuffer *sec_buffer, Average *average, SecFilt *secfilt, int Nsecfilt));
 int    insert_objects_mysql_init          PROTO((IOBuffer *ave_buffer, IOBuffer *sec_buffer, char *basename));
+int    insert_FWobjects_dvopsps             PROTO(());
+int    insert_FWobjects_dvopsps_parallel    PROTO((SkyList *sky));
+int    insert_FWobjects_dvopsps_catalog     PROTO((Catalog *catalog, char *basename, MYSQL *mysql));
+int    insert_FWobjects_mysql_create_tables PROTO((char *basename, MYSQL *mysql));
+int    insert_FWobjects_mysql_init          PROTO((IOBuffer *ave_buffer, IOBuffer *sec_buffer, IOBuffer *cpy_buffer, char *basename));
+int    insert_FWobjects_mysql_value         PROTO((IOBuffer *ave_buffer, IOBuffer *sec_buffer, IOBuffer *cpy_buffer, Average *average, SecFilt *secfilt, int Nsecfilt, Lensobj *lensobj, int Nlensobj));
+int    insert_FWobjects_mysql_commit        PROTO((IOBuffer *ave_buffer, IOBuffer *sec_buffer, IOBuffer *cpy_buffer, MYSQL *mysql));
 int    insert_skytable                    PROTO(());

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvopsps/src/DetectionOps.c

-              r35578
+              r37822
 # include "dvopsps.h"
-# define BZERO_INT16 1.0*0x8000
-# define BZERO_INT32 1.0*0x80000000
-# define BZERO_INT64 1.0*0x8000000000000000
 # define GET_COLUMN(OUT,NAME,TYPE)                                      \
 …
   // need to create and assign to flat-field correction
+  GET_COLUMN(imageID     , "imageID",     int);
+  GET_COLUMN(ippDetectID , "ippDetectID", int);
+  GET_COLUMN(objID       , "objID",       int64_t);
   GET_COLUMN(detectID    , "detectID",    int64_t);
   GET_COLUMN(ippObjID    , "ippObjID",    int64_t);
+  GET_COLUMN(objID       , "objID",       int64_t);
+  GET_COLUMN(photcode    , "photcode",    int);
+  GET_COLUMN(flags       , "flags",       int);
+  GET_COLUMN(zp          , "zp",          float);
+  GET_COLUMN(zpErr       , "zpErr",       float);
+  GET_COLUMN(airMass     , "airMass",     float);
+  GET_COLUMN(expTime     , "expTime",     float);
+  GET_COLUMN(ippDetectID , "ippDetectID", int);
+  GET_COLUMN(imageID     , "imageID",     int);
+  GET_COLUMN(catID       , "catID",       int);
   GET_COLUMN(ra          , "ra",          double); // XXX signed vs unsigned?
   GET_COLUMN(dec         , "dec",         double);
   GET_COLUMN(raErr       , "raErr",       float);
   GET_COLUMN(decErr      , "decErr",      float);
+  GET_COLUMN(zp          , "zp",          float);
+  GET_COLUMN(telluricExt , "telluricExt", float);
+  GET_COLUMN(airmass     , "airmass",     float);
+  GET_COLUMN(expTime     , "expTime",     float);
+  GET_COLUMN(Mpsf        , "Mpsf",        float);
+  GET_COLUMN(dMpsf       , "dMpsf",       float);
+  GET_COLUMN(Mkron       , "Mkron",       float);
+  GET_COLUMN(dMkron      , "dMkron",      float);
+  GET_COLUMN(Map         , "Map",         float);
+  GET_COLUMN(dMap        , "dMap",        float);
+  GET_COLUMN(flags       , "flags",       int);
   gfits_free_header (&theader);
   gfits_free_table  (&ftable);
 …
   ALLOCATE (detections, Detections, Nrow);
   for (i = 0; i < Nrow; i++) {
+    detections[i].imageID      = imageID[i];
+    detections[i].ippDetectID  = ippDetectID[i];
+    detections[i].objID        = objID[i];
     detections[i].detectID     = detectID[i];
     detections[i].ippObjID     = ippObjID[i];
+    detections[i].objID        = objID[i];
+    detections[i].photcode     = photcode[i];
+    detections[i].flags        = flags[i];
+    detections[i].zp           = zp[i];
+    detections[i].zpErr        = zpErr[i];
+    detections[i].airMass      = airMass[i];
+    detections[i].expTime      = expTime[i];
+    detections[i].ippDetectID  = ippDetectID[i];
+    detections[i].imageID      = imageID[i];
+    detections[i].catID        = catID[i];
     detections[i].ra           = ra[i];
     detections[i].dec          = dec[i];
     detections[i].raErr        = raErr[i];
     detections[i].decErr       = decErr[i];
+    detections[i].zp           = zp[i];
+    detections[i].telluricExt  = telluricExt[i];
+    detections[i].airmass      = airmass[i];
+    detections[i].expTime      = expTime[i];
+    detections[i].Mpsf         = Mpsf[i];
+    detections[i].dMpsf        = dMpsf[i];
+    detections[i].Mkron        = Mkron[i];
+    detections[i].dMkron       = dMkron[i];
+    detections[i].Map          = Map[i];
+    detections[i].dMap         = dMap[i];
+    detections[i].flags        = flags[i];
+  }
   fprintf (stderr, "loaded data for %lld detections\n", (long long) Nrow);
+  free (imageID    );
+  free (ippDetectID);
+  free (objID      );
   free (detectID   );
   free (ippObjID   );
+  free (objID      );
+  free (photcode   );
+  free (flags      );
+  free (zp         );
+  free (zpErr      );
+  free (airMass    );
+  free (expTime    );
+  free (ippDetectID);
+  free (imageID    );
+  free (catID      );
   free (ra         );
   free (dec        );
   free (raErr      );
   free (decErr     );
+  free (zp         );
+  free (telluricExt);
+  free (airmass    );
+  free (expTime    );
+  free (Mpsf       );
+  free (dMpsf      );
+  free (Mkron      );
+  free (dMkron     );
+  free (Map        );
+  free (dMap       );
+  free (flags      );
   gfits_free_header (&header);
 …
   // XXX need to get the bzero values right
+  gfits_define_bintable_column (&theader, "J", "imageID",     NULL, NULL, 1.0, BZERO_INT32);
+  gfits_define_bintable_column (&theader, "J", "ippDetectID", NULL, NULL, 1.0, BZERO_INT32);
+  gfits_define_bintable_column (&theader, "K", "objID",       NULL, NULL, 1.0, 0);
   gfits_define_bintable_column (&theader, "K", "detectID",    NULL, NULL, 1.0, 0);
   gfits_define_bintable_column (&theader, "K", "ippObjID",    NULL, NULL, 1.0, 0);
+  gfits_define_bintable_column (&theader, "K", "objID",       NULL, NULL, 1.0, 0);
+  // gfits_define_bintable_column (&theader, "K", "detectID",    NULL, NULL, 1.0, BZERO_INT64);
+  // gfits_define_bintable_column (&theader, "K", "ippObjID",    NULL, NULL, 1.0, BZERO_INT64);
+  // gfits_define_bintable_column (&theader, "K", "objID",       NULL, NULL, 1.0, BZERO_INT64);
+  gfits_define_bintable_column (&theader, "J", "photcode",    NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J", "flags",       NULL, NULL, 1.0, BZERO_INT32);
+  gfits_define_bintable_column (&theader, "E", "zp",          NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "zpErr",       NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "airMass",     NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "expTime",     NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J", "ippDetectID", NULL, NULL, 1.0, FT_BZERO_INT32);
+  gfits_define_bintable_column (&theader, "J", "imageID",     NULL, NULL, 1.0, FT_BZERO_INT32);
+  gfits_define_bintable_column (&theader, "J", "catID",       NULL, NULL, 1.0, FT_BZERO_INT32);
   gfits_define_bintable_column (&theader, "D", "ra",          NULL, NULL, 1.0, 0.0);
   gfits_define_bintable_column (&theader, "D", "dec",         NULL, NULL, 1.0, 0.0);
   gfits_define_bintable_column (&theader, "E", "raErr",       NULL, NULL, 1.0, 0.0);
   gfits_define_bintable_column (&theader, "E", "decErr",      NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "zp",          NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "telluricExt", NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "airmass",     NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "expTime",     NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "Mpsf",        NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "dMpsf",       NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "Mkron",       NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "dMkron",      NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "Map",         NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "dMap",        NULL, NULL, 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J", "flags",       NULL, NULL, 1.0, FT_BZERO_INT32);
   // generate the output array that carries the data
 …
   // create intermediate storage arrays
+   int32_t   *imageID     ; ALLOCATE (imageID     ,   int32_t, Ndetections);
+  uint32_t   *ippDetectID ; ALLOCATE (ippDetectID ,  uint32_t, Ndetections);
+  uint64_t   *objID       ; ALLOCATE (objID       ,  uint64_t, Ndetections);
   uint64_t   *detectID    ; ALLOCATE (detectID    ,  uint64_t, Ndetections);
   uint64_t   *ippObjID    ; ALLOCATE (ippObjID    ,  uint64_t, Ndetections);
+  uint64_t   *objID       ; ALLOCATE (objID       ,  uint64_t, Ndetections);
+  int        *photcode    ; ALLOCATE (photcode    ,  int,      Ndetections);
+  uint32_t   *flags       ; ALLOCATE (flags       ,  uint32_t, Ndetections);
+  float      *zp          ; ALLOCATE (zp          ,  float,    Ndetections);
+  float      *zpErr       ; ALLOCATE (zpErr       ,  float,    Ndetections);
+  float      *airMass     ; ALLOCATE (airMass     ,  float,    Ndetections);
+  float      *expTime     ; ALLOCATE (expTime     ,  float,    Ndetections);
+  uint32_t   *ippDetectID ; ALLOCATE (ippDetectID ,  uint32_t, Ndetections);
+   int32_t   *imageID     ; ALLOCATE (imageID     ,   int32_t, Ndetections);
+   int32_t   *catID       ; ALLOCATE (catID       ,   int32_t, Ndetections);
   double     *ra          ; ALLOCATE (ra          ,  double,   Ndetections);
   double     *dec         ; ALLOCATE (dec         ,  double,   Ndetections);
   float      *raErr       ; ALLOCATE (raErr       ,  float,    Ndetections);
   float      *decErr      ; ALLOCATE (decErr      ,  float,    Ndetections);
+  float      *zp          ; ALLOCATE (zp          ,  float,    Ndetections);
+  float      *telluricExt ; ALLOCATE (telluricExt ,  float,    Ndetections);
+  float      *airmass     ; ALLOCATE (airmass     ,  float,    Ndetections);
+  float      *expTime     ; ALLOCATE (expTime     ,  float,    Ndetections);
+  float      *Mpsf        ; ALLOCATE (Mpsf        ,  float,    Ndetections);
+  float      *dMpsf       ; ALLOCATE (dMpsf       ,  float,    Ndetections);
+  float      *Mkron       ; ALLOCATE (Mkron       ,  float,    Ndetections);
+  float      *dMkron      ; ALLOCATE (dMkron      ,  float,    Ndetections);
+  float      *Map         ; ALLOCATE (Map         ,  float,    Ndetections);
+  float      *dMap        ; ALLOCATE (dMap        ,  float,    Ndetections);
+  uint32_t   *flags       ; ALLOCATE (flags       ,  uint32_t, Ndetections);
   // assign the storage arrays
   for (i = 0; i < Ndetections; i++) {
+    imageID[i]     = detections[i].imageID     ;
+    ippDetectID[i] = detections[i].ippDetectID ;
+    objID[i]       = detections[i].objID       ;
     detectID[i]    = detections[i].detectID    ;
     ippObjID[i]    = detections[i].ippObjID    ;
+    objID[i]       = detections[i].objID       ;
+    photcode[i]    = detections[i].photcode    ;
+    flags[i]       = detections[i].flags       ;
+    zp[i]          = detections[i].zp          ;
+    zpErr[i]       = detections[i].zpErr       ;
+    airMass[i]     = detections[i].airMass     ;
+    expTime[i]     = detections[i].expTime     ;
+    ippDetectID[i] = detections[i].ippDetectID ;
+    imageID[i]     = detections[i].imageID     ;
+    catID[i]       = detections[i].catID       ;
     ra[i]          = detections[i].ra          ;
     dec[i]         = detections[i].dec         ;
     raErr[i]       = detections[i].raErr       ;
     decErr[i]      = detections[i].decErr      ;
+    zp[i]          = detections[i].zp          ;
+    telluricExt[i] = detections[i].telluricExt ;
+    airmass[i]     = detections[i].airmass     ;
+    expTime[i]     = detections[i].expTime     ;
+    Mpsf[i]        = detections[i].Mpsf        ;
+    dMpsf[i]       = detections[i].dMpsf       ;
+    Mkron[i]       = detections[i].Mkron       ;
+    dMkron[i]      = detections[i].dMkron      ;
+    Map[i]         = detections[i].Map         ;
+    dMap[i]        = detections[i].dMap        ;
+    flags[i]       = detections[i].flags       ;
+  }
   // add the columns to the output array
+  gfits_set_bintable_column (&theader, &ftable, "imageID",     imageID     , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "ippDetectID", ippDetectID , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "objID",       objID       , Ndetections);
   gfits_set_bintable_column (&theader, &ftable, "detectID",    detectID    , Ndetections);
   gfits_set_bintable_column (&theader, &ftable, "ippObjID",    ippObjID    , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "objID",       objID       , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "photcode",    photcode    , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "flags",       flags       , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "zp",          zp          , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "zpErr",       zpErr       , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "airMass",     airMass     , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "expTime",     expTime     , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "ippDetectID", ippDetectID , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "imageID",     imageID     , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "catID",       catID       , Ndetections);
   gfits_set_bintable_column (&theader, &ftable, "ra",          ra          , Ndetections);
   gfits_set_bintable_column (&theader, &ftable, "dec",         dec         , Ndetections);
   gfits_set_bintable_column (&theader, &ftable, "raErr",       raErr       , Ndetections);
   gfits_set_bintable_column (&theader, &ftable, "decErr",      decErr      , Ndetections);
+  free (imageID     );
+  free (ippDetectID );
+  gfits_set_bintable_column (&theader, &ftable, "zp",          zp          , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "telluricExt", telluricExt , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "airmass",     airmass     , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "expTime",     expTime     , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "Mpsf",        Mpsf        , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "dMpsf",       dMpsf       , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "Mkron",       Mkron       , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "dMkron",      dMkron      , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "Map",         Map         , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "dMap",        dMap        , Ndetections);
+  gfits_set_bintable_column (&theader, &ftable, "flags",       flags       , Ndetections);
+  free (objID       );
   free (detectID    );
   free (ippObjID    );
+  free (objID       );
+  free (photcode    );
+  free (flags       );
+  free (zp          );
+  free (zpErr       );
+  free (airMass     );
+  free (expTime     );
+  free (ippDetectID );
+  free (imageID     );
+  free (catID       );
   free (ra          );
   free (dec         );
   free (raErr       );
   free (decErr      );
+  free (zp          );
+  free (telluricExt );
+  free (airmass     );
+  free (expTime     );
+  free (Mpsf        );
+  free (dMpsf       );
+  free (Mkron       );
+  free (dMkron      );
+  free (Map         );
+  free (dMap        );
+  free (flags       );
   gfits_fwrite_Theader (f, &theader);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvopsps/src/dvopsps.c

-              r35098
+              r37822
   if (!strcasecmp (argv[1], "objects")) {
     status = insert_objects_dvopsps ();
+  }
+  if (!strcasecmp (argv[1], "forced_warp_objects")) {
+    status = insert_FWobjects_dvopsps ();
+  }
   if (!strcasecmp (argv[1], "skytable")) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvopsps/src/dvopsps_client.c

-              r35111
+              r37822
     status = insert_objects_dvopsps ();
+  }
+  if (!strcasecmp (argv[1], "forced_warp_objects")) {
+    status = insert_FWobjects_dvopsps ();
+  }
   if (status == -1) {
     fprintf (stderr, "invalid mode, should be : detections, skytable\n");

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvopsps/src/initialize_dvopsps.c

r36188	r37822
21	21	fprintf (stderr, "\n");
22	22
23		fprintf (stderr, " (mode) is one of detections, objects, skytable\n");
	23	fprintf (stderr, " (mode) is one of detections, objects, forced_warp_objects, skytable\n");
24	24
25	25	fprintf (stderr, "\n");

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvopsps/src/insert_detections_dvopsps.c

-              r37304
+              r37822
     dvo_catalog_unlock (&catalog);
     dvo_catalog_free (&catalog);
+    if (!status) {
+      fprintf (stderr, "failure to insert data in mysql\n");
+      exit (2);
+    }
+  }
 …
+}
-# define PRINT_FLOAT(BUFFER,FIELD,FORMAT)                 \
-  if (!isfinite(FIELD)) PrintIOBuffer (BUFFER, "NULL, "); \
-  else PrintIOBuffer (BUFFER, FORMAT, FIELD);
-int insert_detections_mysql_detvalue (IOBuffer *buffer, Detections *detection) {
-  PrintIOBuffer (buffer, "(%d, ", detection->imageID);    // imageID
-  PrintIOBuffer (buffer, "%u, ", detection->ippDetectID); // ippDetectID
-  PrintIOBuffer (buffer, "%lu, ", detection->detectID);   // detectID
-  PrintIOBuffer (buffer, "%lu, ", detection->ippObjID);   // ippObjID
-  PrintIOBuffer (buffer, "%lu, ", detection->objID);      // objID
-  PrintIOBuffer (buffer, "%u, ", detection->flags);       // flags
-  PRINT_FLOAT(buffer, detection->zp,      "%.6f, ");
-  PRINT_FLOAT(buffer, detection->zpErr,   "%.6f, ");
-  PRINT_FLOAT(buffer, detection->airMass, "%.6f, ");
-  PRINT_FLOAT(buffer, detection->expTime, "%.6f, ");
-  PRINT_FLOAT(buffer, detection->ra,      "%.8f, ");
-  PRINT_FLOAT(buffer, detection->dec,     "%.8f, ");
-  PRINT_FLOAT(buffer, detection->raErr,   "%.6f, ");
-  PRINT_FLOAT(buffer, detection->decErr,  "%.6f),\n");
-  return TRUE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvopsps/src/insert_detections_dvopsps_catalog.c

-              r37048
+              r37822
 Detections *detections = NULL;
+static float ZeroPoint = 25.0;
 int init_detections () {
   NDETECTIONS = 1000;
 …
   off_t i, j;
+  ZeroPoint = GetZeroPoint();
   int missingID = 0;
 …
       if (measure->photcode >=  PHOTCODE_END) continue;
+      PhotCode *code = GetPhotcodebyCode(measure->photcode);
+      detections[Ndetections].imageID     = measure->imageID;    // imageID
+      detections[Ndetections].ippDetectID = measure->detID;   // ippDetectID
+      detections[Ndetections].detectID    = measure->extID;   // detectID
+      detections[Ndetections].ippObjID    = ((uint64_t)average->catID * 1000000000) + (uint64_t)average->objID; // ippObjID
+      // NOTE: this is better, but the above is the current ippToPsps value
+      // detections[Ndetections]. ((uint64_t)average->catID << 32) + (uint64_t)average->objID; // ippObjID
+      detections[Ndetections].objID        = average->extID;   // objID
+      detections[Ndetections].photcode     = measure->photcode;   // photcode
+      detections[Ndetections].flags        = measure->dbFlags;  // flags
+      detections[Ndetections].zp           = code->C * 0.001 + code->K * (measure->airmass - 1) - measure->Mcal;   // zp
+      detections[Ndetections].zpErr        = measure->dMcal;    // zpErr
+      detections[Ndetections].airMass      = measure->airmass;
+      detections[Ndetections].expTime      = pow(10.0, 0.4 * measure->dt);    // expTime
+      detections[Ndetections].ra           = measure->R;    // ra
+      detections[Ndetections].dec          = measure->D;    // dec
+      detections[Ndetections].raErr        = measure->dXccd * 0.01 * fabs(measure->pltscale); // estimate of raErr
+      detections[Ndetections].decErr       = measure->dYccd * 0.01 * fabs(measure->pltscale); // estimate of decErr
+      assign_detection_values (&detections[Ndetections], measure, average);
       Ndetections ++;
       myAssert (Ndetections <= NDETECTIONS, "programming error");
+    }
 …
   off_t found = 0;
+  ZeroPoint = GetZeroPoint();
   INITTIME;
 …
       // XXX check return status
+      if (!insert_detections_mysql_value (&buffer, &average[i], &measure[Nmeas])) {
+      Detections detection;
+      assign_detection_values (&detection, &measure[Nmeas], &average[i]);
+      if (!insert_detections_mysql_detvalue (&buffer, &detection)) {
         fprintf (stderr, "failure to insert detections in mysql\n");
         status = FALSE;
 …
+  }
+  // PrintIOBuffer (buffer, "INSERT INTO dvoDetectionFull (imageID, ippDetectID, detectID, ippObjID, objID, photcode, flags, zp, zpErr, airMass, expTime, ra, dec_, raErr, decErr) VALUES \n");
+  PrintIOBuffer (buffer, "INSERT INTO dvoDetectionFull (imageID, ippDetectID, detectID, ippObjID, objID, flags, zp, zpErr, airMass, expTime, ra, dec_, raErr, decErr) VALUES \n");
+  return TRUE;
+}
+# define PRINT_FLOAT(BUFFER,FIELD,FORMAT)                 \
+  if (isinf(FIELD) || isnan(FIELD)) PrintIOBuffer (BUFFER, "NULL, ");   \
+  else PrintIOBuffer (BUFFER, FORMAT, FIELD);
+int insert_detections_mysql_value (IOBuffer *buffer, Average *average, Measure *measure) {
+  PhotCode *code = GetPhotcodebyCode(measure->photcode);
+  PrintIOBuffer (buffer, "(%d, ", measure->imageID);      // imageID
+  PrintIOBuffer (buffer, "%u, ", measure->detID); // ippDetectID
+  PrintIOBuffer (buffer, "%lu, ", measure->extID);        // detectID
+  PrintIOBuffer (buffer, "%lu, ", ((uint64_t)average->catID * 1000000000) + (uint64_t)average->objID);    // ippObjID
+  // NOTE: the following is better, but the above is the current ippToPsps value
+  // ((uint64_t)average->catID << 32) + (uint64_t)average->objID, // ippObjID
+  PrintIOBuffer (buffer, "%lu, ", average->extID);        // objID
+  // XXX PrintIOBuffer (buffer, "%d, ", measure->photcode);       // photcode
+  PrintIOBuffer (buffer, "%u, ", measure->dbFlags);       // flags
+  float zp = code->C * 0.001 + code->K * (measure->airmass - 1) - measure->Mcal;
+  float exptime = pow(10.0, 0.4 * measure->dt);
+  double ra  = measure->R;
+  double dec = measure->D;
+  double dR = measure->dXccd * 0.01 * fabs(measure->pltscale);
+  double dD = measure->dYccd * 0.01 * fabs(measure->pltscale);
+  PRINT_FLOAT(buffer, zp,               "%.6f, ");
+  PRINT_FLOAT(buffer, measure->dMcal,   "%.6f, ");
+  PRINT_FLOAT(buffer, measure->airmass, "%.6f, ");
+  PRINT_FLOAT(buffer, exptime,          "%.6f, ");
+  PRINT_FLOAT(buffer, ra,               "%.8f, ");
+  PRINT_FLOAT(buffer, dec,              "%.8f, ");
+  PRINT_FLOAT(buffer, dR,               "%.6f, ");
+  PRINT_FLOAT(buffer, dD,               "%.6f),\n");
+  return TRUE;
+}
+  PrintIOBuffer (buffer, "INSERT INTO dvoDetectionFull (objID, detectID, ippObjID, ippDetectID, imageID, catID, ");
+  PrintIOBuffer (buffer, "ra, dec_, raErr, decErr, zp, telluricExt, airmass, expTime, ");
+  PrintIOBuffer (buffer, "Mpsf, dMpsf, Mkron, dMkron, Map, dMap, flags) VALUES \n");
+  return TRUE;
+}
 int insert_detections_mysql_commit (IOBuffer *buffer, MYSQL *mysql) {
 …
   // XXX check return status
   if (mysql) {
-    if (DEBUG) fprintf (stderr, "%s\n", buffer->buffer);
     int mysqlStatus = mysql_query(mysql, buffer->buffer);
     if (mysqlStatus) {
 …
       fprintf (stderr, "%s\n", mysql_error(mysql));
       fprintf (stderr, "Nbuffer: %d\n", buffer->Nbuffer);
+      if (DEBUG) fprintf (stderr, "%s\n", buffer->buffer);
       status = FALSE;
+    }
 …
   return status;
+}
+# define PRINT_FLOAT(BUFFER,FIELD,FORMAT)                 \
+  if (!isfinite(FIELD)) PrintIOBuffer (BUFFER, "NULL, "); \
+  else PrintIOBuffer (BUFFER, FORMAT, FIELD);
+int insert_detections_mysql_detvalue (IOBuffer *buffer, Detections *detection) {
+  if (detection->detectID == 164458937060000101) {
+    fprintf (stderr, "isfinite: %d\n", isfinite(detection->dMpsf));
+    fprintf (stderr, "isnan: %d\n", isnan(detection->dMpsf));
+    fprintf (stderr, "isinf: %d\n", isinf(detection->dMpsf));
+  }
+  // XXX I needed OFF_T_FMT on my 32bit ubuntu laptop; ok on 64bit?
+  PrintIOBuffer (buffer, "("OFF_T_FMT", ", detection->objID);       // objID
+  PrintIOBuffer (buffer,  OFF_T_FMT", ", detection->detectID);    // detectID
+  PrintIOBuffer (buffer,  OFF_T_FMT", ", detection->ippObjID);    // ippObjID
+  PrintIOBuffer (buffer,  "%u,  ", detection->ippDetectID); // ippDetectID
+  PrintIOBuffer (buffer,  "%d,  ", detection->imageID);     // imageID
+  PrintIOBuffer (buffer,  "%d,  ", detection->catID);       // DVO Catalog ID
+  PRINT_FLOAT(buffer, detection->ra,          "%.8f, ");
+  PRINT_FLOAT(buffer, detection->dec,         "%.8f, ");
+  PRINT_FLOAT(buffer, detection->raErr,       "%.6f, ");
+  PRINT_FLOAT(buffer, detection->decErr,      "%.6f, ");
+  PRINT_FLOAT(buffer, detection->zp,          "%.6f, ");
+  PRINT_FLOAT(buffer, detection->telluricExt, "%.6f, ");
+  PRINT_FLOAT(buffer, detection->airmass,     "%.6f, ");
+  PRINT_FLOAT(buffer, detection->expTime,     "%.6f, ");
+  PRINT_FLOAT(buffer, detection->Mpsf,        "%.6f, ");
+  PRINT_FLOAT(buffer, detection->dMpsf,       "%.6f, ");
+  PRINT_FLOAT(buffer, detection->Mkron,       "%.6f, ");
+  PRINT_FLOAT(buffer, detection->dMkron,      "%.6f, ");
+  PRINT_FLOAT(buffer, detection->Map,         "%.6f, ");
+  PRINT_FLOAT(buffer, detection->dMap,        "%.6f, ");
+  PrintIOBuffer (buffer, "%u),\n", detection->flags);     // flags
+  return TRUE;
+}
+float getMagFromValueOrFlux (float flux, float mag, float zp) {
+  // first, if mag is finite, use mag:
+  if (isfinite(mag)) {
+    return (zp + mag - ZeroPoint);
+  }
+  if (isfinite(flux) && (flux > 0.0)) {
+    // fprintf (stderr, "funny flux: %f with mag %f\n", flux, mag);
+    return (zp - 2.5*log10(flux));
+  }
+  if (isfinite(flux) && (flux <= 0.0)) {
+    return (NAN);
+  }
+  return (NAN);
+}
+float getdMagFromValueOrFlux (float flux, float dflux, float dmag) {
+  // first, if mag is finite, use mag:
+  if (isfinite(dmag)) {
+    return (dmag);
+  }
+  if (isfinite(flux) && isfinite(dflux)) {
+    return (dflux / fabs(flux));
+  }
+  return (NAN);
+}
+int assign_detection_values (Detections *detection, Measure *measure, Average *average) {
+  PhotCode *code = GetPhotcodebyCode(measure->photcode);
+  uint64_t ippObjID = ((uint64_t)average->catID << 32) + (uint64_t)average->objID; // ippObjID
+  float nominalZP   = code->C * 0.001 + code->K * (measure->airmass - 1);
+  float zp          = nominalZP - measure->Mcal;
+  float telluricExt = - measure->Mcal;
+  float expTime     = pow(10.0, 0.4 * measure->dt);
+  float airmass     = measure->airmass;
+  detection->objID        = average->extID;   // objID
+  detection->detectID     = measure->extID;   // detectID
+  detection->ippObjID     = ippObjID;         // ippObjID
+  detection->ippDetectID  = measure->detID;   // ippDetectID
+  detection->imageID      = measure->imageID; // imageID
+  detection->catID        = measure->catID;   // catID
+  detection->ra           = measure->R;    // ra
+  detection->dec          = measure->D;    // dec
+  detection->raErr        = measure->dXccd * 0.01 * fabs(measure->pltscale); // estimate of raErr
+  detection->decErr       = measure->dYccd * 0.01 * fabs(measure->pltscale); // estimate of decErr
+  detection->zp           = zp;
+  detection->telluricExt  = telluricExt;
+  detection->airmass      = airmass;
+  detection->expTime      = expTime;
+  // XXX clean this up with dvo_photcode_ops calls:
+  // if (isfinite(measure->FluxPSF) && (measure->FluxPSF < 0.0))
+  detection->Mpsf  = getMagFromValueOrFlux (measure->FluxPSF,  measure->M,     zp);
+  detection->Mkron = getMagFromValueOrFlux (measure->FluxKron, measure->Mkron, zp);
+  detection->Map   = getMagFromValueOrFlux (measure->FluxAp,   measure->Map,   zp);
+  detection->dMpsf  = getdMagFromValueOrFlux (measure->FluxPSF,  measure->dFluxPSF,  measure->dM);
+  detection->dMkron = getdMagFromValueOrFlux (measure->FluxKron, measure->dFluxKron, measure->dMkron);
+  detection->dMap   = getdMagFromValueOrFlux (measure->FluxAp,   measure->dFluxAp,   measure->dMap);
+  detection->flags  = measure->dbFlags;  // flags
+  return TRUE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvopsps/src/insert_objects_dvopsps_catalog.c

-              r37048
+              r37822
   bzero (buffer.buffer, buffer.Nalloc);
+  // Only send the necessary fields (eg, do not sent parallax and pm)
   PrintIOBuffer (&buffer, "CREATE TABLE %s_cpt ("
+                 "RA DOUBLE,  "
+                 "DEC_ DOUBLE,  "
+                 "RA_ERR FLOAT,  "
+                 "DEC_ERR FLOAT,  "
+                 "U_RA FLOAT,  "
+                 "U_DEC FLOAT,  "
+                 "V_RA_ERR FLOAT,  "
+                 "V_DEC_ERR FLOAT,  "
+                 "PAR FLOAT,  "
+                 "PAR_ERR FLOAT,  "
+                 "CHISQ_POS FLOAT,  "
+                 "CHISQ_PM FLOAT,  "
+                 "CHISQ_PAP FLOAT,  "
+                 "MEAN_EPOCH INT,  "
+                 "TIME_RANGE INT,  "
+                 "PSF_QF FLOAT, "
+                 "PSF_QF_PERF FLOAT,  "
+                 "STARGAL_SEP FLOAT,  "
+                 "NUMBER_POS SMALLINT,  "
+                 "NMEASURE SMALLINT,  "
+                 "NMISSING SMALLINT,  "
+                 "NEXTEND SMALLINT,  "
+                 "OFF_MEASURE INT,  "
+                 "OFF_MISSING INT,  "
+                 "OFF_EXTEND INT,  "
+                 "FLAGS INT,  "
+                 "PHOTFLAGS_U INT,  "
+                 "PHOTFLAGS_L INT,  "
+                 "OBJ_ID INT,  "
+                 "CAT_ID INT,  "
+                 "EXT_ID BIGINT"
+                 "EXT_ID        BIGINT,   "
+                 "OBJ_ID        INT,      "
+                 "CAT_ID        INT,      "
+                 "TESS_ID       TINYINT,  "
+                 "PROJECTION_ID SMALLINT, "
+                 "SKYCELL_ID    TINYINT,  "
+                 "RA_STK        DOUBLE,   "
+                 "DEC_STK       DOUBLE,   "
+                 "RA_STK_ERR    FLOAT,    "
+                 "DEC_STK_ERR   FLOAT,    "
+                 "RA_MEAN       DOUBLE,   "
+                 "DEC_MEAN      DOUBLE,   "
+                 "RA_ERR        FLOAT,    "
+                 "DEC_ERR       FLOAT,    "
+                 "CHISQ_POS     FLOAT,    "
+                 "CHISQ_PM      FLOAT,    "
+                 "CHISQ_PAR     FLOAT,    "
+                 "FLAGS         INT       "
                  ")\n", basename);
+// skipping these cpt fields:
+//               "U_RA        FLOAT,  "
+//               "U_DEC       FLOAT,  "
+//               "V_RA_ERR    FLOAT,  "
+//               "V_DEC_ERR   FLOAT,  "
+//               "PAR         FLOAT,  "
+//               "PAR_ERR     FLOAT,  "
+//               "OFF_MEASURE INT,  "
+//               "OFF_MISSING INT,  "
+//               "OFF_EXTEND  INT,  "
+//               "PSF_QF      FLOAT, "
+//               "PSF_QF_PERF FLOAT,  "
+//               "STARGAL_SEP FLOAT,  "
+//               "NUMBER_POS  SMALLINT,  "
+//               "NMEASURE    SMALLINT,  "
+//               "NMISSING    SMALLINT,  "
+//               "NEXTEND     SMALLINT,  "
+//               "PHOTFLAGS_U INT,  "
+//               "PHOTFLAGS_L INT,  "
   if (DEBUG) fprintf (stderr, "%s\n", buffer.buffer);
 …
   PrintIOBuffer (&buffer, "CREATE TABLE %s_cps ("
                  "MAG FLOAT,  "
                  "MAG_AP FLOAT,  "
                  "MAG_KRON FLOAT,  "
                  "MAG_KRON_ERR FLOAT,  "
                  "MAG_ERR FLOAT,  "
                  "MAG_CHI FLOAT,  "
                  "STACK_PSF_MAG FLOAT,  "
                  "STACK_PSF_MAG_ERR FLOAT,  "
                  "STACK_KRON_MAG FLOAT,  "
                  "STACK_KRON_MAG_ERR FLOAT,  "
                  "FLAGS INT,  "
                  "NCODE SMALLINT,  "
                  "NUSED SMALLINT,  "
                  "MAG_20 SMALLINT,  "
                  "MAG_80 SMALLINT,  "
                  "UBERCAL_DIST SMALLINT,  "
                  "MAG_STDEV SMALLINT,  "
                  "STACK_DETECT_ID BIGINT"
+                 "MAG            FLOAT,  "
+                 "MAG_ERR        FLOAT,  "
+                 "MAG_STDEV      FLOAT,  "
+                 "MAG_MIN        FLOAT,  "
+                 "MAG_MAX        FLOAT,  "
+                 "NUSED          SMALLINT,  "
+                 "MAG_KRON       FLOAT,  "
+                 "MAG_KRON_ERR   FLOAT,  "
+                 "MAG_KRON_STDEV FLOAT,  "
+                 "NUSED_KRON     SMALLINT,  "
+                 "MAG_AP         FLOAT,  "
+                 "MAG_AP_ERR     FLOAT,  "
+                 "MAG_AP_STDEV   FLOAT,  "
+                 "NUSED_AP       SMALLINT,  "
+                 "NCODE          SMALLINT,  "
+                 "NSTACK_DET     SMALLINT,  "
+                 "PSF_QF_PERF_MAX FLOAT, "
+                 "FLAGS          INT "
                  ")\n", basename);
- //              "FLUX_PSF FLOAT,  "
- //              "FLUX_PSF_ERR FLOAT,  "
- //              "FLUX_KRON FLOAT,  "
- //              "FLUX_KRON_ERR FLOAT,  "
   if (DEBUG) fprintf (stderr, "%s\n", buffer.buffer);
 …
   PrintIOBuffer (ave_buffer, "INSERT INTO %s_cpt ("
+                 "RA, "
+                 "DEC_, "
+                 "RA_ERR, "
+                 "DEC_ERR, "
+                 "U_RA, "
+                 "U_DEC, "
+                 "V_RA_ERR, "
+                 "V_DEC_ERR, "
+                 "PAR, "
+                 "PAR_ERR, "
+                 "CHISQ_POS, "
+                 "CHISQ_PM, "
+                 "CHISQ_PAP, "
+                 "MEAN_EPOCH, "
+                 "TIME_RANGE, "
+                 "PSF_QF, "
+                 "PSF_QF_PERF, "
+                 "STARGAL_SEP, "
+                 "NUMBER_POS, "
+                 "NMEASURE, "
+                 "NMISSING, "
+                 "NEXTEND, "
+                 "OFF_MEASURE, "
+                 "OFF_MISSING, "
+                 "OFF_EXTEND, "
+                 "FLAGS, "
+                 "PHOTFLAGS_U, "
+                 "PHOTFLAGS_L, "
+                 "OBJ_ID, "
+                 "CAT_ID, "
+                 "EXT_ID"
+                 "EXT_ID,        "
+                 "OBJ_ID,        "
+                 "CAT_ID,        "
+                 "TESS_ID,       "
+                 "PROJECTION_ID, "
+                 "SKYCELL_ID,    "
+                 "RA_STK,        "
+                 "DEC_STK,       "
+                 "RA_STK_ERR,    "
+                 "DEC_STK_ERR,   "
+                 "RA_MEAN,       "
+                 "DEC_MEAN,      "
+                 "RA_ERR,        "
+                 "DEC_ERR,       "
+                 "CHISQ_POS,     "
+                 "CHISQ_PM,      "
+                 "CHISQ_PAR,     "
+                 "FLAGS          "
                  ") VALUES \n", basename);
 …
   PrintIOBuffer (sec_buffer, "INSERT INTO %s_cps ("
                  "MAG, "
+                 "MAG_AP, "
+                 "MAG_ERR, "
+                 "MAG_STDEV, "
+                 "MAG_MIN, "
+                 "MAG_MAX, "
+                 "NUSED, "
                  "MAG_KRON, "
                  "MAG_KRON_ERR, "
+                 "MAG_ERR, "
+                 "MAG_CHI, "
+                 "STACK_PSF_MAG, "
+                 "STACK_PSF_MAG_ERR, "
+                 "STACK_KRON_MAG, "
+                 "STACK_KRON_MAG_ERR, "
+                 "FLAGS, "
+                 "MAG_KRON_STDEV, "
+                 "NUSED_KRON, "
+                 "MAG_AP, "
+                 "MAG_AP_ERR, "
+                 "MAG_AP_STDEV, "
+                 "NUSED_AP, "
                  "NCODE, "
+                 "NUSED, "
+                 "MAG_20, "
+                 "MAG_80, "
+                 "UBERCAL_DIST, "
+                 "MAG_STDEV, "
+                 "STACK_DETECT_ID "
+                 "NSTACK_DET,  "
+                 "PSF_QF_PERF_MAX, "
+                 "FLAGS "
                  ") VALUES \n", basename);
   return TRUE;
 …
 // XXX this bit could/should be autocoded...
   PrintIOBuffer (ave_buffer, " (");
+  PrintIOBuffer (ave_buffer, OFF_T_FMT", ", average->extID);
+  PrintIOBuffer (ave_buffer, "%u,  ", average->objID);
+  PrintIOBuffer (ave_buffer, "%u,  ", average->catID);
+  PrintIOBuffer (ave_buffer, "%hhd, ", average->tessID);
+  PrintIOBuffer (ave_buffer, "%hd,  ", average->projectionID);
+  PrintIOBuffer (ave_buffer, "%hhd, ", average->skycellID);
+  PRINT_FLOAT(ave_buffer, average->Rstk,     "%.8f, ");  // 0.036 mas precision
+  PRINT_FLOAT(ave_buffer, average->Dstk,     "%.8f, ");  // 0.036 mas precision
+  PRINT_FLOAT(ave_buffer, average->dRstk,    "%.5f, ");  // 0.010 mas precision
+  PRINT_FLOAT(ave_buffer, average->dDstk,    "%.5f, ");  // 0.010 mas precision
   PRINT_FLOAT(ave_buffer, average->R,        "%.8f, ");  // 0.036 mas precision
   PRINT_FLOAT(ave_buffer, average->D,        "%.8f, ");  // 0.036 mas precision
   PRINT_FLOAT(ave_buffer, average->dR,       "%.5f, ");  // 0.010 mas precision
   PRINT_FLOAT(ave_buffer, average->dD,       "%.5f, ");  // 0.010 mas precision
+  PRINT_FLOAT(ave_buffer, average->uR,       "%.5f, ");  // 0.010 mas/yr precision
+  PRINT_FLOAT(ave_buffer, average->uD,       "%.5f, ");
+  PRINT_FLOAT(ave_buffer, average->duR,      "%.5f, ");
+  PRINT_FLOAT(ave_buffer, average->duD,      "%.5f, ");
+  PRINT_FLOAT(ave_buffer, average->P,        "%.5f, ");
+  PRINT_FLOAT(ave_buffer, average->dP,       "%.5f, ");
   PRINT_FLOAT(ave_buffer, average->ChiSqAve, "%.4f, ");
   PRINT_FLOAT(ave_buffer, average->ChiSqPM,  "%.4f, ");
   PRINT_FLOAT(ave_buffer, average->ChiSqPar, "%.4f, ");
+  PrintIOBuffer (ave_buffer, "%d, ",  average->Tmean);
+  PrintIOBuffer (ave_buffer, "%d, ",  average->Trange);
+  PRINT_FLOAT(ave_buffer, average->psfQF,     "%.3f, ");
+  PRINT_FLOAT(ave_buffer, average->psfQFperf, "%.3f, ");
+  PRINT_FLOAT(ave_buffer, average->stargal,   "%.3f, ");
+  PrintIOBuffer (ave_buffer, "%hu, ", average->Npos);
+  PrintIOBuffer (ave_buffer, "%hu, ", average->Nmeasure);
+  PrintIOBuffer (ave_buffer, "%hu, ", average->Nmissing);
+  PrintIOBuffer (ave_buffer, "%hu, ", average->Nextend);
+  PrintIOBuffer (ave_buffer, "%d, ",  average->measureOffset);
+  PrintIOBuffer (ave_buffer, "%d, ",  average->missingOffset);
+  PrintIOBuffer (ave_buffer, "%d, ",  0); // was : average->extendOffset);
+  PrintIOBuffer (ave_buffer, "%u, ",  average->flags);
+  PrintIOBuffer (ave_buffer, "%u, ",  average->photFlagsUpper);
+  PrintIOBuffer (ave_buffer, "%u, ",  average->photFlagsLower);
+  PrintIOBuffer (ave_buffer, "%u, ",  average->objID);
+  PrintIOBuffer (ave_buffer, "%u, ",  average->catID);
+  PrintIOBuffer (ave_buffer, "%lu",   average->extID);
+  PrintIOBuffer (ave_buffer, "%u ",  average->flags);
   PrintIOBuffer (ave_buffer, "),\n");
+  // XXX what rules for keeping or NAN-ing various mags?
   for (i = 0; i < Nsecfilt; i++) {
     float meanPSFMag    = -999.0;
     float meanPSFMagErr = -999.0;
+    float meanPSFMagStd = -999.0;
+    float meanPSFMagMin = -999.0;
+    float meanPSFMagMax = -999.0;
     if (isfinite(secfilt->dM) && isfinite(secfilt->M)) {
       meanPSFMag = secfilt->M;
+      meanPSFMag    = secfilt->M;
       meanPSFMagErr = secfilt->dM;
+      meanPSFMagStd = secfilt->Mstdev;
+      meanPSFMagMin = secfilt->Mmin;
+      meanPSFMagMax = secfilt->Mmax;
+    }
     float meanKronMag    = -999.0;
     float meanKronMagErr = -999.0;
+    float meanKronMagStd = -999.0;
     if (isfinite(secfilt->dMkron) && isfinite(secfilt->Mkron) && (secfilt->dMkron < 0.333)) {
       meanKronMag = secfilt->Mkron;
+      meanKronMag    = secfilt->Mkron;
       meanKronMagErr = secfilt->dMkron;
+      meanKronMagStd = secfilt->sMkron;
+    }
     float meanApMag    = -999.0;
+    if (isfinite(secfilt->Map)) {
+      meanApMag = secfilt->Map;
+    }
+    float stackPSFMag    = -999.0;
+    float stackPSFMagErr = -999.0;
+    if (isfinite(secfilt->dFpsfStk) && isfinite(secfilt->FpsfStk) && (secfilt->dFpsfStk > 0.0)) {
+      float SN = secfilt->FpsfStk / secfilt->dFpsfStk;
+      if (SN > 3.0) {
+        stackPSFMag = -2.5 * log10(secfilt->FpsfStk) + 8.9;
+        stackPSFMagErr = secfilt->dFpsfStk / secfilt->FpsfStk;
+      }
+    }
+    float stackKronMag    = -999.0;
+    float stackKronMagErr = -999.0;
+    if (isfinite(secfilt->dFkronStk) && isfinite(secfilt->FkronStk) && (secfilt->dFkronStk > 0.0)) {
+      float SN = secfilt->FkronStk / secfilt->dFkronStk;
+      if (SN > 3.0) {
+        stackKronMag = -2.5 * log10(secfilt->FkronStk) + 8.9;
+        stackKronMagErr = secfilt->dFkronStk / secfilt->FkronStk;
+      }
+    float meanApMagErr = -999.0;
+    float meanApMagStd = -999.0;
+    if (isfinite(secfilt->dMap) && isfinite(secfilt->Map)) {
+      meanApMag    = secfilt->Map;
+      meanApMagErr = secfilt->dMap;
+      meanApMagStd = secfilt->sMap;
+    }
     PrintIOBuffer (sec_buffer, " (");
     PRINT_FLOAT(sec_buffer, meanPSFMag,      "%.6f, "); // umag precision
+    PRINT_FLOAT(sec_buffer, meanApMag,       "%.6f, "); // umag precision
+    PRINT_FLOAT(sec_buffer, meanPSFMagErr,   "%.6f, "); // umag precision
+    PRINT_FLOAT(sec_buffer, meanPSFMagStd,   "%.6f, "); // umag precision
+    PRINT_FLOAT(sec_buffer, meanPSFMagMin,   "%.6f, "); // umag precision
+    PRINT_FLOAT(sec_buffer, meanPSFMagMax,   "%.6f, "); // umag precision
+    PrintIOBuffer (sec_buffer, "%hd,  ", secfilt->Nused);
     PRINT_FLOAT(sec_buffer, meanKronMag,     "%.6f, "); // umag precision
     PRINT_FLOAT(sec_buffer, meanKronMagErr,  "%.6f, "); // umag precision
     PRINT_FLOAT(sec_buffer, meanPSFMagErr,   "%.6f, "); // umag precision
     PRINT_FLOAT(sec_buffer, secfilt->Mchisq, "%.6f, ");
+    PRINT_FLOAT(sec_buffer, stackPSFMag,     "%.6f, "); // umag precision
     PRINT_FLOAT(sec_buffer, stackPSFMagErr,  "%.6f, "); // umag precision
     PRINT_FLOAT(sec_buffer, stackKronMag,    "%.6f, "); // umag precision
     PRINT_FLOAT(sec_buffer, stackKronMagErr, "%.6f, "); // 0.36 umag precision
     PrintIOBuffer (sec_buffer, "%u,   ", secfilt->flags);
+    PRINT_FLOAT(sec_buffer, meanKronMagStd,  "%.6f, "); // umag precision
+    PrintIOBuffer (sec_buffer, "%hd,  ", secfilt->NusedKron);
+    PRINT_FLOAT(sec_buffer, meanApMag,     "%.6f, "); // umag precision
+    PRINT_FLOAT(sec_buffer, meanApMagErr,  "%.6f, "); // umag precision
+    PRINT_FLOAT(sec_buffer, meanApMagStd,  "%.6f, "); // umag precision
+    PrintIOBuffer (sec_buffer, "%hd,  ", secfilt->NusedAp);
     PrintIOBuffer (sec_buffer, "%hd,  ", secfilt->Ncode);
+    PrintIOBuffer (sec_buffer, "%hd,  ", secfilt->Nused);
+    PrintIOBuffer (sec_buffer, "%.6f, ", secfilt->Mmin);
+    PrintIOBuffer (sec_buffer, "%.6f, ", secfilt->Mmax);
+    PrintIOBuffer (sec_buffer, "%hd, ", secfilt->ubercalDist);
+    PrintIOBuffer (sec_buffer, "%.6f, ", secfilt->Mstdev);
+    PrintIOBuffer (sec_buffer, "%lu  ", secfilt->stackDetectID);
+    PrintIOBuffer (sec_buffer, "%hd,  ", secfilt->NstackDet);
+    PRINT_FLOAT(sec_buffer, secfilt->psfQfPerfMax, "%.6f,");
+    PrintIOBuffer (sec_buffer, "%u ", secfilt->flags);
     PrintIOBuffer (sec_buffer, "),\n");
     secfilt ++;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvosplit/include/dvosplit.h

r33656	r37822
22	22	} AveLinks;
23	23
	24	int FULL_TABLE;
24	25	int VERBOSE;
25	26	char *OUTDIR;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvosplit/src/args.c

-              r33656
+              r37822
+  }
+  // override input catalog format (PS1_V1, PS1_REF, etc)
+  FULL_TABLE = FALSE;
+  if ((N = get_argument (argc, argv, "-full-table"))) {
+    remove_argument (N, &argc, argv);
+    FULL_TABLE = TRUE;
+  }
   /* extra error messages */
   VERBOSE = FALSE;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvosplit/src/split_averages.c

-              r37043
+              r37822
   incatalog[0].catflags = LOAD_AVES | LOAD_SECF;
   if (incatalog[0].catmode == DVO_MODE_SPLIT) {
+  if ((incatalog[0].catmode == DVO_MODE_SPLIT) && !FULL_TABLE) {
     Nblocks = incatalog[0].Naves_disk / NROWS;
     if (incatalog[0].Naves_disk % NROWS) Nblocks ++;
 …
   for (block = 0; block < Nblocks; block++) {
     if (incatalog[0].catmode == DVO_MODE_SPLIT) {
+    if ((incatalog[0].catmode == DVO_MODE_SPLIT) && !FULL_TABLE) {
       // read up to NROWS at a time
       dvo_catalog_load_segment (incatalog, VERBOSE, block*NROWS, NROWS);
       fprintf (stderr, "splitting %s (averages) .. %d of %d\n", incatalog[0].filename, block, Nblocks);
+      assert (block*NROWS == incatalog[0].Naves_off);
     } else {
       dvo_catalog_load (incatalog, VERBOSE);
       fprintf (stderr, "splitting %s (averages)\n", incatalog[0].filename);
+    }
-    assert (block*NROWS == incatalog[0].Naves_off);
     // distribute data to the output catalogs
 …
       inD = incatalog[0].average[ave].D;
+      if (incatalog[0].average[ave].Nmeasure == 0) {
+        fprintf (stderr, "WARNING: object with no measurements, skipping %d (%f, %f)\n", averef, inR, inD);
+        continue;
+      }
       // which of the outcatalogs contains this coordinate?
 …
     // write out the new values
+    for (cat = 0; cat < outlist[0].Nregions; cat++) {
+      outcatalogs[cat].catflags = LOAD_AVES | LOAD_SECF;
+    if (!FULL_TABLE) {
+      for (cat = 0; cat < outlist[0].Nregions; cat++) {
+        outcatalogs[cat].catflags = LOAD_AVES | LOAD_SECF;
       dvo_catalog_save (&outcatalogs[cat], VERBOSE);
       // fprintf (stderr, "secfilt: %d %d %d %d\n", outcatalogs[cat].Nsecf_mem, outcatalogs[cat].Nsecf_disk, outcatalogs[cat].Nsecf_off, outcatalogs[cat].Naverage, outcatalogs[cat].Nsecfilt);
+        dvo_catalog_save (&outcatalogs[cat], VERBOSE);
+        // fprintf (stderr, "secfilt: %d %d %d %d\n", outcatalogs[cat].Nsecf_mem, outcatalogs[cat].Nsecf_disk, outcatalogs[cat].Nsecf_off, outcatalogs[cat].Naverage, outcatalogs[cat].Nsecfilt);
       // advance the pointers and free the current data
       // XXX these should be done within save segment:
       outcatalogs[cat].Naves_disk += outcatalogs[cat].Naverage;
       outcatalogs[cat].Naves_off  += outcatalogs[cat].Naverage;
       outcatalogs[cat].Nsecf_disk += outcatalogs[cat].Nsecfilt * outcatalogs[cat].Naverage;
       outcatalogs[cat].Nsecf_off  += outcatalogs[cat].Nsecfilt * outcatalogs[cat].Naverage;
       outcatalogs[cat].Nsecfilt    = Nsecfilt;
+        // advance the pointers and free the current data
+        // XXX these should be done within save segment:
+        outcatalogs[cat].Naves_disk += outcatalogs[cat].Naverage;
+        outcatalogs[cat].Naves_off  += outcatalogs[cat].Naverage;
+        outcatalogs[cat].Nsecf_disk += outcatalogs[cat].Nsecfilt * outcatalogs[cat].Naverage;
+        outcatalogs[cat].Nsecf_off  += outcatalogs[cat].Nsecfilt * outcatalogs[cat].Naverage;
+        outcatalogs[cat].Nsecfilt    = Nsecfilt;
+      outcatalogs[cat].Naverage    = 0;
+      outcatalogs[cat].Nsecf_mem   = 0;
+        outcatalogs[cat].Naverage    = 0;
+        outcatalogs[cat].Nsecf_mem   = 0;
+      }
+    }
+  }
+  for (cat = 0; cat < outlist[0].Nregions; cat++) {
+    dvo_catalog_free_data (&outcatalogs[cat]);
+  if (!FULL_TABLE) {
+    for (cat = 0; cat < outlist[0].Nregions; cat++) {
+      dvo_catalog_free_data (&outcatalogs[cat]);
+    }
+  }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/dvosplit/src/split_measures.c

-              r37043
+              r37822
   // }
   if (incatalog[0].catmode == DVO_MODE_SPLIT) {
+  if ((incatalog[0].catmode == DVO_MODE_SPLIT) && !FULL_TABLE) {
     Nblocks = incatalog[0].Nmeas_disk / NROWS;
     if (incatalog[0].Nmeas_disk % NROWS) Nblocks ++;
 …
     // read up to NROWS at a time
     if (incatalog[0].catmode == DVO_MODE_SPLIT) {
+    if ((incatalog[0].catmode == DVO_MODE_SPLIT) && !FULL_TABLE) {
       dvo_catalog_load_segment (incatalog, VERBOSE, block*NROWS, NROWS);
       fprintf (stderr, "splitting %s (measures) .. %d of %d\n", incatalog[0].filename, block, Nblocks);
+      assert (block*NROWS == incatalog[0].Nmeas_off);
     } else {
       dvo_catalog_load (incatalog, VERBOSE);
       fprintf (stderr, "splitting %s (measures)\n", incatalog[0].filename);
+    }
-    assert (block*NROWS == incatalog[0].Nmeas_off);
     for (meas = 0; meas < incatalog[0].Nmeasure; meas++) {
 …
       Ncat = outcat[averef];
+      int averef_out = outref[averef];
+      if (averef_out >= outcatalogs[Ncat].Naverage) {
+        fprintf (stderr, "mismatch 1\n");
+        abort();
+      }
       Nout = outcatalogs[Ncat].Nmeasure;
       outcatalogs[Ncat].measure[Nout] = incatalog[0].measure[meas];
       outcatalogs[Ncat].measure[Nout].averef = outref[averef];
       outcatalogs[Ncat].Nmeasure++;
 …
     dvo_catalog_free_data (incatalog);
+    if (!FULL_TABLE) {
+      for (cat = 0; cat < outlist[0].Nregions; cat++) {
+        outcatalogs[cat].catflags = LOAD_MEAS;
+        dvo_catalog_save (&outcatalogs[cat], VERBOSE);
+        outcatalogs[cat].Nmeas_disk += outcatalogs[cat].Nmeasure;
+        outcatalogs[cat].Nmeas_off  += outcatalogs[cat].Nmeasure;
+        outcatalogs[cat].Nmeasure    = 0;
+      }
+    }
+  }
+  if (FULL_TABLE) {
     for (cat = 0; cat < outlist[0].Nregions; cat++) {
       outcatalogs[cat].catflags = LOAD_MEAS;
+      outcatalogs[cat].catflags = LOAD_AVES | LOAD_SECF | LOAD_MEAS;
       dvo_catalog_save (&outcatalogs[cat], VERBOSE);
-      outcatalogs[cat].Nmeas_disk += outcatalogs[cat].Nmeasure;
-      outcatalogs[cat].Nmeas_off  += outcatalogs[cat].Nmeasure;
-      outcatalogs[cat].Nmeasure    = 0;
+    }
+  }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/fixcat/src/gcatstats.c

-              r36481
+              r37822
   /* project onto rectilinear grid with 1 arcsec pixels, sort by X */
   /* reference for coords is center of field  */
+  InitCoords (&catstats[0].coords, "DEC--TAN");
   catstats[0].coords.crval1 = RaCenter;
   catstats[0].coords.crval2 = DecCenter;
-  catstats[0].coords.crpix1 = catstats[0].coords.crpix2 = 0.0;
   catstats[0].coords.cdelt1 = catstats[0].coords.cdelt2 = 1.0 / 3600.0;
-  catstats[0].coords.pc1_1 = catstats[0].coords.pc2_2 = 1.0;
-  catstats[0].coords.pc1_2 = catstats[0].coords.pc2_1 = 0.0;
-  strcpy (catstats[0].coords.ctype, "DEC--TAN");
   X1 = catstats[0].X;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/gastro/src/gfitpoly.c

-              r27435
+              r37822
     det = 1.0 / (a1*b2 - a2*b1);
+    InitCoords (coords, "DEC--PLY");
     coords[0].pc1_1 = p11*a1 + p12*b1*(S2/S1);
     coords[0].pc2_1 = p21*a1 + p22*b1*(S2/S1);
 …
     coords[0].Npolyterms = NORDER;
-    strcpy (coords[0].ctype, "DEC--PLY");
     /* generate higher order terms from vector */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/gastro/src/gstars.c

-              r36481
+              r37822
   if (!strcasecmp (ROUGH_ASTROMETRY, "config")) {
     /* default values for coords */
     strcpy (coords[0].ctype, "DEC--TAN");
+    InitCoords (coords, "DEC--TAN");
     coords[0].pc1_1 = CCD_PC1_1; coords[0].pc1_2 = CCD_PC1_2;
     coords[0].pc2_1 = CCD_PC2_1; coords[0].pc2_2 = CCD_PC2_2;
     coords[0].cdelt1 = coords[0].cdelt2 = ASEC_PIX / 3600.0;
-    coords[0].Npolyterms = 0;
     coords[0].crpix1 = 0.5*(*NX);
     coords[0].crpix2 = 0.5*(*NY);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/gastro2/src/gproject2.c

-              r12332
+              r37822
   /* create Tangent Plane to Sky transformation from input coords */
   strcpy (TPtoSky.ctype, coords[0].ctype);
+  InitCoords (&TPtoSky, coords[0].ctype);
   TPtoSky.crval1 = coords[0].crval1;
   TPtoSky.crval2 = coords[0].crval2;
-  TPtoSky.cdelt1 = TPtoSky.cdelt2 = 1;
-  TPtoSky.crpix1 = TPtoSky.crpix2 = 0;
-  TPtoSky.pc1_1 = TPtoSky.pc2_2 = 1;
-  TPtoSky.pc1_2 = TPtoSky.pc2_1 = 0;
-  TPtoSky.Npolyterms = 0;
-  for (i = 0; i < 7; i++) {
-    TPtoSky.polyterms[i][0] = 0;
-    TPtoSky.polyterms[i][1] = 0;
+  }
   /* create Focal Plane to Tangent Plane transformation from input coords */
+  strcpy (FPtoTP.ctype, "FP---PLY");
+  FPtoTP.crval1 = FPtoTP.crval2 = 0;
+  InitCoords (&FPtoTP, "FP---PLY");
   FPtoTP.cdelt1 = coords[0].cdelt1;
   FPtoTP.cdelt2 = coords[0].cdelt2;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/gastro2/src/gstars2.c

-              r37054
+              r37822
   /* default values for coords */
   strcpy (Target[0].coords.ctype, "DEC--TAN");
+  InitCoords (&Target[0].coords, "DEC--TAN");
   Target[0].coords.pc1_1 = CCD_PC1_1; Target[0].coords.pc1_2 = CCD_PC1_2;
   Target[0].coords.pc2_1 = CCD_PC2_1; Target[0].coords.pc2_2 = CCD_PC2_2;
   Target[0].coords.cdelt1 = Target[0].coords.cdelt2 = ASEC_PIX / 3600.0;
-  Target[0].coords.Npolyterms = 0;
   Target[0].coords.crpix1 = 0.5*NX;
   Target[0].coords.crpix2 = 0.5*NY;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/getstar

Property svn:mergeinfo changed

/branches/eam_branches/ipp-20140717/Ohana/src/getstar (added)	merged: 37243
/branches/eam_branches/ipp-20140813/Ohana/src/getstar (added)	merged: 37308,37344,37351,37353
/branches/eam_branches/ipp-20140904/Ohana/src/getstar (added)	merged: 37378,37386,37803
/branches/eam_branches/ps2-tc3-20130727/Ohana/src/getstar (added)	merged: 36680,37403
/tags/ipp-20141224/Ohana/src/getstar (added)	merged: 37773,37809-37810
/trunk/Ohana/src/getstar (added)	merged: 37070,37116,37246,37359,37412,37772,37807,37812

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/getstar/include/dvoImageOverlaps.h

r27435	r37822
37	37	int edge_check (double x1, double y1, double x2, double y2);
38	38	double opening_angle (double x1, double y1, double x2, double y2, double x3, double y3);
	39
	40	void initMosaicCoords ();
	41	void saveMosaicCoords (Coords *input);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/getstar/src/MatchCoords.c

-              r31238
+              r37822
     if (!WITH_PHU && !strcmp (&dbImages[i].coords.ctype[4], "-DIS")) continue;
     if ( SOLO_PHU &&  strcmp (&dbImages[i].coords.ctype[4], "-DIS")) continue;
-    /* if any of these images are WRP images, need to find matching DIS */
-    if (!FindMosaicForImage (dbImages, NdbImages, i)) continue;
     /* define image corners */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/getstar/src/MatchImages.c

-              r36481
+              r37822
   /* we keep the original crpix1,2 and crref1,2 */
   /* for mosaic astrometry, the grid should be w.r.t. the tangent-plane, not chip coords */
+  InitCoords (&tcoords, "DEC--TAN");
   if (!strcmp (&image[0].coords.ctype[4], "-WRP")) {
+    // if the input image is a mosaic, we need to register that mosaic for the calculations below
+    if (MOSAIC == NULL) {
+      fprintf (stderr, "no mosaic for WRP image (use -mosaic)\n");
+      return NULL;
+    }
+    RegisterMosaic (MOSAIC);
+    tcoords = MOSAIC[0];
+    myAssert (image[0].coords.mosaic, "should already have tested this");
+    tcoords = image[0].coords.mosaic[0];
     tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-    tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-    tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-    tcoords.Npolyterms = 1;
-    strcpy (tcoords.ctype, "DEC--TAN");
     /* register so image->sky conversions below have correct mosaic */
   } else {
     tcoords = image[0].coords;
     tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-    tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-    tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-    tcoords.Npolyterms = 1;
-    strcpy (tcoords.ctype, "DEC--TAN");
+  }
 …
     if (!WITH_PHU && !strcmp (&dbImages[i].coords.ctype[4], "-DIS")) continue;
     if ( SOLO_PHU &&  strcmp (&dbImages[i].coords.ctype[4], "-DIS")) continue;
-    /* if any of these images are WRP images, need to find matching DIS */
-    if (!FindMosaicForImage (dbImages, NdbImages, i)) continue;
     /* define image corners */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/getstar/src/ReadImageFiles.c

r36874	r37822
42	42
43	43	mode = GetFileMode (header);
	44
	45	initMosaicCoords ();
44	46
45	47	/* load data from a single PHU or a collection of PHU files */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/getstar/src/ReadImageHeader.c

-              r21508
+              r37822
 # include "dvoImageOverlaps.h"
+// for DIS/WRP sets, we need to save the DIS set and supply it to the WRP entries
+static Coords *mosaic = NULL;
+void initMosaicCoords () {
+  mosaic = NULL;
+}
+void saveMosaicCoords (Coords *input) {
+  mosaic = input;
+}
 /* read an image header corresponding to a CMF / CMP data block */
 …
   /* only load astrometry, NAXIS1,2, and time if this is a MOSAIC_PHU (ctype is ....-DIS) */
   if (!strcmp (&image[0].coords.ctype[4], "-DIS")) {
     MOSAIC = &image[0].coords;
+    saveMosaicCoords (&image[0].coords);
     return (TRUE);
+  }
 …
+  }
   if (!strcmp (&image[0].coords.ctype[4], "-WRP")) {
     if (MOSAIC == NULL) {
+    if (mosaic == NULL) {
       fprintf (stderr, "no mosaic for WRP image (use -mosaic)\n");
       return (FALSE);
+    }
     RegisterMosaic (MOSAIC);
+    image[0].coords.mosaic = mosaic;
   } else {
     /* force image to lie in 0-360 range */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/getstar/src/WriteImages.c

-              r27435
+              r37822
   int i, N;
   int nWRP, newWRP, isWRP;
+  int isWRP;
   FILE *f;
 …
+  }
   nWRP = -1;
+  Image *mosaic = NULL;
   isWRP = FALSE;
   for (i = 0; i < Nmatches; i++) {
+    if (!strcmp (&images[0].coords.ctype[4], "-WRP")) {
+      if (!FindMosaicForImage (images, Nimages, i)) {
+        fprintf (stderr, "failed to find matching mosaic\n");
+        exit (1);
+      }
+    N = matches[i];
+    if (!strcmp (&images[N].coords.ctype[4], "-WRP")) {
       if (isWRP) {
+        newWRP = GetRegisteredMosaic();
+        if (newWRP != nWRP) {
+        if (mosaic != images[N].parent) {
           fprintf (stderr, "only one mosaic allowed in an output file\n");
           exit (1);
+        }
       } else {
+        nWRP = GetRegisteredMosaic();
+        isWRP = TRUE;
+        mosaic = images[N].parent;
+      }
+    }
 …
   if (isWRP) {
     WriteImageFITS (f, &images[nWRP]);
+    WriteImageFITS (f, mosaic);
   } else {
     // write a blank

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/imregister/imphot/dumpfits.c

r30617	r37822
34	34
35	35	ftable.header = &theader;
36		gfits_table_set_Image (&ftable, subset, Nmatch);
	36	// gfits_table_set_Image (&ftable, subset, Nmatch);
37	37
38	38	gfits_fwrite_header (f, &header);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/imregister/imphot/modify.c

-              r27435
+              r37822
   gfits_vtable_from_ftable (&db[0].ftable, &db[0].vtable, match, Nmatch);
   for (i = 0; i < Nmatch; i++) {
+    gfits_convert_Image ((Image *) db[0].vtable.buffer[i], sizeof (Image), 1);
+    fprintf (stderr, "need to work with real output format\n");
+    exit (2);
+    // gfits_convert_Image ((Image *) db[0].vtable.buffer[i], sizeof (Image), 1);
+  }
   gfits_db_update (db);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/include/constants.h

r36084	r37822
10	10	\| PointerMotionMask)
11	11
12		# define NCHANNELS 3
	12	# define NCHANNELS 10
13	13	# define NPIXELS_DYNAMIC 128
14	14

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/include/structures.h

r32695	r37822
217	217	KapaImageChannel *image;
218	218	KapaImageChannel channel[NCHANNELS];
	219	int currentChannel;
219	220	} KapaImageWidget;
220	221

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/CreatePicture.c

-              r16270
+              r37822
   case 24:
+    extra = 4 - (image[0].wide.dx * 3) % 4;
+    REALLOCATE (image[0].wide.data, char, image[0].wide.dy*(3*image[0].wide.dx+extra));
+    extra = 4 - (image[0].zoom.dx * 3) % 4;
+    REALLOCATE (image[0].zoom.data, char, image[0].zoom.dy*(3*image[0].zoom.dx+extra));
     extra = 4 - (image[0].picture.dx * 3) % 4;
-    REALLOCATE (image[0].wide.data, char, image[0].wide.dy*(3*image[0].wide.dx+extra));
-    REALLOCATE (image[0].zoom.data, char, image[0].zoom.dy*(3*image[0].zoom.dx+extra));
     REALLOCATE (image[0].picture.data, char, image[0].picture.dy*(3*image[0].picture.dx+extra));
     c = (unsigned char *) image[0].picture.data;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/CursorOps.c

-              r25757
+              r37822
   // Sx, Sy are the screen coordinates of the Ix,Iy pixel
   Image_to_Picture (&Sx, &Sy, Ix, Iy, picture);
+  // Sx,Sy should be forced into the pixel
+  int Sxi = Sx + 0.5;
+  int Syi = Sy + 0.5;
   // i_start, j_start are now limited to valid screen coordinates
   *i_start = MIN (MAX (Sx, 0), picture[0].dx);
   *j_start = MIN (MAX (Sy, 0), picture[0].dy);
+  *i_start = MIN (MAX (Sxi, 0), picture[0].dx);
+  *j_start = MIN (MAX (Syi, 0), picture[0].dy);
+}
 …
   Iy = MIN (MAX (Iy, 0), matrix[0].Naxis[1]);
-  // I_end, J_end are the last displayed image pixel
-  // *I_end = Ix;
-  // *J_end = Iy;
   // Sx, Sy are the screen coordinates of the Ix,Iy pixel
   Image_to_Picture (&Sx, &Sy, Ix, Iy, picture);
+  // Sx,Sy should be forced into the pixel
+  int Sxi = Sx + 0.5;
+  int Syi = Sy + 0.5;
+  // double IxTest, IyTest;
+  // Picture_to_Image (&IxTest, &IyTest, Sx, Sy, picture);
+  // fprintf (stderr, "dx,dy: %d,%d : %f,%f : %f,%f : %f:%f\n", picture[0].dx, picture[0].dy, Ix, Iy, Sx, Sy, IxTest, IyTest);
   // i_start, j_start are now limited to valid screen coordinates
+  *i_end = MIN (MAX (Sx, 0), picture[0].dx);
+  *j_end = MIN (MAX (Sy, 0), picture[0].dy);
+  // XXX: i_end, j_end *should* be the last valid screen pixel plus 1
+  *i_end = MIN (MAX (Sxi, 0), picture[0].dx);
+  *j_end = MIN (MAX (Syi, 0), picture[0].dy);
   // round off error can leave us with a small number of extra pixels here.

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/Graphs.c

-              r36487
+              r37822
   graph[0].data.flipnorth = FALSE;      // +North = +Y by default
+  graph[0].data.coords.pc1_1 = graph[0].data.coords.pc2_2 = 1.0;
+  graph[0].data.coords.pc1_2 = graph[0].data.coords.pc2_1 = 0.0;
+  graph[0].data.coords.crval1 = 0.0;
+  graph[0].data.coords.crval2 = 0.0;
+  graph[0].data.coords.crpix1 = 0.0;
+  graph[0].data.coords.crpix2 = 0.0;
+  graph[0].data.coords.cdelt1 = graph[0].data.coords.cdelt2 = 1.0;
+  strcpy (graph[0].data.coords.ctype, "DEC--LIN");
+  InitCoords (&graph[0].data.coords, "DEC--LIN");
   strcpy (graph[0].data.axis, "2222");
   strcpy (graph[0].data.ticks, "2222");

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/Image.c

-              r36487
+              r37822
   channel->slope = 1;
+  channel->coords.pc1_1 = channel->coords.pc2_2 = 1.0;
+  channel->coords.pc1_2 = channel->coords.pc2_1 = 0.0;
+  channel->coords.crval1 = 0.0;
+  channel->coords.crval2 = 0.0;
+  channel->coords.crpix1 = 0.0;
+  channel->coords.crpix2 = 0.0;
+  channel->coords.cdelt1 = channel->coords.cdelt2 = 1.0;
+  strcpy (channel->coords.ctype, "DEC--LIN");
+  channel->coords.Npolyterms = 0;
+  InitCoords (&channel->coords, "DEC--LIN");
   channel->matrix.datasize = 0; /* a flag to show there is no data in the matrix */
 …
     InitImageChannel (&image[0].channel[i]);
+  }
+  image[0].image = &image[0].channel[0];
+  image[0].currentChannel = 0;
+  image[0].image = &image[0].channel[image[0].currentChannel];
   image[0].nPixels = 0;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/InterpretKeys.c

-              r25757
+              r37822
     Z = -1;
+    if (graph) {
+    int haveGraph = graph && graph->haveGraph;
+    if (haveGraph) {
       X = (event[0].x - graph[0].axis[0].fx)*(graph[0].axis[0].max - graph[0].axis[0].min)/graph[0].axis[0].dfx + graph[0].axis[0].min;
       Y = (event[0].y - graph[0].axis[1].fy)*(graph[0].axis[1].max - graph[0].axis[1].min)/graph[0].axis[1].dfy + graph[0].axis[1].min;
       XY_to_RD (&R, &D, X, Y, &graph[0].data.coords);
+    }
     if (image && !graph) {
+    if (image && !haveGraph) {
       if (event[0].x < image[0].picture.x) goto skip_cursor;
       if (event[0].y < image[0].picture.y) goto skip_cursor;
 …
   switch (keysym) {
+    case XK_F1:
+      image[0].image = &image[0].channel[0];
+      SetColorScale (graphic, image);
+      Remap (graphic, image);
+      Reorient (graphic, image, image[0].picture.Xc, image[0].picture.Yc, 0);
+# define SET_CHANNEL_CASE(NCHAN) \
+    case XK_F##NCHAN: \
+      image[0].currentChannel = NCHAN-1; \
+      image[0].image = &image[0].channel[NCHAN-1]; \
+      SetColorScale (graphic, image); \
+      Reorient (graphic, image, image[0].picture.Xc, image[0].picture.Yc, 0); \
+      Screen_to_Image (&X, &Y, (double)(event[0].x + 0.5), (double)(event[0].y + 0.5), &image[0].picture); \
+      UpdateStatusBox (graphic, image, X, Y, 0.0, 1); \
       break;
+    case XK_F2:
+      image[0].image = &image[0].channel[1];
+      SetColorScale (graphic, image);
+      Remap (graphic, image);
+      Reorient (graphic, image, image[0].picture.Xc, image[0].picture.Yc, 0);
+      break;
+//    Remap (graphic, image);
+    case XK_F3:
+      image[0].image = &image[0].channel[2];
+      SetColorScale (graphic, image);
+      Remap (graphic, image);
+      Reorient (graphic, image, image[0].picture.Xc, image[0].picture.Yc, 0);
+      break;
+    // the number of entries here must match the value of NCHANNELS in contants.h
+    SET_CHANNEL_CASE(1);
+    SET_CHANNEL_CASE(2);
+    SET_CHANNEL_CASE(3);
+    SET_CHANNEL_CASE(4);
+    SET_CHANNEL_CASE(5);
+    SET_CHANNEL_CASE(6);
+    SET_CHANNEL_CASE(7);
+    SET_CHANNEL_CASE(8);
+    SET_CHANNEL_CASE(9);
+    SET_CHANNEL_CASE(10);
     case XK_KP_Home:

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/LoadPicture.c

-              r28241
+              r37822
   // choose expand for wide to guarantee we fit:
   wx = MAX ((header.Naxis[0] / (float) image[0].wide.dx), (header.Naxis[1] / (float) image[0].wide.dy));
+  if (wx > 1.0) {
+    image[0].wide.expand = -wx;
+  } else {
+    image[0].wide.expand = 1.0 / wx;
+  }
+  // -4.002 -> -5
+  // image[0].wide.expand = (wx > 1.0) ? ceil (-wx) : floor (1.0 / wx);
+  image[0].wide.expand = (wx > 1.0) ? floor (-wx) : ceil (1.0 / wx);
+  // fprintf (stderr, "%d : %f\n", image[0].wide.expand, wx);
+  image[0].wide.expand = (wx > 1.0) ? ceil (-wx) : floor (1.0 / wx);
   image[0].wide.Xc = 0.5*header.Naxis[0];
   image[0].wide.Yc = 0.5*header.Naxis[1];

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/Reconfig.c

-              r21153
+              r37822
   // if the new size is the same as the old size, do nothing.
+  if ((graphic->dx == NX) && (graphic->dy == NY)) return (TRUE);
+  if ((graphic->dx == NX) && (graphic->dy == NY)) {
+    if (USE_XWINDOW) XClearWindow (graphic->display, graphic->window);
+    Refresh ();
+    return (TRUE);
+  }
   // set the new window size

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/Remap32.c

-              r34088
+              r37822
   swap_client = 0;
 # endif
   swap_server = ImageByteOrder (graphic[0].display);
   swap_bytes = !(swap_client ^ swap_server);
 …
   in_pix  = &image[0].pixmap[DX*(int)MAX(Iy,0) + (int)MAX(Ix,0)];
+  unsigned short *in_base = image[0].pixmap;
+  OUT_TYPE *out_base = (OUT_TYPE *) picture[0].data;
+  int Ninmax = matrix[0].Naxis[0] * matrix[0].Naxis[1];
+  int Noutmax = picture[0].dx * picture[0].dy;
   /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
   /**** fill in bottom area ****/
   for (j = 0; j < dx*j_start; j++, out_pix++) {
+    myAssert (out_pix - out_base < Noutmax, "too far out");
     *out_pix = back;
+  }
 …
       out_pix2 = out_pix + jj*dx;
       for (i = 0; i < i_start; i++, out_pix2++) {
+        myAssert (out_pix2 - out_base < Noutmax, "too far out");
         *out_pix2 = back;
+      }
 …
     if (expand_out == 1) {
       for (i = i_start; i < i_end; i++, in_pix2 += inDX*expand_in, out_pix++) {
+        myAssert (out_pix - out_base < Noutmax, "too far out");
+        myAssert (in_pix2 - in_base < Ninmax, "too far in");
         *out_pix = pixel[*in_pix2];
+      }
     } else {
       for (i = i_start; i < i_end; i+= expand_out, in_pix2 += inDX, out_pix+= expand_out) {
+        myAssert (in_pix2 - in_base < Ninmax, "too far in");
         pixvalue = pixel[*in_pix2];
         out_pix2 = out_pix;
         for (jj = 0; (jj < expand_out) && (j + jj < dy); jj++, out_pix2+=(dx-expand_out)) {
           for (ii = 0; ii < expand_out; ii++, out_pix2++) {
+            myAssert (out_pix2 - out_base < Noutmax, "too far out");
             *out_pix2 = pixvalue;
+          }
 …
       out_pix2 = out_pix + jj*dx;
       for (i = i_end; i < dx; i++, out_pix2++) {
+        myAssert (out_pix2 - out_base < Noutmax, "too far out");
         *out_pix2 = back;
+      }
 …
   for (j = 0; j < dy - j_end; j++) {
     for (i = 0; i < dx; i++, out_pix ++) {
+      myAssert (out_pix - out_base < Noutmax, "too far out");
       *out_pix = back;
+    }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/SetChannel.c

-              r31665
+              r37822
   if (Nchannel >= NCHANNELS) return (TRUE);
+  image[0].image = &image[0].channel[Nchannel];
+  image[0].currentChannel = Nchannel;
+  image[0].image = &image[0].channel[image[0].currentChannel];
   SetColorScale (graphic, image);
 …
   Refresh ();
   XFlush (graphic[0].display);
+  if (USE_XWINDOW) XFlush (graphic[0].display);
   return (TRUE);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/kapa2/src/UpdateStatusBox.c

-              r30606
+              r37822
     bzero (line, 100);
     snprintf (line, 100, "(%d x %d) @ %d                                         ",
              image[0].picture.dx, image[0].picture.dy, image[0].picture.expand);
+    snprintf (line, 100, "(%d x %d) @ %d   ch: %d                                     ",
+              image[0].picture.dx, image[0].picture.dy, image[0].picture.expand, image[0].currentChannel+1);
     XDrawString (graphic[0].display, graphic[0].window, graphic[0].gc,
                  image[0].text_x + PAD1, image[0].text_y + 4*textpad + 4*PAD1, line, 25);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/Makefile.Targets

-              r37034
+              r37822
 AOBJS = \
+$(ASRC)/coords.$(ARCH).o \
+$(ASRC)/coords-disk.$(ARCH).o \
+$(ASRC)/AstromOffsetMap_Disk.$(ARCH).o \
 $(ASRC)/average.$(ARCH).o \
 $(ASRC)/average-loneos.$(ARCH).o \
 …
 $(ASRC)/average-ps1-v4.$(ARCH).o \
 $(ASRC)/average-ps1-v5.$(ARCH).o \
+$(ASRC)/average-ps1-sim.$(ARCH).o \
 $(ASRC)/average-ps1-ref.$(ARCH).o \
 $(ASRC)/secfilt.$(ARCH).o \
 …
 $(ASRC)/secfilt-ps1-v4.$(ARCH).o \
 $(ASRC)/secfilt-ps1-v5.$(ARCH).o \
+$(ASRC)/secfilt-ps1-sim.$(ARCH).o \
 $(ASRC)/secfilt-ps1-ref.$(ARCH).o \
 $(ASRC)/measure.$(ARCH).o \
 …
 $(ASRC)/measure-ps1-v4.$(ARCH).o \
 $(ASRC)/measure-ps1-v5.$(ARCH).o \
+$(ASRC)/measure-ps1-sim.$(ARCH).o \
 $(ASRC)/measure-ps1-ref.$(ARCH).o \
 $(ASRC)/lensing.$(ARCH).o \
 $(ASRC)/lensing-ps1-v5.$(ARCH).o \
+$(ASRC)/lensing-ps1-v5-alt.$(ARCH).o \
 $(ASRC)/lensobj.$(ARCH).o \
 $(ASRC)/lensobj-ps1-v5.$(ARCH).o \
+$(ASRC)/starpar.$(ARCH).o \
+$(ASRC)/starpar-ps1-v5.$(ARCH).o \
+$(ASRC)/starpar-ps1-sim.$(ARCH).o \
 $(ASRC)/missing.$(ARCH).o \
 $(ASRC)/photcode.$(ARCH).o \
 …
 $(ASRC)/photcode-ps1-v5.$(ARCH).o \
 $(ASRC)/photcode-ps1-ref.$(ARCH).o \
-$(ASRC)/image.$(ARCH).o \
 $(ASRC)/image-loneos.$(ARCH).o \
 $(ASRC)/image-elixir.$(ARCH).o \
 …
 $(ASRC)/image-ps1-v4.$(ARCH).o \
 $(ASRC)/image-ps1-v5.$(ARCH).o \
+$(ASRC)/image-ps1-sim.$(ARCH).o \
 $(ASRC)/image-ps1-ref.$(ARCH).o \
 $(ASRC)/regimage.$(ARCH).o \
 …
 AINCS = \
+$(AINC)/coords.h \
+$(AINC)/coords-disk.h \
+$(AINC)/AstromOffsetMap_Disk.h \
 $(AINC)/average.h \
 $(AINC)/average-loneos.h \
 …
 $(AINC)/average-ps1-v4.h \
 $(AINC)/average-ps1-v5.h \
+$(AINC)/average-ps1-sim.h \
 $(AINC)/average-ps1-ref.h \
 $(AINC)/secfilt.h \
 …
 $(AINC)/secfilt-ps1-v4.h \
 $(AINC)/secfilt-ps1-v5.h \
+$(AINC)/secfilt-ps1-sim.h \
 $(AINC)/secfilt-ps1-ref.h \
 $(AINC)/measure.h \
 …
 $(AINC)/measure-ps1-v4.h \
 $(AINC)/measure-ps1-v5.h \
+$(AINC)/measure-ps1-sim.h \
 $(AINC)/measure-ps1-ref.h \
 $(AINC)/lensing.h \
 $(AINC)/lensing-ps1-v5.h \
+$(AINC)/lensing-ps1-v5-alt.h \
 $(AINC)/lensobj.h \
 $(AINC)/lensobj-ps1-v5.h \
+$(AINC)/starpar.h \
+$(AINC)/starpar-ps1-v5.h \
+$(AINC)/starpar-ps1-sim.h \
 $(AINC)/missing.h \
 $(AINC)/photcode.h \
 …
 $(AINC)/photcode-ps1-v5.h \
 $(AINC)/photcode-ps1-ref.h \
-$(AINC)/image.h \
 $(AINC)/image-loneos.h \
 $(AINC)/image-elixir.h \
 …
 $(AINC)/image-ps1-v4.h \
 $(AINC)/image-ps1-v5.h \
+$(AINC)/image-ps1-sim.h \
 $(AINC)/image-ps1-ref.h \
 $(AINC)/regimage.h \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/average-ps1-v5.d

-              r37034
+              r37822
 EXTNAME      DVO_AVERAGE_PS1_V5
 TYPE         BINTABLE
 SIZE         184
+SIZE         192
 DESCRIPTION  DVO Average Object Table
 …
 FIELD lensingOffset,  OFF_LENSING, int,             offset to first lensing obs
 FIELD lensobjOffset,  OFF_LENSOBJ, int,             offset to mean lensing data
+FIELD starparOffset,  OFF_STARPAR, int,             offset to stellar parameter data
 FIELD extendOffset,   OFF_EXTEND,  int,             offset to extended object entry
-FIELD paramsOffset,   OFF_PARAMS,  int,             offset to stellar parameter data
 FIELD refColorBlue,   REF_COLOR_BLUE, float,        color of astrometry ref stars
 FIELD refColorRed,    REF_COLOR_RED,  float,        color of astrometry ref stars
+FIELD tessID,         TESS_ID,       char,          ID of tessellation for primary skycell
+FIELD skycellID,      SKYCELL_ID,    char,          ID of skycell for primary skycell
+FIELD projectionID,   PROJECTION_ID, short,         ID of projection for primary skycell
+FIELD Nstarpar,       DUMMY,         short,         number of stellar parameter entries
+FIELD dummy,          DUMMY,         short,         unassigned bytes
 # 'flags' was called 'code' prior to 2009.02.07

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/average.d

-              r37034
+              r37822
 EXTNAME      DVO_AVERAGE
 TYPE         BINTABLE
 SIZE         184
+SIZE         192
 DESCRIPTION  DVO Average Object Table
 …
 FIELD lensingOffset,  OFF_LENSING, int,             offset to first lensing obs
 FIELD lensobjOffset,  OFF_LENSOBJ, int,             offset to mean lensing data
+FIELD starparOffset,  OFF_STARPAR, int,             offset to stellar parameter data
 FIELD extendOffset,   OFF_EXTEND,  int,             offset to extended object entry
-FIELD paramsOffset,   OFF_PARAMS,  int,             offset to stellar parameter data
 FIELD refColorBlue,   REF_COLOR_BLUE, float,        color of astrometry ref stars
 FIELD refColorRed,    REF_COLOR_RED,  float,        color of astrometry ref stars
+FIELD tessID,         TESS_ID,       char,          ID of tessellation for primary skycell
+FIELD skycellID,      SKYCELL_ID,    char,          ID of skycell for primary skycell
+FIELD projectionID,   PROJECTION_ID, short,         ID of projection for primary skycell
+FIELD Nstarpar,       DUMMY,         short,         number of stellar parameter entries
+FIELD dummy,          DUMMY,         short,         unassigned bytes
 # 'flags' was called 'code' prior to 2009.02.07

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/cmf-ps1-v5-lensing.d

-              r37034
+              r37822
 EXTNAME CMF_PS1_V5
 TYPE    BINTABLE
 SIZE    312
+SIZE    320
 # elements of data structure / FITS table
 …
 FIELD E2_sh_psf,      E2_SH_PSF,         float,    lensing shear
+FIELD srcChipNum,     SRC_CHIP_NUM,      short,    source chip in warp
+FIELD srcChipX,       SRC_CHIP_X,        short,    source chip x coordinate
+FIELD srcChipY,       SRC_CHIP_Y,        short,    source chip y coordinate
+FIELD padding3,       SRC_CHIP_PAD,      short,    source chip in warp
 FIELD Mr1,            MOMENTS_R1,        float,    first radial moment,   pixels
 FIELD Mrh,            MOMENTS_RH,        float,    half radial moment,    pixels^1/2

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/coords.d

r6454	r37822
17	17	FIELD pc2_2, PC2_2, float, rotation matrix
18	18	FIELD polyterms, POLYTERMS, float[7][2], higher order warping terms
19		FIELD ctype, CTYPE, char[15], coordinate type
	19	FIELD ctype, CTYPE, char[15], coordinate type
20	20	FIELD Npolyterms, NPOLYTERMS, char, order of polynomial
	21	FIELD astrom_map_id, ASTROM_MAP_ID, unsigned int, reference to 2D astrometry map

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-elixir.d

r30604	r37822
6	6	# elements of the image structure
7	7
8		SUBSTRUCT coords, COORDS, Coords, astrometric data
	8	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
9	9	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
10	10	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-loneos.d

r30604	r37822
6	6	# elements of the image structure
7	7
8		SUBSTRUCT coords, COORDS, Coords, astrometric data
	8	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
9	9	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
10	10	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-panstarrs-dev-0.d

r30604	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-panstarrs-dev-1.d

r30604	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-ps1-dev-1.d

r30604	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-ps1-dev-2.d

r30604	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-ps1-dev-3.d

r30604	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-ps1-ref.d

r30604	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-ps1-v1.d

r30604	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-ps1-v2.d

r36833	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-ps1-v3.d

r36833	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-ps1-v4.d

r36833	r37822
7	7	# elements of the image structure
8	8
9		SUBSTRUCT coords, COORDS, Coords, astrometric data
	9	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
10	10	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
11	11	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image-ps1-v5.d

r37034	r37822
8	8	# careful of 8-byte boundaries
9	9
10		SUBSTRUCT coords, COORDS, Coords, astrometric data
	10	SUBSTRUCT coords, COORDS, CoordsDisk, astrometric data
11	11	SUBFIELD crval1, CRVAL1, double, coordinate at reference pixel
12	12	SUBFIELD crval2, CRVAL2, double, coordinate at reference pixel

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/image.d

-              r37034
+              r37822
 EXTNAME      DVO_IMAGE
 TYPE         BINTABLE
 SIZE         360
+SIZE         384
 DESCRIPTION  DVO Image Table
 …
 # careful of 8-byte boundaries
+# Coords is an internal structure defined in def/common.h
 SUBSTRUCT coords,           COORDS,               Coords,        astrometric data
 SUBFIELD  crval1,           CRVAL1,               double,        coordinate at reference pixel
 …
 SUBFIELD  ctype,            CTYPE,                char[15],      coordinate type
 SUBFIELD  Npolyterms,       NPOLYTERMS,           char,          order of polynomial
+# 120 bytes
+SUBFIELD  mosaic,           MOSAIC,               e_void,        pointer to parent mosaic
+SUBFIELD  imageMap,         IMAGE_MAP,            e_void,        pointer to image map
+# 136 bytes
 # change this to a double?
 …
 FIELD     photom_map_id,    PHOTOM_MAP_ID,        unsigned int,   reference to 2D zero point map
 FIELD     astrom_map_id,    ASTROM_MAP_ID,        unsigned int,   reference to 2D astrometry map
+FIELD    *parent,           PARENT,               e_void,         pointer to parent mosaic (not save to disk)
 # nFitPhotom lands on the old location of Mxxxx, which was used to mean nFitPhotom in some cases

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/lensing-ps1-v5.d

-              r37329
+              r37822
 FIELD F_ApR5,        FLUX_AP_R5,     float,          Flux inside r = 5
 FIELD dF_ApR5,       FLUX_ERR_AP_R5, float,          Flux inside r = 5
 FIELD sF_ApR5,       FLUX_STD_AP_R5, float,          Flux inside r = 5
 FIELD fF_ApR5,       FLUX_FIL_AP_R5, float,          Flux inside r = 5
+FIELD dF_ApR5,       FLUX_ERR_AP_R5, float,          error on Flux inside r = 5
+FIELD sF_ApR5,       FLUX_STD_AP_R5, float,          stdev of Flux inside r = 5
+FIELD fF_ApR5,       FLUX_FIL_AP_R5, float,          fill factor for Flux inside r = 5
 FIELD F_ApR6,        FLUX_AP_R6,     float,          Flux inside r = 5
 FIELD dF_ApR6,       FLUX_ERR_AP_R6, float,          Flux inside r = 5
 FIELD sF_ApR6,       FLUX_AP_R6,     float,          Flux inside r = 5
 FIELD fF_ApR6,       FLUX_AP_R6,     float,          Flux inside r = 5
+FIELD dF_ApR6,       FLUX_ERR_AP_R6, float,          error on Flux inside r = 5
+FIELD sF_ApR6,       FLUX_STD_AP_R6, float,          stdev of Flux inside r = 5
+FIELD fF_ApR6,       FLUX_FIL_AP_R6, float,          fill factor for Flux inside r = 5
 FIELD  detID,          DET_ID,       unsigned int,   detection ID

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/lensing.d

-              r37329
+              r37822
 FIELD  E2_sh_psf,      E2_SH_PSF,    float,          lensing shear psf stars E2
 FIELD  F_ApR5,       FLUX_AP_R5,     float,          Flux inside r = 5
 FIELD dF_ApR5,       FLUX_ERR_AP_R5, float,          Flux inside r = 5
 FIELD sF_ApR5,       FLUX_STD_AP_R5, float,          Flux inside r = 5
 FIELD fF_ApR5,       FLUX_FIL_AP_R5, float,          Flux inside r = 5
+FIELD F_ApR5,        FLUX_AP_R5,     float,          Flux inside r = 5
+FIELD dF_ApR5,       FLUX_ERR_AP_R5, float,          error on Flux inside r = 5
+FIELD sF_ApR5,       FLUX_STD_AP_R5, float,          stdev of Flux inside r = 5
+FIELD fF_ApR5,       FLUX_FIL_AP_R5, float,          fill factor for Flux inside r = 5
 FIELD  F_ApR6,       FLUX_AP_R6,     float,          Flux inside r = 6
 FIELD dF_ApR6,       FLUX_ERR_AP_R6, float,          Flux inside r = 6
 FIELD sF_ApR6,       FLUX_STD_R6,    float,          Flux inside r = 6
 FIELD fF_ApR6,       FLUX_AP_R6,     float,          Flux inside r = 6
+FIELD F_ApR6,        FLUX_AP_R6,     float,          Flux inside r = 5
+FIELD dF_ApR6,       FLUX_ERR_AP_R6, float,          error on Flux inside r = 5
+FIELD sF_ApR6,       FLUX_STD_AP_R6, float,          stdev of Flux inside r = 5
+FIELD fF_ApR6,       FLUX_FIL_AP_R6, float,          fill factor for Flux inside r = 5
 FIELD   detID,          DET_ID,      int,            detection ID

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/lensobj-ps1-v5.d

-              r37329
+              r37822
 FIELD F_ApR5,        FLUX_AP_R5,     float,          Flux inside r = 5
 FIELD dF_ApR5,       FLUX_ERR_AP_R5, float,          Flux inside r = 5
 FIELD sF_ApR5,       FLUX_STD_AP_R5, float,          Flux inside r = 5
 FIELD fF_ApR5,       FLUX_FIL_AP_R5, float,          Flux inside r = 5
+FIELD dF_ApR5,       FLUX_ERR_AP_R5, float,          error on Flux inside r = 5
+FIELD sF_ApR5,       FLUX_STD_AP_R5, float,          stdev of Flux inside r = 5
+FIELD fF_ApR5,       FLUX_FIL_AP_R5, float,          fill factor for Flux inside r = 5
 FIELD F_ApR6,        FLUX_AP_R6,     float,          Flux inside r = 5
 FIELD dF_ApR6,       FLUX_ERR_AP_R6, float,          Flux inside r = 5
 FIELD sF_ApR6,       FLUX_AP_R6,     float,          Flux inside r = 5
 FIELD fF_ApR6,       FLUX_AP_R6,     float,          Flux inside r = 5
+FIELD dF_ApR6,       FLUX_ERR_AP_R6, float,          error on Flux inside r = 5
+FIELD sF_ApR6,       FLUX_STD_AP_R6, float,          stdev of Flux inside r = 5
+FIELD fF_ApR6,       FLUX_FIL_AP_R6, float,          fill factor for Flux inside r = 5
 FIELD  gamma,            GAMMA,      float

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/lensobj.d

-              r37329
+              r37822
 FIELD  E2_sh_psf,      E2_SH_PSF,    float,          mean lensing shear psf stars E2
 FIELD     F_ApR5,    FLUX_AP_R5,     float,          Flux inside r = 5
 FIELD    dF_ApR5,    FLUX_ERR_AP_R5, float,          Flux inside r = 5
 FIELD    sF_ApR5,    FLUX_STD_AP_R5, float,          Flux inside r = 5
 FIELD    fF_ApR5,    FLUX_FIL_AP_R5, float,          Flux inside r = 5
+FIELD F_ApR5,        FLUX_AP_R5,     float,          Flux inside r = 5
+FIELD dF_ApR5,       FLUX_ERR_AP_R5, float,          error on Flux inside r = 5
+FIELD sF_ApR5,       FLUX_STD_AP_R5, float,          stdev of Flux inside r = 5
+FIELD fF_ApR5,       FLUX_FIL_AP_R5, float,          fill factor for Flux inside r = 5
 FIELD     F_ApR6,    FLUX_AP_R6,     float,          Flux inside r = 5
 FIELD    dF_ApR6,    FLUX_ERR_AP_R6, float,          Flux inside r = 5
 FIELD    sF_ApR6,    FLUX_AP_R6,     float,          Flux inside r = 5
 FIELD    fF_ApR6,    FLUX_AP_R6,     float,          Flux inside r = 5
+FIELD F_ApR6,        FLUX_AP_R6,     float,          Flux inside r = 5
+FIELD dF_ApR6,       FLUX_ERR_AP_R6, float,          error on Flux inside r = 5
+FIELD sF_ApR6,       FLUX_STD_AP_R6, float,          stdev of Flux inside r = 5
+FIELD fF_ApR6,       FLUX_FIL_AP_R6, float,          fill factor for Flux inside r = 5
 FIELD      gamma,        GAMMA,      float

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/measure-ps1-v5.d

r37034	r37822
68	68	FIELD psfNdof, PSF_NDOF, int, psf degrees of freedom
69	69	FIELD psfNpix, PSF_NPIX, int, psf number of pixels
70		FIELD ~~crNsigma, CR_NSIGMA, float, Nsigma deviation towards CR~~
	70	FIELD photFlags2, PHOT_FLAGS, int, flags supplied by photometry program
71	71	FIELD extNsigma, EXT_NSIGMA, float, Nsigma deviation towards EXT
72	72

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/measure.d

r37034	r37822
66	66	FIELD psfNdof, PSF_NDOF, int, psf degrees of freedom
67	67	FIELD psfNpix, PSF_NPIX, int, psf number of pixels
68		FIELD ~~crNsigma, CR_NSIGMA, float, Nsigma deviation towards CR~~
	68	FIELD photFlags2, PHOT_FLAGS, int, flags supplied by photometry program
69	69	FIELD extNsigma, EXT_NSIGMA, float, Nsigma deviation towards EXT
70	70

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/secfilt-ps1-v4.d

r37034	r37822
23	23	FIELD ubercalDist, UBERCAL_DIST, short, number of images from an ubercal-image
24	24	FIELD Mstdev, MAG_STDEV, short, standard deviation of measurements, millimags
25		FIELD stackDetectID, STACK_DETECT_ID, uint64_t, detection ID on stack used for fluxes (if any)
	25	FIELD stackPrmryOff, STACK_PRIMARY_OFF, int, measure entry which is primary stack detection
	26	FIELD stackBestOff, STACK_BEST_OFF, int, measure entry which is best stack detection

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/secfilt-ps1-v5.d

-              r37034
+              r37822
 EXTNAME      DVO_SECFILT_PS1_V5
 TYPE         BINTABLE
 SIZE         160
+SIZE         176
 DESCRIPTION  DVO SecFilt : Secondary Filter Data
 …
 FIELD  sMkron,        MAG_KRON_STDEV,  float,      standard deviation of kron mags,       mags
+# XXX I could add these fields to secfilt or calculate in dvopsps?
+FIELD  psfQfMax,      PSF_QF_MAX,      float,      best psfQf for this filter
+FIELD  psfQfPerfMax,  PSF_QF_PERF_MAX, float,      best psfQfPerfect for this filter
 # these statistics are PSF-specific
 FIELD  Mstdev,        MAG_STDEV,         float,    standard deviation of measurements,    mags
 …
 FIELD  dFapStk,       FLUX_AP_STK_ERR,   float,    mean flux ap error
+## need an 8-byte boundary here ##
+FIELD  stackDetectID, STACK_DETECT_ID,   uint64_t, detection ID on stack used for fluxes (if any)
+FIELD  Nstack,        NSTACK,            short,    number of measurements in band (gpc1 stack only)
+FIELD  NstackDet,     NSTACK_DET,        short,    number of stack detections in band (gpc1 stack only)
+FIELD  stackPrmryOff, STACK_PRIMARY_OFF,  int,     measure entry which is primary stack detection
+FIELD  stackBestOff,  STACK_BEST_OFF,     int,     measure entry which is best stack detection
 ## *** this section is for forced-warp mean values ***
 …
 FIELD  NusedApWrp,    NUSED_AP_WRP,      short,    number of detections used in average
+FIELD  Nwarp,         NWARP,             short,    number of measurements in band (gpc1 warp only)
+FIELD  NwarpGood,     NWARP_GOOD,        short,    number of meas with psf_qf > 0.85 in band (gpc1 warp only)
 FIELD  ubercalDist,   UBERCAL_DIST,      short,    number of images from an ubercal-image

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/def/secfilt.d

-              r37034
+              r37822
 EXTNAME      DVO_SECFILT
 TYPE         BINTABLE
 SIZE         160
+SIZE         176
 DESCRIPTION  DVO SecFilt : Secondary Filter Data
 …
 FIELD  sMkron,        MAG_KRON_STDEV,  float,      standard deviation of kron mags,       mags
+# XXX I could add these fields to secfilt or calculate in dvopsps?
+FIELD  psfQfMax,      PSF_QF_MAX,      float,      best psfQf for this filter
+FIELD  psfQfPerfMax,  PSF_QF_PERF_MAX, float,      best psfQfPerfect for this filter
 # these statistics are PSF-specific
 FIELD  Mstdev,        MAG_STDEV,       float,      standard deviation of measurements,    mags
 …
 FIELD  Mchisq,        MAG_CHI,         float,      chisq on average mag,                  value
 FIELD  Ncode,         NCODE,           short,      number of detections in band
 FIELD  Nused,         NUSED,           short,      number of detections used in average
 FIELD  NusedKron,     NUSED_KRON,      short,      number of detections used in average
 FIELD  NusedAp,       NUSED_AP,        short,      number of detections used in average
+FIELD  Ncode,         NCODE,           short,      number of detections in band (gpc1 chip only)
+FIELD  Nused,         NUSED,           short,      number of detections used to calculate secfilt.M
+FIELD  NusedKron,     NUSED_KRON,      short,      number of detections used to calculate secfilt.Mkron
+FIELD  NusedAp,       NUSED_AP,        short,      number of detections used to calculate secfilt.Map
 FIELD  flags,         FLAGS,           uint32_t,   photometry flags
 …
 FIELD  dFapStk,       FLUX_AP_STK_ERR,   float,    mean flux ap error
+## need an 8-byte boundary here ##
+FIELD  stackDetectID, STACK_DETECT_ID, uint64_t,   detection ID on stack used for fluxes (if any)
+FIELD  Nstack,        NSTACK,            short,    number of measurements in band (gpc1 stack only)
+FIELD  NstackDet,     NSTACK_DET,        short,    number of stack detections in band (gpc1 stack only)
+FIELD  stackPrmryOff, STACK_PRIMARY_OFF, int,      measure entry which is primary stack detection
+FIELD  stackBestOff,  STACK_BEST_OFF,    int,      measure entry which is best stack detection
 ## *** this section is for forced-warp mean values ***
 …
 FIELD  NusedApWrp,    NUSED_AP_WRP,      short,    number of detections used in average
+FIELD  ubercalDist,   UBERCAL_DIST,    short,      number of images from an ubercal-image
+FIELD  Nwarp,         NWARP,             short,    number of measurements in band (gpc1 warp only)
+FIELD  NwarpGood,     NWARP_GOOD,        short,    number of meas with psf_qf > 0.85 in band (gpc1 warp only)
+FIELD  ubercalDist,   UBERCAL_DIST,      short,    number of images from an ubercal-image
 # *** 20090206 : new fields : M_20, M_80; dropped dummy

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/doc/autocode.txt

-              r21508
+              r37822
 - the element name
+- the element FITS field (in FITS table)
 - the element data type
 - the element description
 - the element physical unit
+SUBFIELD / SUBSTRUCT keywords allows the user to define elements of a
+structure which are themselves structures.  These fields are used as
+follow:
+Binary / ASCII FITS tables write out the SUBFIELD entries as if they
+were regular table rows (substructure distinction not visible in FITS
+table).  SUBSTRUCT rows are NOT added to the FITS table.
+In a C-structure, the SUBFIELD rows are skipped and only the SUBSTRUCT
+row is saved.  The definition of the substructure is assumed to be
+defined elsewhere in the C code.
 Template File
 …
 The template file is a source code in whatever language is desired.
 Within the template, the defined keywords may be used as desired,
+wherever needed.  In addition, there are special directives which
+invoke additional special behavior.  All special directives have the
+form of comments within their target language.  They are replaced with
+a block of code in that target language, normally one which iterates
+over the FIELD elements of the schema file.  As such, the directive
+appropriate for one language should not be used within code for a
+different language.  Here is a list of existing special directives:
+wherever needed.
+In addition, there are special directives which invoke additional
+special behavior.  All special directives have the form of comments
+within their target language.  They are replaced with a block of code
+in that target language, normally one which iterates over the FIELD
+elements of the schema file.  As such, the directive appropriate for
+one language should not be used within code for a different language.
+Here is a list of existing special directives:
 /** STRUCT DEFINITION **/

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libautocode/generate

-              r26384
+              r37822
         if ($type eq "e_time")        { $pt1 = "J"; }
         if ($type eq "e_void")        { $pt1 = "B"; $Np = 8*$Np; }
+        # if ($type eq "Image")               { $pt1 = "B"; $Np = 8*$Np; }
         # e_void is a 64 bit pointer, cast to size_t.  its value is not loaded
         # from the table.
 …
         if ($type eq "e_time")        { $pt1 = sprintf "I%s", $length; }
         if ($type eq "e_void")        { $pt1 = sprintf "I%s", $length; }
+        # if ($type eq "Image")               { $pt1 = sprintf "I%s", $length; }
         if (!$pt1) { die "unknown type $type"; }
 …
         if ($type eq "e_time")        { $T = "WORD"; $n = 4; }
         if ($type eq "e_void")        { $T = "DBLE"; $n = 8; }
+        # if ($type eq "Image")               { $T = "DBLE"; $n = 8; }
         if (!$n) { die "unknown type $type"; }
 …
         if ($type eq "e_time")         { $Nbytes += 4*$Np; $valid = 1; }
         if ($type eq "e_void")         { $Nbytes += 8*$Np; $valid = 1; }
+        # if ($type eq "Image")                { $Nbytes += 8*$Np; $valid = 1; }
         if (!$valid) { die "unknown type $type"; }
+    }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/Makefile

-              r37035
+              r37822
 $(DESTINC)/ps1_v5_defs.h \
 $(DESTINC)/ps1_ref_defs.h \
+$(DESTINC)/ps1_sim_defs.h \
 $(DESTINC)/cmf-ps1-dv3.h \
 $(DESTINC)/cmf-ps1-v5.h \
 $(DESTINC)/cmf-ps1-sv3.h \
+$(DESTINC)/cmf-ps1-v5-lensing.h
+$(DESTINC)/cmf-ps1-sv4.h \
+$(DESTINC)/cmf-ps1-v5-lensing.h \
+$(DESTINC)/cmf-ps1-v5-lensing-alt.h
 INCS = $(DEFS) $(DESTINC)/dvo.h $(DESTINC)/autocode.h $(DESTINC)/dvo_util.h $(DESTINC)/dvodb.h $(DESTINC)/libdvo_astro.h $(DESTINC)/convert.h $(DESTINC)/get_graphdata.h
 …
 $(SRC)/version.$(ARCH).o         \
 $(SRC)/coordops.$(ARCH).o        \
+$(SRC)/galaxy_model.$(ARCH).o    \
 $(SRC)/dvosorts.$(ARCH).o        \
 $(SRC)/dvo_photcode_ops.$(ARCH).o \
 …
 $(SRC)/dvo_convert_PS1_V5.$(ARCH).o \
 $(SRC)/dvo_convert_PS1_REF.$(ARCH).o \
+$(SRC)/dvo_convert_PS1_SIM.$(ARCH).o \
 $(SRC)/flatcorr_io.$(ARCH).o    \
 $(SRC)/skyregion_io.$(ARCH).o    \
 $(SRC)/skyregion_gsc.$(ARCH).o    \
 $(SRC)/skyregion_ops.$(ARCH).o \
+$(SRC)/AstromOffsetMapIO.$(ARCH).o    \
+$(SRC)/AstromOffsetMapOps.$(ARCH).o \
+$(SRC)/AstromOffsetMapUtils.$(ARCH).o \
 $(SRC)/dvo_set_skyregion.$(ARCH).o \
 $(SRC)/dvo_set_catdir.$(ARCH).o \
 …
 $(SRC)/cmf-ps1-dv3.$(ARCH).o \
 $(SRC)/cmf-ps1-sv3.$(ARCH).o \
+$(SRC)/cmf-ps1-sv4.$(ARCH).o \
 $(SRC)/cmf-ps1-v5.$(ARCH).o \
 $(SRC)/cmf-ps1-v5-lensing.$(ARCH).o \
+$(SRC)/cmf-ps1-v5-lensing-alt.$(ARCH).o \
 $(SRC)/dvo_util.$(ARCH).o \
 $(SRC)/dbBooleanCond.$(ARCH).o          \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/include/cmf-ps1-v5-lensing.h

-              r37035
+              r37822
   float            E2_sh_psf;            // lensing shear
+  short            srcChipNum;
+  short            srcChipX;
+  short            srcChipY;
   float            Mr1;                  // first radial moment (pixels)
   float            Mrh;                  // half radial moment (pixels^1/2)

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/include/dvo.h

-              r37331
+              r37822
   DVO_FORMAT_PS1_DEV_3,
   DVO_FORMAT_PS1_REF,
+  DVO_FORMAT_PS1_SIM,
   DVO_FORMAT_PS1_V1,
   DVO_FORMAT_PS1_V2,
 …
 typedef enum {DVO_CAT_OPEN_FAIL, DVO_CAT_OPEN_OK, DVO_CAT_OPEN_EMPTY} DVOCatalogOpenModes;
-typedef enum {
-  PROJ_NONE, // undefined
-  PROJ_ZEA, // zenithal
-  PROJ_ZPL, // zenithal
-  PROJ_ARC, // zenithal
-  PROJ_STG, // zenithal
-  PROJ_SIN, // zenithal
-  PROJ_TAN, // zenithal
-  PROJ_TNX, // zenithal
-  PROJ_DIS, // zenithal (TAN + polyterms)
-  PROJ_LIN, // cartesian
-  PROJ_PLY, // cartesian
-  PROJ_WRP, // cartesian
-  PROJ_AIT, // pseudocyl
-  PROJ_GLS, // pseudocyl
-  PROJ_PAR, // pseudocyl
-} OhanaProjection;
-typedef enum {
-  PROJ_MODE_NONE,
-  PROJ_MODE_CARTESIAN,
-  PROJ_MODE_ZENITHAL,
-  PROJ_MODE_PSEUDOCYL,
-} OhanaProjectionMode;
 // these are used as NAN for types of int values
 …
 /* catalog values to be loaded */
+# 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
+# define LOAD_NONE      0x0000
+# define LOAD_AVES      0x0001
+# define LOAD_MEAS      0x0002
+# define LOAD_MISS      0x0004
+# define LOAD_SECF      0x0008
+# define SKIP_AVES      0x0010
+# define SKIP_MEAS      0x0020
+# define SKIP_MISS      0x0040
+# define SKIP_SECF      0x0080
+# define LOAD_LENSING   0x0100
+# define LOAD_LENSOBJ   0x0200
+# define SKIP_LENSING   0x0400
+# define SKIP_LENSOBJ   0x0800
+# define LOAD_STARPAR   0x1000
+# define SKIP_STARPAR   0x2000
 /* photometry code types */
 …
   ID_IMAGE_ASTROM_FEW     = 0x00000100,  /* currently too few measurements for astrometry */
   ID_IMAGE_PHOTOM_UBERCAL = 0x00000200,  /* externally-supplied photometry zero point from ubercal analysis */
+  ID_IMAGE_ASTROM_GMM     = 0x00000400,  /* image was fitted to positions corrected by the galaxy motion model */
 } DVOImageFlags;
 …
   ID_MEAS_BLEND_MEAS     = 0x00000100,  // detection is within radius of multiple objects
   ID_MEAS_BLEND_OBJ      = 0x00000200,  // multiple detections within radius of object
   ID_MEAS_UNDEF_3        = 0x00000400,  // unused
+  ID_MEAS_WARP_USED      = 0x00000400,  // measurement used to find mean warp photometry
   ID_MEAS_UNDEF_4        = 0x00000800,  // unused
   ID_MEAS_BLEND_MEAS_X   = 0x00001000,  // detection is within radius of multiple objects across catalogs
 …
   ID_MEAS_STACK_PRIMARY  = 0x00010000,  // this stack measurement is in the primary skycell
   ID_MEAS_STACK_PHOT_SRC = 0x00020000,  // this measurement supplied the stack photometry
+  ID_MEAS_ICRF_QSO       = 0x00040000,  // this measurement is an ICRF reference position
+  ID_MEAS_IMAGE_EPOCH    = 0x00080000,  // this measurement is registered to the image epoch (not tied to ref catalog epoch)
 } DVOMeasureFlags;
 …
 */
+/** these names were previously used for Average flags in old (LONEOS-era) dvo versions
+  ID_BAD_OBJECT        = 0x00004000, // if all measurements are bad, set this bit
+  ID_MOVING            = 0x00008000, // is a moving object
+  ID_ROCK              = 0x0000a000, // 0x8000 + 0x2000
+  ID_GHOST             = 0x0000c001, // 0x8000 + 0x4000 + 0x0001
+  ID_TRAIL             = 0x0000c002, // 0x8000 + 0x4000 + 0x0002
+  ID_BLEED             = 0x0000c003, // 0x8000 + 0x4000 + 0x0003
+  ID_COSMIC            = 0x0000c004, // 0x8000 + 0x4000 + 0x0004
+**/
 /* Average.flags values -- these values are 32 bit (as of PS1_V1) */
 typedef enum {
+  ID_STAR_FEW       = 0x00000001, // used within relphot: skip star
+  ID_STAR_POOR      = 0x00000002, // used within relphot: skip star
+  ID_PROPER         = 0x00000400, // star with large proper motion
+  ID_TRANSIENT      = 0x00001000, // is this mutually exclusive with USNO?
+  ID_VARIABLE       = 0x00002000, // not currently set?
+  ID_ASTEROID       = 0x00002000, // identified with an asteroid
+  ID_BAD_OBJECT     = 0x00004000, // if all measurements are bad, set this bit
+  ID_MOVING         = 0x00008000, // is a moving object
+  ID_ROCK           = 0x0000a000, // 0x8000 + 0x2000
+  ID_GHOST          = 0x0000c001, // 0x8000 + 0x4000 + 0x0001
+  ID_TRAIL          = 0x0000c002, // 0x8000 + 0x4000 + 0x0002
+  ID_BLEED          = 0x0000c003, // 0x8000 + 0x4000 + 0x0003
+  ID_COSMIC         = 0x0000c004, // 0x8000 + 0x4000 + 0x0004
+  ID_STAR_FIT_AVE   = 0x00010000, // average position fitted
+  ID_STAR_FIT_PM    = 0x00020000, // proper motion fitted
+  ID_STAR_FIT_PAR   = 0x00040000, // parallax fitted
+  ID_STAR_USE_AVE   = 0x00080000, // average position used (not PM or PAR)
+  ID_STAR_USE_PM    = 0x00100000, // proper motion used (not AVE or PAR)
+  ID_STAR_USE_PAR   = 0x00200000, // parallax used (not AVE or PM)
+  ID_STAR_NO_ASTROM = 0x00400000, // mean astrometry could not be measured
+  ID_STAR_BAD_PM    = 0x00800000, // mean astrometry could not be measured
+  ID_OBJ_EXT        = 0x01000000, // extended in our data (eg, PS)
+  ID_OBJ_EXT_ALT    = 0x02000000, // extended in external data (eg, 2MASS)
+  ID_OBJ_GOOD       = 0x04000000, // good-quality measurement in our data (eg,PS)
+  ID_OBJ_GOOD_ALT   = 0x08000000, // good-quality measurement in  external data (eg, 2MASS)
+  ID_OBJ_GOOD_STACK = 0x10000000, // good-quality object in the stack (> 1 good stack)
+  ID_STAR_FEW          = 0x00000001, // used within relphot: skip star
+  ID_STAR_POOR         = 0x00000002, // used within relphot: skip star
+  ID_ICRF_QSO          = 0x00000004, // object IDed with known ICRF quasar (may have ICRF position measurement)
+  ID_OTHEF_QSO         = 0x00000008, // object IDed with known or suspected quasar, without ICRF reference data
+  ID_PROPER            = 0x00000010, // star with large proper motion
+  ID_TRANSIENT         = 0x00000020, // identified as a non-periodic (stationary) transient
+  ID_VARIABLE          = 0x00000040, // identified as a period variable
+  ID_ASTEROID          = 0x00000080, // identified with a known solar-system object (asteroid or other)
+  // bits 0x00000100 - 0x00008000 are currently unused
+  ID_STAR_FIT_AVE      = 0x00010000, // average position fitted
+  ID_STAR_FIT_PM       = 0x00020000, // proper motion fitted
+  ID_STAR_FIT_PAR      = 0x00040000, // parallax fitted
+  ID_STAR_USE_AVE      = 0x00080000, // average position used (not PM or PAR)
+  ID_STAR_USE_PM       = 0x00100000, // proper motion used (not AVE or PAR)
+  ID_STAR_USE_PAR      = 0x00200000, // parallax used (not AVE or PM)
+  ID_STAR_NO_ASTROM    = 0x00400000, // mean astrometry could not be measured
+  ID_STAR_BAD_PM       = 0x00800000, // mean astrometry could not be measured
+  ID_OBJ_EXT           = 0x01000000, // extended in our data (eg, PS)
+  ID_OBJ_EXT_ALT       = 0x02000000, // extended in external data (eg, 2MASS)
+  ID_OBJ_GOOD          = 0x04000000, // good-quality measurement in our data (eg,PS)
+  ID_OBJ_GOOD_ALT      = 0x08000000, // good-quality measurement in  external data (eg, 2MASS)
+  ID_OBJ_GOOD_STACK    = 0x10000000, // good-quality object in the stack (> 1 good stack)
   ID_OBJ_SUSPECT_STACK = 0x20000000, // suspect object in the stack (> 1 good or suspect stack, < 2 good)
   ID_OBJ_BAD_STACK  = 0x40000000, // good-quality object in the stack (> 1 good stack)
+  ID_OBJ_BAD_STACK     = 0x40000000, // good-quality object in the stack (> 1 good stack)
 } DVOAverageFlags;
 …
 } DVOSecfiltFlags;
+/* definitions for parallel dvo host information
+   XXX : need better names (safer namespace)
+*/
+typedef enum {
+  DATA_ON_TGT  = 0x01,
+  DATA_ON_BCK  = 0x02,
+  DATA_USE_BCK = 0x04,
+  DATA_COPY_FAILURE = 0x80,
+} SkyTableDataFlags;
+typedef enum {
+  HOST_STDIN = 0,
+  HOST_STDOUT = 1,
+  HOST_STDERR = 2,
+} HostInfoIOfd;
 /*** general dvo structures (internal use only / not IO) ***/
 …
 } FlatCorrectionTable;
-/* definitions for parallel dvo host information
-   XXX : need better names (safer namespace)
-*/
-typedef enum {
-  DATA_ON_TGT  = 0x01,
-  DATA_ON_BCK  = 0x02,
-  DATA_USE_BCK = 0x04,
-  DATA_COPY_FAILURE = 0x80,
-} SkyTableDataFlags;
-typedef enum {
-  HOST_STDIN = 0,
-  HOST_STDOUT = 1,
-  HOST_STDERR = 2,
-} HostInfoIOfd;
 typedef struct {
   char *hostname;             // name of remote machine
 …
 } HostTable;
+typedef struct {
+  int Nhosts;
+  HostInfo **hosts;
+} HostTableGroup;
 // A RegionHost processes data for some region in parallel with other regions
 typedef struct RegionHostInfo {
 …
   off_t *imseq;
+  AstromOffsetTable *astromTable;
   int *neighbors;             // list of neighbor index values
   int Nneighbors;             // number of neighbors
 …
 # include "cmf-ps1-dv3.h"
 # include "cmf-ps1-sv3.h"
+# include "cmf-ps1-sv4.h"
 # include "cmf-ps1-v5.h"
 # include "cmf-ps1-v5-lensing.h"
+# include "cmf-ps1-v5-lensing-alt.h"
 typedef struct {
 …
   char  ***name; // projection cell name
   int NX_SUB;
   int NY_SUB;
+  float NX_SUB;
+  float NY_SUB;
   double dPix;
   double **Xo;
   double **Yo;
   int **dX;
   int **dY;
+  float **dX;
+  float **dY;
 } BoundaryTree;
 …
   double Do;
   double dPix;
   int dX;
   int dY;
   int NX_SUB;
   int NY_SUB;
+  float dX;
+  float dY;
+  float NX_SUB;
+  float NY_SUB;
   char *basename;
 …
   double         R;
   double         D;
+  float          RoffGAL;
+  float          DoffGAL;
   float          M;
   float          Mcal;
 …
 } MeasureTiny;
 /** STRUCT DEFINITION **/
+// alternate version of PS1_V4 (old dev version)
 typedef struct {
   double           R;                    // RA (decimal degrees )
 …
 Average *Average_PS1_V4alt_ToInternal (Average_PS1_V4alt *in, off_t Nvalues);
 /** STRUCT DEFINITION **/
+// alternate version of PS1_V4 (old dev version)
 typedef struct {
   float            dR;                   // RA offset (arcsec)
 …
 Measure *Measure_PS1_V4alt_ToInternal (Average *ave, Measure_PS1_V4alt *in, off_t Nvalues);
+// alternate version of PS1_V5 (old dev version)
+typedef struct {
+  float            M;                    // average mag in this band (mags)
+  float            dM;                   // formal error on average mag (mags)
+  float            Map;                  // ave aperture mag in this band (mags)
+  float            dMap;                 // ave aperture mag in this band (mags)
+  float            sMap;                 // standard deviation of ap mags (mags)
+  float            Mkron;                // ave kron mag in this band (mags)
+  float            dMkron;               // formal error on average kron mag (mags)
+  float            sMkron;               // standard deviation of kron mags (mags)
+  float            Mstdev;               // standard deviation of measurements (mags)
+  float            Mmin;                 // min accepted mag (mags)
+  float            Mmax;                 // max accepted mag (mags)
+  float            Mchisq;               // chisq on average mag (value)
+  short            Ncode;                // number of detections in band
+  short            Nused;                // number of detections used in average
+  short            NusedKron;            // number of detections used in average
+  short            NusedAp;              // number of detections used in average
+  uint32_t         flags;                // photometry flags
+  float            MpsfStk;              // magnitude from stack (primary if available)
+  float            FpsfStk;              // flux from stack (primary if available)
+  float            dFpsfStk;             // mean flux psf error
+  float            MkronStk;             // magnitude from stack (primary if available)
+  float            FkronStk;             // flux from stack (primary if available)
+  float            dFkronStk;            // mean flux kron error
+  float            MapStk;               // magnitude from stack (primary if available)
+  float            FapStk;               // flux from stack (primary if available)
+  float            dFapStk;              // mean flux ap error
+  int              stackPrmryOff;        // measure entry which is primary stack detection
+  int              stackBestOff;         // measure entry which is best stack detection
+  float            MpsfWrp;              // psf magnitude from stack (primary if available)
+  float            FpsfWrp;              // psf flux from stack (primary if available)
+  float            dFpsfWrp;             // mean flux psf error
+  float            sFpsfWrp;             // mean flux psf stdev
+  float            MkronWrp;             // kron magnitude from stack (primary if available)
+  float            FkronWrp;             // kron flux from stack (primary if available)
+  float            dFkronWrp;            // mean flux kron error
+  float            sFkronWrp;            // mean flux kron stdev
+  float            MapWrp;               // aper magnitude from stack (primary if available)
+  float            FapWrp;               // aper flux from stack (primary if available)
+  float            dFapWrp;              // mean flux ap error
+  float            sFapWrp;              // mean flux ap stdev
+  short            NusedWrp;             // number of detections used in average
+  short            NusedKronWrp;         // number of detections used in average
+  short            NusedApWrp;           // number of detections used in average
+  short            ubercalDist;          // number of images from an ubercal-image
+} SecFilt_PS1_V5alt;
+SecFilt_PS1_V5alt *gfits_table_get_SecFilt_PS1_V5alt (FTable *table, off_t *Ndata, char *swapped);
+int      gfits_convert_SecFilt_PS1_V5alt (SecFilt_PS1_V5alt *data, off_t size, off_t nitems);
+SecFilt *SecFilt_PS1_V5alt_ToInternal (SecFilt_PS1_V5alt *in, off_t Nvalues);
+// alternate version of PS1_V5alt (old dev version)
+typedef struct {
+  double           R;                    // RA (decimal degrees )
+  double           D;                    // DEC (decimal degrees )
+  float            dR;                   // RA error (arcsec)
+  float            dD;                   // DEC error (arcsec)
+  float            uR;                   // RA*cos(D) proper-motion (arcsec/year)
+  float            uD;                   // DEC proper-motion (arcsec/year)
+  float            duR;                  // RA*cos(D) p-m error (arcsec/year)
+  float            duD;                  // DEC p-m error (arcsec/year)
+  float            P;                    // parallax (arcsec)
+  float            dP;                   // parallax error (arcsec)
+  double           Rstk;                 // RA on stack (decimal degrees )
+  double           Dstk;                 // DEC on stack (decimal degrees )
+  float            dRstk;                // RA error on stack (arcsec)
+  float            dDstk;                // DEC error on stack (arcsec)
+  float            ChiSqAve;             // astrometry analysis chisq
+  float            ChiSqPM;              // astrometry analysis chisq
+  float            ChiSqPar;             // astrometry analysis chisq
+  int              Tmean;                // mean epoch (PM,PAR ref) (unix time seconds)
+  int              Trange;               // mean epoch (PM,PAR ref) (unix time seconds)
+  float            psfQF;                // psf coverage (bad masks)
+  float            psfQFperf;            // psf coverage (all masks)
+  float            stargal;              // star / galaxy separator (1/100 arcsec)
+  unsigned short   Npos;                 // number of detections used for astrometry
+  unsigned short   Nmeasure;             // number of psf measurements
+  unsigned short   Nmissing;             // number of missings
+  unsigned short   Nlensing;             // number of lensing measurements
+  unsigned short   Nlensobj;             // number of lensing measurements
+  unsigned short   Nextend;              // number of extended measurements
+  int              measureOffset;        // offset to first psf measurement
+  int              missingOffset;        // offset to first missing obs
+  int              lensingOffset;        // offset to first lensing obs
+  int              lensobjOffset;        // offset to mean lensing data
+  int              extendOffset;         // offset to extended object entry
+  int              starparOffset;        // offset to stellar parameter data
+  float            refColorBlue;         // color of astrometry ref stars
+  float            refColorRed;          // color of astrometry ref stars
+  uint32_t         flags;                // average object flags (star; ghost; etc)
+  uint32_t         photFlagsUpper;       // upper bit of 2 bit summary of per-measure photflags
+  uint32_t         photFlagsLower;       // lower bit of 2 bit summary of per-measure photflags
+  unsigned int     objID;                // unique ID for object in table
+  unsigned int     catID;                // unique ID for table in which object was first realized
+  uint64_t         extID;                // external ID for object (eg PSPS objID)
+  uint64_t         extIDgc;              // external ID for object in galactic coords
+} Average_PS1_V5alt;
+Average_PS1_V5alt *gfits_table_get_Average_PS1_V5alt (FTable *table, off_t *Ndata, char *swapped);
+int      gfits_convert_Average_PS1_V5alt (Average_PS1_V5alt *data, off_t size, off_t nitems);
+Average *Average_PS1_V5alt_ToInternal (Average_PS1_V5alt *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 */
 …
   Lensing *lensing;
   Lensobj *lensobj;
+  StarPar *starpar;
   int Nsecfilt;  /* number of secfilt entries for each average entry */
   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 */
+  off_t Naverage,   Nmeasure,   Nmissing,   Nlensing,      Nlensobj,      Nstarpar,      Nsecf_mem;  /* current number of each component in memory */
+  off_t Naves_disk, Nmeas_disk, Nmiss_disk, Nlensing_disk, Nlensobj_disk, Nstarpar_disk, Nsecf_disk; /* current number of each component on disk */
+  off_t Naves_off,  Nmeas_off,  Nmiss_off,  Nlensing_off,  Nlensobj_off,  Nstarpar_off,  Nsecf_off;  /* index of first loaded data value */
   // note that we use these for the full-sky relphot analysis
 …
   struct Catalog *lensing_catalog;              /* lensing catalog data (split) */
   struct Catalog *lensobj_catalog;              /* lensobj catalog data (split) */
+  struct Catalog *starpar_catalog;              /* starpar catalog data (split) */
   unsigned int objID;
 …
 int   gfits_db_free                PROTO((FITS_DB *db));
-/* in coords.c, using libautocode/def/coords.d */
-int  XY_to_LM (double *L, double *M, double x,  double y,   Coords *coords);
-int  LM_to_XY (double *x,  double *y,   double L, double M, Coords *coords);
-int  RD_to_LM (double *L, double *M, double ra,  double dec,   Coords *coords);
-int  LM_to_RD (double *ra, double *dec,   double L, double M, Coords *coords);
-int  XY_to_RD (double *ra, double *dec, double x,  double y,   Coords *coords);
-int  RD_to_XY (double *x,  double *y,   double ra, double dec, Coords *coords);
-int  fXY_to_RD (float *ra, float *dec, double x,  double y,   Coords *coords);
-int  fRD_to_XY (float *x,  float *y,   double ra, double dec, Coords *coords);
-int  GetCoords (Coords *coords, Header *header);
-int  PutCoords (Coords *coords, Header *header);
-void RegisterMosaic (Coords *coords);
-void coords_precess (double *ra, double *dec, double in_epoch, double out_epoch);
-OhanaProjection GetProjection (char *ctype);
-int SetProjection (char *ctype, OhanaProjection proj);
-OhanaProjectionMode GetProjectionMode (OhanaProjection proj);
 char *libdvo_version (void);
 …
 float PhotFluxInstErr (Measure *measure, dvoMagClassType class);
 float PhotFluxCatErr (Measure *measure, dvoMagClassType class);
+float PhotFluxAveErr (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
 float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt);
 float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt);
+float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt);
+int   PhotNphot (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
+float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
 float PhotMmin (PhotCode *code, Average *average, SecFilt *secfilt);
 float PhotMmax (PhotCode *code, Average *average, SecFilt *secfilt);
 …
 Lensing *FtableToLensing (FTable *ftable, off_t *Nlensing, char *format);
 Lensobj *FtableToLensobj (FTable *ftable, off_t *Nlensobj, char *format);
+StarPar *FtableToStarPar (FTable *ftable, off_t *Nstarpar, char *format);
 int      FtableToImage   (FTable *ftable, Header *theader, 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 StarParToFtable (FTable *ftable, StarPar *starpar, off_t Nstarpar, char format);
 int ImageToFtable (FTable *ftable, Header *theader, char format);
 int ImageToVtable (VTable *vtable, Header *theader, char format);
 …
 # include "ps1_v5_defs.h"
 # include "ps1_ref_defs.h"
+# include "ps1_sim_defs.h"
 /*** DVO image db I/O Functions ***/
 …
 void dvo_image_create (FITS_DB *db, double ZeroPoint);
+int gfits_table_set_Image (FTable *ftable);
+int gfits_table_mkheader_Image (Header *header);
+Image *gfits_table_get_Image (FTable *ftable, off_t *Ndata, char *swapped);
 /* flatcorr APIs */
 FlatCorrectionTable *FlatCorrectionLoad (char *filename, int VERBOSE);
 …
 SkyTable  *SkyTableLoadOptimal     PROTO((char *catdir, char *SKYFILE, char *GSCFILE, int readwrite, int depth, int VERBOSE));
 int        SkyTableSetDepth        PROTO((SkyTable *sky, int depth));
+SkyList   *SkyRegionByIndex        PROTO((SkyTable *table, int index));
 SkyList   *SkyRegionByCPT          PROTO((SkyTable *table, char *filename));
 SkyList   *SkyRegionByPoint        PROTO((SkyTable *table, int depth, double ra, double dec));
 …
 int HostTableTestHost (SkyRegion *region, int hostID);
+void InitHost (HostInfo *host);
+HostTableGroup *HostTableGroups (HostTable *table, int *ngroups);
+int HostTableGroupWaitJobsGetIO (HostTableGroup *table, char *file, int lineno, int VERBOSE);
 // functions to support tiny versions of Average and Measure
 void CopyAverageToTiny (AverageTiny *averageT, Average *average);
 …
 void dvo_lensing_init (Lensing *lensing);
 void dvo_lensobj_init (Lensobj *lensobj, int toZero);
+void dvo_starpar_init (StarPar *starpar);
 void InitRegionHosts (RegionHostInfo *hosts, int Nhosts, int NHOSTS);
 …
 int RegionHostFindNeighbors (RegionHostTable *table, int Nhost);
+// galaxy_model:
+int TransformProperMotion_radians (double *uR, double *uD, double uL, double uB, double Rrad, double Drad, CoordTransform *transform);
+int TransformProperMotion (double *uR, double *uD, double uL, double uB, double R, double D, CoordTransform *transform);
+int SolarMotionModel_radians (double *uL_sol, double *uB_sol, double Lrad, double Brad, double distance);
+int SolarMotionModel (double *uL_sol, double *uB_sol, double L, double B, double distance);
+int GalaxyMotionModel_radians (double *uL_gal, double *uB_gal, double Lrad, double Brad);
+int GalaxyMotionModel (double *uL_gal, double *uB_gal, double L, double B);
+int InitGalaxyModel (char *version);
+# define LENSFIELD(NAME) float LensValue_##NAME (PhotCode *code, Lensobj *lensobj);
+LENSFIELD(X11_sm_obj)
+LENSFIELD(X12_sm_obj)
+LENSFIELD(X22_sm_obj)
+LENSFIELD(E1_sm_obj)
+LENSFIELD(E2_sm_obj)
+LENSFIELD(X11_sh_obj)
+LENSFIELD(X12_sh_obj)
+LENSFIELD(X22_sh_obj)
+LENSFIELD(E1_sh_obj)
+LENSFIELD(E2_sh_obj)
+LENSFIELD(X11_sm_psf)
+LENSFIELD(X12_sm_psf)
+LENSFIELD(X22_sm_psf)
+LENSFIELD(E1_sm_psf)
+LENSFIELD(E2_sm_psf)
+LENSFIELD(X11_sh_psf)
+LENSFIELD(X12_sh_psf)
+LENSFIELD(X22_sh_psf)
+LENSFIELD(E1_sh_psf)
+LENSFIELD(E2_sh_psf)
+# undef LENSFIELD
 # endif // DVO_H

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/include/dvodb.h

-              r37035
+              r37822
   MAG_OPTION_NPHOT, // Nused
   MAG_OPTION_UC_DIST,
-  MAG_OPTION_STACK_DET_ID,
   MAG_OPTION_FLAGS,
+  MAG_OPTION_X11_SM_OBJ,
+  MAG_OPTION_X12_SM_OBJ,
+  MAG_OPTION_X22_SM_OBJ,
+  MAG_OPTION_E1_SM_OBJ,
+  MAG_OPTION_E2_SM_OBJ,
+  MAG_OPTION_X11_SH_OBJ,
+  MAG_OPTION_X12_SH_OBJ,
+  MAG_OPTION_X22_SH_OBJ,
+  MAG_OPTION_E1_SH_OBJ,
+  MAG_OPTION_E2_SH_OBJ,
+  MAG_OPTION_X11_SM_PSF,
+  MAG_OPTION_X12_SM_PSF,
+  MAG_OPTION_X22_SM_PSF,
+  MAG_OPTION_E1_SM_PSF,
+  MAG_OPTION_E2_SM_PSF,
+  MAG_OPTION_X11_SH_PSF,
+  MAG_OPTION_X12_SH_PSF,
+  MAG_OPTION_X22_SH_PSF,
+  MAG_OPTION_E1_SH_PSF,
+  MAG_OPTION_E2_SH_PSF,
+  MAG_OPTION_F_AP_R5,
+  MAG_OPTION_F_ERR_AP_R5,
+  MAG_OPTION_F_STDEV_AP_R5,
+  MAG_OPTION_F_FILL_AP_R5,
+  MAG_OPTION_F_AP_R6,
+  MAG_OPTION_F_ERR_AP_R6,
+  MAG_OPTION_F_STDEV_AP_R6,
+  MAG_OPTION_F_FILL_AP_R6,
 } dvoMagOptionType;
+//  MAG_OPTION_STACK_PRIMARY_OFF,
+//  MAG_OPTION_STACK_BEST_OFF,
 typedef enum {
 …
       MEAS_XFIX,
       MEAS_YFIX,
+      MEAS_XOFF_KH,
+      MEAS_YOFF_KH,
+      MEAS_XOFF_DCR,
+      MEAS_YOFF_DCR,
+      MEAS_ROFF_GAL,
+      MEAS_DOFF_GAL,
       MEAS_POS_SYS_ERR,
       MEAS_XFIELD,
 …
       MEAS_FLAT,
       MEAS_CENTER_OFFSET,
+      MEAS_REF_COLOR,
+      MEAS_REF_COLOR_BLUE,
+      MEAS_REF_COLOR_RED,
+      MEAS_X11_SM_OBJ,
+      MEAS_X12_SM_OBJ,
+      MEAS_X22_SM_OBJ,
+      MEAS_E1_SM_OBJ,
+      MEAS_E2_SM_OBJ,
+      MEAS_X11_SH_OBJ,
+      MEAS_X12_SH_OBJ,
+      MEAS_X22_SH_OBJ,
+      MEAS_E1_SH_OBJ,
+      MEAS_E2_SH_OBJ,
+      MEAS_X11_SM_PSF,
+      MEAS_X12_SM_PSF,
+      MEAS_X22_SM_PSF,
+      MEAS_E1_SM_PSF,
+      MEAS_E2_SM_PSF,
+      MEAS_X11_SH_PSF,
+      MEAS_X12_SH_PSF,
+      MEAS_X22_SH_PSF,
+      MEAS_E1_SH_PSF,
+      MEAS_E2_SH_PSF,
+      MEAS_E_BV,                      // extinction (mags)
+      MEAS_E_BV_ERR,
+      MEAS_DISTANCE_MOD, // distance modulus (mags)
+      MEAS_DISTANCE_MOD_ERR,
+      MEAS_M_R,               // absolute mag in r-band
+      MEAS_M_R_ERR,
+      MEAS_FEH,               // metallicity
+      MEAS_FEH_ERR,
+      MEAS_URA_GALMODEL,      // model pm prediction
+      MEAS_UDEC_GALMODEL,     // model pm prediction
+      MEAS_RA_GALMODEL,      // model pm prediction
+      MEAS_DEC_GALMODEL,     // model pm prediction
 };
 …
       AVE_EXTID_HI,
       AVE_EXTID_LO,
+      AVE_REF_COLOR,
+      AVE_REF_COLOR_BLUE,
+      AVE_REF_COLOR_RED,
       AVE_PHOT, // photometry class of values
+      AVE_E_BV,               // extinction (mags)
+      AVE_E_BV_ERR,
+      AVE_DISTANCE_MOD, // distance modulus (mags)
+      AVE_DISTANCE_MOD_ERR,
+      AVE_M_R,                // absolute mag in r-band
+      AVE_M_R_ERR,
+      AVE_FEH,                // metallicity
+      AVE_FEH_ERR,
+      AVE_URA_GALMODEL,      // model pm prediction
+      AVE_UDEC_GALMODEL,     // model pm prediction
+      AVE_RA_GALMODEL,      // model pm prediction
+      AVE_DEC_GALMODEL,     // model pm prediction
 };
 …
       IMAGE_NLINK_PHOTOM,
       IMAGE_NLINK_ASTROM,
+      IMAGE_REF_COLOR
+      IMAGE_REF_COLOR_BLUE,
+      IMAGE_REF_COLOR_RED
 };
 …
 int          ParseImageField        PROTO((dbField *field, char *fieldName));
 dbValue      dbExtractAverages      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
 dbValue      dbExtractMeasures      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
+dbValue      dbExtractAverages      PROTO((Average *average, SecFilt *secfilt, Measure *measure, Lensobj *lensobj, StarPar *starpar, dbField *field));
+dbValue      dbExtractMeasures      PROTO((Average *average, SecFilt *secfilt, Measure *measure, Lensing *lensing, StarPar *starpar, dbField *field));
 dbValue      dbExtractImages        PROTO((Image *image, off_t Nimage, off_t N, dbField *field));
 …
 int          dbAstroRegionLimits    PROTO((dbStack **stack, int *nstack, SkyRegionSelection *selection, int table));
 char        *strfloat               PROTO((float value));
+int dbFieldNeedMeasure (dbField *fields, int Nfields);
+int dbFieldNeedLensobj (dbField *fields, int Nfields);
+int dbFieldNeedLensing (dbField *fields, int Nfields);
+int dbFieldNeedStarpar (dbField *fields, int Nfields, int isAverage);
 void FreeImageSelection (void);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/include/libdvo_astro.h

-              r31635
+              r37822
+#ifdef notdef
+# include "external.h"
+# include "shell.h"
+# include "dvomath.h"
+# include "convert.h"
+# include "display.h"
+# include "data.h"
+#endif
+# ifndef LIBDVO_ASTRO_H
+# define LIBDVO_ASTRO_H
+# ifndef ASTRO_H
+# define ASTRO_H
+typedef enum {
+  COORD_NONE,
+  COORD_CELESTIAL,
+  COORD_GALACTIC, // based on Liu et al 2011
+  COORD_ECLIPTIC,
+  COORD_GALACTIC_REID_2004, // an older definition of the galactic plane
+} CoordTransformSystem;
+void InitAstro (void);
+void FreeAstro (void);
+typedef enum {
+  PROJ_NONE, // undefined
+  PROJ_ZEA, // zenithal
+  PROJ_ZPL, // zenithal
+  PROJ_ARC, // zenithal
+  PROJ_STG, // zenithal
+  PROJ_SIN, // zenithal
+  PROJ_TAN, // zenithal
+  PROJ_TNX, // zenithal
+  PROJ_DIS, // zenithal (TAN + polyterms)
+  PROJ_LIN, // cartesian
+  PROJ_PLY, // cartesian (allow polyterms)
+  PROJ_WRP, // cartesian (allow polyterms, require mosaic)
+  PROJ_AIT, // pseudocyl
+  PROJ_GLS, // pseudocyl
+  PROJ_PAR, // pseudocyl
+} OhanaProjection;
+typedef enum {
+  PROJ_MODE_NONE,
+  PROJ_MODE_CARTESIAN,
+  PROJ_MODE_ZENITHAL,
+  PROJ_MODE_PSEUDOCYL,
+} OhanaProjectionMode;
 typedef struct {
 …
 } CoordTransform;
+typedef enum {COORD_NONE, COORD_CELESTIAL, COORD_GALACTIC, COORD_ECLIPTIC} CoordTransformSystem;
+typedef struct {
+  int Nx;
+  int Ny;
+  float dX;
+  float dY;
+  float **dXv;
+  float **dYv;
+  unsigned int tableID;
+  unsigned int imageID;
+  int keep;
+} AstromOffsetMap;
+typedef struct {
+  int Nmap;
+  AstromOffsetMap **map;
+   int *imageIDtoTableSeq;
+  int MaxImageID;
+  int MaxTableID;
+} AstromOffsetTable;
+/* Internal version of Coords (see CoordsDisk in libautocode/def/coords-disk.d) */
+typedef struct Coords {
+  double           crval1;               // coordinate at reference pixel
+  double           crval2;               // coordinate at reference pixel
+  float            crpix1;               // coordinate of reference pixel
+  float            crpix2;               // coordinate of reference pixel
+  float            cdelt1;               // degrees per pixel
+  float            cdelt2;               // degrees per pixel
+  float            pc1_1;                // rotation matrix
+  float            pc1_2;                // rotation matrix
+  float            pc2_1;                // rotation matrix
+  float            pc2_2;                // rotation matrix
+  float            polyterms[7][2];      // higher order warping terms
+  char             ctype[15];            // coordinate type
+  char             Npolyterms;           // order of polynomial
+  struct Coords   *mosaic;               // pointer to parent mosaic
+  AstromOffsetMap *offsetMap;            // pointer to offset map transformation
+} Coords;
+typedef struct Image {
+  Coords           coords;               // astrometric data
+  e_time           tzero;                // readout time (row 0)
+  unsigned int     nstar;                // number of stars on image
+  float            secz;                 // airmass (mag)
+  unsigned short   NX;                   // image width
+  unsigned short   NY;                   // image height
+  float            apmifit;              // aperture correction (mag)
+  float            dapmifit;             // apmifit error (mag)
+  float            Mcal;                 // calibration mag (mag)
+  float            dMcal;                // error on Mcal (mag)
+  short            Xm;                   // image chisq (10*log(value))
+  short            photcode;             // identifier for CCD,
+  float            exptime;              // exposure time (seconds)
+  float            sidtime;              // sidereal time of exposure
+  float            latitude;             // observatory latitude (degrees)
+  float            RAo;                  // image center (degrees)
+  float            DECo;                 // image center (degrees)
+  float            Radius;               // image radius (degrees)
+  float            refColorBlue;         // median astrometry ref color
+  float            refColorRed;          // median astrometry ref color
+  char             name[117];            // name of original image
+  unsigned char    detection_limit;      // detection limit (10*mag)
+  unsigned char    saturation_limit;     // saturation limit (10*mag)
+  unsigned char    cerror;               // astrometric error (50*arcsec)
+  unsigned char    fwhm_x;               // PSF x width (25*arcsec)
+  unsigned char    fwhm_y;               // PSF y width (25*arcsec)
+  unsigned char    trate;                // scan rate (100 usec/pixel)
+  unsigned char    ccdnum;               // CCD ID number
+  unsigned int     flags;                // image quality flags
+  unsigned int     imageID;              // internal image ID
+  unsigned int     parentID;             // associated ref image
+  unsigned int     externID;             // external image ID
+  unsigned short   sourceID;             // analysis source ID
+  short            nLinkAstrom;          // mean number of matched measurements for astrometry
+  short            nLinkPhotom;          // mean number of matched measurements for astrometry
+  short            ubercalDist;          // distance to nearest ubercal image
+  float            dXpixSys;             // systematic astrometry error in X
+  float            dYpixSys;             // systematic astrometry error in Y
+  float            dMagSys;              // systematic photometry error
+  unsigned short   nFitAstrom;           // number of stars used for astrometry cal
+  unsigned short   nFitPhotom;           // number of stars used for photometry cal
+  unsigned int     photom_map_id;        // reference to 2D zero point map
+  unsigned int     astrom_map_id;        // reference to 2D astrometry map
+  struct Image    *parent;               // pointer to parent mosaic (not save to disk)
+} Image;
 CoordTransform *InitTransform (CoordTransformSystem input, CoordTransformSystem output);
 int ApplyTransform (double *x, double *y, double X, double Y, CoordTransform *transform);
+/* in coords.c */
+void InitCoords (Coords *coords, char *projection);
+void CopyCoords (Coords *tgt, Coords *src);
+int  XY_to_LM (double *L, double *M, double x,  double y,   Coords *coords);
+int  LM_to_XY (double *x,  double *y,   double L, double M, Coords *coords);
+int  RD_to_LM (double *L, double *M, double ra,  double dec,   Coords *coords);
+int  LM_to_RD (double *ra, double *dec,   double L, double M, Coords *coords);
+int  XY_to_RD (double *ra, double *dec, double x,  double y,   Coords *coords);
+int  RD_to_XY (double *x,  double *y,   double ra, double dec, Coords *coords);
+int  fXY_to_RD (float *ra, float *dec, double x,  double y,   Coords *coords);
+int  fRD_to_XY (float *x,  float *y,   double ra, double dec, Coords *coords);
+int  GetCoords (Coords *coords, Header *header);
+int  PutCoords (Coords *coords, Header *header);
+void coords_precess (double *ra, double *dec, double in_epoch, double out_epoch);
+OhanaProjection GetProjection (char *ctype);
+int SetProjection (char *ctype, OhanaProjection proj);
+OhanaProjectionMode GetProjectionMode (OhanaProjection proj);
+/* in AstromOffsetMapIO.c */
+AstromOffsetTable *AstromOffsetMapLoad (char *filename, int VERBOSE);
+int AstromOffsetMapSave (AstromOffsetTable *table, char *filename);
+AstromOffsetTable *AstromOffsetMapToTable(AstromOffsetMap_Disk_6x6 *map_disk, off_t Nmap);
+AstromOffsetMap_Disk_6x6 *AstromOffsetTableToMap(AstromOffsetTable *table, off_t *Nmap);
+/* in AstromOffsetMapOps.c */
+float AstromOffsetMapValue (AstromOffsetMap *map, float x, float y, int xdir);
+int AstromOffsetMapFit (AstromOffsetMap *map, float *x, float *y, float *f, int Npts, int xdir);
+/* in AstromOffsetMapUtils.c */
+AstromOffsetMap *AstromOffsetMapInit (int Nx, int Ny);
+void AstromOffsetMapFree (AstromOffsetMap *map);
+int AstromOffsetTableNewMap (AstromOffsetTable *table, int Nx, int Ny, Image *image);
+int AstromOffsetTableMatchChips (Image *images, off_t Nimages, AstromOffsetTable *table);
+AstromOffsetTable *AstromOffsetTableInit();
+void AstromOffsetTableFree(AstromOffsetTable *table);
+int AstromOffsetTableAddMapFromImage (AstromOffsetTable *table, Image *image);
+void AstromOffsetMapPrint (AstromOffsetMap *map, char *filename);
+int AstromOffsetMapRepair (AstromOffsetMap *map, int xdir);
+AstromOffsetMap *AstromOffsetMapCopy (AstromOffsetMap *map);
+void AstromOffsetMapCopyData (AstromOffsetMap *tgt, AstromOffsetMap *src);
+void AstromOffsetMapSetOrder (AstromOffsetMap *map, int Nx, int Ny, Image *image);
 # endif

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/include/ps1_v5_defs.h

-              r37035
+              r37822
 Lensing                 *Lensing_PS1_V5_ToInternal (Lensing_PS1_V5 *in, off_t Nvalues);
+Lensing                 *Lensing_PS1_V5_ALT_ToInternal (Lensing_PS1_V5_ALT *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);
+StarPar                 *StarPar_PS1_V5_ToInternal (StarPar_PS1_V5 *in, off_t Nvalues);
+StarPar_PS1_V5          *StarParInternalTo_PS1_V5 (StarPar *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);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/BoundaryTree.c

-              r36490
+              r37822
   gfits_scan (headerPHU, "DEC_ORI",  "%lf", 1, &tree->DEC_origin);
   gfits_scan (headerPHU, "DEC_OFF",  "%lf", 1, &tree->DEC_offset);
   gfits_scan (headerPHU, "NX_SUB",   "%d",  1, &tree->NX_SUB);
   gfits_scan (headerPHU, "NY_SUB",   "%d",  1, &tree->NY_SUB);
+  gfits_scan (headerPHU, "NX_SUB",   "%f",  1, &tree->NX_SUB);
+  gfits_scan (headerPHU, "NY_SUB",   "%f",  1, &tree->NY_SUB);
   gfits_scan (headerPHU, "PIXSCALE", "%lf", 1, &tree->dPix);
 …
   ALLOCATE (tree->Xo,   double *, tree->Nzone);
   ALLOCATE (tree->Yo,   double *, tree->Nzone);
   ALLOCATE (tree->dX,      int *, tree->Nzone);
   ALLOCATE (tree->dY,      int *, tree->Nzone);
+  ALLOCATE (tree->dX,    float *, tree->Nzone);
+  ALLOCATE (tree->dY,    float *, tree->Nzone);
   ALLOCATE (tree->cell,    int *, tree->Nzone);
   ALLOCATE (tree->projID,  int *, tree->Nzone);
 …
     ALLOCATE (tree->Xo[i],   double, tree->Nband[i]);
     ALLOCATE (tree->Yo[i],   double, tree->Nband[i]);
     ALLOCATE (tree->dX[i],      int, tree->Nband[i]);
     ALLOCATE (tree->dY[i],      int, tree->Nband[i]);
+    ALLOCATE (tree->dX[i],    float, tree->Nband[i]);
+    ALLOCATE (tree->dY[i],    float, tree->Nband[i]);
     ALLOCATE (tree->cell[i],    int, tree->Nband[i]);
     ALLOCATE (tree->projID[i],  int, tree->Nband[i]);
 …
   GET_COLUMN_NEW(&headerCell, &ftableCell, Xo,    "X_CENT",      double);
   GET_COLUMN_NEW(&headerCell, &ftableCell, Yo,    "Y_CENT",      double);
   GET_COLUMN_NEW(&headerCell, &ftableCell, dX,    "X_GRID",      int);
   GET_COLUMN_NEW(&headerCell, &ftableCell, dY,    "Y_GRID",      int);
+  GET_COLUMN_NEW(&headerCell, &ftableCell, dX,    "X_GRID",      float);
+  GET_COLUMN_NEW(&headerCell, &ftableCell, dY,    "Y_GRID",      float);
   GET_COLUMN_NEW(&headerCell, &ftableCell, name,  "NAME",        char); // XXX how is this done?
   gfits_free_header (&headerCell);
 …
   gfits_modify (&header, "DEC_OFF", "%lf", 1, tree->DEC_offset);
   gfits_modify (&header, "NX_SUB", "%d", 1, tree->NX_SUB);
   gfits_modify (&header, "NY_SUB", "%d", 1, tree->NY_SUB);
+  gfits_modify (&header, "NX_SUB", "%f", 1, tree->NX_SUB);
+  gfits_modify (&header, "NY_SUB", "%f", 1, tree->NY_SUB);
   gfits_modify (&header, "PIXSCALE", "%lf", 1, tree->dPix);
 …
     gfits_define_bintable_column (&theader, "D", "X_CENT", "projection cell center pixel", "none", 1.0, 0.0);
     gfits_define_bintable_column (&theader, "D", "Y_CENT", "projection cell center pixel", "none", 1.0, 0.0);
     gfits_define_bintable_column (&theader, "J", "X_GRID", "skycell grid spacing", "none", 1.0, 0.0);
     gfits_define_bintable_column (&theader, "J", "Y_GRID", "skycell grid spacing", "none", 1.0, 0.0);
+    gfits_define_bintable_column (&theader, "E", "X_GRID", "skycell grid spacing", "none", 1.0, 0.0);
+    gfits_define_bintable_column (&theader, "E", "Y_GRID", "skycell grid spacing", "none", 1.0, 0.0);
     gfits_define_bintable_column (&theader, fmt, "NAME", "cell name", "none", 1.0, 0.0);
 …
     double *Xo            ; ALLOCATE (Xo,    double, Ncell);
     double *Yo            ; ALLOCATE (Yo,    double, Ncell);
     int    *dX            ; ALLOCATE (dX,    int,    Ncell);
     int    *dY            ; ALLOCATE (dY,    int,    Ncell);
+    float  *dX            ; ALLOCATE (dX,    float,  Ncell);
+    float  *dY            ; ALLOCATE (dY,    float,  Ncell);
     char   *name          ; ALLOCATE (name,  char,   Ncell*BOUNDARY_TREE_NAME_LENGTH);
 …
 int BoundaryTreeCellCoords (BoundaryTree *tree, int *zone, int *band, double ra, double dec) {
+  ra = ohana_normalize_angle (ra);
   // first, find the containing zone

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/HostTable.c

-              r35848
+              r37822
 # include <sys/wait.h>
+void InitHost (HostInfo *host) {
+  host->hostname = NULL;
+  host->pathname = NULL;
+  host->results = NULL;
+  host->stdio[HOST_STDIN] = -1;
+  host->stdio[HOST_STDOUT] = -1;
+  host->stdio[HOST_STDERR] = -1;
+  host->pid = 0;
+  return;
+}
 void InitHosts (HostInfo *hosts, int Nhosts, int NHOSTS) {
   int i;
   for (i = Nhosts; i < NHOSTS; i++) {
+    hosts[i].hostname = NULL;
+    hosts[i].pathname = NULL;
+    hosts[i].results = NULL;
+    hosts[i].stdio[HOST_STDIN] = -1;
+    hosts[i].stdio[HOST_STDOUT] = -1;
+    hosts[i].stdio[HOST_STDERR] = -1;
+    hosts[i].pid = 0;
+    InitHost (&hosts[i]);
+  }
   return;
 …
+  }
   if (table->index) free (table->index);
+  free (table);
+  return;
+}
+// a HostTableGroup is a pointer set to one or more HostTable entries
+void FreeTableGroup (HostTableGroup *table) {
+  if (!table) return;
+  if (table->hosts) {
+    free (table->hosts);
+  }
   free (table);
   return;
 …
   fclose (f);
   return table;
+}
+// split a host table into Ngroups, each with a unique set of hosts
+HostTableGroup *HostTableGroups (HostTable *table, int *ngroups) {
+  // identify the unique host names and the number of times they each exist
+  // (Host tables are not very large; I can afford to do this in an inefficient way)
+  int i, j, k;
+  int Nunique = 0;
+  char **unique_hosts = NULL; // an array of pointers to a set of the names
+  int  *Nunique_hosts = NULL; // an array of pointers to the count of each
+  ALLOCATE ( unique_hosts, char *, table->Nhosts);
+  ALLOCATE (Nunique_hosts, int, table->Nhosts);
+  for (i = 0; i < table->Nhosts; i++) Nunique_hosts[i] = 0;
+  for (i = 0; i < table->Nhosts; i++) {
+    int found = FALSE;
+    for (j = 0; !found && (j < Nunique); j++) {
+      if (!strcmp(table->hosts[i].hostname, unique_hosts[j])) {
+        Nunique_hosts[j] ++;
+        found = TRUE;
+      }
+    }
+    if (!found) {
+      unique_hosts[Nunique] = table->hosts[i].hostname;
+      Nunique_hosts[Nunique] = 1;
+      Nunique ++;
+    }
+  }
+  int Ngroups = 0;
+  for (i = 0; i < Nunique; i++) {
+    Ngroups = MAX (Nunique_hosts[i], Ngroups);
+  }
+  HostTableGroup *groups = NULL;
+  int *foundHost = NULL;
+  ALLOCATE (foundHost, int, table->Nhosts);
+  ALLOCATE (groups, HostTableGroup, Ngroups);
+  for (i = 0; i < table->Nhosts; i++) foundHost[i] = FALSE;
+  // in each group, attempt to add one of each unique host
+  for (i = 0; i < Ngroups; i++) {
+    groups[i].Nhosts = 0;
+    ALLOCATE (groups[i].hosts, HostInfo *, Nunique);
+    for (j = 0; j < Nunique; j++) {
+      int found = FALSE;
+      for (k = 0; !found && (k < table->Nhosts); k++) {
+        if (foundHost[k]) continue;
+        if (strcmp(unique_hosts[j], table->hosts[k].hostname)) continue;
+        groups[i].hosts[groups[i].Nhosts] = &table->hosts[k];
+        groups[i].Nhosts ++;
+        found = TRUE;
+        foundHost[k] = TRUE;
+      }
+    }
+  }
+  *ngroups = Ngroups;
+  return groups;
+}
 …
   // this loop has 2 chunks: (a) check for I/O + (b) check for jobs done
   while (1) {
+  while (Nfound < Nrunning) {
     // Wait up to 0.5 second for host to provide I/O
 …
         // if (table->hosts[i].stdout.Nbuffer > 0x10000) {
         if (table->hosts[i].stdout.Nbuffer > 0x1000) {
           int printHead = VERBOSE || (table->hosts[i].stdout.Nbuffer > 0);
+          int printHead = VERBOSE && (table->hosts[i].stdout.Nbuffer > 0);
           if (printHead) fprintf (stdout, "--- stdout from %s --- (%d bytes, v1)\n", table->hosts[i].hostname, table->hosts[i].stdout.Nbuffer);
           int Nout = write (STDOUT_FILENO, table->hosts[i].stdout.buffer, table->hosts[i].stdout.Nbuffer);
 …
         // if (table->hosts[i].stderr.Nbuffer > 0x10000) {
         if (table->hosts[i].stderr.Nbuffer > 0x1000) {
           int printHead = VERBOSE || (table->hosts[i].stderr.Nbuffer > 0);
+          int printHead = VERBOSE && (table->hosts[i].stderr.Nbuffer > 0);
           if (printHead) fprintf (stdout, "--- stderr from %s --- (%d bytes, v1)\n", table->hosts[i].hostname, table->hosts[i].stderr.Nbuffer);
           int Nout = write (STDOUT_FILENO, table->hosts[i].stderr.buffer, table->hosts[i].stderr.Nbuffer);
 …
       if (!pid) {
         // fprintf (stderr, "no hosts to harvest\n");
         usleep (500000);
+        usleep (200000);
         break; // no outstanding jobs have finished
+      }
 …
+        }
+      }
+      if (!found) {
+        fprintf (stderr, "Programming error: failed to matched finished job to known host!\n");
+        exit (2);
+      }
+      Nfound ++;
+      if (found) Nfound ++;
+      // we sometimes harvest children not in the list (eg, closed kapa window).  just ignore
       if (Nfound == Nrunning) goto escape; // we've harvested all jobs
+    }
 …
+}
+// wait for all children to complete, report output to stdout
+int HostTableGroupWaitJobsGetIO (HostTableGroup *table, char *file, int lineno, int VERBOSE) {
+  // we have launched table->Nhosts jobs; wait for all of them to complete...
+  // if one (N) failed to launch, we will get an ECHILD error from the last (N) calls
+  // we need to read any data waiting on stderr or stdout from these jobs, or the overfull
+  // buffers can cause a problem.  we alternate between 'select' and 'waitpid' calls with
+  // timeouts for both
+  // add all hosts' sockets to the fd_sets
+  fd_set rdSet, wtSet;
+  FD_ZERO (&rdSet);
+  FD_ZERO (&wtSet);
+  // XXX can I set the fd_sets once, since I am not actually closing the fd's?
+  int globalStatus = TRUE;
+  int i;
+  int Nmax = 0;
+  for (i = 0; i < table->Nhosts; i++) {
+    if (!table->hosts[i][0].pid) continue; // any unconnected hosts should be skipped
+    FD_SET (table->hosts[i][0].stdio[HOST_STDIN], &wtSet);
+    Nmax = MAX (Nmax, table->hosts[i][0].stdio[HOST_STDIN]);
+    FD_SET (table->hosts[i][0].stdio[HOST_STDOUT], &rdSet);
+    Nmax = MAX (Nmax, table->hosts[i][0].stdio[HOST_STDOUT]);
+    FD_SET (table->hosts[i][0].stdio[HOST_STDERR], &rdSet);
+    Nmax = MAX (Nmax, table->hosts[i][0].stdio[HOST_STDERR]);
+  }
+  Nmax ++;
+  // need the list of connected hosts for exit test below
+  int Nrunning = 0;
+  for (i = 0; i < table->Nhosts; i++) {
+    if (!table->hosts[i][0].pid) continue; // any unconnected hosts should be skipped
+    Nrunning ++;
+  }
+  int Nfound = 0;
+  // this loop has 2 chunks: (a) check for I/O + (b) check for jobs done
+  while (1) {
+    // Wait up to 0.5 second for host to provide I/O
+    // timeout gets mucked: need to reset before each select
+    struct timeval timeout;
+    timeout.tv_sec = 10;
+    timeout.tv_usec = 500000;
+    int status = select (Nmax, NULL, &wtSet, NULL, &timeout);
+    if (status == -1) {
+      perror("select()");
+      exit (2);
+    }
+    // we have some sockets to check, check sockets for all hosts
+    for (i = 0; (status > 0) && (i < table->Nhosts); i++) {
+      if (!table->hosts[i][0].pid) continue; // any unconnected hosts should be skipped
+      if (FALSE && FD_ISSET (table->hosts[i][0].stdio[HOST_STDIN], &wtSet)) {
+        // this host is waiting for input : this is an error, so exit
+        fprintf (stderr, "host %s is waiting for input\n", table->hosts[i][0].hostname);
+        abort();
+      }
+      if ((table->hosts[i][0].stdio[HOST_STDOUT] > 0) && FD_ISSET (table->hosts[i][0].stdio[HOST_STDOUT], &rdSet)) {
+        // this host has waiting output : read to buffer, and dump if necessary
+        ReadtoIOBuffer (&table->hosts[i][0].stdout, table->hosts[i][0].stdio[HOST_STDOUT]);
+        // if (table->hosts[i][0].stdout.Nbuffer > 0x10000) {
+        if (table->hosts[i][0].stdout.Nbuffer > 0x1000) {
+          int printHead = VERBOSE || (table->hosts[i][0].stdout.Nbuffer > 0);
+          if (printHead) fprintf (stdout, "--- stdout from %s --- (%d bytes, v1)\n", table->hosts[i][0].hostname, table->hosts[i][0].stdout.Nbuffer);
+          int Nout = write (STDOUT_FILENO, table->hosts[i][0].stdout.buffer, table->hosts[i][0].stdout.Nbuffer);
+          if (Nout != table->hosts[i][0].stdout.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); }
+          FlushIOBuffer (&table->hosts[i][0].stdout);
+          if (printHead) fprintf (stdout, "\n");
+        }
+      }
+      if ((table->hosts[i][0].stdio[HOST_STDERR] > 0) && FD_ISSET (table->hosts[i][0].stdio[HOST_STDERR], &rdSet)) {
+        // this host has waiting output : read to buffer, and dump if necessary
+        ReadtoIOBuffer (&table->hosts[i][0].stderr, table->hosts[i][0].stdio[HOST_STDERR]);
+        // if (table->hosts[i][0].stderr.Nbuffer > 0x10000) {
+        if (table->hosts[i][0].stderr.Nbuffer > 0x1000) {
+          int printHead = VERBOSE || (table->hosts[i][0].stderr.Nbuffer > 0);
+          if (printHead) fprintf (stdout, "--- stderr from %s --- (%d bytes, v1)\n", table->hosts[i][0].hostname, table->hosts[i][0].stderr.Nbuffer);
+          int Nout = write (STDOUT_FILENO, table->hosts[i][0].stderr.buffer, table->hosts[i][0].stderr.Nbuffer);
+          if (Nout != table->hosts[i][0].stderr.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); }
+          FlushIOBuffer (&table->hosts[i][0].stderr);
+          if (printHead) fprintf (stdout, "\n");
+        }
+      }
+    }
+    // now check if any children have finished...
+    while (TRUE) {
+      int status = 0;
+      int pid = waitpid (-1, &status, WNOHANG);
+      if (!pid) {
+        // fprintf (stderr, "no hosts to harvest\n");
+        usleep (500000);
+        break; // no outstanding jobs have finished
+      }
+      if ((pid == -1) && (errno == ECHILD)) goto escape; // no more jobs on which to wait
+      if ((pid == -1) && (errno != ECHILD)) {
+        fprintf (stderr, "programming error (2)? %s %d", file, lineno);
+        exit (2);
+      }
+      // find the host which has finished
+      int found = FALSE;
+      for (i = 0; (i < table->Nhosts) && !found; i++) {
+        if (table->hosts[i][0].pid != pid) continue;
+        found = TRUE;
+        HostInfo *host = table->hosts[i];
+        // check on the status of this and report any output?
+        if (VERBOSE) fprintf (stdout, "job finished for %s (%d)\n", host->hostname, pid);
+        // read stdout
+        int printHead;
+        printHead = VERBOSE || (host->stdout.Nbuffer > 0);
+        EmptyIOBuffer (&host->stdout, 100, host->stdio[HOST_STDOUT]);
+        if (printHead) fprintf (stdout, "--- stdout from %s --- (%d bytes, v2)\n", host->hostname, host->stdout.Nbuffer);
+        int Nout = write (STDOUT_FILENO, host->stdout.buffer, host->stdout.Nbuffer);
+        if (Nout != host->stdout.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); }
+        FlushIOBuffer (&host->stdout);
+        if (printHead) fprintf (stdout, "\n");
+        // read stderr
+        printHead = VERBOSE || (host->stderr.Nbuffer > 0);
+        EmptyIOBuffer (&host->stderr, 100, host->stdio[HOST_STDERR]);
+        if (printHead) fprintf (stdout, "--- stderr from %s --- (%d bytes, v2)\n", host->hostname, host->stderr.Nbuffer);
+        Nout = write (STDOUT_FILENO, host->stderr.buffer, host->stderr.Nbuffer);
+        if (Nout != host->stderr.Nbuffer) { fprintf (stderr, "(error writing log?)\n"); }
+        FlushIOBuffer (&host->stderr);
+        if (printHead) fprintf (stdout, "\n");
+        if (WIFEXITED(status)) {
+          if (VERBOSE) fprintf (stdout, "normal completion, exit status is %d\n", WEXITSTATUS(status));
+          host->status = WEXITSTATUS(status);
+          if (host->status) {
+            fprintf (stdout, "job failed on %s\n", host->hostname);
+            globalStatus = FALSE;
+          }
+        } else {
+          host->status = -1;
+          fprintf (stdout, "job exited abnormally on %s\n", host->hostname);
+          globalStatus = FALSE;
+          continue;
+        }
+      }
+      if (!found) {
+        fprintf (stderr, "Programming error: failed to matched finished job to known host!\n");
+        exit (2);
+      }
+      Nfound ++;
+      if (Nfound == Nrunning) goto escape; // we've harvested all jobs
+    }
+  }
+escape:
+  // close all opened connections
+  for (i = 0; i < table->Nhosts; i++) {
+    if (!table->hosts[i][0].pid) continue; // any unconnected hosts should be skipped
+    close (table->hosts[i][0].stdio[HOST_STDIN]);
+    close (table->hosts[i][0].stdio[HOST_STDOUT]);
+    close (table->hosts[i][0].stdio[HOST_STDERR]);
+  }
+  return globalStatus;
+}
 int HostTableTestHost (SkyRegion *region, int hostID) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/ImageMetadata.c

-              r37035
+              r37822
   // assign the storage arrays
   for (i = 0; i < Nimage; i++) {
+    int Nmosaic = FindMosaicForImage (image, Nimage, i);
+    if (!Nmosaic) continue;
+    Nmosaic --;
+    if (!image[i].coords.mosaic) continue;
     imageID[i]  = image[i].imageID;
     externID[i] = image[i].externID;
+    crval1[i]   = image[Nmosaic].coords.crval1;
+    crval2[i]   = image[Nmosaic].coords.crval2;
+    theta[i]    = DEG_RAD*atan2(image[Nmosaic].coords.pc1_2, image[Nmosaic].coords.pc1_1);
+    Coords *mosaic = image[i].coords.mosaic;
+    crval1[i]   = mosaic->crval1;
+    crval2[i]   = mosaic->crval2;
+    theta[i]    = DEG_RAD*atan2(mosaic->pc1_2, mosaic->pc1_1);
     Mcal[i]     = image[i].Mcal;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/ImageMetadataSelection.c

-              r36490
+              r37822
   /* field defines a frame with 0,0 at the field center, and 1 arcsec / pixel */
   field.crpix1 = field.crpix2 = 0.0;
+  InitCoords (&field, "DEC--SIN");
   field.cdelt1 = field.cdelt2 = 1.0 / 3600;
-  field.pc1_1  = field.pc2_2  = 1.0;
-  field.pc1_2  = field.pc2_1  = 0.0;
-  field.Npolyterms = 0;
-  strcpy (field.ctype, "DEC--SIN");
   /* mosaic defines a frame with 0,0 at the mosaic center, and 1 arcsec / pixel */
   mosaic.crpix1 = mosaic.crpix2 = 0.0;
+  InitCoords (&mosaic, "DEC--SIN");
   mosaic.cdelt1 = mosaic.cdelt2 = 1.0 / 3600;
-  mosaic.pc1_1  = mosaic.pc2_2  = 1.0;
-  mosaic.pc1_2  = mosaic.pc2_1  = 0.0;
-  mosaic.Npolyterms = 0;
-  strcpy (mosaic.ctype, "DEC--SIN");
   if ((image = ImageMetadataLoad (filename, &Nimage)) == NULL) return (FALSE);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/ImageOps.c

-              r34088
+              r37822
     if (TimeSelect && ((image[i].tzero < tzero) || (image[i].tzero+image[i].trate*image[i].NY > tzero + trange))) continue;
     if (selection->useDisplay) {
-      if (!FindMosaicForImage (image, Nimage, i)) continue;
       // first check if region center is in image
       status = RD_to_XY (&X, &Y, Rmid, graph.coords.crval2, &image[i].coords);
 …
+    }
     if (selection->useSkyregion) {
-      if (!FindMosaicForImage (image, Nimage, i)) continue;
       /* project this image to screen display coords */
       x[0] = 0;           y[0] = 0;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/ImageSelection.c

-              r36490
+              r37822
   if (mosaicMode) {
+      /* mosaic defines a frame with 0,0 at the mosaic center, and 1 arcsec / pixel */
+      mosaic.crpix1 = mosaic.crpix2 = 0.0;
+      mosaic.cdelt1 = mosaic.cdelt2 = 1.0 / 3600;
+      mosaic.pc1_1  = mosaic.pc2_2  = 1.0;
+      mosaic.pc1_2  = mosaic.pc2_1  = 0.0;
+      mosaic.Npolyterms = 0;
+      strcpy (mosaic.ctype, "DEC--SIN");
+    /* mosaic defines a frame with 0,0 at the mosaic center, and 1 arcsec / pixel */
+    InitCoords (&mosaic, "DEC--SIN");
+    mosaic.cdelt1 = mosaic.cdelt2 = 1.0 / 3600;
+  }
 …
+  }
   if (m == -1) return (NULL);
-  if (!FindMosaicForImage (image, Nimage, m)) return (NULL);
   return (&image[m]);
+}
 …
+  }
   if (m == -1) return (NULL);
-  if (!FindMosaicForImage (image, Nimage, m)) return (NULL);
   return (&image[m]);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/LoadImages.c

-              r33649
+              r37822
 static Image *imageCache = NULL;
 static off_t cacheNimage = 0;
+AstromOffsetTable *table = NULL;
 static time_t getLastModified(char *filename);
 …
     lastModified = 0;
+  }
   gfits_db_init (&db);
 …
+  }
+  // assign image->parent and image->coords.mosaic
+  BuildChipMatch (image, *Nimage);
+  // MARKTIME("build chip match: %f sec\n", dtime);
+  char mapfile[DVO_MAX_PATH];
+  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", catdir);
+  if (table) AstromOffsetTableFree(table);
+  table = AstromOffsetMapLoad (mapfile, FALSE);
+  // assign images.coords.offsetMap -> table->map[i]
+  if (table) {
+    AstromOffsetTableMatchChips (image, *Nimage, table);
+  }
   return (image);
+}
 …
   if (!dvoUseImageCache && (images != NULL)) {
     free(images);
+    AstromOffsetTableFree (table);
   } else {
     // defer free until next LoadImages with a different or modified Images.dat

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/RegionHostTable.c

r36630	r37822
31	31	hosts[i].Nneighbors = 0;
32	32	hosts[i].isNeighbor = FALSE;
	33
	34	hosts[i].astromTable = NULL;
33	35	}
34	36	return;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/TessellationTable.c

-              r36490
+              r37822
     tess[i].dPix = NAN;
     tess[i].dX = 0;
     tess[i].dY = 0;
     tess[i].NX_SUB = 0;
     tess[i].NY_SUB = 0;
+    tess[i].dX = NAN;
+    tess[i].dY = NAN;
+    tess[i].NX_SUB = NAN;
+    tess[i].NY_SUB = NAN;
     tess[i].basename = NULL;
 …
   GET_COLUMN_NEW(Xo,     "X_CENT", double);
   GET_COLUMN_NEW(Yo,     "Y_CENT", double);
   GET_COLUMN_NEW(dX,     "X_GRID", int);
   GET_COLUMN_NEW(dY,     "Y_GRID", int);
+  GET_COLUMN_NEW(dX,     "X_GRID", float);
+  GET_COLUMN_NEW(dY,     "Y_GRID", float);
   GET_COLUMN_NEW(Rmin,   "R_MIN",  double);
   GET_COLUMN_NEW(Rmax,   "R_MAX",  double);
 …
   GET_COLUMN_NEW(Dmax,   "D_MAX",  double);
   GET_COLUMN_NEW(dPix,   "SCALE",  double);
   GET_COLUMN_NEW(NX_SUB, "NX_SUB", int);
   GET_COLUMN_NEW(NY_SUB, "NY_SUB", int);
+  GET_COLUMN_NEW(NX_SUB, "NX_SUB", float);
+  GET_COLUMN_NEW(NY_SUB, "NY_SUB", float);
   GET_COLUMN_NEW(TYPE,   "TYPE",   int);
 …
     gfits_modify (&header, "DEC_OFF", "%lf", 1, rings->DEC_offset);
     gfits_modify (&header, "NX_SUB", "%d", 1, rings->NX_SUB);
     gfits_modify (&header, "NY_SUB", "%d", 1, rings->NY_SUB);
+    gfits_modify (&header, "NX_SUB", "%f", 1, rings->NX_SUB);
+    gfits_modify (&header, "NY_SUB", "%f", 1, rings->NY_SUB);
     gfits_modify (&header, "PIXSCALE", "%lf", 1, rings->dPix);
+  }
 …
   gfits_define_bintable_column (&theader, "D", "X_CENT", "projection cell center pixel", "none", 1.0, 0.0);
   gfits_define_bintable_column (&theader, "D", "Y_CENT", "projection cell center pixel", "none", 1.0, 0.0);
   gfits_define_bintable_column (&theader, "J", "X_GRID", "skycell grid spacing", "none", 1.0, 0.0);
   gfits_define_bintable_column (&theader, "J", "Y_GRID", "skycell grid spacing", "none", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "X_GRID", "skycell grid spacing", "none", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "Y_GRID", "skycell grid spacing", "none", 1.0, 0.0);
   gfits_define_bintable_column (&theader, "D", "R_MIN",  "RA limit (lower)", "none", 1.0, 0.0);
   gfits_define_bintable_column (&theader, "D", "R_MAX",  "RA limit (upper)", "none", 1.0, 0.0);
 …
   gfits_define_bintable_column (&theader, "D", "D_MAX",  "DEC limit (upper)", "none", 1.0, 0.0);
   gfits_define_bintable_column (&theader, "D", "SCALE",  "pixel scale for projection cell", "none", 1.0, 0.0);
   gfits_define_bintable_column (&theader, "J", "NX_SUB", "skycell subdivision in x", "none", 1.0, 0.0);
   gfits_define_bintable_column (&theader, "J", "NY_SUB", "skycell subdivision in y", "none", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "NX_SUB", "skycell subdivision in x", "none", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E", "NY_SUB", "skycell subdivision in y", "none", 1.0, 0.0);
   gfits_define_bintable_column (&theader, "J", "TYPE",   "type of tessellation", "none", 1.0, 0.0);
 …
   double *Xo            ; ALLOCATE (Xo    ,    double, Nout);
   double *Yo            ; ALLOCATE (Yo    ,    double, Nout);
   int    *dX            ; ALLOCATE (dX    ,    int,    Nout);
   int    *dY            ; ALLOCATE (dY    ,    int,    Nout);
+  float  *dX            ; ALLOCATE (dX    ,    float,  Nout);
+  float  *dY            ; ALLOCATE (dY    ,    float,  Nout);
   double *Rmin          ; ALLOCATE (Rmin  ,    double, Nout);
   double *Rmax          ; ALLOCATE (Rmax  ,    double, Nout);
 …
   double *Dmax          ; ALLOCATE (Dmax  ,    double, Nout);
   double *dPix          ; ALLOCATE (dPix  ,    double, Nout);
   int    *NX_SUB        ; ALLOCATE (NX_SUB,    int,    Nout);
   int    *NY_SUB        ; ALLOCATE (NY_SUB,    int,    Nout);
+  float  *NX_SUB        ; ALLOCATE (NX_SUB,    float,  Nout);
+  float  *NY_SUB        ; ALLOCATE (NY_SUB,    float,  Nout);
   int    *TYPE          ; ALLOCATE (TYPE,      int,    Nout);
 …
     int xi = x / tess[myTess].tree->dX[zone][band];
     int yi = y / tess[myTess].tree->dY[zone][band];
+    xi = MAX(MIN(xi, tess[myTess].tree->NX_SUB - 1.0), 0);
+    yi = MAX(MIN(yi, tess[myTess].tree->NY_SUB - 1.0), 0);
     int N = xi + tess[myTess].tree->NX_SUB * yi;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/cmf-ps1-v5-lensing.c

-              r37035
+              r37822
 # include "dvo.h"
 # define ST_SIZE 312
+# define ST_SIZE 320
 // this function is based on the one generated by the autocode of cmf-ps1-v5.d
 …
     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
+    SWAP_BYTE (264); // SRC_CHIP_NUM
+    SWAP_BYTE (266); // SRC_CHIP_X
+    SWAP_BYTE (268); // SRC_CHIP_Y
+    SWAP_WORD (272); // MOMENTS_R1
+    SWAP_WORD (276); // MOMENTS_RH
+    SWAP_WORD (280); // KRON_FLUX
+    SWAP_WORD (284); // KRON_FLUX_ERR
+    SWAP_WORD (288); // KRON_FLUX_INNER
+    SWAP_WORD (292); // KRON_FLUX_OUTER
+    SWAP_WORD (296); // SKY_LIMIT_RAD
+    SWAP_WORD (300); // SKY_LIMIT_FLUX
+    SWAP_WORD (304); // SKY_LIMIT_SLOPE
+    SWAP_WORD (308); // FLAGS
+    SWAP_WORD (312); // FLAGS2
+    SWAP_BYTE (316); // N_FRAMES
+    SWAP_BYTE (318); // PADDING
+  }
 # endif
 …
   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, "I",    "SRC_CHIP_NUM",     "number of source chip for warp",  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "SRC_CHIP_X",       "x-coord in source chip",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "SRC_CHIP_Y",       "y-coord in source chip",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "PADDING3",         "padding for 8byte records",       "",                  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",    "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, "I",    "SRC_CHIP_NUM",     "number of source chip for warp",  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "SRC_CHIP_X",       "x-coord in source chip",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "SRC_CHIP_Y",       "y-coord in source chip",          "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "PADDING3",         "padding for 8byte records",       "",                  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);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/cmf-ps1-v5.c

-              r37035
+              r37822
 # include "dvo.h"
+# define ST_SIZE 232
 // this function is based on the one generated by the autocode of cmf-ps1-v5.d
 …
   unsigned char tmp;
   if (size != 232) {
     fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_V5: "OFF_T_FMT" vs %d\n",  size,  232);
+  if (size != ST_SIZE) {
+    fprintf (stderr, "WARNING: mismatch in data types CMF_PS1_V5: "OFF_T_FMT" vs %d\n",  size,  ST_SIZE);
     return (FALSE);
+  }
 …
 # ifdef BYTE_SWAP
   byte = (unsigned char *) data;
   for (i = 0; i < nitems; i++, byte += 232) {
+  for (i = 0; i < nitems; i++, byte += ST_SIZE) {
     /** BYTE SWAP **/
     SWAP_WORD (0); // IPP_IDET
 …
   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);
+  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;
+  }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/coord_systems.c

-              r31635
+              r37822
 # include "dvo.h"
-# include "libdvo_astro.h"
 CoordTransform *InitTransform (CoordTransformSystem input, CoordTransformSystem output) {
 …
           // \delta^p_J = +27d 07' 41.7087"
           // \theta_J   = 122.93192526 deg
           // these differ from the above at the several milliarcsec level
           // These values were used in the past, but transform to/from B1950.0
 …
           // transform->Xo  = 282.25*RAD_DEG;
           // transform->xo  =  33.00;
+          break;
+        case COORD_GALACTIC_REID_2004:
+          // J2000 FK5 transformation from Reid et al 2004, ApJ 616, 872
+          transform->phi = (27.128336111 - 90.0)*RAD_DEG; // +27d 07' 42.01" (J2000)
+          transform->Xo  = (192.859508333 + 90.0)*RAD_DEG; // 12h 51m 26.282s (J2000)
+          transform->xo  =  32.932;
+          // comments from LSD code (lsd/builtins/misc.py, Mario Juric)
+          // # Appendix of Reid et al. (http://adsabs.harvard.edu/cgi-bin/bib_query?2004ApJ...616..872R)
+          // # This convention is also used by LAMBDA/WMAP (http://lambda.gsfc.nasa.gov/toolbox/tb_coordconv.cfm)
+          // _angp = np.radians(192.859508333) #  12h 51m 26.282s (J2000)
+          // _dngp = np.radians(27.128336111)  # +27d 07' 42.01" (J2000)
+          // _l0   = np.radians(32.932)
           break;
 …
       switch (output) {
         case COORD_CELESTIAL:
           // J2000 transformation from Liu et al 2011 ()
+          // J2000 transformation from Liu et al 2011 (A&A 526, A16)
           transform->phi =  62.8717488056*RAD_DEG;
           transform->Xo  =  32.9319185700*RAD_DEG;
           transform->xo  = 282.8594812080;
+          // These values were used in the past, but transform to/from B1950.0
+          // transform->phi =  62.60*RAD_DEG;
+          // transform->Xo  =  33.00*RAD_DEG;
+          // transform->xo  = 282.25;
+          break;
+        case COORD_GALACTIC:
+          transform->phi = 0.0;
+          transform->Xo  = 0.0;
+          transform->xo  = 0.0;
+          transform->isIdentity = TRUE;
+          break;
+        case COORD_ECLIPTIC:
+          return NULL;
+        default:
+          abort();
+      }
+      break;
+    case COORD_GALACTIC_REID_2004:
+      switch (output) {
+        case COORD_CELESTIAL:
+          // J2000 FK5 transformation from Reid et al 2004, ApJ 616, 872
+          transform->phi = (90.0 - 27.128336111)*RAD_DEG; // +27d 07' 42.01" (J2000)
+          transform->Xo  =  32.932*RAD_DEG;
+          transform->xo  = (192.859508333 + 90.0); // 12h 51m 26.282s (J2000)
           // These values were used in the past, but transform to/from B1950.0
 …
   Y *= RAD_DEG;
+  double cosY = cos(Y);
+  double sinY = sin(Y);
+  double cosX = cos(X);
+  double sinX = sin(X);
   // recast with constants extracted:
   sin_y = cos(Y)*sin(X)*transform->sin_phi_cos_Xo - cos(Y)*cos(X)*transform->sin_phi_sin_Xo + sin(Y)*transform->cos_phi;
+  sin_y = cosY*sinX*transform->sin_phi_cos_Xo - cosY*cosX*transform->sin_phi_sin_Xo + sinY*transform->cos_phi;
   cos_y = sqrt (1 - sin_y*sin_y);
   sin_x = cos(Y)*sin(X)*transform->cos_phi_cos_Xo - cos(Y)*cos(X)*transform->cos_phi_sin_Xo - sin(Y)*transform->sin_phi;
   cos_x = cos(Y)*cos(X)*transform->cos_Xo + cos(Y)*sin(X)*transform->sin_Xo;
+  sin_x = cosY*sinX*transform->cos_phi_cos_Xo - cosY*cosX*transform->cos_phi_sin_Xo - sinY*transform->sin_phi;
+  cos_x = cosY*cosX*transform->cos_Xo + cosY*sinX*transform->sin_Xo;
   // atan2 returns -pi : +pi

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/coordops.c

-              r36490
+              r37822
 /* note that Coords.ctype carries the DEC (ctype2) value */
+static Coords mosaic;
+static int gotMosaic = FALSE;
+void RegisterMosaic (Coords *coords) {
+  mosaic = *coords;
+  gotMosaic = TRUE;
+}
+int isRegisteredMosaic () {
+  return (gotMosaic);
+}
+int GetMosaicCoords (Coords *coords) {
+  *coords = mosaic;
+  return (TRUE);
+}
+// default coordinates have unit scale and no rotation
+void InitCoords (Coords *coords, char *projection) {
+  coords->crval1 = 0.0;
+  coords->crval2 = 0.0;
+  coords->crpix1 = 0.0;
+  coords->crpix2 = 0.0;
+  coords->cdelt1 = 1.0;
+  coords->cdelt2 = 1.0;
+  coords->pc1_1 = 1.0; // EW is flipped relative to sky parity (dRA/dX > 0)
+  coords->pc2_2 = 1.0;
+  coords->pc2_1 = 0.0;
+  coords->pc1_2 = 0.0;
+  coords->Npolyterms = 1;
+  coords->mosaic = NULL;
+  coords->offsetMap = NULL;
+  memset (coords->polyterms, 0, 7*2*sizeof(float));
+  if (projection) {
+    strcpy (coords->ctype, projection);
+  } else {
+    strcpy (coords->ctype, "NONE");
+  }
+}
+// default coordinates have unit scale and no rotation
+void CopyCoords (Coords *tgt, Coords *src) {
+  tgt->crval1     = src->crval1;
+  tgt->crval2     = src->crval2;
+  tgt->crpix1     = src->crpix1;
+  tgt->crpix2     = src->crpix2;
+  tgt->cdelt1     = src->cdelt1;
+  tgt->cdelt2     = src->cdelt2;
+  tgt->pc1_1      = src->pc1_1;
+  tgt->pc2_2      = src->pc2_2;
+  tgt->pc2_1      = src->pc2_1;
+  tgt->pc1_2      = src->pc1_2;
+  tgt->Npolyterms = src->Npolyterms;
+  tgt->mosaic     = src->mosaic;      // pointer to another structure
+  tgt->offsetMap  = src->offsetMap;   // pointer to another structure
+  memcpy (tgt->polyterms, src->polyterms, 7*2*sizeof(float));
+  strcpy (tgt->ctype,     src->ctype);
+}
 int XY_to_LM (double *L, double *M, double x, double y, Coords *coords) {
 …
   proj = GetProjection (coords[0].ctype);
   mode = GetProjectionMode (proj);
+  // if we have an image map, it should be applied to the pixel coordinates
+  // before anything else is done.  It is easier to invert the map if it is
+  // of the form (dX,dY) = f(X,Y), then if (dL,dM) = f(X,Y).
+  if (coords[0].Npolyterms == -1) {
+    myAssert (coords[0].offsetMap, "offsetMap is requested by not defined");
+    float dX = AstromOffsetMapValue (coords->offsetMap, x, y, TRUE);
+    float dY = AstromOffsetMapValue (coords->offsetMap, x, y, FALSE);
+    if (isnan(dX)) dX = 0.0;
+    if (isnan(dY)) dY = 0.0;
+    x += dX;
+    y += dY;
+  }
   /** convert pixel coordinates to cartesian system **/
 …
     /* mosaic astrometry : WRP is chip astrometry; apply mosaic (DIS) term */
     if (proj == PROJ_WRP) {
+      if (!gotMosaic) return (FALSE);
+      XY_to_RD (ra, dec, L, M, &mosaic);
+      if (!coords->mosaic) {
+        myAbort ("missing mosaic element");
+        return (FALSE);
+      }
+      XY_to_RD (ra, dec, L, M, coords->mosaic);
+    }
     return (TRUE);
 …
     *dec = DEG_RAD*delta;
     *ra = ohana_normalize_angle (*ra);
+    // *ra = ohana_normalize_angle (*ra);
     return (TRUE);
 …
     *dec = delta + coords[0].crval2;
     *ra = ohana_normalize_angle (*ra);
+    // *ra = ohana_normalize_angle (*ra);
     return (TRUE);
 …
   if (mode == PROJ_MODE_CARTESIAN) {
     if (proj == PROJ_WRP) {
+      if (!gotMosaic) return (FALSE);
+      RD_to_XY (L, M, ra, dec, &mosaic);
+      if (!coords->mosaic) {
+        myAbort ("missing mosaic element");
+        return (FALSE);
+      }
+      RD_to_XY (L, M, ra, dec, coords->mosaic);
       return (TRUE);
+    }
 …
   *y = Yo / coords[0].cdelt2 + coords[0].crpix2;
+  // if we have an image map, it should be applied to the pixel coordinates
+  // after anything else is done.  It is easier to invert the map if it is
+  // of the form (dX,dY) = f(X,Y), then if (dL,dM) = f(X,Y).
+  if (coords[0].Npolyterms == -1) {
+    myAssert (coords[0].offsetMap, "offsetMap is requested by not defined");
+    double xraw = *x;
+    double yraw = *y;
+    double dXo = 0.0;
+    double dYo = 0.0;
+    int i;
+    for (i = 0; i < 4; i++) {
+      double dX = AstromOffsetMapValue (coords->offsetMap, xraw, yraw, TRUE);
+      double dY = AstromOffsetMapValue (coords->offsetMap, xraw, yraw, FALSE);
+      if (isnan(dX)) dX = 0.0;
+      if (isnan(dY)) dY = 0.0;
+      dX -= dXo;
+      dY -= dYo;
+      xraw -= dX;
+      yraw -= dY;
+      dXo += dX;
+      dYo += dY;
+    }
+    *x = xraw;
+    *y = yraw;
+    // I need to iterate since the position at which I have first made the correction is
+    // not the true position.  but if dX,dY is small and the gradient of dX,dY is also
+    // small, then even a single pass gets us close.
+    // XXX test this and use a while (hypot(dX,dY) > XXX) condition
+  }
   return (TRUE);
+}
 …
   rotate = 0.0;
+  coords[0].crval1 = coords[0].crpix1 = coords[0].cdelt1 = 0.0;
+  coords[0].crval2 = coords[0].crpix2 = coords[0].cdelt2 = 0.0;
+  coords[0].pc1_1 = coords[0].pc2_2 = 1.0;
+  coords[0].pc2_1 = coords[0].pc1_2 = 0.0;
+  coords[0].Npolyterms = 1;
+  strcpy (coords[0].ctype, "NONE");
+  InitCoords (coords, NULL);
   mode = COORD_TYPE_NONE;
 …
   if (status) {
+    if (!gfits_scan (header, "EQUINOX", "%lf", 1, &equinox)) {
+      if (!gfits_scan (header, "EPOCH", "%lf", 1, &equinox)) {
+        equinox = 2000.0;
+    char equinoxString[80];
+    int haveEquinox = gfits_scan (header, "EQUINOX", "%s", 1, equinoxString);
+    if (haveEquinox) {
+      // is the string a valid number (it is bad to interpret an error message as year 0.0)
+      char *endptr;
+      equinox = strtod (equinoxString, &endptr);
+      if (endptr == equinoxString) haveEquinox = FALSE;
+    }
+    if (!haveEquinox) {
+      haveEquinox = gfits_scan (header, "EPOCH", "%s", 1, equinoxString);
+      if (haveEquinox) {
+        // is the string a valid number (it is bad to interpret an error message as year 0.0)
+        char *endptr;
+        equinox = strtod (equinoxString, &endptr);
+        if (endptr == equinoxString) haveEquinox = FALSE;
+      }
+    }
+    if (!haveEquinox) {
+      equinox = 2000.0;
+    }
     if (fabs (equinox - 2000.0) > 0.1) {
 …
+    }
+  }
   if (!status) {
     // fprintf (stderr, "error getting all elements for coordinate mode %s\n", coords[0].ctype);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dbExtractAverages.c

-              r37035
+              r37822
 /* return average.field based on the selection */
 dbValue dbExtractAverages (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
+dbValue dbExtractAverages (Average *average, SecFilt *secfilt, Measure *measure, Lensobj *lensobj, StarPar *starpar, dbField *field) {
   // off_t i;
 …
       value.Flt = average[0].stargal;
       break;
     case AVE_REF_COLOR:
+    case AVE_REF_COLOR_BLUE:
       value.Flt = average[0].refColorBlue;
+      break;
+    case AVE_REF_COLOR_RED:
+      value.Flt = average[0].refColorRed;
       break;
 …
+      }
+      /* in some cases below we need a measurement which matches the requested photcode.
+         here is some sample code to find this.
+          for (i = 0; i < average[0].Nmeasure; i++) {
+            if (field->photcode->code != measure[i].photcode) continue;
+            value.Flt = measure[i].M;
+            break;
+          }
+      */
       switch (field->magOption) {
         case MAG_OPTION_MAG:
 …
               break;
             case MAG_LEVEL_REF:
               // why is measure needed here?
+              // which measure is needed here?
               // PhotRef  (field->photcode, average, secfilt, measure, field->magClass, field->magSource);
               break;
 …
               break;
             case MAG_LEVEL_REF:
+              // value.Flt = PhotFluxRef  (equiv, average, secfilt, measure, field->magClass, field->magSource);
+              // XXX which measure is needed here?
+              // value.Flt = PhotFluxRef  (field->photcode, average, secfilt, measure, field->magClass, field->magSource);
               break;
             case MAG_LEVEL_INST:
 …
             case MAG_LEVEL_AVE:
             case MAG_LEVEL_REF:
               // value.Flt = PhotFluxAveErr (equiv, average, secfilt, field->magClass, field->magSource);
+              value.Flt = PhotFluxAveErr (field->photcode, average, secfilt, field->magClass, field->magSource);
               break;
             case MAG_LEVEL_INST:
 …
         case MAG_OPTION_STDEV:
+          value.Flt = PhotMstdev (field->photcode, average, secfilt, field->magClass, field->magSource);
+          break;
         case MAG_OPTION_CHISQ:
+          value.Flt = PhotXm (field->photcode, average, secfilt);
+          break;
         case MAG_OPTION_MIN:
+          value.Flt = PhotMmin (field->photcode, average, secfilt);
+          break;
         case MAG_OPTION_MAX:
+          value.Flt = PhotMmax (field->photcode, average, secfilt);
+          break;
         case MAG_OPTION_NCODE: {
           int Nsec = GetPhotcodeNsec (field->photcode->code);
 …
+        }
         case MAG_OPTION_NPHOT: {
+          int Nsec = GetPhotcodeNsec (field->photcode->code);
+          if (Nsec == -1) break;
+          value.Int = secfilt[Nsec].Nused;
+          value.Int = PhotNphot (field->photcode, average, secfilt, field->magClass, field->magSource);
           break;
+        }
         case MAG_OPTION_UC_DIST:
+        case MAG_OPTION_STACK_DET_ID:
+          value.Int = PhotStackID (field->photcode, average, secfilt);
+          value.Flt = PhotUCdist (field->photcode, average, secfilt);
           break;
         case MAG_OPTION_FLAGS: {
 …
           break;
+        }
+          // g:X11_SM_OBJ, etc, are only valid for average
+        case MAG_OPTION_X11_SM_OBJ: { value.Flt = LensValue_X11_sm_obj (field->photcode, lensobj); break; }
+        case MAG_OPTION_X12_SM_OBJ: { value.Flt = LensValue_X12_sm_obj (field->photcode, lensobj); break; }
+        case MAG_OPTION_X22_SM_OBJ: { value.Flt = LensValue_X22_sm_obj (field->photcode, lensobj); break; }
+        case MAG_OPTION_E1_SM_OBJ:  { value.Flt = LensValue_E1_sm_obj  (field->photcode, lensobj); break; }
+        case MAG_OPTION_E2_SM_OBJ:  { value.Flt = LensValue_E2_sm_obj  (field->photcode, lensobj); break; }
+        case MAG_OPTION_X11_SH_OBJ: { value.Flt = LensValue_X11_sh_obj (field->photcode, lensobj); break; }
+        case MAG_OPTION_X12_SH_OBJ: { value.Flt = LensValue_X12_sh_obj (field->photcode, lensobj); break; }
+        case MAG_OPTION_X22_SH_OBJ: { value.Flt = LensValue_X22_sh_obj (field->photcode, lensobj); break; }
+        case MAG_OPTION_E1_SH_OBJ:  { value.Flt = LensValue_E1_sh_obj  (field->photcode, lensobj); break; }
+        case MAG_OPTION_E2_SH_OBJ:  { value.Flt = LensValue_E2_sh_obj  (field->photcode, lensobj); break; }
+        case MAG_OPTION_X11_SM_PSF: { value.Flt = LensValue_X11_sm_psf (field->photcode, lensobj); break; }
+        case MAG_OPTION_X12_SM_PSF: { value.Flt = LensValue_X12_sm_psf (field->photcode, lensobj); break; }
+        case MAG_OPTION_X22_SM_PSF: { value.Flt = LensValue_X22_sm_psf (field->photcode, lensobj); break; }
+        case MAG_OPTION_E1_SM_PSF:  { value.Flt = LensValue_E1_sm_psf  (field->photcode, lensobj); break; }
+        case MAG_OPTION_E2_SM_PSF:  { value.Flt = LensValue_E2_sm_psf  (field->photcode, lensobj); break; }
+        case MAG_OPTION_X11_SH_PSF: { value.Flt = LensValue_X11_sh_psf (field->photcode, lensobj); break; }
+        case MAG_OPTION_X12_SH_PSF: { value.Flt = LensValue_X12_sh_psf (field->photcode, lensobj); break; }
+        case MAG_OPTION_X22_SH_PSF: { value.Flt = LensValue_X22_sh_psf (field->photcode, lensobj); break; }
+        case MAG_OPTION_E1_SH_PSF:  { value.Flt = LensValue_E1_sh_psf  (field->photcode, lensobj); break; }
+        case MAG_OPTION_E2_SH_PSF:  { value.Flt = LensValue_E2_sh_psf  (field->photcode, lensobj); break; }
         case MAG_OPTION_NONE:
           break;
+      }
+      break;
+# if (0)
+      switch (field->magMode) {
+        case MAG_AVE:
+          value.Flt = PhotAve  (field->photcode, average, secfilt);
+          break;
+        case MAG_REF:
+          value.Flt = PhotRef  (field->photcode, average, secfilt, measure);
+          break;
+        case MAG_INST:
+        case MAG_CAT:
+        case MAG_SYS:
+        case MAG_REL:
+        case MAG_CAL:
+          // XXX need to code this correctly: this returns just the first matching value
+          value.Flt = NAN;
+          for (i = 0; i < average[0].Nmeasure; i++) {
+            if (field->photcode->code != measure[i].photcode) continue;
+            value.Flt = measure[i].M;
+            break;
+          }
+          break;
+        case MAG_CHISQ:
+          value.Flt = PhotXm (field->photcode, average, secfilt);
+          break;
+        case MAG_ERR:
+          if ((field->photcode->type == PHOT_REF) || (field->photcode->type == PHOT_DEP)) {
+            for (i = 0; i < average[0].Nmeasure; i++) {
+              if (field->photcode->code != measure[i].photcode) continue;
+              value.Flt = measure[i].dM;
+              break;
+            }
+          } else {
+            value.Flt = PhotAveErr (field->photcode, average, secfilt);
+          }
+          break;
+        case MAG_STDEV:
+          value.Flt = PhotMstdev (field->photcode, average, secfilt);
+          break;
+        case MAG_PHOT_FLAGS:
+          if ((field->photcode->type == PHOT_REF) || (field->photcode->type == PHOT_DEP)) {
+            for (i = 0; i < average[0].Nmeasure; i++) {
+              if (field->photcode->code != measure[i].photcode) continue;
+              value.Int = measure[i].photFlags;
+              break;
+            }
+          } else {
+            int Nsec = GetPhotcodeNsec (field->photcode->code);
+            if (Nsec == -1) break;
+            value.Int = secfilt[Nsec].flags;
+          }
+          break;
+        case MAG_NCODE:
+          // XXX push these into dvo_photcode_ops APIs
+          // XXX do I need to allow for conversion to equiv?
+          int Nsec = GetPhotcodeNsec (field->photcode->code);
+          if (Nsec == -1) break;
+          value.Int = secfilt[Nsec].Ncode;
+          break;
+        case MAG_NPHOT:
+          int Nsec = GetPhotcodeNsec (field->photcode->code);
+          if (Nsec == -1) break;
+          value.Int = secfilt[Nsec].Nused;
+          break;
+        case MAG_APER:
+        case MAG_APER_AVE:
+          value.Flt = PhotAperAve (field->photcode, average, secfilt);
+          break;
+        case MAG_APER_REF:
+          value.Flt = PhotAperRef (field->photcode, average, secfilt, measure);
+          break;
+        case MAG_KRON:
+        case MAG_KRON_AVE:
+          value.Flt = PhotKronAve (field->photcode, average, secfilt);
+          break;
+        case MAG_KRON_REF:
+          value.Flt = PhotKronRef (field->photcode, average, secfilt, measure);
+          break;
+        case MAG_KRON_ERR:
+          value.Flt = PhotKronAveErr (field->photcode, average, secfilt);
+          break;
+        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:
+          value.Flt = PhotUCdist (field->photcode, average, secfilt);
+          break;
+        case MAG_STACK_DET_ID:
+          value.Int = PhotStackID (field->photcode, 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);
+          break;
+      }
+      break;
+    case AVE_dMAG:
+      value.Flt = PhotAveErr (field->photcode, average, secfilt);
+      break;
+    case AVE_Xm:
+      value.Flt = PhotXm (field->photcode, average, secfilt);
+      break;
+# endif
+        default:
+          break;
+      }
+      break;
+    case AVE_E_BV:             { value.Flt = starpar->Ebv;      break; }
+    case AVE_E_BV_ERR:         { value.Flt = starpar->dEbv;     break; }
+    case AVE_DISTANCE_MOD:     { value.Flt = starpar->DistMag;  break; }
+    case AVE_DISTANCE_MOD_ERR: { value.Flt = starpar->dDistMag; break; }
+    case AVE_M_R:              { value.Flt = starpar->M_r;      break; }
+    case AVE_M_R_ERR:          { value.Flt = starpar->dM_r;     break; }
+    case AVE_FEH:              { value.Flt = starpar->FeH;      break; }
+    case AVE_FEH_ERR:          { value.Flt = starpar->dFeH;     break; }
+    case AVE_URA_GALMODEL:     { value.Flt = starpar->uRA;      break; }
+    case AVE_UDEC_GALMODEL:    { value.Flt = starpar->uDEC;     break; }
+    case AVE_RA_GALMODEL:      { value.Flt = starpar->R;        break; }
+    case AVE_DEC_GALMODEL:     { value.Flt = starpar->D;        break; }
     case AVE_TYPE:
       break;
     case AVE_TYPEFRAC:
       break;
+  }
   return (value);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dbExtractImages.c

-              r37035
+              r37822
   time_t t;
   dbValue value;
-  off_t Nmosaic;
   value.Flt = NAN;
 …
     case IMAGE_RA:
       if (!haveCelestial) {
-        if (!FindMosaicForImage (image, Nimage, N)) return value;
         if (!strcmp(&image[N].coords.ctype[4], "-DIS")) {
           x = 0.0;
 …
     case IMAGE_DEC:
       if (!haveCelestial) {
-        if (!FindMosaicForImage (image, Nimage, N)) return value;
         if (!strcmp(&image[N].coords.ctype[4], "-DIS")) {
           x = 0.0;
 …
       if (!haveGalactic) {
         if (!haveCelestial) {
-          if (!FindMosaicForImage (image, Nimage, N)) return value;
           if (!strcmp(&image[N].coords.ctype[4], "-DIS")) {
             x = 0.0;
 …
       if (!haveGalactic) {
         if (!haveCelestial) {
-          if (!FindMosaicForImage (image, Nimage, N)) return value;
           if (!strcmp(&image[N].coords.ctype[4], "-DIS")) {
             x = 0.0;
 …
       if (!haveEcliptic) {
         if (!haveCelestial) {
-          if (!FindMosaicForImage (image, Nimage, N)) return value;
           if (!strcmp(&image[N].coords.ctype[4], "-DIS")) {
             x = 0.0;
 …
       if (!haveEcliptic) {
         if (!haveCelestial) {
-          if (!FindMosaicForImage (image, Nimage, N)) return value;
           if (!strcmp(&image[N].coords.ctype[4], "-DIS")) {
             x = 0.0;
 …
     case IMAGE_FWHM_MEDIAN:
+      if (!(Nmosaic = FindMosaicForImage (image, Nimage, N))) return value;
+      Nmosaic --; // XXX kind of a hack: FindMosaicForImage returns 0 or the mosaic seq number + 1
+      value.Flt = (image[Nmosaic].fwhm_x + image[Nmosaic].fwhm_y) / 50.0;
+      if (!image[N].parent) return value;
+      value.Flt = (image[N].parent->fwhm_x + image[N].parent->fwhm_y) / 50.0;
       break;
     case IMAGE_FWHM_MAJ_MEDIAN:
+      if (!(Nmosaic = FindMosaicForImage (image, Nimage, N))) return value;
+      Nmosaic --; // XXX kind of a hack: FindMosaicForImage returns 0 or the mosaic seq number + 1
+      value.Flt = image[Nmosaic].fwhm_x / 25.0;
+      if (!image[N].parent) return value;
+      value.Flt = image[N].parent->fwhm_x / 25.0;
       break;
     case IMAGE_FWHM_MIN_MEDIAN:
+      if (!(Nmosaic = FindMosaicForImage (image, Nimage, N))) return value;
+      Nmosaic --; // XXX kind of a hack: FindMosaicForImage returns 0 or the mosaic seq number + 1
+      value.Flt = image[Nmosaic].fwhm_y / 25.0;
+      if (!image[N].parent) return value;
+      value.Flt = image[N].parent->fwhm_y / 25.0;
       break;
 …
       break;
     case IMAGE_REF_COLOR:
+    case IMAGE_REF_COLOR_BLUE:
       value.Flt = image[N].refColorBlue;
+      break;
+    case IMAGE_REF_COLOR_RED:
+      value.Flt = image[N].refColorRed;
       break;
+  }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dbExtractMeasures.c

-              r37035
+              r37822
 /* return measure.field based on the selection */
 dbValue dbExtractMeasures (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
+dbValue dbExtractMeasures (Average *average, SecFilt *secfilt, Measure *measure, Lensing *lensing, StarPar *starpar, dbField *field) {
   int Nsec;
 …
         case MAG_OPTION_NPHOT:
         case MAG_OPTION_UC_DIST:
-        case MAG_OPTION_STACK_DET_ID:
         case MAG_OPTION_FLAGS:
+        case MAG_OPTION_X11_SM_OBJ:
+        case MAG_OPTION_X12_SM_OBJ:
+        case MAG_OPTION_X22_SM_OBJ:
+        case MAG_OPTION_E1_SM_OBJ:
+        case MAG_OPTION_E2_SM_OBJ:
+        case MAG_OPTION_X11_SH_OBJ:
+        case MAG_OPTION_X12_SH_OBJ:
+        case MAG_OPTION_X22_SH_OBJ:
+        case MAG_OPTION_E1_SH_OBJ:
+        case MAG_OPTION_E2_SH_OBJ:
+        case MAG_OPTION_X11_SM_PSF:
+        case MAG_OPTION_X12_SM_PSF:
+        case MAG_OPTION_X22_SM_PSF:
+        case MAG_OPTION_E1_SM_PSF:
+        case MAG_OPTION_E2_SM_PSF:
+        case MAG_OPTION_X11_SH_PSF:
+        case MAG_OPTION_X12_SH_PSF:
+        case MAG_OPTION_X22_SH_PSF:
+        case MAG_OPTION_E1_SH_PSF:
+        case MAG_OPTION_E2_SH_PSF:
+        case MAG_OPTION_F_AP_R5:
+        case MAG_OPTION_F_ERR_AP_R5:
+        case MAG_OPTION_F_STDEV_AP_R5:
+        case MAG_OPTION_F_FILL_AP_R5:
+        case MAG_OPTION_F_AP_R6:
+        case MAG_OPTION_F_ERR_AP_R6:
+        case MAG_OPTION_F_STDEV_AP_R6:
+        case MAG_OPTION_F_FILL_AP_R6:
         case MAG_OPTION_NONE:
           break;
 …
       break;
     case MEAS_REF_COLOR:
+    case MEAS_REF_COLOR_BLUE:
       value.Flt = average[0].refColorBlue;
+      break;
+    case MEAS_REF_COLOR_RED:
+      value.Flt = average[0].refColorRed;
       break;
 …
 # endif
       break;
+    case MEAS_XFIX: /* OK */
+      value.Flt = measure[0].Xfix;
+      break;
+    case MEAS_YFIX: /* OK */
+      value.Flt = measure[0].Yfix;
+      break;
+    case MEAS_XCCD_ERR: /* OK */
+      value.Flt = FromShortPixels(measure[0].dXccd);
+      break;
+    case MEAS_YCCD_ERR: /* OK */
+      value.Flt = FromShortPixels(measure[0].dYccd);
+      break;
+    case MEAS_POS_SYS_ERR: /* OK */
+      value.Flt = FromShortPixels(measure[0].dRsys);
+      break;
+    case MEAS_XFIX: { value.Flt = measure[0].Xfix; break; }
+    case MEAS_YFIX: { value.Flt = measure[0].Yfix; break; }
+    case MEAS_XCCD_ERR: { value.Flt = FromShortPixels(measure[0].dXccd); break; }
+    case MEAS_YCCD_ERR: { value.Flt = FromShortPixels(measure[0].dYccd); break; }
+    case MEAS_POS_SYS_ERR: { value.Flt = FromShortPixels(measure[0].dRsys); }
+    case MEAS_XOFF_KH:  { value.Flt = measure[0].XoffKH;  break; }
+    case MEAS_YOFF_KH:  { value.Flt = measure[0].YoffKH;  break; }
+    case MEAS_XOFF_DCR: { value.Flt = measure[0].XoffDCR; break; }
+    case MEAS_YOFF_DCR: { value.Flt = measure[0].YoffDCR; break; }
+    case MEAS_ROFF_GAL: { value.Flt = measure[0].RoffGAL; break; }
+    case MEAS_DOFF_GAL: { value.Flt = measure[0].DoffGAL; break; }
     case MEAS_XFIELD: /* offset relative to exposure center in ra,dec space */
 …
     case MEAS_XMOSAIC: /* offset relative to exposure center in camera coords */
       if (!haveMosaicMeas) {
+        if (REMOTE_CLIENT) {
+          mosaic = MatchMosaicMetadata (measure[0].imageID);
+        } else {
+          // fprintf (stderr, "non-parallel Xmos broken\n");
+          // abort();
+          // mosaic = MatchMosaic (measure[0].t, measure[0].photcode);
+          mosaic = MatchMosaicMetadata (measure[0].imageID);
+        }
+        mosaic = MatchMosaicMetadata (measure[0].imageID);
         if (mosaic == NULL) break;
         double Rm = measure[0].R;
 …
     case MEAS_YMOSAIC: /* OK */
       if (!haveMosaicMeas) {
+        if (REMOTE_CLIENT) {
+          mosaic = MatchMosaicMetadata (measure[0].imageID);
+        } else {
+          // fprintf (stderr, "non-parallel Xmos broken\n");
+          // abort();
+          // mosaic = MatchMosaic (measure[0].t, measure[0].photcode);
+          mosaic = MatchMosaicMetadata (measure[0].imageID);
+        }
+        mosaic = MatchMosaicMetadata (measure[0].imageID);
         if (mosaic == NULL) break;
         double Rm = measure[0].R;
 …
     case MEAS_PSF_NPIX: /* OK */
       value.Int = measure[0].psfNpix;
-      break;
-    case MEAS_CR_NSIGMA: /* OK */
-      value.Flt = measure[0].crNsigma;
       break;
     case MEAS_EXT_NSIGMA: /* OK */
 …
       break;
+    case MEAS_MCAL_OFFSET: /* OK */
+      value.Flt = measure[0].Mcal;
+      break;
+    case MEAS_MCAL_OFFSET: { value.Flt = measure[0].Mcal; break; }
     case MEAS_FLAT: /* OK */
 …
+      }
       break;
+    case MEAS_E_BV:             { value.Flt = starpar->Ebv;      break; }
+    case MEAS_E_BV_ERR:         { value.Flt = starpar->dEbv;     break; }
+    case MEAS_DISTANCE_MOD:     { value.Flt = starpar->DistMag;  break; }
+    case MEAS_DISTANCE_MOD_ERR: { value.Flt = starpar->dDistMag; break; }
+    case MEAS_M_R:              { value.Flt = starpar->M_r;      break; }
+    case MEAS_M_R_ERR:          { value.Flt = starpar->dM_r;     break; }
+    case MEAS_FEH:              { value.Flt = starpar->FeH;      break; }
+    case MEAS_FEH_ERR:          { value.Flt = starpar->dFeH;     break; }
+    case MEAS_URA_GALMODEL:     { value.Flt = starpar->uRA;      break; }
+    case MEAS_UDEC_GALMODEL:    { value.Flt = starpar->uDEC;     break; }
+    case MEAS_RA_GALMODEL:      { value.Flt = starpar->R;        break; }
+    case MEAS_DEC_GALMODEL:     { value.Flt = starpar->D;        break; }
     // case MEAS_FLUX_PSF: /* OK */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dbFields.c

-              r37035
+              r37822
+}
+int dbFieldNeedMeasure (dbField *fields, int Nfields) {
+  int i;
+  for (i = 0; i < Nfields; i++) {
+    if (fields[i].photcode == NULL) continue; // non-measure fields do not have a photcode
+    if (fields[i].photcode[0].type == PHOT_REF) return TRUE;
+    if (fields[i].photcode[0].type == PHOT_DEP) return TRUE;
+  }
+  return FALSE;
+}
+int dbFieldNeedLensing (dbField *fields, int Nfields) {
+  int i;
+  for (i = 0; i < Nfields; i++) {
+    if (fields[i].ID == MEAS_X11_SM_OBJ) return TRUE;
+    if (fields[i].ID == MEAS_X12_SM_OBJ) return TRUE;
+    if (fields[i].ID == MEAS_X22_SM_OBJ) return TRUE;
+    if (fields[i].ID == MEAS_E1_SM_OBJ)  return TRUE;
+    if (fields[i].ID == MEAS_E2_SM_OBJ)  return TRUE;
+    if (fields[i].ID == MEAS_X11_SH_OBJ) return TRUE;
+    if (fields[i].ID == MEAS_X12_SH_OBJ) return TRUE;
+    if (fields[i].ID == MEAS_X22_SH_OBJ) return TRUE;
+    if (fields[i].ID == MEAS_E1_SH_OBJ)  return TRUE;
+    if (fields[i].ID == MEAS_E2_SH_OBJ)  return TRUE;
+    if (fields[i].ID == MEAS_X11_SM_PSF) return TRUE;
+    if (fields[i].ID == MEAS_X12_SM_PSF) return TRUE;
+    if (fields[i].ID == MEAS_X22_SM_PSF) return TRUE;
+    if (fields[i].ID == MEAS_E1_SM_PSF)  return TRUE;
+    if (fields[i].ID == MEAS_E2_SM_PSF)  return TRUE;
+    if (fields[i].ID == MEAS_X11_SH_PSF) return TRUE;
+    if (fields[i].ID == MEAS_X12_SH_PSF) return TRUE;
+    if (fields[i].ID == MEAS_X22_SH_PSF) return TRUE;
+    if (fields[i].ID == MEAS_E1_SH_PSF)  return TRUE;
+    if (fields[i].ID == MEAS_E2_SH_PSF)  return TRUE;
+  }
+  return FALSE;
+}
+int dbFieldNeedLensobj (dbField *fields, int Nfields) {
+  int i;
+  for (i = 0; i < Nfields; i++) {
+    if (fields[i].magOption == MAG_OPTION_NONE) continue; // non-measure fields do not have a photcode
+    if (fields[i].magOption == MAG_OPTION_X11_SM_OBJ) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X12_SM_OBJ) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X22_SM_OBJ) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_E1_SM_OBJ)  return TRUE;
+    if (fields[i].magOption == MAG_OPTION_E2_SM_OBJ)  return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X11_SH_OBJ) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X12_SH_OBJ) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X22_SH_OBJ) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_E1_SH_OBJ)  return TRUE;
+    if (fields[i].magOption == MAG_OPTION_E2_SH_OBJ)  return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X11_SM_PSF) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X12_SM_PSF) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X22_SM_PSF) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_E1_SM_PSF)  return TRUE;
+    if (fields[i].magOption == MAG_OPTION_E2_SM_PSF)  return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X11_SH_PSF) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X12_SH_PSF) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_X22_SH_PSF) return TRUE;
+    if (fields[i].magOption == MAG_OPTION_E1_SH_PSF)  return TRUE;
+    if (fields[i].magOption == MAG_OPTION_E2_SH_PSF)  return TRUE;
+  }
+  return FALSE;
+}
+int dbFieldNeedStarpar (dbField *fields, int Nfields, int isAverage) {
+  int i;
+  for (i = 0; i < Nfields; i++) {
+    if (isAverage) {
+      if (fields[i].ID == AVE_E_BV)             return TRUE;
+      if (fields[i].ID == AVE_E_BV_ERR)         return TRUE;
+      if (fields[i].ID == AVE_DISTANCE_MOD)     return TRUE;
+      if (fields[i].ID == AVE_DISTANCE_MOD_ERR) return TRUE;
+      if (fields[i].ID == AVE_M_R)              return TRUE;
+      if (fields[i].ID == AVE_M_R_ERR)          return TRUE;
+      if (fields[i].ID == AVE_FEH)              return TRUE;
+      if (fields[i].ID == AVE_FEH_ERR)          return TRUE;
+      if (fields[i].ID == AVE_URA_GALMODEL)     return TRUE;
+      if (fields[i].ID == AVE_UDEC_GALMODEL)    return TRUE;
+      if (fields[i].ID == AVE_RA_GALMODEL)      return TRUE;
+      if (fields[i].ID == AVE_DEC_GALMODEL)     return TRUE;
+    } else {
+      if (fields[i].ID == MEAS_E_BV)             return TRUE;
+      if (fields[i].ID == MEAS_E_BV_ERR)         return TRUE;
+      if (fields[i].ID == MEAS_DISTANCE_MOD)     return TRUE;
+      if (fields[i].ID == MEAS_DISTANCE_MOD_ERR) return TRUE;
+      if (fields[i].ID == MEAS_M_R)              return TRUE;
+      if (fields[i].ID == MEAS_M_R_ERR)          return TRUE;
+      if (fields[i].ID == MEAS_FEH)              return TRUE;
+      if (fields[i].ID == MEAS_FEH_ERR)          return TRUE;
+      if (fields[i].ID == MEAS_URA_GALMODEL)     return TRUE;
+      if (fields[i].ID == MEAS_UDEC_GALMODEL)    return TRUE;
+      if (fields[i].ID == MEAS_RA_GALMODEL)      return TRUE;
+      if (fields[i].ID == MEAS_DEC_GALMODEL)     return TRUE;
+    }
+  }
+  return FALSE;
+}
 dvoMagSourceType GetMagSource (char *string) {
   if (!strcasecmp (string, "chip")) return (MAG_SRC_CHP);
   if (!strcasecmp (string, "warp")) return (MAG_SRC_WRP);
+  if (!strcasecmp (string, "chip"))  return (MAG_SRC_CHP);
+  if (!strcasecmp (string, "warp"))  return (MAG_SRC_WRP);
   if (!strcasecmp (string, "stack")) return (MAG_SRC_STK);
 …
 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);
+  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, "flags"))         return MAG_OPTION_FLAGS;
+  if (!strcasecmp (string, "X11_SM_OBJ"))    return MAG_OPTION_X11_SM_OBJ;
+  if (!strcasecmp (string, "X12_SM_OBJ"))    return MAG_OPTION_X12_SM_OBJ;
+  if (!strcasecmp (string, "X22_SM_OBJ"))    return MAG_OPTION_X22_SM_OBJ;
+  if (!strcasecmp (string, "E1_SM_OBJ"))     return MAG_OPTION_E1_SM_OBJ;
+  if (!strcasecmp (string, "E2_SM_OBJ"))     return MAG_OPTION_E2_SM_OBJ;
+  if (!strcasecmp (string, "X11_SH_OBJ"))    return MAG_OPTION_X11_SH_OBJ;
+  if (!strcasecmp (string, "X12_SH_OBJ"))    return MAG_OPTION_X12_SH_OBJ;
+  if (!strcasecmp (string, "X22_SH_OBJ"))    return MAG_OPTION_X22_SH_OBJ;
+  if (!strcasecmp (string, "E1_SH_OBJ"))     return MAG_OPTION_E1_SH_OBJ;
+  if (!strcasecmp (string, "E2_SH_OBJ"))     return MAG_OPTION_E2_SH_OBJ;
+  if (!strcasecmp (string, "X11_SM_PSF"))    return MAG_OPTION_X11_SM_PSF;
+  if (!strcasecmp (string, "X12_SM_PSF"))    return MAG_OPTION_X12_SM_PSF;
+  if (!strcasecmp (string, "X22_SM_PSF"))    return MAG_OPTION_X22_SM_PSF;
+  if (!strcasecmp (string, "E1_SM_PSF"))     return MAG_OPTION_E1_SM_PSF;
+  if (!strcasecmp (string, "E2_SM_PSF"))     return MAG_OPTION_E2_SM_PSF;
+  if (!strcasecmp (string, "X11_SH_PSF"))    return MAG_OPTION_X11_SH_PSF;
+  if (!strcasecmp (string, "X12_SH_PSF"))    return MAG_OPTION_X12_SH_PSF;
+  if (!strcasecmp (string, "X22_SH_PSF"))    return MAG_OPTION_X22_SH_PSF;
+  if (!strcasecmp (string, "E1_SH_PSF"))     return MAG_OPTION_E1_SH_PSF;
+  if (!strcasecmp (string, "E2_SH_PSF"))     return MAG_OPTION_E2_SH_PSF;
+  // if (!strcasecmp (string, "F_AP_R5"))       return MAG_OPTION_F_AP_R5;
+  // if (!strcasecmp (string, "F_ERR_AP_R5"))   return MAG_OPTION_F_ERR_AP_R5;
+  // if (!strcasecmp (string, "F_STDEV_AP_R5")) return MAG_OPTION_F_STDEV_AP_R5;
+  // if (!strcasecmp (string, "F_FILL_AP_R5"))  return MAG_OPTION_F_FILL_AP_R5;
+  // if (!strcasecmp (string, "F_AP_R6"))       return MAG_OPTION_F_AP_R6;
+  // if (!strcasecmp (string, "F_ERR_AP_R6"))   return MAG_OPTION_F_ERR_AP_R6;
+  // if (!strcasecmp (string, "F_STDEV_AP_R6")) return MAG_OPTION_F_STDEV_AP_R6;
+  // if (!strcasecmp (string, "F_FILL_AP_R6"))  return MAG_OPTION_F_FILL_AP_R6;
   return MAG_OPTION_NONE;
+}
-# if (0)
-int GetMagMode (char *string) {
-  // these all imply PSF mags:
-  if (!strcasecmp (string, "inst"))        return (MAG_INST);
-  if (!strcasecmp (string, "cat"))         return (MAG_CAT);
-  if (!strcasecmp (string, "sys"))         return (MAG_SYS);
-  if (!strcasecmp (string, "rel"))         return (MAG_REL);
-  if (!strcasecmp (string, "cal"))         return (MAG_CAL);
-  if (!strcasecmp (string, "ave"))         return (MAG_AVE);
-  if (!strcasecmp (string, "ref"))         return (MAG_REF);
-  if (!strcasecmp (string, "err"))         return (MAG_ERR);
-  if (!strcasecmp (string, "aveerr"))      return (MAG_AVE_ERR);
-  // these are explicit PSF mags:
-  if (!strcasecmp (string, "psf_inst"))    return (MAG_INST);
-  if (!strcasecmp (string, "psf_cat"))     return (MAG_CAT);
-  if (!strcasecmp (string, "psf_sys"))     return (MAG_SYS);
-  if (!strcasecmp (string, "psf_rel"))     return (MAG_REL);
-  if (!strcasecmp (string, "psf_cal"))     return (MAG_CAL);
-  if (!strcasecmp (string, "psf_ave"))     return (MAG_AVE);
-  if (!strcasecmp (string, "psf_ref"))     return (MAG_REF);
-  if (!strcasecmp (string, "psf_err"))     return (MAG_ERR);
-  if (!strcasecmp (string, "psf_aveerr"))  return (MAG_AVE_ERR);
-  // these are aper mags:
-  if (!strcasecmp (string, "ap"))          return (MAG_APER);
-  if (!strcasecmp (string, "aper"))        return (MAG_APER);
-  if (!strcasecmp (string, "aperinst"))    return (MAG_APER_INST);
-  if (!strcasecmp (string, "aper_inst"))   return (MAG_APER_INST);
-  if (!strcasecmp (string, "aper_cat"))    return (MAG_APER_CAT);
-  if (!strcasecmp (string, "aper_sys"))    return (MAG_APER_SYS);
-  if (!strcasecmp (string, "aper_rel"))    return (MAG_APER_REL);
-  if (!strcasecmp (string, "aper_cal"))    return (MAG_APER_CAL);
-  if (!strcasecmp (string, "aper_ave"))    return (MAG_APER_AVE);
-  if (!strcasecmp (string, "aper_ref"))    return (MAG_APER_REF);
-  if (!strcasecmp (string, "aper_err"))    return (MAG_APER_ERR);
-  // these are kron mags:
-  if (!strcasecmp (string, "kron"))        return (MAG_KRON);
-  if (!strcasecmp (string, "kron_inst"))   return (MAG_KRON_INST);
-  if (!strcasecmp (string, "kron_cat"))    return (MAG_KRON_CAT);
-  if (!strcasecmp (string, "kron_sys"))    return (MAG_KRON_SYS);
-  if (!strcasecmp (string, "kron_rel"))    return (MAG_KRON_REL);
-  if (!strcasecmp (string, "kron_cal"))    return (MAG_KRON_CAL);
-  if (!strcasecmp (string, "kron_ave"))    return (MAG_KRON_AVE);
-  if (!strcasecmp (string, "kron_ref"))    return (MAG_KRON_REF);
-  if (!strcasecmp (string, "kron_err"))    return (MAG_KRON_ERR);
-  if (!strcasecmp (string, "kroninst"))    return (MAG_KRON_INST);
-  if (!strcasecmp (string, "kronerr"))     return (MAG_KRON_ERR);
-  // other fields:
-  if (!strcasecmp (string, "photflags"))   return (MAG_PHOT_FLAGS);
-  if (!strcasecmp (string, "flags"))       return (MAG_PHOT_FLAGS);
-  if (!strcasecmp (string, "chisq"))       return (MAG_CHISQ);
-  if (!strcasecmp (string, "ncode"))       return (MAG_NCODE);
-  if (!strcasecmp (string, "nphot"))       return (MAG_NPHOT);
-  if (!strcasecmp (string, "stdev"))       return (MAG_STDEV);
-  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);
-  if (!strcasecmp (string, "fluxpsf"))     return (MAG_FLUX_PSF);
-  if (!strcasecmp (string, "fluxpsferr"))  return (MAG_FLUX_PSF_ERR);
-  if (!strcasecmp (string, "fluxkron"))    return (MAG_FLUX_KRON);
-  if (!strcasecmp (string, "fluxkronerr")) return (MAG_FLUX_KRON_ERR);
-  return (MAG_NONE);
+}
-# endif
 // field may be of the form mag:psf:inst:wrp.  except for the first subword,
 …
     fprintf (stderr, "ERROR: unknown mag/photocode argument %s\n", word);
     free (word);
+    return FALSE;
+  }
 …
   switch (field->magOption) {
-    case MAG_OPTION_STACK_DET_ID:
     case MAG_OPTION_NCODE:
     case MAG_OPTION_NPHOT:
 …
   if (!strcasecmp (fieldName, "XFIX"))           ESCAPE (MEAS_XFIX,           OPIHI_FLT);
   if (!strcasecmp (fieldName, "YFIX"))           ESCAPE (MEAS_YFIX,           OPIHI_FLT);
+  if (!strcasecmp (fieldName, "XOFF_KH"))        ESCAPE (MEAS_XOFF_KH,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "YOFF_KH"))        ESCAPE (MEAS_YOFF_KH,        OPIHI_FLT);
+  if (!strcasecmp (fieldName, "XOFF_DCR"))       ESCAPE (MEAS_XOFF_DCR,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "YOFF_DCR"))       ESCAPE (MEAS_YOFF_DCR,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "ROFF_GAL"))       ESCAPE (MEAS_ROFF_GAL,       OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DOFF_GAL"))       ESCAPE (MEAS_DOFF_GAL,       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, "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);
+  // individual lensing measurements are not grouped by photcode:
+  if (!strcasecmp (fieldName, "X11_SM_OBJ"))     ESCAPE (MEAS_X11_SM_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X12_SM_OBJ"))     ESCAPE (MEAS_X12_SM_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X22_SM_OBJ"))     ESCAPE (MEAS_X22_SM_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E1_SM_OBJ"))      ESCAPE (MEAS_E1_SM_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E2_SM_OBJ"))      ESCAPE (MEAS_E2_SM_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X11_SH_OBJ"))     ESCAPE (MEAS_X11_SH_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X12_SH_OBJ"))     ESCAPE (MEAS_X12_SH_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X22_SH_OBJ"))     ESCAPE (MEAS_X22_SH_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E1_SH_OBJ"))      ESCAPE (MEAS_E1_SH_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E2_SH_OBJ"))      ESCAPE (MEAS_E2_SH_OBJ,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X11_SM_PSF"))     ESCAPE (MEAS_X11_SM_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X12_SM_PSF"))     ESCAPE (MEAS_X12_SM_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X22_SM_PSF"))     ESCAPE (MEAS_X22_SM_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E1_SM_PSF"))      ESCAPE (MEAS_E1_SM_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E2_SM_PSF"))      ESCAPE (MEAS_E2_SM_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X11_SH_PSF"))     ESCAPE (MEAS_X11_SH_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X12_SH_PSF"))     ESCAPE (MEAS_X12_SH_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "X22_SH_PSF"))     ESCAPE (MEAS_X22_SH_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E1_SH_PSF"))      ESCAPE (MEAS_E1_SH_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E2_SH_PSF"))      ESCAPE (MEAS_E2_SH_PSF,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E_BV"))             ESCAPE (MEAS_E_BV          ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E_BV_ERR"))         ESCAPE (MEAS_E_BV_ERR      ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DISTANCE_MOD"))     ESCAPE (MEAS_DISTANCE_MOD  ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DISTANCE_MOD_ERR")) ESCAPE (MEAS_DISTANCE_MOD_ERR, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "D_M"))              ESCAPE (MEAS_DISTANCE_MOD  ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "D_M_ERR"))          ESCAPE (MEAS_DISTANCE_MOD_ERR, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "M_R"))              ESCAPE (MEAS_M_R           ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "M_R_ERR"))          ESCAPE (MEAS_M_R_ERR       ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FEH"))              ESCAPE (MEAS_FEH           ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FEH_ERR"))          ESCAPE (MEAS_FEH_ERR       ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "URA_GALMODEL"))     ESCAPE (MEAS_URA_GALMODEL  ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "UDEC_GALMODEL"))    ESCAPE (MEAS_UDEC_GALMODEL ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "RA_GALMODEL"))      ESCAPE (MEAS_RA_GALMODEL   ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DEC_GALMODEL"))     ESCAPE (MEAS_DEC_GALMODEL  ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "URA_GAL"))          ESCAPE (MEAS_URA_GALMODEL  ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "UDEC_GAL"))         ESCAPE (MEAS_UDEC_GALMODEL ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "RA_GAL"))           ESCAPE (MEAS_RA_GALMODEL   ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DEC_GAL"))          ESCAPE (MEAS_DEC_GALMODEL  ,   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_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);
+  if (!strcasecmp (fieldName, "REF_COLOR_BLUE"))    ESCAPE (MEAS_REF_COLOR_BLUE, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "REF_COLOR_RED"))     ESCAPE (MEAS_REF_COLOR_RED,  OPIHI_FLT);
   // for words that don't parse, try a photcode
 …
   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);
+  if (!strcasecmp (fieldName, "REF_COLOR_BLUE")) ESCAPE (AVE_REF_COLOR_BLUE, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "REF_COLOR_RED"))  ESCAPE (AVE_REF_COLOR_RED,  OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E_BV"))             ESCAPE (AVE_E_BV          ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "E_BV_ERR"))         ESCAPE (AVE_E_BV_ERR      ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DISTANCE_MOD"))     ESCAPE (AVE_DISTANCE_MOD  ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DISTANCE_MOD_ERR")) ESCAPE (AVE_DISTANCE_MOD_ERR, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "M_R"))              ESCAPE (AVE_M_R           ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "M_R_ERR"))          ESCAPE (AVE_M_R_ERR       ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FEH"))              ESCAPE (AVE_FEH           ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "FEH_ERR"))          ESCAPE (AVE_FEH_ERR       ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "URA_GALMODEL"))     ESCAPE (AVE_URA_GALMODEL  ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "UDEC_GALMODEL"))    ESCAPE (AVE_UDEC_GALMODEL ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "RA_GALMODEL"))      ESCAPE (AVE_RA_GALMODEL   ,   OPIHI_FLT);
+  if (!strcasecmp (fieldName, "DEC_GALMODEL"))     ESCAPE (AVE_DEC_GALMODEL  ,   OPIHI_FLT);
   // check for code:mode in photcode name
 …
   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);
+  if (!strcasecmp (fieldName, "REF_COLOR_BLUE")) ESCAPE (IMAGE_REF_COLOR_BLUE, OPIHI_FLT);
+  if (!strcasecmp (fieldName, "REF_COLOR_RED"))  ESCAPE (IMAGE_REF_COLOR_RED,  OPIHI_FLT);
   // for words that don't parse, try a photcode

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_catalog.c

-              r37331
+              r37822
   if (!strcasecmp (catformat, "PS1_V5"))          return (DVO_FORMAT_PS1_V5);
   if (!strcasecmp (catformat, "PS1_REF"))         return (DVO_FORMAT_PS1_REF);
+  if (!strcasecmp (catformat, "PS1_SIM"))         return (DVO_FORMAT_PS1_SIM);
   return (DVO_FORMAT_UNDEF);
+}
 …
   average->Nlensing        = 0;
   average->Nlensobj        = 0;
+  average->Nstarpar        = 0;
   average->Nextend         = 0;
 …
   average->lensingOffset   = -1;
   average->lensobjOffset   = -1;
+  average->starparOffset   = -1;
   average->extendOffset    = -1;
-  average->paramsOffset    = -1;
   average->refColorBlue    = NAN;
   average->refColorRed     = NAN;
+  average->tessID          = 0;
+  average->skycellID       = 0;
+  average->projectionID    = 0;
+  average->dummy           = 0;
   average->flags           = 0;
 …
   secfilt->sMkron      = NAN;
+  secfilt->psfQfMax     = NAN;
+  secfilt->psfQfPerfMax = NAN;
   secfilt->Mstdev      = NAN;
   secfilt->Mmin        = NAN;
 …
   secfilt->dFapStk     = NAN;
+  secfilt->stackDetectID = 0;
+  secfilt->Nstack      = 0;
+  secfilt->NstackDet   = 0;
+  secfilt->stackPrmryOff = -1;
+  secfilt->stackBestOff  = -1;
   secfilt->MpsfWrp     = NAN;
 …
   secfilt->NusedKronWrp = 0;
   secfilt->NusedApWrp   = 0;
+  secfilt->Nwarp        = 0;
+  secfilt->NwarpGood    = 0;
   secfilt->ubercalDist = 1000;
 …
  measure->psfNdof   = 0;
  measure->psfNpix   = 0;
- measure->crNsigma  = NAN;
  measure->extNsigma = NAN;
 …
  measure->dbFlags   = 0;
  measure->photFlags = 0;
+ measure->photFlags2= 0;
+}
 …
 // init all data, or just catalog data
+void dvo_starpar_init (StarPar *starpar) {
+  starpar->R        = NAN;
+  starpar->D        = NAN;
+  starpar->galLat   = NAN;
+  starpar->galLon   = NAN;
+  starpar->Ebv      = NAN;
+  starpar->dEbv     = NAN;
+  starpar->DistMag  = NAN;
+  starpar->dDistMag = NAN;
+  starpar->M_r      = NAN;
+  starpar->dM_r     = NAN;
+  starpar->FeH      = NAN;
+  starpar->dFeH     = NAN;
+  starpar->uRA      = NAN;
+  starpar->uDEC     = NAN;
+  starpar->averef   = -1;
+  starpar->objID    = -1;
+  starpar->catID    = -1;
+}
+// init all data, or just catalog data
 void dvo_catalog_init (Catalog *catalog, int complete) {
 …
   catalog[0].lensobj = NULL;
+  catalog[0].starpar = NULL;
   catalog[0].averageT = NULL;
   catalog[0].measureT = NULL;
 …
   catalog[0].Nlensobj = 0;
+  catalog[0].Nstarpar = 0;
   catalog[0].Naves_disk = 0;
   catalog[0].Nmeas_disk = 0;
 …
   catalog[0].Nlensobj_disk = 0;
+  catalog[0].Nstarpar_disk = 0;
   catalog[0].Naves_off  = 0;
   catalog[0].Nmeas_off  = 0;
 …
   catalog[0].Nlensing_off  = 0;
   catalog[0].Nlensobj_off  = 0;
+  catalog[0].Nstarpar_off  = 0;
   /* pointers to SPLIT data files */
 …
   catalog[0].lensing_catalog = NULL;
   catalog[0].lensobj_catalog = NULL;
+  catalog[0].starpar_catalog = NULL;
   /* pointers for data manipulation */
 …
   if (catalog[0].f == (FILE *) NULL) return (2);
+  fflush (catalog[0].f);
+  if (fflush (catalog[0].f)) {
+    fprintf (stderr, "failed to flush file\n");
+    return FALSE;
+  }
   // fprintf (stderr, "unlocking: %s\n", catalog[0].filename);
 …
   // closes f but does not set back to NULL
+  fclearlockfile (catalog[0].filename, catalog[0].f, catalog[0].lockmode, &dbstate);
+  if (!fclearlockfile (catalog[0].filename, catalog[0].f, catalog[0].lockmode, &dbstate)) {
+    fprintf (stderr, "failed to unlock or close file\n");
+    return (0);
+  }
   if (catalog[0].catmode == DVO_MODE_SPLIT) {
+    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);
+    if (catalog[0].measure_catalog) { if (!dvo_catalog_unlock (catalog[0].measure_catalog)) { fprintf (stderr, "failed to unlock measures\n"); return (0); }}
+    if (catalog[0].missing_catalog) { if (!dvo_catalog_unlock (catalog[0].missing_catalog)) { fprintf (stderr, "failed to unlock missing\n"); return (0); }}
+    if (catalog[0].secfilt_catalog) { if (!dvo_catalog_unlock (catalog[0].secfilt_catalog)) { fprintf (stderr, "failed to unlock secfilt\n"); return (0); }}
+    if (catalog[0].lensing_catalog) { if (!dvo_catalog_unlock (catalog[0].lensing_catalog)) { fprintf (stderr, "failed to unlock lensing\n"); return (0); }}
+    if (catalog[0].lensobj_catalog) { if (!dvo_catalog_unlock (catalog[0].lensobj_catalog)) { fprintf (stderr, "failed to unlock lensobj\n"); return (0); }}
+    if (catalog[0].starpar_catalog) { if (!dvo_catalog_unlock (catalog[0].starpar_catalog)) { fprintf (stderr, "failed to unlock starpar\n"); return (0); }}
+  }
   return (1);
 …
+  }
+  // NOTE: this only check if we can write a backup; it does not actually write the backup
   if (!check_file_access (catalog[0].filename, BACKUP, READWRITE, VERBOSE)) {
     fprintf (stderr, "no permission to access %s\n", catalog[0].filename);
 …
       free (catalog[0].lensobj_catalog);
+    }
+    if (catalog[0].starpar_catalog) {
+      free (catalog[0].starpar_catalog[0].filename);
+      dvo_catalog_free (catalog[0].starpar_catalog);
+      free (catalog[0].starpar_catalog);
+    }
+  }
   dvo_catalog_free_data (catalog);
 …
     catalog[0].lensobj = NULL;
+  }
+  // if (catalog[0].X_t)      free (catalog[0].X_t);
+  // if (catalog[0].Y_t)      free (catalog[0].Y_t);
+  if (catalog[0].nOwn_t)      free (catalog[0].nOwn_t);
+  if (catalog[0].found_t)     free (catalog[0].found_t);
+  // if (catalog[0].image_t)  free (catalog[0].image_t);
+  // if (catalog[0].mosaic_t) free (catalog[0].mosaic_t);
+  if (catalog[0].foundWarp_t) free (catalog[0].foundWarp_t);
+  if (catalog[0].starpar) {
+    free (catalog[0].starpar);
+    catalog[0].Nstarpar = 0;
+    catalog[0].starpar = NULL;
+  }
+  if (catalog[0].nOwn_t)      { free (catalog[0].nOwn_t); catalog[0].nOwn_t = NULL; }
+  if (catalog[0].found_t)     { free (catalog[0].found_t); catalog[0].found_t = NULL; }
+  if (catalog[0].foundWarp_t) { free (catalog[0].foundWarp_t); catalog[0].foundWarp_t = NULL; }
+}
 …
+      }
+    }
+    if (catalog[0].starpar_catalog != NULL) {
+      if (catalog[0].Nstarpar_disk == 0) {
+        // need to relock (and re-open) file for close elsewhere
+        status = dvo_catalog_lock (catalog[0].starpar_catalog, lockmode);
+      } else {
+        if (!dvo_catalog_backup (catalog[0].starpar_catalog, FALSE)) {
+          return FALSE;
+        }
+      }
+    }
+  }
   return TRUE;
 …
+      }
+    }
+    if ((catalog[0].starpar_catalog != NULL) && (catalog[0].Nstarpar_disk > 0)) {
+      if (!dvo_catalog_unlink_backup (catalog[0].starpar_catalog, FALSE)) {
+        return FALSE;
+      }
+    }
+  }
   return TRUE;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_catalog_create.c

-              r37035
+              r37822
     free (file);
+    /* define starpar catalog file */
+    ALLOCATE (catalog[0].starpar_catalog, Catalog, 1);
+    dvo_catalog_init (catalog[0].starpar_catalog, TRUE);
+    /* create basic data for starpar catalog file */
+    gfits_create_header (&catalog[0].starpar_catalog[0].header);
+    ALLOCATE (catalog[0].starpar_catalog[0].filename, char, length);
+    sprintf (catalog[0].starpar_catalog[0].filename, "%s/%s.cpz", path, root);
+    file = filebasename (catalog[0].starpar_catalog[0].filename);
+    gfits_modify (&catalog[0].header, "STARPAR", "%s", 1, file);
+    free (file);
     free (path);
     free (root);
 …
+    }
     if (dvo_catalog_lock (catalog[0].lensobj_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
+      fprintf (stderr, "error with file lock\n");
+      exit (2);
+    }
+    if (dvo_catalog_lock (catalog[0].starpar_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
       fprintf (stderr, "error with file lock\n");
       exit (2);
 …
   ALLOCATE (catalog[0].lensing, Lensing, 1);
   ALLOCATE (catalog[0].lensobj, Lensobj, 1);
+  ALLOCATE (catalog[0].starpar, StarPar, 1);
   /* setup secondary filters to match photcodes:

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_catalog_mef.c

-              r37035
+              r37822
   off_t Nbytes;
-  off_t Naverage;
-  off_t Nmeasure;
-  off_t Nmissing;
-  off_t Nlensing;
-  off_t Nlensobj;
   off_t Nitems, Nexpect;
   int Nsecfilt;
 …
   ftable.header = &header;
-  /* get the components from the header */
-  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, "NLENSING", OFF_T_FMT, 1,  &Nlensing)) return (FALSE);
-  if (!gfits_scan (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  &Nlensobj)) return (FALSE);
   /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
 …
     catalog[0].catID = 0;
+  }
+  // NSTARS, average, Naves_disk
+# define GET_TABLE_SIZES(HFIELD, CFIELD, DFIELD, REQUIRED)              \
+  off_t N##CFIELD;                                                      \
+  if (REQUIRED) {                                                       \
+    if (!gfits_scan (&catalog[0].header, HFIELD, OFF_T_FMT, 1, &N##CFIELD)) return (FALSE); \
+  } else {                                                              \
+    if (!gfits_scan (&catalog[0].header, HFIELD, OFF_T_FMT, 1, &N##CFIELD)) N##CFIELD = 0; \
+  }                                                                     \
+  /* save the current number so we can do partial updates */            \
+  catalog[0].DFIELD = N##CFIELD;                                        \
+  /* default values, but we will assign these a valid value before we exit (even if empty) */ \
+  catalog[0].CFIELD = NULL;
   /* save the current number so we can do partial updates */
   catalog[0].Naves_disk = Naverage;
   catalog[0].Nmeas_disk = Nmeasure;
   catalog[0].Nmiss_disk = Nmissing;
   catalog[0].Nsecf_disk = Naverage * Nsecfilt;
   catalog[0].Nlensing_disk = Nlensing;
   catalog[0].Nlensobj_disk = Nlensobj;
+  /* get the components and sizes from the header */
+  GET_TABLE_SIZES ("NSTARS",   average, Naves_disk,    TRUE);
+  GET_TABLE_SIZES ("NMEAS",    measure, Nmeas_disk,    TRUE);
+  GET_TABLE_SIZES ("NMISS",    missing, Nmiss_disk,    FALSE);
+  GET_TABLE_SIZES ("NLENSING", lensing, Nlensing_disk, FALSE);
+  GET_TABLE_SIZES ("NLENSOBJ", lensobj, Nlensobj_disk, FALSE);
+  GET_TABLE_SIZES ("NSTARPAR", starpar, Nstarpar_disk, FALSE);
   /**  Nsecfilt is unusual: it does not list the number of data items in the table
        instead, the number of items is Nsecfilt * Naverage.  **/
+  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0;
   catalog[0].Nsecfilt = Nsecfilt;
+  /* default values, but we will assign these a valid value before we exit (even if empty) */
+  catalog[0].average = NULL;
+  catalog[0].measure = NULL;
+  catalog[0].missing = NULL;
+  catalog[0].Nsecf_disk = Naverage * Nsecfilt;
   catalog[0].secfilt = NULL;
-  catalog[0].lensing = NULL;
-  catalog[0].lensobj = NULL;
-  /* validate table mode ?*/
   /*** Average Table ***/
 …
+  }
+  /* read StarPar table header */
+  if (!gfits_fread_header (catalog[0].f, &header)) {
+    if (VERBOSE) fprintf (stderr, "can't read table starpar header");
+    return (FALSE);
+  }
+  /* read StarPar table data */
+  if (catalog[0].catflags & LOAD_STARPAR) {
+    if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) {
+      if (VERBOSE) fprintf (stderr, "can't read table starpar data");
+      return (FALSE);
+    }
+    catalog[0].starpar = FtableToStarPar (&ftable, &catalog[0].Nstarpar, &catalog[0].catformat);
+    if (Nstarpar != catalog[0].Nstarpar_disk) {
+      fprintf (stderr, "Warning: mismatch between Nstarpar in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nstarpar,  catalog[0].Nstarpar_disk);
+    }
+    catalog[0].Nstarpar = catalog[0].Nstarpar_disk;
+    catalog[0].Nstarpar_off = 0;
+  } else {
+    Nbytes = gfits_data_size (&header);
+    fseeko (catalog[0].f, Nbytes, SEEK_CUR);
+    ALLOCATE (catalog[0].starpar, StarPar, 1);
+    catalog[0].Nstarpar = 0;
+    catalog[0].Nstarpar_off = catalog[0].Nstarpar_disk;
+  }
   return (TRUE);
+}
 …
   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 (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  catalog[0].Nstarpar);
   gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
   gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
 …
   /* 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");
+    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);
+  /* free temp storage */
+  if (primary != NULL) {
+    free (primary);
+    free (secfilt);
+  }
+  return (TRUE);
+  /* write out StarPar table (convert to FITS table format) */
+  StarParToFtable (&ftable, catalog[0].starpar, catalog[0].Nstarpar, catalog[0].catformat);
   if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
     fprintf (stderr, "can't write table header");
 …
   lensobj header
   lensobj table
+  starpar header
+  starpar table
 */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_catalog_raw.c

-              r37035
+              r37822
       FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
+      FORMAT_CASE (PS1_SIM,   PS1_SIM);
     default:
 …
   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");
+  if (catalog[0].catformat == DVO_FORMAT_PS1_SIM)         gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_SIM");
   /* rewind file pointers and truncate file */
 …
       FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
+      FORMAT_CASE (PS1_SIM,   PS1_SIM);
     default:
 …
       FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
+      FORMAT_CASE (PS1_SIM,   PS1_SIM);
     default:
 …
       FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
+      FORMAT_CASE (PS1_SIM,   PS1_SIM);
     default:
 …
       FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
+      FORMAT_CASE (PS1_SIM,   PS1_SIM);
     default:
 …
       FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
+      FORMAT_CASE (PS1_SIM,   PS1_SIM);
     default:
 …
       FORMAT_CASE (PS1_V5,    PS1_V5);
       FORMAT_CASE (PS1_REF,   PS1_REF);
+      FORMAT_CASE (PS1_SIM,   PS1_SIM);
     default:

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_catalog_split.c

-              r37035
+              r37822
   Matrix matrix;
+  // ohana_memcheck_func (TRUE);
+  if (0) {
+    // XXX a TEST : is the data corrupted or the file?
+    char name[1024];
+    snprintf (name, 1024, "%s.phu.v2", catalog->filename);
+    FILE *f = fopen (name, "w");
+    fwrite (catalog->header.buffer, sizeof(char), catalog->header.datasize, f);
+    // fprintf (stderr, "save %d bytes in %s (%zx)\n", (int) catalog->header.datasize, name, (size_t) catalog->header.buffer);
+    // fprintf (stderr, "first bytes are %c%c%c%c%c%c%c%c\n",
+    //       catalog->header.buffer[0], catalog->header.buffer[1], catalog->header.buffer[2], catalog->header.buffer[3],
+    //       catalog->header.buffer[4], catalog->header.buffer[5], catalog->header.buffer[6], catalog->header.buffer[7]);
+    fclose (f);
+  }
+  if (0) {
+    // XXX a TEST : is the data corrupted or the file?
+    char name[1024];
+    snprintf (name, 1024, "%s.phu", catalog->filename);
+    FILE *f = fopen (name, "w");
+    fwrite (catalog->header.buffer, sizeof(char), catalog->header.datasize, f);
+    // fprintf (stderr, "save %d bytes in %s (%zx)\n", (int) catalog->header.datasize, name, (size_t) catalog->header.buffer);
+    // fprintf (stderr, "first bytes are %c%c%c%c%c%c%c%c\n",
+    //       catalog->header.buffer[0], catalog->header.buffer[1], catalog->header.buffer[2], catalog->header.buffer[3],
+    //       catalog->header.buffer[4], catalog->header.buffer[5], catalog->header.buffer[6], catalog->header.buffer[7]);
+    fclose (f);
+  }
+# if (0)
+  {
+    // XXX a TEST : is the data corrupted or the file?
+    char name[1024];
+    snprintf (name, 1024, "%s.phu.v2", catalog->filename);
+    FILE *f = fopen (name, "w");
+    fwrite (catalog->header.buffer, sizeof(char), catalog->header.datasize, f);
+    fprintf (stderr, "save %d bytes in %s (%zx)\n", (int) catalog->header.datasize, name, (size_t) catalog->header.buffer);
+    fprintf (stderr, "first bytes are %c%c%c%c%c%c%c%c\n",
+             catalog->header.buffer[0], catalog->header.buffer[1], catalog->header.buffer[2], catalog->header.buffer[3],
+             catalog->header.buffer[4], catalog->header.buffer[5], catalog->header.buffer[6], catalog->header.buffer[7]);
+    fclose (f);
+  }
+  {
+    // XXX a TEST : is the data corrupted or the file?
+    char name[1024];
+    snprintf (name, 1024, "%s.phu.v3", catalog->filename);
+    FILE *f = fopen (name, "w");
+    fwrite (catalog->header.buffer, sizeof(char), catalog->header.datasize, f);
+    fprintf (stderr, "save %d bytes in %s (%zx)\n", (int) catalog->header.datasize, name, (size_t) catalog->header.buffer);
+    fprintf (stderr, "first bytes are %c%c%c%c%c%c%c%c\n",
+             catalog->header.buffer[0], catalog->header.buffer[1], catalog->header.buffer[2], catalog->header.buffer[3],
+             catalog->header.buffer[4], catalog->header.buffer[5], catalog->header.buffer[6], catalog->header.buffer[7]);
+    fclose (f);
+  }
+# endif
   /* rewind file pointers and truncate (file is still open) */
+  fseeko (catalog->f, 0LL, SEEK_SET);
+  if (fseeko (catalog->f, 0LL, SEEK_SET)) {
+    perror ("dvo_catalog_save_subset: ");
+    fprintf (stderr, "failed to seek to beginning\n");
+  }
   // write PHU header
 …
   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.
+    // databases created prior to ~2014.07.01 did not have the LENSING, LENSOBJ, STARPAR 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);
+    if (!strcmp (name, "STARPAR")) return (DVO_CAT_OPEN_EMPTY);
     return (DVO_CAT_OPEN_FAIL);
+  }
 …
   off_t Nlensing;
   off_t Nlensobj;
+  off_t Nstarpar;
   off_t Nitems;
   int status, Nsecfilt;
 …
   /* get the components from the header - these duplicate information in the split files (NAXIS2) */
   // NSTARS, NMEAS, NMISS are required; NLENSING, NLENSOBJ are not (0 if not found)
+  // NSTARS, NMEAS, NMISS are required; NLENSING, NLENSOBJ, NSTARPAR 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, "NLENSING", OFF_T_FMT, 1,  &Nlensing)) Nlensing = 0;
   if (!gfits_scan (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  &Nlensobj)) Nlensobj = 0;
+  if (!gfits_scan (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  &Nstarpar)) Nstarpar = 0;
   /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
 …
   catalog[0].Nlensing_disk = Nlensing;
   catalog[0].Nlensobj_disk = Nlensobj;
+  catalog[0].Nstarpar_disk = Nstarpar;
   /**  Nsecfilt is unusual: it does not list the number of data items in the table
 …
   catalog[0].lensing = NULL;
   catalog[0].lensobj = NULL;
+  catalog[0].starpar = NULL;
   /*** Average Table ***/
 …
   /*** Secfilt Table ***/
   status = dvo_catalog_open_subcat (catalog, &catalog[0].secfilt_catalog, ftable.header, "SECFILT", VERBOSE);
+  // fprintf (stderr, "secfilt header %s : %zx\n", catalog[0].secfilt_catalog[0].filename, (size_t) catalog[0].secfilt_catalog[0].header.buffer);
   if (status == DVO_CAT_OPEN_FAIL) {
     return (FALSE);
 …
   gfits_free_header (&header);
+  /*** StarPar Table ***/
+  if (!(catalog[0].catflags & SKIP_STARPAR)) {
+    // unless we specify 'skip', we still need to load the
+    status = dvo_catalog_open_subcat (catalog, &catalog[0].starpar_catalog, ftable.header, "STARPAR", VERBOSE);
+    if (status == DVO_CAT_OPEN_FAIL) {
+      return (FALSE);
+    }
+    // the StarPar file need not exist, unless we expect data to exist
+    if ((status == DVO_CAT_OPEN_EMPTY) && (catalog[0].Nstarpar_disk > 0)) {
+      return (FALSE);
+    }
+  }
+  if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_STARPAR)) {
+    // only read the StarPar table if the file actually exists
+    /* read StarPar table data */
+    if (!gfits_fread_ftable_data (catalog[0].starpar_catalog[0].f, &ftable, FALSE)) {
+      if (VERBOSE) fprintf (stderr, "can't read table starpar data\n");
+      return (FALSE);
+    }
+    /* convert data format to internal : returns number of row read in Nstarpar */
+    catalog[0].starpar = FtableToStarPar (&ftable, &Nstarpar, &catalog[0].catformat);
+    if (Nstarpar != catalog[0].Nstarpar_disk) {
+      fprintf (stderr, "Warning: mismatch between Nstarpar in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nstarpar,  catalog[0].Nstarpar_disk);
+    }
+    catalog[0].Nstarpar = catalog[0].Nstarpar_disk;
+    catalog[0].Nstarpar_off = 0;
+  } else {
+    if (catalog[0].starpar_catalog) {
+      gfits_free_header (&catalog[0].starpar_catalog[0].header);
+    } else {
+      ALLOCATE (catalog[0].starpar_catalog, Catalog, 1);
+      dvo_catalog_init (catalog[0].starpar_catalog, TRUE);
+    }
+    gfits_create_header (&catalog[0].starpar_catalog[0].header);
+    ALLOCATE (catalog[0].starpar, StarPar, 1);
+    catalog[0].Nstarpar = 0;
+    catalog[0].Nstarpar_off = catalog[0].Nstarpar_disk;
+  }
+  gfits_free_header (&header);
   return (TRUE);
+}
 …
   off_t Nbytes;
   off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing, Nlensing, Nlensobj;
+  off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing, Nlensing, Nlensobj, Nstarpar;
   Header header;
   FTable ftable;
 …
+    }
     /* read Average table data : format is irrelevant here */
     if (!gfits_fread_ftable_range (catalog[0].f, &ftable, start, Nrows)) {
+    if (!gfits_fread_ftable_range (catalog[0].f, FALSE, &ftable, start, Nrows)) {
       if (VERBOSE) fprintf (stderr, "can't read table average data");
       return (FALSE);
 …
+    }
     /* read Secfilt table data : format is irrelevant here */
     if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start*catalog[0].Nsecfilt, catalog[0].Naverage*catalog[0].Nsecfilt)) {
+    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start*catalog[0].Nsecfilt, catalog[0].Naverage*catalog[0].Nsecfilt)) {
       if (VERBOSE) fprintf (stderr, "can't read table measure data");
       return (FALSE);
 …
+    }
     /* read Measure table data : format is irrelevant here */
     if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) {
+    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
       if (VERBOSE) fprintf (stderr, "can't read table measure data");
       return (FALSE);
 …
+    }
     /* read Missing table data : format is irrelevant here */
     if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) {
+    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
       if (VERBOSE) fprintf (stderr, "can't read table missing data");
       return (FALSE);
 …
+    }
     /* read Lensing table data : format is irrelevant here */
     if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) {
+    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
       if (VERBOSE) fprintf (stderr, "can't read table lensing data");
       return (FALSE);
 …
+    }
     /* read Lensobj table data : format is irrelevant here */
     if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) {
+    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
       if (VERBOSE) fprintf (stderr, "can't read table lensobj data");
       return (FALSE);
 …
+  }
+  // XXX check the open status of the catalog
+  if (catalog[0].catflags & LOAD_STARPAR) {
+    Catalog *subcat = catalog[0].starpar_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 StarPar table header */
+    if (!gfits_fread_header (subcat[0].f, &header)) {
+      if (VERBOSE) fprintf (stderr, "can't read table starpar header");
+      return (FALSE);
+    }
+    /* read StarPar table data : format is irrelevant here */
+    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
+      if (VERBOSE) fprintf (stderr, "can't read table starpar data");
+      return (FALSE);
+    }
+    /* convert data format to internal : returns number of row read in Nstarpar */
+    catalog[0].starpar = FtableToStarPar (&ftable, &Nstarpar, &catalog[0].catformat);
+    if (Nstarpar != Nrows) {
+      // XXX this condition denotes the eof has been reached; not an error or a warning
+      // fprintf (stderr, "Warning: mismatch between Nstarpar in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nstarpar,  Nrows);
+    }
+    gfits_free_header (&header);
+    catalog[0].Nstarpar = Nstarpar;
+    catalog[0].Nstarpar_off = start;
+  }
   return (TRUE);
+}
 …
   SecFilt *primary, *secfilt;
   int Nsecfilt;
   off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new;
+  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new;
   off_t first, start, Nrows;
 …
   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);
+  Nstarpar_disk_new = MAX (catalog[0].Nstarpar_disk, catalog[0].Nstarpar + catalog[0].Nstarpar_off);
   /* make sure header is consistent with data */
 …
   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 (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  Nstarpar_disk_new);
   gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
   gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
 …
+  }
   /*** Lensing Table ***/
   if ((catalog[0].catflags & LOAD_LENSING) && (catalog[0].lensing != NULL)) {
+  /*** Lensing Table (optional, do not save if not loaded) ***/
+  if ((catalog[0].catflags & LOAD_LENSING) && catalog[0].lensing_catalog->f && catalog[0].lensing) {
     first  = 0;                    // first row in memory to write
 …
+  }
   /*** Lensobj Table ***/
   if ((catalog[0].catflags & LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) {
+  /*** Lensobj Table (optional, do not save if not loaded) ***/
+  if ((catalog[0].catflags & LOAD_LENSOBJ) && catalog[0].lensobj_catalog->f && catalog[0].lensobj) {
     first  = 0;                    // first row in memory to write
 …
     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;
+    }
+    gfits_free_header (&header);
+    gfits_free_table (&ftable);
+  }
+  /*** StarPar Table (optional, do not save if not loaded) ***/
+    if ((catalog[0].catflags & LOAD_STARPAR) && catalog[0].starpar_catalog->f && catalog[0].starpar) {
+    first  = 0;                    // first row in memory to write
+    start  = catalog[0].Nstarpar_off; // first disk row to write
+    Nrows  = catalog[0].Nstarpar - first;
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first <= catalog[0].Nstarpar);
+    assert (catalog[0].Nstarpar_disk >= catalog[0].Nstarpar_off);
+    // convert to external table format (note that the block above does not damage or free catalog.average)
+    if (!StarParToFtable (&ftable, &catalog[0].starpar[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+    // write out StarPar table
+    if (!dvo_catalog_save_subcat (catalog[0].starpar_catalog, &ftable, start, Nrows, catalog[0].Nstarpar_disk, Nstarpar_disk_new)) {
+      fprintf (stderr, "trouble writing StarPar table\n");
       goto failure;
+    }
 …
   SecFilt *primary, *secfilt;
   int Nsecfilt;
   off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new;
+  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new;
   off_t first, start, Nrows;
 …
   if (catalog[0].Nlensobj_off > 0) {
     fprintf (stderr, "ERROR: only partial catalog (Lensobj) was loaded\n");
+    goto failure;
+  }
+  if (catalog[0].Nstarpar_off > 0) {
+    fprintf (stderr, "ERROR: only partial catalog (StarPar) was loaded\n");
     goto failure;
+  }
 …
   Nlensing_disk_new = catalog[0].Nlensing;
   Nlensobj_disk_new = catalog[0].Nlensobj;
+  Nstarpar_disk_new = catalog[0].Nstarpar;
   /* make sure header is consistent with data */
 …
   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 (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  Nstarpar_disk_new);
   gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
   gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
 …
     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;
+    }
+    gfits_free_header (&header);
+    gfits_free_table (&ftable);
+  }
+  /*** StarPar Table ***/
+  if ((catalog[0].catflags & LOAD_STARPAR) && (catalog[0].starpar != NULL)) {
+    first  = 0;                    // first row in memory to write
+    start  = catalog[0].Nstarpar_off; // first disk row to write
+    Nrows  = catalog[0].Nstarpar - first;
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first <= catalog[0].Nstarpar);
+    assert (catalog[0].Nstarpar_disk >= catalog[0].Nstarpar_off);
+    // convert to external table format
+    if (!StarParToFtable (&ftable, &catalog[0].starpar[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+    // write out StarPar table
+    if (!dvo_catalog_save_subcat (catalog[0].starpar_catalog, &ftable, start, Nrows, catalog[0].Nstarpar_disk, Nstarpar_disk_new)) {
+      fprintf (stderr, "trouble writing StarPar table\n");
       goto failure;
+    }
 …
   SecFilt *primary, *secfilt;
   int Nsecfilt;
   off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new;
+  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new;
   off_t first, start, Nrows;
 …
   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);
+  Nstarpar_disk_new = MAX (catalog[0].Nstarpar_disk, catalog[0].Nstarpar + catalog[0].Nstarpar_off);
   /* make sure header is consistent with data */
 …
   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 (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  Nstarpar_disk_new);
   gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
   gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
 …
     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;
+    }
+    gfits_free_header (&header);
+    gfits_free_table (&ftable);
+  }
+  /*** StarPar Table ***/
+  if (catalog[0].starpar != NULL) {
+    first  = catalog[0].Nstarpar_disk - catalog[0].Nstarpar_off;  // first row in memory to write
+    start  = catalog[0].Nstarpar_disk; // first disk row to write
+    Nrows  = catalog[0].Nstarpar - first;
+    assert (Nrows >= 0);
+    assert (first >= 0);
+    assert (first <= catalog[0].Nstarpar);
+    assert (catalog[0].Nstarpar_disk >= catalog[0].Nstarpar_off);
+    // convert to external table format
+    // XXX does catalog.starpar have averef correctly set up?
+    if (!StarParToFtable (&ftable, &catalog[0].starpar[first], Nrows, catalog[0].catformat)) {
+      fprintf (stderr, "trouble converting format\n");
+      goto failure;
+    }
+    // write out StarPar table
+    if (!dvo_catalog_save_subcat (catalog[0].starpar_catalog, &ftable, start, Nrows, catalog[0].Nstarpar_disk, Nstarpar_disk_new)) {
+      fprintf (stderr, "trouble writing StarPar table\n");
       goto failure;
+    }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert.c

-              r37035
+              r37822
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_V5",          PS1_V5);
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF",         PS1_REF);
+  CONVERT_FORMAT ("DVO_AVERAGE_PS1_SIM",         PS1_SIM);
 # undef CONVERT_FORMAT
 …
     free (tmpAverage);
     *format = DVO_FORMAT_PS1_V4;
+    return (average);
+  }
+  // block to convert old tables (PS1_V5 versions made during development)
+  if (!strcmp (extname, "DVO_AVERAGE_PS1_V5") && (ftable[0].header[0].Naxis[0] == 184)) {
+    Average_PS1_V5alt *tmpAverage;
+    tmpAverage = gfits_table_get_Average_PS1_V5alt (ftable, Naverage, NULL);
+    if (!tmpAverage) {
+      fprintf (stderr, "ERROR: failed to read averages\n");
+      exit (2);
+    }
+    average = Average_PS1_V5alt_ToInternal (tmpAverage, *Naverage);
+    free (tmpAverage);
+    *format = DVO_FORMAT_PS1_V5;
     return (average);
+  }
 …
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_V5",          PS1_V5,          PS1_V5);
   CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF",         PS1_REF,         PS1_REF);
+  CONVERT_FORMAT ("DVO_AVERAGE_PS1_SIM",         PS1_SIM,         PS1_SIM);
 # undef CONVERT_FORMAT
 …
       FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);
+      FORMAT_CASE (PS1_SIM,         PS1_SIM);
 # undef FORMAT_CASE
 …
   CONVERT_FORMAT ("DVO_MEASURE_PS1_V5",          PS1_V5,          PS1_V5,          TRUE);
   CONVERT_FORMAT ("DVO_MEASURE_PS1_REF",         PS1_REF,         PS1_REF,         FALSE);
+  CONVERT_FORMAT ("DVO_MEASURE_PS1_SIM",         PS1_SIM,         PS1_SIM,         TRUE);
 # undef CONVERT_FORMAT
 …
     case DVO_FORMAT_##FORMAT: { \
       Measure_##TYPE *tmpMeasure; \
       myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
+      myAssert (ABS_COORDS || average, "conversion from internal needs average table"); \
       tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
       gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure); \
 …
       FORMAT_CASE (PS1_V5,          PS1_V5,          TRUE);
       FORMAT_CASE (PS1_REF,         PS1_REF,         FALSE);
+      FORMAT_CASE (PS1_SIM,         PS1_SIM,         TRUE);
 # undef FORMAT_CASE
 …
     return (FALSE);
+  }
+  // block to convert old tables (PS1_V5 versions made during development)
+  if (!strcmp (extname, "DVO_SECFILT_PS1_V5") && (ftable[0].header[0].Naxis[0] == 160)) {
+    SecFilt_PS1_V5alt *tmpSecFilt;
+    tmpSecFilt = gfits_table_get_SecFilt_PS1_V5alt (ftable, Nsecfilt, NULL);
+    if (!tmpSecFilt) {
+      fprintf (stderr, "ERROR: failed to read secfilts\n");
+      exit (2);
+    }
+    secfilt = SecFilt_PS1_V5alt_ToInternal (tmpSecFilt, *Nsecfilt);
+    free (tmpSecFilt);
+    *format = DVO_FORMAT_PS1_V5;
+    return (secfilt);
+  }
 # define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
 …
   CONVERT_FORMAT ("DVO_SECFILT_PS1_V5",          PS1_V5,          PS1_V5);
   CONVERT_FORMAT ("DVO_SECFILT_PS1_REF",         PS1_REF,         PS1_REF);
+  CONVERT_FORMAT ("DVO_SECFILT_PS1_SIM",         PS1_SIM,         PS1_SIM);
 # undef CONVERT_FORMAT
 …
       FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);
+      FORMAT_CASE (PS1_SIM,         PS1_SIM);
 # undef FORMAT_CASE
 …
     return (FALSE);
+  }
+  if (!strcmp (extname, "DVO_LENSING_PS1_V5") && (ftable[0].header[0].Naxis[0] == 128)) {
+    Lensing_PS1_V5_ALT *tmpLensing;
+    tmpLensing = gfits_table_get_Lensing_PS1_V5_ALT (ftable, Nlensing, NULL);
+    if (!tmpLensing) {
+      fprintf (stderr, "ERROR: failed to read lensings\n");
+      exit (2);
+    }
+    lensing = Lensing_PS1_V5_ALT_ToInternal (tmpLensing, *Nlensing);
+    free (tmpLensing);
+    *format = DVO_FORMAT_PS1_V5;
+    return (lensing); }
 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
 …
     return (lensing); }
+# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
+  if (!strcmp (extname, NAME)) {                                        \
+    fprintf (stderr, "ERROR: format %s not defined for lensing, skipping\n", NAME); \
+    *Nlensing = 0; \
+    return NULL; \
+  }
   if (!strcmp (extname, "DVO_LENSING")) {
     lensing = gfits_table_get_Lensing (ftable, Nlensing, NULL);
 …
+  }
 // 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);
+  SKIPPING_FORMAT ("DVO_LENSING_PS1_REF",         PS1_REF,         PS1_REF);
+  SKIPPING_FORMAT ("DVO_LENSING_ELIXIR",          ELIXIR,          Elixir);
+  SKIPPING_FORMAT ("DVO_LENSING_LONEOS",          LONEOS,          Loneos);
+  SKIPPING_FORMAT ("DVO_LENSING_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
+  SKIPPING_FORMAT ("DVO_LENSING_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
+  SKIPPING_FORMAT ("DVO_LENSING_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
+  SKIPPING_FORMAT ("DVO_LENSING_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
+  SKIPPING_FORMAT ("DVO_LENSING_PS1_V1",          PS1_V1,          PS1_V1);
+  SKIPPING_FORMAT ("DVO_LENSING_PS1_V2",          PS1_V2,          PS1_V2);
+  SKIPPING_FORMAT ("DVO_LENSING_PS1_V3",          PS1_V3,          PS1_V3);
+  SKIPPING_FORMAT ("DVO_LENSING_PS1_V4",          PS1_V4,          PS1_V4);
+  CONVERT_FORMAT  ("DVO_LENSING_PS1_V5",          PS1_V5,          PS1_V5);
 # undef CONVERT_FORMAT
 …
     default:
       fprintf (stderr, "table format unknown (lensobj)\n");
+      return (FALSE);
+  }
+  return (TRUE);
+}
+/*** StarPar / FTable conversion functions ***/
+StarPar *FtableToStarPar (FTable *ftable, off_t *Nstarpar, char *format) {
+  StarPar *starpar;
+  char extname[80];
+  /* convert to the internal format */
+  if (!gfits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
+    fprintf (stderr, "EXTNAME missing for starpar table\n");
+    return (FALSE);
+  }
+# define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
+  if (!strcmp (extname, NAME)) {                                        \
+    StarPar_##TYPE *tmpStarPar;                                         \
+    tmpStarPar = gfits_table_get_StarPar_##TYPE (ftable, Nstarpar, NULL); \
+    if (!tmpStarPar) {                                                  \
+      fprintf (stderr, "ERROR: failed to read starpar\n");              \
+      exit (2);                                                         \
+    }                                                                   \
+    starpar = StarPar_##TYPE##_ToInternal (tmpStarPar, *Nstarpar); \
+    free (tmpStarPar);                                                  \
+    *format = DVO_FORMAT_##FORMAT;                                      \
+    return (starpar); }
+  if (!strcmp (extname, "DVO_STARPAR")) {
+    starpar = gfits_table_get_StarPar (ftable, Nstarpar, NULL);
+    if (!starpar) {
+      fprintf (stderr, "ERROR: failed to read starpar\n");
+      exit (2);
+    }
+    *format = DVO_FORMAT_INTERNAL;
+    return (starpar);
+  }
+   CONVERT_FORMAT ("DVO_STARPAR_PS1_SIM",         PS1_SIM,         PS1_SIM);
+// CONVERT_FORMAT ("DVO_STARPAR_PS1_REF",         PS1_REF,         PS1_REF);
+// CONVERT_FORMAT ("DVO_STARPAR_ELIXIR",          ELIXIR,          Elixir);
+// CONVERT_FORMAT ("DVO_STARPAR_LONEOS",          LONEOS,          Loneos);
+// CONVERT_FORMAT ("DVO_STARPAR_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
+// CONVERT_FORMAT ("DVO_STARPAR_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
+// CONVERT_FORMAT ("DVO_STARPAR_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
+// CONVERT_FORMAT ("DVO_STARPAR_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
+// CONVERT_FORMAT ("DVO_STARPAR_PS1_V1",          PS1_V1,          PS1_V1);
+// CONVERT_FORMAT ("DVO_STARPAR_PS1_V2",          PS1_V2,          PS1_V2);
+// CONVERT_FORMAT ("DVO_STARPAR_PS1_V3",          PS1_V3,          PS1_V3);
+// CONVERT_FORMAT ("DVO_STARPAR_PS1_V4",          PS1_V4,          PS1_V4);
+  CONVERT_FORMAT ("DVO_STARPAR_PS1_V5",          PS1_V5,          PS1_V5);
+//  CONVERT_FORMAT ("DVO_STELLAR_PARAMS_PS1_V5",          PS1_V5,          PS1_V5);
+  // XXX fix in libauto: STELLAR_PARAMS to STARPAR
+# undef CONVERT_FORMAT
+  fprintf (stderr, "table format unknown: %s\n", extname);
+  *Nstarpar = 0;
+  return (NULL);
+}
+// StarParToFtable needs the Average since old formats stored starpar.dR,dD only
+int StarParToFtable (FTable *ftable, StarPar *starpar, off_t Nstarpar, char format) {
+# define FORMAT_CASE(FORMAT, TYPE)              \
+    case DVO_FORMAT_##FORMAT: { \
+      StarPar_##TYPE *tmpStarPar; \
+      tmpStarPar = StarParInternalTo_##TYPE (starpar, Nstarpar); \
+      gfits_table_set_StarPar_##TYPE (ftable, tmpStarPar, Nstarpar); \
+      free (tmpStarPar); \
+      break; }
+  /* convert from the internal format */
+  switch (format) {
+    case DVO_FORMAT_INTERNAL: {
+      gfits_table_set_StarPar (ftable, starpar, Nstarpar);
+      break; }
+      FORMAT_CASE (PS1_SIM,         PS1_SIM);
+//    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 (starpar)\n");
       return (FALSE);
+  }
 …
     return (TRUE); }
-  if (!strcmp (extname, "DVO_IMAGE")) {
-    Image *image;
-    image = gfits_table_get_Image (ftable, &Nimage, NULL);
-    if (!image) {
-      fprintf (stderr, "ERROR: failed to read images\n");
-      exit (2);
+    }
-    *format = DVO_FORMAT_INTERNAL;
-    return (TRUE);
+  }
   CONVERT_FORMAT ("DVO_IMAGE_ELIXIR",          ELIXIR,          Elixir);
   CONVERT_FORMAT ("DVO_IMAGE_LONEOS",          LONEOS,          Loneos);
 …
   CONVERT_FORMAT ("DVO_IMAGE_PS1_V5",          PS1_V5,          PS1_V5);
   CONVERT_FORMAT ("DVO_IMAGE_PS1_REF",         PS1_REF,         PS1_REF);
+  CONVERT_FORMAT ("DVO_IMAGE_PS1_SIM",         PS1_SIM,         PS1_SIM);
 # undef CONVERT_FORMAT
 …
   /* convert from the internal format */
   switch (format) {
-    case DVO_FORMAT_INTERNAL: {
-      gfits_convert_Image ((Image *) ftable[0].buffer, sizeof(Image), Nimage);
-      break; }
       FORMAT_CASE (ELIXIR,          Elixir);
       FORMAT_CASE (LONEOS,          Loneos);
 …
       FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);
+      FORMAT_CASE (PS1_SIM,         PS1_SIM);
 # undef FORMAT_CASE
 …
   /* convert from the internal format */
   switch (format) {
-    case DVO_FORMAT_INTERNAL: {
-      for (i = 0; i < Nrow; i++) {
-        gfits_convert_Image ((Image *) vtable[0].buffer[i], sizeof(Image), 1);
+      }
-      return (TRUE); }
       FORMAT_CASE (ELIXIR,          Elixir);
       FORMAT_CASE (LONEOS,          Loneos);
 …
       FORMAT_CASE (PS1_V5,          PS1_V5);
       FORMAT_CASE (PS1_REF,         PS1_REF);
+      FORMAT_CASE (PS1_SIM,         PS1_SIM);
 # undef FORMAT_CASE

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c

-              r37035
+              r37822
     out[i].psfQF      = in[i].psfQF;
     out[i].psfChisq   = in[i].psfChisq;
-    out[i].crNsigma   = in[i].crNsigma;
     out[i].extNsigma  = in[i].extNsigma;
     out[i].FWx        = in[i].FWx;
 …
     out[i].psfQF      = in[i].psfQF;
     out[i].psfChisq   = in[i].psfChisq;
-    out[i].crNsigma   = in[i].crNsigma;
     out[i].extNsigma  = in[i].extNsigma;
     out[i].FWx        = in[i].FWx;
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c

-              r37035
+              r37822
     out[i].psfQF      = in[i].psfQF;
     out[i].psfChisq   = in[i].psfChisq;
-    out[i].crNsigma   = in[i].crNsigma;
     out[i].extNsigma  = in[i].extNsigma;
     out[i].FWx        = in[i].FWx;
 …
     out[i].psfQF      = in[i].psfQF;
     out[i].psfChisq   = in[i].psfChisq;
-    out[i].crNsigma   = in[i].crNsigma;
     out[i].extNsigma  = in[i].extNsigma;
     out[i].FWx        = in[i].FWx;
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_3.c

-              r37055
+              r37822
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c

-              r37035
+              r37822
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c

-              r37035
+              r37822
     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].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;
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c

-              r37035
+              r37822
     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].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;
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c

-              r37035
+              r37822
     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].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;
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c

-              r37035
+              r37822
     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].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].Mstdev        = in[i].Mstdev;
     out[i].ubercalDist   = in[i].ubercalDist;
+    out[i].stackDetectID = in[i].stackDetectID;
+    out[i].stackPrmryOff = in[i].stackPrmryOff;
+    out[i].stackBestOff  = in[i].stackBestOff;
+ }
   return (out);
 …
     out[i].Mstdev        = in[i].Mstdev;
     out[i].ubercalDist   = in[i].ubercalDist;
+    out[i].stackDetectID = in[i].stackDetectID;
+    out[i].stackPrmryOff = in[i].stackPrmryOff;
+    out[i].stackBestOff  = in[i].stackBestOff;
+  }
   return (out);
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only save because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic    = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only save because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
 …
     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;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_PS1_V5.c

-              r37331
+              r37822
     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].dbFlags    = in[i].dbFlags;
     out[i].photFlags  = in[i].photFlags;
+    out[i].photFlags2 = in[i].photFlags2;
+  }
   return (out);
 …
     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].dbFlags    = in[i].dbFlags;
     out[i].photFlags  = in[i].photFlags;
+    out[i].photFlags2 = in[i].photFlags2;
+  }
   return (out);
 …
     out[i].Nlensing      = in[i].Nlensing;
     out[i].Nlensobj      = in[i].Nlensobj;
+    out[i].Nstarpar      = in[i].Nstarpar;
     out[i].Nextend       = in[i].Nextend;
 …
     out[i].lensingOffset = in[i].lensingOffset;
     out[i].lensobjOffset = in[i].lensobjOffset;
+    out[i].starparOffset = in[i].starparOffset;
     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].tessID        = in[i].tessID;
+    out[i].skycellID     = in[i].skycellID;
+    out[i].projectionID  = in[i].projectionID;
     out[i].flags         = in[i].flags;
 …
   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].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].Nstarpar       = in[i].Nstarpar;
+    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].starparOffset  = in[i].starparOffset;
+    out[i].extendOffset   = in[i].extendOffset;
+    out[i].refColorBlue   = in[i].refColorBlue;
+    out[i].refColorRed    = in[i].refColorRed;
+    out[i].tessID         = in[i].tessID;
+    out[i].skycellID      = in[i].skycellID;
+    out[i].projectionID   = in[i].projectionID;
+    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;
+    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);
 …
   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].sMkron        = in[i].sMkron;
+    out[i].psfQfMax      = in[i].psfQfMax;
+    out[i].psfQfPerfMax  = in[i].psfQfPerfMax;
     out[i].Mstdev        = in[i].Mstdev;
     out[i].Mmin          = in[i].Mmin;
 …
     out[i].dFapStk       = in[i].dFapStk;
+    out[i].stackDetectID = in[i].stackDetectID;
+    out[i].Nstack        = in[i].Nstack;
+    out[i].NstackDet     = in[i].NstackDet;
+    out[i].stackPrmryOff = in[i].stackPrmryOff;
+    out[i].stackBestOff  = in[i].stackBestOff;
     out[i].MpsfWrp       = in[i].MpsfWrp;
 …
     out[i].NusedKronWrp  = in[i].NusedKronWrp;
     out[i].NusedApWrp    = in[i].NusedApWrp;
+    out[i].Nwarp         = in[i].Nwarp;
+    out[i].NwarpGood     = in[i].NwarpGood;
+    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].psfQfMax      = in[i].psfQfMax;
+    out[i].psfQfPerfMax  = in[i].psfQfPerfMax;
+    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].Nstack        = in[i].Nstack;
+    out[i].NstackDet     = in[i].NstackDet;
+    out[i].stackPrmryOff = in[i].stackPrmryOff;
+    out[i].stackBestOff  = in[i].stackBestOff;
+    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].Nwarp         = in[i].Nwarp;
+    out[i].NwarpGood     = in[i].NwarpGood;
     out[i].ubercalDist   = in[i].ubercalDist;
 …
+}
+StarPar *StarPar_PS1_V5_ToInternal (StarPar_PS1_V5 *in, off_t Nvalues) {
+  off_t i;
+  StarPar *out;
+  ALLOCATE_ZERO (out, StarPar, Nvalues);
+  for (i = 0; i < Nvalues; i++) {
+    dvo_starpar_init (&out[i]);
+    out[i].R         = in[i].R;
+    out[i].D         = in[i].D;
+    out[i].galLat    = in[i].galLat;
+    out[i].galLon    = in[i].galLon;
+    out[i].Ebv       = in[i].Ebv     ;
+    out[i].dEbv      = in[i].dEbv    ;
+    out[i].DistMag   = in[i].DistMag ;
+    out[i].dDistMag  = in[i].dDistMag;
+    out[i].M_r       = in[i].M_r     ;
+    out[i].dM_r      = in[i].dM_r    ;
+    out[i].FeH       = in[i].FeH     ;
+    out[i].dFeH      = in[i].dFeH    ;
+    out[i].uRA       = in[i].uRA     ;
+    out[i].uDEC      = in[i].uDEC    ;
+    out[i].averef  = in[i].averef;
+    out[i].objID   = in[i].objID ;
+    out[i].catID   = in[i].catID ;
+  }
+  return (out);
+}
+StarPar_PS1_V5 *StarParInternalTo_PS1_V5 (StarPar *in, off_t Nvalues) {
+  off_t i;
+  StarPar_PS1_V5 *out;
+  ALLOCATE_ZERO (out, StarPar_PS1_V5, Nvalues);
+  for (i = 0; i < Nvalues; i++) {
+    out[i].R         = in[i].R;
+    out[i].D         = in[i].D;
+    out[i].galLat    = in[i].galLat;
+    out[i].galLon    = in[i].galLon;
+    out[i].Ebv       = in[i].Ebv     ;
+    out[i].dEbv      = in[i].dEbv    ;
+    out[i].DistMag   = in[i].DistMag ;
+    out[i].dDistMag  = in[i].dDistMag;
+    out[i].M_r       = in[i].M_r     ;
+    out[i].dM_r      = in[i].dM_r    ;
+    out[i].FeH       = in[i].FeH     ;
+    out[i].dFeH      = in[i].dFeH    ;
+    out[i].uRA       = in[i].uRA     ;
+    out[i].uDEC      = in[i].uDEC    ;
+    out[i].averef  = in[i].averef;
+    out[i].objID   = in[i].objID ;
+    out[i].catID   = in[i].catID ;
+  }
+  return (out);
+}
 # define RAW_IMAGE_NAME_LEN 117
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN == DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only save because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN == DVO_IMAGE_NAME_LEN
 …
   return (out);
+}
+/*********************** old / alternate version **********************/
+// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
+Average *Average_PS1_V5alt_ToInternal (Average_PS1_V5alt *in, off_t Nvalues) {
+  off_t i;
+  Average *out;
+  ALLOCATE_ZERO (out, Average, Nvalues);
+  for (i = 0; i < Nvalues; i++) {
+    dvo_average_init (&out[i]);
+    out[i].R              = in[i].R;
+    out[i].D              = in[i].D;
+    out[i].dR             = in[i].dR;
+    out[i].dD             = in[i].dD;
+    out[i].uR             = in[i].uR;
+    out[i].uD             = in[i].uD;
+    out[i].duR            = in[i].duR;
+    out[i].duD            = in[i].duD;
+    out[i].P              = in[i].P;
+    out[i].dP             = in[i].dP;
+    out[i].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].starparOffset  = in[i].starparOffset;
+    out[i].extendOffset   = in[i].extendOffset;
+    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);
+}
+int gfits_convert_Average_PS1_V5alt (Average_PS1_V5alt *data, off_t size, off_t nitems) {
+  off_t i;
+  unsigned char *byte, tmp;
+  if (size != 184) {
+    fprintf (stderr, "WARNING: mismatch in data types Average_PS1_V5alt: "OFF_T_FMT" vs %d\n",  size,  184);
+    return (FALSE);
+  }
+  /* provide initial values to avoid compiler warnings for non-BYTE_SWAP arch */
+  i = tmp = 0;
+  byte = NULL;
+# ifdef BYTE_SWAP
+  byte = (unsigned char *) data;
+  for (i = 0; i < nitems; i++, byte += 184) {
+    /** BYTE SWAP **/
+    SWAP_DBLE (0); // RA
+    SWAP_DBLE (8); // DEC
+    SWAP_WORD (16); // RA_ERR
+    SWAP_WORD (20); // DEC_ERR
+    SWAP_WORD (24); // U_RA
+    SWAP_WORD (28); // U_DEC
+    SWAP_WORD (32); // V_RA_ERR
+    SWAP_WORD (36); // V_DEC_ERR
+    SWAP_WORD (40); // PAR
+    SWAP_WORD (44); // PAR_ERR
+    SWAP_DBLE (48); // RA_STK
+    SWAP_DBLE (56); // DEC_STK
+    SWAP_WORD (64); // RA_STK_ERR
+    SWAP_WORD (68); // DEC_STK_ERR
+    SWAP_WORD (72); // CHISQ_POS
+    SWAP_WORD (76); // CHISQ_PM
+    SWAP_WORD (80); // CHISQ_PAP
+    SWAP_WORD (84); // MEAN_EPOCH
+    SWAP_WORD (88); // TIME_RANGE
+    SWAP_WORD (92); // PSF_QF
+    SWAP_WORD (96); // PSF_QF_PERF
+    SWAP_WORD (100); // STARGAL_SEP
+    SWAP_BYTE (104); // NUMBER_POS
+    SWAP_BYTE (106); // NMEASURE
+    SWAP_BYTE (108); // NMISSING
+    SWAP_BYTE (110); // NLENSING
+    SWAP_BYTE (112); // NLENSOBJ
+    SWAP_BYTE (114); // NEXTEND
+    SWAP_WORD (116); // OFF_MEASURE
+    SWAP_WORD (120); // OFF_MISSING
+    SWAP_WORD (124); // OFF_LENSING
+    SWAP_WORD (128); // OFF_LENSOBJ
+    SWAP_WORD (132); // OFF_EXTEND
+    SWAP_WORD (136); // OFF_PARAMS
+    SWAP_WORD (140); // REF_COLOR_BLUE
+    SWAP_WORD (144); // REF_COLOR_RED
+    SWAP_WORD (148); // FLAGS
+    SWAP_WORD (152); // PHOTFLAGS_U
+    SWAP_WORD (156); // PHOTFLAGS_L
+    SWAP_WORD (160); // OBJ_ID
+    SWAP_WORD (164); // CAT_ID
+    SWAP_DBLE (168); // EXT_ID
+    SWAP_DBLE (176); // EXT_ID_GC
+  }
+# endif
+  return (TRUE);
+}
+/*** add test of EXTNAME and header-defined columns? ***/
+/* return internal structure representation */
+Average_PS1_V5alt *gfits_table_get_Average_PS1_V5alt (FTable *ftable, off_t *Ndata, char *swapped) {
+  int Ncols;
+  Average_PS1_V5alt *data;
+  Ncols = ftable[0].header[0].Naxis[0];
+  if (Ncols != 184) {
+    fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, 184);
+    return NULL;
+  }
+  *Ndata = ftable[0].header[0].Naxis[1];
+  data = (Average_PS1_V5alt *) ftable[0].buffer;
+  if ((swapped == NULL) || (*swapped == FALSE)) {
+    if (!gfits_convert_Average_PS1_V5alt (data, sizeof (Average_PS1_V5alt), *Ndata)) {
+      return NULL;
+    }
+    gfits_table_scale_data (ftable);
+    if (swapped != NULL) *swapped = TRUE;
+  }
+  return (data);
+}
+/****** alt secfilt **********/
+SecFilt *SecFilt_PS1_V5alt_ToInternal (SecFilt_PS1_V5alt *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].stackPrmryOff = in[i].stackPrmryOff;
+    out[i].stackBestOff  = in[i].stackBestOff;
+    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);
+}
+int gfits_convert_SecFilt_PS1_V5alt (SecFilt_PS1_V5alt *data, off_t size, off_t nitems) {
+  off_t i;
+  unsigned char *byte, tmp;
+  if (size != 160) {
+    fprintf (stderr, "WARNING: mismatch in data types SecFilt_PS1_V5alt: "OFF_T_FMT" vs %d\n",  size,  160);
+    return (FALSE);
+  }
+  /* provide initial values to avoid compiler warnings for non-BYTE_SWAP arch */
+  i = tmp = 0;
+  byte = NULL;
+# ifdef BYTE_SWAP
+  byte = (unsigned char *) data;
+  for (i = 0; i < nitems; i++, byte += 160) {
+    /** BYTE SWAP **/
+    SWAP_WORD (0); // MAG
+    SWAP_WORD (4); // MAG_ERR
+    SWAP_WORD (8); // MAG_AP
+    SWAP_WORD (12); // MAG_AP_ERR
+    SWAP_WORD (16); // MAG_AP_STDEV
+    SWAP_WORD (20); // MAG_KRON
+    SWAP_WORD (24); // MAG_KRON_ERR
+    SWAP_WORD (28); // MAG_KRON_STDEV
+    SWAP_WORD (32); // MAG_STDEV
+    SWAP_WORD (36); // MAG_MIN
+    SWAP_WORD (40); // MAG_MAX
+    SWAP_WORD (44); // MAG_CHI
+    SWAP_BYTE (48); // NCODE
+    SWAP_BYTE (50); // NUSED
+    SWAP_BYTE (52); // NUSED_KRON
+    SWAP_BYTE (54); // NUSED_AP
+    SWAP_WORD (56); // FLAGS
+    SWAP_WORD (60); // MAG_PSF_STK
+    SWAP_WORD (64); // FLUX_PSF_STK
+    SWAP_WORD (68); // FLUX_PSF_STK_ERR
+    SWAP_WORD (72); // MAG_KRON_STK
+    SWAP_WORD (76); // FLUX_KRON_STK
+    SWAP_WORD (80); // FLUX_KRON_STK_ERR
+    SWAP_WORD (84); // MAG_AP_STK
+    SWAP_WORD (88); // FLUX_AP_STK
+    SWAP_WORD (92); // FLUX_AP_STK_ERR
+    SWAP_WORD (96); // STACK_PRIMARY_OFF
+    SWAP_WORD (100); // STACK_BEST_OFF
+    SWAP_WORD (104); // MAG_PSF_WRP
+    SWAP_WORD (108); // FLUX_PSF_WRP
+    SWAP_WORD (112); // FLUX_PSF_WRP_ERR
+    SWAP_WORD (116); // FLUX_PSF_WRP_STD
+    SWAP_WORD (120); // MAG_KRON_WRP
+    SWAP_WORD (124); // FLUX_KRON_WRP
+    SWAP_WORD (128); // FLUX_KRON_WRP_ERR
+    SWAP_WORD (132); // FLUX_KRON_WRP_STD
+    SWAP_WORD (136); // MAG_AP_WRP
+    SWAP_WORD (140); // FLUX_AP_WRP
+    SWAP_WORD (144); // FLUX_AP_WRP_ERR
+    SWAP_WORD (148); // FLUX_AP_WRP_STD
+    SWAP_BYTE (152); // NUSED_WRP
+    SWAP_BYTE (154); // NUSED_KRON_WRP
+    SWAP_BYTE (156); // NUSED_AP_WRP
+    SWAP_BYTE (158); // UBERCAL_DIST
+  }
+# endif
+  return (TRUE);
+}
+/*** add test of EXTNAME and header-defined columns? ***/
+/* return internal structure representation */
+SecFilt_PS1_V5alt *gfits_table_get_SecFilt_PS1_V5alt (FTable *ftable, off_t *Ndata, char *swapped) {
+  int Ncols;
+  SecFilt_PS1_V5alt *data;
+  Ncols = ftable[0].header[0].Naxis[0];
+  if (Ncols != 160) {
+    fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, 160);
+    return NULL;
+  }
+  *Ndata = ftable[0].header[0].Naxis[1];
+  data = (SecFilt_PS1_V5alt *) ftable[0].buffer;
+  if ((swapped == NULL) || (*swapped == FALSE)) {
+    if (!gfits_convert_SecFilt_PS1_V5alt (data, sizeof (SecFilt_PS1_V5alt), *Ndata)) {
+      return NULL;
+    }
+    gfits_table_scale_data (ftable);
+    if (swapped != NULL) *swapped = TRUE;
+  }
+  return (data);
+}
+Lensing *Lensing_PS1_V5_ALT_ToInternal (Lensing_PS1_V5_ALT *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);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_elixir.c

-              r37035
+              r37822
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_loneos.c

-              r37035
+              r37822
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c

-              r37035
+              r37822
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c

-              r37035
+              r37822
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
+    out[i].coords.mosaic   = NULL;
+    out[i].coords.offsetMap = NULL;
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
 …
   for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    // this is only safe because the initial 120 bytes in Coords match CoordsDisk
+    memcpy (&out[i].coords, &in[i].coords, sizeof(CoordsDisk));
     // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_image.c

-              r37035
+              r37822
   gfits_create_matrix (&db[0].header, &db[0].matrix);
   gfits_table_set_Image (&db[0].ftable, NULL, 0);
+  gfits_table_set_Image (&db[0].ftable);
   gfits_modify (&db[0].header, "NIMAGES", "%d", 1, 0);
 …
   dvo_image_createID (&db[0].header);
   if (db[0].format == DVO_FORMAT_INTERNAL)        gfits_modify (&db[0].header, "FORMAT", "%s", 1, "INTERNAL");
+  // if (db[0].format == DVO_FORMAT_INTERNAL)     gfits_modify (&db[0].header, "FORMAT", "%s", 1, "INTERNAL");
   if (db[0].format == DVO_FORMAT_LONEOS)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "LONEOS");
   if (db[0].format == DVO_FORMAT_ELIXIR)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "ELIXIR");
 …
   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");
+  if (db[0].format == DVO_FORMAT_PS1_SIM)         gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_SIM");
   return;
 …
+}
+int gfits_table_set_Image (FTable *ftable) {
+  Header *header;
+  header = ftable[0].header;
+  gfits_table_mkheader_Image (header);
+  /* create table */
+  if (!gfits_create_table (header, ftable)) return (FALSE);
+  return (TRUE);
+}
+int gfits_table_mkheader_Image (Header *header) {
+  /* create table header */
+  if (!gfits_create_table_header (header, "BINTABLE", "DVO_IMAGE")) return (FALSE);
+  /* define table layout */
+  /** TABLE DEFINITION **/
+  gfits_define_bintable_column (header, "D",    "CRVAL1",           "coordinate at reference pixel",   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "D",    "CRVAL2",           "coordinate at reference pixel",   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CRPIX1",           "coordinate of reference pixel",   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CRPIX2",           "coordinate of reference pixel",   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CDELT1",           "degrees per pixel",               "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "CDELT2",           "degrees per pixel",               "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PC1_1",            "rotation matrix",                 "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PC1_2",            "rotation matrix",                 "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PC2_1",            "rotation matrix",                 "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "PC2_2",            "rotation matrix",                 "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "14E",  "POLYTERMS",        "higher order warping terms",      "",                  1.0, 0.0);
+  if (sizeof(void *) == 4) {
+    gfits_define_bintable_column (header, "J",    "POINTER1",       "",  "",                  1.0, 0.0);
+    gfits_define_bintable_column (header, "J",    "POINTER2",       "",  "",                  1.0, 0.0);
+  }
+  if (sizeof(void *) == 8) {
+    gfits_define_bintable_column (header, "K",    "POINTER1",       "",  "",                  1.0, 0.0);
+    gfits_define_bintable_column (header, "K",    "POINTER2",       "",  "",                  1.0, 0.0);
+  }
+  gfits_define_bintable_column (header, "15A",  "CTYPE",            "coordinate type",                 "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "A",    "NPOLYTERMS",       "order of polynomial",             "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "TZERO",            "readout time (row 0)",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "NSTAR",            "number of stars on image",        "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "SECZ",             "airmass",                         "mag",               1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "NX",               "image width",                     "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "NY",               "image height",                    "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "APMIFIT",          "aperture correction",             "mag",               1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "DAPMIFIT",         "apmifit error",                   "mag",               1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MCAL",             "calibration mag",                 "mag",               1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "DMCAL",            "error on Mcal",                   "mag",               1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "XM",               "image chisq",                     "10*log(value)",     1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "PHOTCODE",         "identifier for CCD,",             "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "EXPTIME",          "exposure time",                   "seconds",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "ST",               "sidereal time of exposure",       "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "LAT",              "observatory latitude",            "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "RA_CENTER",        "image center",                    "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "DEC_CENTER",       "image center",                    "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "RADIUS",           "image radius",                    "degrees",           1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "REF_COLOR_BLUE",   "median astrometry ref color",     "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "REF_COLOR_RED",    "median astrometry ref color",     "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "117A", "NAME",             "name of original image ",         "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "B",    "DETECTION_LIMIT",  "detection limit",                 "10*mag",            1.0, 0.0);
+  gfits_define_bintable_column (header, "B",    "SATURATION_LIMIT", "saturation limit",                "10*mag",            1.0, 0.0);
+  gfits_define_bintable_column (header, "B",    "CERROR",           "astrometric error",               "50*arcsec",         1.0, 0.0);
+  gfits_define_bintable_column (header, "B",    "FWHM_X",           "PSF x width",                     "25*arcsec",         1.0, 0.0);
+  gfits_define_bintable_column (header, "B",    "FWHM_Y",           "PSF y width",                     "25*arcsec",         1.0, 0.0);
+  gfits_define_bintable_column (header, "B",    "TRATE",            "scan rate",                       "100 usec/pixel",    1.0, 0.0);
+  gfits_define_bintable_column (header, "B",    "CCDNUM",           "CCD ID number",                   "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "FLAGS",            "image quality flags",             "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "IMAGE_ID",         "internal image ID",               "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PARENT_ID",        "associated ref image",            "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "EXTERN_ID",        "external image ID",               "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "SOURCE_ID",        "analysis source ID",              "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "NLINK_ASTROM",     "mean number of matched measurements for astrometry", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "NLINK_PHOTOM",     "mean number of matched measurements for astrometry", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "UBERCAL_DIST",     "distance to nearest ubercal image", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "XPIX_SYS_ERR",     "systematic astrometry error in X", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "YPIX_SYS_ERR",     "systematic astrometry error in Y", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "E",    "MAG_SYS_ERR",      "systematic photometry error",     "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "N_FIT_ASTROM",     "number of stars used for astrometry cal", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "I",    "N_FIT_PHOTOM",     "number of stars used for photometry cal", "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "PHOTOM_MAP_ID",    "reference to 2D zero point map",  "",                  1.0, 0.0);
+  gfits_define_bintable_column (header, "J",    "ASTROM_MAP_ID",    "reference to 2D astrometry map",  "",                  1.0, 0.0);
+  if (sizeof(void *) == 4) {
+    gfits_define_bintable_column (header, "J",    "POINTER3",       "",  "",                  1.0, 0.0);
+  }
+  if (sizeof(void *) == 8) {
+    gfits_define_bintable_column (header, "K",    "POINTER3",       "",  "",                  1.0, 0.0);
+  }
+  return (TRUE);
+}
+/* return internal structure representation */
+Image *gfits_table_get_Image (FTable *ftable, off_t *Ndata, char *swapped) {
+  int Ncols;
+  Image *data;
+  Ncols = ftable[0].header[0].Naxis[0];
+  if (Ncols != sizeof(Image)) {
+    fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, (int) sizeof(Image));
+    return NULL;
+  }
+  *Ndata = ftable[0].header[0].Naxis[1];
+  data = (Image *) ftable[0].buffer;
+  if (!swapped) {
+    myAbort ("invalid to call this without suppying 'swapped'");
+  }
+  if (*swapped == FALSE) {
+    myAbort ("invalid for table to be swapped");
+  }
+  return (data);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_image_raw.c

-              r37035
+              r37822
   if (db[0].format == DVO_FORMAT_PS1_V5)          ImageSize = sizeof(Image_PS1_V5);
   if (db[0].format == DVO_FORMAT_PS1_REF)         ImageSize = sizeof(Image_PS1_REF);
+  if (db[0].format == DVO_FORMAT_PS1_SIM)         ImageSize = sizeof(Image_PS1_SIM);
   /* check that filesize makes sense */
 …
   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);
+  if (db[0].format == DVO_FORMAT_PS1_SIM)         gfits_table_mkheader_Image_PS1_SIM (&db[0].theader);
   /* read data from file */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_photcode_ops.c

-              r37035
+              r37822
+}
+float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt) {
+  int Ns;
+  float Mstdev;
+float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) {
   if (code == NULL) return NAN;
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mstdev  = (Ns == -1) ? NAN : 0.001*secfilt[Ns].Mstdev;
+  int Ns = photcodes[0].hashNsec[code[0].code];
+  if (Ns == -1) return (NAN);
+  float Mstdev = NAN;
+  switch (source) {
+    case MAG_SRC_CHP:
+      switch (class) {
+        case MAG_CLASS_PSF:
+          Mstdev = secfilt[Ns].Mstdev;
+          break;
+        case MAG_CLASS_KRON:
+          Mstdev = secfilt[Ns].sMkron;
+          break;
+        case MAG_CLASS_APER:
+          Mstdev = secfilt[Ns].sMap;
+          break;
+        default:
+          break;
+      }
+      break;
+    case MAG_SRC_WRP:
+      switch (class) {
+        case MAG_CLASS_PSF:
+          Mstdev = secfilt[Ns].sFpsfWrp;
+          break;
+        case MAG_CLASS_KRON:
+          Mstdev = secfilt[Ns].sFkronWrp;
+          break;
+        case MAG_CLASS_APER:
+          Mstdev = secfilt[Ns].sFapWrp;
+          break;
+        default:
+          break;
+      }
+      break;
+    case MAG_SRC_STK:
+    default:
+      break;
+  }
   return (Mstdev);
+}
+int PhotNphot (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) {
+  if (code == NULL) return 0;
+  int Ns = photcodes[0].hashNsec[code[0].code];
+  if (Ns == -1) return 0;
+  int Nphot = 0;
+  switch (source) {
+    case MAG_SRC_CHP:
+      switch (class) {
+        case MAG_CLASS_PSF:
+          Nphot = secfilt[Ns].Nused;
+          break;
+        case MAG_CLASS_KRON:
+          Nphot = secfilt[Ns].NusedKron;
+          break;
+        case MAG_CLASS_APER:
+          Nphot = secfilt[Ns].NusedAp;
+          break;
+        default:
+          break;
+      }
+      break;
+    case MAG_SRC_WRP:
+      switch (class) {
+        case MAG_CLASS_PSF:
+          Nphot = secfilt[Ns].NusedWrp;
+          break;
+        case MAG_CLASS_KRON:
+          Nphot = secfilt[Ns].NusedKronWrp;
+          break;
+        case MAG_CLASS_APER:
+          Nphot = secfilt[Ns].NusedApWrp;
+          break;
+        default:
+          break;
+      }
+      break;
+    case MAG_SRC_STK:
+    default:
+      break;
+  }
+  return (Nphot);
+}
 …
+}
 unsigned int PhotStackID (PhotCode *code, Average *average, SecFilt *secfilt) {
   int Ns;
   unsigned int ID;
   if (code == NULL) return 0;
   Ns = photcodes[0].hashNsec[code[0].code];
   ID = (Ns == -1) ? 0 : secfilt[Ns].stackDetectID;
   return (ID);
+}
+// XX unsigned int PhotStackID (PhotCode *code, Average *average, SecFilt *secfilt) {
+// XX
+// XX   int Ns;
+// XX   unsigned int ID;
+// XX
+// XX   if (code == NULL) return 0;
+// XX
+// XX   Ns = photcodes[0].hashNsec[code[0].code];
+// XX   ID = (Ns == -1) ? 0 : secfilt[Ns].stackDetectID;
+// XX   return (ID);
+// XX }
 // Xm is now (2014.07.03) stored as the chisq except in dvo formats which use as short
 …
+  }
   return (Fave);
+}
+float PhotFluxAveErr (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 dFave = NAN;
+  switch (source) {
+    case MAG_SRC_CHP:
+      switch (class) {
+        case MAG_CLASS_PSF:
+          dFave = secfilt[Ns].dM * MagToFlux(secfilt[Ns].M);
+          break;
+        case MAG_CLASS_KRON:
+          dFave = secfilt[Ns].dMkron * MagToFlux(secfilt[Ns].Mkron);
+          break;
+        case MAG_CLASS_APER:
+          dFave = secfilt[Ns].dMap * MagToFlux(secfilt[Ns].Map);
+          break;
+        default:
+          break;
+      }
+      break;
+    case MAG_SRC_WRP:
+      switch (class) {
+        case MAG_CLASS_PSF:
+          dFave = secfilt[Ns].dFpsfWrp;
+          break;
+        case MAG_CLASS_KRON:
+          dFave = secfilt[Ns].dFkronWrp;
+          break;
+        case MAG_CLASS_APER:
+          dFave = secfilt[Ns].dFapWrp;
+          break;
+        default:
+          break;
+      }
+      break;
+    case MAG_SRC_STK:
+      switch (class) {
+        case MAG_CLASS_PSF:
+          dFave = secfilt[Ns].dFpsfStk;
+          break;
+        case MAG_CLASS_KRON:
+          dFave = secfilt[Ns].dFkronStk;
+          break;
+        case MAG_CLASS_APER:
+          dFave = secfilt[Ns].dFapStk;
+          break;
+        default:
+          break;
+      }
+      break;
+    default:
+      break;
+  }
+  return (dFave);
+}
 …
   m2 = (Ns2 == -1) ? average[0].M : secfilt[Ns2].M;
 */
+/*** lensing *********************************************************************************/
+# define LENSFIELD(NAME) \
+  float LensValue_##NAME (PhotCode *code, Lensobj *lensobj) { \
+  if (code == NULL) return NAN; \
+  int Ns = photcodes->hashNsec[code->code]; \
+  float value = (Ns == -1) ? NAN : lensobj[Ns].NAME; \
+  return (value); \
+}
+LENSFIELD(X11_sm_obj);
+LENSFIELD(X12_sm_obj);
+LENSFIELD(X22_sm_obj);
+LENSFIELD(E1_sm_obj);
+LENSFIELD(E2_sm_obj);
+LENSFIELD(X11_sh_obj);
+LENSFIELD(X12_sh_obj);
+LENSFIELD(X22_sh_obj);
+LENSFIELD(E1_sh_obj);
+LENSFIELD(E2_sh_obj);
+LENSFIELD(X11_sm_psf);
+LENSFIELD(X12_sm_psf);
+LENSFIELD(X22_sm_psf);
+LENSFIELD(E1_sm_psf);
+LENSFIELD(E2_sm_psf);
+LENSFIELD(X11_sh_psf);
+LENSFIELD(X12_sh_psf);
+LENSFIELD(X22_sh_psf);
+LENSFIELD(E1_sh_psf);
+LENSFIELD(E2_sh_psf);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_tiny_values.c

r37035	r37822
20	20	measureT[0].dM = measure[0].dM;
21	21	measureT[0].airmass = measure[0].airmass;
	22	measureT[0].RoffGAL = measure[0].RoffGAL;
	23	measureT[0].DoffGAL = measure[0].DoffGAL;
22	24	measureT[0].Xccd = measure[0].Xccd;
23	25	measureT[0].Yccd = measure[0].Yccd;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/dvo_util.c

-              r33030
+              r37822
         if ((image->externID == externID) && (image->sourceID == sourceID)) {
             BuildChipMatch(dvoConfig->images, dvoConfig->nImages);
+            if (FindMosaicForImage(dvoConfig->images, dvoConfig->nImages, i)) {
+                return image;
+            } else {
+                fprintf(stderr, "FindMosaicForImage failed\n");
+                return NULL;
+            }
+            return image;
+        }
+    }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/flatcorr_io.c

-              r33963
+              r37822
+}
+// eddie uses cell_x = (int) (X + X_PAD) / (base + X_PAD)
+// where base = 600, X_PAD = 8, Y_PAD = 10.  denominator is thus (608,610), whic is (4880/8),(4864/8)
+// these match Eddie's NCELL_X,Y / CHIP_DX,DY, so I think we are good with this:
+# define X_PAD 8
+# define Y_PAD 10
 float FlatCorrectionOffset (FlatCorrectionTable *flatcorr, int ID, int X, int Y) {
 …
   // convert X,Y to Xbin, Ybin:
   int Xbin = MAX(MIN(X * flatcorr->image[seq].Nx / flatcorr->image[seq].DX, flatcorr->image[seq].Nx - 1), 0);
   int Ybin = MAX(MIN(Y * flatcorr->image[seq].Ny / flatcorr->image[seq].DY, flatcorr->image[seq].Ny - 1), 0);
+  int Xbin = MAX(MIN((X + X_PAD) * flatcorr->image[seq].Nx / flatcorr->image[seq].DX, flatcorr->image[seq].Nx - 1), 0);
+  int Ybin = MAX(MIN((Y + Y_PAD) * flatcorr->image[seq].Ny / flatcorr->image[seq].DY, flatcorr->image[seq].Ny - 1), 0);
   // XXX warn if X,Y are out of range? not super important unless *way* out of range

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/mosaic_astrom.c

-              r29938
+              r37822
 # include <dvo.h>
+//  the block of code below was used to define the chip->mosaic relationship before this
+//  was assigned to the coords value
 off_t getDISentry (e_time start, e_time stop, e_time *startMos, off_t *indexMos, off_t Nmosaic);
 void SortDISindex (e_time *S, off_t *I, off_t N);
+# if (0)
 /* chip-match table: j = ChipMatch[i], images[j] is DIS for images[i] WRP */
 …
+}
+int BuildChipMatch_old (Image *images, off_t Nimages) {
+// this is a very old version of BuildChipMatch which does not use bisection
+int BuildChipMatch_nosort (Image *images, off_t Nimages) {
   off_t i, j, NDIS;
 …
+}
+int BuildChipMatch (Image *images, off_t Nimages) {
+// this is an old version of BuildChipMatch which stores the results here in a local static variable
+int BuildChipMatch_static (Image *images, off_t Nimages) {
   off_t i, j, NDIS;
 …
   return (TRUE);
+}
+# endif
+// XXX Note that this links (images[i].coords.mosaic, images[i].parent) will break
+// if we reallocate the Image array in the middle of program
+int BuildChipMatch (Image *images, off_t Nimages) {
+  off_t i, j, NDIS;
+  off_t  Ndis = 0;
+  off_t  *DISentry = NULL;
+  e_time *DIStzero = NULL;
+  if (DISentry != NULL) free (DISentry);
+  if (DIStzero != NULL) free (DIStzero);
+  // allocate containers for DIS indexing
+  Ndis = 0;
+  NDIS = 100;
+  ALLOCATE (DISentry, off_t, NDIS);
+  ALLOCATE (DIStzero, e_time, NDIS);
+  // find all DIS images, save tzero (& photcode?)
+  for (i = 0; i < Nimages; i++) {
+    if (strcmp(&images[i].coords.ctype[4], "-DIS")) continue;
+    DISentry[Ndis] = i;
+    DIStzero[Ndis] = images[i].tzero;
+    Ndis ++;
+    if (Ndis >= NDIS) {
+      NDIS += 100;
+      REALLOCATE (DISentry, off_t, NDIS);
+      REALLOCATE (DIStzero, e_time, NDIS);
+    }
+  }
+  // sort the index, start, and stop by the start times:
+  SortDISindex (DIStzero, DISentry, Ndis);
+  /* find all matched WRP images */
+  for (i = 0; i < Nimages; i++) {
+    images[i].parent        = NULL; // reset to NULL
+    images[i].coords.mosaic = NULL; // reset to NULL
+    if (strcmp(&images[i].coords.ctype[4], "-WRP")) continue; // only define link for WRP coords
+    j = getDISentry (images[i].tzero, images[i].tzero + (int) images[i].exptime, DIStzero, DISentry, Ndis);
+    if (j == -1) {
+      fprintf (stderr, "WARNING: can't find matching mosaic \n");
+      continue;
+    }
+    if (j >= Nimages) myAbort("invalid DIS entry");
+    images[i].parent = &images[j];
+    images[i].coords.mosaic = &images[j].coords;
+  }
+  return (TRUE);
+}
+// use bisection to find the overlapping mosaic
 off_t getDISentry (e_time start, e_time stop, e_time *startMos, off_t *indexMos, off_t Nmosaic) {
-  // use bisection to find the overlapping mosaic
   off_t Nlo, Nhi, N;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/skyregion_gsc.c

r34088	r37822
204	204	for (i = 0; i < Nregions; i++) {
205	205	strncpy (temp, &buffer[i*48], 48);
206		temp[49] = 0;
	206	temp[48] = 0;
207	207	hstgsc_hms_to_deg (&Rmin, &Rmax, &Dmin, &Dmax, &temp[7]);
208	208	if (Dmax < Dmin) SWAP (Dmin, Dmax);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libdvo/src/skyregion_ops.c

-              r35102
+              r37822
   if (c) return (c+1);
   return name;
+}
+/* find region which corresponds to the given index */
+SkyList *SkyRegionByIndex (SkyTable *table, int index) {
+  SkyList *list;
+  ALLOCATE (list, SkyList, 1);
+  ALLOCATE (list[0].regions,  SkyRegion *, 1);
+  ALLOCATE (list[0].filename,  char *, 1);
+  list[0].Nregions = 0;
+  list[0].ownElements = FALSE; // this list is only holding a view to the elements
+  strcpy (list[0].hosts, table[0].hosts);
+  list[0].regions[0] = &table[0].regions[index];
+  list[0].filename[0] = table[0].filename[index];
+  list[0].Nregions = 1;
+  return (list);
+}
 …
+  }
-  if( Rmax > (Rmin+180.)) {
-      double temp = Rmax;
-      Rmax = Rmin;
-      Rmin = temp;
+  }
   list = SkyListByBounds (table, depth, Rmin, Rmax, Dmin, Dmax);
+  return (list);
+}
+  // fprintf (stderr, "%s : %f - %f, %f - %f : %d\n",
+  // image->name, Rmin, Rmax, Dmin, Dmax, (int) list->Nregions);
+  return (list);
+}
+// a region like -10 10 0 20 will become 350 10 0 20 and return all regions on both sides of 0,360
 SkyList *SkyListByBounds (SkyTable *table, int depth, double Rmin, double Rmax, double Dmin, double Dmax) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libfits/Makefile

-              r34088
+              r37822
 $(HEAD)/F_scan.$(ARCH).o                        $(HEAD)/F_print.$(ARCH).o     \
 $(HEAD)/F_copy_H.$(ARCH).o                      $(HEAD)/F_delete.$(ARCH).o    \
+$(HEAD)/F_read_XH.$(ARCH).o                     $(HEAD)/F_init_H.$(ARCH).o    \
+$(HEAD)/F_convert_H.$(ARCH).o                   $(HEAD)/version.$(ARCH).o
+$(HEAD)/F_find_H.$(ARCH).o                      $(HEAD)/F_init_H.$(ARCH).o    \
+$(HEAD)/F_convert_H.$(ARCH).o                   $(HEAD)/F_read_XH.$(ARCH).o   \
+$(HEAD)/version.$(ARCH).o
 MATRIX_OBJ = \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libfits/header/F_free_H.c

r7054	r37822
4	4	/********************* fits free header *********************************/
5	5	void gfits_free_header (Header *header) {
	6
	7	// fprintf (stderr, "free data for %zx\n", (size_t) header->buffer);
6	8
7	9	if (header[0].buffer == (char *) NULL) return;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libfits/include/gfitsio.h

-              r37039
+              r37822
 # define NEWLINE                 10  /* UNIX RETURN character */
 # endif /* NEWLINE */
+/* gfits_bintable_format returns 'byte' as the type associated with one-byte logical (non-char) values */
+typedef char byte;
 /********** FITS Constants *********/
 …
 int     gfits_modify_alt               PROTO((Header *header, char *field, char *mode, int N,...));
 int     gfits_print_alt                PROTO((Header *header, char *field, char *mode, int N,...));
+int     gfits_find_Xheader             PROTO((FILE *f, Header *header, char *extname));
 int     gfits_read_Xheader             PROTO((char *filename, Header *header, int N));
 int     gfits_read_header              PROTO((char *filename, Header *header));
 …
 int     gfits_fread_ftable             PROTO((FILE *f, FTable *ftable, char *extname));
 int     gfits_fread_ftable_data        PROTO((FILE *f, FTable *ftable, int padIfShort));
 int     gfits_fread_ftable_range       PROTO((FILE *f, FTable *ftable, off_t start, off_t Nrows));
+int     gfits_fread_ftable_range       PROTO((FILE *f, int padIfShort, FTable *ftable, off_t start, off_t Nrows));
 int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, off_t Nrow, off_t *row));
 int     gfits_fread_vtable_range       PROTO((FILE *f, VTable *vtable, off_t start, off_t Nrows));

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libfits/table/F_read_T.c

-              r29938
+              r37822
 int gfits_fread_ftable (FILE *f, FTable *table, char *extname) {
-  int j, found;
-  off_t Nbytes;
   Header *header;
-  char tname[80];
   header = table[0].header;
+  fseeko (f, 0, SEEK_SET);
+  found = FALSE;
+  for (j = -1; !found; j++) {
+    /* load data for this header */
+    if (!gfits_load_header (f, header)) return (FALSE);
+    /* check if this is the correct extension or not */
+    bzero (tname, 80);
+    gfits_scan (header, "EXTNAME", "%s", 1, tname);
+    if (!strcmp (tname, extname)) {
+      if (gfits_fread_ftable_data (f, table, FALSE)) return (TRUE);
+      gfits_free_header (header);
+      return (FALSE);
+    }
+    /* skip to next header */
+    Nbytes = gfits_data_size (header);
+    fseeko (f, Nbytes, SEEK_CUR);
+    gfits_free_header (header);
+  }
+  return (TRUE);
+}
+  if (!gfits_find_Xheader (f, header, extname)) return FALSE;
+  if (gfits_fread_ftable_data (f, table, FALSE)) return (TRUE);
+  gfits_free_header (header);
+  return (FALSE);
+}
 /*********************** fits read ftable data ***********************************/
 …
 /*********************** fits read ftable data ***********************************/
 int gfits_fread_ftable_range (FILE *f, FTable *table, off_t start, off_t Nrows) {
+int gfits_fread_ftable_range (FILE *f, int padIfShort, FTable *table, off_t start, off_t Nrows) {
   off_t Nbytes, Nread, Nskip, Nx, Ny;
 …
     if (ferror (f)) {
       perror ("fits read error");
+      free (table[0].buffer);
+      return (FALSE);
+    }
+    fprintf (stderr, "error: fits read error in %s, read "OFF_T_FMT", need "OFF_T_FMT"\n", __func__,  Nread,  Nbytes);
+    if (padIfShort) {
+      memset (&table[0].buffer[Nread], 0, Nbytes - Nread);
+      fprintf (stderr, "warning: file missing data, padding with zeros: USE AT YOUR OWN RISK!\n");
+      table[0].validsize = Nread;
+      table[0].datasize = Nbytes;
     } else {
+      fprintf (stderr, "unexpected eof\n");
+    }
+    free (table[0].buffer);
+    return (FALSE);
+      free (table[0].buffer);
+      return (FALSE);
+    }
+  }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libfits/table/F_write_T.c

-              r28241
+              r37822
   // cursor must be at start of the table (after table header)
+  fseeko (f, Nskip, SEEK_CUR);
+  if (fseeko (f, Nskip, SEEK_CUR)) {
+    fprintf (stderr, "can't seek table start\n");
+    return (FALSE);
+  }
   Nwrite = fwrite (ftable[0].buffer, sizeof (char), Nbytes, f);
   if (Nwrite != Nbytes) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libkapa/src/KapaWindow.c

-              r36488
+              r37822
   graphdata[0].lweight = graphdata[0].size = 1.0;
+  graphdata[0].coords.pc1_1 = graphdata[0].coords.pc2_2 = 1.0;
+  graphdata[0].coords.pc1_2 = graphdata[0].coords.pc2_1 = 0.0;
+  strcpy (graphdata[0].coords.ctype, "DEC--LIN");
+  graphdata[0].coords.crval1 = 0.0;
+  graphdata[0].coords.crval2 = 0.0;
+  graphdata[0].coords.crpix1 = 0.0;
+  graphdata[0].coords.crpix2 = 0.0;
+  graphdata[0].coords.cdelt1 = graphdata[0].coords.cdelt2 = 1.0;
+  graphdata[0].flipeast = TRUE;
+  InitCoords (&graphdata[0].coords, "DEC--LIN");
+  graphdata[0].flipeast = TRUE; // default coords has EW flipped relative to sky
   graphdata[0].flipnorth = FALSE;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libohana/Makefile

-              r33646
+              r37822
 $(SRC)/time.$(ARCH).o            \
 $(SRC)/gaussj.$(ARCH).o          \
+$(SRC)/spherical.$(ARCH).o       \
+$(SRC)/vstats.$(ARCH).o          \
 $(SRC)/config.$(ARCH).o          \
 $(SRC)/Fread.$(ARCH).o           \
 …
 $(SRC)/gprint.$(ARCH).o  \
 $(SRC)/version.$(ARCH).o
+# $(SRC)/legendre.$(ARCH).o      \
+# $(SRC)/gsl_utils.$(ARCH).o     \
 TYPETEST = \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libohana/include/ohana.h

-              r37033
+              r37822
 # ifndef isfinite
 # define isfinite(A) (!isnan(A))
+# define isfinite(A) (!isnan(A) && !isinf(A))
 # endif
 …
 // sorting is now defined as a macro call
 # include <ohana_sort.h>
+// vector statistics options
+typedef enum {
+  VSTATS_NONE,
+  VSTATS_MEAN,
+  VSTATS_MEDIAN,
+  VSTATS_WT_MEAN,
+  VSTATS_INNER_MEAN,
+  VSTATS_INNER_WTMEAN,
+  VSTATS_CHI_INNER_MEAN,
+  VSTATS_CHI_INNER_WTMEAN
+} VStatsMode;
+typedef struct {
+  double median;
+  double mean;
+  double sigma;
+  double error;
+  double chisq;
+  double min;
+  double max;
+  double Upper80;
+  double Lower20;
+  double total;
+  int    Nmeas;
+  VStatsMode statmode;
+} VStatsType;
 /* socket / pipe communication buffer */
 …
 char   *ohana_version          PROTO((void));
+int     dgaussjordan_pivot     PROTO((double **A, double **B, int N, int M, double minPivot));
 int     dgaussjordan           PROTO((double **A, double **B, int N, int M));
 int     fgaussjordan           PROTO((float **A, float **B, int n, int m));
 …
 int rconnect (char *command, char *hostname, char *shell, int *stdio, int *errorInfo, int doHandshake);
+int vstats_setmode (VStatsType *stats, char *mode);
+int vstats_getstats (double *value, double *dvalue, double *weight, int N, VStatsType *stats);
+int vstats_getstats_f (float *value, float *dvalue, float *weight, int N, VStatsType *stats);
 /*
 #   define F_SETFL         4
 …
 */
+# endif
+/** gsl-based functions for legendre and related polynomials **/
+double ohana_gsl_sf_log_1plusx (double x, double *err);
+double ohana_gsl_sf_lnpoch(const double a, const double x, double *err);
+double ohana_gsl_lnpoch_pos (const double a, const double x, double *err);
+double ohana_gsl_pochrel_smallx(const double a, const double x, double *err);
+double legendre_Pl (int l, double x, double *err);
+double legendre_Plm (int l, int m, double x, double *err);
+double legendre_Plm_sphere(int l, int m, double x, double *err);
+typedef struct {
+  double *Fr;
+  double *Fi;
+  int    *l;
+  int    *m;
+  int lmax;
+  int Nterms;
+} SHterms;
+SHterms *SHtermsInit (int lmax);
+void SHtermsFree (SHterms *terms);
+void SHtermsForRD (SHterms *terms, double R, double D);
+void SHtermsForLM (SHterms *terms, double R, double D, int l, int m);
+typedef struct {
+  double *dR_B;
+  double *dR_E;
+  double *dD_B;
+  double *dD_E;
+  int    *l;
+  int    *m;
+  int lmax;
+  int Nterms;
+} VSHterms;
+VSHterms *VSHtermsInit (int lmax);
+void VSHtermsFree (VSHterms *terms);
+void VSHtermsForRD (VSHterms *terms, double R, double D);
+void VSHtermsForLM (VSHterms *terms, double R, double D, int l, int m);
+# endif

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libohana/src/gaussj.c

-              r36084
+              r37822
 # include <ohana.h>
 # define GROWTHTEST 0
+# define MAX_RANGE 1.0e9
+# define VERY_VERBOSE 0
+# define MAX_RANGE 1.0e16
 // Gauss-Jordan elimination using full pivots based on Press et al's description.  Substantially
 …
 // than their implementation.  (largely based on version by William Kahan)
+int dgaussjordan (double **A, double **B, int N, int M) {
+# define myMIN_PIVOT 1.0e-7
+  int status = dgaussjordan_pivot (A, B, N, M, myMIN_PIVOT);
+  return status;
+}
 // MAX_RANGE is used to test for ill-conditioned input matrices.  For an ill-conditioned
 // matrix, one or more of the pivots trends towards zero.  Rather than allow this to go to the
 // numerical precision, I am raising an error if |growth| > 1e8
 int dgaussjordan (double **A, double **B, int N, int M) {
+int dgaussjordan_pivot (double **A, double **B, int N, int M, double MIN_PIVOT) {
   int *colIndex;
 …
     // search for the next pivot
     for (row = 0; row < N; row++) {
+      if (!finite(A[row][diag])) goto escape;
+      if (!finite(A[row][diag])) {
+        fprintf (stderr, "infinity\n");
+        goto escape;
+      }
       // if we have already operated on this row (pivot[row] is true), skip it
 …
 # if (GROWTHTEST)
     fprintf (stderr, "maxcol: %d\n", maxcol);
+# if (VERY_VERBOSE)
     fprintf (stderr, "full A matrix:\n");
     for (row = 0; row < N; row++) {
         for (col = 0; col < N; col++) {
             fprintf (stderr, "%10.3e ", A[row][col]);
+        }
         fprintf (stderr, "\n");
+      for (col = 0; col < N; col++) {
+        fprintf (stderr, "%10.3e ", A[row][col]);
+      }
+      fprintf (stderr, "\n");
+    }
     fprintf (stderr, "\n");
 # endif
+# endif
     // if pivot[maxcol] is set, we have already done this row: this implies a singular matrix
+    if (pivot[maxcol]) goto escape;
+    if (pivot[maxcol]) {
+      fprintf (stderr, "singular\n");
+      goto escape;
+    }
     pivot[maxcol] = TRUE;
 …
     rowIndex[diag] = maxrow;
     colIndex[diag] = maxcol;
+    if (A[maxcol][maxcol] == 0.0) goto escape;
+    if (A[maxcol][maxcol] == 0.0) {
+      fprintf (stderr, "zero pivot\n");
+      goto escape;
+    }
     // XXX Kahan replaces the 0.0 pivot with epsilon*(largest element in column) + underFlow
     /* rescale by pivot reciprocal */
     double tmpval = 1.0 / A[maxcol][maxcol];
+# if (0)
+    if (fabs(A[maxcol][maxcol]) < MIN_PIVOT) {
+      // we are ill-conditioned.  set this row & col to 0.0, 1.0 on pivot
+      // fprintf (stderr, "WARNING: eliminating degenerate pivot %lf @ A[%d][%d]\n", A[maxcol][maxcol], maxcol, maxcol);
+      for (col = 0; col < N; col++) A[maxcol][col] = 0.0;
+      for (col = 0; col < M; col++) B[maxcol][col] = 0.0;
+      for (row = 0; row < N; row++) A[row][maxcol] = 0.0;
+      A[maxcol][maxcol] = 1.0;
+      continue;
+    }
+# endif
     // XXX why is this here (don't I double count this element?) A[maxcol][maxcol] = 1.0;
     A[maxcol][maxcol] = 1.0;
 …
 #   if (GROWTHTEST)
     fprintf (stderr, "column: %d, maxval : %f, growth: %e, epsilon: %e\n", maxcol, tmpval, growth, epsilon);
+# if (VERY_VERBOSE)
     fprintf (stderr, "A diagonal: ");
     for (col = 0; col < N; col++) fprintf (stderr, "%f ", A[col][col]);
     fprintf (stderr, "\n");
 # endif
+    if (fabs(growth) > MAX_RANGE) goto escape;
+# endif
+    if (fabs(growth) > MAX_RANGE) {
+      fprintf (stderr, "max range\n");
+      goto escape;
+    }
     /* adjust the elements above the pivot */
 …
+  }
+# if (GROWTHTEST)
+    fprintf (stderr, "final A matrix:\n");
+    for (row = 0; row < N; row++) {
+        for (col = 0; col < N; col++) {
+            fprintf (stderr, "%10.3e ", A[row][col]);
+        }
+        fprintf (stderr, "\n");
+# if (GROWTHTEST && VERY_VERBOSE)
+  fprintf (stderr, "final A matrix:\n");
+  for (row = 0; row < N; row++) {
+    for (col = 0; col < N; col++) {
+      fprintf (stderr, "%10.3e ", A[row][col]);
+    }
     fprintf (stderr, "\n");
+  }
+  fprintf (stderr, "\n");
 # endif

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libohana/src/glockfile.c

-              r35754
+              r37822
     /* set value to IDLE */
+    fseeko (flock, 0LL, SEEK_SET);
+    if (fseeko (flock, 0LL, SEEK_SET)) {
+      *state = LCK_HARDCLOSE;
+      goto failure;
+    }
     nbytes = fprintf (flock, "IDLE\n");
     if (nbytes != 5) {
 …
   /* now unlock the file */
+  fclose (f);
+  if (fclose (f)) {
+    *state = LCK_UNKNOWN;
+    goto failure;
+  }
   *state = LCK_UNLOCK;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/libohana/src/ohana_allocate.c

-              r32632
+              r37822
   if (!in) return;
+  // fprintf (stderr, "free %zx\n", (size_t) in);
   ref = (Memblock *) in - 1;
+  // fprintf (stderr, "  file: %s, line: %d, func: %s, size: %zd, addr: %zx\n",
+  // ref->file, ref->line, ref->func, ref->size, (size_t) ref);
   pthread_mutex_lock(&memBlockListMutex);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/markrock/src/gcatstats.c

-              r36481
+              r37822
   /* project onto rectilinear grid with 1 arcsec pixels, sort by X */
   /* reference for coords is center of field  */
+  InitCoords (&catstats[0].coords, "DEC--TAN");
   catstats[0].coords.crval1 = RaCenter;
   catstats[0].coords.crval2 = DecCenter;
-  catstats[0].coords.crpix1 = catstats[0].coords.crpix2 = 0.0;
   catstats[0].coords.cdelt1 = catstats[0].coords.cdelt2 = 1.0 / 3600.0;
+  catstats[0].coords.pc1_1 = catstats[0].coords.pc2_2 = 1.0;
+  catstats[0].coords.pc1_2 = catstats[0].coords.pc2_1 = 0.0;
+  strcpy (catstats[0].coords.ctype, "DEC--TAN");
   X1 = catstats[0].X;
   Y1 = catstats[0].Y;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/markstar/src/gcatstats.c

-              r36483
+              r37822
   /* project onto rectilinear grid with 1 arcsec pixels, sort by X */
   /* reference for coords is center of field  */
+  InitCoords (&catstats[0].coords, "DEC--TAN");
   catstats[0].coords.crval1 = RaCenter;
   catstats[0].coords.crval2 = DecCenter;
-  catstats[0].coords.crpix1 = catstats[0].coords.crpix2 = 0.0;
   catstats[0].coords.cdelt1 = catstats[0].coords.cdelt2 = 1.0 / 3600.0;
-  catstats[0].coords.pc1_1 = catstats[0].coords.pc2_2 = 1.0;
-  catstats[0].coords.pc1_2 = catstats[0].coords.pc2_1 = 0.0;
-  strcpy (catstats[0].coords.ctype, "DEC--TAN");
   X1 = catstats[0].X;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/mosastro/src/chips.c

-              r7401
+              r37822
     /* bore site center guess */
+    strcpy (chip[i].map.ctype, "DEC--PLY");
+    chip[i].map.crpix1 = 0.0;
+    chip[i].map.crpix2 = 0.0;
+    chip[i].map.cdelt1 = 1.0;
+    chip[i].map.cdelt2 = 1.0;
+    InitCoords (&chip[i].map, "DEC--PLY");
     /* find (L,M) coords of reference pixel (0,0) */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/mosastro/src/fakefield.c

-              r3401
+              r37822
   /* bore site center guess */
+  strcpy (field.project.ctype, "DEC--TAN");
+  field.project.crpix1 = 0;
+  field.project.crpix2 = 0;
+  InitCoords (&field.project, "DEC--TAN");
   /* set TP plate scale */
 …
   field.project.cdelt2 = 1.0/3600.0;
-  /** allow guess at field rotation?? **/
-  field.project.pc1_1  = 1;
-  field.project.pc2_2  = 1;
-  field.project.pc1_2  = 0;
-  field.project.pc2_1  = 0;
-  field.project.Npolyterms = 1;
   /** distort only has power in polyterms **/
+  strcpy (field.distort.ctype, "DEC--PLY");
+  field.distort.crval1 = 0.0;
+  field.distort.crval2 = 0.0;
+  field.distort.crpix1 = 0.0;
+  field.distort.crpix2 = 0.0;
+  field.distort.cdelt1 = 1.0;
+  field.distort.cdelt2 = 1.0;
+  field.distort.pc1_1  = 1;
+  field.distort.pc2_2  = 1;
+  field.distort.pc1_2  = 0;
+  field.distort.pc2_1  = 0;
+  /* how do we handle renormalization? (fixed at 1000 pixels??) */
+  field.distort.Npolyterms = 3;
+  for (i = 0; i < 7; i++) {
+    field.distort.polyterms[i][0] = 0;
+    field.distort.polyterms[i][1] = 0;
+  }
+  InitCoords (&field.distort, "DEC--PLY");
   return (1);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/mosastro/src/field.c

-              r7401
+              r37822
   /* bore site center guess */
   strcpy (field.project.ctype, "DEC--TAN");
+  InitCoords (&field.project, "DEC--TAN");
   # if (PSASTRO_MODE)
 …
   # endif
-  field.project.crpix1 = 0;
-  field.project.crpix2 = 0;
   /* measure average plate scale - would be better using parabolic min... */
   field.project.cdelt1 = 0;
 …
 *field.project.cdelt1, 3600*field.project.cdelt2);
-  /** allow guess at field rotation?? **/
-  field.project.pc1_1  = 1;
-  field.project.pc2_2  = 1;
-  field.project.pc1_2  = 0;
-  field.project.pc2_1  = 0;
-  field.project.Npolyterms = 1;
   /* bore site center guess */
+  strcpy (field.distort.ctype, "DEC--PLY");
+  field.distort.crval1 = 0.0;
+  field.distort.crval2 = 0.0;
+  field.distort.crpix1 = 0.0;
+  field.distort.crpix2 = 0.0;
+  field.distort.cdelt1 = 1.0;
+  field.distort.cdelt2 = 1.0;
+  /** allow guess at field rotation?? **/
+  field.distort.pc1_1  = 1;
+  field.distort.pc2_2  = 1;
+  field.distort.pc1_2  = 0;
+  field.distort.pc2_1  = 0;
+  /* allow 2nd and 3rd order? */
+  /* how do we handle renormalization? (fixed at 1000 pixels??) */
+  field.distort.Npolyterms = 1;
+  for (i = 0; i < 7; i++) {
+    field.distort.polyterms[i][0] = 0;
+    field.distort.polyterms[i][1] = 0;
+  }
+  InitCoords (&field.distort, "DEC--PLY");
   return (TRUE);
+}
 …
 int load_field (char *filename) {
-  int i;
   Coords coords;
   Header header;
 …
   /* bore site center guess */
   strcpy (field.project.ctype, "DEC--TAN");
+  InitCoords (&field.project, "DEC--TAN");
   field.project.crval1 = 0.5*(field.Rmin + field.Rmax);
   field.project.crval2 = 0.5*(field.Dmin + field.Dmax);
-  field.project.crpix1 = 0;
-  field.project.crpix2 = 0;
   /* measure average plate scale - would be better using parabolic min... */
 …
   /* bore site center guess */
+  strcpy (field.distort.ctype, "DEC--PLY");
+  field.distort.crval1 = 0.0;
+  field.distort.crval2 = 0.0;
+  field.distort.crpix1 = 0.0;
+  field.distort.crpix2 = 0.0;
+  field.distort.cdelt1 = 1.0;
+  field.distort.cdelt2 = 1.0;
+  /** allow guess at field rotation?? **/
+  field.distort.pc1_1  = 1;
+  field.distort.pc2_2  = 1;
+  field.distort.pc1_2  = 0;
+  field.distort.pc2_1  = 0;
+  InitCoords (&field.distort, "DEC--PLY");
-  /* allow 2nd and 3rd order? */
-  /* how do we handle renormalization? (fixed at 1000 pixels??) */
-  field.distort.Npolyterms = coords.Npolyterms;
-  for (i = 0; i < 7; i++) {
-    field.distort.polyterms[i][0] = coords.polyterms[i][0];
-    field.distort.polyterms[i][1] = coords.polyterms[i][1];
+  }
   return (TRUE);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/mosastro/src/fitpoly.c

-              r16058
+              r37822
   double R;
+  InitCoords (coords, "DEC--PLY");
   /* update the higher order terms */
   if (NORDER > 1) {
 …
   coords[0].Npolyterms = NORDER;
-  strcpy (coords[0].ctype, "DEC--PLY");
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/mosastro/src/mkobs.c

-              r7080
+              r37822
       /* Chip-Sky terms */
       strcpy (coords.ctype, "DEC--WRP");
+      InitCoords (&coords, "DEC--WRP");
       coords.crval1 = Ro;
       coords.crval2 = Do;
 …
+      }
-      coords.pc1_1  = 1;
-      coords.pc2_2  = 1;
-      coords.pc1_2  = 0;
-      coords.pc2_1  = 0;
-      coords.Npolyterms = 1;
       header = mkheader (2*dX, 2*dY, Nstars, &coords);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/mosastro/src/mkstandards.c

-              r7080
+              r37822
   /* bore site center guess */
   strcpy (coords.ctype, "DEC--TAN");
+  InitCoords (&coords, "DEC--TAN");
   coords.crval1 = atof(argv[1]);
   coords.crval2 = atof(argv[2]);
   coords.crpix1 = dX;
   coords.crpix2 = dX;
   coords.cdelt1 = 1/3600.0;
   coords.cdelt2 = 1/3600.0;
-  coords.pc1_1  = 1;
-  coords.pc2_2  = 1;
-  coords.pc1_2  = 0;
-  coords.pc2_1  = 0;
-  coords.Npolyterms = 1;
   if (Random) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/mosastro/src/testcoords.c

-              r3404
+              r37822
     exit (1);
+  }
+  RegisterMosaic (&field.project);
+  chip[0].map.mosaic = &field.project;
   strcpy (chip[0].map.ctype, "DEC--WRP");
   for (i = 0; i < chip[0].Nmatch; i++) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/Makefile

r36489	r37822
71	71	$(SRC)/star.$(ARCH).o \
72	72	$(SRC)/transform.$(ARCH).o \
	73	$(SRC)/vshimage.$(ARCH).o \
	74	$(SRC)/shimage.$(ARCH).o \
73	75	$(SRC)/imsub.$(ARCH).o \
74	76	$(SRC)/imfit.$(ARCH).o \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/cdensify.c

-              r36489
+              r37822
   // generate the PSF in a local tangent plane
   Coords coords;
+  coords.crpix1 = coords.crpix2 = 0.0;
+  coords.crval1 = coords.crval2 = 0.0;
+  coords.cdelt1 = coords.cdelt2 = 1.0;
+  coords.pc1_1  = coords.pc2_2  = 1.0;
+  coords.pc1_2  = coords.pc2_1  = 0.0;
+  coords.Npolyterms = 0;
+  strcpy (coords.ctype, "DEC--TAN");
+  InitCoords (&coords, "DEC--TAN");
   r = vr[0].elements.Flt;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/coords.c

r33662	r37822
71	71	if ((mosbuffer = SelectBuffer (MOSAIC, OLDBUFFER, TRUE)) == NULL) goto escape;
72	72	GetCoords (&moscoords, &mosbuffer[0].header);
73		~~RegisterMosaic (&moscoords)~~;
	73	coords.mosaic = &moscoords;
74	74	}
75	75

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/cplot.c

-              r34613
+              r37822
   double ra_prev = 0;
   int i, kapa, Npts, status, leftside;
+  int i, kapa, Npts, status, leftside, valid, size;
   opihi_flt *x, *y, *r, *d, Rmin, Rmax, Rmid;
   Vector Xvec, Yvec, *xvec, *yvec;
 …
   if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
+  if (argc != 3) {
+  valid  = (argc == 3);
+  valid |= (argc > 4) && !strcmp (argv[3], "where");
+  if (!valid) {
     gprint (GP_ERR, "USAGE: cplot <ra> <dec> [style]\n");
+    gprint (GP_ERR, "   OR: cplot <ra> <dec> [style] where (condition)\n");
     return (FALSE);
+  }
 …
+  }
+  // tvec is used for logical test (truth vector)
+  Vector *tvec = NULL;
+  if (argc > 4) {
+    char *out = dvomath (argc - 4, &argv[4], &size, 1);
+    if (out == NULL) {
+      print_error ();
+      return FALSE;
+    }
+    if ((tvec = SelectVector (out, OLDVECTOR, TRUE)) == NULL) {
+      gprint (GP_ERR, " invalid logic result\n");
+      DeleteNamedVector (out);
+      free (out);
+      return (FALSE);
+    }
+  }
+  if (tvec && tvec[0].Nelements != yvec[0].Nelements) {
+    gprint (GP_ERR, "logic test vector not the same length as data vectors\n");
+    DeleteVector (tvec);
+    return (FALSE);
+  }
   SetVector (&Xvec, OPIHI_FLT, xvec[0].Nelements);
   SetVector (&Yvec, OPIHI_FLT, xvec[0].Nelements);
 …
   Npts = 0;
   for (i = 0; i < Xvec.Nelements; i++, r++, d++) {
+    if (tvec) {
+      int skip = (tvec->type == OPIHI_FLT) ? (tvec->elements.Flt[i] == 0.0) : (tvec->elements.Int[i] == 0.0);
+      if (skip) continue;
+    }
     double ra = ohana_normalize_angle (*r);
     while (ra < Rmin) ra += 360.0;
 …
   free (Yvec.elements.Ptr);
+  if (tvec) DeleteVector (tvec);
   return (TRUE);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/csystem.c

-              r34342
+              r37822
   if (argc != 5) goto syntax;
+  switch (argv[1][0]) {
+    case 'C': input = COORD_CELESTIAL; break;
+    case 'G': input = COORD_GALACTIC; break;
+    case 'E': input = COORD_ECLIPTIC; break;
+    default: goto syntax;
+  if (!strcmp(argv[1], "G2004")) {
+    input = COORD_GALACTIC_REID_2004;
+  } else {
+    switch (argv[1][0]) {
+      case 'C': input = COORD_CELESTIAL; break;
+      case 'G': input = COORD_GALACTIC; break;
+      case 'E': input = COORD_ECLIPTIC; break;
+      default: goto syntax;
+    }
+  }
+  switch (argv[2][0]) {
+    case 'C': output = COORD_CELESTIAL; break;
+    case 'G': output = COORD_GALACTIC; break;
+    case 'E': output = COORD_ECLIPTIC; break;
+    default: goto syntax;
+  if (!strcmp(argv[2], "G2004")) {
+    output = COORD_GALACTIC_REID_2004;
+  } else {
+    switch (argv[2][0]) {
+      case 'C': output = COORD_CELESTIAL; break;
+      case 'G': output = COORD_GALACTIC; break;
+      case 'E': output = COORD_ECLIPTIC; break;
+      default: goto syntax;
+    }
+  }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/fitplx.c

-              r36489
+              r37822
   /* project coordinates to a plane centered on the object with units of arcsec */
   Coords coords;
+  InitCoords (&coords, "DEC--SIN");
   coords.crval1 = Rmean;
   coords.crval2 = Dmean;
-  coords.crpix1 = 0;
-  coords.crpix2 = 0;
   coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
-  coords.pc1_1  = coords.pc2_2 = 1.0;
-  coords.pc1_2  = coords.pc2_1 = 0.0;
-  coords.Npolyterms = 1;
-  strcpy (coords.ctype, "DEC--SIN");
   double *X, *Y, *t, *pX, *pY, *dX, *dY;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/fitpm.c

-              r36489
+              r37822
   /* project coordinates to a plane centered on the object with units of arcsec */
   Coords coords;
+  InitCoords (&coords, "DEC--SIN");
   coords.crval1 = Rmean;
   coords.crval2 = Dmean;
-  coords.crpix1 = 0;
-  coords.crpix2 = 0;
   coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
-  coords.pc1_1  = coords.pc2_2 = 1.0;
-  coords.pc1_2  = coords.pc2_1 = 0.0;
-  coords.Npolyterms = 1;
-  strcpy (coords.ctype, "DEC--SIN");
   double *X, *Y, *t, *dX, *dY;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/gauss.c

-              r36679
+              r37822
   if (!GetImageData (&data, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   Nborder = 3;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/getcoords.c

r34345	r37822
54	54	if (!strcmp(&coords.ctype[4], "-WRP")) {
55	55	if (MOSAIC == NULL) {
56		gprint (GP_ERR, "must supply mosaic for WRP coords\n");
	56	gprint (GP_ERR, "must supply mosaic for WRP coords with -mosaic [buffer]\n");
57	57	return (FALSE);
58	58	}
…	…
65	65	}
66	66	GetCoords (&moscoords, &mosbuffer[0].header);
67		~~RegisterMosaic (&moscoords)~~;
	67	coords.mosaic = &moscoords;
68	68	}
69	69

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/init.c

-              r36489
+              r37822
 int times                   PROTO((int, char **));
 int transform               PROTO((int, char **));
+int vshimage                PROTO((int, char **));
+int shimage                 PROTO((int, char **));
 static Command cmds[] = {
 …
   {1, "star",        star,         "star stats at rough coords"},
   {1, "transform",   transform,    "geometric transformation of image"},
+  {1, "vshimage",    vshimage,     "generate images for vector spherical harmonic terms"},
+  {1, "shimage",     shimage,      "generate images for spherical harmonic terms"},
 };

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/objload.c

-              r34088
+              r37822
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   Objtype = 0;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.astro/region.c

-              r36489
+              r37822
   if (!GetGraph (&graphmode, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   NoClear = FALSE;
 …
   if (!ohana_str_to_radec (&Ra, &Dec, argv[1], argv[2])) return (FALSE);
   Radius = atof (argv[3]);
+  strcpy (graphmode.coords.ctype, "DEC--TAN");
+  InitCoords (&graphmode.coords, "DEC--TAN");
   if (argc == 5) {
     if (!strcasecmp (argv[4], "TAN"))
 …
       strcpy (graphmode.coords.ctype, "DEC--PAR");
+  }
+  graphmode.coords.crval1 = Ra;
+  graphmode.coords.crval2 = Dec;
+  graphmode.coords.pc1_1 = (graphmode.flipeast) ? -1 : 1;
+  graphmode.coords.pc2_2 = (graphmode.flipnorth) ? -1 : 1;
   /* ask kapa for coordinate limits, to get the right aspect ratio */
   KapaGetLimits (kapa, &dx, &dy);
 …
   set_int_variable ("NORTH_UP", !graphmode.flipnorth);
-  graphmode.coords.pc1_1 = (graphmode.flipeast) ? -1 : 1;
-  graphmode.coords.pc2_2 = (graphmode.flipnorth) ? -1 : 1;
-  graphmode.coords.pc1_2 = graphmode.coords.pc2_1 = 0.0;
-  graphmode.coords.crval1 = Ra;
-  graphmode.coords.crval2 = Dec;
-  graphmode.coords.crpix1 = 0.0;
-  graphmode.coords.crpix2 = 0.0;
-  graphmode.coords.cdelt1 = graphmode.coords.cdelt2 = 1.0;
   if (!NoClear) KapaClearSections (kapa);
   KapaSetLimits (kapa, &graphmode);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/Makefile

-              r37049
+              r37822
 $(SRC)/densify.$(ARCH).o        \
 $(SRC)/device.$(ARCH).o \
+$(SRC)/dft2d.$(ARCH).o  \
 $(SRC)/dimendown.$(ARCH).o      \
 $(SRC)/dimenup.$(ARCH).o        \
 …
 $(SRC)/vstats.$(ARCH).o            \
 $(SRC)/xsection.$(ARCH).o          \
+$(SRC)/vsh.$(ARCH).o       \
+$(SRC)/vshfit.$(ARCH).o    \
+$(SRC)/shterms.$(ARCH).o           \
+$(SRC)/shfit.$(ARCH).o     \
+$(SRC)/shdot.$(ARCH).o     \
+$(SRC)/shapply.$(ARCH).o           \
 $(SRC)/wd.$(ARCH).o                \
 $(SRC)/write_vectors.$(ARCH).o     \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/center.c

-              r29540
+              r37822
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   // XXX need an option to center the image based on the current plot limits

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/dimenup.c

-              r20936
+              r37822
     return (FALSE);
+  }
+  gfits_free_matrix (&buf[0].matrix);
+  gfits_free_header (&buf[0].header);
+  CreateBuffer (buf, Nx, Ny, -32, 0.0, 1.0);
+  ResetBuffer (buf, Nx, Ny, -32, 0.0, 1.0);
   out = (float *) buf[0].matrix.buffer;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/erase.c

-              r13479
+              r37822
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   if (argc < 2) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/fit2d.c

r31160	r37822
138	138	y = yvec[0].elements.Flt;
139	139	z = zvec[0].elements.Flt;
	140	if (Weight) dz = dzvec[0].elements.Flt;
	141
140	142	for (i = 0; i < xvec[0].Nelements; i++, x++, y++, z++) {
141	143	if (mask[i]) continue;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/init.c

-              r37049
+              r37822
 # include "data.h"
+// XXX adding a comment
 int accum            PROTO((int, char **));
 …
 int densify          PROTO((int, char **));
 int device           PROTO((int, char **));
+int dft2d            PROTO((int, char **));
 int dimendown        PROTO((int, char **));
 int dimenup          PROTO((int, char **));
 …
 int vpop             PROTO((int, char **));
 int vsmooth          PROTO((int, char **));
+int vsh              PROTO((int, char **));
+int vshfit           PROTO((int, char **));
+int shterms          PROTO((int, char **));
+int shfit            PROTO((int, char **));
+int shdot            PROTO((int, char **));
+int shapply          PROTO((int, char **));
 int wd               PROTO((int, char **));
 int write_vectors    PROTO((int, char **));
 …
   {1, "densify",      densify,          "create an image histogram from a set of vectors"},
   {1, "device",       device,           "set / get current graphics device"},
+  {1, "dft2d",        dft2d,            "2D discrete fourier transform"},
   {1, "dimendown",    dimendown,        "convert image to vector"},
   {1, "dimenup",      dimenup,          "convert vector to image"},
 …
   {1, "vstats",       vstats,           "statistics on a vector"},
   {1, "vzload",       vzload,           "load vectors as overlay on image display (scaled points)"},
+  {1, "vsh",          vsh,              "Vector Spherical Harmonics"},
+  {1, "vshfit",       vshfit,           "Vector Spherical Harmonics fits"},
+  {1, "shterms",      shterms,          "Spherical Harmonics terms"},
+  {1, "shfit",        shfit,            "Spherical Harmonics fits"},
+  {1, "shdot",        shdot,            "Spherical Harmonics dot product"},
+  {1, "shapply",      shapply,          "Spherical Harmonics fit application"},
   {1, "wd",           wd,               "write an image to a file"},
   {1, "write",        write_vectors,    "write vectors to datafile"},

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/load.c

-              r34088
+              r37822
   if (!GetImageData (&data, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   ISCEL = FALSE;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/point.c

-              r15620
+              r37822
   if (!GetImageData (&data, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   celestial = FALSE;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/read_vectors.c

-              r37049
+              r37822
 void read_vectors_cleanup ();
+int read_table_sizes (Header *header);
 int datafile (int argc, char **argv) {
 …
   off_t Nbytes;
   int i, j, N, Nextend, Ny, Binary, vecType, padIfShort;
   char type[16], ID[80], *CCDKeyword;
+  int i, j, N, Ny, Binary, vecType;
+  char type[16], ID[80];
   FTable table;
   Header header;
   Vector **vec;
-  int FITS_TRANSPOSE;
   table.buffer = NULL;
   header.buffer = NULL;
   FITS_TRANSPOSE = FALSE;
+  int FITS_TRANSPOSE = FALSE;
   if ((N = get_argument (argc, argv, "-transpose"))) {
     remove_argument (N, &argc, argv);
 …
+  }
   CCDKeyword = NULL;
+  char *CCDKeyword = NULL;
   if ((N = get_argument (argc, argv, "-keyword"))) {
     remove_argument (N, &argc, argv);
 …
+  }
   padIfShort = FALSE;
+  int padIfShort = FALSE;
   if ((N = get_argument (argc, argv, "-pad-if-short"))) {
     remove_argument (N, &argc, argv);
 …
+  }
+  Nextend = -1;
+  int getSizes = FALSE;
+  if ((N = get_argument (argc, argv, "-sizes"))) {
+    remove_argument (N, &argc, argv);
+    getSizes = TRUE;
+  }
+  int Nextend = -1;
   if ((N = get_argument (argc, argv, "-extnum"))) {
     remove_argument (N, &argc, argv);
     Nextend = atoi (extname);
+  }
+  int start = 0;
+  int Nrows = -1; // -1 : read entire table
+  if ((N = get_argument (argc, argv, "-range"))) {
+    remove_argument (N, &argc, argv);
+    start = atoi (argv[N]);
+    remove_argument (N, &argc, argv);
+    Nrows = atoi (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  // if CharAsVectors, char fields will be saved as vectors NAME:0 -- NAME:n for n characters
+  // else char fields will be saved as $NAME:0 - $NAME:m for m rows
+  // if (Ny > 10000), force CharAsVectors
+  int CharAsVectors = FALSE;
+  if ((N = get_argument (argc, argv, "-char-vectors"))) {
+    remove_argument (N, &argc, argv);
+    CharAsVectors = TRUE;
+  }
 …
+    }
     if (!gfits_load_header (f, &header)) ESCAPE ("error reading header for extension %d\n", Nextend);
+    if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension %d\n", Nextend);
+    if (getSizes) {
+      read_table_sizes (&header);
+      if (CCDKeyword != NULL) free (CCDKeyword);
+      gfits_free_header (&header);
+      return TRUE;
+    }
+    if (Nrows == -1) {
+      Nrows = header.Naxis[1] - start;
+    }
+    if (start < 0) ESCAPE ("invalid range: start < 0\n");
+    if (start >= header.Naxis[1]) ESCAPE ("invalid range: start >= Ny (%d)\n", header.Naxis[1]);
+    if (Nrows < 0) ESCAPE ("invalid range: Nrows < 0\n");
+    if (start + Nrows > header.Naxis[1]) ESCAPE ("invalid range: start + Nrows > Ny (%d)\n", header.Naxis[1]);
+    // Ny = 100, start = 0, Nrows = -1 -> Nrows => 100
+    // Ny = 100, start = 10, Nrows = 90
+    if (!gfits_fread_ftable_range (f, padIfShort, &table, start, Nrows)) ESCAPE ("error reading table for extension %d\n", Nextend);
   } else {
     if (CCDKeyword == NULL) {
 …
         continue;
+      }
+      if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension\n");
+      if (Nrows == -1) {
+        Nrows = header.Naxis[1] - start;
+      }
+      if (start < 0) ESCAPE ("invalid range: start < 0\n");
+      if (start >= header.Naxis[1]) ESCAPE ("invalid range: start >= Ny (%d)\n", header.Naxis[1]);
+      if (Nrows < 0) ESCAPE ("invalid range: Nrows < 0\n");
+      if (start + Nrows > header.Naxis[1]) ESCAPE ("invalid range: start + Nrows > Ny (%d)\n", header.Naxis[1]);
+      if (!gfits_fread_ftable_range (f, padIfShort, &table, start, Nrows)) ESCAPE ("error reading table for extension %d\n", Nextend);
+      // if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension\n");
       break;
+    }
 …
     if (!FITS_TRANSPOSE) {
       // read string column into a list rather than a vector
       if (!strcmp (type, "char")) {
+      if (!strcmp (type, "char") && !CharAsVectors && (Ny < 3000)) {
         char *fieldName = argv[i];
         char *Ptr = data;
 …
   if (vec) free (vec);
+}
+// read -fits foo -sizes -- Nx, Ny, Nfields -> $table:Nx, $table:Ny, $table:$Nfields
+// read -fits foo -fields
+int read_table_sizes (Header *header) {
+  int Nfields;
+  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
+  set_int_variable ("table:Nx", header->Naxis[0]);
+  set_int_variable ("table:Nx", header->Naxis[0]);
+  set_int_variable ("table:Nfields", Nfields);
+  return TRUE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/relocate.c

-              r27435
+              r37822
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   if (argc != 3) {
     gprint (GP_ERR, "USAGE: relocate x y [-n]\n");

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/resize.c

-              r29938
+              r37822
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   if ((N = get_argument (argc, argv, "-by-image"))) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/save.c

-              r13479
+              r37822
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   celestial = FALSE;
   if ((N = get_argument (argc, argv, "-c"))) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/tv.c

-              r35757
+              r37822
   if (!GetImage (&data, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    remove_argument (N, &argc, argv);
+    channel = GetKapaChannelFromString (argv[N]);
+    remove_argument (N, &argc, argv);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   /* shell exits on pipe close, FIX */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/tvchannel.c

-              r16038
+              r37822
+  }
+  Nchannel = atoi (argv[1]);
+  Nchannel = GetKapaChannelFromString (argv[1]);
+  if (!Nchannel) return FALSE;
+  KiiSetChannel (kapa, Nchannel - 1);
+  return (TRUE);
+}
+int GetKapaChannelFromString (char *string) {
+  int Nchannel = atoi (string);
   if (Nchannel == 0) {
     // try the string values R/Red, G/Green, B/Blue
     if (!strcasecmp (argv[1], "R") || !strcasecmp (argv[1], "RED")) {
+    if (!strcasecmp (string, "R") || !strcasecmp (string, "RED")) {
       Nchannel = 1;
+    }
     if (!strcasecmp (argv[1], "G") || !strcasecmp (argv[1], "GREEN")) {
+    if (!strcasecmp (string, "G") || !strcasecmp (string, "GREEN")) {
       Nchannel = 2;
+    }
     if (!strcasecmp (argv[1], "B") || !strcasecmp (argv[1], "BLUE")) {
+    if (!strcasecmp (string, "B") || !strcasecmp (string, "BLUE")) {
       Nchannel = 3;
+    }
+  }
+  if ((Nchannel < 1) || (Nchannel > 3)) {
+    gprint (GP_ERR, "invalid channel : use 1 - 3 or (R)ed, (G)reen, (B)lue\n");
+    return (FALSE);
+  if ((Nchannel < 1) || (Nchannel > 10)) {
+    gprint (GP_ERR, "invalid channel : use 1 - 10 or (R)ed, (G)reen, (B)lue\n");
+    gprint (GP_ERR, "   (R)ed, (G)reen, (B)lue == (1,2,3)\n");
+    return (0);
+  }
+  KiiSetChannel (kapa, Nchannel - 1);
+  return (TRUE);
+  return Nchannel;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/tvcontour.c

-              r13479
+              r37822
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   if ((argc != 4) && (argc != 5)) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/tvgrid.c

-              r13479
+              r37822
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   if (argc != 3) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/vload.c

-              r20936
+              r37822
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   type = KII_OVERLAY_BOX;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/cmd.data/vzload.c

-              r20936
+              r37822
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   MAX_OUTPUT_SIZE = 10.0;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/Makefile

r37049	r37822
46	46	$(SRC)/badimages.$(ARCH).o \
47	47	$(SRC)/catdir.$(ARCH).o \
	48	$(SRC)/catname.$(ARCH).o \
48	49	$(SRC)/cmatch.$(ARCH).o \
49	50	$(SRC)/cmpload.$(ARCH).o \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/avextract.c

-              r37049
+              r37822
   off_t i, j, n, m;
   int N, Npts, NPTS, last, next, state, Nfields, Nreturn, Ncstack, Nstack;
   int Nsecfilt, VERBOSE, needMeasures;
+  int Nsecfilt, VERBOSE;
   char **cstack, name[1024];
   void *Signal;
 …
   // this does all the work of re-packaging the command, calling it on the remote machines, then loading in the results
   if (PARALLEL && !HOST_ID) {
       int status = HostTableParallelOps (skylist, argc, argv, RESULT_FILE, TRUE, 0, VERBOSE);
+    int status = HostTableParallelOps (skylist, argc, argv, RESULT_FILE, TRUE, 0, VERBOSE);
     dbFreeFields (fields, Nfields);
 …
+  }
+  // check the requested fields : are all average/secfilt entries, or do we need measures?
+  needMeasures = FALSE;
+  for (i = 0; !needMeasures && (i < Nfields); i++) {
+    if (fields[i].photcode == NULL) continue; // non-measure fields do not have a photcode
+    if (fields[i].photcode[0].type == PHOT_REF) needMeasures = TRUE;
+    if (fields[i].photcode[0].type == PHOT_DEP) needMeasures = TRUE;
+  }
+  // check the requested fields
+  int needMeasure = dbFieldNeedMeasure (fields, Nfields);
+  int needLensobj = dbFieldNeedLensobj (fields, Nfields);
+  int needStarpar = dbFieldNeedStarpar (fields, Nfields, TRUE);
   // grab data from all selected sky regions
 …
     catalog.filename = (HOST_ID || PARALLEL_LOCAL) ? hostfile : skylist[0].filename[i];
     catalog.catflags = LOAD_AVES | LOAD_SECF;
+    catalog.catflags |= needMeasures ? LOAD_MEAS : SKIP_MEAS;
+    catalog.catflags |= needMeasure ? LOAD_MEAS : SKIP_MEAS;
+    catalog.catflags |= needLensobj ? LOAD_LENSOBJ : SKIP_LENSOBJ;
+    catalog.catflags |= needStarpar ? LOAD_STARPAR : SKIP_STARPAR;
     catalog.Nsecfilt = 0;
 …
       // XXX for measure values, this could be optimized for one loop over measures...
-      m = catalog.average[j].measureOffset;
       dbExtractAveragesInitAve ();  // reset counters for saved fields (costs very little)
+      Average *average = &catalog.average[j];
+      m = average->measureOffset;
+      Measure *measure = needMeasure ? &catalog.measure[m] : NULL;
+      m = average->lensobjOffset;
+      Lensobj *lensobj = needLensobj ? &catalog.lensobj[m] : NULL;
+      m = average->starparOffset;
+      StarPar *starpar = needStarpar ? &catalog.starpar[m] : NULL;
+      m = j*Nsecfilt;
+      SecFilt *secfilt = &catalog.secfilt[m];
       for (n = 0; n < Nfields; n++) {
         values[n] = dbExtractAverages (&catalog.average[j], &catalog.secfilt[j*Nsecfilt], &catalog.measure[m], &fields[n]);
+        values[n] = dbExtractAverages (average, secfilt, measure, lensobj, starpar, &fields[n]);
+      }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/avmatch.c

-              r37049
+              r37822
+  }
+  // check the requested fields : are all average/secfilt entries, or do we need measures?
+  int needMeasures = FALSE;
+  for (i = 0; !needMeasures && (i < Nfields); i++) {
+    if (fields[i].photcode == NULL) continue; // assert this?
+    if (fields[i].photcode[0].type == PHOT_REF) needMeasures = TRUE;
+    if (fields[i].photcode[0].type == PHOT_DEP) needMeasures = TRUE;
+  }
+  // check the requested fields
+  int needMeasure = dbFieldNeedMeasure (fields, Nfields);
+  int needLensobj = dbFieldNeedLensobj (fields, Nfields);
+  int needStarpar = dbFieldNeedStarpar (fields, Nfields, TRUE);
   /* create output storage vectors */
 …
     catalog.filename = HOST_ID ? hostfile : skylist[0].filename[i];
     catalog.catflags = LOAD_AVES | LOAD_SECF;
+    catalog.catflags |= needMeasures ? LOAD_MEAS : SKIP_MEAS;
+    catalog.catflags |= needMeasure ? LOAD_MEAS    : SKIP_MEAS;
+    catalog.catflags |= needLensobj ? LOAD_LENSOBJ : SKIP_LENSOBJ;
+    catalog.catflags |= needStarpar ? LOAD_STARPAR : SKIP_STARPAR;
     catalog.Nsecfilt = 0;
 …
       if (Ncat == -2) continue; // no matches to this point
+      m = catalog.average[Ncat].measureOffset;
+      m = Ncat;
+      Average *average = &catalog.average[m];
+      m = average->measureOffset;
+      Measure *measure = needMeasure ? &catalog.measure[m] : NULL;
+      m = average->lensobjOffset;
+      Lensobj *lensobj = needLensobj ? &catalog.lensobj[m] : NULL;
+      m = average->starparOffset;
+      StarPar *starpar = needStarpar ? &catalog.starpar[m] : NULL;
+      m = Ncat*Nsecfilt;
+      SecFilt *secfilt = &catalog.secfilt[m];
       // reset counters for saved fields, extract fields
       dbExtractAveragesInitAve ();
       for (n = 0; n < Nfields; n++) {
         values[n] = dbExtractAverages (&catalog.average[Ncat], &catalog.secfilt[Ncat*Nsecfilt], &catalog.measure[m], &fields[n]);
+        values[n] = dbExtractAverages (average, secfilt, measure, lensobj, starpar, &fields[n]);
+      }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/cmpload.c

-              r34088
+              r37822
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  int channel = 0;
+  if ((N = get_argument (argc, argv, "-ch"))) {
+    channel = GetKapaChannelFromString (argv[N]);
+    if (!channel) return FALSE;
+    KiiSetChannel (kapa, channel - 1);
+  }
   Objtype = 0;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/dvo_host_utils.c

r35416	r37822
137	137
138	138	// determine the sky region
	139	// XXX EAM 20141230 : this needs to respect the -region selection
139	140	double Rmin, Rmax, Dmin, Dmax;
140	141	get_skyregion (&Rmin, &Rmax, &Dmin, &Dmax);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/find_matches.c

-              r36489
+              r37822
    * far from the projection pole. We use the center of the region (catalog) for crval1,2.
    */
+  InitCoords (&tcoords, "DEC--ARC");
   tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
   if (region[0].Dmax < 90) {
 …
     tcoords.crval2 = 90.0;
+  }
-  tcoords.crpix1 = 0;
-  tcoords.crpix2 = 0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-  tcoords.Npolyterms = 1;
-  strcpy (tcoords.ctype, "DEC--ARC");
   // this region includes a boundary layer of size RADIUS

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/gimages.c

-              r36489
+              r37822
   if ((image = LoadImagesDVO (&Nimage)) == NULL) return (FALSE);
   image_subset (image, Nimage, &subset, &Nsubset, selection, tzero, trange, TimeSelect);
   BuildChipMatch (image, Nimage);
+  // BuildChipMatch (image, Nimage);
   int DistortImage = wordhash ("-DIS");
 …
+      }
+    }
-    if (!FindMosaicForImage (image, Nimage, i)) continue;
     typehash = wordhash (&image[i].coords.ctype[4]);
 …
       if (fabs(Ro - Ra) > 120.0) continue;
+      InitCoords (&local, "DEC--TAN");
       local.crval1 = Ro;
       local.crval2 = Do;
-      local.crpix1 = local.crpix2 = 0.0;
       local.cdelt1 = local.cdelt2 = 1.0/3600.0;
-      local.pc1_1 = local.pc2_2 = 1.0;
-      local.pc2_1 = local.pc1_2 = 0.0;
-      local.Npolyterms = 1;
-      strcpy (local.ctype, "DEC--TAN");
       if (typehash == DistortImage) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/gstar.c

-              r37049
+              r37822
   GSTAR_STACK_FLUX_KRON,
   GSTAR_STACK_FLUX_KRON_ERR,
+  GSTAR_STACK_FLUX_APER,
+  GSTAR_STACK_FLUX_APER_ERR,
+  GSTAR_WARP_FLUX_PSF,
+  GSTAR_WARP_FLUX_PSF_ERR,
+  GSTAR_WARP_FLUX_KRON,
+  GSTAR_WARP_FLUX_KRON_ERR,
+  GSTAR_WARP_FLUX_APER,
+  GSTAR_WARP_FLUX_APER_ERR,
+  GSTAR_STACK_MAG_PSF,
+  GSTAR_STACK_MAG_PSF_ERR,
+  GSTAR_STACK_MAG_KRON,
+  GSTAR_STACK_MAG_KRON_ERR,
+  GSTAR_STACK_MAG_APER,
+  GSTAR_STACK_MAG_APER_ERR,
+  GSTAR_WARP_MAG_PSF,
+  GSTAR_WARP_MAG_PSF_ERR,
+  GSTAR_WARP_MAG_KRON,
+  GSTAR_WARP_MAG_KRON_ERR,
+  GSTAR_WARP_MAG_APER,
+  GSTAR_WARP_MAG_APER_ERR,
 } GSTAR_SECF_CODES;
 …
 void sort_index_float (float *X, int *IDX, int N) {
 # define SWAPFUNC(A,B){ float tmp; int itmp;    \
   tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
   itmp = IDX[A]; IDX[A] = IDX[B]; IDX[B] = itmp; \
+}
+# define SWAPFUNC(A,B){ float tmp; int itmp;            \
+    tmp = X[A]; X[A] = X[B]; X[B] = tmp;                \
+    itmp = IDX[A]; IDX[A] = IDX[B]; IDX[B] = itmp;      \
+  }
 # define COMPARE(A,B)(X[A] < X[B])
 …
   off_t i, Nstars, *N1;
   off_t j, k, m, N, Nlo, Nhi;
   int Nsecfilt, NPTS, QUIET, FULL_OUTPUT, STACK_OUTPUT, INST, SHOW_MASKS;
+  int Nsecfilt, NPTS, QUIET, INST, SHOW_MASKS;
   int found, GetMeasures;
   int SaveVectors;
 …
+  }
   FULL_OUTPUT = FALSE;
+  int FULL_OUTPUT = FALSE;
   if ((N = get_argument (argc, argv, "-full"))) {
     FULL_OUTPUT = TRUE;
 …
+  }
   STACK_OUTPUT = FALSE;
   if ((N = get_argument (argc, argv, "-stack"))) {
+  int STACK_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+stack"))) {
     STACK_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  int EXTRA_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+extras"))) {
+    EXTRA_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  int WARP_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+warp"))) {
+    WARP_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  int FLUX_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+flux"))) {
+    FLUX_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  int MAG_OUTPUT = TRUE;
+  if ((N = get_argument (argc, argv, "-mag"))) {
+    MAG_OUTPUT = FALSE;
+    remove_argument (N, &argc, argv);
+  }
+  int KRON_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+kron"))) {
+    KRON_OUTPUT = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  int APER_OUTPUT = FALSE;
+  if ((N = get_argument (argc, argv, "+aper"))) {
+    APER_OUTPUT = TRUE;
     remove_argument (N, &argc, argv);
+  }
 …
   // an error exit status here is a significant error
   if (!dvo_catalog_open (&catalog, NULL, FALSE, "r")) {
       fprintf (stderr, "ERROR: failure to open catalog file %s\n", catalog.filename);
       exit (2);
+    fprintf (stderr, "ERROR: failure to open catalog file %s\n", catalog.filename);
+    exit (2);
+  }
   dvo_catalog_unlock (&catalog);
 …
       k = N1[i];
       if (!QUIET) {
         gprint (GP_LOG, "star: "OFF_T_FMT"\n",  i);
+        gprint (GP_LOG, "star: "OFF_T_FMT"\n",  k);
         gprint (GP_LOG, "%11.7f ", catalog.average[k].R);
         gprint (GP_LOG, "%11.7f ", catalog.average[k].D);
 …
         if (FULL_OUTPUT) {
             gprint (GP_LOG, "%f ",     catalog.average[k].dR);
             gprint (GP_LOG, "%f ",     catalog.average[k].dD);
             gprint (GP_LOG, "%f ",     catalog.average[k].uR);
             gprint (GP_LOG, "%f ",     catalog.average[k].uD);
             gprint (GP_LOG, "%f ",     catalog.average[k].duR);
             gprint (GP_LOG, "%f ",     catalog.average[k].duD);
             gprint (GP_LOG, "%f ",     catalog.average[k].P);
             gprint (GP_LOG, "%f   ",     catalog.average[k].dP);
             gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPM);
             gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPar);
             date = ohana_sec_to_date (catalog.average[k].Tmean);
             gprint (GP_LOG, "%20s ",     date);
             gprint (GP_LOG, "%f   ",     catalog.average[k].Trange / 86400.0);
+          gprint (GP_LOG, "%f ",     catalog.average[k].dR);
+          gprint (GP_LOG, "%f ",     catalog.average[k].dD);
+          gprint (GP_LOG, "%f ",     catalog.average[k].uR);
+          gprint (GP_LOG, "%f ",     catalog.average[k].uD);
+          gprint (GP_LOG, "%f ",     catalog.average[k].duR);
+          gprint (GP_LOG, "%f ",     catalog.average[k].duD);
+          gprint (GP_LOG, "%f ",     catalog.average[k].P);
+          gprint (GP_LOG, "%f   ",     catalog.average[k].dP);
+          gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPM);
+          gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPar);
+          date = ohana_sec_to_date (catalog.average[k].Tmean);
+          gprint (GP_LOG, "%20s ",     date);
+          gprint (GP_LOG, "%f   ",     catalog.average[k].Trange / 86400.0);
+        }
         gprint (GP_LOG, "\n");
+        gprint (GP_LOG, "\n\n");
         /* filter names */
+        gprint (GP_LOG, "filter     : ");
         for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_FILTER_NAMES);
         gprint (GP_LOG, "\n");
         /* average mags */
+        gprint (GP_LOG, "chp_psf_ave: ");
         for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG);
         gprint (GP_LOG, "\n");
         /* average mag errors */
+        gprint (GP_LOG, "chp_psf_err: ");
         for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_ERR);
         gprint (GP_LOG, "\n");
         /* average mag chisq */
+        gprint (GP_LOG, "chp_psf_chi: ");
         for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_CHISQ);
         gprint (GP_LOG, "\n");
+        if (FULL_OUTPUT) {
+        if (APER_OUTPUT) {
           /* Map */
+          gprint (GP_LOG, "chp_ap__ave: ");
           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_AP_MAG);
           gprint (GP_LOG, "\n");
+        }
+        if (KRON_OUTPUT) {
           /* Mkron */
+          gprint (GP_LOG, "chp_krn_ave: ");
           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_KRON_MAG);
           gprint (GP_LOG, "\n");
           /* dMkron */
+          gprint (GP_LOG, "chp_krn_err: ");
           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_KRON_MAG_ERR);
           gprint (GP_LOG, "\n");
+        }
+        if (EXTRA_OUTPUT) {
           /* Mmin */
+          gprint (GP_LOG, "chp_psf_min: ");
           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MIN);
           gprint (GP_LOG, "\n");
           /* Mmax */
+          gprint (GP_LOG, "chp_psf_max: ");
           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MAX);;
           gprint (GP_LOG, "\n");
           /* UCDIST */
+          gprint (GP_LOG, "ubercal_dst: ");
           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_UCDIST);;
           gprint (GP_LOG, "\n");
           /* secfilt flags */
+          gprint (GP_LOG, "filtflags:   ");
           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_SECF_FLAGS);
           gprint (GP_LOG, "\n");
+        }
         if (STACK_OUTPUT) {
+        if (STACK_OUTPUT && MAG_OUTPUT) {
           /* FluxPSF */
+          gprint (GP_LOG, "stk_psf_ave: ");
+          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_PSF);
+          gprint (GP_LOG, "\n");
+          /* dFluxPSF */
+          gprint (GP_LOG, "stk_psf_err: ");
+          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_PSF_ERR);
+          gprint (GP_LOG, "\n");
+          if (KRON_OUTPUT) {
+            /* MagKron */
+            gprint (GP_LOG, "stk_krn_ave: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_KRON);
+            gprint (GP_LOG, "\n");
+            /* dMagKron */
+            gprint (GP_LOG, "stk_krn_err: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_KRON_ERR);
+            gprint (GP_LOG, "\n");
+          }
+          if (APER_OUTPUT) {
+            /* MagAper */
+            gprint (GP_LOG, "stk_ap__ave: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_APER);
+            gprint (GP_LOG, "\n");
+            /* dMagAper */
+            gprint (GP_LOG, "stk_ap__err: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_APER_ERR);
+            gprint (GP_LOG, "\n");
+          }
+        }
+        if (WARP_OUTPUT && MAG_OUTPUT) {
+          /* FluxPSF */
+          gprint (GP_LOG, "wrp_psf_ave: ");
+          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_PSF);
+          gprint (GP_LOG, "\n");
+          /* dFluxPSF */
+          gprint (GP_LOG, "wrp_psf_err: ");
+          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_PSF_ERR);
+          gprint (GP_LOG, "\n");
+          if (KRON_OUTPUT) {
+            /* MagKron */
+            gprint (GP_LOG, "wrp_krn_ave: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_KRON);
+            gprint (GP_LOG, "\n");
+            /* dMagKron */
+            gprint (GP_LOG, "wrp_krn_err: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_KRON_ERR);
+            gprint (GP_LOG, "\n");
+          }
+          if (APER_OUTPUT) {
+            /* MagAper */
+            gprint (GP_LOG, "wrp_ap__ave: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_APER);
+            gprint (GP_LOG, "\n");
+            /* dMagAper */
+            gprint (GP_LOG, "wrp_ap__err: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_APER_ERR);
+            gprint (GP_LOG, "\n");
+          }
+        }
+        if (STACK_OUTPUT && FLUX_OUTPUT) {
+          /* FluxPSF */
+          gprint (GP_LOG, "stk_psf_ave: ");
           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_PSF);
           gprint (GP_LOG, "\n");
           /* dFluxPSF */
+          gprint (GP_LOG, "stk_psf_err: ");
           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_PSF_ERR);
           gprint (GP_LOG, "\n");
+          /* FluxKron */
+          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON);
+          gprint (GP_LOG, "\n");
+          /* dFluxKron */
+          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON_ERR);
+          gprint (GP_LOG, "\n");
+          if (KRON_OUTPUT) {
+            /* FluxKron */
+            gprint (GP_LOG, "stk_krn_ave: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON);
+            gprint (GP_LOG, "\n");
+            /* dFluxKron */
+            gprint (GP_LOG, "stk_krn_err: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON_ERR);
+            gprint (GP_LOG, "\n");
+          }
+          if (APER_OUTPUT) {
+            /* FluxAper */
+            gprint (GP_LOG, "stk_ap_ave: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_APER);
+            gprint (GP_LOG, "\n");
+            /* dFluxAper */
+            gprint (GP_LOG, "stk_ap_err: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_APER_ERR);
+            gprint (GP_LOG, "\n");
+          }
+        }
+      }
+        if (WARP_OUTPUT && FLUX_OUTPUT) {
+          /* FluxPSF */
+          gprint (GP_LOG, "wrp_psf_ave: ");
+          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_PSF);
+          gprint (GP_LOG, "\n");
+          /* dFluxPSF */
+          gprint (GP_LOG, "wrp_psf_ave: ");
+          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_PSF_ERR);
+          gprint (GP_LOG, "\n");
+          if (KRON_OUTPUT) {
+            /* FluxKron */
+            gprint (GP_LOG, "wrp_krn_ave: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_KRON);
+            gprint (GP_LOG, "\n");
+            /* dFluxKron */
+            gprint (GP_LOG, "wrp_krn_err: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_KRON_ERR);
+            gprint (GP_LOG, "\n");
+          }
+          if (APER_OUTPUT) {
+            /* FluxAper */
+            gprint (GP_LOG, "wrp_ap__ave: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_APER);
+            gprint (GP_LOG, "\n");
+            /* dFluxAper */
+            gprint (GP_LOG, "wrp_ap__err: ");
+            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_APER_ERR);
+            gprint (GP_LOG, "\n");
+          }
+        }
+      }
+      gprint (GP_LOG, "\n");
       if (GetMeasures || SaveVectors) {
 …
             if (FULL_OUTPUT) {
                 gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mcal);
                 gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Map);
                 gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mkron);
                 gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].dMkron);
                 gprint (GP_LOG, "%5.1f ", pow(10.0, 0.4*catalog.measure[Nv].dt));
                 gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].airmass);
                 gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].az);
                 gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Xccd);
                 gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Yccd);
                 gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dXccd));
                 gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dYccd));
                 gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Sky);
                 gprint (GP_LOG, "%5.1f ", catalog.measure[Nv].dSky);
                 gprint (GP_LOG, "%8d ", catalog.measure[Nv].averef);
                 gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].detID);
                 gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].imageID);
                 gprint (GP_LOG, "%.3f ", catalog.measure[Nv].psfQF);
                 gprint (GP_LOG, "%.1f ", catalog.measure[Nv].psfChisq);
                 gprint (GP_LOG, "%.1f ", catalog.measure[Nv].crNsigma);
                 gprint (GP_LOG, "%.1f ", catalog.measure[Nv].extNsigma);
                 gprint (GP_LOG, "%.1f ", FromShortDegrees(catalog.measure[Nv].theta));
+              gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mcal);
+              gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Map);
+              gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mkron);
+              gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].dMkron);
+              gprint (GP_LOG, "%5.1f ", pow(10.0, 0.4*catalog.measure[Nv].dt));
+              gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].airmass);
+              gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].az);
+              gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Xccd);
+              gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Yccd);
+              gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dXccd));
+              gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dYccd));
+              gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Sky);
+              gprint (GP_LOG, "%5.1f ", catalog.measure[Nv].dSky);
+              gprint (GP_LOG, "%8d ", catalog.measure[Nv].averef);
+              gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].detID);
+              gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].imageID);
+              gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].psfQF);
+              gprint (GP_LOG, "%7.1f ", catalog.measure[Nv].psfChisq);
+              // gprint (GP_LOG, "%3.1f ", catalog.measure[Nv].crNsigma);
+              gprint (GP_LOG, "%4.1f ", catalog.measure[Nv].extNsigma);
+              gprint (GP_LOG, "%5.1f ", FromShortDegrees(catalog.measure[Nv].theta));
+            }
             if (STACK_OUTPUT) {
                 gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxPSF);
                 gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxPSF);
                 gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxKron);
                 gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxKron);
+            if (FLUX_OUTPUT) {
+              gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxPSF);
+              gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxPSF);
+              gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxKron);
+              gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxKron);
+            }
             gprint (GP_LOG, "\n");
 …
   switch (type) {
     case GSTAR_AVE_MAG: /* average mags */
       if (seq == -1) {
         print_double (NAN);
       } else {
         print_double (secfilt[seq].M);
+      }
       break;
     case GSTAR_AVE_MAG_ERR: /* average mags errors */
       if (seq == -1) {
         print_double (NAN);
       } else {
         print_double (secfilt[seq].dM);
+    case GSTAR_AVE_MAG_MIN: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].Mmin);
+      }
+      break;
+    case GSTAR_AVE_MAG_MAX: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].Mmax);
+      }
       break;
 …
       break;
+      /*** CHIP : MAG ***/
+    case GSTAR_AVE_MAG: /* average mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].M);
+      }
+      break;
+    case GSTAR_AVE_MAG_ERR: /* average mags errors */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].dM);
+      }
+      break;
     case GSTAR_AVE_AP_MAG: /* average ap mags */
       if (seq == -1) {
 …
       break;
-    case GSTAR_AVE_MAG_MIN: /* average ap mags */
-      if (seq == -1) {
-        print_double (NAN);
-      } else {
-        print_double (secfilt[seq].Mmin);
+      }
-      break;
-    case GSTAR_AVE_MAG_MAX: /* average ap mags */
-      if (seq == -1) {
-        print_double (NAN);
-      } else {
-        print_double (secfilt[seq].Mmax);
+      }
-      break;
     case GSTAR_AVE_KRON_MAG: /* average ap mags */
       if (seq == -1) {
 …
       break;
+      /******************* STACK : FLUX **********************/
     case GSTAR_STACK_FLUX_PSF: /* average ap mags */
       if (seq == -1) {
 …
       break;
+    case GSTAR_STACK_FLUX_APER: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double_exp (secfilt[seq].FapStk);
+      }
+      break;
+    case GSTAR_STACK_FLUX_APER_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double_exp (secfilt[seq].dFapStk);
+      }
+      break;
+      /******************* STACK : MAG **********************/
+    case GSTAR_STACK_MAG_PSF: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].MpsfStk);
+      }
+      break;
+    case GSTAR_STACK_MAG_PSF_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].dFpsfStk / secfilt[seq].FpsfStk);
+      }
+      break;
+    case GSTAR_STACK_MAG_KRON: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].MkronStk);
+      }
+      break;
+    case GSTAR_STACK_MAG_KRON_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].dFkronStk / secfilt[seq].FkronStk);
+      }
+      break;
+    case GSTAR_STACK_MAG_APER: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].MapStk);
+      }
+      break;
+    case GSTAR_STACK_MAG_APER_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].dFapStk / secfilt[seq].FapStk);
+      }
+      break;
+      /******************* WARP : FLUX **********************/
+    case GSTAR_WARP_FLUX_PSF: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double_exp (secfilt[seq].FpsfWrp);
+      }
+      break;
+    case GSTAR_WARP_FLUX_PSF_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double_exp (secfilt[seq].dFpsfWrp);
+      }
+      break;
+    case GSTAR_WARP_FLUX_KRON: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double_exp (secfilt[seq].FkronWrp);
+      }
+      break;
+    case GSTAR_WARP_FLUX_KRON_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double_exp (secfilt[seq].dFkronWrp);
+      }
+      break;
+    case GSTAR_WARP_FLUX_APER: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double_exp (secfilt[seq].FapWrp);
+      }
+      break;
+    case GSTAR_WARP_FLUX_APER_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double_exp (secfilt[seq].dFapWrp);
+      }
+      break;
+      /******************* WARP : MAG **********************/
+    case GSTAR_WARP_MAG_PSF: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].MpsfWrp);
+      }
+      break;
+    case GSTAR_WARP_MAG_PSF_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].dFpsfWrp / secfilt[seq].FpsfWrp);
+      }
+      break;
+    case GSTAR_WARP_MAG_KRON: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].MkronWrp);
+      }
+      break;
+    case GSTAR_WARP_MAG_KRON_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].dFkronWrp / secfilt[seq].FkronWrp);
+      }
+      break;
+    case GSTAR_WARP_MAG_APER: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].MapWrp);
+      }
+      break;
+    case GSTAR_WARP_MAG_APER_ERR: /* average ap mags */
+      if (seq == -1) {
+        print_double (NAN);
+      } else {
+        print_double (secfilt[seq].dFapWrp / secfilt[seq].FapWrp);
+      }
+      break;
+  }
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/images.c

-              r34584
+              r37822
   /* it is not an error for the database not to have any images */
   if ((image = LoadImagesDVO (&Nimage)) == NULL) return (TRUE);
   BuildChipMatch (image, Nimage);
+  // BuildChipMatch (image, Nimage);
   if (SOLO_MOSAIC && photcode) {
 …
   SetVector (&Yvec, OPIHI_FLT, NPTS);
+  Image *mosaic = NULL;
   ALLOCATE (plist, int, NPTS);
   n = N = 0;
 …
     if (ByName && strncmp (image[i].name, name, strlen(name))) continue;
     if (TimeSelect && ((image[i].tzero < tzero) || (image[i].tzero+image[i].trate*image[i].NY > tzero + trange))) continue;
+    if (!(Nmosaic = FindMosaicForImage (image, Nimage, i))) continue;
+    Nmosaic --; // XXX kind of a hack: FindMosaicForImage returns 0 or the mosaic seq number + 1
+    mosaic = image[i].parent;
+    Nmosaic = (SOLO_MOSAIC && mosaic) ? mosaic - image : -1;
     if (photcode) {
       if ( photcodeEquiv && (photcode[0].code != GetPhotcodeEquivCodebyCode(image[i].photcode))) continue;
 …
     typehash = wordhash (&image[i].coords.ctype[4]);
     if (photcode && SOLO_MOSAIC) {
+    if (photcode && SOLO_MOSAIC && (Nmosaic >= 0)) {
       // mosaic (DIS) images are not currently given a photcode : plot these via the WRP entries
       /* DIS images represent a field, not a chip */
       if (typehash != ChipImage) continue;
       if (foundMosaic[Nmosaic]) continue;
       x[0] = -0.5*image[Nmosaic].NX; y[0] = -0.5*image[Nmosaic].NY;
       x[1] = +0.5*image[Nmosaic].NX; y[1] = -0.5*image[Nmosaic].NY;
       x[2] = +0.5*image[Nmosaic].NX; y[2] = +0.5*image[Nmosaic].NY;
       x[3] = -0.5*image[Nmosaic].NX; y[3] = +0.5*image[Nmosaic].NY;
+      x[0] = -0.5*mosaic->NX; y[0] = -0.5*mosaic->NY;
+      x[1] = +0.5*mosaic->NX; y[1] = -0.5*mosaic->NY;
+      x[2] = +0.5*mosaic->NX; y[2] = +0.5*mosaic->NY;
+      x[3] = -0.5*mosaic->NX; y[3] = +0.5*mosaic->NY;
       for (j = 0; j < Npts; j++) {
         status = XY_to_RD (&r[j], &d[j], x[j], y[j], &image[Nmosaic].coords);
+        status = XY_to_RD (&r[j], &d[j], x[j], y[j], &mosaic->coords);
         if (!status) break;
         r[j] = ohana_normalize_angle (r[j]);
 …
     /* DIS images represent a field, not a chip */
+    if ((typehash == DistortImage) && !WITH_MOSAIC) continue;
+    if ((typehash != DistortImage) &&  SOLO_MOSAIC) continue;
+    if ((typehash == DistortImage) && !WITH_MOSAIC) continue; // do not plot the mosaic images
+    if ((typehash != DistortImage) &&  SOLO_MOSAIC) continue; // plot only the mosaic images
     if (typehash == DistortImage) {
       x[0] = -0.5*image[i].NX; y[0] = -0.5*image[i].NY;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/imbox.c

-              r34584
+              r37822
   SetVector (&Yvec, OPIHI_FLT, NPTS);
+  mosaic.ctype[0] = 0;
   while (gfits_fread_header (f, &header)) {
     if (!GetCoords (&coords, &header)) goto skip;
     if (!SOLO_PHU && !strcmp (&coords.ctype[4], "-DIS")) {
       mosaic = coords;
-      RegisterMosaic (&mosaic);
       goto skip;
+    }
+    if (!strcmp (&coords.ctype[4], "-WRP")) {
+      if (!mosaic.ctype[0]) {
+        fprintf (stderr, "PHU mosaic not found\n");
+        return FALSE;
+      }
+      coords.mosaic = &mosaic;
+    }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/imdata.c

-              r37049
+              r37822
   if ((image = LoadImagesDVO (&Nimage)) == NULL) return (FALSE);
   image_subset (image, Nimage, &subset, &Nsubset, selection, tzero, trange, TimeSelect);
   BuildChipMatch (image, Nimage);
+  // BuildChipMatch (image, Nimage);
   GetTimeFormat (&TimeReference, &TimeFormat);
 …
     I = subset[i];
-    if (!FindMosaicForImage (image, Nimage, I)) continue;
     skyset = SkyListByImage (sky, -1, &image[I]);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/imdense.c

-              r34584
+              r37822
   if ((image = LoadImagesDVO (&Nimage)) == NULL) return (FALSE);
   BuildChipMatch (image, Nimage);
+  // BuildChipMatch (image, Nimage);
   Rmin = graphmode.coords.crval1 - 182.0;
 …
     /* project this image to screen display coords */
     status = FALSE;
-    if (!FindMosaicForImage (image, Nimage, i)) continue;
     XY_to_RD (&r, &d, x, y, &image[i].coords);
     r = ohana_normalize_angle (r);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/imextract.c

r37049	r37822
90	90
91	91	if ((image = LoadImagesDVO (&Nimage)) == NULL) goto escape;
92		BuildChipMatch (image, Nimage);
	92	// BuildChipMatch (image, Nimage);
93	93	dbExtractImagesInit ();
94	94

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/imlist.c

-              r34088
+              r37822
+  }
-  // int RegionSelect = FALSE;
-  // if ((N = get_argument (argc, argv, "-region"))) {
-  //   remove_argument (N, &argc, argv);
-  //   RegionSelect = TRUE;
-  // }
   PhotcodeValue = NULL;
   PhotcodeSelect = FALSE;
 …
+  }
+  int MAX_LIST = -1;
+  if ((N = get_argument (argc, argv, "-max-list"))) {
+    remove_argument (N, &argc, argv);
+    MAX_LIST = atoi (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
   if (argc != 1) {
     gprint (GP_ERR, "USAGE: image [-time start range] [-region] [-name string]\n");
+    gprint (GP_ERR, "USAGE: image [-time start range] [-region] [-name string] [-photcode code] [-Nphotcode N] [-max-list N]\n");
     return (FALSE);
+  }
 …
   if ((image = LoadImagesDVO (&Nimage)) == NULL) return (FALSE);
   image_subset (image, Nimage, &subset, &Nsubset, selection, tzero, trange, TimeSelect);
   BuildChipMatch (image, Nimage);
+  MAX_LIST = MAX_LIST < 0 ? Nsubset : MIN(MAX_LIST, Nsubset);
   GetTimeFormat (&TimeReference, &TimeFormat);
   for (j = 0; j < Nsubset; j++) {
+  for (j = 0; j < MAX_LIST; j++) {
     i = subset[j];
     if (NameSelect && (strstr (image[i].name, name) == (char *) NULL)) continue;
 …
+      }
+    }
-    if (!FindMosaicForImage (image, Nimage, i)) continue;
     t = TimeValue (image[i].tzero, TimeReference, TimeFormat);
     if (!strcmp(&image[i].coords.ctype[4], "-DIS")) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/imstats.c

-              r34584
+              r37822
   if ((image = LoadImagesDVO (&Nimage)) == NULL) return (FALSE);
   BuildChipMatch (image, Nimage);
+  // BuildChipMatch (image, Nimage);
   /* assign vector values */
 …
     else
       Yvec.elements.Flt[i] = image[i].dMcal;
-    if (!FindMosaicForImage (image, Nimage, i)) continue;
     XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
     gprint (GP_ERR, "%d %8.4f %8.4f %10d %6d  %5.3f %6.3f %6.3f\n",

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/init.c

-              r37049
+              r37822
 int calmextract     PROTO((int, char **));
 int catlog          PROTO((int, char **));
+int catname         PROTO((int, char **));
 int catdir_define   PROTO((int, char **));
 int ccd             PROTO((int, char **));
 …
 //  {1, "calextract",  calextract,   "extract photometry calibration"},
 //  {1, "calmextract", calmextract,  "extract photometry calibration"},
+  {1, "catname",     catname,      "list catalog files by name"},
   {1, "catdir",      catdir_define,"re-define CATDIR"},
 //  {1, "ccd",         ccd,          "plot color-color diagram"},

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/mextract.c

-              r35416
+              r37822
+  }
+  // int needLensing = dbFieldNeedLensing (fields, Nfields);
+  int needStarpar = dbFieldNeedStarpar (fields, Nfields, FALSE);
   // grab data from all selected sky regions
   Signal = signal (SIGINT, handle_interrupt);
 …
     catalog.filename = HOST_ID ? hostfile : skylist[0].filename[i];
     catalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_SECF;
+    // catalog.catflags |= needLensing ? LOAD_LENSING : SKIP_LENSING;
+    catalog.catflags |= needStarpar ? LOAD_STARPAR : SKIP_STARPAR;
     catalog.Nsecfilt = Nsecfilt;
 …
         // extract the relevant values for this measurement
         dbExtractMeasuresInitMeas (); // reset counters for saved fields  (costs very little
+        Average *average = &catalog.average[j];
+        int Nstarpar = average->starparOffset;
+        StarPar *starpar = needStarpar ? &catalog.starpar[Nstarpar] : NULL;
+        // int Nlensing = average->lensobjOffset;
+        // Lensobj *lensobj = needLensobj ? &catalog.lensobj[m] : NULL;
+        int Nsec = j*Nsecfilt;
+        SecFilt *secfilt = &catalog.secfilt[Nsec];
         for (n = 0; n < Nfields; n++) {
           values[n] = dbExtractMeasures (&catalog.average[j], &catalog.secfilt[j*Nsecfilt], &catalog.measure[m], &fields[n]);
+          values[n] = dbExtractMeasures (average, secfilt, &catalog.measure[m], NULL, starpar, &fields[n]);
+        }
         // fprintf (stderr, "object: ave: %f, cat: %f, averef %d\n", fields[n].name, values[2], values[3], catalog.measure[m].averef);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/mmatch.c

-              r35416
+              r37822
   ALLOCATE (index, off_t, Nelem);
+  // int needLensing = dbFieldNeedLensing (fields, Nfields);
+  int needStarpar = dbFieldNeedStarpar (fields, Nfields, FALSE);
   // grab data from all selected sky regions
   Signal = signal (SIGINT, handle_interrupt);
 …
     catalog.filename = HOST_ID ? hostfile : skylist[0].filename[i];
     catalog.catflags = LOAD_AVES | LOAD_SECF | LOAD_MEAS;
+    catalog.catflags |= needStarpar ? LOAD_STARPAR : SKIP_STARPAR;
     catalog.Nsecfilt = Nsecfilt;
 …
         // extract the relevant values for this measurement
         dbExtractMeasuresInitMeas (); // reset counters for saved fields  (costs very little
+        Average *average = &catalog.average[Ncat];
+        int Nstarpar = average->starparOffset;
+        StarPar *starpar = needStarpar ? &catalog.starpar[Nstarpar] : NULL;
+        // int Nlensing = average->lensobjOffset;
+        // Lensobj *lensobj = needLensobj ? &catalog.lensobj[m] : NULL;
+        int Nsec = Ncat*Nsecfilt;
+        SecFilt *secfilt = &catalog.secfilt[Nsec];
         for (n = 0; n < Nfields; n++) {
           values[n] = dbExtractMeasures (&catalog.average[Ncat], &catalog.secfilt[Ncat*Nsecfilt], &catalog.measure[m], &fields[n]);
+          values[n] = dbExtractMeasures (average, secfilt, &catalog.measure[m], NULL, starpar, &fields[n]);
+        }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/mmextract.c

-              r35263
+              r37822
+  }
+  // int needLensing = dbFieldNeedLensing (fields, Nfields);
+  int needStarpar = dbFieldNeedStarpar (fields, Nfields, FALSE);
   // grab data from all selected sky regions
   Signal = signal (SIGINT, handle_interrupt);
 …
         // extract the relevant values for this measurement
         dbExtractMeasuresInitMeas (); // reset counters for saved fields
+        Average *average = &catalog.average[j];
+        int Nstarpar = average->starparOffset;
+        StarPar *starpar = needStarpar ? &catalog.starpar[Nstarpar] : NULL;
+        // int Nlensing = average->lensobjOffset;
+        // Lensobj *lensobj = needLensobj ? &catalog.lensobj[m] : NULL;
+        int Nsec = j*Nsecfilt;
+        SecFilt *secfilt = &catalog.secfilt[Nsec];
         for (n = 0; n < Nfields; n++) {
           // values needs to be a pointer to a type with FLT and INT (with a union, we would save a bit of memory...)
           values[n] = dbExtractMeasures (&catalog.average[j], &catalog.secfilt[j*Nsecfilt], &catalog.measure[m], &fields[n]);
+          values[n] = dbExtractMeasures (average, secfilt, &catalog.measure[m], NULL, starpar, &fields[n]);
+        }
         // fprintf (stderr, "object: ave: %f, cat: %f, averef %d\n", fields[n].name, values[2], values[3], catalog.measure[m].averef);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/objectcoverage.c

-              r34088
+              r37822
   strcpy (buf[0].file, "(empty)");
+  InitCoords (&coords, projection);
   coords.crval1 = RaCenter;
   coords.crval2 = DecCenter;
   coords.crpix1 = 0.5*Nx;
   coords.crpix2 = 0.5*Ny;
+  strcpy (coords.ctype, projection);
+  coords.pc1_1 = -1.0;
+  coords.pc1_1 = -1.0; // sky parity
   coords.pc2_2 = +1.0;
-  coords.pc1_2 =  0.0;
-  coords.pc2_1 =  0.0;
   coords.cdelt1 = coords.cdelt2 = pixscale;
-  coords.Npolyterms = 0;
   PutCoords (&coords, &buf[0].header);
 …
     for (xs = 0; xs < Nx; xs++) {
       status = XY_to_RD (&r, &d, (double)(xs), (double)(ys), &coords);
+      status &= (r >= 0);
+      status &= (r <= 360);
+      r = ohana_normalize_angle (r);
       if (status) {
         V[ys*Nx + xs] = ShowDensity ?  0 : 2;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/showtile.c

-              r36489
+              r37822
   /* reference for coords is this image */
+  coords.crpix1 = coords.crpix2 = 0.0;
+  coords.crval1 = coords.crval2 = 0.0;
+  coords.cdelt1 = coords.cdelt2 = 1.0;
+  coords.pc1_1  = coords.pc2_2  = 1.0;
+  coords.pc1_2  = coords.pc2_1  = 0.0;
+  coords.Npolyterms = 0;
+  strcpy (coords.ctype, "DEC--TAN");
+  InitCoords (&coords, "DEC--TAN");
   /* fill in top-left region */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/simage.c

-              r36489
+              r37822
+  }
   /* get astrometry information */
+  strcpy (coords.ctype, "NONE");
+  gfits_scan (&header, "CTYPE2",   "%s",  1, coords.ctype);
+  if (strcmp (coords.ctype, "DEC--PLY")) {
+    gprint (GP_ERR, "ERROR: wrong astrometric info in header\n");
+  if (!GetCoords (&coords, &header)) {
+    gprint (GP_ERR, "ERROR: can't get coord info from header\n");
     return (FALSE);
+  }
-  gfits_scan (&header, "CDELT1",   "%f", 1, &coords.cdelt1);
-  gfits_scan (&header, "CDELT2",   "%f", 1, &coords.cdelt2);
-  gfits_scan (&header, "CRVAL1",   "%lf", 1, &coords.crval1);
-  gfits_scan (&header, "CRVAL2",   "%lf", 1, &coords.crval2);
-  gfits_scan (&header, "CRPIX1",   "%f", 1, &coords.crpix1);
-  gfits_scan (&header, "CRPIX2",   "%f", 1, &coords.crpix2);
-  gfits_scan (&header, "PC001001", "%f", 1, &coords.pc1_1);
-  gfits_scan (&header, "PC001002", "%f", 1, &coords.pc1_2);
-  gfits_scan (&header, "PC002001", "%f", 1, &coords.pc2_1);
-  gfits_scan (&header, "PC002002", "%f", 1, &coords.pc2_2);
-  /* RA Terms */
-  gfits_scan (&header, "PCA1X2Y0", "%f", 1, &coords.polyterms[0][0]);
-  gfits_scan (&header, "PCA1X1Y1", "%f", 1, &coords.polyterms[1][0]);
-  gfits_scan (&header, "PCA1X0Y2", "%f", 1, &coords.polyterms[2][0]);
-  gfits_scan (&header, "PCA1X3Y0", "%f", 1, &coords.polyterms[3][0]);
-  gfits_scan (&header, "PCA1X2Y1", "%f", 1, &coords.polyterms[4][0]);
-  gfits_scan (&header, "PCA1X1Y2", "%f", 1, &coords.polyterms[5][0]);
-  gfits_scan (&header, "PCA1X0Y3", "%f", 1, &coords.polyterms[6][0]);
-  /* Dec Terms */
-  gfits_scan (&header, "PCA2X2Y0", "%f", 1, &coords.polyterms[0][1]);
-  gfits_scan (&header, "PCA2X1Y1", "%f", 1, &coords.polyterms[1][1]);
-  gfits_scan (&header, "PCA2X0Y2", "%f", 1, &coords.polyterms[2][1]);
-  gfits_scan (&header, "PCA2X3Y0", "%f", 1, &coords.polyterms[3][1]);
-  gfits_scan (&header, "PCA2X2Y1", "%f", 1, &coords.polyterms[4][1]);
-  gfits_scan (&header, "PCA2X1Y2", "%f", 1, &coords.polyterms[5][1]);
-  gfits_scan (&header, "PCA2X0Y3", "%f", 1, &coords.polyterms[6][1]);
-  coords.Npolyterms = 2; /* how many do we use? */
   /* find number of stars */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/skycoverage.c

-              r33963
+              r37822
   strcpy (buf[0].file, "(empty)");
+  InitCoords (&coords, projection);
   coords.crval1 = RaCenter;
   coords.crval2 = DecCenter;
   coords.crpix1 = 0.5*Nx;
   coords.crpix2 = 0.5*Ny;
+  strcpy (coords.ctype, projection);
+  coords.pc1_1 = -1.0;
+  coords.pc1_1 = -1.0; // sky parity
   coords.pc2_2 = +1.0;
-  coords.pc1_2 =  0.0;
-  coords.pc2_1 =  0.0;
   coords.cdelt1 = coords.cdelt2 = pixscale;
-  coords.Npolyterms = 0;
   PutCoords (&coords, &buf[0].header);
 …
       return (FALSE);
+  }
   BuildChipMatch (image, Nimage);
+  // BuildChipMatch (image, Nimage);
   V = (float *)buf[0].matrix.buffer;
 …
     for (xs = 0; xs < Nx; xs++) {
       status = XY_to_RD (&r, &d, (double)(xs), (double)(ys), &coords);
       status &= (r >= 0);
+      status &= (r <= 360);
+      r = ohana_normalize_angle (r);
       // are we in a part of the projection covering the sky or not?
       if (status) {
 …
+      }
+    }
-    if (!FindMosaicForImage (image, Nimage, i)) continue;
     typehash = wordhash (&image[i].coords.ctype[4]);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/dvo/subpix.c

-              r37049
+              r37822
   /* load all images, extract those touching Ra, Dec */
   if ((image = LoadImagesDVO (&Nimage)) == NULL) return (FALSE);
   BuildChipMatch (image, Nimage);
+  // BuildChipMatch (image, Nimage);
   for (i = 0; i < Nimage; i++) {
-    if (!FindMosaicForImage (image, Nimage, i)) continue;
     status = RD_to_XY (&X, &Y, Ra, Dec, &image[i].coords);
     if (!status || (X < 0) || (X > image[i].NX) || (Y < 0) || (Y > image[i].NY)) continue;
 …
   for (i = 0; i < Nsub; i++) {
     I = index[i];
-    if (!FindMosaicForImage (image, Nimage, I)) continue;
     Timage = image[I].tzero;
     for (j = 0; j < Nmeasure; j++) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/include/astro.h

-              r31635
+              r37822
 void FreeAstro (void);
-typedef struct {
-  int    isIdentity;          // identity transformation
-  double phi;                 // saved in radians
-  double Xo;                  // saved in radians
-  double xo;                  // saved in degrees
-  double sin_phi_cos_Xo;      // pre-computed values
-  double sin_phi_sin_Xo;      // pre-computed values
-  double cos_phi_cos_Xo;      // pre-computed values
-  double cos_phi_sin_Xo;      // pre-computed values
-  double cos_phi;             // pre-computed values
-  double sin_phi;             // pre-computed values
-  double cos_Xo;              // pre-computed values
-  double sin_Xo;              // pre-computed values
-} CoordTransform;
-#ifndef MOVED_TO_LIBDVO
-typedef enum {COORD_NONE, COORD_CELESTIAL, COORD_GALACTIC, COORD_ECLIPTIC} CoordTransformSystem;
-#endif
-CoordTransform *InitTransform (CoordTransformSystem input, CoordTransformSystem output);
-int ApplyTransform (double *x, double *y, double X, double Y, CoordTransform *transform);
 # endif

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/include/data.h

r36679	r37822
224	224	void ListMedImages ();
225	225
	226	// in tvchannel.c
	227	int GetKapaChannelFromString (char *string);
	228
226	229	# endif

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/include/dvomath.h

r37049	r37822
187	187	int ListBuffersToList PROTO((char *name));
188	188	int CreateBuffer PROTO((Buffer *buf, int Nx, int Ny, int bitpix, float bzero, float bscale));
	189	int ResetBuffer PROTO((Buffer *buf, int Nx, int Ny, int bitpix, float bzero, float bscale));
189	190	Buffer SelectBuffer PROTO((char name, int mode, int verbose));
190	191	void dump_buffers PROTO((int n)); /* deprecated? */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/lib.shell/BufferOps.c

-              r33662
+              r37822
+}
+int ResetBuffer (Buffer *buf, int Nx, int Ny, int bitpix, float bzero, float bscale) {
+  gfits_free_matrix (&buf[0].matrix);
+  gfits_free_header (&buf[0].header);
+  CreateBuffer (buf, Nx, Ny, bitpix, bzero, bscale);
+  return TRUE;
+}
 int CreateBuffer (Buffer *buf, int Nx, int Ny, int bitpix, float bzero, float bscale) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/pantasks/controller_status.c

-              r23530
+              r37822
 int controller_status (int argc, char **argv) {
   int status;
   char command[1024];
+  int i, status;
+  char command[1024], tmpline[1024];
   IOBuffer buffer;
+  if (argc != 1) {
+    gprint (GP_ERR, "USAGE: controller status\n");
+  if ((argc > 1) && (!strcasecmp(argv[1], "help")))  {
+    gprint (GP_ERR, "USAGE: controller status [options]\n");
+    gprint (GP_ERR, "  OPTIONS:\n");
+    gprint (GP_ERR, "  -cmd command\n");
+    gprint (GP_ERR, "  -host hostname\n");
+    gprint (GP_ERR, "  -state state\n");
+    gprint (GP_ERR, "  -age seconds\n");
+    gprint (GP_ERR, "  +jobs [-nohost]\n");
+    gprint (GP_ERR, "  +host [-nojobs]\n");
     return (FALSE);
+  }
 …
+  }
+  snprintf (command, 1024, "status");
+  for (i = 1; i < argc; i++) {
+    snprintf (tmpline, 1024, "%s %s", command, argv[i]);
+    strcpy (command, tmpline);
+  }
-  sprintf (command, "status");
   InitIOBuffer (&buffer, 0x100);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/pcontrol/Makefile

r34088	r37822
11	11
12	12	# programs may add their own internal requirements here
13		LIBS1 = -lkapa -lFITS -lohana
	13	LIBS1 = -ldvo -lkapa -lFITS -lohana
14	14	LIBS2 = -lbasiccmd -lshell -ldata
15	15	FULL_CFLAGS = $(BASE_CFLAGS)

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/opihi/pcontrol/status.c

r36623	r37822
85	85
86	86	usage:
87		gprint (GP_~~ERR~~, "USAGE: status [-cmd command] [-host hostname] [-state state] [-age seconds] [+jobs,-nohost] [+host,-nojobs]\n");
	87	gprint (GP_LOG, "USAGE: status [-cmd command] [-host hostname] [-state state] [-age seconds] [+jobs,-nohost] [+host,-nojobs]\n");
88	88	return FALSE;
89	89	}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/photdbc/include/photdbc.h

-              r37045
+              r37822
 int    PARALLEL_MANUAL;
 int    PARALLEL_SERIAL;
+char  *PARALLEL_OUTHOSTS;
 int          HOST_ID;
 char        *HOSTDIR;
+char        *HOSTDIR_OUTPUT;
 // need to get RADIUS from Config
 …
 /* global variables */
+int    SKIP_IMAGES;
+int    ONLY_IMAGES;
 int    SHOW_PARAMS;
 int    VERBOSE;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/photdbc/src/CopyToHostLocation.c

-              r33655
+              r37822
+    }
+    char extname[4][16] = {"cpm", "cpt", "cps", "cpn"};
+    for (j = 0; success && (j < 4); j++) {
+    # define NEXTNAME 7
+    char extname[NEXTNAME][16] = {"cpm", "cpt", "cps", "cpn", "cpx", "cpy", "cpz"};
+    for (j = 0; success && (j < NEXTNAME); j++) {
       // set the in and out table names

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/photdbc/src/args.c

-              r36833
+              r37822
     remove_argument (N, &argc, argv);
     SHOW_PARAMS = TRUE;
+  }
+  SKIP_IMAGES = FALSE;
+  if ((N = get_argument (argc, argv, "-skip-images"))) {
+    SKIP_IMAGES = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  ONLY_IMAGES = FALSE;
+  if ((N = get_argument (argc, argv, "-only-images"))) {
+    if (SKIP_IMAGES) {
+      fprintf (stderr, "-skip-images and -only-images cannot be used together\n");
+    }
+    ONLY_IMAGES = TRUE;
+    remove_argument (N, &argc, argv);
+  }
 …
+  }
+  // XXX for the moment, make this selection manual.  it needs to be automatic
+  // based on the state of the SkyTable
+  HOSTDIR_OUTPUT = NULL;
+  PARALLEL_OUTHOSTS = NULL;
+  if ((N = get_argument (argc, argv, "-parallel-output"))) {
+    remove_argument (N, &argc, argv);
+    PARALLEL_OUTHOSTS = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
   if (argc != 2) usage();
 …
   if (!HOSTDIR) usage();
+  HOSTDIR_OUTPUT = NULL;
+  if ((N = get_argument (argc, argv, "-hostdir-output"))) {
+    remove_argument (N, &argc, argv);
+    HOSTDIR_OUTPUT = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
   VERBOSE = FALSE;
   if ((N = get_argument (argc, argv, "-v"))) {
 …
   fprintf (stderr, " photdbc (output)\n\n");
+  fprintf (stderr, " parallel options:\n");
+  fprintf (stderr, "  -parallel:\n");
+  fprintf (stderr, "  -parallel-output HostTable : HostTable should be relative path in OUTPUT directory\n");
+  fprintf (stderr, "  -parallel-manual\n");
+  fprintf (stderr, "  -parallel-serial\n\n");
   fprintf (stderr, " allowed filters / restrictions include:\n\n");
 …
   fprintf (stderr, " option options:\n");
   fprintf (stderr, " -v : verbose mode\n");
+  fprintf (stderr, " -params : list the current parameters\n\n");
+  fprintf (stderr, " -params : list the current parameters\n");
+  fprintf (stderr, " -skip-images\n");
+  fprintf (stderr, " -only-images\n");
+  fprintf (stderr, " -set-format (catformat)\n");
+  fprintf (stderr, " -set-mode (catmode)\n");
   fprintf (stderr, "ptolemy.rc config values used by this program:\n");

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/photdbc/src/copy_images.c

-              r36833
+              r37822
+  }
+  BuildChipMatch (image, Nimage);
+  // MARKTIME("build chip match: %f sec\n", dtime);
+  char mapfile[DVO_MAX_PATH];
+  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", CATDIR);
+  AstromOffsetTable *table_src = AstromOffsetMapLoad (mapfile, VERBOSE);
+  // assign images.coords.offsetMap -> table->map[i]
+  if (table_src) {
+    AstromOffsetTableMatchChips (image, Nimage, table_src);
+  }
   subset = select_images (skylist, image, Nimage, &LineNumber, &Nsubset, FALSE);
+  if (table_src) {
+    AstromOffsetTable *table_tgt = AstromOffsetTableInit ();
+    off_t i;
+    for (i = 0; i < Nsubset; i++) {
+      if (!subset[i].coords.offsetMap) continue;
+      if (subset[i].coords.Npolyterms != -1) continue; // assert on this?
+      AstromOffsetTableAddMapFromImage (table_tgt, &subset[i]);
+    }
+    snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", outdir);
+    AstromOffsetMapSave (table_tgt, mapfile);
+    free (table_tgt->imageIDtoTableSeq);
+    free (table_tgt->map);
+    free (table_tgt);
+  }
   dvo_image_addrows (&out, subset, Nsubset);
 …
   SavePhotcodesFITS (filename);
+  // free the astrom offset tables
+  AstromOffsetTableFree (table_src);
   return (TRUE);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/photdbc/src/find_images.c

-              r36481
+              r37822
   /* we make positional comparisons in the projection of catalog */
+  InitCoords (&tcoords, "DEC--TAN");
   tcoords.crval1 = 0.5*(region[0].RA[0]  + region[0].RA[1]);
   tcoords.crval2 = 0.5*(region[0].DEC[0] + region[0].DEC[1]);
-  tcoords.crpix1 = tcoords.crpix2 = 0.0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1  = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2  = tcoords.pc2_1 = 0.0;
-  strcpy (tcoords.ctype, "DEC--TAN");
   timage = gfits_table_get_Image (&db[0].ftable, &Ntimage, &db[0].swapped);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/photdbc/src/join_stars.c

-              r37045
+              r37822
   /* coordinate system for projection */
+  InitCoords (&tcoords, "DEC--TAN");
   tcoords.crval1 = Rmid;
   tcoords.crval2 = Dmid;
-  tcoords.crpix1 = tcoords.crpix2 = 0.0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1  = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2  = tcoords.pc2_1 = 0.0;
-  tcoords.Npolyterms = 0;
-  strcpy (tcoords.ctype, "DEC--TAN");
   /* project & sort coordinates in local linear frame */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/photdbc/src/photdbc.c

-              r36833
+              r37822
   // load and copy the image table
+  copy_images (argv[1], skylist);
+  if (!SKIP_IMAGES) {
+    copy_images (argv[1], skylist);
+  }
   // hostID is 0 for master program
+  photdbc_catalogs (argv[1], skylist, 0);
+  if (!ONLY_IMAGES) {
+    photdbc_catalogs (argv[1], skylist, 0);
+  }
   char *skyfile = SkyTableFilename (argv[1]);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/photdbc/src/photdbc_catalogs.c

-              r36833
+              r37822
     snprintf (outfile, DVO_MAX_PATH, "%s/%s.cpt", outroot, skylist[0].regions[i]->name);
     outcatalog.filename = outfile;
+    if (HOSTDIR_OUTPUT) {
+      // parallel-ouput puts the output in a per-host directory (keeps the source sky partition)
+      snprintf (outfile, DVO_MAX_PATH, "%s/%s.cpt", HOSTDIR_OUTPUT, skylist[0].regions[i]->name);
+    }
     if (outcatalog.filename == NULL) Shutdown ("error with input catalog name");
 …
+  }
+  HostTable *table_output = NULL;
+  if (PARALLEL_OUTHOSTS) {
+    table_output = HostTableLoad (outroot, PARALLEL_OUTHOSTS);
+    if (!table_output) {
+      fprintf (stderr, "%s not found in %s, please create\n", PARALLEL_OUTHOSTS, outroot);
+    }
+  }
   int i;
   for (i = 0; i < table->Nhosts; i++) {
 …
     if (CATFORMAT)          { snprintf (tmpline, DVO_MAX_PATH, "%s -set-format %s",    command, CATFORMAT);                     strcpy (command, tmpline); }
     if (CATMODE)            { snprintf (tmpline, DVO_MAX_PATH, "%s -set-mode %s",      command, CATMODE);                       strcpy (command, tmpline); }
+    if (PARALLEL_OUTHOSTS) {
+      tmppath = abspath (table_output->hosts[i].pathname, DVO_MAX_PATH);
+      free  (table_output->hosts[i].pathname);
+      table_output->hosts[i].pathname = tmppath;
+      snprintf (tmpline, DVO_MAX_PATH, "%s -hostdir-output %s", command, table_output->hosts[i].pathname); strcpy (command, tmpline);
+    }
     fprintf (stderr, "command: %s\n", command);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/photdbc/src/select_images.c

-              r36833
+              r37822
   // the comparison is made in the catalog local projection. below we set crval1,2
   tcoords.crpix1 = tcoords.crpix2 = 0.0;
+  InitCoords (&tcoords, "DEC--TAN");
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1  = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2  = tcoords.pc2_1 = 0.0;
-  strcpy (tcoords.ctype, "DEC--TAN");
   ALLOCATE (skycoords, SkyRegionCoords, skylist[0].Nregions);
 …
   if (VERBOSE) fprintf (stderr, "finding images\n");
-  BuildChipMatch (timage, Ntimage);
-  MARKTIME("build chip match: %f sec\n", dtime);
   nimage = 0;
 …
 keep_image:
-    // this adds 1.3 sec for 3M images
-    if (!FindMosaicForImage (timage, Ntimage, i)) {
-      fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i);
-      continue;
+    }
     /* define image corners - note the DIS images (mosaic phu) are special */
     if (!strcmp(&timage[i].coords.ctype[4], "-DIS")) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/Makefile

-              r36833
+              r37822
 $(SRC)/save_catalogs.$(ARCH).o       \
 $(SRC)/CoordOps.$(ARCH).o            \
 $(SRC)/FixProblemImages.$(ARCH).o    \
+$(SRC)/extra.$(ARCH).o            \
 $(SRC)/StarMaps.$(ARCH).o    \
 $(SRC)/high_speed_catalogs.$(ARCH).o  \
 …
 $(SRC)/relastro_parallel_regions.$(ARCH).o \
 $(SRC)/MeanPosIO.$(ARCH).o \
+$(SRC)/MeasPosIO.$(ARCH).o \
 $(SRC)/share_mean_pos.$(ARCH).o \
+$(SRC)/share_meas_pos.$(ARCH).o \
 $(SRC)/share_images_pos.$(ARCH).o \
+$(SRC)/share_icrf_obj.$(ARCH).o \
+$(SRC)/ICRF.$(ARCH).o \
+$(SRC)/ICRFobjIO.$(ARCH).o \
+$(SRC)/FrameCorrection.$(ARCH).o \
+$(SRC)/FrameCorrectionIO.$(ARCH).o \
+$(SRC)/FrameCorrectionUtils.$(ARCH).o \
 $(SRC)/ImagePosIO.$(ARCH).o \
 $(SRC)/ImageTable.$(ARCH).o \
 …
 $(SRC)/indexCatalogs.$(ARCH).o \
 $(SRC)/syncfile.$(ARCH).o \
+$(SRC)/client_logger.$(ARCH).o \
 $(SRC)/relastroVisual.$(ARCH).o
 …
 $(SRC)/relastro_objects.$(ARCH).o    \
 $(SRC)/save_catalogs.$(ARCH).o       \
 $(SRC)/CoordOps.$(ARCH).o            \
+$(SRC)/extra.$(ARCH).o            \
 $(SRC)/high_speed_catalogs.$(ARCH).o  \
 $(SRC)/high_speed_objects.$(ARCH).o  \
 …
 $(SRC)/plot_scatter.$(ARCH).o        \
 $(SRC)/plotstuff.$(ARCH).o           \
+$(SRC)/ICRF.$(ARCH).o \
 $(SRC)/relastroVisual.$(ARCH).o \
 $(SRC)/syncfile.$(ARCH).o \
 $(SRC)/BrightCatalog.$(ARCH).o
-#$(SRC)/FitChip.$(ARCH).o             \
-#$(SRC)/FitMosaic.$(ARCH).o           \
-#$(SRC)/UpdateChips.$(ARCH).o         \
-#$(SRC)/UpdateMosaic.$(ARCH).o        \
-#$(SRC)/UpdateSimple.$(ARCH).o        \
-#$(SRC)/write_coords.$(ARCH).o        \
-#$(SRC)/FixProblemImages.$(ARCH).o    \
-#$(SRC)/StarMaps.$(ARCH).o    \
 $(RELASTRO_CLIENT): $(INC)/relastro.h

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/doc/pv2.txt

-              r37038
+              r37822
+.10.28
+Going over the sequence of steps in relastro.  I'm concerned that the
+iteration is not modifying the measure.R,D values, preventing any
+actual iterative improvements.
+* UpdateObjects : takes measure.R,D to calculate average.R,D and
+  motion terms
+* ImageOps :
+  * getImageRaw : takes measure.X,Y, applies image.coords to get (L,M),
+                  (P,Q), etc, calculates
+  * getImageRef : takes average.R,D, applies image.coords to get
+                  (P,Q), (L,M), etc
+  * FitChip : fit raw.X,Y to ref.L,M, plus residual map (dX,dY)
+  *** modified raw.L,M values are then dropped and not used to update measure.R.D
 .07.03

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/include/relastro.h

-              r37038
+              r37822
 typedef struct {
   float R;
   float D;
+  double R;
+  double D;
   unsigned int objID;
   unsigned int catID;
 } MeanPos;
+typedef struct {
+  double R;
+  double D;
+  unsigned int objID;
+  unsigned int catID;
+  unsigned int imageID;
+} MeasPos;
 typedef struct {
 …
   int nFitAstrom;
   int flags;
+  float refColorBlue;
+  float refColorRed;
 } ImagePos;
 …
 } StatType;
+typedef struct {
+  off_t Nave;
+  off_t Npm;
+  off_t Npar;
+  off_t Nskip;
+  off_t Noffset;
+} FitStats;
+typedef struct {
+  double scale;
+  double **Roff;
+  double **Doff;
+  double  *dR;
+  int *Nra;
+  int Ndec;
+} FrameCorrectionType;
+typedef struct {
+  // AstromOffsetMap *map;
+  Coords *coords; // carries a pointer to the AstromOffsetMap
+  FrameCorrectionType *frame;
+} FrameCorrectionSet;
+typedef struct {
+  double *Rave;
+  double *Dave;
+  double *dRoff;
+  double *dDoff;
+  int Nicrfobj;
+} ICRFobj;
 /* global variables set in parameter file */
 # define DVO_MAX_PATH 1024
 …
 double MIN_ERROR;
+int    IMFIT_TOO_FEW; // need more than this number of stars to fit an image
 int    IMFIT_CLIP_NITER; // number of clipping iterations to perform in FitChip
 double IMFIT_CLIP_NSIGMA; // number of sigma to clip in FitChip
 …
 int    USE_FIXED_PIXCOORDS;
+int    USE_GALAXY_MODEL;
+int    USE_ICRF_CORRECT;
+int    USE_ICRF_LOCAL;
+int    USE_ICRF_SHFIT;
+int    USE_ICRF_POLE;
 int    RESET;
+int    RESET_IMAGES;
 int    RESET_BAD_IMAGES;
 int    NLOOP;
 …
 int    PLOTDELAY;
 int    CHIPORDER;
+int    CHIPMAP;
 int MaxDensityUse;
 …
 int    CLIP_THRESH;
 int USE_BASIC_CHECK;
+int APPLY_OFFSETS; // in parallel-regions mode, do not launch UpdateObjectOffsets unless -apply-offsets is called
 int ExcludeBogus;
 …
 void FitSimple (StarData *raw, StarData *ref, int Nmatch, Coords *coords);
 void initObjectData (Catalog *catalog, int Ncatalog);
 int UpdateObjects (Catalog *catalog, int Ncatalog);
+int UpdateObjects (Catalog *catalog, int Ncatalog, int Nloop);
 int UpdateSimple (Catalog *catalog, int Ncatalog);
 int UpdateChips (Catalog *catalog, int Ncatalog);
 …
 StarData *getImageRef (Catalog *catalog, int Ncatalog, off_t im, off_t *Nstars, CoordMode mode);
 StarData *getImageRaw (Catalog *catalog, int Ncatalog, off_t im, off_t *Nstars, CoordMode mode);
+int setImageRaw (Catalog *catalog, int Ncatalog, off_t im, StarData *raw, off_t Nraw, CoordMode mode);
 off_t getImageByID (off_t ID);
+int updateImageRaw (Catalog *catalog, int Ncatalog, off_t im);
 Mosaic *getmosaics (off_t *N);
 …
 int relastroGetVisual(void);
-int FixProblemImages (SkyList *skylist);
 int *getCatlist (int *N, off_t im);
+void initCoords (void);
+void getOffsets (double *dPos, off_t *nPos, off_t N);
+void saveOffsets (double dPos, off_t nPos, off_t N);
+void setBadCoords (off_t N);
+int badCoords (off_t N);
+Coords *getCoords (off_t N);
+int saveCoords (Coords *coords, off_t N);
+void resetImageRaw (Catalog *catalog, int Ncatalog, off_t im);
+void SaveCoords (Coords *tgt, Coords *src);
+void RestoreCoords (Coords *tgt, Coords *src, Image *image);
 int high_speed_catalogs (SkyTable *sky, SkyList *skylist, int hostID, char *hostpath);
 …
 int checkStarMap(int N);
 int createStarMap (Catalog *catalog, int Ncatalog);
+int printStarMap(int N, char *filename);
 int GetScatterRawRef(float *dLsig, float *dMsig, float *dRsig, int *nKeep, StarData *raw, StarData *ref, int Nstars, float SigmaLimit);
 …
 MeanPos *MeanPosLoad(char *filename, off_t *nmeanpos);
+int share_meas_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop);
+int slurp_meas_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop);
+int set_meas_pos (MeasPos *measpos, Average *average, MeasureTiny *measure);
+MeasPos *merge_meas_pos (MeasPos *target, int *ntarget, MeasPos *source, int Nsource);
+int MeasPosSave(char *filename, MeasPos *measpos, off_t Nmeaspos);
+MeasPos *MeasPosLoad(char *filename, off_t *nmeaspos);
 int indexCatalogs (Catalog *catalog, int Ncatalog);
 int catID_and_objID_to_seq (int catID, int objID, int *catSeq, off_t *objSeq);
 …
 int share_image_pos (RegionHostTable *regionHosts, int nloop);
 int slurp_image_pos (RegionHostTable *regionHosts, int nloop);
+int slurp_image_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop);
 ImagePos *merge_image_pos (ImagePos *target, int *ntarget, ImagePos *source, int Nsource);
 int set_image_pos (ImagePos *image_pos, Image *image);
 …
 int areImagesLoaded ();
 int areImagesMatched ();
+int isGPC1chip (int photcode);
+int isGPC1stack (int photcode);
+int isGPC1warp (int photcode);
+int save_astrom_table ();
+AstromOffsetTable *get_astrom_table ();
+void put_astrom_table (AstromOffsetTable *myTable);
+int fit_map (AstromOffsetMap *map, StarData *raw, StarData *ref, int Npts);
+// ICRF QSOs : these must be marked in the database (flag on average, flag on measure)
+void ICRFinit ();
+int ICRFsave (int cat, int ave, int meas);
+int ICRFdata (int n, int *cat, int *ave, int *meas);
+int ICRFmax ();
+int select_catalog_ICRF (Catalog *catalog, int Ncatalog);
+void ICRFobjFree (ICRFobj *icrfobj);
+ICRFobj *get_ICRF_data (Catalog *catalog, int Ncatalog);
+ICRFobj *merge_icrf_obj (ICRFobj *target, ICRFobj *source);
+ICRFobj *slurp_icrf_obj (RegionHostTable *regionHosts, int nloop);
+int share_icrf_obj (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop);
+int ICRFobjSave(char *filename, ICRFobj *icrfobj);
+ICRFobj *ICRFobjLoad(char *filename);
+int SHfitWithMask (double *R, double *D, double *value, int *mask, int Npts, SHterms *fit);
+FrameCorrectionType *FrameCorrectionInit (double scale);
+void FrameCorrectionFree (FrameCorrectionType *frame);
+int FrameCorrectionParallelMaster (RegionHostTable *regionHosts);
+int FrameCorrectionParallelSlave (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop);
+int FrameCorrectionSerial (Catalog *catalog, int Ncatalog);
+FrameCorrectionSet *FrameCorrectionMeasure (ICRFobj *icrfobj);
+int FrameCorrectionFromSH (FrameCorrectionType *frame, SHterms *dR, SHterms *dD);
+Coords *FrameCorrectionImageToMap (Header *header, Matrix *matrix, Coords *coords, int raDirection);
+int FrameCorrectionMapToImage (Header *header, Matrix *matrix, Coords *coords, int raDirection);
+int FrameCorrectionSHtoImage (Header *header, Matrix *matrix, FrameCorrectionType *frame, int raDirection);
+FrameCorrectionType *FrameCorrectionImageToSH (Header *header, Matrix *matrix, FrameCorrectionType *frame, int raDirection);
+int FrameCorrectionFromSH (FrameCorrectionType *frame, SHterms *dR, SHterms *dD);
+void FrameCorrectionFree (FrameCorrectionType *frame);
+FrameCorrectionType *FrameCorrectionInit (double scale);
+void FrameCorrectionSetFree (FrameCorrectionSet *set);
+FrameCorrectionSet *FrameCorrectionSetInit ();
+int FrameCorrectionSetSave(char *filename, FrameCorrectionSet *set);
+FrameCorrectionSet *FrameCorrectionSetLoad(char *filename);
+int FrameCorrectionFitSH (ICRFobj *icrfobj, SHterms *dRc, SHterms *dDc);
+int FrameCorrectionFitLocal (ICRFobj *icrfobj, Coords *coords);
+int FrameCorrectionApply (Catalog *catalog, int Ncatalog, FrameCorrectionType *frame, Coords *coords);
+int dump_stardata_pts (StarData *raw, int Npts, char *filename);
+void printNcatTotal ();
+int HarvestRegionHosts (RegionHostTable *regionHosts);
+void lockUpdateChips ();
+void unlockUpdateChips ();
+int client_logger_init (char *dirname);
+int client_logger_message (char *format,...);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/BrightCatalog.c

-              r37038
+              r37822
   if (!gfits_fread_header (f, &header)) {
     if (VERBOSE) fprintf (stderr, "can't read image subset header\n");
-    fclose (f);
     goto escape;
+  }
   if (!gfits_fread_matrix (f, &matrix, &header)) {
     if (VERBOSE) fprintf (stderr, "can't read image subset matrix\n");
-    gfits_free_header (&header);
-    fclose (f);
     goto escape;
+  }
 …
     GET_COLUMN(R,         "RA",         double);
     GET_COLUMN(D,         "DEC",        double);
+    GET_COLUMN(RoffGAL,   "ROFF_GAL",   float);
+    GET_COLUMN(DoffGAL,   "DOFF_GAL",   float);
     GET_COLUMN(M,         "MAG_SYS",    float);
     GET_COLUMN(Mcal,      "MAG_CAL",    float);
 …
       measure[i].R         = R[i];
       measure[i].D         = D[i];
+      measure[i].RoffGAL   = RoffGAL[i];
+      measure[i].DoffGAL   = DoffGAL[i];
       measure[i].M         = M[i];
       measure[i].Mcal      = Mcal[i];
 …
     free (R       );
     free (D       );
+    free (RoffGAL );
+    free (DoffGAL );
     free (M       );
     free (Mcal    );
 …
   if (catalog) free (catalog);
   fclose (f);
+  if (f) fclose (f);
   return NULL;
+}
 …
     gfits_create_table_header (&theader, "BINTABLE", "MEASURE_TINY");
+    gfits_define_bintable_column (&theader, "E", "RA_OFF",   "ra offset",                  "arcsec", 1.0, 0.0);
+    gfits_define_bintable_column (&theader, "E", "DEC_OFF",  "dec offset",                 "arcsec", 1.0, 0.0);
+    gfits_define_bintable_column (&theader, "D", "RA",       "ra",                         "degrees", 1.0, 0.0);
+    gfits_define_bintable_column (&theader, "D", "DEC",      "dec",                        "degrees", 1.0, 0.0);
+    gfits_define_bintable_column (&theader, "E", "ROFF_GAL", "ra offset",                  "arcsec", 1.0, 0.0);
+    gfits_define_bintable_column (&theader, "E", "DOFF_GAL", "dec offset",                 "arcsec", 1.0, 0.0);
     gfits_define_bintable_column (&theader, "E", "MAG_SYS",  "magnitude (sys)",             NULL,    1.0, 0.0);
     gfits_define_bintable_column (&theader, "E", "MAG_CAL",  "magnitude (cal)",             NULL,    1.0, 0.0);
 …
     double *R         ; ALLOCATE (R        ,  double, catalog->Nmeasure);
     double *D         ; ALLOCATE (D        ,  double, catalog->Nmeasure);
+    float  *RoffGAL   ; ALLOCATE (RoffGAL  ,  float,  catalog->Nmeasure);
+    float  *DoffGAL   ; ALLOCATE (DoffGAL  ,  float,  catalog->Nmeasure);
     float  *M         ; ALLOCATE (M        ,  float,  catalog->Nmeasure);
     float  *Mcal      ; ALLOCATE (Mcal     ,  float,  catalog->Nmeasure);
 …
       R[i]        = measure[i].R        ;
       D[i]        = measure[i].D        ;
+      RoffGAL[i]  = measure[i].RoffGAL  ;
+      DoffGAL[i]  = measure[i].DoffGAL  ;
       M[i]        = measure[i].M        ;
       Mcal[i]     = measure[i].Mcal     ;
 …
     gfits_set_bintable_column (&theader, &ftable, "RA",         R,         catalog->Nmeasure);
     gfits_set_bintable_column (&theader, &ftable, "DEC",        D,         catalog->Nmeasure);
+    gfits_set_bintable_column (&theader, &ftable, "ROFF_GAL",   RoffGAL,   catalog->Nmeasure);
+    gfits_set_bintable_column (&theader, &ftable, "DOFF_GAL",   DoffGAL,   catalog->Nmeasure);
     gfits_set_bintable_column (&theader, &ftable, "MAG_SYS",    M,         catalog->Nmeasure);
     gfits_set_bintable_column (&theader, &ftable, "MAG_CAL",    Mcal,      catalog->Nmeasure);
 …
     free (R       );
     free (D       );
+    free (RoffGAL );
+    free (DoffGAL );
     free (M       );
     free (Mcal    );

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/ConfigInit.c

-              r36630
+              r37822
   if (!ScanConfig (config, "RELASTRO_IMFIT_CLIP_NSIGMA",   "%lf", 0, &IMFIT_CLIP_NSIGMA))   IMFIT_CLIP_NSIGMA = 3.0;
   if (!ScanConfig (config, "RELASTRO_IMFIT_SYS_SIGMA_LIM", "%lf", 0, &IMFIT_SYS_SIGMA_LIM)) IMFIT_SYS_SIGMA_LIM = 0.01;
+  if (!ScanConfig (config, "RELASTRO_IMFIT_TOO_FEW",       "%d",  0, &IMFIT_TOO_FEW))       IMFIT_TOO_FEW = 5;
   if (!ScanConfig (config, "PM_DT_MIN",              "%lf", 0, &PM_DT_MIN))        PM_DT_MIN = 0.25;
 …
   if (!ScanConfig (config, "USE_FIXED_PIXCOORDS", "%d", 0, &USE_FIXED_PIXCOORDS))  USE_FIXED_PIXCOORDS = FALSE;
+  if (!ScanConfig (config, "USE_GALAXY_MODEL",    "%d", 0, &USE_GALAXY_MODEL))     USE_GALAXY_MODEL = FALSE;
+  if (!ScanConfig (config, "USE_ICRF_CORRECT",    "%d", 0, &USE_ICRF_CORRECT))     USE_ICRF_CORRECT = FALSE;
+  if (!ScanConfig (config, "USE_ICRF_LOCAL",      "%d", 0, &USE_ICRF_LOCAL))       USE_ICRF_LOCAL = FALSE;
+  if (!ScanConfig (config, "USE_ICRF_SHFIT",      "%d", 0, &USE_ICRF_SHFIT))       USE_ICRF_SHFIT = FALSE;
+  if (!ScanConfig (config, "USE_ICRF_POLE",       "%d", 0, &USE_ICRF_POLE))        USE_ICRF_POLE = FALSE;
   // force CATDIR to be absolute (so parallel mode will work)

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/FitChip.c

-              r37038
+              r37822
   for (Niter = 0; Niter < IMFIT_CLIP_NITER; Niter ++) {
     // measure the scatter for the unmarked (good) measurements with dM < limit
     // SIGMA_LIM here is redundant with ImageOps.c:915
 …
     // use that count to set order_use below
+    // 20140925 : the same logic below is used to constrain the dimensions of the image map
     // figures to assess the fitting process:
     // x vs dx, x vs dy, y vs dx, y vs dy :
     // residual vector field
     // dx vs mag, dy vs mag
+    if (relastroGetVisual()) {
+      fprintf (stderr, "fitting chip %s, %d matched stars\n", image->name, Nmatch);
+    }
     relastroVisualPlotChipFit(raw, ref, dRmax, Nmatch);
+    // for polynomial fits, I used (5,30,60) = (5,6,7) stars per term
     // set the maximum order for the polynomial (based on number of stars kept above)
     int order_use = 0;
+    if (Nkeep >  5) order_use = 1; // 4 stars per polynomial term (per dimension)
+    if (Nkeep > 30) order_use = 2; // 5 stars per polynomial term (per dimension)
+    if (Nkeep > 60) order_use = 3; // 6 stars per polynomial term (per dimension)
+    if (Nkeep >   5) order_use = 1; //  5 stars per cell
+    if (Nkeep >  24) order_use = 2; //  6 stars per cell
+    if (Nkeep >  63) order_use = 3; //  7 stars per cell
+    if (Nkeep > 128) order_use = 4; //  8 stars per cell
+    if (Nkeep > 225) order_use = 5; //  9 stars per cell
+    if (Nkeep > 360) order_use = 6; // 10 stars per cell
     if (order_use < 1) {
       if (VERBOSE2) fprintf (stderr, "insufficient measurements (%d) for linear fit\n", Nkeep);
 …
       return FALSE;
+    }
+    image[0].coords.Npolyterms = order_use;
+    if (CHIPMAP) {
+      order_use = MIN(MIN(order_use, CHIPMAP), 6); // can only go up to 6th order map (can be user limited)
+    } else {
+      order_use = MIN(order_use, 3); // can only go up to 3rd order for polynomials
+    }
+    if (VERBOSE2) fprintf (stderr, "using %d for %s\n", order_use, image[0].name);
+    // when fitting the map, first fit a linear model (below? change Npolyterms to -1)
+    image[0].coords.Npolyterms = CHIPMAP ? 1 : order_use;
     if (fit) fit_free (fit);
 …
+    }
+    // apply fit to get the fitted X,Y coordinates.  we need these to fit the residual map below
     for (i = 0; i < Nmatch; i++) {
+      // we have not yet fitted the map, so Npolyterms needs to be 1 here:
+      LM_to_XY (&ref[i].X, &ref[i].Y, ref[i].L, ref[i].M, &image[0].coords);
+    }
+    if (CHIPMAP) {
+      if (image[0].coords.offsetMap == NULL) {
+        // allocate a new table and assign to this image
+        // need to lock threads here because 'table' is a static with
+        // modifiable elements
+        lockUpdateChips ();
+        AstromOffsetTable *table = get_astrom_table ();
+        AstromOffsetTableNewMap(table, order_use, order_use, image);
+        unlockUpdateChips ();
+      }
+      // XXX Need to check / update the order of the map here.  if we already have a map, it might have been
+      // allocated with too small arrays
+      AstromOffsetMapSetOrder (image[0].coords.offsetMap, order_use, order_use, image);
+      image[0].coords.offsetMap->keep = TRUE; // if we are trying or re-trying this map, we should keep it unless it fails
+      fit_map (image[0].coords.offsetMap, raw, ref, Nmatch);
+      image[0].coords.Npolyterms = -1;
+    }
+    if (!strcmp(image[0].name, "o5745g0403o.356777.cm.982487.smf[XY17.hdr]")) {
+      fprintf (stderr, "test image\n");
+    }
+    for (i = 0; i < Nmatch; i++) {
+      // if we have fitted the map above, Npolyterms needs to be -1 here:
       XY_to_LM (&raw[i].L, &raw[i].M, raw[i].X, raw[i].Y, &image[0].coords);
+    }
+  }
 …
    L,M -> X,Y (polynomial transformation : WRP)
 Some details about this function:
 - the initial value of the clipping radius is set based on the distribution of the dR
   values for the bright sources.
 - NITER clipping passes are performed
 - the per-star astrometric errors are included in the fit.  The photcode table controls
   whether only the reported positional errors are used, or if the magnitudes errors are
   scaled to determine the error, and if there is a systematic floor for all sources.
 - input detections are pre-filtered on the basis of the photFlags, etc, in bcatalog
 - outlying detections are clipped in the iterative passes, but the clipped detections are
   not recorded
+   Some details about this function:
+   - the initial value of the clipping radius is set based on the distribution of the dR
+   values for the bright sources.
+   - NITER clipping passes are performed
+   - the per-star astrometric errors are included in the fit.  The photcode table controls
+   whether only the reported positional errors are used, or if the magnitudes errors are
+   scaled to determine the error, and if there is a systematic floor for all sources.
+   - input detections are pre-filtered on the basis of the photFlags, etc, in bcatalog
+   - outlying detections are clipped in the iterative passes, but the clipped detections are
+   not recorded
 */
 …
 /* example using fit_apply() :
+  f = fopen ("test3.dat", "w");
+  // apply new coords to raw (X,Y -> L,M)
+  for (i = 0; i < Nmatch; i++) {
+    fprintf (f, "%f %f  %f %f  ", raw[i].X, raw[i].Y, raw[i].L, raw[i].M);
+    fit_apply (newfit, &L1, &M1, raw[i].X - coords[0].crpix1, raw[i].Y - coords[0].crpix2);
+    fprintf (f, "%f %f\n", L1, M1);
+   f = fopen ("test3.dat", "w");
+   // apply new coords to raw (X,Y -> L,M)
+   for (i = 0; i < Nmatch; i++) {
+   fprintf (f, "%f %f  %f %f  ", raw[i].X, raw[i].Y, raw[i].L, raw[i].M);
+   fit_apply (newfit, &L1, &M1, raw[i].X - coords[0].crpix1, raw[i].Y - coords[0].crpix2);
+   fprintf (f, "%f %f\n", L1, M1);
+   }
+   fclose (f);
+*/
+int fit_map (AstromOffsetMap *map, StarData *raw, StarData *ref, int Npts) {
+  // we are actually fitting the residual after the linear fit has been taken off
+  // fit the linear terms as above
+  // calculate dX (raw.X - ref.X) and dY
+  int i, N;
+  float *x, *y, *dX, *dY;
+  ALLOCATE (x,  float, Npts);
+  ALLOCATE (y,  float, Npts);
+  ALLOCATE (dX, float, Npts);
+  ALLOCATE (dY, float, Npts);
+  N = 0;
+  for (i = 0; i < Npts; i++) {
+    if (raw[i].mask) continue;
+    x[N] = raw[i].X;
+    y[N] = raw[i].Y;
+    dX[N] = ref[i].X - raw[i].X;
+    dY[N] = ref[i].Y - raw[i].Y;
+    N++;
+  }
+  // in coordsops.c:XY_to_LM, the map is defined to carry dX,dY so that:
+  // (L,M) = f(X',Y') : (X',Y') = (X,Y) + (dX,dY)
+  AstromOffsetMapFit (map, x, y, dX, N, TRUE);
+  AstromOffsetMapFit (map, x, y, dY, N, FALSE);
+  AstromOffsetMapRepair (map, TRUE);
+  AstromOffsetMapRepair (map, FALSE);
+  free (x);
+  free (y);
+  free (dX);
+  free (dY);
+  return TRUE;
+}
+int dump_stardata_pts (StarData *raw, int Npts, char *filename) {
+  FILE *f = fopen (filename, "w");
+  if (!f) {
+    fprintf (stderr, "failed to open file %s\n", filename);
+    return FALSE;
+  }
+  int i;
+  for (i = 0; i < Npts; i++) {
+    fprintf (f, "%4d %10.6f %10.6f  %10.6f %10.6f  %9.2f %9.2f  %9.2f %9.2f  %9.4f %3d\n",
+             i, raw[i].R, raw[i].D, raw[i].P, raw[i].Q, raw[i].L, raw[i].M, raw[i].X, raw[i].Y, raw[i].dPos, raw[i].mask);
+  }
   fclose (f);
+*/
+  return TRUE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/ImageOps.c

-              r37038
+              r37822
 static off_t        *imageIDs; // list of all image IDs
 static off_t        *imageIdx; // list of index for image IDs
+# else
+// as an alternative, we generate imageSeq, which directly maps imageID -> seq
+static off_t        *imageSeq; // list of index for image IDs
+// MAX_ID requires 512M to store the image index
+# define MAX_ID      0x8000000
+static off_t         minImageID = MAX_ID;
+static off_t         maxImageID = 0;
+# else /* not using IMAGE_ID */
 static unsigned int *start;
 static unsigned int *stop;
 …
     imageIdx[i] = i;
     imageIDs[i] = image[i].imageID;
+    minImageID = MIN(minImageID, image[i].imageID);
+    maxImageID = MAX(maxImageID, image[i].imageID);
+    myAssert (image[i].imageID < MAX_ID, "image IDs too large for index memory");
+  }
   llsortpair (imageIDs, imageIdx, Nimage);
+  ALLOCATE (imageSeq, off_t, maxImageID + 1);
+  for (i = 0; i < maxImageID + 1; i++)  {
+    imageSeq[i] = -1; // not yet assigned
+  }
+  for (i = 0; i < Nimage; i++) {
+    off_t N = image[i].imageID;
+    myAssert (imageSeq[N] == -1, "previously assigned");
+    imageSeq[N] = i;
+  }
 # else
   ALLOCATE (start, unsigned, Nimage);
 …
 off_t getImageByID (off_t ID) {
+# if USE_IMAGE_ID
+  if (imageSeq) {
+    if (ID < minImageID) return (-1);
+    if (ID > maxImageID) return (-1);
+    off_t N = imageSeq[ID];
+    return N;
+  }
   // we have a pair of vectors (imageIDs, imageIdx) sorted by imageIDs
   // use bisection to find the specified image ID
-# if USE_IMAGE_ID
   off_t Nlo, Nhi, N;
 …
     if (VERBOSE2 || (MATCHCAT && (N_onImage[i] < 20))) {
       name = GetPhotcodeNamebyCode (image[i].photcode);
+      fprintf (stderr, "image "OFF_T_FMT" (%d, %s) has "OFF_T_FMT" of %d measures (%s, %s)",  i,  image[i].imageID, image[i].name, N_onImage[i], image[i].nstar,
+      int showExample = (Nfew < 30);
+      if (showExample) fprintf (stderr, "image "OFF_T_FMT" (%d, %s) has "OFF_T_FMT" of %d measures (%s, %s) ",  i,  image[i].imageID, image[i].name, N_onImage[i], image[i].nstar,
                ohana_sec_to_date(image[i].tzero), name);
       if (N_onImage[i] < 20) {
         fprintf (stderr, "*");
+        if (showExample) fprintf (stderr, "*");
         Nfew ++;
+      }
       if (N_onImage[i] < 15) {
         fprintf (stderr, "*** warning ***");
+        if (showExample) fprintf (stderr, "*** warning ***");
         Nbad ++;
+      }
       fprintf (stderr, "\n");
+    }
+  }
   fprintf (stderr, OFF_T_FMT" total images, %d with < 20 measurements, %d with < 15\n", Nimage, Nfew, Nbad);
+      if (showExample) fprintf (stderr, "\n");
+    }
+  }
+  if (MATCHCAT) fprintf (stderr, OFF_T_FMT" total images, %d with < 20 measurements, %d with < 15\n", Nimage, Nfew, Nbad);
+}
 …
+  }
+  if (!ID) return; // detection not associated with an image
   idx = getImageByID (ID);
   if (idx == -1) {
 …
     return;
+  }
+  measure->myDet = TRUE; // I 'own' this detection (I am calibrating its image)
   // index for (catalog, measure) -> image
 …
 # endif
-/*
-Coords *getCoords (off_t meas, int cat) {
-  off_t i;
-  i = MeasureToImage[cat][meas];
-  if (i == -1) return (NULL);
-  return (&image[i].coords);
+}
-*/
 float getColorBlue (off_t meas, int cat) {
 …
   Coords *moscoords, *imcoords;
-  // check if this image is bad and should be skipped
-  if (badCoords(im)) return;
   // WRP images need to have an associated mosaic
   moscoords = NULL;
 …
     int TESTPT = FALSE;
+    TESTPT |= CAT_ID_SRC && OBJ_ID_SRC && (measure->imageID == CAT_ID_SRC) && (measure->detID == OBJ_ID_SRC);
+    TESTPT |= CAT_ID_DST && OBJ_ID_DST && (measure->imageID == CAT_ID_DST) && (measure->detID == OBJ_ID_DST);
+    TESTPT |= CAT_ID_SRC && OBJ_ID_SRC && (measure->catID == CAT_ID_SRC) && (measure->objID == OBJ_ID_SRC);
+    TESTPT |= CAT_ID_DST && OBJ_ID_DST && (measure->catID == CAT_ID_DST) && (measure->objID == OBJ_ID_DST);
     if (TESTPT) {
       fprintf (stderr, "got test det\n");
 …
   int Noff = NoffRAave + NoffDECave + NoffRAori + NoffDECori;
   if (VERBOSE2 && (Noff > 0)) fprintf (stderr, "Noff ave RA %d, Noff ave DEC %d, Noff ori RA %d, Noff ori DEC %d\n", NoffRAave, NoffDECave, NoffRAori, NoffDECori);
-  saveOffsets (dPos, nPos, im);
   return;
 …
 void printNcatTotal () {
   fprintf (stderr, "NcatTotal: %d\n", NcatTotal);
+}
-// return StarData values for detections in the specified image, converting coordinates from the
-// chip positions: X,Y -> L,M -> P,Q -> R,D
-void resetImageRaw (Catalog *catalog, int Ncatalog, off_t im) {
-  off_t i, m, c, n;
-  double X, Y, L, M, P, Q, R, D;
-  Mosaic *mosaic;
-  Coords *moscoords, *imcoords, *oldcoords;
-  fprintf (stderr, "fix resetImageRaw wrt MeasureTiny\n");
-  abort();
-  // check if this image is bad and should be skipped
-  if (!badCoords(im)) {
-    fprintf (stderr, "ERROR: inconsistent result?");
-    abort();
+  }
-  // replace the current coords with the old coords:
-  oldcoords = getCoords (im);
-  memcpy (&image[im].coords, oldcoords, sizeof(Coords));
-  // WRP images need to have an associated mosaic
-  moscoords = NULL;
-  if (!strcmp(&image[im].coords.ctype[4], "-WRP")) {
-    mosaic = getMosaicForImage (im);
-    if (mosaic == NULL) return;  // if we cannot find the associated image, skip it
-    moscoords = &mosaic[0].coords;
+  }
-  imcoords = &image[im].coords;
-  for (i = 0; i < N_onImage[im]; i++) {
-    m = ImageToMeasure[im][i];
-    c = ImageToCatalog[im][i];
-    // XXX unclear if this should use Measure or MeasureTiny; it is only called by FixProblemImages, which has not been updated
-    Measure *measure = &catalog[c].measure[m];
-    X = measure[0].Xccd;
-    Y = measure[0].Yccd;
-    if (USE_FIXED_PIXCOORDS) {
-      if (isfinite(measure[0].Xfix) && isfinite(measure[0].Yfix)) {
-        float dX = measure[0].Xfix - measure[0].Xccd;
-        float dY = measure[0].Yfix - measure[0].Yccd;
-        if (hypot(dX,dY) < 2.0) {
-          X = measure[0].Xfix;
-          Y = measure[0].Yfix;
+        }
+      }
+    }
-    n = measure[0].averef;
-    if (moscoords == NULL) {
-      // this is a Simple image (not a mosaic)
-      // note that for a Simple image, L,M = P,Q
-      XY_to_LM (&L, &M, X, Y, imcoords);
-      LM_to_RD (&R, &D, L, M, imcoords);
-    } else {
-      XY_to_LM (&L, &M, X, Y, imcoords);
-      XY_to_LM (&P, &Q, L, M, moscoords);
-      LM_to_RD (&R, &D, P, Q, moscoords);
+    }
-    measure[0].R = R;
-    measure[0].D = D;
-    float dRoff = dvoOffsetR(measure, &catalog[c].average[n]);
-    if (dRoff > +180.0*3600.0) {
-      // average on high end of boundary, move star up
-      measure[0].R += 360.0;
-      dRoff -= 360.0*3600.0;
+    }
-    if (dRoff < -180.0*3600.0) {
-      measure[0].R -= 360.0;
-      dRoff += 360.0*3600.0;
+    }
+  }
-  return;
+}
 …
     n = measure[0].averef;
+    int TESTPT = FALSE;
+    TESTPT |= CAT_ID_SRC && OBJ_ID_SRC && (catalog[c].average[n].catID == CAT_ID_SRC) && (catalog[c].average[n].objID == OBJ_ID_SRC);
+    TESTPT |= CAT_ID_DST && OBJ_ID_DST && (catalog[c].average[n].catID == CAT_ID_DST) && (catalog[c].average[n].objID == OBJ_ID_DST);
+    if (TESTPT) {
+      fprintf (stderr, "got test det\n");
+    }
     // an object with only one detection provides no information about the image calibration
 …
     ref[i].D = catalog[c].average[n].D;
+    // if we are correcting for the Galaxy Motion Model, we assume the mean R,D is at the J2000 epoch position
+    if (USE_GALAXY_MODEL) {
+      myAssert (!isnan(measure[0].RoffGAL), "oops");
+      myAssert (!isnan(measure[0].DoffGAL), "oops");
+      ref[i].R += measure[0].RoffGAL / 3600.0;
+      ref[i].D += measure[0].DoffGAL / 3600.0;
+    }
     ref[i].Mag  = measure[0].M;
     ref[i].dMag = measure[0].dM;
 …
   *Nstars = N_onImage[im];
   return (ref);
+}
+// return StarData values for detections in the specified image, converting coordinates from the
+// chip positions: X,Y -> L,M -> P,Q -> R,D.  This function is used by the image fitting steps, for
+// which the detections have already been filtered when they were loaded (bcatalog)
+int setImageRaw (Catalog *catalog, int Ncatalog, off_t im, StarData *raw, off_t Nraw, CoordMode mode) {
+  off_t i, m, c;
+  Coords *moscoords;
+  moscoords = NULL;
+  if (mode == MODE_MOSAIC) {
+    moscoords = image[im].coords.mosaic;
+    myAssert (moscoords, "coords.mosaic not defined for image %s (%d)", image[im].name, (int) im);
+  }
+  myAssert (Nraw == N_onImage[im], "impossible!");
+  for (i = 0; i < N_onImage[im]; i++) {
+    m = ImageToMeasure[im][i];
+    c = ImageToCatalog[im][i];
+    // XXX should I use the raw coords or just measure.X,Y -> R,D?
+    switch (mode) {
+      case MODE_SIMPLE:
+        /* note that for a Simple image, L,M = P,Q */
+        XY_to_LM (&raw[i].L, &raw[i].M, raw[i].X, raw[i].Y, &image[im].coords);
+        raw[i].P = raw[i].L;
+        raw[i].Q = raw[i].M;
+        LM_to_RD (&raw[i].R, &raw[i].D, raw[i].P, raw[i].Q, &image[im].coords);
+        break;
+      case MODE_MOSAIC:
+        XY_to_LM (&raw[i].L, &raw[i].M, raw[i].X, raw[i].Y, &image[im].coords);
+        XY_to_LM (&raw[i].P, &raw[i].Q, raw[i].L, raw[i].M, moscoords);
+        LM_to_RD (&raw[i].R, &raw[i].D, raw[i].P, raw[i].Q, moscoords);
+        break;
+      default:
+        fprintf (stderr, "error: invalid mode in getImageRaw");
+        abort ();
+    }
+    MeasureTiny *measure = &catalog[c].measureT[m];
+    measure->R = raw[i].R;
+    measure->D = raw[i].D;
+    if (catalog[c].measure) {
+      catalog[c].measure[m].R = raw[i].R;
+      catalog[c].measure[m].D = raw[i].D;
+    }
+  }
+  return TRUE;
+}
+// return StarData values for detections in the specified image, converting coordinates from the
+// chip positions: X,Y -> L,M -> P,Q -> R,D.  This function is used by the image fitting steps, for
+// which the detections have already been filtered when they were loaded (bcatalog)
+int updateImageRaw (Catalog *catalog, int Ncatalog, off_t im) {
+  off_t i, m, c;
+  for (i = 0; i < N_onImage[im]; i++) {
+    m = ImageToMeasure[im][i];
+    c = ImageToCatalog[im][i];
+    MeasureTiny *measure = &catalog[c].measureT[m];
+    /* apply the current image transformation or use the current value of R+dR, D+dD? */
+    double X = measure[0].Xccd;
+    double Y = measure[0].Yccd;
+    if (USE_FIXED_PIXCOORDS) {
+      if (isfinite(measure[0].Xfix) && isfinite(measure[0].Yfix)) {
+        float dX = measure[0].Xfix - measure[0].Xccd;
+        float dY = measure[0].Yfix - measure[0].Yccd;
+        if (hypot(dX,dY) < 2.0) {
+          X = measure[0].Xfix;
+          Y = measure[0].Yfix;
+        }
+      }
+    }
+    double R, D;
+    XY_to_RD (&R, &D, X, Y, &image[im].coords);
+    measure->R = R;
+    measure->D = D;
+    if (catalog[c].measure) {
+      catalog[c].measure[m].R = R;
+      catalog[c].measure[m].D = D;
+    }
+  }
+  return TRUE;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/ImagePosIO.c

-              r36630
+              r37822
   GET_COLUMN (polyterms,        "POLYTERMS",         float); // verify that we got 14 columns?
   GET_COLUMN (ctype,            "CTYPE",             char);  // verify that we got 15 columns?
   GET_COLUMN (Npolyterms,       "NPOLYTERMS",        char);
+  GET_COLUMN (Npolyterms,       "NPOLYTERMS",        byte);
   GET_COLUMN (dXpixSys,         "XPIX_SYS_ERR",      float);
   GET_COLUMN (dYpixSys,         "YPIX_SYS_ERR",      float);
+  GET_COLUMN (refColorBlue,     "REF_COLOR_BLUE",    float);
+  GET_COLUMN (refColorRed,      "REF_COLOR_RED",     float);
   GET_COLUMN (imageID,          "ID",                int);
   GET_COLUMN (nFitAstrom,       "NFIT",              int);
 …
   ALLOCATE (image_pos, ImagePos, Nrow);
   for (i = 0; i < Nrow; i++) {
+    image_pos[i].coords.crval1             = crval1    [i];
+    image_pos[i].coords.crval2             = crval2    [i];
+    image_pos[i].coords.crpix1             = crpix1    [i];
+    image_pos[i].coords.crpix2             = crpix2    [i];
+    image_pos[i].coords.cdelt1             = cdelt1    [i];
+    image_pos[i].coords.cdelt2             = cdelt2    [i];
+    image_pos[i].coords.pc1_1              = pc1_1     [i];
+    image_pos[i].coords.pc1_2              = pc1_2     [i];
+    image_pos[i].coords.pc2_1              = pc2_1     [i];
+    image_pos[i].coords.pc2_2              = pc2_2     [i];
+    image_pos[i].coords.Npolyterms         = Npolyterms[i];
+    image_pos[i].dXpixSys                  = dXpixSys  [i];
+    image_pos[i].dYpixSys                  = dYpixSys  [i];
+    image_pos[i].imageID                   = imageID   [i];
+    image_pos[i].nFitAstrom                = nFitAstrom[i];
+    image_pos[i].flags                     = flags     [i];
+    InitCoords(&image_pos[i].coords, NULL);
+    image_pos[i].coords.crval1             = crval1      [i];
+    image_pos[i].coords.crval2             = crval2      [i];
+    image_pos[i].coords.crpix1             = crpix1      [i];
+    image_pos[i].coords.crpix2             = crpix2      [i];
+    image_pos[i].coords.cdelt1             = cdelt1      [i];
+    image_pos[i].coords.cdelt2             = cdelt2      [i];
+    image_pos[i].coords.pc1_1              = pc1_1       [i];
+    image_pos[i].coords.pc1_2              = pc1_2       [i];
+    image_pos[i].coords.pc2_1              = pc2_1       [i];
+    image_pos[i].coords.pc2_2              = pc2_2       [i];
+    image_pos[i].coords.Npolyterms         = Npolyterms  [i];
+    image_pos[i].dXpixSys                  = dXpixSys    [i];
+    image_pos[i].dYpixSys                  = dYpixSys    [i];
+    image_pos[i].refColorBlue              = refColorBlue[i];
+    image_pos[i].refColorRed               = refColorRed [i];
+    image_pos[i].imageID                   = imageID     [i];
+    image_pos[i].nFitAstrom                = nFitAstrom  [i];
+    image_pos[i].flags                     = flags       [i];
     // polyterms and ctype are a bit different
 …
   fprintf (stderr, "loaded data for %lld images\n", (long long) Nrow);
+  free (crval1    );
+  free (crval2    );
+  free (crpix1    );
+  free (crpix2    );
+  free (cdelt1    );
+  free (cdelt2    );
+  free (pc1_1     );
+  free (pc1_2     );
+  free (pc2_1     );
+  free (pc2_2     );
+  free (polyterms );
+  free (ctype     );
+  free (Npolyterms);
+  free (dXpixSys  );
+  free (dYpixSys  );
+  free (imageID   );
+  free (nFitAstrom);
+  free (flags     );
+  free (crval1      );
+  free (crval2      );
+  free (crpix1      );
+  free (crpix2      );
+  free (cdelt1      );
+  free (cdelt2      );
+  free (pc1_1       );
+  free (pc1_2       );
+  free (pc2_1       );
+  free (pc2_2       );
+  free (polyterms   );
+  free (ctype       );
+  free (Npolyterms  );
+  free (dXpixSys    );
+  free (dYpixSys    );
+  free (refColorBlue);
+  free (refColorRed );
+  free (imageID     );
+  free (nFitAstrom  );
+  free (flags       );
   *nimage_pos = Nrow;
 …
   gfits_create_table_header (&theader, "BINTABLE", "IMAGE_POS");
+  gfits_define_bintable_column (&theader, "D",   "CRVAL1",       "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "D",   "CRVAL2",       "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "CRPIX1",       "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "CRPIX2",       "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "CDELT1",       "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "CDELT2",       "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "PC1_1",        "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "PC1_2",        "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "PC2_1",        "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "PC2_2",        "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "14E", "POLYTERMS",    "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "15A", "CTYPE",        "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "L",   "NPOLYTERMS",   "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "XPIX_SYS_ERR", "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "YPIX_SYS_ERR", "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J",   "ID",           "image ID",               "unitless", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J",   "NFIT",         "number of fitted stars", "unitless", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J",   "FLAGS",        "analysis flags",         "unitless", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "D",   "CRVAL1",         "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "D",   "CRVAL2",         "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "CRPIX1",         "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "CRPIX2",         "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "CDELT1",         "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "CDELT2",         "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "PC1_1",          "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "PC1_2",          "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "PC2_1",          "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "PC2_2",          "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "14E", "POLYTERMS",      "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "15A", "CTYPE",          "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "L",   "NPOLYTERMS",     "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "XPIX_SYS_ERR",   "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "YPIX_SYS_ERR",   "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "REF_COLOR_BLUE", "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "E",   "REF_COLOR_RED",  "word", "unit", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J",   "ID",             "image ID",               "unitless", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J",   "NFIT",           "number of fitted stars", "unitless", 1.0, 0.0);
+  gfits_define_bintable_column (&theader, "J",   "FLAGS",          "analysis flags",         "unitless", 1.0, 0.0);
   // generate the output array that carries the data
   gfits_create_table (&theader, &ftable);
+  double *crval1    ;
+  double *crval2    ;
+  float  *crpix1    ;
+  float  *crpix2    ;
+  float  *cdelt1    ;
+  float  *cdelt2    ;
+  float  *pc1_1     ;
+  float  *pc1_2     ;
+  float  *pc2_1     ;
+  float  *pc2_2     ;
+  float  *polyterms ;
+  char   *ctype     ;
+  char   *Npolyterms;
+  float  *dXpixSys  ;
+  float  *dYpixSys  ;
+  int    *imageID   ;
+  int    *nFitAstrom;
+  int    *flags     ;
+  double *crval1      ;
+  double *crval2      ;
+  float  *crpix1      ;
+  float  *crpix2      ;
+  float  *cdelt1      ;
+  float  *cdelt2      ;
+  float  *pc1_1       ;
+  float  *pc1_2       ;
+  float  *pc2_1       ;
+  float  *pc2_2       ;
+  float  *polyterms   ;
+  char   *ctype       ;
+  char   *Npolyterms  ;
+  float  *dXpixSys    ;
+  float  *dYpixSys    ;
+  float  *refColorBlue;
+  float  *refColorRed ;
+  int    *imageID     ;
+  int    *nFitAstrom  ;
+  int    *flags       ;
   // create intermediate storage arrays
 …
   ALLOCATE (dXpixSys  ,         float ,          Nimage_pos);
   ALLOCATE (dYpixSys  ,         float ,          Nimage_pos);
+  ALLOCATE (refColorBlue,       float ,          Nimage_pos);
+  ALLOCATE (refColorRed ,       float ,          Nimage_pos);
   ALLOCATE (imageID   ,         int   ,          Nimage_pos);
   ALLOCATE (nFitAstrom,         int   ,          Nimage_pos);
 …
   // assign the storage arrays
   for (i = 0; i < Nimage_pos; i++) {
+    crval1    [i] = image_pos[i].coords.crval1    ;
+    crval2    [i] = image_pos[i].coords.crval2    ;
+    crpix1    [i] = image_pos[i].coords.crpix1    ;
+    crpix2    [i] = image_pos[i].coords.crpix2    ;
+    cdelt1    [i] = image_pos[i].coords.cdelt1    ;
+    cdelt2    [i] = image_pos[i].coords.cdelt2    ;
+    pc1_1     [i] = image_pos[i].coords.pc1_1     ;
+    pc1_2     [i] = image_pos[i].coords.pc1_2     ;
+    pc2_1     [i] = image_pos[i].coords.pc2_1     ;
+    pc2_2     [i] = image_pos[i].coords.pc2_2     ;
+    Npolyterms[i] = image_pos[i].coords.Npolyterms;
+    dXpixSys  [i] = image_pos[i].dXpixSys         ;
+    dYpixSys  [i] = image_pos[i].dYpixSys         ;
+    imageID   [i] = image_pos[i].imageID          ;
+    nFitAstrom[i] = image_pos[i].nFitAstrom       ;
+    flags     [i] = image_pos[i].flags            ;
+    crval1      [i] = image_pos[i].coords.crval1    ;
+    crval2      [i] = image_pos[i].coords.crval2    ;
+    crpix1      [i] = image_pos[i].coords.crpix1    ;
+    crpix2      [i] = image_pos[i].coords.crpix2    ;
+    cdelt1      [i] = image_pos[i].coords.cdelt1    ;
+    cdelt2      [i] = image_pos[i].coords.cdelt2    ;
+    pc1_1       [i] = image_pos[i].coords.pc1_1     ;
+    pc1_2       [i] = image_pos[i].coords.pc1_2     ;
+    pc2_1       [i] = image_pos[i].coords.pc2_1     ;
+    pc2_2       [i] = image_pos[i].coords.pc2_2     ;
+    Npolyterms  [i] = image_pos[i].coords.Npolyterms;
+    dXpixSys    [i] = image_pos[i].dXpixSys         ;
+    dYpixSys    [i] = image_pos[i].dYpixSys         ;
+    refColorBlue[i] = image_pos[i].refColorBlue     ;
+    refColorRed [i] = image_pos[i].refColorRed      ;
+    imageID     [i] = image_pos[i].imageID          ;
+    nFitAstrom  [i] = image_pos[i].nFitAstrom       ;
+    flags       [i] = image_pos[i].flags            ;
     // polyterms and ctype are a bit different
 …
   // add the columns to the output array
+  gfits_set_bintable_column (&theader, &ftable, "CRVAL1",      crval1    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CRVAL2",      crval2    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CRPIX1",      crpix1    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CRPIX2",      crpix2    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CDELT1",      cdelt1    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CDELT2",      cdelt2    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "PC1_1",       pc1_1     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "PC1_2",       pc1_2     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "PC2_1",       pc2_1     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "PC2_2",       pc2_2     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "POLYTERMS",   polyterms ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CTYPE",       ctype     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "NPOLYTERMS",  Npolyterms,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "XPIX_SYS_ERR",dXpixSys  ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "YPIX_SYS_ERR",dYpixSys  ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "ID",          imageID   ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "NFIT",        nFitAstrom,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "FLAGS",       flags     ,         Nimage_pos);
+  free (crval1    );
+  free (crval2    );
+  free (crpix1    );
+  free (crpix2    );
+  free (cdelt1    );
+  free (cdelt2    );
+  free (pc1_1     );
+  free (pc1_2     );
+  free (pc2_1     );
+  free (pc2_2     );
+  free (polyterms );
+  free (ctype     );
+  free (Npolyterms);
+  free (dXpixSys  );
+  free (dYpixSys  );
+  free (imageID   );
+  free (nFitAstrom);
+  free (flags     );
+  gfits_set_bintable_column (&theader, &ftable, "CRVAL1",         crval1    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CRVAL2",         crval2    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CRPIX1",         crpix1    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CRPIX2",         crpix2    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CDELT1",         cdelt1    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CDELT2",         cdelt2    ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "PC1_1",          pc1_1     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "PC1_2",          pc1_2     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "PC2_1",          pc2_1     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "PC2_2",          pc2_2     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "POLYTERMS",      polyterms ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "CTYPE",          ctype     ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "NPOLYTERMS",     Npolyterms,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "XPIX_SYS_ERR",   dXpixSys  ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "YPIX_SYS_ERR",   dYpixSys  ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "REF_COLOR_BLUE", refColorBlue,       Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "REF_COLOR_RED",  refColorRed ,       Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "ID",             imageID   ,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "NFIT",           nFitAstrom,         Nimage_pos);
+  gfits_set_bintable_column (&theader, &ftable, "FLAGS",          flags     ,         Nimage_pos);
+  free (crval1      );
+  free (crval2      );
+  free (crpix1      );
+  free (crpix2      );
+  free (cdelt1      );
+  free (cdelt2      );
+  free (pc1_1       );
+  free (pc1_2       );
+  free (pc2_1       );
+  free (pc2_2       );
+  free (polyterms   );
+  free (ctype       );
+  free (Npolyterms  );
+  free (dXpixSys    );
+  free (dYpixSys    );
+  free (refColorBlue);
+  free (refColorRed );
+  free (imageID     );
+  free (nFitAstrom  );
+  free (flags       );
   FILE *f = fopen (filename, "w");

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/ParFactor.c

-              r33652
+              r37822
   double jd, lambda, beta, epsilon, Radius;
+  /* given a time T in UNIX seconds, determine the solar longitude S */
+  /* given a Time relative to Tmean, Tmean in years since J2000, determine the solar
+    longitude S */
   // jd = ohana_sec_to_jd (365.25*86400.0*(Time + Tmean));

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/StarMaps.c

-              r36630
+              r37822
+}
+int printStarMap(int N, char *filename) {
+  off_t i, Nimages;
+  Image *images = getimages(&Nimages, NULL);
+  double L, M;
+  FILE *f = fopen (filename, "w");
+  for (i = 0; i < starmap[N].Npoints; i++) {
+    // set the transformed coordinates
+    XY_to_LM (&L, &M, starmap[N].points[i].X, starmap[N].points[i].Y, &images[N].coords);
+    fprintf (f, "%d %7.2f %f : %7.2f %7.2f : %7.2f %7.2f : %7.2f %7.2f\n", (int) i, starmap[N].points[i].X, starmap[N].points[i].Y, starmap[N].points[i].L, starmap[N].points[i].M, L, M, starmap[N].points[i].L - L, starmap[N].points[i].M - M);
+  }
+  fclose (f);
+  return (TRUE);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/UpdateChips.c

-              r33652
+              r37822
   off_t i, Nraw, Nref, nFitAstr;
   StarData *raw, *ref;
-  Coords *oldCoords;
   float dXpixSys, dYpixSys;
   double *Ro, *Do;
 …
       Nskip ++;
       mode[i] = 0;
+      continue;
+    }
+    if (Nraw <= IMFIT_TOO_FEW) {
+      Nskip ++;
+      mode[i] = 0;
+      free (raw);
       continue;
+    }
 …
     // save these in case of failure
+    saveCoords (&image[i].coords, i);
+    Coords oldCoords;
+    SaveCoords (&oldCoords, &image[i].coords);
     dXpixSys = image[i].dXpixSys;
     dYpixSys = image[i].dYpixSys;
 …
       if (VERBOSE) fprintf (stderr, "reject fit for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT" of %d\n", image[i].name,  i,  Nraw, image[i].nstar);
+      // restore status quo ante
+      oldCoords = getCoords (i);
+      memcpy (&image[i].coords, oldCoords, sizeof(Coords));
+      image[i].dXpixSys = dXpixSys;
+      image[i].dYpixSys = dYpixSys;
+      image[i].nFitAstrom = nFitAstr;
+      saveCenter (image, &Ro[i], &Do[i], i);
+      mode[i] = 1;
+      NoldFit ++;
+      free (raw);
+      free (ref);
+      continue;
+      if (1) {
+        // restore status quo ante (replace truMap with tmpMap)
+        RestoreCoords (&image[i].coords, &oldCoords, &image[i]);
+        image[i].dXpixSys = dXpixSys;
+        image[i].dYpixSys = dYpixSys;
+        image[i].nFitAstrom = nFitAstr;
+        saveCenter (image, &Ro[i], &Do[i], i);
+        mode[i] = 1;
+        NoldFit ++;
+        free (raw);
+        free (ref);
+        continue;
+      }
+    }
     if (!checkStarMap (i)) {
       if (VERBOSE) fprintf (stderr, "fit diverges too much for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT"\n", image[i].name,  i,  Nraw);
+      // restore status quo ante
+      oldCoords = getCoords (i);
+      memcpy (&image[i].coords, oldCoords, sizeof(Coords));
+      image[i].dXpixSys = dXpixSys;
+      image[i].dYpixSys = dYpixSys;
+      image[i].nFitAstrom = nFitAstr;
+      saveCenter (image, &Ro[i], &Do[i], i);
+      mode[i] = 2;
+      image[i].flags |= ID_IMAGE_ASTROM_POOR;
+      NoldFit ++;
+      free (raw);
+      free (ref);
+      continue;
+      if (1) {
+        // restore status quo ante (replace truMap with tmpMap)
+        RestoreCoords (&image[i].coords, &oldCoords, &image[i]);
+        image[i].dXpixSys = dXpixSys;
+        image[i].dYpixSys = dYpixSys;
+        image[i].nFitAstrom = nFitAstr;
+        saveCenter (image, &Ro[i], &Do[i], i);
+        mode[i] = 2;
+        image[i].flags |= ID_IMAGE_ASTROM_POOR;
+        NoldFit ++;
+        free (raw);
+        free (ref);
+        continue;
+      }
+    }
+    // Apply the modified coords back to the measure.R,D.  Note that raw.R,D, ref.L,M, etc
+    // are all automatically updated in this block because they are re-generated from
+    // image.coords on each pass.
+    setImageRaw (catalog, Ncatalog, i, raw, Nraw, MODE_MOSAIC);
+    if (USE_GALAXY_MODEL) {
+      image[i].flags |= ID_IMAGE_ASTROM_GMM;
+    }
     saveCenter (image, &Ro[i], &Do[i], i);
 …
   off_t Nraw, Nref, nFitAstr;
   StarData *raw, *ref;
-  Coords *oldCoords;
   float dXpixSys, dYpixSys;
 …
       threadinfo->Nskip ++;
       threadinfo->mode[i] = 0;
+      continue;
+    }
+    if (Nraw <= IMFIT_TOO_FEW) {
+      threadinfo->Nskip ++;
+      threadinfo->mode[i] = 0;
+      free (raw);
       continue;
+    }
 …
     // save these in case of failure
+    saveCoords (&image[i].coords, i);
+    Coords oldCoords;
+    SaveCoords (&oldCoords, &image[i].coords);
     dXpixSys = image[i].dXpixSys;
     dYpixSys = image[i].dYpixSys;
 …
       if (VERBOSE) fprintf (stderr, "reject fit for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT" of %d\n", image[i].name,  i,  Nraw, image[i].nstar);
+      // restore status quo ante
+      oldCoords = getCoords (i);
+      memcpy (&image[i].coords, oldCoords, sizeof(Coords));
+      // restore status quo ante (replace truMap with tmpMap)
+      RestoreCoords (&image[i].coords, &oldCoords, &image[i]);
       image[i].dXpixSys = dXpixSys;
       image[i].dYpixSys = dYpixSys;
 …
     if (!checkStarMap (i)) {
       if (VERBOSE) fprintf (stderr, "fit diverges too much for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT"\n", image[i].name,  i,  Nraw);
+      // restore status quo ante
       oldCoords = getCoords (i);
       memcpy (&image[i].coords, oldCoords, sizeof(Coords));
+      // restore status quo ante (replace truMap with tmpMap)
+      RestoreCoords (&image[i].coords, &oldCoords, &image[i]);
       image[i].dXpixSys = dXpixSys;
       image[i].dYpixSys = dYpixSys;
 …
+    }
+    // apply the modified R,D back to the measures
+    setImageRaw (threadinfo->catalog, threadinfo->Ncatalog, i, raw, Nraw, MODE_MOSAIC);
     saveCenter (image, &threadinfo->Ro[i], &threadinfo->Do[i], i);
     threadinfo->mode[i] = 3;
 …
 static pthread_mutex_t UpdateChips_mutex = PTHREAD_MUTEX_INITIALIZER;
+void lockUpdateChips () {
+  pthread_mutex_lock (&UpdateChips_mutex);
+}
+void unlockUpdateChips () {
+  pthread_mutex_unlock (&UpdateChips_mutex);
+}
 // we have an array of chips (image, Nimage).  we need to hand out images one at a time to
 // the worker threads as they need
 off_t getNextImageForThread () {
   pthread_mutex_lock (&UpdateChips_mutex);
+  lockUpdateChips ();
   if (nextImage >= Nimage) {
     pthread_mutex_unlock (&UpdateChips_mutex);
+    unlockUpdateChips ();
     return (-1);
+  }
 …
   nextImage ++;
   pthread_mutex_unlock (&UpdateChips_mutex);
+  unlockUpdateChips ();
   return (thisImage);
+}
 …
+}
+// XXX if (!FindMosaicForImage (image, Nimage, i)) { }
+// save the coords and offset map in src at tgt
+void SaveCoords (Coords *tgt, Coords *src) {
+  myAssert (tgt, "oops");
+  myAssert (src, "oops");
+  CopyCoords (tgt, src); // src retains a pointer to the AstromOffsetMap table, to be saved
+  tgt->offsetMap = AstromOffsetMapCopy(src->offsetMap); // oldCoords now saves the old values in a new structure
+}
+// restore the coords and offset map at tgt from src
+void RestoreCoords (Coords *tgt, Coords *src, Image *image) {
+  AstromOffsetMap *truMap = tgt->offsetMap;
+  AstromOffsetMap *tmpMap = src->offsetMap;
+  // copy the coords structure data first, then fix the offsetMap pointers
+  // this modifies tgt.coords, but we need to keep the original pointer
+  CopyCoords (tgt, src);
+  tgt->offsetMap = truMap;
+  // we want to keep the old solution, which is (maybe) a pointer to a stand-alone
+  // map.  the image has a bad solution, but it is a pointer to the map in the I/O
+  // table.  those values will be saved on exit.
+  if (!tmpMap && !truMap) return;
+  if (tmpMap && truMap) {
+    AstromOffsetMapSetOrder (truMap, tmpMap->Nx, tmpMap->Ny, image);
+    AstromOffsetMapCopyData (truMap, tmpMap);
+    return;
+  }
+  if (tmpMap && !truMap) {
+    // is this even possible?
+    lockUpdateChips ();
+    AstromOffsetTable *table = get_astrom_table ();
+    AstromOffsetTableNewMap(table, tmpMap->Nx, tmpMap->Ny, image);  // registers the map with the image
+    unlockUpdateChips ();
+    AstromOffsetMapCopyData (image->coords.offsetMap, tmpMap);
+    return;
+  }
+  if (!tmpMap && truMap) {
+    truMap->keep = FALSE;
+    return;
+  }
+  myAbort ("oops");
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/UpdateMeasures.c

-              r35763
+              r37822
 # include "relastro.h"
+void dump_measures (Average *average, Measure *measure); // in ImageOps.c
+void printNcatTotal ();
+// this function is called by UpdateObjectOffsets or relastro_images.c for reset
+int UpdateMeasures (Catalog *catalog, int Ncatalog) {
+  off_t i, j, Nimage;
+  Image *image;
+  double DPOS_MAX_ASEC;
+  int badImage =
+    ID_IMAGE_ASTROM_NOCAL |
+    ID_IMAGE_ASTROM_POOR |
+    ID_IMAGE_ASTROM_FAIL |
+    ID_IMAGE_ASTROM_SKIP |
+    ID_IMAGE_ASTROM_FEW;
+  if (RESET_BAD_IMAGES) badImage = 0;
+  image = getimages (&Nimage, NULL);
+  // track measurements which are far from their original position (poor at pole)
+  int NoffRAave = 0;  int NoffRAori = 0;
+  int NoffDECave = 0; int NoffDECori = 0;
+  for (i = 0; i < Ncatalog; i++) {
+    myAssert (!catalog[i].Nmeasure || catalog[i].measureT, "programming error");
+    for (j = 0; j < catalog[i].Nmeasure; j++) {
+      MeasureTiny *measureT = &catalog[i].measureT[j];
+      Measure     *measureB = catalog[i].measure ? &catalog[i].measure[j] : NULL;
+      off_t im = getImageByID (measureT->imageID);
+      if (im < 0) continue; // detections without imageIDs are not associated with a known image (eg, refs)
+      // check that we have the right image:
+      myAssert (measureT->photcode == image[im].photcode, "image photcode mismatch");
+      myAssert (measureT->t >= image[im].tzero, "image time mismatch (1)");
+      myAssert (measureT->t <= image[im].tzero + image[im].NX*image[im].trate/5000.0, "image time mismatch (2)");
+      // I'm allowing the trate*NX to be a factor of 2x too small
+      // skip measurements on images that have failed solutions (divergent or otherwise)
+      // XXX apply this or not??
+      if (FALSE && (image[im].flags & badImage)) continue;
+      Coords *moscoords = image[im].coords.mosaic;
+      Coords *imcoords = &image[im].coords;
+      if (moscoords) {
+        DPOS_MAX_ASEC = 3600.0*DPOS_MAX*hypot(moscoords->cdelt1, moscoords->cdelt2);
+      } else {
+        DPOS_MAX_ASEC = 3600.0*DPOS_MAX*hypot(imcoords->cdelt1, imcoords->cdelt2);
+      }
+      double X = measureT->Xccd;
+      double Y = measureT->Yccd;
+      if (USE_FIXED_PIXCOORDS) {
+        if (isfinite(measureT->Xfix) && isfinite(measureT->Yfix)) {
+          float dX = measureT->Xfix - measureT->Xccd;
+          float dY = measureT->Yfix - measureT->Yccd;
+          if (hypot(dX,dY) < 2.0) {
+            X = measureT->Xfix;
+            Y = measureT->Yfix;
+          }
+        }
+      }
+      double R, D;
+      XY_to_RD (&R, &D, X, Y, imcoords);
+      int n = measureT[0].averef;
+      Average *average = &catalog[i].average[n];
+      double dR = 3600.0*(average[0].R - R);
+      double dD = 3600.0*(average[0].D - D);
+      // make sure detection is on the same side of the 0,360 boundary as the average
+      // this will give some funny results withing ~1 arcsec of the pol
+      if (dR > +180.0*3600.0) {
+        // average on high end of boundary, move star up
+        R += 360.0;
+        dR = 3600.0*(average[0].R - R);
+      }
+      if (dR < -180.0*3600.0) {
+        // average on low end of boundary, move star down
+        R -= 360.0;
+        dR = 3600.0*(average[0].R - R);
+      }
+      float csdec = cos(average[0].D * RAD_DEG);
+      // complain if the new location is far from the average location
+      // NOTE: This should never happen, or our StarMap tests are not working
+      if (fabs(dR*csdec) > 3.0*ADDSTAR_RADIUS) {
+        NoffRAave ++;
+        if (VERBOSE2 && catalog[i].measure) {
+          fprintf (stderr, "measurement is far from average location (R): %f %f (%f %f %f)\n", average[0].R, average[0].D, dR, dR*csdec, dD);
+          dump_measures (&average[0], catalog[i].measure);
+        }
+      }
+      if (fabs(dD) > 3.0*ADDSTAR_RADIUS) {
+        NoffDECave ++;
+        if (VERBOSE2 && catalog[i].measure) {
+          fprintf (stderr, "measurement is far from average location (D): %f %f (%f %f)\n", average[0].R, average[0].D, dR, dD);
+          dump_measures (&average[0], catalog[i].measure);
+        }
+      }
+      // complain if the new location is far from the old location
+      if (fabs(csdec*(measureT[0].R - R)) > DPOS_MAX_ASEC) {
+        NoffRAori ++;
+        if (VERBOSE2 && catalog[i].measure) {
+          fprintf (stderr, "measurement moves far from original location (R): %f %f (%f %f %f %f)\n", average[0].R, average[0].D, measureT[0].R, dR, csdec*(measureT[0].R - R), dD);
+          dump_measures (&average[0], catalog[i].measure);
+        }
+      }
+      if (fabs(measureT[0].D - D) > DPOS_MAX_ASEC) {
+        NoffDECori ++;
+        if (VERBOSE2 && catalog[i].measure) {
+          fprintf (stderr, "measurement moves far from original location (D): %f %f (%f %f %f)\n", average[0].R, average[0].D, dR, measureT[0].D, dD);
+          dump_measures (&average[0], catalog[i].measure);
+        }
+      }
+      measureT->R = R;
+      measureT->D = D;
+      if (measureB) {
+        measureB->R = R;
+        measureB->D = D;
+      }
+    }
+  }
+  // printNcatTotal ();
+  int Noff = NoffRAave + NoffDECave + NoffRAori + NoffDECori;
+  if (VERBOSE && (Noff > 0)) fprintf (stderr, "Noff ave RA %d, Noff ave DEC %d, Noff ori RA %d, Noff ori DEC %d\n", NoffRAave, NoffDECave, NoffRAori, NoffDECori);
+  return (TRUE);
+}
 // this function operates on Measure, not MeasureTiny
 int UpdateMeasures (Catalog *catalog, int Ncatalog) {
+int UpdateMeasuresOld (Catalog *catalog, int Ncatalog) {
   off_t i, Nimage;
 …
+  }
   printNcatTotal ();
+  // printNcatTotal ();
   return (TRUE);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/UpdateObjectOffsets.c

-              r37038
+              r37822
     // uses MeasureTiny values, but will also update Measure values when populated
+    UpdateObjects (&catalog, 1);
+    // if Galaxy Motion Model correction is active, do not apply at this last stage
+    UpdateObjects (&catalog, 1, FALSE);
     free_tiny_values(&catalog);
 …
     save_catalogs (&catalog, 1);
+  }
+  printNcatTotal();
   return (TRUE);
+}
+int UpdateObjectOffsets_parallel_group (HostTableGroup *group, SkyList *sky);
+int UpdateObjectOffsets_parallel_table (HostTable *table, SkyList *sky);
 // CATDIR is supplied globally
 …
     exit (1);
+  }
+# if (0)
+  UpdateObjectOffsets_parallel_table (table, sky);
+# else
+  int Ngroups;
+  HostTableGroup *groups = HostTableGroups (table, &Ngroups);
+  // split the table into Ngroups, each with a unique set of machines (this avoids overloading the remote host machines)
+  int i;
+  for (i = 0; i < Ngroups; i++) {
+    // update only a group of unique machines at a time
+    UpdateObjectOffsets_parallel_group (&groups[i], sky);
+  }
+# endif
+  return TRUE;
+}
+// CATDIR is supplied globally
+# define DEBUG 1
+int UpdateObjectOffsets_parallel_group (HostTableGroup *group, SkyList *sky) {
+  // launch the relastro_client jobs to the parallel hosts
+  int i, j;
+  for (i = 0; i < group->Nhosts; i++) {
+    if (sky->Nregions < group->Nhosts) {
+      // do any of the regions want this host?
+      int wantThisHost = FALSE;
+      for (j = 0; j < sky->Nregions; j++) {
+        if (HostTableTestHost (sky->regions[j], group->hosts[i][0].hostID)) {
+          wantThisHost = TRUE;
+          break;
+        }
+      }
+      if (!wantThisHost) {
+        // fprintf (stderr, "skip host %s\n", group->hosts[i][0].hostname);
+        continue;
+      }
+    }
+    // ensure that the paths are absolute path names
+    char *tmppath = abspath (group->hosts[i][0].pathname, DVO_MAX_PATH);
+    free (group->hosts[i][0].pathname);
+    group->hosts[i][0].pathname = tmppath;
+    // options / arguments that can affect relastro_client -load:
+    // VERBOSE, VERBOSE2
+    // RESET (-reset)
+    // TimeSelect -time
+    // (note that psfQF is applied rigidly at 0.85, as is the galaxy test)
+    // ImagSelect, ImagMin, ImagMax
+    // MaxDensityUse, MaxDensityValue
+    char command[1024];
+    snprintf (command, 1024, "relastro_client -update-offsets -hostID %d -D CATDIR %s -hostdir %s -region %f %f %f %f -statmode %s -minerror %f",
+              group->hosts[i][0].hostID, CATDIR, group->hosts[i][0].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, STATMODE, MIN_ERROR);
+    if (FIT_MODE == FIT_PM_ONLY)         strextend (command, "-pm");
+    if (FIT_MODE == FIT_PAR_ONLY)        strextend (command, "-par");
+    if (FIT_MODE == FIT_PM_AND_PAR)      strextend (command, "-pmpar");
+    if (VERBOSE)       strextend (command, "-v");
+    if (VERBOSE2)      strextend (command, "-vv");
+    if (RESET)         strextend (command, "-reset");
+    if (UPDATE)        strextend (command, "-update");
+    if (RESET_BAD_IMAGES) strextend (command, "-reset-bad-images");
+    if (ImagSelect)    strextend (command, "-instmag %f %f", ImagMin, ImagMax);
+    if (MaxDensityUse) strextend (command, "-max-density %f", MaxDensityValue);
+    if (USE_BASIC_CHECK) strextend (command, "-basic-image-search");
+    if (FlagOutlier)     strextend (command, "-clip %d", CLIP_THRESH);
+    if (ExcludeBogus)    strextend (command, "-exclude-bogus %f", ExcludeBogusRadius);
+    if (USE_FIXED_PIXCOORDS) strextend (command, "-D USE_FIXED_PIXCOORDS 1");
+    if (PHOTCODE_KEEP_LIST) strextend (command, "+photcode %s", PHOTCODE_KEEP_LIST);
+    if (PHOTCODE_SKIP_LIST) strextend (command, "-photcode %s", PHOTCODE_SKIP_LIST);
+    if (PhotFlagSelect)     strextend (command, "+photflags");
+    if (PhotFlagBad)        strextend (command, "+photflagbad %d", PhotFlagBad);
+    if (PhotFlagPoor)       strextend (command, "+photflagpoor %d", PhotFlagPoor);
+    // XXX note that the above pass in the flag as decimal -- also note that args.c cannot handle 0xHEX values
+    if (DCR_BLUE_COLOR_POS && DCR_BLUE_COLOR_NEG) {
+      strextend (command, "-dcr-blue-color %s %s", DCR_BLUE_COLOR_POS, DCR_BLUE_COLOR_NEG);
+    }
+    if (DCR_RED_COLOR_POS && DCR_RED_COLOR_NEG) {
+      strextend (command, "-dcr-red-color %s %s", DCR_RED_COLOR_POS, DCR_RED_COLOR_NEG);
+    }
+    if (MinBadQF > 0.0)        strextend (command, "-min-bad-psfqf %f", MinBadQF);
+    if (MaxMeanOffset != 10.0) strextend (command, "-max-mean-offset  %f", MaxMeanOffset);
+    if (TimeSelect) {
+      char *tstart = ohana_sec_to_date (TSTART);
+      char *tstop  = ohana_sec_to_date (TSTOP);
+      strextend (command, "-time %s %s", tstart, tstop);
+      free (tstart);
+      free (tstop);
+    }
+    fprintf (stderr, "command: %s\n", command);
+    if (PARALLEL_MANUAL) continue;
+    if (PARALLEL_SERIAL) {
+      int status = system (command);
+      if (status) {
+        fprintf (stderr, "ERROR running relastro_client\n");
+        exit (2);
+      }
+    } else {
+      // launch the job on the remote machine (no handshake)
+      int errorInfo = 0;
+      int pid = rconnect ("ssh", group->hosts[i][0].hostname, command, group->hosts[i][0].stdio, &errorInfo, FALSE);
+      if (!pid) {
+        if (DEBUG) fprintf (stderr, "failure to start %s (error %d)\n", group->hosts[i][0].hostname, errorInfo);
+        exit (1);
+      }
+      group->hosts[i][0].pid = pid; // save for future reference
+    }
+  }
+  if (PARALLEL_MANUAL) {
+    fprintf (stderr, "run the relastro_client commands above.  when these are done, hit return\n");
+    getchar();
+  }
+  if (!PARALLEL_MANUAL && !PARALLEL_SERIAL) {
+    HostTableGroupWaitJobsGetIO (group, __FILE__, __LINE__, VERBOSE);
+  }
+  return TRUE;
+}
+// CATDIR is supplied globally
+# define DEBUG 1
+int UpdateObjectOffsets_parallel_table (HostTable *table, SkyList *sky) {
+  // launch the relastro_client jobs to the parallel hosts
   int i, j;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/UpdateObjects.c

-              r37038
+              r37822
 # include "relastro.h"
+# define PAR_TOOFEW 5
+int UpdateObjects_Chips (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats, int i, off_t m, int applyGalaxyOffset);
+int UpdateObjects_Stack (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats);
 static off_t Nmax;
 …
 static double *C_red;
+static Coords coords;
+static time_t T2000;
+void initFitStats (FitStats *fitStats) {
+  fitStats->Nave = 0;
+  fitStats->Npm = 0;
+  fitStats->Npar = 0;
+  fitStats->Nskip = 0;
+  fitStats->Noffset = 0;
+  return;
+}
+void sumFitStats (FitStats *srcFitStats, FitStats *tgtFitStats) {
+  tgtFitStats->Nave    += srcFitStats->Nave    ;
+  tgtFitStats->Npm     += srcFitStats->Npm     ;
+  tgtFitStats->Npar    += srcFitStats->Npar    ;
+  tgtFitStats->Nskip   += srcFitStats->Nskip   ;
+  tgtFitStats->Noffset += srcFitStats->Noffset ;
+  return;
+}
 void initObjectData (Catalog *catalog, int Ncatalog) {
 …
   ALLOCATE (C_blue, double, MAX (1, Nmax));
   ALLOCATE (C_red,  double, MAX (1, Nmax));
+  /* project coordinates to a plane centered on the object with units of arcsec */
+  InitCoords (&coords, "DEC--SIN");
+  coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
+  // use J2000 as a reference time
+  T2000 = ohana_date_to_sec ("2000/01/01,12:00:00");
+}
 …
 // This function operates on both Measure and MeasureTiny.  In the big stages, this should
 // be called with just MeasureTiny set and Measure == NULL
+int UpdateObjects (Catalog *catalog, int Ncatalog) {
+  off_t j, k, m;
+  int i, N, NcBlue, NcRed, Nsecfilt, mode, result, status, XVERB;
+  StatType statsR, statsD;
+  Coords coords;
+  PMFit fitAve, fitPM, fitPAR, fit;
+  time_t T2000;
+  off_t Nave, Npm, Npar, Nskip, Noffset;
+  off_t NaveSum, NpmSum, NparSum, NskipSum, NoffSum;
+  double Tmin, Tmax, Tmean, Trange;
+  memset (&fit,    0, sizeof(fit));
+  memset (&fitAve, 0, sizeof(fitAve));
+  memset (&fitPM,  0, sizeof(fitPM));
+  memset (&fitPAR, 0, sizeof(fitPAR));
+int UpdateObjects (Catalog *catalog, int Ncatalog, int Nloop) {
   initObjectData (catalog, Ncatalog);
-  int setRefColor = areImagesMatched();
-  /* project coordinates to a plane centered on the object with units of arcsec */
-  coords.crval1 = 0;
-  coords.crval2 = 0;
-  coords.crpix1 = 0;
-  coords.crpix2 = 0;
-  coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
-  coords.pc1_1  = coords.pc2_2 = 1.0;
-  coords.pc1_2  = coords.pc2_1 = 0.0;
-  coords.Npolyterms = 1;
-  strcpy (coords.ctype, "DEC--SIN");
-  XVERB = FALSE;
-  // use J2000 as a reference time
-  T2000 = ohana_date_to_sec ("2000/01/01");
   // XXX in the future, use catalog[0].Nsecfilt only?  allow catalogs to have variable Nsecfilt?
+  Nsecfilt = GetPhotcodeNsecfilt ();
+  int Nsecfilt = GetPhotcodeNsecfilt ();
   if (Ncatalog) {
     assert (catalog[0].Nsecfilt == Nsecfilt);
+  }
+  NaveSum = NparSum = NpmSum = NoffSum = NskipSum = 0;
+  FitStats sumStatsChips; initFitStats (&sumStatsChips);
+  FitStats sumStatsStack; initFitStats (&sumStatsStack);
+  int i;
   for (i = 0; i < Ncatalog; i++) {
     if (VERBOSE2) fprintf (stderr, "astrometrize catalog %d : "OFF_T_FMT" ave, "OFF_T_FMT" meas\n", i,  catalog[i].Naverage,  catalog[i].Nmeasure);
+    Nave = Npar = Npm = Nskip = Noffset = 0;
+    FitStats fitStatsChips; initFitStats (&fitStatsChips);
+    FitStats fitStatsStack; initFitStats (&fitStatsStack);
+    off_t j;
     for (j = 0; j < catalog[i].Naverage; j++) {
       /* calculate the average value of R,D for a single star */
+      XVERB = FALSE;
+      fitAve.chisq = NAN;
+      fitPM.chisq = NAN;
+      fitPAR.chisq = NAN;
+      // if we fail to fit the astrometry for some reason, we need to set/reset these
+      catalog[i].average[j].flags |= ID_STAR_NO_ASTROM;
+      catalog[i].average[j].ChiSqAve  = NAN;
+      catalog[i].average[j].ChiSqPM   = NAN;
+      catalog[i].average[j].ChiSqPar  = NAN;
+      catalog[i].average[j].Npos = 0;
+      if (catalog[i].average[j].Nmeasure == 0) {
+      off_t m = catalog[i].average[j].measureOffset;
+      MeasureTiny *measure = &catalog[i].measureT[m];
+      Measure *measureBig = catalog[i].measure ? &catalog[i].measure[m] : NULL;
+      Average *average = &catalog[i].average[j];
+      SecFilt *secfilt = &catalog[i].secfilt[j*Nsecfilt];
+      UpdateObjects_Stack(average, secfilt, measure, measureBig, Nsecfilt, &fitStatsStack);
+      UpdateObjects_Chips(average, secfilt, measure, measureBig, Nsecfilt, &fitStatsChips, i, m, Nloop);
+    }
+    if (VERBOSE2) fprintf (stderr, "catalog %d : chips "OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par : Nskip "OFF_T_FMT", Noffset "OFF_T_FMT"\n",  i,  fitStatsChips.Nave,  fitStatsChips.Npm,  fitStatsChips.Npar,  fitStatsChips.Nskip, fitStatsChips.Noffset);
+    if (VERBOSE2) fprintf (stderr, "catalog %d : stack "OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par : Nskip "OFF_T_FMT", Noffset "OFF_T_FMT"\n",  i,  fitStatsStack.Nave,  fitStatsStack.Npm,  fitStatsStack.Npar,  fitStatsStack.Nskip, fitStatsStack.Noffset);
+    sumFitStats (&fitStatsChips, &sumStatsChips);
+    sumFitStats (&fitStatsStack, &sumStatsStack);
+  }
+  freeObjectData ();
+  if (VERBOSE && (Ncatalog > 1)) fprintf (stderr, "fitted "OFF_T_FMT" objects ("OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par), skipped "OFF_T_FMT", "OFF_T_FMT" have too large an offset\n",  (sumStatsChips.Nave + sumStatsChips.Npm + sumStatsChips.Npar),  sumStatsChips.Nave,  sumStatsChips.Npm,  sumStatsChips.Npar,  sumStatsChips.Nskip, sumStatsChips.Noffset);
+  if (VERBOSE && (Ncatalog > 1)) fprintf (stderr, "fitted "OFF_T_FMT" objects ("OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par), skipped "OFF_T_FMT", "OFF_T_FMT" have too large an offset\n",  (sumStatsStack.Nave + sumStatsStack.Npm + sumStatsStack.Npar),  sumStatsStack.Nave,  sumStatsStack.Npm,  sumStatsStack.Npar,  sumStatsStack.Nskip, sumStatsStack.Noffset);
+  return (TRUE);
+}
+// This function operates on both Measure and MeasureTiny.  In the big stages, this should
+// be called with just MeasureTiny set and Measure == NULL
+int UpdateObjects_Chips (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats, int i, off_t m, int applyGalaxyOffset) {
+  int setRefColor = areImagesMatched();
+  /* calculate the average value of R,D for a single star */
+  PMFit fit;    memset (&fit,    0, sizeof(fit));
+  PMFit fitAve; memset (&fitAve, 0, sizeof(fitAve)); fitAve.chisq = NAN;
+  PMFit fitPM;  memset (&fitPM,  0, sizeof(fitPM));  fitPM.chisq = NAN;
+  PMFit fitPAR; memset (&fitPAR, 0, sizeof(fitPAR)); fitPAR.chisq = NAN;
+  // if we fail to fit the astrometry for some reason, we need to set/reset these
+  average[0].flags |= ID_STAR_NO_ASTROM;
+  average[0].ChiSqAve  = NAN;
+  average[0].ChiSqPM   = NAN;
+  average[0].ChiSqPar  = NAN;
+  average[0].Npos = 0;
+  // an object with no measurements is externally supplied
+  if (average[0].Nmeasure == 0) return TRUE;
+  int NcBlue = 0;
+  int NcRed = 0;
+  int N = 0;
+  int mode = FIT_MODE; // start with the globally-defined fit mode
+  int XVERB = FALSE;
+  XVERB |= (average[0].objID == OBJ_ID_SRC) && (average[0].catID == CAT_ID_SRC);
+  XVERB |= (average[0].objID == OBJ_ID_DST) && (average[0].catID == CAT_ID_DST);
+  // find the basic properties of the detections for this object (Tmin, Tmax, Tmean)
+  off_t k;
+  for (k = 0; k < average[0].Nmeasure; k++) {
+    if (XVERB) {
+      char *date = ohana_sec_to_date (measure[k].t);
+      int dbFlagsBig = measureBig ? measureBig[k].dbFlags : 0;
+      fprintf (stderr, OFF_T_FMT" %f %f %s : 0x%08x : 0x%08x\n",  k, measure[k].R, measure[k].D, date, measure[k].dbFlags, dbFlagsBig);
+      free (date);
+    }
+    // SKIP gpc1 stack data
+    if (isGPC1stack(measure[k].photcode)) continue;
+    // SKIP gpc1 forced-warp data
+    if (isGPC1warp(measure[k].photcode)) continue;
+    // reset the bit to note that a detection was used (or not)
+    measure[k].dbFlags &= ~ID_MEAS_USED_OBJ;
+    if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_USED_OBJ; }
+    // does the measurement pass the supplied filtering constraints?
+    // MeasFilterTestTiny does not test psfQF
+    // exclude bad detections based on: photcodes, psfQF, time range, photflags & astromBadMask, mag_inst
+    int keepMeasure = measureBig ? MeasFilterTest(&measureBig[k], FALSE) : MeasFilterTestTiny(&measure[k], FALSE);
+    if (!keepMeasure) {
+      continue;
+    }
+    double Ri = getMeanR (&measure[k], average, secfilt);
+    double Di = getMeanD (&measure[k], average, secfilt);
+    // if we are correcting for the Galaxy Motion Model, only should apply it here
+    // (a) when we are working to correct the images (mean R,D assumed to be at J2000) and
+    // (b) if we think the measure R,D is already at the image epoch position
+    if (USE_GALAXY_MODEL && applyGalaxyOffset) {
+      Ri -= measure[k].RoffGAL / 3600.0;
+      Di -= measure[k].DoffGAL / 3600.0;
+    }
+    // XXX add in dR,dD GAL here
+    // mark (as POOR) any measurements which are deviant from the mean by > ExcludeBogusRadius
+    if (ExcludeBogus) {
+      coords.crval1 = average[0].R;
+      coords.crval2 = average[0].D;
+      double Xi, Yi;
+      RD_to_XY (&Xi, &Yi, Ri, Di, &coords);
+      double radius = hypot(Xi, Yi);
+      if (radius > ExcludeBogusRadius) {
+        measure[k].dbFlags |= ID_MEAS_POOR_ASTROM;
+        if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_POOR_ASTROM; }
         continue;
+      }
+      NcBlue = 0;
+      NcRed = 0;
+      N = 0;
+      m = catalog[i].average[j].measureOffset;
+      MeasureTiny *measure = &catalog[i].measureT[m];
+      Measure *measureBig = catalog[i].measure ? &catalog[i].measure[m] : NULL;
+      // when we update the output measure values, we need to do it here
+      mode = FIT_MODE;
+      // XVERB |= (catalog[i].averge[j].objID == 0xc90) && (catalog[i].average[j].catID == 0x2a1e);
+      XVERB |= (catalog[i].average[j].objID == OBJ_ID_SRC) && (catalog[i].average[j].catID == CAT_ID_SRC);
+      XVERB |= (catalog[i].average[j].objID == OBJ_ID_DST) && (catalog[i].average[j].catID == CAT_ID_DST);
+      // find the basic properties of the detections for this object (Tmin, Tmax, Tmean)
+      for (k = 0; k < catalog[i].average[j].Nmeasure; k++) {
+        if (XVERB) {
+          char *date = ohana_sec_to_date (measure[k].t);
+          int dbFlagsBig = measureBig ? measureBig[k].dbFlags : 0;
+          fprintf (stderr, OFF_T_FMT" %f %f %s : 0x%08x : 0x%08x\n",  k, measure[k].R, measure[k].D, date, measure[k].dbFlags, dbFlagsBig);
+          free (date);
+        }
+        // reset the bit to note that a detection was used (or not)
+        measure[k].dbFlags &= ~ID_MEAS_USED_OBJ;
+        if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_USED_OBJ; }
+        // does the measurement pass the supplied filtering constraints?
+        // MeasFilterTestTiny does not test psfQF
+        // exclude bad detections based on: photcodes, psfQF, time range, photflags & astromBadMask, mag_inst
+        int keepMeasure = measureBig ? MeasFilterTest(&measureBig[k], FALSE) : MeasFilterTestTiny(&measure[k], FALSE);
+        if (!keepMeasure) {
+          continue;
+        }
+        // mark (as POOR) any measurements which are deviant from the mean by > ExcludeBogusRadius
+        if (ExcludeBogus) {
+          double Ri = getMeanR (&measure[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]);
+          double Di = getMeanD (&measure[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]);
+          coords.crval1 = catalog[i].average[j].R;
+          coords.crval2 = catalog[i].average[j].D;
+          double Xi, Yi;
+          RD_to_XY (&Xi, &Yi, Ri, Di, &coords);
+          double radius = hypot(Xi, Yi);
+          if (radius > ExcludeBogusRadius) {
+              measure[k].dbFlags |= ID_MEAS_POOR_ASTROM;
+              if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_POOR_ASTROM; }
+              continue;
+          }
+          measure[k].dbFlags &= ~ID_MEAS_POOR_ASTROM;
+          if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_POOR_ASTROM; }
+        }
+        // outlier rejection
+        if (FALSE && FlagOutlier && (measure[k].dbFlags & ID_MEAS_POOR_ASTROM)) {
+          continue;
+        }
+        R[N] = getMeanR (&measure[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]);
+        D[N] = getMeanD (&measure[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]);
+        // XXX I think this is a problem: T[] is time in years relative to J2000, but ParFactor expects
+        // to get Time in years relative to UNIX Tzero (1970/01/01)
+        T[N] = (measure[k].t - T2000) / (86400*365.25) ; // time relative to J2000 in years
+        // dX, dY : error in arcsec --
+        dX[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_RA);
+        dY[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_DEC);
+        // allow a given photcode or measurement to be
+        // ignored if the error is NAN (for photcode, set astromErrSys to NaN)
+        if (isnan(dX[N])) continue;
+        if (isnan(dY[N])) continue;
+        // add systematic error in quadrature, if desired
+        // only do this after the fit has converged (or you will never improve the poor images)
+        // if (INCLUDE_SYS_ERR) {
+        // float dRsys = FromShortPixels(measure[k].dRsys);
+        // dX[N] = hypot(dX[N], dRsys);
+        // dY[N] = hypot(dY[N], dRsys);
+        // }
+        // dX[N] = 0.1;
+        // dY[N] = 0.1;
+        dT[N] = measure[k].dt;
+        // XXX this is (slightly) inconsistent: dX,dY are the X and Y direction errors in
+        // arcseconds.  dR, dD are the errors in those directions in degrees.  IF we have
+        // non-circular errors (different values for X and Y), then dR and dD will be
+        // incorrect: they would need to be rotated to take out the position angle
+        dR[N] = dX[N] / 3600.0;
+        dD[N] = dY[N] / 3600.0;
+        if (setRefColor) {
+          float colorBlue = getColorBlue (m+k, i);
+          if (!isnan(colorBlue)) {
+            C_blue[NcBlue] = colorBlue;
+            NcBlue++;
+          }
+          float colorRed = getColorRed (m+k, i);
+          if (!isnan(colorRed)) {
+            C_red[NcRed] = colorRed;
+            NcRed++;
+          }
+        }
+        measure[k].dbFlags |= ID_MEAS_USED_OBJ;
+        if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_USED_OBJ; }
+        N++;
+      } // loop over measurements : catalog[i].average[j].Nmeasure
+      // if we have too few good detections for the desired fit, or too limited a
+      // baseline, use a fit with fewer parameters.  XXX if we have too few measurements
+      // for even the average position, consider including the lower-quality detections?
+      // find Tmin & Tmax from the list of accepted measurements
+      Tmean = 0;
+      Tmin = Tmax = T[0];
+      for (k = 0; k < N; k++) {
+        Tmin = MIN(Tmin, T[k]);
+        Tmax = MAX(Tmax, T[k]);
+        Tmean += T[k];
+      measure[k].dbFlags &= ~ID_MEAS_POOR_ASTROM;
+      if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_POOR_ASTROM; }
+    }
+    // outlier rejection
+    if (FALSE && FlagOutlier && (measure[k].dbFlags & ID_MEAS_POOR_ASTROM)) {
+      continue;
+    }
+    R[N] = Ri;
+    D[N] = Di;
+    // measure[k].t is UNIX seconds, T2000 is UNIX seconds for J2000.
+    // T[] is time in years since J2000 (jd = 2451545)
+    T[N] = (measure[k].t - T2000) / (86400*365.25) ; // time relative to J2000 in years
+    // dX, dY : error in arcsec --
+    dX[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_RA);
+    dY[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_DEC);
+    // allow a given photcode or measurement to be
+    // ignored if the error is NAN (for photcode, set astromErrSys to NaN)
+    if (isnan(dX[N])) continue;
+    if (isnan(dY[N])) continue;
+    // add systematic error in quadrature, if desired
+    // only do this after the fit has converged (or you will never improve the poor images)
+    // if (INCLUDE_SYS_ERR) {
+    // float dRsys = FromShortPixels(measure[k].dRsys);
+    // dX[N] = hypot(dX[N], dRsys);
+    // dY[N] = hypot(dY[N], dRsys);
+    // }
+    // dX[N] = 0.1;
+    // dY[N] = 0.1;
+    dT[N] = measure[k].dt;
+    // XXX this is (slightly) inconsistent: dX,dY are the X and Y direction errors in
+    // arcseconds.  dR, dD are the errors in those directions in degrees.  IF we have
+    // non-circular errors (different values for X and Y), then dR and dD will be
+    // incorrect: they would need to be rotated to take out the position angle
+    dR[N] = dX[N] / 3600.0;
+    dD[N] = dY[N] / 3600.0;
+    if (setRefColor) {
+      float colorBlue = getColorBlue (m+k, i);
+      if (!isnan(colorBlue)) {
+        C_blue[NcBlue] = colorBlue;
+        NcBlue++;
+      }
+      // XXX add the parallax factor range as a criterion as well
+      Trange = Tmax - Tmin;
+      if (Trange < PM_DT_MIN) mode = FIT_AVERAGE;
+      if (((mode == FIT_PM_ONLY) || (mode == FIT_PM_AND_PAR)) && (N <= PM_TOOFEW)) mode = FIT_AVERAGE;
+      if (RELASTRO_OP == OP_HIGH_SPEED) {
+          Tmean = 0.5*(Tmax - Tmin);
+      } else {
+          Tmean /= (float) N;
+      float colorRed = getColorRed (m+k, i);
+      if (!isnan(colorRed)) {
+        C_red[NcRed] = colorRed;
+        NcRed++;
+      }
+      // too few measurements for average position (require 2 values)
+      if (N < SRC_MEAS_TOOFEW) {
+        if (N < 2) continue;
+      }
+      /* we need to do the fit in a locally linear space; choose a ref coordinate */
+      coords.crval1 = R[0];
+      coords.crval2 = D[0];
+      // to judge the quality of the PM and PAR fits, we need to fit all three models and compare Chisq
+      if ((mode == FIT_PM_ONLY) || (mode == FIT_PM_AND_PAR)) {
+        // project all of the R,D coordinates to a plane centered on this coordinate. set
+        // the times to be relative to Tmean (this is required for parallax as well)
+        for (k = 0; k < N; k++) {
+          RD_to_XY (&X[k], &Y[k], R[k], D[k], &coords);
+          T[k] -= Tmean;
+          if (XVERB) {
+            fprintf (stderr, OFF_T_FMT" %f %f %f  %f %f +/- %f %f\n",  k, T[k], R[k], D[k], X[k], Y[k], dX[k], dY[k]);
+          }
+        }
+        FitPM (&fitPM, X, dX, Y, dY, T, N, XVERB);
+        if (XVERB) fprintf (stderr, "fitted PM:  %f - %f : %f %f : %f %f : %f vs %f\n", Tmin, Tmax, fitPM.Ro, fitPM.Do, fitPM.uR, fitPM.uD, fitPM.chisq, fitAve.chisq);
+        // project Ro, Do back to RA,DEC
+        XY_to_RD (&fitPM.Ro, &fitPM.Do, fitPM.Ro, fitPM.Do, &coords);
+        if (XVERB) fprintf (stderr, "project: %f %f : %f %f : %f\n", fitPM.Ro, fitPM.Do, fitPM.uR, fitPM.uD, fitPM.p);
+        fitPM.p  = fitPM.dp  = 0.0;
+        catalog[i].average[j].flags |= ID_STAR_FIT_PM;
+        Npm ++;
+        // XXX a hard-wired hack...
+        if ((fabs(fitPM.uR) > 2.0) || (fabs(fitPM.uD) > 2.0)) {
+          mode = FIT_AVERAGE;
+          catalog[i].average[j].flags |= ID_STAR_BAD_PM;
+        }
+      }
+      if (mode == FIT_PM_AND_PAR) {
+        float pXmin = +2.0;
+        float pXmax = -2.0;
+        float pYmin = +2.0;
+        float pYmax = -2.0;
+        for (k = 0; k < N; k++) {
+          ParFactor (&pX[k], &pY[k], R[k], D[k], T[k], Tmean);
+          pXmin = MIN (pXmin, pX[k]);
+          pXmax = MAX (pXmax, pX[k]);
+          pYmin = MIN (pYmin, pY[k]);
+          pYmax = MAX (pYmax, pY[k]);
+        }
+        float dXRange = pXmax - pXmin;
+        float dYRange = pYmax - pYmin;
+        float parRange = hypot (dXRange, dYRange);
+    }
+    measure[k].dbFlags |= ID_MEAS_USED_OBJ;
+    if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_USED_OBJ; }
+    N++;
+  } // loop over measurements : average[0].Nmeasure
+  if (N < 1) {
+    if (isfinite(average[0].Rstk) && isfinite(average[0].Dstk)) {
+      average[0].R  = average[0].Rstk;
+      average[0].D  = average[0].Dstk;
+      average[0].dR = average[0].dRstk;
+      average[0].dD = average[0].dDstk;
+    }
+    return FALSE;
+  }
+  // if we have too few good detections for the desired fit, or too limited a
+  // baseline, use a fit with fewer parameters.  XXX if we have too few measurements
+  // for even the average position, consider including the lower-quality detections?
+  // find Tmin & Tmax from the list of accepted measurements
+  double Tmean = 0.0;
+  double Tmin = T[0];
+  double Tmax = T[0];
+  for (k = 0; k < N; k++) {
+    Tmin = MIN(Tmin, T[k]);
+    Tmax = MAX(Tmax, T[k]);
+    Tmean += T[k];
+  }
+  double Trange = Tmax - Tmin;
+  if (RELASTRO_OP == OP_HIGH_SPEED) {
+    Tmean = 0.5*(Tmax - Tmin);
+  } else {
+    Tmean /= (float) N;
+  }
+  /* we need to do the fit in a locally linear space; choose a ref coordinate */
+  coords.crval1 = R[0];
+  coords.crval2 = D[0];
+  // to judge the quality of the PM and PAR fits, we need to fit all three models and compare Chisq
+  // project all of the R,D coordinates to a plane centered on this coordinate. set
+  // the times to be relative to Tmean (this is required for parallax as well)
+  for (k = 0; k < N; k++) {
+    RD_to_XY (&X[k], &Y[k], R[k], D[k], &coords);
+    T[k] -= Tmean;
+    if (XVERB) {
+      fprintf (stderr, OFF_T_FMT" %f %f %f  %f %f +/- %f %f\n",  k, T[k], R[k], D[k], X[k], Y[k], dX[k], dY[k]);
+    }
+  }
+  // *** first fit for the proper motion (skip fit if Trange or Npts is too small) ***
+  if ((mode == FIT_PM_ONLY) || (mode == FIT_PM_AND_PAR)) {
+    if (Trange < PM_DT_MIN) {
+      mode = FIT_AVERAGE;
+      goto skipPM;
+    }
+    if (N <= PM_TOOFEW) {
+      mode = FIT_AVERAGE;
+      goto skipPM;
+    }
+    FitPM (&fitPM, X, dX, Y, dY, T, N, XVERB);
+    if (XVERB) fprintf (stderr, "fitted PM:  %f - %f : %f %f : %f %f : %f vs %f\n", Tmin, Tmax, fitPM.Ro, fitPM.Do, fitPM.uR, fitPM.uD, fitPM.chisq, fitAve.chisq);
+    // project Ro, Do back to RA,DEC
+    XY_to_RD (&fitPM.Ro, &fitPM.Do, fitPM.Ro, fitPM.Do, &coords);
+    if (XVERB) fprintf (stderr, "project: %f %f : %f %f : %f\n", fitPM.Ro, fitPM.Do, fitPM.uR, fitPM.uD, fitPM.p);
+    if (fabs(fitPM.Ro) < 0.01) fprintf (stderr, "watch out for 0,360 boundary\n");
+    // XXX : does this make sense at 0,360 boundary?
+    fitPM.p  = fitPM.dp  = 0.0;
+    average[0].flags |= ID_STAR_FIT_PM;
+    fitStats->Npm ++;
+    // XXX a hard-wired hack...
+    if ((fabs(fitPM.uR) > 2.0) || (fabs(fitPM.uD) > 2.0)) {
+      mode = FIT_AVERAGE;
+      average[0].flags |= ID_STAR_BAD_PM;
+    }
+  }
+skipPM:
+  // fit the parallax + proper-motion model
+  // NOTE : we only fit PAR if we have already fitted for proper motion. if we do not fit PM or we fail
+  // to fit PM, we do not attempt PAR.  thus failure to fit PAR falls back to PM-only
+  if (mode == FIT_PM_AND_PAR) {
+    if (Trange < PM_DT_MIN) {
+      mode = FIT_PM_ONLY;
+      goto skipPAR;
+    }
+    if (N <= PAR_TOOFEW) {
+      mode = FIT_PM_ONLY;
+      goto skipPAR;
+    }
+    float pXmin = +2.0;
+    float pXmax = -2.0;
+    float pYmin = +2.0;
+    float pYmax = -2.0;
+    for (k = 0; k < N; k++) {
+      ParFactor (&pX[k], &pY[k], R[k], D[k], T[k], Tmean);
+      pXmin = MIN (pXmin, pX[k]);
+      pXmax = MAX (pXmax, pX[k]);
+      pYmin = MIN (pYmin, pY[k]);
+      pYmax = MAX (pYmax, pY[k]);
+    }
+    float dXRange = pXmax - pXmin;
+    float dYRange = pYmax - pYmin;
+    float parRange = hypot (dXRange, dYRange);
+# define PAR_TOOFEW 5
+        if ((parRange >= PAR_FACTOR_MIN) && (N > PAR_TOOFEW)) {
+          FitPMandPar (&fitPAR, X, dX, Y, dY, T, pX, pY, N, XVERB);
+          if (XVERB) fprintf (stderr, "fitted PM+PAR:  %f - %f : %f %f : %f %f : %f %f : %f vs %f vs %f\n", Tmin, Tmax, fitPAR.Ro, fitPAR.Do, fitPAR.uR, fitPAR.uD, fitPAR.p, fitPAR.dp, fitPAR.chisq, fitPM.chisq, fitAve.chisq);
+          XY_to_RD (&fitPAR.Ro, &fitPAR.Do, fitPAR.Ro, fitPAR.Do, &coords);
+          catalog[i].average[j].flags |= ID_STAR_FIT_PAR;
+          Npar ++;
+          // XXX a hard-wired hack...
+          if ((fabs(fitPAR.uR) > 2.0) || (fabs(fitPAR.uD) > 2.0)) {
+            mode = FIT_AVERAGE;
+            catalog[i].average[j].flags |= ID_STAR_BAD_PM;
+          }
+        } else {
+          // need to set mode = FIT_PM_ONLY if we do not fit for parallax
+          mode = FIT_PM_ONLY;
+        }
+      }
+      // fit the average model
+      if ((mode == FIT_AVERAGE) || (mode == FIT_PM_ONLY) || (mode == FIT_PM_AND_PAR)) {
+        liststats_pos (R, dR, N, &statsR, XVERB); // WARNING: this function modifies R (do not use after here)
+        liststats_pos (D, dD, N, &statsD, XVERB); // WARNING: this function modifies D (do not use after here)
+        fitAve.Ro = statsR.mean;
+        fitAve.dRo = 3600.0*statsR.sigma;
+        fitAve.Do = statsD.mean;
+        fitAve.dDo = 3600.0*statsD.sigma;
+        fitAve.chisq = 0.5 * (statsR.chisq + statsD.chisq);
+        fitAve.Nfit = N;
+        fitAve.uR = fitAve.duR = 0.0;
+        fitAve.uD = fitAve.duD = 0.0;
+        fitAve.p  = fitAve.dp  = 0.0;
+        catalog[i].average[j].flags |= ID_STAR_FIT_AVE;
+        Nave ++;
+      }
+      if (setRefColor) {
+        float colorMedian;
+        dsort (C_blue, NcBlue);
+        colorMedian = (NcBlue > 0) ? C_blue[(int)(0.5*NcBlue)] : NAN;
+        catalog[i].average[j].refColorBlue = colorMedian;
+        dsort (C_red, NcRed);
+        colorMedian = (NcRed > 0) ? C_red[(int)(0.5*NcRed)] : NAN;
+        catalog[i].average[j].refColorRed = colorMedian;
+      }
+      /* choose the result based on the chisq values */
+      // XXXX for now, just use the mode as the result:
+      result = mode;
+      switch (result) {
+      case FIT_AVERAGE:
+        catalog[i].average[j].flags |= ID_STAR_USE_AVE;
+        fit = fitAve;
+        break;
+      case FIT_PM_ONLY:
+        catalog[i].average[j].flags |= ID_STAR_USE_PM;
+        fit = fitPM;
+        break;
+      case FIT_PM_AND_PAR:
+        catalog[i].average[j].flags |= ID_STAR_USE_PAR;
+        fit = fitPAR;
+        break;
+      }
+      if (XVERB) fprintf (stderr, "%f %f -> %f %f (%f,%f) pm=(%f %f) plx=(%f +/- %f)\n",
+                          catalog[i].average[j].R,
+                          catalog[i].average[j].D,
+                          fit.Ro, fit.Do,
+*(catalog[i].average[j].R - fit.Ro),
+*(catalog[i].average[j].D - fit.Do),
+                          fit.uR, fit.uD, fit.p, fit.dp);
+      // make sure that the fit succeeded
+      status = TRUE;
+      status &= finite(fit.Ro);
+      status &= finite(fit.Do);
+      status &= finite(fit.dRo);
+      status &= finite(fit.dDo);
+      status &= finite(fit.uR);
+      status &= finite(fit.uD);
+      status &= finite(fit.duR);
+      status &= finite(fit.duD);
+      status &= finite(fit.p);
+      status &= finite(fit.dp);
+      if (!status) {
+        Nskip ++;
+        continue;
+      }
+      // what is the offset relative to the mean fit position?
+      coords.crval1 = catalog[i].average[j].R;
+      coords.crval2 = catalog[i].average[j].D;
+      double dXoff, dYoff;
+      RD_to_XY (&dXoff, &dYoff, fit.Ro, fit.Do, &coords);
+      float dPos = hypot (dXoff, dYoff);
+      if (dPos > MaxMeanOffset) {
+        if (Noffset < 100) {
+          fprintf (stderr, "(%f,%f) -> (%f,%f) (%f,%f)\n", coords.crval1, coords.crval2, fit.Ro, fit.Do, dXoff, dYoff);
+        }
+        Noffset ++;
+        continue;
+      }
+      // the measure fields must be updated before the average fields
+      for (k = 0; k < catalog[i].average[j].Nmeasure; k++) {
+        setMeanR (fit.Ro, &measure[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]);
+        setMeanD (fit.Do, &measure[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]);
+        if (measureBig) {
+          setMeanR_Big (fit.Ro, &measureBig[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]);
+          setMeanD_Big (fit.Do, &measureBig[k], &catalog[i].average[j], &catalog[i].secfilt[j*Nsecfilt]);
+        }
+      }
+      catalog[i].average[j].R   = fit.Ro; // RA in degrees
+      catalog[i].average[j].D   = fit.Do; // DEC in degrees
+      catalog[i].average[j].dR  = fit.dRo; // RA scatter in arcsec
+      catalog[i].average[j].dD  = fit.dDo; // DEC scatter in arcsec
+      catalog[i].average[j].uR  = fit.uR; // RA proper motion in arcsec/year
+      catalog[i].average[j].uD  = fit.uD; // DEC proper motion in arcsec/year
+      catalog[i].average[j].duR = fit.duR; // RA proper motion error in arcsec/year
+      catalog[i].average[j].duD = fit.duD; // DEC proper motion error in arcsec/year
+      catalog[i].average[j].P   = fit.p; // parallax in arcsec
+      catalog[i].average[j].dP  = fit.dp; // parallax error in arcsec
+      catalog[i].average[j].ChiSqAve  = fitAve.chisq;
+      catalog[i].average[j].ChiSqPM   = fitPM.chisq;
+      catalog[i].average[j].ChiSqPar  = fitPAR.chisq;
+      catalog[i].average[j].Tmean = (Tmean * 86400 * 365.25) + T2000;
+      catalog[i].average[j].Trange = (Trange * 86400 * 365.25);
+      catalog[i].average[j].Npos = fit.Nfit;
+      // unset the NO_ASTROM bit (not(NO_ASTROM) == HAVE_ASTROM)
+      catalog[i].average[j].flags &= ~ID_STAR_NO_ASTROM;
+      if (XVERB) fprintf (stderr, "%f %f -> %f %f (%f,%f) pm=(%f %f) chisq=(%f, %f, %f)\n",
+                          catalog[i].average[j].R,
+                          catalog[i].average[j].D,
+                          fit.Ro, fit.Do,
+*(catalog[i].average[j].R - fit.Ro),
+*(catalog[i].average[j].D - fit.Do),
+                          catalog[i].average[j].uR,
+                          catalog[i].average[j].uD,
+                          fitAve.chisq, fitPM.chisq, fitPAR.chisq);
+    }
+    NaveSum += Nave;
+    NpmSum += Npm;
+    NparSum += Npar;
+    NskipSum += Nskip;
+    NoffSum += Noffset;
+    if (VERBOSE) fprintf (stderr, "catalog %d : "OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par : Nskip "OFF_T_FMT", Noffset "OFF_T_FMT"\n",  i,  Nave,  Npm,  Npar,  Nskip, Noffset);
+  }
+  freeObjectData ();
+  if (VERBOSE) fprintf (stderr, "fitted "OFF_T_FMT" objects ("OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par), skipped "OFF_T_FMT", "OFF_T_FMT" have too large an offset\n",  (NaveSum + NpmSum + NparSum),  NaveSum,  NpmSum,  NparSum,  NskipSum, NoffSum);
+    if (parRange < PAR_FACTOR_MIN) {
+      mode = FIT_PM_ONLY;
+      goto skipPAR;
+    }
+    FitPMandPar (&fitPAR, X, dX, Y, dY, T, pX, pY, N, XVERB);
+    if (XVERB) fprintf (stderr, "fitted PM+PAR:  %f - %f : %f %f : %f %f : %f %f : %f vs %f vs %f\n", Tmin, Tmax, fitPAR.Ro, fitPAR.Do, fitPAR.uR, fitPAR.uD, fitPAR.p, fitPAR.dp, fitPAR.chisq, fitPM.chisq, fitAve.chisq);
+    XY_to_RD (&fitPAR.Ro, &fitPAR.Do, fitPAR.Ro, fitPAR.Do, &coords);
+    average[0].flags |= ID_STAR_FIT_PAR;
+    fitStats->Npar ++;
+    if (fabs(fitPM.Ro) < 0.01) fprintf (stderr, "watch out for 0,360 boundary\n");
+    // XXX a hard-wired hack...
+    if ((fabs(fitPAR.uR) > 2.0) || (fabs(fitPAR.uD) > 2.0)) {
+      mode = FIT_PM_ONLY;
+    }
+  }
+skipPAR:
+  {
+    // ALWAYS fit the average model
+    StatType statsR, statsD;
+    liststats_pos (X, dX, N, &statsR, XVERB); // WARNING: this function modifies R (do not use after here)
+    liststats_pos (Y, dY, N, &statsD, XVERB); // WARNING: this function modifies D (do not use after here)
+    // project Ro, Do back to RA,DEC
+    XY_to_RD (&fitAve.Ro, &fitAve.Do, statsR.mean, statsD.mean, &coords);
+    if (XVERB) fprintf (stderr, "average: %f %f\n", fitAve.Ro, fitAve.Do);
+    fitAve.dRo = statsR.sigma;
+    fitAve.dDo = statsD.sigma;
+    fitAve.chisq = (N > 1) ? 0.5 * (statsR.chisq + statsD.chisq) : NAN;
+    fitAve.Nfit = N;
+    fitAve.uR = fitAve.duR = 0.0;
+    fitAve.uD = fitAve.duD = 0.0;
+    fitAve.p  = fitAve.dp  = 0.0;
+    average[0].flags |= ID_STAR_FIT_AVE;
+    fitStats->Nave ++;
+  }
+  if (setRefColor) {
+    float colorMedian;
+    dsort (C_blue, NcBlue);
+    colorMedian = (NcBlue > 0) ? C_blue[(int)(0.5*NcBlue)] : NAN;
+    average[0].refColorBlue = colorMedian;
+    dsort (C_red, NcRed);
+    colorMedian = (NcRed > 0) ? C_red[(int)(0.5*NcRed)] : NAN;
+    average[0].refColorRed = colorMedian;
+  }
+  /* choose the result based on the chisq values */
+  // XXXX for now, just use the mode as the result:
+  int result = mode;
+  switch (result) {
+    case FIT_AVERAGE:
+      average[0].flags |= ID_STAR_USE_AVE;
+      fit = fitAve;
+      break;
+    case FIT_PM_ONLY:
+      average[0].flags |= ID_STAR_USE_PM;
+      fit = fitPM;
+      break;
+    case FIT_PM_AND_PAR:
+      average[0].flags |= ID_STAR_USE_PAR;
+      fit = fitPAR;
+      break;
+  }
+  if (XVERB) {
+    fprintf (stderr, "%f %f -> %f %f (%f,%f) pm=(%f %f) plx=(%f +/- %f)\n",
+             average[0].R,
+             average[0].D,
+             fit.Ro, fit.Do,
+*(average[0].R - fit.Ro),
+*(average[0].D - fit.Do),
+             fit.uR, fit.uD, fit.p, fit.dp);
+    fprintf (stderr, "-----\n");
+  }
+  // make sure that the fit succeeded
+  int status = TRUE;
+  status &= finite(fit.Ro);
+  status &= finite(fit.Do);
+  status &= finite(fit.dRo);
+  status &= finite(fit.dDo);
+  status &= finite(fit.uR);
+  status &= finite(fit.uD);
+  status &= finite(fit.duR);
+  status &= finite(fit.duD);
+  status &= finite(fit.p);
+  status &= finite(fit.dp);
+  if (!status) {
+    fitStats->Nskip ++;
+    return FALSE; // XXX ??
+  }
+  // what is the offset relative to the mean fit position?
+  coords.crval1 = average[0].R;
+  coords.crval2 = average[0].D;
+  if (isnan(coords.crval1)) {
+    return (FALSE);
+  }
+  if (isnan(coords.crval2)) {
+    return (FALSE);
+  }
+  double dXoff, dYoff;
+  RD_to_XY (&dXoff, &dYoff, fit.Ro, fit.Do, &coords);
+  float dPos = hypot (dXoff, dYoff);
+  if (dPos > MaxMeanOffset) {
+    if (fitStats->Noffset < 100) {
+      fprintf (stderr, "(%f,%f) -> (%f,%f) (%f,%f)\n", coords.crval1, coords.crval2, fit.Ro, fit.Do, dXoff, dYoff);
+    }
+    fitStats->Noffset ++;
+    return FALSE; // XXX ??
+  }
+  if (XVERB) fprintf (stderr, "%f %f -> %f %f (%f,%f) pm=(%f %f) chisq=(%f, %f, %f)\n",
+                      average[0].R,
+                      average[0].D,
+                      fit.Ro, fit.Do,
+*(average[0].R - fit.Ro),
+*(average[0].D - fit.Do),
+                      average[0].uR,
+                      average[0].uD,
+                      fitAve.chisq, fitPM.chisq, fitPAR.chisq);
+  average[0].R          = fit.Ro; // RA in degrees
+  average[0].D          = fit.Do; // DEC in degrees
+  average[0].dR         = fit.dRo; // RA scatter in arcsec
+  average[0].dD         = fit.dDo; // DEC scatter in arcsec
+  average[0].uR         = fit.uR; // RA proper motion in arcsec/year
+  average[0].uD         = fit.uD; // DEC proper motion in arcsec/year
+  average[0].duR        = fit.duR; // RA proper motion error in arcsec/year
+  average[0].duD        = fit.duD; // DEC proper motion error in arcsec/year
+  average[0].P          = fit.p; // parallax in arcsec
+  average[0].dP         = fit.dp; // parallax error in arcsec
+  average[0].ChiSqAve   = fitAve.chisq;
+  average[0].ChiSqPM    = fitPM.chisq;
+  average[0].ChiSqPar   = fitPAR.chisq;
+  average[0].Tmean      = (Tmean * 86400 * 365.25) + T2000;
+  average[0].Trange     = (Trange * 86400 * 365.25);
+  average[0].Npos       = fit.Nfit;
+  // unset the NO_ASTROM bit (not(NO_ASTROM) == HAVE_ASTROM)
+  average[0].flags &= ~ID_STAR_NO_ASTROM;
   return (TRUE);
+}
+// This function operates on both Measure and MeasureTiny.  In the big stages, this should
+// be called with just MeasureTiny set and Measure == NULL
+int UpdateObjects_Stack (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats) {
+  off_t k;
+  // set the default values
+  average[0].Rstk  = NAN; // RA in degrees
+  average[0].Dstk  = NAN; // DEC in degrees
+  average[0].dRstk = NAN; // RA scatter in arcsec
+  average[0].dDstk = NAN; // DEC scatter in arcsec
+  /* calculate the average value of R,D for a single star */
+  PMFit fitAve;
+  memset (&fitAve, 0, sizeof(fitAve));
+  fitAve.chisq = NAN;
+  if (average[0].Nmeasure == 0) return TRUE;
+  int N = 0;
+  int XVERB = FALSE;
+  XVERB |= (average[0].objID == OBJ_ID_SRC) && (average[0].catID == CAT_ID_SRC);
+  XVERB |= (average[0].objID == OBJ_ID_DST) && (average[0].catID == CAT_ID_DST);
+  // find the basic properties of the detections for this object (Tmin, Tmax, Tmean)
+  for (k = 0; k < average[0].Nmeasure; k++) {
+    if (XVERB) {
+      char *date = ohana_sec_to_date (measure[k].t);
+      int dbFlagsBig = measureBig ? measureBig[k].dbFlags : 0;
+      fprintf (stderr, "stack: "OFF_T_FMT" %f %f %s : 0x%08x : 0x%08x\n",  k, measure[k].R, measure[k].D, date, measure[k].dbFlags, dbFlagsBig);
+      free (date);
+    }
+    // SKIP everything except gpc1 stack data
+    if (!isGPC1stack(measure[k].photcode)) continue;
+    // exclude bad detections based on: photcodes, psfQF, time range, photflags & astromBadMask, mag_inst
+    int keepMeasure = measureBig ? MeasFilterTest(&measureBig[k], FALSE) : MeasFilterTestTiny(&measure[k], FALSE);
+    if (!keepMeasure) {
+      continue;
+    }
+    R[N] = getMeanR (&measure[k], average, secfilt);
+    D[N] = getMeanD (&measure[k], average, secfilt);
+    // dX, dY : error in arcsec --
+    dX[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_RA);
+    dY[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_DEC);
+    // allow a given photcode or measurement to be
+    // ignored if the error is NAN (for photcode, set astromErrSys to NaN)
+    if (isnan(dX[N])) continue;
+    if (isnan(dY[N])) continue;
+    // XXX this is (slightly) inconsistent: dX,dY are the X and Y direction errors in
+    // arcseconds.  dR, dD are the errors in those directions in degrees.  IF we have
+    // non-circular errors (different values for X and Y), then dR and dD will be
+    // incorrect: they would need to be rotated to take out the position angle
+    dR[N] = dX[N] / 3600.0;
+    dD[N] = dY[N] / 3600.0;
+    // XXX use a different flag for stack measurements?
+    // measure[k].dbFlags |= ID_MEAS_USED_OBJ;
+    // if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_USED_OBJ; }
+    N++;
+  } // loop over measurements : average[0].Nmeasure
+  // if we have too few good detections for the desired fit, or too limited a
+  // baseline, use a fit with fewer parameters.  XXX if we have too few measurements
+  // for even the average position, consider including the lower-quality detections?
+  // too few measurements for average position (require 2 values)
+  if (N < 1) return FALSE; // XXX ??
+  // find the mean position
+  StatType statsR, statsD;
+  liststats_pos (R, dR, N, &statsR, XVERB); // WARNING: this function modifies R (do not use after here)
+  liststats_pos (D, dD, N, &statsD, XVERB); // WARNING: this function modifies D (do not use after here)
+  fitAve.Ro = statsR.mean;
+  fitAve.dRo = 3600.0*statsR.sigma;
+  fitAve.Do = statsD.mean;
+  fitAve.dDo = 3600.0*statsD.sigma;
+  fitAve.chisq = 0.5 * (statsR.chisq + statsD.chisq);
+  fitAve.Nfit = N;
+  // XXX choose stack flag? average[0].flags |= ID_STAR_FIT_AVE;
+  fitStats->Nave ++;
+  if (XVERB) fprintf (stderr, "%f %f -> %f %f (%f,%f)\n",
+                      average[0].R,
+                      average[0].D,
+                      fitAve.Ro, fitAve.Do,
+*(average[0].R - fitAve.Ro),
+*(average[0].D - fitAve.Do));
+  // make sure that the fit succeeded
+  int status = TRUE;
+  status &= finite(fitAve.Ro);
+  status &= finite(fitAve.Do);
+  status &= finite(fitAve.dRo);
+  status &= finite(fitAve.dDo);
+  if (!status) {
+    fitStats->Nskip ++;
+    return FALSE;
+  }
+  // what is the offset relative to the mean fit position?
+  coords.crval1 = average[0].R;
+  coords.crval2 = average[0].D;
+  double dXoff, dYoff;
+  RD_to_XY (&dXoff, &dYoff, fitAve.Ro, fitAve.Do, &coords);
+  float dPos = hypot (dXoff, dYoff);
+  if (dPos > MaxMeanOffset) {
+    if (fitStats->Noffset < 100) {
+      fprintf (stderr, "(%f,%f) -> (%f,%f) (%f,%f)\n", coords.crval1, coords.crval2, fitAve.Ro, fitAve.Do, dXoff, dYoff);
+    }
+    fitStats->Noffset ++;
+    return FALSE;
+  }
+  // set the stack position values
+  average[0].Rstk  = fitAve.Ro; // RA in degrees
+  average[0].Dstk  = fitAve.Do; // DEC in degrees
+  average[0].dRstk = fitAve.dRo; // RA scatter in arcsec
+  average[0].dDstk = fitAve.dDo; // DEC scatter in arcsec
+  return (TRUE);
+}
 /* fitting proper-motion and parallax:

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/args.c

-              r37038
+              r37822
     remove_argument (N, &argc, argv);
     MaxDensityUse = TRUE;
+  }
+  APPLY_OFFSETS = FALSE;
+  if ((N = get_argument (argc, argv, "-apply-offsets"))) {
+    remove_argument (N, &argc, argv);
+    APPLY_OFFSETS = TRUE;
+  }
 …
+  }
+  CHIPMAP = 0;
+  if ((N = get_argument (argc, argv, "-chipmap"))) {
+    remove_argument (N, &argc, argv);
+    CHIPMAP = atoi(argv[N]);
+    remove_argument (N, &argc, argv);
+  }
   SAVEPLOT = FALSE;
   PLOTSTUFF = FALSE;
 …
     RESET = TRUE;
+  }
   RESET_BAD_IMAGES = FALSE;
   if ((N = get_argument (argc, argv, "-reset-bad-images"))) {
     remove_argument (N, &argc, argv);
     RESET_BAD_IMAGES = TRUE;
+  }
+  RESET_IMAGES = FALSE;
+  if ((N = get_argument (argc, argv, "-reset-images"))) {
+    remove_argument (N, &argc, argv);
+    RESET_IMAGES = TRUE;
+  }
 …
   fprintf (stderr, "  -high-speed (code[,code,code]) (code[,code,code]) (radius) (output catdir)\n");
   fprintf (stderr, "  -hpm (radius) (output catdir)\n");
+  fprintf (stderr, "  -chipmap (MaxOrder)\n");
   fprintf (stderr, "  -merge-source (objID) (catID) into (objID) (catID)\n\n");
 …
   fprintf (stderr, "  -statmode (mode)\n");
   fprintf (stderr, "  -reset\n");
+  fprintf (stderr, "  -reset-images\n");
   fprintf (stderr, "  -nloop (N) : number of image-fit iterations\n");
   fprintf (stderr, "  -update : apply new fit to database\n");

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/assign_images.c

-              r36630
+              r37822
   BuildChipMatch (image, Nimage);
   MARKTIME("build chip match for %d images: %f sec\n", (int) Nimage, dtime);
+  char mapfile[DVO_MAX_PATH];
+  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", CATDIR);
+  AstromOffsetTable *table = AstromOffsetMapLoad (mapfile, VERBOSE);
+  // assign images.coords.offsetMap -> table->map[i]
+  if (table) {
+    AstromOffsetTableMatchChips (image, Nimage, table);
+  } else {
+    table = AstromOffsetTableInit ();
+  }
+  put_astrom_table (table);
   initMosaics (image, Nimage);
 …
     if (!strcmp(&image[j].coords.ctype[4], "-DIS")) continue;
-    // match the image to its corresponding ASTROMETRIC mosaic (not the same as the Mosaic above)
-    if (!FindMosaicForImage (image, Nimage, j)) {
-      if (VERBOSE2) fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i);
-      continue;
+    }
     // Exclude images with crazy astrometry
     // XXX NOTE : this is gpc1-specific
 …
     // this is a bit memory expensive : I am making a complete copy of the image table here
+    off_t Nsubset = regionHosts->hosts[i].Nimage;
+    regionHosts->hosts[i].image[Nsubset] = image[j];
+    regionHosts->hosts[i].imseq[Nsubset] = j;
+    regionHosts->hosts[i].Nimage ++;
+    if (regionHosts->hosts[i].Nimage == regionHosts->hosts[i].NIMAGE) {
+      regionHosts->hosts[i].NIMAGE += D_NIMAGE;
+      REALLOCATE (regionHosts->hosts[i].image, Image, regionHosts->hosts[i].NIMAGE);
+      REALLOCATE (regionHosts->hosts[i].imseq, off_t, regionHosts->hosts[i].NIMAGE);
+    off_t Nsubset = host->Nimage;
+    host->image[Nsubset] = image[j];
+    host->imseq[Nsubset] = j;
+    host->Nimage ++;
+    if (host->Nimage == host->NIMAGE) {
+      host->NIMAGE += D_NIMAGE;
+      REALLOCATE (host->image, Image, host->NIMAGE);
+      REALLOCATE (host->imseq, off_t, host->NIMAGE);
+    }
+    // save the astrometry maps, where they exist
+    if (image[j].coords.offsetMap) {
+      if (!host->astromTable) {
+        host->astromTable = AstromOffsetTableInit();
+      }
+      AstromOffsetTableAddMapFromImage(host->astromTable, &image[j]);
+    }
+  }
 …
+}
-int calculate_host_image_bounds (RegionHostTable *regionHosts) {
-  int i, n;
-  off_t j;
-  for (i = 0; i < regionHosts->Nhosts; i++) {
-    RegionHostInfo *host = &regionHosts->hosts[i];
-    // XXX clear the chip match?
-    BuildChipMatch (host->image, host->Nimage);
-    double Rmin = 360.0;
-    double Rmax =   0.0;
-    double Dmin = +90.0;
-    double Dmax = -90.0;
-    for (j = 0; j < host->Nimage; j++) {
-      Image *image = &host->image[j];
-      if (!FindMosaicForImage (host->image, host->Nimage, j)) {
-        fprintf (stderr, "missing astrometry? programming error?\n");
-        abort ();
+      }
-      // define image corners
-      for (n = 0; n < 4; n++) {
-        double Xc, Yc, Rc, Dc;
-        Xc = Xf[n]*image->NX;
-        Yc = Yf[n]*image->NY;
-        XY_to_RD (&Rc, &Dc, Xc, Yc, &image->coords);
-        Rc = ohana_normalize_angle_to_midpoint (Rc, 180.0);
-        Rmin = MIN (Rmin, Rc);
-        Dmin = MIN (Dmin, Rc);
-        Rmax = MAX (Rmax, Rc);
-        Dmax = MAX (Dmax, Rc);
+      }
+    }
-    host->RminCat = Rmin;
-    host->DminCat = Dmin;
-    host->RmaxCat = Rmax;
-    host->DmaxCat = Dmax;
-    // regionHosts needs to have the full outer boundary
-    // (so reload_catalogs covers the correct region)
-    regionHosts->Rmin = MIN(Rmin, regionHosts->Rmin);
-    regionHosts->Rmax = MAX(Rmax, regionHosts->Rmax);
-    regionHosts->Dmin = MIN(Dmin, regionHosts->Dmin);
-    regionHosts->Dmax = MAX(Dmax, regionHosts->Dmax);
+  }
-  return TRUE;
+}
 // XXX add a search tree to speed this up?
 int find_host_for_coords (RegionHostTable *regionHosts, double Rc, double Dc) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/bcatalog.c

-              r36833
+              r37822
   /* for outlier rejection, project coordinates to a plane centered on the object with units of arcsec */
+  coords.crval1 = 0;
+  coords.crval2 = 0;
+  coords.crpix1 = 0;
+  coords.crpix2 = 0;
+  InitCoords (&coords, "DEC--SIN");
   coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
-  coords.pc1_1  = coords.pc2_2 = 1.0;
-  coords.pc1_2  = coords.pc2_1 = 0.0;
-  coords.Npolyterms = 1;
-  strcpy (coords.ctype, "DEC--SIN");
   // XXX in the future, use catalog[0].Nsecfilt only?  allow catalogs to have variable Nsecfilt?
 …
     if (catalog[0].average[i].Nmeasure <= SRC_MEAS_TOOFEW) {
       continue;
-      // XXX can't (easily) count this for a given chip
+    }
 …
     if (RESET) {
       subcatalog[0].average[Naverage].flags &= ~averageBits;
+    }
+    // if we want to do static correction to ICRF, keep the ICRF QSOs (regardless of other data quality)
+    if (USE_ICRF_CORRECT && (subcatalog[0].average[Naverage].flags & ID_ICRF_QSO)) {
+      Nm = 0;
+      for (j = 0; j < catalog[0].average[i].Nmeasure; j++) {
+        offset = catalog[0].average[i].measureOffset + j;
+        CopyMeasureToTiny (&subcatalog[0].measureT[Nmeasure], &catalog[0].measure[offset]);
+        subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_SKIP_ASTROM;
+        subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_NOCAL;
+        subcatalog[0].measureT[Nmeasure].averef   = Naverage;
+        if (RESET) {
+          subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_POOR_ASTROM;
+          subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_AREA;
+        }
+        Nmeasure ++;
+        Nm ++;
+        if (Nmeasure == NMEASURE) {
+          NMEASURE += 1000;
+          REALLOCATE (subcatalog[0].measureT, MeasureTiny, NMEASURE);
+        }
+      }
+      subcatalog[0].average[Naverage].Nmeasure = Nm;
+      Naverage ++;
+      if (Naverage == NAVERAGE) {
+        NAVERAGE += 50;
+        REALLOCATE (subcatalog[0].average, Average, NAVERAGE);
+        REALLOCATE (subcatalog[0].secfilt, SecFilt, NAVERAGE*Nsecfilt);
+      }
+      continue;
+    }
+    // if we want to correct to the galay model, we need to use objects with distances determined by Green & Schlafly
+    if (USE_GALAXY_MODEL && !catalog[0].average[i].Nstarpar) {
+      // we may want to add some starpar quality filters...
+      continue;
+    }
 …
       // exclude bogus
       if (ExcludeBogus) {
+          double Ri = getMeanR_Big (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]);
+          double Di = getMeanD_Big (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]);
+          coords.crval1 = catalog[0].average[i].R;
+          coords.crval2 = catalog[0].average[i].D;
+          double Xi, Yi;
+          RD_to_XY (&Xi, &Yi, Ri, Di, &coords);
+          double radius = hypot(Xi, Yi);
+          if (radius > ExcludeBogusRadius) {
+              NskipBogus ++;
+              if (VERBOSE2) {
+                FILE *foutput = fbogus ? fbogus : stderr;
+                char *date = ohana_sec_to_date(catalog[0].measure[offset].t);
+                fprintf (foutput, "exclude bogus: %10.6f %10.6f : %10.6f %10.6f : %6.2f %6.2f : %6.2f : %5d %s\n", catalog[0].average[i].R, catalog[0].average[i].D, Ri, Di, Xi, Yi, radius, catalog[0].measure[offset].photcode, date);
+                free (date);
+              }
+              continue;
+        double Ri = getMeanR_Big (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]);
+        double Di = getMeanD_Big (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]);
+        coords.crval1 = catalog[0].average[i].R;
+        coords.crval2 = catalog[0].average[i].D;
+        double Xi, Yi;
+        RD_to_XY (&Xi, &Yi, Ri, Di, &coords);
+        double radius = hypot(Xi, Yi);
+        if (radius > ExcludeBogusRadius) {
+          NskipBogus ++;
+          if (VERBOSE2) {
+            FILE *foutput = fbogus ? fbogus : stderr;
+            char *date = ohana_sec_to_date(catalog[0].measure[offset].t);
+            fprintf (foutput, "exclude bogus: %10.6f %10.6f : %10.6f %10.6f : %6.2f %6.2f : %6.2f : %5d %s\n", catalog[0].average[i].R, catalog[0].average[i].D, Ri, Di, Xi, Yi, radius, catalog[0].measure[offset].photcode, date);
+            free (date);
+          }
+          continue;
+        }
+      }
 …
       subcatalog[0].measureT[Nmeasure].averef   = Naverage;
       if (RESET) {
         subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_POOR_ASTROM;
         subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_AREA;
+        subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_POOR_ASTROM;
+        subcatalog[0].measureT[Nmeasure].dbFlags &= ~ID_MEAS_AREA;
+      }
 …
       Nm ++;
       if (Nmeasure == NMEASURE) {
+        NMEASURE += 1000;
+        REALLOCATE (subcatalog[0].measureT, MeasureTiny, NMEASURE);
+      }
+        NMEASURE += 1000;
+        REALLOCATE (subcatalog[0].measureT, MeasureTiny, NMEASURE);
+      }
+    }
+    // we have filtered this object.  do not keep it if we now have too few meas
+    if (Nm <= SRC_MEAS_TOOFEW) {
+      Nmeasure -= Nm;
+      continue;
+    }
     subcatalog[0].average[Naverage].Nmeasure = Nm;
 …
   assert (Nsecfilt == catalog[0].Nsecfilt);
   // limit the total number of stars in the catalog
+// limit the total number of stars in the catalog
   if (MaxDensityUse) {
     LimitDensityCatalog_ByNmeasureGrid (subcatalog, catalog);
 …
 # define SWAPFUNC(A,B){ int tmpI; off_t tmpT;   \
   tmpI = X[A]; X[A] = X[B]; X[B] = tmpI; \
   tmpT = Y[A]; Y[A] = Y[B]; Y[B] = tmpT; \
+}
+    tmpI = X[A]; X[A] = X[B]; X[B] = tmpI;      \
+    tmpT = Y[A]; Y[A] = Y[B]; Y[B] = tmpT;      \
+  }
 # define COMPARE(A,B)(X[A] > X[B])
 …
 /* generate a grid in a locally-projected coordinate system, try to select average entries
    from each grid cell in decending Nmeasure order.
  */
+*/
 int LimitDensityCatalog_ByNmeasureGrid (Catalog *subcatalog, Catalog *oldcatalog) {
 …
   /* project coordinates to a plane centered on the object with units of arcsec */
   Coords coords;
+  InitCoords (&coords, "DEC--SIN");
   coords.crval1 = Rc;
   coords.crval2 = Dc;
-  coords.crpix1 = 0;
-  coords.crpix2 = 0;
   coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
-  coords.pc1_1  = coords.pc2_2 = 1.0;
-  coords.pc1_2  = coords.pc2_1 = 0.0;
-  coords.Npolyterms = 1;
-  strcpy (coords.ctype, "DEC--SIN");
   // convert all average R,D values to X,Y:

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/fitpoly.c

-              r33652
+              r37822
+}
+int array_print (double **matrix, int Nx, int Ny) {
+  int i, j;
+  for (i = 0; i < Nx; i++) {
+    for (j = 0; j < Ny; j++) {
+      fprintf (stderr, "%10.3e ", matrix[i][j]);
+    }
+    fprintf (stderr, "\n");
+  }
+  return TRUE;
+}
+int fit_print (CoordFit *fit) {
+  fprintf (stderr, "Npts: %d, Norder: %d, Nterms: %d, Nsums: %d, Nelems: %d\n",
+           fit[0].Npts, fit[0].Norder, fit[0].Nterms, fit[0].Nsums, fit[0].Nelems);
+  fprintf (stderr, "sums: \n");
+  array_print (fit[0].sum, fit[0].Nsums, fit[0].Nsums);
+  fprintf (stderr, "xsums: \n");
+  array_print (fit[0].xsum, fit[0].Nterms, fit[0].Nterms);
+  fprintf (stderr, "ysums: \n");
+  array_print (fit[0].ysum, fit[0].Nterms, fit[0].Nterms);
+  fprintf (stderr, "xfits: \n");
+  array_print (fit[0].xfit, fit[0].Nterms, fit[0].Nterms);
+  fprintf (stderr, "yfits: \n");
+  array_print (fit[0].yfit, fit[0].Nterms, fit[0].Nterms);
+  return TRUE;
+}
 // XXX use implicit masks as below or explicit masks (with function to set?)
 // XXX eg, add a global mask to this file and
 …
       for (j = 0; j < fit[0].Nelems; j++) {
         matrix[i][j] = 0.0;
+        matrix[j][i] = 0.0;
+      }
       vector[i][0] = 0.0;
 …
+  }
   if (!dgaussjordan (matrix, vector, fit[0].Nelems, 2)) {
+  if (!dgaussjordan_pivot (matrix, vector, fit[0].Nelems, 2, 1e-16)) {
     array_free (matrix, fit[0].Nelems);
     array_free (vector, fit[0].Nelems);
 …
 /* this should only apply to the polynomial, not the projection terms */
 /* compare with psastro supporting code */
+// this code will work for linear (Npolyterm == 0 or 1) and linear + map fits
 int fit_apply_coords (CoordFit *fit, Coords *coords, int keepRef) {
 …
   /* keep the order and type from initial values */
+  if (isnan(coords[0].crval1)) {
+    return FALSE;
+  }
+  if (isnan(coords[0].crval2)) {
+    return FALSE;
+  }
+  if (isnan(coords[0].crpix1)) {
+    return FALSE;
+  }
+  if (isnan(coords[0].crpix2)) {
+    return FALSE;
+  }
   return (TRUE);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/high_speed_objects.c

-              r37038
+              r37822
   // define a local projection
+  InitCoords (&tcoords, "DEC--ARC");
   tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
   if (region[0].Dmax < 90) {
 …
     tcoords.crval2 = 90.0;
+  }
-  tcoords.crpix1 = 0;
-  tcoords.crpix2 = 0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-  tcoords.Npolyterms = 1;
-  strcpy (tcoords.ctype, "DEC--ARC");
   /* build spatial index (RA sort) referencing input array sequence */
 …
   populate_tiny_values (&catalogOut, DVO_TV_MEASURE);
   UpdateObjects (&catalogOut, 1);
+  UpdateObjects (&catalogOut, 1, 0);
   free_tiny_values(&catalogOut);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/high_speed_utils.c

-              r33652
+              r37822
     off_t n;
     for (n = 0; n < NfieldsA; n++) {
         valuesA[n] = dbExtractAverages (&catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], &catalog[0].measure[m], &fieldsA[n]);
+      valuesA[n] = dbExtractAverages (&catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], &catalog[0].measure[m], NULL, NULL, &fieldsA[n]);
+    }
     return dbBooleanCond(stackA, NstackA, valuesA);
 …
     off_t n;
     for (n = 0; n < NfieldsB; n++) {
         valuesB[n] = dbExtractAverages (&catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], &catalog[0].measure[m], &fieldsB[n]);
+        valuesB[n] = dbExtractAverages (&catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], &catalog[0].measure[m], NULL, NULL, &fieldsB[n]);
+    }
     return dbBooleanCond(stackB, NstackB, valuesB);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/hpm_objects.c

-              r37038
+              r37822
   // define a local projection
+  InitCoords (&tcoords, "DEC--ARC");
   tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
   if (region[0].Dmax < 90) {
 …
     tcoords.crval2 = 90.0;
+  }
-  tcoords.crpix1 = 0;
-  tcoords.crpix2 = 0;
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1 = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2 = tcoords.pc2_1 = 0.0;
-  tcoords.Npolyterms = 1;
   strcpy (tcoords.ctype, "DEC--ARC");
 …
     // distinguishing a bad fit from a fit with 1 or 2 bad points
     FIT_MODE = FIT_PM_ONLY;
     UpdateObjects (&testcat, 1);
+    UpdateObjects (&testcat, 1, 0);
     free_tiny_values(&testcat);
 …
   populate_tiny_values (&catalogOut, DVO_TV_MEASURE);
   UpdateObjects (&catalogOut, 1);
+  UpdateObjects (&catalogOut, 1, 0);
   free_tiny_values(&catalogOut);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/initialize.c

-              r37038
+              r37822
   if (DCR_BLUE_COLOR_POS)  fprintf (stderr, "DCR_BLUE_COLOR_POS:  %s - %s\n", DCR_BLUE_COLOR_POS, DCR_BLUE_COLOR_NEG);
   if (DCR_BLUE_COLOR_POS)  fprintf (stderr, "DCR_BLUE_COLOR_POS:  %s - %s\n", DCR_BLUE_COLOR_POS, DCR_BLUE_COLOR_NEG);
+  if (DCR_RED_COLOR_POS)   fprintf (stderr, "DCR_RED_COLOR_POS:   %s - %s\n", DCR_RED_COLOR_POS, DCR_RED_COLOR_NEG);
   if (PHOTCODE_KEEP_LIST)  fprintf (stderr, "PHOTCODE_KEEP_LIST:  %s\n", PHOTCODE_KEEP_LIST);
 …
   initstats (STATMODE);
+  if (USE_ICRF_CORRECT) {
+    if (!USE_ICRF_LOCAL && !USE_ICRF_SHFIT) {
+      fprintf (stderr, "no ICRF correction method chosen\n");
+      exit (2);
+    }
+  }
+  if (USE_ICRF_CORRECT) ICRFinit();
   /* XXX drop irrelevant entries */
   if (SHOW_PARAMS) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/launch_region_hosts.c

-              r37038
+              r37822
   int i;
+  // clear the I/O files
+  for (i = 0; i < regionHosts->Nhosts; i++) {
+    char *syncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanmags.sync");
+    if (truncate (syncfile, 0)) fprintf (stderr, "trouble clearing syncfile %s\n", syncfile);
+    free (syncfile);
+  // do not remote the sync and fits files if we do a manual run -- user must clear if needed
+  if (!PARALLEL_REGIONS_MANUAL) {
+    // clear the I/O files
+    for (i = 0; i < regionHosts->Nhosts; i++) {
+      char *meansync = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanpos.sync");
+      if (truncate (meansync, 0)) fprintf (stderr, "trouble clearing meansync %s\n", meansync);
+      free (meansync);
     char *fitsfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanmags.fits");
     if (truncate (fitsfile, 0)) fprintf (stderr, "trouble clearing fitsfile %s\n", fitsfile);
     free (fitsfile);
+      char *meanfits = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "meanpos.fits");
+      if (truncate (meanfits, 0)) fprintf (stderr, "trouble clearing meanfits %s\n", meanfits);
+      free (meanfits);
     char *imsyncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagemags.sync");
     if (truncate (imsyncfile, 0)) fprintf (stderr, "trouble clearing imsyncfile %s\n", imsyncfile);
     free (imsyncfile);
+      char *meassync = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "measpos.sync");
+      if (truncate (meassync, 0)) fprintf (stderr, "trouble clearing meassync %s\n", meassync);
+      free (meassync);
     char *imfitsfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagemags.fits");
     if (truncate (imfitsfile, 0)) fprintf (stderr, "trouble clearing imfitsfile %s\n", imfitsfile);
     free (imfitsfile);
+      char *measfits = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "measpos.fits");
+      if (truncate (measfits, 0)) fprintf (stderr, "trouble clearing measfits %s\n", measfits);
+      free (measfits);
+    char *loopsyncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "loop.sync");
+    if (truncate (loopsyncfile, 0)) fprintf (stderr, "trouble clearing loopsyncfile %s\n", loopsyncfile);
+    free (loopsyncfile);
+      char *icrfsync = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "icrfobj.sync");
+      if (truncate (icrfsync, 0)) fprintf (stderr, "trouble clearing icrfsync %s\n", icrfsync);
+      free (icrfsync);
+      char *icrffits = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "icrfobj.fits");
+      if (truncate (icrffits, 0)) fprintf (stderr, "trouble clearing icrffits %s\n", icrffits);
+      free (icrffits);
+      char *imsyncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagepos.sync");
+      if (truncate (imsyncfile, 0)) fprintf (stderr, "trouble clearing imsyncfile %s\n", imsyncfile);
+      free (imsyncfile);
+      char *imfitsfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "imagepos.fits");
+      if (truncate (imfitsfile, 0)) fprintf (stderr, "trouble clearing imfitsfile %s\n", imfitsfile);
+      free (imfitsfile);
+      char *loopsyncfile = make_filename (CATDIR, regionHosts->hosts[i].hostname, regionHosts->hosts[i].hostID, "loop.sync");
+      if (truncate (loopsyncfile, 0)) fprintf (stderr, "trouble clearing loopsyncfile %s\n", loopsyncfile);
+      free (loopsyncfile);
+    }
+    char *framesync = make_filename (CATDIR, "master", 0, "frame.corr.sync");
+    if (truncate (framesync, 0)) fprintf (stderr, "trouble clearing framesync %s\n", framesync);
+    free (framesync);
+    char *framefits = make_filename (CATDIR, "master", 0, "frame.corr.fits");
+    if (truncate (framefits, 0)) fprintf (stderr, "trouble clearing framefits %s\n", framefits);
+    free (framefits);
+  }
 …
     char filename[1024];
     snprintf (filename, 1024, "%s/Image.%d.fits", CATDIR, host->hostID);
+    if (unlink (filename)) fprintf (stderr, "trouble clearing image %s\n", filename);
     // write the image subset for this host
     ImageTableSave (filename, host->image, host->Nimage);
+    if (host->astromTable) {
+      char mapname[1024];
+      snprintf (mapname, 1024, "%s/AstroMap.%d.fits", CATDIR, host->hostID);
+      // write the image subset for this host
+      AstromOffsetMapSave (host->astromTable, mapname);
+    }
     char command[1024];
 …
     if (PhotFlagPoor)       strextend (command, "+photflagpoor %d", PhotFlagPoor);
+    if (CHIPMAP)            strextend (command, "-chipmap %d", CHIPMAP);
+    if (RESET_IMAGES)       strextend (command, "-reset-images");
     if (MinBadQF > 0.0)        strextend (command, "-min-bad-psfqf %f", MinBadQF);
     if (MaxMeanOffset != 10.0) strextend (command, "-max-mean-offset  %f", MaxMeanOffset);
 …
     strextend (command, "-D RELASTRO_DPOS_MAX %f", DPOS_MAX);
     strextend (command, "-D ADDSTAR_RADIUS %f", ADDSTAR_RADIUS);
+    strextend (command, "-D USE_GALAXY_MODEL %d", USE_GALAXY_MODEL);
+    strextend (command, "-D USE_ICRF_CORRECT %d", USE_ICRF_CORRECT);
+    strextend (command, "-D USE_ICRF_LOCAL %d",   USE_ICRF_LOCAL);
+    strextend (command, "-D USE_ICRF_SHFIT %d",   USE_ICRF_SHFIT);
+    strextend (command, "-D USE_ICRF_POLE %d",    USE_ICRF_POLE);
     if (USE_FIXED_PIXCOORDS) strextend (command, "-D USE_FIXED_PIXCOORDS 1");
 …
+  }
+  if (USE_ICRF_CORRECT) return TRUE;
+  int status = HarvestRegionHosts (regionHosts);
+  return status;
+}
+int HarvestRegionHosts (RegionHostTable *regionHosts) {
+  int status = TRUE;
   if (PARALLEL_REGIONS_MANUAL) {
     fprintf (stderr, "run the relastro_client commands above.  when these are done, hit return\n");
     getchar();
   } else {
     RegionHostTableWaitJobsGetIO (regionHosts, __FILE__, __LINE__, VERBOSE);
+    status = RegionHostTableWaitJobsGetIO (regionHosts, __FILE__, __LINE__, VERBOSE);
+  }
-  int status = TRUE;
-  for (i = 0; i < regionHosts->Nhosts; i++) {
-    status = status && (regionHosts->hosts[i].status == 0);
+  }
   return status;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/liststats.c

r34576	r37822
252	252	X2 += M / dM;
253	253	dS += M;
254		if (XVERB) fprintf (stderr, "chisq contrib : %f : %f : %f : %f : %f\n", Mo, 3600.0(value[i] - Mo), 3600.0dvalue[i], (value[i] - Mo) / dvalue[i], X2);
	254	if (XVERB) fprintf (stderr, "chisq contrib : %f : %f : %f : %f : %f\n", Mo, (value[i] - Mo), dvalue[i], (value[i] - Mo) / dvalue[i], X2);
255	255	}
256	256	X2 = X2 / (Nm - 1);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/load_catalogs.c

-              r37038
+              r37822
 Catalog *load_catalogs (SkyList *skylist, int *Ncatalog, int subselect, int hostID, char *hostpath, char *syncfile) {
   int i, j, Nstar;
+  int i, j;
   // int k, m;
   Catalog *catalog, *pcatalog, tcatalog;
 …
   bcatalog_show_skips();
+  Nstar = 0;
+  fprintf (stderr, "included %d ICRF QSOs\n", ICRFmax());
+  int Nstar = 0;
+  int Nmeas = 0;
   for (i = 0; i < Ncat; i++) {
     Nstar += catalog[i].Naverage;
+    Nmeas += catalog[i].Nmeasure;
     if ((sizeof(IDX_T) == 8) && (catalog[i].Nmeasure > 0xffffffff)) {
       fprintf (stderr, "ERROR: using small-sized IDX_T on data with more than 2G detections per table will cause errors\n");
 …
     fprintf (stderr, "warning: insufficient stars %d\n", Nstar);
+  }
+  fprintf (stderr, "using %d stars, %d measurements to calibrate\n", Nstar, Nmeas);
   // if we are running with parallel_images but not a parallel database, we need to
 …
     if (FlagOutlier)   strextend (command, "-clip %d", CLIP_THRESH);
     if (ExcludeBogus)  strextend (command, "-exclude-bogus %f", ExcludeBogusRadius);
+    if (USE_ICRF_CORRECT) strextend (command, "-D USE_ICRF_CORRECT %d", USE_ICRF_CORRECT);
+    if (USE_GALAXY_MODEL) strextend (command, "-D USE_GALAXY_MODEL %d", USE_GALAXY_MODEL);
     if (DCR_BLUE_COLOR_POS && DCR_BLUE_COLOR_NEG) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/load_images.c

-              r36630
+              r37822
 # include "relastro.h"
+static AstromOffsetTable *table = NULL;
+/* AstromOffsetMap is the map of Astrometry Offsets for non-polynomial astrometric
+ * corrections for each chip.
+ */
 int load_images (FITS_DB *db, SkyList *skylist, int UseFullOverlap) {
 …
   MARKTIME("  convert image table: %f sec\n", dtime);
+  // assign image->parent and image->coords.mosaic
+  BuildChipMatch (image, Nimage);
+  MARKTIME("build chip match: %f sec\n", dtime);
+  char mapfile[DVO_MAX_PATH];
+  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", CATDIR);
+  table = AstromOffsetMapLoad (mapfile, VERBOSE);
+  // assign images.coords.offsetMap -> table->map[i]
+  if (table) {
+    AstromOffsetTableMatchChips (image, Nimage, table);
+  } else {
+    table = AstromOffsetTableInit ();
+  }
   // select the images which overlap the selected sky regions
   subset = select_images (skylist, image, Nimage, &LineNumber, &Nsubset, UseFullOverlap);
   MARKTIME("  select images: %f sec\n", dtime);
+  if (Nsubset == Nimage) {
+    free (subset);
+    subset = image;
+  }
   initImages (subset, LineNumber, Nsubset);
 …
   return TRUE;
+}
+int save_astrom_table () {
+  char mapfile[DVO_MAX_PATH];
+  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", CATDIR);
+  AstromOffsetMapSave (table, mapfile);
+  return TRUE;
+}
+AstromOffsetTable *get_astrom_table () {
+  return table;
+}
+void put_astrom_table (AstromOffsetTable *myTable) {
+  table = myTable;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/markObjects.c

-              r37038
+              r37822
       int m = catalog[i].average[j].measureOffset;
       for (n = 0; n < catalog[i].average[j].Nmeasure; n++) {
+        if (!catalog[i].measureT[m+n].myDet) continue;
+        nOwn ++;
+        // this is a detection I own (it is on one of my images)
+        if (catalog[i].measureT[m+n].myDet) {
+          nOwn ++;
+          continue;
+        }
+        // 2MASS detections are counted as 'owned' (I completely control this object is nOwn_t == Nmeasure; no sharing needed)
+        if ((catalog[i].measureT[m+n].photcode == 2011) ||
+            (catalog[i].measureT[m+n].photcode == 2012) ||
+            (catalog[i].measureT[m+n].photcode == 2013)) {
+          nOwn ++;
+          continue;
+        }
+      }
       catalog[i].nOwn_t[j] = nOwn;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/relastroVisual.c

-              r37038
+              r37822
 /** Spawn a kapa window */
 static int initWindow(int *kapid) {
+  if (NTHREADS) {
+    fprintf (stderr, "-visual and -threads are incompatible, quitting\n");
+    exit (2);
+  }
   if (*kapid == -1) {
     *kapid = KapaOpenNamedSocket("kapa", "relastro_plots");
 …
   int i;
   for(i = 0; i < numObj; i++) {
+  for (i = 0; i < numObj; i++) {
     if (raw[i].mask) continue; // XXX

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/relastro_client.c

r36833	r37822
79	79	load_images (&db, skylist, FALSE);
80	80
	81	// I can free the database after I have loaded the images...
	82
81	83	// // load the image subset table from the specified location
82	84	// off_t Nimage;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/relastro_images.c

-              r36833
+              r37822
   MARKTIME("load images: %f sec\n", dtime);
-  initCoords();
   /* load catalog data from region files : subselect high-quality measurements */
-  // XXX pass in the image table
-  // XXX who carries the image grid?
   // photcodesKeep is used here to allow measurements from the images being calibrated
 …
   catalog = load_catalogs (skylist, &Ncatalog, TRUE, 0, NULL, NULL);
   MARKTIME("load catalog data: %f sec\n", dtime);
+  // find ICRF QSOs for reference downstream (only if USE_ICRF_CORRECT)
+  select_catalog_ICRF (catalog, Ncatalog);
   if (photcodesReset) {
 …
     case TARGET_SIMPLE:
       for (i = 0; i < NLOOP; i++) {
         UpdateObjects (catalog, Ncatalog);
+        UpdateObjects (catalog, Ncatalog, i);
         UpdateSimple (catalog, Ncatalog);
+      }
 …
     case TARGET_CHIPS:
+      if (RESET_IMAGES) UpdateMeasures (catalog, Ncatalog);
       for (i = 0; i < NLOOP; i++) {
+        UpdateObjects (catalog, Ncatalog);
+        UpdateChips (catalog, Ncatalog);
+        UpdateObjects (catalog, Ncatalog, (i > 0)); // calculate <R>,<D>; if (i > 0), apply Galaxy Motion Model (if desired)
+        if ((i > 1) || !USE_GALAXY_MODEL) {
+          // if GALAXY_MODEL is selected, we want to delay the frame correction until we have
+          // applied the galaxy model a couple of times.
+          FrameCorrectionSerial (catalog, Ncatalog);
+        }
+        UpdateChips (catalog, Ncatalog);   // measure.X,Y -> R,D, fit image.coords
         MARKTIME("update chips: %f sec\n", dtime);
+      }
 …
     case TARGET_MOSAICS:
       for (i = 0; i < NLOOP; i++) {
         UpdateObjects (catalog, Ncatalog);
+        UpdateObjects (catalog, Ncatalog, i);
         UpdateMosaic (catalog, Ncatalog);
+      }
 …
   if (PARALLEL) {
     // save the updated image parameters
+    // need to also save the image map table...
+    save_astrom_table ();
     dvo_image_update (&db, VERBOSE);
     dvo_image_unlock (&db);
 …
   UpdateObjectOffsets (skylist, 0, NULL);
-  // iterate over catalogs to make detection coordinates consistant
-  // FixProblemImages (skylist);
   if (!PARALLEL) {
     // save the updated image parameters
+    save_astrom_table ();
     dvo_image_update (&db, VERBOSE);
     dvo_image_unlock (&db);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/relastro_objects.c

r36833	r37822
77	77	populate_tiny_values(&catalog, DVO_TV_MEASURE);
78	78
79		UpdateObjects (&catalog, 1);
	79	UpdateObjects (&catalog, 1, 0);
80	80
81	81	free_tiny_values(&catalog);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/relastro_parallel_images.c

-              r36833
+              r37822
   INITTIME;
+  client_logger_init (CATDIR);
   // load the RegionTable (UserRegion should not be used at this level)
   RegionHostTable *regionHosts = RegionHostTableLoad (CATDIR, REGION_FILE);
   int myHost = regionHosts->index[REGION_HOST_ID];
   RegionHostFindNeighbors (regionHosts, myHost);
+  client_logger_message ("started parallel images on %s\n", regionHosts->hosts[myHost].hostname);
   // load the subset images belonging to this host
 …
     exit (2);
+  }
+  // assign image->parent and image->coords.mosaic
+  BuildChipMatch (image, Nimage);
+  char mapfile[DVO_MAX_PATH];
+  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.%d.fits", CATDIR, REGION_HOST_ID);
+  AstromOffsetTable *table = AstromOffsetMapLoad (mapfile, VERBOSE);
+  // assign images.coords.offsetMap -> table->map[i]
+  if (table) {
+    AstromOffsetTableMatchChips (image, Nimage, table);
+  } else {
+    table = AstromOffsetTableInit ();
+  }
+  put_astrom_table (table);
+  client_logger_message ("loaded images on %s\n", regionHosts->hosts[myHost].hostname);
   // once we have read this table, we should remove it for repeat runs
 …
   SkyList *skylist = SkyListByBounds (sky, -1, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
-  initCoords();
   /* load catalog data from region files (hostID is 0 since we are not a client */
   char *syncfile = make_filename (CATDIR, regionHosts->hosts[myHost].hostname, REGION_HOST_ID, "loadcat.sync");
   catalog = load_catalogs (skylist, &Ncatalog, TRUE, 0, NULL, syncfile);
   MARKTIME("-- load catalog data: %f sec\n", dtime);
+  MARKTIME("-- load catalog data, host %d: %f sec\n", REGION_HOST_ID, dtime);
   free (syncfile);
+  client_logger_message ("loaded catalog data %s\n", regionHosts->hosts[myHost].hostname);
+  // find ICRF QSOs for reference downstream (only if USE_ICRF_CORRECT)
+  select_catalog_ICRF (catalog, Ncatalog);
   if (photcodesReset) {
     photcodesKeep  = photcodesReset;
 …
   /* match measurements with images, mosaics */
   initImageBins  (catalog, Ncatalog, TRUE);
   MARKTIME("-- make image bins: %f sec\n", dtime);
+  MARKTIME("-- make image bins, host %d: %f sec\n", REGION_HOST_ID, dtime);
   findImages (catalog, Ncatalog, TRUE);
   MARKTIME("-- set up image indexes: %f sec\n", dtime);
+  MARKTIME("-- set up image indexes, host %d: %f sec\n", REGION_HOST_ID, dtime);
   // set test points based on the starmap
   createStarMap (catalog, Ncatalog);
+  client_logger_message ("set up image indexes on %s\n", regionHosts->hosts[myHost].hostname);
   markObjects (catalog, Ncatalog);
 …
   SAVEPLOT = FALSE;
+  client_logger_message ("starting the loops: %s\n", regionHosts->hosts[myHost].hostname);
   /* major modes */
   switch (FIT_TARGET) {
     case TARGET_SIMPLE:
       for (i = 0; i < NLOOP; i++) {
         UpdateObjects (catalog, Ncatalog);
+        UpdateObjects (catalog, Ncatalog, i);
         share_mean_pos (catalog, Ncatalog, regionHosts, i);
         slurp_mean_pos (catalog, Ncatalog, regionHosts, i);
         UpdateSimple (catalog, Ncatalog);
         share_image_pos (regionHosts, i);
         slurp_image_pos (regionHosts, i);
+        slurp_image_pos (catalog, Ncatalog, regionHosts, i);
+      }
       break;
     case TARGET_CHIPS:
+      if (RESET_IMAGES) {
+        UpdateMeasures (catalog, Ncatalog);
+        MARKTIME("reset measures, host %d: %f sec\n", REGION_HOST_ID, dtime);
+        client_logger_message ("reset measures: %s\n", regionHosts->hosts[myHost].hostname);
+      }
       for (i = 0; i < NLOOP; i++) {
+        UpdateObjects (catalog, Ncatalog);
+        UpdateObjects (catalog, Ncatalog, (i > 0));
+        MARKTIME("update objects loop %d, host %d: %f sec\n", i, REGION_HOST_ID, dtime);
+        client_logger_message ("update objects loop %d: %s\n", i, regionHosts->hosts[myHost].hostname);
+        if ((i > 1) || !USE_GALAXY_MODEL) {
+          // if GALAXY_MODEL is selected, we want to delay the frame correction until we have
+          // applied the galaxy model a couple of times.
+          FrameCorrectionParallelSlave (catalog, Ncatalog, regionHosts, i);
+          MARKTIME("frame correction loop %d, host %d: %f sec\n", i, REGION_HOST_ID, dtime);
+          client_logger_message ("frame correction loop %d: %s\n", i, regionHosts->hosts[myHost].hostname);
+        }
         share_mean_pos (catalog, Ncatalog, regionHosts, i);
         slurp_mean_pos (catalog, Ncatalog, regionHosts, i);
+        client_logger_message ("slurp mags loop %d: %s\n", i, regionHosts->hosts[myHost].hostname);
         UpdateChips (catalog, Ncatalog);
+        MARKTIME("update chips loop %d, host %d: %f sec\n", i, REGION_HOST_ID, dtime);
+        client_logger_message ("update chips loop %d: %s\n", i, regionHosts->hosts[myHost].hostname);
         share_image_pos (regionHosts, i);
+        slurp_image_pos (regionHosts, i);
+        MARKTIME("update chips: %f sec\n", dtime);
+        slurp_image_pos (catalog, Ncatalog, regionHosts, i);
+        client_logger_message ("slurp image pos loop %d: %s\n", i, regionHosts->hosts[myHost].hostname);
+        share_meas_pos (catalog, Ncatalog, regionHosts, i);
+        slurp_meas_pos (catalog, Ncatalog, regionHosts, i);
+        MARKTIME("done exchange loop %d, host %d: %f sec\n", i, REGION_HOST_ID, dtime);
+        client_logger_message ("slurp meas loop %d: %s\n", i, regionHosts->hosts[myHost].hostname);
+      }
       // create summary plots of the process
 …
     case TARGET_MOSAICS:
       for (i = 0; i < NLOOP; i++) {
         UpdateObjects (catalog, Ncatalog);
+        UpdateObjects (catalog, Ncatalog, i);
         share_mean_pos (catalog, Ncatalog, regionHosts, i);
         slurp_mean_pos (catalog, Ncatalog, regionHosts, i);
         UpdateMosaic (catalog, Ncatalog);
         share_image_pos (regionHosts, i);
         slurp_image_pos (regionHosts, i);
+        slurp_image_pos (catalog, Ncatalog, regionHosts, i);
+      }
       break;
 …
   share_image_pos (regionHosts, -1);
+  client_logger_message ("share image pos loop %d: %s\n", -1, regionHosts->hosts[myHost].hostname);
   exit (0);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/relastro_parallel_regions.c

-              r36630
+              r37822
   if (!launch_region_hosts (regionHosts)) Shutdown ("error launching region hosts");
+  // If we are doing FrameCorrection, we have to loop here waiting for ICRF objects from the region
+  // hosts.  we then measure the frame correction and send back the result
+  if (!FrameCorrectionParallelMaster (regionHosts)) Shutdown ("error running parallel frame correction");
   // retrieve updated image parameters from the remote hosts (also set Image.mcal)
   if (!slurp_image_pos (regionHosts, -1)) Shutdown ("error loading image updates");
+  if (!slurp_image_pos (NULL, 0, regionHosts, -1)) Shutdown ("error loading image updates");
   if (!UPDATE) {
 …
   if (PARALLEL) {
+    // save the updated image parameters
+    // save the updated image parameters.  if we are NOT PARALLEL, we have to wait
+    // until after UpdateObjectOffsets, or the image parameters are swapped and/or freed
+    save_astrom_table ();
     dvo_image_save (&db, VERBOSE);
     dvo_image_unlock (&db);
 …
   // iterate over catalogs to make detection coordinates consistant
+  UpdateObjectOffsets (skylist, 0, NULL);
+  if (APPLY_OFFSETS) {
+    UpdateObjectOffsets (skylist, 0, NULL);
+  }
   if (!PARALLEL) {
     // save the changes to the image parameters
+    save_astrom_table ();
     dvo_image_save (&db, VERBOSE);
     dvo_image_unlock (&db);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/select_images.c

-              r36630
+              r37822
   int InRange, found;
   double Ri[5], Di[5], Xi[5], Yi[5], dx, dy;
-  Coords tcoords;
   SkyRegionCoords *skycoords;
 …
   // the comparison is made in the catalog local projection. below we set crval1,2
+  tcoords.crpix1 = tcoords.crpix2 = 0.0;
+  Coords tcoords;
+  InitCoords (&tcoords, "DEC--TAN");
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1  = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2  = tcoords.pc2_1 = 0.0;
-  strcpy (tcoords.ctype, "DEC--TAN");
   ALLOCATE (skycoords, SkyRegionCoords, skylist[0].Nregions);
 …
   if (VERBOSE) fprintf (stderr, "finding images\n");
-  BuildChipMatch (timage, Ntimage);
-  MARKTIME("build chip match: %f sec\n", dtime);
   nimage = 0;
 …
+    }
-    // this adds 1.3 sec for 3M images
-    if (!FindMosaicForImage (timage, Ntimage, i)) {
-      fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i);
-      continue;
+    }
     /* define image corners - note the DIS images (mosaic phu) are special */
     if (!strcmp(&timage[i].coords.ctype[4], "-DIS")) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/share_images_pos.c

-              r36630
+              r37822
   free (iposfile);
+  // save the per-chip residual table
+  AstromOffsetTable *table = get_astrom_table ();
+  if (table) {
+    char mapname[1024];
+    snprintf (mapname, 1024, "%s/AstroMapUpdate.%d.fits", CATDIR, REGION_HOST_ID);
+    // write the image subset for this host
+    AstromOffsetMapSave (table, mapname);
+  }
   char *syncfile = make_filename (CATDIR, hostname, REGION_HOST_ID, "imagepos.sync");
   update_sync_file (syncfile, nloop);
 …
+}
 int slurp_image_pos (RegionHostTable *regionHosts, int nloop) {
+int slurp_image_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop) {
   off_t Nimage, i;
+  off_t Nimage, i, j;
   Image *images = getimages (&Nimage, NULL);
 …
       continue;
+    }
+    Coords *moscoords = images[seq].coords.mosaic;
     images[seq].coords     = image_pos[i].coords    ;
+    images[seq].dXpixSys   = image_pos[i].dXpixSys  ;
+    images[seq].dYpixSys   = image_pos[i].dYpixSys  ;
+    images[seq].imageID    = image_pos[i].imageID   ;
+    images[seq].nFitAstrom = image_pos[i].nFitAstrom;
+    images[seq].flags      = image_pos[i].flags     ;
+    images[seq].coords.mosaic = moscoords;
+    images[seq].dXpixSys     = image_pos[i].dXpixSys  ;
+    images[seq].dYpixSys     = image_pos[i].dYpixSys  ;
+    images[seq].refColorBlue = image_pos[i].refColorBlue;
+    images[seq].refColorRed  = image_pos[i].refColorRed;
+    images[seq].imageID      = image_pos[i].imageID   ;
+    images[seq].nFitAstrom   = image_pos[i].nFitAstrom;
+    images[seq].flags        = image_pos[i].flags     ;
+  }
+  // load the astrometry offset maps, if they exist, and apply
+  for (i = 0; i < regionHosts->Nhosts; i++) {
+    if (regionHosts->hosts[i].hostID == REGION_HOST_ID) continue;
+    if (REGION_HOST_ID && !regionHosts->hosts[i].isNeighbor) continue;
+    char mapname[1024];
+    snprintf (mapname, 1024, "%s/AstroMapUpdate.%d.fits", CATDIR, regionHosts->hosts[i].hostID);
+    AstromOffsetTable *table = AstromOffsetMapLoad (mapname, VERBOSE);
+    // apply table entries here to existing images
+    for (j = 0; j < table->Nmap; j++) {
+      off_t seq = getImageByID (table->map[j][0].imageID);
+      // I do not necessarily own all images listed in the table.  skip if not found
+      if (seq < 0) continue;
+      AstromOffsetMap *oldMap = images[seq].coords.offsetMap;
+      AstromOffsetMap *newMap = table->map[j];
+      if (oldMap) {
+        AstromOffsetMapSetOrder (oldMap, newMap->Nx, newMap->Ny, &images[seq]);
+        AstromOffsetMapCopyData (oldMap, newMap);
+      } else {
+        lockUpdateChips ();
+        AstromOffsetTable *FullTable = get_astrom_table ();
+        AstromOffsetTableNewMap(FullTable, newMap->Nx, newMap->Ny, &images[seq]);  // registers the map with the image
+        unlockUpdateChips ();
+        AstromOffsetMapCopyData (images[seq].coords.offsetMap, newMap); // oldMap is now not valid
+      }
+    }
+    AstromOffsetTableFree(table);
+  }
+  // apply the modified image parameters to my detections
+  for (i = 0; FALSE && (Ncatalog > 0) && (i < Nimage_pos); i++) {
+    off_t seq = getImageByID (image_pos[i].imageID);
+    if (seq < 0) continue;
+    updateImageRaw (catalog, Ncatalog, seq);
+  }
   free (image_pos);
 …
   image_pos->dXpixSys     = image->dXpixSys;
   image_pos->dYpixSys     = image->dYpixSys;
+  image_pos->refColorBlue = image->refColorBlue;
+  image_pos->refColorRed  = image->refColorRed;
   image_pos->imageID      = image->imageID;
   image_pos->nFitAstrom   = image->nFitAstrom;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relastro/src/testparallax.c

-              r36482
+              r37822
   /* project coordinates to a plane centered on the object with units of arcsec */
+  coords.crval1 = 0;
+  coords.crval2 = 0;
+  coords.crpix1 = 0;
+  coords.crpix2 = 0;
+  InitCoords (&coords, "DEC--SIN");
   coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
-  coords.pc1_1  = coords.pc2_2 = 1.0;
-  coords.pc1_2  = coords.pc2_1 = 0.0;
-  coords.Npolyterms = 1;
-  strcpy (coords.ctype, "DEC--SIN");
   // use one point as a local reference

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/include/relphot.h

-              r37037
+              r37822
 int MatchImageName (off_t meas, int cat, char *name);
 int MatchImageSkycellID (off_t meas, int cat, int myTessID, int myProjectionID, int mySkycellID);
+int FindImageSkycellID (off_t meas, int cat, int *myTessID, int *myProjectionID, int *mySkycellID);
 int load_tess (char *treefile);
 …
 int setMrel_catalog_alt (Catalog *catalog, int Nc, int pass, FlatCorrectionTable *flatcorr, SetMrelInfo *results, int Nsecfilt);
 int setMrelAverageExposure (off_t meas, int cat, int pass, FlatCorrectionTable *flatcorr, SetMrelInfo *results, Average *average, AverageTiny *averageT, SecFilt *secfilt, Measure *measure, MeasureTiny *measureT, off_t *found);
+int setMrelAverageStack (off_t meas, int cat, FlatCorrectionTable *flatcorr, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, char *primaryCell);
+int setMrelAverageStack (off_t measureOffset, int cat, FlatCorrectionTable *flatcorr, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, off_t Nmeasure);
+int setMrelAverageForcedWarp (off_t measureOffset, int cat, int pass, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, off_t *found, off_t Nmeasure);
 int setGlobalObjStats (Average *average, Measure *measure);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/BoundaryTreeOps.c

-              r36491
+              r37822
   if (!tess) return FALSE;
+  status = TessellationPrimaryCellIDs(tess, Ntess, tessID, projID, skycellID, ra, dec);
+  double R = ohana_normalize_angle(ra);
+  status = TessellationPrimaryCellIDs(tess, Ntess, tessID, projID, skycellID, R, dec);
   return status;
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/ImageOps.c

-              r37037
+              r37822
 static off_t        *imageIdx; // list of index for image IDs
+// QQ // as an alternative, we generate imageSeq, which directly maps imageID -> seq
+// QQ static off_t        *imageSeq; // list of index for image IDs
+// QQ
+// QQ // MAX_ID requires 512M to store the image index
+// QQ # define MAX_ID 0x8000000
+// QQ static off_t         minImageID = MAX_ID;
+// QQ static off_t         maxImageID = 0;
 // elsewhere, we have loaded a set of catalogs with measures (catalog[cat].measure[meas])
 // each image has N_onImage[ImageIndex] measurements
 …
     TessellationIDsByImageName (&tessID[i], &projectID[i], &skycellID[i], image[i].name);
+    // QQ minImageID = MIN(minImageID, image[i].imageID);
+    // QQ maxImageID = MAX(maxImageID, image[i].imageID);
+    // QQ myAssert (image[i].imageID < MAX_ID, "image IDs too large for index memory");
+  }
 …
   // XXX does this break the imageID <-> projectID, etc match?
   llsortpair (imageIDs, imageIdx, Nimage);
+  // QQ ALLOCATE (imageSeq, off_t, maxImageID + 1);
+  // QQ for (i = 0; i < maxImageID + 1; i++)  {
+  // QQ   imageSeq[i] = -1; // not yet assigned
+  // QQ }
+  // QQ
+  // QQ for (i = 0; i < Nimage; i++) {
+  // QQ   off_t N = image[i].imageID;
+  // QQ   myAssert (imageSeq[N] == -1, "previously assigned");
+  // QQ   imageSeq[N] = i;
+  // QQ }
+}
 …
 off_t getImageByID (off_t ID) {
+  // QQ  if (imageSeq) {
+  // QQ    myAssert (ID >= minImageID, "oops");
+  // QQ    myAssert (ID <= maxImageID, "oops");
+  // QQ    off_t N = imageSeq[ID];
+  // QQ    return N;
+  // QQ  }
   // we have a pair of vectors (imageIDs, imageIdx) sorted by imageIDs
   // use bisection to find the specified image ID
 …
   if (projectID[i] != myProjectionID) return FALSE;
   if (skycellID[i] != mySkycellID) return FALSE;
+  return TRUE;
+}
+// returns image.Mcal - ff(x,y)
+int FindImageSkycellID (off_t meas, int cat, int *myTessID, int *myProjectionID, int *mySkycellID) {
+  off_t i;
+  if (!MeasureToImage) return FALSE;
+  if (meas < 0) return FALSE;
+  i = MeasureToImage[cat][meas];
+  if (i == -1) return FALSE;
+  if (tessID[i]    == -1) return FALSE;
+  if (projectID[i] == -1) return FALSE;
+  if (skycellID[i] == -1) return FALSE;
+  *myTessID = tessID[i];
+  *myProjectionID = projectID[i];
+  *mySkycellID =  skycellID[i];
   return TRUE;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/ImageTable.c

-              r36630
+              r37822
+  }
+  // XXX do not make the chip match -- we have not loaded the PHU entries (and do not need them here)
+  // BuildChipMatch (image, Nimage);
   *nimage = Nimage;
   return image;

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/MosaicOps.c

-              r37037
+              r37822
       m = MosaicToImage[i][j];
-      if (!FindMosaicForImage (image, Nimage, m)) {
-        if (VERBOSE2) fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i);
-        continue;
+      }
       NX = image[m].NX;
       NY = image[m].NY;
       XY_to_RD (&R, &D, 0.5*NX, 0.5*NY, &image[m].coords);
+      if (!XY_to_RD (&R, &D, 0.5*NX, 0.5*NY, &image[m].coords)) continue;
       R = ohana_normalize_angle_to_midpoint (R, 180.0);
 …
+    }
     strcpy (mosaic[i].coords.ctype, "DEC--TAN");
+    InitCoords (&mosaic[i].coords, "DEC--TAN");
     mosaic[i].coords.crval1 = Rmid;
     mosaic[i].coords.crval2 = Dmid;
-    mosaic[i].coords.crpix1 = 0.0;
-    mosaic[i].coords.crpix2 = 0.0;
     mosaic[i].coords.cdelt1 = 1.0 / 3600.0;
     mosaic[i].coords.cdelt2 = 1.0 / 3600.0;
-    mosaic[i].coords.pc1_1  = 1.0;
-    mosaic[i].coords.pc2_2  = 1.0;
-    mosaic[i].coords.pc1_2  = 0.0;
-    mosaic[i].coords.pc2_1  = 0.0;
     mosaic[i].Mcal   = 0.0;
 …
       NY = image[m].NY;
       dS += hypot (image[m].coords.cdelt1*image[m].coords.pc1_1, image[m].coords.cdelt1*image[m].coords.pc2_1);
+      XY_to_RD (&R, &D, 0.0, 0.0, &image[m].coords);
+      OhanaProjection proj = GetProjection (image[m].coords.ctype);
+      if ((proj == PROJ_WRP) && !image[m].coords.mosaic) {
+        XY_to_LM (&R, &D, 0.0, 0.0, &image[m].coords);
+      } else {
+        XY_to_RD (&R, &D, 0.0, 0.0, &image[m].coords);
+      }
       Rmin = MIN (Rmin, R);
       Rmax = MAX (Rmax, R);
       Dmin = MIN (Dmin, D);
       Dmax = MAX (Dmax, D);
+      XY_to_RD (&R, &D, (double) NX, 0.0, &image[m].coords);
+      if ((proj == PROJ_WRP) && !image[m].coords.mosaic) {
+        XY_to_LM (&R, &D, (double) NX, 0.0, &image[m].coords);
+      } else {
+        XY_to_RD (&R, &D, (double) NX, 0.0, &image[m].coords);
+      }
       Rmin = MIN (Rmin, R);
       Rmax = MAX (Rmax, R);
       Dmin = MIN (Dmin, D);
       Dmax = MAX (Dmax, D);
+      XY_to_RD (&R, &D, (double) NX, (double) NY, &image[m].coords);
+      if ((proj == PROJ_WRP) && !image[m].coords.mosaic) {
+        XY_to_LM (&R, &D, (double) NX, (double) NY, &image[m].coords);
+      } else {
+        XY_to_RD (&R, &D, (double) NX, (double) NY, &image[m].coords);
+      }
       Rmin = MIN (Rmin, R);
       Rmax = MAX (Rmax, R);
       Dmin = MIN (Dmin, D);
       Dmax = MAX (Dmax, D);
+      XY_to_RD (&R, &D, 0.0, (double) NY, &image[m].coords);
+      if ((proj == PROJ_WRP) && !image[m].coords.mosaic) {
+        XY_to_LM (&R, &D, 0.0, (double) NY, &image[m].coords);
+      } else {
+        XY_to_RD (&R, &D, 0.0, (double) NY, &image[m].coords);
+      }
       Rmin = MIN (Rmin, R);
       Rmax = MAX (Rmax, R);
 …
       Dmax = MAX (Dmax, D);
+      // XXX : this probably does not handle mosaics at RA = 0,360 well
       /* we are using mosaic.Mcal, not image.Mcal. reset image.Mcal */
 …
+    }
     dS /= MosaicN_Image[i];
+    strcpy (mosaic[i].coords.ctype, "DEC--TAN");
+    InitCoords (&mosaic[i].coords, "DEC--TAN");
     mosaic[i].coords.crval1 = Rmin;
     mosaic[i].coords.crval2 = Dmin;
-    mosaic[i].coords.crpix1 = 0.0;
-    mosaic[i].coords.crpix2 = 0.0;
     mosaic[i].coords.cdelt1 = dS;
     mosaic[i].coords.cdelt2 = dS;
+    mosaic[i].coords.pc1_1  = 1.0;
+    mosaic[i].coords.pc2_2  = 1.0;
+    mosaic[i].coords.pc1_2  = 0.0;
+    mosaic[i].coords.pc2_1  = 0.0;
     RD_to_XY (&dX, &dY, Rmax, Dmax, &mosaic[i].coords);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/StarOps.c

-              r37037
+              r37822
           if (ecode != thisCode) { continue; }
+          // SKIP gpc1 stack data
+          if (isGPC1stack(catalog[i].measureT[m].photcode)) continue;
+          // SKIP gpc1 forced-warp data
+          if (isGPC1warp(catalog[i].measureT[m].photcode)) continue;
           // NOTE: we do not skip MEAS_BAD because this measurement is just an internal assessment of the outliers
           Mcal  = getMcal  (m, i, flatcorr, catalog);
 …
           if (ecode != thisCode) { continue; }
+          // SKIP gpc1 stack data
+          if (isGPC1stack(catalog[i].measureT[m].photcode)) continue;
+          // SKIP gpc1 forced-warp data
+          if (isGPC1warp(catalog[i].measureT[m].photcode)) continue;
           // NOTE: we do not skip MEAS_BAD because this measurement is just an internal assessment of the outliers
           Mcal  = getMcal  (m, i, flatcorr, catalog);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/assign_images.c

-              r37037
+              r37822
     if (!strcmp(&image[j].coords.ctype[4], "-DIS")) continue;
-    // match the image to its corresponding ASTROMETRIC mosaic (not the same as the Mosaic above)
-    if (!FindMosaicForImage (image, Nimage, j)) {
-      if (VERBOSE2) fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i);
-      continue;
+    }
     // Exclude images with crazy astrometry
     // XXX NOTE : this is gpc1-specific
 …
     if (MOSAIC_ZEROPT) {
       // use the coords of the associated mosaic to select
+      // use the coords of the associated mosaic to select (only for chips; stacks use their own center)
       Mosaic *mosaic = getMosaicForImage (j);
+      Rc = mosaic->coords.crval1;
+      Dc = mosaic->coords.crval2;
+      // NOTE : have defined mosaic Rc,Dc to choose the side of 0,360 on which most of the
+      // chips are located.  but, for host assignment, we rationalize to 0.0 - 360.0
+      Rc = ohana_normalize_angle_to_midpoint (Rc, 180.0);
+      if (mosaic) {
+        Rc = mosaic->coords.crval1;
+        Dc = mosaic->coords.crval2;
+        // NOTE : have defined mosaic Rc,Dc to choose the side of 0,360 on which most of the
+        // chips are located.  but, for host assignment, we rationalize to 0.0 - 360.0
+        Rc = ohana_normalize_angle_to_midpoint (Rc, 180.0);
+      }
+    }
 …
+}
-int calculate_host_image_bounds (RegionHostTable *regionHosts, double Rmid) {
-  int i, n;
-  off_t j;
-  for (i = 0; i < regionHosts->Nhosts; i++) {
-    RegionHostInfo *host = &regionHosts->hosts[i];
-    // XXX clear the chip match?
-    BuildChipMatch (host->image, host->Nimage);
-    double Rmin =  720.0;
-    double Rmax = -360.0;
-    double Dmin =  +90.0;
-    double Dmax = -90.0;
-    for (j = 0; j < host->Nimage; j++) {
-      Image *image = &host->image[j];
-      if (!FindMosaicForImage (host->image, host->Nimage, j)) {
-        fprintf (stderr, "missing astrometry? programming error?\n");
-        abort ();
+      }
-      // define image corners
-      for (n = 0; n < 4; n++) {
-        double Xc, Yc, Rc, Dc;
-        Xc = Xf[n]*image->NX;
-        Yc = Yf[n]*image->NY;
-        XY_to_RD (&Rc, &Dc, Xc, Yc, &image->coords);
-        Rc = ohana_normalize_angle_to_midpoint (Rc, Rmid);
-        Rmin = MIN (Rmin, Rc);
-        Dmin = MIN (Dmin, Rc);
-        Rmax = MAX (Rmax, Rc);
-        Dmax = MAX (Dmax, Rc);
+      }
+    }
-    // RminCat, RmaxCat may extended beyond 0.0 - 360.0
-    host->RminCat = Rmin;
-    host->DminCat = Dmin;
-    host->RmaxCat = Rmax;
-    host->DmaxCat = Dmax;
-    // regionHosts needs to have the full outer boundary
-    // (so reload_catalogs covers the correct region)
-    regionHosts->Rmin = MIN(Rmin, regionHosts->Rmin);
-    regionHosts->Rmax = MAX(Rmax, regionHosts->Rmax);
-    regionHosts->Dmin = MIN(Dmin, regionHosts->Dmin);
-    regionHosts->Dmax = MAX(Dmax, regionHosts->Dmax);
+  }
-  return TRUE;
+}
 // Rc is in range 0.0 - 360.0, hosts Rmin,Rmax in range 0.0 - 360.0
 int find_host_for_coords (RegionHostTable *regionHosts, double Rc, double Dc) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/bcatalog.c

r37037	r37822
78	78	int Nsec = GetPhotcodeNsec(thisCode);
79	79
80		fprintf (stderr, "really use dvo_secfilt_init?");
	80	// fprintf (stderr, "really use dvo_secfilt_init?");
81	81	dvo_secfilt_init (&subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec]);
82	82

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/load_images.c

-              r35759
+              r37822
+  }
   MARKTIME("read image table: %f sec\n", dtime);
+  BuildChipMatch (image, Nimage);
+  MARKTIME("build chip match for %d images: %f sec\n", (int) Nimage, dtime);
+  char mapfile[DVO_MAX_PATH];
+  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", CATDIR);
+  AstromOffsetTable *table = AstromOffsetMapLoad (mapfile, VERBOSE);
+  // assign images.coords.offsetMap -> table->map[i]
+  if (table) {
+    AstromOffsetTableMatchChips (image, Nimage, table);
+  }
   // allocate and init an array to identify the images included in the subset

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/reload_catalogs.c

-              r36630
+              r37822
+}
+int reload_catalog_parallel_group (HostTableGroup *group, SkyList *sky, char *imageFile);
 // XXX Image to Image Subset
 int reload_catalogs_parallel (SkyList *sky) {
 …
     free (BOUNDARY_TREE);
     BOUNDARY_TREE = tmppath;
+  }
+  }
+  int Ngroups;
+  HostTableGroup *groups = HostTableGroups (table, &Ngroups);
+  // split the table into Ngroups, each with a unique set of machines (this avoids overloading the remote host machines)
+  int i;
+  for (i = 0; i < Ngroups; i++) {
+    // update only a group of unique machines at a time
+    reload_catalog_parallel_group (&groups[i], sky, imageFile);
+  }
+  return TRUE;
+}
+int reload_catalog_parallel_group (HostTableGroup *group, SkyList *sky, char *imageFile) {
   int i, j;
   for (i = 0; i < table->Nhosts; i++) {
     if (sky->Nregions < table->Nhosts) {
+  for (i = 0; i < group->Nhosts; i++) {
+    if (sky->Nregions < group->Nhosts) {
       // do any of the regions want this host?
       int wantThisHost = FALSE;
       for (j = 0; j < sky->Nregions; j++) {
         if (HostTableTestHost (sky->regions[j], table->hosts[i].hostID)) {
+        if (HostTableTestHost (sky->regions[j], group->hosts[i][0].hostID)) {
           wantThisHost = TRUE;
           break;
 …
+      }
       if (!wantThisHost) {
         // fprintf (stderr, "skip host %s\n", table->hosts[i].hostname);
+        // fprintf (stderr, "skip host %s\n", group->hosts[i][0].hostname);
         continue;
+      }
 …
     // ensure that the paths are absolute path names
     char *tmppath = abspath (table->hosts[i].pathname, DVO_MAX_PATH);
     free (table->hosts[i].pathname);
     table->hosts[i].pathname = tmppath;
+    char *tmppath = abspath (group->hosts[i][0].pathname, DVO_MAX_PATH);
+    free (group->hosts[i][0].pathname);
+    group->hosts[i][0].pathname = tmppath;
     char command[1024];
     snprintf (command, 1024, "relphot_client %s -update-catalogs %s -hostID %d -D CATDIR %s -hostdir %s -region %f %f %f %f -statmode %s -D CAMERA %s -D STAR_TOOFEW %d -minerror %f",
               PhotcodeList, imageFile, table->hosts[i].hostID, CATDIR, table->hosts[i].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, STATMODE, CAMERA, STAR_TOOFEW, MIN_ERROR);
+              PhotcodeList, imageFile, group->hosts[i][0].hostID, CATDIR, group->hosts[i][0].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, STATMODE, CAMERA, STAR_TOOFEW, MIN_ERROR);
     // options & configs which affect relphot_client -update-catalogs
 …
       // launch the job on the remote machine (no handshake)
       int errorInfo = 0;
       int pid = rconnect ("ssh", table->hosts[i].hostname, command, table->hosts[i].stdio, &errorInfo, FALSE);
+      int pid = rconnect ("ssh", group->hosts[i][0].hostname, command, group->hosts[i][0].stdio, &errorInfo, FALSE);
       if (!pid) {
         if (DEBUG) fprintf (stderr, "failure to start %s (error %d)\n", table->hosts[i].hostname, errorInfo);
+        if (DEBUG) fprintf (stderr, "failure to start %s (error %d)\n", group->hosts[i][0].hostname, errorInfo);
         exit (1);
+      }
       table->hosts[i].pid = pid; // save for future reference
+      group->hosts[i][0].pid = pid; // save for future reference
+    }
+  }
 …
+  }
   if (!PARALLEL_MANUAL && !PARALLEL_SERIAL) {
     int status = HostTableWaitJobsGetIO (table, __FILE__, __LINE__, VERBOSE);
+    int status = HostTableGroupWaitJobsGetIO (group, __FILE__, __LINE__, VERBOSE);
     if (!status) {
       fprintf (stderr, "at least one remote client job failed to load data, exiting\n");

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/relphot.c

-              r36630
+              r37822
   switch (mode) {
     case UPDATE_IMAGES:
+      // IF CALLED WITH NLOOP == 0, DOES NOT LOAD bcatalog, just loads image table and generates ImageSubset.dat
       relphot_images ();
       exit (0);
 …
     case UPDATE_AVERAGES:
       // take the current set of detections and set the mean magnitudes
+      // DOES NOT LOAD THE IMAGE TABLE
       relphot_objects (0, NULL);
       exit (0);
 …
   exit (1);
+}
+/***
+    I would like to merge the functionality of relphot_images (Nloop == 0), relphot_objects, and apply_offsets
+***/

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/relphot_objects.c

r35104	r37822
36	36	if (!HostTableTestHost(skylist[0].regions[i], hostID)) continue;
37	37
38		~~// set up the basic catalog info~~
39	38	// set up the basic catalog info
40	39	char hostfile[1024];

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/relphot_parallel_regions.c

-              r37037
+              r37822
   MARKTIME("-- load image data: %f sec\n", dtime);
+  // save Images.dat using the copied structure
+  if (UPDATE_CATFORMAT) {
+    // ensure the db format is updated
+    db.format = dvo_catalog_catformat (UPDATE_CATFORMAT);
+  }
   /* assign the images to the different region hosts */
   if (!assign_images (&db, regionHosts)) Shutdown ("error assigning images to region hosts");
 …
   /* launch processing on the parallel region hosts */
   if (!launch_region_hosts (regionHosts)) Shutdown ("error launching region hosts");
+  MARKTIME ("finished relphot -parallel-regions: %f sec total\n", dtime);
   // retrieve updated image parameters from the remote hosts (also set Image.mcal)

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/select_images.c

-              r36491
+              r37822
   // the comparison is made in the catalog local projection. below we set crval1,2
   tcoords.crpix1 = tcoords.crpix2 = 0.0;
+  InitCoords (&tcoords, "DEC--TAN");
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1  = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2  = tcoords.pc2_1 = 0.0;
-  strcpy (tcoords.ctype, "DEC--TAN");
   double RminSkyRegion = region[0].Rmin;
 …
   if (VERBOSE) fprintf (stderr, "finding images\n");
-  BuildChipMatch (timage, Ntimage);
-  MARKTIME("build chip match for %d images: %f sec\n", (int) Ntimage, dtime);
   D_NIMAGE = 6000;
 …
     if (!(i % 300000)) fprintf (stderr, ".");
+    // XXX I am just going for force this for the moment:
+    goto found_it;
     /* exclude images by photcode */
 …
+    }
-    // this adds 1.3 sec for 3M images
-    if (!FindMosaicForImage (timage, Ntimage, i)) {
-      if (VERBOSE2) fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i);
-      continue;
+    }
     /* define image corners - note the DIS images (mosaic phu) are special */
     if (!strcmp(&timage[i].coords.ctype[4], "-DIS")) {
 …
   // the comparison is made in the catalog local projection. below we set crval1,2
   tcoords.crpix1 = tcoords.crpix2 = 0.0;
+  InitCoords (&tcoords, "DEC--TAN");
   tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
-  tcoords.pc1_1  = tcoords.pc2_2 = 1.0;
-  tcoords.pc1_2  = tcoords.pc2_1 = 0.0;
-  tcoords.Npolyterms = 0;
-  memset (tcoords.polyterms, 0, 14*sizeof(float));
-  strcpy (tcoords.ctype, "DEC--TAN");
   /* compare with each region file */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/relphot/src/setMrelCatalog.c

-              r37037
+              r37822
+}
-int setMrelAverageForcedWarp (off_t measureOffset, int cat, int pass, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, off_t *found);
 int setMrel_catalog_alt (Catalog *catalog, int Nc, int pass, FlatCorrectionTable *flatcorr, SetMrelInfo *results, int Nsecfilt) {
 …
   int isSetMrelFinal = (pass >= 0);
   char *primaryCell = NULL;
   if (isSetMrelFinal) {
     ALLOCATE (primaryCell, char, DVO_MAX_PATH);
+  }
+  // XX char *primaryCell = NULL;
+  // XX if (isSetMrelFinal) {
+  // XX   ALLOCATE (primaryCell, char, DVO_MAX_PATH);
+  // XX }
   for (j = 0; j < catalog[Nc].Naverage; j++) {
 …
     Average *average = catalog[Nc].average ? &catalog[Nc].average[j] : NULL;
     Measure *measure = catalog[Nc].measure ? &catalog[Nc].measure[m] : NULL;
+    setMrelAverageExposure (m, Nc, pass, flatcorr, results, average, &catalog[Nc].averageT[j], &catalog[Nc].secfilt[j*Nsecfilt], measure, &catalog[Nc].measureT[m], &catalog[Nc].found_t[Nsecfilt*j]);
+    SecFilt *secfilt = catalog[Nc].secfilt ? &catalog[Nc].secfilt[j*Nsecfilt] : NULL;
+    setMrelAverageExposure (m, Nc, pass, flatcorr, results, average, &catalog[Nc].averageT[j], secfilt, measure, &catalog[Nc].measureT[m], &catalog[Nc].found_t[Nsecfilt*j]);
     // only apply Stack operation on setMrelFinal in first pass
     if (isSetMrelFinal && (pass == 0)) {
       setMrelAverageStack (m, Nc, flatcorr, results, &catalog[Nc].average[j], &catalog[Nc].secfilt[j*Nsecfilt], &catalog[Nc].measure[m], primaryCell);
+      setMrelAverageStack (m, Nc, flatcorr, results, average, secfilt, &catalog[Nc].measure[m], catalog[Nc].Nmeasure);
       setGlobalObjStats (&catalog[Nc].average[j], &catalog[Nc].measure[m]);
+    }
 …
     // only measure force-warp mean values if issetMrelFinal (make it optional?)
     if (isSetMrelFinal) {
       setMrelAverageForcedWarp (m, Nc, pass, results, &catalog[Nc].average[j], &catalog[Nc].secfilt[j*Nsecfilt], &catalog[Nc].measure[m], &catalog[Nc].foundWarp_t[Nsecfilt*j]);
       setGlobalObjStats (&catalog[Nc].average[j], &catalog[Nc].measure[m]);
+    }
+  }
   if (primaryCell) free (primaryCell);
+      setMrelAverageForcedWarp (m, Nc, pass, results, average, secfilt, measure, &catalog[Nc].foundWarp_t[Nsecfilt*j], catalog[Nc].Nmeasure);
+      setGlobalObjStats (average, measure);
+    }
+  }
+  // if (primaryCell) free (primaryCell);
   return (TRUE);
+}
 …
     off_t meas = measureOffset;
+    float psfQfMax = 0.0;
+    float psfQfPerfMax = 0.0;
     int Nap = 0;
     int Npsf = 0;
 …
       // SKIP gpc1 forced-warp data
       if (isGPC1warp(measureT[k].photcode)) continue;
+      if (isSetMrelFinal) {
+        if (measure[k].psfQF     > psfQfMax)     psfQfMax     = measure[k].psfQF;
+        if (measure[k].psfQFperf > psfQfPerfMax) psfQfPerfMax = measure[k].psfQFperf;
+      }
       if (measureT[k].dbFlags & MEAS_BAD) SKIP_THIS_MEAS(Nbad);
 …
       secfilt[Nsec].Mmin = psfstats->min;
+      secfilt[Nsec].psfQfMax     = psfQfMax;
+      secfilt[Nsec].psfQfPerfMax = psfQfPerfMax;
       // NOTE : use the modified weight for apmags as well as psf mags
       liststats (Maplist, daplist, waplist, Nap, apstats);
 …
 // only apply Stack operation on setMrelFinal in first pass
+int setMrelAverageStack (off_t measureOffset, int cat, FlatCorrectionTable *flatcorr, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, char *primaryCell) {
+  off_t k, ID;
+  float Msys = 0, Mcal= 0, Mmos = 0, Mgrid = 0;
+// this function has 3 goals, not to be confused:
+// 1) find and mark the PRIMARY detections (regardless of the quality of the detection)
+// 2) select the BEST detections per filter (regardless of PRIMARY)
+// 3) apply the zero point and AB->Jy transformations
+int setMrelAverageStack (off_t measureOffset, int cat, FlatCorrectionTable *flatcorr, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, off_t Nmeasure) {
+  off_t k;
+  float Mcal= 0, Mmos = 0, Mgrid = 0, Finst = 0;
   // set the primary projection cell and skycell for this coordinate
 …
   get_tess_ids(&tessID, &projectID, &skycellID, average[0].R, average[0].D);
+  average[0].tessID       = tessID;
+  average[0].projectionID = projectID;
+  average[0].skycellID    = skycellID;
   int NstackGood = 0;
   int NstackSuspect = 0;
 …
     int haveStack = FALSE;
+    // need to find the measurement closest to the center of its skycell, as well as the
+    // closest for the subset of primary projection cells
+    float stackCenterOffsetMin = 1e9;
+    off_t stackCenterMeasureMin = -1;
+    float stackPrimaryOffsetMin = 1e9;
+    off_t stackPrimaryMeasureMin = -1;
+    float psfQFbest = 0.0;
+    off_t stackBestMeasure = -1;
+    off_t stackPrimaryMeasure = -1;
     int isBad = FALSE;
     int isSuspect = FALSE;
+    int Nstack = 0; // number for this photcode
+    int NstackDet = 0; // number for this photcode
+    secfilt[Nsec].stackBestOff = -1;
+    secfilt[Nsec].stackPrmryOff = -1;
     off_t meas = measureOffset;
     for (k = 0; k < average[0].Nmeasure; k++, meas++) {
+      // only examine gpc1 stack data
+      if (!isGPC1stack(measure[k].photcode)) continue;
       // skip measurements that do not match the current photcode
 …
       if (code->equiv != thisCode) { continue; }
+      Nstack ++;
+      if ((measure[k].photFlags2 & 0x00000004) == 0) NstackDet ++;
       // clear this bit for all measurements
       measure[k].dbFlags &= ~ID_MEAS_STACK_PRIMARY;
+      // only examine gpc1 stack data
+      if (!isGPC1stack(measure[k].photcode)) continue;
+      measure[k].dbFlags &= ~ID_MEAS_STACK_PHOT_SRC;
       haveStack = TRUE;
       haveStackObject = TRUE;
+      // find the PRIMARY measurement
+      // if we request the primary (USE_TREE_FOR_PRIMARY), this is true if the measurement is from the
+      // primary skycell for this position
+      if (MatchImageSkycellID (meas, cat, tessID, projectID, skycellID)) {
+        stackPrimaryMeasure = k;
+        measure[k].dbFlags |= ID_MEAS_STACK_PRIMARY;
+        secfilt[Nsec].stackPrmryOff = meas;
+        myAssert (secfilt[Nsec].stackPrmryOff <= Nmeasure, "stackPrmryOff out of range");
+      }
+      // now choose the BEST measurements (may also be PRIMARY)
       if (measure[k].dbFlags & MEAS_BAD) SKIP_THIS_MEAS_STACK(Nbad);
-      if (getImageEntry (meas, cat) < 0) continue;
       // measurements without an image are either external reference photometry or
       // data for which the associated image has not been loaded (probably because of
       // overlaps).  we only want measurements associated with stack images in this loop
+      Mcal  = getMcal_alt  (meas, cat, flatcorr, measure[k].Xccd, measure[k].Yccd);
+      if (isnan(Mcal))  SKIP_THIS_MEAS_STACK(Ncal);
+      Mmos  = getMmos  (meas, cat);
+      if (isnan(Mmos))  SKIP_THIS_MEAS_STACK(Nmos);
+      Mgrid = getMgrid (meas, cat);
+      if (isnan(Mgrid)) SKIP_THIS_MEAS_STACK(Ngrid);
+      Msys = PhotSys (&measure[k], &average[0], &secfilt[0], MAG_CLASS_PSF);
+      if (isnan(Msys)) SKIP_THIS_MEAS_STACK(Nsys);
+      unsigned int stackImageID;
+      // which stack image should we use for the mean value?
+      // if we request the primary (USE_TREE_FOR_PRIMARY), then find the min distances for data from the primary cell
+      if (MatchImageSkycellID (meas, cat, tessID, projectID, skycellID)) {
+        float stackPrimaryOffset = getCenterOffset (meas, cat, &measure[k], &stackImageID);
+        if (stackPrimaryOffset < stackPrimaryOffsetMin) {
+          stackPrimaryOffsetMin = stackPrimaryOffset;
+          // stackPrimaryIDmin = stackImageID;
+          stackPrimaryMeasureMin = k;
+        }
+      }
+      // get the center distance for the generic case:
+      float stackCenterOffset = getCenterOffset (meas, cat, &measure[k], &stackImageID);
+      if (stackCenterOffset < stackCenterOffsetMin) {
+        stackCenterOffsetMin = stackCenterOffset;
+        // stackCenterIDmin = stackImageID;
+        stackCenterMeasureMin = k;
+      // match measurement to its image (this is just a check, right?)
+      if (getImageEntry (meas, cat) < 0) {
+        // measurements without an image are either external reference photometry or
+        // data for which the associated image has not been loaded (probably because of
+        // overlaps).  Msys + measure.Mcal is our best guess of the true magnitude
+        Mmos = Mgrid = 0;
+        Mcal = measure[k].Mcal; // check that this is zero for loaded REF value
+      } else {
+        Mcal  = getMcal_alt  (meas, cat, flatcorr, measure[k].Xccd, measure[k].Yccd);
+        if (isnan(Mcal))  SKIP_THIS_MEAS_STACK(Ncal);
+        Mmos  = getMmos  (meas, cat);
+        if (isnan(Mmos))  SKIP_THIS_MEAS_STACK(Nmos);
+        Mgrid = getMgrid (meas, cat);
+        if (isnan(Mgrid)) SKIP_THIS_MEAS_STACK(Ngrid);
+      }
+      // NOTE: negative and insignificant vlues values are allowed, but not NAN flux values
+      Finst = PhotFluxInst (&measure[k], MAG_CLASS_PSF);
+      if (isnan(Finst)) SKIP_THIS_MEAS_STACK(Ninst);
+      if (measure[k].psfQFperf > psfQFbest) {
+        psfQFbest = measure[k].psfQFperf;
+        stackBestMeasure = k;
+      }
 …
     // measurements which are bad will not have a valid stack entry and are skipped
     k = (stackPrimaryMeasureMin >= 0) ? stackPrimaryMeasureMin : stackCenterMeasureMin;
+    k = (stackBestMeasure >= 0) ? stackBestMeasure : stackPrimaryMeasure;
     if (k < 0) continue;
     // we are now populating stackDetectID not stack Image ID in secfilt
     // ID = (stackPrimaryMeasureMin >= 0) ? stackPrimaryIDmin      : stackCenterIDmin;
     ID = measure[k].extID; // for the stack, this is the stackDetectID
+    // ID = measure[k].extID; // for the stack, this is the stackDetectID
     // get the zero point for the selected image
 …
     secfilt[Nsec].dFapStk   = zpFactor * measure[k].dFluxAp;
+    // Jy to AB mags
     secfilt[Nsec].MpsfStk   = (measure[k].FluxPSF  > 0.0) ? 8.9 - 2.5*log10(secfilt[Nsec].FpsfStk) : NAN;
     secfilt[Nsec].MkronStk  = (measure[k].FluxKron > 0.0) ? 8.9 - 2.5*log10(secfilt[Nsec].FkronStk) : NAN;
     secfilt[Nsec].MapStk    = (measure[k].FluxAp   > 0.0) ? 8.9 - 2.5*log10(secfilt[Nsec].FapStk) : NAN;
+    secfilt[Nsec].stackDetectID = ID;
+    secfilt[Nsec].stackBestOff = k + measureOffset;
+    myAssert (secfilt[Nsec].stackBestOff <= Nmeasure, "stackBestOff out of range");
+    secfilt[Nsec].Nstack    = Nstack;
+    secfilt[Nsec].NstackDet = NstackDet;
+    // this is the measurement used by secfilt[]
     measure[k].dbFlags |= ID_MEAS_STACK_PHOT_SRC;
+    if (stackPrimaryMeasureMin >= 0) {
+      measure[k].dbFlags |= ID_MEAS_STACK_PRIMARY;
+    if (k == stackPrimaryMeasure) {
       secfilt[Nsec].flags |= ID_SECF_STACK_PRIMARY;
+    }
 …
 // somewhat simplified relative to chip-photometry:
 // * no grid, no mosaic, no 2MASS, no SYNTH, no Ubercal, no flatcorr
 int setMrelAverageForcedWarp (off_t measureOffset, int cat, int pass, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, off_t *found) {
+int setMrelAverageForcedWarp (off_t measureOffset, int cat, int pass, SetMrelInfo *results, Average *average, SecFilt *secfilt, Measure *measure, off_t *found, off_t Nmeasure) {
   off_t k;
   float Fsys = 0, Mcal= 0;
+  float Mcal= 0;
   // we are measuring means for 3 types of FLUXes: psf, ap, kron.  I am using the psf mag
 …
   // option for a test print
   if (FALSE && (average[0].objID == 0x7146) && (average[0].catID == 0x49d8)) {
+  if ((average[0].objID == 0xd6e) && (average[0].catID == 0x4984)) {
     fprintf (stderr, "test obj\n");
     print_measure_set_alt (average, secfilt, measure);
 …
     if (found[Nsec]) continue;
+    // I need to restrict the measurements coming only from the same skycell as the secfilt values
+    // if we cannot make that association, skip this set of warps
+    int stkTessID, stkProjID, stkSkycellID;
+    myAssert (secfilt[Nsec].stackBestOff <= Nmeasure, "stackBestOff out of range");
+    if (!FindImageSkycellID (secfilt[Nsec].stackBestOff, cat, &stkTessID, &stkProjID, &stkSkycellID)) continue;
     off_t meas = measureOffset;
 …
     int Npsf = 0;
     int Nkron = 0;
+    int Nwarp = 0;
+    int NwarpGood = 0;
     for (k = 0; k < average[0].Nmeasure; k++, meas++) {
 …
       if (!code) continue;
       if (code->equiv != thisCode) { continue; }
+      Nwarp ++;
+      if (measure[k].psfQFperf > 0.85) NwarpGood ++;
+      measure[k].dbFlags &= ~ID_MEAS_WARP_USED;
+      if (!MatchImageSkycellID (meas, cat, stkTessID, stkProjID, stkSkycellID)) continue;
       if (measure[k].dbFlags & MEAS_BAD) SKIP_THIS_MEAS(Nbad);
 …
       // are small (and not measured)
       float Fpsf = PhotFluxCat (&measure[k], MAG_CLASS_PSF);
       if (isnan(Fsys)) SKIP_THIS_MEAS(Nsys);
+      if (isnan(Fpsf)) SKIP_THIS_MEAS(Nsys);
       // if (Msys <  0.0) SKIP_THIS_MEAS(Nsys);
       // if (Msys > 30.0) SKIP_THIS_MEAS(Nsys);
       float dFpsf = PhotFluxCatErr (&measure[k], MAG_CLASS_PSF);
+      if (isnan(dFpsf)) SKIP_THIS_MEAS (Nsys);
+      int isBad = (measure[k].psfQF < 0.85);
+      isBad |= isnan(measure[k].psfQF);
+      if (isBad) SKIP_THIS_MEAS (Nsys);
+      int isPoor = (measure[k].psfQFperf < 0.85);
+      if ((pass == 0) && isPoor) SKIP_THIS_MEAS (Nsys);
       dFpsf = MAX (dFpsf, MIN_ERROR*Fpsf); // MIN_ERROR is a fractional error
       Fpsflist[Npsf] = Fpsf * Fcal;
 …
       wpsflist[Npsf] = 1.0;
       Npsf ++;
+      measure[k].dbFlags |= ID_MEAS_WARP_USED;
       float Fap = PhotFluxCat (&measure[k], MAG_CLASS_APER);
 …
     secfilt[Nsec].NusedKronWrp = Nkron;
     secfilt[Nsec].MkronWrp  = isnan(secfilt[Nsec].FkronWrp) ? NAN : 8.9 - 2.5*log10(secfilt[Nsec].FkronWrp); // 8.9 since flux is in Jy
+    secfilt[Nsec].Nwarp     = Nwarp;
+    secfilt[Nsec].NwarpGood = NwarpGood;
+  }
   return (TRUE);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/Makefile

-              r35764
+              r37822
 default: uniphot setphot setphot_client setfwhm setposangle setposangle_client setastrom setastrom_client fiximids fiximids_client fixstkids fixstkids_client ckids ckids_client
+default: uniphot setphot setphot_client setfwhm setposangle setposangle_client setastrom setastrom_client setgalmodel setgalmodel_client fiximids fiximids_client fixstkids fixstkids_client ckids ckids_client
 help:
 @echo "make options: uniphot setphot setfwhm default help install default (uniphot setphot setfwhm)"
 …
 setastrom: $(BIN)/setastrom.$(ARCH)
 setastrom_client: $(BIN)/setastrom_client.$(ARCH)
+setgalmodel: $(BIN)/setgalmodel.$(ARCH)
+setgalmodel_client: $(BIN)/setgalmodel_client.$(ARCH)
 fiximids: $(BIN)/fiximids.$(ARCH)
 fiximids_client: $(BIN)/fiximids_client.$(ARCH)
 …
 ckids_client: $(BIN)/ckids_client.$(ARCH)
 install: $(DESTBIN)/uniphot $(DESTBIN)/setfwhm $(DESTBIN)/setphot $(DESTBIN)/setphot_client $(DESTBIN)/setposangle $(DESTBIN)/setposangle_client $(DESTBIN)/setastrom $(DESTBIN)/setastrom_client $(DESTBIN)/fiximids $(DESTBIN)/fiximids_client $(DESTBIN)/fixstkids $(DESTBIN)/fixstkids_client $(DESTBIN)/ckids $(DESTBIN)/ckids_client
+install: $(DESTBIN)/uniphot $(DESTBIN)/setfwhm $(DESTBIN)/setphot $(DESTBIN)/setphot_client $(DESTBIN)/setposangle $(DESTBIN)/setposangle_client $(DESTBIN)/setastrom $(DESTBIN)/setastrom_client $(DESTBIN)/setgalmodel $(DESTBIN)/setgalmodel_client $(DESTBIN)/fiximids $(DESTBIN)/fiximids_client $(DESTBIN)/fixstkids $(DESTBIN)/fixstkids_client $(DESTBIN)/ckids $(DESTBIN)/ckids_client
 UNIPHOT = \
 …
 $(SRC)/setastrom.$(ARCH).o          \
 $(SRC)/initialize_setastrom.$(ARCH).o \
+$(SRC)/dcr_correction.$(ARCH).o \
+$(SRC)/kh_correction.$(ARCH).o \
 $(SRC)/astrom_correction.$(ARCH).o \
 $(SRC)/update_dvo_setastrom.$(ARCH).o \
 …
 $(SRC)/update_dvo_setastrom.$(ARCH).o \
 $(SRC)/update_catalog_setastrom.$(ARCH).o \
+$(SRC)/dcr_correction.$(ARCH).o \
+$(SRC)/kh_correction.$(ARCH).o \
 $(SRC)/astrom_correction.$(ARCH).o \
 $(SRC)/initialize_setastrom.$(ARCH).o
 …
 $(SETASTROM_CLIENT): $(INC)/setastrom.h
 $(BIN)/setastrom_client.$(ARCH): $(SETASTROM_CLIENT)
+SETGALMODEL = \
+$(SRC)/setgalmodel.$(ARCH).o        \
+$(SRC)/initialize_setgalmodel.$(ARCH).o \
+$(SRC)/galmodel_correction.$(ARCH).o \
+$(SRC)/update_dvo_setgalmodel.$(ARCH).o \
+$(SRC)/update_catalog_setgalmodel.$(ARCH).o \
+$(SRC)/SetSignals.$(ARCH).o         \
+$(SRC)/Shutdown.$(ARCH).o
+$(SETGALMODEL): $(INC)/setgalmodel.h
+$(BIN)/setgalmodel.$(ARCH): $(SETGALMODEL)
+SETGALMODEL_CLIENT = \
+$(SRC)/setgalmodel_client.$(ARCH).o         \
+$(SRC)/update_dvo_setgalmodel.$(ARCH).o \
+$(SRC)/update_catalog_setgalmodel.$(ARCH).o \
+$(SRC)/galmodel_correction.$(ARCH).o \
+$(SRC)/initialize_setgalmodel.$(ARCH).o
+$(SETGALMODEL_CLIENT): $(INC)/setgalmodel.h
+$(BIN)/setgalmodel_client.$(ARCH): $(SETGALMODEL_CLIENT)
 SETFWHM =                           \

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/include/setastrom.h

-              r35103
+              r37822
 char        *SINGLE_CPT;
+char        *KH_FILE;
+char        *DCR_FILE;
+int          KH_RESET;
+int          DCR_RESET;
 SkyRegion    UserPatch;
 …
 // int           SetSignals                      PROTO((void));
 int           update_dvo_setastrom            PROTO((char *corrfile));
 int           update_dvo_setastrom_parallel   PROTO((SkyTable *sky, char *corrfile));
+int           update_dvo_setastrom            PROTO(());
+int           update_dvo_setastrom_parallel   PROTO((SkyTable *sky));
 int           update_catalog_setastrom        PROTO((Catalog *catalog));
 // spline correction functions
-int load_astrom_correction (char *filename);
-int get_astrom_correction (int sub, int chip, double *dX, double *dY, float Minst);
 double spline_apply_dbl (double *x, double *y, double *y2, int N, double X);
+int load_kh_correction (char *filename);
+int get_kh_correction (int sub, int chip, double *dX, double *dY, float Minst);
+int load_dcr_correction (char *filename);
+int get_dcr_correction (int filter, double *dX, double *dY, float Color);

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/src/astrom_correction.c

-              r35103
+              r37822
 // astrometry correction functions:
+// load the correction set from a file
+// the correction is saved as a set of splines, one per file extension
+// extensions have names of the form XYnn.Dx.Td
+// where nn = 00 - 77, the chip number
+// x is X or Y, the correction direction (dir)
+// d is 0 or 1, pre or post camera correction (sub)
+// these are stored in an N-D array of (Spline *) splineset[sub][dir][chip]
+# define N_SUB 2
+# define N_DIR 2
+# define N_CHIP 78
+// note that we are allocating pointers for XY00 - XY77, but only the octal elements are set (and not the 00,07,70,77 ones)
+Spline ****splineset;
+int load_astrom_correction (char *filename) {
+  int Ncol;
+  off_t Nrow;
+  char type[16];
+  char extname[80];
+  Header header;
+  Header theader;
+  FTable ftable;
+  /* open file for input */
+  FILE *f = fopen (filename, "r");
+  if (f == (FILE *) NULL) {
+    gprint (GP_ERR, "can't open file for read : %s\n", filename);
+    return FALSE;
+  }
+  // read the PHU header
+  if (!gfits_load_header (f, &header)) return (FALSE);
+  int Nbytes = gfits_data_size (&header);
+  fseeko (f, Nbytes, SEEK_CUR);
+  // XXX gfits_free_header (&header);
+  ftable.header = &theader;
+  int sub, dir, chip;
+  // we have a N-D array of splines:
+  // splineset[sub][dir][chip]
+  ALLOCATE (splineset, Spline ***, N_SUB);
+  for (sub = 0; sub < N_SUB; sub++) {
+    ALLOCATE (splineset[sub], Spline **, N_DIR);
+    for (dir = 0; dir < N_DIR; dir++) {
+      ALLOCATE (splineset[sub][dir], Spline *, N_CHIP);
+      for (chip = 0; chip < N_CHIP; chip ++) {
+        splineset[sub][dir][chip] = NULL;
+      }
+    }
+  }
+  while (TRUE) {
+    // load data for this header : if not found, assume we hit the end of the file
+    if (!gfits_load_header (f, &theader)) break;
+    if (!gfits_fread_ftable_data (f, &ftable, FALSE)) return (FALSE);
+    if (!gfits_scan (&theader, "EXTNAME", "%s", 1, extname)) return (FALSE);
+    // figure out the chip ID, diretion, and sequence from the EXTNAME
+    // EXTNAME is of the form XY%d%d.D%s.T%s where
+    char chipname[3];
+    chipname[0] = extname[2];
+    chipname[1] = extname[3];
+    chipname[2] = 0;
+    int chip = atoi(chipname);
+    myAssert (chip >   0, "error in extname %s not(chip >   0)\n", extname);
+    myAssert (chip <  77, "error in extname %s not(chip <  77)\n", extname);
+    myAssert (chip !=  7, "error in extname %s not(chip !=  7)\n", extname);
+    myAssert (chip != 70, "error in extname %s not(chip != 70)\n", extname);
+    int dir = -1;
+    if (extname[6] == 'X') {
+      dir = 0;
+    }
+    if (extname[6] == 'Y') {
+      dir = 1;
+    }
+    myAssert (dir != -1, "error in extname %s (dir)\n", extname);
+    int sub = -1;
+    if (extname[9] == '0') {
+      sub = 0;
+    }
+    if (extname[9] == '1') {
+      sub = 1;
+    }
+    myAssert (sub != -1, "error in extname %s (sub)\n", extname);
+    // need to create and assign to flat-field correction
+    double *xk = gfits_get_bintable_column_data (&theader, &ftable, "X_KNOT", type, &Nrow, &Ncol);
+    myAssert (!strcmp(type, "double"), "error reading X_KNOT");
+    // need to create and assign to flat-field correction
+    double *yk = gfits_get_bintable_column_data (&theader, &ftable, "Y_KNOT", type, &Nrow, &Ncol);
+    myAssert (!strcmp(type, "double"), "error reading X_KNOT");
+    // need to create and assign to flat-field correction
+    double *y2 = gfits_get_bintable_column_data (&theader, &ftable, "DY2_DX", type, &Nrow, &Ncol);
+    myAssert (!strcmp(type, "double"), "error reading X_KNOT");
+    ALLOCATE (splineset[sub][dir][chip], Spline, 1);
+    splineset[sub][dir][chip]->xk = xk;
+    splineset[sub][dir][chip]->yk = yk;
+    splineset[sub][dir][chip]->y2 = y2;
+    splineset[sub][dir][chip]->Nknots = Nrow;
+  }
+  return (TRUE);
+}
+int get_astrom_correction (int sub, int chip, double *dX, double *dY, float Minst) {
+  Spline *spline = NULL;
+  *dX = 0.0;
+  *dY = 0.0;
+  // XXX need to include some limits on Minst?
+  spline = splineset[sub][0][chip];
+  if (spline) {
+    *dX = spline_apply_dbl (spline->xk, spline->yk, spline->y2, spline->Nknots, Minst);
+  }
+  spline = splineset[sub][1][chip];
+  if (spline) {
+    *dY = spline_apply_dbl (spline->xk, spline->yk, spline->y2, spline->Nknots, Minst);
+  }
+  return (TRUE);
+}
+// KH correction
+// DCR correction
 /* evaluate spline for x, y, y2 at X */

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/src/find_image_sgroups.c

-              r36481
+              r37822
+  }
+  coords.crpix1 = coords.crpix2 = 0.0;
+  coords.cdelt1 = coords.cdelt2 = 1.0; /* scale is degrees, radius in degrees */
+  coords.pc1_1 = coords.pc2_2 = 1.0;
+  coords.pc1_2 = coords.pc2_1 = 0.0;
+  strcpy (coords.ctype, "DEC--TAN");
+  InitCoords (&coords, "DEC--TAN");
   Ngroup = 0;
 …
     // NOCAL above is used to mark images which do not match the photcode (including the DIS)
     // if (!strcmp(&image[i].coords.ctype[4], "-DIS")) continue;
-    // this adds 1.3 sec for 3M images
-    if (!FindMosaicForImage (image, Nimage, i)) {
-      fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", i);
-      continue;
+    }
     /* define image center - note the DIS images (mosaic phu) are special */
 …
       // if (!strcmp(&image[j].coords.ctype[4], "-DIS")) continue;
-      // this adds 1.3 sec for 3M images
-      if (!FindMosaicForImage (image, Nimage, j)) {
-          fprintf (stderr, "cannot find mosaic for "OFF_T_FMT"\n", j);
-          continue;
+      }
       /* project image center to local coords, check radius */
       if (!strcmp(&image[j].coords.ctype[4], "-DIS")) {

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/src/initialize_setastrom.c

-              r35103
+              r37822
 void usage_setastrom () {
     fprintf (stderr, "USAGE: setastrom (corrections) [options]\n");
+    fprintf (stderr, "USAGE: setastrom [options]\n");
     fprintf (stderr, "  options:\n");
+    fprintf (stderr, "    -DCR (file) : supply DCR correction splines\n");
+    fprintf (stderr, "    -KH (file) : supply Koppenhoefer correction splines\n");
     fprintf (stderr, "    -v : verbose mode\n");
     fprintf (stderr, "    -region Rmin Rmax Dmin Dmax\n");
 …
   int N;
+  KH_FILE = NULL;
+  if ((N = get_argument (argc, argv, "-KH"))) {
+    remove_argument (N, &argc, argv);
+    char *tmpfile = strcreate (argv[N]);
+    KH_FILE = abspath (tmpfile, DVO_MAX_PATH);
+    remove_argument (N, &argc, argv);
+  }
+  KH_RESET = FALSE;
+  if ((N = get_argument (argc, argv, "-KH-reset"))) {
+    remove_argument (N, &argc, argv);
+    KH_RESET = TRUE;
+  }
+  DCR_FILE = NULL;
+  if ((N = get_argument (argc, argv, "-DCR"))) {
+    remove_argument (N, &argc, argv);
+    char *tmpfile = strcreate (argv[N]);
+    DCR_FILE = abspath (tmpfile, DVO_MAX_PATH);
+    remove_argument (N, &argc, argv);
+  }
+  DCR_RESET = FALSE;
+  if ((N = get_argument (argc, argv, "-DCR-reset"))) {
+    remove_argument (N, &argc, argv);
+    DCR_RESET = TRUE;
+  }
   SINGLE_CPT = NULL;
   if ((N = get_argument (argc, argv, "-cpt"))) {
 …
+  }
+  if (argc != 2) usage_setastrom();
+  if (!KH_FILE && !DCR_FILE) {
+    fprintf (stderr, "at least one of -KH and -DCR must be supplied\n");
+    exit (1);
+  }
+  if (argc != 1) usage_setastrom();
   return (TRUE);
 …
 void usage_setastrom_client () {
   fprintf (stderr, "USAGE: setastrom_client (correction) -hostID (hostID) -catdir (catdir) -hostdir (hostdir) [options]\n");
+  fprintf (stderr, "USAGE: setastrom_client -hostID (hostID) -catdir (catdir) -hostdir (hostdir) [options]\n");
   fprintf (stderr, "  options:\n");
+  fprintf (stderr, "    -DCR (file) : supply DCR correction splines\n");
+  fprintf (stderr, "    -KH (file) : supply Koppenhoefer correction splines\n");
   fprintf (stderr, "    -region Rmin Rmax Dmin Dmax\n");
   fprintf (stderr, "    -update-catformat (format) : change database schema on output\n");
 …
   int N;
+  KH_FILE = NULL;
+  if ((N = get_argument (argc, argv, "-KH"))) {
+    remove_argument (N, &argc, argv);
+    KH_FILE = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  KH_RESET = FALSE;
+  if ((N = get_argument (argc, argv, "-KH-reset"))) {
+    remove_argument (N, &argc, argv);
+    KH_RESET = TRUE;
+  }
+  DCR_FILE = NULL;
+  if ((N = get_argument (argc, argv, "-DCR"))) {
+    remove_argument (N, &argc, argv);
+    DCR_FILE = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  DCR_RESET = FALSE;
+  if ((N = get_argument (argc, argv, "-DCR-reset"))) {
+    remove_argument (N, &argc, argv);
+    DCR_RESET = TRUE;
+  }
   /* specify portion of the sky : allow default of all sky? */
 …
   if (!CATDIR) usage_setastrom_client();
+  if (argc != 2) usage_setastrom_client();
+  if (!KH_FILE && !DCR_FILE) {
+    fprintf (stderr, "at least one of -KH and -DCR must be supplied\n");
+    exit (1);
+  }
+  if (argc != 1) usage_setastrom_client();
   return (TRUE);
+}

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/src/load_zpt_table.c

-              r33654
+              r37822
       mjdstart = tstart_uc[i];
       mjdstop  = tstop_uc[i];
   } else {
+    } else {
       char name[9];
+      snprintf (name, 9, "TS0_%04d", i);
+      // snprintf (name, 9, "TS0_%04d", i);
+      snprintf (name, 9, "S0_MJD%d", i);
       if (!gfits_scan (&header, name, "%lf", 1, &mjdstart)) {
         fprintf (stderr, "cannot find %s in header of %s\n", name, filename);
 …
+      }
+      snprintf (name, 9, "TS1_%04d", i);
+      // snprintf (name, 9, "TS1_%04d", i);
+      snprintf (name, 9, "S1_MJD%d", i);
       if (!gfits_scan (&header, name, "%lf", 1, &mjdstop)) {
         fprintf (stderr, "cannot find %s in header of %s\n", name, filename);
 …
+      }
+    }
     flatcorrTable->tstart[i] = ohana_mjd_to_sec(mjdstart);
     flatcorrTable->tstop[i]  = ohana_mjd_to_sec(mjdstop);
+    flatcorrTable->tstart[i] = (mjdstart > 0) ? ohana_mjd_to_sec(mjdstart) : ohana_mjd_to_sec(50000.0); // 1995/10/10 (ancient history)
+    flatcorrTable->tstop[i]  = (mjdstop  > 0) ? ohana_mjd_to_sec(mjdstop)  : ohana_mjd_to_sec(60000.0); // 2023/02/25 (infinite future)
+  }
 …
     } else {
       if (!gfits_scan (&header, "FILTER", "%s", 1, filter)) {
+        fprintf (stderr, "cannot find FILTER in header of %s\n", filename);
+        fclose (f);
+        return NULL;
+        fprintf (stderr, "cannot find FILTER in header of %s, using %s\n", filename, filters_uc[nfilter]);
+        strcpy (filter, filters_uc[nfilter]);
+        // fclose (f);
+        // return NULL;
+      }
+    }
 …
       REALLOCATE (offset64, double, matrix.Naxis[0]);
       matrix.buffer = (char *) offset64;
+    }
+    if (matrix.Naxes == 1) {
+      int Ntotal = NSEASON*NCHIP_X*NCHIP_Y*NCELL_X*NCELL_Y;
+      if (matrix.Naxis[0] != Ntotal) {
+        int Nextra = Ntotal - matrix.Naxis[0];
+        assert (Nextra >= 0);
+        fprintf (stderr, "warning: images are not fully populated, extending by %d\n", Nextra);
+        REALLOCATE (offset64, double, Ntotal);
+        int npix;
+        for (npix = matrix.Naxis[0]; npix < Ntotal; npix ++) offset64[npix] = 0.0;
+        matrix.Naxis[0] = Ntotal;
+        matrix.buffer = (char *) offset64;
+      }
+    }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/src/match_zpts_to_images.c

-              r35764
+              r37822
+    }
+    // if secz is crazy, do not trust ubercal; skip and move along
+    if (image[Ni].secz < 0.1) {
+      i++;
+      continue;
+    }
     // we have a match: set zpt and record the match
     // is the zero point supplied nominally corrected or not?

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/src/update_catalog_setastrom.c

-              r37043
+              r37822
 # include "setastrom.h"
+// this code does both DCR and KH corrections, if both are specified.
 // XXX this function is dependent in two ways on the specific numerical values of the photcodes
 …
 int update_catalog_setastrom (Catalog *catalog) {
   off_t i, found;
+  off_t i;
   time_t timeRef = ohana_date_to_sec("2011/05/11,00:00:00");
+  found = 0;
+  int Nsecfilt = GetPhotcodeNsecfilt ();
+  PhotCode *code_g = GetPhotcodebyName ("g");
+  PhotCode *code_i = GetPhotcodebyName ("i");
+  PhotCode *code_z = GetPhotcodebyName ("z");
+  PhotCode *code_y = GetPhotcodebyName ("y");
+  int Nsec_g = GetPhotcodeNsec(code_g->code);
+  int Nsec_i = GetPhotcodeNsec(code_i->code);
+  int Nsec_z = GetPhotcodeNsec(code_z->code);
+  int Nsec_y = GetPhotcodeNsec(code_y->code);
+  off_t found = 0;
   for (i = 0; i < catalog[0].Nmeasure; i++) {
 …
     Measure *measure = &catalog[0].measure[i];
     // XXX only do GPC1 data for now
+    // only do GPC1 data for now (true for both DCR and KH)
     if (measure[0].photcode < 10000) continue;
     if (measure[0].photcode > 10600) continue;
+    // XXX hardwire the list of chips to correct
+    int averef = measure->averef;
+    Average *average = &catalog[0].average[averef];
+    SecFilt *secfilt = &catalog[0].secfilt[averef*Nsecfilt];
+    int chipID = measure[0].photcode % 100;
+    // XXX hardwire the list of chips to KH correct
     // some notes:
     // XY24 surpisingly does not need correction
+    // XY24 surprisingly does not need correction
     // XY27 has poor astrometry with a weird correction for all mags
     // XY36 surpisingly does not need correction
+    // XY36 surprisingly does not need correction
     // XY67 has poor astrometry with a weird correction for all mags
     int chipID = measure[0].photcode % 100;
+    int doKH = FALSE;
     switch (chipID) {
       case 4:
 …
       case 72:
       case 73:
+        doKH = TRUE;
         break;
       default:
+        measure[0].Xfix = measure[0].Xccd;
+        measure[0].Yfix = measure[0].Yccd;
+        continue;
+    }
+    double Xccd = measure[0].Xccd;
+    double Yccd = measure[0].Yccd;
+        break;
+    }
     double pltScale = fabs(measure[0].pltscale);
+    // this is not needed, is it?
+    // double posAngle = FromShortDegrees(measure[0].posangle);
+    // I need to know which chip we have.  use photcode assuming range
+    int chip = measure[0].photcode % 100;
+    // correction may be Minst or Minst + 5.0*log(fwhm
+    float fwhm_maj = FromShortPixels(measure[0].FWx);
+    float Minst = PhotInst (measure, MAG_CLASS_PSF);
+    float MinstSB = Minst + 5.0*log10(fwhm_maj);
+    // I should validate that the spline I'm using is SB corrected not Minst...
+    // XXX this is very ad hoc.  the splines are measured based on an extraction from dvo
+    // the dvo values of fwhm_maj are sigmas (NOT FWHM!) in pixels.
+    double posAngle = FromShortDegrees(measure[0].posangle);
+    /**** KH section ****/
+    double dX_KH = 0.0;
+    double dY_KH = 0.0;
+    if (KH_FILE && doKH && (measure[0].t < timeRef)) {
+      // correction may be Minst or Minst + 5.0*log(fwhm
+      float fwhm_maj = FromShortPixels(measure[0].FWx);
+      float Minst = PhotInst (measure, MAG_CLASS_PSF);
+      // float MinstSB = Minst + 5.0*log10(fwhm_maj);
+      // NOTE: the spline correction was measured on the nightly-science database using measurements
+      // from the period in which fwhm_maj & fwhm_min were a factor of sqrt(2) too small.  I am making
+      // this correction here (but ideally I would re-measure the KH trend from PV2 data and re-generate
+      // the splines
+      float MinstSB = Minst + 5.0*log10(M_SQRT2*fwhm_maj);
+      // I should validate that the spline I'm using is SB corrected not Minst..
+      // NOTE: it is SB, not raw Minst
+      // XXX this is very ad hoc.  the splines are measured based on an extraction from dvo
+      // the dvo values of fwhm_maj are sigmas (NOT FWHM!) in pixels.
+    // saturate fwhm_maj in the range 1.0 < fwhm_maj < 5.0
+    // (images with really odd psf probably have poor astrometry anyway...)
+    fwhm_maj = MIN(fwhm_maj,5.0);
+    fwhm_maj = MAX(fwhm_maj,1.0);
+    double dX;
+    double dY;
+    // correction is in arcseconds
+    if (measure[0].t < timeRef) {
+      get_astrom_correction (0, chip, &dX, &dY, MinstSB);
+    } else {
+      // XXX do not correct new data
+      // get_astrom_correction (1, chip, &dX, &dY, MinstSB);
+      dX = 0.0;
+      dY = 0.0;
+    }
+      // saturate fwhm_maj in the range 1.0 < fwhm_maj < 5.0
+      // (images with really odd psf probably have poor astrometry anyway...)
+      fwhm_maj = MIN(fwhm_maj,5.0);
+      fwhm_maj = MAX(fwhm_maj,1.0);
+      // correction is in arcseconds
+      get_kh_correction (0, chipID, &dX_KH, &dY_KH, MinstSB);
+    }
+    /**** DCR section ****/
+    double dX_DCR = 0.0;
+    double dY_DCR = 0.0;
+    if (DCR_FILE) {
+      // check if the color*airmass term is not-nan (Skip otherwise)
+      // XXX hard-wire gpc1 photcodes for now:
+      // I should use photcode ops: PhotCode *code = PhotCodeByCode(measure->photcode)
+      // int equiv = code->equiv
+      // Nsec = GetNsec(equiv)
+      float dColor = 0.0;
+      int filtCode = (int)(measure->photcode / 100); // eg, 101 = r
+      switch (filtCode) {
+        case 100:
+        case 101:
+        case 102: {
+          float gmag = secfilt[Nsec_g].M;
+          float imag = secfilt[Nsec_i].M;
+          dColor = average->refColorBlue - (gmag - imag);
+          break;
+        }
+        case 103:
+        case 104: {
+          float zmag = secfilt[Nsec_z].M;
+          float ymag = secfilt[Nsec_y].M;
+          dColor = average->refColorRed - (zmag - ymag);
+          break;
+        }
+      }
+      int filtSeq = filtCode % 100;
+      if (!isfinite(dColor)) goto skip_DCR;
+      // I need to get the parallactic angle, but I only have alt & az, s:o
+      // airmass = 1.0 / cos(90 - alt)
+      // cos(90 - alt) = cos(zd) = sin(alt) = 1.0 / airmass
+      // airmass = 1.0 / sin(alt)
+      // airmass = 1.0 / cos(zd)
+      // cos(zd) = 1.0 / airmass == sn_alt
+      // sin(zd) = sqrt(1.0 - cos(zd)^2) == cs_alt
+      // tan(zd) = sin(zd) / cos(zd) = cs_alt / sn_alt
+      double sn_alt = 1.0 / measure->airmass;
+      double cs_alt = sqrt(1.0 - SQ(sn_alt));
+      double tan_zd = cs_alt / sn_alt;
+      double cs_az  = cos(RAD_DEG*measure->az);
+      double sn_az  = sin(RAD_DEG*measure->az);
+# define LATITUDE (20.7070999146*RAD_DEG)
+      double sn_lat = sin(LATITUDE);
+      double cs_lat = cos(LATITUDE);
+      // double sind = sn_alt * sn_lat + cs_alt * cs_az * cs_lat;
+      // *dec  = DEG_RAD * asin (sind);
+      // WARNING: these are NOT sin(ha),cos(ha) but are scaled
+      // double ha = DEG_RAD * atan2 (sinh, cosh);
+      double sinh = -cs_alt * sn_az;
+      double cosh =  sn_alt * cs_lat - cs_alt * cs_az * sn_lat;
+      double r_ha = hypot(sinh, cosh);
+      double sn_ha = sinh / r_ha;
+      double cs_ha = cosh / r_ha;
+      sinh = -cs_az * sn_alt * sn_ha * sn_lat + sn_az * sn_alt * cs_ha - sn_ha * cs_alt * cs_lat;
+      cosh = -sn_az          * sn_ha * sn_lat - cs_az          * cs_ha;
+      double r_rot = hypot(sinh, cosh);
+      double sn_rot = -sinh / r_rot;
+      double cs_rot = +cosh / r_rot;
+      double dPx = 0.0;
+      double dPy = 0.0;
+      float colorOffset = dColor * tan_zd;
+      get_dcr_correction (filtSeq, &dPx, &dPy, colorOffset);
+      // if we had x-terms, we would have:
+      // double dPx = dRx *cs_rot + dD_s*sn_rot;
+      // double dPy = dD_s*cs_rot - dRx *sn_rot;
+      // double dR = dPx*cs_rot - dPy*sn_rot;
+      // double dD = dPx*sn_rot + dPy*cs_rot;
+      // since dPx = 0.0, instead we have: dPx, dPy as measured in dvo.dcr.sh
+      double dR = -dPy*sn_rot;
+      double dD = +dPy*cs_rot;
+      // dR = (measure->R - average->R) * 3600 * dcos(dec) [ie, in the projected plane]
+      // dD = (measure->D - average->D) * 3600
+      // average->D = measure->D - dD/3600
+      // now we need to rotate dR,dD into the chip frame and correction Xccd,Yccd
+      // are the plate-scale and posangle correctly set in the db?
+      // XXX the koppenhoefer code implies pos if angle from y -> D, (ie negative of the
+      // below).  if so, apply sin(pos) -> -sin(pos)
+      // if parity = sky:
+      // double dR =  dX*cos(pos) + dY*sin(pos);
+      // double dD = -dX*sin(pos) + dY*cos(pos);
+      // XXX signs set here to reflect pos = -pos
+      float posAngRad = posAngle * RAD_DEG;
+      dX_DCR =  dR*cos(posAngRad) + dD*sin(posAngRad);
+      dY_DCR = -dR*sin(posAngRad) + dD*cos(posAngRad);
+    }
+  skip_DCR:
     // do not modify the original Xccd,Yccd values
+    measure[0].Xfix = Xccd + dX / pltScale;
+    measure[0].Yfix = Yccd + dY / pltScale;
+    if (KH_FILE) {
+      measure[0].XoffKH = dX_KH / pltScale;
+      measure[0].YoffKH = dY_KH / pltScale;
+    }
+    if (KH_RESET) {
+      measure[0].XoffKH = 0.0;
+      measure[0].YoffKH = 0.0;
+    }
+    if (DCR_FILE) {
+      measure[0].XoffDCR = -dX_DCR / pltScale;
+      measure[0].YoffDCR = -dY_DCR / pltScale;
+    }
+    if (DCR_RESET) {
+      measure[0].XoffDCR = -dX_DCR / pltScale;
+      measure[0].YoffDCR = -dY_DCR / pltScale;
+    }
+    measure[0].Xfix = measure[0].Xccd;
+    measure[0].Yfix = measure[0].Yccd;
+    if (isfinite(measure[0].XoffKH) && isfinite(measure[0].YoffKH)) {
+      measure[0].Xfix += measure[0].XoffKH;
+      measure[0].Yfix += measure[0].YoffKH;
+    }
+    if (isfinite(measure[0].XoffDCR) && isfinite(measure[0].YoffDCR)) {
+      measure[0].Xfix += measure[0].XoffDCR;
+      measure[0].Yfix += measure[0].YoffDCR;
+    }
     found ++;
+  }

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/src/update_dvo_setastrom.c

-              r35103
+              r37822
 # include "setastrom.h"
 int update_dvo_setastrom (char *corrfile) {
+int update_dvo_setastrom () {
   SkyTable *sky = NULL;
 …
   if (PARALLEL && !HOST_ID) {
     int status = update_dvo_setastrom_parallel (sky, corrfile);
+    int status = update_dvo_setastrom_parallel (sky);
     return status;
+  }
+  load_astrom_correction (corrfile);
+  if (KH_FILE)  load_kh_correction (KH_FILE);
+  if (DCR_FILE) load_dcr_correction (DCR_FILE);
   // determine the populated SkyRegions overlapping the requested area (default depth)
 …
 # define DEBUG 1
 int update_dvo_setastrom_parallel (SkyTable *sky, char *corrfile) {
+int update_dvo_setastrom_parallel (SkyTable *sky) {
   // now launch the setastrom_client jobs to the parallel hosts
-  char *abscorrfile = abspath (corrfile, DVO_MAX_PATH);
   // load the list of hosts
 …
     char command[1024];
     snprintf (command, 1024, "setastrom_client %s -hostID %d -catdir %s -hostdir %s -region %f %f %f %f",
               abscorrfile, table->hosts[i].hostID, CATDIR, table->hosts[i].pathname,
+    snprintf (command, 1024, "setastrom_client -hostID %d -catdir %s -hostdir %s -region %f %f %f %f",
+              table->hosts[i].hostID, CATDIR, table->hosts[i].pathname,
               UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
-    fprintf (stderr, "command: %s\n", command);
     char tmpline[1024];
     if (VERBOSE)          { snprintf (tmpline, 1024, "%s -v",                   command);                   strcpy (command, tmpline); }
     if (UPDATE)           { snprintf (tmpline, 1024, "%s -update",              command);                   strcpy (command, tmpline); }
+    if (KH_FILE)          { snprintf (tmpline, 1024, "%s -KH %s",               command, KH_FILE);          strcpy (command, tmpline); }
+    if (DCR_FILE)         { snprintf (tmpline, 1024, "%s -DCR %s",              command, DCR_FILE);         strcpy (command, tmpline); }
     if (UPDATE_CATFORMAT) { snprintf (tmpline, 1024, "%s -update-catformat %s", command, UPDATE_CATFORMAT); strcpy (command, tmpline); }
+    if (KH_RESET)         { snprintf (tmpline, 1024, "%s -KH-reset",            command);                   strcpy (command, tmpline); }
+    if (DCR_RESET)        { snprintf (tmpline, 1024, "%s -DCR-reset",           command);                   strcpy (command, tmpline); }
+    fprintf (stderr, "command: %s\n", command);
     if (PARALLEL_MANUAL) continue;
 …
+    }
+  }
-  free (abscorrfile);
   // wait for the remote jobs to be completed

branches/eam_branches/ipp-pv3-20140717-merge/Ohana/src/uniphot/src/update_dvo_uniphot.c

-              r36481
+              r37822
   glob (line, 0, NULL, &pglob);
+  coords.crpix1 = coords.crpix2 = 0.0;
+  coords.cdelt1 = coords.cdelt2 = 1.0; /* scale is degrees, radius in degrees */
+  coords.pc1_1 = coords.pc2_2 = 1.0;
+  coords.pc1_2 = coords.pc2_1 = 0.0;
+  strcpy (coords.ctype, "DEC--TAN");
+  InitCoords (&coords, "DEC--TAN");
   for (i = 0; i < pglob.gl_pathc; i++) {

Context Navigation

Legend: