Changeset 5014

Timestamp:

Sep 12, 2005, 3:04:48 PM (21 years ago)

Author:

eugene

Message:

substantial work to enable mode and format selections for DVO:image and DVO:secfilt

Location:

trunk/Ohana/src

Files:

• addstar/include/addstar.h (modified) (1 diff)
• addstar/src/airmass.c (modified) (2 diffs)
• addstar/src/calibrate.c (modified) (3 diffs)
• addstar/src/find_matches.c (modified) (5 diffs)
• addstar/src/gcatalog.c (modified) (1 diff)
• addstar/src/gstars.c (modified) (6 diffs)
• addstar/src/image-db.c (modified) (3 diffs)
• addstar/src/mkcatalog.c (modified) (2 diffs)
• addstar/src/wcatalog.c (modified) (1 diff)
• delstar/src/gcatalog.c (modified) (1 diff)
• delstar/src/gimages.c (modified) (1 diff)
• delstar/src/wcatalog.c (modified) (1 diff)
• gastro/src/gptolemy.c (modified) (2 diffs)
• gastro2/src/gptolemy2.c (modified) (2 diffs)
• imregister/imphot/dumpfits.c (modified) (1 diff)
• imregister/imphot/output.c (modified) (1 diff)
• libautocode/Makefile (modified) (4 diffs)
• libautocode/def/average-panstarrs.d (modified) (2 diffs)
• libautocode/def/image-ascii.d (added)
• libautocode/def/image-elixir.d (added)
• libautocode/def/image-loneos.d (added)
• libautocode/def/image-panstarrs.d (added)
• libautocode/def/image.d (modified) (4 diffs)
• libautocode/def/measure-panstarrs.d (modified) (2 diffs)
• libautocode/def/secfilt-loneos.d (added)
• libautocode/def/secfilt-panstarrs.d (modified) (1 diff)
• libautocode/def/secfilt.d (modified) (2 diffs)
• libautocode/generate (modified) (2 diffs)
• libfits/include/fits.h (modified) (1 diff)
• libohana/Makefile (modified) (3 diffs)
• libohana/include/dvo.h (modified) (4 diffs)
• libohana/src/dvo_convert.c (modified) (6 diffs)
• libohana/src/dvo_convert_elixir.c (modified) (5 diffs)
• libohana/src/dvo_convert_loneos.c (modified) (6 diffs)
• libohana/src/dvo_convert_panstarrs.c (modified) (5 diffs)
• libohana/src/dvo_image.c (modified) (5 diffs)
• libohana/src/dvo_image_raw.c (added)
• libohana/src/fits_db.c (modified) (1 diff)
• libohana/src/phot_catalog.c (modified) (1 diff)
• libohana/src/phot_catalog_mef.c (modified) (10 diffs)
• libohana/src/phot_catalog_raw.c (modified) (9 diffs)
• libohana/src/photfits.c (modified) (8 diffs)
• mosastro/src/gptolemy.c (modified) (2 diffs)
• opihi/dvo/avextract.c (modified) (1 diff)
• opihi/dvo/calextract.c (modified) (1 diff)
• opihi/dvo/calmextract.c (modified) (1 diff)
• opihi/dvo/catalog.c (modified) (1 diff)
• opihi/dvo/ccd.c (modified) (1 diff)
• opihi/dvo/cmatch.c (modified) (1 diff)
• opihi/dvo/cmd.c (modified) (1 diff)
• opihi/dvo/ddmags.c (modified) (1 diff)
• opihi/dvo/dmagaves.c (modified) (1 diff)
• opihi/dvo/dmagmeas.c (modified) (1 diff)
• opihi/dvo/dmags.c (modified) (1 diff)
• opihi/dvo/dmt.c (modified) (1 diff)
• opihi/dvo/extract.c (modified) (1 diff)
• opihi/dvo/fitcolors.c (modified) (3 diffs)
• opihi/dvo/gimages.c (modified) (2 diffs)
• opihi/dvo/gstar.c (modified) (1 diff)
• opihi/dvo/imdata.c (modified) (1 diff)
• opihi/dvo/imextract.c (modified) (1 diff)
• opihi/dvo/imlist.c (modified) (1 diff)
• opihi/dvo/imphot.c (modified) (1 diff)
• opihi/dvo/imstats.c (modified) (1 diff)
• opihi/dvo/lcurve.c (modified) (1 diff)
• opihi/dvo/lightcurve.c (modified) (1 diff)
• opihi/dvo/mextract.c (modified) (1 diff)
• opihi/dvo/pmeasure.c (modified) (1 diff)
• opihi/dvo/subpix.c (modified) (2 diffs)
• relphot/src/ConfigInit.c (modified) (1 diff)
• relphot/src/ImageOps.c (modified) (9 diffs)
• relphot/src/MosaicOps.c (modified) (8 diffs)
• relphot/src/find_images.c (modified) (1 diff)
• relphot/src/gcatalog.c (modified) (2 diffs)
• relphot/src/wcatalog.c (modified) (1 diff)
• uniphot/include/uniphot.h (modified) (1 diff)
• uniphot/src/fit_groups.c (modified) (4 diffs)
• uniphot/src/gcatalog.c (modified) (1 diff)
• uniphot/src/update.c (modified) (1 diff)
• uniphot/src/wcatalog.c (modified) (1 diff)

trunk/Ohana/src/addstar/include/addstar.h

@@ -124 +124 @@
 int        Shutdown               PROTO((char *message, ...); ) 
 void       TrapSignal             PROTO((int sig));
-short      airmass                PROTO((short secz_image, double ra, double dec, double st, double latitude));
+float      airmass                PROTO((float secz_image, double ra, double dec, double st, double latitude));
 void       aregion                PROTO((GSCRegion *region, FILE *f, double ra, double dec));
 int        args                   PROTO((int argc, char **argv));

trunk/Ohana/src/addstar/src/airmass.c

@@ -1 +1 @@
 # include "addstar.h"
 
-short airmass (short secz_image, double ra, double dec, double st, double latitude) {
+float airmass (float secz_image, double ra, double dec, double st, double latitude) {
 
   double hour, cosz, secz;
@@ -13 +13 @@
   hour = 15.0*st - ra;
   cosz = sin (RAD_DEG*dec) * sin (RAD_DEG*latitude) + cos (RAD_DEG*dec) * cos (RAD_DEG*hour) * cos (RAD_DEG*latitude);
-  
-  /* modify to match storage units (millimags) */
-  secz = 1000.0 / cosz;
+  secz = 1.000 / cosz;
   return (secz);
 }

trunk/Ohana/src/addstar/src/calibrate.c

@@ -95 +95 @@
   if (MaxN == -1) {
     fprintf (stderr, "no clean stars\n");
-    image[0].Mcal = 10000;
-    image[0].dMcal = 10000;
+    image[0].Mcal_PS = 10.000;
+    image[0].dMcal_PS = 10.000;
     return;
   }
@@ -137 +137 @@
   if (Nkeep < 5) {
     fprintf (stderr, "too few stars\n");
-    image[0].Mcal = 10000;
-    image[0].dMcal = 10000;
+    image[0].Mcal_PS = 10.000;
+    image[0].dMcal_PS = 10.000;
     return;
   }
@@ -169 +169 @@
     Mw = W1 / W2;
     fprintf (stderr, "N: %.0f, mean: %f, wt mean: %f, stdev: %f, precision: %f\n", N, M1, Mw, M2, M2 / sqrt (N));
-    image[0].Mcal = 1000 * M1;
-    image[0].dMcal = 1000 * M2 / sqrt (N);
+    image[0].Mcal_PS = M1;
+    image[0].dMcal_PS = M2 / sqrt (N);
     image[0].Mxxxx = N;
   } else {
     fprintf (stderr, "too few stars\n");
-    image[0].Mcal = 10000;
-    image[0].dMcal = 10000;
+    image[0].Mcal_PS = 10.000;
+    image[0].dMcal_PS = 10.000;
     image[0].Mxxxx = 0;
   }
 }
-
-/*** image.Mcal is still in millimags ***/

trunk/Ohana/src/addstar/src/find_matches.c

@@ -12 +12 @@
   Missing *tmpmissing;
   Coords tcoords;
-  int Nsecfilt, Nsec, MTIME;
-  float Mcat, *Mval;
+  int Nsecfilt, Nsec;
+  float Mcat, *Mval, MTIME;
 
   /* photcode data - must by of type DEP, (PRI, SEC) - probably should restrict to DEP */
@@ -143 +143 @@
         
       /* calculate accurate per-star airmass */
-      secz = airmass (image[0].secz, stars[N].R, stars[N].D, SiderealTime, Latitude);
+      secz = airmass (image[0].secz_PS, stars[N].R, stars[N].D, SiderealTime, Latitude);
       
       /** add measurements for this star **/
@@ -151 +151 @@
       catalog[0].measure[Nmeas].M_PS        = MIN (stars[N].M + MTIME, NO_MAG);
       catalog[0].measure[Nmeas].dM_PS       = MIN (stars[N].dM, NO_ERR);  /* error in input files stored in thousandths of mag */
-      catalog[0].measure[Nmeas].Mcal_PS     = 0.001*image[0].Mcal; /* XXX image.Mcal still millimags */
+      catalog[0].measure[Nmeas].Mcal_PS     = image[0].Mcal_PS;
       catalog[0].measure[Nmeas].t           = image[0].tzero + 1e-4*stars[N].Y*image[0].trate;  /* trate is in 0.1 msec / row */
       catalog[0].measure[Nmeas].averef      = n;
@@ -252 +252 @@
     if (!IN_CATALOG (stars[N].R, stars[N].D)) continue;
 
-    secz = airmass (image[0].secz, stars[N].R, stars[N].D, SiderealTime, Latitude);
+    secz = airmass (image[0].secz_PS, stars[N].R, stars[N].D, SiderealTime, Latitude);
 
     catalog[0].average[Nave].R_PS      = stars[N].R;
@@ -277 +277 @@
     catalog[0].measure[Nmeas].M_PS        = MIN (stars[N].M + MTIME, NO_MAG);
     catalog[0].measure[Nmeas].dM_PS       = MIN (stars[N].dM, NO_ERR);
-    catalog[0].measure[Nmeas].Mcal_PS     = 0.001*image[0].Mcal;
+    catalog[0].measure[Nmeas].Mcal_PS     = image[0].Mcal_PS;
     catalog[0].measure[Nmeas].t           = image[0].tzero + 1e-4*stars[N].Y*image[0].trate; /* trate is in 0.1 msec / row */
     catalog[0].measure[Nmeas].averef      = Nave;

trunk/Ohana/src/addstar/src/gcatalog.c

@@ -6 +6 @@
   char mode;
 
-  /* no autodetect for CATMODE yet */
-  strcpy (catalog[0].catmode, CATMODE);
+  /* CATMODE and CATFORMAT determined from catalog */
 
   /* read catalog header */

trunk/Ohana/src/addstar/src/gstars.c

@@ -4 +4 @@
 
   FILE *f;
-  int j, N, Nbytes;
+  int j, N, Nbytes, extend;
   int itmp, hour, min;
   char *c, photcode[64], line[80];
@@ -76 +76 @@
   image[0].exptime = tmp;
   
+  /*** why are we no longer using APMIFIT?? ***/
   tmp = 0;
   /* fits_scan (&header, "APMIFIT",  "%lf", 1, &tmp); */
-  image[0].apmifit = tmp * 1000.0;
+  image[0].apmifit_PS = tmp;
 
   tmp = 0;
   /* fits_scan (&header, "dAPMIFIT", "%lf", 1, &tmp); */
-  image[0].dapmifit = tmp * 1000.0;
+  image[0].dapmifit_PS = tmp;
 
   tmp = 0;
@@ -110 +111 @@
   tmp = 0;
   fits_scan (&header, AirmassKeyword, "%lf", 1, &tmp);
-  image[0].secz = MIN (NO_MAG, 1000*tmp);
+  image[0].secz_PS = MIN (NO_MAG, tmp);
 
   if (!fits_scan (&header, CCDNumKeyword, "%d", 1, &itmp)) {
@@ -122 +123 @@
 
   /* secz is in units milli-airmass */
-  image[0].Mcal = 0.0;
+  image[0].Mcal_PS = 0.0;
   image[0].Xm   = NO_MAG;
   image[0].code = 0;
@@ -162 +163 @@
   fseek (f, header.size, SEEK_SET); 
 
+  /* read from FITS table or from text table */
+  extend = FALSE;
+  fits_scan (&header, "EXTEND",  "%t", 1, &extend);
+  if (extend) {
+    Nbytes = fits_matrix_size (&header);
+    fseek (f, Nbytes, SEEK_CUR); 
+    rdstars = rfits (f, &image[0].nstar);
+  } else {
+    /* allocate space for stars */
+    if (!fits_scan (&header, "NSTARS", "%d", 1, &image[0].nstar)) {
+      fprintf (stderr, "ERROR: failed to find NSTARS\n");
+      exit (1);
+    }
+    rdstars = rtext (f, &image[0].nstar);
+  }
+  fclose (f);
+
+  /* 
   if (FITS_INPUT) {
     Nbytes = fits_matrix_size (&header); 
@@ -170 +189 @@
   }
   fclose (f);
+  */
 
   /* modify resulting star list */

trunk/Ohana/src/addstar/src/image-db.c

@@ -39 +39 @@
   fits_init_header (&db[0].header);
 
+  /* set the recommended mode */
   if (!strcmp (CATMODE, "RAW")) {
     /* make header a fake image */
@@ -46 +47 @@
     db[0].header.Naxis[1] = 1;
     fits_create_header (&db[0].header);
+    db[0].mode = DVO_MODE_RAW;
   }
 
   if (!strcmp (CATMODE, "MEF") || !strcmp (CATMODE, "SPLIT")) {
+    db[0].header.extend   = TRUE;
     fits_create_header (&db[0].header);
+    db[0].mode = DVO_MODE_MEF;
+  }
+
+  /* set the recommended format */
+  db[0].format = DVO_FORMAT_UNDEF;
+  if (!strcmp (CATFORMAT, "INTERNAL"))  db[0].format = DVO_FORMAT_INTERNAL;
+  if (!strcmp (CATFORMAT, "LONEOS"))    db[0].format = DVO_FORMAT_LONEOS;
+  if (!strcmp (CATFORMAT, "ELIXIR"))    db[0].format = DVO_FORMAT_ELIXIR;
+  if (!strcmp (CATFORMAT, "PANSTARRS")) db[0].format = DVO_FORMAT_PANSTARRS;
+  if (db[0].format == DVO_FORMAT_UNDEF) {
+    fprintf (stderr, "invalid output catalog format\n");
+    exit (1);
   }
 
@@ -58 +73 @@
   fits_modify (&db[0].header, "ZERO_PT", "%lf", 1, ZeroPt);
   fits_modify (&db[0].header, "NIMAGES", "%d", 1, 0);
+
+  if (db[0].format == DVO_FORMAT_INTERNAL)  fits_modify (&db[0].header, "FORMAT", "%s", 1, "INTERNAL");
+  if (db[0].format == DVO_FORMAT_LONEOS)    fits_modify (&db[0].header, "FORMAT", "%s", 1, "LONEOS");
+  if (db[0].format == DVO_FORMAT_ELIXIR)    fits_modify (&db[0].header, "FORMAT", "%s", 1, "ELIXIR");
+  if (db[0].format == DVO_FORMAT_PANSTARRS) fits_modify (&db[0].header, "FORMAT", "%s", 1, "PANSTARRS");
 }
-

trunk/Ohana/src/addstar/src/mkcatalog.c

@@ -8 +8 @@
   if (VERBOSE) fprintf (stderr, "new catalog file: %s\n", region[0].filename);
 
+  /* set the recommended CATFORMAT */
+  catalog[0].catformat = DVO_FORMAT_UNDEF;
+  if (!strcmp (CATFORMAT, "INTERNAL"))  catalog[0].catformat = DVO_FORMAT_INTERNAL;
+  if (!strcmp (CATFORMAT, "LONEOS"))    catalog[0].catformat = DVO_FORMAT_LONEOS;
+  if (!strcmp (CATFORMAT, "ELIXIR"))    catalog[0].catformat = DVO_FORMAT_ELIXIR;
+  if (!strcmp (CATFORMAT, "PANSTARRS")) catalog[0].catformat = DVO_FORMAT_PANSTARRS;
+  if (catalog[0].catformat == DVO_FORMAT_UNDEF) {
+    fprintf (stderr, "invalid output catalog format\n");
+    exit (1);
+  }
+
+  /* set the recommended CATMODE */
+  catalog[0].catmode = DVO_MODE_RAW;
+  if (!strcmp (CATMODE, "RAW"))  catalog[0].catmode = DVO_MODE_RAW;
+  if (!strcmp (CATMODE, "MEF"))  catalog[0].catmode = DVO_MODE_MEF;
+
   fits_init_header (&catalog[0].header);
+
+  if (catalog[0].catmode == DVO_MODE_RAW) {
+    /* make header a fake image */
+    catalog[0].header.bitpix   = 16;
+    catalog[0].header.Naxes    = 2;
+    catalog[0].header.Naxis[0] = 1;
+    catalog[0].header.Naxis[1] = 1;
+  }
+
   fits_create_header (&catalog[0].header);
   
@@ -34 +59 @@
   ALLOCATE (catalog[0].secfilt, SecFilt, 1);
   catalog[0].Nsecfilt = GetPhotcodeNsecfilt ();
-
-  /* set catalog mode (raw, mef, etc) - no autodetect for CATMODE yet */
-  strcpy (catalog[0].catmode, CATMODE);
-
-  /* set catalog format (elixir, loneos, etc) */
-  if (!strcmp (CATFORMAT, "INTERNAL")) {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE");
-    sprintf (catalog[0].measure_format, "DVO_MEASURE");
-  } else {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE_%s", CATFORMAT);
-    sprintf (catalog[0].measure_format, "DVO_MEASURE_%s", CATFORMAT);
-  }
 }

trunk/Ohana/src/addstar/src/wcatalog.c

