Changeset 36630 for trunk

trunk

Property svn:mergeinfo changed

/branches/eam_branches/ipp-20140206 (added)

merged: 36494,36503-36506,36516-36520,36530-36536,36545,36548-36550,36558,36562,36564-36571,36574-36578,36589-36591,36611-36613,36616-36618,36624-36629

trunk/Ohana/src/libdvo/Makefile

r36490	r36630
103	103	$(SRC)/ImageMetadata.$(ARCH).o \
104	104	$(SRC)/ImageOps.$(ARCH).o \
	105	$(SRC)/RegionHostTable.$(ARCH).o \
105	106	$(SRC)/match_image.$(ARCH).o \
106	107	$(SRC)/db_utils.$(ARCH).o \

trunk/Ohana/src/libdvo/include/dvo.h

-              r36528
+              r36630
 } HostTable;
+// A RegionHost processes data for some region in parallel with other regions
+typedef struct RegionHostInfo {
+  double Rmin;        // (Rmin,Rmax),(Dmin,Dmax) arehard RA,DEC boundaries of the
+  double Rmax;        // region for which each host is responsible.  A given host
+  double Dmin;        // calibrates the images for which the fiducial point (center)
+  double Dmax;        // lands in the region, and all objects in the region
+  double RminCat;      // (RminCat,RmaxCat),(DminCat,DmaxCat) are the region for which
+  double RmaxCat;      // the catalogs need to be loaded : this is the outer bounds
+  double DminCat;      // of the region containing all images completely
+  double DmaxCat;
+  char *hostname;
+  int hostID;                 // remove machine ID in SkyTable
+  int stdio[3];               // fd's for communication with the remote host
+  int pid;                    // remote process ID
+  int status;
+  IOBuffer stdout;
+  IOBuffer stderr;
+  off_t Nimage;
+  off_t NIMAGE;
+  Image *image;
+  off_t *imseq;
+  int *neighbors;             // list of neighbor index values
+  int Nneighbors;             // number of neighbors
+  char isNeighbor;            // TRUE if I am a neighbor to the current region host
+} RegionHostInfo;
+typedef struct {
+  double Rmin;
+  double Rmax;
+  double Dmin;
+  double Dmax;
+  int Nhosts;
+  RegionHostInfo *hosts;
+  short *index;
+} RegionHostTable;
 // special-case function:
 CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, off_t *Ndata, char *swapped);
 …
   uint32_t       flags;
   int            catID;
+  int            objID;
+  int            nOwn;
 } AverageTiny;
 …
   short          dYccd;
   short          dRsys;
+  char           myDet;
 } MeasureTiny;
 …
   float *X;
   float *Y;
+  int   *nOwn; // relastro uses this to count owned detections per object
 } Catalog;
 …
 float PhotInst (Measure *measure);
 float PhotCat (Measure *measure);
-float PhotAper (Measure *measure);
-float PhotKron (Measure *measure);
 float PhotSys (Measure *measure, Average *average, SecFilt *secfilt);
 float PhotRel (Measure *measure, Average *average, SecFilt *secfilt);
 …
 float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt);
 float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
+float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
+float PhotAperInst (Measure *measure);
+float PhotAperCat (Measure *measure);
+float PhotAperSys (Measure *measure, Average *average, SecFilt *secfilt);
+float PhotAperRel (Measure *measure, Average *average, SecFilt *secfilt);
+float PhotAperCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
+float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt);
+float PhotAperRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
+float PhotKronInst (Measure *measure);
+float PhotKronCat (Measure *measure);
+float PhotKronSys (Measure *measure, Average *average, SecFilt *secfilt);
+float PhotKronRel (Measure *measure, Average *average, SecFilt *secfilt);
+float PhotKronCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
+float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt);
+float PhotKronRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
+float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
 float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt);
-float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt);
-float PhotAperInst (Measure *measure);
-float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt);
-float PhotKronInst (Measure *measure);
-float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt);
-float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
 float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt);
 …
 void dvo_measureT_init (MeasureTiny *measure);
+void InitRegionHosts (RegionHostInfo *hosts, int Nhosts, int NHOSTS);
+void FreeRegionHosts (RegionHostInfo *hosts, int Nhosts);
+void FreeRegionHostTable (RegionHostTable *table);
+RegionHostTable *RegionHostTableLoad (char *catdir, char *rootname);
+int RegionHostTableWaitJobs (RegionHostTable *regionHosts, char *file, int lineno);
+int RegionHostTableWaitJobsGetIO (RegionHostTable *regionHosts, char *file, int lineno, int VERBOSE);
+int RegionHostFindNeighbors (RegionHostTable *table, int Nhost);
 # endif // DVO_H

trunk/Ohana/src/libdvo/include/dvodb.h

-              r36490
+              r36630
 /* magnitude types */
 enum {MAG_NONE,
+      MAG_INST,
+      MAG_CAT,
+      MAG_APER,
+      MAG_APER_INST,
+      MAG_KRON,
+      MAG_KRON_INST,
+      MAG_KRON_ERR,
+      MAG_SYS,
+      MAG_REL,
+      MAG_CAL,
+      // these magnitude types are from the measurement table (or derived therein)
+      // the following imply PSF magnitudes:
+      MAG_INST, // -2.5*log(DN) [ie, not DN/sec]
+      MAG_CAT,  // MAG_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
+      MAG_SYS,  // MAG_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
+      MAG_REL,  // MAG_SYS - Mcal [specific zero point for image]
+      MAG_CAL,  // MAG_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
+      MAG_ERR,  // error on PSF MAG
+      // the following imply APERTURE magnitudes:
+      MAG_APER_INST, // -2.5*log(DN) [ie, not DN/sec]
+      MAG_APER_CAT,  // MAG_APER_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
+      MAG_APER_SYS,  // MAG_APER_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
+      MAG_APER_REL,  // MAG_APER_SYS - Mcal [specific zero point for image]
+      MAG_APER_CAL,  // MAG_APER_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
+      MAG_APER_ERR,  // error on APER MAG (if known, else psf error)
+      MAG_APER,      // in mextract -> MAG_APER_REL, in avextract -> MAG_APER_AVE
+      // the following imply KRON magnitudes:
+      MAG_KRON_INST, // -2.5*log(DN) [ie, not DN/sec]
+      MAG_KRON_CAT,  // MAG_KRON_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
+      MAG_KRON_SYS,  // MAG_KRON_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
+      MAG_KRON_REL,  // MAG_KRON_SYS - Mcal [specific zero point for image]
+      MAG_KRON_CAL,  // MAG_KRON_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
+      MAG_KRON_ERR,  // error on KRON MAG
+      MAG_KRON,      // in mextract -> MAG_KRON_REL, in avextract -> MAG_KRON_AVE
+      // these magnitude types are from the average (secfilt) table:
+      // the following imply PSF magnitudes (or fluxes)
       MAG_AVE,
       MAG_REF,
-      MAG_ERR,
       MAG_STDEV,
       MAG_AVE_ERR,
+      MAG_CHISQ,
+      MAG_20,
+      MAG_80,
+      MAG_FLUX_PSF,
+      MAG_FLUX_PSF_ERR,
+      // the following imply APERTURE magnitudes:
+      MAG_APER_AVE,
+      MAG_APER_REF,
+      // the following imply KRON magnitudes or fluxes:
+      MAG_KRON_AVE,
+      MAG_KRON_REF,
+      MAG_FLUX_KRON,
+      MAG_FLUX_KRON_ERR,
+      // other secfilt fields of interest
       MAG_PHOT_FLAGS,
-      MAG_CHISQ,
       MAG_NCODE,
       MAG_NPHOT,
-      MAG_20,
-      MAG_80,
       MAG_UC_DIST,
       MAG_STACK_DET_ID,
-      MAG_FLUX_PSF,
-      MAG_FLUX_PSF_ERR,
-      MAG_FLUX_KRON,
-      MAG_FLUX_KRON_ERR,
 };

trunk/Ohana/src/libdvo/src/dbExtractAverages.c

-              r36528
+              r36630
+            }
           } else {
             value.Flt = PhotdM (field->photcode, average, secfilt);
+            value.Flt = PhotAveErr (field->photcode, average, secfilt);
+          }
           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;
 …
       break;
     case AVE_dMAG:
       value.Flt = PhotdM (field->photcode, average, secfilt);
+      value.Flt = PhotAveErr (field->photcode, average, secfilt);
       break;
     case AVE_Xm:

trunk/Ohana/src/libdvo/src/dbExtractMeasures.c

-              r35508
+              r36630
           case MAG_REL:
           case MAG_CAL:
+          case MAG_APER:
+          case MAG_ERR:
           case MAG_APER_INST:
+          case MAG_KRON:
+          case MAG_APER_CAT:
+          case MAG_APER_SYS:
+          case MAG_APER_REL:
+          case MAG_APER_CAL:
+          case MAG_APER_ERR:
           case MAG_KRON_INST:
+          case MAG_KRON_CAT:
+          case MAG_KRON_SYS:
+          case MAG_KRON_REL:
+          case MAG_KRON_CAL:
           case MAG_KRON_ERR:
+          case MAG_ERR:
           case MAG_PHOT_FLAGS:
             equiv = myEquiv;
 …
           case MAG_AVE:
           case MAG_REF:
+          case MAG_STDEV:
+          case MAG_AVE_ERR:
           case MAG_CHISQ:
+          case MAG_AVE_ERR:
+          case MAG_FLUX_PSF:
+          case MAG_FLUX_PSF_ERR:
+          case MAG_APER_AVE:
+          case MAG_KRON_AVE:
+          case MAG_FLUX_KRON:
+          case MAG_FLUX_KRON_ERR:
+          case MAG_20:
+          case MAG_80:
+          case MAG_UC_DIST:
+          case MAG_STACK_DET_ID:
           case MAG_NCODE:
           case MAG_NPHOT:
-          case MAG_FLUX_PSF:
-          case MAG_FLUX_PSF_ERR:
-          case MAG_FLUX_KRON:
-          case MAG_FLUX_KRON_ERR:
             equiv = field->photcode;
             goto valid_photcode;
 …
           value.Flt = PhotRef  (equiv, average, secfilt, measure);
           break;
+        case MAG_APER:
+          value.Flt = PhotAper (measure);
+          break;
+        case MAG_ERR:
+          value.Flt = measure[0].dM;
+          break;
+        case MAG_AVE_ERR:
+          value.Flt = PhotAveErr  (equiv, average, secfilt);
+          break;
         case MAG_APER_INST:
           value.Flt = PhotAperInst (measure);
           break;
+        case MAG_KRON:
+          value.Flt = PhotKron (measure);
+          break;
+        case MAG_APER_CAT:
+          value.Flt = PhotAperCat (measure);
+          break;
+        case MAG_APER_SYS:
+          value.Flt = PhotAperSys (measure, average, secfilt);
+          break;
+        case MAG_APER:
+        case MAG_APER_REL:
+          value.Flt = PhotAperRel (measure, average, secfilt);
+          break;
+        case MAG_APER_CAL:
+          value.Flt = PhotAperCal (measure, average, secfilt, measure, equiv);
+          break;
+        case MAG_APER_AVE:
+          value.Flt = PhotAperAve (equiv, average, secfilt);
+          break;
+        case MAG_APER_REF:
+          value.Flt = PhotAperRef (equiv, average, secfilt, measure);
+          break;
+        case MAG_APER_ERR:
+          value.Flt = measure[0].dM;
+          break;
         case MAG_KRON_INST:
           value.Flt = PhotKronInst (measure);
           break;
+        case MAG_KRON_CAT:
+          value.Flt = PhotKronCat (measure);
+          break;
+        case MAG_KRON_SYS:
+          value.Flt = PhotKronSys (measure, average, secfilt);
+          break;
+        case MAG_KRON:
+        case MAG_KRON_REL:
+          value.Flt = PhotKronRel (measure, average, secfilt);
+          break;
+        case MAG_KRON_CAL:
+          value.Flt = PhotKronCal (measure, average, secfilt, measure, equiv);
+          break;
+        case MAG_KRON_AVE:
+          value.Flt = PhotKronAve (equiv, average, secfilt);
+          break;
+        case MAG_KRON_REF:
+          value.Flt = PhotKronRef (equiv, average, secfilt, measure);
+          break;
         case MAG_KRON_ERR:
+          value.Flt = measure[0].dMkron;
+          break;
+        case MAG_ERR:
+          value.Flt = measure[0].dM;
+          break;
+        case MAG_AVE_ERR:
+          value.Flt = PhotdM  (equiv, average, secfilt);
+          break;
+          value.Flt = measure[0].dMkron;
+          break;
         case MAG_PHOT_FLAGS:
           if ((field->photcode->type == PHOT_REF) || (field->photcode->type == PHOT_DEP)) {
             value.Int = measure[0].photFlags;
-          } else {
-            value.Int = 0;
+          }
           break;
+        case MAG_CHISQ:
+          value.Flt = PhotXm  (equiv, average, secfilt);
+          break;
         case MAG_NCODE:
+          if (equiv == NULL) {
+            value.Int = 0;
+            break;
+          }
+          if (equiv == NULL) break;
           Nsec = GetPhotcodeNsec (equiv->code);
           if (Nsec == -1) break;
 …
           break;
         case MAG_NPHOT:
+          if (equiv == NULL) {
+            value.Int = 0;
+            break;
+          }
+          if (equiv == NULL) break;
           Nsec = GetPhotcodeNsec (equiv->code);
           if (Nsec == -1) break;
           value.Int = secfilt[Nsec].Nused;
           break;
+        case MAG_CHISQ:
+          value.Flt = PhotXm (equiv, average, secfilt);
+          break;
+        case MAG_STDEV:
+          value.Flt = PhotMstdev (equiv, average, secfilt);
+          break;
+        case MAG_20:
+          value.Flt = PhotM20 (equiv, average, secfilt);
+          break;
+        case MAG_80:
+          value.Flt = PhotM80 (equiv, average, secfilt);
+          break;
+        case MAG_UC_DIST:
+          value.Flt = PhotUCdist (equiv, average, secfilt);
+          break;
         case MAG_FLUX_PSF:
           value.Flt = PhotAveFluxPSF (field->photcode, average, secfilt);
 …
           fieldc = MatchFieldMetadata (measure[0].imageID);
         } else {
           fprintf (stderr, "non-parallel Xmos broken\n");
           abort();
+          // fprintf (stderr, "non-parallel Xmos broken\n");
+          // abort();
           // fieldc = MatchField (measure[0].t, measure[0].photcode);
+          fieldc = MatchFieldMetadata (measure[0].imageID);
+        }
         if (fieldc == NULL) break;
 …
           fieldc = MatchFieldMetadata (measure[0].imageID);
         } else {
           fprintf (stderr, "non-parallel Xmos broken\n");
           abort();
+          // fprintf (stderr, "non-parallel Xmos broken\n");
+          // abort();
           // fieldc = MatchField (measure[0].t, measure[0].photcode);
+          fieldc = MatchFieldMetadata (measure[0].imageID);
+        }
         if (fieldc == NULL) break;
 …
           mosaic = MatchMosaicMetadata (measure[0].imageID);
         } else {
+          fprintf (stderr, "non-parallel Xmos broken\n");
+          abort();
+          mosaic = MatchMosaic (measure[0].t, measure[0].photcode);
+          // fprintf (stderr, "non-parallel Xmos broken\n");
+          // abort();
+          // mosaic = MatchMosaic (measure[0].t, measure[0].photcode);
+          mosaic = MatchMosaicMetadata (measure[0].imageID);
+        }
         if (mosaic == NULL) break;
 …
           mosaic = MatchMosaicMetadata (measure[0].imageID);
         } else {
+          fprintf (stderr, "non-parallel Xmos broken\n");
+          abort();
+          mosaic = MatchMosaic (measure[0].t, measure[0].photcode);
+          // fprintf (stderr, "non-parallel Xmos broken\n");
+          // abort();
+          // mosaic = MatchMosaic (measure[0].t, measure[0].photcode);
+          mosaic = MatchMosaicMetadata (measure[0].imageID);
+        }
         if (mosaic == NULL) break;

trunk/Ohana/src/libdvo/src/dbFields.c

-              r36084
+              r36630
 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, "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, "kron_inst"))   return (MAG_KRON_INST);
   if (!strcasecmp (string, "kronerr"))     return (MAG_KRON_ERR);
+  if (!strcasecmp (string, "err"))         return (MAG_ERR);
   if (!strcasecmp (string, "aveerr"))      return (MAG_AVE_ERR);
+  // other fields:
   if (!strcasecmp (string, "photflags"))   return (MAG_PHOT_FLAGS);
   if (!strcasecmp (string, "flags"))       return (MAG_PHOT_FLAGS);

trunk/Ohana/src/libdvo/src/dvo_catalog.c

-              r35416
+              r36630
   average->measureOffset   = -1;
   average->catID           = 0;
+  average->nOwn            = 0;
+}
 …
  measure->dYccd     = 0;
  measure->dRsys     = 0;
+ measure->myDet     = FALSE;
+}

trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c

