IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 37035


Ignore:
Timestamp:
Jul 17, 2014, 10:10:16 AM (12 years ago)
Author:
eugene
Message:

major re-work of dvo photcode-based-field parsing; adding PS1_V5 and lensing parameters, adding reference colors blue & red

Location:
trunk/Ohana/src/libdvo
Files:
45 edited
9 copied

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/libdvo/Makefile

    r36630 r37035  
    3636$(DESTINC)/ps1_v3_defs.h \
    3737$(DESTINC)/ps1_v4_defs.h \
     38$(DESTINC)/ps1_v5_defs.h \
    3839$(DESTINC)/ps1_ref_defs.h \
    39 $(DESTINC)/cmf-ps1-dv3.h
     40$(DESTINC)/cmf-ps1-dv3.h \
     41$(DESTINC)/cmf-ps1-v5.h \
     42$(DESTINC)/cmf-ps1-sv3.h \
     43$(DESTINC)/cmf-ps1-v5-lensing.h
    4044
    4145INCS = $(DEFS) $(DESTINC)/dvo.h $(DESTINC)/autocode.h $(DESTINC)/dvo_util.h $(DESTINC)/dvodb.h $(DESTINC)/libdvo_astro.h $(DESTINC)/convert.h $(DESTINC)/get_graphdata.h
    … …  
    7680$(SRC)/dvo_convert_PS1_V3.$(ARCH).o \
    7781$(SRC)/dvo_convert_PS1_V4.$(ARCH).o \
     82$(SRC)/dvo_convert_PS1_V5.$(ARCH).o \
    7883$(SRC)/dvo_convert_PS1_REF.$(ARCH).o \
    7984$(SRC)/flatcorr_io.$(ARCH).o    \
    … …  
    8691$(SRC)/cmf-ps1-sv1-alt.$(ARCH).o \
    8792$(SRC)/cmf-ps1-dv3.$(ARCH).o \
     93$(SRC)/cmf-ps1-sv3.$(ARCH).o \
     94$(SRC)/cmf-ps1-v5.$(ARCH).o \
     95$(SRC)/cmf-ps1-v5-lensing.$(ARCH).o \
    8896$(SRC)/dvo_util.$(ARCH).o \
    8997$(SRC)/dbBooleanCond.$(ARCH).o          \

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

    r36833 r37035  
    2828  DVO_FORMAT_PS1_V3,
    2929  DVO_FORMAT_PS1_V4,
     30  DVO_FORMAT_PS1_V5,
    3031} DVOTableFormat;
    3132
    … …  
    7879
    7980/* catalog values to be loaded */
    80 # define LOAD_NONE      0x00
    81 # define LOAD_AVES      0x01
    82 # define LOAD_MEAS      0x02
    83 # define LOAD_MISS      0x04
    84 # define LOAD_SECF      0x08
    85 # define SKIP_AVES      0x10
    86 # define SKIP_MEAS      0x20
    87 # define SKIP_MISS      0x40
    88 # define SKIP_SECF      0x80
    89 
    90 // # define LOAD_MEAS_META 0x100 -- is this used??
     81# define LOAD_NONE      0x000
     82# define LOAD_AVES      0x001
     83# define LOAD_MEAS      0x002
     84# define LOAD_MISS      0x004
     85# define LOAD_SECF      0x008
     86# define SKIP_AVES      0x010
     87# define SKIP_MEAS      0x020
     88# define SKIP_MISS      0x040
     89# define SKIP_SECF      0x080
     90# define LOAD_LENSING   0x100
     91# define LOAD_LENSOBJ   0x200
     92# define SKIP_LENSING   0x400
     93# define SKIP_LENSOBJ   0x800
    9194
    9295/* photometry code types */
    … …  
    334337// another special case : does not match byte-boundaries
    335338# include "cmf-ps1-dv3.h"
     339# include "cmf-ps1-sv3.h"
     340# include "cmf-ps1-v5.h"
     341# include "cmf-ps1-v5-lensing.h"
    336342
    337343typedef struct {
    … …  
    434440// a reduced-subset structure for relphot & relastro
    435441typedef struct {
    436   float          dR;
    437   float          dD;
     442  double         R;
     443  double         D;
    438444  float          M;
    439445  float          Mcal;
    … …  
    548554
    549555Measure_PS1_V4alt *gfits_table_get_Measure_PS1_V4alt (FTable *table, off_t *Ndata, char *swapped);
    550 Measure *Measure_PS1_V4alt_ToInternal (Measure_PS1_V4alt *in, off_t Nvalues);
     556Measure *Measure_PS1_V4alt_ToInternal (Average *ave, Measure_PS1_V4alt *in, off_t Nvalues);
     557
     558/* for some reason I have merged the set of tables and the file description,
     559   so I need to have an internal structure to point to the separate files */
    551560
    552561/* a catalog contains this data */
    … …  
    562571  SecFilt *secfilt;
    563572
     573  // lensing data (optional?)
     574  Lensing *lensing;
     575  Lensobj *lensobj;
     576
    564577  int Nsecfilt;  /* number of secfilt entries for each average entry */
    565   off_t Naverage,   Nmeasure,   Nmissing,   Nsecf_mem;  /* current number of each component in memory */
    566   off_t Naves_disk, Nmeas_disk, Nmiss_disk, Nsecf_disk; /* current number of each component on disk */
    567   off_t Naves_off,  Nmeas_off,  Nmiss_off,  Nsecf_off;  /* index of first loaded data value */
     578  off_t Naverage,   Nmeasure,   Nmissing,   Nlensing,      Nlensobj,      Nsecf_mem;  /* current number of each component in memory */
     579  off_t Naves_disk, Nmeas_disk, Nmiss_disk, Nlensing_disk, Nlensobj_disk, Nsecf_disk; /* current number of each component on disk */
     580  off_t Naves_off,  Nmeas_off,  Nmiss_off,  Nlensing_off,  Nlensobj_off,  Nsecf_off;  /* index of first loaded data value */
    568581
    569582  // note that we use these for the full-sky relphot analysis
    … …  
    584597  struct Catalog *missing_catalog;              /* missing catalog data (split) */
    585598  struct Catalog *secfilt_catalog;              /* secfilt catalog data (split) */
     599  struct Catalog *lensing_catalog;              /* lensing catalog data (split) */
     600  struct Catalog *lensobj_catalog;              /* lensobj catalog data (split) */
    586601
    587602  unsigned int objID;
    … …  
    592607  char catmode;                         /* storage mode (raw, mef, split, mysql) */
    593608  char catformat;                       /* storage format (elixir, panstarrs, etc) */
    594   char catflags;                                /* choices to be loaded */
    595   char sorted;                          /* is measure table average-sorted? */
     609  int sorted;                           /* is measure table average-sorted? (NOTE this is an int only because gfits_scan %t requires it) */
    596610 
     611  short catflags; /* choices to be loaded */
     612
    597613  /* pointers for data manipulation */
    598   off_t *found;
    599   off_t *image;
    600   off_t *mosaic;
    601   float *X;
    602   float *Y;
    603   int   *nOwn; // relastro uses this to count owned detections per object
     614  off_t *found_t;
     615  off_t *foundWarp_t;
     616//  off_t *image_t;
     617//  off_t *mosaic_t;
     618//  float *X_t;
     619//  float *Y_t;
     620  int   *nOwn_t; // relastro uses this to count owned detections per object
    604621
    605622} Catalog;
    … …  
    661678char     *GetPhotcodeNamebyCode (int code);
    662679
    663 float PhotInst (Measure *measure);
    664 float PhotCat (Measure *measure);
    665 float PhotSys (Measure *measure, Average *average, SecFilt *secfilt);
    666 float PhotRel (Measure *measure, Average *average, SecFilt *secfilt);
    667 float PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
    668 float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt);
    669 float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
    670 float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
    671 
    672 float PhotAperInst (Measure *measure);
    673 float PhotAperCat (Measure *measure);
    674 float PhotAperSys (Measure *measure, Average *average, SecFilt *secfilt);
    675 float PhotAperRel (Measure *measure, Average *average, SecFilt *secfilt);
    676 float PhotAperCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
    677 float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt);
    678 float PhotAperRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
    679 
    680 float PhotKronInst (Measure *measure);
    681 float PhotKronCat (Measure *measure);
    682 float PhotKronSys (Measure *measure, Average *average, SecFilt *secfilt);
    683 float PhotKronRel (Measure *measure, Average *average, SecFilt *secfilt);
    684 float PhotKronCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
    685 float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt);
    686 float PhotKronRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
    687 float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
     680float PhotInst (Measure *measure, dvoMagClassType class);
     681float PhotCat (Measure *measure, dvoMagClassType class);
     682float PhotSys (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class);
     683float PhotRel (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class);
     684float PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code, dvoMagClassType class);
     685float PhotErr (Measure *measure, dvoMagClassType class);
     686float PhotCalErr (Measure *measure, dvoMagClassType class);
     687
     688float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
     689float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure, dvoMagClassType class, dvoMagSourceType source);
     690float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
     691
     692float PhotInstTiny (MeasureTiny *measure, dvoMagClassType class);
     693float PhotCatTiny (MeasureTiny *measure, dvoMagClassType class);
     694float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class);
     695float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class);
     696float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code, dvoMagClassType class);
     697
     698float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
     699float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, dvoMagClassType class, dvoMagSourceType source);
     700
     701float PhotFluxInst (Measure *measure, dvoMagClassType class);
     702float PhotFluxCat (Measure *measure, dvoMagClassType class);
     703float PhotFluxSys (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class);
     704float PhotFluxRel (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class);
     705float PhotFluxCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code, dvoMagClassType class);
     706
     707float PhotFluxAve (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
     708float PhotFluxRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure, dvoMagClassType class, dvoMagSourceType source);
     709
     710float PhotFluxInstErr (Measure *measure, dvoMagClassType class);
     711float PhotFluxCatErr (Measure *measure, dvoMagClassType class);
    688712
    689713float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt);
    690 
    691714float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt);
    692 float PhotAveFluxPSF (PhotCode *code, Average *average, SecFilt *secfilt);
    693 float PhotAvedFluxPSF (PhotCode *code, Average *average, SecFilt *secfilt);
    694 float PhotAveFluxKron (PhotCode *code, Average *average, SecFilt *secfilt);
    695 float PhotAvedFluxKron (PhotCode *code, Average *average, SecFilt *secfilt);
    696715
    697716float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt);
    698 float PhotM20 (PhotCode *code, Average *average, SecFilt *secfilt);
    699 float PhotM80 (PhotCode *code, Average *average, SecFilt *secfilt);
     717float PhotMmin (PhotCode *code, Average *average, SecFilt *secfilt);
     718float PhotMmax (PhotCode *code, Average *average, SecFilt *secfilt);
    700719float PhotUCdist (PhotCode *code, Average *average, SecFilt *secfilt);
    701720unsigned int PhotStackID (PhotCode *code, Average *average, SecFilt *secfilt);
    … …  
    704723int PhotColor (Average *average, SecFilt *secfilt, Measure *measure, int c1, int c2, double *color);
    705724
    706 float PhotInstTiny (MeasureTiny *measure);
    707 float PhotCatTiny (MeasureTiny *measure);
    708 float PhotAperTiny (MeasureTiny *measure);
    709 float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt);
    710 float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt);
    711 float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code);
    712 float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt);
    713 float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure);
    714725float PhotXmTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt);
    715726float PhotdMTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt);
    … …  
    782793/*** conversion functions / I/O conversions ***/
    783794Average *ReadRawAverage (FILE *f, off_t Naverage, char format, SecFilt **primary);
    784 Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format);
     795Measure *ReadRawMeasure (FILE *f, Average *average, off_t Nmeasure, char format);
    785796SecFilt *ReadRawSecFilt (FILE *f, off_t Nsecfilt, char format);
    786797int WriteRawAverage (FILE *f, Average *average, off_t Naverage, char format, SecFilt *primary);
    787 int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format);
     798int WriteRawMeasure (FILE *f, Average *average, Measure *measure, off_t Nmeasure, char format);
    788799int WriteRawSecFilt (FILE *f, SecFilt *secfilt, off_t Nsecfilt, char format);
    789800
    … …  
    791802
    792803Average *FtableToAverage (FTable *ftable, off_t *Naverage, char *format, SecFilt **primary);
    793 Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format);
     804Measure *FtableToMeasure (FTable *ftable, Average *average, off_t *Nmeasure, char *format);
    794805SecFilt *FtableToSecFilt (FTable *ftable, off_t *Nsecfilt, char *format);
     806Lensing *FtableToLensing (FTable *ftable, off_t *Nlensing, char *format);
     807Lensobj *FtableToLensobj (FTable *ftable, off_t *Nlensobj, char *format);
    795808int      FtableToImage   (FTable *ftable, Header *theader, char *format);
    796809
    797810int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, char format, SecFilt *primary);
    798 int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format);
     811int MeasureToFtable (FTable *ftable, Average *average, Measure *measure, off_t Nmeasure, char format);
    799812int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, char format);
     813int LensingToFtable (FTable *ftable, Lensing *lensing, off_t Nlensing, char format);
     814int LensobjToFtable (FTable *ftable, Lensobj *lensobj, off_t Nlensobj, char format);
    800815int ImageToFtable (FTable *ftable, Header *theader, char format);
    801816int ImageToVtable (VTable *vtable, Header *theader, char format);
    … …  
    812827# include "ps1_v3_defs.h"
    813828# include "ps1_v4_defs.h"
     829# include "ps1_v5_defs.h"
    814830# include "ps1_ref_defs.h"
    815831
    … …  
    906922void TessellationTableInit (TessellationTable *tess, int Ntess);
    907923
     924float dvoOffsetR (Measure *measure, Average *average);
     925float dvoOffsetD (Measure *measure, Average *average);
     926double dvoMeanR (float dR, Average *average);
     927double dvoMeanD (float dD, Average *average);
     928
    908929void dvo_average_init (Average *average);
    909930void dvo_averageT_init (AverageTiny *average);
    … …  
    911932void dvo_measure_init (Measure *measure);
    912933void dvo_measureT_init (MeasureTiny *measure);
     934
     935void dvo_lensing_init (Lensing *lensing);
     936void dvo_lensobj_init (Lensobj *lensobj);
    913937
    914938void InitRegionHosts (RegionHostInfo *hosts, int Nhosts, int NHOSTS);

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

    r36840 r37035  
    2222
    2323/* magnitude types */
    24 enum {MAG_NONE,
    25 
    26       // these magnitude types are from the measurement table (or derived therein)
    27       // the following imply PSF magnitudes:
    28       MAG_INST, // -2.5*log(DN) [ie, not DN/sec]
    29       MAG_CAT,  // MAG_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
    30       MAG_SYS,  // MAG_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
    31       MAG_REL,  // MAG_SYS - Mcal [specific zero point for image]
    32       MAG_CAL,  // MAG_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
    33       MAG_ERR,  // error on PSF MAG
    34 
    35       // the following imply APERTURE magnitudes:
    36       MAG_APER_INST, // -2.5*log(DN) [ie, not DN/sec]
    37       MAG_APER_CAT,  // MAG_APER_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
    38       MAG_APER_SYS,  // MAG_APER_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
    39       MAG_APER_REL,  // MAG_APER_SYS - Mcal [specific zero point for image]
    40       MAG_APER_CAL,  // MAG_APER_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
    41       MAG_APER_ERR,  // error on APER MAG (if known, else psf error)
    42       MAG_APER,      // in mextract -> MAG_APER_REL, in avextract -> MAG_APER_AVE
    43 
    44       // the following imply KRON magnitudes:
    45       MAG_KRON_INST, // -2.5*log(DN) [ie, not DN/sec]
    46       MAG_KRON_CAT,  // MAG_KRON_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
    47       MAG_KRON_SYS,  // MAG_KRON_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
    48       MAG_KRON_REL,  // MAG_KRON_SYS - Mcal [specific zero point for image]
    49       MAG_KRON_CAL,  // MAG_KRON_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
    50       MAG_KRON_ERR,  // error on KRON MAG
    51       MAG_KRON,      // in mextract -> MAG_KRON_REL, in avextract -> MAG_KRON_AVE
    52 
    53       // these magnitude types are from the average (secfilt) table:
    54       // the following imply PSF magnitudes (or fluxes)
    55       MAG_AVE,
    56       MAG_REF,
    57       MAG_STDEV,
    58       MAG_AVE_ERR,
    59       MAG_CHISQ,
    60       MAG_20,
    61       MAG_80,
    62       MAG_FLUX_PSF,
    63       MAG_FLUX_PSF_ERR,
    64 
    65       // the following imply APERTURE magnitudes:
    66       MAG_APER_AVE,
    67       MAG_APER_REF,
    68 
    69       // the following imply KRON magnitudes or fluxes:
    70       MAG_KRON_AVE,
    71       MAG_KRON_REF,
    72       MAG_FLUX_KRON,
    73       MAG_FLUX_KRON_ERR,
    74 
    75       // other secfilt fields of interest
    76       MAG_PHOT_FLAGS,
    77       MAG_NCODE,
    78       MAG_NPHOT,
    79       MAG_UC_DIST,
    80       MAG_STACK_DET_ID,
    81 };
     24
     25typedef enum {
     26  MAG_SRC_NONE,
     27  MAG_SRC_CHP,
     28  MAG_SRC_WRP,
     29  MAG_SRC_STK,
     30} dvoMagSourceType;
     31
     32typedef enum {
     33  MAG_LEVEL_NONE,       // -2.5*log(DN) [ie, not DN/sec]
     34  MAG_LEVEL_INST,               // -2.5*log(DN) [ie, not DN/sec]
     35  MAG_LEVEL_CAT,                // MAG_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
     36  MAG_LEVEL_SYS, // MAG_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
     37  MAG_LEVEL_REL, // MAG_SYS - Mcal [specific zero point for image]
     38  MAG_LEVEL_CAL, // MAG_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
     39  MAG_LEVEL_AVE,
     40  MAG_LEVEL_REF,
     41} dvoMagLevelType;
     42
     43typedef enum {
     44  MAG_OPTION_NONE,
     45  MAG_OPTION_MAG,
     46  MAG_OPTION_ERR,
     47  MAG_OPTION_FLUX,
     48  MAG_OPTION_FLUX_ERR,
     49  MAG_OPTION_STDEV,
     50  MAG_OPTION_CHISQ,
     51  MAG_OPTION_MIN,
     52  MAG_OPTION_MAX,
     53  MAG_OPTION_NCODE,
     54  MAG_OPTION_NPHOT, // Nused
     55  MAG_OPTION_UC_DIST,
     56  MAG_OPTION_STACK_DET_ID,
     57  MAG_OPTION_FLAGS,
     58} dvoMagOptionType;
     59
     60typedef enum {
     61  MAG_CLASS_NONE,
     62  MAG_CLASS_PSF,
     63  MAG_CLASS_KRON,
     64  MAG_CLASS_APER,
     65} dvoMagClassType;
    8266
    8367/* measure fields */
    … …  
    119103      MEAS_OBJ_FLAGS,
    120104      MEAS_SECFILT_FLAGS,
    121       MEAS_MAG,
     105      MEAS_PHOT, // photometry class of measurements
    122106      MEAS_MINST,
    123107      MEAS_MCAT,
    … …  
    173157      MEAS_EXTERN_ID,
    174158      MEAS_EXPNAME_AS_INT,
    175       MEAS_MCAL_OFFSET,
     159      MEAS_MCAL_OFFSET, // make this a dvoMagOption?
    176160      MEAS_FLAT,
    177161      MEAS_CENTER_OFFSET,
    178       MEAS_FLUX_PSF,
    179       MEAS_FLUX_PSF_ERR,
    180       MEAS_FLUX_KRON,
    181       MEAS_FLUX_KRON_ERR,
    182162      MEAS_REF_COLOR,
    183163};
    … …  
    211191      AVE_NMISS,
    212192      AVE_NPOS,
    213       AVE_NPHOT,
    214       AVE_NCODE,
    215       AVE_MAG,
    216       AVE_dMAG,
    217       AVE_Xm,
    218193      AVE_OBJ_FLAGS,
    219194      AVE_TYPE,
    … …  
    224199      AVE_EXTID_LO,
    225200      AVE_REF_COLOR,
     201      AVE_PHOT, // photometry class of values
    226202};
     203
     204//       AVE_NPHOT,
     205//       AVE_NCODE,
     206//       AVE_MAG,
     207//       AVE_dMAG,
     208//       AVE_Xm,
    227209
    228210enum {IMAGE_ZERO,
    … …  
    312294  int table;
    313295  int ID;
    314   int magMode;
     296
     297  dvoMagSourceType magSource; // chip, (forced) warp, stack [only relevant for averages]
     298  dvoMagLevelType magLevel;  // inst, cat, sys, rel, ave, ref, err, min, max, stdev, nphot, chisq,
     299  dvoMagOptionType magOption;  // psf, kron, aper
     300  dvoMagClassType magClass;
     301
    315302  char type;
    316303  PhotCode *photcode;
    … …  
    374361
    375362int          GetMagMode             PROTO((char *string));
    376 PhotCode    *ParsePhotcodeField     PROTO((char *field, int *mode, int def));
     363int          ParsePhotcodeField     PROTO((dbField *field, char *fieldName, int fieldID));
    377364int          ParseMeasureField      PROTO((dbField *field, char *fieldName));
    378365int          ParseAverageField      PROTO((dbField *field, char *fieldName));

  • trunk/Ohana/src/libdvo/include/elixir_defs.h

    r35162 r37035  
    33Average                 *Average_Elixir_ToInternal (Average_Elixir *in, off_t Nvalues, SecFilt **primary);
    44Average_Elixir          *AverageInternalTo_Elixir (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_Elixir_ToInternal (Measure_Elixir *in, off_t Nvalues);
    6 Measure_Elixir          *MeasureInternalTo_Elixir (Measure *in, off_t Nvalues);
     5Measure                 *Measure_Elixir_ToInternal (Average *ave, Measure_Elixir *in, off_t Nvalues);
     6Measure_Elixir          *MeasureInternalTo_Elixir (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_Elixir_ToInternal (SecFilt_Elixir *in, off_t Nvalues);
    88SecFilt_Elixir          *SecFiltInternalTo_Elixir (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/loneos_defs.h

    r35162 r37035  
    33Average                 *Average_Loneos_ToInternal (Average_Loneos *in, off_t Nvalues, SecFilt **primary);
    44Average_Loneos          *AverageInternalTo_Loneos (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_Loneos_ToInternal (Measure_Loneos *in, off_t Nvalues);
    6 Measure_Loneos          *MeasureInternalTo_Loneos (Measure *in, off_t Nvalues);
     5Measure                 *Measure_Loneos_ToInternal (Average *ave, Measure_Loneos *in, off_t Nvalues);
     6Measure_Loneos          *MeasureInternalTo_Loneos (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_Loneos_ToInternal (SecFilt_Loneos *in, off_t Nvalues);
    88SecFilt_Loneos          *SecFiltInternalTo_Loneos (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/panstarrs_dev_0_defs.h

    r35162 r37035  
    33Average                 *Average_Panstarrs_DEV_0_ToInternal (Average_Panstarrs_DEV_0 *in, off_t Nvalues, SecFilt **primary);
    44Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, off_t Nvalues);
    6 Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, off_t Nvalues);
     5Measure                 *Measure_Panstarrs_DEV_0_ToInternal (Average *ave, Measure_Panstarrs_DEV_0 *in, off_t Nvalues);
     6Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_Panstarrs_DEV_0_ToInternal (SecFilt_Panstarrs_DEV_0 *in, off_t Nvalues);
    88SecFilt_Panstarrs_DEV_0 *SecFiltInternalTo_Panstarrs_DEV_0 (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/panstarrs_dev_1_defs.h

    r35162 r37035  
    33Average                 *Average_Panstarrs_DEV_1_ToInternal (Average_Panstarrs_DEV_1 *in, off_t Nvalues, SecFilt **primary);
    44Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, off_t Nvalues);
    6 Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, off_t Nvalues);
     5Measure                 *Measure_Panstarrs_DEV_1_ToInternal (Average *ave, Measure_Panstarrs_DEV_1 *in, off_t Nvalues);
     6Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_Panstarrs_DEV_1_ToInternal (SecFilt_Panstarrs_DEV_1 *in, off_t Nvalues);
    88SecFilt_Panstarrs_DEV_1 *SecFiltInternalTo_Panstarrs_DEV_1 (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/ps1_dev_1_defs.h

    r35162 r37035  
    33Average                 *Average_PS1_DEV_1_ToInternal (Average_PS1_DEV_1 *in, off_t Nvalues, SecFilt **primary);
    44Average_PS1_DEV_1       *AverageInternalTo_PS1_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, off_t Nvalues);
    6 Measure_PS1_DEV_1       *MeasureInternalTo_PS1_DEV_1 (Measure *in, off_t Nvalues);
     5Measure                 *Measure_PS1_DEV_1_ToInternal (Average *ave, Measure_PS1_DEV_1 *in, off_t Nvalues);
     6Measure_PS1_DEV_1       *MeasureInternalTo_PS1_DEV_1 (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_PS1_DEV_1_ToInternal (SecFilt_PS1_DEV_1 *in, off_t Nvalues);
    88SecFilt_PS1_DEV_1       *SecFiltInternalTo_PS1_DEV_1 (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/ps1_dev_2_defs.h

    r35162 r37035  
    33Average                 *Average_PS1_DEV_2_ToInternal (Average_PS1_DEV_2 *in, off_t Nvalues, SecFilt **primary);
    44Average_PS1_DEV_2       *AverageInternalTo_PS1_DEV_2 (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, off_t Nvalues);
    6 Measure_PS1_DEV_2       *MeasureInternalTo_PS1_DEV_2 (Measure *in, off_t Nvalues);
     5Measure                 *Measure_PS1_DEV_2_ToInternal (Average *ave, Measure_PS1_DEV_2 *in, off_t Nvalues);
     6Measure_PS1_DEV_2       *MeasureInternalTo_PS1_DEV_2 (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_PS1_DEV_2_ToInternal (SecFilt_PS1_DEV_2 *in, off_t Nvalues);
    88SecFilt_PS1_DEV_2       *SecFiltInternalTo_PS1_DEV_2 (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/ps1_ref_defs.h

    r35162 r37035  
    33Average                 *Average_PS1_REF_ToInternal (Average_PS1_REF *in, off_t Nvalues, SecFilt **primary);
    44Average_PS1_REF          *AverageInternalTo_PS1_REF (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, off_t Nvalues);
    6 Measure_PS1_REF          *MeasureInternalTo_PS1_REF (Measure *in, off_t Nvalues);
     5Measure                 *Measure_PS1_REF_ToInternal (Average *ave, Measure_PS1_REF *in, off_t Nvalues);
     6Measure_PS1_REF          *MeasureInternalTo_PS1_REF (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_PS1_REF_ToInternal (SecFilt_PS1_REF *in, off_t Nvalues);
    88SecFilt_PS1_REF          *SecFiltInternalTo_PS1_REF (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/ps1_v1_defs.h

    r35162 r37035  
    33Average                 *Average_PS1_V1_ToInternal (Average_PS1_V1 *in, off_t Nvalues, SecFilt **primary);
    44Average_PS1_V1          *AverageInternalTo_PS1_V1 (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, off_t Nvalues);
    6 Measure_PS1_V1          *MeasureInternalTo_PS1_V1 (Measure *in, off_t Nvalues);
     5Measure                 *Measure_PS1_V1_ToInternal (Average *ave, Measure_PS1_V1 *in, off_t Nvalues);
     6Measure_PS1_V1          *MeasureInternalTo_PS1_V1 (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_PS1_V1_ToInternal (SecFilt_PS1_V1 *in, off_t Nvalues);
    88SecFilt_PS1_V1          *SecFiltInternalTo_PS1_V1 (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/ps1_v2_defs.h

    r35162 r37035  
    33Average                 *Average_PS1_V2_ToInternal (Average_PS1_V2 *in, off_t Nvalues, SecFilt **primary);
    44Average_PS1_V2          *AverageInternalTo_PS1_V2 (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_V2_ToInternal (Measure_PS1_V2 *in, off_t Nvalues);
    6 Measure_PS1_V2          *MeasureInternalTo_PS1_V2 (Measure *in, off_t Nvalues);
     5Measure                 *Measure_PS1_V2_ToInternal (Average *ave, Measure_PS1_V2 *in, off_t Nvalues);
     6Measure_PS1_V2          *MeasureInternalTo_PS1_V2 (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_PS1_V2_ToInternal (SecFilt_PS1_V2 *in, off_t Nvalues);
    88SecFilt_PS1_V2          *SecFiltInternalTo_PS1_V2 (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/ps1_v3_defs.h

    r35162 r37035  
    33Average                 *Average_PS1_V3_ToInternal (Average_PS1_V3 *in, off_t Nvalues, SecFilt **primary);
    44Average_PS1_V3          *AverageInternalTo_PS1_V3 (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_V3_ToInternal (Measure_PS1_V3 *in, off_t Nvalues);
    6 Measure_PS1_V3          *MeasureInternalTo_PS1_V3 (Measure *in, off_t Nvalues);
     5Measure                 *Measure_PS1_V3_ToInternal (Average *ave, Measure_PS1_V3 *in, off_t Nvalues);
     6Measure_PS1_V3          *MeasureInternalTo_PS1_V3 (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_PS1_V3_ToInternal (SecFilt_PS1_V3 *in, off_t Nvalues);
    88SecFilt_PS1_V3          *SecFiltInternalTo_PS1_V3 (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/include/ps1_v4_defs.h

    r35162 r37035  
    33Average                 *Average_PS1_V4_ToInternal (Average_PS1_V4 *in, off_t Nvalues, SecFilt **primary);
    44Average_PS1_V4          *AverageInternalTo_PS1_V4 (Average *in, off_t Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_V4_ToInternal (Measure_PS1_V4 *in, off_t Nvalues);
    6 Measure_PS1_V4          *MeasureInternalTo_PS1_V4 (Measure *in, off_t Nvalues);
     5Measure                 *Measure_PS1_V4_ToInternal (Average *ave, Measure_PS1_V4 *in, off_t Nvalues);
     6Measure_PS1_V4          *MeasureInternalTo_PS1_V4 (Average *ave, Measure *in, off_t Nvalues);
    77SecFilt                 *SecFilt_PS1_V4_ToInternal (SecFilt_PS1_V4 *in, off_t Nvalues);
    88SecFilt_PS1_V4          *SecFiltInternalTo_PS1_V4 (SecFilt *in, off_t Nvalues);

  • trunk/Ohana/src/libdvo/src/ImageMetadata.c

    r35416 r37035  
    124124  gfits_create_table_header (&theader, "BINTABLE", "IMAGE_SUBSET");
    125125
    126   gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, 1.0*0x8000);
    127   gfits_define_bintable_column (&theader, "J", "EXTERN_ID", "extern ID", NULL, 1.0, 1.0*0x8000);
    128   gfits_define_bintable_column (&theader, "J", "EXPNAME_AS_INT", "expname as integer", NULL, 1.0, 1.0*0x8000);
    129   gfits_define_bintable_column (&theader, "D", "CRVAL1", "ra at center", "degrees", 1.0, 0.0);
    130   gfits_define_bintable_column (&theader, "D", "CRVAL2", "dec at center", "degrees", 1.0, 0.0);
    131   gfits_define_bintable_column (&theader, "E", "THETA", "camera rot angle", "degrees", 1.0, 0.0);
    132   gfits_define_bintable_column (&theader, "E", "MCAL", "zero point offset", "magnitudes", 1.0, 0.0);
    133   gfits_define_bintable_column (&theader, "E", "SECZ", "airmass", "none", 1.0, 0.0);
    134   gfits_define_bintable_column (&theader, "E", "X_CENTER", "chip center", "none", 1.0, 0.0);
    135   gfits_define_bintable_column (&theader, "E", "Y_CENTER", "chip center", "none", 1.0, 0.0);
     126  gfits_define_bintable_column (&theader, "J", "IMAGE_ID",       "image ID",           NULL,         1.0, FT_BZERO_INT32);
     127  gfits_define_bintable_column (&theader, "J", "EXTERN_ID",      "extern ID",          NULL,         1.0, FT_BZERO_INT32);
     128  gfits_define_bintable_column (&theader, "J", "EXPNAME_AS_INT", "expname as integer", NULL,         1.0, FT_BZERO_INT32);
     129  gfits_define_bintable_column (&theader, "D", "CRVAL1",         "ra at center",       "degrees",    1.0, 0.0);
     130  gfits_define_bintable_column (&theader, "D", "CRVAL2",         "dec at center",      "degrees",    1.0, 0.0);
     131  gfits_define_bintable_column (&theader, "E", "THETA",          "camera rot angle",   "degrees",    1.0, 0.0);
     132  gfits_define_bintable_column (&theader, "E", "MCAL",           "zero point offset", "magnitudes", 1.0, 0.0);
     133  gfits_define_bintable_column (&theader, "E", "SECZ",           "airmass",            "none",      1.0, 0.0);
     134  gfits_define_bintable_column (&theader, "E", "X_CENTER",       "chip center",        "none",      1.0, 0.0);
     135  gfits_define_bintable_column (&theader, "E", "Y_CENTER",       "chip center",        "none",      1.0, 0.0);
    136136
    137137  // generate the output array that carries the data

  • trunk/Ohana/src/libdvo/src/LoadPhotcodesFITS.c

    r35755 r37035  
    6464  CONVERT_FORMAT("DVO_PHOTCODE_PS1_V3",    PS1_V3);
    6565  CONVERT_FORMAT("DVO_PHOTCODE_PS1_V4",    PS1_V4);
     66  CONVERT_FORMAT("DVO_PHOTCODE_PS1_V5",    PS1_V5);
    6667
    6768  table = GetPhotcodeTable ();
    … …  
    100101  // photcode.equiv of 0 means "undefined"
    101102  for (i = 0; i < Ncode; i++) {
     103    if (!strcasecmp(photcode[i].name, "MAG")) {
     104      fprintf (stderr, "MAG is not an allowed photcode name (reserved to DVO internals)\n");
     105      free (photcode);
     106      return FALSE;
     107    }
     108    if (!strcasecmp(photcode[i].name, "FLUX")) {
     109      fprintf (stderr, "FLUX is not an allowed photcode name (reserved to DVO internals)\n");
     110      free (photcode);
     111      return FALSE;
     112    }
     113
    102114    if (photcode[i].type == PHOT_DEP) {
    103115      if (photcode[i].equiv == 0) continue;

  • trunk/Ohana/src/libdvo/src/LoadPhotcodesText.c

    r28833 r37035  
    108108    }
    109109
     110    if (!strcasecmp(name, "MAG")) {
     111      fprintf (stderr, "MAG is not an allowed photcode name (reserved to DVO internals)\n");
     112      return FALSE;
     113    }
     114
    110115    photcode[Ncode].type = 0;
    111116    memset(photcode[Ncode].dummy, 0, sizeof(photcode[Ncode].dummy));
    … …  
    137142    photcode[Ncode].photomErrSys      = atof (photomErrSys);
    138143
    139     photcode[Ncode].astromPoorMask    = strtol (astromPoorMask, NULL, 0);
    140     photcode[Ncode].astromBadMask     = strtol (astromBadMask, NULL, 0);
    141     photcode[Ncode].photomPoorMask    = strtol (photomPoorMask, NULL, 0);
    142     photcode[Ncode].photomBadMask     = strtol (photomBadMask, NULL, 0);
     144    photcode[Ncode].astromPoorMask    = strtoll (astromPoorMask, NULL, 0);
     145    photcode[Ncode].astromBadMask     = strtoll (astromBadMask, NULL, 0);
     146    photcode[Ncode].photomPoorMask    = strtoll (photomPoorMask, NULL, 0);
     147    photcode[Ncode].photomBadMask     = strtoll (photomBadMask, NULL, 0);
    143148
    144149    switch (photcode[Ncode].type) {

  • trunk/Ohana/src/libdvo/src/SavePhotcodesFITS.c

    r34260 r37035  
    3030  // for the moment, we simply support the latest photcode format for output
    3131  // XXX update this as needed as new formats are defined
    32   PhotCode_PS1_V4 *photcode_output = PhotCode_Internal_To_PS1_V4 (table[0].code, table[0].Ncode);
     32  PhotCode_PS1_V5 *photcode_output = PhotCode_Internal_To_PS1_V5 (table[0].code, table[0].Ncode);
    3333
    3434  /* convert FITS format data to internal format (byteswaps & EXTNAME) */
    3535  if (!gfits_db_create (&db)) return (FALSE);
    36   if (!gfits_table_set_PhotCode_PS1_V4 (&db.ftable, photcode_output, table[0].Ncode)) return (FALSE);
     36  if (!gfits_table_set_PhotCode_PS1_V5 (&db.ftable, photcode_output, table[0].Ncode)) return (FALSE);
    3737  if (!gfits_db_save (&db)) return (FALSE);
    3838  if (!gfits_db_close (&db)) return (FALSE);

  • trunk/Ohana/src/libdvo/src/cmf-ps1-dv3.c

    r35416 r37035  
    22
    33/*** note : this file is derived from the autocode version, but is modified because
    4      the forma does not match with structure byte boundaries ***/
     4     the format does not match with structure byte boundaries ***/
    55
    66/* if we are not correctly including the ohana headers, this will fail */

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

    r36833 r37035  
    5252dbValue dbExtractAverages (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
    5353
    54   off_t i;
    55   int Nsec;
     54  // off_t i;
    5655  dbValue value;
    5756
    … …  
    163162      break;
    164163    case AVE_REF_COLOR:
    165       value.Flt = average[0].refColor;
     164      value.Flt = average[0].refColorBlue;
    166165      break;
    167166
    … …  
    182181      break;
    183182
    184     case AVE_MAG:
     183    case AVE_PHOT:
     184      // if we request mag:ave, use equiv for photcode (ie a given measure, say GPC1.g.XY01, will return g for mag:ave)
     185      if  (field->photcode->type == PHOT_MAG) {
     186        // this is an error
     187        break;
     188      }
     189
     190      // if we ask for 2MASS_K, etc (REF values), return NAN unless measure->code matches
     191      if (field->photcode->type == PHOT_REF) {
     192        // need to ensure measure exists.
     193        break;
     194      }
     195
     196      // if we ask for GPC1.g.XY03:rel, etc (DEP values), return NAN unless measure->code matches
     197      if (field->photcode->type == PHOT_DEP) {
     198        // again.
     199        break;
     200      }
     201
     202      switch (field->magOption) {
     203        case MAG_OPTION_MAG:
     204          switch (field->magLevel) {
     205            case MAG_LEVEL_AVE:
     206              value.Flt = PhotAve  (field->photcode, average, secfilt, field->magClass, field->magSource);
     207              break;
     208            case MAG_LEVEL_REF:
     209              // why is measure needed here?
     210              // PhotRef  (field->photcode, average, secfilt, measure, field->magClass, field->magSource);
     211              break;
     212            case MAG_LEVEL_INST:
     213            case MAG_LEVEL_CAT:
     214            case MAG_LEVEL_SYS:
     215            case MAG_LEVEL_REL:
     216            case MAG_LEVEL_CAL:
     217            case MAG_LEVEL_NONE:
     218              break;
     219          }
     220          break;
     221
     222        case MAG_OPTION_ERR:
     223          switch (field->magLevel) {
     224            case MAG_LEVEL_AVE:
     225            case MAG_LEVEL_REF:
     226              value.Flt = PhotAveErr (field->photcode, average, secfilt, field->magClass, field->magSource); 
     227              break;
     228            case MAG_LEVEL_INST:
     229            case MAG_LEVEL_CAT:
     230            case MAG_LEVEL_SYS:
     231            case MAG_LEVEL_REL:
     232            case MAG_LEVEL_CAL:
     233            case MAG_LEVEL_NONE:
     234              break;
     235          }
     236          break;
     237
     238        case MAG_OPTION_FLUX:
     239          switch (field->magLevel) {
     240            case MAG_LEVEL_AVE:
     241              value.Flt = PhotFluxAve  (field->photcode, average, secfilt, field->magClass, field->magSource);
     242              break;
     243            case MAG_LEVEL_REF:
     244              // value.Flt = PhotFluxRef  (equiv, average, secfilt, measure, field->magClass, field->magSource);
     245              break;
     246            case MAG_LEVEL_INST:
     247            case MAG_LEVEL_CAT:
     248            case MAG_LEVEL_SYS:
     249            case MAG_LEVEL_REL:
     250            case MAG_LEVEL_CAL:
     251            case MAG_LEVEL_NONE:
     252              break;
     253          }
     254          break;
     255
     256        case MAG_OPTION_FLUX_ERR:
     257          switch (field->magLevel) {
     258            case MAG_LEVEL_AVE:
     259            case MAG_LEVEL_REF:
     260              // value.Flt = PhotFluxAveErr (equiv, average, secfilt, field->magClass, field->magSource); 
     261              break;
     262            case MAG_LEVEL_INST:
     263            case MAG_LEVEL_CAT:
     264            case MAG_LEVEL_SYS:
     265            case MAG_LEVEL_REL:
     266            case MAG_LEVEL_CAL:
     267            case MAG_LEVEL_NONE:
     268              break;
     269          }
     270          break;
     271
     272        case MAG_OPTION_STDEV:
     273        case MAG_OPTION_CHISQ:
     274        case MAG_OPTION_MIN:
     275        case MAG_OPTION_MAX:
     276        case MAG_OPTION_NCODE: {
     277          int Nsec = GetPhotcodeNsec (field->photcode->code);
     278          if (Nsec == -1) break;
     279          value.Int = secfilt[Nsec].Ncode;
     280          break;
     281        }
     282        case MAG_OPTION_NPHOT: {
     283          int Nsec = GetPhotcodeNsec (field->photcode->code);
     284          if (Nsec == -1) break;
     285          value.Int = secfilt[Nsec].Nused;
     286          break;
     287        }
     288        case MAG_OPTION_UC_DIST:
     289        case MAG_OPTION_STACK_DET_ID:
     290          value.Int = PhotStackID (field->photcode, average, secfilt);
     291          break;
     292        case MAG_OPTION_FLAGS: {
     293          int Nsec = GetPhotcodeNsec (field->photcode->code);
     294          if (Nsec == -1) break;
     295          value.Int = secfilt[Nsec].flags;
     296          break;
     297        }
     298        case MAG_OPTION_NONE:
     299          break;
     300      }
     301      break;
     302
     303# if (0)
    185304      switch (field->magMode) {
    186305        case MAG_AVE:
    … …  
    228347            }
    229348          } else {
    230             Nsec = GetPhotcodeNsec (field->photcode->code);
     349            int Nsec = GetPhotcodeNsec (field->photcode->code);
    231350            if (Nsec == -1) break;
    232351            value.Int = secfilt[Nsec].flags;
    … …  
    236355          // XXX push these into dvo_photcode_ops APIs
    237356          // XXX do I need to allow for conversion to equiv?
    238           Nsec = GetPhotcodeNsec (field->photcode->code);
     357          int Nsec = GetPhotcodeNsec (field->photcode->code);
    239358          if (Nsec == -1) break;
    240359          value.Int = secfilt[Nsec].Ncode;
    241360          break;
    242361        case MAG_NPHOT:
    243           Nsec = GetPhotcodeNsec (field->photcode->code);
     362          int Nsec = GetPhotcodeNsec (field->photcode->code);
    244363          if (Nsec == -1) break;
    245364          value.Int = secfilt[Nsec].Nused;
    … …  
    268387          break;
    269388
    270         case MAG_20:
    271           value.Flt = PhotM20 (field->photcode, average, secfilt);
    272           break;
    273         case MAG_80:
    274           value.Flt = PhotM80 (field->photcode, average, secfilt);
     389        case MAG_MIN:
     390          value.Flt = PhotMmin (field->photcode, average, secfilt);
     391          break;
     392        case MAG_MAX:
     393          value.Flt = PhotMmax (field->photcode, average, secfilt);
    275394          break;
    276395        case MAG_UC_DIST:
    … …  
    301420      value.Flt = PhotXm (field->photcode, average, secfilt);
    302421      break;
     422# endif
    303423    case AVE_TYPE:
    304424      break;

  • trunk/Ohana/src/libdvo/src/dbExtractImages.c

    r36833 r37035  
    376376
    377377    case IMAGE_REF_COLOR:
    378       value.Flt = image[N].refColor;
     378      value.Flt = image[N].refColorBlue;
    379379      break;
    380380  }

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

    r36840 r37035  
    9090  dbValue value;
    9191  double dT;
     92  float dR, dD;
    9293
    9394  Coords *mosaic, *fieldc;
    … …  
    99100
    100101  switch (field->ID) {
    101     case MEAS_MAG: { /* magnitudes are already determined above */
     102    case MEAS_PHOT: { /* magnitudes are already determined above */
    102103      PhotCode *myEquiv = GetPhotcodeEquivbyCode (measure[0].photcode);
    103104
    104       // if we request mag:ave, use equiv for photcode
     105      // if we request mag:ave, use equiv for photcode (ie a given measure, say GPC1.g.XY01, will return g for mag:ave)
    105106      if  (field->photcode->type == PHOT_MAG) {
    106107        equiv = myEquiv;
    … …  
    116117      // if we ask for g:ave, or other SEC-level values, return the corresponding field
    117118      if (field->photcode->type == PHOT_SEC) {
    118         switch (field->magMode) {
     119        switch (field->magLevel) {
    119120          // measure-like : return non-NAN if measure.equiv.photcode matches field.photcode
    120           case MAG_INST:
    121           case MAG_CAT:
    122           case MAG_SYS:
    123           case MAG_REL:
    124           case MAG_CAL:
    125           case MAG_ERR:
    126 
    127           case MAG_APER_INST:
    128           case MAG_APER_CAT:
    129           case MAG_APER_SYS:
    130           case MAG_APER_REL:
    131           case MAG_APER_CAL:
    132           case MAG_APER_ERR:
    133 
    134           case MAG_KRON_INST:
    135           case MAG_KRON_CAT:
    136           case MAG_KRON_SYS:
    137           case MAG_KRON_REL:
    138           case MAG_KRON_CAL:
    139           case MAG_KRON_ERR:
    140 
    141           case MAG_PHOT_FLAGS:
     121          case MAG_LEVEL_INST:
     122          case MAG_LEVEL_CAT:
     123          case MAG_LEVEL_SYS:
     124          case MAG_LEVEL_REL:
     125          case MAG_LEVEL_CAL:
    142126            equiv = myEquiv;
    143127            if (equiv && (equiv->code == field->photcode->code)) goto valid_photcode;
    … …  
    145129
    146130            // mean-like : return value for the given photcode
    147           case MAG_AVE:
    148           case MAG_REF:
    149           case MAG_STDEV:
    150           case MAG_AVE_ERR:
    151           case MAG_CHISQ:
    152           case MAG_FLUX_PSF:
    153           case MAG_FLUX_PSF_ERR:
    154 
    155           case MAG_APER_AVE:
    156 
    157           case MAG_KRON_AVE:
    158           case MAG_FLUX_KRON:
    159           case MAG_FLUX_KRON_ERR:
    160 
    161           case MAG_20:
    162           case MAG_80:
    163           case MAG_UC_DIST:
    164           case MAG_STACK_DET_ID:
    165 
    166           case MAG_NCODE:
    167           case MAG_NPHOT:
     131          case MAG_LEVEL_AVE:
     132          case MAG_LEVEL_REF:
    168133            equiv = field->photcode;
    169134            goto valid_photcode;
    … …  
    177142
    178143  valid_photcode:
    179       switch (field->magMode) {
    180         case MAG_INST:
    181           value.Flt = PhotInst (measure); 
    182           break;
    183         case MAG_CAT:
    184           value.Flt = PhotCat  (measure);
    185           break;
    186         case MAG_SYS:
    187           value.Flt = PhotSys  (measure, average, secfilt);
    188           break;
    189         case MAG_REL:
    190           value.Flt = PhotRel  (measure, average, secfilt);
    191           break;
    192         case MAG_CAL:
    193           value.Flt = PhotCal  (measure, average, secfilt, measure, equiv);
    194           break;
    195         case MAG_AVE:
    196           value.Flt = PhotAve  (equiv, average, secfilt);
    197           break;
    198         case MAG_REF:
    199           value.Flt = PhotRef  (equiv, average, secfilt, measure);
    200           break;
    201         case MAG_ERR:
    202           value.Flt = measure[0].dM;
    203           break;
    204         case MAG_AVE_ERR:
    205           value.Flt = PhotAveErr  (equiv, average, secfilt);
    206           break;
    207 
    208         case MAG_APER_INST:
    209           value.Flt = PhotAperInst (measure);
    210           break;
    211         case MAG_APER_CAT:
    212           value.Flt = PhotAperCat (measure);
    213           break;
    214         case MAG_APER_SYS:
    215           value.Flt = PhotAperSys (measure, average, secfilt);
    216           break;
    217         case MAG_APER:
    218         case MAG_APER_REL:
    219           value.Flt = PhotAperRel (measure, average, secfilt);
    220           break;
    221         case MAG_APER_CAL:
    222           value.Flt = PhotAperCal (measure, average, secfilt, measure, equiv);
    223           break;
    224         case MAG_APER_AVE:
    225           value.Flt = PhotAperAve (equiv, average, secfilt);
    226           break;
    227         case MAG_APER_REF:
    228           value.Flt = PhotAperRef (equiv, average, secfilt, measure);
    229           break;
    230         case MAG_APER_ERR:
    231           value.Flt = measure[0].dM;
    232           break;
    233 
    234         case MAG_KRON_INST:
    235           value.Flt = PhotKronInst (measure);
    236           break;
    237         case MAG_KRON_CAT:
    238           value.Flt = PhotKronCat (measure);
    239           break;
    240         case MAG_KRON_SYS:
    241           value.Flt = PhotKronSys (measure, average, secfilt);
    242           break;
    243         case MAG_KRON:
    244         case MAG_KRON_REL:
    245           value.Flt = PhotKronRel (measure, average, secfilt);
    246           break;
    247         case MAG_KRON_CAL:
    248           value.Flt = PhotKronCal (measure, average, secfilt, measure, equiv);
    249           break;
    250         case MAG_KRON_AVE:
    251           value.Flt = PhotKronAve (equiv, average, secfilt);
    252           break;
    253         case MAG_KRON_REF:
    254           value.Flt = PhotKronRef (equiv, average, secfilt, measure);
    255           break;
    256         case MAG_KRON_ERR:
    257           value.Flt = measure[0].dMkron;
    258           break;
    259 
    260         case MAG_PHOT_FLAGS:
    261           if ((field->photcode->type == PHOT_REF) || (field->photcode->type == PHOT_DEP)) {
    262             value.Int = measure[0].photFlags;
     144      switch (field->magOption) {
     145        case MAG_OPTION_MAG:
     146          switch (field->magLevel) {
     147            case MAG_LEVEL_INST:
     148              value.Flt = PhotInst (measure, field->magClass); 
     149              break;
     150            case MAG_LEVEL_CAT:
     151              value.Flt = PhotCat  (measure, field->magClass);
     152              break;
     153            case MAG_LEVEL_SYS:
     154              value.Flt = PhotSys  (measure, average, secfilt, field->magClass);
     155              break;
     156            case MAG_LEVEL_REL:
     157              value.Flt = PhotRel  (measure, average, secfilt, field->magClass);
     158              break;
     159            case MAG_LEVEL_CAL:
     160              value.Flt = PhotCal  (measure, average, secfilt, measure, equiv, field->magClass);
     161              break;
     162            case MAG_LEVEL_AVE:
     163              value.Flt = PhotAve  (equiv, average, secfilt, field->magClass, field->magSource);
     164              break;
     165            case MAG_LEVEL_REF:
     166              value.Flt = PhotRef  (equiv, average, secfilt, measure, field->magClass, field->magSource);
     167              break;
     168            case MAG_LEVEL_NONE:
     169              break;
    263170          }
    264171          break;
    265172
    266         case MAG_NCODE:
    267           if (equiv == NULL) break;
    268           Nsec = GetPhotcodeNsec (equiv->code);
    269           if (Nsec == -1) break;
    270           value.Int = secfilt[Nsec].Ncode;
     173        case MAG_OPTION_ERR:
     174          switch (field->magLevel) {
     175            case MAG_LEVEL_INST:
     176            case MAG_LEVEL_CAT:
     177            case MAG_LEVEL_SYS:
     178            case MAG_LEVEL_REL:
     179              value.Flt = PhotErr (measure, field->magClass); 
     180              break;
     181            case MAG_LEVEL_CAL:
     182              value.Flt = PhotCalErr (measure, field->magClass); 
     183              break;
     184            case MAG_LEVEL_AVE:
     185            case MAG_LEVEL_REF:
     186              value.Flt = PhotAveErr (equiv, average, secfilt, field->magClass, field->magSource); 
     187              break;
     188            case MAG_LEVEL_NONE:
     189              break;
     190          }
    271191          break;
    272         case MAG_NPHOT:
    273           if (equiv == NULL) break;
    274           Nsec = GetPhotcodeNsec (equiv->code);
    275           if (Nsec == -1) break;
    276           value.Int = secfilt[Nsec].Nused;
     192
     193        case MAG_OPTION_FLUX:
     194          switch (field->magLevel) {
     195            case MAG_LEVEL_INST:
     196              value.Flt = PhotFluxInst (measure, field->magClass); 
     197              break;
     198            case MAG_LEVEL_CAT:
     199              value.Flt = PhotFluxCat  (measure, field->magClass);
     200              break;
     201            case MAG_LEVEL_SYS:
     202              value.Flt = PhotFluxSys  (measure, average, secfilt, field->magClass);
     203              break;
     204            case MAG_LEVEL_REL:
     205              value.Flt = PhotFluxRel  (measure, average, secfilt, field->magClass);
     206              break;
     207            case MAG_LEVEL_CAL:
     208              value.Flt = PhotFluxCal  (measure, average, secfilt, measure, equiv, field->magClass);
     209              break;
     210            case MAG_LEVEL_AVE:
     211              value.Flt = PhotFluxAve  (equiv, average, secfilt, field->magClass, field->magSource);
     212              break;
     213            case MAG_LEVEL_REF:
     214              value.Flt = PhotFluxRef  (equiv, average, secfilt, measure, field->magClass, field->magSource);
     215              break;
     216            case MAG_LEVEL_NONE:
     217              break;
     218          }
    277219          break;
    278220
    279         case MAG_CHISQ:
    280           value.Flt = PhotXm (equiv, average, secfilt);
     221        case MAG_OPTION_FLUX_ERR:
     222          switch (field->magLevel) {
     223            case MAG_LEVEL_INST:
     224              value.Flt = PhotFluxInstErr (measure, field->magClass); 
     225              break;
     226            case MAG_LEVEL_CAT:
     227              value.Flt = PhotFluxCatErr (measure, field->magClass); 
     228              break;
     229            case MAG_LEVEL_SYS:
     230            case MAG_LEVEL_REL:
     231            case MAG_LEVEL_CAL:
     232              // value.Flt = PhotFluxErr (measure, field->magClass); 
     233              break;
     234            case MAG_LEVEL_AVE:
     235            case MAG_LEVEL_REF:
     236              // value.Flt = PhotFluxAveErr (equiv, average, secfilt, field->magClass, field->magSource); 
     237              break;
     238            case MAG_LEVEL_NONE:
     239              break;
     240          }
    281241          break;
    282         case MAG_STDEV:
    283           value.Flt = PhotMstdev (equiv, average, secfilt);
    284           break;
    285         case MAG_20:
    286           value.Flt = PhotM20 (equiv, average, secfilt);
    287           break;
    288         case MAG_80:
    289           value.Flt = PhotM80 (equiv, average, secfilt);
    290           break;
    291         case MAG_UC_DIST:
    292           value.Flt = PhotUCdist (equiv, average, secfilt);
    293           break;
    294 
    295         case MAG_FLUX_PSF:
    296           value.Flt = PhotAveFluxPSF (field->photcode, average, secfilt);
    297           break;
    298         case MAG_FLUX_PSF_ERR:
    299           value.Flt = PhotAvedFluxPSF (field->photcode, average, secfilt);
    300           break;
    301         case MAG_FLUX_KRON:
    302           value.Flt = PhotAveFluxKron (field->photcode, average, secfilt);
    303           break;
    304         case MAG_FLUX_KRON_ERR:
    305           value.Flt = PhotAvedFluxKron (field->photcode, average, secfilt);
     242
     243        case MAG_OPTION_STDEV:
     244        case MAG_OPTION_CHISQ:
     245        case MAG_OPTION_MIN:
     246        case MAG_OPTION_MAX:
     247        case MAG_OPTION_NCODE:
     248        case MAG_OPTION_NPHOT:
     249        case MAG_OPTION_UC_DIST:
     250        case MAG_OPTION_STACK_DET_ID:
     251        case MAG_OPTION_FLAGS:
     252        case MAG_OPTION_NONE:
    306253          break;
    307254      }
    … …  
    309256    }
    310257    case MEAS_RA: /* OK */
    311       value.Flt = average[0].R - measure[0].dR / 3600.0;
     258      value.Flt = measure[0].R;
    312259      break;
    313260    case MEAS_DEC: /* OK */
    314       value.Flt = average[0].D - measure[0].dD / 3600.0;
     261      value.Flt = measure[0].D;
    315262      break;
    316263    case MEAS_RA_AVE: /* OK */
    … …  
    323270    case MEAS_GLON:
    324271      if (!haveGalacticMeas) {
    325         ApplyTransform (&GLON_MEAS, &GLAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_galactic);
     272        ApplyTransform (&GLON_MEAS, &GLAT_MEAS, measure[0].R, measure[0].D, celestial_to_galactic);
    326273        haveGalacticMeas = TRUE;
    327274      }
    … …  
    330277    case MEAS_GLAT:
    331278      if (!haveGalacticMeas) {
    332         ApplyTransform (&GLON_MEAS, &GLAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_galactic);
     279        ApplyTransform (&GLON_MEAS, &GLAT_MEAS, measure[0].R, measure[0].D, celestial_to_galactic);
    333280        haveGalacticMeas = TRUE;
    334281      }
    … …  
    337284    case MEAS_ELON:
    338285      if (!haveEclipticMeas) {
    339         ApplyTransform (&ELON_MEAS, &ELAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_ecliptic);
     286        ApplyTransform (&ELON_MEAS, &ELAT_MEAS, measure[0].R, measure[0].D, celestial_to_ecliptic);
    340287        haveEclipticMeas = TRUE;
    341288      }
    … …  
    344291    case MEAS_ELAT:
    345292      if (!haveEclipticMeas) {
    346         ApplyTransform (&ELON_MEAS, &ELAT_MEAS, average[0].R - measure[0].dR / 3600.0, average[0].D - measure[0].dD / 3600.0, celestial_to_ecliptic);
     293        ApplyTransform (&ELON_MEAS, &ELAT_MEAS, measure[0].R, measure[0].D, celestial_to_ecliptic);
    347294        haveEclipticMeas = TRUE;
    348295      }
    … …  
    441388    // the error.
    442389    case MEAS_RA_OFFSET: /* OK */
    443       value.Flt = measure[0].dR;
     390      value.Flt = dvoOffsetR (measure, average);
    444391      break;
    445392    case MEAS_DEC_OFFSET: /* OK */
    446       value.Flt = measure[0].dD;
     393      value.Flt = dvoOffsetD (measure, average);
    447394      break;
    448395    case MEAS_RA_FIT_OFFSET: /* OK */
    449396      dT = (measure[0].t - average[0].Tmean) / (86400*365.25);
    450       value.Flt = average[0].uR * dT + measure[0].dR;
     397      dR = dvoOffsetR (measure, average);
     398      value.Flt = average[0].uR * dT + dR;
    451399      break;
    452400    case MEAS_DEC_FIT_OFFSET: /* OK */
    453401      dT = (measure[0].t - average[0].Tmean) / (86400*365.25);
    454       value.Flt = average[0].uD * dT + measure[0].dD;
     402      dD = dvoOffsetD (measure, average);
     403      value.Flt = average[0].uD * dT + dD;
    455404      break;
    456405    case MEAS_RA_OFFSET_ERR: /* OK */
    … …  
    527476
    528477    case MEAS_REF_COLOR:
    529       value.Flt = average[0].refColor;
     478      value.Flt = average[0].refColorBlue;
    530479      break;
    531480
    … …  
    556505        // measure.xccd if we need it
    557506        Image *image;
    558         ra  = average[0].R - measure[0].dR / 3600.0;
    559         dec = average[0].D - measure[0].dD / 3600.0;
     507        ra  = measure[0].R;
     508        dec = measure[0].D;
    560509        image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID);
    561510        if (image == NULL) break;
    … …  
    571520      {
    572521        Image *image;
    573         ra  = average[0].R - measure[0].dR / 3600.0;
    574         dec = average[0].D - measure[0].dD / 3600.0;
     522        ra  = measure[0].R;
     523        dec = measure[0].D;
    575524        image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID);
    576525        if (image == NULL) break;
    … …  
    607556        }
    608557        if (fieldc == NULL) break;
    609         double Rm = average[0].R - measure[0].dR / 3600.0;
    610         double Dm = average[0].D - measure[0].dD / 3600.0;
     558        double Rm = measure[0].R;
     559        double Dm = measure[0].D;
    611560        RD_to_XY (&XFIELD_MEAS, &YFIELD_MEAS, Rm, Dm, fieldc);
    612561      }
    … …  
    624573        }
    625574        if (fieldc == NULL) break;
    626         double Rm = average[0].R - measure[0].dR / 3600.0;
    627         double Dm = average[0].D - measure[0].dD / 3600.0;
     575        double Rm = measure[0].R;
     576        double Dm = measure[0].D;
    628577        RD_to_XY (&XFIELD_MEAS, &YFIELD_MEAS, Rm, Dm, fieldc);
    629578      }
    … …  
    642591        }
    643592        if (mosaic == NULL) break;
    644         double Rm = average[0].R - measure[0].dR / 3600.0;
    645         double Dm = average[0].D - measure[0].dD / 3600.0;
     593        double Rm = measure[0].R;
     594        double Dm = measure[0].D;
    646595        RD_to_XY (&XMOS_MEAS, &YMOS_MEAS, Rm, Dm, mosaic);
    647596      }
    … …  
    659608        }
    660609        if (mosaic == NULL) break;
    661         double Rm = average[0].R - measure[0].dR / 3600.0;
    662         double Dm = average[0].D - measure[0].dD / 3600.0;
     610        double Rm = measure[0].R;
     611        double Dm = measure[0].D;
    663612        RD_to_XY (&XMOS_MEAS, &YMOS_MEAS, Rm, Dm, mosaic);
    664613      }
    … …  
    773722      break;
    774723
    775     case MEAS_FLUX_PSF: /* OK */
    776       value.Flt = measure[0].FluxPSF;
    777       break;
    778     case MEAS_FLUX_PSF_ERR: /* OK */
    779       value.Flt = measure[0].dFluxPSF;
    780       break;
    781     case MEAS_FLUX_KRON: /* OK */
    782       value.Flt = measure[0].FluxKron;
    783       break;
    784     case MEAS_FLUX_KRON_ERR: /* OK */
    785       value.Flt = measure[0].dFluxKron;
    786       break;
     724    // case MEAS_FLUX_PSF: /* OK */
     725    //   value.Flt = measure[0].FluxPSF;
     726    //   break;
     727    // case MEAS_FLUX_PSF_ERR: /* OK */
     728    //   value.Flt = measure[0].dFluxPSF;
     729    //   break;
     730    // case MEAS_FLUX_KRON: /* OK */
     731    //   value.Flt = measure[0].FluxKron;
     732    //   break;
     733    // case MEAS_FLUX_KRON_ERR: /* OK */
     734    //   value.Flt = measure[0].dFluxKron;
     735    //   break;
    787736  }
    788737  return (value);

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

    r36840 r37035  
    99  for (i = 0; i < Nfields; i++) {
    1010    if (fields[i].name != NULL) free (fields[i].name);
    11     if (fields[i].photcode != NULL) {
    12       if (fields[i].photcode[0].type == PHOT_MAG) {
    13         free (fields[i].photcode);
    14       }
    15     }
    1611  }
    1712  free (fields);
    … …  
    2419  field->ID = 0;
    2520  field->type = OPIHI_FLT;
    26   field->magMode = 0;
     21
     22  field->magSource = MAG_SRC_NONE;
     23  field->magLevel  = MAG_LEVEL_NONE;
     24  field->magClass  = MAG_CLASS_NONE;
     25  field->magOption = MAG_OPTION_NONE;
     26
    2727  field->photcode = NULL;
    2828}
    2929
     30dvoMagSourceType GetMagSource (char *string) {
     31
     32  if (!strcasecmp (string, "chip")) return (MAG_SRC_CHP);
     33  if (!strcasecmp (string, "warp")) return (MAG_SRC_WRP);
     34  if (!strcasecmp (string, "stack")) return (MAG_SRC_STK);
     35
     36  if (!strcasecmp (string, "chp")) return (MAG_SRC_CHP);
     37  if (!strcasecmp (string, "wrp")) return (MAG_SRC_WRP);
     38  if (!strcasecmp (string, "stk")) return (MAG_SRC_STK);
     39
     40  return MAG_SRC_NONE;
     41}
     42
     43dvoMagLevelType GetMagLevel (char *string) {
     44
     45  if (!strcasecmp (string, "inst")) return (MAG_LEVEL_INST);
     46  if (!strcasecmp (string, "cat"))  return (MAG_LEVEL_CAT);
     47  if (!strcasecmp (string, "sys"))  return (MAG_LEVEL_SYS);
     48  if (!strcasecmp (string, "rel"))  return (MAG_LEVEL_REL);
     49  if (!strcasecmp (string, "cal"))  return (MAG_LEVEL_CAL);
     50  if (!strcasecmp (string, "ave"))  return (MAG_LEVEL_AVE);
     51  if (!strcasecmp (string, "ref"))  return (MAG_LEVEL_REF);
     52
     53  return MAG_LEVEL_NONE;
     54}
     55
     56dvoMagClassType GetMagClass (char *string) {
     57
     58  if (!strcasecmp (string, "psf"))   return (MAG_CLASS_PSF);
     59  if (!strcasecmp (string, "kron"))  return (MAG_CLASS_KRON);
     60  if (!strcasecmp (string, "aper"))  return (MAG_CLASS_APER);
     61  if (!strcasecmp (string, "ap"))    return (MAG_CLASS_APER);
     62
     63  return MAG_CLASS_NONE;
     64}
     65
     66dvoMagOptionType GetMagOption (char *string) {
     67
     68  if (!strcasecmp (string, "mag"))          return (MAG_OPTION_MAG);
     69  if (!strcasecmp (string, "err"))          return (MAG_OPTION_ERR);
     70  if (!strcasecmp (string, "magerr"))       return (MAG_OPTION_ERR);
     71  if (!strcasecmp (string, "flux"))         return (MAG_OPTION_FLUX);
     72  if (!strcasecmp (string, "fluxerr"))      return (MAG_OPTION_FLUX_ERR);
     73  if (!strcasecmp (string, "stdev"))        return (MAG_OPTION_STDEV);
     74  if (!strcasecmp (string, "chisq"))        return (MAG_OPTION_CHISQ);
     75  if (!strcasecmp (string, "min"))          return (MAG_OPTION_MIN);
     76  if (!strcasecmp (string, "max"))          return (MAG_OPTION_MAX);
     77  if (!strcasecmp (string, "ncode"))        return (MAG_OPTION_NCODE);
     78  if (!strcasecmp (string, "nphot"))        return (MAG_OPTION_NPHOT);
     79  if (!strcasecmp (string, "uc_dist"))      return (MAG_OPTION_UC_DIST);
     80  if (!strcasecmp (string, "stack_det_id")) return (MAG_OPTION_STACK_DET_ID);
     81  if (!strcasecmp (string, "flags"))        return (MAG_OPTION_FLAGS);
     82
     83  return MAG_OPTION_NONE;
     84}
     85
     86# if (0)
    3087int GetMagMode (char *string) {
    3188
    … …  
    85142  if (!strcasecmp (string, "nphot"))       return (MAG_NPHOT);
    86143  if (!strcasecmp (string, "stdev"))       return (MAG_STDEV);
    87   if (!strcasecmp (string, "20"))          return (MAG_20);
    88   if (!strcasecmp (string, "80"))          return (MAG_80);
     144  if (!strcasecmp (string, "min"))         return (MAG_MIN);
     145  if (!strcasecmp (string, "max"))         return (MAG_MAX);
    89146  if (!strcasecmp (string, "ucdist"))      return (MAG_UC_DIST);
    90147  if (!strcasecmp (string, "stackDetectID")) return (MAG_STACK_DET_ID);
    … …  
    95152  return (MAG_NONE);
    96153}
    97 
    98 PhotCode *ParsePhotcodeField (char *field, int *mode, int defMode) {
    99 
    100   int useDefault;
    101   char *tmpstring, *p;
    102   PhotCode *code;
    103 
    104   *mode = defMode;
    105   useDefault = TRUE;
    106 
    107   p = strchr (field, ':');
    108   if (p != NULL) {
    109     *mode = GetMagMode (p + 1);
    110     useDefault = FALSE;
    111     if (*mode == MAG_NONE) return (NULL);
    112     tmpstring = strncreate (field, p - field);
    113   } else {
    114     tmpstring = strcreate (field);
    115   }
    116   if (!strcasecmp (tmpstring, "MAG")) {
    117     ALLOCATE (code, PhotCode, 1);
    118     code[0].code = 0;
    119     strcpy (code[0].name, "MAG");
    120     code[0].type = PHOT_MAG;
    121     // the field call 'mag' is only valid for mextract
    122     // it should default to REL, but other types should default to AVE
    123     if (useDefault) {
    124       *mode = MAG_REL;
     154# endif
     155
     156// field may be of the form mag:psf:inst:wrp.  except for the first subword,
     157// the words may be in any order
     158int ParsePhotcodeField (dbField *field, char *fieldName, int fieldID) {
     159
     160  int j;
     161
     162  // defaults:
     163  field->ID = fieldID; // change if not true in the end?
     164
     165  // check what options are provided.  do not allow duplicate types
     166  // except mag and flux may exist with err
     167  dvoMagSourceType mySource = MAG_SRC_NONE;
     168  dvoMagLevelType myLevel = MAG_LEVEL_NONE;
     169  dvoMagClassType myClass = MAG_CLASS_NONE;
     170  dvoMagOptionType myOption = MAG_OPTION_NONE;
     171
     172  field->magSource = MAG_SRC_CHP;
     173  field->magLevel  = MAG_LEVEL_AVE;
     174  field->magClass  = MAG_CLASS_PSF;
     175  field->magOption = MAG_OPTION_MAG;
     176
     177  // make a local working copy of fieldName and replace ':' with spaces
     178  char *fieldCopy = strcreate(fieldName);
     179  for (j = 0; fieldCopy[j]; j++) {
     180    if (fieldCopy[j] == ':') fieldCopy[j] = ' ';
     181  }
     182
     183  char *firstWord = getword(fieldCopy);
     184 
     185  // firstWord may be either flux, mag or photcode
     186  if (!strcasecmp (firstWord, "MAG")) {
     187    // default level for 'mag' is rel
     188    field->magLevel  = MAG_LEVEL_REL;
     189    myOption = MAG_OPTION_MAG;
     190  }
     191  if (!strcasecmp (firstWord, "FLUX")) {
     192    // default level for 'flux' is rel
     193    field->magLevel  = MAG_LEVEL_REL;
     194    myOption = MAG_OPTION_FLUX;
     195  }
     196  PhotCode *code = GetPhotcodebyName (firstWord);
     197  free (firstWord);
     198
     199  if (!code) return FALSE;
     200
     201  // defaults for photcode clases
     202  if (code->type == PHOT_DEP) {
     203    field->magLevel = MAG_LEVEL_REL;
     204  }
     205  if (code->type == PHOT_SEC) {
     206    field->magLevel = MAG_LEVEL_AVE;
     207  }
     208  if (code->type == PHOT_REF) {
     209    field->magLevel = MAG_LEVEL_CAT;
     210    // is this one required?
     211  }
     212 
     213  // look at the remaining words and assign properties as approrpiate
     214  char *ptr = skipword(fieldCopy);
     215  while (ptr) {
     216
     217    char *word = getword(ptr);
     218    if (!word) break;
     219   
     220    dvoMagSourceType source = GetMagSource (word);
     221    if (source != MAG_SRC_NONE) {
     222      if (mySource != MAG_SRC_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; }
     223      mySource = source;
     224      ptr = skipword (ptr);
     225      continue;
    125226    }
    126     free (tmpstring);
    127     return (code);
    128   }
    129   code = GetPhotcodebyName (tmpstring);
    130   if (!code) {
    131       return NULL;
    132   }
    133 
    134   // enforce compatibility
    135   if (useDefault) {
    136     if (code[0].type == PHOT_REF) {
    137       *mode = MAG_CAT;
     227
     228    dvoMagLevelType level = GetMagLevel (word);
     229    if (level != MAG_LEVEL_NONE) {
     230      if (myLevel != MAG_LEVEL_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; }
     231      myLevel = level;
     232      ptr = skipword (ptr);
     233      continue;
    138234    }
    139     if (code[0].type == PHOT_DEP) {
    140       *mode = MAG_REL;
     235
     236    dvoMagClassType class = GetMagClass (word);
     237    if (class != MAG_CLASS_NONE) {
     238      if (myClass != MAG_CLASS_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; }
     239      myClass = class;
     240      ptr = skipword (ptr);
     241      continue;
    141242    }
    142   }
    143   free (tmpstring);
    144   return (code);
    145 }
    146 
    147 # define ESCAPE(F,M,T) { \
    148   field->ID = (F); \
    149   field->magMode = (M); \
    150   field->type = (T); \
    151   field->photcode = NULL; \
    152   return (TRUE); }
    153 
    154 int ParseMeasureField (dbField *field, char *fieldName) {
    155 
    156   int mode;
    157   PhotCode *code;
    158 
    159   field->table = DVO_TABLE_MEASURE;
    160   field->name  = strcreate (fieldName);
    161 
    162   if (!strcasecmp (fieldName, "GLON"))       {
    163     dbExtractMeasuresInitTransform (COORD_GALACTIC);
    164     ESCAPE (MEAS_GLON, MAG_NONE, OPIHI_FLT);
    165   }
    166   if (!strcasecmp (fieldName, "GLAT")) {
    167     dbExtractMeasuresInitTransform (COORD_GALACTIC);
    168     ESCAPE (MEAS_GLAT, MAG_NONE, OPIHI_FLT);
    169   }
    170   if (!strcasecmp (fieldName, "GLON:AVE")) {
    171     dbExtractMeasuresInitTransform (COORD_GALACTIC);
    172     ESCAPE (MEAS_GLON_AVE, MAG_NONE, OPIHI_FLT);
    173   }
    174   if (!strcasecmp (fieldName, "GLAT:AVE")) {
    175     dbExtractMeasuresInitTransform (COORD_GALACTIC);
    176     ESCAPE (MEAS_GLAT_AVE, MAG_NONE, OPIHI_FLT);
    177   }
    178 
    179   if (!strcasecmp (fieldName, "ELON"))       {
    180     dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
    181     ESCAPE (MEAS_ELON, MAG_NONE, OPIHI_FLT);
    182   }
    183   if (!strcasecmp (fieldName, "ELAT")) {
    184     dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
    185     ESCAPE (MEAS_ELAT, MAG_NONE, OPIHI_FLT);
    186   }
    187   if (!strcasecmp (fieldName, "ELON:AVE")) {
    188     dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
    189     ESCAPE (MEAS_ELON_AVE, MAG_NONE, OPIHI_FLT);
    190   }
    191   if (!strcasecmp (fieldName, "ELAT:AVE")) {
    192     dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
    193     ESCAPE (MEAS_ELAT_AVE, MAG_NONE, OPIHI_FLT);
    194   }
    195 
    196   if (!strcasecmp (fieldName, "RA"))             ESCAPE (MEAS_RA,             MAG_NONE, OPIHI_FLT);
    197   if (!strcasecmp (fieldName, "DEC"))            ESCAPE (MEAS_DEC,            MAG_NONE, OPIHI_FLT);
    198   if (!strcasecmp (fieldName, "RA:AVE"))         ESCAPE (MEAS_RA_AVE,         MAG_NONE, OPIHI_FLT);
    199   if (!strcasecmp (fieldName, "DEC:AVE"))        ESCAPE (MEAS_DEC_AVE,        MAG_NONE, OPIHI_FLT);
    200   if (!strcasecmp (fieldName, "RA:ERR"))         ESCAPE (MEAS_RA_AVE_ERR,     MAG_NONE, OPIHI_FLT);
    201   if (!strcasecmp (fieldName, "DEC:ERR"))        ESCAPE (MEAS_DEC_AVE_ERR,    MAG_NONE, OPIHI_FLT);
    202   if (!strcasecmp (fieldName, "uRA"))            ESCAPE (MEAS_U_RA,           MAG_NONE, OPIHI_FLT);
    203   if (!strcasecmp (fieldName, "uDEC"))           ESCAPE (MEAS_U_DEC,          MAG_NONE, OPIHI_FLT);
    204   if (!strcasecmp (fieldName, "duRA"))           ESCAPE (MEAS_U_RA_ERR,       MAG_NONE, OPIHI_FLT);
    205   if (!strcasecmp (fieldName, "duDEC"))          ESCAPE (MEAS_U_DEC_ERR,      MAG_NONE, OPIHI_FLT);
    206   if (!strcasecmp (fieldName, "PAR"))            ESCAPE (MEAS_PAR,            MAG_NONE, OPIHI_FLT);
    207   if (!strcasecmp (fieldName, "dPAR"))           ESCAPE (MEAS_PAR_ERR,        MAG_NONE, OPIHI_FLT);
    208   if (!strcasecmp (fieldName, "dR"))             ESCAPE (MEAS_RA_OFFSET,      MAG_NONE, OPIHI_FLT);
    209   if (!strcasecmp (fieldName, "dD"))             ESCAPE (MEAS_DEC_OFFSET,     MAG_NONE, OPIHI_FLT);
    210   if (!strcasecmp (fieldName, "dR:FIT"))         ESCAPE (MEAS_RA_FIT_OFFSET,  MAG_NONE, OPIHI_FLT);
    211   if (!strcasecmp (fieldName, "dD:FIT"))         ESCAPE (MEAS_DEC_FIT_OFFSET, MAG_NONE, OPIHI_FLT);
    212   if (!strcasecmp (fieldName, "dR:ERR"))         ESCAPE (MEAS_RA_OFFSET_ERR,  MAG_NONE, OPIHI_FLT);
    213   if (!strcasecmp (fieldName, "dD:ERR"))         ESCAPE (MEAS_DEC_OFFSET_ERR, MAG_NONE, OPIHI_FLT);
    214   if (!strcasecmp (fieldName, "ChiSqPos"))       ESCAPE (MEAS_CHISQ_POS,      MAG_NONE, OPIHI_FLT);
    215   if (!strcasecmp (fieldName, "ChiSqPM"))        ESCAPE (MEAS_CHISQ_PM,       MAG_NONE, OPIHI_FLT);
    216   if (!strcasecmp (fieldName, "ChiSqPar"))       ESCAPE (MEAS_CHISQ_PAR,      MAG_NONE, OPIHI_FLT);
    217   if (!strcasecmp (fieldName, "Tmean"))          ESCAPE (MEAS_TMEAN,          MAG_NONE, OPIHI_FLT);
    218   if (!strcasecmp (fieldName, "Trange"))         ESCAPE (MEAS_TRANGE,         MAG_NONE, OPIHI_FLT);
    219   if (!strcasecmp (fieldName, "nmeas"))          ESCAPE (MEAS_NMEAS,          MAG_NONE, OPIHI_INT);
    220   if (!strcasecmp (fieldName, "nmiss"))          ESCAPE (MEAS_NMISS,          MAG_NONE, OPIHI_INT);
    221   if (!strcasecmp (fieldName, "npos"))           ESCAPE (MEAS_NPOS,           MAG_NONE, OPIHI_INT);
    222   if (!strcasecmp (fieldName, "OBJFLAGS"))       ESCAPE (MEAS_OBJ_FLAGS,      MAG_NONE, OPIHI_INT);
    223   if (!strcasecmp (fieldName, "OBJ_FLAGS"))      ESCAPE (MEAS_OBJ_FLAGS,      MAG_NONE, OPIHI_INT);
    224   if (!strcasecmp (fieldName, "OBJ_PHOT_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS,      MAG_NONE, OPIHI_INT);
    225   if (!strcasecmp (fieldName, "SECFLAGS"))       ESCAPE (MEAS_SECFILT_FLAGS,      MAG_NONE, OPIHI_INT);
    226   if (!strcasecmp (fieldName, "SEC_FLAGS"))      ESCAPE (MEAS_SECFILT_FLAGS,      MAG_NONE, OPIHI_INT);
    227   if (!strcasecmp (fieldName, "SECFILT_FLAGS"))  ESCAPE (MEAS_SECFILT_FLAGS,      MAG_NONE, OPIHI_INT);
    228   if (!strcasecmp (fieldName, "DB_FLAGS"))       ESCAPE (MEAS_DB_FLAGS,       MAG_NONE, OPIHI_INT);
    229   if (!strcasecmp (fieldName, "PHOT_FLAGS"))     ESCAPE (MEAS_PHOT_FLAGS,     MAG_NONE, OPIHI_INT);
    230   if (!strcasecmp (fieldName, "DBFLAGS"))        ESCAPE (MEAS_DB_FLAGS,       MAG_NONE, OPIHI_INT);
    231   if (!strcasecmp (fieldName, "PHOTFLAGS"))      ESCAPE (MEAS_PHOT_FLAGS,     MAG_NONE, OPIHI_INT);
    232   if (!strcasecmp (fieldName, "AIRMASS"))        ESCAPE (MEAS_AIRMASS,        MAG_NONE, OPIHI_FLT);
    233   if (!strcasecmp (fieldName, "MEAN_AIRMASS"))   ESCAPE (MEAS_MEAN_AIRMASS,   MAG_NONE, OPIHI_FLT);
    234   if (!strcasecmp (fieldName, "ALT"))            ESCAPE (MEAS_ALT,            MAG_NONE, OPIHI_FLT);
    235   if (!strcasecmp (fieldName, "AZ"))             ESCAPE (MEAS_AZ,             MAG_NONE, OPIHI_FLT);
    236   if (!strcasecmp (fieldName, "EXPTIME"))        ESCAPE (MEAS_EXPTIME,        MAG_NONE, OPIHI_FLT);
    237   if (!strcasecmp (fieldName, "PHOTCODE"))       ESCAPE (MEAS_PHOTCODE,       MAG_NONE, OPIHI_INT);
    238   if (!strcasecmp (fieldName, "PHOTCODE:KLAM"))  ESCAPE (MEAS_PHOTCODE_KLAM,  MAG_NONE, OPIHI_FLT);
    239   if (!strcasecmp (fieldName, "PHOTCODE:C"))     ESCAPE (MEAS_PHOTCODE_C,     MAG_NONE, OPIHI_FLT);
    240   if (!strcasecmp (fieldName, "PHOTCODE:EQUIV")) ESCAPE (MEAS_PHOTCODE_EQUIV, MAG_NONE, OPIHI_INT);
    241   if (!strcasecmp (fieldName, "TIME"))           ESCAPE (MEAS_TIME,           MAG_NONE, OPIHI_FLT);
    242   if (!strcasecmp (fieldName, "FWHM"))           ESCAPE (MEAS_FWHM,           MAG_NONE, OPIHI_FLT);
    243   if (!strcasecmp (fieldName, "FWHM_MAJ"))       ESCAPE (MEAS_FWHM_MAJ,       MAG_NONE, OPIHI_FLT);
    244   if (!strcasecmp (fieldName, "FWHM_MIN"))       ESCAPE (MEAS_FWHM_MIN,       MAG_NONE, OPIHI_FLT);
    245   if (!strcasecmp (fieldName, "THETA"))          ESCAPE (MEAS_THETA,          MAG_NONE, OPIHI_FLT);
    246   if (!strcasecmp (fieldName, "POSANGLE"))       ESCAPE (MEAS_POSANGLE,       MAG_NONE, OPIHI_FLT);
    247   if (!strcasecmp (fieldName, "PLATESCALE"))     ESCAPE (MEAS_PLATESCALE,     MAG_NONE, OPIHI_FLT);
    248   if (!strcasecmp (fieldName, "MXX"))            ESCAPE (MEAS_MXX,            MAG_NONE, OPIHI_FLT);
    249   if (!strcasecmp (fieldName, "MYY"))            ESCAPE (MEAS_MYY,            MAG_NONE, OPIHI_FLT);
    250   if (!strcasecmp (fieldName, "MXY"))            ESCAPE (MEAS_MXY,            MAG_NONE, OPIHI_FLT);
    251   if (!strcasecmp (fieldName, "DOPHOT"))         ESCAPE (MEAS_DOPHOT,         MAG_NONE, OPIHI_INT);
    252   if (!strcasecmp (fieldName, "XCCD"))           ESCAPE (MEAS_XCCD,           MAG_NONE, OPIHI_FLT);
    253   if (!strcasecmp (fieldName, "YCCD"))           ESCAPE (MEAS_YCCD,           MAG_NONE, OPIHI_FLT);
    254   if (!strcasecmp (fieldName, "XCCD:ERR"))       ESCAPE (MEAS_XCCD_ERR,       MAG_NONE, OPIHI_FLT);
    255   if (!strcasecmp (fieldName, "YCCD:ERR"))       ESCAPE (MEAS_YCCD_ERR,       MAG_NONE, OPIHI_FLT);
    256   if (!strcasecmp (fieldName, "XFIX"))           ESCAPE (MEAS_XFIX,           MAG_NONE, OPIHI_FLT);
    257   if (!strcasecmp (fieldName, "YFIX"))           ESCAPE (MEAS_YFIX,           MAG_NONE, OPIHI_FLT);
    258   if (!strcasecmp (fieldName, "POS_SYS_ERR"))    ESCAPE (MEAS_POS_SYS_ERR,    MAG_NONE, OPIHI_FLT);
    259   if (!strcasecmp (fieldName, "XFIELD"))         ESCAPE (MEAS_XFIELD,         MAG_NONE, OPIHI_FLT);
    260   if (!strcasecmp (fieldName, "YFIELD"))         ESCAPE (MEAS_YFIELD,         MAG_NONE, OPIHI_FLT);
    261   if (!strcasecmp (fieldName, "XMOSAIC"))        ESCAPE (MEAS_XMOSAIC,        MAG_NONE, OPIHI_FLT);
    262   if (!strcasecmp (fieldName, "YMOSAIC"))        ESCAPE (MEAS_YMOSAIC,        MAG_NONE, OPIHI_FLT);
    263   if (!strcasecmp (fieldName, "XCHIP"))          ESCAPE (MEAS_XCCD,           MAG_NONE, OPIHI_FLT);
    264   if (!strcasecmp (fieldName, "YCHIP"))          ESCAPE (MEAS_YCCD,           MAG_NONE, OPIHI_FLT);
    265   if (!strcasecmp (fieldName, "XFPA"))           ESCAPE (MEAS_XMOSAIC,        MAG_NONE, OPIHI_FLT);
    266   if (!strcasecmp (fieldName, "YFPA"))           ESCAPE (MEAS_YMOSAIC,        MAG_NONE, OPIHI_FLT);
    267   if (!strcasecmp (fieldName, "DETID"))          ESCAPE (MEAS_DET_ID,         MAG_NONE, OPIHI_INT);
    268   if (!strcasecmp (fieldName, "OBJID"))          ESCAPE (MEAS_OBJ_ID,         MAG_NONE, OPIHI_INT);
    269   if (!strcasecmp (fieldName, "CATID"))          ESCAPE (MEAS_CAT_ID,         MAG_NONE, OPIHI_INT);
    270   if (!strcasecmp (fieldName, "IMAGEID"))        ESCAPE (MEAS_IMAGE_ID,       MAG_NONE, OPIHI_INT);
    271   if (!strcasecmp (fieldName, "EXTERNID"))       ESCAPE (MEAS_EXTERN_ID,      MAG_NONE, OPIHI_INT);
    272   if (!strcasecmp (fieldName, "EXPNAME"))        ESCAPE (MEAS_EXPNAME_AS_INT, MAG_NONE, OPIHI_INT);
    273   if (!strcasecmp (fieldName, "PSF_QF"))         ESCAPE (MEAS_PSF_QF,         MAG_NONE, OPIHI_FLT);
    274   if (!strcasecmp (fieldName, "PSF_QF_PERFECT")) ESCAPE (MEAS_PSF_QF_PERFECT, MAG_NONE, OPIHI_FLT);
    275   if (!strcasecmp (fieldName, "PSF_CHISQ"))      ESCAPE (MEAS_PSF_CHISQ,      MAG_NONE, OPIHI_FLT);
    276   if (!strcasecmp (fieldName, "PSF_NDOF"))       ESCAPE (MEAS_PSF_NDOF,       MAG_NONE, OPIHI_INT);
    277   if (!strcasecmp (fieldName, "PSF_NPIX"))       ESCAPE (MEAS_PSF_NPIX,       MAG_NONE, OPIHI_INT);
    278   if (!strcasecmp (fieldName, "CR_NSIGMA"))      ESCAPE (MEAS_CR_NSIGMA,      MAG_NONE, OPIHI_FLT);
    279   if (!strcasecmp (fieldName, "EXT_NSIGMA"))     ESCAPE (MEAS_EXT_NSIGMA,     MAG_NONE, OPIHI_FLT);
    280   if (!strcasecmp (fieldName, "SKY"))            ESCAPE (MEAS_SKY,            MAG_NONE, OPIHI_FLT);
    281   if (!strcasecmp (fieldName, "SKY_ERR"))        ESCAPE (MEAS_dSKY,           MAG_NONE, OPIHI_FLT);
    282   if (!strcasecmp (fieldName, "MCAL_OFFSET"))    ESCAPE (MEAS_MCAL_OFFSET,    MAG_NONE, OPIHI_FLT);
    283   if (!strcasecmp (fieldName, "FLAT"))           ESCAPE (MEAS_FLAT,           MAG_NONE, OPIHI_FLT);
    284   if (!strcasecmp (fieldName, "CENTER_OFFSET"))  ESCAPE (MEAS_CENTER_OFFSET,  MAG_NONE, OPIHI_FLT);
    285   if (!strcasecmp (fieldName, "FLUX"))           ESCAPE (MEAS_FLUX_PSF,       MAG_NONE, OPIHI_FLT);
    286   if (!strcasecmp (fieldName, "FLUX_ERR"))       ESCAPE (MEAS_FLUX_PSF_ERR,   MAG_NONE, OPIHI_FLT);
    287   if (!strcasecmp (fieldName, "FLUX_PSF"))       ESCAPE (MEAS_FLUX_PSF,       MAG_NONE, OPIHI_FLT);
    288   if (!strcasecmp (fieldName, "FLUX_PSF_ERR"))   ESCAPE (MEAS_FLUX_PSF_ERR,   MAG_NONE, OPIHI_FLT);
    289   if (!strcasecmp (fieldName, "FLUX_KRON"))      ESCAPE (MEAS_FLUX_KRON,      MAG_NONE, OPIHI_FLT);
    290   if (!strcasecmp (fieldName, "FLUX_KRON_ERR"))  ESCAPE (MEAS_FLUX_KRON_ERR,  MAG_NONE, OPIHI_FLT);
    291   if (!strcasecmp (fieldName, "REF_COLOR"))      ESCAPE (MEAS_REF_COLOR,      MAG_NONE, OPIHI_FLT);
    292 
    293   // for words that don't parse, try a photcode
    294 
    295   // check for code:mode in photcode name
    296   code = ParsePhotcodeField (fieldName, &mode, MAG_AVE);
    297   if (code == NULL) {
    298     gprint (GP_ERR, "unknown field '%s' for measurement table in DVO database\n", fieldName);
    299     return (FALSE);
    300   }
    301 
    302   field->ID = MEAS_MAG;
    303   field->magMode = mode;
    304   switch (mode) {
    305     case MAG_STACK_DET_ID:
    306     case MAG_NCODE:
    307     case MAG_NPHOT:
    308     case MAG_PHOT_FLAGS:
     243
     244    dvoMagOptionType option = GetMagOption (word);
     245    if (option != MAG_OPTION_NONE) {
     246      // some combinations are OK: mag + err -> err
     247      if ((myOption == MAG_OPTION_MAG) && (option == MAG_OPTION_ERR)) {
     248        myOption = option;
     249        ptr = skipword (ptr);
     250        continue;
     251      }
     252      // some combinations are OK: err + mag -> err
     253      if ((myOption == MAG_OPTION_ERR) && (option == MAG_OPTION_MAG)) {
     254        ptr = skipword (ptr);
     255        continue;
     256      }
     257      // some combinations are OK: flux + err -> FLUX_ERR
     258      if ((myOption == MAG_OPTION_FLUX) && (option == MAG_OPTION_ERR)) {
     259        myOption = MAG_OPTION_FLUX_ERR;
     260        ptr = skipword (ptr);
     261        continue;
     262      }
     263      // some combinations are OK: err + flux -> FLUX_ERR
     264      if ((myOption == MAG_OPTION_ERR) && (option == MAG_OPTION_FLUX)) {
     265        myOption = MAG_OPTION_FLUX_ERR;
     266        ptr = skipword (ptr);
     267        continue;
     268      }
     269      // some combinations are OK: flux + fluxerr -> FLUX_ERR
     270      if ((myOption == MAG_OPTION_FLUX) && (option == MAG_OPTION_FLUX_ERR)) {
     271        myOption = MAG_OPTION_FLUX_ERR;
     272        ptr = skipword (ptr);
     273        continue;
     274      }
     275      // some combinations are OK: fluxerr + flux -> FLUX_ERR
     276      if ((myOption == MAG_OPTION_FLUX_ERR) && (option == MAG_OPTION_FLUX)) {
     277        myOption = MAG_OPTION_FLUX_ERR;
     278        ptr = skipword (ptr);
     279        continue;
     280      }
     281      if (myOption != MAG_OPTION_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; }
     282      myOption = option;
     283      ptr = skipword (ptr);
     284      continue;
     285    }
     286
     287    fprintf (stderr, "ERROR: unknown mag/photocode argument %s\n", word);
     288    free (word);
     289  }
     290
     291  // if nothing is provided, use the defaults
     292  field->magSource = (mySource == MAG_SRC_NONE)    ? field->magSource : mySource;
     293  field->magLevel  = (myLevel  == MAG_LEVEL_NONE)  ? field->magLevel  : myLevel;
     294  field->magClass  = (myClass  == MAG_CLASS_NONE)  ? field->magClass  : myClass;
     295  field->magOption = (myOption == MAG_OPTION_NONE) ? field->magOption : myOption;
     296
     297  switch (field->magOption) {
     298    case MAG_OPTION_STACK_DET_ID:
     299    case MAG_OPTION_NCODE:
     300    case MAG_OPTION_NPHOT:
     301    case MAG_OPTION_FLAGS:
    309302      field->type = OPIHI_INT;
    310303      break;
    … …  
    314307  }
    315308  field->photcode = code;
     309  return TRUE;
     310}
     311
     312// field needs to be initialized with dbInitField()
     313# define ESCAPE(F,T) { \
     314  field->ID = (F); \
     315  field->type = (T); \
     316  return (TRUE); }
     317
     318int ParseMeasureField (dbField *field, char *fieldName) {
     319
     320  field->table = DVO_TABLE_MEASURE;
     321  field->name  = strcreate (fieldName);
     322
     323  if (!strcasecmp (fieldName, "GLON"))       {
     324    dbExtractMeasuresInitTransform (COORD_GALACTIC);
     325    ESCAPE (MEAS_GLON, OPIHI_FLT);
     326  }
     327  if (!strcasecmp (fieldName, "GLAT")) {
     328    dbExtractMeasuresInitTransform (COORD_GALACTIC);
     329    ESCAPE (MEAS_GLAT, OPIHI_FLT);
     330  }
     331  if (!strcasecmp (fieldName, "GLON:AVE")) {
     332    dbExtractMeasuresInitTransform (COORD_GALACTIC);
     333    ESCAPE (MEAS_GLON_AVE, OPIHI_FLT);
     334  }
     335  if (!strcasecmp (fieldName, "GLAT:AVE")) {
     336    dbExtractMeasuresInitTransform (COORD_GALACTIC);
     337    ESCAPE (MEAS_GLAT_AVE, OPIHI_FLT);
     338  }
     339
     340  if (!strcasecmp (fieldName, "ELON"))       {
     341    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
     342    ESCAPE (MEAS_ELON, OPIHI_FLT);
     343  }
     344  if (!strcasecmp (fieldName, "ELAT")) {
     345    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
     346    ESCAPE (MEAS_ELAT, OPIHI_FLT);
     347  }
     348  if (!strcasecmp (fieldName, "ELON:AVE")) {
     349    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
     350    ESCAPE (MEAS_ELON_AVE, OPIHI_FLT);
     351  }
     352  if (!strcasecmp (fieldName, "ELAT:AVE")) {
     353    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
     354    ESCAPE (MEAS_ELAT_AVE, OPIHI_FLT);
     355  }
     356
     357  if (!strcasecmp (fieldName, "RA"))             ESCAPE (MEAS_RA,             OPIHI_FLT);
     358  if (!strcasecmp (fieldName, "DEC"))            ESCAPE (MEAS_DEC,            OPIHI_FLT);
     359  if (!strcasecmp (fieldName, "RA:AVE"))         ESCAPE (MEAS_RA_AVE,         OPIHI_FLT);
     360  if (!strcasecmp (fieldName, "DEC:AVE"))        ESCAPE (MEAS_DEC_AVE,        OPIHI_FLT);
     361  if (!strcasecmp (fieldName, "RA:ERR"))         ESCAPE (MEAS_RA_AVE_ERR,     OPIHI_FLT);
     362  if (!strcasecmp (fieldName, "DEC:ERR"))        ESCAPE (MEAS_DEC_AVE_ERR,    OPIHI_FLT);
     363  if (!strcasecmp (fieldName, "uRA"))            ESCAPE (MEAS_U_RA,           OPIHI_FLT);
     364  if (!strcasecmp (fieldName, "uDEC"))           ESCAPE (MEAS_U_DEC,          OPIHI_FLT);
     365  if (!strcasecmp (fieldName, "duRA"))           ESCAPE (MEAS_U_RA_ERR,       OPIHI_FLT);
     366  if (!strcasecmp (fieldName, "duDEC"))          ESCAPE (MEAS_U_DEC_ERR,      OPIHI_FLT);
     367  if (!strcasecmp (fieldName, "PAR"))            ESCAPE (MEAS_PAR,            OPIHI_FLT);
     368  if (!strcasecmp (fieldName, "dPAR"))           ESCAPE (MEAS_PAR_ERR,        OPIHI_FLT);
     369  if (!strcasecmp (fieldName, "dR"))             ESCAPE (MEAS_RA_OFFSET,      OPIHI_FLT);
     370  if (!strcasecmp (fieldName, "dD"))             ESCAPE (MEAS_DEC_OFFSET,     OPIHI_FLT);
     371  if (!strcasecmp (fieldName, "dR:FIT"))         ESCAPE (MEAS_RA_FIT_OFFSET,  OPIHI_FLT);
     372  if (!strcasecmp (fieldName, "dD:FIT"))         ESCAPE (MEAS_DEC_FIT_OFFSET, OPIHI_FLT);
     373  if (!strcasecmp (fieldName, "dR:ERR"))         ESCAPE (MEAS_RA_OFFSET_ERR,  OPIHI_FLT);
     374  if (!strcasecmp (fieldName, "dD:ERR"))         ESCAPE (MEAS_DEC_OFFSET_ERR, OPIHI_FLT);
     375  if (!strcasecmp (fieldName, "ChiSqPos"))       ESCAPE (MEAS_CHISQ_POS,      OPIHI_FLT);
     376  if (!strcasecmp (fieldName, "ChiSqPM"))        ESCAPE (MEAS_CHISQ_PM,       OPIHI_FLT);
     377  if (!strcasecmp (fieldName, "ChiSqPar"))       ESCAPE (MEAS_CHISQ_PAR,      OPIHI_FLT);
     378  if (!strcasecmp (fieldName, "Tmean"))          ESCAPE (MEAS_TMEAN,          OPIHI_FLT);
     379  if (!strcasecmp (fieldName, "Trange"))         ESCAPE (MEAS_TRANGE,         OPIHI_FLT);
     380  if (!strcasecmp (fieldName, "nmeas"))          ESCAPE (MEAS_NMEAS,          OPIHI_INT);
     381  if (!strcasecmp (fieldName, "nmiss"))          ESCAPE (MEAS_NMISS,          OPIHI_INT);
     382  if (!strcasecmp (fieldName, "npos"))           ESCAPE (MEAS_NPOS,           OPIHI_INT);
     383  if (!strcasecmp (fieldName, "OBJFLAGS"))       ESCAPE (MEAS_OBJ_FLAGS,      OPIHI_INT);
     384  if (!strcasecmp (fieldName, "OBJ_FLAGS"))      ESCAPE (MEAS_OBJ_FLAGS,      OPIHI_INT);
     385  if (!strcasecmp (fieldName, "OBJ_PHOT_FLAGS")) ESCAPE (MEAS_SECFILT_FLAGS,      OPIHI_INT);
     386  if (!strcasecmp (fieldName, "SECFLAGS"))       ESCAPE (MEAS_SECFILT_FLAGS,      OPIHI_INT);
     387  if (!strcasecmp (fieldName, "SEC_FLAGS"))      ESCAPE (MEAS_SECFILT_FLAGS,      OPIHI_INT);
     388  if (!strcasecmp (fieldName, "SECFILT_FLAGS"))  ESCAPE (MEAS_SECFILT_FLAGS,      OPIHI_INT);
     389  if (!strcasecmp (fieldName, "DB_FLAGS"))       ESCAPE (MEAS_DB_FLAGS,       OPIHI_INT);
     390  if (!strcasecmp (fieldName, "PHOT_FLAGS"))     ESCAPE (MEAS_PHOT_FLAGS,     OPIHI_INT);
     391  if (!strcasecmp (fieldName, "DBFLAGS"))        ESCAPE (MEAS_DB_FLAGS,       OPIHI_INT);
     392  if (!strcasecmp (fieldName, "PHOTFLAGS"))      ESCAPE (MEAS_PHOT_FLAGS,     OPIHI_INT);
     393  if (!strcasecmp (fieldName, "AIRMASS"))        ESCAPE (MEAS_AIRMASS,        OPIHI_FLT);
     394  if (!strcasecmp (fieldName, "MEAN_AIRMASS"))   ESCAPE (MEAS_MEAN_AIRMASS,   OPIHI_FLT);
     395  if (!strcasecmp (fieldName, "ALT"))            ESCAPE (MEAS_ALT,            OPIHI_FLT);
     396  if (!strcasecmp (fieldName, "AZ"))             ESCAPE (MEAS_AZ,             OPIHI_FLT);
     397  if (!strcasecmp (fieldName, "EXPTIME"))        ESCAPE (MEAS_EXPTIME,        OPIHI_FLT);
     398  if (!strcasecmp (fieldName, "PHOTCODE"))       ESCAPE (MEAS_PHOTCODE,       OPIHI_INT);
     399  if (!strcasecmp (fieldName, "PHOTCODE:KLAM"))  ESCAPE (MEAS_PHOTCODE_KLAM,  OPIHI_FLT);
     400  if (!strcasecmp (fieldName, "PHOTCODE:C"))     ESCAPE (MEAS_PHOTCODE_C,     OPIHI_FLT);
     401  if (!strcasecmp (fieldName, "PHOTCODE:EQUIV")) ESCAPE (MEAS_PHOTCODE_EQUIV, OPIHI_INT);
     402  if (!strcasecmp (fieldName, "TIME"))           ESCAPE (MEAS_TIME,           OPIHI_FLT);
     403  if (!strcasecmp (fieldName, "FWHM"))           ESCAPE (MEAS_FWHM,           OPIHI_FLT);
     404  if (!strcasecmp (fieldName, "FWHM_MAJ"))       ESCAPE (MEAS_FWHM_MAJ,       OPIHI_FLT);
     405  if (!strcasecmp (fieldName, "FWHM_MIN"))       ESCAPE (MEAS_FWHM_MIN,       OPIHI_FLT);
     406  if (!strcasecmp (fieldName, "THETA"))          ESCAPE (MEAS_THETA,          OPIHI_FLT);
     407  if (!strcasecmp (fieldName, "POSANGLE"))       ESCAPE (MEAS_POSANGLE,       OPIHI_FLT);
     408  if (!strcasecmp (fieldName, "PLATESCALE"))     ESCAPE (MEAS_PLATESCALE,     OPIHI_FLT);
     409  if (!strcasecmp (fieldName, "MXX"))            ESCAPE (MEAS_MXX,            OPIHI_FLT);
     410  if (!strcasecmp (fieldName, "MYY"))            ESCAPE (MEAS_MYY,            OPIHI_FLT);
     411  if (!strcasecmp (fieldName, "MXY"))            ESCAPE (MEAS_MXY,            OPIHI_FLT);
     412  if (!strcasecmp (fieldName, "DOPHOT"))         ESCAPE (MEAS_DOPHOT,         OPIHI_INT);
     413  if (!strcasecmp (fieldName, "XCCD"))           ESCAPE (MEAS_XCCD,           OPIHI_FLT);
     414  if (!strcasecmp (fieldName, "YCCD"))           ESCAPE (MEAS_YCCD,           OPIHI_FLT);
     415  if (!strcasecmp (fieldName, "XCCD:ERR"))       ESCAPE (MEAS_XCCD_ERR,       OPIHI_FLT);
     416  if (!strcasecmp (fieldName, "YCCD:ERR"))       ESCAPE (MEAS_YCCD_ERR,       OPIHI_FLT);
     417  if (!strcasecmp (fieldName, "XFIX"))           ESCAPE (MEAS_XFIX,           OPIHI_FLT);
     418  if (!strcasecmp (fieldName, "YFIX"))           ESCAPE (MEAS_YFIX,           OPIHI_FLT);
     419  if (!strcasecmp (fieldName, "POS_SYS_ERR"))    ESCAPE (MEAS_POS_SYS_ERR,    OPIHI_FLT);
     420  if (!strcasecmp (fieldName, "XFIELD"))         ESCAPE (MEAS_XFIELD,         OPIHI_FLT);
     421  if (!strcasecmp (fieldName, "YFIELD"))         ESCAPE (MEAS_YFIELD,         OPIHI_FLT);
     422  if (!strcasecmp (fieldName, "XMOSAIC"))        ESCAPE (MEAS_XMOSAIC,        OPIHI_FLT);
     423  if (!strcasecmp (fieldName, "YMOSAIC"))        ESCAPE (MEAS_YMOSAIC,        OPIHI_FLT);
     424  if (!strcasecmp (fieldName, "XCHIP"))          ESCAPE (MEAS_XCCD,           OPIHI_FLT);
     425  if (!strcasecmp (fieldName, "YCHIP"))          ESCAPE (MEAS_YCCD,           OPIHI_FLT);
     426  if (!strcasecmp (fieldName, "XFPA"))           ESCAPE (MEAS_XMOSAIC,        OPIHI_FLT);
     427  if (!strcasecmp (fieldName, "YFPA"))           ESCAPE (MEAS_YMOSAIC,        OPIHI_FLT);
     428  if (!strcasecmp (fieldName, "DETID"))          ESCAPE (MEAS_DET_ID,         OPIHI_INT);
     429  if (!strcasecmp (fieldName, "OBJID"))          ESCAPE (MEAS_OBJ_ID,         OPIHI_INT);
     430  if (!strcasecmp (fieldName, "CATID"))          ESCAPE (MEAS_CAT_ID,         OPIHI_INT);
     431  if (!strcasecmp (fieldName, "IMAGEID"))        ESCAPE (MEAS_IMAGE_ID,       OPIHI_INT);
     432  if (!strcasecmp (fieldName, "EXTERNID"))       ESCAPE (MEAS_EXTERN_ID,      OPIHI_INT);
     433  if (!strcasecmp (fieldName, "EXPNAME"))        ESCAPE (MEAS_EXPNAME_AS_INT, OPIHI_INT);
     434  if (!strcasecmp (fieldName, "PSF_QF"))         ESCAPE (MEAS_PSF_QF,         OPIHI_FLT);
     435  if (!strcasecmp (fieldName, "PSF_QF_PERFECT")) ESCAPE (MEAS_PSF_QF_PERFECT, OPIHI_FLT);
     436  if (!strcasecmp (fieldName, "PSF_CHISQ"))      ESCAPE (MEAS_PSF_CHISQ,      OPIHI_FLT);
     437  if (!strcasecmp (fieldName, "PSF_NDOF"))       ESCAPE (MEAS_PSF_NDOF,       OPIHI_INT);
     438  if (!strcasecmp (fieldName, "PSF_NPIX"))       ESCAPE (MEAS_PSF_NPIX,       OPIHI_INT);
     439  if (!strcasecmp (fieldName, "CR_NSIGMA"))      ESCAPE (MEAS_CR_NSIGMA,      OPIHI_FLT);
     440  if (!strcasecmp (fieldName, "EXT_NSIGMA"))     ESCAPE (MEAS_EXT_NSIGMA,     OPIHI_FLT);
     441  if (!strcasecmp (fieldName, "SKY"))            ESCAPE (MEAS_SKY,            OPIHI_FLT);
     442  if (!strcasecmp (fieldName, "SKY_ERR"))        ESCAPE (MEAS_dSKY,           OPIHI_FLT);
     443  if (!strcasecmp (fieldName, "MCAL_OFFSET"))    ESCAPE (MEAS_MCAL_OFFSET,    OPIHI_FLT);
     444  if (!strcasecmp (fieldName, "FLAT"))           ESCAPE (MEAS_FLAT,           OPIHI_FLT);
     445  if (!strcasecmp (fieldName, "CENTER_OFFSET"))  ESCAPE (MEAS_CENTER_OFFSET,  OPIHI_FLT);
     446  // if (!strcasecmp (fieldName, "FLUX"))                ESCAPE (MEAS_FLUX_PSF,       OPIHI_FLT);
     447  // if (!strcasecmp (fieldName, "FLUX_ERR"))       ESCAPE (MEAS_FLUX_PSF_ERR,   OPIHI_FLT);
     448  // if (!strcasecmp (fieldName, "FLUX_PSF"))       ESCAPE (MEAS_FLUX_PSF,       OPIHI_FLT);
     449  // if (!strcasecmp (fieldName, "FLUX_PSF_ERR"))   ESCAPE (MEAS_FLUX_PSF_ERR,   OPIHI_FLT);
     450  // if (!strcasecmp (fieldName, "FLUX_KRON"))      ESCAPE (MEAS_FLUX_KRON,      OPIHI_FLT);
     451  // if (!strcasecmp (fieldName, "FLUX_KRON_ERR"))  ESCAPE (MEAS_FLUX_KRON_ERR,  OPIHI_FLT);
     452  if (!strcasecmp (fieldName, "REF_COLOR"))      ESCAPE (MEAS_REF_COLOR,      OPIHI_FLT);
     453
     454  // for words that don't parse, try a photcode
     455
     456  // check for code:mode in photcode name
     457  if (!ParsePhotcodeField (field, fieldName, MEAS_PHOT)) {
     458    gprint (GP_ERR, "unknown field '%s' for measurement table in DVO database\n", fieldName);
     459    return (FALSE);
     460  }
     461
    316462  return (TRUE);
    317463}
    318464
    319465int ParseAverageField (dbField *field, char *fieldName) {
    320 
    321   int mode;
    322   PhotCode *code;
    323466
    324467  field->table = DVO_TABLE_AVERAGE;
    … …  
    329472  if (!strcasecmp (fieldName, "GLON"))  {
    330473    dbExtractAveragesInitTransform (COORD_GALACTIC);
    331     ESCAPE (AVE_GLON, MAG_NONE, OPIHI_FLT);
     474    ESCAPE (AVE_GLON, OPIHI_FLT);
    332475  }
    333476  if (!strcasecmp (fieldName, "GLAT"))  {
    334477    dbExtractAveragesInitTransform (COORD_GALACTIC);
    335     ESCAPE (AVE_GLAT, MAG_NONE, OPIHI_FLT);
     478    ESCAPE (AVE_GLAT, OPIHI_FLT);
    336479  }
    337480
    … …  
    340483  if (!strcasecmp (fieldName, "ELON"))  {
    341484    dbExtractAveragesInitTransform (COORD_ECLIPTIC);
    342     ESCAPE (AVE_ELON, MAG_NONE, OPIHI_FLT);
     485    ESCAPE (AVE_ELON, OPIHI_FLT);
    343486  }
    344487  if (!strcasecmp (fieldName, "ELAT"))  {
    345488    dbExtractAveragesInitTransform (COORD_ECLIPTIC);
    346     ESCAPE (AVE_ELAT, MAG_NONE, OPIHI_FLT);
    347   }
    348 
    349   if (!strcasecmp (fieldName, "RA"))          ESCAPE (AVE_RA,          MAG_NONE, OPIHI_FLT);
    350   if (!strcasecmp (fieldName, "DEC"))         ESCAPE (AVE_DEC,         MAG_NONE, OPIHI_FLT);
    351   if (!strcasecmp (fieldName, "GLON"))        ESCAPE (AVE_GLON,        MAG_NONE, OPIHI_FLT);
    352   if (!strcasecmp (fieldName, "GLAT"))        ESCAPE (AVE_GLAT,        MAG_NONE, OPIHI_FLT);
    353   if (!strcasecmp (fieldName, "ELON"))        ESCAPE (AVE_ELON,        MAG_NONE, OPIHI_FLT);
    354   if (!strcasecmp (fieldName, "ELAT"))        ESCAPE (AVE_ELAT,        MAG_NONE, OPIHI_FLT);
    355   if (!strcasecmp (fieldName, "dRA"))         ESCAPE (AVE_RA_ERR,      MAG_NONE, OPIHI_FLT);
    356   if (!strcasecmp (fieldName, "dDEC"))        ESCAPE (AVE_DEC_ERR,     MAG_NONE, OPIHI_FLT);
    357   if (!strcasecmp (fieldName, "uRA"))         ESCAPE (AVE_U_RA,        MAG_NONE, OPIHI_FLT);
    358   if (!strcasecmp (fieldName, "uDEC"))        ESCAPE (AVE_U_DEC,       MAG_NONE, OPIHI_FLT);
    359   if (!strcasecmp (fieldName, "duRA"))        ESCAPE (AVE_U_RA_ERR,    MAG_NONE, OPIHI_FLT);
    360   if (!strcasecmp (fieldName, "duDEC"))       ESCAPE (AVE_U_DEC_ERR,   MAG_NONE, OPIHI_FLT);
    361   if (!strcasecmp (fieldName, "PAR"))         ESCAPE (AVE_PAR,         MAG_NONE, OPIHI_FLT);
    362   if (!strcasecmp (fieldName, "dPAR"))        ESCAPE (AVE_PAR_ERR,     MAG_NONE, OPIHI_FLT);
    363   if (!strcasecmp (fieldName, "ChiSqPos"))    ESCAPE (AVE_CHISQ_POS,   MAG_NONE, OPIHI_FLT);
    364   if (!strcasecmp (fieldName, "ChiSqPM"))     ESCAPE (AVE_CHISQ_PM,    MAG_NONE, OPIHI_FLT);
    365   if (!strcasecmp (fieldName, "ChiSqPar"))    ESCAPE (AVE_CHISQ_PAR,   MAG_NONE, OPIHI_FLT);
    366   if (!strcasecmp (fieldName, "Tmean"))       ESCAPE (AVE_TMEAN,       MAG_NONE, OPIHI_FLT);
    367   if (!strcasecmp (fieldName, "Trange"))      ESCAPE (AVE_TRANGE,      MAG_NONE, OPIHI_FLT);
    368   if (!strcasecmp (fieldName, "psfqf"))       ESCAPE (AVE_PSF_QF,      MAG_NONE, OPIHI_FLT);
    369   if (!strcasecmp (fieldName, "psfqfperf"))   ESCAPE (AVE_PSF_QF_PERF, MAG_NONE, OPIHI_FLT);
    370   if (!strcasecmp (fieldName, "psf_qf"))      ESCAPE (AVE_PSF_QF,      MAG_NONE, OPIHI_FLT);
    371   if (!strcasecmp (fieldName, "psf_qf_perf")) ESCAPE (AVE_PSF_QF_PERF, MAG_NONE, OPIHI_FLT);
    372   if (!strcasecmp (fieldName, "stargal"))     ESCAPE (AVE_STARGAL,     MAG_NONE, OPIHI_FLT);
    373   if (!strcasecmp (fieldName, "NMEAS"))       ESCAPE (AVE_NMEAS,       MAG_NONE, OPIHI_INT);
    374   if (!strcasecmp (fieldName, "NMISS"))       ESCAPE (AVE_NMISS,       MAG_NONE, OPIHI_INT);
    375   if (!strcasecmp (fieldName, "NPOS"))        ESCAPE (AVE_NPOS,        MAG_NONE, OPIHI_INT);
    376   if (!strcasecmp (fieldName, "NASTROM"))     ESCAPE (AVE_NPOS,        MAG_NONE, OPIHI_INT);
    377   if (!strcasecmp (fieldName, "FLAGS"))       ESCAPE (AVE_OBJ_FLAGS,   MAG_NONE, OPIHI_INT);
    378   if (!strcasecmp (fieldName, "OBJ_FLAGS"))   ESCAPE (AVE_OBJ_FLAGS,   MAG_NONE, OPIHI_INT);
    379   if (!strcasecmp (fieldName, "OBJFLAGS"))    ESCAPE (AVE_OBJ_FLAGS,   MAG_NONE, OPIHI_INT);
    380   if (!strcasecmp (fieldName, "OBJID"))       ESCAPE (AVE_OBJID,       MAG_NONE, OPIHI_INT);
    381   if (!strcasecmp (fieldName, "CATID"))       ESCAPE (AVE_CATID,       MAG_NONE, OPIHI_INT);
    382   if (!strcasecmp (fieldName, "EXTID_HI"))    ESCAPE (AVE_EXTID_HI,    MAG_NONE, OPIHI_INT);
    383   if (!strcasecmp (fieldName, "EXTID_LO"))    ESCAPE (AVE_EXTID_LO,    MAG_NONE, OPIHI_INT);
    384   if (!strcasecmp (fieldName, "REF_COLOR"))   ESCAPE (AVE_REF_COLOR,   MAG_NONE, OPIHI_FLT);
     489    ESCAPE (AVE_ELAT, OPIHI_FLT);
     490  }
     491
     492  if (!strcasecmp (fieldName, "RA"))          ESCAPE (AVE_RA,          OPIHI_FLT);
     493  if (!strcasecmp (fieldName, "DEC"))         ESCAPE (AVE_DEC,         OPIHI_FLT);
     494  if (!strcasecmp (fieldName, "GLON"))        ESCAPE (AVE_GLON,        OPIHI_FLT);
     495  if (!strcasecmp (fieldName, "GLAT"))        ESCAPE (AVE_GLAT,        OPIHI_FLT);
     496  if (!strcasecmp (fieldName, "ELON"))        ESCAPE (AVE_ELON,        OPIHI_FLT);
     497  if (!strcasecmp (fieldName, "ELAT"))        ESCAPE (AVE_ELAT,        OPIHI_FLT);
     498  if (!strcasecmp (fieldName, "dRA"))         ESCAPE (AVE_RA_ERR,      OPIHI_FLT);
     499  if (!strcasecmp (fieldName, "dDEC"))        ESCAPE (AVE_DEC_ERR,     OPIHI_FLT);
     500  if (!strcasecmp (fieldName, "uRA"))         ESCAPE (AVE_U_RA,        OPIHI_FLT);
     501  if (!strcasecmp (fieldName, "uDEC"))        ESCAPE (AVE_U_DEC,       OPIHI_FLT);
     502  if (!strcasecmp (fieldName, "duRA"))        ESCAPE (AVE_U_RA_ERR,    OPIHI_FLT);
     503  if (!strcasecmp (fieldName, "duDEC"))       ESCAPE (AVE_U_DEC_ERR,   OPIHI_FLT);
     504  if (!strcasecmp (fieldName, "PAR"))         ESCAPE (AVE_PAR,         OPIHI_FLT);
     505  if (!strcasecmp (fieldName, "dPAR"))        ESCAPE (AVE_PAR_ERR,     OPIHI_FLT);
     506  if (!strcasecmp (fieldName, "ChiSqPos"))    ESCAPE (AVE_CHISQ_POS,   OPIHI_FLT);
     507  if (!strcasecmp (fieldName, "ChiSqPM"))     ESCAPE (AVE_CHISQ_PM,    OPIHI_FLT);
     508  if (!strcasecmp (fieldName, "ChiSqPar"))    ESCAPE (AVE_CHISQ_PAR,   OPIHI_FLT);
     509  if (!strcasecmp (fieldName, "Tmean"))       ESCAPE (AVE_TMEAN,       OPIHI_FLT);
     510  if (!strcasecmp (fieldName, "Trange"))      ESCAPE (AVE_TRANGE,      OPIHI_FLT);
     511  if (!strcasecmp (fieldName, "psfqf"))       ESCAPE (AVE_PSF_QF,      OPIHI_FLT);
     512  if (!strcasecmp (fieldName, "psfqfperf"))   ESCAPE (AVE_PSF_QF_PERF, OPIHI_FLT);
     513  if (!strcasecmp (fieldName, "psf_qf"))      ESCAPE (AVE_PSF_QF,      OPIHI_FLT);
     514  if (!strcasecmp (fieldName, "psf_qf_perf")) ESCAPE (AVE_PSF_QF_PERF, OPIHI_FLT);
     515  if (!strcasecmp (fieldName, "stargal"))     ESCAPE (AVE_STARGAL,     OPIHI_FLT);
     516  if (!strcasecmp (fieldName, "NMEAS"))       ESCAPE (AVE_NMEAS,       OPIHI_INT);
     517  if (!strcasecmp (fieldName, "NMISS"))       ESCAPE (AVE_NMISS,       OPIHI_INT);
     518  if (!strcasecmp (fieldName, "NPOS"))        ESCAPE (AVE_NPOS,        OPIHI_INT);
     519  if (!strcasecmp (fieldName, "NASTROM"))     ESCAPE (AVE_NPOS,        OPIHI_INT);
     520  if (!strcasecmp (fieldName, "FLAGS"))       ESCAPE (AVE_OBJ_FLAGS,   OPIHI_INT);
     521  if (!strcasecmp (fieldName, "OBJ_FLAGS"))   ESCAPE (AVE_OBJ_FLAGS,   OPIHI_INT);
     522  if (!strcasecmp (fieldName, "OBJFLAGS"))    ESCAPE (AVE_OBJ_FLAGS,   OPIHI_INT);
     523  if (!strcasecmp (fieldName, "OBJID"))       ESCAPE (AVE_OBJID,       OPIHI_INT);
     524  if (!strcasecmp (fieldName, "CATID"))       ESCAPE (AVE_CATID,       OPIHI_INT);
     525  if (!strcasecmp (fieldName, "EXTID_HI"))    ESCAPE (AVE_EXTID_HI,    OPIHI_INT);
     526  if (!strcasecmp (fieldName, "EXTID_LO"))    ESCAPE (AVE_EXTID_LO,    OPIHI_INT);
     527  if (!strcasecmp (fieldName, "REF_COLOR"))   ESCAPE (AVE_REF_COLOR,   OPIHI_FLT);
    385528
    386529  // check for code:mode in photcode name
    387   code = ParsePhotcodeField (fieldName, &mode, MAG_AVE);
    388   if (code == NULL) {
     530  if (!ParsePhotcodeField (field, fieldName, AVE_PHOT)) {
    389531    gprint (GP_ERR, "unknown field '%s' for average table in DVO database\n", fieldName);
    390532    return (FALSE);
    391533  }
    392534
    393   if (code[0].type == PHOT_MAG) {
     535  if (field->photcode->type == PHOT_MAG) {
    394536    gprint (GP_ERR, "'mag' is ambiguous for avextract\n");
    395     free (code);
    396537    return (FALSE);
    397538  }
    398539
    399   field->ID = AVE_MAG;
    400   field->magMode = mode;
    401   switch (mode) {
    402     case MAG_STACK_DET_ID:
    403     case MAG_NCODE:
    404     case MAG_NPHOT:
    405     case MAG_PHOT_FLAGS:
    406       field->type = OPIHI_INT;
    407       break;
    408     default:
    409       field->type = OPIHI_FLT;
    410       break;
    411   }
    412   field->photcode = code;
    413540  return (TRUE);
    414541}
    … …  
    424551  if (!strcasecmp (fieldName, "GLON"))  {
    425552    dbExtractImagesInitTransform (COORD_GALACTIC);
    426     ESCAPE (IMAGE_GLON, MAG_NONE, OPIHI_FLT);
     553    ESCAPE (IMAGE_GLON, OPIHI_FLT);
    427554  }
    428555  if (!strcasecmp (fieldName, "GLAT"))  {
    429556    dbExtractImagesInitTransform (COORD_GALACTIC);
    430     ESCAPE (IMAGE_GLAT, MAG_NONE, OPIHI_FLT);
     557    ESCAPE (IMAGE_GLAT, OPIHI_FLT);
    431558  }
    432559
    … …  
    435562  if (!strcasecmp (fieldName, "ELON"))  {
    436563    dbExtractImagesInitTransform (COORD_ECLIPTIC);
    437     ESCAPE (IMAGE_ELON, MAG_NONE, OPIHI_FLT);
     564    ESCAPE (IMAGE_ELON, OPIHI_FLT);
    438565  }
    439566  if (!strcasecmp (fieldName, "ELAT"))  {
    440567    dbExtractImagesInitTransform (COORD_ECLIPTIC);
    441     ESCAPE (IMAGE_ELAT, MAG_NONE, OPIHI_FLT);
    442   }
    443 
    444   if (!strcasecmp (fieldName, "RA"       )) ESCAPE (IMAGE_RA,        MAG_NONE, OPIHI_FLT);
    445   if (!strcasecmp (fieldName, "DEC"      )) ESCAPE (IMAGE_DEC,       MAG_NONE, OPIHI_FLT);
    446   if (!strcasecmp (fieldName, "GLON"     )) ESCAPE (IMAGE_GLON,      MAG_NONE, OPIHI_FLT);
    447   if (!strcasecmp (fieldName, "GLAT"     )) ESCAPE (IMAGE_GLAT,      MAG_NONE, OPIHI_FLT);
    448   if (!strcasecmp (fieldName, "ELON"     )) ESCAPE (IMAGE_ELON,      MAG_NONE, OPIHI_FLT);
    449   if (!strcasecmp (fieldName, "ELAT"     )) ESCAPE (IMAGE_ELAT,      MAG_NONE, OPIHI_FLT);
    450 
    451   if (!strcasecmp (fieldName, "theta"    )) ESCAPE (IMAGE_THETA,     MAG_NONE, OPIHI_FLT);
    452   if (!strcasecmp (fieldName, "skew"     )) ESCAPE (IMAGE_SKEW,      MAG_NONE, OPIHI_FLT);
    453   if (!strcasecmp (fieldName, "scale"    )) ESCAPE (IMAGE_SCALE,     MAG_NONE, OPIHI_FLT);
    454   if (!strcasecmp (fieldName, "dscale"   )) ESCAPE (IMAGE_DSCALE,    MAG_NONE, OPIHI_FLT);
    455 
    456   if (!strcasecmp (fieldName, "time"     )) ESCAPE (IMAGE_TIME,      MAG_NONE, OPIHI_FLT);
    457   if (!strcasecmp (fieldName, "nstar"    )) ESCAPE (IMAGE_NSTAR,     MAG_NONE, OPIHI_INT);
    458   if (!strcasecmp (fieldName, "airmass"  )) ESCAPE (IMAGE_AIRMASS,   MAG_NONE, OPIHI_FLT);
    459   if (!strcasecmp (fieldName, "NX"       )) ESCAPE (IMAGE_NX_PIX,    MAG_NONE, OPIHI_INT);
    460   if (!strcasecmp (fieldName, "NY"       )) ESCAPE (IMAGE_NY_PIX,    MAG_NONE, OPIHI_INT);
    461   if (!strcasecmp (fieldName, "apresid"  )) ESCAPE (IMAGE_APRESID,   MAG_NONE, OPIHI_FLT);
    462   if (!strcasecmp (fieldName, "dapresid" )) ESCAPE (IMAGE_DAPRESID,  MAG_NONE, OPIHI_FLT);
    463 
    464   if (!strcasecmp (fieldName, "Mcal"     )) ESCAPE (IMAGE_MCAL,      MAG_NONE, OPIHI_FLT);
    465   if (!strcasecmp (fieldName, "dMcal"    )) ESCAPE (IMAGE_dMCAL,     MAG_NONE, OPIHI_FLT);
    466   if (!strcasecmp (fieldName, "Xm"       )) ESCAPE (IMAGE_XM,        MAG_NONE, OPIHI_FLT);
    467   if (!strcasecmp (fieldName, "photcode" )) ESCAPE (IMAGE_PHOTCODE,  MAG_NONE, OPIHI_INT);
    468   if (!strcasecmp (fieldName, "exptime"  )) ESCAPE (IMAGE_EXPTIME,   MAG_NONE, OPIHI_FLT);
    469   if (!strcasecmp (fieldName, "sidtime"  )) ESCAPE (IMAGE_SIDTIME,   MAG_NONE, OPIHI_FLT);
    470 
    471   if (!strcasecmp (fieldName, "latitude" )) ESCAPE (IMAGE_LATITUDE,  MAG_NONE, OPIHI_FLT);
    472 
    473   if (!strcasecmp (fieldName, "detlimit" )) ESCAPE (IMAGE_DET_LIMIT, MAG_NONE, OPIHI_FLT);
    474   if (!strcasecmp (fieldName, "satlimit" )) ESCAPE (IMAGE_SAT_LIMIT, MAG_NONE, OPIHI_FLT);
    475   if (!strcasecmp (fieldName, "cerror"   )) ESCAPE (IMAGE_CERROR,    MAG_NONE, OPIHI_FLT);
    476 
    477   if (!strcasecmp (fieldName, "FWHM"       )) ESCAPE (IMAGE_FWHM,      MAG_NONE, OPIHI_FLT);
    478   if (!strcasecmp (fieldName, "FWHM_MAJ"   )) ESCAPE (IMAGE_FWHM_MAJ,  MAG_NONE, OPIHI_FLT);
    479   if (!strcasecmp (fieldName, "FWHM_MIN"   )) ESCAPE (IMAGE_FWHM_MIN,  MAG_NONE, OPIHI_FLT);
    480   if (!strcasecmp (fieldName, "FWHM_MAJOR" )) ESCAPE (IMAGE_FWHM_MAJ,  MAG_NONE, OPIHI_FLT);
    481   if (!strcasecmp (fieldName, "FWHM_MINOR" )) ESCAPE (IMAGE_FWHM_MIN,  MAG_NONE, OPIHI_FLT);
    482 
    483   if (!strcasecmp (fieldName, "FWHM_MEDIAN"    ))   ESCAPE (IMAGE_FWHM_MEDIAN,      MAG_NONE, OPIHI_FLT);
    484   if (!strcasecmp (fieldName, "FWHM_MAJ_MEDIAN"))   ESCAPE (IMAGE_FWHM_MAJ_MEDIAN,  MAG_NONE, OPIHI_FLT);
    485   if (!strcasecmp (fieldName, "FWHM_MIN_MEDIAN"))   ESCAPE (IMAGE_FWHM_MIN_MEDIAN,  MAG_NONE, OPIHI_FLT);
    486   if (!strcasecmp (fieldName, "FWHM_MAJOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MAJ_MEDIAN,  MAG_NONE, OPIHI_FLT);
    487   if (!strcasecmp (fieldName, "FWHM_MINOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MIN_MEDIAN,  MAG_NONE, OPIHI_FLT);
    488 
    489   if (!strcasecmp (fieldName, "trate"    )) ESCAPE (IMAGE_TRATE,     MAG_NONE, OPIHI_FLT);
    490 
    491   if (!strcasecmp (fieldName, "ncal"     )) ESCAPE (IMAGE_NCAL,      MAG_NONE, OPIHI_INT);
    492   if (!strcasecmp (fieldName, "sky"      )) ESCAPE (IMAGE_SKY,       MAG_NONE, OPIHI_FLT); // deprecated for now
    493 
    494   if (!strcasecmp (fieldName, "imflags"  )) ESCAPE (IMAGE_FLAGS,     MAG_NONE, OPIHI_INT);
    495   if (!strcasecmp (fieldName, "flags"    )) ESCAPE (IMAGE_FLAGS,     MAG_NONE, OPIHI_INT);
    496   if (!strcasecmp (fieldName, "ccdnum"   )) ESCAPE (IMAGE_CCDNUM,    MAG_NONE, OPIHI_INT);
    497 
    498   if (!strcasecmp (fieldName, "imageID"  )) ESCAPE (IMAGE_IMAGE_ID,  MAG_NONE, OPIHI_INT);
    499   if (!strcasecmp (fieldName, "externID" )) ESCAPE (IMAGE_EXTERN_ID, MAG_NONE, OPIHI_INT);
    500   if (!strcasecmp (fieldName, "sourceID" )) ESCAPE (IMAGE_SOURCE_ID, MAG_NONE, OPIHI_INT);
    501 
    502   if (!strcasecmp (fieldName, "X_LL_CHIP")) ESCAPE (IMAGE_X_LL_CHIP, MAG_NONE, OPIHI_FLT);
    503   if (!strcasecmp (fieldName, "X_LR_CHIP")) ESCAPE (IMAGE_X_LR_CHIP, MAG_NONE, OPIHI_FLT);
    504   if (!strcasecmp (fieldName, "X_UL_CHIP")) ESCAPE (IMAGE_X_UL_CHIP, MAG_NONE, OPIHI_FLT);
    505   if (!strcasecmp (fieldName, "X_UR_CHIP")) ESCAPE (IMAGE_X_UR_CHIP, MAG_NONE, OPIHI_FLT);
    506   if (!strcasecmp (fieldName, "Y_LL_CHIP")) ESCAPE (IMAGE_Y_LL_CHIP, MAG_NONE, OPIHI_FLT);
    507   if (!strcasecmp (fieldName, "Y_LR_CHIP")) ESCAPE (IMAGE_Y_LR_CHIP, MAG_NONE, OPIHI_FLT);
    508   if (!strcasecmp (fieldName, "Y_UL_CHIP")) ESCAPE (IMAGE_Y_UL_CHIP, MAG_NONE, OPIHI_FLT);
    509   if (!strcasecmp (fieldName, "Y_UR_CHIP")) ESCAPE (IMAGE_Y_UR_CHIP, MAG_NONE, OPIHI_FLT);
    510   if (!strcasecmp (fieldName, "X_LL_FP"  )) ESCAPE (IMAGE_X_LL_FP,   MAG_NONE, OPIHI_FLT);
    511   if (!strcasecmp (fieldName, "X_LR_FP"  )) ESCAPE (IMAGE_X_LR_FP,   MAG_NONE, OPIHI_FLT);
    512   if (!strcasecmp (fieldName, "X_UL_FP"  )) ESCAPE (IMAGE_X_UL_FP,   MAG_NONE, OPIHI_FLT);
    513   if (!strcasecmp (fieldName, "X_UR_FP"  )) ESCAPE (IMAGE_X_UR_FP,   MAG_NONE, OPIHI_FLT);
    514   if (!strcasecmp (fieldName, "Y_LL_FP"  )) ESCAPE (IMAGE_Y_LL_FP,   MAG_NONE, OPIHI_FLT);
    515   if (!strcasecmp (fieldName, "Y_LR_FP"  )) ESCAPE (IMAGE_Y_LR_FP,   MAG_NONE, OPIHI_FLT);
    516   if (!strcasecmp (fieldName, "Y_UL_FP"  )) ESCAPE (IMAGE_Y_UL_FP,   MAG_NONE, OPIHI_FLT);
    517   if (!strcasecmp (fieldName, "Y_UR_FP"  )) ESCAPE (IMAGE_Y_UR_FP,   MAG_NONE, OPIHI_FLT);
    518 
    519   if (!strcasecmp (fieldName, "dX_SYS"  )) ESCAPE (IMAGE_X_ERR_SYS,  MAG_NONE, OPIHI_FLT);
    520   if (!strcasecmp (fieldName, "dY_SYS"  )) ESCAPE (IMAGE_Y_ERR_SYS,  MAG_NONE, OPIHI_FLT);
    521   if (!strcasecmp (fieldName, "dM_SYS"  )) ESCAPE (IMAGE_MAG_ERR_SYS,MAG_NONE, OPIHI_FLT);
    522 
    523   if (!strcasecmp (fieldName, "UBERCAL_DIST")) ESCAPE (IMAGE_UBERCAL_DIST,MAG_NONE, OPIHI_INT);
    524   if (!strcasecmp (fieldName, "UCDIST")) ESCAPE (IMAGE_UBERCAL_DIST,MAG_NONE, OPIHI_INT);
    525 
    526   if (!strcasecmp (fieldName, "NFIT_PHOTOM"))  ESCAPE (IMAGE_NFIT_PHOTOM,  MAG_NONE, OPIHI_INT);
    527   if (!strcasecmp (fieldName, "NFIT_ASTROM"))  ESCAPE (IMAGE_NFIT_ASTROM,  MAG_NONE, OPIHI_INT);
    528   if (!strcasecmp (fieldName, "NLINK_PHOTOM")) ESCAPE (IMAGE_NLINK_PHOTOM, MAG_NONE, OPIHI_INT);
    529   if (!strcasecmp (fieldName, "NLINK_ASTROM")) ESCAPE (IMAGE_NLINK_ASTROM, MAG_NONE, OPIHI_INT);
    530   if (!strcasecmp (fieldName, "REF_COLOR"))    ESCAPE (IMAGE_REF_COLOR,    MAG_NONE, OPIHI_FLT);
     568    ESCAPE (IMAGE_ELAT, OPIHI_FLT);
     569  }
     570
     571  if (!strcasecmp (fieldName, "RA"       )) ESCAPE (IMAGE_RA,        OPIHI_FLT);
     572  if (!strcasecmp (fieldName, "DEC"      )) ESCAPE (IMAGE_DEC,       OPIHI_FLT);
     573  if (!strcasecmp (fieldName, "GLON"     )) ESCAPE (IMAGE_GLON,      OPIHI_FLT);
     574  if (!strcasecmp (fieldName, "GLAT"     )) ESCAPE (IMAGE_GLAT,      OPIHI_FLT);
     575  if (!strcasecmp (fieldName, "ELON"     )) ESCAPE (IMAGE_ELON,      OPIHI_FLT);
     576  if (!strcasecmp (fieldName, "ELAT"     )) ESCAPE (IMAGE_ELAT,      OPIHI_FLT);
     577
     578  if (!strcasecmp (fieldName, "theta"    )) ESCAPE (IMAGE_THETA,     OPIHI_FLT);
     579  if (!strcasecmp (fieldName, "skew"     )) ESCAPE (IMAGE_SKEW,      OPIHI_FLT);
     580  if (!strcasecmp (fieldName, "scale"    )) ESCAPE (IMAGE_SCALE,     OPIHI_FLT);
     581  if (!strcasecmp (fieldName, "dscale"   )) ESCAPE (IMAGE_DSCALE,    OPIHI_FLT);
     582
     583  if (!strcasecmp (fieldName, "time"     )) ESCAPE (IMAGE_TIME,      OPIHI_FLT);
     584  if (!strcasecmp (fieldName, "nstar"    )) ESCAPE (IMAGE_NSTAR,     OPIHI_INT);
     585  if (!strcasecmp (fieldName, "airmass"  )) ESCAPE (IMAGE_AIRMASS,   OPIHI_FLT);
     586  if (!strcasecmp (fieldName, "NX"       )) ESCAPE (IMAGE_NX_PIX,    OPIHI_INT);
     587  if (!strcasecmp (fieldName, "NY"       )) ESCAPE (IMAGE_NY_PIX,    OPIHI_INT);
     588  if (!strcasecmp (fieldName, "apresid"  )) ESCAPE (IMAGE_APRESID,   OPIHI_FLT);
     589  if (!strcasecmp (fieldName, "dapresid" )) ESCAPE (IMAGE_DAPRESID,  OPIHI_FLT);
     590
     591  if (!strcasecmp (fieldName, "Mcal"     )) ESCAPE (IMAGE_MCAL,      OPIHI_FLT);
     592  if (!strcasecmp (fieldName, "dMcal"    )) ESCAPE (IMAGE_dMCAL,     OPIHI_FLT);
     593  if (!strcasecmp (fieldName, "Xm"       )) ESCAPE (IMAGE_XM,        OPIHI_FLT);
     594  if (!strcasecmp (fieldName, "photcode" )) ESCAPE (IMAGE_PHOTCODE,  OPIHI_INT);
     595  if (!strcasecmp (fieldName, "exptime"  )) ESCAPE (IMAGE_EXPTIME,   OPIHI_FLT);
     596  if (!strcasecmp (fieldName, "sidtime"  )) ESCAPE (IMAGE_SIDTIME,   OPIHI_FLT);
     597
     598  if (!strcasecmp (fieldName, "latitude" )) ESCAPE (IMAGE_LATITUDE,  OPIHI_FLT);
     599
     600  if (!strcasecmp (fieldName, "detlimit" )) ESCAPE (IMAGE_DET_LIMIT, OPIHI_FLT);
     601  if (!strcasecmp (fieldName, "satlimit" )) ESCAPE (IMAGE_SAT_LIMIT, OPIHI_FLT);
     602  if (!strcasecmp (fieldName, "cerror"   )) ESCAPE (IMAGE_CERROR,    OPIHI_FLT);
     603
     604  if (!strcasecmp (fieldName, "FWHM"       )) ESCAPE (IMAGE_FWHM,      OPIHI_FLT);
     605  if (!strcasecmp (fieldName, "FWHM_MAJ"   )) ESCAPE (IMAGE_FWHM_MAJ,  OPIHI_FLT);
     606  if (!strcasecmp (fieldName, "FWHM_MIN"   )) ESCAPE (IMAGE_FWHM_MIN,  OPIHI_FLT);
     607  if (!strcasecmp (fieldName, "FWHM_MAJOR" )) ESCAPE (IMAGE_FWHM_MAJ,  OPIHI_FLT);
     608  if (!strcasecmp (fieldName, "FWHM_MINOR" )) ESCAPE (IMAGE_FWHM_MIN,  OPIHI_FLT);
     609
     610  if (!strcasecmp (fieldName, "FWHM_MEDIAN"    ))   ESCAPE (IMAGE_FWHM_MEDIAN,      OPIHI_FLT);
     611  if (!strcasecmp (fieldName, "FWHM_MAJ_MEDIAN"))   ESCAPE (IMAGE_FWHM_MAJ_MEDIAN,  OPIHI_FLT);
     612  if (!strcasecmp (fieldName, "FWHM_MIN_MEDIAN"))   ESCAPE (IMAGE_FWHM_MIN_MEDIAN,  OPIHI_FLT);
     613  if (!strcasecmp (fieldName, "FWHM_MAJOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MAJ_MEDIAN,  OPIHI_FLT);
     614  if (!strcasecmp (fieldName, "FWHM_MINOR_MEDIAN")) ESCAPE (IMAGE_FWHM_MIN_MEDIAN,  OPIHI_FLT);
     615
     616  if (!strcasecmp (fieldName, "trate"    )) ESCAPE (IMAGE_TRATE,     OPIHI_FLT);
     617
     618  if (!strcasecmp (fieldName, "ncal"     )) ESCAPE (IMAGE_NCAL,      OPIHI_INT);
     619  if (!strcasecmp (fieldName, "sky"      )) ESCAPE (IMAGE_SKY,       OPIHI_FLT); // deprecated for now
     620
     621  if (!strcasecmp (fieldName, "imflags"  )) ESCAPE (IMAGE_FLAGS,     OPIHI_INT);
     622  if (!strcasecmp (fieldName, "flags"    )) ESCAPE (IMAGE_FLAGS,     OPIHI_INT);
     623  if (!strcasecmp (fieldName, "ccdnum"   )) ESCAPE (IMAGE_CCDNUM,    OPIHI_INT);
     624
     625  if (!strcasecmp (fieldName, "imageID"  )) ESCAPE (IMAGE_IMAGE_ID,  OPIHI_INT);
     626  if (!strcasecmp (fieldName, "externID" )) ESCAPE (IMAGE_EXTERN_ID, OPIHI_INT);
     627  if (!strcasecmp (fieldName, "sourceID" )) ESCAPE (IMAGE_SOURCE_ID, OPIHI_INT);
     628
     629  if (!strcasecmp (fieldName, "X_LL_CHIP")) ESCAPE (IMAGE_X_LL_CHIP, OPIHI_FLT);
     630  if (!strcasecmp (fieldName, "X_LR_CHIP")) ESCAPE (IMAGE_X_LR_CHIP, OPIHI_FLT);
     631  if (!strcasecmp (fieldName, "X_UL_CHIP")) ESCAPE (IMAGE_X_UL_CHIP, OPIHI_FLT);
     632  if (!strcasecmp (fieldName, "X_UR_CHIP")) ESCAPE (IMAGE_X_UR_CHIP, OPIHI_FLT);
     633  if (!strcasecmp (fieldName, "Y_LL_CHIP")) ESCAPE (IMAGE_Y_LL_CHIP, OPIHI_FLT);
     634  if (!strcasecmp (fieldName, "Y_LR_CHIP")) ESCAPE (IMAGE_Y_LR_CHIP, OPIHI_FLT);
     635  if (!strcasecmp (fieldName, "Y_UL_CHIP")) ESCAPE (IMAGE_Y_UL_CHIP, OPIHI_FLT);
     636  if (!strcasecmp (fieldName, "Y_UR_CHIP")) ESCAPE (IMAGE_Y_UR_CHIP, OPIHI_FLT);
     637  if (!strcasecmp (fieldName, "X_LL_FP"  )) ESCAPE (IMAGE_X_LL_FP,   OPIHI_FLT);
     638  if (!strcasecmp (fieldName, "X_LR_FP"  )) ESCAPE (IMAGE_X_LR_FP,   OPIHI_FLT);
     639  if (!strcasecmp (fieldName, "X_UL_FP"  )) ESCAPE (IMAGE_X_UL_FP,   OPIHI_FLT);
     640  if (!strcasecmp (fieldName, "X_UR_FP"  )) ESCAPE (IMAGE_X_UR_FP,   OPIHI_FLT);
     641  if (!strcasecmp (fieldName, "Y_LL_FP"  )) ESCAPE (IMAGE_Y_LL_FP,   OPIHI_FLT);
     642  if (!strcasecmp (fieldName, "Y_LR_FP"  )) ESCAPE (IMAGE_Y_LR_FP,   OPIHI_FLT);
     643  if (!strcasecmp (fieldName, "Y_UL_FP"  )) ESCAPE (IMAGE_Y_UL_FP,   OPIHI_FLT);
     644  if (!strcasecmp (fieldName, "Y_UR_FP"  )) ESCAPE (IMAGE_Y_UR_FP,   OPIHI_FLT);
     645
     646  if (!strcasecmp (fieldName, "dX_SYS"  )) ESCAPE (IMAGE_X_ERR_SYS,  OPIHI_FLT);
     647  if (!strcasecmp (fieldName, "dY_SYS"  )) ESCAPE (IMAGE_Y_ERR_SYS,  OPIHI_FLT);
     648  if (!strcasecmp (fieldName, "dM_SYS"  )) ESCAPE (IMAGE_MAG_ERR_SYS,OPIHI_FLT);
     649
     650  if (!strcasecmp (fieldName, "UBERCAL_DIST")) ESCAPE (IMAGE_UBERCAL_DIST,OPIHI_INT);
     651  if (!strcasecmp (fieldName, "UCDIST")) ESCAPE (IMAGE_UBERCAL_DIST,OPIHI_INT);
     652
     653  if (!strcasecmp (fieldName, "NFIT_PHOTOM"))  ESCAPE (IMAGE_NFIT_PHOTOM,  OPIHI_INT);
     654  if (!strcasecmp (fieldName, "NFIT_ASTROM"))  ESCAPE (IMAGE_NFIT_ASTROM,  OPIHI_INT);
     655  if (!strcasecmp (fieldName, "NLINK_PHOTOM")) ESCAPE (IMAGE_NLINK_PHOTOM, OPIHI_INT);
     656  if (!strcasecmp (fieldName, "NLINK_ASTROM")) ESCAPE (IMAGE_NLINK_ASTROM, OPIHI_INT);
     657  if (!strcasecmp (fieldName, "REF_COLOR"))    ESCAPE (IMAGE_REF_COLOR,    OPIHI_FLT);
    531658
    532659  // for words that don't parse, try a photcode

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

    r36833 r37035  
    5656  if (!strcasecmp (catformat, "PS1_V3"))          return (DVO_FORMAT_PS1_V3);
    5757  if (!strcasecmp (catformat, "PS1_V4"))          return (DVO_FORMAT_PS1_V4);
     58  if (!strcasecmp (catformat, "PS1_V5"))          return (DVO_FORMAT_PS1_V5);
    5859  if (!strcasecmp (catformat, "PS1_REF"))         return (DVO_FORMAT_PS1_REF);
    5960  return (DVO_FORMAT_UNDEF);
    … …  
    6970}
    7071
     72float dvoOffsetR (Measure *measure, Average *average) {
     73
     74  float dR = (measure[0].R - average[0].R) * 3600.0;
     75  return dR;
     76}
     77
     78float dvoOffsetD (Measure *measure, Average *average) {
     79
     80  float dD = (measure[0].D - average[0].D) * 3600.0;
     81  return dD;
     82}
     83
     84double dvoMeanR (float dR, Average *average) {
     85
     86  double ra = average[0].R - dR / 3600.0;
     87  return ra;
     88}
     89
     90double dvoMeanD (float dD, Average *average) {
     91
     92  double dec = average[0].D - dD / 3600.0;
     93  return dec;
     94}
     95
    7196// init all data, or just catalog data
    7297void dvo_average_init (Average *average) {
    7398  average->R               = 0;
    7499  average->D               = 0;
    75   average->dR              = 0;
    76   average->dD              = 0;
     100  average->dR              = NAN;
     101  average->dD              = NAN;
    77102
    78103  average->uR              = 0;
    79104  average->uD              = 0;
    80   average->duR             = 0;
    81   average->duD             = 0;
     105  average->duR             = NAN;
     106  average->duD             = NAN;
    82107  average->P               = 0;
    83   average->dP              = 0;
     108  average->dP              = NAN;
     109
     110  average->Rstk            = NAN;
     111  average->Dstk            = NAN;
     112  average->dRstk           = NAN;
     113  average->dDstk           = NAN;
    84114
    85115  average->ChiSqAve        = NAN;
    … …  
    97127  average->Nmeasure        = 0;
    98128  average->Nmissing        = 0;
     129  average->Nlensing        = 0;
     130  average->Nlensobj        = 0;
    99131  average->Nextend         = 0;
     132
    100133  average->measureOffset   = -1;
    101134  average->missingOffset   = -1;
    102   average->refColor        = NAN;
     135  average->lensingOffset   = -1;
     136  average->lensobjOffset   = -1;
     137  average->extendOffset    = -1;
     138  average->paramsOffset    = -1;
     139
     140  average->refColorBlue    = NAN;
     141  average->refColorRed     = NAN;
    103142
    104143  average->flags           = 0;
    … …  
    109148  average->catID           = 0;
    110149  average->extID           = 0;
     150  average->extIDgc         = 0;
    111151}
    112152
    … …  
    125165void dvo_secfilt_init (SecFilt *secfilt) {
    126166  secfilt->M           = NAN;
     167  secfilt->dM          = NAN;
    127168  secfilt->Map         = NAN;
     169  secfilt->dMap        = NAN;
     170  secfilt->sMap        = NAN;
    128171  secfilt->Mkron       = NAN;
    129172  secfilt->dMkron      = NAN;
    130   secfilt->dM          = NAN;
    131   secfilt->Xm          = NAN_S_SHORT;
    132 
    133   secfilt->FluxPSF     = NAN;
    134   secfilt->dFluxPSF    = NAN;
    135   secfilt->FluxKron    = NAN;
    136   secfilt->dFluxKron   = NAN;
    137 
    138   secfilt->flags       = 0;
     173  secfilt->sMkron      = NAN;
     174
     175  secfilt->Mstdev      = NAN;
     176  secfilt->Mmin        = NAN;
     177  secfilt->Mmax        = NAN;
     178  secfilt->Mchisq      = NAN;
     179
    139180  secfilt->Ncode       = 0;
    140181  secfilt->Nused       = 0;
    141 
    142   secfilt->M_20        = NAN_S_SHORT;
    143   secfilt->M_80        = NAN_S_SHORT;
     182  secfilt->NusedKron   = 0;
     183  secfilt->NusedAp     = 0;
     184
     185  secfilt->flags       = 0;
     186
     187  secfilt->MpsfStk     = NAN;
     188  secfilt->FpsfStk     = NAN;
     189  secfilt->dFpsfStk    = NAN;
     190
     191  secfilt->MkronStk    = NAN;
     192  secfilt->FkronStk    = NAN;
     193  secfilt->dFkronStk   = NAN;
     194
     195  secfilt->MapStk      = NAN;
     196  secfilt->FapStk      = NAN;
     197  secfilt->dFapStk     = NAN;
     198
     199  secfilt->stackDetectID = 0;
     200
     201  secfilt->MpsfWrp     = NAN;
     202  secfilt->FpsfWrp     = NAN;
     203  secfilt->dFpsfWrp    = NAN;
     204  secfilt->sFpsfWrp    = NAN;
     205
     206  secfilt->MkronWrp    = NAN;
     207  secfilt->FkronWrp    = NAN;
     208  secfilt->dFkronWrp   = NAN;
     209  secfilt->sFkronWrp   = NAN;
     210
     211  secfilt->MapWrp      = NAN;
     212  secfilt->FapWrp      = NAN;
     213  secfilt->dFapWrp     = NAN;
     214  secfilt->sFapWrp     = NAN;
     215
     216  secfilt->NusedWrp     = 0;
     217  secfilt->NusedKronWrp = 0;
     218  secfilt->NusedApWrp   = 0;
    144219
    145220  secfilt->ubercalDist = 1000;
    146   secfilt->Mstdev      = NAN_S_SHORT;
    147   secfilt->stackDetectID     = 0;
    148221}
    149222
    150223// init all data, or just catalog data
    151224void dvo_measure_init (Measure *measure) {
     225 measure->R         = NAN;
     226 measure->D         = NAN;
     227
    152228 measure->M         = NAN;
    153  measure->dR        = NAN;
    154  measure->dD        = NAN;
    155  measure->Mcal      = NAN;
     229 measure->dM        = NAN;
    156230 measure->Map       = NAN;
     231 measure->dMap      = NAN;
    157232 measure->Mkron     = NAN;
    158233 measure->dMkron    = NAN;
    159  measure->dM        = NAN;
     234 measure->Mcal      = NAN;
    160235 measure->dMcal     = NAN;
    161236 measure->dt        = NAN;
    … …  
    165240 measure->FluxKron  = NAN;
    166241 measure->dFluxKron = NAN;
     242 measure->FluxAp    = NAN;
     243 measure->dFluxAp   = NAN;
    167244
    168245 measure->airmass   = NAN;
    … …  
    174251 measure->Yfix      = NAN;
    175252
     253 measure->XoffKH    = NAN;
     254 measure->YoffKH    = NAN;
     255 measure->XoffDCR   = NAN;
     256 measure->YoffDCR   = NAN;
     257 measure->RoffGAL   = NAN;
     258 measure->DoffGAL   = NAN;
     259
    176260 measure->Sky       = NAN;
    177261 measure->dSky      = NAN;
    178262
    179263 measure->t         = 0;
    180  measure->t_msec    = 0;
    181264 measure->averef    = 0;
    182265
    183266 measure->detID     = 0;
    184  measure->imageID   = 0;
    185267 measure->objID     = 0;
    186268 measure->catID     = 0;
     269
    187270 measure->extID     = 0;
     271
     272 measure->imageID   = 0;
    188273
    189274 measure->psfQF     = NAN;
    190275 measure->psfQFperf = NAN;
    191276 measure->psfChisq  = NAN;
     277
    192278 measure->psfNdof   = 0;
    193279 measure->psfNpix   = 0;
    … …  
    203289 measure->Myy       = 0;
    204290
     291 measure->t_msec    = 0;
     292 measure->photcode  = 0;
     293
    205294 measure->dXccd     = 0;
    206295 measure->dYccd     = 0;
    … …  
    210299 measure->pltscale  = NAN;
    211300
    212  measure->photcode  = 0;
    213301 measure->dbFlags   = 0;
    214302 measure->photFlags = 0;
    … …  
    216304
    217305void dvo_measureT_init (MeasureTiny *measure) {
    218  measure->dR        = NAN;
    219  measure->dD        = NAN;
     306 measure->R         = NAN;
     307 measure->D         = NAN;
    220308 measure->M         = NAN;
    221309 measure->Mcal      = NAN;
    … …  
    244332 measure->dRsys     = 0;
    245333 measure->myDet     = FALSE;
     334}
     335
     336// init all data, or just catalog data
     337void dvo_lensing_init (Lensing *lensing) {
     338  lensing->X11_sm_obj = NAN;
     339  lensing->X12_sm_obj = NAN;
     340  lensing->X22_sm_obj = NAN;
     341  lensing->E1_sm_obj  = NAN;
     342  lensing->E2_sm_obj  = NAN;
     343
     344  lensing->X11_sh_obj = NAN;
     345  lensing->X12_sh_obj = NAN;
     346  lensing->X22_sh_obj = NAN;
     347  lensing->E1_sh_obj  = NAN;
     348  lensing->E2_sh_obj  = NAN;
     349
     350  lensing->X11_sm_psf = NAN;
     351  lensing->X12_sm_psf = NAN;
     352  lensing->X22_sm_psf = NAN;
     353  lensing->E1_sm_psf  = NAN;
     354  lensing->E2_sm_psf  = NAN;
     355
     356  lensing->X11_sh_psf = NAN;
     357  lensing->X12_sh_psf = NAN;
     358  lensing->X22_sh_psf = NAN;
     359  lensing->E1_sh_psf  = NAN;
     360  lensing->E2_sh_psf  = NAN;
     361
     362  lensing->F_ApR5     = NAN;
     363  lensing->dF_ApR5    = NAN;
     364  lensing->sF_ApR5    = NAN;
     365  lensing->fF_ApR5    = NAN;
     366
     367  lensing->F_ApR6     = NAN;
     368  lensing->dF_ApR6    = NAN;
     369  lensing->sF_ApR6    = NAN;
     370  lensing->fF_ApR6    = NAN;
     371
     372  lensing->detID = -1;
     373  lensing->objID = -1;
     374  lensing->catID = -1;
     375  lensing->averef = 0;
     376}
     377
     378// init all data, or just catalog data
     379void dvo_lensobj_init (Lensobj *lensobj) {
     380  lensobj->X11_sm_obj = NAN;
     381  lensobj->X12_sm_obj = NAN;
     382  lensobj->X22_sm_obj = NAN;
     383  lensobj->E1_sm_obj  = NAN;
     384  lensobj->E2_sm_obj  = NAN;
     385
     386  lensobj->X11_sh_obj = NAN;
     387  lensobj->X12_sh_obj = NAN;
     388  lensobj->X22_sh_obj = NAN;
     389  lensobj->E1_sh_obj  = NAN;
     390  lensobj->E2_sh_obj  = NAN;
     391
     392  lensobj->X11_sm_psf = NAN;
     393  lensobj->X12_sm_psf = NAN;
     394  lensobj->X22_sm_psf = NAN;
     395  lensobj->E1_sm_psf  = NAN;
     396  lensobj->E2_sm_psf  = NAN;
     397
     398  lensobj->X11_sh_psf = NAN;
     399  lensobj->X12_sh_psf = NAN;
     400  lensobj->X22_sh_psf = NAN;
     401  lensobj->E1_sh_psf  = NAN;
     402  lensobj->E2_sh_psf  = NAN;
     403
     404  lensobj->F_ApR5     = NAN;
     405  lensobj->dF_ApR5    = NAN;
     406  lensobj->sF_ApR5    = NAN;
     407  lensobj->fF_ApR5    = NAN;
     408
     409  lensobj->F_ApR6     = NAN;
     410  lensobj->dF_ApR6    = NAN;
     411  lensobj->sF_ApR6    = NAN;
     412  lensobj->fF_ApR6    = NAN;
     413
     414  lensobj->gamma = NAN;
     415  lensobj->E1 = NAN;
     416  lensobj->E2 = NAN;
     417
     418  lensobj->objID = -1;
     419  lensobj->catID = -1;
     420
     421  lensobj->pad = 0;
    246422}
    247423
    … …  
    269445  catalog[0].secfilt = NULL;
    270446 
     447  catalog[0].lensing = NULL;
     448  catalog[0].lensobj = NULL;
     449
    271450  catalog[0].averageT = NULL;
    272451  catalog[0].measureT = NULL;
    … …  
    281460  catalog[0].Nsecf_mem = 0;
    282461
     462  catalog[0].Nlensing = 0;
     463  catalog[0].Nlensobj = 0;
     464
    283465  catalog[0].Naves_disk = 0;
    284466  catalog[0].Nmeas_disk = 0;
    … …  
    286468  catalog[0].Nsecf_disk = 0;
    287469
     470  catalog[0].Nlensing_disk = 0;
     471  catalog[0].Nlensobj_disk = 0;
     472
    288473  catalog[0].Naves_off  = 0;
    289474  catalog[0].Nmeas_off  = 0;
    … …  
    291476  catalog[0].Nsecf_off  = 0;
    292477
     478  catalog[0].Nlensing_off  = 0;
     479  catalog[0].Nlensobj_off  = 0;
     480
    293481  /* pointers to SPLIT data files */
    294482  catalog[0].measure_catalog = NULL;
    295483  catalog[0].missing_catalog = NULL;
    296484  catalog[0].secfilt_catalog = NULL;
     485  catalog[0].lensing_catalog = NULL;
     486  catalog[0].lensobj_catalog = NULL;
    297487
    298488  /* pointers for data manipulation */
    299   catalog[0].found = NULL;
    300   catalog[0].image = NULL;
    301   catalog[0].mosaic = NULL;
    302   catalog[0].X = NULL;
    303   catalog[0].Y = NULL;
     489  // catalog[0].X_t = NULL;
     490  // catalog[0].Y_t = NULL;
     491  catalog[0].nOwn_t = NULL;
     492  catalog[0].found_t = NULL;
     493  // catalog[0].image_t = NULL;
     494  // catalog[0].mosaic_t = NULL;
     495  catalog[0].foundWarp_t = NULL;
    304496}
    305497
    … …  
    345537  }
    346538
     539  // closes f but does not set back to NULL
    347540  fclearlockfile (catalog[0].filename, catalog[0].f, catalog[0].lockmode, &dbstate);
    348541
    349542  if (catalog[0].catmode == DVO_MODE_SPLIT) {
    350     if (catalog[0].measure_catalog != NULL) dvo_catalog_unlock (catalog[0].measure_catalog);
    351     if (catalog[0].missing_catalog != NULL) dvo_catalog_unlock (catalog[0].missing_catalog);
    352     if (catalog[0].secfilt_catalog != NULL) dvo_catalog_unlock (catalog[0].secfilt_catalog);
     543    if (catalog[0].measure_catalog) dvo_catalog_unlock (catalog[0].measure_catalog);
     544    if (catalog[0].missing_catalog) dvo_catalog_unlock (catalog[0].missing_catalog);
     545    if (catalog[0].secfilt_catalog) dvo_catalog_unlock (catalog[0].secfilt_catalog);
     546    if (catalog[0].lensing_catalog) dvo_catalog_unlock (catalog[0].lensing_catalog);
     547    if (catalog[0].lensobj_catalog) dvo_catalog_unlock (catalog[0].lensobj_catalog);
    353548  }
    354549  return (1);
    … …  
    579774    for (in = out = i = 0; i < catalog[0].Naverage; i++) {
    580775      for (j = 0; j < catalog[0].Nsecfilt; j++, in++, out++) {
    581         outsec[out].M  = insec[in].M;
    582         outsec[out].dM = insec[in].dM;
    583         outsec[out].Xm = insec[in].Xm;
     776        outsec[out].M      = insec[in].M;
     777        outsec[out].dM     = insec[in].dM;
     778        outsec[out].Mchisq = insec[in].Mchisq;
    584779      }
    585780      for (j = 0; j < Nextra; j++, out++) {
    586         outsec[out].M  = NAN;
    587         outsec[out].dM = NAN;
    588         outsec[out].Xm = NAN_S_SHORT;
     781        outsec[out].M      = NAN;
     782        outsec[out].dM     = NAN;
     783        outsec[out].Mchisq = NAN;
    589784      }
    590785    }
    … …  
    616811      free (catalog[0].secfilt_catalog);
    617812    }
     813    if (catalog[0].lensing_catalog) {
     814      free (catalog[0].lensing_catalog[0].filename);
     815      dvo_catalog_free (catalog[0].lensing_catalog);
     816      free (catalog[0].lensing_catalog);
     817    }
     818    if (catalog[0].lensobj_catalog) {
     819      free (catalog[0].lensobj_catalog[0].filename);
     820      dvo_catalog_free (catalog[0].lensobj_catalog);
     821      free (catalog[0].lensobj_catalog);
     822    }
    618823  }
    619824  dvo_catalog_free_data (catalog);
    … …  
    625830
    626831  /* free, initialize data structures */
    627   if (catalog[0].average != NULL) {
     832  if (catalog[0].average) {
    628833    free (catalog[0].average);
    629834    catalog[0].Naverage = 0;
    630835    catalog[0].average = NULL;
    631836  }
    632   if (catalog[0].measure != NULL) {
     837  if (catalog[0].measure) {
    633838    free (catalog[0].measure);
    634839    catalog[0].Nmeasure = 0;
    635840    catalog[0].measure = NULL;
    636841  }
    637   if (catalog[0].missing != NULL) {
     842  if (catalog[0].missing) {
    638843    free (catalog[0].missing);
    639844    catalog[0].Nmissing = 0;
    640845    catalog[0].missing = NULL;
    641846  }
    642   if (catalog[0].secfilt != NULL) {
     847  if (catalog[0].secfilt) {
    643848    free (catalog[0].secfilt);
    644849    catalog[0].Nsecf_mem = 0;
    645850    catalog[0].secfilt = NULL;
    646851  }
     852  if (catalog[0].lensing) {
     853    free (catalog[0].lensing);
     854    catalog[0].Nlensing = 0;
     855    catalog[0].lensing = NULL;
     856  }
     857  if (catalog[0].lensobj) {
     858    free (catalog[0].lensobj);
     859    catalog[0].Nlensobj = 0;
     860    catalog[0].lensobj = NULL;
     861  }
     862  // if (catalog[0].X_t)      free (catalog[0].X_t);
     863  // if (catalog[0].Y_t)      free (catalog[0].Y_t);
     864  if (catalog[0].nOwn_t)      free (catalog[0].nOwn_t);
     865  if (catalog[0].found_t)     free (catalog[0].found_t);
     866  // if (catalog[0].image_t)  free (catalog[0].image_t);
     867  // if (catalog[0].mosaic_t) free (catalog[0].mosaic_t);
     868  if (catalog[0].foundWarp_t) free (catalog[0].foundWarp_t);
    647869}
    648870
    … …  
    733955      }
    734956    }
     957    if (catalog[0].lensing_catalog != NULL) {
     958      if (catalog[0].Nlensing_disk == 0) {
     959        // need to relock (and re-open) file for close elsewhere
     960        status = dvo_catalog_lock (catalog[0].lensing_catalog, lockmode);
     961      } else {
     962        if (!dvo_catalog_backup (catalog[0].lensing_catalog, FALSE)) {
     963          return FALSE;
     964        }
     965      }
     966    }
     967    if (catalog[0].lensobj_catalog != NULL) {
     968      if (catalog[0].Nlensobj_disk == 0) {
     969        // need to relock (and re-open) file for close elsewhere
     970        status = dvo_catalog_lock (catalog[0].lensobj_catalog, lockmode);
     971      } else {
     972        if (!dvo_catalog_backup (catalog[0].lensobj_catalog, FALSE)) {
     973          return FALSE;
     974        }
     975      }
     976    }
    735977  }
    736978  return TRUE;
    … …  
    754996  status = unlink (tmpfilename);
    755997  if (status) {
    756     fprintf (stderr, "failed to unlink catalog %s\n", catalog->filename);
     998    fprintf (stderr, "failed to unlink catalog %s~\n", catalog->filename);
    757999    return FALSE;
    7581000  }
    … …  
    7741016      }
    7751017    }
     1018    if ((catalog[0].lensing_catalog != NULL) && (catalog[0].Nlensing_disk > 0)) {
     1019      if (!dvo_catalog_unlink_backup (catalog[0].lensing_catalog, FALSE)) {
     1020        return FALSE;
     1021      }
     1022    }
     1023    if ((catalog[0].lensobj_catalog != NULL) && (catalog[0].Nlensobj_disk > 0)) {
     1024      if (!dvo_catalog_unlink_backup (catalog[0].lensobj_catalog, FALSE)) {
     1025        return FALSE;
     1026      }
     1027    }
    7761028  }
    7771029  return TRUE;

  • trunk/Ohana/src/libdvo/src/dvo_catalog_chipcoords.c

    r16810 r37035  
    5656    m = average[i].measureOffset;
    5757    for (j = 0; j < average[i].Nmeasure; j++, m++) {
    58       ra  = average[i].R - measure[m].dR / 3600.0;
    59       dec = average[i].D - measure[m].dD / 3600.0;
     58      ra  = measure[m].R;
     59      dec = measure[m].D;
    6060      N = dvo_match_image (image, Nimage, measure[m].t, measure[m].photcode);
    6161      if (N == -1) continue;

  • trunk/Ohana/src/libdvo/src/dvo_catalog_create.c

    r27435 r37035  
    7070    gfits_modify (&catalog[0].header, "SECFILT", "%s", 1, file);
    7171    free (file);
     72
     73    /* define lensing catalog file */
     74    ALLOCATE (catalog[0].lensing_catalog, Catalog, 1);
     75    dvo_catalog_init (catalog[0].lensing_catalog, TRUE);
     76
     77    /* create basic data for lensing catalog file */
     78    gfits_create_header (&catalog[0].lensing_catalog[0].header);
     79    ALLOCATE (catalog[0].lensing_catalog[0].filename, char, length);
     80    sprintf (catalog[0].lensing_catalog[0].filename, "%s/%s.cpx", path, root);
     81    file = filebasename (catalog[0].lensing_catalog[0].filename);
     82    gfits_modify (&catalog[0].header, "LENSING", "%s", 1, file);
     83    free (file);
     84
     85    /* define lensobj catalog file */
     86    ALLOCATE (catalog[0].lensobj_catalog, Catalog, 1);
     87    dvo_catalog_init (catalog[0].lensobj_catalog, TRUE);
     88
     89    /* create basic data for lensobj catalog file */
     90    gfits_create_header (&catalog[0].lensobj_catalog[0].header);
     91    ALLOCATE (catalog[0].lensobj_catalog[0].filename, char, length);
     92    sprintf (catalog[0].lensobj_catalog[0].filename, "%s/%s.cpy", path, root);
     93    file = filebasename (catalog[0].lensobj_catalog[0].filename);
     94    gfits_modify (&catalog[0].header, "LENSOBJ", "%s", 1, file);
     95    free (file);
     96
    7297    free (path);
    7398    free (root);
    … …  
    84109    }
    85110    if (dvo_catalog_lock (catalog[0].secfilt_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
     111      fprintf (stderr, "error with file lock\n");
     112      exit (2);
     113    }
     114    if (dvo_catalog_lock (catalog[0].lensing_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
     115      fprintf (stderr, "error with file lock\n");
     116      exit (2);
     117    }
     118    if (dvo_catalog_lock (catalog[0].lensobj_catalog, catalog[0].lockmode) != DVO_CAT_OPEN_EMPTY) {
    86119      fprintf (stderr, "error with file lock\n");
    87120      exit (2);
    … …  
    111144  ALLOCATE (catalog[0].missing, Missing, 1);
    112145  ALLOCATE (catalog[0].secfilt, SecFilt, 1);
     146  ALLOCATE (catalog[0].lensing, Lensing, 1);
     147  ALLOCATE (catalog[0].lensobj, Lensobj, 1);
    113148
    114149  /* setup secondary filters to match photcodes:

  • trunk/Ohana/src/libdvo/src/dvo_catalog_mef.c

    r33649 r37035  
    77  off_t Nmeasure;
    88  off_t Nmissing;
     9  off_t Nlensing;
     10  off_t Nlensobj;
    911  off_t Nitems, Nexpect;
    1012  int Nsecfilt;
    … …  
    2224  if (!gfits_scan (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  &Nmissing)) return (FALSE);
    2325  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d",   1,               &Nsecfilt)) Nsecfilt = 0;
     26  if (!gfits_scan (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  &Nlensing)) return (FALSE);
     27  if (!gfits_scan (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  &Nlensobj)) return (FALSE);
    2428
    2529  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
    … …  
    4044  catalog[0].Nmiss_disk = Nmissing;
    4145  catalog[0].Nsecf_disk = Naverage * Nsecfilt;
     46  catalog[0].Nlensing_disk = Nlensing;
     47  catalog[0].Nlensobj_disk = Nlensobj;
    4248
    4349  /**  Nsecfilt is unusual: it does not list the number of data items in the table
    … …  
    5056  catalog[0].missing = NULL;
    5157  catalog[0].secfilt = NULL;
     58  catalog[0].lensing = NULL;
     59  catalog[0].lensobj = NULL;
    5260
    5361  /* validate table mode ?*/
    … …  
    101109      return (FALSE);
    102110    }
    103     catalog[0].measure = FtableToMeasure (&ftable, &catalog[0].Nmeasure, &catalog[0].catformat);
     111    catalog[0].measure = FtableToMeasure (&ftable, catalog[0].average, &catalog[0].Nmeasure, &catalog[0].catformat);
    104112    if (Nmeasure != catalog[0].Nmeas_disk) {
    105113      fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nmeasure,  catalog[0].Nmeas_disk);
    … …  
    201209  }
    202210
     211  /* read Lensing table header */
     212  if (!gfits_fread_header (catalog[0].f, &header)) {
     213    if (VERBOSE) fprintf (stderr, "can't read table lensing header");
     214    return (FALSE);
     215  }
     216  /* read Lensing table data */
     217  if (catalog[0].catflags & LOAD_LENSING) {
     218    if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) {
     219      if (VERBOSE) fprintf (stderr, "can't read table lensing data");
     220      return (FALSE);
     221    }
     222    catalog[0].lensing = FtableToLensing (&ftable, &catalog[0].Nlensing, &catalog[0].catformat);
     223    if (Nlensing != catalog[0].Nlensing_disk) {
     224      fprintf (stderr, "Warning: mismatch between Nlensing in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensing,  catalog[0].Nlensing_disk);
     225    }
     226    catalog[0].Nlensing = catalog[0].Nlensing_disk;
     227    catalog[0].Nlensing_off = 0;
     228  } else {
     229    Nbytes = gfits_data_size (&header);
     230    fseeko (catalog[0].f, Nbytes, SEEK_CUR);
     231    ALLOCATE (catalog[0].lensing, Lensing, 1);
     232    catalog[0].Nlensing = 0;
     233    catalog[0].Nlensing_off = catalog[0].Nlensing_disk;
     234  }
     235
     236  /* read Lensobj table header */
     237  if (!gfits_fread_header (catalog[0].f, &header)) {
     238    if (VERBOSE) fprintf (stderr, "can't read table lensobj header");
     239    return (FALSE);
     240  }
     241  /* read Lensobj table data */
     242  if (catalog[0].catflags & LOAD_LENSOBJ) {
     243    if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) {
     244      if (VERBOSE) fprintf (stderr, "can't read table lensobj data");
     245      return (FALSE);
     246    }
     247    catalog[0].lensobj = FtableToLensobj (&ftable, &catalog[0].Nlensobj, &catalog[0].catformat);
     248    if (Nlensobj != catalog[0].Nlensobj_disk) {
     249      fprintf (stderr, "Warning: mismatch between Nlensobj in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensobj,  catalog[0].Nlensobj_disk);
     250    }
     251    catalog[0].Nlensobj = catalog[0].Nlensobj_disk;
     252    catalog[0].Nlensobj_off = 0;
     253  } else {
     254    Nbytes = gfits_data_size (&header);
     255    fseeko (catalog[0].f, Nbytes, SEEK_CUR);
     256    ALLOCATE (catalog[0].lensobj, Lensobj, 1);
     257    catalog[0].Nlensobj = 0;
     258    catalog[0].Nlensobj_off = catalog[0].Nlensobj_disk;
     259  }
     260
    203261  return (TRUE);
    204262}
    … …  
    249307  gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  catalog[0].Nmissing);
    250308  gfits_modify (&catalog[0].header, "NSECFILT", "%d",   1,                        Nsecfilt);
     309  gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  catalog[0].Nlensing);
     310  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  catalog[0].Nlensobj);
    251311  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    252312  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    … …  
    289349
    290350  /* write out Measure table (convert to FITS table format) */
    291   MeasureToFtable (&ftable, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
     351  MeasureToFtable (&ftable, catalog[0].average, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
    292352  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
    293353    fprintf (stderr, "can't write table header");
    … …  
    317377  Nitems = catalog[0].Naverage * Nsecfilt;
    318378  SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
     379  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
     380    fprintf (stderr, "can't write table header");
     381    goto failure;
     382  }
     383  if (!gfits_fwrite_table (catalog[0].f, &ftable)) {
     384    fprintf (stderr, "can't write table data");
     385    goto failure;
     386  }
     387  gfits_free_table (&ftable);
     388  gfits_free_header (&header);
     389
     390  /* write out Lensing table (convert to FITS table format) */
     391  LensingToFtable (&ftable, catalog[0].lensing, catalog[0].Nlensing, catalog[0].catformat);
     392  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
     393    fprintf (stderr, "can't write table header");
     394    goto failure;
     395  }
     396  if (!gfits_fwrite_table (catalog[0].f, &ftable)) {
     397    fprintf (stderr, "can't write table data");
     398    goto failure;
     399  }
     400  gfits_free_table (&ftable);
     401  gfits_free_header (&header);
     402
     403  /* write out Lensobj table (convert to FITS table format) */
     404  LensobjToFtable (&ftable, catalog[0].lensobj, catalog[0].Nlensobj, catalog[0].catformat);
    319405  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
    320406    fprintf (stderr, "can't write table header");
    … …  
    356442  secfilt header
    357443  secfilt table
     444  lensing header
     445  lensing table
     446  lensobj header
     447  lensobj table
    358448*/
    359449   

  • trunk/Ohana/src/libdvo/src/dvo_catalog_raw.c

    r34260 r37035  
    9090      FORMAT_CASE (PS1_V3,    PS1_V3);
    9191      FORMAT_CASE (PS1_V4,    PS1_V4);
     92      FORMAT_CASE (PS1_V5,    PS1_V5);
    9293      FORMAT_CASE (PS1_REF,   PS1_REF);
    9394
    … …  
    144145  /* read and convert the measures (use a macro to clean this up?) */
    145146  if (catalog[0].catflags & LOAD_MEAS) {
    146     catalog[0].measure = ReadRawMeasure (catalog[0].f, catalog[0].Nmeasure, catalog[0].catformat);
     147    catalog[0].measure = ReadRawMeasure (catalog[0].f, catalog[0].average, catalog[0].Nmeasure, catalog[0].catformat);
    147148  } else {
    148149    /* skip over measures */
    … …  
    284285  if (catalog[0].catformat == DVO_FORMAT_PS1_V3)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V3");
    285286  if (catalog[0].catformat == DVO_FORMAT_PS1_V4)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V4");
     287  if (catalog[0].catformat == DVO_FORMAT_PS1_V5)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_V5");
    286288  if (catalog[0].catformat == DVO_FORMAT_PS1_REF)         gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_REF");
    287289
    … …  
    303305  /* write averages and measures */
    304306  WriteRawAverage (f, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
    305   WriteRawMeasure (f, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
     307  WriteRawMeasure (f, catalog[0].average, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
    306308
    307309  /* write missing data */
    … …  
    387389      FORMAT_CASE (PS1_V3,    PS1_V3);
    388390      FORMAT_CASE (PS1_V4,    PS1_V4);
     391      FORMAT_CASE (PS1_V5,    PS1_V5);
    389392      FORMAT_CASE (PS1_REF,   PS1_REF);
    390393
    … …  
    438441      FORMAT_CASE (PS1_V3,    PS1_V3);
    439442      FORMAT_CASE (PS1_V4,    PS1_V4);
     443      FORMAT_CASE (PS1_V5,    PS1_V5);
    440444      FORMAT_CASE (PS1_REF,   PS1_REF);
    441445
    … …  
    451455/** Average / Raw Table conversions **/
    452456
    453 Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format) {
     457Measure *ReadRawMeasure (FILE *f, Average *average, off_t Nmeasure, char format) {
    454458
    455459  Measure *measure;
    … …  
    467471      } \
    468472      gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \
    469       measure = Measure_##TYPE##_ToInternal (tmpMeasure, Nmeasure); \
     473      measure = Measure_##TYPE##_ToInternal (average, tmpMeasure, Nmeasure); \
    470474      free (tmpMeasure); \
    471475      break; }
    … …  
    481485      }
    482486      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
     487      break; }
     488
     489      FORMAT_CASE (LONEOS, Loneos);
     490      FORMAT_CASE (ELIXIR, Elixir);
     491      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     492      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     493      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
     494      FORMAT_CASE (PS1_DEV_2, PS1_DEV_2);
     495      FORMAT_CASE (PS1_V1,    PS1_V1);
     496      FORMAT_CASE (PS1_V2,    PS1_V2);
     497      FORMAT_CASE (PS1_V3,    PS1_V3);
     498      FORMAT_CASE (PS1_V5,    PS1_V5);
     499      FORMAT_CASE (PS1_REF,   PS1_REF);
     500
     501    default:
     502      fprintf (stderr, "error reading measures\n");
     503      return (NULL);
     504  }
     505# undef FORMAT_CASE
     506
     507  return (measure);
     508}
     509
     510/* accepts and converts internal measure formats and outputs
     511   raw data in the specified format */
     512int WriteRawMeasure (FILE *f, Average *average, Measure *measure, off_t Nmeasure, char format) {
     513
     514// this macro generates the case statements for each type
     515# define FORMAT_CASE(NAME,TYPE) \
     516    case DVO_FORMAT_##NAME: { \
     517      off_t nitems; \
     518      Measure_##TYPE *tmpMeasure; \
     519      tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
     520      gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \
     521      nitems = fwrite (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \
     522      free (tmpMeasure); \
     523      if (nitems != Nmeasure) { \
     524        fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n",  nitems,  Nmeasure); \
     525        return (FALSE); \
     526      } \
     527      break; }
     528
     529  switch (format) {
     530    case DVO_FORMAT_INTERNAL: {
     531      off_t nitems;
     532      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
     533      nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
     534      if (nitems != Nmeasure) {
     535        fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n",  nitems,  Nmeasure);
     536        return (FALSE);
     537      }
    483538      break; }
    484539
    … …  
    493548      FORMAT_CASE (PS1_V3,    PS1_V3);
    494549      FORMAT_CASE (PS1_V4,    PS1_V4);
    495       FORMAT_CASE (PS1_REF,   PS1_REF);
    496 
    497     default:
    498       fprintf (stderr, "error reading measures\n");
    499       return (NULL);
    500   }
    501 # undef FORMAT_CASE
    502 
    503   return (measure);
    504 }
    505 
    506 /* accepts and converts internal measure formats and outputs
    507    raw data in the specified format */
    508 int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format) {
    509 
    510 // this macro generates the case statements for each type
    511 # define FORMAT_CASE(NAME,TYPE) \
    512     case DVO_FORMAT_##NAME: { \
    513       off_t nitems; \
    514       Measure_##TYPE *tmpMeasure; \
    515       tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \
    516       gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \
    517       nitems = fwrite (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \
    518       free (tmpMeasure); \
    519       if (nitems != Nmeasure) { \
    520         fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n",  nitems,  Nmeasure); \
    521         return (FALSE); \
    522       } \
    523       break; }
    524 
    525   switch (format) {
    526     case DVO_FORMAT_INTERNAL: {
    527       off_t nitems;
    528       gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
    529       nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
    530       if (nitems != Nmeasure) {
    531         fprintf (stderr, "failed to write measures ("OFF_T_FMT" vs "OFF_T_FMT")\n",  nitems,  Nmeasure);
    532         return (FALSE);
    533       }
    534       break; }
    535 
    536       FORMAT_CASE (LONEOS, Loneos);
    537       FORMAT_CASE (ELIXIR, Elixir);
    538       FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
    539       FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
    540       FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
    541       FORMAT_CASE (PS1_DEV_2, PS1_DEV_2);
    542       FORMAT_CASE (PS1_V1,    PS1_V1);
    543       FORMAT_CASE (PS1_V2,    PS1_V2);
    544       FORMAT_CASE (PS1_V3,    PS1_V3);
    545       FORMAT_CASE (PS1_V4,    PS1_V4);
     550      FORMAT_CASE (PS1_V5,    PS1_V5);
    546551      FORMAT_CASE (PS1_REF,   PS1_REF);
    547552
    … …  
    599604      FORMAT_CASE (PS1_V3,    PS1_V3);
    600605      FORMAT_CASE (PS1_V4,    PS1_V4);
     606      FORMAT_CASE (PS1_V5,    PS1_V5);
    601607      FORMAT_CASE (PS1_REF,   PS1_REF);
    602608
    … …  
    650656      FORMAT_CASE (PS1_V3,    PS1_V3);
    651657      FORMAT_CASE (PS1_V4,    PS1_V4);
     658      FORMAT_CASE (PS1_V5,    PS1_V5);
    652659      FORMAT_CASE (PS1_REF,   PS1_REF);
    653660

  • trunk/Ohana/src/libdvo/src/dvo_catalog_split.c

    r34844 r37035  
    134134  if (!gfits_scan (&catalog[0].header, name,  "%s", 1, string)) {
    135135    free (path);
     136    // databases created prior to ~2014.07.01 did not have the LENSING or LENSOBJ paths in their headers.
     137    // in these cases, we do not try to lock or open the relevant file
     138    if (!strcmp (name, "LENSING")) return (DVO_CAT_OPEN_EMPTY);
     139    if (!strcmp (name, "LENSOBJ")) return (DVO_CAT_OPEN_EMPTY);
    136140    return (DVO_CAT_OPEN_FAIL);
    137141  }
    … …  
    161165  fseeko (subcat[0].f, Nskip, SEEK_CUR);
    162166
    163   /* read Measure table header */
     167  /* read table header */
    164168  if (!gfits_fread_header (subcat[0].f, header)) {
    165169    if (VERBOSE) fprintf (stderr, "can't read %s PHU header\n", name);
    … …  
    176180  off_t Nmeasure;
    177181  off_t Nmissing;
     182  off_t Nlensing;
     183  off_t Nlensobj;
    178184  off_t Nitems;
    179185  int status, Nsecfilt;
    … …  
    190196
    191197  /* get the components from the header - these duplicate information in the split files (NAXIS2) */
     198  // NSTARS, NMEAS, NMISS are required; NLENSING, NLENSOBJ are not (0 if not found)
    192199  if (!gfits_scan (&catalog[0].header, "NSTARS",   OFF_T_FMT, 1,  &Naverage)) return (FALSE);
    193200  if (!gfits_scan (&catalog[0].header, "NMEAS",    OFF_T_FMT, 1,  &Nmeasure)) return (FALSE);
    194201  if (!gfits_scan (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  &Nmissing)) return (FALSE);
    195   if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d",   1,               &Nsecfilt)) Nsecfilt = 0;
     202  if (!gfits_scan (&catalog[0].header, "NSECFILT",      "%d", 1,  &Nsecfilt)) Nsecfilt = 0;
     203  if (!gfits_scan (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  &Nlensing)) Nlensing = 0;
     204  if (!gfits_scan (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  &Nlensobj)) Nlensobj = 0;
    196205
    197206  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
    … …  
    212221  catalog[0].Nmiss_disk = Nmissing;
    213222  catalog[0].Nsecf_disk = Naverage * Nsecfilt;
     223  catalog[0].Nlensing_disk = Nlensing;
     224  catalog[0].Nlensobj_disk = Nlensobj;
    214225
    215226  /**  Nsecfilt is unusual: it does not list the number of data items in the table
    … …  
    222233  catalog[0].missing = NULL;
    223234  catalog[0].secfilt = NULL;
     235  catalog[0].lensing = NULL;
     236  catalog[0].lensobj = NULL;
    224237
    225238  /*** Average Table ***/
    … …  
    277290    }
    278291    /* convert data format to internal : returns number of row read in Nmeasure */
    279     catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat);
     292    catalog[0].measure = FtableToMeasure (&ftable, catalog[0].average, &Nmeasure, &catalog[0].catformat);
    280293    if (Nmeasure != catalog[0].Nmeas_disk) {
    281294      fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nmeasure,  catalog[0].Nmeas_disk);
    … …  
    372385  gfits_free_header (ftable.header);
    373386
     387  /*** Lensing Table ***/
     388  if (!(catalog[0].catflags & SKIP_LENSING)) {
     389    // unless we specify 'skip', we still need to load the Lensing table
     390    status = dvo_catalog_open_subcat (catalog, &catalog[0].lensing_catalog, ftable.header, "LENSING", VERBOSE);
     391    if (status == DVO_CAT_OPEN_FAIL) {
     392      return (FALSE);
     393    }
     394    // the Lensing file need not exist, unless we expect data to exist
     395    if ((status == DVO_CAT_OPEN_EMPTY) && (catalog[0].Nlensing_disk > 0)) {
     396      return (FALSE);
     397    }
     398  }
     399  if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_LENSING)) {
     400    // only read the Lensing table if the file actually exists
     401    /* read Lensing table data */
     402    if (!gfits_fread_ftable_data (catalog[0].lensing_catalog[0].f, &ftable, FALSE)) {
     403      if (VERBOSE) fprintf (stderr, "can't read table lensing data\n");
     404      return (FALSE);
     405    }
     406    /* convert data format to internal : returns number of row read in Nlensing */
     407    catalog[0].lensing = FtableToLensing (&ftable, &Nlensing, &catalog[0].catformat);
     408    if (Nlensing != catalog[0].Nlensing_disk) {
     409      fprintf (stderr, "Warning: mismatch between Nlensing in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensing,  catalog[0].Nlensing_disk);
     410    }
     411    catalog[0].Nlensing = catalog[0].Nlensing_disk;
     412    catalog[0].Nlensing_off = 0;
     413  } else {
     414    if (catalog[0].lensing_catalog) {
     415      gfits_free_header (&catalog[0].lensing_catalog[0].header);
     416    } else {
     417      ALLOCATE (catalog[0].lensing_catalog, Catalog, 1);
     418      dvo_catalog_init (catalog[0].lensing_catalog, TRUE);
     419    }
     420    gfits_create_header (&catalog[0].lensing_catalog[0].header);
     421    ALLOCATE (catalog[0].lensing, Lensing, 1);
     422    catalog[0].Nlensing = 0;
     423    catalog[0].Nlensing_off = catalog[0].Nlensing_disk;
     424  }
     425  gfits_free_header (&header);
     426
     427  /*** Lensobj Table ***/
     428  if (!(catalog[0].catflags & SKIP_LENSOBJ)) {
     429    // unless we specify 'skip', we still need to load the
     430    status = dvo_catalog_open_subcat (catalog, &catalog[0].lensobj_catalog, ftable.header, "LENSOBJ", VERBOSE);
     431    if (status == DVO_CAT_OPEN_FAIL) {
     432      return (FALSE);
     433    }
     434    // the Lensobj file need not exist, unless we expect data to exist
     435    if ((status == DVO_CAT_OPEN_EMPTY) && (catalog[0].Nlensobj_disk > 0)) {
     436      return (FALSE);
     437    }
     438  }
     439  if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_LENSOBJ)) {
     440    // only read the Lensobj table if the file actually exists
     441    /* read Lensobj table data */
     442    if (!gfits_fread_ftable_data (catalog[0].lensobj_catalog[0].f, &ftable, FALSE)) {
     443      if (VERBOSE) fprintf (stderr, "can't read table lensobj data\n");
     444      return (FALSE);
     445    }
     446    /* convert data format to internal : returns number of row read in Nlensobj */
     447    catalog[0].lensobj = FtableToLensobj (&ftable, &Nlensobj, &catalog[0].catformat);
     448    if (Nlensobj != catalog[0].Nlensobj_disk) {
     449      fprintf (stderr, "Warning: mismatch between Nlensobj in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensobj,  catalog[0].Nlensobj_disk);
     450    }
     451    catalog[0].Nlensobj = catalog[0].Nlensobj_disk;
     452    catalog[0].Nlensobj_off = 0;
     453  } else {
     454    if (catalog[0].lensobj_catalog) {
     455      gfits_free_header (&catalog[0].lensobj_catalog[0].header);
     456    } else {
     457      ALLOCATE (catalog[0].lensobj_catalog, Catalog, 1);
     458      dvo_catalog_init (catalog[0].lensobj_catalog, TRUE);
     459    }
     460    gfits_create_header (&catalog[0].lensobj_catalog[0].header);
     461    ALLOCATE (catalog[0].lensobj, Lensobj, 1);
     462    catalog[0].Nlensobj = 0;
     463    catalog[0].Nlensobj_off = catalog[0].Nlensobj_disk;
     464  }
     465  gfits_free_header (&header);
     466
    374467  return (TRUE);
    375468}
    … …  
    380473
    381474  off_t Nbytes;
    382   off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing;
     475  off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing, Nlensing, Nlensobj;
    383476  Header header;
    384477  FTable ftable;
    … …  
    476569
    477570    /* convert data format to internal : returns number of row read in Nmeasure */
    478     catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat);
     571    catalog[0].measure = FtableToMeasure (&ftable, catalog[0].average, &Nmeasure, &catalog[0].catformat);
    479572    if (Nmeasure != Nrows) {
    480573      // XXX this condition denotes the eof has been reached; not an error or a warning
    … …  
    519612    catalog[0].Nmiss_off = start;
    520613  }
     614
     615  // XXX check the open status of the catalog
     616  if (catalog[0].catflags & LOAD_LENSING) {
     617
     618    Catalog *subcat = catalog[0].lensing_catalog;
     619
     620    /* move pointer past header -- must be already read (load_catalog) */
     621    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
     622    fseeko (subcat[0].f, Nbytes, SEEK_SET);
     623
     624    /* read Lensing table header */
     625    if (!gfits_fread_header (subcat[0].f, &header)) {
     626      if (VERBOSE) fprintf (stderr, "can't read table lensing header");
     627      return (FALSE);
     628    }
     629    /* read Lensing table data : format is irrelevant here */
     630    if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) {
     631      if (VERBOSE) fprintf (stderr, "can't read table lensing data");
     632      return (FALSE);
     633    }
     634
     635    /* convert data format to internal : returns number of row read in Nlensing */
     636    catalog[0].lensing = FtableToLensing (&ftable, &Nlensing, &catalog[0].catformat);
     637    if (Nlensing != Nrows) {
     638      // XXX this condition denotes the eof has been reached; not an error or a warning
     639      // fprintf (stderr, "Warning: mismatch between Nlensing in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensing,  Nrows);
     640    }
     641    gfits_free_header (&header);
     642    catalog[0].Nlensing = Nlensing;
     643    catalog[0].Nlensing_off = start;
     644  }
     645
     646  // XXX check the open status of the catalog
     647  if (catalog[0].catflags & LOAD_LENSOBJ) {
     648
     649    Catalog *subcat = catalog[0].lensobj_catalog;
     650
     651    /* move pointer past header -- must be already read (load_catalog) */
     652    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
     653    fseeko (subcat[0].f, Nbytes, SEEK_SET);
     654
     655    /* read Lensobj table header */
     656    if (!gfits_fread_header (subcat[0].f, &header)) {
     657      if (VERBOSE) fprintf (stderr, "can't read table lensobj header");
     658      return (FALSE);
     659    }
     660    /* read Lensobj table data : format is irrelevant here */
     661    if (!gfits_fread_ftable_range (subcat[0].f, &ftable, start, Nrows)) {
     662      if (VERBOSE) fprintf (stderr, "can't read table lensobj data");
     663      return (FALSE);
     664    }
     665
     666    /* convert data format to internal : returns number of row read in Nlensobj */
     667    catalog[0].lensobj = FtableToLensobj (&ftable, &Nlensobj, &catalog[0].catformat);
     668    if (Nlensobj != Nrows) {
     669      // XXX this condition denotes the eof has been reached; not an error or a warning
     670      // fprintf (stderr, "Warning: mismatch between Nlensobj in PHU and Table headers ("OFF_T_FMT" vs "OFF_T_FMT")\n",  Nlensobj,  Nrows);
     671    }
     672    gfits_free_header (&header);
     673    catalog[0].Nlensobj = Nlensobj;
     674    catalog[0].Nlensobj_off = start;
     675  }
     676
    521677  return (TRUE);
    522678}
    … …  
    530686  SecFilt *primary, *secfilt;
    531687  int Nsecfilt;
    532   off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
     688  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new;
    533689  off_t first, start, Nrows;
    534690
    … …  
    561717  Nmiss_disk_new = MAX (catalog[0].Nmiss_disk, catalog[0].Nmissing + catalog[0].Nmiss_off);
    562718  Nsecf_disk_new = MAX (catalog[0].Nsecf_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecf_off);
     719  Nlensing_disk_new = MAX (catalog[0].Nlensing_disk, catalog[0].Nlensing + catalog[0].Nlensing_off);
     720  Nlensobj_disk_new = MAX (catalog[0].Nlensobj_disk, catalog[0].Nlensobj + catalog[0].Nlensobj_off);
    563721
    564722  /* make sure header is consistent with data */
    … …  
    567725  gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  Nmiss_disk_new);
    568726  gfits_modify (&catalog[0].header, "NSECFILT", "%d",   1, Nsecfilt);
     727  gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  Nlensing_disk_new);
     728  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
    569729  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    570730  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    … …  
    621781    assert (catalog[0].Nmeas_disk >= catalog[0].Nmeas_off);
    622782
    623     // convert to external table format
    624     if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
     783    // convert to external table format (note that the block above does not damage or free catalog.average)
     784    if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
    625785      fprintf (stderr, "trouble converting format\n");
    626786      goto failure;
    … …  
    679839    if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) {
    680840      fprintf (stderr, "failure writing SecFilt table\n");
     841      goto failure;
     842    }
     843    gfits_free_header (&header);
     844    gfits_free_table (&ftable);
     845  }
     846
     847  /*** Lensing Table ***/
     848  if ((catalog[0].catflags & LOAD_LENSING) && (catalog[0].lensing != NULL)) {
     849
     850    first  = 0;                    // first row in memory to write
     851    start  = catalog[0].Nlensing_off; // first disk row to write
     852    Nrows  = catalog[0].Nlensing - first;
     853
     854    assert (Nrows >= 0);
     855    assert (first >= 0);
     856    assert (first <= catalog[0].Nlensing);
     857    assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off);
     858
     859    // convert to external table format (note that the block above does not damage or free catalog.average)
     860    if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat)) {
     861      fprintf (stderr, "trouble converting format\n");
     862      goto failure;
     863    }
     864
     865    // write out Lensing table
     866    if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) {
     867      fprintf (stderr, "trouble writing Lensing table\n");
     868      goto failure;
     869    }
     870    gfits_free_header (&header);
     871    gfits_free_table (&ftable);
     872  }
     873
     874  /*** Lensobj Table ***/
     875  if ((catalog[0].catflags & LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) {
     876
     877    first  = 0;                    // first row in memory to write
     878    start  = catalog[0].Nlensobj_off; // first disk row to write
     879    Nrows  = catalog[0].Nlensobj - first;
     880
     881    assert (Nrows >= 0);
     882    assert (first >= 0);
     883    assert (first <= catalog[0].Nlensobj);
     884    assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off);
     885
     886    // convert to external table format (note that the block above does not damage or free catalog.average)
     887    if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat)) {
     888      fprintf (stderr, "trouble converting format\n");
     889      goto failure;
     890    }
     891
     892    // write out Lensobj table
     893    if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) {
     894      fprintf (stderr, "trouble writing Lensobj table\n");
    681895      goto failure;
    682896    }
    … …  
    711925  SecFilt *primary, *secfilt;
    712926  int Nsecfilt;
    713   off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
     927  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new;
    714928  off_t first, start, Nrows;
    715929
    … …  
    734948  if (catalog[0].Nsecf_off > 0) {
    735949    fprintf (stderr, "ERROR: only partial catalog (Secfilt) was loaded\n");
     950    goto failure;
     951  }
     952  if (catalog[0].Nlensing_off > 0) {
     953    fprintf (stderr, "ERROR: only partial catalog (Lensing) was loaded\n");
     954    goto failure;
     955  }
     956  if (catalog[0].Nlensobj_off > 0) {
     957    fprintf (stderr, "ERROR: only partial catalog (Lensobj) was loaded\n");
    736958    goto failure;
    737959  }
    … …  
    760982  Nmiss_disk_new = catalog[0].Nmissing;
    761983  Nsecf_disk_new = catalog[0].Naverage*Nsecfilt;
     984  Nlensing_disk_new = catalog[0].Nlensing;
     985  Nlensobj_disk_new = catalog[0].Nlensobj;
    762986
    763987  /* make sure header is consistent with data */
    … …  
    766990  gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  Nmiss_disk_new);
    767991  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
     992  gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  Nlensing_disk_new);
     993  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
    768994  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    769995  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    … …  
    8211047
    8221048    // convert to external table format
    823     if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
     1049    if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
    8241050      fprintf (stderr, "trouble converting format\n");
    8251051      goto failure;
    … …  
    8781104    if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) {
    8791105      fprintf (stderr, "failure writing SecFilt table\n");
     1106      goto failure;
     1107    }
     1108    gfits_free_header (&header);
     1109    gfits_free_table (&ftable);
     1110  }
     1111
     1112  /*** Lensing Table ***/
     1113  if ((catalog[0].catflags & LOAD_LENSING) && (catalog[0].lensing != NULL)) {
     1114
     1115    first  = 0;                    // first row in memory to write
     1116    start  = catalog[0].Nlensing_off; // first disk row to write
     1117    Nrows  = catalog[0].Nlensing - first;
     1118
     1119    assert (Nrows >= 0);
     1120    assert (first >= 0);
     1121    assert (first <= catalog[0].Nlensing);
     1122    assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off);
     1123
     1124    // convert to external table format
     1125    if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat)) {
     1126      fprintf (stderr, "trouble converting format\n");
     1127      goto failure;
     1128    }
     1129
     1130    // write out Lensing table
     1131    if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) {
     1132      fprintf (stderr, "trouble writing Lensing table\n");
     1133      goto failure;
     1134    }
     1135    gfits_free_header (&header);
     1136    gfits_free_table (&ftable);
     1137  }
     1138
     1139  /*** Lensobj Table ***/
     1140  if ((catalog[0].catflags & LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) {
     1141
     1142    first  = 0;                    // first row in memory to write
     1143    start  = catalog[0].Nlensobj_off; // first disk row to write
     1144    Nrows  = catalog[0].Nlensobj - first;
     1145
     1146    assert (Nrows >= 0);
     1147    assert (first >= 0);
     1148    assert (first <= catalog[0].Nlensobj);
     1149    assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off);
     1150
     1151    // convert to external table format
     1152    if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat)) {
     1153      fprintf (stderr, "trouble converting format\n");
     1154      goto failure;
     1155    }
     1156
     1157    // write out Lensobj table
     1158    if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) {
     1159      fprintf (stderr, "trouble writing Lensobj table\n");
    8801160      goto failure;
    8811161    }
    … …  
    9091189  SecFilt *primary, *secfilt;
    9101190  int Nsecfilt;
    911   off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
     1191  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new, Nlensing_disk_new, Nlensobj_disk_new;
    9121192  off_t first, start, Nrows;
    9131193
    … …  
    9391219  Nmiss_disk_new = MAX (catalog[0].Nmiss_disk, catalog[0].Nmissing + catalog[0].Nmiss_off);
    9401220  Nsecf_disk_new = MAX (catalog[0].Nsecf_disk, catalog[0].Naverage*Nsecfilt + catalog[0].Nsecf_off);
     1221  Nlensing_disk_new = MAX (catalog[0].Nlensing_disk, catalog[0].Nlensing + catalog[0].Nlensing_off);
     1222  Nlensobj_disk_new = MAX (catalog[0].Nlensobj_disk, catalog[0].Nlensobj + catalog[0].Nlensobj_off);
    9411223
    9421224  /* make sure header is consistent with data */
    … …  
    9451227  gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  Nmiss_disk_new);
    9461228  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
     1229  gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  Nlensing_disk_new);
     1230  gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
    9471231  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    9481232  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    … …  
    10001284
    10011285    // convert to external table format
    1002     if (!MeasureToFtable (&ftable, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
     1286    // XXX does catalog.measure have averef correctly set up?
     1287    if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat)) {
    10031288      fprintf (stderr, "trouble converting format\n");
    10041289      goto failure;
    … …  
    10581343    if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecf_disk, Nsecf_disk_new)) {
    10591344      fprintf (stderr, "failure writing SecFilt table\n");
     1345      goto failure;
     1346    }
     1347    gfits_free_header (&header);
     1348    gfits_free_table (&ftable);
     1349  }
     1350
     1351  /*** Lensing Table ***/
     1352  if (catalog[0].lensing != NULL) {
     1353
     1354    first  = catalog[0].Nlensing_disk - catalog[0].Nlensing_off;  // first row in memory to write
     1355    start  = catalog[0].Nlensing_disk; // first disk row to write
     1356    Nrows  = catalog[0].Nlensing - first;
     1357
     1358    assert (Nrows >= 0);
     1359    assert (first >= 0);
     1360    assert (first <= catalog[0].Nlensing);
     1361    assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off);
     1362
     1363    // convert to external table format
     1364    // XXX does catalog.lensing have averef correctly set up?
     1365    if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat)) {
     1366      fprintf (stderr, "trouble converting format\n");
     1367      goto failure;
     1368    }
     1369
     1370    // write out Lensing table
     1371    if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) {
     1372      fprintf (stderr, "trouble writing Lensing table\n");
     1373      goto failure;
     1374    }
     1375    gfits_free_header (&header);
     1376    gfits_free_table (&ftable);
     1377  }
     1378
     1379  /*** Lensobj Table ***/
     1380  if (catalog[0].lensobj != NULL) {
     1381
     1382    first  = catalog[0].Nlensobj_disk - catalog[0].Nlensobj_off;  // first row in memory to write
     1383    start  = catalog[0].Nlensobj_disk; // first disk row to write
     1384    Nrows  = catalog[0].Nlensobj - first;
     1385
     1386    assert (Nrows >= 0);
     1387    assert (first >= 0);
     1388    assert (first <= catalog[0].Nlensobj);
     1389    assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off);
     1390
     1391    // convert to external table format
     1392    // XXX does catalog.lensobj have averef correctly set up?
     1393    if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat)) {
     1394      fprintf (stderr, "trouble converting format\n");
     1395      goto failure;
     1396    }
     1397
     1398    // write out Lensobj table
     1399    if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) {
     1400      fprintf (stderr, "trouble writing Lensobj table\n");
    10601401      goto failure;
    10611402    }

  • trunk/Ohana/src/libdvo/src/dvo_convert.c

    r36528 r37035  
    4141  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V3",          PS1_V3);
    4242  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V4",          PS1_V4);
     43  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V5",          PS1_V5);
    4344  CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF",         PS1_REF);
    4445# undef CONVERT_FORMAT
    … …  
    112113  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V3",          PS1_V3,          PS1_V3);
    113114  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V4",          PS1_V4,          PS1_V4);
     115  CONVERT_FORMAT ("DVO_AVERAGE_PS1_V5",          PS1_V5,          PS1_V5);
    114116  CONVERT_FORMAT ("DVO_AVERAGE_PS1_REF",         PS1_REF,         PS1_REF);
    115117# undef CONVERT_FORMAT
    … …  
    147149      FORMAT_CASE (PS1_V3,          PS1_V3);
    148150      FORMAT_CASE (PS1_V4,          PS1_V4);
     151      FORMAT_CASE (PS1_V5,          PS1_V5);
    149152      FORMAT_CASE (PS1_REF,         PS1_REF);
    150153# undef FORMAT_CASE
    … …  
    159162/*** Measure / FTable conversion functions ***/
    160163
    161 Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format) {
     164// FtableToMeasure needs the Average since old formats stored measure.dR,dD only
     165Measure *FtableToMeasure (FTable *ftable, Average *average, off_t *Nmeasure, char *format) {
    162166
    163167  Measure *measure;
    … …  
    179183      exit (2);
    180184    }
    181     measure = Measure_PS1_V4alt_ToInternal (tmpMeasure, *Nmeasure);
     185    myAssert (average, "conversion to internal needs average table");
     186    measure = Measure_PS1_V4alt_ToInternal (average, tmpMeasure, *Nmeasure);
    182187    free (tmpMeasure);
    183188    *format = DVO_FORMAT_PS1_V4;
    … …  
    185190  }
    186191
    187 # define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
    188   if (!strcmp (extname, NAME)) { \
    189     Measure_##TYPE *tmpMeasure; \
     192# define CONVERT_FORMAT(NAME, FORMAT, TYPE, ABS_COORDS)         \
     193  if (!strcmp (extname, NAME)) {                                        \
     194    Measure_##TYPE *tmpMeasure;                                         \
    190195    tmpMeasure = gfits_table_get_Measure_##TYPE (ftable, Nmeasure, NULL); \
    191     if (!tmpMeasure) { \
    192       fprintf (stderr, "ERROR: failed to read measures\n"); \
    193       exit (2); \
    194     } \
    195     measure = Measure_##TYPE##_ToInternal (tmpMeasure, *Nmeasure); \
    196     free (tmpMeasure); \
    197     *format = DVO_FORMAT_##FORMAT; \
     196    if (!tmpMeasure) {                                                  \
     197      fprintf (stderr, "ERROR: failed to read measures\n");             \
     198      exit (2);                                                         \
     199    }                                                                   \
     200    myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
     201    measure = Measure_##TYPE##_ToInternal (average, tmpMeasure, *Nmeasure); \
     202    free (tmpMeasure);                                                  \
     203    *format = DVO_FORMAT_##FORMAT;                                      \
    198204    return (measure); }
    199205
    … …  
    208214  }
    209215
    210   CONVERT_FORMAT ("DVO_MEASURE_ELIXIR",          ELIXIR,          Elixir);
    211   CONVERT_FORMAT ("DVO_MEASURE_LONEOS",          LONEOS,          Loneos);
    212   CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
    213   CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
    214   CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
    215   CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
    216   CONVERT_FORMAT ("DVO_MEASURE_PS1_V1",          PS1_V1,          PS1_V1);
    217   CONVERT_FORMAT ("DVO_MEASURE_PS1_V2",          PS1_V2,          PS1_V2);
    218   CONVERT_FORMAT ("DVO_MEASURE_PS1_V3",          PS1_V3,          PS1_V3);
    219   CONVERT_FORMAT ("DVO_MEASURE_PS1_V4",          PS1_V4,          PS1_V4);
    220   CONVERT_FORMAT ("DVO_MEASURE_PS1_REF",         PS1_REF,         PS1_REF);
     216  CONVERT_FORMAT ("DVO_MEASURE_ELIXIR",          ELIXIR,          Elixir,          FALSE);
     217  CONVERT_FORMAT ("DVO_MEASURE_LONEOS",          LONEOS,          Loneos,          FALSE);
     218  CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0, FALSE);
     219  CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1, FALSE);
     220  CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1,       FALSE);
     221  CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2,       FALSE);
     222  CONVERT_FORMAT ("DVO_MEASURE_PS1_V1",          PS1_V1,          PS1_V1,          FALSE);
     223  CONVERT_FORMAT ("DVO_MEASURE_PS1_V2",          PS1_V2,          PS1_V2,          FALSE);
     224  CONVERT_FORMAT ("DVO_MEASURE_PS1_V3",          PS1_V3,          PS1_V3,          FALSE);
     225  CONVERT_FORMAT ("DVO_MEASURE_PS1_V4",          PS1_V4,          PS1_V4,          FALSE);
     226  CONVERT_FORMAT ("DVO_MEASURE_PS1_V5",          PS1_V5,          PS1_V5,          TRUE);
     227  CONVERT_FORMAT ("DVO_MEASURE_PS1_REF",         PS1_REF,         PS1_REF,         FALSE);
    221228# undef CONVERT_FORMAT
    222229
    … …  
    227234}
    228235
    229 int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format) {
    230 
    231 # define FORMAT_CASE(FORMAT, TYPE) \
     236// MeasureToFtable needs the Average since old formats stored measure.dR,dD only
     237int MeasureToFtable (FTable *ftable, Average *average, Measure *measure, off_t Nmeasure, char format) {
     238
     239# define FORMAT_CASE(FORMAT, TYPE, ABS_COORDS)          \
    232240    case DVO_FORMAT_##FORMAT: { \
    233241      Measure_##TYPE *tmpMeasure; \
    234       tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \
     242      myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
     243      tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
    235244      gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure); \
    236245      free (tmpMeasure); \
    … …  
    243252      break; }
    244253
    245       FORMAT_CASE (ELIXIR,          Elixir);
    246       FORMAT_CASE (LONEOS,          Loneos);
    247       FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
    248       FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
    249       FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
    250       FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
    251       FORMAT_CASE (PS1_V1,          PS1_V1);
    252       FORMAT_CASE (PS1_V2,          PS1_V2);
    253       FORMAT_CASE (PS1_V3,          PS1_V3);
    254       FORMAT_CASE (PS1_V4,          PS1_V4);
    255       FORMAT_CASE (PS1_REF,         PS1_REF);
     254      FORMAT_CASE (ELIXIR,          Elixir,          FALSE);
     255      FORMAT_CASE (LONEOS,          Loneos,          FALSE);
     256      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0, FALSE);
     257      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1, FALSE);
     258      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1,       FALSE);
     259      FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2,       FALSE);
     260      FORMAT_CASE (PS1_V1,          PS1_V1,          FALSE);
     261      FORMAT_CASE (PS1_V2,          PS1_V2,          FALSE);
     262      FORMAT_CASE (PS1_V3,          PS1_V3,          FALSE);
     263      FORMAT_CASE (PS1_V4,          PS1_V4,          FALSE);
     264      FORMAT_CASE (PS1_V5,          PS1_V5,          TRUE);
     265      FORMAT_CASE (PS1_REF,         PS1_REF,         FALSE);
    256266# undef FORMAT_CASE
    257267
    … …  
    309319  CONVERT_FORMAT ("DVO_SECFILT_PS1_V3",          PS1_V3,          PS1_V3);
    310320  CONVERT_FORMAT ("DVO_SECFILT_PS1_V4",          PS1_V4,          PS1_V4);
     321  CONVERT_FORMAT ("DVO_SECFILT_PS1_V5",          PS1_V5,          PS1_V5);
    311322  CONVERT_FORMAT ("DVO_SECFILT_PS1_REF",         PS1_REF,         PS1_REF);
    312323# undef CONVERT_FORMAT
    … …  
    344355      FORMAT_CASE (PS1_V3,          PS1_V3);
    345356      FORMAT_CASE (PS1_V4,          PS1_V4);
     357      FORMAT_CASE (PS1_V5,          PS1_V5);
    346358      FORMAT_CASE (PS1_REF,         PS1_REF);
    347359# undef FORMAT_CASE
    … …  
    349361    default:
    350362      fprintf (stderr, "table format unknown (secfilt)\n");
     363      return (FALSE);
     364  }
     365  return (TRUE);
     366}
     367
     368/*** Lensing / FTable conversion functions ***/
     369
     370Lensing *FtableToLensing (FTable *ftable, off_t *Nlensing, char *format) {
     371
     372  Lensing *lensing;
     373  char extname[80];
     374
     375  /* convert to the internal format */
     376  if (!gfits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
     377    fprintf (stderr, "EXTNAME missing for lensing table\n");
     378    return (FALSE);
     379  }
     380
     381# define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     382  if (!strcmp (extname, NAME)) {                                        \
     383    Lensing_##TYPE *tmpLensing;                                         \
     384    tmpLensing = gfits_table_get_Lensing_##TYPE (ftable, Nlensing, NULL); \
     385    if (!tmpLensing) {                                                  \
     386      fprintf (stderr, "ERROR: failed to read lensings\n");             \
     387      exit (2);                                                         \
     388    }                                                                   \
     389    lensing = Lensing_##TYPE##_ToInternal (tmpLensing, *Nlensing); \
     390    free (tmpLensing);                                                  \
     391    *format = DVO_FORMAT_##FORMAT;                                      \
     392    return (lensing); }
     393
     394  if (!strcmp (extname, "DVO_LENSING")) {
     395    lensing = gfits_table_get_Lensing (ftable, Nlensing, NULL);
     396    if (!lensing) {
     397      fprintf (stderr, "ERROR: failed to read lensings\n");
     398      exit (2);
     399    }
     400    *format = DVO_FORMAT_INTERNAL;
     401    return (lensing);
     402  }
     403
     404// CONVERT_FORMAT ("DVO_LENSING_PS1_REF",         PS1_REF,         PS1_REF);
     405// CONVERT_FORMAT ("DVO_LENSING_ELIXIR",          ELIXIR,          Elixir);
     406// CONVERT_FORMAT ("DVO_LENSING_LONEOS",          LONEOS,          Loneos);
     407// CONVERT_FORMAT ("DVO_LENSING_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
     408// CONVERT_FORMAT ("DVO_LENSING_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
     409// CONVERT_FORMAT ("DVO_LENSING_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
     410// CONVERT_FORMAT ("DVO_LENSING_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
     411// CONVERT_FORMAT ("DVO_LENSING_PS1_V1",          PS1_V1,          PS1_V1);
     412// CONVERT_FORMAT ("DVO_LENSING_PS1_V2",          PS1_V2,          PS1_V2);
     413// CONVERT_FORMAT ("DVO_LENSING_PS1_V3",          PS1_V3,          PS1_V3);
     414// CONVERT_FORMAT ("DVO_LENSING_PS1_V4",          PS1_V4,          PS1_V4);
     415  CONVERT_FORMAT ("DVO_LENSING_PS1_V5",          PS1_V5,          PS1_V5);
     416# undef CONVERT_FORMAT
     417
     418  fprintf (stderr, "table format unknown: %s\n", extname);
     419
     420  *Nlensing = 0;
     421  return (NULL);
     422}
     423
     424// LensingToFtable needs the Average since old formats stored lensing.dR,dD only
     425int LensingToFtable (FTable *ftable, Lensing *lensing, off_t Nlensing, char format) {
     426
     427# define FORMAT_CASE(FORMAT, TYPE)              \
     428    case DVO_FORMAT_##FORMAT: { \
     429      Lensing_##TYPE *tmpLensing; \
     430      tmpLensing = LensingInternalTo_##TYPE (lensing, Nlensing); \
     431      gfits_table_set_Lensing_##TYPE (ftable, tmpLensing, Nlensing); \
     432      free (tmpLensing); \
     433      break; }
     434
     435  /* convert from the internal format */
     436  switch (format) {
     437    case DVO_FORMAT_INTERNAL: {
     438      gfits_table_set_Lensing (ftable, lensing, Nlensing);
     439      break; }
     440
     441//    FORMAT_CASE (PS1_REF,         PS1_REF);
     442//    FORMAT_CASE (ELIXIR,          Elixir);
     443//    FORMAT_CASE (LONEOS,          Loneos);
     444//    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     445//    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     446//    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     447//    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
     448//    FORMAT_CASE (PS1_V1,          PS1_V1);
     449//    FORMAT_CASE (PS1_V2,          PS1_V2);
     450//    FORMAT_CASE (PS1_V3,          PS1_V3);
     451//    FORMAT_CASE (PS1_V4,          PS1_V4);
     452      FORMAT_CASE (PS1_V5,          PS1_V5);
     453# undef FORMAT_CASE
     454
     455    default:
     456      fprintf (stderr, "table format unknown (lensing)\n");
     457      return (FALSE);
     458  }
     459  return (TRUE);
     460}
     461
     462/*** Lensobj / FTable conversion functions ***/
     463
     464Lensobj *FtableToLensobj (FTable *ftable, off_t *Nlensobj, char *format) {
     465
     466  Lensobj *lensobj;
     467  char extname[80];
     468
     469  /* convert to the internal format */
     470  if (!gfits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
     471    fprintf (stderr, "EXTNAME missing for lensobj table\n");
     472    return (FALSE);
     473  }
     474
     475# define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     476  if (!strcmp (extname, NAME)) {                                        \
     477    Lensobj_##TYPE *tmpLensobj;                                         \
     478    tmpLensobj = gfits_table_get_Lensobj_##TYPE (ftable, Nlensobj, NULL); \
     479    if (!tmpLensobj) {                                                  \
     480      fprintf (stderr, "ERROR: failed to read lensobjs\n");             \
     481      exit (2);                                                         \
     482    }                                                                   \
     483    lensobj = Lensobj_##TYPE##_ToInternal (tmpLensobj, *Nlensobj); \
     484    free (tmpLensobj);                                                  \
     485    *format = DVO_FORMAT_##FORMAT;                                      \
     486    return (lensobj); }
     487
     488  if (!strcmp (extname, "DVO_LENSOBJ")) {
     489    lensobj = gfits_table_get_Lensobj (ftable, Nlensobj, NULL);
     490    if (!lensobj) {
     491      fprintf (stderr, "ERROR: failed to read lensobjs\n");
     492      exit (2);
     493    }
     494    *format = DVO_FORMAT_INTERNAL;
     495    return (lensobj);
     496  }
     497
     498// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_REF",         PS1_REF,         PS1_REF);
     499// CONVERT_FORMAT ("DVO_LENSOBJ_ELIXIR",          ELIXIR,          Elixir);
     500// CONVERT_FORMAT ("DVO_LENSOBJ_LONEOS",          LONEOS,          Loneos);
     501// CONVERT_FORMAT ("DVO_LENSOBJ_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
     502// CONVERT_FORMAT ("DVO_LENSOBJ_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
     503// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
     504// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_DEV_2",       PS1_DEV_2,       PS1_DEV_2);
     505// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V1",          PS1_V1,          PS1_V1);
     506// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V2",          PS1_V2,          PS1_V2);
     507// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V3",          PS1_V3,          PS1_V3);
     508// CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V4",          PS1_V4,          PS1_V4);
     509  CONVERT_FORMAT ("DVO_LENSOBJ_PS1_V5",          PS1_V5,          PS1_V5);
     510# undef CONVERT_FORMAT
     511
     512  fprintf (stderr, "table format unknown: %s\n", extname);
     513
     514  *Nlensobj = 0;
     515  return (NULL);
     516}
     517
     518// LensobjToFtable needs the Average since old formats stored lensobj.dR,dD only
     519int LensobjToFtable (FTable *ftable, Lensobj *lensobj, off_t Nlensobj, char format) {
     520
     521# define FORMAT_CASE(FORMAT, TYPE)              \
     522    case DVO_FORMAT_##FORMAT: { \
     523      Lensobj_##TYPE *tmpLensobj; \
     524      tmpLensobj = LensobjInternalTo_##TYPE (lensobj, Nlensobj); \
     525      gfits_table_set_Lensobj_##TYPE (ftable, tmpLensobj, Nlensobj); \
     526      free (tmpLensobj); \
     527      break; }
     528
     529  /* convert from the internal format */
     530  switch (format) {
     531    case DVO_FORMAT_INTERNAL: {
     532      gfits_table_set_Lensobj (ftable, lensobj, Nlensobj);
     533      break; }
     534
     535//    FORMAT_CASE (PS1_REF,         PS1_REF);
     536//    FORMAT_CASE (ELIXIR,          Elixir);
     537//    FORMAT_CASE (LONEOS,          Loneos);
     538//    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     539//    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     540//    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     541//    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
     542//    FORMAT_CASE (PS1_V1,          PS1_V1);
     543//    FORMAT_CASE (PS1_V2,          PS1_V2);
     544//    FORMAT_CASE (PS1_V3,          PS1_V3);
     545//    FORMAT_CASE (PS1_V4,          PS1_V4);
     546      FORMAT_CASE (PS1_V5,          PS1_V5);
     547# undef FORMAT_CASE
     548
     549    default:
     550      fprintf (stderr, "table format unknown (lensobj)\n");
    351551      return (FALSE);
    352552  }
    … …  
    428628  CONVERT_FORMAT ("DVO_IMAGE_PS1_V3",          PS1_V3,          PS1_V3);
    429629  CONVERT_FORMAT ("DVO_IMAGE_PS1_V4",          PS1_V4,          PS1_V4);
     630  CONVERT_FORMAT ("DVO_IMAGE_PS1_V5",          PS1_V5,          PS1_V5);
    430631  CONVERT_FORMAT ("DVO_IMAGE_PS1_REF",         PS1_REF,         PS1_REF);
    431632
    … …  
    467668      FORMAT_CASE (PS1_V3,          PS1_V3);
    468669      FORMAT_CASE (PS1_V4,          PS1_V4);
     670      FORMAT_CASE (PS1_V5,          PS1_V5);
    469671      FORMAT_CASE (PS1_REF,         PS1_REF);
    470672
    … …  
    522724      FORMAT_CASE (PS1_V3,          PS1_V3);
    523725      FORMAT_CASE (PS1_V4,          PS1_V4);
     726      FORMAT_CASE (PS1_V5,          PS1_V5);
    524727      FORMAT_CASE (PS1_REF,         PS1_REF);
    525728

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c

    r35162 r37035  
    33/* convert PS1_DEV_1 formats to internal formats */
    44
    5 Measure *Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, off_t Nvalues) {
     5Measure *Measure_PS1_DEV_1_ToInternal (Average *ave, Measure_PS1_DEV_1 *in, off_t Nvalues) {
    66
    77  off_t i;
    … …  
    1212  for (i = 0; i < Nvalues; i++) {
    1313    dvo_measure_init (&out[i]);
    14     out[i].dR         = in[i].dR;
    15     out[i].dD         = in[i].dD;
     14
     15    int averef = in[i].averef;
     16    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     17    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    1618    out[i].M          = in[i].M;
    1719    out[i].Mcal       = in[i].Mcal;
    … …  
    5052}
    5153
    52 Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Measure *in, off_t Nvalues) {
     54Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Average *ave, Measure *in, off_t Nvalues) {
    5355
    5456  off_t i;
    … …  
    5860
    5961  for (i = 0; i < Nvalues; i++) {
    60     out[i].dR         = in[i].dR;
    61     out[i].dD         = in[i].dD;
     62    int averef = in[i].averef;
     63
     64    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
     65    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
    6266    out[i].M          = in[i].M;
    6367    out[i].Mcal       = in[i].Mcal;
    … …  
    180184    out[i].M     = in[i].M;     
    181185    out[i].dM    = in[i].dM;     
    182     out[i].Xm    = in[i].Xm;     
     186    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
    183187    out[i].Ncode = in[i].Ncode;
    184188    out[i].Nused = in[i].Nused;
    … …  
    197201    out[i].M     = in[i].M;     
    198202    out[i].dM    = in[i].dM;     
    199     out[i].Xm    = in[i].Xm;     
     203    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
    200204    out[i].Ncode = in[i].Ncode;
    201205    out[i].Nused = in[i].Nused;
    … …  
    203207  return (out);
    204208}
     209
     210# define RAW_IMAGE_NAME_LEN 64
    205211
    206212Image *Image_PS1_DEV_1_ToInternal (Image_PS1_DEV_1 *in, off_t Nvalues, off_t Nalloc) {
    … …  
    217223    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    218224
    219     strncpy (out[i].name, in[i].name, 63); // out[128], in[64]
    220     out[i].name[63] = 0; // force termination
     225    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     226    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     227    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    221228
    222229    out[i].tzero            = in[i].tzero;
    … …  
    284291    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    285292
    286     strncpy (out[i].name, in[i].name, 63); // out[128], in[64]
    287     out[i].name[63] = 0; // force termination
     293    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     294    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     295    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    288296
    289297    out[i].tzero            = in[i].tzero;

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c

    r36833 r37035  
    33/* convert PS1_DEV_2 formats to internal formats */
    44
    5 Measure *Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, off_t Nvalues) {
     5Measure *Measure_PS1_DEV_2_ToInternal (Average *ave, Measure_PS1_DEV_2 *in, off_t Nvalues) {
    66
    77  off_t i;
    … …  
    1212  for (i = 0; i < Nvalues; i++) {
    1313    dvo_measure_init (&out[i]);
    14     out[i].dR         = in[i].dR;
    15     out[i].dD         = in[i].dD;
     14
     15    int averef = in[i].averef;
     16    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     17    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    1618    out[i].M          = in[i].M;
    1719    out[i].Mcal       = in[i].Mcal;
    … …  
    4850}
    4951
    50 Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Measure *in, off_t Nvalues) {
     52Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Average *ave, Measure *in, off_t Nvalues) {
    5153
    5254  off_t i;
    … …  
    5658
    5759  for (i = 0; i < Nvalues; i++) {
    58     out[i].dR         = in[i].dR;
    59     out[i].dD         = in[i].dD;
     60    int averef = in[i].averef;
     61
     62    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
     63    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
    6064    out[i].M          = in[i].M;
    6165    out[i].Mcal       = in[i].Mcal;
    … …  
    119123    out[i].measureOffset = in[i].measureOffset;
    120124    out[i].missingOffset = in[i].missingOffset;
    121     out[i].refColor  = in[i].refColor;
     125    out[i].refColorBlue  = in[i].refColor;
    122126    out[i].objID         = in[i].objID;
    123127    out[i].catID         = in[i].catID;
    … …  
    153157    out[i].measureOffset = in[i].measureOffset;
    154158    out[i].missingOffset = in[i].missingOffset;
    155     out[i].refColor  = in[i].refColor;
     159    out[i].refColor  = in[i].refColorBlue;
    156160    out[i].objID         = in[i].objID;
    157161    out[i].catID         = in[i].catID;
    … …  
    175179    out[i].M     = in[i].M;     
    176180    out[i].dM    = in[i].dM;     
    177     out[i].Xm    = in[i].Xm;     
     181    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
    178182    out[i].Ncode = in[i].Ncode;
    179183    out[i].Nused = in[i].Nused;
    … …  
    192196    out[i].M     = in[i].M;     
    193197    out[i].dM    = in[i].dM;     
    194     out[i].Xm    = in[i].Xm;     
     198    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
    195199    out[i].Ncode = in[i].Ncode;
    196200    out[i].Nused = in[i].Nused;
    … …  
    198202  return (out);
    199203}
     204
     205# define RAW_IMAGE_NAME_LEN 64
    200206
    201207Image *Image_PS1_DEV_2_ToInternal (Image_PS1_DEV_2 *in, off_t Nvalues, off_t Nalloc) {
    … …  
    212218    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    213219
    214     strncpy (out[i].name, in[i].name, 63); // out[121], in[64]
    215     out[i].name[63] = 0; // force termination
     220    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     221    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     222    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    216223
    217224    out[i].tzero            = in[i].tzero;
    … …  
    276283    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    277284
    278     strncpy (out[i].name, in[i].name, 63); // in[121], out[64]
    279     out[i].name[63] = 0; // force termination
     285    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     286    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     287    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    280288
    281289    out[i].tzero            = in[i].tzero;

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_REF.c

    r35162 r37035  
    33/* convert PS1_REF formats to internal formats */
    44
    5 Measure *Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, off_t Nvalues) {
     5Measure *Measure_PS1_REF_ToInternal (Average *ave, Measure_PS1_REF *in, off_t Nvalues) {
    66
    77  off_t i;
    … …  
    1313    dvo_measure_init (&out[i]);
    1414
    15     out[i].dR         = in[i].dR;
    16     out[i].dD         = in[i].dD;
     15    int averef = in[i].averef;
     16    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     17    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    1718    out[i].M          = in[i].M;
    1819    out[i].dM         = in[i].dM;
    … …  
    2829}
    2930
    30 Measure_PS1_REF *MeasureInternalTo_PS1_REF (Measure *in, off_t Nvalues) {
     31Measure_PS1_REF *MeasureInternalTo_PS1_REF (Average *ave, Measure *in, off_t Nvalues) {
    3132
    3233  off_t i;
    … …  
    3637
    3738  for (i = 0; i < Nvalues; i++) {
    38     out[i].dR         = in[i].dR;
    39     out[i].dD         = in[i].dD;
     39    int averef = in[i].averef;
     40
     41    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
     42    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
    4043    out[i].M          = in[i].M;
    4144    out[i].dM         = in[i].dM;
    … …  
    129132}
    130133
     134# define RAW_IMAGE_NAME_LEN 121
     135
    131136Image *Image_PS1_REF_ToInternal (Image_PS1_REF *in, off_t Nvalues, off_t Nalloc) {
    132137
    … …  
    142147    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    143148
    144     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    145     out[i].name[120] = 0; // force termination
     149    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     150    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     151    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    146152
    147153    out[i].tzero            = in[i].tzero;
    … …  
    204210    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    205211
    206     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    207     out[i].name[120] = 0; // force termination
     212    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     213    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     214    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    208215
    209216    out[i].tzero            = in[i].tzero;

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c

    r36833 r37035  
    33/* convert PS1_V1 formats to internal formats */
    44
    5 Measure *Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, off_t Nvalues) {
     5Measure *Measure_PS1_V1_ToInternal (Average *ave, Measure_PS1_V1 *in, off_t Nvalues) {
    66
    77  off_t i;
    … …  
    1313    dvo_measure_init (&out[i]);
    1414
    15     out[i].dR         = in[i].dR;
    16     out[i].dD         = in[i].dD;
     15    int averef = in[i].averef;
     16    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     17    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    1718    out[i].M          = in[i].M;
    1819    out[i].Mcal       = in[i].Mcal;
    … …  
    5859}
    5960
    60 Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Measure *in, off_t Nvalues) {
     61Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Average *ave, Measure *in, off_t Nvalues) {
    6162
    6263  off_t i;
    … …  
    6667
    6768  for (i = 0; i < Nvalues; i++) {
    68     out[i].dR         = in[i].dR;
    69     out[i].dD         = in[i].dD;
     69    int averef = in[i].averef;
     70
     71    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
     72    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
    7073    out[i].M          = in[i].M;
    7174    out[i].Mcal       = in[i].Mcal;
    … …  
    140143    out[i].measureOffset = in[i].measureOffset;
    141144    out[i].missingOffset = in[i].missingOffset;
    142     out[i].refColor  = in[i].refColor;
     145    out[i].refColorBlue  = in[i].refColor;
    143146    out[i].flags         = in[i].flags;   
    144147    out[i].objID         = in[i].objID;
    … …  
    175178    out[i].measureOffset = in[i].measureOffset;
    176179    out[i].missingOffset = in[i].missingOffset;
    177     out[i].refColor  = in[i].refColor;
     180    out[i].refColor      = in[i].refColorBlue;
    178181    out[i].flags         = in[i].flags;   
    179182    out[i].objID         = in[i].objID;
    … …  
    196199    out[i].M     = in[i].M;     
    197200    out[i].dM    = in[i].dM;     
    198     out[i].Xm    = in[i].Xm;     
     201    out[i].Mchisq= in[i].Mchisq;     
    199202    out[i].Ncode = in[i].Ncode;
    200203    out[i].Nused = in[i].Nused;
    201     out[i].M_20  = in[i].M_20;     
    202     out[i].M_80  = in[i].M_80;     
     204    out[i].Mmin  = in[i].M_20*0.001;     
     205    out[i].Mmax  = in[i].M_80*0.001;     
    203206 }
    204207  return (out);
    … …  
    215218    out[i].M     = in[i].M;     
    216219    out[i].dM    = in[i].dM;     
    217     out[i].Xm    = in[i].Xm;     
     220    out[i].Mchisq= in[i].Mchisq;     
    218221    out[i].Ncode = in[i].Ncode;
    219222    out[i].Nused = in[i].Nused;
    220     out[i].M_20  = in[i].M_20;     
    221     out[i].M_80  = in[i].M_80;     
    222   }
    223   return (out);
    224 }
     223    out[i].M_20  = in[i].Mmin*1000.0;     
     224    out[i].M_80  = in[i].Mmax*1000.0;     
     225  }
     226  return (out);
     227}
     228
     229# define RAW_IMAGE_NAME_LEN 121
    225230
    226231Image *Image_PS1_V1_ToInternal (Image_PS1_V1 *in, off_t Nvalues, off_t Nalloc) {
    … …  
    237242    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    238243
    239     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    240     out[i].name[120] = 0; // force termination
     244    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     245    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     246    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    241247
    242248    out[i].tzero            = in[i].tzero;
    … …  
    300306    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    301307
    302     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    303     out[i].name[120] = 0; // force termination
     308    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     309    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     310    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    304311
    305312    out[i].tzero            = in[i].tzero;

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V2.c

    r36833 r37035  
    33/* convert PS1_V2 formats to internal formats */
    44
    5 Measure *Measure_PS1_V2_ToInternal (Measure_PS1_V2 *in, off_t Nvalues) {
     5Measure *Measure_PS1_V2_ToInternal (Average *ave, Measure_PS1_V2 *in, off_t Nvalues) {
    66
    77  off_t i;
    … …  
    1313    dvo_measure_init (&out[i]);
    1414
    15     out[i].dR         = in[i].dR;
    16     out[i].dD         = in[i].dD;
     15    int averef = in[i].averef;
     16    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     17    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    1718    out[i].M          = in[i].M;
    1819    out[i].Mcal       = in[i].Mcal;
    … …  
    5960}
    6061
    61 Measure_PS1_V2 *MeasureInternalTo_PS1_V2 (Measure *in, off_t Nvalues) {
     62Measure_PS1_V2 *MeasureInternalTo_PS1_V2 (Average *ave, Measure *in, off_t Nvalues) {
    6263
    6364  off_t i;
    … …  
    6768
    6869  for (i = 0; i < Nvalues; i++) {
    69     out[i].dR         = in[i].dR;
    70     out[i].dD         = in[i].dD;
     70    int averef = in[i].averef;
     71
     72    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
     73    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
    7174    out[i].M          = in[i].M;
    7275    out[i].Mcal       = in[i].Mcal;
    … …  
    145148    out[i].measureOffset = in[i].measureOffset;
    146149    out[i].missingOffset = in[i].missingOffset;
    147     out[i].refColor  = in[i].refColor;
     150    out[i].refColorBlue  = in[i].refColor;
    148151    out[i].flags         = in[i].flags;   
    149152    out[i].objID         = in[i].objID;
    … …  
    184187    out[i].measureOffset = in[i].measureOffset;
    185188    out[i].missingOffset = in[i].missingOffset;
    186     out[i].refColor  = in[i].refColor;
     189    out[i].refColor  = in[i].refColorBlue;
    187190    out[i].flags         = in[i].flags;   
    188191    out[i].objID         = in[i].objID;
    … …  
    205208    out[i].M     = in[i].M;     
    206209    out[i].dM    = in[i].dM;     
    207     out[i].Xm    = in[i].Xm;     
     210    out[i].Mchisq= in[i].Mchisq;     
    208211    out[i].flags = in[i].flags;     
    209212    out[i].Ncode = in[i].Ncode;
    210213    out[i].Nused = in[i].Nused;
    211     out[i].M_20  = in[i].M_20;     
    212     out[i].M_80  = in[i].M_80;     
     214    out[i].Mmin  = in[i].M_20*0.001;     
     215    out[i].Mmax  = in[i].M_80*0.001;     
    213216 }
    214217  return (out);
    … …  
    225228    out[i].M     = in[i].M;     
    226229    out[i].dM    = in[i].dM;     
    227     out[i].Xm    = in[i].Xm;     
     230    out[i].Mchisq= in[i].Mchisq;     
    228231    out[i].flags = in[i].flags;     
    229232    out[i].Ncode = in[i].Ncode;
    230233    out[i].Nused = in[i].Nused;
    231     out[i].M_20  = in[i].M_20;     
    232     out[i].M_80  = in[i].M_80;     
    233   }
    234   return (out);
    235 }
     234    out[i].M_20  = in[i].Mmin*1000.0;     
     235    out[i].M_80  = in[i].Mmax*1000.0;     
     236  }
     237  return (out);
     238}
     239
     240# define RAW_IMAGE_NAME_LEN 121
    236241
    237242Image *Image_PS1_V2_ToInternal (Image_PS1_V2 *in, off_t Nvalues, off_t Nalloc) {
    … …  
    248253    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    249254
    250     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    251     out[i].name[120] = 0; // force termination
     255    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     256    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     257    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    252258
    253259    out[i].tzero            = in[i].tzero;
    … …  
    269275    out[i].DECo             = in[i].DECo;
    270276    out[i].Radius           = in[i].Radius;
    271     out[i].refColor         = in[i].refColor;
     277    out[i].refColorBlue             = in[i].refColor;
    272278
    273279    out[i].detection_limit  = in[i].detection_limit;
    … …  
    311317    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    312318
    313     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    314     out[i].name[120] = 0; // force termination
     319    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     320    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     321    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    315322
    316323    out[i].tzero            = in[i].tzero;
    … …  
    332339    out[i].DECo             = in[i].DECo;
    333340    out[i].Radius           = in[i].Radius;
    334     out[i].refColor         = in[i].refColor;
     341    out[i].refColor         = in[i].refColorBlue;
    335342
    336343    out[i].detection_limit  = in[i].detection_limit;

  • trunk/Ohana/src/libdvo/src/dvo_convert_PS1_V3.c

    r36833 r37035  
    33/* convert PS1_V3 formats to internal formats */
    44
    5 Measure *Measure_PS1_V3_ToInternal (Measure_PS1_V3 *in, off_t Nvalues) {
     5Measure *Measure_PS1_V3_ToInternal (Average *ave, Measure_PS1_V3 *in, off_t Nvalues) {
    66
    77  off_t i;
    … …  
    1313    dvo_measure_init (&out[i]);
    1414
    15     out[i].dR         = in[i].dR;
    16     out[i].dD         = in[i].dD;
     15    int averef = in[i].averef;
     16    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     17    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    1718    out[i].M          = in[i].M;
    1819    out[i].Mcal       = in[i].Mcal;
    … …  
    5960}
    6061
    61 Measure_PS1_V3 *MeasureInternalTo_PS1_V3 (Measure *in, off_t Nvalues) {
     62Measure_PS1_V3 *MeasureInternalTo_PS1_V3 (Average *ave, Measure *in, off_t Nvalues) {
    6263
    6364  off_t i;
    … …  
    6768
    6869  for (i = 0; i < Nvalues; i++) {
    69     out[i].dR         = in[i].dR;
    70     out[i].dD         = in[i].dD;
     70    int averef = in[i].averef;
     71
     72    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
     73    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
    7174    out[i].M          = in[i].M;
    7275    out[i].Mcal       = in[i].Mcal;
    … …  
    145148    out[i].measureOffset = in[i].measureOffset;
    146149    out[i].missingOffset = in[i].missingOffset;
    147     out[i].refColor  = in[i].refColor;
     150    out[i].refColorBlue  = in[i].refColor;
    148151    out[i].flags         = in[i].flags;   
    149152    out[i].photFlagsUpper = in[i].photFlagsUpper;   
    … …  
    186189    out[i].measureOffset = in[i].measureOffset;
    187190    out[i].missingOffset = in[i].missingOffset;
    188     out[i].refColor  = in[i].refColor;
     191    out[i].refColor      = in[i].refColorBlue;
    189192    out[i].flags         = in[i].flags;   
    190193    out[i].photFlagsUpper = in[i].photFlagsUpper;   
    … …  
    210213    out[i].Map         = in[i].Map;     
    211214    out[i].dM          = in[i].dM;     
    212     out[i].Xm          = in[i].Xm;     
     215    out[i].Mchisq      = in[i].Mchisq;     
    213216    out[i].flags       = in[i].flags;     
    214217    out[i].Ncode       = in[i].Ncode;
    215218    out[i].Nused       = in[i].Nused;
    216     out[i].M_20        = in[i].M_20;     
    217     out[i].M_80        = in[i].M_80;     
     219    out[i].Mmin        = in[i].M_20*0.001;     
     220    out[i].Mmax        = in[i].M_80*0.001;     
    218221    out[i].Mstdev      = in[i].Mstdev;     
    219222    out[i].ubercalDist = in[i].ubercalDist;     
    … …  
    233236    out[i].Map         = in[i].Map;     
    234237    out[i].dM          = in[i].dM;     
    235     out[i].Xm          = in[i].Xm;     
     238    out[i].Mchisq      = in[i].Mchisq;     
    236239    out[i].flags       = in[i].flags;     
    237240    out[i].Ncode       = in[i].Ncode;
    238241    out[i].Nused       = in[i].Nused;
    239     out[i].M_20        = in[i].M_20;     
    240     out[i].M_80        = in[i].M_80;     
     242    out[i].M_20        = in[i].Mmin*1000.0;     
     243    out[i].M_80        = in[i].Mmax*1000.0;     
    241244    out[i].Mstdev      = in[i].Mstdev;     
    242245    out[i].ubercalDist = in[i].ubercalDist;     
    … …  
    244247  return (out);
    245248}
     249
     250# define RAW_IMAGE_NAME_LEN 121
    246251
    247252Image *Image_PS1_V3_ToInternal (Image_PS1_V3 *in, off_t Nvalues, off_t Nalloc) {
    … …  
    258263    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    259264
    260     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    261     out[i].name[120] = 0; // force termination
     265    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     266    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     267    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    262268
    263269    out[i].tzero            = in[i].tzero;
    … …  
    279285    out[i].DECo             = in[i].DECo;
    280286    out[i].Radius           = in[i].Radius;
    281     out[i].refColor         = in[i].refColor;
     287    out[i].refColorBlue     = in[i].refColor;
    282288
    283289    out[i].detection_limit  = in[i].detection_limit;
    … …  
    321327    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    322328
    323     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    324     out[i].name[120] = 0; // force termination
     329    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     330    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     331    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    325332
    326333    out[i].tzero            = in[i].tzero;
    … …  
    342349    out[i].DECo             = in[i].DECo;
    343350    out[i].Radius           = in[i].Radius;
    344     out[i].refColor         = in[i].refColor;
     351    out[i].refColor         = in[i].refColorBlue;
    345352
    346353    out[i].detection_limit  = in[i].detection_limit;

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

    r36833 r37035  
    33/* convert PS1_V4 formats to internal formats */
    44
    5 Measure *Measure_PS1_V4_ToInternal (Measure_PS1_V4 *in, off_t Nvalues) {
     5Measure *Measure_PS1_V4_ToInternal (Average *ave, Measure_PS1_V4 *in, off_t Nvalues) {
    66
    77  off_t i;
    … …  
    1313    dvo_measure_init (&out[i]);
    1414
    15     out[i].dR         = in[i].dR;
    16     out[i].dD         = in[i].dD;
     15    int averef = in[i].averef;
     16    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     17    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    1718    out[i].M          = in[i].M;
    1819    out[i].Mcal       = in[i].Mcal;
    … …  
    6869}
    6970
    70 Measure_PS1_V4 *MeasureInternalTo_PS1_V4 (Measure *in, off_t Nvalues) {
     71Measure_PS1_V4 *MeasureInternalTo_PS1_V4 (Average *ave, Measure *in, off_t Nvalues) {
    7172
    7273  off_t i;
    … …  
    7677
    7778  for (i = 0; i < Nvalues; i++) {
    78     out[i].dR         = in[i].dR;
    79     out[i].dD         = in[i].dD;
     79    int averef = in[i].averef;
     80
     81    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
     82    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
    8083    out[i].M          = in[i].M;
    8184    out[i].Mcal       = in[i].Mcal;
    … …  
    166169    out[i].measureOffset = in[i].measureOffset;
    167170    out[i].missingOffset = in[i].missingOffset;
    168     out[i].refColor      = in[i].refColor;
     171    out[i].refColorBlue  = in[i].refColor;
    169172    out[i].flags         = in[i].flags;   
    170173    out[i].photFlagsUpper = in[i].photFlagsUpper;   
    … …  
    210213    out[i].measureOffset = in[i].measureOffset;
    211214    out[i].missingOffset = in[i].missingOffset;
    212     out[i].refColor      = in[i].refColor;
     215    out[i].refColor      = in[i].refColorBlue;
    213216    out[i].flags         = in[i].flags;   
    214217    out[i].photFlagsUpper = in[i].photFlagsUpper;   
    … …  
    236239    out[i].dMkron        = in[i].dMkron;     
    237240    out[i].dM            = in[i].dM;     
    238     out[i].Xm            = in[i].Xm;     
    239     out[i].FluxPSF       = in[i].FluxPSF;
    240     out[i].dFluxPSF      = in[i].dFluxPSF;
    241     out[i].FluxKron      = in[i].FluxKron;
    242     out[i].dFluxKron     = in[i].dFluxKron;
     241    out[i].Mchisq        = in[i].Mchisq;     
     242    out[i].FpsfStk       = in[i].FluxPSF;
     243    out[i].dFpsfStk      = in[i].dFluxPSF;
     244    out[i].FkronStk      = in[i].FluxKron;
     245    out[i].dFkronStk     = in[i].dFluxKron;
    243246    out[i].flags         = in[i].flags;     
    244247    out[i].Ncode         = in[i].Ncode;
    245248    out[i].Nused         = in[i].Nused;
    246     out[i].M_20          = in[i].M_20;     
    247     out[i].M_80          = in[i].M_80;     
     249    out[i].Mmin          = in[i].M_20*0.001;     
     250    out[i].Mmax          = in[i].M_80*0.001;     
    248251    out[i].Mstdev        = in[i].Mstdev;     
    249252    out[i].ubercalDist   = in[i].ubercalDist;     
    … …  
    266269    out[i].dMkron        = in[i].dMkron;     
    267270    out[i].dM            = in[i].dM;     
    268     out[i].Xm            = in[i].Xm;     
    269     out[i].FluxPSF       = in[i].FluxPSF;
    270     out[i].dFluxPSF      = in[i].dFluxPSF;
    271     out[i].FluxKron      = in[i].FluxKron;
    272     out[i].dFluxKron     = in[i].dFluxKron;
     271    out[i].Mchisq        = in[i].Mchisq;
     272    out[i].FluxPSF       = in[i].FpsfStk;
     273    out[i].dFluxPSF      = in[i].dFpsfStk;
     274    out[i].FluxKron      = in[i].FkronStk;
     275    out[i].dFluxKron     = in[i].dFkronStk;
    273276    out[i].flags         = in[i].flags;     
    274277    out[i].Ncode         = in[i].Ncode;
    275278    out[i].Nused         = in[i].Nused;
    276     out[i].M_20          = in[i].M_20;     
    277     out[i].M_80          = in[i].M_80;     
     279    out[i].M_20          = in[i].Mmin*1000.0;     
     280    out[i].M_80          = in[i].Mmax*1000.0;     
    278281    out[i].Mstdev        = in[i].Mstdev;     
    279282    out[i].ubercalDist   = in[i].ubercalDist;     
    … …  
    282285  return (out);
    283286}
     287
     288# define RAW_IMAGE_NAME_LEN 121
    284289
    285290Image *Image_PS1_V4_ToInternal (Image_PS1_V4 *in, off_t Nvalues, off_t Nalloc) {
    … …  
    296301    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    297302
    298     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    299     out[i].name[120] = 0; // force termination
     303    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     304    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     305    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    300306
    301307    out[i].tzero            = in[i].tzero;
    … …  
    317323    out[i].DECo             = in[i].DECo;
    318324    out[i].Radius           = in[i].Radius;
    319     out[i].refColor         = in[i].refColor;
     325    out[i].refColorBlue     = in[i].refColor;
    320326
    321327    out[i].detection_limit  = in[i].detection_limit;
    … …  
    359365    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    360366
    361     strncpy (out[i].name, in[i].name, 120); // out[121], in[121]
    362     out[i].name[120] = 0; // force termination
     367    // RAW_IMAGE_NAME_LEN > DVO_IMAGE_NAME_LEN
     368    strncpy (out[i].name, in[i].name, DVO_IMAGE_NAME_LEN - 1);
     369    out[i].name[DVO_IMAGE_NAME_LEN - 1] = 0; // force termination
    363370
    364371    out[i].tzero            = in[i].tzero;
    … …  
    380387    out[i].DECo             = in[i].DECo;
    381388    out[i].Radius           = in[i].Radius;
    382     out[i].refColor         = in[i].refColor;
     389    out[i].refColor         = in[i].refColorBlue;
    383390
    384391    out[i].detection_limit  = in[i].detection_limit;
    … …  
    486493/*** there are some mini dvodbs with the wrong PS1_V4 format (missing Xoff,Yoff / Xfix,Yfix) ************/
    487494
    488 Measure *Measure_PS1_V4alt_ToInternal (Measure_PS1_V4alt *in, off_t Nvalues) {
     495Measure *Measure_PS1_V4alt_ToInternal (Average *ave, Measure_PS1_V4alt *in, off_t Nvalues) {
    489496
    490497  off_t i;
    … …  
    496503    dvo_measure_init (&out[i]);
    497504
    498     out[i].dR         = in[i].dR;
    499     out[i].dD         = in[i].dD;
     505    int averef = in[i].averef;
     506    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     507    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    500508    out[i].M          = in[i].M;
    501509    out[i].Mcal       = in[i].Mcal;
    … …  
    682690    out[i].measureOffset = in[i].measureOffset;
    683691    out[i].missingOffset = in[i].missingOffset;
    684     out[i].refColor      = in[i].refColor;
     692    out[i].refColorBlue  = in[i].refColor;
    685693    out[i].flags         = in[i].flags;   
    686694    out[i].photFlagsUpper = in[i].photFlagsUpper;   

  • trunk/Ohana/src/libdvo/src/dvo_convert_elixir.c

    r35162 r37035  
    22
    33/* convert elixir-format measures to internal measures */
    4 Measure *Measure_Elixir_ToInternal (Measure_Elixir *in, off_t Nvalues) {
     4Measure *Measure_Elixir_ToInternal (Average *ave, Measure_Elixir *in, off_t Nvalues) {
    55
    66  off_t i;
    … …  
    1515    out[i].averef   = in[i].averef;
    1616
     17    // changed for PS1_V5
     18    int averef = out[i].averef;
     19    out[i].R          = (in[i].dR == NAN_S_SHORT) ? NAN : ave[averef].R - 0.01 * in[i].dR / 3600.0;
     20    out[i].D          = (in[i].dD == NAN_S_SHORT) ? NAN : ave[averef].D - 0.01 * in[i].dD / 3600.0;
     21
    1722    // changed for PANSTARRS_DEV_0
    18     out[i].dR       = (in[i].dR      == NAN_S_SHORT) ? NAN : in[i].dR     * 0.01;
    19     out[i].dD       = (in[i].dD      == NAN_S_SHORT) ? NAN : in[i].dD     * 0.01;
    2023    out[i].M        = (in[i].M       == NAN_S_SHORT) ? NAN : in[i].M      * 0.001;
    2124    out[i].dM       = (in[i].dM      == NAN_U_CHAR)  ? NAN : in[i].dM     * 0.001;
    … …  
    4750
    4851/* convert internal measures to elixir-format measures */
    49 Measure_Elixir *MeasureInternalTo_Elixir (Measure *in, off_t Nvalues) {
     52Measure_Elixir *MeasureInternalTo_Elixir (Average *ave, Measure *in, off_t Nvalues) {
    5053
    5154  off_t i;
    … …  
    5962    out[i].averef  = in[i].averef;
    6063
     64    // changed for PS1_V5
     65    int averef = in[i].averef;
     66    int isBad = isnan(in[i].R) || isnan(in[i].D);
     67    out[i].dR     = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].R - in[i].R);
     68    out[i].dD     = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].D - in[i].D);
     69
    6170    // changed for PANSTARRS_DEV_0
    62     out[i].dR       = isnan(in[i].dR     ) ? NAN_S_SHORT : in[i].dR      *  100.0;
    63     out[i].dD       = isnan(in[i].dD     ) ? NAN_S_SHORT : in[i].dD      *  100.0;
    6471    out[i].M        = isnan(in[i].M      ) ? NAN_S_SHORT : in[i].M       * 1000.0;
    6572    out[i].dM       = isnan(in[i].dM     ) ? NAN_U_CHAR  : in[i].dM      * 1000.0;
    … …  
    104111    primary[0][i].M     = (in[i].M  == NAN_S_SHORT) ? NAN : in[i].M  * 0.001;     
    105112    primary[0][i].dM    = (in[i].dM == NAN_S_SHORT) ? NAN : in[i].dM * 0.001;     
    106     primary[0][i].Xm    = in[i].Xm;     
     113    primary[0][i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
    107114
    108115    // added for PANSTARRS_DEV_0
    … …  
    137144    out[i].M       = isnan(primary[i].M)  ? NAN_S_SHORT : primary[i].M   * 1000.0;
    138145    out[i].dM      = isnan(primary[i].dM) ? NAN_S_SHORT : primary[i].dM  * 1000.0;
    139     out[i].Xm      = primary[i].Xm;     
     146    out[i].Xm      = 100.0*log10(primary[i].Mchisq);     
    140147
    141148    // changed or added for PS1_DEV_2
    … …  
    162169    dvo_secfilt_init (&out[i]);
    163170
    164     out[i].Xm    = in[i].Xm;     
     171    out[i].Mchisq = pow (10.0, 0.01*in[i].Xm);     
    165172
    166173    // added or changed for PANSTARRS_DEV_0
    … …  
    180187
    181188  for (i = 0; i < Nvalues; i++) {
    182     out[i].Xm    = in[i].Xm;     
     189    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
    183190
    184191    // added or changed for PANSTARRS_DEV_0
    … …  
    188195  return (out);
    189196}
     197
     198# define RAW_IMAGE_NAME_LEN 32
    190199
    191200/* convert elixir-format images to internal images */
    … …  
    203212    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    204213
    205     strncpy (out[i].name, in[i].name, 31); // in[32], out[128]
    206     out[i].name[31] = 0; // force termination
     214    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     215    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     216    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    207217
    208218    out[i].tzero            = in[i].tzero;
    … …  
    272282    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    273283
    274     strncpy (out[i].name, in[i].name, 31); // out[32], in[128]
    275     out[i].name[31] = 0; // force termination
     284    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     285    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     286    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    276287
    277288    out[i].tzero            = in[i].tzero;

  • trunk/Ohana/src/libdvo/src/dvo_convert_loneos.c

    r35162 r37035  
    22
    33/* convert loneos-format measures to internal measures */
    4 Measure *Measure_Loneos_ToInternal (Measure_Loneos *in, off_t Nvalues) {
     4Measure *Measure_Loneos_ToInternal (Average *ave, Measure_Loneos *in, off_t Nvalues) {
    55
    66  off_t i;
    … …  
    1818    out[i].t         = in[i].t;
    1919
     20    // changed for PS1_V5
     21    int averef = out[i].averef;
     22    out[i].R          = (in[i].dR == NAN_S_SHORT) ? NAN : ave[averef].R - 0.01 * in[i].dR / 3600.0;
     23    out[i].D          = (in[i].dD == NAN_S_SHORT) ? NAN : ave[averef].D - 0.01 * in[i].dD / 3600.0;
     24
    2025    // changed for PANSTARRS_DEV_0
    21     out[i].dR       = (in[i].dR      == NAN_S_SHORT) ? NAN : in[i].dR     * 0.01;
    22     out[i].dD       = (in[i].dD      == NAN_S_SHORT) ? NAN : in[i].dD     * 0.01;
    2326    out[i].M        = (in[i].M       == NAN_S_SHORT) ? NAN : in[i].M      * 0.001;
    2427    out[i].dM       = (in[i].dM      == NAN_U_CHAR)  ? NAN : in[i].dM     * 0.001;
    … …  
    4043
    4144/* convert internal measures to loneos-format measures */
    42 Measure_Loneos *MeasureInternalTo_Loneos (Measure *in, off_t Nvalues) {
     45Measure_Loneos *MeasureInternalTo_Loneos (Average *ave, Measure *in, off_t Nvalues) {
    4346
    4447  off_t i;
    … …  
    4851
    4952  for (i = 0; i < Nvalues; i++) {
    50 
    51     // changed for PANSTARRS_DEV_0
    52     out[i].dR     = isnan(in[i].dR     ) ? NAN_S_SHORT : in[i].dR      *  100.0;
    53     out[i].dD     = isnan(in[i].dD     ) ? NAN_S_SHORT : in[i].dD      *  100.0;
     53    // changed for PS1_V5
     54    int averef = in[i].averef;
     55    int isBad = isnan(in[i].R) || isnan(in[i].D);
     56    out[i].dR     = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].R - in[i].R);
     57    out[i].dD     = isBad ? NAN_S_SHORT : 100.0*3600.0*(ave[averef].D - in[i].D);
     58
    5459    out[i].M      = isnan(in[i].M      ) ? NAN_S_SHORT : in[i].M       * 1000.0;
    5560    out[i].dM     = isnan(in[i].dM     ) ? NAN_U_CHAR  : in[i].dM      * 1000.0;
    … …  
    8590    // changed for PANSTARRS_DEV_0 (moved from Average to Measure)
    8691    primary[0][i].M     = (in[i].M  == NAN_S_SHORT) ? NAN : in[i].M  * 0.001;     
    87     primary[0][i].Xm    = in[i].Xm;     
     92    primary[0][i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
    8893
    8994    // added for PANSTARRS_DEV_0
    … …  
    119124    // changed for PANSTARRS_DEV_0 (moved from Average to Measure)
    120125    out[i].M       = isnan(primary[i].M)  ? NAN_S_SHORT : primary[i].M   * 1000.0;
    121     out[i].Xm      = primary[i].Xm;     
     126    out[i].Xm      = 100.0*log10(primary[i].Mchisq);     
    122127
    123128    // changed or added for PS1_DEV_2
    … …  
    144149    dvo_secfilt_init (&out[i]);
    145150
    146     out[i].Xm    = in[i].Xm;      
     151    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
    147152
    148153    // added or changed for PANSTARRS_DEV_0
    … …  
    161166
    162167  for (i = 0; i < Nvalues; i++) {
    163     out[i].Xm   = in[i].Xm;     
     168    out[i].Xm   = 100.0*log10(in[i].Mchisq);     
    164169
    165170    // added or changed for PANSTARRS_DEV_0
    … …  
    168173  return (out);
    169174}
     175
     176# define RAW_IMAGE_NAME_LEN 32
    170177
    171178/* convert loneos-format images to internal images */
    … …  
    183190    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    184191
    185     strncpy (out[i].name, in[i].name, 31); // in[32], out[128]
    186     out[i].name[31] = 0; // force termination
     192    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     193    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     194    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    187195
    188196    out[i].tzero            = in[i].tzero;
    … …  
    253261    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    254262
    255     strncpy (out[i].name, in[i].name, 31); // out[32], in[128]
    256     out[i].name[31] = 0; // force termination
     263    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     264    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     265    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    257266
    258267    out[i].tzero            = in[i].tzero;

  • trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c

    r35162 r37035  
    22
    33/* convert panstarrs-format measures to internal measures */
    4 Measure *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, off_t Nvalues) {
     4Measure *Measure_Panstarrs_DEV_0_ToInternal (Average *ave, Measure_Panstarrs_DEV_0 *in, off_t Nvalues) {
    55
    66  off_t i;
    … …  
    1111  for (i = 0; i < Nvalues; i++) {
    1212    dvo_measure_init (&out[i]);
    13     out[i].dR         = in[i].dR;
    14     out[i].dD         = in[i].dD;
     13
     14    int averef = in[i].averef;
     15    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     16    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    1517    out[i].M          = in[i].M;
    1618    out[i].dM         = in[i].dM;
    … …  
    5254
    5355/* convert internal measures to panstarrs-format measures */
    54 Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, off_t Nvalues) {
     56Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Average *ave, Measure *in, off_t Nvalues) {
    5557
    5658  off_t i;
    … …  
    6062
    6163  for (i = 0; i < Nvalues; i++) {
    62     out[i].dR         = in[i].dR;
    63     out[i].dD         = in[i].dD;
     64    int averef = in[i].averef;
     65
     66    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
     67    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
    6468    out[i].M          = in[i].M;
    6569    out[i].dM         = in[i].dM;
    … …  
    184188    out[i].M     = in[i].M;     
    185189    out[i].dM    = in[i].dM;     
    186     out[i].Xm    = in[i].Xm;     
     190    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
    187191    out[i].Ncode = in[i].Ncode;
    188192    out[i].Nused = in[i].Nused;
    … …  
    202206    out[i].M     = in[i].M;     
    203207    out[i].dM    = in[i].dM;     
    204     out[i].Xm    = in[i].Xm;     
     208    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
    205209    out[i].Ncode = in[i].Ncode;
    206210    out[i].Nused = in[i].Nused;
    … …  
    208212  return (out);
    209213}
     214
     215# define RAW_IMAGE_NAME_LEN 32
    210216
    211217/* convert panstarrs-format images to internal images */
    … …  
    223229    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    224230
    225     strncpy (out[i].name, in[i].name, 31); // out[128], in[32]
    226     out[i].name[31] = 0; // force termination
     231    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     232    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     233    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    227234
    228235    out[i].tzero            = in[i].tzero;
    … …  
    292299    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    293300
    294     strncpy (out[i].name, in[i].name, 31); // out[32], in[128]
    295     out[i].name[31] = 0; // force termination
     301    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     302    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     303    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    296304
    297305    out[i].tzero            = in[i].tzero;

  • trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c

    r35162 r37035  
    22
    33/* convert panstarrs-format measures to internal measures */
    4 Measure *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, off_t Nvalues) {
     4Measure *Measure_Panstarrs_DEV_1_ToInternal (Average *ave, Measure_Panstarrs_DEV_1 *in, off_t Nvalues) {
    55
    66  off_t i;
    … …  
    1111  for (i = 0; i < Nvalues; i++) {
    1212    dvo_measure_init (&out[i]);
    13     out[i].dR         = in[i].dR;
    14     out[i].dD         = in[i].dD;
     13
     14    int averef = in[i].averef;
     15    out[i].R          = ave[averef].R - in[i].dR / 3600.0;
     16    out[i].D          = ave[averef].D - in[i].dD / 3600.0;
    1517    out[i].M          = in[i].M;
    1618    out[i].dM         = in[i].dM;
    … …  
    5254
    5355/* convert internal measures to panstarrs-format measures */
    54 Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, off_t Nvalues) {
     56Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Average *ave, Measure *in, off_t Nvalues) {
    5557
    5658  off_t i;
    … …  
    6062
    6163  for (i = 0; i < Nvalues; i++) {
    62     out[i].dR         = in[i].dR;
    63     out[i].dD         = in[i].dD;
     64    int averef = in[i].averef;
     65
     66    out[i].dR         = 3600.0*(ave[averef].R - in[i].R);
     67    out[i].dD         = 3600.0*(ave[averef].D - in[i].D);
    6468    out[i].M          = in[i].M;
    6569    out[i].dM         = in[i].dM;
    … …  
    184188    out[i].M     = in[i].M;     
    185189    out[i].dM    = in[i].dM;     
    186     out[i].Xm    = in[i].Xm;     
     190    out[i].Mchisq= pow (10.0, 0.01*in[i].Xm);     
    187191    out[i].Ncode = in[i].Ncode;
    188192    out[i].Nused = in[i].Nused;
    … …  
    202206    out[i].M     = in[i].M;     
    203207    out[i].dM    = in[i].dM;     
    204     out[i].Xm    = in[i].Xm;     
     208    out[i].Xm    = 100.0*log10(in[i].Mchisq);     
    205209    out[i].Ncode = in[i].Ncode;
    206210    out[i].Nused = in[i].Nused;
    … …  
    208212  return (out);
    209213}
     214
     215# define RAW_IMAGE_NAME_LEN 64
    210216
    211217/* convert panstarrs-format images to internal images */
    … …  
    223229    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    224230
    225     strncpy (out[i].name, in[i].name, 63); // in[64], out[128]
    226     out[i].name[63] = 0; // force termination
     231    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     232    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     233    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    227234
    228235    out[i].tzero            = in[i].tzero;
    … …  
    292299    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    293300
    294     strncpy (out[i].name, in[i].name, 63); // in[128], out[64]
    295     out[i].name[63] = 0; // force termination
     301    // RAW_IMAGE_NAME_LEN < DVO_IMAGE_NAME_LEN
     302    strncpy (out[i].name, in[i].name, RAW_IMAGE_NAME_LEN - 1);
     303    out[i].name[RAW_IMAGE_NAME_LEN - 1] = 0; // force termination
    296304
    297305    out[i].tzero            = in[i].tzero;

  • trunk/Ohana/src/libdvo/src/dvo_image.c

    r35162 r37035  
    219219  if (db[0].format == DVO_FORMAT_PS1_V3)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V3");
    220220  if (db[0].format == DVO_FORMAT_PS1_V4)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V4");
     221  if (db[0].format == DVO_FORMAT_PS1_V5)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_V5");
    221222  if (db[0].format == DVO_FORMAT_PS1_REF)         gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_REF");
    222223 

  • trunk/Ohana/src/libdvo/src/dvo_image_raw.c

    r34260 r37035  
    5959  if (db[0].format == DVO_FORMAT_PS1_V3)          ImageSize = sizeof(Image_PS1_V3);
    6060  if (db[0].format == DVO_FORMAT_PS1_V4)          ImageSize = sizeof(Image_PS1_V4);
     61  if (db[0].format == DVO_FORMAT_PS1_V5)          ImageSize = sizeof(Image_PS1_V5);
    6162  if (db[0].format == DVO_FORMAT_PS1_REF)         ImageSize = sizeof(Image_PS1_REF);
    6263
    … …  
    8990  if (db[0].format == DVO_FORMAT_PS1_V3)          gfits_table_mkheader_Image_PS1_V3 (&db[0].theader);
    9091  if (db[0].format == DVO_FORMAT_PS1_V4)          gfits_table_mkheader_Image_PS1_V4 (&db[0].theader);
     92  if (db[0].format == DVO_FORMAT_PS1_V5)          gfits_table_mkheader_Image_PS1_V5 (&db[0].theader);
    9193  if (db[0].format == DVO_FORMAT_PS1_REF)         gfits_table_mkheader_Image_PS1_REF (&db[0].theader);
    9294   

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

    r36630 r37035  
    1818
    1919static PhotCodeData *photcodes = NULL;
     20static PhotCode *genericCodeMag = NULL;
     21static PhotCode *genericCodeFlux = NULL;
    2022
    2123PhotCodeData *GetPhotcodeTable () {
    … …  
    2628    photcodes[0].code = NULL;
    2729  }
     30  if (genericCodeMag == NULL) {
     31    ALLOCATE (genericCodeMag, PhotCode, 1);
     32    genericCodeMag->code = 0;
     33    strcpy (genericCodeMag->name, "MAG");
     34    genericCodeMag->type = PHOT_MAG;
     35  }
     36  if (genericCodeFlux == NULL) {
     37    ALLOCATE (genericCodeFlux, PhotCode, 1);
     38    genericCodeFlux->code = 0;
     39    strcpy (genericCodeFlux->name, "MAG");
     40    genericCodeFlux->type = PHOT_MAG;
     41  }
    2842  return photcodes;
    2943}
    … …  
    5771  if (name == NULL) return (NULL);
    5872 
     73  // "MAG" is a special word, not allowed for a photcode name
     74  if (!strcasecmp (name, "MAG")) {
     75    return genericCodeMag;
     76  }
     77
     78  // "FLUX" is a special word, not allowed for a photcode name
     79  if (!strcasecmp (name, "FLUX")) {
     80    return genericCodeFlux;
     81  }
     82
    5983  for (i = 0; i < photcodes[0].Ncode; i++) {
    6084    if (!strcmp (photcodes[0].code[i].name, name)) {
    … …  
    7094 
    7195  if (name == NULL) return (0);
     96
     97  // "MAG" is a special photcode name for internal use
     98  if (!strcasecmp (name, "MAG")) {
     99    return genericCodeMag->code;
     100  }
     101  // "FLUX" is a special photcode name for internal use
     102  if (!strcasecmp (name, "FLUX")) {
     103    return genericCodeFlux->code;
     104  }
    72105
    73106  for (i = 0; i < photcodes[0].Ncode; i++) {
    … …  
    222255
    223256/******** photometry conversion functions *********/
    224 float PhotInst (Measure *measure) {
    225 
    226   int Np;
    227   float M;
    228 
    229   Np = photcodes[0].hashcode[measure[0].photcode];
     257float PhotInst (Measure *measure, dvoMagClassType class) {
     258
     259  int Np = photcodes[0].hashcode[measure[0].photcode];
    230260  if (Np == -1) return (NAN);
    231 
    232   if (photcodes[0].code[Np].type == PHOT_REF) {
    233     M = measure[0].M;
    234     return (M);
    235   }
    236 
    237   M = measure[0].M - measure[0].dt - ZERO_POINT;
    238          
    239   return (M);
    240 
    241 }
    242 
    243 float PhotCat (Measure *measure) {
    244 
    245   int Np;
    246   float Mcat;
    247   PhotCode *code;
    248 
    249   Np = photcodes[0].hashcode[measure[0].photcode];
     261  PhotCode *code = &photcodes[0].code[Np];
     262
     263  float Mraw = NAN;
     264  switch (class) {
     265    case MAG_CLASS_PSF:
     266      Mraw = measure[0].M;
     267      break;
     268    case MAG_CLASS_KRON:
     269      Mraw = measure[0].Mkron;
     270      break;
     271    case MAG_CLASS_APER:
     272      Mraw = measure[0].Map;
     273      break;
     274    default:
     275      break;
     276  }
     277  if (code->type == PHOT_REF) {
     278    return (Mraw);
     279  }
     280  float Minst = Mraw - measure[0].dt - ZERO_POINT;
     281
     282  return (Minst);
     283}
     284
     285float PhotCat (Measure *measure, dvoMagClassType class) {
     286
     287  int Np = photcodes[0].hashcode[measure[0].photcode];
    250288  if (Np == -1) return (NAN);
    251 
    252   if (photcodes[0].code[Np].type == PHOT_REF) {
    253     Mcat = measure[0].M;
    254     return (Mcat);
    255   }
    256   code = &photcodes[0].code[Np];
    257   Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     289  PhotCode *code = &photcodes[0].code[Np];
     290
     291  float Mraw = NAN;
     292  switch (class) {
     293    case MAG_CLASS_PSF:
     294      Mraw = measure[0].M;
     295      break;
     296    case MAG_CLASS_KRON:
     297      Mraw = measure[0].Mkron;
     298      break;
     299    case MAG_CLASS_APER:
     300      Mraw = measure[0].Map;
     301      break;
     302    default:
     303      break;
     304  }
     305  if (code->type == PHOT_REF) {
     306    return (Mraw);
     307  }
     308
     309  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    258310 
    259311  return (Mcat);
    260312}
    261313
    262 float PhotSys (Measure *measure, Average *average, SecFilt *secfilt) {
    263 
    264   int i, Np;
    265   float Mcat, Mcol, Msys, mc, Mc;
    266   PhotCode *code;
    267 
    268   Np = photcodes[0].hashcode[measure[0].photcode];
     314float PhotSys (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) {
     315
     316  int Np = photcodes[0].hashcode[measure[0].photcode];
    269317  if (Np == -1) return (NAN);
    270 
    271   if (photcodes[0].code[Np].type == PHOT_REF) {
    272     Msys = measure[0].M;
    273     return (Msys);
    274   }
    275   code = &photcodes[0].code[Np];
    276   Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     318  PhotCode *code = &photcodes[0].code[Np];
     319
     320  float Mraw = NAN;
     321  switch (class) {
     322    case MAG_CLASS_PSF:
     323      Mraw = measure[0].M;
     324      break;
     325    case MAG_CLASS_KRON:
     326      Mraw = measure[0].Mkron;
     327      break;
     328    case MAG_CLASS_APER:
     329      Mraw = measure[0].Map;
     330      break;
     331    default:
     332      break;
     333  }
     334  if (code->type == PHOT_REF) {
     335    return (Mraw);
     336  }
     337  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    277338
    278339  /* for DEP, color must be made of PRI/SEC */
    279   mc = PhotColorForCode (average, secfilt, NULL, code);
     340  float mc = PhotColorForCode (average, secfilt, NULL, code);
    280341  if (isnan(mc)) return (Mcat);
    281   mc = mc - SCALE*code[0].dX;
    282 
    283   Mc = mc;
    284   Mcol = 0;
     342  mc -= SCALE*code[0].dX;
     343
     344  int i = 0;
     345  double Mc = mc;
     346  float Mcol = 0;
    285347  for (i = 0; i < code[0].Nc; i++) {
    286348    Mcol += code[0].X[i]*Mc;
    287349    Mc *= mc;
    288350  }
    289   Msys = Mcat + Mcol;
     351  float Msys = Mcat + Mcol;
    290352  return (Msys);
    291353}
    292354
    293 float PhotRel (Measure *measure, Average *average, SecFilt *secfilt) {
    294 
    295   int i, Np;
    296   float Mcat, Mcol, Mrel, mc, Mc;
    297   PhotCode *code;
    298 
    299   Np = photcodes[0].hashcode[measure[0].photcode];
     355float PhotRel (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) {
     356
     357  int Np = photcodes[0].hashcode[measure[0].photcode];
    300358  if (Np == -1) return (NAN);
    301 
    302   if (photcodes[0].code[Np].type == PHOT_REF) {
    303     Mcat = measure[0].M;
    304     return (Mcat);
    305   }
    306   code = &photcodes[0].code[Np];
    307   Mrel = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
     359  PhotCode *code = &photcodes[0].code[Np];
     360
     361  float Mraw = NAN;
     362  switch (class) {
     363    case MAG_CLASS_PSF:
     364      Mraw = measure[0].M;
     365      break;
     366    case MAG_CLASS_KRON:
     367      Mraw = measure[0].Mkron;
     368      break;
     369    case MAG_CLASS_APER:
     370      Mraw = measure[0].Map;
     371      break;
     372    default:
     373      break;
     374  }
     375  if (code->type == PHOT_REF) {
     376    return (Mraw);
     377  }
     378  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
    308379
    309380  /* for DEP, color must be made of PRI/SEC */
    310   mc = PhotColorForCode (average, secfilt, NULL, code);
    311   if (isnan(mc)) return (Mrel);
    312   mc = mc - SCALE*code[0].dX;
    313 
    314   Mc = mc;
    315   Mcol = 0;
     381  float mc = PhotColorForCode (average, secfilt, NULL, code);
     382  if (isnan(mc)) return (Mcat);
     383  mc -= SCALE*code[0].dX;
     384
     385  double Mc = mc;
     386  float Mcol = 0;
     387  int i = 0;
     388  for (i = 0; i < code[0].Nc; i++) {
     389    Mcol += code[0].X[i]*Mc;
     390    Mc *= mc;
     391  }
     392  float Mrel = Mcat + Mcol;
     393  return (Mrel);
     394}
     395
     396/* return calibrated magnitude from measure for given photcode */
     397float PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code, dvoMagClassType class) {
     398
     399  int i;
     400
     401  if (code == NULL) return NAN;
     402
     403  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
     404  int Np = photcodes[0].hashcode[thisone[0].photcode];
     405  if (Np == -1) return (NAN);
     406  PhotCode *myCode = &photcodes[0].code[Np];
     407
     408  if (code->code != myCode->equiv) return (NAN);
     409
     410  // if we are REF type, just get the right version and return
     411  if (myCode->type == PHOT_REF) {
     412    float Mraw = NAN;
     413    switch (class) {
     414      case MAG_CLASS_PSF:
     415        Mraw = thisone[0].M;
     416        break;
     417      case MAG_CLASS_KRON:
     418        Mraw = thisone[0].Mkron;
     419        break;
     420      case MAG_CLASS_APER:
     421        Mraw = thisone[0].Map;
     422        break;
     423      default:
     424        break;
     425    }
     426    return (Mraw);
     427  }
     428
     429  float Mcal = PhotRel (thisone, average, secfilt, class) + SCALE*code[0].C;
     430
     431  float mc = PhotColorForCode (average, secfilt, measure, code);
     432  if (isnan(mc)) return (Mcal);
     433  mc -= SCALE*code[0].dX;
     434
     435  double Mc = mc;
     436  float Mcol = 0;
     437  for (i = 0; i < code[0].Nc; i++) {
     438    Mcol += code[0].X[i]*Mc;
     439    Mc *= mc;
     440  }
     441  Mcal += Mcol;
     442  return (Mcal);
     443}
     444
     445/***/
     446float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) {
     447
     448  if (code == NULL) return NAN;
     449
     450  int Ns = photcodes[0].hashNsec[code[0].code];
     451  if (Ns == -1) return (NAN);
     452
     453  float Mave = NAN;
     454  switch (source) {
     455    case MAG_SRC_CHP:
     456      switch (class) {
     457        case MAG_CLASS_PSF:
     458          Mave = secfilt[Ns].M;
     459          break;
     460        case MAG_CLASS_KRON:
     461          Mave = secfilt[Ns].Mkron;
     462          break;
     463        case MAG_CLASS_APER:
     464          Mave = secfilt[Ns].Map;
     465          break;
     466        default:
     467          break;
     468      }
     469      break;
     470    case MAG_SRC_WRP:
     471      switch (class) {
     472        case MAG_CLASS_PSF:
     473          Mave = secfilt[Ns].MpsfWrp;
     474          break;
     475        case MAG_CLASS_KRON:
     476          Mave = secfilt[Ns].MkronWrp;
     477          break;
     478        case MAG_CLASS_APER:
     479          Mave = secfilt[Ns].MapWrp;
     480          break;
     481        default:
     482          break;
     483      }
     484      break;
     485    case MAG_SRC_STK:
     486      switch (class) {
     487        case MAG_CLASS_PSF:
     488          Mave = secfilt[Ns].MpsfStk;
     489          break;
     490        case MAG_CLASS_KRON:
     491          Mave = secfilt[Ns].MkronStk;
     492          break;
     493        case MAG_CLASS_APER:
     494          Mave = secfilt[Ns].MapStk;
     495          break;
     496        default:
     497          break;
     498      }
     499      break;
     500    default:
     501      break;
     502  }
     503  return (Mave);
     504}
     505
     506/* return calibrated magnitude from average/secfilt for given photcode */
     507float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure, dvoMagClassType class, dvoMagSourceType source) {
     508
     509  int i;
     510
     511  float Mave = PhotAve (code, average, secfilt, class, source);
     512  if (isnan(Mave)) return NAN;
     513
     514  // correct for relative zero-point
     515  float Mref = Mave + SCALE*code[0].C;
     516
     517  float mc = PhotColorForCode (average, secfilt, measure, code);
     518  if (isnan(mc)) return (Mref);
     519  mc -= SCALE*code[0].dX;
     520
     521  // correct for color terms
     522  double Mc = mc;
     523  float Mcol = 0;
    316524  for (i = 0; i < code[0].Nc; i++) {
    317525    Mcol += code[0].X[i]*Mc;
    318526    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    319527  }
    320   Mrel += Mcol;
    321   return (Mrel);
    322 }
    323 
    324 /* return calibrated magnitude from measure for given photcode */
    325 float PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
    326 
    327   int i, Np;
    328   float Mcal, Mrel, Mcol, mc, Mc;
    329 
    330   if (code == NULL) return NAN;
    331 
    332   /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
    333   Np = photcodes[0].hashcode[thisone[0].photcode];
    334   if (Np == -1) return (NAN);
    335 
    336   if (photcodes[0].code[Np].type == PHOT_REF) {
    337     Mrel = thisone[0].M;
    338     return (Mrel);
    339   }
    340   if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
    341 
    342   Mcal = PhotRel (thisone, average, secfilt) + SCALE*code[0].C;
    343 
    344   mc = PhotColorForCode (average, secfilt, measure, code);
    345   if (isnan(mc)) return (Mcal);
    346   mc = mc - SCALE*code[0].dX;
    347 
    348   Mc = mc;
    349   Mcol = 0;
    350   for (i = 0; i < code[0].Nc; i++) {
    351     Mcol += code[0].X[i]*Mc;
    352     Mc *= mc;
    353   }
    354   Mcal += Mcol;
    355   return (Mcal);
    356 }
    357 
    358 /***/
    359 float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt) {
    360 
    361   int Ns;
    362   float Mave;
    363 
    364   if (code == NULL) return NAN;
    365 
    366   Ns = photcodes[0].hashNsec[code[0].code];
    367   Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
    368   return (Mave);
    369 }
    370 
    371 /* return calibrated magnitude from average/secfilt for given photcode */
    372 float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
    373 
    374   int i, Ns;
    375   float Mave, Mref, Mcol, mc;
    376   double Mc;
    377 
    378   if (code == NULL) return NAN;
    379 
    380   Ns = photcodes[0].hashNsec[code[0].code];
    381   Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
    382   Mref = Mave + SCALE*code[0].C;
    383 
    384   mc = PhotColorForCode (average, secfilt, measure, code);
    385   if (isnan(mc)) return (Mref);
    386   mc = mc - SCALE*code[0].dX;
    387 
    388   Mc = mc;
    389   Mcol = 0;
    390   for (i = 0; i < code[0].Nc; i++) {
    391     Mcol += code[0].X[i]*Mc;
    392     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    393   }
    394528  Mref += Mcol;
    395529  return (Mref);
    396530}
    397531
    398 float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt) {
    399 
    400   int Ns;
    401   float dM;
    402 
    403   if (code == NULL) return NAN;
    404 
    405   Ns = photcodes[0].hashNsec[code[0].code];
    406   dM  = (Ns == -1) ? NAN : secfilt[Ns].dM;
    407   return (dM);
    408 }
    409 
    410 /************************************** APERTURE-related Magnitudes ***********************************************/
    411 
    412 float PhotAperInst (Measure *measure) {
    413 
    414   int Np;
    415   float Minst;
    416 
    417   Np = photcodes[0].hashcode[measure[0].photcode];
    418   if (Np == -1) return (NAN);
    419 
    420   if (photcodes[0].code[Np].type == PHOT_REF) {
    421     Minst = measure[0].Map;
    422     return (Minst);
    423   }
    424   Minst = measure[0].Map - measure[0].dt - ZERO_POINT;
    425  
    426   return (Minst);
    427 }
    428 
    429 float PhotAperCat (Measure *measure) {
    430 
    431   int Np;
    432   float Mcat;
    433   PhotCode *code;
    434 
    435   Np = photcodes[0].hashcode[measure[0].photcode];
    436   if (Np == -1) return (NAN);
    437 
    438   if (photcodes[0].code[Np].type == PHOT_REF) {
    439     Mcat = measure[0].Map;
    440     return (Mcat);
    441   }
    442   code = &photcodes[0].code[Np];
    443   Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    444  
    445   return (Mcat);
    446 }
    447 
    448 float PhotAperSys (Measure *measure, Average *average, SecFilt *secfilt) {
    449 
    450   int i, Np;
    451   float Mcat, Mcol, Msys, mc, Mc;
    452   PhotCode *code;
    453 
    454   Np = photcodes[0].hashcode[measure[0].photcode];
    455   if (Np == -1) return (NAN);
    456 
    457   if (photcodes[0].code[Np].type == PHOT_REF) {
    458     Mcat = measure[0].Map;
    459     return (Mcat);
    460   }
    461   code = &photcodes[0].code[Np];
    462   Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    463  
    464   /* for DEP, color must be made of PRI/SEC */
    465   mc = PhotColorForCode (average, secfilt, NULL, code);
    466   if (isnan(mc)) return (Mcat);
    467   mc = mc - SCALE*code[0].dX;
    468 
    469   Mc = mc;
    470   Mcol = 0;
    471   for (i = 0; i < code[0].Nc; i++) {
    472     Mcol += code[0].X[i]*Mc;
    473     Mc *= mc;
    474   }
    475   Msys = Mcat + Mcol;
    476   return (Msys);
    477 }
    478 
    479 float PhotAperRel (Measure *measure, Average *average, SecFilt *secfilt) {
    480 
    481   int i, Np;
    482   float Mcat, Mcol, Mrel, mc, Mc;
    483   PhotCode *code;
    484 
    485   Np = photcodes[0].hashcode[measure[0].photcode];
    486   if (Np == -1) return (NAN);
    487 
    488   if (photcodes[0].code[Np].type == PHOT_REF) {
    489     Mcat = measure[0].Map;
    490     return (Mcat);
    491   }
    492   code = &photcodes[0].code[Np];
    493   Mrel = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
    494 
    495   /* for DEP, color must be made of PRI/SEC */
    496   mc = PhotColorForCode (average, secfilt, NULL, code);
    497   if (isnan(mc)) return (Mrel);
    498   mc = mc - SCALE*code[0].dX;
    499 
    500   Mc = mc;
    501   Mcol = 0;
    502   for (i = 0; i < code[0].Nc; i++) {
    503     Mcol += code[0].X[i]*Mc;
    504     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    505   }
    506   Mrel += Mcol;
    507   return (Mrel);
    508 }
    509 
    510 /* return calibrated magnitude from measure for given photcode */
    511 float PhotAperCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
    512 
    513   int i, Np;
    514   float Mcal, Mrel, Mcol, mc, Mc;
    515 
    516   if (code == NULL) return NAN;
    517 
    518   /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
    519   Np = photcodes[0].hashcode[thisone[0].photcode];
    520   if (Np == -1) return (NAN);
    521 
    522   if (photcodes[0].code[Np].type == PHOT_REF) {
    523     Mrel = thisone[0].Map;
    524     return (Mrel);
    525   }
    526   if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
    527 
    528   Mcal = PhotAperRel (thisone, average, secfilt) + SCALE*code[0].C;
    529 
    530   mc = PhotColorForCode (average, secfilt, measure, code);
    531   if (isnan(mc)) return (Mcal);
    532   mc = mc - SCALE*code[0].dX;
    533 
    534   Mc = mc;
    535   Mcol = 0;
    536   for (i = 0; i < code[0].Nc; i++) {
    537     Mcol += code[0].X[i]*Mc;
    538     Mc *= mc;
    539   }
    540   Mcal += Mcol;
    541   return (Mcal);
    542 }
    543 
    544 float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt) {
    545 
    546   int Ns;
    547   float Maper;
    548 
    549   if (code == NULL) return NAN;
    550 
    551   Ns = photcodes[0].hashNsec[code[0].code];
    552   Maper = (Ns == -1) ? NAN : secfilt[Ns].Map;
    553   return (Maper);
    554 }
    555 
    556 /* return calibrated magnitude from average/secfilt for given photcode */
    557 float PhotAperRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
    558 
    559   int i, Ns;
    560   float Mave, Mref, Mcol, mc;
    561   double Mc;
    562 
    563   if (code == NULL) return NAN;
    564 
    565   Ns = photcodes[0].hashNsec[code[0].code];
    566   Mave = (Ns == -1) ? NAN : secfilt[Ns].Map;
    567   Mref = Mave + SCALE*code[0].C;
    568 
    569   mc = PhotColorForCode (average, secfilt, measure, code);
    570   if (isnan(mc)) return (Mref);
    571   mc = mc - SCALE*code[0].dX;
    572 
    573   Mc = mc;
    574   Mcol = 0;
    575   for (i = 0; i < code[0].Nc; i++) {
    576     Mcol += code[0].X[i]*Mc;
    577     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    578   }
    579   Mref += Mcol;
    580   return (Mref);
    581 }
    582 
    583 /************************************** KRON-related Magnitudes ***********************************************/
    584 
    585 float PhotKronInst (Measure *measure) {
    586 
    587   int Np;
    588   float Minst;
    589 
    590   Np = photcodes[0].hashcode[measure[0].photcode];
    591   if (Np == -1) return (NAN);
    592 
    593   if (photcodes[0].code[Np].type == PHOT_REF) {
    594     Minst = measure[0].Mkron;
    595     return (Minst);
    596   }
    597   Minst = measure[0].Mkron - measure[0].dt - ZERO_POINT;
    598  
    599   return (Minst);
    600 }
    601 
    602 float PhotKronCat (Measure *measure) {
    603 
    604   int Np;
    605   float Mcat;
    606   PhotCode *code;
    607 
    608   Np = photcodes[0].hashcode[measure[0].photcode];
    609   if (Np == -1) return (NAN);
    610 
    611   if (photcodes[0].code[Np].type == PHOT_REF) {
    612     Mcat = measure[0].Mkron;
    613     return (Mcat);
    614   }
    615   code = &photcodes[0].code[Np];
    616   Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    617  
    618   return (Mcat);
    619 }
    620 
    621 float PhotKronSys (Measure *measure, Average *average, SecFilt *secfilt) {
    622 
    623   int i, Np;
    624   float Mcat, Mcol, Msys, mc, Mc;
    625   PhotCode *code;
    626 
    627   Np = photcodes[0].hashcode[measure[0].photcode];
    628   if (Np == -1) return (NAN);
    629 
    630   if (photcodes[0].code[Np].type == PHOT_REF) {
    631     Msys = measure[0].Mkron;
    632     return (Msys);
    633   }
    634   code = &photcodes[0].code[Np];
    635   Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    636 
    637   /* for DEP, color must be made of PRI/SEC */
    638   mc = PhotColorForCode (average, secfilt, NULL, code);
    639   if (isnan(mc)) return (Mcat);
    640   mc = mc - SCALE*code[0].dX;
    641 
    642   Mc = mc;
    643   Mcol = 0;
    644   for (i = 0; i < code[0].Nc; i++) {
    645     Mcol += code[0].X[i]*Mc;
    646     Mc *= mc;
    647   }
    648   Msys = Mcat + Mcol;
    649   return (Msys);
    650 }
    651 
    652 float PhotKronRel (Measure *measure, Average *average, SecFilt *secfilt) {
    653 
    654   int i, Np;
    655   float Mcat, Mcol, Mrel, mc, Mc;
    656   PhotCode *code;
    657 
    658   Np = photcodes[0].hashcode[measure[0].photcode];
    659   if (Np == -1) return (NAN);
    660 
    661   if (photcodes[0].code[Np].type == PHOT_REF) {
    662     Mcat = measure[0].Mkron;
    663     return (Mcat);
    664   }
    665   code = &photcodes[0].code[Np];
    666   Mrel = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
    667 
    668   /* for DEP, color must be made of PRI/SEC */
    669   mc = PhotColorForCode (average, secfilt, NULL, code);
    670   if (isnan(mc)) return (Mrel);
    671   mc = mc - SCALE*code[0].dX;
    672 
    673   Mc = mc;
    674   Mcol = 0;
    675   for (i = 0; i < code[0].Nc; i++) {
    676     Mcol += code[0].X[i]*Mc;
    677     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    678   }
    679   Mrel += Mcol;
    680   return (Mrel);
    681 }
    682 
    683 /* return calibrated magnitude from measure for given photcode */
    684 float PhotKronCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
    685 
    686   int i, Np;
    687   float Mcal, Mrel, Mcol, mc, Mc;
    688 
    689   if (code == NULL) return NAN;
    690 
    691   /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
    692   Np = photcodes[0].hashcode[thisone[0].photcode];
    693   if (Np == -1) return (NAN);
    694 
    695   if (photcodes[0].code[Np].type == PHOT_REF) {
    696     Mrel = thisone[0].Mkron;
    697     return (Mrel);
    698   }
    699   if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
    700 
    701   Mcal = PhotKronRel (thisone, average, secfilt) + SCALE*code[0].C;
    702 
    703   mc = PhotColorForCode (average, secfilt, measure, code);
    704   if (isnan(mc)) return (Mcal);
    705   mc = mc - SCALE*code[0].dX;
    706 
    707   Mc = mc;
    708   Mcol = 0;
    709   for (i = 0; i < code[0].Nc; i++) {
    710     Mcol += code[0].X[i]*Mc;
    711     Mc *= mc;
    712   }
    713   Mcal += Mcol;
    714   return (Mcal);
    715 }
    716 
    717 float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt) {
    718 
    719   int Ns;
    720   float Mkron;
    721 
    722   if (code == NULL) return NAN;
    723 
    724   Ns = photcodes[0].hashNsec[code[0].code];
    725   Mkron = (Ns == -1) ? NAN : secfilt[Ns].Mkron;
    726   return (Mkron);
    727 }
    728 
    729 /* return calibrated magnitude from average/secfilt for given photcode */
    730 float PhotKronRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
    731 
    732   int i, Ns;
    733   float Mave, Mref, Mcol, mc;
    734   double Mc;
    735 
    736   if (code == NULL) return NAN;
    737 
    738   Ns = photcodes[0].hashNsec[code[0].code];
    739   Mave = (Ns == -1) ? NAN : secfilt[Ns].Mkron;
    740   Mref = Mave + SCALE*code[0].C;
    741 
    742   mc = PhotColorForCode (average, secfilt, measure, code);
    743   if (isnan(mc)) return (Mref);
    744   mc = mc - SCALE*code[0].dX;
    745 
    746   Mc = mc;
    747   Mcol = 0;
    748   for (i = 0; i < code[0].Nc; i++) {
    749     Mcol += code[0].X[i]*Mc;
    750     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    751   }
    752   Mref += Mcol;
    753   return (Mref);
    754 }
    755 
    756 float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt) {
    757 
    758   int Ns;
    759   float dMkron;
    760 
    761   if (code == NULL) return NAN;
    762 
    763   Ns = photcodes[0].hashNsec[code[0].code];
    764   dMkron = (Ns == -1) ? NAN : secfilt[Ns].dMkron;
    765   return (dMkron);
     532float PhotErr (Measure *measure, dvoMagClassType class) {
     533
     534  float dMraw = NAN;
     535  switch (class) {
     536    case MAG_CLASS_PSF:
     537      dMraw = measure[0].dM;
     538      break;
     539    case MAG_CLASS_KRON:
     540      dMraw = measure[0].dMkron;
     541      break;
     542    case MAG_CLASS_APER:
     543      dMraw = measure[0].dMap;
     544      break;
     545    default:
     546      break;
     547  }
     548  return (dMraw);
     549}
     550
     551float PhotCalErr (Measure *measure, dvoMagClassType class) {
     552
     553  float dMcal = measure[0].dMcal;
     554  return (dMcal);
     555}
     556
     557float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) {
     558
     559  if (code == NULL) return NAN;
     560
     561  int Ns = photcodes[0].hashNsec[code[0].code];
     562  if (Ns == -1) return (NAN);
     563
     564  float dMave = NAN;
     565  switch (source) {
     566    case MAG_SRC_CHP:
     567      switch (class) {
     568        case MAG_CLASS_PSF:
     569          dMave = secfilt[Ns].dM;
     570          break;
     571        case MAG_CLASS_KRON:
     572          dMave = secfilt[Ns].dMkron;
     573          break;
     574        case MAG_CLASS_APER:
     575          dMave = secfilt[Ns].dMap;
     576          break;
     577        default:
     578          break;
     579      }
     580      break;
     581    case MAG_SRC_WRP:
     582      switch (class) {
     583        case MAG_CLASS_PSF:
     584          dMave = secfilt[Ns].dFpsfWrp / secfilt[Ns].FpsfWrp;
     585          break;
     586        case MAG_CLASS_KRON:
     587          dMave = secfilt[Ns].dFkronWrp / secfilt[Ns].FkronWrp;
     588          break;
     589        case MAG_CLASS_APER:
     590          dMave = secfilt[Ns].dFapWrp / secfilt[Ns].FapWrp;
     591          break;
     592        default:
     593          break;
     594      }
     595      break;
     596    case MAG_SRC_STK:
     597      switch (class) {
     598        case MAG_CLASS_PSF:
     599          dMave = secfilt[Ns].dFpsfStk / secfilt[Ns].FpsfStk;
     600          break;
     601        case MAG_CLASS_KRON:
     602          dMave = secfilt[Ns].dFkronStk / secfilt[Ns].FkronStk;
     603          break;
     604        case MAG_CLASS_APER:
     605          dMave = secfilt[Ns].dFapStk / secfilt[Ns].FapStk;
     606          break;
     607        default:
     608          break;
     609      }
     610      break;
     611    default:
     612      break;
     613  }
     614  return (dMave);
    766615}
    767616
    … …  
    788637
    789638/* color term may not use DEP magnitude */
     639// currently only returns the PSF color
    790640float PhotColorForCode (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
    791641
    … …  
    857707
    858708  Ns = photcodes[0].hashNsec[code[0].code];
    859   Fpsf = (Ns == -1) ? NAN : secfilt[Ns].FluxPSF;
     709  Fpsf = (Ns == -1) ? NAN : secfilt[Ns].FpsfStk;
    860710  return (Fpsf);
    861711}
    … …  
    869719
    870720  Ns = photcodes[0].hashNsec[code[0].code];
    871   dFpsf = (Ns == -1) ? NAN : secfilt[Ns].dFluxPSF;
     721  dFpsf = (Ns == -1) ? NAN : secfilt[Ns].dFpsfStk;
    872722  return (dFpsf);
    873723}
    … …  
    881731
    882732  Ns = photcodes[0].hashNsec[code[0].code];
    883   Fkron = (Ns == -1) ? NAN : secfilt[Ns].FluxKron;
     733  Fkron = (Ns == -1) ? NAN : secfilt[Ns].FkronStk;
    884734  return (Fkron);
    885735}
    … …  
    893743
    894744  Ns = photcodes[0].hashNsec[code[0].code];
    895   dFkron = (Ns == -1) ? NAN : secfilt[Ns].dFluxKron;
     745  dFkron = (Ns == -1) ? NAN : secfilt[Ns].dFkronStk;
    896746  return (dFkron);
    897747}
    898748
    899 float PhotM20 (PhotCode *code, Average *average, SecFilt *secfilt) {
     749float PhotMmin (PhotCode *code, Average *average, SecFilt *secfilt) {
    900750
    901751  int Ns;
    902   float M20;
     752  float Mmin;
    903753
    904754  if (code == NULL) return NAN;
    905755
    906756  Ns = photcodes[0].hashNsec[code[0].code];
    907   M20  = (Ns == -1) ? NAN : 0.001*secfilt[Ns].M_20;
    908   return (M20);
    909 }
    910 
    911 float PhotM80 (PhotCode *code, Average *average, SecFilt *secfilt) {
     757  Mmin  = (Ns == -1) ? NAN : secfilt[Ns].Mmin;
     758  return (Mmin);
     759}
     760
     761float PhotMmax (PhotCode *code, Average *average, SecFilt *secfilt) {
    912762
    913763  int Ns;
    914   float M80;
     764  float Mmax;
    915765
    916766  if (code == NULL) return NAN;
    917767
    918768  Ns = photcodes[0].hashNsec[code[0].code];
    919   M80  = (Ns == -1) ? NAN : 0.001*secfilt[Ns].M_80;
    920   return (M80);
     769  Mmax  = (Ns == -1) ? NAN : secfilt[Ns].Mmax;
     770  return (Mmax);
    921771}
    922772
    … …  
    945795}
    946796
    947 // XXX return NAN or NAN_S_SHORT? (secfilt->Xm is short)
     797// Xm is now (2014.07.03) stored as the chisq except in dvo formats which use as short
    948798float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt) {
    949799
    950800  int Ns;
    951   short Mi;
    952801  float Xm;
    953802
    … …  
    955804
    956805  Ns = photcodes[0].hashNsec[code[0].code];
    957   Mi = (Ns == -1) ? NAN : secfilt[Ns].Xm;
    958   Xm = (isnan(Mi)) ? -1.0 : pow (10.0, 0.01*Mi);
     806  Xm = (Ns == -1) ? NAN : secfilt[Ns].Mchisq;
    959807  return (Xm);
    960808}
    … …  
    1006854}
    1007855
    1008 /******** alternate photometry conversion functions using MeasureTiny and AverageTiny *********/
    1009 float PhotInstTiny (MeasureTiny *measure) {
    1010 
    1011   int Np;
    1012   float M;
    1013 
    1014   Np = photcodes[0].hashcode[measure[0].photcode];
     856float MagToFlux (float Mag) {
     857  float Flux = pow(10.0, -0.4*(Mag));
     858  return (Flux);
     859}
     860
     861/** flux conversion *******************************************************************/
     862float PhotFluxInst (Measure *measure, dvoMagClassType class) {
     863
     864  float Moff = - measure[0].dt - ZERO_POINT;
     865  float Finst = NAN;
     866  switch (class) {
     867    case MAG_CLASS_PSF:
     868      Finst = isnan (measure[0].FluxPSF)  ? MagToFlux(measure[0].M + Moff)     : measure[0].FluxPSF;
     869      break;
     870    case MAG_CLASS_KRON:
     871      Finst = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron;
     872      break;
     873    case MAG_CLASS_APER:
     874      Finst = isnan (measure[0].FluxAp)   ? MagToFlux(measure[0].Map + Moff)   : measure[0].FluxAp;
     875      break;
     876    default:
     877      break;
     878  }
     879  return (Finst);
     880}
     881
     882// returns Jy fluxes assuming mag in AB? (needs an extra AP factor, right?)
     883float PhotFluxCat (Measure *measure, dvoMagClassType class) {
     884
     885  int Np = photcodes[0].hashcode[measure[0].photcode];
    1015886  if (Np == -1) return (NAN);
    1016 
    1017   if (photcodes[0].code[Np].type == PHOT_REF) {
    1018     M = measure[0].M;
    1019     return (M);
    1020   }
    1021 
    1022   M = measure[0].M - measure[0].dt - ZERO_POINT;
    1023          
    1024   return (M);
    1025 
    1026 }
    1027 
    1028 float PhotCatTiny (MeasureTiny *measure) {
    1029 
    1030   int Np;
    1031   float Mcat;
    1032   PhotCode *code;
    1033 
    1034   Np = photcodes[0].hashcode[measure[0].photcode];
     887  PhotCode *code = &photcodes[0].code[Np];
     888
     889  // mag_AB = -2.5 log (flux_cgs) - 48.6 (by definition) [~Vega flux in V-band]
     890  // flux_Jy = flux_cgs * 10^23
     891  // -2.5 log (flux_cgs) = -2.5 log (flux_Jy * 10^-23) = -2.5 log (flux_Jy) + 2.5*23
     892
     893  // from these we get:
     894  // mag_AB = -2.5 log (flux_Jy) + 8.9
     895  // log (flux_Jy) = -0.4*mag_AB + 3.56
     896
     897  // mag_AB = mag_inst + ZP
     898
     899  // log(flux_Jy) = -0.4*mag_inst -0.4*ZP + 3.56
     900  // mag_inst = -2.5 log (flux_Jy) - ZP + 8.9
     901
     902  // log (flux_Jy) = -0.4*(mag_inst + ZP - 8.9)
     903
     904  // -2.5 log (flux_inst) = -2.5 log (flux_Jy) - ZP + 8.9
     905  // log (flux_inst) = log (flux_Jy) + 0.4 ZP - 3.56
     906  // flux_inst = flux_Jy * 10^(0.4*ZP - 3.56)
     907  // flux_Jy = flux_inst * 10^(3.56 - 0.4*ZP) = flux_inst * zpFactor
     908  // flux_Jy = flux_inst * 3630.8 * 10^(-0.4*ZP)
     909
     910  // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux
     911  float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     912  float Moff = Mcal - ZERO_POINT + 8.9;
     913  float Foff = 3630.8 * MagToFlux(Mcal);
     914  float Fcat = NAN;
     915  switch (class) {
     916    case MAG_CLASS_PSF:
     917      Fcat = isnan (measure[0].FluxPSF)  ? MagToFlux(measure[0].M + Moff)     : measure[0].FluxPSF * Foff;
     918      break;
     919    case MAG_CLASS_KRON:
     920      Fcat = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron * Foff;
     921      break;
     922    case MAG_CLASS_APER:
     923      Fcat = isnan (measure[0].FluxAp)   ? MagToFlux(measure[0].Map + Moff)   : measure[0].FluxAp * Foff;
     924      break;
     925    default:
     926      break;
     927  }
     928  return (Fcat);
     929}
     930
     931// corrected for color trends
     932float PhotFluxSys (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) {
     933
     934  int Np = photcodes[0].hashcode[measure[0].photcode];
    1035935  if (Np == -1) return (NAN);
    1036 
    1037   if (photcodes[0].code[Np].type == PHOT_REF) {
    1038     Mcat = measure[0].M;
    1039     return (Mcat);
    1040   }
    1041   code = &photcodes[0].code[Np];
    1042   Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    1043  
    1044   return (Mcat);
    1045 }
    1046 
    1047 # if (0)
    1048 float PhotAperTiny (MeasureTiny *measure) {
    1049 
    1050   int Np;
    1051   float Mcat;
    1052   PhotCode *code;
    1053 
    1054   Np = photcodes[0].hashcode[measure[0].photcode];
    1055   if (Np == -1) return (NAN);
    1056 
    1057   if (photcodes[0].code[Np].type == PHOT_REF) {
    1058     Mcat = measure[0].Map;
    1059     return (Mcat);
    1060   }
    1061   code = &photcodes[0].code[Np];
    1062   Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    1063  
    1064   return (Mcat);
    1065 }
    1066 # endif
    1067 
    1068 float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt) {
    1069 
    1070   int i, Np;
    1071   float Mcat, Mcol, Msys, mc, Mc;
    1072   PhotCode *code;
    1073 
    1074   Np = photcodes[0].hashcode[measure[0].photcode];
    1075   if (Np == -1) return (NAN);
    1076 
    1077   if (photcodes[0].code[Np].type == PHOT_REF) {
    1078     Msys = measure[0].M;
    1079     return (Msys);
    1080   }
    1081   code = &photcodes[0].code[Np];
    1082   Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    1083 
    1084   /* for DEP, color must be made of PRI/SEC */
    1085   mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
    1086   if (isnan(mc)) return (Mcat);
    1087   mc = mc - SCALE*code[0].dX;
    1088 
    1089   Mc = mc;
    1090   Mcol = 0;
     936  PhotCode *code = &photcodes[0].code[Np];
     937
     938  // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux
     939  float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     940  float Moff = Mcal - ZERO_POINT + 8.9;
     941  float Foff = 3630.8 * MagToFlux(Mcal);
     942  float Fcat = NAN;
     943  switch (class) {
     944    case MAG_CLASS_PSF:
     945      Fcat = isnan (measure[0].FluxPSF)  ? MagToFlux(measure[0].M + Moff)     : measure[0].FluxPSF * Foff;
     946      break;
     947    case MAG_CLASS_KRON:
     948      Fcat = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron * Foff;
     949      break;
     950    case MAG_CLASS_APER:
     951      Fcat = isnan (measure[0].FluxAp)   ? MagToFlux(measure[0].Map + Moff)   : measure[0].FluxAp * Foff;
     952      break;
     953    default:
     954      break;
     955  }
     956  if (isnan(Fcat)) return (NAN);
     957
     958  // find the relevant color
     959  float mc = PhotColorForCode (average, secfilt, NULL, code);
     960  if (isnan(mc)) return (Fcat);
     961  mc -= SCALE*code[0].dX;
     962
     963  // find the color correction in mags
     964  int i = 0;
     965  double Mc = mc;
     966  float Mcol = 0;
    1091967  for (i = 0; i < code[0].Nc; i++) {
    1092968    Mcol += code[0].X[i]*Mc;
    1093969    Mc *= mc;
    1094970  }
    1095   Msys = Mcat + Mcol;
    1096   return (Msys);
    1097 }
    1098 
    1099 float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt) {
    1100 
    1101   int i, Np;
    1102   float Mcat, Mcol, Mrel, mc, Mc;
    1103   PhotCode *code;
    1104 
    1105   Np = photcodes[0].hashcode[measure[0].photcode];
     971  float Fcol = MagToFlux (Mcol);
     972
     973  float Fsys = Fcat * Fcol;
     974  return (Fsys);
     975}
     976
     977float PhotFluxRel (Measure *measure, Average *average, SecFilt *secfilt, dvoMagClassType class) {
     978
     979  int Np = photcodes[0].hashcode[measure[0].photcode];
    1106980  if (Np == -1) return (NAN);
    1107 
    1108   if (photcodes[0].code[Np].type == PHOT_REF) {
    1109     Mcat = measure[0].M;
    1110     return (Mcat);
    1111   }
    1112   code = &photcodes[0].code[Np];
    1113   Mrel = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
     981  PhotCode *code = &photcodes[0].code[Np];
     982
     983  // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux
     984  float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
     985  float Moff = Mcal - ZERO_POINT + 8.9;
     986  float Foff = 3630.8 * MagToFlux(Mcal);
     987  float Fcat = NAN;
     988  switch (class) {
     989    case MAG_CLASS_PSF:
     990      Fcat = isnan (measure[0].FluxPSF)  ? MagToFlux(measure[0].M + Moff)     : measure[0].FluxPSF * Foff;
     991      break;
     992    case MAG_CLASS_KRON:
     993      Fcat = isnan (measure[0].FluxKron) ? MagToFlux(measure[0].Mkron + Moff) : measure[0].FluxKron * Foff;
     994      break;
     995    case MAG_CLASS_APER:
     996      Fcat = isnan (measure[0].FluxAp)   ? MagToFlux(measure[0].Map + Moff)   : measure[0].FluxAp * Foff;
     997      break;
     998    default:
     999      break;
     1000  }
     1001  if (isnan(Fcat)) return (NAN);
    11141002
    11151003  /* for DEP, color must be made of PRI/SEC */
    1116   mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
    1117   if (isnan(mc)) return (Mrel);
    1118   mc = mc - SCALE*code[0].dX;
    1119 
    1120   Mc = mc;
    1121   Mcol = 0;
     1004  float mc = PhotColorForCode (average, secfilt, NULL, code);
     1005  if (isnan(mc)) return (Fcat);
     1006  mc -= SCALE*code[0].dX;
     1007
     1008  double Mc = mc;
     1009  float Mcol = 0;
     1010  int i = 0;
     1011  for (i = 0; i < code[0].Nc; i++) {
     1012    Mcol += code[0].X[i]*Mc;
     1013    Mc *= mc;
     1014  }
     1015  float Fcol = MagToFlux (Mcol);
     1016
     1017  float Frel = Fcat * Fcol;
     1018  return (Frel);
     1019}
     1020
     1021/* return calibrated magnitude from measure for given photcode */
     1022float PhotFluxCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code, dvoMagClassType class) {
     1023
     1024  int i;
     1025
     1026  if (code == NULL) return NAN;
     1027
     1028  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
     1029  int Np = photcodes[0].hashcode[thisone[0].photcode];
     1030  if (Np == -1) return (NAN);
     1031  PhotCode *myCode = &photcodes[0].code[Np];
     1032
     1033  if (code->code != myCode->equiv) return (NAN);
     1034
     1035  float Frel = PhotFluxRel (thisone, average, secfilt, class) + SCALE*code[0].C;
     1036
     1037  // get the relevant color term
     1038  float mc = PhotColorForCode (average, secfilt, measure, code);
     1039  if (isnan(mc)) return (Frel);
     1040  mc -= SCALE*code[0].dX;
     1041
     1042  // get the corresponding color correction in mags, convert to flux
     1043  double Mc = mc;
     1044  float Mcol = 0;
     1045  for (i = 0; i < code[0].Nc; i++) {
     1046    Mcol += code[0].X[i]*Mc;
     1047    Mc *= mc;
     1048  }
     1049  float Fcol = MagToFlux (Mcol);
     1050
     1051  float Fcal = Frel * Fcol;
     1052  return (Fcal);
     1053}
     1054
     1055/***/
     1056float PhotFluxAve (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) {
     1057
     1058  if (code == NULL) return NAN;
     1059
     1060  int Ns = photcodes[0].hashNsec[code[0].code];
     1061  if (Ns == -1) return (NAN);
     1062
     1063  float Fave = NAN;
     1064  switch (source) {
     1065    case MAG_SRC_CHP:
     1066      switch (class) {
     1067        case MAG_CLASS_PSF:
     1068          Fave = MagToFlux(secfilt[Ns].M);
     1069          break;
     1070        case MAG_CLASS_KRON:
     1071          Fave = MagToFlux(secfilt[Ns].Mkron);
     1072          break;
     1073        case MAG_CLASS_APER:
     1074          Fave = MagToFlux(secfilt[Ns].Map);
     1075          break;
     1076        default:
     1077          break;
     1078      }
     1079      break;
     1080    case MAG_SRC_WRP:
     1081      switch (class) {
     1082        case MAG_CLASS_PSF:
     1083          Fave = isnan (secfilt[Ns].FpsfWrp)  ? MagToFlux(secfilt[Ns].MpsfWrp)  : secfilt[Ns].FpsfWrp;
     1084          break;
     1085        case MAG_CLASS_KRON:
     1086          Fave = isnan (secfilt[Ns].FkronWrp) ? MagToFlux(secfilt[Ns].MkronWrp) : secfilt[Ns].FkronWrp;
     1087          break;
     1088        case MAG_CLASS_APER:
     1089          Fave = isnan (secfilt[Ns].FapWrp)   ? MagToFlux(secfilt[Ns].MapWrp)   : secfilt[Ns].FapWrp;
     1090          break;
     1091        default:
     1092          break;
     1093      }
     1094      break;
     1095    case MAG_SRC_STK:
     1096      switch (class) {
     1097        case MAG_CLASS_PSF:
     1098          Fave = isnan (secfilt[Ns].FpsfStk)  ? MagToFlux(secfilt[Ns].MpsfStk)  : secfilt[Ns].FpsfStk;
     1099          break;
     1100        case MAG_CLASS_KRON:
     1101          Fave = isnan (secfilt[Ns].FkronStk) ? MagToFlux(secfilt[Ns].MkronStk) : secfilt[Ns].FkronStk;
     1102          break;
     1103        case MAG_CLASS_APER:
     1104          Fave = isnan (secfilt[Ns].FapStk)   ? MagToFlux(secfilt[Ns].MapStk)   : secfilt[Ns].FapStk;
     1105          break;
     1106        default:
     1107          break;
     1108      }
     1109      break;
     1110    default:
     1111      break;
     1112  }
     1113  return (Fave);
     1114}
     1115
     1116/* return calibrated magnitude from average/secfilt for given photcode */
     1117float PhotFluxRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure, dvoMagClassType class, dvoMagSourceType source) {
     1118
     1119  int i;
     1120
     1121  float Fave = PhotFluxAve (code, average, secfilt, class, source);
     1122  if (isnan(Fave)) return NAN;
     1123
     1124  // correct for relative zero-point
     1125  float Moff = SCALE*code[0].C;
     1126
     1127  float mc = PhotColorForCode (average, secfilt, measure, code);
     1128  if (isnan(mc)) return (Fave * MagToFlux(Moff));
     1129  mc -= SCALE*code[0].dX;
     1130
     1131  // correct for color terms
     1132  double Mc = mc;
     1133  float Mcol = 0;
    11221134  for (i = 0; i < code[0].Nc; i++) {
    11231135    Mcol += code[0].X[i]*Mc;
    11241136    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    11251137  }
    1126   Mrel += Mcol;
    1127   return (Mrel);
    1128 }
    1129 
    1130 /* return calibrated magnitude from measure for given photcode */
    1131 float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code) {
    1132 
    1133   int i, Np;
    1134   float Mcal, Mrel, Mcol, mc, Mc;
    1135 
    1136   if (code == NULL) return NAN;
    1137 
    1138   /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
    1139   Np = photcodes[0].hashcode[thisone[0].photcode];
     1138  float Foff = MagToFlux(Mcol);
     1139  return (Fave * Foff);
     1140}
     1141
     1142float PhotFluxInstErr (Measure *measure, dvoMagClassType class) {
     1143
     1144  float Moff = - measure[0].dt - ZERO_POINT;
     1145
     1146  // use dFlux if we can, but use dMag if we must:
     1147  // dFlux = Flux * dMag
     1148
     1149  float dFinst = NAN;
     1150  switch (class) {
     1151    case MAG_CLASS_PSF:
     1152      if (isnan (measure[0].dFluxPSF)) {
     1153        float Finst = MagToFlux(measure[0].M + Moff);
     1154        dFinst = measure[0].dM * Finst;
     1155      } else {
     1156        dFinst = measure[0].dFluxPSF;
     1157      }
     1158      break;
     1159    case MAG_CLASS_KRON:
     1160      if (isnan (measure[0].dFluxKron)) {
     1161        float Finst = MagToFlux(measure[0].Mkron + Moff);
     1162        dFinst = measure[0].dMkron * Finst;
     1163      } else {
     1164        dFinst = measure[0].dFluxKron;
     1165      }
     1166      break;
     1167    case MAG_CLASS_APER:
     1168      if (isnan (measure[0].dFluxAp)) {
     1169        float Finst = MagToFlux(measure[0].Map + Moff);
     1170        dFinst = measure[0].dMap * Finst;
     1171      } else {
     1172        dFinst = measure[0].dFluxAp;
     1173      }
     1174      break;
     1175    default:
     1176      break;
     1177  }
     1178  return (dFinst);
     1179}
     1180
     1181float PhotFluxCatErr (Measure *measure, dvoMagClassType class) {
     1182
     1183  int Np = photcodes[0].hashcode[measure[0].photcode];
    11401184  if (Np == -1) return (NAN);
    1141 
    1142   if (photcodes[0].code[Np].type == PHOT_REF) {
    1143     Mrel = thisone[0].M;
    1144     return (Mrel);
    1145   }
    1146   if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
    1147 
    1148   Mcal = PhotRelTiny (thisone, average, secfilt) + SCALE*code[0].C;
    1149 
    1150   mc = PhotColorForCodeTiny (average, secfilt, measure, code);
    1151   if (isnan(mc)) return (Mcal);
    1152   mc = mc - SCALE*code[0].dX;
    1153 
    1154   Mc = mc;
    1155   Mcol = 0;
     1185  PhotCode *code = &photcodes[0].code[Np];
     1186
     1187  // measure.M has the static ZERO_POINT (25.0) applied, but not measure.Flux
     1188  float Mcal = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     1189  float Moff = Mcal - ZERO_POINT + 8.9;
     1190  float Foff = 3630.8 * MagToFlux(Mcal);
     1191
     1192  // use dFlux if we can, but use dMag if we must:
     1193  // dFlux = Flux * dMag
     1194
     1195  float dFcat = NAN;
     1196  switch (class) {
     1197    case MAG_CLASS_PSF:
     1198      if (isnan (measure[0].dFluxPSF)) {
     1199        float Finst = MagToFlux(measure[0].M + Moff);
     1200        dFcat = measure[0].dM * Finst;
     1201      } else {
     1202        dFcat = measure[0].dFluxPSF * Foff;
     1203      }
     1204      break;
     1205    case MAG_CLASS_KRON:
     1206      if (isnan (measure[0].dFluxKron)) {
     1207        float Finst = MagToFlux(measure[0].Mkron + Moff);
     1208        dFcat = measure[0].dMkron * Finst;
     1209      } else {
     1210        dFcat = measure[0].dFluxKron * Foff;
     1211      }
     1212      break;
     1213    case MAG_CLASS_APER:
     1214      if (isnan (measure[0].dFluxAp)) {
     1215        float Finst = MagToFlux(measure[0].Map + Moff);
     1216        dFcat = measure[0].dMap * Finst;
     1217      } else {
     1218        dFcat = measure[0].dFluxAp * Foff;
     1219      }
     1220      break;
     1221    default:
     1222      break;
     1223  }
     1224  return (dFcat);
     1225}
     1226
     1227/******** alternate photometry conversion functions using MeasureTiny and AverageTiny *********/
     1228float PhotInstTiny (MeasureTiny *measure, dvoMagClassType class) {
     1229
     1230  int Np = photcodes[0].hashcode[measure[0].photcode];
     1231  if (Np == -1) return (NAN);
     1232  PhotCode *code = &photcodes[0].code[Np];
     1233
     1234  float Mraw = NAN;
     1235  switch (class) {
     1236    case MAG_CLASS_PSF:
     1237      Mraw = measure[0].M;
     1238      break;
     1239    case MAG_CLASS_KRON:
     1240      // Mraw = measure[0].Mkron;
     1241      break;
     1242    case MAG_CLASS_APER:
     1243      // Mraw = measure[0].Map;
     1244      break;
     1245    default:
     1246      break;
     1247  }
     1248  if (code->type == PHOT_REF) {
     1249    return (Mraw);
     1250  }
     1251  float Minst = Mraw - measure[0].dt - ZERO_POINT;
     1252
     1253  return (Minst);
     1254}
     1255
     1256float PhotCatTiny (MeasureTiny *measure, dvoMagClassType class) {
     1257
     1258  int Np = photcodes[0].hashcode[measure[0].photcode];
     1259  if (Np == -1) return (NAN);
     1260  PhotCode *code = &photcodes[0].code[Np];
     1261
     1262  float Mraw = NAN;
     1263  switch (class) {
     1264    case MAG_CLASS_PSF:
     1265      Mraw = measure[0].M;
     1266      break;
     1267    case MAG_CLASS_KRON:
     1268      // Mraw = measure[0].Mkron;
     1269      break;
     1270    case MAG_CLASS_APER:
     1271      // Mraw = measure[0].Map;
     1272      break;
     1273    default:
     1274      break;
     1275  }
     1276  if (code->type == PHOT_REF) {
     1277    return (Mraw);
     1278  }
     1279
     1280  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     1281 
     1282  return (Mcat);
     1283}
     1284
     1285float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class) {
     1286
     1287  int Np = photcodes[0].hashcode[measure[0].photcode];
     1288  if (Np == -1) return (NAN);
     1289  PhotCode *code = &photcodes[0].code[Np];
     1290
     1291  float Mraw = NAN;
     1292  switch (class) {
     1293    case MAG_CLASS_PSF:
     1294      Mraw = measure[0].M;
     1295      break;
     1296    case MAG_CLASS_KRON:
     1297      // Mraw = measure[0].Mkron;
     1298      break;
     1299    case MAG_CLASS_APER:
     1300      // Mraw = measure[0].Map;
     1301      break;
     1302    default:
     1303      break;
     1304  }
     1305  if (code->type == PHOT_REF) {
     1306    return (Mraw);
     1307  }
     1308  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     1309
     1310  /* for DEP, color must be made of PRI/SEC */
     1311  float mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
     1312  if (isnan(mc)) return (Mcat);
     1313  mc -= SCALE*code[0].dX;
     1314
     1315  int i = 0;
     1316  double Mc = mc;
     1317  float Mcol = 0;
    11561318  for (i = 0; i < code[0].Nc; i++) {
    11571319    Mcol += code[0].X[i]*Mc;
    11581320    Mc *= mc;
    11591321  }
     1322  float Msys = Mcat + Mcol;
     1323  return (Msys);
     1324}
     1325
     1326float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class) {
     1327
     1328  int Np = photcodes[0].hashcode[measure[0].photcode];
     1329  if (Np == -1) return (NAN);
     1330  PhotCode *code = &photcodes[0].code[Np];
     1331
     1332  float Mraw = NAN;
     1333  switch (class) {
     1334    case MAG_CLASS_PSF:
     1335      Mraw = measure[0].M;
     1336      break;
     1337    case MAG_CLASS_KRON:
     1338      // Mraw = measure[0].Mkron;
     1339      break;
     1340    case MAG_CLASS_APER:
     1341      // Mraw = measure[0].Map;
     1342      break;
     1343    default:
     1344      break;
     1345  }
     1346  if (code->type == PHOT_REF) {
     1347    return (Mraw);
     1348  }
     1349  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
     1350
     1351  /* for DEP, color must be made of PRI/SEC */
     1352  float mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
     1353  if (isnan(mc)) return (Mcat);
     1354  mc -= SCALE*code[0].dX;
     1355
     1356  double Mc = mc;
     1357  float Mcol = 0;
     1358  int i = 0;
     1359  for (i = 0; i < code[0].Nc; i++) {
     1360    Mcol += code[0].X[i]*Mc;
     1361    Mc *= mc;
     1362  }
     1363  float Mrel = Mcat + Mcol;
     1364  return (Mrel);
     1365}
     1366
     1367/* return calibrated magnitude from measure for given photcode */
     1368float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code, dvoMagClassType class) {
     1369
     1370  int i;
     1371
     1372  if (code == NULL) return NAN;
     1373
     1374  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
     1375  int Np = photcodes[0].hashcode[thisone[0].photcode];
     1376  if (Np == -1) return (NAN);
     1377  PhotCode *myCode = &photcodes[0].code[Np];
     1378
     1379  if (code->code != myCode->equiv) return (NAN);
     1380
     1381  // if we are REF type, just get the right version and return
     1382  if (myCode->type == PHOT_REF) {
     1383    float Mraw = NAN;
     1384    switch (class) {
     1385      case MAG_CLASS_PSF:
     1386        Mraw = thisone[0].M;
     1387        break;
     1388      case MAG_CLASS_KRON:
     1389        // Mraw = thisone[0].Mkron;
     1390        break;
     1391      case MAG_CLASS_APER:
     1392        // Mraw = thisone[0].Map;
     1393        break;
     1394      default:
     1395        break;
     1396    }
     1397    return (Mraw);
     1398  }
     1399
     1400  float Mcal = PhotRelTiny (thisone, average, secfilt, class) + SCALE*code[0].C;
     1401
     1402  float mc = PhotColorForCodeTiny (average, secfilt, measure, code);
     1403  if (isnan(mc)) return (Mcal);
     1404  mc -= SCALE*code[0].dX;
     1405
     1406  double Mc = mc;
     1407  float Mcol = 0;
     1408  for (i = 0; i < code[0].Nc; i++) {
     1409    Mcol += code[0].X[i]*Mc;
     1410    Mc *= mc;
     1411  }
    11601412  Mcal += Mcol;
    11611413  return (Mcal);
     1414}
     1415
     1416/***/
     1417float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) {
     1418
     1419  if (code == NULL) return NAN;
     1420
     1421  int Ns = photcodes[0].hashNsec[code[0].code];
     1422  if (Ns == -1) return (NAN);
     1423
     1424  float Mave = NAN;
     1425  switch (source) {
     1426    case MAG_SRC_CHP:
     1427      switch (class) {
     1428        case MAG_CLASS_PSF:
     1429          Mave = secfilt[Ns].M;
     1430          break;
     1431        case MAG_CLASS_KRON:
     1432          Mave = secfilt[Ns].Mkron;
     1433          break;
     1434        case MAG_CLASS_APER:
     1435          Mave = secfilt[Ns].Map;
     1436          break;
     1437        default:
     1438          break;
     1439      }
     1440      break;
     1441    case MAG_SRC_WRP:
     1442      switch (class) {
     1443        case MAG_CLASS_PSF:
     1444          Mave = secfilt[Ns].MpsfWrp;
     1445          break;
     1446        case MAG_CLASS_KRON:
     1447          Mave = secfilt[Ns].MkronWrp;
     1448          break;
     1449        case MAG_CLASS_APER:
     1450          Mave = secfilt[Ns].MapWrp;
     1451          break;
     1452        default:
     1453          break;
     1454      }
     1455      break;
     1456    case MAG_SRC_STK:
     1457      switch (class) {
     1458        case MAG_CLASS_PSF:
     1459          Mave = secfilt[Ns].MpsfStk;
     1460          break;
     1461        case MAG_CLASS_KRON:
     1462          Mave = secfilt[Ns].MkronStk;
     1463          break;
     1464        case MAG_CLASS_APER:
     1465          Mave = secfilt[Ns].MapStk;
     1466          break;
     1467        default:
     1468          break;
     1469      }
     1470      break;
     1471    default:
     1472      break;
     1473  }
     1474  return (Mave);
     1475}
     1476
     1477/* return calibrated magnitude from average/secfilt for given photcode */
     1478float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, dvoMagClassType class, dvoMagSourceType source) {
     1479
     1480  int i;
     1481
     1482  float Mave = PhotAveTiny (code, average, secfilt, class, source);
     1483  if (isnan(Mave)) return NAN;
     1484
     1485  // correct for relative zero-point
     1486  float Mref = Mave + SCALE*code[0].C;
     1487
     1488  float mc = PhotColorForCodeTiny (average, secfilt, measure, code);
     1489  if (isnan(mc)) return (Mref);
     1490  mc -= SCALE*code[0].dX;
     1491
     1492  // correct for color terms
     1493  double Mc = mc;
     1494  float Mcol = 0;
     1495  for (i = 0; i < code[0].Nc; i++) {
     1496    Mcol += code[0].X[i]*Mc;
     1497    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
     1498  }
     1499  Mref += Mcol;
     1500  return (Mref);
    11621501}
    11631502
    … …  
    12121551}
    12131552
    1214 /* return calibrated magnitude from average/secfilt for given photcode */
    1215 float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure) {
    1216 
    1217   int i, Ns;
    1218   float Mave, Mref, Mcol, mc;
    1219   double Mc;
    1220 
    1221   if (code == NULL) return NAN;
    1222 
    1223   Ns = photcodes[0].hashNsec[code[0].code];
    1224   Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
    1225   Mref = Mave + SCALE*code[0].C;
    1226 
    1227   mc = PhotColorForCodeTiny (average, secfilt, measure, code);
    1228   if (isnan(mc)) return (Mref);
    1229   mc = mc - SCALE*code[0].dX;
    1230 
    1231   Mc = mc;
    1232   Mcol = 0;
    1233   for (i = 0; i < code[0].Nc; i++) {
    1234     Mcol += code[0].X[i]*Mc;
    1235     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    1236   }
    1237   Mref += Mcol;
    1238   return (Mref);
    1239 }
    1240 
    1241 /***/
    1242 float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) {
    1243 
    1244   int Ns;
    1245   float Mave;
    1246 
    1247   if (code == NULL) return NAN;
    1248 
    1249   Ns = photcodes[0].hashNsec[code[0].code];
    1250   Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
    1251   return (Mave);
    1252 }
    1253 
    12541553float PhotdMTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) {
    12551554
    … …  
    12641563}
    12651564
    1266 // XXX return NAN or NAN_S_SHORT? (secfilt->Xm is short)
     1565// Xm is now (2014.07.03) stored as the chisq except in dvo formats which use as short
    12671566float PhotXmTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) {
    12681567
    12691568  int Ns;
    1270   short Mi;
    12711569  float Xm;
    12721570
    … …  
    12741572
    12751573  Ns = photcodes[0].hashNsec[code[0].code];
    1276   Mi = (Ns == -1) ? NAN : secfilt[Ns].Xm;
    1277   Xm = (isnan(Mi)) ? -1.0 : pow (10.0, 0.01*Mi);
     1574  Xm = (Ns == -1) ? NAN : secfilt[Ns].Mchisq;
    12781575  return (Xm);
    12791576}

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

    r36630 r37035  
    1414
    1515void CopyMeasureToTiny (MeasureTiny *measureT, Measure *measure) {
    16   measureT[0].dR         = measure[0].dR;
    17   measureT[0].dD         = measure[0].dD;
     16  measureT[0].R          = measure[0].R;
     17  measureT[0].D          = measure[0].D;
    1818  measureT[0].M          = measure[0].M;
    1919  measureT[0].Mcal       = measure[0].Mcal;
Note: See TracChangeset for help on using the changeset viewer.