@@ -3 +3 @@
 void wcatalog (Catalog *catalog) {
   
-  /* set catalog format (elixir, loneos, etc) */
-  if (!strcmp (CATFORMAT, "INTERNAL")) {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE");
-    sprintf (catalog[0].measure_format, "DVO_MEASURE");
-  } else {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE_%s", CATFORMAT);
-    sprintf (catalog[0].measure_format, "DVO_MEASURE_%s", CATFORMAT);
-  }
+  /* output CATMODE and CATFORMAT are set by mkcatalog 
+     or by mode and format of existing data */
 
   if (!save_catalog (catalog, VERBOSE)) {

trunk/Ohana/src/delstar/src/gcatalog.c

@@ -6 +6 @@
   char mode;
 
-  /* no autodetect for CATMODE yet */
-  strcpy (catalog[0].catmode, CATMODE);
+  /* CATMODE and CATFORMAT determined from catalog */
 
   /* read catalog header */

trunk/Ohana/src/delstar/src/gimages.c

@@ -76 +76 @@
   tmp = 0;
   fits_scan (&header, "AIRMASS", "%lf", 1, &tmp);
-  image[0].secz = 1000*tmp;
+  image[0].secz_PS = tmp;
 
   /* secz is in units milli-airmass */
-  image[0].Mcal =  ALPHA*(image[0].secz - 1000);
+  image[0].Mcal_PS =  ALPHA*(image[0].secz_PS - 1.000);
   image[0].Xm   = NO_MAG;
 

trunk/Ohana/src/delstar/src/wcatalog.c

@@ -3 +3 @@
 int wcatalog (Catalog *catalog) {
   
-  /* set catalog format (elixir, loneos, etc) */
-  if (!strcmp (CATFORMAT, "INTERNAL")) {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE");
-    sprintf (catalog[0].measure_format, "DVO_MEASURE");
-  } else {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE_%s", CATFORMAT);
-    sprintf (catalog[0].measure_format, "DVO_MEASURE_%s", CATFORMAT);
-  }
+  /* output CATMODE and CATFORMAT are set by mkcatalog 
+     or by mode and format of existing data */
 
   if (!save_catalog (catalog, VERBOSE)) {

trunk/Ohana/src/gastro/src/gptolemy.c

@@ -8 +8 @@
   char filename[256], *fileroot, *filepath, *subdir;
   Catalog catalog;
-
-  strcpy (catalog.catmode, CATMODE);
 
   filepath = pathname (fullpath);
@@ -25 +23 @@
     break;
   }
+
+  /* CATMODE and CATFORMAT determined from catalog */
   if (!load_catalog (&catalog, LOAD_AVES | LOAD_MEAS, FALSE)) {
     fprintf (stderr, "can't load catalog data\n");

trunk/Ohana/src/gastro2/src/gptolemy2.c

@@ -9 +9 @@
   Catalog catalog;
   GSCdata *stars;
-
-  strcpy (catalog.catmode, CATMODE);
 
   filepath = pathname (fullpath);
@@ -27 +25 @@
     break;
   }
+
+  /* CATMODE and CATFORMAT determined from catalog */
   if (!load_catalog (&catalog, LOAD_AVES | LOAD_MEAS, FALSE)) {
     fprintf (stderr, "can't load catalog data %s\n", filename);

trunk/Ohana/src/imregister/imphot/dumpfits.c

@@ -114 +114 @@
     startstr = sec_to_date (subset[0].tzero);
     filtstr  = GetPhotcodeNamebyCode (subset[0].source);
-    zp       = 0.001*subset[0].Mcal;
-    dzp      = 0.001*subset[0].dMcal;
+    zp       = subset[0].Mcal_PS;
+    dzp      = subset[0].dMcal_PS;
     XY_to_RD (&ra, &dec, 0.0, 0.0, &subset[0].coords);
-    airmass  = 0.001*subset[0].secz;
+    airmass  = subset[0].secz_PS;
     sky      = subset[0].Myyyy + 0x8000;
 

trunk/Ohana/src/imregister/imphot/output.c

@@ -39 +39 @@
       
     fprintf (stdout, "%s %s %s  %7.4f %7.4f  %7.4f %5d %02x\n", image[i].name, photstr, timestr, 
-             0.001*image[i].Mcal, 0.001*image[i].dMcal, 0.001*image[i].secz, image[i].nstar, image[i].code); 
+             image[i].Mcal_PS, image[i].dMcal_PS, image[i].secz_PS, image[i].nstar, image[i].code); 
     free (timestr);
   }

trunk/Ohana/src/libautocode/Makefile

@@ -29 +29 @@
 $(SRC)/average-panstarrs.$(ARCH).o \
 $(SRC)/secfilt.$(ARCH).o \
+$(SRC)/secfilt-loneos.$(ARCH).o \
 $(SRC)/secfilt-elixir.$(ARCH).o \
 $(SRC)/secfilt-panstarrs.$(ARCH).o \
@@ -38 +39 @@
 $(SRC)/photcode.$(ARCH).o \
 $(SRC)/image.$(ARCH).o \
+$(SRC)/image-loneos.$(ARCH).o \
+$(SRC)/image-elixir.$(ARCH).o \
+$(SRC)/image-panstarrs.$(ARCH).o \
 $(SRC)/regimage.$(ARCH).o \
 $(SRC)/detreg.$(ARCH).o \
@@ -53 +57 @@
 $(INC)/average-panstarrs.h \
 $(INC)/secfilt.h \
+$(INC)/secfilt-loneos.h \
 $(INC)/secfilt-elixir.h \
 $(INC)/secfilt-panstarrs.h \
@@ -62 +67 @@
 $(INC)/photcode.h \
 $(INC)/image.h \
+$(INC)/image-loneos.h \
+$(INC)/image-elixir.h \
+$(INC)/image-panstarrs.h \
 $(INC)/regimage.h \
 $(INC)/detreg.h \

trunk/Ohana/src/libautocode/def/average-panstarrs.d

@@ -2 +2 @@
 EXTNAME DVO_AVERAGE_PANSTARRS
 TYPE    BINTABLE
-SIZE    44
+SIZE    48
 
 # elements of data structure / FITS table
@@ -18 +18 @@
 FIELD offset,         offset,     int,              offset to first measurement
 FIELD missing,        missing,    int,              offset to first missing obs
+FIELD dummy,          dummmy,     int,              extra space

trunk/Ohana/src/libautocode/def/image.d

@@ -1 @@
-STRUCT Image
-EXTNAME DVO_IMAGES
-TYPE BINTABLE
-SIZE 240
+STRUCT  Image
+EXTNAME DVO_IMAGE
+TYPE    BINTABLE
+SIZE    248
 
 # elements of the image structure
@@ -20 +20 @@
 SUBFIELD  ctype,            CTYPE,                char[15],      coordinate type
 SUBFIELD  Npolyterms,       NPOLYTERMS,           char,          order of polynomial
+# 120 bytes
 
 FIELD     tzero,            TZERO,                e_time,         readout time (row 0)
 FIELD     nstar,            NSTAR,                unsigned int,   number of stars on image
-FIELD     secz,             SECZ,                 short,          airmass,                   milliairmass
+FIELD     secz_PS,          SECZ,                 float,          airmass,                   mag
 FIELD     NX,               NX,                   short,          image width
 FIELD     NY,               NY,                   short,          image height
-FIELD     apmifit,          APMIFIT,              short,          aperture correction,       millimag
-FIELD     dapmifit,         DAPMIFIT,             short,          apmifit error,             millimag
+FIELD     apmifit_PS,       APMIFIT,              float,          aperture correction,       mag
+FIELD     dapmifit_PS,      DAPMIFIT,             float,          apmifit error,             mag
+FIELD     Mcal_PS,          MCAL,                 float,          calibration mag,           mag
+FIELD     dMcal_PS,         DMCAL,                float,          error on Mcal,             mag
+FIELD     Xm,               XM,                   short,          image chisq,               10*log(value)
 FIELD     source,           SOURCE,               short,          identifier for CCD,
-FIELD     Mcal,             MCAL,                 short,          calibration mag,           millimag
-FIELD     dMcal,            DMCAL,                short,          error on Mcal,             millimag
-FIELD     Xm,               XM,                   short,          image chisq,               10*log(value)
+FIELD     exptime,          EXPTIME,              float,          exposure time,             seconds
+# 40 bytes
+
 FIELD     name,             NAME,                 char[32],       name of original image 
 FIELD     detection_limit,  DETECTION_LIMIT,      unsigned char,  detection limit,           10*mag
@@ -39 +43 @@
 FIELD     fwhm_y,           FWHM_Y,               unsigned char,  PSF y width,               25*arcsec
 FIELD     trate,            TRATE,                unsigned char,  scan rate,                 100 usec/pixel
-FIELD     exptime,          EXPTIME,              float,          exposure time,             seconds
 FIELD     code,             CODE,                 char,           image quality flag
 FIELD     ccdnum,           CCDNUM,               unsigned char,  CCD ID number
-FIELD     dummy,            DUMMY,                char[20],       unused
+# 40 bytes 
+
+FIELD     dummy,            DUMMY,                char[18],       unused
 FIELD     order,            ORDER,                short,          Mrel 2D polynomical order 
 FIELD     Mx,               MX,                   short,          Mrel polyterm
@@ -58 +63 @@
 FIELD     Mxyyy,            MXYYY,                short,          Mrel polyterm
 FIELD     Myyyy,            MYYYY,                short,          Mrel polyterm
+# 48 bytes

trunk/Ohana/src/libautocode/def/measure-panstarrs.d

@@ -2 +2 @@
 EXTNAME DVO_MEASURE_PANSTARRS
 TYPE    BINTABLE
-SIZE    50
+SIZE    52
 
 # elements of data structure / FITS table
@@ -20 +20 @@
 FIELD source,         source,     unsigned short, photcode
 FIELD flags,          flags,      unsigned short, flags for various uses  
+FIELD dummy,          dummy,      short,          extra space
 FIELD t,              t,          unsigned int,   time in seconds (UNIX)
 FIELD averef,         averef,     unsigned int,   reference to average entry      

trunk/Ohana/src/libautocode/def/secfilt-panstarrs.d

@@ -2 +2 @@
 EXTNAME DVO_SECFILT_PANSTARRS
 TYPE    BINTABLE
-SIZE    8
+SIZE    12
 
 # elements of data structure / FITS table
 FIELD  M,  MAG,      float,                other mags,       mags
-FIELD  dM, MAG_ERR,  short,                scatter on mag    1e4*mag
+FIELD  dM, MAG_ERR,  float,                scatter on mag    1e4*mag
 FIELD  Xm, MAG_CHI,  short,                chisq on mag,     [100*log(value)]
+FIELD  dummy, JUNK,  short,                chisq on mag,     [100*log(value)]

trunk/Ohana/src/libautocode/def/secfilt.d

@@ -2 +2 @@
 EXTNAME DVO_SECFILT
 TYPE    BINTABLE
-SIZE    10
+SIZE    12
 
 # elements of data structure / FITS table
@@ -8 +8 @@
 FIELD  dM_PS, MAG_ERR,  float,                scatter on mag    mags
 FIELD  Xm,    MAG_CHI,  short,                chisq on mag      [100*log(value)]
+FIELD  dummy, JUNK,     short,                place holder

trunk/Ohana/src/libautocode/generate

@@ -35 +35 @@
         ($key, $value) = split (" ", $line, 2);
         
+        # strip white space from the following
+        if ($key eq "TYPE")    { ($value) = $value =~ m|\s*(\S+)\s*|; }
+        if ($key eq "SIZE")    { ($value) = $value =~ m|\s*(\S+)\s*|; }
+        if ($key eq "STRUCT")  { ($value) = $value =~ m|\s*(\S+)\s*|; }
+        if ($key eq "EXTNAME") { ($value) = $value =~ m|\s*(\S+)\s*|; }
+
         &set_keypair ($key, $value);
 
         # there are used internally (not just a replacement)
-        if ($key eq "TYPE")   { $TYPE = $value;   }
-        if ($key eq "SIZE")   { $SIZE = $value;   }
-        if ($key eq "STRUCT") { $STRUCT = $value; }
+        if ($key eq "TYPE")    { $TYPE = $value;   }
+        if ($key eq "SIZE")    { $SIZE = $value;   }
+        if ($key eq "STRUCT")  { $STRUCT = $value; }
 
         # not a simple key/value entry
@@ -54 +60 @@
         }
     }
+    $Nexpect = 0;
     if ($TYPE eq "BINTABLE") { $Nexpect = &count_bintablesize; }
     if ($TYPE eq "TABLE")    { $Nexpect = &count_tablesize;    }
+    if (! $Nexpect) { die "missing valid TYPE\n"; }
     if ($Nexpect != $SIZE) { die "size mismatch: $Nexpect vs $SIZE\n"; }
 }

trunk/Ohana/src/libfits/include/fits.h

@@ -46 +46 @@
       fprintf(stderr,"failed realloc increment at %d in %s\n", __LINE__, __FILE__);\
       exit (10); } }
+# define free(X) \
+  free(X); X = NULL;
+
 # endif /* ALLOCATE */
 

trunk/Ohana/src/libohana/Makefile

@@ -48 +48 @@
 $(SRC)/photfits.$(ARCH).o        \
 $(SRC)/dvo_image.$(ARCH).o           \
+$(SRC)/dvo_image_raw.$(ARCH).o           \
 $(SRC)/phot_catalog.$(ARCH).o    \
 $(SRC)/phot_catalog_mef.$(ARCH).o      \
@@ -63 +64 @@
 $(ASRC)/average-panstarrs.$(ARCH).o \
 $(ASRC)/secfilt.$(ARCH).o \
+$(ASRC)/secfilt-loneos.$(ARCH).o \
 $(ASRC)/secfilt-elixir.$(ARCH).o \
 $(ASRC)/secfilt-panstarrs.$(ARCH).o \
@@ -72 +74 @@
 $(ASRC)/photcode.$(ARCH).o \
 $(ASRC)/image.$(ARCH).o \
+$(ASRC)/image-loneos.$(ARCH).o \
+$(ASRC)/image-elixir.$(ARCH).o \
+$(ASRC)/image-panstarrs.$(ARCH).o \
 $(ASRC)/regimage.$(ARCH).o \
 $(ASRC)/detreg.$(ARCH).o \

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

@@ -11 +11 @@
 
 /* DVO table modes */
-enum {DVO_MODE_RAW, DVO_MODE_MEF, DVO_MODE_SPLIT, DVO_MODE_MYSQL} DVOTableMode;
+enum {DVO_MODE_UNDEF, DVO_MODE_RAW, DVO_MODE_MEF, DVO_MODE_SPLIT, DVO_MODE_MYSQL} DVOTableMode;
 
 /* DVO table formats */
-enum {DVO_FORMAT_UNDEF, DVO_FORMAT_ELIXIR, DVO_FORMAT_LONEOS, DVO_FORMAT_PANSTARRS} DVOTableFormat;
+enum {DVO_FORMAT_UNDEF, DVO_FORMAT_INTERNAL, DVO_FORMAT_ELIXIR, DVO_FORMAT_LONEOS, DVO_FORMAT_PANSTARRS} DVOTableFormat;
 
 /* image data modes in RegImage */
@@ -125 +125 @@
 
   /* extra table data if needed (move these to enums?) */
+  # if (0)
   char catmode[10];         /* storage mode: raw, mef, split, mysql */
   char average_format[80];  /* table format: internal, loneos, elixir, panstarrs */
   char measure_format[80];  /* table format: must match average_format */
+  char secfilt_format[80];  /* table format: must match average_format */
+  # endif
+
+  int catmode;
+  int catformat;
   
   /* data in the catalog */
@@ -245 +251 @@
 /*** conversion functions / I/O conversions ***/
 
-Average *AveragePanstarrsToInternal (AveragePanstarrs *in, int Nvalues);
-Average *FtableToAverage (FTable *ftable, int *Naverage, char *extname);
-Average *ReadRawAverage (FILE *f, int Naverage, char *format);
+Average *ReadRawAverage (FILE *f, int Naverage, int format);
+Measure *ReadRawMeasure (FILE *f, int Nmeasure, int format);
+SecFilt *ReadRawSecFilt (FILE *f, int Nsecfilt, int format);
+int WriteRawAverage (FILE *f, Average *average, int Naverage, int format);
+int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, int format);
+int WriteRawSecFilt (FILE *f, SecFilt *secfilt, int Nsecfilt, int format);
+
+Average *FtableToAverage (FTable *ftable, int *Naverage, int *format);
 Average *AverageLoneosToInternal (AverageLoneos *in, int Nvalues);
 Average *AverageElixirToInternal (AverageElixir *in, int Nvalues);
+Average *AveragePanstarrsToInternal (AveragePanstarrs *in, int Nvalues);
+AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues);
 AverageElixir *AverageInternalToElixir (Average *in, int Nvalues);
-AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues);
 AveragePanstarrs *AverageInternalToPanstarrs (Average *in, int Nvalues);
-Measure *MeasurePanstarrsToInternal (MeasurePanstarrs *in, int Nvalues);
-Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, char *extname);
-Measure *ReadRawMeasure (FILE *f, int Nmeasure, char *format);
+
+Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, int *format);
 Measure *MeasureLoneosToInternal (MeasureLoneos *in, int Nvalues);
 Measure *MeasureElixirToInternal (MeasureElixir *in, int Nvalues);
+Measure *MeasurePanstarrsToInternal (MeasurePanstarrs *in, int Nvalues);
+MeasureLoneos *MeasureInternalToLoneos (Measure *in, int Nvalues);
 MeasureElixir *MeasureInternalToElixir (Measure *in, int Nvalues);
-MeasureLoneos *MeasureInternalToLoneos (Measure *in, int Nvalues);
 MeasurePanstarrs *MeasureInternalToPanstarrs (Measure *in, int Nvalues);
-int AverageToFtable (FTable *ftable, Average *average, int Naverage, char *extname);
-int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, char *extname);
-int WriteRawAverage (FILE *f, Average *average, int Naverage, char *format);
-int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, char *format);
+
+SecFilt *FtableToSecFilt (FTable *ftable, int *Nsecfilt, int *format);
+SecFilt *SecFiltLoneosToInternal (SecFiltLoneos *in, int Nvalues);
+SecFilt *SecFiltElixirToInternal (SecFiltElixir *in, int Nvalues);
+SecFilt *SecFiltPanstarrsToInternal (SecFiltPanstarrs *in, int Nvalues);
+SecFiltLoneos *SecFiltInternalToLoneos (SecFilt *in, int Nvalues);
+SecFiltElixir *SecFiltInternalToElixir (SecFilt *in, int Nvalues);
+SecFiltPanstarrs *SecFiltInternalToPanstarrs (SecFilt *in, int Nvalues);
+
+int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format);
+int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format);
+int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format);
+
 int load_catalog_raw (Catalog *catalog, char mode, int VERBOSE);
 int save_catalog_raw (Catalog *catalog, char VERBOSE);
@@ -279 +300 @@
 int dvo_image_addrows (FITS_DB *db, Image *new, int Nnew);
 
+int FtableToImage (FTable *ftable, Header *theader, int *format);
+int ImageToFtable (FTable *ftable, Header *theader, int format);
+int ImageToVtable (VTable *vtable, Header *theader, int format);
+Image *ImageElixirToInternal (ImageElixir *in, int Nvalues);
+ImageElixir *ImageInternalToElixir (Image *in, int Nvalues);
+Image *ImageLoneosToInternal (ImageLoneos *in, int Nvalues);
+ImageLoneos *ImageInternalToLoneos (Image *in, int Nvalues);
+Image *ImagePanstarrsToInternal (ImagePanstarrs *in, int Nvalues);
+ImagePanstarrs *ImageInternalToPanstarrs (Image *in, int Nvalues);
+
 # endif

trunk/Ohana/src/libohana/src/dvo_convert.c

@@ -3 +3 @@
 
 /* The Ftable-TYPE conversion functions determine the format of table based on EXTNAME in header.
-   they convert the table to the internal format, and set 'extname'.  
+   they convert the table to the internal format, and set 'format'.  
 
    The TYPE-Ftable conversions functions create output tables in the format requested
-   by the 'extname' function parameter.
+   by the 'format' function parameter.
  */
 
@@ -14 +14 @@
 /*** Average / FTable conversion functions ***/
 
