IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 38419


Ignore:
Timestamp:
Jun 6, 2015, 9:10:50 PM (11 years ago)
Author:
eugene
Message:

renamed galshape to galphot for convenience (8 chars in NGALPHOT); fix open / close for galphot

Location:
branches/eam_branches/ohana.20150429/src/libdvo
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ohana.20150429/src/libdvo/include/dvo.h

    r38414 r38419  
    5454  DVO_LOAD_STARPAR  = 0x1000,
    5555  DVO_SKIP_STARPAR  = 0x2000,
    56   DVO_LOAD_GALSHAPE = 0x4000,
    57   DVO_SKIP_GALSHAPE = 0x8000,
     56  DVO_LOAD_GALPHOT = 0x4000,
     57  DVO_SKIP_GALPHOT = 0x8000,
    5858} DVOCatFlags;
    5959
    … …  
    494494  unsigned short   Nmeasure;             // number of psf measurements
    495495  unsigned short   Nmissing;             // number of missings
    496   unsigned short   Ngalshape;            // number of extended measurements
     496  unsigned short   Ngalphot;            // number of extended measurements
    497497  uint32_t         measureOffset;        // offset to first psf measurement
    498498  uint32_t         missingOffset;        // offset to first missing obs
    … …  
    714714  unsigned short   Nlensing;             // number of lensing measurements
    715715  unsigned short   Nlensobj;             // number of lensing measurements
    716   unsigned short   Ngalshape;            // number of galshape measurements
     716  unsigned short   Ngalphot;            // number of galphot measurements
    717717  int              measureOffset;        // offset to first psf measurement
    718718  int              missingOffset;        // offset to first missing obs
    719719  int              lensingOffset;        // offset to first lensing obs
    720720  int              lensobjOffset;        // offset to mean lensing data
    721   int              galshapeOffset;       // offset to extended object entry
     721  int              galphotOffset;       // offset to extended object entry
    722722  int              starparOffset;        // offset to stellar parameter data
    723723  float            refColorBlue;         // color of astrometry ref stars
    … …  
    755755  Lensobj  *lensobj;
    756756  StarPar  *starpar;
    757   GalShape *galshape;
     757  GalPhot *galphot;
    758758
    759759  int Nsecfilt;  /* number of secfilt entries for each average entry */
    760   off_t Naverage,      Nmeasure,      Nmissing,      Nlensing,      Nlensobj,      Nstarpar,      Ngalshape,      Nsecfilt_mem;  /* current number of each component in memory */
    761   off_t Naverage_disk, Nmeasure_disk, Nmissing_disk, Nlensing_disk, Nlensobj_disk, Nstarpar_disk, Ngalshape_disk, Nsecfilt_disk; /* current number of each component on disk */
    762   off_t Naverage_off,  Nmeasure_off,  Nmissing_off,  Nlensing_off,  Nlensobj_off,  Nstarpar_off,  Ngalshape_off,  Nsecfilt_off;  /* index of first loaded data value */
     760  off_t Naverage,      Nmeasure,      Nmissing,      Nlensing,      Nlensobj,      Nstarpar,      Ngalphot,      Nsecfilt_mem;  /* current number of each component in memory */
     761  off_t Naverage_disk, Nmeasure_disk, Nmissing_disk, Nlensing_disk, Nlensobj_disk, Nstarpar_disk, Ngalphot_disk, Nsecfilt_disk; /* current number of each component on disk */
     762  off_t Naverage_off,  Nmeasure_off,  Nmissing_off,  Nlensing_off,  Nlensobj_off,  Nstarpar_off,  Ngalphot_off,  Nsecfilt_off;  /* index of first loaded data value */
    763763
    764764  // note that we use these for the full-sky relphot analysis
    … …  
    782782  struct Catalog *lensobj_catalog;              /* lensobj  catalog data (split) */
    783783  struct Catalog *starpar_catalog;              /* starpar  catalog data (split) */
    784   struct Catalog *galshape_catalog;             /* galshape catalog data (split) */
     784  struct Catalog *galphot_catalog;              /* galphot catalog data (split) */
    785785
    786786  unsigned int objID;
    … …  
    982982Lensobj *FtableToLensobj   (FTable *ftable, Average *average, off_t *Nlensobj,  DVOCatFormat *format, char nativeOrder);
    983983StarPar *FtableToStarPar   (FTable *ftable, Average *average, off_t *Nstarpar,  DVOCatFormat *format, char nativeOrder);
    984 GalShape *FtableToGalShape (FTable *ftable, Average *average, off_t *Ngalshape, DVOCatFormat *format, char nativeOrder);
     984GalPhot *FtableToGalPhot (FTable *ftable, Average *average, off_t *Ngalphot, DVOCatFormat *format, char nativeOrder);
    985985
    986986int      FtableToImage   (FTable *ftable, Header *theader, DVOCatFormat *format);
    … …  
    992992int LensobjToFtable  (FTable *ftable, Lensobj  *lensobj,  off_t Nlensobj,  DVOCatFormat format, int swapFromNative);
    993993int StarParToFtable  (FTable *ftable, StarPar  *starpar,  off_t Nstarpar,  DVOCatFormat format, int swapFromNative);
    994 int GalShapeToFtable (FTable *ftable, GalShape *galshape, off_t Ngalshape, DVOCatFormat format, int swapFromNative);
     994int GalPhotToFtable (FTable *ftable, GalPhot *galphot, off_t Ngalphot, DVOCatFormat format, int swapFromNative);
    995995
    996996int ImageToFtable (FTable *ftable, Header *theader, DVOCatFormat format);
    … …  
    11281128void dvo_lensobj_init (Lensobj *lensobj, int toZero);
    11291129void dvo_starpar_init (StarPar *starpar);
    1130 void dvo_galshape_init (GalShape *galshape);
     1130void dvo_galphot_init (GalPhot *galphot);
    11311131
    11321132void InitRegionHosts (RegionHostInfo *hosts, int Nhosts, int NHOSTS);

  • branches/eam_branches/ohana.20150429/src/libdvo/include/ps1_v5_defs.h

    r38331 r38419  
    2323StarPar_PS1_V5          *StarParInternalTo_PS1_V5 (StarPar *in, off_t Nvalues);
    2424
    25 GalShape                *GalShape_PS1_V5_ToInternal (GalShape_PS1_V5 *in, off_t Nvalues);
    26 GalShape_PS1_V5         *GalShapeInternalTo_PS1_V5 (GalShape *in, off_t Nvalues);
     25GalPhot                 *GalPhot_PS1_V5_ToInternal (GalPhot_PS1_V5 *in, off_t Nvalues);
     26GalPhot_PS1_V5         *GalPhotInternalTo_PS1_V5 (GalPhot *in, off_t Nvalues);
    2727
    2828PhotCode                *PhotCode_PS1_V5_To_Internal (PhotCode_PS1_V5 *in, off_t Nvalues);

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_catalog.c

    r38414 r38419  
    176176  average->Nlensobj        = 0;
    177177  average->Nstarpar        = 0;
    178   average->Ngalshape       = 0;
     178  average->Ngalphot       = 0;
    179179
    180180  average->measureOffset   = -1;
    … …  
    183183  average->lensobjOffset   = -1;
    184184  average->starparOffset   = -1;
    185   average->galshapeOffset  = -1;
     185  average->galphotOffset  = -1;
    186186
    187187  average->refColorBlue    = NAN;
    … …  
    511511
    512512// init all data, or just catalog data
    513 void dvo_galshape_init (GalShape *galshape) {
    514   galshape->Xfit         = NAN;
    515   galshape->Yfit         = NAN;
    516   galshape->mag          = NAN;
    517   galshape->magErr       = NAN;
    518   galshape->majorAxis    = NAN;
    519   galshape->minorAxis    = NAN;
    520   galshape->majorAxisErr = NAN;
    521   galshape->minorAxisErr = NAN;
    522   galshape->theta        = NAN;
    523   galshape->theta_err    = NAN;
    524   galshape->index        = NAN;
    525   galshape->chisq        = NAN;
    526   galshape->Npix         = 0;
    527 
    528   galshape->detID   = -1;
    529   galshape->objID   = -1;
    530   galshape->catID   = -1;
    531   galshape->imageID = -1;
    532 
    533   galshape->photcode = 0;
    534   galshape->modelType = 0;
     513void dvo_galphot_init (GalPhot *galphot) {
     514  galphot->Xfit         = NAN;
     515  galphot->Yfit         = NAN;
     516  galphot->mag          = NAN;
     517  galphot->magErr       = NAN;
     518  galphot->majorAxis    = NAN;
     519  galphot->minorAxis    = NAN;
     520  galphot->majorAxisErr = NAN;
     521  galphot->minorAxisErr = NAN;
     522  galphot->theta        = NAN;
     523  galphot->theta_err    = NAN;
     524  galphot->index        = NAN;
     525  galphot->chisq        = NAN;
     526  galphot->Npix         = 0;
     527
     528  galphot->detID   = -1;
     529  galphot->objID   = -1;
     530  galphot->catID   = -1;
     531  galphot->imageID = -1;
     532
     533  galphot->photcode = 0;
     534  galphot->modelType = 0;
    535535}
    536536
    … …  
    582582  INIT_TABLE(lensobj);
    583583  INIT_TABLE(starpar);
    584   INIT_TABLE(galshape);
     584  INIT_TABLE(galphot);
    585585
    586586  catalog[0].objID = 0;
    … …  
    618618  if (catalog[0].f == NULL)   return (DVO_CAT_OPEN_FAIL);
    619619
    620   fseeko (catalog[0].f, 0, SEEK_SET);
     620  if (fseeko (catalog[0].f, 0, SEEK_SET)) {
     621    perror ("fseeko: ");
     622    exit (1);
     623  }
    621624  return (DVO_CAT_OPEN_OK);
    622625}
    … …  
    630633
    631634  if (fflush (catalog[0].f)) {
    632     fprintf (stderr, "failed to flush file\n");
     635    perror ("fflush: ");
     636    fprintf (stderr, "failed to flush file %s\n", catalog[0].filename);
    633637    return FALSE;
    634638  }
    … …  
    657661    if (catalog[0].lensobj_catalog) { if (!dvo_catalog_unlock (catalog[0].lensobj_catalog)) { fprintf (stderr, "failed to unlock lensobj\n"); return (0); }}
    658662    if (catalog[0].starpar_catalog) { if (!dvo_catalog_unlock (catalog[0].starpar_catalog)) { fprintf (stderr, "failed to unlock starpar\n"); return (0); }}
     663    if (catalog[0].galphot_catalog) { if (!dvo_catalog_unlock (catalog[0].galphot_catalog)) { fprintf (stderr, "failed to unlock galphot\n"); return (0); }}
    659664  }
    660665  return (1);
    … …  
    938943      free (catalog[0].starpar_catalog);
    939944    }
     945    if (catalog[0].galphot_catalog) {
     946      free (catalog[0].galphot_catalog[0].filename);
     947      dvo_catalog_free (catalog[0].galphot_catalog);
     948      free (catalog[0].galphot_catalog);
     949    }
    940950  }
    941951  dvo_catalog_free_data (catalog);
    … …  
    981991    catalog[0].Nstarpar = 0;
    982992    catalog[0].starpar = NULL;
     993  }
     994  if (catalog[0].galphot) {
     995    free (catalog[0].galphot);
     996    catalog[0].Ngalphot = 0;
     997    catalog[0].galphot = NULL;
    983998  }
    984999  if (catalog[0].nOwn_t)      { free (catalog[0].nOwn_t); catalog[0].nOwn_t = NULL; }
    … …  
    11031118      }
    11041119    }
     1120    if (catalog[0].galphot_catalog != NULL) {
     1121      if (catalog[0].Ngalphot_disk == 0) {
     1122        // need to relock (and re-open) file for close elsewhere
     1123        status = dvo_catalog_lock (catalog[0].galphot_catalog, lockmode);
     1124      } else {
     1125        if (!dvo_catalog_backup (catalog[0].galphot_catalog, FALSE)) {
     1126          return FALSE;
     1127        }
     1128      }
     1129    }
    11051130  }
    11061131  return TRUE;
    … …  
    11591184      }
    11601185    }
     1186    if ((catalog[0].galphot_catalog != NULL) && (catalog[0].Ngalphot_disk > 0)) {
     1187      if (!dvo_catalog_unlink_backup (catalog[0].galphot_catalog, FALSE)) {
     1188        return FALSE;
     1189      }
     1190    }
    11611191  }
    11621192  return TRUE;

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_catalog_create.c

    r38348 r38419  
    3333    catalog[0].lensobj_catalog  = dvo_catalog_create_subcat (catalog, "cpy", "LENSOBJ");
    3434    catalog[0].starpar_catalog  = dvo_catalog_create_subcat (catalog, "cpz", "STARPAR");
    35     catalog[0].galshape_catalog = dvo_catalog_create_subcat (catalog, "cpq", "GALSHAPE");
     35    catalog[0].galphot_catalog = dvo_catalog_create_subcat (catalog, "cpq", "GALPHOT");
    3636
    3737    // lock the additional split files
    … …  
    6161      exit (2);
    6262    }
    63     if (dvo_catalog_lock (catalog[0].galshape_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
     63    if (dvo_catalog_lock (catalog[0].galphot_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
    6464      fprintf (stderr, "error with file lock\n");
    6565      exit (2);
    … …  
    9393  ALLOCATE (catalog[0].lensobj, Lensobj, 1);
    9494  ALLOCATE (catalog[0].starpar, StarPar, 1);
    95   ALLOCATE (catalog[0].galshape, GalShape, 1);
     95  ALLOCATE (catalog[0].galphot, GalPhot, 1);
    9696
    9797  /* setup secondary filters to match photcodes:

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_catalog_mef.c

    r38351 r38419  
    4747  GET_TABLE_SIZES ("NLENSOBJ",  lensobj,  Nlensobj_disk,  FALSE);
    4848  GET_TABLE_SIZES ("NSTARPAR",  starpar,  Nstarpar_disk,  FALSE);
    49   GET_TABLE_SIZES ("NGALSHAPE", galshape, Ngalshape_disk, FALSE);
     49  GET_TABLE_SIZES ("NGALPHOT", galphot, Ngalphot_disk, FALSE);
    5050
    5151  /**  Nsecfilt is unusual: it does not list the number of data items in the table
    … …  
    280280  }
    281281
    282   /* read GalShape table header */
    283   if (!gfits_fread_header (catalog[0].f, &header)) {
    284     if (VERBOSE) fprintf (stderr, "can't read table galshape header");
    285     return (FALSE);
    286   }
    287   /* read GalShape table data */
    288   if (catalog[0].catflags & DVO_LOAD_GALSHAPE) {
    289     if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) {
    290       if (VERBOSE) fprintf (stderr, "can't read table galshape data");
    291       return (FALSE);
    292     }
    293     catalog[0].galshape = FtableToGalShape (&ftable, catalog[0].average, &catalog[0].Ngalshape, &catalog[0].catformat, FALSE);
    294     if (Ngalshape != catalog[0].Ngalshape_disk) {
    295       fprintf (stderr, "Warning: mismatch between Ngalshape in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Ngalshape,  catalog[0].Ngalshape_disk);
    296     }
    297     catalog[0].Ngalshape = catalog[0].Ngalshape_disk;
    298     catalog[0].Ngalshape_off = 0;
    299   } else {
    300     Nbytes = gfits_data_size (&header);
    301     fseeko (catalog[0].f, Nbytes, SEEK_CUR);
    302     ALLOCATE (catalog[0].galshape, GalShape, 1);
    303     catalog[0].Ngalshape = 0;
    304     catalog[0].Ngalshape_off = catalog[0].Ngalshape_disk;
     282  /* read GalPhot table header */
     283  if (!gfits_fread_header (catalog[0].f, &header)) {
     284    if (VERBOSE) fprintf (stderr, "can't read table galphot header");
     285    return (FALSE);
     286  }
     287  /* read GalPhot table data */
     288  if (catalog[0].catflags & DVO_LOAD_GALPHOT) {
     289    if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) {
     290      if (VERBOSE) fprintf (stderr, "can't read table galphot data");
     291      return (FALSE);
     292    }
     293    catalog[0].galphot = FtableToGalPhot (&ftable, catalog[0].average, &catalog[0].Ngalphot, &catalog[0].catformat, FALSE);
     294    if (Ngalphot != catalog[0].Ngalphot_disk) {
     295      fprintf (stderr, "Warning: mismatch between Ngalphot in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Ngalphot,  catalog[0].Ngalphot_disk);
     296    }
     297    catalog[0].Ngalphot = catalog[0].Ngalphot_disk;
     298    catalog[0].Ngalphot_off = 0;
     299  } else {
     300    Nbytes = gfits_data_size (&header);
     301    fseeko (catalog[0].f, Nbytes, SEEK_CUR);
     302    ALLOCATE (catalog[0].galphot, GalPhot, 1);
     303    catalog[0].Ngalphot = 0;
     304    catalog[0].Ngalphot_off = catalog[0].Ngalphot_disk;
    305305  }
    306306
    … …  
    356356  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  catalog[0].Nlensobj);
    357357  gfits_modify (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  catalog[0].Nstarpar);
    358   gfits_modify (&catalog[0].header, "NGALSHAPE", OFF_T_FMT, 1,  catalog[0].Ngalshape);
     358  gfits_modify (&catalog[0].header, "NGALPHOT", OFF_T_FMT, 1,  catalog[0].Ngalphot);
    359359
    360360  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    … …  
    476476  gfits_free_header (&header);
    477477
    478   /* write out GalShape table (convert to FITS table format) */
    479   GalShapeToFtable (&ftable, catalog[0].galshape, catalog[0].Ngalshape, catalog[0].catformat, TRUE);
     478  /* write out GalPhot table (convert to FITS table format) */
     479  GalPhotToFtable (&ftable, catalog[0].galphot, catalog[0].Ngalphot, catalog[0].catformat, TRUE);
    480480  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
    481481    fprintf (stderr, "can't write table header");

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_catalog_split.c

    r38414 r38419  
    8989    perror ("dvo_catalog_save_subset: ");
    9090    fprintf (stderr, "failed to seek to beginning\n");
     91    return FALSE;
    9192  }
    9293
    … …  
    197198    if (!strcmp (name, "LENSOBJ"))  return (DVO_CAT_OPEN_EMPTY);
    198199    if (!strcmp (name, "STARPAR"))  return (DVO_CAT_OPEN_EMPTY);
    199     if (!strcmp (name, "GALSHAPE")) return (DVO_CAT_OPEN_EMPTY);
     200    if (!strcmp (name, "GALPHOT")) return (DVO_CAT_OPEN_EMPTY);
    200201    return (DVO_CAT_OPEN_FAIL);
    201202  }
    … …  
    226227  }
    227228  Nskip = gfits_data_size (&subcat[0].header);
    228   fseeko (subcat[0].f, Nskip, SEEK_CUR);
     229  if (fseeko (subcat[0].f, Nskip, SEEK_CUR)) { perror ("fseeko: "); exit (1); }
    229230
    230231  /* read table header */
    … …  
    316317          fprintf (stderr, "Warning: mismatch between N%s in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n", #FIELD, Nitems, catalog[0].N##FIELD##_disk); \
    317318        }                                                               \
    318         catalog[0].N##FIELD = catalog[0].N##FIELD##_disk;                       \
    319           catalog[0].N##FIELD##_off = 0;                                        \
     319        catalog[0].N##FIELD = catalog[0].N##FIELD##_disk;               \
     320          catalog[0].N##FIELD##_off = 0;                                \
    320321    } else {                                                            \
    321322      if (catalog[0].FIELD##_catalog) {                                 \
    … …  
    342343  off_t Nlensobj;
    343344  off_t Nstarpar;
    344   off_t Ngalshape;
     345  off_t Ngalphot;
    345346  int Nsecfilt;
    346347  SecFilt *primary;
    … …  
    349350
    350351  /* get the components from the header - these duplicate information in the split files (NAXIS2) */
    351   // NSTARS, NMEAS, NMISS are required; NLENSING, NLENSOBJ, NSTARPAR, NGALSHAPE are not (0 if not found)
     352  // NSTARS, NMEAS, NMISS are required; NLENSING, NLENSOBJ, NSTARPAR, NGALPHOT are not (0 if not found)
    352353  if (!gfits_scan (&catalog[0].header, "NSTARS",    OFF_T_FMT, 1,  &Naverage))  return (FALSE);
    353354  if (!gfits_scan (&catalog[0].header, "NMEAS",     OFF_T_FMT, 1,  &Nmeasure))  return (FALSE);
    … …  
    357358  if (!gfits_scan (&catalog[0].header, "NLENSOBJ",  OFF_T_FMT, 1,  &Nlensobj))  Nlensobj  = 0;
    358359  if (!gfits_scan (&catalog[0].header, "NSTARPAR",  OFF_T_FMT, 1,  &Nstarpar))  Nstarpar  = 0;
    359   if (!gfits_scan (&catalog[0].header, "NGALSHAPE", OFF_T_FMT, 1,  &Ngalshape)) Ngalshape = 0;
     360  if (!gfits_scan (&catalog[0].header, "NGALPHOT", OFF_T_FMT, 1,  &Ngalphot)) Ngalphot = 0;
    360361
    361362  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
    … …  
    379380  catalog[0].Nlensobj_disk  = Nlensobj;
    380381  catalog[0].Nstarpar_disk  = Nstarpar;
    381   catalog[0].Ngalshape_disk = Ngalshape;
     382  catalog[0].Ngalphot_disk = Ngalphot;
    382383
    383384  /* default values, but we will assign these a valid value before we exit (even if empty) */
    … …  
    389390  catalog[0].lensobj  = NULL;
    390391  catalog[0].starpar  = NULL;
    391   catalog[0].galshape = NULL;
     392  catalog[0].galphot = NULL;
    392393
    393394  /*** Average Table ***/
    … …  
    396397  /* move pointer past PHU header -- must be already read (load_catalog) */
    397398  Nbytes = catalog[0].header.datasize + gfits_data_size (&catalog[0].header);
    398   fseeko (catalog[0].f, Nbytes, SEEK_SET);
     399  if (fseeko (catalog[0].f, Nbytes, SEEK_SET)) { perror ("fseeko: "); exit (1); }
    399400
    400401  /* ftable header storage for below */
    … …  
    443444  LOAD_SUBCAT(lensobj,LENSOBJ,Lensobj);
    444445  LOAD_SUBCAT(starpar,STARPAR,StarPar);
    445   LOAD_SUBCAT(galshape,GALSHAPE,GalShape);
     446  LOAD_SUBCAT(galphot,GALPHOT,GalPhot);
    446447
    447448  /**  catalog->Nsecfilt is unusual: it does not list the number of data items in the
    … …  
    472473
    473474  off_t Nbytes;
    474   off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing, Nlensing, Nlensobj, Nstarpar, Ngalshape;
     475  off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing, Nlensing, Nlensobj, Nstarpar, Ngalphot;
    475476  Header header;
    476477  FTable ftable;
    … …  
    489490    /* move pointer past header and matrix -- must be already read (load_catalog) */
    490491    Nbytes = catalog[0].header.datasize + gfits_data_size (&catalog[0].header);
    491     fseeko (catalog[0].f, Nbytes, SEEK_SET);
     492    if (fseeko (catalog[0].f, Nbytes, SEEK_SET)) { perror ("fseeko: "); exit (1); }
     493
    492494    /* read Average table header */
    493495    if (!gfits_fread_header (catalog[0].f, &header)) {
    … …  
    518520    /* move pointer past header -- must be already read (load_catalog) */
    519521    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
    520     fseeko (subcat[0].f, Nbytes, SEEK_SET);
     522    if (fseeko (subcat[0].f, Nbytes, SEEK_SET)) { perror ("fseeko: "); exit (1); }
    521523
    522524    /* read Secfilt table header */
    … …  
    554556    /* move pointer past header -- must be already read (load_catalog) */
    555557    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
    556     fseeko (subcat[0].f, Nbytes, SEEK_SET);
     558    if (fseeko (subcat[0].f, Nbytes, SEEK_SET)) { perror ("fseeko: "); exit (1); }
    557559
    558560    /* read Measure table header */
    … …  
    585587    /* move pointer past header -- must be already read (load_catalog) */
    586588    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
    587     fseeko (subcat[0].f, Nbytes, SEEK_SET);
     589    if (fseeko (subcat[0].f, Nbytes, SEEK_SET)) { perror ("fseeko: "); exit (1); }
    588590
    589591    /* read Missing table header */
    … …  
    619621    /* move pointer past header -- must be already read (load_catalog) */
    620622    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
    621     fseeko (subcat[0].f, Nbytes, SEEK_SET);
     623    if (fseeko (subcat[0].f, Nbytes, SEEK_SET)) { perror ("fseeko: "); exit (1); }
    622624
    623625    /* read Lensing table header */
    … …  
    650652    /* move pointer past header -- must be already read (load_catalog) */
    651653    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
    652     fseeko (subcat[0].f, Nbytes, SEEK_SET);
     654    if (fseeko (subcat[0].f, Nbytes, SEEK_SET)) { perror ("fseeko: "); exit (1); }
    653655
    654656    /* read Lensobj table header */
    … …  
    681683    /* move pointer past header -- must be already read (load_catalog) */
    682684    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
    683     fseeko (subcat[0].f, Nbytes, SEEK_SET);
     685    if (fseeko (subcat[0].f, Nbytes, SEEK_SET)) { perror ("fseeko: "); exit (1); }
    684686
    685687    /* read StarPar table header */
    … …  
    706708
    707709  // XXX check the open status of the catalog
    708   if (catalog[0].catflags & DVO_LOAD_GALSHAPE) {
    709 
    710     Catalog *subcat = catalog[0].galshape_catalog;
     710  if (catalog[0].catflags & DVO_LOAD_GALPHOT) {
     711
     712    Catalog *subcat = catalog[0].galphot_catalog;
    711713
    712714    /* move pointer past header -- must be already read (load_catalog) */
    713715    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
    714     fseeko (subcat[0].f, Nbytes, SEEK_SET);
    715 
    716     /* read GalShape table header */
     716    if (fseeko (subcat[0].f, Nbytes, SEEK_SET)) { perror ("fseeko: "); exit (1); }
     717
     718    /* read GalPhot table header */
    717719    if (!gfits_fread_header (subcat[0].f, &header)) {
    718       if (VERBOSE) fprintf (stderr, "can't read table galshape header");
    719       return (FALSE);
    720     }
    721     /* read GalShape table data : format is irrelevant here */
     720      if (VERBOSE) fprintf (stderr, "can't read table galphot header");
     721      return (FALSE);
     722    }
     723    /* read GalPhot table data : format is irrelevant here */
    722724    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
    723       if (VERBOSE) fprintf (stderr, "can't read table galshape data");
    724       return (FALSE);
    725     }
    726 
    727     /* convert data format to internal : returns number of row read in Ngalshape */
    728     catalog[0].galshape = FtableToGalShape (&ftable, catalog[0].average, &Ngalshape, &catalog[0].catformat, FALSE);
    729     if (Ngalshape != Nrows) {
     725      if (VERBOSE) fprintf (stderr, "can't read table galphot data");
     726      return (FALSE);
     727    }
     728
     729    /* convert data format to internal : returns number of row read in Ngalphot */
     730    catalog[0].galphot = FtableToGalPhot (&ftable, catalog[0].average, &Ngalphot, &catalog[0].catformat, FALSE);
     731    if (Ngalphot != Nrows) {
    730732      // XXX this condition denotes the eof has been reached; not an error or a warning
    731       // fprintf (stderr, "Warning: mismatch between Ngalshape in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Ngalshape,  Nrows);
    732     }
    733     gfits_free_header (&header);
    734     catalog[0].Ngalshape = Ngalshape;
    735     catalog[0].Ngalshape_off = start;
     733      // fprintf (stderr, "Warning: mismatch between Ngalphot in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Ngalphot,  Nrows);
     734    }
     735    gfits_free_header (&header);
     736    catalog[0].Ngalphot = Ngalphot;
     737    catalog[0].Ngalphot_off = start;
    736738  }
    737739
    … …  
    747749  SecFilt *primary, *secfilt;
    748750  int Nsecfilt;
    749   off_t Naverage_disk_new, Nmeasure_disk_new, Nmissing_disk_new, Nsecfilt_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new, Ngalshape_disk_new;
     751  off_t Naverage_disk_new, Nmeasure_disk_new, Nmissing_disk_new, Nsecfilt_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new, Ngalphot_disk_new;
    750752  off_t first, start, Nrows;
    751753
    … …  
    781783  Nlensobj_disk_new = MAX (catalog[0].Nlensobj_disk, catalog[0].Nlensobj + catalog[0].Nlensobj_off);
    782784  Nstarpar_disk_new = MAX (catalog[0].Nstarpar_disk, catalog[0].Nstarpar + catalog[0].Nstarpar_off);
    783   Ngalshape_disk_new = MAX (catalog[0].Ngalshape_disk, catalog[0].Ngalshape + catalog[0].Ngalshape_off);
     785  Ngalphot_disk_new = MAX (catalog[0].Ngalphot_disk, catalog[0].Ngalphot + catalog[0].Ngalphot_off);
    784786
    785787  /* make sure header is consistent with data */
    … …  
    791793  gfits_modify (&catalog[0].header, "NLENSOBJ",  OFF_T_FMT, 1,  Nlensobj_disk_new);
    792794  gfits_modify (&catalog[0].header, "NSTARPAR",  OFF_T_FMT, 1,  Nstarpar_disk_new);
    793   gfits_modify (&catalog[0].header, "NGALSHAPE", OFF_T_FMT, 1,  Ngalshape_disk_new);
     795  gfits_modify (&catalog[0].header, "NGALPHOT", OFF_T_FMT, 1,  Ngalphot_disk_new);
    794796
    795797  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    … …  
    812814    /* convert internal to external format : also results in a byte-swapped, scaled output
    813815       table.  Note that ftable is newly allocated.
    814      */
     816    */
    815817   
    816818    // if we are going to compress, we need to receive unswapped data --
    … …  
    831833    // even if we do not save the average table, we need to keep the header in sync
    832834    /* rewind file pointers and truncate (file is still open) */
    833     fseeko (catalog[0].f, 0, SEEK_SET);
     835    if (fseeko (catalog[0].f, 0, SEEK_SET)) { perror ("fseeko: "); exit (1); }
     836
     837    /* write table PHU header - always write this out */
     838    /* XXX EAM : check if disk file size has changed */
     839    if (!gfits_fwrite_header  (catalog[0].f, &catalog[0].header)) {
     840      fprintf (stderr, "can't write primary header");
     841      goto failure;
     842    }
     843  }
     844
     845  /*** Measure Table ***/
     846  if ((catalog[0].catflags & DVO_LOAD_MEASURE) && (catalog[0].measure != NULL)) {
     847
     848    first  = 0;                    // first row in memory to write
     849    start  = catalog[0].Nmeasure_off; // first disk row to write
     850    Nrows  = catalog[0].Nmeasure - first;
     851
     852    assert (Nrows >= 0);
     853    assert (first >= 0);
     854    assert (first <= catalog[0].Nmeasure);
     855    assert (catalog[0].Nmeasure_disk >= catalog[0].Nmeasure_off);
     856
     857    // convert to external table format
     858    if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat, TRUE)) {
     859      fprintf (stderr, "trouble converting format\n");
     860      goto failure;
     861    }
     862
     863    // write out Measure table
     864    if (!dvo_catalog_save_subcat (catalog[0].measure_catalog, &ftable, start, Nrows, catalog[0].Nmeasure_disk, Nmeasure_disk_new)) {
     865      fprintf (stderr, "trouble writing Measure table\n");
     866      goto failure;
     867    }
     868    gfits_free_header (&header);
     869    gfits_free_table (&ftable);
     870  }
     871
     872  /*** Missing Table ***/
     873  if ((catalog[0].catflags & DVO_LOAD_MISSING) && (catalog[0].missing != NULL)) {
     874
     875    if (catalog[0].Nmissing_off != 0) {
     876      fprintf (stderr, "inconsistency: Missing table cannot be written in segments\n");
     877      goto failure;
     878    }
     879
     880    // convert to external table format
     881    if (!gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing, TRUE)) {
     882      fprintf (stderr, "trouble converting format\n");
     883      goto failure;
     884    }
     885
     886    // write out Missing table (must write out entire table)
     887    if (!dvo_catalog_save_subcat (catalog[0].missing_catalog, &ftable, 0, catalog[0].Nmissing, catalog[0].Nmissing, catalog[0].Nmissing)) {
     888      fprintf (stderr, "trouble writing Missing Table\n");
     889      goto failure;
     890    }
     891    gfits_free_header (&header);
     892    gfits_free_table (&ftable);
     893  }
     894
     895  /*** Secfilt Table ***/
     896  if ((catalog[0].catflags & DVO_LOAD_SECFILT) && (catalog[0].secfilt != NULL)) {
     897
     898    first  = 0;                    // first row in memory to write
     899    start  = catalog[0].Nsecfilt_off; // first disk row to write
     900    Nitems = catalog[0].Naverage*Nsecfilt;
     901    Nrows  = Nitems - first;
     902
     903    assert (Nrows >= 0);
     904    assert (first >= 0);
     905    assert (first <= Nitems);
     906    assert (catalog[0].Nsecfilt_disk >= catalog[0].Nsecfilt_off);
     907    // XXX check these for consistency...
     908
     909    // convert to external table format
     910    SecFiltToFtable (&ftable, &secfilt[first], Nrows, catalog[0].catformat, TRUE);
     911
     912    // write out SecFilt table
     913    if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecfilt_disk, Nsecfilt_disk_new)) {
     914      fprintf (stderr, "failure writing SecFilt table\n");
     915      goto failure;
     916    }
     917    gfits_free_header (&header);
     918    gfits_free_table (&ftable);
     919  }
     920
     921  /*** Lensing Table ***/
     922  if ((catalog[0].catflags & DVO_LOAD_LENSING) && (catalog[0].lensing != NULL)) {
     923
     924    first  = 0;                    // first row in memory to write
     925    start  = catalog[0].Nlensing_off; // first disk row to write
     926    Nrows  = catalog[0].Nlensing - first;
     927
     928    assert (Nrows >= 0);
     929    assert (first >= 0);
     930    assert (first <= catalog[0].Nlensing);
     931    assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off);
     932
     933    // convert to external table format
     934    if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat, TRUE)) {
     935      fprintf (stderr, "trouble converting format\n");
     936      goto failure;
     937    }
     938
     939    // write out Lensing table
     940    if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) {
     941      fprintf (stderr, "trouble writing Lensing table\n");
     942      goto failure;
     943    }
     944    gfits_free_header (&header);
     945    gfits_free_table (&ftable);
     946  }
     947
     948  /*** Lensobj Table ***/
     949  if ((catalog[0].catflags & DVO_LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) {
     950
     951    first  = 0;                    // first row in memory to write
     952    start  = catalog[0].Nlensobj_off; // first disk row to write
     953    Nrows  = catalog[0].Nlensobj - first;
     954
     955    assert (Nrows >= 0);
     956    assert (first >= 0);
     957    assert (first <= catalog[0].Nlensobj);
     958    assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off);
     959
     960    // convert to external table format
     961    if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat, TRUE)) {
     962      fprintf (stderr, "trouble converting format\n");
     963      goto failure;
     964    }
     965
     966    // write out Lensobj table
     967    if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) {
     968      fprintf (stderr, "trouble writing Lensobj table\n");
     969      goto failure;
     970    }
     971    gfits_free_header (&header);
     972    gfits_free_table (&ftable);
     973  }
     974
     975  /*** StarPar Table ***/
     976  if ((catalog[0].catflags & DVO_LOAD_STARPAR) && (catalog[0].starpar != NULL)) {
     977
     978    first  = 0;                    // first row in memory to write
     979    start  = catalog[0].Nstarpar_off; // first disk row to write
     980    Nrows  = catalog[0].Nstarpar - first;
     981
     982    assert (Nrows >= 0);
     983    assert (first >= 0);
     984    assert (first <= catalog[0].Nstarpar);
     985    assert (catalog[0].Nstarpar_disk >= catalog[0].Nstarpar_off);
     986
     987    // convert to external table format
     988    if (!StarParToFtable (&ftable, &catalog[0].starpar[first], Nrows, catalog[0].catformat, TRUE)) {
     989      fprintf (stderr, "trouble converting format\n");
     990      goto failure;
     991    }
     992
     993    // write out StarPar table
     994    if (!dvo_catalog_save_subcat (catalog[0].starpar_catalog, &ftable, start, Nrows, catalog[0].Nstarpar_disk, Nstarpar_disk_new)) {
     995      fprintf (stderr, "trouble writing StarPar table\n");
     996      goto failure;
     997    }
     998    gfits_free_header (&header);
     999    gfits_free_table (&ftable);
     1000  }
     1001
     1002  /*** GalPhot Table ***/
     1003  if ((catalog[0].catflags & DVO_LOAD_GALPHOT) && (catalog[0].galphot != NULL)) {
     1004
     1005    first  = 0;                    // first row in memory to write
     1006    start  = catalog[0].Ngalphot_off; // first disk row to write
     1007    Nrows  = catalog[0].Ngalphot - first;
     1008
     1009    assert (Nrows >= 0);
     1010    assert (first >= 0);
     1011    assert (first <= catalog[0].Ngalphot);
     1012    assert (catalog[0].Ngalphot_disk >= catalog[0].Ngalphot_off);
     1013
     1014    // convert to external table format
     1015    if (!GalPhotToFtable (&ftable, &catalog[0].galphot[first], Nrows, catalog[0].catformat, TRUE)) {
     1016      fprintf (stderr, "trouble converting format\n");
     1017      goto failure;
     1018    }
     1019
     1020    // write out GalPhot table
     1021    if (!dvo_catalog_save_subcat (catalog[0].galphot_catalog, &ftable, start, Nrows, catalog[0].Ngalphot_disk, Ngalphot_disk_new)) {
     1022      fprintf (stderr, "trouble writing GalPhot table\n");
     1023      goto failure;
     1024    }
     1025    gfits_free_header (&header);
     1026    gfits_free_table (&ftable);
     1027  }
     1028
     1029  /* free temp storage */
     1030  if (primary != NULL) {
     1031    free (primary);
     1032    free (secfilt);
     1033  }
     1034  return (TRUE);
     1035
     1036 failure:
     1037  /* free temp storage */
     1038  gfits_free_header (&header);
     1039  gfits_free_table (&ftable);
     1040  if (primary != NULL) {
     1041    free (primary);
     1042    free (secfilt);
     1043  }
     1044  return (FALSE);
     1045}
     1046
     1047/* update_catalog_split only writes new lines to file. */
     1048int dvo_catalog_update_split (Catalog *catalog, char VERBOSE) {
     1049
     1050  off_t Nitems;
     1051  Header header;
     1052  FTable ftable;
     1053  SecFilt *primary, *secfilt;
     1054  int Nsecfilt;
     1055  off_t Naverage_disk_new, Nmeasure_disk_new, Nmissing_disk_new, Nsecfilt_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new, Ngalphot_disk_new;
     1056  off_t first, start, Nrows;
     1057
     1058  ftable.header = &header;
     1059  ftable.buffer = NULL;
     1060  header.buffer = NULL;
     1061
     1062  // skip empty catalogs: it is illegal to have Measures without corresponding Averages
     1063  Naverage_disk_new = MAX (catalog[0].Naverage_disk, catalog[0].Naverage + catalog[0].Naverage_off);
     1064  if (Naverage_disk_new == 0) {
     1065    if (VERBOSE) fprintf (stderr, "no stars in catalog, skipping\n");
     1066    return (TRUE);
     1067  }
     1068
     1069  // for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary
     1070  switch (catalog[0].catformat) {
     1071    case DVO_FORMAT_ELIXIR: // special case for ELIXIR
     1072    case DVO_FORMAT_LONEOS: // special case for LONEOS
     1073      dvo_catalog_secfilt_to_primary (catalog, &primary, &secfilt, &Nsecfilt);
     1074      break;
     1075    default:
     1076      primary = NULL;
     1077      secfilt = catalog[0].secfilt;
     1078      Nsecfilt = catalog[0].Nsecfilt;
     1079      break;
     1080  }
     1081
     1082  Nmeasure_disk_new = MAX (catalog[0].Nmeasure_disk, catalog[0].Nmeasure + catalog[0].Nmeasure_off);
     1083  Nmissing_disk_new = MAX (catalog[0].Nmissing_disk, catalog[0].Nmissing + catalog[0].Nmissing_off);
     1084  Nsecfilt_disk_new = MAX (catalog[0].Nsecfilt_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecfilt_off);
     1085  Nlensing_disk_new = MAX (catalog[0].Nlensing_disk, catalog[0].Nlensing + catalog[0].Nlensing_off);
     1086  Nlensobj_disk_new = MAX (catalog[0].Nlensobj_disk, catalog[0].Nlensobj + catalog[0].Nlensobj_off);
     1087  Nstarpar_disk_new = MAX (catalog[0].Nstarpar_disk, catalog[0].Nstarpar + catalog[0].Nstarpar_off);
     1088  Ngalphot_disk_new = MAX (catalog[0].Ngalphot_disk, catalog[0].Ngalphot + catalog[0].Ngalphot_off);
     1089
     1090  /* make sure header is consistent with data */
     1091  gfits_modify (&catalog[0].header, "NSTARS",   OFF_T_FMT, 1,  Naverage_disk_new);
     1092  gfits_modify (&catalog[0].header, "NMEAS",    OFF_T_FMT, 1,  Nmeasure_disk_new);
     1093  gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  Nmissing_disk_new);
     1094  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
     1095  gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  Nlensing_disk_new);
     1096  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
     1097  gfits_modify (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  Nstarpar_disk_new);
     1098  gfits_modify (&catalog[0].header, "NGALPHOT", OFF_T_FMT, 1,  Ngalphot_disk_new);
     1099
     1100  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
     1101  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
     1102
     1103  /* in split mode, we can save only part of the data */
     1104
     1105  /*** Average Table ***/
     1106  if (catalog[0].average != NULL) {
     1107
     1108    first  = catalog[0].Naverage_disk - catalog[0].Naverage_off; // first row to write (memory)
     1109    start  = catalog[0].Naverage_disk;                        // first row to write (disk)
     1110    Nrows  = catalog[0].Naverage - first;
     1111
     1112    assert (Nrows >= 0);
     1113    assert (first >= 0);
     1114    assert (first <= catalog[0].Naverage);
     1115    assert (catalog[0].Naverage_disk >= catalog[0].Naverage_off);
     1116
     1117    /* convert internal to external format */
     1118    if (!AverageToFtable (&ftable, &catalog[0].average[first], Nrows, catalog[0].catformat, primary, TRUE)) {
     1119      fprintf (stderr, "trouble converting format\n");
     1120      goto failure;
     1121    }
     1122
     1123    if (!dvo_catalog_save_subcat (catalog, &ftable, start, Nrows, catalog[0].Naverage_disk, Naverage_disk_new)) {
     1124      fprintf (stderr, "failure writing Average table\n");
     1125      goto failure;
     1126    }
     1127    gfits_free_header (&header);
     1128    gfits_free_table (&ftable);
     1129  } else {
     1130    // even if we do not save the average table, we need to keep the header in sync
     1131    /* rewind file pointers and truncate (file is still open) */
     1132    if (fseeko (catalog[0].f, 0, SEEK_SET)) { perror ("fseeko: "); exit (1); }
    8341133
    8351134    /* write table PHU header - always write this out */
    … …  
    9911290
    9921291  /*** StarPar Table (optional, do not save if not loaded) ***/
    993     if ((catalog[0].catflags & DVO_LOAD_STARPAR) && catalog[0].starpar_catalog->f && catalog[0].starpar) {
     1292  if ((catalog[0].catflags & DVO_LOAD_STARPAR) && catalog[0].starpar_catalog->f && catalog[0].starpar) {
    9941293
    9951294    first  = 0;                    // first row in memory to write
    … …  
    10221321  }
    10231322
    1024   /*** GalShape Table (optional, do not save if not loaded) ***/
    1025   if ((catalog[0].catflags & DVO_LOAD_GALSHAPE) && catalog[0].galshape_catalog->f && catalog[0].galshape) {
     1323  /*** GalPhot Table (optional, do not save if not loaded) ***/
     1324  if ((catalog[0].catflags & DVO_LOAD_GALPHOT) && catalog[0].galphot_catalog->f && catalog[0].galphot) {
    10261325
    10271326    first  = 0;                    // first row in memory to write
    1028     start  = catalog[0].Ngalshape_off; // first disk row to write
    1029     Nrows  = catalog[0].Ngalshape - first;
    1030 
    1031     assert (Nrows >= 0);
    1032     assert (first >= 0);
    1033     assert (first <= catalog[0].Ngalshape);
    1034     assert (catalog[0].Ngalshape_disk >= catalog[0].Ngalshape_off);
    1035 
    1036     if (catalog[0].Ngalshape) {
     1327    start  = catalog[0].Ngalphot_off; // first disk row to write
     1328    Nrows  = catalog[0].Ngalphot - first;
     1329
     1330    assert (Nrows >= 0);
     1331    assert (first >= 0);
     1332    assert (first <= catalog[0].Ngalphot);
     1333    assert (catalog[0].Ngalphot_disk >= catalog[0].Ngalphot_off);
     1334
     1335    if (catalog[0].Ngalphot) {
    10371336      // if we are going to compress, we need to receive unswapped data --
    1038       int swapFromNative = !output_is_compressed (start, Nrows, Ngalshape_disk_new, catalog->catcompress);
     1337      int swapFromNative = !output_is_compressed (start, Nrows, Ngalphot_disk_new, catalog->catcompress);
    10391338
    10401339      // convert to external table format (note that the block above does not damage or free catalog.average)
    1041       if (!GalShapeToFtable (&ftable, &catalog[0].galshape[first], Nrows, catalog[0].catformat, swapFromNative)) {
     1340      if (!GalPhotToFtable (&ftable, &catalog[0].galphot[first], Nrows, catalog[0].catformat, swapFromNative)) {
    10421341        fprintf (stderr, "trouble converting format\n");
    10431342        goto failure;
    10441343      }
    10451344
    1046       // write out GalShape table
    1047       if (!dvo_catalog_save_subcat (catalog[0].galshape_catalog, &ftable, start, Nrows, catalog[0].Ngalshape_disk, Ngalshape_disk_new)) {
    1048         fprintf (stderr, "trouble writing GalShape table\n");
     1345      // write out GalPhot table
     1346      if (!dvo_catalog_save_subcat (catalog[0].galphot_catalog, &ftable, start, Nrows, catalog[0].Ngalphot_disk, Ngalphot_disk_new)) {
     1347        fprintf (stderr, "trouble writing GalPhot table\n");
    10491348        goto failure;
    10501349      }
    … …  
    10611360  return (TRUE);
    10621361
    1063 failure:
     1362 failure:
    10641363  /* free temp storage */
    10651364  gfits_free_header (&header);
    … …  
    10751374int dvo_catalog_save_split_complete (Catalog *catalog, char VERBOSE) {
    10761375
    1077   off_t Nitems;
    10781376  Header header;
    10791377  FTable ftable;
    10801378  SecFilt *primary, *secfilt;
    10811379  int Nsecfilt;
    1082   off_t Naverage_disk_new, Nmeasure_disk_new, Nmissing_disk_new, Nsecfilt_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new, Ngalshape_disk_new;
     1380  off_t Naverage_disk_new, Nmeasure_disk_new, Nmissing_disk_new, Nsecfilt_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new, Ngalphot_disk_new;
    10831381  off_t first, start, Nrows;
    10841382
    … …  
    11171415    goto failure;
    11181416  }
    1119   if (catalog[0].Ngalshape_off > 0) {
    1120     fprintf (stderr, "ERROR: only partial catalog (GalShape) was loaded\n");
     1417  if (catalog[0].Ngalphot_off > 0) {
     1418    fprintf (stderr, "ERROR: only partial catalog (GalPhot) was loaded\n");
    11211419    goto failure;
    11221420  }
    … …  
    11481446  Nlensobj_disk_new = catalog[0].Nlensobj;
    11491447  Nstarpar_disk_new = catalog[0].Nstarpar;
    1150   Ngalshape_disk_new = catalog[0].Ngalshape;
     1448  Ngalphot_disk_new = catalog[0].Ngalphot;
    11511449
    11521450  /* make sure header is consistent with data */
    … …  
    11581456  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
    11591457  gfits_modify (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  Nstarpar_disk_new);
    1160   gfits_modify (&catalog[0].header, "NGALSHAPE", OFF_T_FMT, 1, Ngalshape_disk_new);
     1458  gfits_modify (&catalog[0].header, "NGALPHOT", OFF_T_FMT, 1, Ngalphot_disk_new);
    11611459  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    11621460  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    … …  
    11911489    // even if we do not save the average table, we need to keep the header in sync
    11921490    /* rewind file pointers and truncate (file is still open) */
    1193     fseeko (catalog[0].f, 0, SEEK_SET);
     1491    if (fseeko (catalog[0].f, 0, SEEK_SET)) { perror ("fseeko: "); exit (1); }
    11941492
    11951493    /* write table PHU header - always write this out */
    … …  
    12021500
    12031501  /*** Measure Table ***/
    1204   if ((catalog[0].catflags & DVO_LOAD_MEASURE) && (catalog[0].measure != NULL)) {
    1205 
    1206     first  = 0;                    // first row in memory to write
    1207     start  = catalog[0].Nmeasure_off; // first disk row to write
     1502  if (catalog[0].measure != NULL) {
     1503
     1504    first  = catalog[0].Nmeasure_disk - catalog[0].Nmeasure_off;  // first row in memory to write
     1505    start  = catalog[0].Nmeasure_disk; // first disk row to write
    12081506    Nrows  = catalog[0].Nmeasure - first;
    12091507
    … …  
    12141512
    12151513    // convert to external table format
     1514    // XXX does catalog.measure have averef correctly set up?
    12161515    if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat, TRUE)) {
    12171516      fprintf (stderr, "trouble converting format\n");
    … …  
    12281527  }
    12291528
     1529  /* missing table CANNOT be written unsorted, thus it is always written
     1530     out in full */
     1531
    12301532  /*** Missing Table ***/
    1231   if ((catalog[0].catflags & DVO_LOAD_MISSING) && (catalog[0].missing != NULL)) {
     1533
     1534  if (catalog[0].missing != NULL) {
    12321535
    12331536    if (catalog[0].Nmissing_off != 0) {
    … …  
    12521555
    12531556  /*** Secfilt Table ***/
    1254   if ((catalog[0].catflags & DVO_LOAD_SECFILT) && (catalog[0].secfilt != NULL)) {
    1255 
    1256     first  = 0;                    // first row in memory to write
    1257     start  = catalog[0].Nsecfilt_off; // first disk row to write
    1258     Nitems = catalog[0].Naverage*Nsecfilt;
    1259     Nrows  = Nitems - first;
    1260 
    1261     assert (Nrows >= 0);
    1262     assert (first >= 0);
    1263     assert (first <= Nitems);
     1557  if (catalog[0].secfilt != NULL) {
     1558
     1559    first  = catalog[0].Nsecfilt_disk - catalog[0].Nsecfilt_off;  // first row in memory to write
     1560    start  = catalog[0].Nsecfilt_disk; // first disk row to write
     1561    Nrows  = catalog[0].Nsecfilt_mem - first;
     1562
     1563    assert (Nrows >= 0);
     1564    assert (first >= 0);
    12641565    assert (catalog[0].Nsecfilt_disk >= catalog[0].Nsecfilt_off);
    1265     // XXX check these for consistency...
    12661566
    12671567    // convert to external table format
    … …  
    12781578
    12791579  /*** Lensing Table ***/
    1280   if ((catalog[0].catflags & DVO_LOAD_LENSING) && (catalog[0].lensing != NULL)) {
    1281 
    1282     first  = 0;                    // first row in memory to write
    1283     start  = catalog[0].Nlensing_off; // first disk row to write
     1580  if (catalog[0].lensing != NULL) {
     1581
     1582    first  = catalog[0].Nlensing_disk - catalog[0].Nlensing_off;  // first row in memory to write
     1583    start  = catalog[0].Nlensing_disk; // first disk row to write
    12841584    Nrows  = catalog[0].Nlensing - first;
    12851585
    … …  
    12901590
    12911591    // convert to external table format
     1592    // XXX does catalog.lensing have averef correctly set up?
    12921593    if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat, TRUE)) {
    12931594      fprintf (stderr, "trouble converting format\n");
    … …  
    13051606
    13061607  /*** Lensobj Table ***/
    1307   if ((catalog[0].catflags & DVO_LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) {
    1308 
    1309     first  = 0;                    // first row in memory to write
    1310     start  = catalog[0].Nlensobj_off; // first disk row to write
     1608  if (catalog[0].lensobj != NULL) {
     1609
     1610    first  = catalog[0].Nlensobj_disk - catalog[0].Nlensobj_off;  // first row in memory to write
     1611    start  = catalog[0].Nlensobj_disk; // first disk row to write
    13111612    Nrows  = catalog[0].Nlensobj - first;
    13121613
    … …  
    13171618
    13181619    // convert to external table format
     1620    // XXX does catalog.lensobj have averef correctly set up?
    13191621    if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat, TRUE)) {
    13201622      fprintf (stderr, "trouble converting format\n");
    … …  
    13321634
    13331635  /*** StarPar Table ***/
    1334   if ((catalog[0].catflags & DVO_LOAD_STARPAR) && (catalog[0].starpar != NULL)) {
    1335 
    1336     first  = 0;                    // first row in memory to write
    1337     start  = catalog[0].Nstarpar_off; // first disk row to write
     1636  if (catalog[0].starpar != NULL) {
     1637
     1638    first  = catalog[0].Nstarpar_disk - catalog[0].Nstarpar_off;  // first row in memory to write
     1639    start  = catalog[0].Nstarpar_disk; // first disk row to write
    13381640    Nrows  = catalog[0].Nstarpar - first;
    13391641
    … …  
    13441646
    13451647    // convert to external table format
     1648    // XXX does catalog.starpar have averef correctly set up?
    13461649    if (!StarParToFtable (&ftable, &catalog[0].starpar[first], Nrows, catalog[0].catformat, TRUE)) {
    13471650      fprintf (stderr, "trouble converting format\n");
    … …  
    13581661  }
    13591662
    1360   /*** GalShape Table ***/
    1361   if ((catalog[0].catflags & DVO_LOAD_GALSHAPE) && (catalog[0].galshape != NULL)) {
    1362 
    1363     first  = 0;                    // first row in memory to write
    1364     start  = catalog[0].Ngalshape_off; // first disk row to write
    1365     Nrows  = catalog[0].Ngalshape - first;
    1366 
    1367     assert (Nrows >= 0);
    1368     assert (first >= 0);
    1369     assert (first <= catalog[0].Ngalshape);
    1370     assert (catalog[0].Ngalshape_disk >= catalog[0].Ngalshape_off);
     1663  /*** GalPhot Table ***/
     1664  if (catalog[0].galphot != NULL) {
     1665
     1666    first  = catalog[0].Ngalphot_disk - catalog[0].Ngalphot_off;  // first row in memory to write
     1667    start  = catalog[0].Ngalphot_disk; // first disk row to write
     1668    Nrows  = catalog[0].Ngalphot - first;
     1669
     1670    assert (Nrows >= 0);
     1671    assert (first >= 0);
     1672    assert (first <= catalog[0].Ngalphot);
     1673    assert (catalog[0].Ngalphot_disk >= catalog[0].Ngalphot_off);
    13711674
    13721675    // convert to external table format
    1373     if (!GalShapeToFtable (&ftable, &catalog[0].galshape[first], Nrows, catalog[0].catformat, TRUE)) {
     1676    // XXX does catalog.galphot have averef correctly set up?
     1677    if (!GalPhotToFtable (&ftable, &catalog[0].galphot[first], Nrows, catalog[0].catformat, TRUE)) {
    13741678      fprintf (stderr, "trouble converting format\n");
    13751679      goto failure;
    13761680    }
    13771681
    1378     // write out GalShape table
    1379     if (!dvo_catalog_save_subcat (catalog[0].galshape_catalog, &ftable, start, Nrows, catalog[0].Ngalshape_disk, Ngalshape_disk_new)) {
    1380       fprintf (stderr, "trouble writing GalShape table\n");
     1682    // write out GalPhot table
     1683    if (!dvo_catalog_save_subcat (catalog[0].galphot_catalog, &ftable, start, Nrows, catalog[0].Ngalphot_disk, Ngalphot_disk_new)) {
     1684      fprintf (stderr, "trouble writing GalPhot table\n");
    13811685      goto failure;
    13821686    }
    … …  
    13901694    free (secfilt);
    13911695  }
     1696
    13921697  return (TRUE);
    13931698
    1394 failure:
    1395   /* free temp storage */
    1396   gfits_free_header (&header);
    1397   gfits_free_table (&ftable);
    1398   if (primary != NULL) {
    1399     free (primary);
    1400     free (secfilt);
    1401   }
    1402   return (FALSE);
    1403 }
    1404 
    1405 /* update_catalog_split only writes new lines to file. */
    1406 int dvo_catalog_update_split (Catalog *catalog, char VERBOSE) {
    1407 
    1408   Header header;
    1409   FTable ftable;
    1410   SecFilt *primary, *secfilt;
    1411   int Nsecfilt;
    1412   off_t Naverage_disk_new, Nmeasure_disk_new, Nmissing_disk_new, Nsecfilt_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new, Ngalshape_disk_new;
    1413   off_t first, start, Nrows;
    1414 
    1415   ftable.header = &header;
    1416   ftable.buffer = NULL;
    1417   header.buffer = NULL;
    1418 
    1419   // skip empty catalogs: it is illegal to have Measures without corresponding Averages
    1420   Naverage_disk_new = MAX (catalog[0].Naverage_disk, catalog[0].Naverage + catalog[0].Naverage_off);
    1421   if (Naverage_disk_new == 0) {
    1422     if (VERBOSE) fprintf (stderr, "no stars in catalog, skipping\n");
    1423     return (TRUE);
    1424   }
    1425 
    1426   // for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary
    1427   switch (catalog[0].catformat) {
    1428     case DVO_FORMAT_ELIXIR: // special case for ELIXIR
    1429     case DVO_FORMAT_LONEOS: // special case for LONEOS
    1430       dvo_catalog_secfilt_to_primary (catalog, &primary, &secfilt, &Nsecfilt);
    1431       break;
    1432     default:
    1433       primary = NULL;
    1434       secfilt = catalog[0].secfilt;
    1435       Nsecfilt = catalog[0].Nsecfilt;
    1436       break;
    1437   }
    1438 
    1439   Nmeasure_disk_new = MAX (catalog[0].Nmeasure_disk, catalog[0].Nmeasure + catalog[0].Nmeasure_off);
    1440   Nmissing_disk_new = MAX (catalog[0].Nmissing_disk, catalog[0].Nmissing + catalog[0].Nmissing_off);
    1441   Nsecfilt_disk_new = MAX (catalog[0].Nsecfilt_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecfilt_off);
    1442   Nlensing_disk_new = MAX (catalog[0].Nlensing_disk, catalog[0].Nlensing + catalog[0].Nlensing_off);
    1443   Nlensobj_disk_new = MAX (catalog[0].Nlensobj_disk, catalog[0].Nlensobj + catalog[0].Nlensobj_off);
    1444   Nstarpar_disk_new = MAX (catalog[0].Nstarpar_disk, catalog[0].Nstarpar + catalog[0].Nstarpar_off);
    1445   Ngalshape_disk_new = MAX (catalog[0].Ngalshape_disk, catalog[0].Ngalshape + catalog[0].Ngalshape_off);
    1446 
    1447   /* make sure header is consistent with data */
    1448   gfits_modify (&catalog[0].header, "NSTARS",   OFF_T_FMT, 1,  Naverage_disk_new);
    1449   gfits_modify (&catalog[0].header, "NMEAS",    OFF_T_FMT, 1,  Nmeasure_disk_new);
    1450   gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  Nmissing_disk_new);
    1451   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    1452   gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  Nlensing_disk_new);
    1453   gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
    1454   gfits_modify (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  Nstarpar_disk_new);
    1455   gfits_modify (&catalog[0].header, "NGALSHAPE", OFF_T_FMT, 1,  Ngalshape_disk_new);
    1456 
    1457   gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    1458   gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    1459 
    1460   /* in split mode, we can save only part of the data */
    1461 
    1462   /*** Average Table ***/
    1463   if (catalog[0].average != NULL) {
    1464 
    1465     first  = catalog[0].Naverage_disk - catalog[0].Naverage_off; // first row to write (memory)
    1466     start  = catalog[0].Naverage_disk;                        // first row to write (disk)
    1467     Nrows  = catalog[0].Naverage - first;
    1468 
    1469     assert (Nrows >= 0);
    1470     assert (first >= 0);
    1471     assert (first <= catalog[0].Naverage);
    1472     assert (catalog[0].Naverage_disk >= catalog[0].Naverage_off);
    1473 
    1474     /* convert internal to external format */
    1475     if (!AverageToFtable (&ftable, &catalog[0].average[first], Nrows, catalog[0].catformat, primary, TRUE)) {
    1476       fprintf (stderr, "trouble converting format\n");
    1477       goto failure;
    1478     }
    1479 
    1480     if (!dvo_catalog_save_subcat (catalog, &ftable, start, Nrows, catalog[0].Naverage_disk, Naverage_disk_new)) {
    1481       fprintf (stderr, "failure writing Average table\n");
    1482       goto failure;
    1483     }
    1484     gfits_free_header (&header);
    1485     gfits_free_table (&ftable);
    1486   } else {
    1487     // even if we do not save the average table, we need to keep the header in sync
    1488     /* rewind file pointers and truncate (file is still open) */
    1489     fseeko (catalog[0].f, 0, SEEK_SET);
    1490 
    1491     /* write table PHU header - always write this out */
    1492     /* XXX EAM : check if disk file size has changed */
    1493     if (!gfits_fwrite_header  (catalog[0].f, &catalog[0].header)) {
    1494       fprintf (stderr, "can't write primary header");
    1495       goto failure;
    1496     }
    1497   }
    1498 
    1499   /*** Measure Table ***/
    1500   if (catalog[0].measure != NULL) {
    1501 
    1502     first  = catalog[0].Nmeasure_disk - catalog[0].Nmeasure_off;  // first row in memory to write
    1503     start  = catalog[0].Nmeasure_disk; // first disk row to write
    1504     Nrows  = catalog[0].Nmeasure - first;
    1505 
    1506     assert (Nrows >= 0);
    1507     assert (first >= 0);
    1508     assert (first <= catalog[0].Nmeasure);
    1509     assert (catalog[0].Nmeasure_disk >= catalog[0].Nmeasure_off);
    1510 
    1511     // convert to external table format
    1512     // XXX does catalog.measure have averef correctly set up?
    1513     if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat, TRUE)) {
    1514       fprintf (stderr, "trouble converting format\n");
    1515       goto failure;
    1516     }
    1517 
    1518     // write out Measure table
    1519     if (!dvo_catalog_save_subcat (catalog[0].measure_catalog, &ftable, start, Nrows, catalog[0].Nmeasure_disk, Nmeasure_disk_new)) {
    1520       fprintf (stderr, "trouble writing Measure table\n");
    1521       goto failure;
    1522     }
    1523     gfits_free_header (&header);
    1524     gfits_free_table (&ftable);
    1525   }
    1526 
    1527   /* missing table CANNOT be written unsorted, thus it is always written
    1528      out in full */
    1529 
    1530   /*** Missing Table ***/
    1531 
    1532   if (catalog[0].missing != NULL) {
    1533 
    1534     if (catalog[0].Nmissing_off != 0) {
    1535       fprintf (stderr, "inconsistency: Missing table cannot be written in segments\n");
    1536       goto failure;
    1537     }
    1538 
    1539     // convert to external table format
    1540     if (!gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing, TRUE)) {
    1541       fprintf (stderr, "trouble converting format\n");
    1542       goto failure;
    1543     }
    1544 
    1545     // write out Missing table (must write out entire table)
    1546     if (!dvo_catalog_save_subcat (catalog[0].missing_catalog, &ftable, 0, catalog[0].Nmissing, catalog[0].Nmissing, catalog[0].Nmissing)) {
    1547       fprintf (stderr, "trouble writing Missing Table\n");
    1548       goto failure;
    1549     }
    1550     gfits_free_header (&header);
    1551     gfits_free_table (&ftable);
    1552   }
    1553 
    1554   /*** Secfilt Table ***/
    1555   if (catalog[0].secfilt != NULL) {
    1556 
    1557     first  = catalog[0].Nsecfilt_disk - catalog[0].Nsecfilt_off;  // first row in memory to write
    1558     start  = catalog[0].Nsecfilt_disk; // first disk row to write
    1559     Nrows  = catalog[0].Nsecfilt_mem - first;
    1560 
    1561     assert (Nrows >= 0);
    1562     assert (first >= 0);
    1563     assert (catalog[0].Nsecfilt_disk >= catalog[0].Nsecfilt_off);
    1564 
    1565     // convert to external table format
    1566     SecFiltToFtable (&ftable, &secfilt[first], Nrows, catalog[0].catformat, TRUE);
    1567 
    1568     // write out SecFilt table
    1569     if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecfilt_disk, Nsecfilt_disk_new)) {
    1570       fprintf (stderr, "failure writing SecFilt table\n");
    1571       goto failure;
    1572     }
    1573     gfits_free_header (&header);
    1574     gfits_free_table (&ftable);
    1575   }
    1576 
    1577   /*** Lensing Table ***/
    1578   if (catalog[0].lensing != NULL) {
    1579 
    1580     first  = catalog[0].Nlensing_disk - catalog[0].Nlensing_off;  // first row in memory to write
    1581     start  = catalog[0].Nlensing_disk; // first disk row to write
    1582     Nrows  = catalog[0].Nlensing - first;
    1583 
    1584     assert (Nrows >= 0);
    1585     assert (first >= 0);
    1586     assert (first <= catalog[0].Nlensing);
    1587     assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off);
    1588 
    1589     // convert to external table format
    1590     // XXX does catalog.lensing have averef correctly set up?
    1591     if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat, TRUE)) {
    1592       fprintf (stderr, "trouble converting format\n");
    1593       goto failure;
    1594     }
    1595 
    1596     // write out Lensing table
    1597     if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) {
    1598       fprintf (stderr, "trouble writing Lensing table\n");
    1599       goto failure;
    1600     }
    1601     gfits_free_header (&header);
    1602     gfits_free_table (&ftable);
    1603   }
    1604 
    1605   /*** Lensobj Table ***/
    1606   if (catalog[0].lensobj != NULL) {
    1607 
    1608     first  = catalog[0].Nlensobj_disk - catalog[0].Nlensobj_off;  // first row in memory to write
    1609     start  = catalog[0].Nlensobj_disk; // first disk row to write
    1610     Nrows  = catalog[0].Nlensobj - first;
    1611 
    1612     assert (Nrows >= 0);
    1613     assert (first >= 0);
    1614     assert (first <= catalog[0].Nlensobj);
    1615     assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off);
    1616 
    1617     // convert to external table format
    1618     // XXX does catalog.lensobj have averef correctly set up?
    1619     if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat, TRUE)) {
    1620       fprintf (stderr, "trouble converting format\n");
    1621       goto failure;
    1622     }
    1623 
    1624     // write out Lensobj table
    1625     if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) {
    1626       fprintf (stderr, "trouble writing Lensobj table\n");
    1627       goto failure;
    1628     }
    1629     gfits_free_header (&header);
    1630     gfits_free_table (&ftable);
    1631   }
    1632 
    1633   /*** StarPar Table ***/
    1634   if (catalog[0].starpar != NULL) {
    1635 
    1636     first  = catalog[0].Nstarpar_disk - catalog[0].Nstarpar_off;  // first row in memory to write
    1637     start  = catalog[0].Nstarpar_disk; // first disk row to write
    1638     Nrows  = catalog[0].Nstarpar - first;
    1639 
    1640     assert (Nrows >= 0);
    1641     assert (first >= 0);
    1642     assert (first <= catalog[0].Nstarpar);
    1643     assert (catalog[0].Nstarpar_disk >= catalog[0].Nstarpar_off);
    1644 
    1645     // convert to external table format
    1646     // XXX does catalog.starpar have averef correctly set up?
    1647     if (!StarParToFtable (&ftable, &catalog[0].starpar[first], Nrows, catalog[0].catformat, TRUE)) {
    1648       fprintf (stderr, "trouble converting format\n");
    1649       goto failure;
    1650     }
    1651 
    1652     // write out StarPar table
    1653     if (!dvo_catalog_save_subcat (catalog[0].starpar_catalog, &ftable, start, Nrows, catalog[0].Nstarpar_disk, Nstarpar_disk_new)) {
    1654       fprintf (stderr, "trouble writing StarPar table\n");
    1655       goto failure;
    1656     }
    1657     gfits_free_header (&header);
    1658     gfits_free_table (&ftable);
    1659   }
    1660 
    1661   /*** GalShape Table ***/
    1662   if (catalog[0].galshape != NULL) {
    1663 
    1664     first  = catalog[0].Ngalshape_disk - catalog[0].Ngalshape_off;  // first row in memory to write
    1665     start  = catalog[0].Ngalshape_disk; // first disk row to write
    1666     Nrows  = catalog[0].Ngalshape - first;
    1667 
    1668     assert (Nrows >= 0);
    1669     assert (first >= 0);
    1670     assert (first <= catalog[0].Ngalshape);
    1671     assert (catalog[0].Ngalshape_disk >= catalog[0].Ngalshape_off);
    1672 
    1673     // convert to external table format
    1674     // XXX does catalog.galshape have averef correctly set up?
    1675     if (!GalShapeToFtable (&ftable, &catalog[0].galshape[first], Nrows, catalog[0].catformat, TRUE)) {
    1676       fprintf (stderr, "trouble converting format\n");
    1677       goto failure;
    1678     }
    1679 
    1680     // write out GalShape table
    1681     if (!dvo_catalog_save_subcat (catalog[0].galshape_catalog, &ftable, start, Nrows, catalog[0].Ngalshape_disk, Ngalshape_disk_new)) {
    1682       fprintf (stderr, "trouble writing GalShape table\n");
    1683       goto failure;
    1684     }
    1685     gfits_free_header (&header);
    1686     gfits_free_table (&ftable);
    1687   }
    1688 
    1689   /* free temp storage */
    1690   if (primary != NULL) {
    1691     free (primary);
    1692     free (secfilt);
    1693   }
    1694 
    1695   return (TRUE);
    1696 
    1697 failure:
     1699 failure:
    16981700  /* free temp storage */
    16991701  if (primary != NULL) {
    … …  
    17191721
    17201722
    1721     // * convert to an ftable
    1722     // * optionally write the PHU header/matrix
    1723     // * advance to the start of the output data block:
    1724     // ** Nx * catalog[0].Nmeasure_off
    1725     // * write out the ftable data block
    1726     // * if Nmeasure_off + Nmeasure >= Nmeasure_disk, update padding
    1727     // ** start = Nmeasure_off
    1728     // ** Nrows = Nmeasure
    1729 
     1723// * convert to an ftable
     1724// * optionally write the PHU header/matrix
     1725// * advance to the start of the output data block:
     1726// ** Nx * catalog[0].Nmeasure_off
     1727// * write out the ftable data block
     1728// * if Nmeasure_off + Nmeasure >= Nmeasure_disk, update padding
     1729// ** start = Nmeasure_off
     1730// ** Nrows = Nmeasure
     1731

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_convert.c

    r38354 r38419  
    853853}
    854854
    855 /*** GalShape / FTable conversion functions ***/
    856 
    857 GalShape *FtableToGalShape (FTable *ftable, Average *average, off_t *Ngalshape, DVOCatFormat *format, char nativeBytes) {
    858 
    859   GalShape *galshape;
     855/*** GalPhot / FTable conversion functions ***/
     856
     857GalPhot *FtableToGalPhot (FTable *ftable, Average *average, off_t *Ngalphot, DVOCatFormat *format, char nativeBytes) {
     858
     859  GalPhot *galphot;
    860860  char extname[80];
    861861
    862862  /* convert to the internal format */
    863863  if (!gfits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
    864     fprintf (stderr, "EXTNAME missing for galshape table\n");
     864    fprintf (stderr, "EXTNAME missing for galphot table\n");
    865865    return (FALSE);
    866866  }
    … …  
    868868# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
    869869  if (!strcmp (extname, NAME)) {                                        \
    870     fprintf (stderr, "ERROR: format %s not defined for galshape, skipping\n", NAME); \
    871     *Ngalshape = 0; \
     870    fprintf (stderr, "ERROR: format %s not defined for galphot, skipping\n", NAME); \
     871    *Ngalphot = 0; \
    872872    return NULL; \
    873873  }
    … …  
    875875# define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
    876876  if (!strcmp (extname, NAME)) {                                        \
    877     GalShape_##TYPE *tmpGalShape;                                               \
    878     tmpGalShape = gfits_table_get_GalShape_##TYPE (ftable, Ngalshape, NULL, &nativeBytes); \
    879     if (!tmpGalShape) {                                                 \
    880       fprintf (stderr, "ERROR: failed to read galshapes\n");            \
     877    GalPhot_##TYPE *tmpGalPhot;                                         \
     878    tmpGalPhot = gfits_table_get_GalPhot_##TYPE (ftable, Ngalphot, NULL, &nativeBytes); \
     879    if (!tmpGalPhot) {                                                  \
     880      fprintf (stderr, "ERROR: failed to read galphots\n");             \
    881881      exit (2);                                                         \
    882882    }                                                                   \
    883     galshape = GalShape_##TYPE##_ToInternal (tmpGalShape, *Ngalshape); \
    884     free (tmpGalShape);                                                 \
     883    galphot = GalPhot_##TYPE##_ToInternal (tmpGalPhot, *Ngalphot); \
     884    free (tmpGalPhot);                                                  \
    885885    *format = DVO_FORMAT_##FORMAT;                                      \
    886     return (galshape); }
    887 
    888   if (!strcmp (extname, "DVO_GALSHAPE")) {
    889     galshape = gfits_table_get_GalShape (ftable, Ngalshape, NULL, &nativeBytes);
    890     if (!galshape) {
    891       fprintf (stderr, "ERROR: failed to read galshapes\n");
     886    return (galphot); }
     887
     888  if (!strcmp (extname, "DVO_GALPHOT")) {
     889    galphot = gfits_table_get_GalPhot (ftable, Ngalphot, NULL, &nativeBytes);
     890    if (!galphot) {
     891      fprintf (stderr, "ERROR: failed to read galphots\n");
    892892      exit (2);
    893893    }
    894894    *format = DVO_FORMAT_INTERNAL;
    895     return (galshape);
    896   }
    897 
    898   SKIPPING_FORMAT ("DVO_GALSHAPE_PS1_REF",         PS1_REF,         PS1_REF);
    899   SKIPPING_FORMAT ("DVO_GALSHAPE_ELIXIR",         ELIXIR,          Elixir);
    900   SKIPPING_FORMAT ("DVO_GALSHAPE_LONEOS",         LONEOS,          Loneos);
    901   SKIPPING_FORMAT ("DVO_GALSHAPE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
    902   SKIPPING_FORMAT ("DVO_GALSHAPE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
    903   SKIPPING_FORMAT ("DVO_GALSHAPE_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
    904   SKIPPING_FORMAT ("DVO_GALSHAPE_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
    905   SKIPPING_FORMAT ("DVO_GALSHAPE_PS1_V1",          PS1_V1,          PS1_V1);
    906   SKIPPING_FORMAT ("DVO_GALSHAPE_PS1_V2",          PS1_V2,          PS1_V2);
    907   SKIPPING_FORMAT ("DVO_GALSHAPE_PS1_V3",          PS1_V3,          PS1_V3);
    908   SKIPPING_FORMAT ("DVO_GALSHAPE_PS1_V4",          PS1_V4,          PS1_V4);
    909   CONVERT_FORMAT  ("DVO_GALSHAPE_PS1_V5",          PS1_V5,          PS1_V5);
    910   SKIPPING_FORMAT ("DVO_GALSHAPE_PS1_SIM",         PS1_SIM,         PS1_SIM);
     895    return (galphot);
     896  }
     897
     898  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_REF",         PS1_REF,         PS1_REF);
     899  SKIPPING_FORMAT ("DVO_GALPHOT_ELIXIR",          ELIXIR,          Elixir);
     900  SKIPPING_FORMAT ("DVO_GALPHOT_LONEOS",          LONEOS,          Loneos);
     901  SKIPPING_FORMAT ("DVO_GALPHOT_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
     902  SKIPPING_FORMAT ("DVO_GALPHOT_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
     903  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
     904  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
     905  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_V1",          PS1_V1,          PS1_V1);
     906  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_V2",          PS1_V2,          PS1_V2);
     907  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_V3",          PS1_V3,          PS1_V3);
     908  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_V4",          PS1_V4,          PS1_V4);
     909  CONVERT_FORMAT  ("DVO_GALPHOT_PS1_V5",          PS1_V5,          PS1_V5);
     910  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_SIM",         PS1_SIM,         PS1_SIM);
    911911# undef CONVERT_FORMAT
    912912# undef SKIPPING_FORMAT
    … …  
    914914  fprintf (stderr, "table format unknown: %s\n", extname);
    915915
    916   *Ngalshape = 0;
     916  *Ngalphot = 0;
    917917  return (NULL);
    918918}
    919919
    920 // GalShapeToFtable needs the Average since old formats stored galshape.dR,dD only
    921 int GalShapeToFtable (FTable *ftable, GalShape *galshape, off_t Ngalshape, DVOCatFormat format, int swapFromNative) {
     920// GalPhotToFtable needs the Average since old formats stored galphot.dR,dD only
     921int GalPhotToFtable (FTable *ftable, GalPhot *galphot, off_t Ngalphot, DVOCatFormat format, int swapFromNative) {
    922922
    923923# define FORMAT_CASE(FORMAT, TYPE)              \
    924924    case DVO_FORMAT_##FORMAT: { \
    925       GalShape_##TYPE *tmpGalShape; \
    926       tmpGalShape = GalShapeInternalTo_##TYPE (galshape, Ngalshape); \
    927         gfits_table_set_GalShape_##TYPE (ftable, tmpGalShape, Ngalshape, swapFromNative); \
    928       free (tmpGalShape); \
     925      GalPhot_##TYPE *tmpGalPhot; \
     926      tmpGalPhot = GalPhotInternalTo_##TYPE (galphot, Ngalphot); \
     927        gfits_table_set_GalPhot_##TYPE (ftable, tmpGalPhot, Ngalphot, swapFromNative); \
     928      free (tmpGalPhot); \
    929929      break; }
    930930
    … …  
    932932  switch (format) {
    933933    case DVO_FORMAT_INTERNAL: {
    934       gfits_table_set_GalShape (ftable, galshape, Ngalshape, swapFromNative);
     934      gfits_table_set_GalPhot (ftable, galphot, Ngalphot, swapFromNative);
    935935      break; }
    936936
    … …  
    950950
    951951    default:
    952       fprintf (stderr, "table format unknown (galshape)\n");
     952      fprintf (stderr, "table format unknown (galphot)\n");
    953953      return (FALSE);
    954954  }

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_convert_PS1_DEV_2.c

    r38331 r38419  
    118118    out[i].Nmeasure      = in[i].Nmeasure;     
    119119    out[i].Nmissing      = in[i].Nmissing;     
    120     out[i].Ngalshape     = in[i].Nextend;     
     120    out[i].Ngalphot     = in[i].Nextend;     
    121121    out[i].measureOffset = in[i].measureOffset;
    122122    out[i].missingOffset = in[i].missingOffset;
    … …  
    152152    out[i].Nmeasure      = in[i].Nmeasure;     
    153153    out[i].Nmissing      = in[i].Nmissing;     
    154     out[i].Nextend       = in[i].Ngalshape;     
     154    out[i].Nextend       = in[i].Ngalphot;     
    155155    out[i].measureOffset = in[i].measureOffset;
    156156    out[i].missingOffset = in[i].missingOffset;

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_convert_PS1_V1.c

    r38331 r38419  
    138138    out[i].Nmeasure      = in[i].Nmeasure;     
    139139    out[i].Nmissing      = in[i].Nmissing;     
    140     out[i].Ngalshape     = in[i].Ngalshape;     
     140    out[i].Ngalphot     = in[i].Ngalphot;     
    141141    out[i].measureOffset = in[i].measureOffset;
    142142    out[i].missingOffset = in[i].missingOffset;
    … …  
    173173    out[i].Nmeasure      = in[i].Nmeasure;     
    174174    out[i].Nmissing      = in[i].Nmissing;     
    175     out[i].Ngalshape     = in[i].Ngalshape;     
     175    out[i].Ngalphot     = in[i].Ngalphot;     
    176176    out[i].measureOffset = in[i].measureOffset;
    177177    out[i].missingOffset = in[i].missingOffset;

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_convert_PS1_V2.c

    r38331 r38419  
    143143    out[i].Nmeasure      = in[i].Nmeasure;     
    144144    out[i].Nmissing      = in[i].Nmissing;     
    145     out[i].Ngalshape     = in[i].Ngalshape;     
     145    out[i].Ngalphot     = in[i].Ngalphot;     
    146146    out[i].measureOffset = in[i].measureOffset;
    147147    out[i].missingOffset = in[i].missingOffset;
    … …  
    182182    out[i].Nmeasure      = in[i].Nmeasure;     
    183183    out[i].Nmissing      = in[i].Nmissing;     
    184     out[i].Ngalshape     = in[i].Ngalshape;     
     184    out[i].Ngalphot     = in[i].Ngalphot;     
    185185    out[i].measureOffset = in[i].measureOffset;
    186186    out[i].missingOffset = in[i].missingOffset;

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_convert_PS1_V3.c

    r38331 r38419  
    143143    out[i].Nmeasure      = in[i].Nmeasure;     
    144144    out[i].Nmissing      = in[i].Nmissing;     
    145     out[i].Ngalshape     = in[i].Ngalshape;     
     145    out[i].Ngalphot     = in[i].Ngalphot;     
    146146    out[i].measureOffset = in[i].measureOffset;
    147147    out[i].missingOffset = in[i].missingOffset;
    … …  
    184184    out[i].Nmeasure      = in[i].Nmeasure;     
    185185    out[i].Nmissing      = in[i].Nmissing;     
    186     out[i].Ngalshape     = in[i].Ngalshape;     
     186    out[i].Ngalphot     = in[i].Ngalphot;     
    187187    out[i].measureOffset = in[i].measureOffset;
    188188    out[i].missingOffset = in[i].missingOffset;

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_convert_PS1_V4.c

    r38331 r38419  
    164164    out[i].Nmeasure      = in[i].Nmeasure;     
    165165    out[i].Nmissing      = in[i].Nmissing;     
    166     out[i].Ngalshape     = in[i].Ngalshape;     
     166    out[i].Ngalphot     = in[i].Ngalphot;     
    167167    out[i].measureOffset = in[i].measureOffset;
    168168    out[i].missingOffset = in[i].missingOffset;
    … …  
    208208    out[i].Nmeasure      = in[i].Nmeasure;     
    209209    out[i].Nmissing      = in[i].Nmissing;     
    210     out[i].Ngalshape     = in[i].Ngalshape;     
     210    out[i].Ngalphot     = in[i].Ngalphot;     
    211211    out[i].measureOffset = in[i].measureOffset;
    212212    out[i].missingOffset = in[i].missingOffset;
    … …  
    690690    out[i].Nmeasure      = in[i].Nmeasure;     
    691691    out[i].Nmissing      = in[i].Nmissing;     
    692     out[i].Ngalshape     = in[i].Ngalshape;     
     692    out[i].Ngalphot     = in[i].Ngalphot;     
    693693    out[i].measureOffset = in[i].measureOffset;
    694694    out[i].missingOffset = in[i].missingOffset;

  • branches/eam_branches/ohana.20150429/src/libdvo/src/dvo_convert_PS1_V5.c

    r38219 r38419  
    196196    out[i].Nlensobj      = in[i].Nlensobj;     
    197197    out[i].Nstarpar      = in[i].Nstarpar;     
    198     out[i].Ngalshape     = in[i].Ngalshape;     
     198    out[i].Ngalphot     = in[i].Ngalphot;     
    199199
    200200    out[i].measureOffset = in[i].measureOffset;
    … …  
    203203    out[i].lensobjOffset = in[i].lensobjOffset;
    204204    out[i].starparOffset = in[i].starparOffset;
    205     out[i].galshapeOffset  = in[i].galshapeOffset;
     205    out[i].galphotOffset  = in[i].galphotOffset;
    206206
    207207    out[i].refColorBlue  = in[i].refColorBlue;
    … …  
    264264    out[i].Nlensobj       = in[i].Nlensobj;     
    265265    out[i].Nstarpar       = in[i].Nstarpar;     
    266     out[i].Ngalshape        = in[i].Ngalshape;     
     266    out[i].Ngalphot        = in[i].Ngalphot;     
    267267                         
    268268    out[i].measureOffset  = in[i].measureOffset;
    … …  
    271271    out[i].lensobjOffset  = in[i].lensobjOffset;
    272272    out[i].starparOffset  = in[i].starparOffset;
    273     out[i].galshapeOffset   = in[i].galshapeOffset;
     273    out[i].galphotOffset   = in[i].galphotOffset;
    274274                         
    275275    out[i].refColorBlue   = in[i].refColorBlue;
    … …  
    979979}
    980980
    981 GalShape *GalShape_PS1_V5_ToInternal (GalShape_PS1_V5 *in, off_t Nvalues) {
    982 
    983   off_t i;
    984   GalShape *out;
    985 
    986   ALLOCATE_ZERO (out, GalShape, Nvalues);
    987 
    988   for (i = 0; i < Nvalues; i++) {
    989     dvo_galshape_init (&out[i]);
     981GalPhot *GalPhot_PS1_V5_ToInternal (GalPhot_PS1_V5 *in, off_t Nvalues) {
     982
     983  off_t i;
     984  GalPhot *out;
     985
     986  ALLOCATE_ZERO (out, GalPhot, Nvalues);
     987
     988  for (i = 0; i < Nvalues; i++) {
     989    dvo_galphot_init (&out[i]);
    990990
    991991    out[i].Xfit          = in[i].Xfit;
    … …  
    10121012}
    10131013
    1014 GalShape_PS1_V5 *GalShapeInternalTo_PS1_V5 (GalShape *in, off_t Nvalues) {
    1015 
    1016   off_t i;
    1017   GalShape_PS1_V5 *out;
    1018 
    1019   ALLOCATE_ZERO (out, GalShape_PS1_V5, Nvalues);
     1014GalPhot_PS1_V5 *GalPhotInternalTo_PS1_V5 (GalPhot *in, off_t Nvalues) {
     1015
     1016  off_t i;
     1017  GalPhot_PS1_V5 *out;
     1018
     1019  ALLOCATE_ZERO (out, GalPhot_PS1_V5, Nvalues);
    10201020
    10211021  for (i = 0; i < Nvalues; i++) {
    … …  
    12981298    out[i].Nlensing       = in[i].Nlensing;     
    12991299    out[i].Nlensobj       = in[i].Nlensobj;     
    1300     out[i].Ngalshape        = in[i].Ngalshape;     
     1300    out[i].Ngalphot        = in[i].Ngalphot;     
    13011301                         
    13021302    out[i].measureOffset  = in[i].measureOffset;
    … …  
    13051305    out[i].lensobjOffset  = in[i].lensobjOffset;
    13061306    out[i].starparOffset  = in[i].starparOffset;
    1307     out[i].galshapeOffset   = in[i].galshapeOffset;
     1307    out[i].galphotOffset   = in[i].galphotOffset;
    13081308                         
    13091309    out[i].refColorBlue   = in[i].refColorBlue;
    … …  
    13661366    SWAP_BYTE (110); // NLENSING
    13671367    SWAP_BYTE (112); // NLENSOBJ
    1368     SWAP_BYTE (114); // NGALSHAPE
     1368    SWAP_BYTE (114); // NGALPHOT
    13691369    SWAP_WORD (116); // OFF_MEASURE
    13701370    SWAP_WORD (120); // OFF_MISSING
    13711371    SWAP_WORD (124); // OFF_LENSING
    13721372    SWAP_WORD (128); // OFF_LENSOBJ
    1373     SWAP_WORD (132); // OFF_GALSHAPE
     1373    SWAP_WORD (132); // OFF_GALPHOT
    13741374    SWAP_WORD (136); // OFF_PARAMS
    13751375    SWAP_WORD (140); // REF_COLOR_BLUE

  • branches/eam_branches/ohana.20150429/src/libdvo/src/flatcorr_io.c

    r38345 r38419  
    9393    for (j = 0; j < flatcorrTable->image[i].Nx; j++) {
    9494      ALLOCATE (flatcorrTable->offset[i][j], float, flatcorrTable->image[i].Ny);
    95       memset (flatcorrTable->offset[i][j], 0.0, flatcorrTable->image[i].Ny*sizeof(float));
     95      memset (flatcorrTable->offset[i][j], 0, flatcorrTable->image[i].Ny*sizeof(float));
    9696    }
    9797  }
Note: See TracChangeset for help on using the changeset viewer.