Changeset 38525

Timestamp:

Jun 24, 2015, 6:38:37 AM (11 years ago)

Author:

eugene

Message:

converting from Stars to Catalog

Location:

branches/eam_branches/ipp-20150616/Ohana/src/addstar

Files:

• Makefile (modified) (2 diffs)
• include/addstar.h (modified) (6 diffs)
• src/FilterStars.c (modified) (6 diffs)
• src/LoadData.c (modified) (5 diffs)
• src/LoadStars.c (modified) (5 diffs)
• src/ReadStarsFITS.c (modified) (12 diffs)
• src/UpdateImageIDs.c (modified) (2 diffs)
• src/addstar.c (modified) (10 diffs)
• src/find_matches_closest.c (modified) (14 diffs)

branches/eam_branches/ipp-20150616/Ohana/src/addstar/Makefile

@@ -76 +76 @@
 $(SRC)/MatchHeaders.$(ARCH).o \
 $(SRC)/LoadData.$(ARCH).o \
-$(SRC)/LoadDataSDSS.$(ARCH).o \
-$(SRC)/LoadDataUKIRT.$(ARCH).o \
-$(SRC)/LoadDataPMM.$(ARCH).o \
 $(SRC)/in_image.$(ARCH).o \
 $(SRC)/load_subpix.$(ARCH).o \
@@ -102 +99 @@
 $(SRC)/update_coords.$(ARCH).o \
 $(SRC)/psps_ids.$(ARCH).o
+
+## $(SRC)/LoadDataSDSS.$(ARCH).o \
+## $(SRC)/LoadDataUKIRT.$(ARCH).o \
+## $(SRC)/LoadDataPMM.$(ARCH).o \
+##
 
 # this is the client for parallel operations

branches/eam_branches/ipp-20150616/Ohana/src/addstar/include/addstar.h

@@ -216 +216 @@
 Image     *fakeimage              PROTO((char *rootname, off_t *Nimage, int photcode));
 
