Index: branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise.c
===================================================================
--- branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise.c	(revision 32328)
+++ branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise.c	(revision 32328)
@@ -0,0 +1,52 @@
+# include "addstar.h"
+# include "WISE.h"
+
+int main (int argc, char **argv) {
+
+  char *path;
+  int i;
+  SkyTable *sky, *skyWISE;
+  SkyList *skylist = NULL;
+  SkyList *overlap = NULL;
+  AddstarClientOptions options;
+
+  // need to construct these options with args_loadWISE...
+  options = ConfigInit (&argc, argv);
+  options = args_loadWISE (argc, argv, options);
+
+  // load the full sky description table:
+  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, TRUE, SKY_DEPTH, VERBOSE);
+  SkyTableSetFilenames (sky, CATDIR, "cpt");
+  
+  // generate the subset matching the user-selected region
+  skylist = SkyListByPatch (sky, -1, &UserPatch);
+
+  // if we only match to existing (already populated) regions, limit the select to those regions:
+  if (options.existing_regions) {
+    SkyList *tmp;
+    tmp = SkyListExistingSubset (skylist, CATDIR);
+    SkyListFree (skylist);
+    skylist = tmp;
+  }
+
+  path = WISE_DIR_PRELIM;
+
+  // the accel.dat file has the raw filenames
+  // test if the file exists, or else try the .gz version
+  // XXX can we build an accelerator?
+  skyWISE = loadWISE_acc (path, "accel.dat");
+  
+  for (i = 0; i < skyWISE[0].Nregions; i++) {
+    // check if any of the skylist entries overlap this WISE catalog:
+    overlap = SkyListByBounds_List (skylist, -1, skyWISE[0].regions[i].Rmin, skyWISE[0].regions[i].Rmax, skyWISE[0].regions[i].Dmin, skyWISE[0].regions[i].Dmax);
+    if (overlap[0].Nregions == 0) {
+      SkyListFree (overlap);
+      continue;
+    }
+    
+    fprintf (stderr, "loading %s\n", skyWISE[0].filename[i]);
+    loadWISE_as_rawdata (overlap, skyWISE[0].filename[i], options);
+    SkyListFree (overlap);
+  }
+  exit (0);
+}  
Index: branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise_ops.c
===================================================================
--- branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise_ops.c	(revision 32328)
+++ branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise_ops.c	(revision 32328)
@@ -0,0 +1,155 @@
+# include "addstar.h"
+# include "WISE.h"
+
+static int FilterSkip;
+static int TimeSkip;
+static int Qentry;
+static int Photcode;
+
+int getWISE_setup () {
+
+  NAMED_PHOTCODE (WISE_W1, "WISE_W1");
+  NAMED_PHOTCODE (WISE_W2, "WISE_W2");
+  NAMED_PHOTCODE (WISE_W3, "WISE_W3");
+  NAMED_PHOTCODE (WISE_W4, "WISE_W4");
+
+  return TRUE;
+}
+
+// fill in the coords for a single star.  takes a pointer to the start of the line
+int getWISE_coords (char *line, double *R, double *D, int Nmax) {
+
+  char *ptr = line;
+
+  ptr = skipNbounds (ptr, '|', 1, Nmax);
+  *R = strtod (ptr, NULL);
+  ptr = skipNbounds (ptr, '|', 1, Nmax);
+  *D = strtod (ptr, NULL);
+  if (*D > 90) Shutdown ("weird DEC value: something is wrong");
+
+  return TRUE;
+}
+
+int getWISE_sortStars (WISE_Stars *tstars, int Ntstars) {
+
+# define SWAPFUNC(A,B){ WISE_Stars temp = tstars[A]; tstars[A] = tstars[B]; tstars[B] = temp; }
+# define COMPARE(A,B)(tstars[A].R < tstars[B].R)
+
+  OHANA_SORT (Ntstars, COMPARE, SWAPFUNC);
+
+# undef SWAPFUNC
+# undef COMPARE
+  
+  return TRUE;
+}
+
+// this function retrieves the time from the DATE field
+e_time getWISE_date (char *ptr, int Nbound, int Nmax) {
+
+  e_time time;
+  char *p, *end;
+
+  p = skipNbounds (ptr, '|', Nbound, Nmax);
+  if (p == NULL) Shutdown ("format error in WISE");
+  end = memchr (p, '|', Nmax - (p - ptr));
+  if (end == NULL) Shutdown ("format error in WISE");
+  *end = 0;
+  time = ohana_date_to_sec (ptr);
+  *end = '|';
+
+  return (time);
+}
+
+// this function retrieves the time from the JDATE field (%12.4f)
+e_time getWISE_time (char *ptr, int Nbound, int Nmax) {
+
+  e_time time;
+  double jd;
+  char *p, *end;
+
+  p = skipNbounds (ptr, '|', Nbound, Nmax);
+  if (p == NULL) Shutdown ("format error in WISE");
+  end = memchr (p, '|', Nmax - (p - ptr));
+  if (end == NULL) Shutdown ("format error in WISE");
+  *end = 0;
+  jd = strtod (p, NULL);
+  time = ohana_jd_to_sec (jd);
+  *end = '|';
+
+  return (time);
+}
+
+/* return a pointer to the first char after Nbound of value bound */
+char *skipNbounds (char *line, char bound, int Nbound, int Nbyte) {
+
+  int i;
+  char *p, *q;
+
+  p = line;
+  for (i = 0; i < Nbound; i++) {
+    q = memchr (p, bound, Nbyte - (p - line));
+    if (q == NULL) return (NULL);
+    p = q + 1;
+    if (p - line == Nbyte) return (NULL);
+  }
+  return (p);
+}
+  
+/* watch for patches which cross 0,360 boundary */
+SkyTable *loadWISE_acc (char *path, char *accel) {
+
+  int Nregions, NREGIONS, Nrec;
+  char accelfile[1024], line[256], filename[128], datafile[256], **filenames;
+  FILE *f;
+  double Rs, Re, Ds, De;
+
+  SkyTable *sky;
+  SkyRegion *regions;
+
+  sprintf (accelfile, "%s/%s", path, accel);
+  f = fopen (accelfile, "r");
+  if (f == NULL) Shutdown ("can't read data from accelerator %s", accelfile);
+
+  Nregions = 0;
+  NREGIONS = 200;
+  ALLOCATE (regions, SkyRegion, NREGIONS);
+  ALLOCATE (filenames, char *, NREGIONS);
+
+  /* read in stars line-by-line */
+  while (scan_line (f, line) != EOF) {
+    stripwhite (line);
+    if (line[0] == 0) continue;
+    if (line[0] == '#') continue;
+    sscanf (line, "%s %lf %lf %lf %lf %d", filename, &Rs, &Re, &Ds, &De, &Nrec);
+    Rs *= 15.0;
+    Re *= 15.0;
+
+    // don't restrict by RA, but limit by DEC
+    if (De < UserPatch.Dmin) continue;
+    if (Ds > UserPatch.Dmax) continue;
+
+    regions[Nregions].Rmin = Rs;
+    regions[Nregions].Rmax = Re;
+    regions[Nregions].Dmin = Ds;
+    regions[Nregions].Dmax = De;
+    regions[Nregions].childE = Nrec; // a cheat since WISE only has one depth
+
+    sprintf (datafile, "%s/%s", path, filename);
+    filenames[Nregions] = strcreate (datafile);
+
+    Nregions ++;
+    if (Nregions >= NREGIONS) {
+	NREGIONS += 20;
+	REALLOCATE (regions, SkyRegion, NREGIONS);
+	REALLOCATE (filenames, char *, NREGIONS);
+    }
+  }    
+  fclose (f);
+
+  ALLOCATE (sky, SkyTable, 1);
+  sky[0].regions = regions;
+  sky[0].filename = filenames;
+  sky[0].Nregions = Nregions;
+  return (sky);
+}
+
Index: branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise_prelim_rawdata.c
===================================================================
--- branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise_prelim_rawdata.c	(revision 32328)
+++ branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise_prelim_rawdata.c	(revision 32328)
@@ -0,0 +1,241 @@
+# include "addstar.h"
+# include "WISE.h"
+
+/* unlike the DR2 data, the AS data is NOT fixed bytes/row 
+ * we need to handle fractional lines at the end of each read block
+ */
+
+/* read in chunks of ~64MB */
+# define NBYTE 0x4000000
+# define DEBUG 0
+
+int loadWISE_as_rawdata (SkyList *skytable, char *filename, AddstarClientOptions options) {
+  
+  int i, j, verbose;
+  int Nstars, NSTARS, Ntstars, NTSTARS;
+  int Nbyte, Nextra, Ntotal, offset;
+
+  double Rmin, Rmax, Dmin, Dmax;
+
+  FILE *f;
+  char *buffer, *p, *q;
+
+  Stars **stars; // this is an array of pointers to be consistent with input to find_match_refstars
+  WISE_Stars *tstars;
+  SkyList *skylist;
+  SkyRegion *region;
+  Catalog catalog;
+
+  getWISE_setup ();
+
+  ALLOCATE (buffer, char, NBYTE);
+
+  // scan through the entire WISE file
+  f = fopen (filename, "r");
+  if (f == NULL) Shutdown ("can't read WISE data file: %s", filename);
+  // test if this is a raw datafile or gzipped...
+
+  Nextra = 0;  // number excess bytes from lsat partial row
+  Ntotal = 0;  // track the total number of bytes read 
+  while ((Nbyte = fread (&buffer[Nextra], 1, NBYTE-Nextra, f)) != 0) {
+    if (Nbyte == -1) Shutdown ("error reading from raw file %s", filename);
+    if (DEBUG) fprintf (stderr, "read %d bytes", Nbyte);
+
+    Nbyte += Nextra;
+
+    if (VERBOSE) fprintf (stderr, "read .. ");
+
+    /* find bounds on first complete line */
+    p = buffer;
+    q = memchr (p, '\n', Nbyte);
+    if (q == NULL) Shutdown ("incomplete line at end of file\n");
+    offset = p - buffer; // offset within this scan
+
+    Ntstars = 0;
+    NTSTARS = 10000;
+    ALLOCATE (tstars, WISE_Stars, NTSTARS);
+
+    Rmin = 360.0;
+    Rmax =   0.0;
+    Dmin = +90.0;
+    Dmax = -90.0;
+
+    // scan through entire buffer for star coords
+    while (1) {
+      getWISE_coords (p, &tstars[Ntstars].R, &tstars[Ntstars].D, Nbyte - offset);
+      tstars[Ntstars].offset = offset; // offset within scan
+      tstars[Ntstars].flag = FALSE;
+
+      if (VERBOSE) {
+	Rmin = MIN (Rmin, tstars[Ntstars].R);
+	Rmax = MAX (Rmax, tstars[Ntstars].R);
+	Dmin = MIN (Dmin, tstars[Ntstars].D);
+	Dmax = MAX (Dmax, tstars[Ntstars].D);
+      }
+
+      Ntstars ++;
+      CHECK_REALLOCATE (tstars, WISE_Stars, NTSTARS, Ntstars, 10000);
+
+      /* start of the next line */
+      p = q + 1;
+      offset = p - buffer; // offset within this scan
+      if (offset == Nbyte) {
+	// last line in buffer is a complete line
+	Nextra = 0;
+	break;
+      }
+      /* end of the next line */
+      q = memchr (p, '\n', Nbyte - offset);
+      if (q == NULL) {
+	// last, incomplete line in buffer
+	Nextra = Nbyte - offset;
+	break;
+      } 
+    }
+    if (VERBOSE) fprintf (stderr, "scan %d stars (%10.6f - %10.6f, %10.6f - %10.6f) .. ", Ntstars, Rmin, Rmax, Dmin, Dmax);
+
+    // sort the tstars by RA
+    getWISE_sortStars (tstars, Ntstars);
+
+    // scan through the stars, loading the containing catalogs
+    // skip through table for unsaved stars
+    for (i = 0; i < Ntstars; i++) {
+      if (tstars[i].flag) continue;
+
+      // scan forward until we read the UserPatch
+      if (tstars[i].R < UserPatch.Rmin) continue;
+      if (tstars[i].R > UserPatch.Rmax) break;
+      if (tstars[i].D < UserPatch.Dmin) continue;
+      if (tstars[i].D > UserPatch.Dmax) continue;
+
+      // identify the relevant catalog
+      skylist = SkyRegionByPoint_List (skytable, -1, tstars[i].R, tstars[i].D);
+      if (skylist[0].Nregions == 0) {
+	  SkyListFree (skylist);
+	  continue;
+      }
+      region = skylist[0].regions[0];
+      if (DEBUG) fprintf (stderr, "writing to %s\n", skylist[0].filename[0]);
+
+      // collect array of (Stars *) stars in a new output catalog
+      Nstars = 0;
+      NSTARS = 3000;
+      ALLOCATE (stars, Stars *, NSTARS);
+
+      // loop over stars in this WISE region that are also in this output region
+      for (j = i; j < Ntstars; j++) {
+	if (tstars[j].flag) continue;
+
+	// check if in skyregion
+	if (tstars[j].R < region[0].Rmin) continue;
+	if (tstars[j].R > region[0].Rmax) break;
+	if (tstars[j].D < region[0].Dmin) continue;
+	if (tstars[j].D > region[0].Dmax) continue;
+	  
+	// check if in UserPatch
+	if (tstars[j].R < UserPatch.Rmin) continue;
+	if (tstars[j].R > UserPatch.Rmax) break;
+	if (tstars[j].D < UserPatch.Dmin) continue;
+	if (tstars[j].D > UserPatch.Dmax) continue;
+	  
+	offset = tstars[j].offset;
+
+	ALLOCATE (stars[Nstars+0], Stars, 1);
+	ALLOCATE (stars[Nstars+1], Stars, 1);
+	ALLOCATE (stars[Nstars+2], Stars, 1);
+	ALLOCATE (stars[Nstars+3], Stars, 1);
+
+	InitStar (stars[Nstars+0]);
+	InitStar (stars[Nstars+1]);
+	InitStar (stars[Nstars+2]);
+	InitStar (stars[Nstars+3]);
+
+	stars[Nstars+0][0].average.R = tstars[j].R;
+	stars[Nstars+0][0].average.D = tstars[j].D;
+	stars[Nstars+1][0].average.R = tstars[j].R;
+	stars[Nstars+1][0].average.D = tstars[j].D;
+	stars[Nstars+2][0].average.R = tstars[j].R;
+	stars[Nstars+2][0].average.D = tstars[j].D;
+	stars[Nstars+3][0].average.R = tstars[j].R;
+	stars[Nstars+3][0].average.D = tstars[j].D;
+	getWISE_star_full (&stars[Nstars], &buffer[offset], Nbyte - offset);
+
+	tstars[j].flag = TRUE;
+
+	Nstars += 4;
+	if (Nstars >= NSTARS - 4) {
+	  NSTARS += 4000;
+	  REALLOCATE (stars, Stars *, NSTARS);
+	}
+      }
+
+      if (!Nstars) {
+	free (stars);
+	continue;
+      }
+
+      if (DEBUG) fprintf (stderr, "selected %d stars (%10.6f - %10.6f, %10.6f - %10.6f)\n", Nstars, 
+			  region[0].Rmin, region[0].Rmax, region[0].Dmin, region[0].Dmax);
+
+      if (1) {
+	verbose = VERBOSE;
+	VERBOSE = FALSE;
+
+	// now we have all of the loaded stars in this catalog
+	catalog.filename = skylist[0].filename[0];
+	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_MISS | LOAD_SECF;
+	catalog.Nsecfilt  = GetPhotcodeNsecfilt ();
+
+	// an error exit status here is a significant error
+	if (!dvo_catalog_open (&catalog, skylist[0].regions[0], VERBOSE, "w")) {
+	  fprintf (stderr, "ERROR: failure to open/create catalog file %s\n", catalog.filename);
+	  exit (2);
+	}
+
+	// assume no input star matches an existing star 
+	// simply add to the existing table
+	// loadWISE_catalog (&catalog, stars, Nstars);
+	find_matches_refstars (skylist[0].regions[0], stars, Nstars, &catalog, options);
+	// loadWISE_catalog (&catalog, stars, Nstars);
+
+	dvo_catalog_save (&catalog, VERBOSE);
+	dvo_catalog_unlock (&catalog);
+	dvo_catalog_free (&catalog);
+	// free (catalog.filename);
+	// XXX don't free this! it points to an element of the skytable
+      }
+
+      SkyListFree (skylist);
+      for (j = 0; j < Nstars; j++) free (stars[j]);
+      free (stars);
+      VERBOSE = verbose;
+    }
+    free (tstars);
+    if (VERBOSE) fprintf (stderr, "done\n");
+
+    // at end, p points at the start of last, partial line
+    if (Nextra) memmove (buffer, p, Nextra);
+  }
+
+  if (VERBOSE) fprintf (stderr, "\n");
+  
+  fclose (f);
+  free (buffer);
+  return (TRUE);
+}
+
+/*
+  for each WISE file:
+  for each data block
+  generate a table of: R, D, byte, flag
+  for each unsaved star
+  find containing catalog
+  load catalog
+  find all contained stars
+  add to catalog
+  save catalog 
+  mark all contained stars
+*/
+
Index: branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise_star_full.c
===================================================================
--- branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise_star_full.c	(revision 32328)
+++ branches/eam_branches/ipp-20110710/Ohana/src/addstar/src/loadwise_star_full.c	(revision 32328)
@@ -0,0 +1,264 @@
+# include "addstar.h"
+# include "WISE.h"
+
+// XXX check to see if desired output format is PS1_V1 or later?  (use 16bit version if not?)
+
+// 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 getWISE_star_full (Stars **star, char *line, int Nmax) {
+
+  char *ptr;
+  double dMfull;
+  double jd;
+
+  if (line == NULL) Shutdown ("format error in WISE");
+
+  ptr = skipNbounds (ptr, '|', 3, Nmax); // skip: desig, ra, dec,
+  star[0][0].measure.FWx = ToShortPixels(strtod (ptr, NULL));
+  ptr = nextWISEfield (ptr); // sig_dec
+  star[0][0].measure.FWy = ToShortPixels(strtod (ptr, NULL));
+  ptr = nextWISEfield (ptr); // sig_radec
+  star[0][0].measure.theta = ToShortPixels(strtod (ptr, NULL));
+
+  star[1][0].measure.FWx   = star[0][0].measure.FWx;
+  star[1][0].measure.FWy   = star[0][0].measure.FWy;
+  star[1][0].measure.theta = star[0][0].measure.theta;
+  star[2][0].measure.FWx   = star[0][0].measure.FWx;
+  star[2][0].measure.FWy   = star[0][0].measure.FWy;
+  star[2][0].measure.theta = star[0][0].measure.theta;
+  star[3][0].measure.FWx   = star[0][0].measure.FWx;
+  star[3][0].measure.FWy   = star[0][0].measure.FWy;
+  star[3][0].measure.theta = star[0][0].measure.theta;
+
+  ptr = skipNbounds (ptr, '|', 10, Nmax); // skip: glon, glat, elon, elat, wx, wy, cntr, source_id, coadd_id, src
+
+  // W1
+  star[0][0].measure.M  = strtod (ptr, NULL);
+  ptr = nextWISEfield (ptr); // j_cmsig
+  star[0][0].measure.dM = strtod (ptr, NULL);
+  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: w1snr, w1rchi2
+
+  // W2
+  star[1][0].measure.M  = strtod (ptr, NULL);
+  ptr = nextWISEfield (ptr); // j_cmsig
+  star[1][0].measure.dM = strtod (ptr, NULL);
+  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: w2snr, w2rchi2
+
+  // W3
+  star[2][0].measure.M  = strtod (ptr, NULL);
+  ptr = nextWISEfield (ptr); // j_cmsig
+  star[2][0].measure.dM = strtod (ptr, NULL);
+  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: w3snr, w3rchi2
+
+  // W4
+  star[3][0].measure.M  = strtod (ptr, NULL);
+  ptr = nextWISEfield (ptr); // j_cmsig
+  star[3][0].measure.dM = strtod (ptr, NULL);
+  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: w4snr, w4rchi2
+
+  star[0][0].measure.photFlags = 0;
+  star[1][0].measure.photFlags = 0;
+  star[2][0].measure.photFlags = 0;
+  star[3][0].measure.photFlags = 0;
+  ptr = skipNbounds (ptr, '|', 8, Nmax); // skip fields
+
+  setWISE_cc_flag (star[0], ptr[0]); // cc_flg
+  setWISE_cc_flag (star[1], ptr[1]); // cc_flg
+  setWISE_cc_flag (star[2], ptr[2]); // cc_flg
+  setWISE_cc_flag (star[3], ptr[2]); // cc_flg
+  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: ext_flg, var_flg
+
+  setWISE_ph_qual (star[0], ptr[0]); // ph_qual
+  setWISE_ph_qual (star[1], ptr[1]); // ph_qual
+  setWISE_ph_qual (star[2], ptr[2]); // ph_qual
+  setWISE_ph_qual (star[3], ptr[3]); // ph_qual
+  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: ext_flg, var_flg
+
+  // setWISE_rd_flag (star[0], ptr[0]);
+  // setWISE_bl_flag (star[0], ptr[0]);
+  // setWISE_gal_flag (star[0], ptr[0]);
+  // setWISE_mp_flag (star[0], ptr[0]);
+
+  // ptr = nextWISEfield (ptr); // x_scan
+  // star[0][0].measure.Xccd = strtod (ptr, NULL);
+  // star[2][0].measure.Xccd = star[1][0].measure.Xccd = star[0][0].measure.Xccd;
+  // ptr = nextWISEfield (ptr); // jdate (julian date)
+
+  jd = 2455263.0; // NOTE : WISE prelim release does not contain per-detection time info. 
+  // the release is based on data taken in the period 14 January 2010 to 29 April 2010
+  star[0][0].measure.t = ohana_jd_to_sec (jd);
+  star[1][0].measure.t = star[0][0].measure.t;
+  star[2][0].measure.t = star[0][0].measure.t;
+  star[3][0].measure.t = star[0][0].measure.t;
+
+  // ptr = nextWISEfield (ptr); // j_psfchi
+  // star[0][0].measure.psfChisq = strtod (ptr, NULL);
+  // ptr = nextWISEfield (ptr); // h_psfchi
+  // star[1][0].measure.psfChisq = strtod (ptr, NULL);
+  // ptr = nextWISEfield (ptr); // k_psfchi
+  // star[2][0].measure.psfChisq = strtod (ptr, NULL);
+  // 
+  // ptr = nextWISEfield (ptr); // j_m_stdap
+  // star[0][0].measure.Map = strtod (ptr, NULL);
+  // ptr = nextWISEfield (ptr); // j_msig_stdap (skip?)
+  // 
+  // ptr = nextWISEfield (ptr); // h_m_stdap
+  // star[1][0].measure.Map = strtod (ptr, NULL);
+  // ptr = nextWISEfield (ptr); // h_msig_stdap (skip?)
+  // 
+  // ptr = nextWISEfield (ptr); // k_m_stdap
+  // star[2][0].measure.Map = strtod (ptr, NULL);
+  // ptr = nextWISEfield (ptr); // k_msig_stdap (skip?)
+  // 
+  // ptr = nextWISEfield (ptr); // dist_edge_ns (skip)
+  // ptr = nextWISEfield (ptr); // dist_edge_ew (skip)
+  // ptr = nextWISEfield (ptr); // dist_edge_flg (skip)
+  // 
+  // ptr = nextWISEfield (ptr); // dup_src (one flag for all filters)
+  // setWISE_dup_flag (star[0], ptr[0]);
+  // setWISE_dup_flag (star[1], ptr[0]);
+  // setWISE_dup_flag (star[2], ptr[0]);
+  // 
+  // ptr = nextWISEfield (ptr); // use_src (one flag for all filters)
+  // setWISE_use_flag (star[0], ptr[0]);
+  // setWISE_use_flag (star[1], ptr[0]);
+  // setWISE_use_flag (star[2], ptr[0]);
+
+  star[0][0].measure.photcode  = TM_J;
+  star[0][0].measure.detID   = 0;
+  star[0][0].measure.imageID = 0;
+
+  star[1][0].measure.photcode  = TM_H;
+  star[1][0].measure.detID   = 0;
+  star[1][0].measure.imageID = 0;
+
+  star[2][0].measure.photcode  = TM_K;
+  star[2][0].measure.detID   = 0;
+  star[2][0].measure.imageID = 0;
+
+  return TRUE;
+}
+
+/* return a pointer to the first char after the next field separator (|) */
+char *nextWISEfield (char *line) {
+
+  char *p, *q;
+
+  p = line;
+  q = strchr (p, '|');
+  if (q == NULL) return (NULL);
+  p = q + 1;
+  if (*p == 0) return (NULL);
+  return (p);
+}
+
+int setWISE_cc_flag (Stars *star, char qual) {
+
+  switch (qual) {
+    case 'p': star[0].measure.photFlags |= 0x00010000; break;
+    case 'P': star[0].measure.photFlags |= 0x00010000; break;
+    case 'h': star[0].measure.photFlags |= 0x00020000; break;
+    case 'H': star[0].measure.photFlags |= 0x00020000; break;
+    case 'd': star[0].measure.photFlags |= 0x00040000; break;
+    case 'D': star[0].measure.photFlags |= 0x00040000; break;
+    case 'o': star[0].measure.photFlags |= 0x00020000; break;
+    case 'O': star[0].measure.photFlags |= 0x00020000; break;
+    case '0': break;
+    default: 
+      fprintf (stderr, "error!\n");
+      exit (2);
+  }      
+  return (TRUE);
+}
+
+int setWISE_ph_qual (Stars *star, char qual) {
+
+  switch (qual) {
+    case 'A': star[0].measure.photFlags |= 0x00000001; break; // was: 0x0004
+    case 'B': star[0].measure.photFlags |= 0x00000002; break; // was: 0x0005
+    case 'C': star[0].measure.photFlags |= 0x00000004; break; // was: 0x0006
+    case 'U': star[0].measure.photFlags |= 0x00000040; break; // was: 0x0001
+    case 'X': star[0].measure.photFlags |= 0x00000080; break; // was: 0x0000
+    default: 
+      fprintf (stderr, "error!\n");
+      exit (2);
+  }      
+  return (TRUE);
+}
+
+int setWISE_rd_flag (Stars *star, char qual) {
+
+  switch (qual) {
+    case '0': star[0].measure.photFlags |= 0x00000100; break; // was: 0x0000 
+    case '1': star[0].measure.photFlags |= 0x00000200; break; // was: 0x0010 
+    case '2': star[0].measure.photFlags |= 0x00000400; break; // was: 0x0020 
+    case '3': star[0].measure.photFlags |= 0x00000800; break; // was: 0x0030 
+    case '4': star[0].measure.photFlags |= 0x00001000; break; // was: 0x0040 
+    case '6': star[0].measure.photFlags |= 0x00002000; break; // was: 0x0050 
+    case '9': star[0].measure.photFlags |= 0x00004000; break; // was: 0x0060 
+    default: 
+      fprintf (stderr, "error!\n");
+      exit (2);
+  }      
+  return (TRUE);
+}
+
+int setWISE_bl_flag (Stars *star, char qual) {
+
+  switch (qual) {
+    case '0': star[0].measure.photFlags &= ~0x00300000; break; // was: ~0x0008
+    case '1': star[0].measure.photFlags |=  0x00100000; break; // was: ~0x0008
+    default:  star[0].measure.photFlags |=  0x00200000; break; // was:  0x0008
+  }      
+  return (TRUE);
+}
+
+int setWISE_gal_flag (Stars *star, char qual) {
+
+  switch (qual) {
+    case '0': star[0].measure.photFlags &= ~0x00c00000; break; // was: ~0x0080 
+    case '1': star[0].measure.photFlags |=  0x00400000; break; // was: ~0x0080 
+    default:  star[0].measure.photFlags |=  0x00800000;	       // was:  0x0080
+      star[0].measure.extNsigma = 100.0;
+      break;
+  }      
+  return (TRUE);
+}
+
+int setWISE_mp_flag (Stars *star, char qual) {
+
+  switch (qual) {
+    case '0': star[0].measure.photFlags &= ~0x03000000; break; // was: ~0x0800
+    case '1': star[0].measure.photFlags |=  0x01000000; break; // was: ~0x0800
+    default:  star[0].measure.photFlags |=  0x02000000; break; // was:  0x0800
+  }      
+  return (TRUE);
+}
+
+int setWISE_dup_flag (Stars *star, char qual) {
+
+  switch (qual) {
+    case '0': star[0].measure.photFlags &= ~0x0c000000; break; // was: ~0x1000
+    case '1': star[0].measure.photFlags |=  0x04000000; break; // was: ~0x1000
+    default:  star[0].measure.photFlags |=  0x08000000; break; // was:  0x1000
+  }      
+  return (TRUE);
+}
+
+int setWISE_use_flag (Stars *star, char qual) {
+
+  switch (qual) {
+    case '0': star[0].measure.photFlags &= ~0x10000000; break; // was: ~0x2000
+    case '1': star[0].measure.photFlags |=  0x10000000; break; // was:  0x2000
+    default:  abort();
+  }      
+  return (TRUE);
+}
+
+// unused photFlags:
+// 0x0000.8000
+// 0x0004.0000
+// 0x0008.0000
+// 0x2000.0000
+// 0x4000.0000
+// 0x8000.0000