-Average *FtableToAverage (FTable *ftable, int *Naverage, char *extname) {
+Average *FtableToAverage (FTable *ftable, int *Naverage, int *format) {
 
   Average *average;
+  char extname[80];
 
   /* convert to the internal format */
@@ -25 +26 @@
   if (!strcmp (extname, "DVO_AVERAGE")) {
     average = fits_table_get_Average (ftable, Naverage, NULL);
+    *format = DVO_FORMAT_INTERNAL;
     return (average);
   }
   if (!strcmp (extname, "DVO_AVERAGE_ELIXIR")) {
-    AverageElixir *tmpaverage;
-    tmpaverage = fits_table_get_AverageElixir (ftable, Naverage, NULL);
-    average = AverageElixirToInternal (tmpaverage, *Naverage);
-    free (tmpaverage);
+    AverageElixir *tmpAverage;
+    tmpAverage = fits_table_get_AverageElixir (ftable, Naverage, NULL);
+    average = AverageElixirToInternal (tmpAverage, *Naverage);
+    free (tmpAverage);
+    *format = DVO_FORMAT_ELIXIR;
     return (average);
   }
   if (!strcmp (extname, "DVO_AVERAGE_LONEOS")) {
-    AverageLoneos *tmpaverage;
-    tmpaverage = fits_table_get_AverageLoneos (ftable, Naverage, NULL);
-    average = AverageLoneosToInternal (tmpaverage, *Naverage);
-    free (tmpaverage);
+    AverageLoneos *tmpAverage;
+    tmpAverage = fits_table_get_AverageLoneos (ftable, Naverage, NULL);
+    average = AverageLoneosToInternal (tmpAverage, *Naverage);
+    free (tmpAverage);
+    *format = DVO_FORMAT_LONEOS;
     return (average);
   }
   if (!strcmp (extname, "DVO_AVERAGE_PANSTARRS")) {
-    AveragePanstarrs *tmpaverage;
-    tmpaverage = fits_table_get_AveragePanstarrs (ftable, Naverage, NULL);
-    average = AveragePanstarrsToInternal (tmpaverage, *Naverage);
-    free (tmpaverage);
+    AveragePanstarrs *tmpAverage;
+    tmpAverage = fits_table_get_AveragePanstarrs (ftable, Naverage, NULL);
+    average = AveragePanstarrsToInternal (tmpAverage, *Naverage);
+    free (tmpAverage);
+    *format = DVO_FORMAT_PANSTARRS;
     return (average);
   }
@@ -55 +60 @@
 }
 
-int AverageToFtable (FTable *ftable, Average *average, int Naverage, char *extname) {
+int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format) {
+
+  AverageElixir *tmpAverageElixir;
+  AverageLoneos *tmpAverageLoneos ;
+  AveragePanstarrs *tmpAveragePanstarrs;
 
   /* convert from the internal format */
-  if (!strcmp (extname, "DVO_AVERAGE")) {
-    fits_table_set_Average (ftable, average, Naverage);
-    return (TRUE);
-  }
-  if (!strcmp (extname, "DVO_AVERAGE_ELIXIR")) {
-    AverageElixir *tmpaverage;
-    tmpaverage = AverageInternalToElixir (average, Naverage);
-    fits_table_set_AverageElixir (ftable, tmpaverage, Naverage);
-    free (tmpaverage);
-    return (TRUE);
-  }
-  if (!strcmp (extname, "DVO_AVERAGE_LONEOS")) {
-    AverageLoneos *tmpaverage;
-    tmpaverage = AverageInternalToLoneos (average, Naverage);
-    fits_table_set_AverageLoneos (ftable, tmpaverage, Naverage);
-    free (tmpaverage);
-    return (TRUE);
-  }
-  if (!strcmp (extname, "DVO_AVERAGE_PANSTARRS")) {
-    AveragePanstarrs *tmpaverage;
-    tmpaverage = AverageInternalToPanstarrs (average, Naverage);
-    fits_table_set_AveragePanstarrs (ftable, tmpaverage, Naverage);
-    free (tmpaverage);
-    return (TRUE);
-  }
-  fprintf (stderr, "table format unknown: %s\n", extname);
-  return (FALSE);
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      fits_table_set_Average (ftable, average, Naverage);
+      break;
+    case DVO_FORMAT_ELIXIR:
+      tmpAverageElixir = AverageInternalToElixir (average, Naverage);
+      fits_table_set_AverageElixir (ftable, tmpAverageElixir, Naverage);
+      free (tmpAverageElixir);
+      break;
+    case DVO_FORMAT_LONEOS:
+      tmpAverageLoneos  = AverageInternalToLoneos (average, Naverage);
+      fits_table_set_AverageLoneos (ftable, tmpAverageLoneos , Naverage);
+      free (tmpAverageLoneos );
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      tmpAveragePanstarrs = AverageInternalToPanstarrs (average, Naverage);
+      fits_table_set_AveragePanstarrs (ftable, tmpAveragePanstarrs, Naverage);
+      free (tmpAveragePanstarrs);
+      break;
+    default:
+      fprintf (stderr, "table format unknown (average)\n");
+      return (FALSE);
+  }
+  return (TRUE);
 }
 
 /*** Measure / FTable conversion functions ***/
 
-Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, char *extname) {
+Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, int *format) {
 
   Measure *measure;
+  char extname[80];
 
   /* convert to the internal format */
@@ -100 +107 @@
   if (!strcmp (extname, "DVO_MEASURE")) {
     measure = fits_table_get_Measure (ftable, Nmeasure, NULL);
+    *format = DVO_FORMAT_INTERNAL;
     return (measure);
   }
   if (!strcmp (extname, "DVO_MEASURE_ELIXIR")) {
-    MeasureElixir *tmpmeasure;
-    tmpmeasure = fits_table_get_MeasureElixir (ftable, Nmeasure, NULL);
-    measure = MeasureElixirToInternal (tmpmeasure, *Nmeasure);
-    free (tmpmeasure);
+    MeasureElixir *tmpMeasure;
+    tmpMeasure = fits_table_get_MeasureElixir (ftable, Nmeasure, NULL);
+    measure = MeasureElixirToInternal (tmpMeasure, *Nmeasure);
+    free (tmpMeasure);
+    *format = DVO_FORMAT_ELIXIR;
     return (measure);
   }
   if (!strcmp (extname, "DVO_MEASURE_LONEOS")) {
-    MeasureLoneos *tmpmeasure;
-    tmpmeasure = fits_table_get_MeasureLoneos (ftable, Nmeasure, NULL);
-    measure = MeasureLoneosToInternal (tmpmeasure, *Nmeasure);
-    free (tmpmeasure);
+    MeasureLoneos *tmpMeasure;
+    tmpMeasure = fits_table_get_MeasureLoneos (ftable, Nmeasure, NULL);
+    measure = MeasureLoneosToInternal (tmpMeasure, *Nmeasure);
+    free (tmpMeasure);
+    *format = DVO_FORMAT_LONEOS;
     return (measure);
   }
   if (!strcmp (extname, "DVO_MEASURE_PANSTARRS")) {
-    MeasurePanstarrs *tmpmeasure;
-    tmpmeasure = fits_table_get_MeasurePanstarrs (ftable, Nmeasure, NULL);
-    measure = MeasurePanstarrsToInternal (tmpmeasure, *Nmeasure);
-    free (tmpmeasure);
+    MeasurePanstarrs *tmpMeasure;
+    tmpMeasure = fits_table_get_MeasurePanstarrs (ftable, Nmeasure, NULL);
+    measure = MeasurePanstarrsToInternal (tmpMeasure, *Nmeasure);
+    free (tmpMeasure);
+    *format = DVO_FORMAT_PANSTARRS;
     return (measure);
   }
@@ -130 +141 @@
 }
 