-              r36528
+              r36630
+}
+// XXX note that there are 2 bad versions of PS1_V4 : the other one does have have PSF_QF_PERFECT, but has PAD instead
 int gfits_convert_Measure_PS1_V4alt (Measure_PS1_V4alt *data, off_t size, off_t nitems) {
 …
 # ifdef BYTE_SWAP
   byte = (unsigned char *) data;
   for (i = 0; i < nitems; i++, byte += 129) {
+  for (i = 0; i < nitems; i++, byte += 120) {
     /** BYTE SWAP **/
     SWAP_DBLE (0); // RA
 …
   Ncols = ftable[0].header[0].Naxis[0];
   if (Ncols != 120) {
     fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, 176);
+    fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, 120);
     return NULL;
+  }

trunk/Ohana/src/libdvo/src/dvo_photcode_ops.c

-              r36528
+              r36630
+}
+// returns Nsec if code is PRI/SEC, else -1
 int GetPhotcodeNsec (int code) {
 …
+}
-float PhotAper (Measure *measure) {
-  int Np;
-  float Mcat;
-  PhotCode *code;
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Mcat = measure[0].Map;
-    return (Mcat);
+  }
-  code = &photcodes[0].code[Np];
-  Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
-  return (Mcat);
+}
-float PhotAperInst (Measure *measure) {
-  int Np;
-  float Minst;
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Minst = measure[0].Map;
-    return (Minst);
+  }
-  Minst = measure[0].Map - measure[0].dt - ZERO_POINT;
-  return (Minst);
+}
-float PhotKron (Measure *measure) {
-  int Np;
-  float Mcat;
-  PhotCode *code;
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Mcat = measure[0].Mkron;
-    return (Mcat);
+  }
-  code = &photcodes[0].code[Np];
-  Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
-  return (Mcat);
+}
-float PhotKronInst (Measure *measure) {
-  int Np;
-  float Minst;
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Minst = measure[0].Mkron;
-    return (Minst);
+  }
-  Minst = measure[0].Mkron - measure[0].dt - ZERO_POINT;
-  return (Minst);
+}
 float PhotSys (Measure *measure, Average *average, SecFilt *secfilt) {
 …
+}
-float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt) {
-  int Np;
-  float ZP;
-  PhotCode *code;
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    ZP = 0.0;
-    return (ZP);
+  }
-  code = &photcodes[0].code[Np];
-  ZP = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
-  return (ZP);
+}
 float PhotRel (Measure *measure, Average *average, SecFilt *secfilt) {
 …
   Mcal += Mcol;
   return (Mcal);
+}
+/***/
+float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt) {
+  int Ns;
+  float Mave;
+  if (code == NULL) return NAN;
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
+  return (Mave);
+}
+/* return calibrated magnitude from average/secfilt for given photcode */
+float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
+  int i, Ns;
+  float Mave, Mref, Mcol, mc;
+  double Mc;
+  if (code == NULL) return NAN;
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
+  Mref = Mave + SCALE*code[0].C;
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mref);
+  mc = mc - SCALE*code[0].dX;
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mref += Mcol;
+  return (Mref);
+}
+float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt) {
+  int Ns;
+  float dM;
+  if (code == NULL) return NAN;
+  Ns = photcodes[0].hashNsec[code[0].code];
+  dM  = (Ns == -1) ? NAN : secfilt[Ns].dM;
+  return (dM);
+}
+/************************************** APERTURE-related Magnitudes ***********************************************/
+float PhotAperInst (Measure *measure) {
+  int Np;
+  float Minst;
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Minst = measure[0].Map;
+    return (Minst);
+  }
+  Minst = measure[0].Map - measure[0].dt - ZERO_POINT;
+  return (Minst);
+}
+float PhotAperCat (Measure *measure) {
+  int Np;
+  float Mcat;
+  PhotCode *code;
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Map;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  return (Mcat);
+}
+float PhotAperSys (Measure *measure, Average *average, SecFilt *secfilt) {
+  int i, Np;
+  float Mcat, Mcol, Msys, mc, Mc;
+  PhotCode *code;
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Map;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  /* for DEP, color must be made of PRI/SEC */
+  mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mcat);
+  mc = mc - SCALE*code[0].dX;
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  Msys = Mcat + Mcol;
+  return (Msys);
+}
+float PhotAperRel (Measure *measure, Average *average, SecFilt *secfilt) {
+  int i, Np;
+  float Mcat, Mcol, Mrel, mc, Mc;
+  PhotCode *code;
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Map;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mrel = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
+  /* for DEP, color must be made of PRI/SEC */
+  mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mrel);
+  mc = mc - SCALE*code[0].dX;
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mrel += Mcol;
+  return (Mrel);
+}
+/* return calibrated magnitude from measure for given photcode */
+float PhotAperCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
+  int i, Np;
+  float Mcal, Mrel, Mcol, mc, Mc;
+  if (code == NULL) return NAN;
+  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
+  Np = photcodes[0].hashcode[thisone[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mrel = thisone[0].Map;
+    return (Mrel);
+  }
+  if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
+  Mcal = PhotAperRel (thisone, average, secfilt) + SCALE*code[0].C;
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mcal);
+  mc = mc - SCALE*code[0].dX;
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  Mcal += Mcol;
+  return (Mcal);
+}
+float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt) {
+  int Ns;
+  float Maper;
+  if (code == NULL) return NAN;
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Maper = (Ns == -1) ? NAN : secfilt[Ns].Map;
+  return (Maper);
+}
+/* return calibrated magnitude from average/secfilt for given photcode */
+float PhotAperRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
+  int i, Ns;
+  float Mave, Mref, Mcol, mc;
+  double Mc;
+  if (code == NULL) return NAN;
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mave = (Ns == -1) ? NAN : secfilt[Ns].Map;
+  Mref = Mave + SCALE*code[0].C;
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mref);
+  mc = mc - SCALE*code[0].dX;
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mref += Mcol;
+  return (Mref);
+}
+/************************************** KRON-related Magnitudes ***********************************************/
+float PhotKronInst (Measure *measure) {
+  int Np;
+  float Minst;
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Minst = measure[0].Mkron;
+    return (Minst);
+  }
+  Minst = measure[0].Mkron - measure[0].dt - ZERO_POINT;
+  return (Minst);
+}
+float PhotKronCat (Measure *measure) {
+  int Np;
+  float Mcat;
+  PhotCode *code;
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Mkron;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  return (Mcat);
+}
+float PhotKronSys (Measure *measure, Average *average, SecFilt *secfilt) {
+  int i, Np;
+  float Mcat, Mcol, Msys, mc, Mc;
+  PhotCode *code;
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Msys = measure[0].Mkron;
+    return (Msys);
+  }
+  code = &photcodes[0].code[Np];
+  Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  /* for DEP, color must be made of PRI/SEC */
+  mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mcat);
+  mc = mc - SCALE*code[0].dX;
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  Msys = Mcat + Mcol;
+  return (Msys);
+}
+float PhotKronRel (Measure *measure, Average *average, SecFilt *secfilt) {
+  int i, Np;
+  float Mcat, Mcol, Mrel, mc, Mc;
+  PhotCode *code;
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Mkron;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mrel = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
+  /* for DEP, color must be made of PRI/SEC */
+  mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mrel);
+  mc = mc - SCALE*code[0].dX;
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mrel += Mcol;
+  return (Mrel);
+}
+/* return calibrated magnitude from measure for given photcode */
+float PhotKronCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
+  int i, Np;
+  float Mcal, Mrel, Mcol, mc, Mc;
+  if (code == NULL) return NAN;
+  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
+  Np = photcodes[0].hashcode[thisone[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mrel = thisone[0].Mkron;
+    return (Mrel);
+  }
+  if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
+  Mcal = PhotKronRel (thisone, average, secfilt) + SCALE*code[0].C;
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mcal);
+  mc = mc - SCALE*code[0].dX;
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  Mcal += Mcol;
+  return (Mcal);
+}
+float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt) {
+  int Ns;
+  float Mkron;
+  if (code == NULL) return NAN;
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mkron = (Ns == -1) ? NAN : secfilt[Ns].Mkron;
+  return (Mkron);
+}
+/* return calibrated magnitude from average/secfilt for given photcode */
+float PhotKronRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
+  int i, Ns;
+  float Mave, Mref, Mcol, mc;
+  double Mc;
+  if (code == NULL) return NAN;
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mave = (Ns == -1) ? NAN : secfilt[Ns].Mkron;
+  Mref = Mave + SCALE*code[0].C;
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mref);
+  mc = mc - SCALE*code[0].dX;
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mref += Mcol;
+  return (Mref);
+}
+float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt) {
+  int Ns;
+  float dMkron;
+  if (code == NULL) return NAN;
+  Ns = photcodes[0].hashNsec[code[0].code];
+  dMkron = (Ns == -1) ? NAN : secfilt[Ns].dMkron;
+  return (dMkron);
+}
+/********************* other support functions ********************************/
+float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt) {
+  int Np;
+  float ZP;
+  PhotCode *code;
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    ZP = 0.0;
+    return (ZP);
+  }
+  code = &photcodes[0].code[Np];
+  ZP = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  return (ZP);
+}
 …
+}
-/* return calibrated magnitude from average/secfilt for given photcode */
-float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
-  int i, Ns;
-  float Mave, Mref, Mcol, mc;
-  double Mc;
-  if (code == NULL) return NAN;
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
-  Mref = Mave + SCALE*code[0].C;
-  mc = PhotColorForCode (average, secfilt, measure, code);
-  if (isnan(mc)) return (Mref);
-  mc = mc - SCALE*code[0].dX;
-  Mc = mc;
-  Mcol = 0;
-  for (i = 0; i < code[0].Nc; i++) {
-    Mcol += code[0].X[i]*Mc;
-    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
-  Mref += Mcol;
-  return (Mref);
+}
-/***/
-float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt) {
-  int Ns;
-  float Mave;
-  if (code == NULL) return NAN;
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
-  return (Mave);
+}
-float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt) {
-  int Ns;
-  float dM;
-  if (code == NULL) return NAN;
-  Ns = photcodes[0].hashNsec[code[0].code];
-  dM  = (Ns == -1) ? NAN : secfilt[Ns].dM;
-  return (dM);
+}
 float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt) {
 …
   Mstdev  = (Ns == -1) ? NAN : 0.001*secfilt[Ns].Mstdev;
   return (Mstdev);
+}
-float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt) {
-  int Ns;
-  float Maper;
-  if (code == NULL) return NAN;
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Maper = (Ns == -1) ? NAN : secfilt[Ns].Map;
-  return (Maper);
+}
-float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt) {
-  int Ns;
-  float Mkron;
-  if (code == NULL) return NAN;
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Mkron = (Ns == -1) ? NAN : secfilt[Ns].Mkron;
-  return (Mkron);
+}
-float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt) {
-  int Ns;
-  float dMkron;
-  if (code == NULL) return NAN;
-  Ns = photcodes[0].hashNsec[code[0].code];
-  dMkron = (Ns == -1) ? NAN : secfilt[Ns].dMkron;
-  return (dMkron);
+}

trunk/Ohana/src/libdvo/src/dvo_tiny_values.c

-              r35102
+              r36630
   averageT[0].measureOffset = average[0].measureOffset;
   averageT[0].catID         = average[0].catID;
+  averageT[0].objID         = average[0].objID;
+  averageT[0].nOwn          = -1;
   return;
+}
 …
   measureT[0].dYccd      = measure[0].dYccd;
   measureT[0].dRsys      = measure[0].dRsys;
+  measureT[0].myDet      = 0;
   return ;
+}

trunk/Ohana/src/libfits/table/F_get_column.c

-              r35101
+              r36630
 int gfits_get_bintable_column (Header *header, FTable *table, char *label, void **data) {
+  off_t Nx, Ny;
+  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
+  char tlabel[80], field[80], format[80], type[16], tmpline[16];
+  char *Pin, *Pout, *array;
+  double Bscale, Bzero;
+  if (label == (char *) NULL) return (FALSE);
+  if (label[0] == 0) return (FALSE);
+  /* find label in header */
+  tlabel[0] = 0;
+  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
+  for (i = 1; strcasecmp (label, tlabel) && (i < Nfields + 1); i++) {
+    sprintf (field, "TTYPE%d", i);
+    gfits_scan (header, field, "%s", 1, tlabel);
+  }
+  if (strcasecmp (label, tlabel)) return (FALSE);
+  N = i - 1;
+  Bscale = 1;
+  Bzero  = 0;
+  /* interpret format */
+  sprintf (field, "TSCAL%d", N);
+  gfits_scan (header, field, "%lf", 1, &Bscale);
+  sprintf (field, "TZERO%d", N);
+  gfits_scan (header, field, "%lf", 1, &Bzero);
+  sprintf (field, "TFORM%d", N);
+  gfits_scan (header, field, "%s", 1, format);
+  if (!gfits_bintable_format (format, type, &Nval, &Nbytes)) return (FALSE);
+  /* check existing table dimensions */
+  gfits_scan (header, "NAXIS1",  OFF_T_FMT, 1,  &Nx);
+  gfits_scan (header, "NAXIS2",  OFF_T_FMT, 1,  &Ny);
+  /* scan columns to find insert point */
+  Nstart = 0;
+  for (i = 1; i < N; i++) {
+    sprintf (field, "TFORM%d", i);
+    gfits_scan (header, field, "%s", 1, format);
+    gfits_bintable_format (format, tmpline, &Nv, &Nb);
+    Nstart += Nv*Nb;
+  }
+  /* extract bytes from table into temporary array */
+  ALLOCATE (array, char, Nbytes*Nval*Ny);
+  Pin  = table[0].buffer + Nstart;
+  Pout = array;
+  for (i = 0; i < Ny; i++, Pin += Nx, Pout += Nval*Nbytes) {
+    memcpy (Pout, Pin, Nval*Nbytes);
+  }
+  /* convert data in-situ with correct type, byte swap and Bzero/Bscale */
+  Pin  = array;
+  Pout = array;
+  if (!strcmp (type, "char")) {
+    for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) {
+      *(char *)Pout = *(char *)Pin*Bscale + Bzero;
+    }
+  }
+  if (!strcmp (type, "short")) {
+    for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) {
+# ifdef BYTE_SWAP
+      SWAP_BYTE;
+# endif
+      *(short *)Pout = *(short *)Pin*Bscale + Bzero;
+    }
+  }
+  if (!strcmp (type, "int")) {
+    for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) {
+# ifdef BYTE_SWAP
+      SWAP_WORD;
+# endif
+      *(int *)Pout = *(int *)Pin*Bscale + Bzero;
+    }
+  }
+  if (!strcmp (type, "int64_t")) {
+    // XXX 64 bit int operations with Bzero & Bscale are inaccurate even with doubles
+    if ((Bzero == 0.0) && (Bscale == 1.0)) {
+      for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) {
+# ifdef BYTE_SWAP
+        SWAP_DBLE;
+# endif
+        *(int64_t *)Pout = *(int64_t *)Pin;
+      }
+    } else {
+      for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) {
+# ifdef BYTE_SWAP
+        SWAP_DBLE;
+# endif
+        *(int64_t *)Pout = *(int64_t *)Pin*Bscale + Bzero;
+      }
+    }
+  }
+  if (!strcmp (type, "float")) {
+    for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) {
+# ifdef BYTE_SWAP
+      SWAP_WORD;
+# endif
+      *(float *)Pout = *(float *)Pin*Bscale + Bzero;
+    }
+  }
+  if (!strcmp (type, "double")) {
+    for (i = 0; i < Nval*Ny; i++, Pin+=Nbytes, Pout+=Nbytes) {
+# ifdef BYTE_SWAP
+      SWAP_DBLE;
+# endif
+      *(double *)Pout = *(double *)Pin*Bscale + Bzero;
+    }
+  }
+  char type[16];
+  off_t Nrow;
+  int Ncol;
+  char *array = gfits_get_bintable_column_data (header, table, label, type, &Nrow, &Ncol);
+  if (array == NULL) return (FALSE);
   *data = array;
   return (TRUE);
+  return TRUE;
+}

trunk/Ohana/src/libohana/src

Property svn:mergeinfo changed
/branches/eam_branches/ipp-20140206/Ohana/src/libohana/src (added) merged: 36536,36626
/branches/eam_branches/ipp-20140214/Ohana/src/libohana/src (added) merged: 36525-36527

trunk/Ohana/src/opihi/dvo/photometry.c

-              r35416
+              r36630
       break;
     case AVE_dMAG:
       value = PhotdM (code, average, secfilt);
+      value = PhotAveErr (code, average, secfilt);
       break;
     case AVE_Xm:
 …
   /* for ErrSelect, check average errors */
   if (ErrSelect) {
     dM = PhotdM (code, average, secfilt);
+    dM = PhotAveErr (code, average, secfilt);
     if (dM > ErrValue) return (FALSE);
+  }

trunk/Ohana/src/relastro/Makefile

-              r35416
+              r36630
 $(SRC)/resort_catalog.$(ARCH).o  \
 $(SRC)/BrightCatalog.$(ARCH).o  \
+$(SRC)/assign_images.$(ARCH).o \
+$(SRC)/launch_region_hosts.$(ARCH).o \
+$(SRC)/relastro_parallel_images.$(ARCH).o \
+$(SRC)/relastro_parallel_regions.$(ARCH).o \
+$(SRC)/MeanPosIO.$(ARCH).o \
+$(SRC)/share_mean_pos.$(ARCH).o \
+$(SRC)/share_images_pos.$(ARCH).o \
+$(SRC)/ImagePosIO.$(ARCH).o \
+$(SRC)/ImageTable.$(ARCH).o \
+$(SRC)/markObjects.$(ARCH).o \
+$(SRC)/indexCatalogs.$(ARCH).o \
+$(SRC)/syncfile.$(ARCH).o \
 $(SRC)/relastroVisual.$(ARCH).o