+int        find_matches_closest          PROTO((SkyRegion *region, Catalog *newcat, Catalog *catalog, AddstarClientOptions options));
+
 int        find_matches                  PROTO((SkyRegion *region, Stars *stars,  unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
-int        find_matches_closest          PROTO((SkyRegion *region, Stars *stars,  unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
+// int        find_matches_closest       PROTO((SkyRegion *region, Stars *stars,  unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
 int        find_matches_refstars         PROTO((SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
 int        find_matches_closest_refstars PROTO((SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
@@ -234 +236 @@
 Stars     *grefstars              PROTO((char *file, int photcode, unsigned int *Nstars));
 
-Stars     *LoadStars              PROTO((char *file, unsigned int *Nstars, Image **images, off_t *Nimages, AddstarClientOptions *options));
+Catalog   *LoadStars              PROTO((char *file, Image **images, off_t *Nimages, AddstarClientOptions *options));
 Header   **LoadHeaders            PROTO((FILE *f, int *mode, int *Nheader));
 HeaderSet *MatchHeaders           PROTO((off_t **extsize, off_t *nimage, int mode, Header **headers, int Nheaders));
 void       HeaderSetFree          PROTO((HeaderSet *headerSets, off_t NheaderSets));
-int        LoadData               PROTO((FILE *f, AddstarFile *file, Image **images, off_t *nvalid, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, int NheaderSets, AddstarClientOptions *options));
+Catalog   *LoadData               PROTO((FILE *f, AddstarFile *file, Image **images, off_t *nvalid, Header **headers, off_t *extsize, HeaderSet *headerSets, int NheaderSets, AddstarClientOptions *options));
 int        GetZeroPointExposure   PROTO((Header **headers, HeaderSet *headerSets, off_t Nimages));
 
@@ -257 +259 @@
 void       resort_catalog_old     PROTO((Catalog *catalog));
 
-Stars     *ReadStarsFITS          PROTO((FILE *f, Header *header, Header *in_theader, unsigned int *nstars));
+Catalog   *ReadStarsFITS          PROTO((FILE *f, Header *header, Header *in_theader));
 Stars     *ReadStarsTEXT          PROTO((FILE *f, unsigned int *nstars));
 Stars     *ReadStarsSDSS          PROTO((FILE *f, char *name, Header *header, Header *in_theader, Image *images, off_t *nimages, unsigned int *nstars));
 int        ReadImageHeader        PROTO((Header *header, Image *image, int photcode));
-Stars     *FilterStars            PROTO((Stars *instars, Image *image, unsigned int imageID, const AddstarClientOptions *options));
-Stars     *MergeStars             PROTO((Stars *stars, unsigned int *Nstars, Stars *instars, unsigned int Ninstars));
-
-int        ReadXradFITS           PROTO((FILE *f, Header *theader, Stars *stars, unsigned int Nstars));
+Catalog   *FilterStars            PROTO((Catalog *newcat, Image *image, unsigned int imageID, const AddstarClientOptions *options));
+// Stars     *MergeStars             PROTO((Stars *stars, unsigned int *Nstars, Stars *instars, unsigned int Ninstars));
+
+// int        ReadXradFITS           PROTO((FILE *f, Header *theader, Stars *stars, unsigned int Nstars));
 
 double     scat_subpix            PROTO((double x, double y));
@@ -310 +312 @@
 int args_skycells (int argc, char **argv);
 int ConfigInit_skycells (int *argc, char **argv);
-int UpdateImageIDs (Stars *stars, unsigned int Nstars, Image *images, off_t Nimages);
+int UpdateImageIDs (Catalog *catalog, Image *images, off_t Nimages);
 
 int CheckDuplicateImageIDs (Image *images, off_t Nimages);
@@ -338 +340 @@
 void saveMosaicCoords (Coords *input);
 
-
 Stars *ReadStarsUKIRT (FILE *f, char *name, Header *header, Image *images, off_t *nimages, unsigned int *nstars);
 int LoadDataUKIRT (FILE *f, char *file, Image **images, off_t *nimages, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, off_t NheaderSets);
@@ -344 +345 @@
 AddstarFile *LoadFilenames (int *nfile, char *filename, AddstarClientOptions *options);
 void AddstarFileFree (AddstarFile *file, int Nfile);
+
+Catalog *addstar_catalog_init (int Nstars);
 
 /** 

branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/FilterStars.c

@@ -10 +10 @@
 // the imageID supplied here is the sequence **within this set**
 // this value is updated based on the image table later (in UpdateImageIDs)
-Stars *FilterStars (Stars *instars, Image *image, unsigned int imageID, const AddstarClientOptions *options) {
+Catalog *FilterStars (Catalog *newcat, Image *image, unsigned int imageID, const AddstarClientOptions *options) {
 
   int j, N;
   float MTIME, dMs, dMx;
-  Stars *stars;
   float RMIN, RMAX, DMIN, DMAX;
 
@@ -26 +25 @@
 
   /* modify resulting star list */
-  ALLOCATE (stars, Stars, image[0].nstar);
-  for (N = j = 0; j < image[0].nstar; j++) {
+  Catalog *outcat = addstar_catalog_init (newcat->Nmeasure);
+  ALLOCATE (outcat->average, Average, newcat->Nmeasure);
+  
+  for (N = j = 0; j < newcat->Nmeasure; j++) {
 
-    if (instars[j].measure.photFlags & options->detectionFilter) continue;
+    if (newcat->measure[j].photFlags & options->detectionFilter) continue;
 
     /* allow for some dynamic filtering of star list */
-    if (SNLIMIT && instars[j].measure.dM > SNLIMIT) continue;
-    if (XMAX && (instars[j].measure.Xccd > XMAX)) continue;
-    if (XMIN && (instars[j].measure.Xccd < XMIN)) continue;
-    if (YMAX && (instars[j].measure.Yccd > YMAX)) continue;
-    if (YMIN && (instars[j].measure.Yccd < YMIN)) continue;
-    if (PHOTFLAG_EXCLUDE && (instars[j].measure.photFlags & PHOTFLAG_EXCLUDE)) continue;
+    if (SNLIMIT && newcat->measure[j].dM > SNLIMIT) continue;
+    if (XMAX && (newcat->measure[j].Xccd > XMAX)) continue;
+    if (XMIN && (newcat->measure[j].Xccd < XMIN)) continue;
+    if (YMAX && (newcat->measure[j].Yccd > YMAX)) continue;
+    if (YMIN && (newcat->measure[j].Yccd < YMIN)) continue;
+    if (PHOTFLAG_EXCLUDE && (newcat->measure[j].photFlags & PHOTFLAG_EXCLUDE)) continue;
 
-    stars[N] = instars[j];
+    dvo_average_init (&outcat->average[N]);
+    outcat->measure[N] = newcat->measure[j];
 
-    XY_to_RD (&stars[N].average.R, &stars[N].average.D, stars[N].measure.Xccd, stars[N].measure.Yccd, &image[0].coords);
-    stars[N].average.R = ohana_normalize_angle (stars[N].average.R);
-    stars[N].measure.R = stars[N].average.R;
-    stars[N].measure.D = stars[N].average.D;
+    outcat->average[N].Nmeasure = 1;
+    outcat->average[N].measureOffset = N;
 
-    stars[N].measure.photcode = image[0].photcode;
+    XY_to_RD (&outcat->average[N].R, &outcat->average[N].D, outcat->measure[N].Xccd, outcat->measure[N].Yccd, &image[0].coords);
+    outcat->average[N].R = ohana_normalize_angle (outcat->average[N].R);
+    outcat->measure[N].R = outcat->average[N].R;
+    outcat->measure[N].D = outcat->average[N].D;
+
+    outcat->measure[N].photcode = image[0].photcode;
 
     // determine the full coverage of this set of measurements
-    RMIN = MIN (RMIN, stars[N].average.R);
-    RMAX = MAX (RMAX, stars[N].average.R);
-    DMIN = MIN (DMIN, stars[N].average.D);
-    DMAX = MAX (DMAX, stars[N].average.D);
+    RMIN = MIN (RMIN, outcat->average[N].R);
+    RMAX = MAX (RMAX, outcat->average[N].R);
+    DMIN = MIN (DMIN, outcat->average[N].D);
+    DMAX = MAX (DMAX, outcat->average[N].D);
 
     /** additional quantities to supply to Stars based on the image data **/
 
     /* calculate accurate per-star airmass and azimuth */
-    stars[N].measure.airmass = airmass (image[0].secz, stars[N].average.R, stars[N].average.D, image[0].sidtime, image[0].latitude);
-    stars[N].measure.az      = azimuth (15.0*image[0].sidtime - stars[N].average.R, stars[N].average.D, image[0].latitude);
-    stars[N].measure.Mcal    = image[0].Mcal;
-    stars[N].measure.t       = image[0].tzero + 1e-4*stars[N].measure.Yccd*image[0].trate;  /* trate is in 0.1 msec / row */
-    stars[N].measure.dt      = MTIME;
+    outcat->measure[N].airmass = airmass (image[0].secz, outcat->average[N].R, outcat->average[N].D, image[0].sidtime, image[0].latitude);
+    outcat->measure[N].az      = azimuth (15.0*image[0].sidtime - outcat->average[N].R, outcat->average[N].D, image[0].latitude);
+    outcat->measure[N].Mcal    = image[0].Mcal;
+    outcat->measure[N].t       = image[0].tzero + 1e-4*outcat->measure[N].Yccd*image[0].trate;  /* trate is in 0.1 msec / row */
+    outcat->measure[N].dt      = MTIME;
 
     // watch out for any strange values:
-    if ((stars[N].measure.M > 25.0) && (stars[N].measure.M < 32.0)) {
+    if ((outcat->measure[N].M > 25.0) && (outcat->measure[N].M < 32.0)) {
       fprintf (stderr, "*");
     }
@@ -73 +78 @@
     dMx = 0.0;
     if (SUBPIX) {
-      dMs =  get_subpix (stars[N].measure.Xccd, stars[N].measure.Yccd);
-      dMx = scat_subpix (stars[N].measure.Xccd, stars[N].measure.Yccd);
-      if (!isnan(stars[N].measure.dM)) {
-        stars[N].measure.dM = hypot (stars[N].measure.dM, dMx);
+      dMs =  get_subpix (outcat->measure[N].Xccd, outcat->measure[N].Yccd);
+      dMx = scat_subpix (outcat->measure[N].Xccd, outcat->measure[N].Yccd);
+      if (!isnan(outcat->measure[N].dM)) {
+        outcat->measure[N].dM = hypot (outcat->measure[N].dM, dMx);
       }
     }
 
-    if (!isnan(stars[N].measure.M)) {
-      stars[N].measure.M   += MTIME - dMs;
+    if (!isnan(outcat->measure[N].M)) {
+      outcat->measure[N].M   += MTIME - dMs;
     }
-    if (!isnan(stars[N].measure.Map)) {
-      stars[N].measure.Map += MTIME - dMs;
+    if (!isnan(outcat->measure[N].Map)) {
+      outcat->measure[N].Map += MTIME - dMs;
     }
-    if (!isnan(stars[N].measure.Mkron)) {
-      stars[N].measure.Mkron += MTIME - dMs;
+    if (!isnan(outcat->measure[N].Mkron)) {
+      outcat->measure[N].Mkron += MTIME - dMs;
     }
-    if (!isnan(stars[N].measure.FluxPSF)) {
-      stars[N].measure.FluxPSF /= image[0].exptime;
+    if (!isnan(outcat->measure[N].FluxPSF)) {
+      outcat->measure[N].FluxPSF /= image[0].exptime;
     }
-    if (!isnan(stars[N].measure.dFluxPSF)) {
-      stars[N].measure.dFluxPSF /= image[0].exptime;
+    if (!isnan(outcat->measure[N].dFluxPSF)) {
+      outcat->measure[N].dFluxPSF /= image[0].exptime;
     }
-    if (!isnan(stars[N].measure.FluxKron)) {
-      stars[N].measure.FluxKron /= image[0].exptime;
+    if (!isnan(outcat->measure[N].FluxKron)) {
+      outcat->measure[N].FluxKron /= image[0].exptime;
     }
-    if (!isnan(stars[N].measure.dFluxKron)) {
-      stars[N].measure.dFluxKron /= image[0].exptime;
+    if (!isnan(outcat->measure[N].dFluxKron)) {
+      outcat->measure[N].dFluxKron /= image[0].exptime;
     }
-    if (!isnan(stars[N].measure.FluxAp)) {
-      stars[N].measure.FluxAp /= image[0].exptime;
+    if (!isnan(outcat->measure[N].FluxAp)) {
+      outcat->measure[N].FluxAp /= image[0].exptime;
     }
-    if (!isnan(stars[N].measure.dFluxAp)) {
-      stars[N].measure.dFluxAp /= image[0].exptime;
+    if (!isnan(outcat->measure[N].dFluxAp)) {
+      outcat->measure[N].dFluxAp /= image[0].exptime;
     }
-    if (stars[N].lensing) {
-      if (!isnan(stars[N].lensing-> F_ApR5)) stars[N].lensing-> F_ApR5 /= image[0].exptime;
-      if (!isnan(stars[N].lensing->dF_ApR5)) stars[N].lensing->dF_ApR5 /= image[0].exptime;
-      if (!isnan(stars[N].lensing->sF_ApR5)) stars[N].lensing->sF_ApR5 /= image[0].exptime;
-      if (!isnan(stars[N].lensing->fF_ApR5)) stars[N].lensing->fF_ApR5 /= image[0].exptime;
-
-      if (!isnan(stars[N].lensing-> F_ApR6)) stars[N].lensing-> F_ApR6 /= image[0].exptime;
-      if (!isnan(stars[N].lensing->dF_ApR6)) stars[N].lensing->dF_ApR6 /= image[0].exptime;
-      if (!isnan(stars[N].lensing->sF_ApR6)) stars[N].lensing->sF_ApR6 /= image[0].exptime;
-      if (!isnan(stars[N].lensing->fF_ApR6)) stars[N].lensing->fF_ApR6 /= image[0].exptime;
-
-      if (!isnan(stars[N].lensing-> F_ApR7)) stars[N].lensing-> F_ApR7 /= image[0].exptime;
-      if (!isnan(stars[N].lensing->dF_ApR7)) stars[N].lensing->dF_ApR7 /= image[0].exptime;
-      if (!isnan(stars[N].lensing->sF_ApR7)) stars[N].lensing->sF_ApR7 /= image[0].exptime;
-      if (!isnan(stars[N].lensing->fF_ApR7)) stars[N].lensing->fF_ApR7 /= image[0].exptime;
+    if (outcat->lensing) {
+      if (!isnan(outcat->lensing[N]. F_ApR5)) outcat->lensing[N]. F_ApR5 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N].dF_ApR5)) outcat->lensing[N].dF_ApR5 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N].sF_ApR5)) outcat->lensing[N].sF_ApR5 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N].fF_ApR5)) outcat->lensing[N].fF_ApR5 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N]. F_ApR6)) outcat->lensing[N]. F_ApR6 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N].dF_ApR6)) outcat->lensing[N].dF_ApR6 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N].sF_ApR6)) outcat->lensing[N].sF_ApR6 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N].fF_ApR6)) outcat->lensing[N].fF_ApR6 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N]. F_ApR7)) outcat->lensing[N]. F_ApR7 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N].dF_ApR7)) outcat->lensing[N].dF_ApR7 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N].sF_ApR7)) outcat->lensing[N].sF_ApR7 /= image[0].exptime;
+      if (!isnan(outcat->lensing[N].fF_ApR7)) outcat->lensing[N].fF_ApR7 /= image[0].exptime;
     }
     
     // the external ID is supplied, but do we trust it?
     if (!EXTERNAL_ID) {
-      stars[N].measure.detID = N; // sequence number within image
+      outcat->measure[N].detID = N; // sequence number within image
     }
 