-int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, char *extname) {
+int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format) {
+
+  MeasureElixir *tmpMeasureElixir;
+  MeasureLoneos *tmpMeasureLoneos;
+  MeasurePanstarrs *tmpMeasurePanstarrs;
 
   /* convert from the internal format */
-  if (!strcmp (extname, "DVO_MEASURE")) {
-    fits_table_set_Measure (ftable, measure, Nmeasure);
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      fits_table_set_Measure (ftable, measure, Nmeasure);
+      break;
+    case DVO_FORMAT_ELIXIR:
+      tmpMeasureElixir = MeasureInternalToElixir (measure, Nmeasure);
+      fits_table_set_MeasureElixir (ftable, tmpMeasureElixir, Nmeasure);
+      free (tmpMeasureElixir);
+      break;
+    case DVO_FORMAT_LONEOS:
+      tmpMeasureLoneos = MeasureInternalToLoneos (measure, Nmeasure);
+      fits_table_set_MeasureLoneos (ftable, tmpMeasureLoneos, Nmeasure);
+      free (tmpMeasureLoneos);
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      tmpMeasurePanstarrs = MeasureInternalToPanstarrs (measure, Nmeasure);
+      fits_table_set_MeasurePanstarrs (ftable, tmpMeasurePanstarrs, Nmeasure);
+      free (tmpMeasurePanstarrs);
+      break;
+    default:
+      fprintf (stderr, "table format unknown (measure)\n");
+      return (FALSE);
+  }
+  return (TRUE);
+}
+
+/*** SecFilt / FTable conversion functions ***/
+
+SecFilt *FtableToSecFilt (FTable *ftable, int *Nsecfilt, int *format) {
+
+  SecFilt *secfilt;
+  char extname[80];
+
+  /* convert to the internal format */
+  if (!fits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
+    fprintf (stderr, "EXTNAME missing for secfilt table\n");
+    return (FALSE);
+  }
+  if (!strcmp (extname, "DVO_SECFILT")) {
+    secfilt = fits_table_get_SecFilt (ftable, Nsecfilt, NULL);
+    *format = DVO_FORMAT_INTERNAL;
+    return (secfilt);
+  }
+  if (!strcmp (extname, "DVO_SECFILT_ELIXIR")) {
+    SecFiltElixir *tmpSecFilt;
+    tmpSecFilt = fits_table_get_SecFiltElixir (ftable, Nsecfilt, NULL);
+    secfilt = SecFiltElixirToInternal (tmpSecFilt, *Nsecfilt);
+    free (tmpSecFilt);
+    *format = DVO_FORMAT_ELIXIR;
+    return (secfilt);
+  }
+  if (!strcmp (extname, "DVO_SECFILT_LONEOS")) {
+    SecFiltLoneos *tmpSecFilt;
+    tmpSecFilt = fits_table_get_SecFiltLoneos (ftable, Nsecfilt, NULL);
+    secfilt = SecFiltLoneosToInternal (tmpSecFilt, *Nsecfilt);
+    free (tmpSecFilt);
+    *format = DVO_FORMAT_LONEOS;
+    return (secfilt);
+  }
+  if (!strcmp (extname, "DVO_SECFILT_PANSTARRS")) {
+    SecFiltPanstarrs *tmpSecFilt;
+    tmpSecFilt = fits_table_get_SecFiltPanstarrs (ftable, Nsecfilt, NULL);
+    secfilt = SecFiltPanstarrsToInternal (tmpSecFilt, *Nsecfilt);
+    free (tmpSecFilt);
+    *format = DVO_FORMAT_PANSTARRS;
+    return (secfilt);
+  }
+
+  fprintf (stderr, "table format unknown: %s\n", extname);
+
+  *Nsecfilt = 0;
+  return (NULL);
+}
+
+int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format) {
+
+  SecFiltElixir *tmpSecFiltElixir;
+  SecFiltLoneos *tmpSecFiltLoneos;
+  SecFiltPanstarrs *tmpSecFiltPanstarrs;
+
+  /* convert from the internal format */
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      fits_table_set_SecFilt (ftable, secfilt, Nsecfilt);
+      break;
+    case DVO_FORMAT_ELIXIR:
+      tmpSecFiltElixir = SecFiltInternalToElixir (secfilt, Nsecfilt);
+      fits_table_set_SecFiltElixir (ftable, tmpSecFiltElixir, Nsecfilt);
+      free (tmpSecFiltElixir);
+      break;
+    case DVO_FORMAT_LONEOS:
+      tmpSecFiltLoneos = SecFiltInternalToLoneos (secfilt, Nsecfilt);
+      fits_table_set_SecFiltLoneos (ftable, tmpSecFiltLoneos, Nsecfilt);
+      free (tmpSecFiltLoneos);
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      tmpSecFiltPanstarrs = SecFiltInternalToPanstarrs (secfilt, Nsecfilt);
+      fits_table_set_SecFiltPanstarrs (ftable, tmpSecFiltPanstarrs, Nsecfilt);
+      free (tmpSecFiltPanstarrs);
+      break;
+    default:
+      fprintf (stderr, "table format unknown (secfilt)\n");
+      return (FALSE);
+  }
+  return (TRUE);
+}
+
+/*** Image Conversions ***/
+
+int FtableToImage (FTable *ftable, Header *theader, int *format) {
+
+  int Nimage;
+  char extname[80];
+
+  /* extname may be set from outside if the source is RAW not MEF */
+  if (*format == DVO_FORMAT_ELIXIR) {
+    ImageElixir *tmpimage;
+    tmpimage = fits_table_get_ImageElixir (ftable, &Nimage, NULL);
+    ftable[0].buffer = (char *) ImageElixirToInternal (tmpimage, Nimage);
+    free (tmpimage);
+    goto set_header;
+  }
+
+  /* convert to the internal format */
+  if (!fits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
+    fprintf (stderr, "EXTNAME missing for image table\n");
+    return (FALSE);
+  }
+  if (!strcmp (extname, "DVO_IMAGE")) {
+    Image *image;
+    image = fits_table_get_Image (ftable, &Nimage, NULL);
+    *format = DVO_FORMAT_INTERNAL;
     return (TRUE);
   }
-  if (!strcmp (extname, "DVO_MEASURE_ELIXIR")) {
-    MeasureElixir *tmpmeasure;
-    tmpmeasure = MeasureInternalToElixir (measure, Nmeasure);
-    fits_table_set_MeasureElixir (ftable, tmpmeasure, Nmeasure);
-    free (tmpmeasure);
-    return (TRUE);
-  }
-  if (!strcmp (extname, "DVO_MEASURE_LONEOS")) {
-    MeasureLoneos *tmpmeasure;
-    tmpmeasure = MeasureInternalToLoneos (measure, Nmeasure);
-    fits_table_set_MeasureLoneos (ftable, tmpmeasure, Nmeasure);
-    free (tmpmeasure);
-    return (TRUE);
-  }
-  if (!strcmp (extname, "DVO_MEASURE_PANSTARRS")) {
-    MeasurePanstarrs *tmpmeasure;
-    tmpmeasure = MeasureInternalToPanstarrs (measure, Nmeasure);
-    fits_table_set_MeasurePanstarrs (ftable, tmpmeasure, Nmeasure);
-    free (tmpmeasure);
-    return (TRUE);
-  }
-
+  if (!strcmp (extname, "DVO_IMAGE_ELIXIR")) {
+    ImageElixir *tmpimage;
+    *format = DVO_FORMAT_ELIXIR;
+    tmpimage = fits_table_get_ImageElixir (ftable, &Nimage, NULL);
+    ftable[0].buffer = (char *) ImageElixirToInternal (tmpimage, Nimage);
+    free (tmpimage);
+    goto set_header;
+  }
+  if (!strcmp (extname, "DVO_IMAGE_LONEOS")) {
+    ImageLoneos *tmpimage;
+    *format = DVO_FORMAT_LONEOS;
+    tmpimage = fits_table_get_ImageLoneos (ftable, &Nimage, NULL);
+    ftable[0].buffer = (char *) ImageLoneosToInternal (tmpimage, Nimage);
+    free (tmpimage);
+    goto set_header;
+  }
+  if (!strcmp (extname, "DVO_IMAGE_PANSTARRS")) {
+    ImagePanstarrs *tmpimage;
+    *format = DVO_FORMAT_PANSTARRS;
+    tmpimage = fits_table_get_ImagePanstarrs (ftable, &Nimage, NULL);
+    ftable[0].buffer = (char *) ImagePanstarrsToInternal (tmpimage, Nimage);
+    free (tmpimage);
+    goto set_header;
+  }
   fprintf (stderr, "table format unknown: %s\n", extname);
   return (FALSE);
-}
-
-/** Average / Raw Table conversions **/
-
-Average *ReadRawAverage (FILE *f, int Naverage, char *format) {
-
-  int nitems;
-  Average *average;
-
-  if (!strcmp (format, "DVO_AVERAGE")) {
-    ALLOCATE (average, Average, MAX (Naverage, 1));
-    nitems = fread (average, sizeof(Average), Naverage, f);
-    if (nitems != Naverage) {
-      fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
-      return (NULL);
-    }
-    fits_convert_Average (average, sizeof(Average), Naverage);
-    return (average);
-  }
-  if (!strcmp (format, "DVO_AVERAGE_ELIXIR")) {
-    AverageElixir *tmpaverage;
-    ALLOCATE (tmpaverage, AverageElixir, MAX (Naverage, 1));
-    nitems = fread (tmpaverage, sizeof(AverageElixir), Naverage, f);
-    if (nitems != Naverage) {
-      fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
-      return (NULL);
-    }
-    fits_convert_AverageElixir (tmpaverage, sizeof(AverageElixir), Naverage);
-    average = AverageElixirToInternal (tmpaverage, Naverage);
-    free (tmpaverage);
-    return (average);
-  }
-  if (!strcmp (format, "DVO_AVERAGE_LONEOS")) {
-    AverageLoneos *tmpaverage;
-    ALLOCATE (tmpaverage, AverageLoneos, MAX (Naverage, 1));
-    nitems = fread (tmpaverage, sizeof(AverageLoneos), Naverage, f);
-    if (nitems != Naverage) {
-      fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
-      return (NULL);
-    }
-    fits_convert_AverageLoneos (tmpaverage, sizeof(AverageLoneos), Naverage);
-    average = AverageLoneosToInternal (tmpaverage, Naverage);
-    free (tmpaverage);
-    return (average);
-  }
-  if (!strcmp (format, "DVO_AVERAGE_PANSTARRS")) {
-    AveragePanstarrs *tmpaverage;
-    ALLOCATE (tmpaverage, AveragePanstarrs, MAX (Naverage, 1));
-    nitems = fread (tmpaverage, sizeof(AveragePanstarrs), Naverage, f);
-    if (nitems != Naverage) {
-      fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
-      return (NULL);
-    }
-    fits_convert_AveragePanstarrs (tmpaverage, sizeof(AveragePanstarrs), Naverage);
-    average = AveragePanstarrsToInternal (tmpaverage, Naverage);
-    free (tmpaverage);
-    return (average);
-  }
-  fprintf (stderr, "error reading averages\n");
-  return (NULL);
-}
-
-/* accepts and converts internal average formats and outputs 
-   raw data in the specified format */
-int WriteRawAverage (FILE *f, Average *average, int Naverage, char *format) {
-
-  int nitems;
-
-  if (!strcmp (format, "DVO_AVERAGE")) {
-    fits_convert_Average (average, sizeof(Average), Naverage);
-    nitems = fwrite (average, sizeof(Average), Naverage, f);
-    if (nitems != Naverage) {
-      fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
+
+set_header:
+  fits_free_header (theader);
+  fits_table_mkheader_Image (theader);
+  fits_modify (theader, "NAXIS2", "%d", 1, Nimage);
+  theader[0].Naxis[1] = Nimage;
+  ftable[0].size = fits_matrix_size (theader);
+  return (TRUE);
+}
+
+int ImageToFtable (FTable *ftable, Header *theader, int format) {
+
+  int Nimage;
+  ImageElixir *tmpImageElixir;
+  ImageLoneos *tmpImageLoneos;
+  ImagePanstarrs *tmpImagePanstarrs;
+
+  Nimage = theader[0].Naxis[1];
+
+  /* convert from the internal format */
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      fits_convert_Image ((Image *) ftable[0].buffer, sizeof(Image), Nimage);
+      break;
+    case DVO_FORMAT_ELIXIR:
+      tmpImageElixir = ImageInternalToElixir ((Image *) ftable[0].buffer, Nimage);
+      free (ftable[0].buffer);
+      fits_table_set_ImageElixir (ftable, tmpImageElixir, Nimage);
+      free (tmpImageElixir);
+      break;
+    case DVO_FORMAT_LONEOS:
+      tmpImageLoneos = ImageInternalToLoneos ((Image *) ftable[0].buffer, Nimage);
+      free (ftable[0].buffer);
+      fits_table_set_ImageLoneos (ftable, tmpImageLoneos, Nimage);
+      free (tmpImageLoneos);
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      tmpImagePanstarrs = ImageInternalToPanstarrs ((Image *) ftable[0].buffer, Nimage);
+      free (ftable[0].buffer);
+      fits_table_set_ImagePanstarrs (ftable, tmpImagePanstarrs, Nimage);
+      free (tmpImagePanstarrs);
+      break;
+    default:
+      fprintf (stderr, "table format unknown (image ftable)\n");
       return (FALSE);
+  }
+  return (TRUE);
+}
+
+int ImageToVtable (VTable *vtable, Header *theader, int format) {
+
+  int i, Nrow, Nimage;
+
+  Nrow = vtable[0].Nrow;
+
+  /* convert from the internal format */
+  if (format == DVO_FORMAT_INTERNAL) {
+    for (i = 0; i < Nrow; i++) {
+      fits_convert_Image ((Image *) vtable[0].buffer[i], sizeof(Image), 1);
     }
     return (TRUE);
   }
-  if (!strcmp (format, "DVO_AVERAGE_ELIXIR")) {
-    AverageElixir *tmpaverage;
-    tmpaverage = AverageInternalToElixir (average, Naverage);
-    fits_convert_AverageElixir (tmpaverage, sizeof(AverageElixir), Naverage);
-    nitems = fwrite (tmpaverage, sizeof(AverageElixir), Naverage, f);
-    free (tmpaverage);
-    if (nitems != Naverage) {
-      fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
-      return (FALSE);
+  if (format == DVO_FORMAT_ELIXIR) {
+    ImageElixir *tmpImage;
+
+    /* convert table rows from internal to external format */
+    for (i = 0; i < Nrow; i++) {
+      tmpImage = ImageInternalToElixir ((Image *) vtable[0].buffer[i], 1);
+      fits_convert_ImageElixir (tmpImage, sizeof(ImageElixir), 1);
+      free (vtable[0].buffer[i]);
+      vtable[0].buffer[i] = (char *) tmpImage;
     }
+
+    /* convert header from old format to new format */
+    fits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
+
+    fits_free_header (theader);
+    fits_table_mkheader_ImageElixir (theader);
+
+    fits_modify (theader, "NAXIS2", "%d", 1, Nimage);
+    theader[0].Naxis[1] = Nimage;
+    vtable[0].size = fits_matrix_size (theader);
     return (TRUE);
   }
-  if (!strcmp (format, "DVO_AVERAGE_LONEOS")) {
-    AverageLoneos *tmpaverage;
-    tmpaverage = AverageInternalToLoneos (average, Naverage);
-    fits_convert_AverageLoneos (tmpaverage, sizeof(AverageLoneos), Naverage);
-    nitems = fwrite (tmpaverage, sizeof(AverageLoneos), Naverage, f);
-    free (tmpaverage);
-    if (nitems != Naverage) {
-      fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
-      return (FALSE);
+  if (format == DVO_FORMAT_LONEOS) {
+    ImageLoneos *tmpImage;
+
+    /* convert table rows from internal to external format */
+    for (i = 0; i < Nrow; i++) {
+      tmpImage = ImageInternalToLoneos ((Image *) vtable[0].buffer[i], 1);
+      fits_convert_ImageLoneos (tmpImage, sizeof(ImageLoneos), 1);
+      free (vtable[0].buffer[i]);
+      vtable[0].buffer[i] = (char *) tmpImage;
     }
+
+    /* convert header from old format to new format */
+    fits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
+
+    fits_free_header (theader);
+    fits_table_mkheader_ImageLoneos (theader);
+
+    fits_modify (theader, "NAXIS2", "%d", 1, Nimage);
+    theader[0].Naxis[1] = Nimage;
+    vtable[0].size = fits_matrix_size (theader);
     return (TRUE);
   }
-  if (!strcmp (format, "DVO_AVERAGE_PANSTARRS")) {
-    AveragePanstarrs *tmpaverage;
-    tmpaverage = AverageInternalToPanstarrs (average, Naverage);
-    fits_convert_AveragePanstarrs (tmpaverage, sizeof(AveragePanstarrs), Naverage);
-    nitems = fwrite (tmpaverage, sizeof(AveragePanstarrs), Naverage, f);
-    free (tmpaverage);
-    if (nitems != Naverage) {
-      fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
-      return (FALSE);
+  if (format == DVO_FORMAT_PANSTARRS) {
+    ImagePanstarrs *tmpImage;
+
+    /* convert table rows from internal to external format */
+    for (i = 0; i < Nrow; i++) {
+      tmpImage = ImageInternalToPanstarrs ((Image *) vtable[0].buffer[i], 1);
+      fits_convert_ImagePanstarrs (tmpImage, sizeof(ImagePanstarrs), 1);
+      free (vtable[0].buffer[i]);
+      vtable[0].buffer[i] = (char *) tmpImage;
     }
+
+    /* convert header from old format to new format */
+    fits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
+    fits_free_header (theader);
+    fits_table_mkheader_ImagePanstarrs (theader);
+    fits_modify (theader, "NAXIS2", "%d", 1, Nimage);
+    theader[0].Naxis[1] = Nimage;
+    vtable[0].size = fits_matrix_size (theader);
     return (TRUE);
   }
-  fprintf (stderr, "error writing averages\n");
+  fprintf (stderr, "table format unknown (image vtable)\n");
   return (FALSE);
 }
-/** Average / Raw Table conversions **/
-
-Measure *ReadRawMeasure (FILE *f, int Nmeasure, char *format) {
-
-  int nitems;
-  Measure *measure;
-
-  if (!strcmp (format, "DVO_MEASURE")) {
-    ALLOCATE (measure, Measure, MAX (Nmeasure, 1));
-    nitems = fread (measure, sizeof(Measure), Nmeasure, f);
-    if (nitems != Nmeasure) {
-      fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
-      return (NULL);
-    }
-    fits_convert_Measure (measure, sizeof(Measure), Nmeasure);
-    return (measure);
-  }
-  if (!strcmp (format, "DVO_MEASURE_ELIXIR")) {
-    MeasureElixir *tmpmeasure;
-    ALLOCATE (tmpmeasure, MeasureElixir, MAX (Nmeasure, 1));
-    nitems = fread (tmpmeasure, sizeof(MeasureElixir), Nmeasure, f);
-    if (nitems != Nmeasure) {
-      fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
-      return (NULL);
-    }
-    fits_convert_MeasureElixir (tmpmeasure, sizeof(MeasureElixir), Nmeasure);
-    measure = MeasureElixirToInternal (tmpmeasure, Nmeasure);
-    free (tmpmeasure);
-    return (measure);
-  }
-  if (!strcmp (format, "DVO_MEASURE_LONEOS")) {
-    MeasureLoneos *tmpmeasure;
-    ALLOCATE (tmpmeasure, MeasureLoneos, MAX (Nmeasure, 1));
-    nitems = fread (tmpmeasure, sizeof(MeasureLoneos), Nmeasure, f);
-    if (nitems != Nmeasure) {
-      fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
-      return (NULL);
-    }
-    fits_convert_MeasureLoneos (tmpmeasure, sizeof(MeasureLoneos), Nmeasure);
-    measure = MeasureLoneosToInternal (tmpmeasure, Nmeasure);
-    free (tmpmeasure);
-    return (measure);
-  }
-  if (!strcmp (format, "DVO_MEASURE_PANSTARRS")) {
-    MeasurePanstarrs *tmpmeasure;
-    ALLOCATE (tmpmeasure, MeasurePanstarrs, MAX (Nmeasure, 1));
-    nitems = fread (tmpmeasure, sizeof(MeasurePanstarrs), Nmeasure, f);
-    if (nitems != Nmeasure) {
-      fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
-      return (NULL);
-    }
-    fits_convert_MeasurePanstarrs (tmpmeasure, sizeof(MeasurePanstarrs), Nmeasure);
-    measure = MeasurePanstarrsToInternal (tmpmeasure, Nmeasure);
-    free (tmpmeasure);
-    return (measure);
-  }
-  fprintf (stderr, "error reading measures\n");
-  return (NULL);
-}
-
-/* accepts and converts internal measure formats and outputs 
-   raw data in the specified format */
-int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, char *format) {
-
-  int nitems;
-
-  if (!strcmp (format, "DVO_MEASURE")) {
-    fits_convert_Measure (measure, sizeof(Measure), Nmeasure);
-    nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
-    if (nitems != Nmeasure) {
-      fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
-      return (FALSE);
-    }
-    return (TRUE);
-  }
-  if (!strcmp (format, "DVO_MEASURE_ELIXIR")) {
-    MeasureElixir *tmpmeasure;
-    tmpmeasure = MeasureInternalToElixir (measure, Nmeasure);
-    fits_convert_MeasureElixir (tmpmeasure, sizeof(MeasureElixir), Nmeasure);
-    nitems = fwrite (tmpmeasure, sizeof(MeasureElixir), Nmeasure, f);
-    free (tmpmeasure);
-    if (nitems != Nmeasure) {
-      fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
-      return (FALSE);
-    }
-    return (TRUE);
-  }
-  if (!strcmp (format, "DVO_MEASURE_LONEOS")) {
-    MeasureLoneos *tmpmeasure;
-    tmpmeasure = MeasureInternalToLoneos (measure, Nmeasure);
-    fits_convert_MeasureLoneos (tmpmeasure, sizeof(MeasureLoneos), Nmeasure);
-    nitems = fwrite (tmpmeasure, sizeof(MeasureLoneos), Nmeasure, f);
-    free (tmpmeasure);
-    if (nitems != Nmeasure) {
-      fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
-      return (FALSE);
-    }
-    return (TRUE);
-  }
-  if (!strcmp (format, "DVO_MEASURE_PANSTARRS")) {
-    MeasurePanstarrs *tmpmeasure;
-    tmpmeasure = MeasureInternalToPanstarrs (measure, Nmeasure);
-    fits_convert_MeasurePanstarrs (tmpmeasure, sizeof(MeasurePanstarrs), Nmeasure);
-    nitems = fwrite (tmpmeasure, sizeof(MeasurePanstarrs), Nmeasure, f);
-    free (tmpmeasure);
-    if (nitems != Nmeasure) {
-      fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
-      return (FALSE);
-    }
-    return (TRUE);
-  }
-  fprintf (stderr, "error writing measures\n");
-  return (FALSE);
-}
-
-/*** Image Conversions ***/
-
-Image *FtableToImage (FTable *ftable, int *format) {
-
-  int Nimage;
-  Image *image;
-  char extname[80];
-
-  /* extname may be set from outside if the source is RAW not MEF */
-  if (*format == DVO_FORMAT_ELIXIR) {
-    Imagelixir *tmpimage;
-    tmpimage = fits_table_get_AverageElixir (ftable, &Nimage, NULL);
-    image = ImageElixirToInternal (tmpimage, Nimage);
-    free (tmpimage);
-    return (image);
-  }
-
-  /* convert to the internal format */
-  if (!fits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
-    fprintf (stderr, "EXTNAME missing for average table\n");
-    return (NULL);
-  }
-  if (!strcmp (extname, "DVO_IMAGE")) {
-    image = fits_table_get_Image (ftable, Nimage, NULL);
-    *format = DVO_FORMAT_INTERNAL;
-    return (image);
-  }
-  if (!strcmp (extname, "DVO_IMAGE_ELIXIR")) {
-    ImageElixir *tmpimage;
-    tmpimage = fits_table_get_ImageElixir (ftable, Nimage, NULL);
-    image = ImageElixirToInternal (tmpimage, Nimage);
-    free (tmpimage);
-    *format = DVO_FORMAT_ELIXIR;
-    return (image);
-  }
-  if (!strcmp (extname, "DVO_IMAGE_LONEOS")) {
-    ImageLoneos *tmpimage;
-    tmpimage = fits_table_get_ImageLoneos (ftable, Nimage, NULL);
-    image = ImageLoneosToInternal (tmpimage, Nimage);
-    free (tmpimage);
-    *format = DVO_FORMAT_LONEOS;
-    return (image);
-  }
-  if (!strcmp (extname, "DVO_IMAGE_PANSTARRS")) {
-    ImagePanstarrs *tmpimage;
-    tmpimage = fits_table_get_ImagePanstarrs (ftable, Nimage, NULL);
-    image = ImagePanstarrsToInternal (tmpimage, Nimage);
-    free (tmpimage);
-    *format = DVO_FORMAT_PANSTARRS;
-    return (image);
-  }
-
-  fprintf (stderr, "table format unknown: %s\n", extname);
-
-  *Nimage = 0;
-  return (NULL);
-}
-
-int ImageToFtable (FTable *ftable, Image *image, int Nimage, int format) {
-
-  /* convert from the internal format */
-  if (!strcmp (extname, "DVO_IMAGE")) {
-    fits_table_set_Image (ftable, image, Nimage);
-    return (TRUE);
-  }
-  if (!strcmp (extname, "DVO_IMAGE_ELIXIR")) {
-    ImageElixir *tmpimage;
-    tmpimage = ImageInternalToElixir (image, Nimage);
-    fits_table_set_ImageElixir (ftable, tmpimage, Nimage);
-    free (tmpimage);
-    return (TRUE);
-  }
-  if (!strcmp (extname, "DVO_IMAGE_LONEOS")) {
-    ImageLoneos *tmpimage;
-    tmpimage = ImageInternalToLoneos (image, Nimage);
-    fits_table_set_ImageLoneos (ftable, tmpimage, Nimage);
-    free (tmpimage);
-    return (TRUE);
-  }
-  if (!strcmp (extname, "DVO_IMAGE_PANSTARRS")) {
-    ImagePanstarrs *tmpimage;
-    tmpimage = ImageInternalToPanstarrs (image, Nimage);
-    fits_table_set_ImagePanstarrs (ftable, tmpimage, Nimage);
-    free (tmpimage);
-    return (TRUE);
-  }
-  fprintf (stderr, "table format unknown: %s\n", extname);
-  return (FALSE);
-}
-
+

trunk/Ohana/src/libohana/src/dvo_convert_elixir.c

@@ -2 +2 @@
 # include <dvo.h>
 
-/* convert loneos-style measures to internal measures */
+/* convert elixir-format measures to internal measures */
 Measure *MeasureElixirToInternal (MeasureElixir *in, int Nvalues) {
 
@@ -31 +31 @@
 }
 
-/* convert internal measures to loneos-style measures */
+/* convert internal measures to elixir-format measures */
 MeasureElixir *MeasureInternalToElixir (Measure *in, int Nvalues) {
 
@@ -60 +60 @@
 }
 
+/* convert elixir-format averages to internal averages */
 Average *AverageElixirToInternal (AverageElixir *in, int Nvalues) {
 
@@ -84 +85 @@
 }
 
+/* convert internal averages to elixir-format averages */
 AverageElixir *AverageInternalToElixir (Average *in, int Nvalues) {
 
@@ -107 +109 @@
   return (out);
 }
+
+/* convert elixir-format secfilts to internal secfilts */
+SecFilt *SecFiltElixirToInternal (SecFiltElixir *in, int Nvalues) {
+
+  int i;
+  SecFilt *out;
+
+  ALLOCATE (out, SecFilt, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    out[i].M_PS    = in[i].M  * 0.001;      
+    out[i].dM_PS   = in[i].dM * 0.001;      
+    out[i].Xm      = in[i].Xm;     
+  }
+  return (out);
+}
+
+/* convert internal secfilts to elixir-format secfilts */
+SecFiltElixir *SecFiltInternalToElixir (SecFilt *in, int Nvalues) {
+
+  int i;
+  SecFiltElixir *out;
+
+  ALLOCATE (out, SecFiltElixir, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    out[i].M       = in[i].M_PS  * 1000.0;      
+    out[i].dM      = in[i].dM_PS * 1000.0;
+    out[i].Xm      = in[i].Xm;     
+  }
+  return (out);
+}
+
+/* convert elixir-format images to internal images */
+Image *ImageElixirToInternal (ImageElixir *in, int Nvalues) {
+
+  int i;
+  Image *out;
+
+  ALLOCATE (out, Image, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    memcpy (out[i].dummy, in[i].dummy, 20);
+    strcpy (out[i].name, in[i].name);
+
+    out[i].tzero            = in[i].tzero;
+    out[i].nstar            = in[i].nstar;
+    out[i].secz_PS          = in[i].secz * 0.001;
+    out[i].NX               = in[i].NX;
+    out[i].NY               = in[i].NY;
+    out[i].apmifit_PS       = in[i].apmifit * 0.001;
+    out[i].dapmifit_PS      = in[i].dapmifit * 0.001;
+    out[i].Mcal_PS          = in[i].Mcal * 0.001;
+    out[i].dMcal_PS         = in[i].dMcal * 0.001;
+    out[i].Xm               = in[i].Xm;
+    out[i].source           = in[i].source;
+    out[i].exptime          = in[i].exptime;
+    out[i].detection_limit  = in[i].detection_limit;
+    out[i].saturation_limit = in[i].saturation_limit;
+    out[i].cerror           = in[i].cerror;
+    out[i].fwhm_x           = in[i].fwhm_x;
+    out[i].fwhm_y           = in[i].fwhm_y;
+    out[i].trate            = in[i].trate;
+    out[i].code             = in[i].code;
+    out[i].ccdnum           = in[i].ccdnum;
+    out[i].order            = in[i].order;
+    out[i].Mx               = in[i].Mx;
+    out[i].My               = in[i].My;
+    out[i].Mxx              = in[i].Mxx;
+    out[i].Mxy              = in[i].Mxy;
+    out[i].Myy              = in[i].Myy;
+    out[i].Mxxx             = in[i].Mxxx;
+    out[i].Mxxy             = in[i].Mxxy;
+    out[i].Mxyy             = in[i].Mxyy;
+    out[i].Myyy             = in[i].Myyy;
+    out[i].Mxxxx            = in[i].Mxxxx;
+    out[i].Mxxxy            = in[i].Mxxxy;
+    out[i].Mxxyy            = in[i].Mxxyy;
+    out[i].Mxyyy            = in[i].Mxyyy;
+    out[i].Myyyy            = in[i].Myyyy;
+  }
+  return (out);
+}
+
+/* convert internal images to elixir-format images */
+ImageElixir *ImageInternalToElixir (Image *in, int Nvalues) {
+
+  int i;
+  ImageElixir *out;
+
+  ALLOCATE (out, ImageElixir, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    memcpy (out[i].dummy, in[i].dummy, 20);
+    strcpy (out[i].name, in[i].name);
+
+    out[i].tzero            = in[i].tzero;
+    out[i].nstar            = in[i].nstar;
+    out[i].secz             = in[i].secz_PS * 1000.0;
+    out[i].NX               = in[i].NX;
+    out[i].NY               = in[i].NY;
+    out[i].apmifit          = in[i].apmifit_PS * 1000.0;
+    out[i].dapmifit         = in[i].dapmifit_PS * 1000.0;
+    out[i].Mcal             = in[i].Mcal_PS * 1000.0;
+    out[i].dMcal            = in[i].dMcal_PS * 1000.0;
+    out[i].Xm               = in[i].Xm;
+    out[i].source           = in[i].source;
+    out[i].exptime          = in[i].exptime;
+    out[i].detection_limit  = in[i].detection_limit;
+    out[i].saturation_limit = in[i].saturation_limit;
+    out[i].cerror           = in[i].cerror;
+    out[i].fwhm_x           = in[i].fwhm_x;
+    out[i].fwhm_y           = in[i].fwhm_y;
+    out[i].trate            = in[i].trate;
+    out[i].code             = in[i].code;
+    out[i].ccdnum           = in[i].ccdnum;
+    out[i].order            = in[i].order;
+    out[i].Mx               = in[i].Mx;
+    out[i].My               = in[i].My;
+    out[i].Mxx              = in[i].Mxx;
+    out[i].Mxy              = in[i].Mxy;
+    out[i].Myy              = in[i].Myy;
+    out[i].Mxxx             = in[i].Mxxx;
+    out[i].Mxxy             = in[i].Mxxy;
+    out[i].Mxyy             = in[i].Mxyy;
+    out[i].Myyy             = in[i].Myyy;
+    out[i].Mxxxx            = in[i].Mxxxx;
+    out[i].Mxxxy            = in[i].Mxxxy;
+    out[i].Mxxyy            = in[i].Mxxyy;
+    out[i].Mxyyy            = in[i].Mxyyy;
+    out[i].Myyyy            = in[i].Myyyy;
+  }
+  return (out);
+}

trunk/Ohana/src/libohana/src/dvo_convert_loneos.c

@@ -2 +2 @@
 # include <dvo.h>
 
-/* convert loneos-style measures to internal measures */
+/* convert loneos-format measures to internal measures */
 Measure *MeasureLoneosToInternal (MeasureLoneos *in, int Nvalues) {
 
@@ -35 +35 @@
 }
 
-/* convert internal measures to loneos-style measures */
+/* convert internal measures to loneos-format measures */
 MeasureLoneos *MeasureInternalToLoneos (Measure *in, int Nvalues) {
 
@@ -59 +59 @@
 }
 
+/* convert loneos-format averages to internal averages */
 Average *AverageLoneosToInternal (AverageLoneos *in, int Nvalues) {
 
@@ -85 +86 @@
 }
 
+/* convert internal averages to loneos-format averages */
 AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues) {
 
@@ -107 +109 @@
 }
 
-/*
-I need to add these to the dvo_convert structures:
-
-SecFilt *SecFiltLoneosToInternal (SecFiltLoneos *in, int Nvalues);
-SecFiltLoneos *SecFiltInternalToLoneos (SecFilt *in, int Nvalues);
-
+/* convert loneos-format secfilts to internal secfilts */
 SecFilt *SecFiltLoneosToInternal (SecFiltLoneos *in, int Nvalues) {
 
@@ -121 +118 @@
 
   for (i = 0; i < Nvalues; i++) {
-    out[i].M    = in[i].M;      
+    out[i].M_PS  = in[i].M*0.001;      
+    out[i].dM_PS = 0xffff;
+    out[i].Xm    = in[i].Xm;      
+  }
+  return (out);
+}
+
+/* convert internal secfilts to loneos-format secfilts */
+SecFiltLoneos *SecFiltInternalToLoneos (SecFilt *in, int Nvalues) {
+
+  int i;
+  SecFiltLoneos *out;
+
+  ALLOCATE (out, SecFiltLoneos, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    out[i].M    = in[i].M_PS*1000.0;      
     out[i].Xm   = in[i].Xm;      
-    out[i].dM   = 0xffff;
-  }
-  return (out);
-}
-
-SecFiltLoneos *SecFiltInternalToLoneos (SecFilt *in, int Nvalues) {
-
-  int i;
-  SecFiltLoneos *out;
-
-  ALLOCATE (out, SecFiltLoneos, Nvalues);
-
-  for (i = 0; i < Nvalues; i++) {
-    out[i].M    = in[i].M;      
-    out[i].Xm   = in[i].Xm;      
-  }
-  return (out);
-}
-*/
+  }
+  return (out);
+}
+
+/* convert loneos-format images to internal images */
+Image *ImageLoneosToInternal (ImageLoneos *in, int Nvalues) {
+
+  int i;
+  Image *out;
+
+  ALLOCATE (out, Image, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    memcpy (out[i].dummy, in[i].dummy, 20);
+    strcpy (out[i].name, in[i].name);
+
+    out[i].tzero            = in[i].tzero;
+    out[i].nstar            = in[i].nstar;
+    out[i].secz_PS          = in[i].secz * 0.001;
+    out[i].NX               = in[i].NX;
+    out[i].NY               = in[i].NY;
+    out[i].apmifit_PS       = in[i].apmifit * 0.001;
+    out[i].dapmifit_PS      = in[i].dapmifit * 0.001;
+    out[i].Mcal_PS          = in[i].Mcal * 0.001;
+    out[i].dMcal_PS         = in[i].dMcal * 0.001;
+    out[i].Xm               = in[i].Xm;
+    out[i].source           = in[i].source;
+    out[i].exptime          = in[i].exptime;
+    out[i].detection_limit  = in[i].detection_limit;
+    out[i].saturation_limit = in[i].saturation_limit;
+    out[i].cerror           = in[i].cerror;
+    out[i].fwhm_x           = in[i].fwhm_x;
+    out[i].fwhm_y           = in[i].fwhm_y;
+    out[i].trate            = in[i].trate;
+    out[i].code             = in[i].code;
+    out[i].ccdnum           = in[i].ccdnum;
+    out[i].order            = in[i].order;
+    out[i].Mx               = in[i].Mx;
+    out[i].My               = in[i].My;
+    out[i].Mxx              = in[i].Mxx;
+    out[i].Mxy              = in[i].Mxy;
+    out[i].Myy              = in[i].Myy;
+    out[i].Mxxx             = in[i].Mxxx;
+    out[i].Mxxy             = in[i].Mxxy;
+    out[i].Mxyy             = in[i].Mxyy;
+    out[i].Myyy             = in[i].Myyy;
+    out[i].Mxxxx            = in[i].Mxxxx;
+    out[i].Mxxxy            = in[i].Mxxxy;
+    out[i].Mxxyy            = in[i].Mxxyy;
+    out[i].Mxyyy            = in[i].Mxyyy;
+    out[i].Myyyy            = in[i].Myyyy;
+  }
+  return (out);
+}
+
+/* convert internal images to loneos-format images */
+ImageLoneos *ImageInternalToLoneos (Image *in, int Nvalues) {
+
+  int i;
+  ImageLoneos *out;
+
+  ALLOCATE (out, ImageLoneos, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    memcpy (out[i].dummy, in[i].dummy, 20);
+    strcpy (out[i].name, in[i].name);
+
+    out[i].tzero            = in[i].tzero;
+    out[i].nstar            = in[i].nstar;
+    out[i].secz             = in[i].secz_PS * 1000.0;
+    out[i].NX               = in[i].NX;
+    out[i].NY               = in[i].NY;
+    out[i].apmifit          = in[i].apmifit_PS * 1000.0;
+    out[i].dapmifit         = in[i].dapmifit_PS * 1000.0;
+    out[i].Mcal             = in[i].Mcal_PS * 1000.0;
+    out[i].dMcal            = in[i].dMcal_PS * 1000.0;
+    out[i].Xm               = in[i].Xm;
+    out[i].source           = in[i].source;
+    out[i].exptime          = in[i].exptime;
+    out[i].detection_limit  = in[i].detection_limit;
+    out[i].saturation_limit = in[i].saturation_limit;
+    out[i].cerror           = in[i].cerror;
+    out[i].fwhm_x           = in[i].fwhm_x;
+    out[i].fwhm_y           = in[i].fwhm_y;
+    out[i].trate            = in[i].trate;
+    out[i].code             = in[i].code;
+    out[i].ccdnum           = in[i].ccdnum;
+    out[i].order            = in[i].order;
+    out[i].Mx               = in[i].Mx;
+    out[i].My               = in[i].My;
+    out[i].Mxx              = in[i].Mxx;
+    out[i].Mxy              = in[i].Mxy;
+    out[i].Myy              = in[i].Myy;
+    out[i].Mxxx             = in[i].Mxxx;
+    out[i].Mxxy             = in[i].Mxxy;
+    out[i].Mxyy             = in[i].Mxyy;
+    out[i].Myyy             = in[i].Myyy;
+    out[i].Mxxxx            = in[i].Mxxxx;
+    out[i].Mxxxy            = in[i].Mxxxy;
+    out[i].Mxxyy            = in[i].Mxxyy;
+    out[i].Mxyyy            = in[i].Mxyyy;
+    out[i].Myyyy            = in[i].Myyyy;
+  }
+  return (out);
+}

trunk/Ohana/src/libohana/src/dvo_convert_panstarrs.c

@@ -2 +2 @@
 # include <dvo.h>
 
-/* convert loneos-style measures to internal measures */
+/*** note that these structures are identical ***/
+
+/* convert panstarrs-format measures to internal measures */
 Measure *MeasurePanstarrsToInternal (MeasurePanstarrs *in, int Nvalues) {
 
   int i;
   Measure *out;
-
-  /*** note that these structures are identical ***/
 
   ALLOCATE (out, Measure, Nvalues);
@@ -33 +33 @@
 }
 
-/* convert internal measures to loneos-style measures */
+/* convert internal measures to panstarrs-format measures */
 MeasurePanstarrs *MeasureInternalToPanstarrs (Measure *in, int Nvalues) {
 
@@ -62 +62 @@
 }
 
+/* convert panstarrs-format averages to internal averages */
 Average *AveragePanstarrsToInternal (AveragePanstarrs *in, int Nvalues) {
 
@@ -86 +87 @@
 }
 
+/* convert internal averages to panstarrs-format averages */
 AveragePanstarrs *AverageInternalToPanstarrs (Average *in, int Nvalues) {
 
@@ -109 +111 @@
   return (out);
 }
+
+/* convert panstarrs-format secfilts to internal secfilts */
+SecFilt *SecFiltPanstarrsToInternal (SecFiltPanstarrs *in, int Nvalues) {
+
+  int i;
+  SecFilt *out;
+
+  ALLOCATE (out, SecFilt, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    out[i].M_PS    = in[i].M;      
+    out[i].dM_PS   = in[i].dM;      
+    out[i].Xm      = in[i].Xm;     
+  }
+  return (out);
+}
+
+/* convert internal secfilts to panstarrs-format secfilts */
+SecFiltPanstarrs *SecFiltInternalToPanstarrs (SecFilt *in, int Nvalues) {
+
+  int i;
+  SecFiltPanstarrs *out;
+
+  ALLOCATE (out, SecFiltPanstarrs, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    out[i].M       = in[i].M_PS;      
+    out[i].dM      = in[i].dM_PS;
+    out[i].Xm      = in[i].Xm;     
+  }
+  return (out);
+}
+
+/* convert panstarrs-format images to internal images */
+Image *ImagePanstarrsToInternal (ImagePanstarrs *in, int Nvalues) {
+
+  int i;
+  Image *out;
+
+  ALLOCATE (out, Image, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    memcpy (out[i].dummy, in[i].dummy, 20);
+    strcpy (out[i].name, in[i].name);
+
+    out[i].tzero            = in[i].tzero;
+    out[i].nstar            = in[i].nstar;
+    out[i].secz_PS                  = in[i].secz;
+    out[i].NX               = in[i].NX;
+    out[i].NY               = in[i].NY;
+    out[i].apmifit_PS       = in[i].apmifit;
+    out[i].dapmifit_PS      = in[i].dapmifit;
+    out[i].Mcal_PS                  = in[i].Mcal;
+    out[i].dMcal_PS         = in[i].dMcal;
+    out[i].Xm               = in[i].Xm;
+    out[i].source           = in[i].source;
+    out[i].exptime          = in[i].exptime;
+    out[i].detection_limit  = in[i].detection_limit;
+    out[i].saturation_limit = in[i].saturation_limit;
+    out[i].cerror           = in[i].cerror;
+    out[i].fwhm_x           = in[i].fwhm_x;
+    out[i].fwhm_y           = in[i].fwhm_y;
+    out[i].trate            = in[i].trate;
+    out[i].code             = in[i].code;
+    out[i].ccdnum           = in[i].ccdnum;
+    out[i].order            = in[i].order;
+    out[i].Mx               = in[i].Mx;
+    out[i].My               = in[i].My;
+    out[i].Mxx              = in[i].Mxx;
+    out[i].Mxy              = in[i].Mxy;
+    out[i].Myy              = in[i].Myy;
+    out[i].Mxxx             = in[i].Mxxx;
+    out[i].Mxxy             = in[i].Mxxy;
+    out[i].Mxyy             = in[i].Mxyy;
+    out[i].Myyy             = in[i].Myyy;
+    out[i].Mxxxx            = in[i].Mxxxx;
+    out[i].Mxxxy            = in[i].Mxxxy;
+    out[i].Mxxyy            = in[i].Mxxyy;
+    out[i].Mxyyy            = in[i].Mxyyy;
+    out[i].Myyyy            = in[i].Myyyy;
+  }
+  return (out);
+}
+
+/* convert internal images to panstarrs-format images */
+ImagePanstarrs *ImageInternalToPanstarrs (Image *in, int Nvalues) {
+
+  int i;
+  ImagePanstarrs *out;
+
+  ALLOCATE (out, ImagePanstarrs, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
+    memcpy (out[i].dummy, in[i].dummy, 20);
+    strcpy (out[i].name, in[i].name);
+
+    out[i].tzero            = in[i].tzero;
+    out[i].nstar            = in[i].nstar;
+    out[i].secz             = in[i].secz_PS;
+    out[i].NX               = in[i].NX;
+    out[i].NY               = in[i].NY;
+    out[i].apmifit          = in[i].apmifit_PS;
+    out[i].dapmifit         = in[i].dapmifit_PS;
+    out[i].Mcal             = in[i].Mcal_PS;
+    out[i].dMcal            = in[i].dMcal_PS;
+    out[i].Xm               = in[i].Xm;
+    out[i].source           = in[i].source;
+    out[i].exptime          = in[i].exptime;
+    out[i].detection_limit  = in[i].detection_limit;
+    out[i].saturation_limit = in[i].saturation_limit;
+    out[i].cerror           = in[i].cerror;
+    out[i].fwhm_x           = in[i].fwhm_x;
+    out[i].fwhm_y           = in[i].fwhm_y;
+    out[i].trate            = in[i].trate;
+    out[i].code             = in[i].code;
+    out[i].ccdnum           = in[i].ccdnum;
+    out[i].order            = in[i].order;
+    out[i].Mx               = in[i].Mx;
+    out[i].My               = in[i].My;
+    out[i].Mxx              = in[i].Mxx;
+    out[i].Mxy              = in[i].Mxy;
+    out[i].Myy              = in[i].Myy;
+    out[i].Mxxx             = in[i].Mxxx;
+    out[i].Mxxy             = in[i].Mxxy;
+    out[i].Mxyy             = in[i].Mxyy;
+    out[i].Myyy             = in[i].Myyy;
+    out[i].Mxxxx            = in[i].Mxxxx;
+    out[i].Mxxxy            = in[i].Mxxxy;
+    out[i].Mxxyy            = in[i].Mxxyy;
+    out[i].Mxyyy            = in[i].Mxyyy;
+    out[i].Myyyy            = in[i].Myyyy;
+  }
+  return (out);
+}

trunk/Ohana/src/libohana/src/dvo_image.c

@@ -2 +2 @@
 # include <dvo.h>
 
-/* determine db mode (raw/fits) and read the complete table */
+/* determine db mode (RAW/MEF) and read the complete table */
 int dvo_image_load (FITS_DB *db, int VERBOSE, int FORCE_READ) {
 
@@ -27 +27 @@
   fseek (db[0].f, 0, SEEK_SET);
 
-  /* image table can only be RAW or MEF */
+  /* default values */
   db[0].mode = DVO_MODE_MEF;
-  if (Naxis == 2) db[0].mode = DVO_MODE_RAW;
+  db[0].format = DVO_FORMAT_UNDEF;
+  if (Naxis == 2) db[0].mode = DVO_MODE_RAW; /* image table can only be RAW or MEF */
+
   switch (db[0].mode) {
     case DVO_MODE_MEF:
       if (VERBOSE) fprintf (stderr, "reading images (mode DVO_MODE_MEF)\n");
       status = fits_db_load (db);
-      db[0].format = UNDEF;
       break;
     case DVO_MODE_RAW:
       if (VERBOSE) fprintf (stderr, "reading images (mode DVO_MODE_RAW)\n");
       status = dvo_image_load_raw (db, VERBOSE, FORCE_READ);
-      db[0].format = ELIXIR;
       break;
     default:
@@ -45 +45 @@
       exit (2);
   }
-  /* convert from external to internal format */
-  /**** this is confused: where does the converted image table go?
-        back in db[0].ftable.buffer? 
-        keep the db[0].ftable.header?
-        sync with the correct format??
-        dvo_image_load_raw creates a new theader for Image 
-          - should be ImageElixir
-        FtableToImage should create a new theader for Image
-        ImageToFtable should create a new theader for ImageFOO
-  ****/
-  image = FtableToImage (db[0].ftable, &db[0].format);
-  db[0].swapped = FALSE;
+  FtableToImage (&db[0].ftable, &db[0].theader, &db[0].format);
+  db[0].swapped = TRUE;  /* table has internal byte-order */
   return (TRUE);
 }
@@ -63 +53 @@
 int dvo_image_save (FITS_DB *db, int VERBOSE) {
 
-  int Nrow, mode, status;
+  int status;
 
-  mode = FITS;
-  if (db[0].header.Naxes == 2) mode = RAW;
-  
-  /* convert from external to internal format */
-  FtableToImage (db[0].ftable, db[0].format);
+  /* convert from internal to requested external format */
+  ImageToFtable (&db[0].ftable, &db[0].theader, db[0].format);
   db[0].swapped = FALSE;
 
-  /* byteswap table data */
-  Nrow = db[0].theader.Naxis[1];
-  if (db[0].swapped) {
-    fits_convert_Image ((Image *) db[0].ftable.buffer, sizeof(Image), Nrow);
-    db[0].swapped = FALSE;
-  }  
-  
   /* write data in appropriate mode */
-  if (mode == FITS) {
-    status = fits_db_save (db);
-  } else {
-    status = dvo_image_save_raw (db, VERBOSE);
+  switch (db[0].mode) {
+    case DVO_MODE_MEF:
+    case DVO_MODE_SPLIT:
+      status = fits_db_save (db);
+      break;
+    case DVO_MODE_RAW:
+      status = dvo_image_save_raw (db, VERBOSE);
+      break;
+    default:
+      fprintf (stderr, "error writing image mode\n");
+      exit (2);
   }
   return (TRUE);
@@ -111 +98 @@
 int dvo_image_update (FITS_DB *db, int VERBOSE) {
 
-  int i, mode, status;
+  int status;
 
-  mode = FITS;
-  if (db[0].header.Naxes == 2) mode = RAW;
-  
-  /* byteswap table data */
-  for (i = 0; i < db[0].vtable.Nrow; i++) {
-    fits_convert_Image ((Image *) db[0].vtable.buffer[i], sizeof(Image), 1);
-  }
+  /* convert from internal to requested external format */
+  /* theader is modified to match output format */
+  ImageToVtable (&db[0].vtable, &db[0].theader, db[0].format);
+  db[0].swapped = FALSE;
 
   /* write data in appropriate mode */
-  if (mode == FITS) {
-    status = fits_db_update (db);
-  } else {
-    status = dvo_image_update_raw (db, VERBOSE);
+  switch (db[0].mode) {
+    case DVO_MODE_MEF:
+    case DVO_MODE_SPLIT:
+      status = fits_db_update (db);
+      break;
+    case DVO_MODE_RAW:
+      status = dvo_image_update_raw (db, VERBOSE);
+      break;
+    default:
+      fprintf (stderr, "error writing image mode\n");
+      exit (2);
   }
   return (TRUE);
 }
-
-/* the old Image.dat files used a fake FITS header defining a finite data block
- * this function reads in the data portion, assuming header already loaded
- */
-
-int dvo_image_load_raw (FITS_DB *db, int VERBOSE, int FORCE_READ) {
-
-  int Nimage, size, nimage;
-  struct stat filestatus;
-  Image *image;
-
-  /* init & load in FITS table data - return FALSE on error */
-  if (!fits_fread_header (db[0].f, &db[0].header)) {
-    fprintf (stderr, "can't read primary header\n"); 
-    return (FALSE);
-  }
-
-  /* check that file size makes sense */
-  Nimage = 0;
-  fits_scan (&db[0].header, "NIMAGES", "%d", 1, &Nimage);
-  if (stat (db[0].filename, &filestatus) == -1) {
-    if (VERBOSE) fprintf (stderr, "ERROR: failed to get status of image catalog\n");
-    exit (1);
-  }
-  size = Nimage*sizeof(Image) + db[0].header.size;
-  if (size != filestatus.st_size) {
-    int Ndata;
-
-    Ndata = (filestatus.st_size - db[0].header.size) / sizeof (Image);
-    if (VERBOSE) fprintf (stderr, "ERROR: image catalog has inconsistent size\n");
-    if (VERBOSE) fprintf (stderr, "header: %d, data: %d\n", Nimage, Ndata);
-    if (!FORCE_READ) exit (1);
-    Nimage = Ndata;
-  } 
-
-  /* create a dummy set of table information */
-  /* (original table has NAXIS = 2, change to 0) */
-  /* fits_modify (&db[0].header, "NAXIS", "%d", 1, 0); */
-  fits_create_matrix (&db[0].header, &db[0].matrix);
-  fits_table_mkheader_Image (&db[0].theader);
-  db[0].ftable.header = &db[0].theader;
-
-  /* alloc, read images */
-  ALLOCATE (image, Image, MAX (Nimage, 1));
-  nimage = fread (image, sizeof(Image), Nimage, db[0].f);
-  if (nimage != Nimage) {
-    if (VERBOSE) fprintf (stderr, "ERROR: problem loading image catalog\n");
-    exit (1);
-  } 
-  db[0].ftable.buffer = (char *) image;
-  fits_modify (&db[0].theader, "NAXIS2", "%d", 1, Nimage);
-  db[0].theader.Naxis[1] = Nimage;
-  db[0].ftable.size = fits_matrix_size (&db[0].theader);
-  
-  return (TRUE);
-}
-
-/* write out image db elements from vtable */
-int dvo_image_update_raw (FITS_DB *db, int VERBOSE) {
-
-  int i, Nx, Ny, Nrow, Nbytes;
-  int status, start, offset;
-  int *row;
-
-  if (VERBOSE) fprintf (stderr, "writing out %d images\n", db[0].vtable.Nrow);
-
-  /* position to start of file */
-  Fseek (db[0].f, 0, SEEK_SET);
-  
-  /* write out complete header (no check on disk size?) */
-  status = fwrite (db[0].header.buffer, 1, db[0].header.size, db[0].f);
-  if (status != db[0].header.size) {
-    fprintf (stderr, "ERROR: failed writing data to image header\n");
-    exit (1);
-  }
-
-  /** this code is identical to fits_fwrite_vtable, except without padding */
-  Nrow = db[0].vtable.Nrow;
-  row = db[0].vtable.row;
-  fits_scan (db[0].vtable.header, "NAXIS1", "%d", 1, &Nx);
-  fits_scan (db[0].vtable.header, "NAXIS2", "%d", 1, &Ny);
-
-  /* file pointer is at beginning of desired table data */
-  start = ftell (db[0].f);
-  
-  for (i = 0; i < Nrow; i++) {
-    offset = start + Nx*row[i];
-    fseek (db[0].f, offset, SEEK_SET);
-    Nbytes = fwrite (db[0].vtable.buffer[i], sizeof (char), Nx, db[0].f);
-    if (Nbytes != Nx) { return (FALSE); }
-  }
-  return (TRUE);
-}
-
-/* write out complete image db table from ftable */
-int dvo_image_save_raw (FITS_DB *db, int VERBOSE) {
-
-  int status, Nx, Ny, size, Nbytes;
-
-  if (VERBOSE) fprintf (stderr, "writing out %d images\n", db[0].theader.Naxis[1]);
-
-  /* position to start of file */
-  Fseek (db[0].f, 0, SEEK_SET);
-  
-  /* write out complete header (no check on disk size?) */
-  status = fwrite (db[0].header.buffer, 1, db[0].header.size, db[0].f);
-  if (status != db[0].header.size) {
-    fprintf (stderr, "ERROR: failed writing data to image header\n");
-    exit (1);
-  }
-
-  fits_scan (db[0].ftable.header, "NAXIS1", "%d", 1, &Nx);
-  fits_scan (db[0].ftable.header, "NAXIS2", "%d", 1, &Ny);
-  size = Nx * Ny;
-  Nbytes = fwrite (db[0].ftable.buffer, sizeof(char), size, db[0].f);
-  if (Nbytes != size) return (FALSE);
-  return (TRUE);
-}

trunk/Ohana/src/libohana/src/fits_db.c

@@ -85 +85 @@
     return (FALSE);
   }
-  db[0].swapped = FALSE;  /* is table in internal byte-order? */
+  db[0].swapped = FALSE;  /* table does not have internal byte-order */
   return (TRUE);
 }

trunk/Ohana/src/libohana/src/phot_catalog.c

@@ -36 +36 @@
 int load_catalog (Catalog *catalog, char mode, int VERBOSE) {
   
-  if (!strcmp (catalog[0].catmode, "RAW")) {
-    load_catalog_raw (catalog, mode, VERBOSE);
-    return (TRUE);
+  int Naxis, Nread;
+  char buffer[241];
+
+  /** we will have to check catmode for MYSQL before reading from the file **/
+
+  /* check for mode RAW (NAXIS == 2 in FITS header 3) */
+  bzero (buffer, 241);
+  fseek (catalog[0].f, 0, SEEK_SET);
+  Nread = fread (buffer, 1, 240, catalog[0].f);
+  if (Nread != 240) {
+    if (VERBOSE) fprintf (stderr, "can't determine image db mode\n");
+    return (FALSE);
   }
-  if (!strcmp (catalog[0].catmode, "MEF")) {
-    load_catalog_mef (catalog, mode, VERBOSE);
-    return (TRUE);
+  Nread = sscanf (&buffer[160], "NAXIS   = %d", &Naxis);
+  if (Nread != 1) {
+    if (VERBOSE) fprintf (stderr, "can't determine catalog db mode\n");
+    return (FALSE);
   }
-  /*
-  if (!strcmp (catalog[0].catmode, "SPLIT")) {
-    load_catalog_split (catalog, mode, VERBOSE);
-    return (TRUE);
+  fseek (catalog[0].f, 0, SEEK_SET);
+
+  /* the test for MEF vs SPLIT should be EXTEND = T */
+
+  /* currenly, the mode information is carried per table.
+     the user-set value of catmode will set the output mode for new tables
+     an old table will keep its mode
+  */
+
+  catalog[0].catmode = DVO_MODE_MEF;
+  catalog[0].catformat = DVO_FORMAT_UNDEF;
+  if (Naxis == 2) catalog[0].catmode = DVO_MODE_RAW;
+
+  switch (catalog[0].catmode) {
+    case DVO_MODE_RAW:
+      if (VERBOSE) fprintf (stderr, "reading catalog (mode DVO_MODE_RAW)\n");
+      load_catalog_raw (catalog, mode, VERBOSE);
+      break;
+    case DVO_MODE_MEF:
+      if (VERBOSE) fprintf (stderr, "reading catalog (mode DVO_MODE_MEF)\n");
+      load_catalog_mef (catalog, mode, VERBOSE);
+      break;
+    default:
+      fprintf (stderr, "error getting catalog mode\n");
+      exit (2);
   }
-  if (!strcmp (catalog[0].catmode, "MYSQL")) {
-    load_catalog_mysql (catalog, mode, VERBOSE);
-    return (TRUE);
-  }
-  */
-  return (FALSE);
+  return (TRUE);
 }
 
 int save_catalog (Catalog *catalog, char VERBOSE) {
 
-  if (!strcmp (catalog[0].catmode, "RAW")) {
-    save_catalog_raw (catalog, VERBOSE);
-    return (TRUE);
+  switch (catalog[0].catmode) {
+    case DVO_MODE_RAW:
+      save_catalog_raw (catalog, VERBOSE);
+      break;
+    case DVO_MODE_MEF:
+      save_catalog_mef (catalog, VERBOSE);
+      break;
+    default:
+      fprintf (stderr, "invalid catalog mode\n");
+      exit (2);
   }
-  if (!strcmp (catalog[0].catmode, "MEF")) {
-    save_catalog_mef (catalog, VERBOSE);
-    return (TRUE);
-  }
-
-  return (FALSE);
+  return (TRUE);
 }
 

trunk/Ohana/src/libohana/src/phot_catalog_mef.c

@@ -4 +4 @@
 int load_catalog_mef (Catalog *catalog, char mode, int VERBOSE) {
   
-  int Nitems, Nbytes, Naverage, Nmeasure, Nmissing, Nsecfilt;
+  int Nitems, Nbytes, Nexpect, Naverage, Nmeasure, Nmissing, Nsecfilt;
   FILE *f;
 
@@ -31 +31 @@
   if (!fits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0;
 
+  /**  Nsecfilt is unusual: it does not list the number of data items in the table
+       instead, the number of items is Nsecfilt * Naverage.  **/
+  catalog[0].Nsecfilt = Nsecfilt;
+
   /* validate table mode */
 
@@ -44 +48 @@
       return (FALSE);
     }
-    catalog[0].average = FtableToAverage (&ftable, &catalog[0].Naverage, catalog[0].average_format);
+    catalog[0].average = FtableToAverage (&ftable, &catalog[0].Naverage, &catalog[0].catformat);
     if (Naverage != catalog[0].Naverage) {
       fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%d vs %d)\n", Naverage, catalog[0].Naverage);
@@ -66 +70 @@
       return (FALSE);
     }
-    catalog[0].measure = FtableToMeasure (&ftable, &catalog[0].Nmeasure, catalog[0].measure_format);
+    catalog[0].measure = FtableToMeasure (&ftable, &catalog[0].Nmeasure, &catalog[0].catformat);
     if (Nmeasure != catalog[0].Nmeasure) {
       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%d vs %d)\n", Nmeasure, catalog[0].Nmeasure);
@@ -96 +100 @@
   }
 
+  // catalog[0].secfilt = fits_table_get_SecFilt (&ftable, &Nitems, NULL);
+  // catalog[0].Nsecfilt = Nitems / catalog[0].Naverage;
+
   /* read secfilt table header */
   if (!fits_fread_header (f, &header)) {
@@ -107 +114 @@
       return (FALSE);
     }
-    /* no conversions currently defined */
-    catalog[0].secfilt = fits_table_get_SecFilt (&ftable, &Nitems, NULL);
-    catalog[0].Nsecfilt = Nitems / catalog[0].Naverage;
-    if (Nsecfilt != catalog[0].Nsecfilt) {
-      fprintf (stderr, "Warning: mismatch between Nsecfilt in PHU and Table headers (%d vs %d)\n", Nsecfilt, catalog[0].Nsecfilt);
+    Nexpect = catalog[0].Nsecfilt * catalog[0].Naverage;
+    catalog[0].secfilt = FtableToSecFilt (&ftable, &Nitems, &catalog[0].catformat);
+    if (Nexpect != Nitems) {
+      fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%d vs %d)\n", Nexpect, Nitems);
     }
   } else {
@@ -125 +131 @@
 int save_catalog_mef (Catalog *catalog, char VERBOSE) {
 
+  int Nitems;
   FILE *f;
   Matrix matrix;
@@ -163 +170 @@
 
   /* write out Average table (convert to FITS table format) */
-  AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].average_format);
+  AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
   if (!fits_fwrite_Theader (catalog[0].f, &header)) {
     fprintf (stderr, "can't write table header");
@@ -176 +183 @@
 
   /* write out Measure table (convert to FITS table format) */
-  MeasureToFtable (&ftable, catalog[0].measure, catalog[0].Nmeasure, catalog[0].measure_format);
+  MeasureToFtable (&ftable, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
   if (!fits_fwrite_Theader (catalog[0].f, &header)) {
     fprintf (stderr, "can't write table header");
@@ -201 +208 @@
   fits_free_header (&header);
 
-  /* write out Secfilt table (convert to FITS table format) */
-  /*** note that Nsecfilt is NOT the number of rows! ***/
-  fits_table_set_SecFilt (&ftable, catalog[0].secfilt, catalog[0].Naverage * catalog[0].Nsecfilt);
-  if (!fits_fwrite_Theader (catalog[0].f, &header)) {
-    fprintf (stderr, "can't write table header");
-    return (FALSE);
-  }
-  if (!fits_fwrite_table   (catalog[0].f, &ftable)) {
+  /* write out SecFilt table (convert to FITS table format) */
+  Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
+  SecFiltToFtable (&ftable, catalog[0].secfilt, Nitems, catalog[0].catformat);
+  if (!fits_fwrite_Theader (catalog[0].f, &header)) {
+    fprintf (stderr, "can't write table header");
+    return (FALSE);
+  }
+  if (!fits_fwrite_table (catalog[0].f, &ftable)) {
     fprintf (stderr, "can't write table data");
     return (FALSE);

trunk/Ohana/src/libohana/src/phot_catalog_raw.c

@@ -33 +33 @@
   if (!fits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &catalog[0].Nsecfilt)) catalog[0].Nsecfilt = 0;
 
-  /* determine average and measure format */
-  strcpy (catalog[0].average_format, "NONE");
-  strcpy (catalog[0].measure_format, "NONE");
+  /* determine catalog format */
+  catalog[0].catformat = DVO_FORMAT_UNDEF;
   if (fits_scan (&catalog[0].header, "FORMAT",  "%s", 1, format)) {
-    if (!strcmp (format, "INTERNAL")) {
-      sprintf (catalog[0].average_format, "DVO_AVERAGE");
-      sprintf (catalog[0].measure_format, "DVO_MEASURE");
-    } else {
-      sprintf (catalog[0].average_format, "DVO_AVERAGE_%s", format);
-      sprintf (catalog[0].measure_format, "DVO_MEASURE_%s", format);
-    }
-    goto got_format;
+    if (!strcmp (format, "INTERNAL")) catalog[0].catformat = DVO_FORMAT_INTERNAL;
+    if (!strcmp (format, "LONEOS")) catalog[0].catformat = DVO_FORMAT_LONEOS;
+    if (!strcmp (format, "ELIXIR")) catalog[0].catformat = DVO_FORMAT_ELIXIR;
+    if (!strcmp (format, "PANSTARRS")) catalog[0].catformat = DVO_FORMAT_PANSTARRS;
+    if (catalog[0].catformat != DVO_FORMAT_UNDEF) goto got_format;
   }
   if (fits_scan (&catalog[0].header, "NEWMEAS",  "%t", 1, &NewMeasure)) {
-    strcpy (catalog[0].average_format, "DVO_AVERAGE_ELIXIR");
-    strcpy (catalog[0].measure_format, "DVO_MEASURE_ELIXIR");
+    catalog[0].catformat = DVO_FORMAT_ELIXIR;
     goto got_format;
   }
   if (fits_scan (&catalog[0].header, "TELESCOP",  "%s", 1, telescope)) {
     if (!strncmp (telescope, "LONEOS", strlen("LONEOS"))) {
-      strcpy (catalog[0].average_format, "DVO_AVERAGE_ELIXIR");
-      strcpy (catalog[0].measure_format, "DVO_MEASURE_ELIXIR");
+      catalog[0].catformat = DVO_FORMAT_LONEOS;
       goto got_format;
     }
-  }
+    if (!strncmp (telescope, "1.3m McGraw-Hill", strlen("1.3m McGraw-Hill"))) {
+      catalog[0].catformat = DVO_FORMAT_ELIXIR;
+      goto got_format;
+    }
+  }
+  if (VERBOSE) fprintf (stderr, "cannot determine catalog format\n");
+  return (FALSE);
 
 got_format:
   /* determine datatype sizes */
-  AverageSize = 0;
-  if (!strcmp (catalog[0].average_format, "DVO_AVERAGE")) AverageSize = sizeof(Average);
-  if (!strcmp (catalog[0].average_format, "DVO_AVERAGE_ELIXIR")) AverageSize = sizeof(AverageElixir);
-  if (!strcmp (catalog[0].average_format, "DVO_AVERAGE_LONEOS")) AverageSize = sizeof(AverageLoneos);
-  if (!strcmp (catalog[0].average_format, "DVO_AVERAGE_PANSTARRS")) AverageSize = sizeof(AveragePanstarrs);
-  if (AverageSize == 0) {
-    fprintf (stderr, "average format is invalid: %s\n", catalog[0].average_format);
-    return (FALSE);
-  }
-  MeasureSize = 0;
-  if (!strcmp (catalog[0].measure_format, "DVO_MEASURE")) MeasureSize = sizeof(Measure);
-  if (!strcmp (catalog[0].measure_format, "DVO_MEASURE_ELIXIR")) MeasureSize = sizeof(MeasureElixir);
-  if (!strcmp (catalog[0].measure_format, "DVO_MEASURE_LONEOS")) MeasureSize = sizeof(MeasureLoneos);
-  if (!strcmp (catalog[0].measure_format, "DVO_MEASURE_PANSTARRS")) MeasureSize = sizeof(MeasurePanstarrs);
-  if (MeasureSize == 0) {
-    fprintf (stderr, "measure format is invalid: %s\n", catalog[0].measure_format);
-    return (FALSE);
+  switch (catalog[0].catformat) {
+    case DVO_FORMAT_INTERNAL:
+      AverageSize = sizeof(Average);
+      MeasureSize = sizeof(Measure);
+      SecFiltSize = sizeof (SecFilt);
+      break;
+    case DVO_FORMAT_LONEOS:
+      AverageSize = sizeof(AverageLoneos);
+      MeasureSize = sizeof(MeasureLoneos);
+      SecFiltSize = sizeof (SecFiltLoneos);
+      break;
+    case DVO_FORMAT_ELIXIR:
+      AverageSize = sizeof(AverageElixir);
+      MeasureSize = sizeof(MeasureElixir);
+      SecFiltSize = sizeof (SecFiltElixir);
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      AverageSize = sizeof(AveragePanstarrs);
+      MeasureSize = sizeof(MeasurePanstarrs);
+      SecFiltSize = sizeof (SecFiltPanstarrs);
+      break;
+    default:
+      fprintf (stderr, "programming error in phot_catalog_raw\n");
+      exit (2);
   }
   MissingSize = sizeof (Missing);
-  SecFiltSize = sizeof (SecFilt);
 
   /* predicted file size - for double checking data validity */
@@ -116 +122 @@
   /* read and convert the averages (use a macro to clean this up?) */
   if (mode & LOAD_AVES) {
-    catalog[0].average = ReadRawAverage (catalog[0].f, catalog[0].Naverage, catalog[0].average_format);
+    catalog[0].average = ReadRawAverage (catalog[0].f, catalog[0].Naverage, catalog[0].catformat);
   } else {
     /* skip over averages */
@@ -125 +131 @@
   /* read and convert the measures (use a macro to clean this up?) */
   if (mode & LOAD_MEAS) {
-    catalog[0].measure = ReadRawMeasure (catalog[0].f, catalog[0].Nmeasure, catalog[0].measure_format);
+    catalog[0].measure = ReadRawMeasure (catalog[0].f, catalog[0].Nmeasure, catalog[0].catformat);
   } else {
     /* skip over measures */
@@ -151 +157 @@
   if (mode & LOAD_SECF) {
     Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
-    ALLOCATE (catalog[0].secfilt, SecFilt, MAX (Nitems, 1));
-    nitems = fread (catalog[0].secfilt, SecFiltSize, Nitems, f);
-    if (nitems != Nitems) {
-      if (VERBOSE) fprintf (stderr, "failed to read secondary filters from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
-      return (FALSE);
-    }
-    fits_convert_SecFilt (catalog[0].secfilt, SecFiltSize, Nitems);
+    catalog[0].secfilt = ReadRawSecFilt (catalog[0].f, Nitems, catalog[0].catformat);
   } else {
     /* skip over secfilts */
-    Nskip = catalog[0].Nsecfilt * SecFiltSize * catalog[0].Naverage;
+    Nskip = catalog[0].Nsecfilt * catalog[0].Naverage * SecFiltSize;
     fseek (f, Nskip, SEEK_CUR); 
   }
@@ -188 +188 @@
 
   int Nitems, nitems;
-  char *p;
   FILE *f;
 
@@ -203 +202 @@
 
   /* specify the appropriate data format */
-  if (!strcmp (catalog[0].average_format, "DVO_AVERAGE")) {
-    fits_modify (&catalog[0].header, "FORMAT", "%s", 1, "INTERNAL");
-  } else {
-    p = catalog[0].average_format + strlen ("DVO_AVERAGE_");
-    fits_modify (&catalog[0].header, "FORMAT", "%s", 1, p);
-  }
+  if (catalog[0].catformat == DVO_FORMAT_INTERNAL)  fits_modify (&catalog[0].header, "FORMAT", "%s", 1, "INTERNAL");
+  if (catalog[0].catformat == DVO_FORMAT_LONEOS)    fits_modify (&catalog[0].header, "FORMAT", "%s", 1, "LONEOS");
+  if (catalog[0].catformat == DVO_FORMAT_ELIXIR)    fits_modify (&catalog[0].header, "FORMAT", "%s", 1, "ELIXIR");
+  if (catalog[0].catformat == DVO_FORMAT_PANSTARRS) fits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PANSTARRS");
 
   /* rewind file pointers and truncate file */
@@ -223 +220 @@
 
   /* write averages and measures */
-  WriteRawAverage (f, catalog[0].average, catalog[0].Naverage, catalog[0].average_format);
-  WriteRawMeasure (f, catalog[0].measure, catalog[0].Nmeasure, catalog[0].measure_format);
+  WriteRawAverage (f, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
+  WriteRawMeasure (f, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
 
   /* write missing data */
@@ -235 +232 @@
   }
 
-  /* write secfilt data */
   Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
-  fits_convert_SecFilt (catalog[0].secfilt, sizeof(SecFilt), Nitems);
-  nitems = fwrite (catalog[0].secfilt, sizeof(SecFilt), Nitems, f);
-  if (nitems != Nitems) {
-    if (VERBOSE) fprintf (stderr, "failed to write catalog file secfilt %s\n", catalog[0].filename);
-    return (FALSE);
-  }
-
+  WriteRawSecFilt (f, catalog[0].secfilt, Nitems, catalog[0].catformat);
   return (TRUE);
-
 }
 
@@ -251 +240 @@
      some warnings:
      - need to be wary of exit condition errors
-     - average_format and measure_format must be the same format (not checked)
 ***/
+
+/** Average / Raw Table conversions **/
+
+Average *ReadRawAverage (FILE *f, int Naverage, int format) {
+
+  int nitems;
+  Average *average;
+  AverageElixir *tmpAverageElixir;
+  AverageLoneos *tmpAverageLoneos;
+  AveragePanstarrs *tmpAveragePanstarrs;
+
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      ALLOCATE (average, Average, MAX (Naverage, 1));
+      nitems = fread (average, sizeof(Average), Naverage, f);
+      if (nitems != Naverage) {
+        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
+        return (NULL);
+      }
+      fits_convert_Average (average, sizeof(Average), Naverage);
+      break;
+    case DVO_FORMAT_ELIXIR:
+      ALLOCATE (tmpAverageElixir, AverageElixir, MAX (Naverage, 1));
+      nitems = fread (tmpAverageElixir, sizeof(AverageElixir), Naverage, f);
+      if (nitems != Naverage) {
+        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
+        return (NULL);
+      }
+      fits_convert_AverageElixir (tmpAverageElixir, sizeof(AverageElixir), Naverage);
+      average = AverageElixirToInternal (tmpAverageElixir, Naverage);
+      free (tmpAverageElixir);
+      break;
+    case DVO_FORMAT_LONEOS:
+      ALLOCATE (tmpAverageLoneos, AverageLoneos, MAX (Naverage, 1));
+      nitems = fread (tmpAverageLoneos, sizeof(AverageLoneos), Naverage, f);
+      if (nitems != Naverage) {
+        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
+        return (NULL);
+      }
+      fits_convert_AverageLoneos (tmpAverageLoneos, sizeof(AverageLoneos), Naverage);
+      average = AverageLoneosToInternal (tmpAverageLoneos, Naverage);
+      free (tmpAverageLoneos);
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      ALLOCATE (tmpAveragePanstarrs, AveragePanstarrs, MAX (Naverage, 1));
+      nitems = fread (tmpAveragePanstarrs, sizeof(AveragePanstarrs), Naverage, f);
+      if (nitems != Naverage) {
+        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
+        return (NULL);
+      }
+      fits_convert_AveragePanstarrs (tmpAveragePanstarrs, sizeof(AveragePanstarrs), Naverage);
+      average = AveragePanstarrsToInternal (tmpAveragePanstarrs, Naverage);
+      free (tmpAveragePanstarrs);
+      break;
+    default:
+      fprintf (stderr, "error reading measures\n");
+      return (NULL);
+  }
+  return (average);
+}
+
+/* accepts and converts internal average formats and outputs 
+   raw data in the specified format */
+int WriteRawAverage (FILE *f, Average *average, int Naverage, int format) {
+
+  int nitems;
+  AverageElixir *tmpAverageElixir;
+  AverageLoneos *tmpAverageLoneos;
+  AveragePanstarrs *tmpAveragePanstarrs;
+
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      fits_convert_Average (average, sizeof(Average), Naverage);
+      nitems = fwrite (average, sizeof(Average), Naverage, f);
+      if (nitems != Naverage) {
+        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
+        return (FALSE);
+      }
+      break;
+    case DVO_FORMAT_ELIXIR:
+      tmpAverageElixir = AverageInternalToElixir (average, Naverage);
+      fits_convert_AverageElixir (tmpAverageElixir, sizeof(AverageElixir), Naverage);
+      nitems = fwrite (tmpAverageElixir, sizeof(AverageElixir), Naverage, f);
+      free (tmpAverageElixir);
+      if (nitems != Naverage) {
+        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
+        return (FALSE);
+      }
+      break;
+    case DVO_FORMAT_LONEOS:
+      tmpAverageLoneos = AverageInternalToLoneos (average, Naverage);
+      fits_convert_AverageLoneos (tmpAverageLoneos, sizeof(AverageLoneos), Naverage);
+      nitems = fwrite (tmpAverageLoneos, sizeof(AverageLoneos), Naverage, f);
+      free (tmpAverageLoneos);
+      if (nitems != Naverage) {
+        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
+        return (FALSE);
+      }
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      tmpAveragePanstarrs = AverageInternalToPanstarrs (average, Naverage);
+      fits_convert_AveragePanstarrs (tmpAveragePanstarrs, sizeof(AveragePanstarrs), Naverage);
+      nitems = fwrite (tmpAveragePanstarrs, sizeof(AveragePanstarrs), Naverage, f);
+      free (tmpAveragePanstarrs);
+      if (nitems != Naverage) {
+        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
+        return (FALSE);
+      }
+      break;
+    default:
+      fprintf (stderr, "error writing averages\n");
+      return (FALSE);
+  }
+  return (TRUE);
+}
+
+/** Average / Raw Table conversions **/
+
+Measure *ReadRawMeasure (FILE *f, int Nmeasure, int format) {
+
+  int nitems;
+  Measure *measure;
+  MeasureElixir *tmpMeasureElixir;
+  MeasureLoneos *tmpMeasureLoneos;
+  MeasurePanstarrs *tmpMeasurePanstarrs;
+
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      ALLOCATE (measure, Measure, MAX (Nmeasure, 1));
+      nitems = fread (measure, sizeof(Measure), Nmeasure, f);
+      if (nitems != Nmeasure) {
+        fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
+        return (NULL);
+      }
+      fits_convert_Measure (measure, sizeof(Measure), Nmeasure);
+      break;
+    case DVO_FORMAT_ELIXIR:
+      ALLOCATE (tmpMeasureElixir, MeasureElixir, MAX (Nmeasure, 1));
+      nitems = fread (tmpMeasureElixir, sizeof(MeasureElixir), Nmeasure, f);
+      if (nitems != Nmeasure) {
+        fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
+        return (NULL);
+      }
+      fits_convert_MeasureElixir (tmpMeasureElixir, sizeof(MeasureElixir), Nmeasure);
+      measure = MeasureElixirToInternal (tmpMeasureElixir, Nmeasure);
+      free (tmpMeasureElixir);
+      break;
+    case DVO_FORMAT_LONEOS:
+      ALLOCATE (tmpMeasureLoneos, MeasureLoneos, MAX (Nmeasure, 1));
+      nitems = fread (tmpMeasureLoneos, sizeof(MeasureLoneos), Nmeasure, f);
+      if (nitems != Nmeasure) {
+        fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
+        return (NULL);
+      }
+      fits_convert_MeasureLoneos (tmpMeasureLoneos, sizeof(MeasureLoneos), Nmeasure);
+      measure = MeasureLoneosToInternal (tmpMeasureLoneos, Nmeasure);
+      free (tmpMeasureLoneos);
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      ALLOCATE (tmpMeasurePanstarrs, MeasurePanstarrs, MAX (Nmeasure, 1));
+      nitems = fread (tmpMeasurePanstarrs, sizeof(MeasurePanstarrs), Nmeasure, f);
+      if (nitems != Nmeasure) {
+        fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
+        return (NULL);
+      }
+      fits_convert_MeasurePanstarrs (tmpMeasurePanstarrs, sizeof(MeasurePanstarrs), Nmeasure);
+      measure = MeasurePanstarrsToInternal (tmpMeasurePanstarrs, Nmeasure);
+      free (tmpMeasurePanstarrs);
+      break;
+    default:
+      fprintf (stderr, "error reading measures\n");
+      return (NULL);
+  }
+  return (measure);
+}
+
+/* accepts and converts internal measure formats and outputs 
+   raw data in the specified format */
+int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, int format) {
+
+  int nitems;
+  MeasureElixir *tmpMeasureElixir;
+  MeasureLoneos *tmpMeasureLoneos;
+  MeasurePanstarrs *tmpMeasurePanstarrs;
+
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      fits_convert_Measure (measure, sizeof(Measure), Nmeasure);
+      nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
+      if (nitems != Nmeasure) {
+        fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
+        return (FALSE);
+      }
+      break;
+    case DVO_FORMAT_ELIXIR:
+      tmpMeasureElixir = MeasureInternalToElixir (measure, Nmeasure);
+      fits_convert_MeasureElixir (tmpMeasureElixir, sizeof(MeasureElixir), Nmeasure);
+      nitems = fwrite (tmpMeasureElixir, sizeof(MeasureElixir), Nmeasure, f);
+      free (tmpMeasureElixir);
+      if (nitems != Nmeasure) {
+        fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
+        return (FALSE);
+      }
+      break;
+    case DVO_FORMAT_LONEOS:
+      tmpMeasureLoneos = MeasureInternalToLoneos (measure, Nmeasure);
+      fits_convert_MeasureLoneos (tmpMeasureLoneos, sizeof(MeasureLoneos), Nmeasure);
+      nitems = fwrite (tmpMeasureLoneos, sizeof(MeasureLoneos), Nmeasure, f);
+      free (tmpMeasureLoneos);
+      if (nitems != Nmeasure) {
+        fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
+        return (FALSE);
+      }
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      tmpMeasurePanstarrs = MeasureInternalToPanstarrs (measure, Nmeasure);
+      fits_convert_MeasurePanstarrs (tmpMeasurePanstarrs, sizeof(MeasurePanstarrs), Nmeasure);
+      nitems = fwrite (tmpMeasurePanstarrs, sizeof(MeasurePanstarrs), Nmeasure, f);
+      free (tmpMeasurePanstarrs);
+      if (nitems != Nmeasure) {
+        fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
+        return (FALSE);
+      }
+      break;
+    default:
+      fprintf (stderr, "error writing measures\n");
+      return (FALSE);
+  }
+  return (TRUE);
+}
+
+/** SecFilt / Raw Table conversions **/
+
+SecFilt *ReadRawSecFilt (FILE *f, int Nsecfilt, int format) {
+
+  int nitems;
+  SecFilt *secfilt;
+  SecFiltElixir *tmpSecFiltElixir;
+  SecFiltLoneos *tmpSecFiltLoneos;
+  SecFiltPanstarrs *tmpSecFiltPanstarrs;
+
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      ALLOCATE (secfilt, SecFilt, MAX (Nsecfilt, 1));
+      nitems = fread (secfilt, sizeof(SecFilt), Nsecfilt, f);
+      if (nitems != Nsecfilt) {
+        fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
+        return (NULL);
+      }
+      fits_convert_SecFilt (secfilt, sizeof(SecFilt), Nsecfilt);
+      break;
+    case DVO_FORMAT_ELIXIR:
+      ALLOCATE (tmpSecFiltElixir, SecFiltElixir, MAX (Nsecfilt, 1));
+      nitems = fread (tmpSecFiltElixir, sizeof(SecFiltElixir), Nsecfilt, f);
+      if (nitems != Nsecfilt) {
+        fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
+        return (NULL);
+      }
+      fits_convert_SecFiltElixir (tmpSecFiltElixir, sizeof(SecFiltElixir), Nsecfilt);
+      secfilt = SecFiltElixirToInternal (tmpSecFiltElixir, Nsecfilt);
+      free (tmpSecFiltElixir);
+      break;
+    case DVO_FORMAT_LONEOS:
+      ALLOCATE (tmpSecFiltLoneos, SecFiltLoneos, MAX (Nsecfilt, 1));
+      nitems = fread (tmpSecFiltLoneos, sizeof(SecFiltLoneos), Nsecfilt, f);
+      if (nitems != Nsecfilt) {
+        fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
+        return (NULL);
+      }
+      fits_convert_SecFiltLoneos (tmpSecFiltLoneos, sizeof(SecFiltLoneos), Nsecfilt);
+      secfilt = SecFiltLoneosToInternal (tmpSecFiltLoneos, Nsecfilt);
+      free (tmpSecFiltLoneos);
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      ALLOCATE (tmpSecFiltPanstarrs, SecFiltPanstarrs, MAX (Nsecfilt, 1));
+      nitems = fread (tmpSecFiltPanstarrs, sizeof(SecFiltPanstarrs), Nsecfilt, f);
+      if (nitems != Nsecfilt) {
+        fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
+        return (NULL);
+      }
+      fits_convert_SecFiltPanstarrs (tmpSecFiltPanstarrs, sizeof(SecFiltPanstarrs), Nsecfilt);
+      secfilt = SecFiltPanstarrsToInternal (tmpSecFiltPanstarrs, Nsecfilt);
+      free (tmpSecFiltPanstarrs);
+      break;
+    default:
+      fprintf (stderr, "error reading measures\n");
+      return (NULL);
+  }
+  return (secfilt);
+}
+
+/* accepts and converts internal secfilt formats and outputs 
+   raw data in the specified format */
+int WriteRawSecFilt (FILE *f, SecFilt *secfilt, int Nsecfilt, int format) {
+
+  int nitems;
+  SecFiltElixir *tmpSecFiltElixir;
+  SecFiltLoneos *tmpSecFiltLoneos;
+  SecFiltPanstarrs *tmpSecFiltPanstarrs;
+
+  switch (format) {
+    case DVO_FORMAT_INTERNAL:
+      fits_convert_SecFilt (secfilt, sizeof(SecFilt), Nsecfilt);
+      nitems = fwrite (secfilt, sizeof(SecFilt), Nsecfilt, f);
+      if (nitems != Nsecfilt) {
+        fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
+        return (FALSE);
+      }
+      break;
+    case DVO_FORMAT_ELIXIR:
+      tmpSecFiltElixir = SecFiltInternalToElixir (secfilt, Nsecfilt);
+      fits_convert_SecFiltElixir (tmpSecFiltElixir, sizeof(SecFiltElixir), Nsecfilt);
+      nitems = fwrite (tmpSecFiltElixir, sizeof(SecFiltElixir), Nsecfilt, f);
+      free (tmpSecFiltElixir);
+      if (nitems != Nsecfilt) {
+        fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
+        return (FALSE);
+      }
+      break;
+    case DVO_FORMAT_LONEOS:
+      tmpSecFiltLoneos = SecFiltInternalToLoneos (secfilt, Nsecfilt);
+      fits_convert_SecFiltLoneos (tmpSecFiltLoneos, sizeof(SecFiltLoneos), Nsecfilt);
+      nitems = fwrite (tmpSecFiltLoneos, sizeof(SecFiltLoneos), Nsecfilt, f);
+      free (tmpSecFiltLoneos);
+      if (nitems != Nsecfilt) {
+        fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
+        return (FALSE);
+      }
+      break;
+    case DVO_FORMAT_PANSTARRS:
+      tmpSecFiltPanstarrs = SecFiltInternalToPanstarrs (secfilt, Nsecfilt);
+      fits_convert_SecFiltPanstarrs (tmpSecFiltPanstarrs, sizeof(SecFiltPanstarrs), Nsecfilt);
+      nitems = fwrite (tmpSecFiltPanstarrs, sizeof(SecFiltPanstarrs), Nsecfilt, f);
+      free (tmpSecFiltPanstarrs);
+      if (nitems != Nsecfilt) {
+        fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
+        return (FALSE);
+      }
+      break;
+    default:
+      fprintf (stderr, "error writing secfilts\n");
+      return (FALSE);
+  }
+  return (TRUE);
+}
+

trunk/Ohana/src/libohana/src/photfits.c

@@ -2 +2 @@
 # include <dvo.h>
 # define MAX_ORDER 3
+
+/**** XXXX warning: these functions have not been corrected to handle 
+      the change of Mcal from millimags to mags
+      I don't think most functions are using the Mcal polynomial terms in 
+      any case... ****/
+
+/* all terms of order > 0 are stored as 16bit floats 
+   the zero-order term is stored as a short int (-32k,+32k) */
 
 /* convert double to low-precision short int */
@@ -50 +58 @@
 
 /* convert image parameters to c[i] coeffs */
-/* all terms of order > 0 are stored as 16bit floats 
-   the zero-order term is stored as a short int (-32k,+32k) */
-
 void returnMcal (Image *image, double *c) {
 
   switch (image[0].order) {
   case 0:
-    c[0] = image[0].Mcal;
-    return;
-  case 1:
-    c[0] = image[0].Mcal;
+    c[0] = image[0].Mcal_PS;
+    return;
+  case 1:
+    c[0] = image[0].Mcal_PS;
     c[1] = getMi (image[0].Mx);
     c[2] = getMi (image[0].My);
     return;
   case 2:
-    c[0] = image[0].Mcal;
+    c[0] = image[0].Mcal_PS;
     c[1] = getMi (image[0].Mx);
     c[2] = getMi (image[0].Mxx);
@@ -73 +78 @@
     return;
   case 3:
-    c[0] = image[0].Mcal;
+    c[0] = image[0].Mcal_PS;
     c[1] = getMi (image[0].Mx);
     c[2] = getMi (image[0].Mxx);
@@ -85 +90 @@
     return;
   case 4:
-    c[0] = image[0].Mcal;
+    c[0] = image[0].Mcal_PS;
     c[1] = getMi (image[0].Mx);
     c[2] = getMi (image[0].Mxx);
@@ -113 +118 @@
   switch (order) {
   case 0:
-    image[0].Mcal = c[0];
-    return;
-  case 1:
-    image[0].Mcal = c[0];
+    image[0].Mcal_PS = c[0];
+    return;
+  case 1:
+    image[0].Mcal_PS = c[0];
     image[0].Mx    = putMi(c[1]);
     image[0].My    = putMi(c[2]);
     return;
   case 2:
-    image[0].Mcal = c[0];
+    image[0].Mcal_PS = c[0];
     image[0].Mx    = putMi(c[1]);
     image[0].Mxx   = putMi(c[2]);
@@ -129 +134 @@
     return;
   case 3:
-    image[0].Mcal = c[0];
+    image[0].Mcal_PS = c[0];
     image[0].Mx    = putMi(c[1]);
     image[0].Mxx   = putMi(c[2]);
@@ -141 +146 @@
     return;
   case 4:
-    image[0].Mcal = c[0];
+    image[0].Mcal_PS = c[0];
     image[0].Mx    = putMi(c[1]);
     image[0].Mxx   = putMi(c[2]);
@@ -158 +163 @@
     return;
   default:
-    image[0].Mcal = 0.0;
+    image[0].Mcal_PS = 0.0;
     image[0].order = 0;
     return;

trunk/Ohana/src/mosastro/src/gptolemy.c

@@ -6 +6 @@
   Catalog catalog;
   StarData *stars;
-
-  /* no autodetect for CATMODE yet */
-  strcpy (catalog.catmode, CATMODE);
 
   Nstars = 0;
@@ -21 +18 @@
     break;
   }
+
+  /* CATMODE and CATFORMAT determined from catalog */
   if (!load_catalog (&catalog, LOAD_AVES | LOAD_MEAS, FALSE)) {
     fprintf (stderr, "can't load catalog data %s\n", filename);

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

@@ -28 +28 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* interpret command-line options */

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

@@ -30 +30 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* command line arguments */

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

@@ -31 +31 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* command line arguments */

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

@@ -32 +32 @@
   VarConfig ("GSCDIR", "%s", gscdir);
   VarConfig ("CATDIR", "%s", catdir);
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   Mz = 17.0;

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

@@ -28 +28 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* interpret command-line options */

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

@@ -11 +11 @@
   VarConfig ("GSCDIR", "%s", gscdir);
   VarConfig ("CATDIR", "%s", catdir);
-  if (VarConfig ("CATMODE", "%s", catalog1.catmode) == NULL) 
-    strcpy (catalog1.catmode, "RAW");
       
   if (argc != 9) {

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

@@ -28 +28 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* interpret command-line options */

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

@@ -28 +28 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* interpret command-line options */

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

@@ -29 +29 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* interpret command-line options */

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

@@ -29 +29 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* interpret command-line options */

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

@@ -28 +28 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* interpret command-line options */

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

@@ -20 +20 @@
 
   VarConfig ("CATDIR", "%s", catdir);
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   vec1 = vec2 = vec3 = vec4 = vec5 = NULL;

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

@@ -36 +36 @@
   VarConfig ("GSCDIR", "%s", gscdir);
   VarConfig ("CATDIR", "%s", catdir);
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   regions = (RegionFile *) NULL;

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

@@ -14 +14 @@
   int N1, N2, i1, i2, mode[4];
   int Nsec, Nregions, status;
-  char catdir[256], catmode[16], filename[256], *RegionName, *RegionList;
+  char catdir[256], filename[256], *RegionName, *RegionList;
   char *cmd, *outcmd, *camera;
   double *M1, *M2;
@@ -37 +37 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catmode) == NULL) strcpy (catmode, "RAW");
 
   /* interpret command-line options */
@@ -104 +103 @@
   for (k = 0; k < Nregions; k++) {
     /* lock, load, unlock catalog */
-    strcpy (catalog[k].catmode, catmode);
     sprintf (filename, "%s/%s", catdir, regions[k].name);
     catalog[k].filename = filename;

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

@@ -4 +4 @@
   
   int i, j, N, Nimage, Nfound, *subset, Nsubset, status;
-  double ra, dec, Ra, Dec, X, Y, Mcal;
+  double ra, dec, Ra, Dec, X, Y;
   double trange, t;
   int TimeSelect, PixelCoords, TimeFormat, PhotCodeSelect;
@@ -96 +96 @@
     if (Y > image[i].NY) continue;
 
+    /*** XXX we need to re-introduce the use of applyMcal
     Mcal = applyMcal (&image[i], 2048.0, 2048.0);
+    ***/
+
     date = sec_to_date (image[i].tzero);
 
     if (PixelCoords) {
       fprintf (GetOutfile(), "%3d %s %6.1f %6.1f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x\n", 
-               Nfound, image[i].name, X, Y, date, image[i].nstar, image[i].source, 0.001*image[i].secz, 0.001*Mcal, 0.001*image[i].dMcal, image[i].exptime, image[i].code);
+               Nfound, image[i].name, X, Y, date, image[i].nstar, image[i].source, image[i].secz_PS, image[i].Mcal_PS, image[i].dMcal_PS, image[i].exptime, image[i].code);
     } else {
       XY_to_RD (&ra, &dec, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
       fprintf (GetOutfile(), "%3d %s %8.4f %8.4f %20s %5d %2d %4.2f %6.3f %5.3f %5.3f %4x\n", 
-               Nfound, image[i].name, ra, dec, date, image[i].nstar, image[i].source, 0.001*image[i].secz, 0.001*Mcal, 0.001*image[i].dMcal, image[i].exptime, image[i].code);
+               Nfound, image[i].name, ra, dec, date, image[i].nstar, image[i].source, image[i].secz_PS, image[i].Mcal_PS, image[i].dMcal_PS, image[i].exptime, image[i].code);
     }
     sprintf (name, "IMAGEx:%d", Nfound);

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

@@ -18 +18 @@
 
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) return (FALSE);
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   if (!InitPhotcodes ()) return (FALSE);

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

@@ -40 +40 @@
     }      
   }
-
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   if (argc != 4) {

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

@@ -139 +139 @@
       break;
     case (AIRMASS):
-      vec[0].elements[N] = 0.001*image[j].secz;
+      vec[0].elements[N] = image[j].secz_PS;
       break;
     case (MCAL):
-      vec[0].elements[N] = 0.001*image[j].Mcal;
+      vec[0].elements[N] = image[j].Mcal_PS;
       break;
     case (dMCAL):
-      vec[0].elements[N] = 0.001*image[j].dMcal;
+      vec[0].elements[N] = image[j].dMcal_PS;
       break;
     case (PHOTCODE):

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

@@ -86 +86 @@
     XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
     fprintf (GetOutfile(), "%3d %s %8.4f %8.4f %f %5d %2d %4.2f %5.3f %5.3f\n", 
-             i, image[i].name, r, d, t, image[i].nstar, image[i].source, 0.001*image[i].secz, 0.001*image[i].Mcal, 0.001*image[i].dMcal);
+             i, image[i].name, r, d, t, image[i].nstar, image[i].source, image[i].secz_PS, image[i].Mcal_PS, image[i].dMcal_PS);
   }
 

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

@@ -74 +74 @@
     switch (image[i].order) {
     case 0:
-      fprintf (stderr, "%s: %d - %d\n", image[i].name, image[i].order, image[i].Mcal);
+      fprintf (stderr, "%s: %d - %f\n", image[i].name, image[i].order, image[i].Mcal_PS);
       break;
     case 1:
-      fprintf (stderr, "%s: %d - %d, %d %d\n", image[i].name, image[i].order, image[i].Mcal, image[i].Mx, image[i].My);
+      fprintf (stderr, "%s: %d - %f, %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My);
       break;
     case 2:
-      fprintf (stderr, "%s: %d - %d, %d %d, %d %d %d\n", image[i].name, image[i].order, image[i].Mcal, image[i].Mx, image[i].My, image[i].Mxx, image[i].Mxy, image[i].Myy);
+      fprintf (stderr, "%s: %d - %f, %d %d, %d %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My, image[i].Mxx, image[i].Mxy, image[i].Myy);
       break;
     case 3:
-      fprintf (stderr, "%s: %d - %d, %d %d, %d %d %d, %d %d %d %d\n", image[i].name, image[i].order, image[i].Mcal, image[i].Mx, image[i].My, 
+      fprintf (stderr, "%s: %d - %f, %d %d, %d %d %d, %d %d %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My, 
                image[i].Mxx, image[i].Mxy, image[i].Myy, image[i].Mxxx, image[i].Mxxy, image[i].Mxyy, image[i].Myyy);
       break;
     case 4:
-      fprintf (stderr, "%s: %d - %d, %d %d, %d %d %d, %d %d %d %d, %d %d %d %d %d\n", image[i].name, image[i].order, image[i].Mcal, image[i].Mx, image[i].My, 
+      fprintf (stderr, "%s: %d - %f, %d %d, %d %d %d, %d %d %d %d, %d %d %d %d %d\n", image[i].name, image[i].order, image[i].Mcal_PS, image[i].Mx, image[i].My, 
                image[i].Mxx, image[i].Mxy, image[i].Myy, image[i].Mxxx, image[i].Mxxy, image[i].Mxyy, image[i].Myyy,
                image[i].Mxxxx, image[i].Mxxxy, image[i].Mxxyy, image[i].Mxyyy, image[i].Myyyy);

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

@@ -45 +45 @@
   fprintf (stdout, "seq  ra (J2000) dec    time (s)   Nstars\n");
   for (i = 0; i < Nimage; i++) {
-    Xvec.elements[i] = 0.001*image[i].secz;
+    Xvec.elements[i] = image[i].secz_PS;
     if (Mcal) 
-      Yvec.elements[i] = 0.001*image[i].Mcal;
+      Yvec.elements[i] = image[i].Mcal_PS;
     else 
-      Yvec.elements[i] = 0.001*image[i].dMcal;
+      Yvec.elements[i] = image[i].dMcal_PS;
     if (!FindMosaicForImage (image, Nimage, i)) continue;
     XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
     fprintf (stderr, "%d %8.4f %8.4f %10d %6d  %5.3f %6.3f %6.3f\n", 
              i, r, d, image[i].tzero, image[i].nstar, Xvec.elements[i], 
-             0.001*image[i].Mcal, 0.001*image[i].dMcal);
+             image[i].Mcal_PS, image[i].dMcal_PS);
   } 
   if (AutoLimits) SetLimits (&Xvec, &Yvec, &graphmode);

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

@@ -18 +18 @@
 
   VarConfig ("CATDIR", "%s", catdir);
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   if (!InitPhotcodes ()) return (FALSE);

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

@@ -15 +15 @@
 
   VarConfig ("CATDIR", "%s", catdir);
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   if (!InitPhotcodes ()) return (FALSE);

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

@@ -29 +29 @@
   /* find CATDIR in config system */
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) goto escape;
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   /* interpret command-line options */

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

@@ -22 +22 @@
   if (!GetGraph (&graphmode, NULL, &Ngraph)) return (FALSE);
   if (VarConfig ("CATDIR", "%s", catdir) == NULL) return (FALSE);
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   regions = (RegionFile *) NULL;

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

@@ -23 +23 @@
 
   VarConfig ("CATDIR", "%s", catdir);
-  if (VarConfig ("CATMODE", "%s", catalog.catmode) == NULL) 
-    strcpy (catalog.catmode, "RAW");
 
   GetTimeFormat (&TimeReference, &TimeFormat);
@@ -150 +148 @@
         RD_to_XY (&X, &Y, Ra, Dec, &image[I].coords);
         t = TimeValue (measure[j].t, TimeReference, TimeFormat);
-        fprintf (GetOutfile(), "%f %6.3f %7.2f %7.2f %5.3f\n", t, Mabs, X, Y, 0.001*image[I].secz);
+        fprintf (GetOutfile(), "%f %6.3f %7.2f %7.2f %5.3f\n", t, Mabs, X, Y, image[I].secz_PS);
       } 
     }

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

@@ -22 +22 @@
   GetConfig (config, "IMAGE_SCATTER",          "%lf", 0, &IMAGE_SCATTER);
   GetConfig (config, "IMAGE_OFFSET",           "%lf", 0, &IMAGE_OFFSET);
-
-  IMAGE_SCATTER *= 1000;
-  IMAGE_OFFSET *= 1000;
 
   GetConfig (config, "STAR_CHISQ",             "%lf", 0, &STAR_CHISQ);

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

@@ -145 +145 @@
 
   if (image[i].code & IMAGE_BAD)  return (NO_MAG);  
-  value = 0.001*image[i].Mcal;
+  value = image[i].Mcal_PS;
   return (value);
 }
@@ -217 +217 @@
     
     liststats (list, dlist, N, &stats);
-    image[i].Mcal  = 1000.0*stats.mean;
-    image[i].dMcal = 1000.0*stats.sigma;
+    image[i].Mcal_PS  = stats.mean;
+    image[i].dMcal_PS = stats.sigma;
     image[i].Xm    = 100.0*log10(stats.chisq);
   }
@@ -249 +249 @@
   for (i = N = 0; i < Nimage; i++) {
     if (image[i].code & IMAGE_BAD) continue;
-    mlist[N] = fabs (image[i].Mcal);
-    slist[N] = image[i].dMcal;
+    mlist[N] = fabs (image[i].Mcal_PS);
+    slist[N] = image[i].dMcal_PS;
     dlist[N] = 1;
     N++;
@@ -260 +260 @@
   liststats (slist, dlist, N, &stats);
   MaxScatter = MAX (IMAGE_SCATTER, 2*stats.median);
-  fprintf (stderr, "Mrel: %f, dMrel: %f, Max Scatter: %f, Max Offset: %f\n", 0.001*MedOffset, 0.001*stats.median, 0.001*MaxScatter, 0.001*MaxOffset);
+  fprintf (stderr, "Mrel: %f, dMrel: %f, Max Scatter: %f, Max Offset: %f\n", MedOffset, stats.median, MaxScatter, MaxOffset);
   
   Nmark = 0;
@@ -266 +266 @@
     mark = FALSE;
     image[i].code &= ~ID_IMAGE_POOR;
-    mark = (image[i].dMcal > MaxScatter) || (fabs(image[i].Mcal - MedOffset) > MaxOffset);
+    mark = (image[i].dMcal_PS > MaxScatter) || (fabs(image[i].Mcal_PS - MedOffset) > MaxOffset);
     if (mark) { 
       Nmark ++;
@@ -296 +296 @@
   /**** dMcal vs airmass ****/
   for (i = 0; i < Nimage; i++) {
-    Mlist[i] = 0.001*image[i].Mcal;
-    dlist[i] = 0.001*image[i].dMcal;
-    xlist[i] = 0.001*image[i].secz;
+    Mlist[i] = image[i].Mcal_PS;
+    dlist[i] = image[i].dMcal_PS;
+    xlist[i] = image[i].secz_PS;
   }
 
@@ -316 +316 @@
   bzero (Mlist, NBIN*sizeof(double));
   for (i = 0; i < Nimage; i++) {
-    bin = 0.001*image[i].dMcal / 0.0025;
+    bin = image[i].dMcal_PS / 0.0025;
     bin = MAX (0, MIN (NBIN - 1, bin));
     Mlist[bin] += 1.0;
@@ -413 +413 @@
     if (image[i].code & IMAGE_BAD)  continue;
 
-    list[n] = 0.001*image[i].Mcal;
+    list[n] = image[i].Mcal_PS;
     dlist[n] = 1;
     n++;
@@ -441 +441 @@
     if (image[i].code & IMAGE_BAD)  continue;
 
-    list[n] = 0.001*image[i].dMcal;
+    list[n] = image[i].dMcal_PS;
     dlist[n] = 1;
     n++;

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

@@ -69 +69 @@
     mosaic[Nmosaic].Xm    = 0.0;
     mosaic[Nmosaic].code  = image[i].code;
-    mosaic[Nmosaic].secz  = image[i].secz;
+    mosaic[Nmosaic].secz  = image[i].secz_PS;
 
     /* add image to mosaic image list */
@@ -134 +134 @@
       Dmin = MIN (Dmin, D);
       Dmax = MAX (Dmax, D);
-      Mcal += 0.001*image[m].Mcal;
-      dMcal += 0.001*image[m].dMcal;
+      Mcal += image[m].Mcal_PS;
+      dMcal += image[m].dMcal_PS;
       Xm += image[m].Xm;
       /* we are using mosaic.Mcal, not image.Mcal. reset image.Mcal */
-      image[m].Mcal = 0.0;
-      image[m].dMcal = image[m].Xm = NO_MAG;
+      image[m].Mcal_PS = 0.0;
+      image[m].dMcal_PS = image[m].Xm = NO_MAG;
     }
     dS /= Nimlist[i];
@@ -179 +179 @@
     for (j = 0; j < Nimlist[i]; j++) {
       im = imlist[i][j];
-      image[im].Mcal = 1000.0*mosaic[i].Mcal;
-      image[im].dMcal = 1000.0*mosaic[i].dMcal;
+      image[im].Mcal_PS = mosaic[i].Mcal;
+      image[im].dMcal_PS = mosaic[i].dMcal;
       image[im].Xm = mosaic[i].Xm;
       image[im].code |= (mosaic[i].code & ID_IMAGE_FEW);
@@ -405 +405 @@
   for (i = 0; i < Nmosaic; i++) {
     if (mosaic[i].code & IMAGE_BAD) continue;
-    list[n] = 0.001*mosaic[i].Mcal;
+    list[n] = mosaic[i].Mcal;
     dlist[n] = 1;
     n++;
@@ -432 +432 @@
 
     if (mosaic[i].code & IMAGE_BAD) continue;
-    list[n] = 0.001*mosaic[i].dMcal;
+    list[n] = mosaic[i].dMcal;
     dlist[n] = 1;
     n++;
@@ -538 +538 @@
   liststats (slist, dlist, N, &stats);
   MaxScatter = MAX (IMAGE_SCATTER, 2*stats.median);
-  fprintf (stderr, "Mrel: %f, dMrel: %f, Max Scatter: %f, Max Offset: %f\n", 0.001*MedOffset, 0.001*stats.median, 0.001*MaxScatter, 0.001*MaxOffset);
+  fprintf (stderr, "Mrel: %f, dMrel: %f, Max Scatter: %f, Max Offset: %f\n", MedOffset, stats.median, MaxScatter, MaxOffset);
   
   Nmark = 0;
@@ -618 +618 @@
 
   for (i = 0; i < Nmosaic; i++) {
-    Mlist[i] = 0.001*mosaic[i].Mcal;
-    dlist[i] = 0.001*mosaic[i].dMcal;
-    xlist[i] = 0.001*mosaic[i].secz;
+    Mlist[i] = mosaic[i].Mcal;
+    dlist[i] = mosaic[i].dMcal;
+    xlist[i] = mosaic[i].secz;
   }
 
@@ -640 +640 @@
   bzero (Mlist, NBIN*sizeof(double));
   for (i = 0; i < Nmosaic; i++) {
-    bin = 0.001*mosaic[i].dMcal / 0.0025;
+    bin = mosaic[i].dMcal / 0.0025;
     bin = MAX (0, MIN (NBIN - 1, bin));
     Mlist[bin] += 1.0;

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

@@ -104 +104 @@
         if (RESET) {
           assignMcal (&image[nimage], (double *) NULL, -1);
-          image[nimage].dMcal = NO_MAG;
+          image[nimage].dMcal_PS = NO_MAG;
           image[nimage].code &= ~ID_IMAGE_POOR;
         }

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

@@ -5 +5 @@
   char mode;
 
-  /* no autodetect for CATMODE yet */
-  strcpy (catalog[0].catmode, CATMODE);
-
   if (FINAL) {
     mode = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
@@ -13 +10 @@
     mode = LOAD_AVES | LOAD_MEAS | LOAD_SECF;
   }    
+
+  /* CATMODE and CATFORMAT determined from catalog */
 
   if (!load_catalog (catalog, mode, VERBOSE)) {

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

@@ -3 +3 @@
 void wcatalog (Catalog *catalog) {
   
-  /* set catalog format (elixir, loneos, etc) */
-  if (!strcmp (CATFORMAT, "INTERNAL")) {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE");
-    sprintf (catalog[0].measure_format, "DVO_MEASURE");
-  } else {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE_%s", CATFORMAT);
-    sprintf (catalog[0].measure_format, "DVO_MEASURE_%s", CATFORMAT);
-  }
+  /* CATMODE and CATFORMAT determined from catalog */
 
   if (!save_catalog (catalog, VERBOSE)) {

trunk/Ohana/src/uniphot/include/uniphot.h

@@ -5 +5 @@
 # ifdef ANSI
 #   define F_SETFL      4   
-#   define O_NONBLOCK 0200000  
-#   define       AF_UNIX         1          
-#   define       SOCK_STREAM     1          
-#define ENOENT          2       /* No such file or directory    */
+#   define O_NONBLOCK   0200000  
+#   define AF_UNIX      1          
+#   define SOCK_STREAM  1          
+#   define ENOENT       2       /* No such file or directory    */
 # endif /* ANSI */
 

trunk/Ohana/src/uniphot/src/fit_groups.c

@@ -4 +4 @@
 
   int i, j, Nlist;
-  short Mcal, Mgrp;
+  float Mcal, Mgrp;
   double *mlist, *dlist;
   StatType stats;
@@ -18 +18 @@
       if (tgroup[i].image[j][0].code & IMAGE_BAD) continue;
       sgroup = (Group *) tgroup[i].imlink[j][0].sgroup;
-      Mcal = tgroup[i].image[j][0].Mcal;
+      Mcal = tgroup[i].image[j][0].Mcal_PS;
       Mgrp = sgroup[0].M;
       mlist[Nlist] = (Mcal - Mgrp);
-      dlist[Nlist] = tgroup[i].image[j][0].dMcal;
+      dlist[Nlist] = tgroup[i].image[j][0].dMcal_PS;
       Nlist ++;
     }
@@ -41 +41 @@
 
   int i, j, Nlist;
-  short Mcal, Mgrp;
+  float Mcal, Mgrp;
   double *mlist, *dlist;
   StatType stats;
@@ -56 +56 @@
       if (sgroup[i].image[j][0].code & IMAGE_BAD) continue;
       tgroup = (Group *) sgroup[i].imlink[j][0].tgroup;
-      Mcal = sgroup[i].image[j][0].Mcal;
+      Mcal = sgroup[i].image[j][0].Mcal_PS;
       Mgrp = tgroup[0].M;
       mlist[Nlist] = (Mcal - Mgrp);
-      dlist[Nlist] = sgroup[i].image[j][0].dMcal;
+      dlist[Nlist] = sgroup[i].image[j][0].dMcal_PS;
       Nlist ++;
     }

trunk/Ohana/src/uniphot/src/gcatalog.c

@@ -5 +5 @@
   int mode;
 
-  /* no autodetect for CATMODE yet */
-  strcpy (catalog[0].catmode, CATMODE);
+  mode = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
 
-  mode = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
+  /* CATMODE and CATFORMAT determined from catalog */
 
   switch (lock_catalog (catalog, LCK_SOFT)) {

trunk/Ohana/src/uniphot/src/update.c

@@ -22 +22 @@
   for (i = 0; i < Nsgroup; i++) {
     for (j = 0; j < sgroup[i].Nimage; j++) {
-      sgroup[i].image[j][0].Mcal -= sgroup[i].M;
+      sgroup[i].image[j][0].Mcal_PS -= sgroup[i].M;
     }
   }

trunk/Ohana/src/uniphot/src/wcatalog.c

@@ -3 +3 @@
 void wcatalog (Catalog *catalog) {
 
-  /* set catalog format (elixir, loneos, etc) */
-  if (!strcmp (CATFORMAT, "INTERNAL")) {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE");
-    sprintf (catalog[0].measure_format, "DVO_MEASURE");
-  } else {
-    sprintf (catalog[0].average_format, "DVO_AVERAGE_%s", CATFORMAT);
-    sprintf (catalog[0].measure_format, "DVO_MEASURE_%s", CATFORMAT);
-  }
+  /* CATMODE and CATFORMAT determined from catalog */
 
   /** write out catalog, free memory **/