trunk/Ohana/src/relastro/include/relastro.h

-              r35763
+              r36630
 # include <pthread.h>
+# define MARKTIME(MSG,...) {                    \
+    gettimeofday (&stopTimer, (void *) NULL);   \
+    float dtime = DTIME (stopTimer, startTimer);        \
+    fprintf (stderr, MSG, __VA_ARGS__); }
+# define INITTIME \
+  struct timeval startTimer, stopTimer; \
+  gettimeofday (&startTimer, (void *) NULL);
 // choose off_t or int depending on full-scale relphot analysis resources
 // # define IDX_T off_t
 …
 typedef enum {FIT_NONE, FIT_AVERAGE, FIT_PM_ONLY, FIT_PAR_ONLY, FIT_PM_AND_PAR} FitMode;
+typedef enum {TARGET_NONE, TARGET_SIMPLE, TARGET_CHIPS, TARGET_MOSAICS, TARGET_HIGH_SPEED, TARGET_MERGE_SOURCE, TARGET_UPDATE_OBJECTS, TARGET_UPDATE_OFFSETS, TARGET_LOAD_OBJECTS, TARGET_HPM} FitTarget;
+typedef enum {OP_NONE, OP_IMAGES, OP_HIGH_SPEED, OP_MERGE_SOURCE, OP_UPDATE_OBJECTS, OP_UPDATE_OFFSETS, OP_LOAD_OBJECTS, OP_HPM, OP_PARALLEL_REGIONS, OP_PARALLEL_IMAGES} RelastroOp;
+typedef enum {TARGET_NONE, TARGET_SIMPLE, TARGET_CHIPS, TARGET_MOSAICS} FitTarget;
 typedef enum {
 …
   MARK_BIG_OFFSET    = 0x0010,
 } MeasurementMask;
+typedef struct {
+  float R;
+  float D;
+  unsigned int objID;
+  unsigned int catID;
+} MeanPos;
+typedef struct {
+  Coords coords;
+  float dXpixSys;
+  float dYpixSys;
+  unsigned int imageID;
+  int nFitAstrom;
+  int flags;
+} ImagePos;
 typedef struct {
 …
   unsigned int start;
   unsigned int stop;
+  off_t myImage;
   float Mcal;
   float dMcal;
 …
 } StatType;
-# define MARKTIME(MSG,...) { \
-  float dtime; \
-  gettimeofday (&stop, (void *) NULL); \
-  dtime = DTIME (stop, start); \
-  fprintf (stderr, MSG, __VA_ARGS__); }
 /* global variables set in parameter file */
 # define DVO_MAX_PATH 1024
 …
 char   SKY_TABLE[DVO_MAX_PATH];
 int    SKY_DEPTH;  /** XXX EAM : depth of catalog tables, fix usage */
+// globals for parallel region operations
+char  *REGION_FILE;
+char  *IMAGE_TABLE;
+int    REGION_HOST_ID;
+int    PARALLEL_REGIONS_MANUAL;
 int          HOST_ID;
 …
 FitMode FIT_MODE;
+RelastroOp RELASTRO_OP;
 FitTarget FIT_TARGET;
 …
 int hpm_catalogs_parallel (SkyList *skylist);
 int hpm_objects (SkyRegion *region, Catalog *catalog);
+int strextend (char *input, char *format,...);
+int launch_region_hosts (RegionHostTable *regionHosts);
+int assign_images (FITS_DB *db, RegionHostTable *regionHosts);
+int select_images_hostregion (RegionHostTable *regionHosts, Image *image, off_t Nimage);
+int calculate_image_bounds (Image *image, double *rmin, double *rmax, double *dmin, double *dmax, double Rmid);
+int calculate_host_image_bounds (RegionHostTable *regionHosts);
+int find_host_for_coords (RegionHostTable *regionHosts, double Rc, double Dc);
+int relastro_parallel_regions ();
+int relastro_parallel_images ();
+char *make_filename (char *dirname, char *hostname, int hostID, char *tailname);
+int check_sync_file (char *filename, int nloop);
+int clear_sync_file (char *filename);
+int update_sync_file (char *filename, int nloop);
+int share_mean_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop);
+int slurp_mean_pos (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop);
+int set_mean_pos (MeanPos *meanpos, Average *average);
+MeanPos *merge_mean_pos (MeanPos *target, int *ntarget, MeanPos *source, int Nsource);
+int MeanPosSave(char *filename, MeanPos *meanpos, off_t Nmeanpos);
+MeanPos *MeanPosLoad(char *filename, off_t *nmeanpos);
+int indexCatalogs (Catalog *catalog, int Ncatalog);
+int catID_and_objID_to_seq (int catID, int objID, int *catSeq, off_t *objSeq);
+int markObjects (Catalog *catalog, int Ncatalog);
+int ImagePosSave(char *filename, ImagePos *image_pos, off_t Nimage_pos);
+ImagePos *ImagePosLoad(char *filename, off_t *nimage_pos);
+int share_image_pos (RegionHostTable *regionHosts, int nloop);
+int slurp_image_pos (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);
+Image *ImageTableLoad(char *filename, off_t *nimage);
+int ImageTableSave (char *filename, Image *images, off_t Nimages);
+int select_mosaics_hostregion (RegionHostTable *regionHosts, Image *image, off_t Nimage);

trunk/Ohana/src/relastro/src/ConfigInit.c

-              r35105
+              r36630
   if (VERBOSE) fprintf (stderr, "loaded config file: %s\n", file);
+  GetConfig (config, "RELASTRO_SIGMA_LIM",         "%lf", 0, &SIGMA_LIM); // exclude measurements on this basis
+  GetConfig (config, "RELASTRO_SRC_MEAS_TOOFEW",   "%d",  0, &SRC_MEAS_TOOFEW);
+  // set defaults for all of these if they are not used by parallel / remote clients
+  if (!ScanConfig (config, "RELASTRO_SIGMA_LIM",         "%lf", 0, &SIGMA_LIM))       SIGMA_LIM = 0.01;
+  if (!ScanConfig (config, "RELASTRO_SRC_MEAS_TOOFEW",   "%d",  0, &SRC_MEAS_TOOFEW)) SRC_MEAS_TOOFEW = 3;
   if (!ScanConfig (config, "RELASTRO_IMFIT_CLIP_NITER",    "%d",  0, &IMFIT_CLIP_NITER))    IMFIT_CLIP_NITER  = 3;
 …
   if (!ScanConfig (config, "RELASTRO_IMFIT_SYS_SIGMA_LIM", "%lf", 0, &IMFIT_SYS_SIGMA_LIM)) IMFIT_SYS_SIGMA_LIM = 0.01;
+  GetConfig (config, "PM_DT_MIN",              "%lf", 0, &PM_DT_MIN);
+  GetConfig (config, "PM_TOOFEW",              "%d",  0, &PM_TOOFEW);
+  GetConfig (config, "POS_TOOFEW",             "%d",  0, &POS_TOOFEW);
+  if (!ScanConfig (config, "PM_DT_MIN",              "%lf", 0, &PM_DT_MIN))        PM_DT_MIN = 0.25;
+  if (!ScanConfig (config, "PM_TOOFEW",              "%d",  0, &PM_TOOFEW))        PM_TOOFEW = 4;
+  if (!ScanConfig (config, "POS_TOOFEW",             "%d",  0, &POS_TOOFEW))       POS_TOOFEW = 1;
+  if (!ScanConfig (config, "PAR_FACTOR_MIN",         "%lf", 0, &PAR_FACTOR_MIN))   PAR_FACTOR_MIN = 0.2;
+  if (!ScanConfig (config, "RELASTRO_MAP_NX",        "%d",  0, &NX_MAP))           NX_MAP = 5;
+  if (!ScanConfig (config, "RELASTRO_MAP_NY",        "%d",  0, &NY_MAP))           NY_MAP = 5;
+  if (!ScanConfig (config, "RELASTRO_DPOS_MAX",      "%lf", 0, &DPOS_MAX))         DPOS_MAX = 6.0;
+  if (!ScanConfig (config, "ADDSTAR_RADIUS",         "%lf", 0, &ADDSTAR_RADIUS))   ADDSTAR_RADIUS = 1.0;
+  GetConfig (config, "PAR_FACTOR_MIN",         "%lf", 0, &PAR_FACTOR_MIN);
+  GetConfig (config, "RELASTRO_MAP_NX",        "%d",  0, &NX_MAP);
+  GetConfig (config, "RELASTRO_MAP_NY",        "%d",  0, &NY_MAP);
+  GetConfig (config, "RELASTRO_DPOS_MAX",      "%lf", 0, &DPOS_MAX);
+  GetConfig (config, "ADDSTAR_RADIUS",         "%lf", 0, &ADDSTAR_RADIUS);
+  if (!ScanConfig (config, "USE_FIXED_PIXCOORDS", "%d", 0, &USE_FIXED_PIXCOORDS)) {
+    USE_FIXED_PIXCOORDS = FALSE;
+  }
+  if (!ScanConfig (config, "USE_FIXED_PIXCOORDS", "%d", 0, &USE_FIXED_PIXCOORDS))  USE_FIXED_PIXCOORDS = FALSE;
   // force CATDIR to be absolute (so parallel mode will work)
 …
   sprintf (ImageCat, "%s/Images.dat", CATDIR);
+  if (!ScanConfig (config, "SKY_DEPTH",         "%d",  0, &SKY_DEPTH)) {
+    SKY_DEPTH = 2;
+  }
+  if (!ScanConfig (config, "SKY_TABLE",         "%s",  0, SKY_TABLE)) {
+    SKY_TABLE[0] = 0;
+  }
+  if (!ScanConfig (config, "SKY_DEPTH",         "%d",  0, &SKY_DEPTH)) SKY_DEPTH = 2;
+  if (!ScanConfig (config, "SKY_TABLE",         "%s",  0, SKY_TABLE)) SKY_TABLE[0] = 0;
   if (*CATMODE == 0) strcpy (CATMODE, "RAW");

trunk/Ohana/src/relastro/src/ImageOps.c

-              r35763
+              r36630
     Measure *measureBig = &catalog[cat].measure[meas];
     int TESTPT = FALSE;
     TESTPT |= (measureBig->imageID == CAT_ID_SRC) && (measureBig->detID == OBJ_ID_SRC);
     TESTPT |= (measureBig->imageID == CAT_ID_DST) && (measureBig->detID == OBJ_ID_DST);
+    TESTPT |= CAT_ID_SRC && OBJ_ID_SRC && (measureBig->imageID == CAT_ID_SRC) && (measureBig->detID == OBJ_ID_SRC);
+    TESTPT |= CAT_ID_DST && OBJ_ID_DST && (measureBig->imageID == CAT_ID_DST) && (measureBig->detID == OBJ_ID_DST);
     if (TESTPT) {
       fprintf (stderr, "got test det\n");
 …
     int TESTPT = FALSE;
     TESTPT |= (measure->imageID == CAT_ID_SRC) && (measure->detID == OBJ_ID_SRC);
     TESTPT |= (measure->imageID == CAT_ID_DST) && (measure->detID == OBJ_ID_DST);
+    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);
     if (TESTPT) {
       fprintf (stderr, "got test det\n");

trunk/Ohana/src/relastro/src/MosaicOps.c

-              r27581
+              r36630
 // list of mosaic associated with each image
 static off_t    Nmosaic_for_images; // number of images (for off_ternal checks)
+static off_t    Nmosaic_for_images; // number of images (for internal checks)
 static off_t    *mosaic_for_images; // array of: image -> mosaic
 …
     mosaic[Nmosaic].secz  = image[i].secz;
     mosaic[Nmosaic].coords = image[i].coords;
+    mosaic[Nmosaic].myImage = i;
     // init the mosaic_own_images array data
 …
   ALLOCATE (mosaic_for_images, off_t, Nmosaic_for_images);
+  // emit an error if we miss mosaics, but stop if we miss too many
+  int NmissMosaic = 0;
+  int NtestMosaic = 0;
   /* now assign the WRP images to these mosaics */
   for (i = 0; i < Nimage; i++) {
 …
     if (strcmp(&image[i].coords.ctype[4], "-WRP")) continue;
+    NtestMosaic ++;
     /* set image time range */
 …
     Nmos = getMosaicByTimes (start, stop, startMos, stopMos, indexMos);
     if (Nmos == -1) {
+      fprintf (stderr, "cannot match mosaic for %s\n", image[i].name);
+      if (NmissMosaic < 1000) {
+        fprintf (stderr, "cannot match mosaic for %s\n", image[i].name);
+      }
+      NmissMosaic ++;
       continue;
+    }
 …
+  }
+  fprintf (stderr, "mosaic matching : %d of possible %d failed to match\n", NmissMosaic, NtestMosaic);
+  if (NmissMosaic > 0.5*NtestMosaic) {
+    fprintf (stderr, "serious problem with mosaic matching\n");
+    exit (5);
+  }
   free (startMos);
   free (stopMos);
 …
   if (im >= Nmosaic_for_images) abort();
   // search for the mosaic that
+  // search for the mosaic that matches this image
   mos = mosaic_for_images[im];
   if (mos < 0) return NULL;
 …
   return &mosaic[mos];
+}
+// extend each host image table to include the mosaic 'images' needed by the host
+int select_mosaics_hostregion (RegionHostTable *regionHosts, Image *image, off_t Nimage) {
+  int i;
+  off_t j;
+  char *mosaicUsed;
+  ALLOCATE (mosaicUsed, char, Nmosaic);
+  // we need to add the mosaics to each of the region hosts lists of images
+  for (i = 0; i < regionHosts->Nhosts; i++) {
+    int Nadd = 0;
+    int NADD = 100;
+    off_t *addMosaic = NULL;
+    ALLOCATE (addMosaic, off_t, NADD);
+    // reset the mosaicUsed flags (valid only for this host)
+    memset (mosaicUsed, 0, Nmosaic * sizeof(char));
+    RegionHostInfo *host = &regionHosts->hosts[i];
+    // find the mosaics associated with a given
+    for (j = 0; j < host->Nimage; j++) {
+      int im = host->imseq[j];
+      if (im < 0) abort();
+      if (im >= Nmosaic_for_images) abort();
+      // search for the mosaic that matches this image (skip unmatched images)
+      off_t mos = mosaic_for_images[im];
+      if (mos < 0) continue;
+      if (mosaicUsed[mos]) continue;
+      mosaicUsed[mos] = TRUE;
+      addMosaic[Nadd] = mos;
+      Nadd ++;
+      CHECK_REALLOCATE (addMosaic, off_t, NADD, Nadd, 100);
+    }
+    REALLOCATE (host->image, Image, host->Nimage + Nadd);
+    for (j = 0; j < Nadd; j++) {
+      off_t mos = addMosaic[j];
+      off_t mos_im = mosaic[mos].myImage;
+      host->image[host->Nimage + j] = image[mos_im];
+    }
+    host->Nimage += Nadd;
+  }
+  return TRUE;
+}

trunk/Ohana/src/relastro/src/StarMaps.c

-              r35105
+              r36630
   off_t i, N, Nimages;
   int xbin, ybin;
-  struct timeval start, stop;
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   // Images *images = getimages(&Nimages, NULL); return value ignored

trunk/Ohana/src/relastro/src/UpdateObjects.c

-              r36482
+              r36630
 # include "relastro.h"
 static off_t   Nmax;
+static off_t Nmax;
 static double *X, *dX;
 static double *Y, *dY;
 …
   ALLOCATE (pX, double, MAX (1, Nmax));
   ALLOCATE (pY, double, MAX (1, Nmax));
+}
+void freeObjectData () {
+  free (R);
+  free (D);
+  free (T);
+  free (X);
+  free (Y);
+  free (dR);
+  free (dD);
+  free (dT);
+  free (dX);
+  free (dY);
+  free (pX);
+  free (pY);
+}
 …
       if (((mode == FIT_PM_ONLY) || (mode == FIT_PM_AND_PAR)) && (N <= PM_TOOFEW)) mode = FIT_AVERAGE;
       if (FIT_TARGET == TARGET_HIGH_SPEED) {
+      if (RELASTRO_OP == OP_HIGH_SPEED) {
           Tmean = 0.5*(Tmax - Tmin);
       } else {
 …
+  }
+  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);
   return (TRUE);

trunk/Ohana/src/relastro/src/args.c

-              r35763
+              r36630
   /* possible operations */
   FIT_TARGET = TARGET_NONE;
+  RELASTRO_OP = OP_NONE;
   FIT_MODE = FIT_AVERAGE;
 …
     if (N > argc - 6) usage_merge_source();
     if (strcmp(argv[N+3], "into")) usage_merge_source();
     FIT_TARGET = TARGET_MERGE_SOURCE;