@@ -135 +138 @@
 
       if (isStack) {
-        stars[N].measure.extID = CreatePSPSStackDetectionID(image[0].sourceID, image[0].externID, stars[N].measure.detID);
+        outcat->measure[N].extID = CreatePSPSStackDetectionID(image[0].sourceID, image[0].externID, outcat->measure[N].detID);
       } else {
-        stars[N].measure.extID = CreatePSPSDetectionID(mjd, image[0].ccdnum, stars[N].measure.detID);
+        outcat->measure[N].extID = CreatePSPSDetectionID(mjd, image[0].ccdnum, outcat->measure[N].detID);
       }
     } else {
-      stars[N].measure.extID = 0;
+      outcat->measure[N].extID = 0;
     }
 
-    stars[N].measure.imageID = imageID; // this value is updated in UpdateImageIDs
+    outcat->measure[N].imageID = imageID; // this value is updated in UpdateImageIDs
 
     // add imageID to lensing entry, if it exists
-    if (stars[N].lensing) {
-      stars[N].lensing->imageID = imageID;
+    if (outcat->lensing) {
+      outcat->lensing[N].imageID = imageID;
     }
 
@@ -156 +159 @@
   
   image[0].nstar = N;
-  REALLOCATE (stars, Stars, image[0].nstar);
-  free (instars);
 
-  if (VERBOSE) fprintf (stderr, "read %d stars from target file\n", image[0].nstar);
+  REALLOCATE (outcat->measure, Measure, N);
+  REALLOCATE (outcat->average, Average, N);
+  if (outcat->lensing) {
+    REALLOCATE (outcat->average, Average, N);
+  }
+  dvo_catalog_free (newcat);
+  free (newcat);
+
+  outcat->Naverage = N;
+  outcat->Nmeasure = N;
+  outcat->Nlensing = outcat->lensing ? N : 0;
+
+  if (VERBOSE) fprintf (stderr, "read %d stars from target file\n", N);
   if (VERBOSE) fprintf (stderr, "stars cover region %f,%f - %f,%f\n", RMIN, DMIN, RMAX, DMAX);
-  return (stars);
+
+  return (outcat);
 }
 
+# if (0)
 Stars *MergeStars (Stars *stars, unsigned int *Nstars, Stars *instars, unsigned int Ninstars) {
 
@@ -181 +196 @@
   return (stars);
 }
+# endif

branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/LoadData.c

@@ -1 +1 @@
 # include "addstar.h"
 
-// XXX this function is somewhat specific to the elixir format output files 
-// it is capable of distinguishing several format versions defined for elixir/psphot
-
+// load photometry data from psphot, sextractor, and a few other formats
 // examine the header sets and set the Image entries for the the valid images
-Catalog *LoadData (FILE *f, AddstarFile *file, Image **images, off_t *nvalid, unsigned int *Ncatalog, Header **headers, off_t *extsize, HeaderSet *headerSets, int Nimages, AddstarClientOptions *options) {
+Catalog *LoadData (FILE *f, AddstarFile *file, Image **images, off_t *nvalid, Header **headers, off_t *extsize, HeaderSet *headerSets, int Nimages, AddstarClientOptions *options) {
 
   off_t Nskip, Nvalid, NVALID;
@@ -11 +9 @@
   uint32_t parentID = UINT32_MAX;
 
-  int ncatalog = 0;
-  int NCATALOG = Nimages;
   Catalog *catalog = NULL;
-  ALLOCATE (catalog, Catalog, NCATALOG);
+  // ALLOCATE (catalog, Catalog, 1);
+  // dvo_catalog_init (catalog, TRUE);
 
   if (images[0] == NULL) {
@@ -80 +77 @@
     fseeko (f, Nskip, SEEK_SET); 
          
-    status = ReadStarsFITS (f, headers[Nhead], headers[Ndata], &images[0][Nvalid].nstar, &catalog[ncatalog]);
-    if (!status) {
-      // XXX need to free the data here or in ReadStarsFITS on error
+    // ReadStarsFITS populates catalog->measure,Nmeasure 
+    Catalog *newcat = ReadStarsFITS (f, headers[Nhead], headers[Ndata]);
+    if (!newcat) {
+      dvo_catalog_free (newcat);
       continue;
     }
+    images[0][Nvalid].nstar = newcat->Nmeasure;
 
+# if (0)
     // XRAD : if we want to read the xrad table, skip to that table here:
     if (headerSets[i].extnum_xrad != -1) {
@@ -99 +99 @@
       }
     }
+# endif
 
-    FilterStars (&catalog[ncatalog], &images[0][Nvalid], Nvalid, options);
+    // replace full input catalog newcat with subset version
+    newcat = FilterStars (newcat, &images[0][Nvalid], Nvalid, options);
+    catalog = newcat;
 
-    // XXX merge catalogs here : I should only have one output catalog!
-
-    // XXX need to merge here?
-    // *stars = MergeStars (*stars, Nstars, inStars, images[0][Nvalid].nstar);
-    // FREE (inStars);
+    // XXX I need to use find_matches_closest here, but for testing:
+    // find_matches_closest (region, catalog, newcat, options);
+    // dvo_catalog_free (newcat);
+    // free (newcat);
 
     Nvalid++;
@@ -113 +115 @@
 
   if (isfinite(OFFSET_ZPT)) {
-    for (i = 0; i < *Nstars; i++) {
-      stars[0][i].measure.M   += OFFSET_ZPT;
-      stars[0][i].measure.Map += OFFSET_ZPT;
+    for (i = 0; i < catalog->Nmeasure; i++) {
+      catalog->measure[i].M   += OFFSET_ZPT;
+      catalog->measure[i].Map += OFFSET_ZPT;
     }
   }
 
   *nvalid = Nvalid;
-  return (TRUE);
+  return catalog;
 }
 

branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/LoadStars.c

@@ -1 +1 @@
 # include "addstar.h"
 
-Catalog *LoadStars (char *filename, unsigned int *Ncatalog, Image **images, off_t *Nimages, AddstarClientOptions *options) {
+Catalog *LoadStars (char *filename, Image **images, off_t *Nimages, AddstarClientOptions *options) {
 
   off_t *extsize;
@@ -9 +9 @@
 
   *Nimages = 0;
-  *Ncatalog = 0;
   *images = NULL;
+
   Catalog *catalog = NULL;
+  // ALLOCATE (catalog, Catalog, 1);
+  // dvo_catalog_init (catalog, TRUE);
 
   for (i = 0; i < Nfile; i++) {
@@ -22 +24 @@
     // load PMM data if specified (these are not stored as FITS-tables)
     if (PMM_CCD_TABLE != NULL) {
-      *Ncatalog = 1;
       // XXX catalog = LoadDataPMM (f, file[i].imagename, images, Nimages);
       continue;
@@ -58 +59 @@
     // if these are SDSS data, load with SDSS-specific wrapper
     if (headerSets[0].exttype && !strcmp (headerSets[0].exttype, "SDSS_OBJ")) {
-      *Ncatalog = 1;
       // XXX catalog = LoadDataSDSS (f, file[i].imagename, images, Nimages, headers, extsize, headerSets, NheaderSets);
       goto next_file;
@@ -65 +65 @@
     // if these are SDSS data, load with SDSS-specific wrapper
     if (headerSets[0].exttype && !strcmp (headerSets[0].exttype, "UKIRT_OBJ")) {
-      *Ncatalog = 1;
       // XXX catalog = LoadDataUKIRT (f, file[i].imagename, images, Nimages, headers, extsize, headerSets, NheaderSets);
       goto next_file;
     }
 
-    catalog = LoadData (f, &file[i], images, Nimages, Ncatalog, headers, extsize, headerSets, NheaderSets, options);
+    Catalog *newcat = LoadData (f, &file[i], images, Nimages, headers, extsize, headerSets, NheaderSets, options);
+    catalog = newcat;
+
+    // XXX I need to use find_matches_closest here, but for testing:
+    // find_matches_closest (region, catalog, newcat, options);
+    // dvo_catalog_free (newcat);
+    // free (newcat);
 
   next_file:

branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/ReadStarsFITS.c

@@ -4 +4 @@
 // (excluding SDSS data and reference database info, such as 2MASS)
 // NOTE: these must also be listed in MatchHeaders.c (line ~ 62)
-Stars     *Convert_SMPDATA           PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_DEV_0         PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_DEV_1         PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_V1            PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_V1_Alt        PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_V2            PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_V3            PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_V4            PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_V5            PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_V5_R0_Lensing PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_V5_R1_Lensing PROTO((FTable *table, unsigned int *nstars));
-Stars     *Convert_PS1_V5_R2_Lensing 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));
-Stars     *Convert_PS1_DV5           PROTO((FTable *table, unsigned int *nstars));
+Catalog *Convert_SMPDATA           PROTO((FTable *table));
+Catalog *Convert_PS1_DEV_0         PROTO((FTable *table));
+Catalog *Convert_PS1_DEV_1         PROTO((FTable *table));
+Catalog *Convert_PS1_V1            PROTO((FTable *table));
+Catalog *Convert_PS1_V1_Alt        PROTO((FTable *table));
+Catalog *Convert_PS1_V2            PROTO((FTable *table));
+Catalog *Convert_PS1_V3            PROTO((FTable *table));
+Catalog *Convert_PS1_V4            PROTO((FTable *table));
+Catalog *Convert_PS1_V5            PROTO((FTable *table));
+Catalog *Convert_PS1_V5_R0_Lensing PROTO((FTable *table));
+Catalog *Convert_PS1_V5_R1_Lensing PROTO((FTable *table));
+Catalog *Convert_PS1_V5_R2_Lensing PROTO((FTable *table));
+Catalog *Convert_PS1_SV1           PROTO((FTable *table));
+Catalog *Convert_PS1_SV1_Alt       PROTO((FTable *table));
+Catalog *Convert_PS1_SV2           PROTO((FTable *table));
+Catalog *Convert_PS1_SV3           PROTO((FTable *table));
+Catalog *Convert_PS1_SV4           PROTO((FTable *table));
+Catalog *Convert_PS1_DV3           PROTO((FTable *table));
+Catalog *Convert_PS1_DV4           PROTO((FTable *table));
+Catalog *Convert_PS1_DV5           PROTO((FTable *table));
+
+Catalog *addstar_catalog_init (int Nstars) {
+  Catalog *catalog = NULL;
+  ALLOCATE (catalog, Catalog, 1);
+  dvo_catalog_init (catalog, TRUE);
+
+  ALLOCATE (catalog->measure, Measure, Nstars);
+
+  int i;
+  for (i = 0; i < Nstars; i++) {
+    dvo_measure_init (&catalog->measure[i]);
+  }
+  catalog->Nmeasure = Nstars;
+  return catalog;
+}
 
 // given a file with the pointer at the start of the table block and the 
 // corresponding image header, load the stars from the table
-Stars *ReadStarsFITS (FILE *f, Header *header, Header *in_theader, unsigned int *nstars) {
+Catalog *ReadStarsFITS (FILE *f, Header *header, Header *in_theader) {
 
   off_t Nskip;
-  unsigned int Nstars;
   char type[80];
   Header theader;
   FTable table;
-  Stars *stars; // Stars contains Average and Measure
   
   if (in_theader == NULL) {
@@ -55 +68 @@
   }
 
-  stars = NULL;
+  Catalog *catalog = NULL;
+# if (0)
   if (!strcmp (type, "SMPDATA")) {
     stars = Convert_SMPDATA (&table, &Nstars);
@@ -81 +95 @@
     stars = Convert_PS1_V4 (&table, &Nstars);
   }
+# endif
   if (!strcmp (type, "PS1_V5")) {
     switch (table.header[0].Naxis[0]) {
       case 232:
-        stars = Convert_PS1_V5 (&table, &Nstars);
+        catalog = Convert_PS1_V5 (&table);
         break;
+# if (0)
       case 312:
         stars = Convert_PS1_V5_R0_Lensing (&table, &Nstars);
@@ -95 +111 @@
         stars = Convert_PS1_V5_R2_Lensing (&table, &Nstars);
         break;
+# endif
       default:
         fprintf (stderr, "invalid PS1_V5 table size %d\n", (int) table.header[0].Naxis[0]);
@@ -100 +117 @@
     }
   }
+# if (0)
   if (!strcmp (type, "PS1_SV1")) {
     stars = Convert_PS1_SV1 (&table, &Nstars);
@@ -121 +139 @@
     stars = Convert_PS1_DV5 (&table, &Nstars);
   }
-  if (stars == NULL) {
+# endif
+  if (catalog == NULL) {
     fprintf (stderr, "invalid table type %s\n", type);
     return (NULL);
@@ -127 +146 @@
 
   gfits_free_table (&table);
-
-  // Nstars is not necessarily == *nstars (The former is the number of detections, the
-  // latter are the 'good' detections reported by the photometry system.
-  *nstars = Nstars;
-
-  return stars;
+  return catalog;
 }
 
@@ -151 +165 @@
   return dFlux;
 }
+
+# if (0)
 
 Stars *Convert_SMPDATA (FTable *table, unsigned int *nstars) {
@@ -784 +800 @@
 }
 
-Stars *Convert_PS1_V5 (FTable *table, unsigned int *nstars) {
+# endif
+
+Catalog *Convert_PS1_V5 (FTable *table) {
 
   off_t Nstars; 
   unsigned int i;
   double ZeroPt;
-  Stars *stars;
   CMF_PS1_V5 *ps1data;
 
@@ -799 +816 @@
   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;
+  Catalog *catalog = addstar_catalog_init (Nstars);
+
+  for (i = 0; i < Nstars; i++) {
+    catalog->measure[i].Xccd       = ps1data[i].X;
+    catalog->measure[i].Yccd       = ps1data[i].Y;
+    catalog->measure[i].dXccd      = ToShortPixels(ps1data[i].dX);
+    catalog->measure[i].dYccd      = ToShortPixels(ps1data[i].dY);
+
+    catalog->measure[i].posangle   = ToShortDegrees(ps1data[i].posangle);
+    catalog->measure[i].pltscale   = ps1data[i].pltscale;
 
     if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
-      stars[i].measure.M      = NAN;
+      catalog->measure[i].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;
+      catalog->measure[i].M      = ps1data[i].M + ZeroPt;
+    }
+    catalog->measure[i].dM         = ps1data[i].dM;
+    catalog->measure[i].dMcal      = ps1data[i].dMcal;
+    catalog->measure[i].Map        = ps1data[i].Map + ZeroPt;
+    catalog->measure[i].dMap       = (ps1data[i].apFlux > 0.0) ? fabs(ps1data[i].apFluxErr / ps1data[i].apFlux) : NAN;
+                        
+    catalog->measure[i].Mkron      = (ps1data[i].kronFlux > 0.0) ? -2.5*log10(ps1data[i].kronFlux) + ZeroPt : NAN;
+    catalog->measure[i].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; 
+    catalog->measure[i].FluxPSF    = GetFluxFromFluxOrMag (ps1data[i].Flux, ps1data[i].M); 
+    catalog->measure[i].dFluxPSF   = GetFluxErrFromFluxOrMag (ps1data[i].dFlux, catalog->measure[i].FluxPSF, ps1data[i].dM);
+    catalog->measure[i].FluxKron   = ps1data[i].kronFlux;
+    catalog->measure[i].dFluxKron  = ps1data[i].kronFluxErr;
+    catalog->measure[i].FluxAp     = GetFluxFromFluxOrMag (ps1data[i].apFlux, ps1data[i].Map); 
+    catalog->measure[i].dFluxAp    = GetFluxErrFromFluxOrMag (ps1data[i].apFluxErr, catalog->measure[i].FluxAp, catalog->measure[i].dMap);
+
+    catalog->measure[i].Sky        = ps1data[i].sky;
+    catalog->measure[i].dSky       = ps1data[i].dSky;
+                        
+    catalog->measure[i].psfChisq   = ps1data[i].psfChisq;
+    catalog->measure[i].psfQF      = ps1data[i].psfQF;
+    catalog->measure[i].psfQFperf  = ps1data[i].psfQFperf;
+
+    catalog->measure[i].psfNdof    = ps1data[i].psfNdof;
+    catalog->measure[i].psfNpix    = ps1data[i].psfNpix;
+    catalog->measure[i].extNsigma  = ps1data[i].extNsigma;
+
+    catalog->measure[i].FWx        = ToShortPixels(ps1data[i].fx);
+    catalog->measure[i].FWy        = ToShortPixels(ps1data[i].fy);
+    catalog->measure[i].theta      = ToShortDegrees(ps1data[i].df);
+
+    catalog->measure[i].Mxx        = ToShortPixels(ps1data[i].Mxx);
+    catalog->measure[i].Mxy        = ToShortPixels(ps1data[i].Mxy);
+    catalog->measure[i].Myy        = ToShortPixels(ps1data[i].Myy);
+                        
+    catalog->measure[i].photFlags  = ps1data[i].flags;
+    catalog->measure[i].photFlags2 = ps1data[i].flags2;
+
+    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
+    catalog->measure[i].detID      = ps1data[i].detID; 
 
     // the Average fields and the following Measure fields are set in FilterStars after
@@ -865 +882 @@
     // the following fields are currently not being set anywhere: t_msec
   }    
-  *nstars = Nstars;
-  return (stars);
-}
+  return (catalog);
+}
+
+# if (0)
 
 Stars *Convert_PS1_V5_R0_Lensing (FTable *table, unsigned int *nstars) {
@@ -1915 +1933 @@
   return (stars);
 }
-
-
-
+# endif
+
+

branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/UpdateImageIDs.c

@@ -1 +1 @@
 # include "addstar.h"
 
-int UpdateImageIDs (Stars *stars, unsigned int Nstars, Image *images, off_t Nimages) {
+int UpdateImageIDs (Catalog *catalog, Image *images, off_t Nimages) {
 
   int i, status, isEmpty;
@@ -54 +54 @@
   }
 
-  for (i = 0; i < Nstars; i++) {
-    stars[i].measure.imageID += imageID;
-    if (stars[i].lensing) {
-      stars[i].lensing->imageID += imageID;
+  off_t j, m;
+  for (i = 0; i < catalog->Naverage; i++) {
+    m = catalog->average[i].measureOffset;
+    for (j = 0; j < catalog->average[i].Nmeasure; j++, m++) {
+      catalog->measure[m].imageID += imageID;
+    }
+    m = catalog->average[i].lensingOffset;
+    for (j = 0; j < catalog->average[i].Nlensing; j++, m++) {
+      catalog->lensing[m].imageID += imageID;
     }
   }

branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/addstar.c

@@ -6 +6 @@
 int main (int argc, char **argv) {
 
-  unsigned int Nstars, Nsubset;
   int Nmatch, status, loadObjects;
   off_t i, Nimages;
@@ -46 +45 @@
   MARKTIME ("init and config: %f sec\n", dtime); RESETTIME; 
 
-  Stars *stars = NULL;
+  Catalog *newcat = NULL;
   Image *images = NULL;
 
@@ -52 +51 @@
   switch (options.mode) {
     case ADDSTAR_MODE_IMAGE:
-      stars = LoadStars (argv[1], &Nstars, &images, &Nimages, &options);
+      newcat = LoadStars (argv[1], &images, &Nimages, &options);
       MARKTIME ("load smf: %f sec\n", dtime); RESETTIME; 
 
       // set and update the imageID sequence
-      UpdateImageIDs (stars, Nstars, images, Nimages);
-
-      if ((DUMP != NULL) && !strcmp (DUMP, "rawstars")) dump_rawstars (stars, Nstars);
+      UpdateImageIDs (newcat, images, Nimages);
+
+      // if ((DUMP != NULL) && !strcmp (DUMP, "rawstars")) dump_rawstars (stars, Nstars);
       for (i = 0; i < Nimages; i++) {
         newlist = SkyListByImage (sky, -1, &images[i]);
@@ -67 +66 @@
       ImageOptions (&options, images, Nimages);
       break;
+# if (0)
     case ADDSTAR_MODE_REFLIST:
       stars = grefstars (argv[1], options.photcode, &Nstars);
@@ -80 +80 @@
       skylist[0].ownElements = FALSE;
       break;
+# endif
 
     default:
@@ -145 +146 @@
     switch (options.mode) {
       case ADDSTAR_MODE_IMAGE:
-        Nsubset = Nstars;
+        // Nsubset = Nstars;
         if (options.closest) {
-          Nmatch += find_matches_closest (skylist[0].regions[i], stars, Nstars, &catalog, options);
+          Nmatch += find_matches_closest (skylist[0].regions[i], newcat, &catalog, options);
         } else {
-          Nmatch += find_matches (skylist[0].regions[i], stars, Nstars, &catalog, options);
+          // XXX Nmatch += find_matches (skylist[0].regions[i], stars, Nstars, &catalog, options);
         }
         break;
+# if (0)
       case ADDSTAR_MODE_REFCAT:
         stars = greference (argv[1], skylist[0].regions[i], options.photcode, &Nstars);
@@ -164 +166 @@
         break;
       }
+# endif
+      default:
+        abort();
     }
     if (VERBOSE) MARKTIME ("match stars: %f sec\n", dtime); RESETTIME; 
@@ -173 +178 @@
 
     // write out catalog, if appropriate
-    if (Nsubset && !options.only_images) {
+    if (newcat->Naverage && !options.only_images) {
       SetProtect (TRUE);
       if (options.update) {
@@ -187 +192 @@
     if (VERBOSE) MARKTIME ("save cpt: %f sec\n", dtime); RESETTIME; 
 
-    if (options.mode == ADDSTAR_MODE_REFCAT) free (stars);
+    if (options.mode == ADDSTAR_MODE_REFCAT) dvo_catalog_free (newcat);
   }
   SkyListFree (skylist);
 
   if (options.mode != ADDSTAR_MODE_REFCAT) {
-    FREE (stars);
+    dvo_catalog_free (newcat);
+    free (newcat);
   }
 
@@ -229 +235 @@
   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);
+  fprintf (stderr, "SUCCESS: elapsed time %9.4f sec for "OFF_T_FMT" stars (%5d matches), "OFF_T_FMT" average, "OFF_T_FMT" measure, "OFF_T_FMT" lensing\n", dtime, newcat->Naverage, Nmatch,  Naverage,  Nmeasure, Nlensing);
 
   // XXX test

branches/eam_branches/ipp-20150616/Ohana/src/addstar/src/find_matches_closest.c

@@ -1 +1 @@
 # include "addstar.h"
 
-int find_matches_closest (SkyRegion *region, Stars *stars, unsigned int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
+int find_matches_closest (SkyRegion *region, Catalog *newcat, Catalog *catalog, AddstarClientOptions options) {
   
   off_t i, j, n, N, J, Jmin, status, Nstars;
@@ -13 +13 @@
   Coords tcoords;
 
+  // XXX this probably is no longer needed (absorbed by catalog->average[j].Nmeasure
   if (NSTAR_GROUP <= 0) {
       fprintf (stderr, "ERROR: NSTAR_GROUP NOT SET!\n");
@@ -26 +27 @@
   Nsec     = GetPhotcodeNsec (options.photcode);
 
-  /** allocate local arrays (stars) **/
-  ALLOCATE (X1, double, NstarsIn);
-  ALLOCATE (Y1, double, NstarsIn);
-  ALLOCATE (N1, off_t,  NstarsIn);
+  /** allocate local arrays (newcat) **/
+  ALLOCATE (X1, double, newcat->Naverage);
+  ALLOCATE (Y1, double, newcat->Naverage);
+  ALLOCATE (N1, off_t,  newcat->Naverage);
+
+  if (!newcat->found_t) {
+    ALLOCATE (newcat->found_t, off_t, newcat->Naverage);
+    for (i = 0; i < newcat->Naverage; i++) {
+      newcat->found_t[i] = -1;
+    }
+  }
 
   /** allocate local arrays (catalog) **/
@@ -64 +72 @@
   /* build spatial index (RA sort) referencing input array sequence */
   Nstars = 0;
-  for (i = 0; i < NstarsIn; i++) {
-    status = RD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i].average.R, stars[i].average.D, &tcoords);
+  for (i = 0; i < newcat->Naverage; i++) {
+    status = RD_to_XY (&X1[Nstars], &Y1[Nstars], newcat->average[i].R, newcat->average[i].D, &tcoords);
     if (!status) continue;
     N1[Nstars] = i;
@@ -129 +137 @@
     }
 
-    if (stars[N1[i]].found != -1) {
+    // XXX check that this is allocated
+    if (newcat->found_t[N1[i]] != -1) {
         /* this star has already been assigned to an object in this or another catalog */
         i++;
@@ -186 +195 @@
 
     // set the new measurements
-    catalog[0].measure[Nmeas]          = stars[N].measure;
+    catalog[0].measure[Nmeas]          = newcat->measure[N];
 
     // measure now carries R,D (not dR,dD) 
@@ -213 +222 @@
             fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n", 
                      catalog[0].average[n].R, catalog[0].average[n].D, 
-                     stars[N].average.R, stars[N].average.D,
+                     newcat->average[N].R, newcat->average[N].D,
                      X1[i], X2[Jmin], 
                      Y1[i], Y2[Jmin]);
@@ -221 +230 @@
 
     // add the lensing values if they exist
-    if (stars[N].lensing) {
+    if (newcat->lensing) {
       add_lens_link (&catalog[0].average[n], next_lens, Nlens, NLENS); // ?
-      catalog[0].lensing[Nlens] = stars[N].lensing[0];
+      catalog[0].lensing[Nlens] = newcat->lensing[N];
       
       catalog[0].lensing[Nlens].averef = n;
@@ -251 +260 @@
     /* Nm is updated, but not written out in -update mode (for existing entries)
        Nm is recalculated in build_meas_links if loaded table is not sorted */
-    stars[N].found = Nmeas;
+    newcat->found_t[N] = Nmeas;
     catalog[0].found_t[n] = Nmeas;
     catalog[0].average[n].Nmeasure ++;
@@ -278 +287 @@
     }
 
-    if (stars[i].found != -1) continue;
-    if (!IN_REGION (stars[i].average.R, stars[i].average.D)) continue;
+    if (newcat->found_t[i] != -1) continue;
+    if (!IN_REGION (newcat->average[i].R, newcat->average[i].D)) continue;
 
     dvo_average_init (&catalog[0].average[Nave]);
-    catalog[0].average[Nave].R             = stars[i].average.R;
-    catalog[0].average[Nave].D             = stars[i].average.D;
+    catalog[0].average[Nave].R             = newcat->average[i].R;
+    catalog[0].average[Nave].D             = newcat->average[i].D;
 
     catalog[0].average[Nave].Nmeasure      = NSTAR_GROUP;
@@ -303 +312 @@
       // supply the measurments from this detection
       dvo_measure_init (&catalog[0].measure[Nmeas]);
-      catalog[0].measure[Nmeas]           = stars[i + j].measure;
+      catalog[0].measure[Nmeas] = newcat->measure[i + j];
 
       // the following measure elements cannot be set until here:
@@ -319 +328 @@
       /* next[Nmeas] should always be -1 in this context (it is always the only
          measurement for the star) */
-      stars[i+j].found = Nmeas;
+      newcat->found_t[i+j] = Nmeas;
       next_meas[Nmeas] = -1;  // inital value here update below
       Nmeas ++;
@@ -328 +337 @@
 
     // if we have lensing data, insert that as well
-    if (stars[i].lensing) {
+    if (newcat->lensing) {
       catalog[0].average[Nave].Nlensing = NSTAR_GROUP;
       catalog[0].average[Nave].lensingOffset = Nlens;
       for (j = 0; j < NSTAR_GROUP; j++) {
         // add the lensing values if they exist
-        if (stars[i + j].lensing) {
+        if (newcat->lensing) {
           dvo_lensing_init (&catalog[0].lensing[Nlens]);
-          catalog[0].lensing[Nlens] = stars[i + j].lensing[0];
+          catalog[0].lensing[Nlens] = newcat->lensing[i + j];
           
           catalog[0].lensing[Nlens].averef = Nave;
@@ -365 +374 @@
 
   /* note stars which have been found in this catalog */
-  for (i = 0; i < NstarsIn; i++) {
-    if (stars[i].found > -1) {
-      stars[i].found = -2;
+  for (i = 0; i < newcat->Naverage; i++) {
+    if (newcat->found_t[i] > -1) {
+      newcat->found_t[i] = -2;
     }
   }