+    RELASTRO_OP = OP_MERGE_SOURCE;
     remove_argument (N, &argc, argv);
     OBJ_ID_SRC = strtol(argv[N], &endptr, 0);
 …
   if ((N = get_argument (argc, argv, "-update-objects"))) {
     remove_argument (N, &argc, argv);
     FIT_TARGET = TARGET_UPDATE_OBJECTS;
+    RELASTRO_OP = OP_UPDATE_OBJECTS;
+  }
   if ((N = get_argument (argc, argv, "-update-offsets"))) {
     remove_argument (N, &argc, argv);
+    FIT_TARGET = TARGET_UPDATE_OFFSETS;
+    RELASTRO_OP = OP_UPDATE_OFFSETS;
+  }
+  // elements needed for parallel regions / parallel images
+  REGION_FILE = NULL;
+  if ((N = get_argument (argc, argv, "-region-hosts"))) {
+    remove_argument (N, &argc, argv);
+    REGION_FILE = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  REGION_HOST_ID = 0;
+  if ((N = get_argument (argc, argv, "-region-hostID"))) {
+    remove_argument (N, &argc, argv);
+    REGION_HOST_ID = atoi (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  IMAGE_TABLE = NULL;
+  if ((N = get_argument (argc, argv, "-parallel-images"))) {
+    remove_argument (N, &argc, argv);
+    RELASTRO_OP = OP_PARALLEL_IMAGES;
+    if (N >= argc) usage();
+    IMAGE_TABLE = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+    if (!REGION_FILE) usage();
+  }
+  if ((N = get_argument (argc, argv, "-images"))) {
+    remove_argument (N, &argc, argv);
+    RELASTRO_OP = OP_IMAGES;
+  }
+  PARALLEL_REGIONS_MANUAL = FALSE;
+  if ((N = get_argument (argc, argv, "-parallel-regions"))) {
+    remove_argument (N, &argc, argv);
+    RELASTRO_OP = OP_PARALLEL_REGIONS;
+    if (!REGION_FILE) usage();
+    if ((N = get_argument (argc, argv, "-parallel-regions-manual"))) {
+      remove_argument (N, &argc, argv);
+      PARALLEL_REGIONS_MANUAL = TRUE;
+    }
+  }
 …
     // XXX include a parallax / no-parallax option
     if (N >= argc - 4) usage();
     FIT_TARGET = TARGET_HIGH_SPEED;
+    RELASTRO_OP = OP_HIGH_SPEED;
     remove_argument (N, &argc, argv);
     PHOTCODE_A_LIST = strcreate(argv[N]);
 …
   if ((N = get_argument (argc, argv, "-hpm"))) {
     if (N >= argc - 2) usage();
     FIT_TARGET = TARGET_HPM;
+    RELASTRO_OP = OP_HPM;
     remove_argument (N, &argc, argv);
     RADIUS = atof(argv[N]);
 …
     remove_argument (N, &argc, argv);
     PARALLEL_OUTPUT = TRUE;
     if ((FIT_TARGET != TARGET_HIGH_SPEED) && (FIT_TARGET != TARGET_HPM)) {
+    if ((RELASTRO_OP != OP_HIGH_SPEED) && (RELASTRO_OP != OP_HPM)) {
       fprintf (stderr, "-parallel-output only valid for -high-speed or -hpm modes\n");
       exit (1);
 …
+  }
+  if (FIT_TARGET == TARGET_NONE) usage();
+  if (RELASTRO_OP == OP_NONE) usage();
+  if (((RELASTRO_OP == OP_IMAGES) || (RELASTRO_OP == OP_PARALLEL_REGIONS) || (RELASTRO_OP == OP_PARALLEL_IMAGES)) && (FIT_TARGET == TARGET_NONE)) usage();
   /* specify portion of the sky : allow default of all sky? */
 …
   /* possible operations */
   FIT_TARGET = TARGET_NONE;
+  RELASTRO_OP = TARGET_NONE;
   FIT_MODE = FIT_AVERAGE;
 …
   BCATALOG = NULL;
+  REGION_FILE = NULL;
+  REGION_HOST_ID = 0;
+  IMAGE_TABLE = NULL;
+  PARALLEL_REGIONS_MANUAL = FALSE;
   HOST_ID = 0;
   if ((N = get_argument (argc, argv, "-hostID"))) {
 …
     BCATALOG = strcreate(argv[N]);
     remove_argument (N, &argc, argv);
     FIT_TARGET = TARGET_LOAD_OBJECTS;
+    RELASTRO_OP = OP_LOAD_OBJECTS;
+  }
   if ((N = get_argument (argc, argv, "-update-objects"))) {
     remove_argument (N, &argc, argv);
     FIT_TARGET = TARGET_UPDATE_OBJECTS;
+    RELASTRO_OP = OP_UPDATE_OBJECTS;
+  }
   if ((N = get_argument (argc, argv, "-update-offsets"))) {
     remove_argument (N, &argc, argv);
     FIT_TARGET = TARGET_UPDATE_OFFSETS;
+    RELASTRO_OP = OP_UPDATE_OFFSETS;
+  }
 …
     // XXX include a parallax / no-parallax option
     if (N >= argc - 5) usage_client();
     FIT_TARGET = TARGET_HIGH_SPEED;
+    RELASTRO_OP = OP_HIGH_SPEED;
     remove_argument (N, &argc, argv);
     PHOTCODE_A_LIST = strcreate(argv[N]);
 …
   if ((N = get_argument (argc, argv, "-hpm"))) {
     if (N >= argc - 3) usage();
     FIT_TARGET = TARGET_HPM;
+    RELASTRO_OP = OP_HPM;
     remove_argument (N, &argc, argv);
     RADIUS = atof(argv[N]);
 …
+  }
   if (FIT_TARGET == TARGET_NONE) usage_client();
+  if (RELASTRO_OP == OP_NONE) usage_client();
   /* specify portion of the sky : allow default of all sky? */
 …
 void usage () {
+  fprintf (stderr, "ERROR: USAGE: relastro -update-simple [options]\n");
+  fprintf (stderr, "       OR:    relastro -update-chips [options]\n");
+  fprintf (stderr, "       OR:    relastro -update-mosaic [options]\n");
+  fprintf (stderr, "ERROR: USAGE: relastro -images -update-simple [options]\n");
+  fprintf (stderr, "       OR:    relastro -images -update-chips [options]\n");
+  fprintf (stderr, "       OR:    relastro -images -update-mosaic [options]\n");
+  fprintf (stderr, "       OR:    relastro -parallel-regions -update-simple [options]\n");
+  fprintf (stderr, "       OR:    relastro -parallel-regions -update-chips [options]\n");
+  fprintf (stderr, "       OR:    relastro -parallel-regions -update-mosaic [options]\n");
+  fprintf (stderr, "       OR:    relastro -parallel-images -update-simple [options]\n");
+  fprintf (stderr, "       OR:    relastro -parallel-images -update-chips [options]\n");
+  fprintf (stderr, "       OR:    relastro -parallel-images -update-mosaic [options]\n");
   fprintf (stderr, "       OR:    relastro -update-objects [options]\n");
   fprintf (stderr, "       OR:    relastro -high-speed [options]\n");

trunk/Ohana/src/relastro/src/initialize.c

r34429	r36630
6	6	args (argc, argv);
7	7
8		if (~~FIT_TARGET == TARGET~~_MERGE_SOURCE) return;
	8	if (RELASTRO_OP == OP_MERGE_SOURCE) return;
9	9
10	10	fprintf (stderr, "PHOTCODE_KEEP_LIST: %s\n", PHOTCODE_KEEP_LIST);

trunk/Ohana/src/relastro/src/load_catalogs.c

-              r35105
+              r36630
 Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog) {
+  char uniquer[12];
+  int TIME = time(NULL);
+  int PID = getpid();
+  snprintf (uniquer, 12, "%05d.%05d", PID, TIME % 100000);
   // load the list of hosts
   HostTable *table = HostTableLoad (CATDIR, sky->hosts);
 …
     ALLOCATE (table->hosts[i].results, char, 1024);
     snprintf (table->hosts[i].results, 1024, "%s/relastro.catalog.subset.dat", table->hosts[i].pathname);
+    snprintf (table->hosts[i].results, 1024, "%s/relastro.catalog.%s.dat", table->hosts[i].pathname, uniquer);
     // options / arguments that can affect relastro_client -load:

trunk/Ohana/src/relastro/src/load_images.c

-              r35763
+              r36630
 # include "relastro.h"
-# define MARKTIME(MSG,...) { \
-  float dtime; \
-  gettimeofday (&stop, (void *) NULL); \
-  dtime = DTIME (stop, start); \
-  fprintf (stderr, MSG, __VA_ARGS__); }
 int load_images (FITS_DB *db, SkyList *skylist, int UseFullOverlap) {
 …
   off_t      Nimage, Nsubset;
   off_t     *LineNumber;
-  struct timeval start, stop;
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   // convert database table to internal structure
 …
   /* unlock, if we can (else, unlocked below) */
   int unlockImages = !UPDATE || (FIT_TARGET == TARGET_UPDATE_OFFSETS);
+  int unlockImages = !UPDATE || (RELASTRO_OP == OP_UPDATE_OFFSETS);
   if (unlockImages) dvo_image_unlock (db);

trunk/Ohana/src/relastro/src/relastro.c

-              r35763
+              r36630
   SkyList *skylist = SkyListByPatch (sky, -1, &UserPatch);
   switch (FIT_TARGET) {
     case TARGET_UPDATE_OBJECTS:
+  switch (RELASTRO_OP) {
+    case OP_UPDATE_OBJECTS:
       /* the object analysis is a separate process iterating over catalogs */
       relastro_objects (skylist, 0, NULL);
       exit (0);
     case TARGET_HIGH_SPEED:
+    case OP_HIGH_SPEED:
       /* high-speed is a 2pt cross-correlation process for linking moving objects (high PM) */
       high_speed_catalogs (sky, skylist, 0, NULL);
       exit (0);
     case TARGET_HPM:
+    case OP_HPM:
       hpm_catalogs (sky, skylist, 0, NULL);
       exit (0);
     case TARGET_MERGE_SOURCE:
+    case OP_MERGE_SOURCE:
       /* a special method to manually merge unlinked detections of sources togther (not parallel) */
       relastro_merge_source (sky);
       exit (0);
+    case TARGET_SIMPLE:
+    case TARGET_CHIPS:
+    case TARGET_MOSAICS:
+    case OP_IMAGES:
       relastro_images (skylist);
       exit (0);
     case TARGET_UPDATE_OFFSETS:
+    case OP_UPDATE_OFFSETS:
       // iterate over catalogs to make detection coordinates consistant
       UpdateObjectOffsets (skylist, 0, NULL);
+      exit (0);
+    case OP_PARALLEL_REGIONS:
+      // run image updates in parallel across multiple remote machines
+      relastro_parallel_regions ();
+      exit (0);
+    case OP_PARALLEL_IMAGES:
+      // operation on the remote machines in the PARALLEL_REGION mode
+      relastro_parallel_images ();
       exit (0);

trunk/Ohana/src/relastro/src/relastro_client.c

-              r35763
+              r36630
   SkyList *skylist = SkyListByPatch (sky, -1, &UserPatch);
   switch (FIT_TARGET) {
+  switch (RELASTRO_OP) {
     case TARGET_LOAD_OBJECTS: {
+    case OP_LOAD_OBJECTS: {
       // USAGE: relastro_client -load-objects
       int Ncatalog;
       Catalog *catalog = load_catalogs (skylist, &Ncatalog, TRUE, HOST_ID, HOSTDIR);
       if (!catalog) {
           fprintf (stderr, "ERROR loading catalogs from %s\n", CATDIR);
           exit (2);
+        fprintf (stderr, "ERROR loading catalogs from %s\n", CATDIR);
+        exit (2);
+      }
       BrightCatalog *bcatalog = BrightCatalogMerge (catalog, Ncatalog);
       if (!BrightCatalogSave (BCATALOG, bcatalog)) {
           fprintf (stderr, "ERROR saving bright catalog from %s\n", CATDIR);
           exit (2);
+        fprintf (stderr, "ERROR saving bright catalog from %s\n", CATDIR);
+        exit (2);
+      }
       break;
+    }
     case TARGET_UPDATE_OBJECTS: {
+    case OP_UPDATE_OBJECTS: {
       // USAGE: relastro_client -update-objects
       relastro_objects (skylist, HOST_ID, HOSTDIR);
 …
+    }
     case TARGET_HIGH_SPEED: {
+    case OP_HIGH_SPEED: {
       // USAGE: relastro_client -high-speed
       high_speed_catalogs (sky, skylist, HOST_ID, HOSTDIR);
 …
+    }
     case TARGET_HPM: {
+    case OP_HPM: {
       // USAGE: relastro_client -high-speed
       hpm_catalogs (sky, skylist, HOST_ID, HOSTDIR);
 …
+    }
       // XXX loading the images is fairly costly -- see if we can do an image subset
     case TARGET_UPDATE_OFFSETS: {
+      // XXX loading the images is fairly costly -- see if we can do an image subset?
+    case OP_UPDATE_OFFSETS: {
       FITS_DB db;

trunk/Ohana/src/relastro/src/relastro_images.c

-              r35763
+              r36630
   Catalog *catalog;
   FITS_DB db;
-  struct timeval start, stop;
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   /* register database handle with shutdown procedure */

trunk/Ohana/src/relastro/src/relastro_objects.c

r35763	r36630
144	144	// PM_TOOFEW
145	145	// SRC_MEAS_TOOFEW
146		~~// FIT_TARGET~~
147	146
148	147	char command[1024];

trunk/Ohana/src/relastro/src/resort_catalog.c

-              r34088
+              r36630
   if (catalog[0].sorted == TRUE) return;
+  // struct timeval start, stop;
+  // gettimeofday (&start, NULL);
+  // INITTIME;
   /* internal counters */

trunk/Ohana/src/relastro/src/select_images.c

-              r36482
+              r36630
 void dsortindex (double *X, off_t *Y, int N);
 off_t getRegionStartByRA (double R, double *Rref, off_t Nregions);
-# define MARKTIME(MSG,...) { \
-  float dtime; \
-  gettimeofday (&stop, (void *) NULL); \
-  dtime = DTIME (stop, start); \
-  fprintf (stderr, MSG, __VA_ARGS__); }
 Image *select_images (SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage, int UseFullOverlap) {
 …
   Coords tcoords;
   SkyRegionCoords *skycoords;
-  struct timeval start, stop;
   double RmaxSkyRegion, RminSkyRegion, RmidSkyRegion, DminSkyRegion, DmaxSkyRegion;
 …
+  }
   gettimeofday (&start, (void *) NULL);
+  INITTIME;
   // the comparison is made in the catalog local projection. below we set crval1,2
 …
     if (NphotcodesKeep > 0) {
       found = FALSE;
+      // XXX this bit of code excludes DIS mosaics and should be fixed
+      // we have to keep DIS mosaics explicitly (photcode = 0)
+      if (!strcmp(&timage[i].coords.ctype[4], "-DIS")) found = TRUE;
       for (k = 0; (k < NphotcodesKeep) && !found; k++) {
         if (photcodesKeep[k][0].code == timage[i].photcode) found = TRUE;

trunk/Ohana/src/relphot/Makefile

-              r35416
+              r36630
 $(SRC)/relphot_images.$(ARCH).o  \
 $(SRC)/relphot_objects.$(ARCH).o         \
+$(SRC)/relphot_parallel_regions.$(ARCH).o \
+$(SRC)/relphot_parallel_images.$(ARCH).o \
 $(SRC)/select_images.$(ARCH).o   \
+$(SRC)/assign_images.$(ARCH).o   \
+$(SRC)/launch_region_hosts.$(ARCH).o     \
+$(SRC)/ImageTable.$(ARCH).o      \
+$(SRC)/ImageMagIO.$(ARCH).o      \
+$(SRC)/syncfile.$(ARCH).o        \
+$(SRC)/share_image_mags.$(ARCH).o        \
+$(SRC)/share_mean_mags.$(ARCH).o         \
+$(SRC)/MeanMagIO.$(ARCH).o       \
+$(SRC)/indexCatalog.$(ARCH).o    \
 $(SRC)/client_logger.$(ARCH).o   \
 $(SRC)/setExclusions.$(ARCH).o   \

trunk/Ohana/src/relphot/doc/parallel.txt

-              r33651
+              r36630
+.02.15
+Nearly done with the relphot mods.  some outstanding questions;
+ * image vs mosaic?
+ * how do decide which images need to be shared?
+.02.14
+ more relphot notes:
+ * I load the catalogs, with a
+.02.12
+I am making progess on the relphot -parallel-regions implementation.  some things I need to deal with:
+ * assign_images: select mosaics for all images saved for a given host (need to supply them as well)
+   ** I need to decide on the Image / Mosaic split.  If I am calibrating by image, then the image center defines ownership
+   ** if I am calibrating by exposure, then the mosaic center must define ownership
+ o determine SkyList covering the images for region host
+ o tag detections and objects which I own or do not own
+   o ImageOps.c / matchImage matches detections to images and needs to handle mine / not mine cases
+   o ditto for matchMosaics
+ o load_catalogs : I need to make my requested catalogs unique (just add uniquer to load_catalogs.c:130
+ o figure out what fields I'm saving in meanmags and how to construct it
+   -- mag, objID, catID, photcode, (dmag or other stats?)
+ * from which hosts do I slurp mean mags?
+ o function to merge a new meanmag array into the existing one
+ o how to go from (objID,catID) to a given catalog[i].average[j]
+.02.06
+** a single region-level host owns images for which the center lands
+   in its region.
+** it owns detections which come from images which it owns
+** it owns objects which land in its region
+Extending parallel relphot processing to split the sky (and images)
+into regions, each of which runs in parallel at the same time:
+Top Level (relphot -parallel-images):
+ * define regions of the sky -> hosts
+ * load images, assign to hosts
+ * launch region-level jobs on remote hosts
+ Region Level (relphot -parallel-images-region)
+  * load my image subset table
+  * request objects and detections for my skyregion
+  * match images & objects, etc
+  * update my image parameters
+  * update my detections
+  * write out detections
+  * load detections from my border hosts
+  * match to my objects
+  * update my objects
+  * write out objects
+  * load objects from my border hosts
+  * update images
+    (iterate N times)
+  * write out image parameters
+Top Level
+  * read image parameters, update
+  * update objects
 .02.13

trunk/Ohana/src/relphot/include/relphot.h

-              r36528
+              r36630
 // # define IDX_T off_t
 # define IDX_T int
+typedef enum {
+  MODE_ERROR = 0,
+  UPDATE_IMAGES,
+  UPDATE_AVERAGES,
+  PARALLEL_REGIONS,
+  PARALLEL_IMAGES,
+  APPLY_OFFSETS,
+} RelphotMode;
 typedef enum {
 …
 typedef struct {
+  float M;
+  float dM;
+  float Xm;
+  int Nsec;
+  unsigned int objID;
+  unsigned int catID;
+  int photcode;
+} MeanMag;
+typedef struct {
+  float Mcal;
+  float dMcal;
+  float dMagSys;
+  float Xm;
+  int nFitPhotom;
+  int flags;
+  unsigned int imageID;
+  short ubercalDist;
+} ImageMag;
+typedef struct {
   AverageTiny *average;       // array of (minimal) average data
   MeasureTiny *measure;       // array of (minimal) measure data
 …
 int    SKY_DEPTH;  /** XXX EAM : depth of catalog tables, fix usage */
+// globals for parallel region operations
+char  *REGION_FILE;
+char  *IMAGE_TABLE;
+int    REGION_HOST_ID;
 int          HOST_ID;
 char        *HOSTDIR;
 …
 int    PARALLEL_MANUAL;
 int    PARALLEL_SERIAL;
+int    PARALLEL_REGIONS_MANUAL;
 int    NTHREADS;
 …
 void          InterpolateGrid     PROTO((float *buffer, int Nx, int Ny, Coords *ccd, Coords *gcoords));
 off_t        *SelectRefMosaic     PROTO((Mosaic **refmosaic, off_t *Nimage));
 int           args                PROTO((int argc, char **argv));
+RelphotMode   args                PROTO((int argc, char **argv));
 int           args_client         PROTO((int argc, char **argv));
 int           bcatalog            PROTO((Catalog *subcatalog, Catalog *catalog, int Ncat));
 …
 void          findImages          PROTO((Catalog *catalog, int Ncatalog, int doImageList));
 int           findMosaics         PROTO((Catalog *catalog, int Ncatalog, int doMosaicList));
+void makeMosaics (Image *image, off_t Nimage);
+Mosaic *getMosaicForImage (off_t im);
+void setMosaicCenters (Image *image, off_t Nimage);
 void set_db (FITS_DB *in);
 …
 void          initMosaics         PROTO((Image *subset, off_t Nsubset, Image *image, char *inSubset, off_t Nimage));
 void          initMrel            PROTO((Catalog *catalog, int Ncatalog));
 void          initialize          PROTO((int argc, char **argv));
+RelphotMode   initialize          PROTO((int argc, char **argv));
 void          initialize_client   PROTO((int argc, char **argv));
 void          liststats_setmode   PROTO((StatType *stats, char *strmode));
 …
 int init_synthetic_mags ();
 int add_synthetic_mags (AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, off_t *Nmeasure, off_t *Nm);
+int relphot_parallel_regions ();
+int assign_images (FITS_DB *db, RegionHostTable *regionHosts);
+int select_images_hostregion (RegionHostTable *hosts, Image *image, off_t Nimage);
+int find_host_for_coords (RegionHostTable *regionHosts, double R, double d);
+int calculate_image_bounds (Image *image, double *rmin, double *rmax, double *dmin, double *dmax, double Rmid);
+int launch_region_hosts (RegionHostTable *regionHosts);
+int strextend (char *input, char *format,...);
+Image *ImageTableLoad(char *filename, off_t *nimage);
+int ImageTableSave (char *filename, Image *images, off_t Nimages);
+int indexCatalogs (Catalog *catalog, int Ncatalog);
+int catID_and_objID_to_seq (int catID, int objID, int *catSeq, off_t *objSeq);
+int check_sync_file (char *filename, int nloop);
+int clear_sync_file (char *filename);
+int update_sync_file (char *filename, int nloop);
+char *make_filename (char *dirname, char *hostname, int hostID, char *tailname);
+int share_mean_mags (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop);
+int slurp_mean_mags (Catalog *catalog, int Ncatalog, RegionHostTable *regionHosts, int nloop);
+int set_mean_mags (MeanMag *meanmags, AverageTiny *average, SecFilt *secfilt, int Nsec);
+MeanMag *merge_mean_mags (MeanMag *target, int *ntarget, MeanMag *source, int Nsource);
+MeanMag *MeanMagLoad(char *filename, off_t *nmeanmags);
+int MeanMagSave(char *filename, MeanMag *meanmags, off_t Nmeanmags);
+int share_image_mags (RegionHostTable *regionHosts, int nloop);
+int slurp_image_mags (RegionHostTable *regionHosts, int nloop);
+int set_image_mags (ImageMag *image_mags, Image *image);
+ImageMag *merge_image_mags (ImageMag *target, int *ntarget, ImageMag *source, int Nsource);
+ImageMag *ImageMagLoad(char *filename, off_t *nimage_mags);
+int ImageMagSave(char *filename, ImageMag *image_mags, off_t Nimage_mags);
+int markObjects (Catalog *catalog, int Ncatalog);
+int relphot_parallel_images ();
+int relphot_parallel_regions ();

trunk/Ohana/src/relphot/src/BrightCatalog.c

-              r33651
+              r36630
       measure[i].catID     = catID[i];
       measure[i].photcode  = photcode[i];
+      measure[i].myDet     = FALSE;
+    }
     fprintf (stderr, "loaded data for %lld measure\n", (long long) Nrow);
 …
     GET_COLUMN(flags,         "FLAGS",       int);
     GET_COLUMN(catID,         "CAT_ID",      int);
+    GET_COLUMN(objID,         "OBJ_ID",      int);
     gfits_free_header (&theader);
     gfits_free_table  (&ftable);
 …
       average[i].flags          = flags[i];
       average[i].catID          = catID[i];
+      average[i].objID          = objID[i];
+      average[i].nOwn           = 0;
+    }
     fprintf (stderr, "loaded data for %lld average\n", (long long) Nrow);
 …
     free (flags         );
     free (catID         );
+    free (objID         );
     catalog->average = average;
 …
     gfits_define_bintable_column (&theader, "J", "FLAGS",       "flags",                  NULL,    1.0, 0.0);
     gfits_define_bintable_column (&theader, "J", "CAT_ID",      "catalog ref",            NULL,    1.0, 0.0);
+    gfits_define_bintable_column (&theader, "J", "OBJ_ID",      "object ref",             NULL,    1.0, 0.0);
     // generate the output array that carries the data
 …
     int   *flags          ; ALLOCATE (flags,         int,    catalog->Naverage);
     int   *catID          ; ALLOCATE (catID,         int,    catalog->Naverage);
+    int   *objID          ; ALLOCATE (objID,         int,    catalog->Naverage);
     // assign the storage arrays
 …
       flags[i]          = average[i].flags;
       catID[i]          = average[i].catID;
+      objID[i]          = average[i].objID;
+    }
 …
     gfits_set_bintable_column (&theader, &ftable, "FLAGS",       flags,         catalog->Naverage);
     gfits_set_bintable_column (&theader, &ftable, "CAT_ID",      catID,         catalog->Naverage);
+    gfits_set_bintable_column (&theader, &ftable, "OBJ_ID",      objID,         catalog->Naverage);
     free (R             );
 …
     free (flags         );
     free (catID         );
+    free (objID         );
     gfits_fwrite_Theader (f, &theader);

trunk/Ohana/src/relphot/src/ImageOps.c

-              r36491
+              r36630
   int Nmatch = 0;
  for (i = 0; i < Ncatalog; i++) {
+  for (i = 0; i < Ncatalog; i++) {
     for (j = 0; j < catalog[i].Nmeasure; j++) {
+      catalog[i].measureT[j].myDet = FALSE; // a detetion is not mine until proven otherwise
       ecode = GetPhotcodeEquivCodebyCode (catalog[i].measureT[j].photcode);
+      // skip measurements which do not match one of the requested photcodes (
+      // (do we not already exclude in bcatalog -- maybe needed for reload_objects?
       found = FALSE;
       for (Ns = 0; !found && (Ns < Nphotcodes); Ns++) {
 …
+      }
       if (!found) continue;
+      // if we match one of our images, myDet gets set to TRUE
       matchImage (catalog, j, i, doImageList);
       Nmatch ++;
 …
     return;
+  }
+  catalog[cat].measureT[meas].myDet = TRUE;
   if (USE_GRID) {

trunk/Ohana/src/relphot/src/MosaicOps.c

-              r36491
+              r36630
+}
+/* find mosaic frames (unique time periods) (NOTE : we do NOT require matching photcodes but we
+   match images by MOSAICNAME.  this last point is weak: it forces a single camera at a time.
+   we can extend the logic to multiple cameras if we make list of MOSAICNAMES (better to assign a camera ID)
+ */
+void makeMosaics (Image *image, off_t Nimage) {
+  off_t i, j, status, found, NMOSAIC, *MosaicN_IMAGE;
+  unsigned int start, stop, *startTimes, *startTimesMosaic;
+  char *pname;
+  if (!MOSAIC_ZEROPT) return;
+  INITTIME;
+  /* a 'mosaic' in relphot is (unlike relastro) a virtual concept: there is no
+   * entry in the image table that represents this mosaic.  Instead, it is an
+   * internal construct that defines a group of related images
+   */
+  // generate a list of all image start times
+  ALLOCATE (startTimes, unsigned int, Nimage);
+  for (i = 0; i < Nimage; i++) {
+    startTimes[i] = image[i].tzero;
+  }
+  sort_times (startTimes, Nimage);
+  MARKTIME("create array of all image obstimes: %f sec\n", dtime);
+  Nmosaic = 0;
+  NMOSAIC = 1000;
+  ALLOCATE (startTimesMosaic, unsigned int, NMOSAIC);
+  startTimesMosaic[0] = startTimes[0];
+  // generate a list of the unique start times (these define the mosaics)
+  for (i = 0; i < Nimage; i++) {
+    if (startTimes[i] < startTimesMosaic[Nmosaic]) {
+      fprintf (stderr, "error?\n");
+      abort();
+    }
+    if (startTimes[i] == startTimesMosaic[Nmosaic]) continue;
+    Nmosaic ++;
+    if (Nmosaic >= NMOSAIC) {
+      NMOSAIC += 1000;
+      REALLOCATE (startTimesMosaic, unsigned int, NMOSAIC);
+    }
+    startTimesMosaic[Nmosaic] = startTimes[i];
+  }
+  Nmosaic ++;
+  MARKTIME("create array of mosaic obstimes: %f sec\n", dtime);
+  // now I have a list of uniq start times, and they are in order
+  // create the mosaic arrays for these times
+  ALLOCATE (mosaic, Mosaic, Nmosaic);
+  ALLOCATE (MosaicToImage, off_t *, Nmosaic);
+  ALLOCATE (MosaicN_Image, off_t,   Nmosaic);
+  ALLOCATE (MosaicN_IMAGE, off_t,   Nmosaic);
+  // init the mosaic array values
+  for (i = 0; i < Nmosaic; i++) {
+    mosaic[i].start = startTimesMosaic[i];
+    mosaic[i].stop  = 0;
+    mosaic[i].Mcal  = 0.0;
+    mosaic[i].dMcal = 0.0;
+    mosaic[i].dMsys = 0.0;
+    mosaic[i].Xm    = 0.0;
+    mosaic[i].flags = 0;
+    mosaic[i].secz  = NAN;
+    mosaic[i].photcode = 0;
+    mosaic[i].skipCal = FALSE;
+    memset (&mosaic[i].coords, 0, sizeof(Coords));
+    MosaicN_IMAGE[i] = 10;
+    MosaicN_Image[i] = 0;
+    ALLOCATE (MosaicToImage[i], off_t, MosaicN_IMAGE[i]);
+    MosaicToImage[i][0] = -1;
+  }
+  ALLOCATE (ImageToMosaic, off_t, Nimage); // mosaic to which image belongs
+  // assign each image to a mosaic
+  for (i = 0; i < Nimage; i++) {
+    ImageToMosaic[i] = -1;
+    /* select valid mosaic images by photcode */
+    pname = GetPhotcodeNamebyCode (image[i].photcode);
+    if (!pname) continue;
+    status = strncmp (pname, MOSAICNAME, strlen (MOSAICNAME));
+    if (status) continue;
+    start = image[i].tzero;
+    stop  = image[i].tzero + MAX(1.01*image[i].trate*image[i].NY, 1);
+    j = findMosaic(startTimesMosaic, Nmosaic, start);
+    if (j == -1) {
+      fprintf (stderr, "programming error? all image images should belong to a mosaic\n");
+      abort();
+    }
+    // add reference from image to mosaic
+    ImageToMosaic[i] = j;
+    // have we already found this mosaic?
+    found = (MosaicN_Image[j] > 0);
+    /* add image to mosaic image list */
+    MosaicToImage[j][MosaicN_Image[j]] = i;
+    MosaicN_Image[j] ++;
+    if (MosaicN_Image[j] == MosaicN_IMAGE[j]) {
+      MosaicN_IMAGE[j] += 10;
+      REALLOCATE (MosaicToImage[j], off_t, MosaicN_IMAGE[j]);
+    }
+    if (found) continue;
+    /* a new mosaic, define ranges */
+    if (mosaic[j].start != start) {
+      fprintf (stderr, "error?\n");
+      abort();
+    }
+    mosaic[j].stop  = stop;
+    mosaic[j].Mcal  = 0.0;
+    mosaic[j].dMcal = 0.0;
+    mosaic[j].Xm    = 0.0;
+    mosaic[j].dMsys = image[i].flags;
+    mosaic[j].flags = image[i].flags;
+    mosaic[j].secz  = image[i].secz;
+    mosaic[j].photcode = GetPhotcodeEquivCodebyCode (image[i].photcode);
+  }
+  MARKTIME("assign images to mosaic: %f sec\n", dtime);
+  // free this or not?
+  free (MosaicN_IMAGE);
+  free (startTimes);
+  free (startTimesMosaic);
+  fprintf (stderr, "matched %d images to %d mosaics\n", (int) Nimage, (int) Nmosaic);
+  return;
+}
+Mosaic *getMosaicForImage (off_t im) {
+  if (im < 0) return NULL;
+  if (!ImageToMosaic) return NULL;
+  off_t m = ImageToMosaic[im];
+  if (m < 0) return NULL;
+  if (m >= Nmosaic) return NULL;
+  return (&mosaic[m]);
+}
 // use bisection to find the overlapping mosaic (returns exact match)
 // startTimes is a sorted, unique list of times
 …
+  }
   return (-1);
+}
+void setMosaicCenters (Image *image, off_t Nimage) {
+  /* find max dR, dD range for all mosaics */
+  /* define mosaic.coords to cover dR, dD */
+  /* send results to initGridBins */
+  off_t i, j, m, NX, NY, NC, Nc;
+  double R, D, Rmid, Dmid;
+  double Mcal, dMcal, Xm;
+  double *Rc, *Dc;
+  NC = 100;
+  ALLOCATE (Rc, double, NC);
+  ALLOCATE (Dc, double, NC);
+  for (i = 0; i < Nmosaic; i++) {
+    Nc = 0;
+    Rmid = Dmid = NAN;
+    Mcal = dMcal = Xm = 0;
+    for (j = 0; j < MosaicN_Image[i]; j++) {
+      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);
+      R = ohana_normalize_angle_to_midpoint (R, 180.0);
+      // Exclude images with crazy astrometry
+      // XXX NOTE : this is gpc1-specific
+      {
+        double dP1 = hypot(image[m].coords.pc1_1, image[m].coords.pc1_2);
+        double dP2 = hypot(image[m].coords.pc2_1, image[m].coords.pc2_2);
+        if (fabs(dP1 - 1.0) > 0.02) continue;
+        if (fabs(dP2 - 1.0) > 0.02) continue;
+        double X00, Y00, X10, Y10, X01, Y01;
+        XY_to_LM (&X00, &Y00, 0.0, 0.0, &image[m].coords);
+        XY_to_LM (&X10, &Y10, image[m].NX, 0.0, &image[m].coords);
+        XY_to_LM (&X01, &Y01, 0.0, image[m].NY, &image[m].coords);
+        double dS0 = hypot ((X00 - X10), (Y00 - Y10));
+        double dS1 = hypot ((X00 - X01), (Y00 - Y01));
+        if (dS0 > 6000) continue;
+        if (dS1 > 6500) continue;
+      }
+      Rc[Nc] = R;
+      Dc[Nc] = D;
+      Nc ++;
+      if (Nc >= NC) {
+        NC += 100;
+        REALLOCATE (Rc, double, NC);
+        REALLOCATE (Dc, double, NC);
+      }
+      Mcal  += image[m].Mcal;
+      dMcal += image[m].dMcal;
+      Xm    += image[m].Xm;
+      // for ubercal images, we (elsewhere) keep Mcal frozen
+      /* we are using mosaic.Mcal, not image.Mcal. reset image.Mcal */
+      image[m].Mcal  = 0.0;
+      image[m].dMcal = NAN;
+      image[m].Xm    = NAN_S_SHORT;
+    }
+    if (Nc > 0) {
+      dsort (Rc, Nc);
+      if (Rc[Nc-1] - Rc[0] > 180.0) {
+        // in our list, Rc is in the range 0.0 to 360.0.
+        // any mosaic which is close to the 0.0, 360.0 boundary may have some on
+        // one side or the other.  count how many have values more than Rc[0] + 180.
+        // if more than half are at the large end, re-normalize to that range
+        int Nbig = 0;
+        for (j = 1; j < Nc; j++) {
+          if (Rc[j] - Rc[0] > 180.0) Nbig ++;
+        }
+        if (Nbig  > 0.5*Nc) {
+          for (j = 0; j < Nc; j++) {
+            Rc[j] = ohana_normalize_angle_to_midpoint (Rc[j], 360.0);
+          }
+          dsort (Rc, Nc);
+        } else if (Nbig > 0) {
+          for (j = 0; j < Nc; j++) {
+            Rc[j] = ohana_normalize_angle_to_midpoint (Rc[j], 0.0);
+          }
+          dsort (Rc, Nc);
+        }
+      }
+      dsort (Dc, Nc);
+      Rmid = Rc[(int)(0.5*Nc)];
+      Dmid = Dc[(int)(0.5*Nc)];
+    }
+    strcpy (mosaic[i].coords.ctype, "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  = Mcal / MosaicN_Image[i];
+    mosaic[i].dMcal = dMcal / MosaicN_Image[i];
+    mosaic[i].Xm    = Xm / MosaicN_Image[i];
+  }
+  return;
+}
 …
   if (!MOSAIC_ZEROPT) return (FALSE);
+  // if we are calibrating by mosaic, redefine myDet == on one of my mosaics
   int Nmatch = 0;
   for (i = 0; i < Ncatalog; i++) {
     for (j = 0; j < catalog[i].Nmeasure; j++) {
+      catalog[i].measureT[j].myDet = FALSE; // a detetion is not mine until proven otherwise
       if (TimeSelect) {
         if (catalog[i].measureT[j].t < TSTART) continue;
 …
+  }
+  // this measurement is on one of my mosaics, mark it as mine.
+  catalog[cat].measureT[meas].myDet = TRUE;
   MeasureToMosaic[cat][meas] = mosID;

trunk/Ohana/src/relphot/src/StarOps.c

-              r36528
+              r36630
+}
+int markObjects (Catalog *catalog, int Ncatalog) {
+  int i, n;
+  off_t j;
+  // How strongly do I own this object?
+  for (i = 0; i < Ncatalog; i++) {
+    for (j = 0; j < catalog[i].Naverage; j++) {
+      int nOwn = 0;
+      int m = catalog[i].averageT[j].measureOffset;
+      for (n = 0; n < catalog[i].averageT[j].Nmeasure; n++) {
+        if (!catalog[i].measureT[m+n].myDet) continue;
+        nOwn ++;
+      }
+      catalog[i].averageT[j].nOwn = nOwn;
+    }
+  }
+  return TRUE;
+}
+int dumpObjects (char *filename, Catalog *catalog, int Ncatalog) {
+  int i, n;
+  off_t j;
+  FILE *ftest = fopen (filename, "w");
+  for (i = 0; i < Ncatalog; i++) {
+    for (j = 0; j < catalog[i].Naverage; j++) {
+      int m = catalog[i].averageT[j].measureOffset;
+      for (n = 0; n < catalog[i].averageT[j].Nmeasure; n++) {
+        fprintf (ftest, "%08x %08x %10.6f %10.6f  %3d %1d\n", catalog[i].averageT[j].catID, catalog[i].averageT[j].objID, catalog[i].averageT[j].R, catalog[i].averageT[j].D, catalog[i].averageT[j].Nmeasure, catalog[i].measureT[m+n].myDet);
+      }
+    }
+  }
+  fclose (ftest);
+  return TRUE;
+}
 void clean_stars (Catalog *catalog, int Ncatalog) {

trunk/Ohana/src/relphot/src/args.c

-              r36491
+              r36630
 # include "relphot.h"
 int args (int argc, char **argv) {
+RelphotMode args (int argc, char **argv) {
   int N;
   double trange;
+  /* define time */
+  TimeSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-time"))) {
+    remove_argument (N, &argc, argv);
+    if (!ohana_str_to_time (argv[N], &TSTART)) {
+      fprintf (stderr, "ERROR: syntax error\n");
+      return (MODE_ERROR);
+    }
+    remove_argument (N, &argc, argv);
+    if (!ohana_str_to_dtime (argv[N], &trange)) {
+      if (!ohana_str_to_time (argv[N], &TSTOP)) {
+        fprintf (stderr, "ERROR: syntax error\n");
+        return (MODE_ERROR);
+      }
+    } else {
+      if (trange < 0) {
+        trange = fabs (trange);
+        TSTOP = TSTART;
+        TSTART -= trange;
+      } else {
+        TSTOP = TSTART + trange;
+      }
+    }
+    remove_argument (N, &argc, argv);
+    TimeSelect = TRUE;
+  }
+  /* specify portion of the sky */
+  UserPatch.Rmin = 0;
+  UserPatch.Rmax = 360;
+  UserPatch.Dmin = -90;
+  UserPatch.Dmax = +90;
+  if ((N = get_argument (argc, argv, "-region"))) {
+    remove_argument (N, &argc, argv);
+    UserPatch.Rmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Rmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Dmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Dmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  /* specify region file by name (eg n0000/0000.00) */
+  UserCatalog = NULL;
+  if ((N = get_argument (argc, argv, "-catalog"))) {
+    remove_argument (N, &argc, argv);
+    UserCatalog = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  USE_BASIC_CHECK = FALSE;
+  if ((N = get_argument (argc, argv, "-basic-image-search"))) {
+    remove_argument (N, &argc, argv);
+    USE_BASIC_CHECK = TRUE;
+  }
+  USE_FULL_OVERLAP = TRUE;
+  if ((N = get_argument (argc, argv, "-sloppy-image-overlap"))) {
+    remove_argument (N, &argc, argv);
+    USE_FULL_OVERLAP = FALSE;
+  }
+  SET_MREL_VERSION = 1;
+  if ((N = get_argument (argc, argv, "-set-mrel-version"))) {
+    remove_argument (N, &argc, argv);
+    SET_MREL_VERSION = atof(argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  VERBOSE = VERBOSE2 = FALSE;
+  if ((N = get_argument (argc, argv, "-v"))) {
+    VERBOSE = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-vv"))) {
+    VERBOSE2 = VERBOSE = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  NTHREADS = 0;
+  if ((N = get_argument (argc, argv, "-threads"))) {
+    remove_argument (N, &argc, argv);
+    NTHREADS = atof (argv[N]);
+    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
+  HOST_ID = 0;
+  PARALLEL = FALSE;
+  if ((N = get_argument (argc, argv, "-parallel"))) {
+    PARALLEL = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  // this is a test mode : rather than launching the remote jobs and waiting for completion,
+  // relphot will simply list the remote command and wait for the user to signal completion
+  PARALLEL_MANUAL = FALSE;
+  if ((N = get_argument (argc, argv, "-parallel-manual"))) {
+    PARALLEL = TRUE; // -parallel-manual implies -parallel
+    PARALLEL_MANUAL = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  // this is a test mode : rather than launching the relphot_client jobs remotely, they are
+  // run in serial via 'system'
+  PARALLEL_SERIAL = FALSE;
+  if ((N = get_argument (argc, argv, "-parallel-serial"))) {
+    if (PARALLEL_MANUAL) {
+      fprintf (stderr, "ERROR: cannot mix -parallel-manual and -parallel-serial\n");
+      exit (1);
+    }
+    PARALLEL = TRUE; // -parallel-serial implies -parallel
+    PARALLEL_SERIAL = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  PLOTSTUFF = FALSE;
+  if ((N = get_argument (argc, argv, "-plot"))) {
+    PLOTSTUFF = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  PLOTDELAY = 500000;
+  if ((N = get_argument (argc, argv, "-plotdelay"))) {
+    remove_argument (N, &argc, argv);
+    PLOTDELAY = 1e6*atof(argv[N]);
+    PLOTSTUFF = TRUE; // always turn on plotting if i request a plot delay
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-outroot"))) {
+    remove_argument (N, &argc, argv);
+    OUTROOT = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  } else {
+    OUTROOT = strcreate ("relphot");
+  }
+  strcpy (STATMODE, "WT_MEAN");
+  if ((N = get_argument (argc, argv, "-statmode"))) {
+    remove_argument (N, &argc, argv);
+    strcpy (STATMODE, argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  NLOOP = 8;
+  if ((N = get_argument (argc, argv, "-n"))) {
+    remove_argument (N, &argc, argv);
+    NLOOP = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-nloop"))) {
+    remove_argument (N, &argc, argv);
+    NLOOP = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  NGRID = 8;
+  if ((N = get_argument (argc, argv, "-ngrid"))) {
+    remove_argument (N, &argc, argv);
+    NGRID = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  RESET = FALSE;
+  if ((N = get_argument (argc, argv, "-reset"))) {
+    remove_argument (N, &argc, argv);
+    RESET = TRUE;
+  }
+  RESET_ZEROPTS = FALSE;
+  if ((N = get_argument (argc, argv, "-reset-zpts"))) {
+    remove_argument (N, &argc, argv);
+    RESET_ZEROPTS = TRUE;
+  }
+  UPDATE = FALSE;
+  if ((N = get_argument (argc, argv, "-update"))) {
+    remove_argument (N, &argc, argv);
+    UPDATE = TRUE;
+  }
+  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);
+  }
+  SAVE_IMAGE_UPDATES = TRUE;
+  if ((N = get_argument (argc, argv, "-skip-image-updates"))) {
+    remove_argument (N, &argc, argv);
+    SAVE_IMAGE_UPDATES = FALSE;
+  }
+  MaxDensityUse = FALSE;
+  if ((N = get_argument (argc, argv, "-max-density"))) {
+    remove_argument (N, &argc, argv);
+    MaxDensityValue = atof(argv[N]);
+    remove_argument (N, &argc, argv);
+    MaxDensityUse = TRUE;
+  }
+  CLOUD_TOLERANCE = 0.02;
+  if ((N = get_argument (argc, argv, "-cloud-limit"))) {
+    remove_argument (N, &argc, argv);
+    CLOUD_TOLERANCE = atof(argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  // XXX should we load a tree from CATDIR by default?
+  // NOTE: a given catdir needs an appropriate boundary tree
+  BOUNDARY_TREE = NULL;
+  if ((N = get_argument (argc, argv, "-boundary-tree"))) {
+    remove_argument (N, &argc, argv);
+    BOUNDARY_TREE = strcreate(argv[N]);
+    load_tess (BOUNDARY_TREE);
+    remove_argument (N, &argc, argv);
+  }
+  SHOW_PARAMS = FALSE;
+  if ((N = get_argument (argc, argv, "-params"))) {
+    remove_argument (N, &argc, argv);
+    SHOW_PARAMS = TRUE;
+  }
+  PlotMmin = 10.0; PlotMmax = 20.0; PlotdMmin = -1.0; PlotdMmax = 1.0;
+  if ((N = get_argument (argc, argv, "-plrange"))) {
+    remove_argument (N, &argc, argv);
+    PlotMmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    PlotMmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    PlotdMmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    PlotdMmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  /* XXX this argument used to do two things: specify the camera name and tell the analysis to
+     calculate a common zero point for a single mosaic.  I've moved the MOSAICNAME concept into the
+     config system, but need to use this argument to specify that the mosaic zeropoints should be
+     calculated. */
+  MOSAIC_ZEROPT = FALSE;
+  if ((N = get_argument (argc, argv, "-mosaic"))) {
+    remove_argument (N, &argc, argv);
+    MOSAIC_ZEROPT = TRUE;
+    if (!strcasecmp (MOSAICNAME, "none")) {
+      fprintf (stderr, "mosaic astrometry selected by MOSAICNAME not defined\n");
+      exit (2);
+    }
+  }
+  FREEZE_IMAGES = FALSE;
+  if ((N = get_argument (argc, argv, "-imfreeze"))) {
+    remove_argument (N, &argc, argv);
+    FREEZE_IMAGES = TRUE;
+  }
+  FREEZE_MOSAICS = FALSE;
+  if ((N = get_argument (argc, argv, "-mosfreeze"))) {
+    remove_argument (N, &argc, argv);
+    FREEZE_MOSAICS = TRUE;
+  }
+  // USE_GRID is not valid for all cases, probably should be its own mode...
+  USE_GRID = FALSE;
+  if ((N = get_argument (argc, argv, "-grid"))) {
+    remove_argument (N, &argc, argv);
+    USE_GRID = TRUE;
+  }
+  KEEP_UBERCAL = TRUE;
+  if ((N = get_argument (argc, argv, "-reset-ubercal"))) {
+    remove_argument (N, &argc, argv);
+    KEEP_UBERCAL = FALSE;
+  }
+  MIN_ERROR = 0.001;
+  if ((N = get_argument (argc, argv, "-minerror"))) {
+    remove_argument (N, &argc, argv);
+    MIN_ERROR = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    /* require MIN_ERROR > 0 */
+  }
+  AreaSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-area"))) {
+    remove_argument (N, &argc, argv);
+    AreaXmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaXmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaYmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaYmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaSelect = TRUE;
+  }
+  ImagSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-instmag"))) {
+    remove_argument (N, &argc, argv);
+    ImagMin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    ImagMax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    ImagSelect = TRUE;
+  }
+  DophotSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-dophot"))) {
+    remove_argument (N, &argc, argv);
+    DophotValue = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    DophotSelect = TRUE;
+  }
+  SyntheticPhotometry = FALSE;
+  if ((N = get_argument (argc, argv, "-synthphot"))) {
+    remove_argument (N, &argc, argv);
+    SyntheticPhotometry = TRUE;
+    init_synthetic_mags();
+  }
+  refPhotcode = NULL;
+  if ((N = get_argument (argc, argv, "-refcode"))) {
+    remove_argument (N, &argc, argv);
+    refPhotcode = GetPhotcodebyName (argv[N]);
+    if (!refPhotcode) {
+      fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", argv[N]);
+      exit (1);
+    }
+    remove_argument (N, &argc, argv);
+  }
+  REGION_FILE = NULL;
+  if ((N = get_argument (argc, argv, "-region-hosts"))) {
+    remove_argument (N, &argc, argv);
+    REGION_FILE = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  REGION_HOST_ID = 0;
+  if ((N = get_argument (argc, argv, "-region-hostID"))) {
+    remove_argument (N, &argc, argv);
+    REGION_HOST_ID = atoi (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  RelphotMode mode = MODE_ERROR;
+  if ((N = get_argument (argc, argv, "-images"))) {
+    remove_argument (N, &argc, argv);
+    mode = UPDATE_IMAGES;
+  }
+  if ((N = get_argument (argc, argv, "-averages"))) {
+    remove_argument (N, &argc, argv);
+    mode = UPDATE_AVERAGES;
+  }
+  if ((N = get_argument (argc, argv, "-apply-offsets"))) {
+    remove_argument (N, &argc, argv);
+    mode = APPLY_OFFSETS;
+  }
+  IMAGE_TABLE = NULL;
+  if ((N = get_argument (argc, argv, "-parallel-images"))) {
+    remove_argument (N, &argc, argv);
+    mode = PARALLEL_IMAGES;
+    if (N >= argc) relphot_usage();
+    IMAGE_TABLE = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+    if (!REGION_FILE) relphot_usage();
+  }
+  PARALLEL_REGIONS_MANUAL = FALSE;
+  if ((N = get_argument (argc, argv, "-parallel-regions"))) {
+    remove_argument (N, &argc, argv);
+    mode = PARALLEL_REGIONS;
+    if (!REGION_FILE) relphot_usage();
+    if ((N = get_argument (argc, argv, "-parallel-regions-manual"))) {
+      remove_argument (N, &argc, argv);
+      PARALLEL_REGIONS_MANUAL = TRUE;
+    }
+  }
+  switch (mode) {
+    case UPDATE_AVERAGES:
+      if (argc != 1) relphot_usage();
+      break;
+    case UPDATE_IMAGES:
+    case PARALLEL_IMAGES:
+    case PARALLEL_REGIONS:
+      PhotcodeList = strcreate (argv[1]);
+      photcodes = ParsePhotcodeList (PhotcodeList, &Nphotcodes, TRUE); // require SEC photcodes
+      remove_argument (1, &argc, argv);
+      break;
+    default:
+      fprintf (stderr, "no valid mode selected\n");
+      relphot_usage();
+      break;
+  }
+  if (argc != 1) relphot_usage ();
+  return mode;
+}
+int args_client (int argc, char **argv) {
+  int N;
+  double trange;
+  // by definition, the client is not parallel
+  PARALLEL = FALSE;
+  PARALLEL_MANUAL = FALSE;
+  PARALLEL_SERIAL = FALSE;
+  HOST_ID = 0;
+  if ((N = get_argument (argc, argv, "-hostID"))) {
+    remove_argument (N, &argc, argv);
+    HOST_ID = atoi (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if (!HOST_ID) relphot_client_usage();
+  HOSTDIR = NULL;
+  if ((N = get_argument (argc, argv, "-hostdir"))) {
+    remove_argument (N, &argc, argv);
+    HOSTDIR = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if (!HOSTDIR) relphot_client_usage();
+  IMAGES = NULL; // used in -update mode
+  BCATALOG = NULL; // used in -load mode
+  MODE = MODE_NONE;
+  if ((N = get_argument (argc, argv, "-load"))) {
+    MODE = MODE_LOAD;
+    remove_argument (N, &argc, argv);
+    BCATALOG = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-update-catalogs"))) {
+    if (MODE) {
+      fprintf (stderr, "ERROR: cannot mix modes (-load, -update-catalogs, -update-objects)\n");
+      relphot_client_usage();
+    }
+    MODE = MODE_UPDATE;
+    remove_argument (N, &argc, argv);
+    IMAGES = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-update-objects"))) {
+    if (MODE) {
+      fprintf (stderr, "ERROR: cannot mix modes (-load, -update-catalogs, -update-objects)\n");
+      relphot_client_usage();
+    }
+    MODE = MODE_UPDATE_OBJECTS;
+    remove_argument (N, &argc, argv);
+  }
+  if (!MODE) relphot_client_usage();
+  strcpy (STATMODE, "WT_MEAN");
+  if ((N = get_argument (argc, argv, "-statmode"))) {
+    remove_argument (N, &argc, argv);
+    strcpy (STATMODE, argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  BOUNDARY_TREE = NULL;
+  if ((N = get_argument (argc, argv, "-boundary-tree"))) {
+    remove_argument (N, &argc, argv);
+    BOUNDARY_TREE = strcreate(argv[N]);
+    load_tess (BOUNDARY_TREE);
+    remove_argument (N, &argc, argv);
+  }
+  /* specify portion of the sky */
+  UserPatch.Rmin = 0;
+  UserPatch.Rmax = 360;
+  UserPatch.Dmin = -90;
+  UserPatch.Dmax = +90;
+  if ((N = get_argument (argc, argv, "-region"))) {
+    remove_argument (N, &argc, argv);
+    UserPatch.Rmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Rmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Dmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Dmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  SET_MREL_VERSION = 1;
+  if ((N = get_argument (argc, argv, "-set-mrel-version"))) {
+    remove_argument (N, &argc, argv);
+    SET_MREL_VERSION = atof(argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  VERBOSE = VERBOSE2 = FALSE;
+  if ((N = get_argument (argc, argv, "-v"))) {
+    VERBOSE = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-vv"))) {
+    VERBOSE2 = VERBOSE = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  RESET = FALSE;
+  if ((N = get_argument (argc, argv, "-reset"))) {
+    remove_argument (N, &argc, argv);
+    RESET = TRUE;
+  }
+  RESET_ZEROPTS = FALSE;
+  if ((N = get_argument (argc, argv, "-reset-zpts"))) {
+    remove_argument (N, &argc, argv);
+    RESET_ZEROPTS = TRUE;
+  }
+  KEEP_UBERCAL = TRUE;
+  if ((N = get_argument (argc, argv, "-reset-ubercal"))) {
+    remove_argument (N, &argc, argv);
+    KEEP_UBERCAL = FALSE;
+  }
   /* define time */
 …
+  }
+  /* specify portion of the sky */
+  UserPatch.Rmin = 0;
+  UserPatch.Rmax = 360;
+  UserPatch.Dmin = -90;
+  UserPatch.Dmax = +90;
+  if ((N = get_argument (argc, argv, "-region"))) {
+    remove_argument (N, &argc, argv);
+    UserPatch.Rmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Rmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Dmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Dmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  /* specify region file by name (eg n0000/0000.00) */
+  UserCatalog = NULL;
+  if ((N = get_argument (argc, argv, "-catalog"))) {
+    remove_argument (N, &argc, argv);
+    UserCatalog = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  USE_BASIC_CHECK = FALSE;
+  if ((N = get_argument (argc, argv, "-basic-image-search"))) {
+    remove_argument (N, &argc, argv);
+    USE_BASIC_CHECK = TRUE;
+  }
+  USE_FULL_OVERLAP = TRUE;
+  if ((N = get_argument (argc, argv, "-sloppy-image-overlap"))) {
+    remove_argument (N, &argc, argv);
+    USE_FULL_OVERLAP = FALSE;
+  }
+  SET_MREL_VERSION = 1;
+  if ((N = get_argument (argc, argv, "-set-mrel-version"))) {
+    remove_argument (N, &argc, argv);
+    SET_MREL_VERSION = atof(argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  VERBOSE = VERBOSE2 = FALSE;
+  if ((N = get_argument (argc, argv, "-v"))) {
+    VERBOSE = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-vv"))) {
+    VERBOSE2 = VERBOSE = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  NTHREADS = 0;
+  if ((N = get_argument (argc, argv, "-threads"))) {
+    remove_argument (N, &argc, argv);
+    NTHREADS = atof (argv[N]);
+    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
+  HOST_ID = 0;
+  PARALLEL = FALSE;
+  if ((N = get_argument (argc, argv, "-parallel"))) {
+    PARALLEL = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  // this is a test mode : rather than launching the remote jobs and waiting for completion,
+  // relphot will simply list the remote command and wait for the user to signal completion
+  PARALLEL_MANUAL = FALSE;
+  if ((N = get_argument (argc, argv, "-parallel-manual"))) {
+    PARALLEL = TRUE; // -parallel-manual implies -parallel
+    PARALLEL_MANUAL = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  // this is a test mode : rather than launching the relphot_client jobs remotely, they are
+  // run in serial via 'system'
+  PARALLEL_SERIAL = FALSE;
+  if ((N = get_argument (argc, argv, "-parallel-serial"))) {
+    if (PARALLEL_MANUAL) {
+      fprintf (stderr, "ERROR: cannot mix -parallel-manual and -parallel-serial\n");
+      exit (1);
+    }
+    PARALLEL = TRUE; // -parallel-serial implies -parallel
+    PARALLEL_SERIAL = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  PLOTSTUFF = FALSE;
+  if ((N = get_argument (argc, argv, "-plot"))) {
+    PLOTSTUFF = TRUE;
+    remove_argument (N, &argc, argv);
+  }
+  PLOTDELAY = 500000;
+  if ((N = get_argument (argc, argv, "-plotdelay"))) {
+    remove_argument (N, &argc, argv);
+    PLOTDELAY = 1e6*atof(argv[N]);
+    PLOTSTUFF = TRUE; // always turn on plotting if i request a plot delay
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-outroot"))) {
+    remove_argument (N, &argc, argv);
+    OUTROOT = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  } else {
+    OUTROOT = strcreate ("relphot");
+  }
+  strcpy (STATMODE, "WT_MEAN");
+  if ((N = get_argument (argc, argv, "-statmode"))) {
+    remove_argument (N, &argc, argv);
+    strcpy (STATMODE, argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  NLOOP = 8;
+  if ((N = get_argument (argc, argv, "-n"))) {
+    remove_argument (N, &argc, argv);
+    NLOOP = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-nloop"))) {
+    remove_argument (N, &argc, argv);
+    NLOOP = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  NGRID = 8;
+  if ((N = get_argument (argc, argv, "-ngrid"))) {
+    remove_argument (N, &argc, argv);
+    NGRID = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  RESET = FALSE;
+  if ((N = get_argument (argc, argv, "-reset"))) {
+    remove_argument (N, &argc, argv);
+    RESET = TRUE;
+  }
+  RESET_ZEROPTS = FALSE;
+  if ((N = get_argument (argc, argv, "-reset-zpts"))) {
+    remove_argument (N, &argc, argv);
+    RESET_ZEROPTS = TRUE;
+  }
+  MIN_ERROR = 0.001;
+  if ((N = get_argument (argc, argv, "-minerror"))) {
+    remove_argument (N, &argc, argv);
+    MIN_ERROR = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    /* require MIN_ERROR > 0 */
+  }
   UPDATE = FALSE;
 …
+  }
+  SAVE_IMAGE_UPDATES = TRUE;
+  if ((N = get_argument (argc, argv, "-skip-image-updates"))) {
+    remove_argument (N, &argc, argv);
+    SAVE_IMAGE_UPDATES = FALSE;
+  AreaSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-area"))) {
+    remove_argument (N, &argc, argv);
+    AreaXmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaXmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaYmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaYmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaSelect = TRUE;
+  }
+  SyntheticPhotometry = FALSE;
+  if ((N = get_argument (argc, argv, "-synthphot"))) {
+    remove_argument (N, &argc, argv);
+    SyntheticPhotometry = FALSE;
+    init_synthetic_mags();
+  }
+  ImagSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-instmag"))) {
+    remove_argument (N, &argc, argv);
+    ImagMin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    ImagMax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    ImagSelect = TRUE;
+  }
+  DophotSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-dophot"))) {
+    remove_argument (N, &argc, argv);
+    DophotValue = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    DophotSelect = TRUE;
+  }
 …
+  }
+  CLOUD_TOLERANCE = 0.02;
+  if ((N = get_argument (argc, argv, "-cloud-limit"))) {
+    remove_argument (N, &argc, argv);
+    CLOUD_TOLERANCE = atof(argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  // XXX should we load a tree from CATDIR by default?
+  // NOTE: a given catdir needs an appropriate boundary tree
+  BOUNDARY_TREE = NULL;
+  if ((N = get_argument (argc, argv, "-boundary-tree"))) {
+    remove_argument (N, &argc, argv);
+    BOUNDARY_TREE = strcreate(argv[N]);
+    load_tess (BOUNDARY_TREE);
+    remove_argument (N, &argc, argv);
+  }
+  SHOW_PARAMS = FALSE;
+  if ((N = get_argument (argc, argv, "-params"))) {
+    remove_argument (N, &argc, argv);
+    SHOW_PARAMS = TRUE;
+  }
+  PlotMmin = 10.0; PlotMmax = 20.0; PlotdMmin = -1.0; PlotdMmax = 1.0;
+  if ((N = get_argument (argc, argv, "-plrange"))) {
+    remove_argument (N, &argc, argv);
+    PlotMmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    PlotMmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    PlotdMmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    PlotdMmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  /* XXX this argument used to do two things: specify the camera name and tell the analysis to
+     calculate a common zero point for a single mosaic.  I've moved the MOSAICNAME concept into the
+     config system, but need to use this argument to specify that the mosaic zeropoints should be
+     calculated. */
+  MOSAIC_ZEROPT = FALSE;
+  if ((N = get_argument (argc, argv, "-mosaic"))) {
+    remove_argument (N, &argc, argv);
+    MOSAIC_ZEROPT = TRUE;
+    if (!strcasecmp (MOSAICNAME, "none")) {
+      fprintf (stderr, "mosaic astrometry selected by MOSAICNAME not defined\n");
+      exit (2);
+    }
+  }
+  FREEZE_IMAGES = FALSE;
+  if ((N = get_argument (argc, argv, "-imfreeze"))) {
+    remove_argument (N, &argc, argv);
+    FREEZE_IMAGES = TRUE;
+  }
+  FREEZE_MOSAICS = FALSE;
+  if ((N = get_argument (argc, argv, "-mosfreeze"))) {
+    remove_argument (N, &argc, argv);
+    FREEZE_MOSAICS = TRUE;
+  }
+  USE_GRID = FALSE;
+  if ((N = get_argument (argc, argv, "-grid"))) {
+    remove_argument (N, &argc, argv);
+    USE_GRID = TRUE;
+  }
+  KEEP_UBERCAL = TRUE;
+  if ((N = get_argument (argc, argv, "-reset-ubercal"))) {
+    remove_argument (N, &argc, argv);
+    KEEP_UBERCAL = FALSE;
+  }
+  MIN_ERROR = 0.001;
+  if ((N = get_argument (argc, argv, "-minerror"))) {
+    remove_argument (N, &argc, argv);
+    MIN_ERROR = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    /* require MIN_ERROR > 0 */
+  }
+  AreaSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-area"))) {
+    remove_argument (N, &argc, argv);
+    AreaXmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaXmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaYmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaYmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    AreaSelect = TRUE;
+  }
+  ImagSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-instmag"))) {
+    remove_argument (N, &argc, argv);
+    ImagMin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    ImagMax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    ImagSelect = TRUE;
+  }
+  DophotSelect = FALSE;
+  if ((N = get_argument (argc, argv, "-dophot"))) {
+    remove_argument (N, &argc, argv);
+    DophotValue = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    DophotSelect = TRUE;
+  }
+  SyntheticPhotometry = FALSE;
+  if ((N = get_argument (argc, argv, "-synthphot"))) {
+    remove_argument (N, &argc, argv);
+    SyntheticPhotometry = TRUE;
+    init_synthetic_mags();
+  }
+  refPhotcode = NULL;
+  if ((N = get_argument (argc, argv, "-refcode"))) {
+    remove_argument (N, &argc, argv);
+    refPhotcode = GetPhotcodebyName (argv[N]);
+    if (!refPhotcode) {
+      fprintf (stderr, "ERROR: photcode %s not found in photcode table\n", argv[N]);
+      exit (1);
+    }
+    remove_argument (N, &argc, argv);
+  }
+  UpdateAverages = FALSE;
+  if ((N = get_argument (argc, argv, "-averages"))) {
+    remove_argument (N, &argc, argv);
+    UpdateAverages = TRUE;
+  }
+  ApplyOffsets = FALSE;
+  if ((N = get_argument (argc, argv, "-apply-offsets"))) {
+    remove_argument (N, &argc, argv);
+    ApplyOffsets = TRUE;
+  }
+  if (UpdateAverages && (argc == 1)) return TRUE;
+  if (argc != 2) relphot_usage ();
+  if ((MODE == MODE_UPDATE_OBJECTS)  && (argc == 1)) return TRUE;
+  if (argc != 2) relphot_client_usage ();
   return TRUE;
+}
-int args_client (int argc, char **argv) {
-  int N;
-  double trange;
-  // by definition, the client is not parallel
-  PARALLEL = FALSE;
-  PARALLEL_MANUAL = FALSE;
-  PARALLEL_SERIAL = FALSE;
-  HOST_ID = 0;
-  if ((N = get_argument (argc, argv, "-hostID"))) {
-    remove_argument (N, &argc, argv);
-    HOST_ID = atoi (argv[N]);
-    remove_argument (N, &argc, argv);
+  }
-  if (!HOST_ID) relphot_client_usage();
-  HOSTDIR = NULL;
-  if ((N = get_argument (argc, argv, "-hostdir"))) {
-    remove_argument (N, &argc, argv);
-    HOSTDIR = strcreate (argv[N]);
-    remove_argument (N, &argc, argv);
+  }
-  if (!HOSTDIR) relphot_client_usage();
-  IMAGES = NULL; // used in -update mode
-  BCATALOG = NULL; // used in -load mode
-  MODE = MODE_NONE;
-  if ((N = get_argument (argc, argv, "-load"))) {
-    MODE = MODE_LOAD;
-    remove_argument (N, &argc, argv);
-    BCATALOG = strcreate (argv[N]);
-    remove_argument (N, &argc, argv);
+  }
-  if ((N = get_argument (argc, argv, "-update-catalogs"))) {
-    if (MODE) {
-      fprintf (stderr, "ERROR: cannot mix modes (-load, -update-catalogs, -update-objects)\n");
-      relphot_client_usage();
+    }
-    MODE = MODE_UPDATE;
-    remove_argument (N, &argc, argv);
-    IMAGES = strcreate (argv[N]);
-    remove_argument (N, &argc, argv);
+  }
-  if ((N = get_argument (argc, argv, "-update-objects"))) {
-    if (MODE) {
-      fprintf (stderr, "ERROR: cannot mix modes (-load, -update-catalogs, -update-objects)\n");
-      relphot_client_usage();
+    }
-    MODE = MODE_UPDATE_OBJECTS;
-    remove_argument (N, &argc, argv);
+  }
-  if (!MODE) relphot_client_usage();
-  strcpy (STATMODE, "WT_MEAN");
-  if ((N = get_argument (argc, argv, "-statmode"))) {
-    remove_argument (N, &argc, argv);
-    strcpy (STATMODE, argv[N]);
-    remove_argument (N, &argc, argv);
+  }
-  BOUNDARY_TREE = NULL;
-  if ((N = get_argument (argc, argv, "-boundary-tree"))) {
-    remove_argument (N, &argc, argv);
-    BOUNDARY_TREE = strcreate(argv[N]);
-    load_tess (BOUNDARY_TREE);
-    remove_argument (N, &argc, argv);
+  }
-  /* specify portion of the sky */
-  UserPatch.Rmin = 0;
-  UserPatch.Rmax = 360;
-  UserPatch.Dmin = -90;
-  UserPatch.Dmax = +90;
-  if ((N = get_argument (argc, argv, "-region"))) {
-    remove_argument (N, &argc, argv);
-    UserPatch.Rmin = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    UserPatch.Rmax = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    UserPatch.Dmin = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    UserPatch.Dmax = atof (argv[N]);
-    remove_argument (N, &argc, argv);
+  }
-  SET_MREL_VERSION = 1;
-  if ((N = get_argument (argc, argv, "-set-mrel-version"))) {
-    remove_argument (N, &argc, argv);
-    SET_MREL_VERSION = atof(argv[N]);
-    remove_argument (N, &argc, argv);
+  }
-  VERBOSE = VERBOSE2 = FALSE;
-  if ((N = get_argument (argc, argv, "-v"))) {
-    VERBOSE = TRUE;
-    remove_argument (N, &argc, argv);
+  }
-  if ((N = get_argument (argc, argv, "-vv"))) {
-    VERBOSE2 = VERBOSE = TRUE;
-    remove_argument (N, &argc, argv);
+  }
-  RESET = FALSE;
-  if ((N = get_argument (argc, argv, "-reset"))) {
-    remove_argument (N, &argc, argv);
-    RESET = TRUE;
+  }
-  RESET_ZEROPTS = FALSE;
-  if ((N = get_argument (argc, argv, "-reset-zpts"))) {
-    remove_argument (N, &argc, argv);
-    RESET_ZEROPTS = TRUE;
+  }
-  KEEP_UBERCAL = TRUE;
-  if ((N = get_argument (argc, argv, "-reset-ubercal"))) {
-    remove_argument (N, &argc, argv);
-    KEEP_UBERCAL = FALSE;
+  }
-  /* define time */
-  TimeSelect = FALSE;
-  if ((N = get_argument (argc, argv, "-time"))) {
-    remove_argument (N, &argc, argv);
-    if (!ohana_str_to_time (argv[N], &TSTART)) {
-      fprintf (stderr, "ERROR: syntax error\n");
-      return (FALSE);
+    }
-    remove_argument (N, &argc, argv);
-    if (!ohana_str_to_dtime (argv[N], &trange)) {
-      if (!ohana_str_to_time (argv[N], &TSTOP)) {
-        fprintf (stderr, "ERROR: syntax error\n");
-        return (FALSE);
+      }
-    } else {
-      if (trange < 0) {
-        trange = fabs (trange);
-        TSTOP = TSTART;
-        TSTART -= trange;
-      } else {
-        TSTOP = TSTART + trange;
+      }
+    }
-    remove_argument (N, &argc, argv);
-    TimeSelect = TRUE;
+  }
-  MIN_ERROR = 0.001;
-  if ((N = get_argument (argc, argv, "-minerror"))) {
-    remove_argument (N, &argc, argv);
-    MIN_ERROR = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    /* require MIN_ERROR > 0 */
+  }
-  UPDATE = FALSE;
-  if ((N = get_argument (argc, argv, "-update"))) {
-    remove_argument (N, &argc, argv);
-    UPDATE = TRUE;
+  }
-  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);
+  }
-  AreaSelect = FALSE;
-  if ((N = get_argument (argc, argv, "-area"))) {
-    remove_argument (N, &argc, argv);
-    AreaXmin = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    AreaXmax = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    AreaYmin = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    AreaYmax = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    AreaSelect = TRUE;
+  }
-  SyntheticPhotometry = FALSE;
-  if ((N = get_argument (argc, argv, "-synthphot"))) {
-    remove_argument (N, &argc, argv);
-    SyntheticPhotometry = FALSE;
-    init_synthetic_mags();
+  }
-  ImagSelect = FALSE;
-  if ((N = get_argument (argc, argv, "-instmag"))) {
-    remove_argument (N, &argc, argv);
-    ImagMin = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    ImagMax = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    ImagSelect = TRUE;
+  }
-  DophotSelect = FALSE;
-  if ((N = get_argument (argc, argv, "-dophot"))) {
-    remove_argument (N, &argc, argv);
-    DophotValue = atof (argv[N]);
-    remove_argument (N, &argc, argv);
-    DophotSelect = TRUE;
+  }
-  MaxDensityUse = FALSE;
-  if ((N = get_argument (argc, argv, "-max-density"))) {
-    remove_argument (N, &argc, argv);
-    MaxDensityValue = atof(argv[N]);
-    remove_argument (N, &argc, argv);
-    MaxDensityUse = TRUE;
+  }
-  if ((MODE == MODE_UPDATE_OBJECTS)  && (argc == 1)) return TRUE;
-  if (argc != 2) relphot_client_usage ();
-  return TRUE;
+}

trunk/Ohana/src/relphot/src/client_logger.c

-              r33963
+              r36630
 static FILE *logfile = NULL;
 int client_logger_init () {
+int client_logger_init (char *dirname) {
   char filename[DVO_MAX_PATH];
   snprintf (filename, DVO_MAX_PATH, "%s/log.rlpc.XXXXXX", HOSTDIR);
+  snprintf (filename, DVO_MAX_PATH, "%s/log.rlpc.XXXXXX", dirname);
   int fd = mkstemp (filename);
   if (fd == -1) {
     fprintf (stderr, "failed to open client logger, exiting\n");
+    fprintf (stderr, "failed to open client logger %s, exiting\n", filename);
     exit (50);
+  }
 …
   vfprintf (logfile, format, argp);
   va_end (argp);
+  fflush (logfile);
   return TRUE;
+}

trunk/Ohana/src/relphot/src/help.c

-              r33651
+              r36630
 void relphot_usage (void) {
+  fprintf (stderr, "ERROR: USAGE: relphot (photcodes) -region RA RA DEC DEC\n");
+  fprintf (stderr, "       or:    relphot (photcodes) -catalog (name)\n");
+  fprintf (stderr, "       or:    relphot -averages -region RA RA DEC DEC\n");
+  fprintf (stderr, "ERROR: USAGE: relphot (photcodes) -images\n");
+  fprintf (stderr, "       or:    relphot -averages\n");
+  fprintf (stderr, "       or:    relphot -apply-offsets\n");
+  fprintf (stderr, "       or:    relphot (photcodes) -parallel-regions -region-hosts (RegionFile)\n");
+  fprintf (stderr, "       or:    relphot (photcodes) -parallel-images (ImageTable) -region-hosts (RegionFile)\n\n");
+  fprintf (stderr, "  regions:    -region RA RA DEC DEC)\n");
+  fprintf (stderr, "       or:    -catalog (name)\n");
   fprintf (stderr, "  use -h for more usage information\n");
   exit (2);
 …
 show_help:
+  fprintf (stderr, "ERROR: USAGE: relphot (photcode) -region RA RA DEC DEC\n");
+  fprintf (stderr, "       or:    relphot (photcode) -catalog (name)\n");
+  fprintf (stderr, "       or:    relphot -averages -region RA RA DEC DEC\n");
+  fprintf (stderr, "ERROR: USAGE: relphot (photcodes) -images\n");
+  fprintf (stderr, "       or:    relphot -averages\n");
+  fprintf (stderr, "       or:    relphot -apply-offsets\n");
+  fprintf (stderr, "       or:    relphot (photcodes) -parallel-regions -region-hosts (RegionFile)\n");
+  fprintf (stderr, "       or:    relphot (photcodes) -parallel-images (ImageTable) -region-hosts (RegionFile)\n\n");
+  fprintf (stderr, "  regions:    -region RA RA DEC DEC)\n");
+  fprintf (stderr, "       or:    -catalog (name)\n");
   fprintf (stderr, "  options: \n");
   fprintf (stderr, "  -time (start) (stop)\n");

trunk/Ohana/src/relphot/src/initialize.c

-              r34429
+              r36630
 # include "relphot.h"
 void initialize (int argc, char **argv) {
+RelphotMode initialize (int argc, char **argv) {
   relphot_help (argc, argv);
   ConfigInit (&argc, argv);
+  args (argc, argv);
+  RelphotMode mode = args (argc, argv);
+  if (!mode) exit (2);
+  if (!UpdateAverages) {
+    // load the list of photcodes into the globals (photcodes, Nphotcodes)
+    // only a single remaining argument in this mode (the list of photcodes, eg g,r,i)
+    PhotcodeList = strcreate (argv[1]);
+    photcodes = ParsePhotcodeList (PhotcodeList, &Nphotcodes, TRUE); // require SEC photcodes
+  } else {
+  // UPDATE_AVERAGES always operates on all photcodes?
+  if (mode == UPDATE_AVERAGES) {
     char tmpline1[256];
     int Ns;
 …
   for (B = 0; A == time(NULL); B++);
   srand48(B);
+  return mode;
+}

trunk/Ohana/src/relphot/src/load_catalogs.c

-              r35416
+              r36630
   fprintf (stderr, "using "OFF_T_FMT" of "OFF_T_FMT" stars ("OFF_T_FMT" of "OFF_T_FMT" measurements)\n", Nstar, Nstar_total, Nmeas, Nmeas_total);
   if (!hostID && (Nstar < 1)) Shutdown ("%s", "ERROR: no stars match the minimum requirements; exiting \n");
+  if (!hostID && !REGION_HOST_ID && (Nstar < 1)) Shutdown ("%s", "ERROR: no stars match the minimum requirements; exiting \n");
   // in regular relphot, we shutdown here; in relphot_client, we generate and return an empty table (for consistency)
   // XXX consider only returning the populated catalogs
 …
 # define DEBUG 1
 Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog) {
+  char uniquer[12];
+  int TIME = time(NULL);
+  int PID = getpid();
+  snprintf (uniquer, 12, "%05d.%05d", PID, TIME % 100000);
   int Nsecfilt  = GetPhotcodeNsecfilt ();               // set the desired number in case we need to create the catalog
 …
     ALLOCATE (table->hosts[i].results, char, 1024);
     snprintf (table->hosts[i].results, 1024, "%s/relphot.catalog.subset.dat", table->hosts[i].pathname);
+    snprintf (table->hosts[i].results, 1024, "%s/relphot.catalog.%s.dat", table->hosts[i].pathname, uniquer);
     // options / arguments that can affect relphot_client -load:

trunk/Ohana/src/relphot/src/reload_catalogs.c

-              r35806
+              r36630
   // load the list of hosts
   HostTable *table = HostTableLoad (CATDIR, sky->hosts);
+  if (!table) {
+    fprintf (stderr, "ERROR: problem with parallel host table\n");
+    exit (2);
+  }
   if (BOUNDARY_TREE) {

trunk/Ohana/src/relphot/src/relphot.c

-              r35416
+              r36630
 int main (int argc, char **argv) {
+  /* get configuration info, args */
+  initialize (argc, argv);
+  // get configuration info, args
+  RelphotMode mode = initialize (argc, argv);
+  if (!mode) exit (2);
+  /* the object analysis is a separate process iterating over catalogs */
+  if (UpdateAverages) {
+    relphot_objects (0, NULL);
+    exit (0);
+  switch (mode) {
+    case UPDATE_IMAGES:
+      relphot_images ();
+      exit (0);
+    case UPDATE_AVERAGES:
+      // take the current set of detections and set the mean magnitudes
+      relphot_objects (0, NULL);
+      exit (0);
+    case PARALLEL_REGIONS:
+      // run image updates in parallel across multiple remote machines
+      relphot_parallel_regions ();
+      exit (0);
+    case PARALLEL_IMAGES:
+      // operation on the remote machines in the PARALLEL_REGION mode
+      relphot_parallel_images ();
+      exit (0);
+    case APPLY_OFFSETS:
+      // re-run this step from a previous attempt (assumes an existing Images.subset.dat file)
+      if (!PARALLEL) {
+        fprintf (stderr, "-apply-offsets only makes sense in an parallel context\n");
+        exit (2);
+      }
+      reload_catalogs (NULL, NULL, 0, NULL);
+      exit (0);
+    default:
+      fprintf (stderr, "ERROR: no valid relphot mode chosen\n");
+      exit (2);
+  }
+  if (ApplyOffsets) {
+    // re-run this step from a previous attempt (assumes an existing Images.subset.dat file)
+    if (!PARALLEL) {
+      fprintf (stderr, "-apply-offsets only makes sense in an parallel context\n");
+      exit (2);
+    }
+    reload_catalogs (NULL, NULL, 0, NULL);
+    exit (0);
+  }
+  relphot_images ();
+  exit (0);
+  fprintf (stderr, "IMPOSSIBLE: skipped out of switch?\n");
+  exit (1);
+}

trunk/Ohana/src/relphot/src/relphot_client.c

r33963	r36630
19	19	// get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, etc)
20	20	initialize_client (argc, argv);
21		client_logger_init ();
	21	client_logger_init (HOSTDIR);
22	22
23	23	// load the current sky table (layout of all SkyRegions)

trunk/Ohana/src/relphot/src/relphot_images.c

-              r35806
+              r36630
   if (!UPDATE) exit (0);
+  /* load catalog data from region files, update Mrel include all data */
+  /* Load catalog data from region files, update Mrel include all data.  In a parallel
+     context, this function writes the image parameters as a subset table for the remote
+     clients */
   reload_catalogs (skylist, flatcorr, 0, NULL);
   MARKTIME("-- updated all catalogs: %f sec\n", dtime);

trunk/Ohana/src/relphot/src/setMrelCatalog.c

-              r36528
+              r36630
         // Map (Maplist) and Mkron (Mkronlist,dkronlist) are used to calculate mean mags per filter
         float Map = PhotAper (&measure[k]);
+        float Map = PhotAperCat (&measure[k]);
         if (!isnan(Map)) {
             Maplist[Nap] = Map - Mcal - Mmos - Mgrid;
 …
+        }
         float Mkron = PhotKron (&measure[k]);
+        float Mkron = PhotKronCat (&measure[k]);
         if (!isnan(Mkron)) {
           Mkronlist[Nkron] = Mkron - Mcal - Mmos - Mgrid;
 …
       wpsflist[Npsf] = isUbercal ? 10.0 : 1.0;
+      // NOTE:
+      // Msys is measure[i].M + zp corrections
+      // Mcal is image[j].Mcal
+      // Mmos and Mgrid are offsets for mosaic and grid
       // tie down reference photometry if the -refcode (code) option is selected

trunk/Ohana/src/uniphot/src/update_dvo_setphot.c

r35103	r36630
2	2	int update_dvo_setphot_parallel (SkyTable sky, Image image, off_t Nimage);
3	3
	4	// XXX convert this to use the ImageSubset to save space
4	5	int update_dvo_setphot (Image image, off_t Nimage, FlatCorrectionTable flatcorr) {
5	6

trunk/ippScripts/scripts/ipp_apply_burntool_single.pl

Property svn:mergeinfo changed

/branches/eam_branches/ipp-20140206/ippScripts/scripts/ipp_apply_burntool_single.pl (added)	merged: 36536,36627
/branches/eam_branches/ipp-20140214/ippScripts/scripts/ipp_apply_burntool_single.pl (added)	merged: 36525-36527

trunk/ippScripts/scripts/publish_file.pl

Property svn:mergeinfo changed
/branches/eam_branches/ipp-20140206/ippScripts/scripts/publish_file.pl (added) merged: 36536,36627
/branches/eam_branches/ipp-20140214/ippScripts/scripts/publish_file.pl (added) merged: 36525-36527

trunk/ippconfig/recipes/ppSub.config

Property svn:mergeinfo changed
/branches/eam_branches/ipp-20140206/ippconfig/recipes/ppSub.config (added) merged: 36536,36627
/branches/eam_branches/ipp-20140214/ippconfig/recipes/ppSub.config (added) merged: 36525-36527

trunk/ippconfig/recipes/reductionClasses.mdc

Property svn:mergeinfo changed

/branches/eam_branches/ipp-20140206/ippconfig/recipes/reductionClasses.mdc (added)	merged: 36536,36627
/branches/eam_branches/ipp-20140214/ippconfig/recipes/reductionClasses.mdc (added)	merged: 36525-36527

trunk/psphot/src

Property svn:mergeinfo changed
/branches/eam_branches/ipp-20140206/psphot/src (added) merged: 36536,36627-36629
/branches/eam_branches/ipp-20140214/psphot/src (added) merged: 36525-36527

trunk/psphot/src/psphotFullForceReadout.c

-              r36375
+              r36630
     psphotMagnitudes(config, view, filerule);
+    // calculate lensing parameters
+    if (!psphotLensing(config, view, filerule)) {
+        psErrorStackPrint(stderr, "Unable to do lensing parameters.");
+        psErrorClear();
+    }
     // replace background in residual image
     psphotSkyReplace (config, view, filerule);

trunk/psphot/src/psphotStackImageLoop.c

Property svn:mergeinfo changed
/branches/eam_branches/ipp-20140206/psphot/src/psphotStackImageLoop.c (added) merged: 36536,36627
/branches/eam_branches/ipp-20140214/psphot/src/psphotStackImageLoop.c (added) merged: 36525-36527

trunk/psphot/src/psphotStackReadout.c

-              r36542
+              r36630
     // calculate source magnitudes
     psphotMagnitudes(config, view, STACK_RAW);
+    // calculate lensing parameters
+    if (!psphotLensing(config, view, STACK_RAW)) {
+        psErrorStackPrint(stderr, "Unable to do lensing parameters.");
+        psErrorClear();
+    }
     if (!psphotEfficiency(config, view, STACK_RAW)) {

/branches/eam_branches/ipp-20140206/Ohana/src/libohana/src (added)	merged: 36536,36626
/branches/eam_branches/ipp-20140214/Ohana/src/libohana/src (added)	merged: 36525-36527

/branches/eam_branches/ipp-20140206/psphot/src (added)	merged: 36536,36627-36629
/branches/eam_branches/ipp-20140214/psphot/src (added)	merged: 36525-36527

Context Navigation

Legend:

Download in other formats: